#include <PythiaFilterIsolatedTrack.h>

Inheritance diagram for PythiaFilterIsolatedTrack:

Public Member Functions
void	endStream () override

bool	filter (edm::Event &, edm::EventSetup const &) override

double	getDistInCM (double eta1, double phi1, double eta2, double phi2)

std::pair< double, double >	GetEtaPhiAtEcal (double etaIP, double phiIP, double pT, int charge, double vtxZ)

	PythiaFilterIsolatedTrack (const edm::ParameterSet &, const PythiaFilterIsoTracks::Counters *count)

	~PythiaFilterIsolatedTrack () override

Public Member Functions inherited from edm::stream::EDFilter< edm::GlobalCache< PythiaFilterIsoTracks::Counters > >
	EDFilter ()=default

bool	hasAbilityToProduceInLumis () const final

bool	hasAbilityToProduceInRuns () const final

Public Member Functions inherited from edm::stream::EDFilterBase
	EDFilterBase ()

ModuleDescription const &	moduleDescription () const

	~EDFilterBase () override

Public Member Functions inherited from edm::ProducerBase
void	callWhenNewProductsRegistered (std::function< void(BranchDescription const &)> const &func)

std::vector< edm::ProductResolverIndex > const &	indiciesForPutProducts (BranchType iBranchType) const

	ProducerBase ()

std::vector< edm::ProductResolverIndex > const &	putTokenIndexToProductResolverIndex () const

void	registerProducts (ProducerBase , ProductRegistry , ModuleDescription const &)

std::function< void(BranchDescription const &)>	registrationCallback () const
	used by the fwk to register list of products More...

void	resolvePutIndicies (BranchType iBranchType, ModuleToResolverIndicies const &iIndicies, std::string const &moduleLabel)

	~ProducerBase () noexcept(false) 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)

Static Public Member Functions
static void	globalEndJob (const PythiaFilterIsoTracks::Counters *counters)

static std::unique_ptr< PythiaFilterIsoTracks::Counters >	initializeGlobalCache (edm::ParameterSet const &)

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

static void	fillDescriptions (ConfigurationDescriptions &descriptions)

static void	prevalidate (ConfigurationDescriptions &descriptions)

Private Attributes
double	ecDist_

double	ecRad_

double	IsolCone_

double	MaxSeedEta_

double	MinIsolTrackMom_

double	MinSeedMom_

unsigned int	nAll_

unsigned int	nGood_

bool	onlyHadrons_

edm::EDGetTokenT< edm::HepMCProduct >	token_

Additional Inherited Members
Public Types inherited from edm::stream::EDFilter< edm::GlobalCache< PythiaFilterIsoTracks::Counters > >
typedef CacheContexts< T... >	CacheTypes

typedef CacheTypes::GlobalCache	GlobalCache

typedef AbilityChecker< T... >	HasAbility

typedef CacheTypes::LuminosityBlockCache	LuminosityBlockCache

typedef LuminosityBlockContextT< LuminosityBlockCache, RunCache, GlobalCache >	LuminosityBlockContext

typedef CacheTypes::LuminosityBlockSummaryCache	LuminosityBlockSummaryCache

typedef CacheTypes::RunCache	RunCache

typedef RunContextT< RunCache, GlobalCache >	RunContext

typedef CacheTypes::RunSummaryCache	RunSummaryCache

Public Types inherited from edm::stream::EDFilterBase
typedef EDFilterAdaptorBase	ModuleType

Public Types inherited from edm::ProducerBase
using	ModuleToResolverIndicies = std::unordered_multimap< std::string, std::tuple< edm::TypeID const , const char , edm::ProductResolverIndex >>

typedef ProductRegistryHelper::TypeLabelList	TypeLabelList

Public Types inherited from edm::EDConsumerBase
typedef ProductLabels	Labels

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

PythiaFilterGammaJet filter implements generator-level preselections for ChargedHadron+jet like events to be used in jet energy calibration. Ported from fortran code written by V.Konoplianikov.

Author: O.Kodolova, SINP

Cleaned up code

Author: J.P. Chou, Brown University

Definition at line 43 of file PythiaFilterIsolatedTrack.h.

Constructor & Destructor Documentation

PythiaFilterIsolatedTrack::PythiaFilterIsolatedTrack	(	const edm::ParameterSet &	iConfig,
		const PythiaFilterIsoTracks::Counters *	count
	)

explicit

Definition at line 77 of file PythiaFilterIsolatedTrack.cc.

References edm::ParameterSet::getUntrackedParameter(), IsolCone_, MaxSeedEta_, MinIsolTrackMom_, MinSeedMom_, onlyHadrons_, and token_.

                                                                                                                                   : nAll_(0), nGood_(0), ecDist_(317.0), ecRad_(129.0) {
 
   token_ = consumes<edm::HepMCProduct>(iConfig.getUntrackedParameter("ModuleLabel",edm::InputTag("generator","unsmeared")));
   MaxSeedEta_ = iConfig.getUntrackedParameter<double>("MaxSeedEta", 2.3);
   MinSeedMom_ = iConfig.getUntrackedParameter<double>("MinSeedMom", 20.);
   MinIsolTrackMom_ = iConfig.getUntrackedParameter<double>("MinIsolTrackMom",2.0);
   IsolCone_   = iConfig.getUntrackedParameter<double>("IsolCone", 40.0);
   onlyHadrons_= iConfig.getUntrackedParameter<bool>("OnlyHadrons", true);
 }

PythiaFilterIsolatedTrack::~PythiaFilterIsolatedTrack ( )

override

Definition at line 87 of file PythiaFilterIsolatedTrack.cc.

87 { }

Member Function Documentation

void PythiaFilterIsolatedTrack::endStream ( )

overridevirtual

Reimplemented from edm::stream::EDFilterBase.

Definition at line 172 of file PythiaFilterIsolatedTrack.cc.

References nAll_, and nGood_.

                                           {
   globalCache()->nAll_  += nAll_;
   globalCache()->nGood_ += nGood_;
 }

bool PythiaFilterIsolatedTrack::filter	(	edm::Event &	iEvent,
		edm::EventSetup const &	iSetup
	)

overridevirtual

Implements edm::stream::EDFilterBase.

Definition at line 90 of file PythiaFilterIsolatedTrack.cc.

References funct::abs(), MBUEandQCDValidation_cff::chargedParticles, GenParticle::GenParticle, edm::Event::getByToken(), edm::EventSetup::getData(), getDistInCM(), GetEtaPhiAtEcal(), edm::HepMCProduct::GetEvent(), IsolCone_, MaxSeedEta_, MinIsolTrackMom_, MinSeedMom_, nAll_, nGood_, onlyHadrons_, AlCaHLTBitMon_ParallelJobs::p, p1, p2, mps_update::status, and token_.

                                                                                     {
 
   ++nAll_;
   edm::ESHandle<ParticleDataTable> pdt;
   iSetup.getData( pdt );
 
   edm::Handle<edm::HepMCProduct> evt;
   iEvent.getByToken(token_, evt);
 
   const HepMC::GenEvent* myGenEvent = evt->GetEvent();
 
   // all of the stable, charged particles with momentum>MinIsolTrackMom_ and |eta|<MaxSeedEta_+0.5
   std::vector<const HepMC::GenParticle *> chargedParticles;
 
   // all of the stable, charged particles with momentum>MinSeedMom_ and |eta|<MaxSeedEta_
   std::vector<const HepMC::GenParticle *> seeds;
 
   // fill the vector of charged particles and seeds in the event
   for (HepMC::GenEvent::particle_const_iterator iter=myGenEvent->particles_begin(); iter!=myGenEvent->particles_end(); ++iter) {
     const HepMC::GenParticle *p=*iter;
     if (!(pdt->particle(p->pdg_id()))) continue;
     int charge3 = pdt->particle(p->pdg_id())->ID().threeCharge();
     int status = p->status();
     double momentum = p->momentum().rho();
     double abseta = fabs(p->momentum().eta());
 
     // only consider stable, charged particles
     if (abs(charge3)==3 && status==1 && momentum>MinIsolTrackMom_ && abseta<MaxSeedEta_+0.5) {
       chargedParticles.push_back(p);
       if (momentum>MinSeedMom_ && abseta<MaxSeedEta_) {
     seeds.push_back(p);
       }
     }
   }
 
   // loop over all the seeds and see if any of them are isolated
   unsigned int ntrk(0);
   for (std::vector<const HepMC::GenParticle *>::const_iterator it1=seeds.begin(); it1!=seeds.end(); ++it1) {
     const HepMC::GenParticle *p1=*it1;
     if (!(pdt->particle(p1->pdg_id()))) continue;
     if (p1->pdg_id() < -100 || p1->pdg_id() > 100 || (!onlyHadrons_)) { // Select hadrons only
       std::pair<double,double> EtaPhi1=GetEtaPhiAtEcal(p1->momentum().eta(),
                                p1->momentum().phi(),
                                p1->momentum().perp(),
                                (pdt->particle(p1->pdg_id()))->ID().threeCharge()/3,
                                0.0);
 
       // loop over all of the other charged particles in the event, and see if any are close by
       bool failsIso=false;
       for (std::vector<const HepMC::GenParticle *>::const_iterator it2=chargedParticles.begin(); it2!=chargedParticles.end(); ++it2) {
     const HepMC::GenParticle *p2=*it2;
 
     // don't consider the seed particle among the other charge particles
     if (p1!=p2) {
 
       std::pair<double,double> EtaPhi2=GetEtaPhiAtEcal(p2->momentum().eta(),
                                p2->momentum().phi(),
                                p2->momentum().perp(),
                                (pdt->particle(p2->pdg_id()))->ID().threeCharge()/3,
                                0.0);
       
       // find out how far apart the particles are
       // if the seed fails the isolation requirement, try a different seed
       // occasionally allow a seed to pass to isolation requirement
       if (getDistInCM(EtaPhi1.first, EtaPhi1.second, EtaPhi2.first, EtaPhi2.second) < IsolCone_) {
         failsIso=true;
         break;
       }
     }
       }
 
       if (!failsIso) ++ntrk;
     }
   } //loop over seeds
   if (ntrk>0) {
     ++nGood_;
     return true;
   } else {
     return false;
   }
 }

double PythiaFilterIsolatedTrack::getDistInCM	(	double	eta1,
		double	phi1,
		double	eta2,
		double	phi2
	)

Definition at line 61 of file PythiaFilterIsolatedTrack.cc.

References funct::cos(), ecDist_, ecRad_, mathSSE::sqrt(), and z.

Referenced by filter().

 {
   double dR, Rec;
   if (fabs(eta1)<1.479) Rec=ecRad_;
   else                  Rec=ecDist_;
   double ce1=cosh(eta1);
   double ce2=cosh(eta2);
   double te1=tanh(eta1);
   double te2=tanh(eta2);
   
   double z=cos(phi1-phi2)/ce1/ce2+te1*te2;
   if(z!=0) dR=fabs(Rec*ce1*sqrt(1./z/z-1.));
   else     dR=999999.;
   return dR;
 }

std::pair< double, double > PythiaFilterIsolatedTrack::GetEtaPhiAtEcal	(	double	etaIP,
		double	phiIP,
		double	pT,
		int	charge,
		double	vtxZ
	)

Definition at line 14 of file PythiaFilterIsolatedTrack.cc.

References alpha, ALCARECOTkAlJpsiMuMu_cff::charge, hiPixelPairStep_cff::deltaPhi, ecDist_, ecRad_, JetChargeProducer_cfi::exp, cmsBatch::log, pi, funct::sin(), funct::tan(), theta(), and z.

Referenced by filter().

 {
   double deltaPhi;
   double etaEC=100;
   double phiEC=100;
   double Rcurv=pT*33.3*100/38; //r(m)=pT(GeV)*33.3/B(kG)
   double theta=2*atan(exp(-etaIP));
   double zNew;
   if (theta>CLHEP::halfpi) theta=CLHEP::pi-theta;
   if (fabs(etaIP)<1.479) {
     deltaPhi=-charge*asin(0.5*ecRad_/Rcurv);
     double alpha1=2*asin(0.5*ecRad_/Rcurv);
     double z=ecRad_/tan(theta);
     if (etaIP>0) zNew=z*(Rcurv*alpha1)/ecRad_+vtxZ; //new z-coordinate of track
     else  zNew=-z*(Rcurv*alpha1)/ecRad_+vtxZ; //new z-coordinate of track
     double zAbs=fabs(zNew);
     if (zAbs<ecDist_) {
       etaEC=-log(tan(0.5*atan(ecRad_/zAbs)));
       deltaPhi=-charge*asin(0.5*ecRad_/Rcurv);
     }
     if (zAbs>ecDist_) {
       zAbs=(fabs(etaIP)/etaIP)*ecDist_;
       double Zflight=fabs(zAbs-vtxZ);
       double alpha=(Zflight*ecRad_)/(z*Rcurv);
       double Rec=2*Rcurv*sin(alpha/2);
       deltaPhi=-charge*alpha/2;
       etaEC=-log(tan(0.5*atan(Rec/ecDist_)));
     }
   } else {
     zNew=(fabs(etaIP)/etaIP)*ecDist_;
     double Zflight=fabs(zNew-vtxZ);
     double Rvirt=fabs(Zflight*tan(theta));
     double Rec=2*Rcurv*sin(Rvirt/(2*Rcurv));
     deltaPhi=-(charge)*(Rvirt/(2*Rcurv));
     etaEC=-log(tan(0.5*atan(Rec/ecDist_)));
   }
   
   if (zNew<0) etaEC=-etaEC;
   phiEC=phiIP+deltaPhi;
   
   if (phiEC<-CLHEP::pi) phiEC= 2*CLHEP::pi+phiEC;
   if (phiEC> CLHEP::pi) phiEC=-2*CLHEP::pi+phiEC;
   
   std::pair<double,double> retVal(etaEC,phiEC);
   return retVal;
 }

void PythiaFilterIsolatedTrack::globalEndJob ( const PythiaFilterIsoTracks::Counters * counters )

static

Definition at line 177 of file PythiaFilterIsolatedTrack.cc.

References PythiaFilterIsoTracks::Counters::nAll_, and PythiaFilterIsoTracks::Counters::nGood_.

                                                                                        {
   edm::LogInfo("PythiaFilter") << "PythiaFilterIsolatedTrack::Accepts " 
                    << count->nGood_ <<" events out of "
                                << count->nAll_ << std::endl;
 }

static std::unique_ptr<PythiaFilterIsoTracks::Counters> PythiaFilterIsolatedTrack::initializeGlobalCache ( edm::ParameterSet const & )

inlinestatic

Definition at line 49 of file PythiaFilterIsolatedTrack.h.

References ALCARECOTkAlJpsiMuMu_cff::charge, ALCARECOTkAlBeamHalo_cff::filter, and PVValHelper::pT.

                                                                                                      {
     return std::unique_ptr<PythiaFilterIsoTracks::Counters>(new PythiaFilterIsoTracks::Counters());
   }