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 const &)=delete

	EDConsumerBase (EDConsumerBase &&)=default

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 const &	operator= (EDConsumerBase const &)=delete

EDConsumerBase &	operator= (EDConsumerBase &&)=default

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_cluster_flags_

vector< float >	element_corr_energy_

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< float >	element_gsf_electronseed_trkorecal_

vector< int >	element_layer_

vector< float >	element_muon_csc_hits_

vector< float >	element_muon_dt_hits_

vector< float >	element_muon_type_

vector< float >	element_num_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
template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	consumes (edm::InputTag const &tag)

template<BranchType B = InEvent>
EDConsumerBaseAdaptor< B >	consumes (edm::InputTag tag) noexcept

EDGetToken	consumes (const TypeToGet &id, edm::InputTag const &tag)

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<typename ESProduct , typename ESRecord , Transition Tr = Transition::Event>
auto	esConsumes (ESInputTag const &tag)

template<Transition Tr = Transition::Event>
constexpr auto	esConsumes ()

template<Transition Tr = Transition::Event>
auto	esConsumes (ESInputTag tag)

template<Transition Tr = Transition::Event>
ESGetTokenGeneric	esConsumes (eventsetup::EventSetupRecordKey const &iRecord, eventsetup::DataKey const &iKey)
	Used with EventSetupRecord::doGet. More...

template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	mayConsume (edm::InputTag const &tag)

EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)

template<BranchType B>
EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)

void	resetItemsToGetFrom (BranchType iType)

Detailed Description

Definition at line 124 of file PFAnalysisNtuplizer.cc.

Member Typedef Documentation

◆ Point

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

Definition at line 126 of file PFAnalysisNtuplizer.cc.

Constructor & Destructor Documentation

◆ PFAnalysis() [1/2]

PFAnalysis::PFAnalysis ( )

Definition at line 301 of file PFAnalysisNtuplizer.cc.

301 { ; }

◆ PFAnalysis() [2/2]

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

explicit

Definition at line 303 of file PFAnalysisNtuplizer.cc.

References compareTotals::fs, edm::ParameterSet::getUntrackedParameter(), HLT_2022v14_cff::InputTag, and TFileService::kSharedResource.

                                                      {
   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_corr_energy", &element_corr_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_);
   t_->Branch("element_muon_type", &element_muon_type_);
   t_->Branch("element_cluster_flags", &element_cluster_flags_);
   t_->Branch("element_gsf_electronseed_trkorecal", &element_gsf_electronseed_trkorecal_);
   t_->Branch("element_num_hits", &element_num_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

◆ ~PFAnalysis()

PFAnalysis::~PFAnalysis ( )

override

Definition at line 446 of file PFAnalysisNtuplizer.cc.

446 {}

Member Function Documentation

◆ analyze()

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

overrideprivatevirtual

Implements edm::one::EDAnalyzerBase.

Definition at line 593 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 corr_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;
     float muon_type = 0.0;
     float cluster_flags = 0.0;
     float gsf_electronseed_trkorecal = 0.0;
     float num_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();
       num_hits = ref->recHitsSize();
 
       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();
         }
         muon_type = muonRef->type();
       }
 
     } else if (type == reco::PFBlockElement::BREM) {
       const auto* orig2 = (const reco::PFBlockElementBrem*)&orig;
       const auto& ref = orig2->GsftrackRef();
       trajpoint = orig2->indTrajPoint();
       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();
         charge = ref->charge();
       }
 
       const auto& gsfextraref = ref->extra();
       if (gsfextraref.isAvailable() && gsfextraref->seedRef().isAvailable()) {
         reco::ElectronSeedRef seedref = gsfextraref->seedRef().castTo<reco::ElectronSeedRef>();
         if (seedref.isAvailable()) {
           if (seedref->isEcalDriven()) {
             gsf_electronseed_trkorecal = 1.0;
           } else if (seedref->isTrackerDriven()) {
             gsf_electronseed_trkorecal = 2.0;
           }
         }
       }
 
     } 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();
 
       const auto& vec2 = orig2->Pout();
       eta_ecal = vec2.eta();
       phi_ecal = vec2.phi();
 
       if (!orig2->GsftrackRefPF().isNull()) {
         charge = orig2->GsftrackRefPF()->charge();
         num_hits = orig2->GsftrackRefPF()->PFRecBrem().size();
       }
 
       const auto& ref = orig2->GsftrackRef();
 
       const auto& gsfextraref = ref->extra();
       if (gsfextraref.isAvailable() && gsfextraref->seedRef().isAvailable()) {
         reco::ElectronSeedRef seedref = gsfextraref->seedRef().castTo<reco::ElectronSeedRef>();
         if (seedref.isAvailable()) {
           if (seedref->isEcalDriven()) {
             gsf_electronseed_trkorecal = 1.0;
           } else if (seedref->isTrackerDriven()) {
             gsf_electronseed_trkorecal = 2.0;
           }
         }
       };
 
     } 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()) {
         cluster_flags = ref->flags();
         eta = ref->eta();
         phi = ref->phi();
         pt = ref->pt();
         px = ref->position().x();
         py = ref->position().y();
         pz = ref->position().z();
         energy = ref->energy();
         corr_energy = ref->correctedEnergy();
         layer = ref->layer();
         depth = ref->depth();
         num_hits = ref->recHitFractions().size();
       }
     } else if (type == reco::PFBlockElement::SC) {
       const auto& clref = ((const reco::PFBlockElementSuperCluster*)&orig)->superClusterRef();
       if (clref.isNonnull()) {
         cluster_flags = clref->flags();
         eta = clref->eta();
         phi = clref->phi();
         px = clref->position().x();
         py = clref->position().y();
         pz = clref->position().z();
         energy = clref->energy();
         num_hits = clref->clustersSize();
       }
     }
     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_corr_energy_.push_back(corr_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);
     element_muon_type_.push_back(muon_type);
     element_cluster_flags_.push_back(cluster_flags);
     element_gsf_electronseed_trkorecal_.push_back(gsf_electronseed_trkorecal);
     element_num_hits_.push_back(num_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

◆ associateClusterToSimCluster()

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

private

Definition at line 1081 of file PFAnalysisNtuplizer.cc.

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, reco::PFBlockElement::SC, and x.

                                                                                           {
   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
 }

◆ beginJob()

void PFAnalysis::beginJob ( void )

overrideprivatevirtual

Reimplemented from edm::one::EDAnalyzerBase.

Definition at line 1210 of file PFAnalysisNtuplizer.cc.

1210 { ; }

◆ beginRun()

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

override

Definition at line 1203 of file PFAnalysisNtuplizer.cc.

References edm::EventSetup::getData().

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

◆ clearVariables()

void PFAnalysis::clearVariables ( )

private

Definition at line 448 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_corr_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_muon_type_.clear();
   element_cluster_flags_.clear();
   element_gsf_electronseed_trkorecal_.clear();
   element_num_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 1212 of file PFAnalysisNtuplizer.cc.

1212 {}

◆ endRun()

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

override

Definition at line 1208 of file PFAnalysisNtuplizer.cc.

1208 {}

◆ fillDescriptions()

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

static

Definition at line 1214 of file PFAnalysisNtuplizer.cc.

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

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

◆ getHitPosition()

GlobalPoint PFAnalysis::getHitPosition ( const DetId & id )

private

Definition at line 575 of file PFAnalysisNtuplizer.cc.

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

                                                       {
   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;
 }

◆ processBlocks()

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

private

Definition at line 1049 of file PFAnalysisNtuplizer.cc.

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

                                             {
   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

◆ processTrackingParticles()

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

private

Definition at line 1002 of file PFAnalysisNtuplizer.cc.

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

                                                                                                          {
   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());
   }
 }

Member Data Documentation

◆ aField_

MagneticField const* PFAnalysis::aField_

private

Definition at line 287 of file PFAnalysisNtuplizer.cc.

◆ caloParticles_

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

private

Definition at line 156 of file PFAnalysisNtuplizer.cc.

◆ element_charge_

vector<int> PFAnalysis::element_charge_

private

Definition at line 256 of file PFAnalysisNtuplizer.cc.

◆ element_cluster_flags_

vector<float> PFAnalysis::element_cluster_flags_

private

Definition at line 264 of file PFAnalysisNtuplizer.cc.

◆ element_corr_energy_

vector<float> PFAnalysis::element_corr_energy_

private

Definition at line 251 of file PFAnalysisNtuplizer.cc.

◆ element_deltap_

vector<float> PFAnalysis::element_deltap_

private

Definition at line 246 of file PFAnalysisNtuplizer.cc.

◆ element_depth_

vector<float> PFAnalysis::element_depth_

private

Definition at line 259 of file PFAnalysisNtuplizer.cc.

◆ element_distance_d_

vector<float> PFAnalysis::element_distance_d_

private

Definition at line 270 of file PFAnalysisNtuplizer.cc.

◆ element_distance_i_

vector<int> PFAnalysis::element_distance_i_

private

Definition at line 268 of file PFAnalysisNtuplizer.cc.

◆ element_distance_j_

vector<int> PFAnalysis::element_distance_j_

private

Definition at line 269 of file PFAnalysisNtuplizer.cc.

◆ element_energy_

vector<float> PFAnalysis::element_energy_

private

Definition at line 250 of file PFAnalysisNtuplizer.cc.

◆ element_eta_

vector<float> PFAnalysis::element_eta_

private

Definition at line 248 of file PFAnalysisNtuplizer.cc.

◆ element_eta_ecal_

vector<float> PFAnalysis::element_eta_ecal_

private

Definition at line 252 of file PFAnalysisNtuplizer.cc.

◆ element_eta_hcal_

vector<float> PFAnalysis::element_eta_hcal_

private

Definition at line 254 of file PFAnalysisNtuplizer.cc.

◆ element_gsf_electronseed_trkorecal_

vector<float> PFAnalysis::element_gsf_electronseed_trkorecal_

private

Definition at line 265 of file PFAnalysisNtuplizer.cc.

◆ element_layer_

vector<int> PFAnalysis::element_layer_

private

Definition at line 258 of file PFAnalysisNtuplizer.cc.

◆ element_muon_csc_hits_

vector<float> PFAnalysis::element_muon_csc_hits_

private

Definition at line 262 of file PFAnalysisNtuplizer.cc.

◆ element_muon_dt_hits_

vector<float> PFAnalysis::element_muon_dt_hits_

private

Definition at line 261 of file PFAnalysisNtuplizer.cc.

◆ element_muon_type_

vector<float> PFAnalysis::element_muon_type_

private

Definition at line 263 of file PFAnalysisNtuplizer.cc.

◆ element_num_hits_

vector<float> PFAnalysis::element_num_hits_

private

Definition at line 266 of file PFAnalysisNtuplizer.cc.

◆ element_phi_

vector<float> PFAnalysis::element_phi_

private

Definition at line 249 of file PFAnalysisNtuplizer.cc.

◆ element_phi_ecal_

vector<float> PFAnalysis::element_phi_ecal_

private

Definition at line 253 of file PFAnalysisNtuplizer.cc.

◆ element_phi_hcal_

vector<float> PFAnalysis::element_phi_hcal_

private

Definition at line 255 of file PFAnalysisNtuplizer.cc.

◆ element_pt_

vector<float> PFAnalysis::element_pt_

private

Definition at line 242 of file PFAnalysisNtuplizer.cc.

◆ element_px_

vector<float> PFAnalysis::element_px_

private

Definition at line 243 of file PFAnalysisNtuplizer.cc.

◆ element_py_

vector<float> PFAnalysis::element_py_

private

Definition at line 244 of file PFAnalysisNtuplizer.cc.

◆ element_pz_

vector<float> PFAnalysis::element_pz_

private

Definition at line 245 of file PFAnalysisNtuplizer.cc.

◆ element_sigmadeltap_

vector<float> PFAnalysis::element_sigmadeltap_

private

Definition at line 247 of file PFAnalysisNtuplizer.cc.

◆ element_to_candidate

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

private

Definition at line 284 of file PFAnalysisNtuplizer.cc.

◆ element_trajpoint_

vector<float> PFAnalysis::element_trajpoint_

private

Definition at line 260 of file PFAnalysisNtuplizer.cc.

◆ element_type_

vector<int> PFAnalysis::element_type_

private

Definition at line 257 of file PFAnalysisNtuplizer.cc.

◆ ev_event_

edm::EventNumber_t PFAnalysis::ev_event_

private

Definition at line 166 of file PFAnalysisNtuplizer.cc.

◆ ev_lumi_

edm::LuminosityBlockNumber_t PFAnalysis::ev_lumi_

private

Definition at line 165 of file PFAnalysisNtuplizer.cc.

◆ ev_run_

edm::RunNumber_t PFAnalysis::ev_run_

private

Definition at line 164 of file PFAnalysisNtuplizer.cc.

◆ gen_charge_

vector<int> PFAnalysis::gen_charge_

private

Definition at line 237 of file PFAnalysisNtuplizer.cc.

◆ gen_daughters_

vector<vector<int> > PFAnalysis::gen_daughters_

private

Definition at line 240 of file PFAnalysisNtuplizer.cc.

◆ gen_energy_

vector<float> PFAnalysis::gen_energy_

private

Definition at line 236 of file PFAnalysisNtuplizer.cc.

◆ gen_eta_

vector<float> PFAnalysis::gen_eta_

private

Definition at line 230 of file PFAnalysisNtuplizer.cc.

◆ gen_pdgid_

vector<int> PFAnalysis::gen_pdgid_

private

Definition at line 238 of file PFAnalysisNtuplizer.cc.

◆ gen_phi_

vector<float> PFAnalysis::gen_phi_

private

Definition at line 231 of file PFAnalysisNtuplizer.cc.

◆ gen_pt_

vector<float> PFAnalysis::gen_pt_

private

Definition at line 232 of file PFAnalysisNtuplizer.cc.

◆ gen_px_

vector<float> PFAnalysis::gen_px_

private

Definition at line 233 of file PFAnalysisNtuplizer.cc.

◆ gen_py_

vector<float> PFAnalysis::gen_py_

private

Definition at line 234 of file PFAnalysisNtuplizer.cc.

◆ gen_pz_

vector<float> PFAnalysis::gen_pz_

private

Definition at line 235 of file PFAnalysisNtuplizer.cc.

◆ gen_status_

vector<int> PFAnalysis::gen_status_

private

Definition at line 239 of file PFAnalysisNtuplizer.cc.

◆ genParticles_

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

private

Definition at line 154 of file PFAnalysisNtuplizer.cc.

◆ geom

CaloGeometry* PFAnalysis::geom

private

Definition at line 294 of file PFAnalysisNtuplizer.cc.

◆ geometryToken_

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

private

Definition at line 289 of file PFAnalysisNtuplizer.cc.

◆ hcal_topo

HcalTopology* PFAnalysis::hcal_topo

private

Definition at line 295 of file PFAnalysisNtuplizer.cc.

◆ hcalDDDrecToken_

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

private

Definition at line 292 of file PFAnalysisNtuplizer.cc.

◆ hcons

const HcalDDDRecConstants* PFAnalysis::hcons

private

Definition at line 296 of file PFAnalysisNtuplizer.cc.

◆ magFieldToken_

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

private

Definition at line 291 of file PFAnalysisNtuplizer.cc.

◆ pfBlocks_

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

private

Definition at line 158 of file PFAnalysisNtuplizer.cc.

◆ pfcandidate_energy_

vector<float> PFAnalysis::pfcandidate_energy_

private

Definition at line 278 of file PFAnalysisNtuplizer.cc.

◆ pfcandidate_eta_

vector<float> PFAnalysis::pfcandidate_eta_

private

Definition at line 272 of file PFAnalysisNtuplizer.cc.

◆ pfcandidate_pdgid_

vector<int> PFAnalysis::pfcandidate_pdgid_

private

Definition at line 279 of file PFAnalysisNtuplizer.cc.

◆ pfcandidate_phi_

vector<float> PFAnalysis::pfcandidate_phi_

private

Definition at line 273 of file PFAnalysisNtuplizer.cc.

◆ pfcandidate_pt_

vector<float> PFAnalysis::pfcandidate_pt_

private

Definition at line 274 of file PFAnalysisNtuplizer.cc.

◆ pfcandidate_px_

vector<float> PFAnalysis::pfcandidate_px_

private

Definition at line 275 of file PFAnalysisNtuplizer.cc.

◆ pfcandidate_py_

vector<float> PFAnalysis::pfcandidate_py_

private

Definition at line 276 of file PFAnalysisNtuplizer.cc.

◆ pfcandidate_pz_

vector<float> PFAnalysis::pfcandidate_pz_

private

Definition at line 277 of file PFAnalysisNtuplizer.cc.

◆ pfCandidates_

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

private

Definition at line 159 of file PFAnalysisNtuplizer.cc.

◆ rechit_det_

vector<float> PFAnalysis::rechit_det_

private

Definition at line 217 of file PFAnalysisNtuplizer.cc.

◆ rechit_detid_

vector<uint64_t> PFAnalysis::rechit_detid_

private

Definition at line 222 of file PFAnalysisNtuplizer.cc.

◆ rechit_e_

vector<float> PFAnalysis::rechit_e_

private

Definition at line 213 of file PFAnalysisNtuplizer.cc.

◆ rechit_eta_

vector<float> PFAnalysis::rechit_eta_

private

Definition at line 219 of file PFAnalysisNtuplizer.cc.

◆ rechit_idx_element_

vector<int> PFAnalysis::rechit_idx_element_

private

Definition at line 221 of file PFAnalysisNtuplizer.cc.

◆ rechit_phi_

vector<float> PFAnalysis::rechit_phi_

private

Definition at line 220 of file PFAnalysisNtuplizer.cc.

◆ rechit_subdet_

vector<float> PFAnalysis::rechit_subdet_

private

Definition at line 218 of file PFAnalysisNtuplizer.cc.

◆ rechit_x_

vector<float> PFAnalysis::rechit_x_

private

Definition at line 214 of file PFAnalysisNtuplizer.cc.

◆ rechit_y_

vector<float> PFAnalysis::rechit_y_

private

Definition at line 215 of file PFAnalysisNtuplizer.cc.

◆ rechit_z_

vector<float> PFAnalysis::rechit_z_

private

Definition at line 216 of file PFAnalysisNtuplizer.cc.

◆ saveHits

bool PFAnalysis::saveHits

private

Definition at line 298 of file PFAnalysisNtuplizer.cc.

◆ simcluster_bx_

vector<int> PFAnalysis::simcluster_bx_

private

Definition at line 195 of file PFAnalysisNtuplizer.cc.

◆ simcluster_detids_

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

private

Definition at line 200 of file PFAnalysisNtuplizer.cc.

◆ simcluster_energy_

vector<float> PFAnalysis::simcluster_energy_

private

Definition at line 191 of file PFAnalysisNtuplizer.cc.

◆ simcluster_eta_

vector<float> PFAnalysis::simcluster_eta_

private

Definition at line 188 of file PFAnalysisNtuplizer.cc.

◆ simcluster_ev_

vector<int> PFAnalysis::simcluster_ev_

private

Definition at line 196 of file PFAnalysisNtuplizer.cc.

◆ simcluster_idx_trackingparticle_

vector<int> PFAnalysis::simcluster_idx_trackingparticle_

private

Definition at line 198 of file PFAnalysisNtuplizer.cc.

◆ simcluster_nhits_

vector<int> PFAnalysis::simcluster_nhits_

private

Definition at line 199 of file PFAnalysisNtuplizer.cc.

◆ simcluster_phi_

vector<float> PFAnalysis::simcluster_phi_

private

Definition at line 189 of file PFAnalysisNtuplizer.cc.

◆ simcluster_pid_

vector<int> PFAnalysis::simcluster_pid_

private

Definition at line 197 of file PFAnalysisNtuplizer.cc.

◆ simcluster_pt_

vector<float> PFAnalysis::simcluster_pt_

private

Definition at line 190 of file PFAnalysisNtuplizer.cc.

◆ simcluster_px_

vector<float> PFAnalysis::simcluster_px_

private

Definition at line 192 of file PFAnalysisNtuplizer.cc.

◆ simcluster_py_

vector<float> PFAnalysis::simcluster_py_

private

Definition at line 193 of file PFAnalysisNtuplizer.cc.

◆ simcluster_pz_

vector<float> PFAnalysis::simcluster_pz_

private

Definition at line 194 of file PFAnalysisNtuplizer.cc.

◆ simcluster_to_element

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

private

Definition at line 282 of file PFAnalysisNtuplizer.cc.

◆ simcluster_to_element_cmp

vector<float> PFAnalysis::simcluster_to_element_cmp

private

Definition at line 283 of file PFAnalysisNtuplizer.cc.

◆ simhit_det_

vector<int> PFAnalysis::simhit_det_

private

Definition at line 208 of file PFAnalysisNtuplizer.cc.

◆ simhit_detid_

vector<uint64_t> PFAnalysis::simhit_detid_

private

Definition at line 211 of file PFAnalysisNtuplizer.cc.

◆ simhit_eta_

vector<float> PFAnalysis::simhit_eta_

private

Definition at line 206 of file PFAnalysisNtuplizer.cc.

◆ simhit_frac_

vector<float> PFAnalysis::simhit_frac_

private

Definition at line 202 of file PFAnalysisNtuplizer.cc.

◆ simhit_idx_simcluster_

vector<int> PFAnalysis::simhit_idx_simcluster_

private

Definition at line 210 of file PFAnalysisNtuplizer.cc.

◆ simhit_phi_

vector<float> PFAnalysis::simhit_phi_

private

Definition at line 207 of file PFAnalysisNtuplizer.cc.

◆ simhit_subdet_

vector<int> PFAnalysis::simhit_subdet_

private

Definition at line 209 of file PFAnalysisNtuplizer.cc.

◆ simhit_x_

vector<float> PFAnalysis::simhit_x_

private

Definition at line 203 of file PFAnalysisNtuplizer.cc.

◆ simhit_y_

vector<float> PFAnalysis::simhit_y_

private

Definition at line 204 of file PFAnalysisNtuplizer.cc.

◆ simhit_z_

vector<float> PFAnalysis::simhit_z_

private

Definition at line 205 of file PFAnalysisNtuplizer.cc.

◆ simtrack_idx_simcluster_

vector<int> PFAnalysis::simtrack_idx_simcluster_

private

Definition at line 227 of file PFAnalysisNtuplizer.cc.

◆ simtrack_pid_

vector<int> PFAnalysis::simtrack_pid_

private

Definition at line 228 of file PFAnalysisNtuplizer.cc.

◆ simtrack_x_

vector<float> PFAnalysis::simtrack_x_

private

Definition at line 224 of file PFAnalysisNtuplizer.cc.

◆ simtrack_y_

vector<float> PFAnalysis::simtrack_y_

private

Definition at line 225 of file PFAnalysisNtuplizer.cc.

◆ simtrack_z_

vector<float> PFAnalysis::simtrack_z_

private

Definition at line 226 of file PFAnalysisNtuplizer.cc.

◆ t_

TTree* PFAnalysis::t_

private

Definition at line 162 of file PFAnalysisNtuplizer.cc.

◆ topologyToken_

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

private

Definition at line 290 of file PFAnalysisNtuplizer.cc.

◆ trackingparticle_bx_

vector<int> PFAnalysis::trackingparticle_bx_

private

Definition at line 178 of file PFAnalysisNtuplizer.cc.

◆ trackingparticle_dvx_

vector<float> PFAnalysis::trackingparticle_dvx_

private

Definition at line 175 of file PFAnalysisNtuplizer.cc.

◆ trackingparticle_dvy_

vector<float> PFAnalysis::trackingparticle_dvy_

private

Definition at line 176 of file PFAnalysisNtuplizer.cc.

◆ trackingparticle_dvz_

vector<float> PFAnalysis::trackingparticle_dvz_

private

Definition at line 177 of file PFAnalysisNtuplizer.cc.

◆ trackingparticle_energy_

vector<float> PFAnalysis::trackingparticle_energy_

private

Definition at line 174 of file PFAnalysisNtuplizer.cc.

◆ trackingparticle_eta_

vector<float> PFAnalysis::trackingparticle_eta_

private

Definition at line 168 of file PFAnalysisNtuplizer.cc.

◆ trackingparticle_ev_

vector<int> PFAnalysis::trackingparticle_ev_

private

Definition at line 179 of file PFAnalysisNtuplizer.cc.

◆ trackingparticle_exx_

vector<float> PFAnalysis::trackingparticle_exx_

private

Definition at line 183 of file PFAnalysisNtuplizer.cc.

◆ trackingparticle_exy_

vector<float> PFAnalysis::trackingparticle_exy_

private

Definition at line 184 of file PFAnalysisNtuplizer.cc.

◆ trackingparticle_mother_

vector<int> PFAnalysis::trackingparticle_mother_

private

Definition at line 185 of file PFAnalysisNtuplizer.cc.

◆ trackingparticle_ovx_

vector<float> PFAnalysis::trackingparticle_ovx_

private

Definition at line 180 of file PFAnalysisNtuplizer.cc.

◆ trackingparticle_ovy_

vector<float> PFAnalysis::trackingparticle_ovy_

private

Definition at line 181 of file PFAnalysisNtuplizer.cc.

◆ trackingparticle_ovz_

vector<float> PFAnalysis::trackingparticle_ovz_

private

Definition at line 182 of file PFAnalysisNtuplizer.cc.

◆ trackingparticle_phi_

vector<float> PFAnalysis::trackingparticle_phi_

private

Definition at line 169 of file PFAnalysisNtuplizer.cc.

◆ trackingparticle_pid_

vector<int> PFAnalysis::trackingparticle_pid_

private

Definition at line 186 of file PFAnalysisNtuplizer.cc.

◆ trackingparticle_pt_

vector<float> PFAnalysis::trackingparticle_pt_

private

Definition at line 170 of file PFAnalysisNtuplizer.cc.

◆ trackingparticle_px_

vector<float> PFAnalysis::trackingparticle_px_

private

Definition at line 171 of file PFAnalysisNtuplizer.cc.

◆ trackingparticle_py_

vector<float> PFAnalysis::trackingparticle_py_

private

Definition at line 172 of file PFAnalysisNtuplizer.cc.

◆ trackingparticle_pz_

vector<float> PFAnalysis::trackingparticle_pz_

private

Definition at line 173 of file PFAnalysisNtuplizer.cc.

◆ trackingparticle_to_element

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

private

Definition at line 281 of file PFAnalysisNtuplizer.cc.

◆ trackingParticles_

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

private

Definition at line 155 of file PFAnalysisNtuplizer.cc.

◆ tracks_

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

private

Definition at line 157 of file PFAnalysisNtuplizer.cc.

◆ tracks_recotosim_

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

private

Definition at line 160 of file PFAnalysisNtuplizer.cc.

Public Types

Public Member Functions

Static Public Member Functions

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Member Typedef Documentation

◆ Point

Constructor & Destructor Documentation

◆ PFAnalysis() [1/2]

◆ PFAnalysis() [2/2]

◆ ~PFAnalysis()

Member Function Documentation

◆ analyze()

◆ associateClusterToSimCluster()

◆ beginJob()

◆ beginRun()

◆ clearVariables()

◆ endJob()

◆ endRun()

◆ fillDescriptions()

◆ getHitPosition()

◆ processBlocks()

◆ processTrackingParticles()

Member Data Documentation

◆ aField_

◆ caloParticles_

◆ element_charge_

◆ element_cluster_flags_

◆ element_corr_energy_

◆ element_deltap_

◆ element_depth_

◆ element_distance_d_

◆ element_distance_i_

◆ element_distance_j_

◆ element_energy_

◆ element_eta_

◆ element_eta_ecal_

◆ element_eta_hcal_

◆ element_gsf_electronseed_trkorecal_

◆ element_layer_

◆ element_muon_csc_hits_

◆ element_muon_dt_hits_

◆ element_muon_type_

◆ element_num_hits_

◆ element_phi_

◆ element_phi_ecal_

◆ element_phi_hcal_

◆ element_pt_

◆ element_px_

◆ element_py_

◆ element_pz_

◆ element_sigmadeltap_

◆ element_to_candidate

◆ element_trajpoint_

◆ element_type_

◆ ev_event_

◆ ev_lumi_

◆ ev_run_

◆ gen_charge_

◆ gen_daughters_

◆ gen_energy_

◆ gen_eta_

◆ gen_pdgid_

◆ gen_phi_

◆ gen_pt_

◆ gen_px_

◆ gen_py_

◆ gen_pz_

◆ gen_status_

◆ genParticles_

◆ geom

◆ geometryToken_

◆ hcal_topo

◆ hcalDDDrecToken_

◆ hcons

◆ magFieldToken_

◆ pfBlocks_

◆ pfcandidate_energy_