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

	EDConsumerBase (EDConsumerBase &&)=default

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

EDConsumerBase &	operator= (EDConsumerBase &&)=default

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

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

Detailed Description

Definition at line 35 of file CTPPSProtonReconstructionSimulationValidator.cc.

Constructor & Destructor Documentation

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

explicit

Definition at line 158 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")),
   outputFile_(iConfig.getParameter<string>("outputFile"))
 {}

Member Function Documentation

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

overrideprivate

Definition at line 169 of file CTPPSProtonReconstructionSimulationValidator.cc.

References CTPPSDetId::arm(), fillPlots(), edm::EventSetup::get(), edm::Event::getByToken(), edm::HepMCProduct::GetEvent(), cmsBatch::handle, training_settings::idx, lhcInfoLabel_, reco::ForwardProton::multiRP, reco::ForwardProton::sector45, reco::ForwardProton::singleRP, tokenHepMCAfterSmearing_, tokenHepMCBeforeSmearing_, tokenRecoProtonsMultiRP_, tokenRecoProtonsSingleRP_, and badGlobalMuonTaggersAOD_cff::vtx.

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

void CTPPSProtonReconstructionSimulationValidator::endJob ( void )

overrideprivatevirtual

Reimplemented from edm::one::EDAnalyzerBase.

Definition at line 330 of file CTPPSProtonReconstructionSimulationValidator.cc.

References DEFINE_FWK_MODULE, AlcaSiPixelAliHarvester0T_cff::method, outputFile_, and plots_.

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

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.

References reco::ForwardProton::calculateT(), LHCInfo::energy(), training_settings::idx, plots_, mathSSE::sqrt(), reco::ForwardProton::t(), reco::ForwardProton::thetaX(), reco::ForwardProton::thetaY(), reco::ForwardProton::vertex(), and reco::ForwardProton::xi().

Referenced by analyze().

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