Inheritance diagram for CTPPSProtonReconstructionSimulationValidator:

Classes
struct	PlotGroup

Public Member Functions
	CTPPSProtonReconstructionSimulationValidator (const edm::ParameterSet &)

Public Member Functions inherited from edm::one::EDAnalyzer<>
	EDAnalyzer ()=default

SerialTaskQueue *	globalLuminosityBlocksQueue () final

SerialTaskQueue *	globalRunsQueue () final

bool	wantsGlobalLuminosityBlocks () const final

bool	wantsGlobalRuns () 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

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::vector< ModuleDescription const * > &modules, 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

ProductResolverIndexAndSkipBit	uncheckedIndexFrom (EDGetToken) const

void	updateLookup (BranchType iBranchType, ProductResolverIndexHelper const &, bool iPrefetchMayGet)

void	updateLookup (eventsetup::ESRecordsToProxyIndices const &)

virtual	~EDConsumerBase () noexcept(false)

Private Member Functions
void	analyze (const edm::Event &, const edm::EventSetup &) override

void	endJob () override

void	fillPlots (unsigned int meth_idx, unsigned int idx, const reco::ForwardProton &rec_pr, const HepMC::FourVector &vtx, const HepMC::FourVector &mom, const LHCInfo &lhcInfo)

Private Attributes
std::string	lhcInfoLabel_

std::string	outputFile_

std::map< unsigned int, std::map< unsigned int, PlotGroup > >	plots_

edm::EDGetTokenT< edm::HepMCProduct >	tokenHepMCAfterSmearing_

edm::EDGetTokenT< edm::HepMCProduct >	tokenHepMCBeforeSmearing_

edm::EDGetTokenT< reco::ForwardProtonCollection >	tokenRecoProtonsMultiRP_

edm::EDGetTokenT< reco::ForwardProtonCollection >	tokenRecoProtonsSingleRP_

Additional Inherited Members
Public Types inherited from edm::one::EDAnalyzerBase
typedef EDAnalyzerBase	ModuleType

Public Types inherited from edm::EDConsumerBase
typedef ProductLabels	Labels

Static Public Member Functions inherited from edm::one::EDAnalyzerBase
static const std::string &	baseType ()

static void	fillDescriptions (ConfigurationDescriptions &descriptions)

static void	prevalidate (ConfigurationDescriptions &descriptions)

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>
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)

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 34 of file CTPPSProtonReconstructionSimulationValidator.cc.

Constructor & Destructor Documentation

◆ CTPPSProtonReconstructionSimulationValidator()

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

explicit

Definition at line 156 of file CTPPSProtonReconstructionSimulationValidator.cc.

     : tokenHepMCBeforeSmearing_(
           consumes<edm::HepMCProduct>(iConfig.getParameter<edm::InputTag>("tagHepMCBeforeSmearing"))),
       tokenHepMCAfterSmearing_(
           consumes<edm::HepMCProduct>(iConfig.getParameter<edm::InputTag>("tagHepMCAfterSmearing"))),
       tokenRecoProtonsSingleRP_(
           consumes<reco::ForwardProtonCollection>(iConfig.getParameter<InputTag>("tagRecoProtonsSingleRP"))),
       tokenRecoProtonsMultiRP_(
           consumes<reco::ForwardProtonCollection>(iConfig.getParameter<InputTag>("tagRecoProtonsMultiRP"))),
       lhcInfoLabel_(iConfig.getParameter<std::string>("lhcInfoLabel")),

Member Function Documentation

◆ analyze()

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

overrideprivatevirtual

Implements edm::one::EDAnalyzerBase.

Definition at line 171 of file CTPPSProtonReconstructionSimulationValidator.cc.

                                                                                                               {
   // get conditions
   edm::ESHandle<LHCInfo> hLHCInfo;
   iSetup.get<LHCInfoRcd>().get(lhcInfoLabel_, hLHCInfo);
  
   // get input
   edm::Handle<edm::HepMCProduct> hHepMCBeforeSmearing;
   iEvent.getByToken(tokenHepMCBeforeSmearing_, hHepMCBeforeSmearing);
   HepMC::GenEvent *hepMCEventBeforeSmearing = (HepMC::GenEvent *)hHepMCBeforeSmearing->GetEvent();
  
   edm::Handle<edm::HepMCProduct> hHepMCAfterSmearing;
   iEvent.getByToken(tokenHepMCAfterSmearing_, hHepMCAfterSmearing);
   HepMC::GenEvent *hepMCEventAfterSmearing = (HepMC::GenEvent *)hHepMCAfterSmearing->GetEvent();
  
   Handle<reco::ForwardProtonCollection> hRecoProtonsSingleRP;
   iEvent.getByToken(tokenRecoProtonsSingleRP_, hRecoProtonsSingleRP);
  
   Handle<reco::ForwardProtonCollection> hRecoProtonsMultiRP;
   iEvent.getByToken(tokenRecoProtonsMultiRP_, hRecoProtonsMultiRP);
  
   // extract vertex position
   bool vertex_set = false;
   FourVector vtx;
   for (auto it = hepMCEventAfterSmearing->vertices_begin(); it != hepMCEventAfterSmearing->vertices_end(); ++it) {
     if (vertex_set) {
       LogError("CTPPSProtonReconstructionSimulationValidator") << "Multiple vertices found.";
       return;
     }
  
     vertex_set = true;
     vtx = (*it)->position();
   }
  
   // extract forward protons
   bool proton_45_set = false;
   bool proton_56_set = false;
   FourVector mom_45, mom_56;
  
   for (auto it = hepMCEventBeforeSmearing->particles_begin(); it != hepMCEventBeforeSmearing->particles_end(); ++it) {
     const auto &part = *it;
  
     // accept only stable non-beam protons
     if (part->pdg_id() != 2212)
       continue;
  
     if (part->status() != 1)
       continue;
  
     if (part->is_beam())
       continue;
  
     const auto &mom = part->momentum();
  
     if (mom.e() < 4500.)
       continue;
  
     if (mom.z() > 0) {
       // 45
       if (proton_45_set) {
         LogError("CTPPSProtonReconstructionSimulationValidator") << "Found multiple protons in sector 45.";
         return;
       }
  
       proton_45_set = true;
       mom_45 = mom;
     } else {
       // 56
       if (proton_56_set) {
         LogError("CTPPSProtonReconstructionSimulationValidator") << "Found multiple protons in sector 56.";
         return;
       }
  
       proton_56_set = true;
       mom_56 = mom;
     }
   }
  
   // do comparison
   for (const auto &handle : {hRecoProtonsSingleRP, hRecoProtonsMultiRP}) {
     for (const auto &rec_pr : *handle) {
       if (!rec_pr.validFit())
         continue;
  
       unsigned int idx;
  
       bool mom_set = false;
       FourVector mom;
  
       if (rec_pr.lhcSector() == reco::ForwardProton::LHCSector::sector45) {
         idx = 0;
         mom_set = proton_45_set;
         mom = mom_45;
       } else {
         idx = 1;
         mom_set = proton_56_set;
         mom = mom_56;
       }
  
       if (!mom_set)
         continue;
  
       unsigned int meth_idx = 1234;
  
       if (rec_pr.method() == reco::ForwardProton::ReconstructionMethod::singleRP) {
         meth_idx = 0;
  
         CTPPSDetId rpId((*rec_pr.contributingLocalTracks().begin())->rpId());
         idx = 100 * rpId.arm() + 10 * rpId.station() + rpId.rp();
       }
  
       if (rec_pr.method() == reco::ForwardProton::ReconstructionMethod::multiRP)
         meth_idx = 1;
  
       fillPlots(meth_idx, idx, rec_pr, vtx, mom, *hLHCInfo);
     }
   }

References edm::RefVector< C, T, F >::begin(), reco::ForwardProton::contributingLocalTracks(), fillPlots(), edm::EventSetup::get(), get, edm::HepMCProduct::GetEvent(), patZpeak::handle, training_settings::idx, iEvent, lhcInfoLabel_, reco::ForwardProton::lhcSector(), reco::ForwardProton::method(), reco::ForwardProton::multiRP, year_2016_postTS2_cff::rpId, reco::ForwardProton::sector45, reco::ForwardProton::singleRP, tokenHepMCAfterSmearing_, tokenHepMCBeforeSmearing_, tokenRecoProtonsMultiRP_, tokenRecoProtonsSingleRP_, reco::ForwardProton::validFit(), and badGlobalMuonTaggersAOD_cff::vtx.

◆ endJob()

void CTPPSProtonReconstructionSimulationValidator::endJob ( void )

overrideprivatevirtual

Reimplemented from edm::one::EDAnalyzerBase.

Definition at line 333 of file CTPPSProtonReconstructionSimulationValidator.cc.

                                                           {
   auto f_out = std::make_unique<TFile>(outputFile_.c_str(), "recreate");
  
   for (const auto &mit : plots_) {
     const char *method = (mit.first == 0) ? "single rp" : "multi rp";
     TDirectory *d_method = f_out->mkdir(method);
  
     for (const auto &eit : mit.second) {
       gDirectory = d_method->mkdir(Form("%i", eit.first));
       eit.second.write();
     }
   }

References AlcaSiPixelAliHarvester0T_cff::method, outputFile_, and plots_.

◆ fillPlots()

void CTPPSProtonReconstructionSimulationValidator::fillPlots	(	unsigned int	meth_idx,
		unsigned int	idx,
		const reco::ForwardProton &	rec_pr,
		const HepMC::FourVector &	vtx,
		const HepMC::FourVector &	mom,
		const LHCInfo &	lhcInfo
	)

private

Definition at line 291 of file CTPPSProtonReconstructionSimulationValidator.cc.

                                                                                      {
   const double p_nom = lhcInfo.energy();
   const double xi_simu = (p_nom - mom.rho()) / p_nom;
   const double th_x_simu = mom.x() / mom.rho();
   const double th_y_simu = mom.y() / mom.rho();
   const double vtx_y_simu = vtx.y();
   const double th_simu = sqrt(th_x_simu * th_x_simu + th_y_simu * th_y_simu);
   const double t_simu = -reco::ForwardProton::calculateT(p_nom, mom.rho(), th_simu);
  
   const double xi_reco = rec_pr.xi();
   const double th_x_reco = rec_pr.thetaX();
   const double th_y_reco = rec_pr.thetaY();
   const double vtx_y_reco = rec_pr.vertex().y() * 10.;  // conversion: cm --> mm
   const double t_reco = -rec_pr.t();
  
   auto &plt = plots_[meth_idx][idx];
  
   plt.h_xi_reco_vs_xi_simu->Fill(xi_simu, xi_reco);
   plt.h_de_xi->Fill(xi_reco - xi_simu);
   plt.p_de_xi_vs_xi_simu->Fill(xi_simu, xi_reco - xi_simu);
  
   plt.h_de_th_x->Fill(th_x_reco - th_x_simu);
   plt.p_de_th_x_vs_xi_simu->Fill(xi_simu, th_x_reco - th_x_simu);
  
   plt.h_de_th_y->Fill(th_y_reco - th_y_simu);
   plt.p_de_th_y_vs_xi_simu->Fill(xi_simu, th_y_reco - th_y_simu);
  
   plt.h_de_vtx_y->Fill(vtx_y_reco - vtx_y_simu);
   plt.p_de_vtx_y_vs_xi_simu->Fill(xi_simu, vtx_y_reco - vtx_y_simu);
  
   plt.h_de_t->Fill(t_reco - t_simu);
   plt.p_de_t_vs_xi_simu->Fill(xi_simu, t_reco - t_simu);
   plt.p_de_t_vs_t_simu->Fill(t_simu, t_reco - t_simu);