CMS 3D CMS Logo
List of all members | Public Types | Public Member Functions | Private Member Functions | Private Attributes
ZToLLEdmNtupleDumper Class Reference
Inheritance diagram for ZToLLEdmNtupleDumper:
edm::EDProducer edm::ProducerBase edm::EDConsumerBase edm::ProductRegistryHelper

Public Types

typedef math::XYZVector Vector
 
- Public Types inherited from edm::EDProducer
typedef EDProducer 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
 

Public Member Functions

 ZToLLEdmNtupleDumper (const edm::ParameterSet &)
 
- Public Member Functions inherited from edm::EDProducer
 EDProducer ()
 
SerialTaskQueue * globalLuminosityBlocksQueue ()
 
SerialTaskQueue * globalRunsQueue ()
 
ModuleDescription const & moduleDescription () const
 
 ~EDProducer () 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
 
std::vector< bool > const & recordProvenanceList () 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)
 
TypeLabelList const & typeLabelList () const
 used by the fwk to register the list of products of this module More...
 
 ~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 &&)=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 produce (edm::Event &, const edm::EventSetup &) override
 

Private Attributes

std::vector< double > alpha_
 
edm::EDGetTokenT< BeamSpot > beamSpotToken_
 
std::vector< double > beta_
 
int counter
 
std::vector< double > dREcal_
 
std::vector< double > dRHcal_
 
std::vector< double > dRTrk_
 
std::vector< double > dRVetoTrk_
 
std::vector< double > etEcalThreshold_
 
std::vector< double > etHcalThreshold_
 
std::vector< string > hltPath_
 
edm::EDGetTokenT< VertexCollection > primaryVerticesToken_
 
std::vector< double > ptThreshold_
 
std::vector< double > relativeIsolation_
 
std::vector< edm::EDGetTokenT< GenParticleMatch > > zGenParticlesMatchTokens_
 
std::vector< std::string > zName_
 
std::vector< edm::EDGetTokenT< CandidateView > > zTokens_
 

Additional Inherited Members

- Static Public Member Functions inherited from edm::EDProducer
static const std::string & baseType ()
 
static void fillDescriptions (ConfigurationDescriptions &descriptions)
 
static void prevalidate (ConfigurationDescriptions &descriptions)
 
static bool wantsGlobalLuminosityBlocks ()
 
static bool wantsGlobalRuns ()
 
static bool wantsStreamLuminosityBlocks ()
 
static bool wantsStreamRuns ()
 
- Protected Member Functions inherited from edm::ProducerBase
template<class ProductType >
BranchAliasSetterT< ProductType > produces ()
 declare what type of product will make and with which optional label More...
 
template<typename ProductType , BranchType B>
BranchAliasSetterT< ProductType > produces ()
 
template<typename ProductType , Transition B>
BranchAliasSetterT< ProductType > produces ()
 
BranchAliasSetter produces (const TypeID &id, std::string instanceName=std::string(), bool recordProvenance=true)
 
template<BranchType B>
BranchAliasSetter produces (const TypeID &id, std::string instanceName=std::string(), bool recordProvenance=true)
 
template<Transition B>
BranchAliasSetter produces (const TypeID &id, std::string instanceName=std::string(), bool recordProvenance=true)
 
template<typename ProductType , Transition B>
BranchAliasSetterT< ProductType > produces (std::string instanceName)
 
template<class ProductType >
BranchAliasSetterT< ProductType > produces (std::string instanceName)
 
template<typename ProductType , BranchType B>
BranchAliasSetterT< ProductType > produces (std::string instanceName)
 
ProducesCollector producesCollector ()
 
- 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 38 of file ZToLLEdmNtupleDumper.cc.

Member Typedef Documentation

◆ Vector

typedef math::XYZVector ZToLLEdmNtupleDumper::Vector

Definition at line 40 of file ZToLLEdmNtupleDumper.cc.

Constructor & Destructor Documentation

◆ ZToLLEdmNtupleDumper()

ZToLLEdmNtupleDumper::ZToLLEdmNtupleDumper ( const edm::ParameterSet &  cfg)

Definition at line 147 of file ZToLLEdmNtupleDumper.cc.

147  {
148  string alias;
149  vector<ParameterSet> psets = cfg.getParameter<vector<ParameterSet> >("zBlocks");
150  for (std::vector<edm::ParameterSet>::const_iterator i = psets.begin(); i != psets.end(); ++i) {
151  string zName = i->getParameter<string>("zName");
152  edm::EDGetTokenT<CandidateView> zToken = consumes<CandidateView>(i->getParameter<InputTag>("z"));
153  edm::EDGetTokenT<GenParticleMatch> zGenParticlesMatchToken =
154  consumes<GenParticleMatch>(i->getParameter<InputTag>("zGenParticlesMatch"));
155  beamSpotToken_ = consumes<BeamSpot>(i->getParameter<InputTag>("beamSpot"));
156  primaryVerticesToken_ = consumes<VertexCollection>(i->getParameter<InputTag>("primaryVertices"));
157  double ptThreshold = i->getParameter<double>("ptThreshold");
158  double etEcalThreshold = i->getParameter<double>("etEcalThreshold");
159  double etHcalThreshold = i->getParameter<double>("etHcalThreshold");
160  double dRVetoTrk = i->getParameter<double>("deltaRVetoTrk");
161  double dRTrk = i->getParameter<double>("deltaRTrk");
162  double dREcal = i->getParameter<double>("deltaREcal");
163  double dRHcal = i->getParameter<double>("deltaRHcal");
164  double alpha = i->getParameter<double>("alpha");
165  double beta = i->getParameter<double>("beta");
166  bool relativeIsolation = i->getParameter<bool>("relativeIsolation");
167  string hltPath = i->getParameter<std::string>("hltPath");
168  zName_.push_back(zName);
169  zTokens_.push_back(zToken);
170  zGenParticlesMatchTokens_.push_back(zGenParticlesMatchToken);
171  ptThreshold_.push_back(ptThreshold);
172  etEcalThreshold_.push_back(etEcalThreshold);
173  etHcalThreshold_.push_back(etHcalThreshold);
174  dRVetoTrk_.push_back(dRVetoTrk);
175  dRTrk_.push_back(dRTrk);
176  dREcal_.push_back(dREcal);
177  dRHcal_.push_back(dRHcal);
178  alpha_.push_back(alpha);
179  beta_.push_back(beta);
180  relativeIsolation_.push_back(relativeIsolation);
181  hltPath_.push_back(hltPath);
182  produces<vector<edm::EventNumber_t> >(alias = zName + "EventNumber").setBranchAlias(alias);
183  produces<vector<unsigned int> >(alias = zName + "RunNumber").setBranchAlias(alias);
184  produces<vector<unsigned int> >(alias = zName + "LumiBlock").setBranchAlias(alias);
185  produces<vector<float> >(alias = zName + "Mass").setBranchAlias(alias);
186  produces<vector<float> >(alias = zName + "MassSa").setBranchAlias(alias);
187  produces<vector<float> >(alias = zName + "Pt").setBranchAlias(alias);
188  produces<vector<float> >(alias = zName + "Eta").setBranchAlias(alias);
189  produces<vector<float> >(alias = zName + "Phi").setBranchAlias(alias);
190  produces<vector<float> >(alias = zName + "Y").setBranchAlias(alias);
191  produces<vector<float> >(alias = zName + "Dau1Pt").setBranchAlias(alias);
192  produces<vector<float> >(alias = zName + "Dau2Pt").setBranchAlias(alias);
193  produces<vector<float> >(alias = zName + "Dau1SaPt").setBranchAlias(alias);
194  produces<vector<float> >(alias = zName + "Dau2SaPt").setBranchAlias(alias);
195  produces<vector<unsigned int> >(alias = zName + "Dau1HLTBit").setBranchAlias(alias);
196  produces<vector<unsigned int> >(alias = zName + "Dau2HLTBit").setBranchAlias(alias);
197  produces<vector<int> >(alias = zName + "Dau1Q").setBranchAlias(alias);
198  produces<vector<int> >(alias = zName + "Dau2Q").setBranchAlias(alias);
199  produces<vector<float> >(alias = zName + "Dau1Eta").setBranchAlias(alias);
200  produces<vector<float> >(alias = zName + "Dau2Eta").setBranchAlias(alias);
201  produces<vector<float> >(alias = zName + "Dau1SaEta").setBranchAlias(alias);
202  produces<vector<float> >(alias = zName + "Dau2SaEta").setBranchAlias(alias);
203  produces<vector<float> >(alias = zName + "Dau1Phi").setBranchAlias(alias);
204  produces<vector<float> >(alias = zName + "Dau2Phi").setBranchAlias(alias);
205  produces<vector<float> >(alias = zName + "Dau1SaPhi").setBranchAlias(alias);
206  produces<vector<float> >(alias = zName + "Dau2SaPhi").setBranchAlias(alias);
207  produces<vector<float> >(alias = zName + "Dau1Iso").setBranchAlias(alias);
208  produces<vector<float> >(alias = zName + "Dau2Iso").setBranchAlias(alias);
209  produces<vector<float> >(alias = zName + "Dau1TrkIso").setBranchAlias(alias);
210  produces<vector<float> >(alias = zName + "Dau2TrkIso").setBranchAlias(alias);
211  produces<vector<float> >(alias = zName + "Dau1EcalIso").setBranchAlias(alias);
212  produces<vector<float> >(alias = zName + "Dau2EcalIso").setBranchAlias(alias);
213  produces<vector<float> >(alias = zName + "Dau1HcalIso").setBranchAlias(alias);
214  produces<vector<float> >(alias = zName + "Dau2HcalIso").setBranchAlias(alias);
215  produces<vector<float> >(alias = zName + "Dau1MuEnergyEm").setBranchAlias(alias);
216  produces<vector<float> >(alias = zName + "Dau1MuEnergyHad").setBranchAlias(alias);
217  produces<vector<float> >(alias = zName + "Dau2MuEnergyEm").setBranchAlias(alias);
218  produces<vector<float> >(alias = zName + "Dau2MuEnergyHad").setBranchAlias(alias);
219 
220  produces<vector<float> >(alias = zName + "VtxNormChi2").setBranchAlias(alias);
221  produces<vector<unsigned int> >(alias = zName + "Dau1NofHit").setBranchAlias(alias);
222  produces<vector<unsigned int> >(alias = zName + "Dau2NofHit").setBranchAlias(alias);
223  produces<vector<unsigned int> >(alias = zName + "Dau1NofHitTk").setBranchAlias(alias);
224  produces<vector<unsigned int> >(alias = zName + "Dau1NofHitSta").setBranchAlias(alias);
225  produces<vector<unsigned int> >(alias = zName + "Dau2NofHitTk").setBranchAlias(alias);
226  produces<vector<unsigned int> >(alias = zName + "Dau2NofHitSta").setBranchAlias(alias);
227  produces<vector<unsigned int> >(alias = zName + "Dau1NofMuChambers").setBranchAlias(alias);
228  produces<vector<unsigned int> >(alias = zName + "Dau2NofMuChambers").setBranchAlias(alias);
229  produces<vector<unsigned int> >(alias = zName + "Dau1NofMuMatches").setBranchAlias(alias);
230  produces<vector<unsigned int> >(alias = zName + "Dau2NofMuMatches").setBranchAlias(alias);
231  produces<vector<float> >(alias = zName + "Dau1Chi2").setBranchAlias(alias);
232  produces<vector<float> >(alias = zName + "Dau2Chi2").setBranchAlias(alias);
233  produces<vector<float> >(alias = zName + "Dau1TrkChi2").setBranchAlias(alias);
234  produces<vector<float> >(alias = zName + "Dau2TrkChi2").setBranchAlias(alias);
235  produces<vector<float> >(alias = zName + "Dau1dxyFromBS").setBranchAlias(alias);
236  produces<vector<float> >(alias = zName + "Dau2dxyFromBS").setBranchAlias(alias);
237  produces<vector<float> >(alias = zName + "Dau1dzFromBS").setBranchAlias(alias);
238  produces<vector<float> >(alias = zName + "Dau2dzFromBS").setBranchAlias(alias);
239  produces<vector<float> >(alias = zName + "Dau1dxyFromPV").setBranchAlias(alias);
240  produces<vector<float> >(alias = zName + "Dau2dxyFromPV").setBranchAlias(alias);
241  produces<vector<float> >(alias = zName + "Dau1dzFromPV").setBranchAlias(alias);
242  produces<vector<float> >(alias = zName + "Dau2dzFromPV").setBranchAlias(alias);
243  produces<vector<float> >(alias = zName + "TrueMass").setBranchAlias(alias);
244  produces<vector<float> >(alias = zName + "TruePt").setBranchAlias(alias);
245  produces<vector<float> >(alias = zName + "TrueEta").setBranchAlias(alias);
246  produces<vector<float> >(alias = zName + "TruePhi").setBranchAlias(alias);
247  produces<vector<float> >(alias = zName + "TrueY").setBranchAlias(alias);
248  }
249 }

References SiStripOfflineCRack_cfg::alias, zMuMuMuonUserData::alpha, zMuMuMuonUserData::beta, looper::cfg, zMuMuMuonUserData::dREcal, zMuMuMuonUserData::dRHcal, zMuMuMuonUserData::dRTrk, zMuMuMuonUserData::dRVetoTrk, zMuMuMuonUserData::etEcalThreshold, zMuMuMuonUserData::etHcalThreshold, zMuMuMuonUserData::hltPath, mps_fire::i, ewkMuLumiMonitorDQM_cfi::ptThreshold, ZMuMuCategoriesNtuples_cff::relativeIsolation, AlCaHLTBitMon_QueryRunRegistry::string, and ZMuMuCategoriesNtuples_cff::zName.

Member Function Documentation

◆ produce()

void ZToLLEdmNtupleDumper::produce ( edm::Event &  evt,
const edm::EventSetup &   
)
overrideprivatevirtual

only for ZGolden evaluated zMassSa for the mu+sta pdf, see zmumuSaMassHistogram.cc

I fill the dau1 with positive and dau2 with negatove values for the pt, in order to flag the muons used for building zMassSa

I fill the dau1 with negatove and dau2 with positive values for the pt

Implements edm::EDProducer.

Definition at line 251 of file ZToLLEdmNtupleDumper.cc.

251  {
252  Handle<reco::BeamSpot> beamSpotHandle;
253  if (!evt.getByToken(beamSpotToken_, beamSpotHandle)) {
254  std::cout << ">>> No beam spot found !!!" << std::endl;
255  }
256  Handle<reco::VertexCollection> primaryVertices; // Collection of primary Vertices
257  if (!evt.getByToken(primaryVerticesToken_, primaryVertices)) {
258  std::cout << ">>> No primary verteces found !!!" << std::endl;
259  }
260 
261  unsigned int size = zTokens_.size();
262  for (unsigned int c = 0; c < size; ++c) {
263  Handle<CandidateView> zColl;
264  evt.getByToken(zTokens_[c], zColl);
265  bool isMCMatchTrue = false;
266  //if (zGenParticlesMatchTokens_[c] != "") isMCMatchTrue = true;
267  Handle<GenParticleMatch> zGenParticlesMatch;
268  if (evt.getByToken(zGenParticlesMatchTokens_[c], zGenParticlesMatch)) {
269  isMCMatchTrue = true;
270  }
271  unsigned int zSize = zColl->size();
272  unique_ptr<vector<edm::EventNumber_t> > event(new vector<edm::EventNumber_t>);
273  unique_ptr<vector<unsigned int> > run(new vector<unsigned int>);
274  unique_ptr<vector<unsigned int> > lumi(new vector<unsigned int>);
275  unique_ptr<vector<float> > zMass(new vector<float>);
276  unique_ptr<vector<float> > zMassSa(new vector<float>);
277  unique_ptr<vector<float> > zPt(new vector<float>);
278  unique_ptr<vector<float> > zEta(new vector<float>);
279  unique_ptr<vector<float> > zPhi(new vector<float>);
280  unique_ptr<vector<float> > zY(new vector<float>);
281  unique_ptr<vector<float> > zDau1Pt(new vector<float>);
282  unique_ptr<vector<float> > zDau2Pt(new vector<float>);
283  unique_ptr<vector<float> > zDau1SaPt(new vector<float>);
284  unique_ptr<vector<float> > zDau2SaPt(new vector<float>);
285  unique_ptr<vector<unsigned int> > zDau1HLTBit(new vector<unsigned int>);
286  unique_ptr<vector<unsigned int> > zDau2HLTBit(new vector<unsigned int>);
287  unique_ptr<vector<int> > zDau1Q(new vector<int>);
288  unique_ptr<vector<int> > zDau2Q(new vector<int>);
289  unique_ptr<vector<float> > zDau1Eta(new vector<float>);
290  unique_ptr<vector<float> > zDau2Eta(new vector<float>);
291  unique_ptr<vector<float> > zDau1SaEta(new vector<float>);
292  unique_ptr<vector<float> > zDau2SaEta(new vector<float>);
293  unique_ptr<vector<float> > zDau1Phi(new vector<float>);
294  unique_ptr<vector<float> > zDau2Phi(new vector<float>);
295  unique_ptr<vector<float> > zDau1SaPhi(new vector<float>);
296  unique_ptr<vector<float> > zDau2SaPhi(new vector<float>);
297  unique_ptr<vector<float> > zDau1Iso(new vector<float>);
298  unique_ptr<vector<float> > zDau2Iso(new vector<float>);
299  unique_ptr<vector<float> > zDau1TrkIso(new vector<float>);
300  unique_ptr<vector<float> > zDau2TrkIso(new vector<float>);
301  unique_ptr<vector<float> > zDau1EcalIso(new vector<float>);
302  unique_ptr<vector<float> > zDau2EcalIso(new vector<float>);
303  unique_ptr<vector<float> > zDau1HcalIso(new vector<float>);
304  unique_ptr<vector<float> > zDau2HcalIso(new vector<float>);
305  unique_ptr<vector<float> > zDau1MuEnergyEm(new vector<float>);
306  unique_ptr<vector<float> > zDau2MuEnergyEm(new vector<float>);
307  unique_ptr<vector<float> > zDau1MuEnergyHad(new vector<float>);
308  unique_ptr<vector<float> > zDau2MuEnergyHad(new vector<float>);
309  unique_ptr<vector<float> > vtxNormChi2(new vector<float>);
310  unique_ptr<vector<unsigned int> > zDau1NofHit(new vector<unsigned int>);
311  unique_ptr<vector<unsigned int> > zDau2NofHit(new vector<unsigned int>);
312  unique_ptr<vector<unsigned int> > zDau1NofHitTk(new vector<unsigned int>);
313  unique_ptr<vector<unsigned int> > zDau2NofHitTk(new vector<unsigned int>);
314  unique_ptr<vector<unsigned int> > zDau1NofHitSta(new vector<unsigned int>);
315  unique_ptr<vector<unsigned int> > zDau2NofHitSta(new vector<unsigned int>);
316  unique_ptr<vector<unsigned int> > zDau1NofMuChambers(new vector<unsigned int>);
317  unique_ptr<vector<unsigned int> > zDau2NofMuChambers(new vector<unsigned int>);
318  unique_ptr<vector<unsigned int> > zDau1NofMuMatches(new vector<unsigned int>);
319  unique_ptr<vector<unsigned int> > zDau2NofMuMatches(new vector<unsigned int>);
320  unique_ptr<vector<float> > zDau1Chi2(new vector<float>);
321  unique_ptr<vector<float> > zDau2Chi2(new vector<float>);
322  unique_ptr<vector<float> > zDau1TrkChi2(new vector<float>);
323  unique_ptr<vector<float> > zDau2TrkChi2(new vector<float>);
324  unique_ptr<vector<float> > zDau1dxyFromBS(new vector<float>);
325  unique_ptr<vector<float> > zDau2dxyFromBS(new vector<float>);
326  unique_ptr<vector<float> > zDau1dzFromBS(new vector<float>);
327  unique_ptr<vector<float> > zDau2dzFromBS(new vector<float>);
328  unique_ptr<vector<float> > zDau1dxyFromPV(new vector<float>);
329  unique_ptr<vector<float> > zDau2dxyFromPV(new vector<float>);
330  unique_ptr<vector<float> > zDau1dzFromPV(new vector<float>);
331  unique_ptr<vector<float> > zDau2dzFromPV(new vector<float>);
332  unique_ptr<vector<float> > trueZMass(new vector<float>);
333  unique_ptr<vector<float> > trueZPt(new vector<float>);
334  unique_ptr<vector<float> > trueZEta(new vector<float>);
335  unique_ptr<vector<float> > trueZPhi(new vector<float>);
336  unique_ptr<vector<float> > trueZY(new vector<float>);
337  event->push_back(evt.id().event());
338  run->push_back(evt.id().run());
339  lumi->push_back(evt.luminosityBlock());
340  for (unsigned int i = 0; i < zSize; ++i) {
341  const Candidate &z = (*zColl)[i];
342  CandidateBaseRef zRef = zColl->refAt(i);
343  zMass->push_back(z.mass());
344  zPt->push_back(z.pt());
345  zEta->push_back(z.eta());
346  zPhi->push_back(z.phi());
347  zY->push_back(z.rapidity());
348  vtxNormChi2->push_back(z.vertexNormalizedChi2());
349  const Candidate *dau1 = z.daughter(0);
350  const Candidate *dau2 = z.daughter(1);
351  zDau1Pt->push_back(dau1->pt());
352  zDau2Pt->push_back(dau2->pt());
353  zDau1Q->push_back(dau1->charge());
354  zDau2Q->push_back(dau2->charge());
355  zDau1Eta->push_back(dau1->eta());
356  zDau2Eta->push_back(dau2->eta());
357  zDau1Phi->push_back(dau1->phi());
358  zDau2Phi->push_back(dau2->phi());
359  if (!(dau1->hasMasterClone() && dau2->hasMasterClone()))
360  throw edm::Exception(edm::errors::InvalidReference) << "Candidate daughters have no master clone\n";
361  const CandidateBaseRef &mr1 = dau1->masterClone(), &mr2 = dau2->masterClone();
362 
363  const Candidate *m1 = &*mr1, *m2 = &*mr2;
364 
365  // isolation as defined by us into the analyzer
366  double iso1 = candIsolation(m1,
367  ptThreshold_[c],
368  etEcalThreshold_[c],
369  etHcalThreshold_[c],
370  dRVetoTrk_[c],
371  dRTrk_[c],
372  dREcal_[c],
373  dRHcal_[c],
374  alpha_[c],
375  beta_[c],
376  relativeIsolation_[c]);
377  double iso2 = candIsolation(m2,
378  ptThreshold_[c],
379  etEcalThreshold_[c],
380  etHcalThreshold_[c],
381  dRVetoTrk_[c],
382  dRTrk_[c],
383  dREcal_[c],
384  dRHcal_[c],
385  alpha_[c],
386  beta_[c],
387  relativeIsolation_[c]);
388  // tracker isolation : alpha =0
389  double trkIso1 = candIsolation(m1,
390  ptThreshold_[c],
391  etEcalThreshold_[c],
392  etHcalThreshold_[c],
393  dRVetoTrk_[c],
394  dRTrk_[c],
395  dREcal_[c],
396  dRHcal_[c],
397  0.0,
398  beta_[c],
399  relativeIsolation_[c]);
400  double trkIso2 = candIsolation(m2,
401  ptThreshold_[c],
402  etEcalThreshold_[c],
403  etHcalThreshold_[c],
404  dRVetoTrk_[c],
405  dRTrk_[c],
406  dREcal_[c],
407  dRHcal_[c],
408  0.0,
409  beta_[c],
410  relativeIsolation_[c]);
411  // ecal isolation : alpha =1, beta =1
412  double ecalIso1 = candIsolation(m1,
413  ptThreshold_[c],
414  etEcalThreshold_[c],
415  etHcalThreshold_[c],
416  dRVetoTrk_[c],
417  dRTrk_[c],
418  dREcal_[c],
419  dRHcal_[c],
420  1.0,
421  1.0,
422  relativeIsolation_[c]);
423  double ecalIso2 = candIsolation(m2,
424  ptThreshold_[c],
425  etEcalThreshold_[c],
426  etHcalThreshold_[c],
427  dRVetoTrk_[c],
428  dRTrk_[c],
429  dREcal_[c],
430  dRHcal_[c],
431  1.0,
432  1.0,
433  relativeIsolation_[c]);
434  // hcal isolation : alpha =1, beta =-1
435  double hcalIso1 = candIsolation(m1,
436  ptThreshold_[c],
437  etEcalThreshold_[c],
438  etHcalThreshold_[c],
439  dRVetoTrk_[c],
440  dRTrk_[c],
441  dREcal_[c],
442  dRHcal_[c],
443  1.0,
444  -1.0,
445  relativeIsolation_[c]);
446  double hcalIso2 = candIsolation(m2,
447  ptThreshold_[c],
448  etEcalThreshold_[c],
449  etHcalThreshold_[c],
450  dRVetoTrk_[c],
451  dRTrk_[c],
452  dREcal_[c],
453  dRHcal_[c],
454  1.0,
455  -1.0,
456  relativeIsolation_[c]);
457 
458  zDau1Iso->push_back(iso1);
459  zDau2Iso->push_back(iso2);
460  zDau1TrkIso->push_back(trkIso1);
461  zDau2TrkIso->push_back(trkIso2);
462  zDau1EcalIso->push_back(ecalIso1);
463  zDau2EcalIso->push_back(ecalIso2);
464  zDau1HcalIso->push_back(hcalIso1);
465  zDau2HcalIso->push_back(hcalIso2);
466  if (isMCMatchTrue) {
467  GenParticleRef trueZRef = (*zGenParticlesMatch)[zRef];
468  //CandidateRef trueZRef = trueZIter->val;
469  if (trueZRef.isNonnull()) {
470  const Candidate &z = *trueZRef;
471  trueZMass->push_back(z.mass());
472  trueZPt->push_back(z.pt());
473  trueZEta->push_back(z.eta());
474  trueZPhi->push_back(z.phi());
475  trueZY->push_back(z.rapidity());
476  } else {
477  trueZMass->push_back(-100);
478  trueZPt->push_back(-100);
479  trueZEta->push_back(-100);
480  trueZPhi->push_back(-100);
481  trueZY->push_back(-100);
482  }
483  }
484  // quality variables
485  const pat::Muon *mu1 = dynamic_cast<const pat::Muon *>(m1);
486  // protection for standalone and trackerMuon
487  if (mu1->isGlobalMuon() == true) {
488  zDau1NofHit->push_back(mu1->numberOfValidHits());
489  zDau1NofHitTk->push_back(mu1->innerTrack()->numberOfValidHits());
490  zDau1NofHitSta->push_back(mu1->outerTrack()->numberOfValidHits());
491  zDau1Chi2->push_back(mu1->normChi2());
492  TrackRef mu1TrkRef = mu1->innerTrack();
493  zDau1TrkChi2->push_back(mu1TrkRef->normalizedChi2());
494  zDau1dxyFromBS->push_back(mu1TrkRef->dxy(beamSpotHandle->position()));
495  zDau1dzFromBS->push_back(mu1TrkRef->dz(beamSpotHandle->position()));
496  zDau1dxyFromPV->push_back(mu1TrkRef->dxy(primaryVertices->begin()->position()));
497  zDau1dzFromPV->push_back(mu1TrkRef->dz(primaryVertices->begin()->position()));
498  zDau1MuEnergyEm->push_back(mu1->calEnergy().em);
499  zDau1MuEnergyHad->push_back(mu1->calEnergy().had);
500 
501  } else if (mu1->isStandAloneMuon() == true) {
502  // the muon is a standalone
503  TrackRef mu1StaRef = mu1->outerTrack();
504  zDau1NofHit->push_back(mu1StaRef->numberOfValidHits());
505  zDau1NofHitTk->push_back(0);
506  zDau1NofHitSta->push_back(mu1StaRef->numberOfValidHits());
507  zDau1Chi2->push_back(mu1StaRef->normalizedChi2());
508  zDau1TrkChi2->push_back(0);
509  zDau1dxyFromBS->push_back(mu1StaRef->dxy(beamSpotHandle->position()));
510  zDau1dzFromBS->push_back(mu1StaRef->dz(beamSpotHandle->position()));
511  zDau1dxyFromPV->push_back(mu1StaRef->dxy(primaryVertices->begin()->position()));
512  zDau1dzFromPV->push_back(mu1StaRef->dz(primaryVertices->begin()->position()));
513  zDau1MuEnergyEm->push_back(-1);
514  zDau1MuEnergyHad->push_back(-1);
515  } else if (mu1->isTrackerMuon() == true) {
516  // the muon is a trackerMuon
517  TrackRef mu1TrkRef = mu1->innerTrack();
518  zDau1NofHit->push_back(mu1TrkRef->numberOfValidHits());
519  zDau1NofHitTk->push_back(mu1TrkRef->numberOfValidHits());
520  zDau1NofHitSta->push_back(0);
521  zDau1Chi2->push_back(mu1TrkRef->normalizedChi2());
522  zDau1TrkChi2->push_back(mu1TrkRef->normalizedChi2());
523  zDau1dxyFromBS->push_back(mu1TrkRef->dxy(beamSpotHandle->position()));
524  zDau1dzFromBS->push_back(mu1TrkRef->dz(beamSpotHandle->position()));
525  zDau1dxyFromPV->push_back(mu1TrkRef->dxy(primaryVertices->begin()->position()));
526  zDau1dzFromPV->push_back(mu1TrkRef->dz(primaryVertices->begin()->position()));
527  zDau1MuEnergyEm->push_back(mu1->calEnergy().em);
528  zDau1MuEnergyHad->push_back(mu1->calEnergy().had);
529  }
530  zDau1NofMuChambers->push_back(mu1->numberOfChambers());
531  zDau1NofMuMatches->push_back(mu1->numberOfMatches());
532 
533  // would we like to add another variables???
534  // HLT trigger bit
535  const pat::TriggerObjectStandAloneCollection mu1HLTMatches = mu1->triggerObjectMatchesByPath(hltPath_[c]);
536 
537  int dimTrig1 = mu1HLTMatches.size();
538  if (dimTrig1 != 0) {
539  zDau1HLTBit->push_back(1);
540  } else {
541  zDau1HLTBit->push_back(0);
542  }
543  const pat::Muon *mu2 = dynamic_cast<const pat::Muon *>(m2);
544  if (mu2 != nullptr) {
545  if (mu2->isGlobalMuon() == true) {
546  zDau2NofHit->push_back(mu2->numberOfValidHits());
547  zDau2NofHitTk->push_back(mu2->innerTrack()->numberOfValidHits());
548  zDau2NofHitSta->push_back(mu2->outerTrack()->numberOfValidHits());
549  zDau2Chi2->push_back(mu2->normChi2());
550  TrackRef mu2TrkRef = mu2->innerTrack();
551  zDau1TrkChi2->push_back(mu2TrkRef->normalizedChi2());
552  zDau2dxyFromBS->push_back(mu2TrkRef->dxy(beamSpotHandle->position()));
553  zDau2dzFromBS->push_back(mu2TrkRef->dz(beamSpotHandle->position()));
554  zDau2dxyFromPV->push_back(mu2TrkRef->dxy(primaryVertices->begin()->position()));
555  zDau2dzFromPV->push_back(mu2TrkRef->dz(primaryVertices->begin()->position()));
556  zDau2MuEnergyEm->push_back(mu2->calEnergy().em);
557  zDau2MuEnergyHad->push_back(mu2->calEnergy().had);
558  } else if (mu2->isStandAloneMuon() == true) {
559  // its' a standalone
560  zDau2HLTBit->push_back(0);
561  TrackRef mu2StaRef = mu2->outerTrack();
562  zDau2NofHit->push_back(mu2StaRef->numberOfValidHits());
563  zDau2NofHitTk->push_back(0);
564  zDau2NofHitSta->push_back(mu2StaRef->numberOfValidHits());
565  zDau2Chi2->push_back(mu2StaRef->normalizedChi2());
566  zDau2TrkChi2->push_back(0);
567  zDau2dxyFromBS->push_back(mu2StaRef->dxy(beamSpotHandle->position()));
568  zDau2dzFromBS->push_back(mu2StaRef->dz(beamSpotHandle->position()));
569  zDau2dxyFromPV->push_back(mu2StaRef->dxy(primaryVertices->begin()->position()));
570  zDau2dzFromPV->push_back(mu2StaRef->dz(primaryVertices->begin()->position()));
571  zDau1MuEnergyEm->push_back(-1);
572  zDau1MuEnergyHad->push_back(-1);
573  } else if (mu2->isTrackerMuon() == true) {
574  // the muon is a trackerMuon
575  TrackRef mu2TrkRef = mu2->innerTrack();
576  zDau2NofHit->push_back(mu2TrkRef->numberOfValidHits());
577  zDau2NofHitSta->push_back(0);
578  zDau2NofHitTk->push_back(mu2TrkRef->numberOfValidHits());
579  zDau2Chi2->push_back(mu2TrkRef->normalizedChi2());
580  zDau2TrkChi2->push_back(mu2TrkRef->normalizedChi2());
581  zDau2dxyFromBS->push_back(mu2TrkRef->dxy(beamSpotHandle->position()));
582  zDau2dzFromBS->push_back(mu2TrkRef->dz(beamSpotHandle->position()));
583  zDau2dxyFromPV->push_back(mu2TrkRef->dxy(primaryVertices->begin()->position()));
584  zDau2dzFromPV->push_back(mu2TrkRef->dz(primaryVertices->begin()->position()));
585  zDau2MuEnergyEm->push_back(mu2->calEnergy().em);
586  zDau2MuEnergyHad->push_back(mu2->calEnergy().had);
587  }
588 
589  // HLT trigger bit
590  const pat::TriggerObjectStandAloneCollection mu2HLTMatches = mu2->triggerObjectMatchesByPath(hltPath_[c]);
591  int dimTrig2 = mu2HLTMatches.size();
592  if (dimTrig2 != 0) {
593  zDau2HLTBit->push_back(1);
594  } else {
595  zDau2HLTBit->push_back(0);
596  }
598  if (mu1->isGlobalMuon() && mu2->isGlobalMuon()) {
599  TrackRef stAloneTrack1;
600  TrackRef stAloneTrack2;
601  Vector momentum;
602  Candidate::PolarLorentzVector p4_1;
603  double mu_mass;
604  stAloneTrack1 = dau1->get<TrackRef, reco::StandAloneMuonTag>();
605  stAloneTrack2 = dau2->get<TrackRef, reco::StandAloneMuonTag>();
606  zDau1SaEta->push_back(stAloneTrack1->eta());
607  zDau2SaEta->push_back(stAloneTrack2->eta());
608  zDau1SaPhi->push_back(stAloneTrack1->phi());
609  zDau2SaPhi->push_back(stAloneTrack2->phi());
610  if (counter % 2 == 0) {
611  momentum = stAloneTrack1->momentum();
612  p4_1 = dau2->polarP4();
613  mu_mass = dau1->mass();
615  zDau1SaPt->push_back(stAloneTrack1->pt());
616  zDau2SaPt->push_back(-stAloneTrack2->pt());
617  } else {
618  momentum = stAloneTrack2->momentum();
619  p4_1 = dau1->polarP4();
620  mu_mass = dau2->mass();
622  zDau1SaPt->push_back(-stAloneTrack1->pt());
623  zDau2SaPt->push_back(stAloneTrack2->pt());
624  }
625 
626  Candidate::PolarLorentzVector p4_2(momentum.rho(), momentum.eta(), momentum.phi(), mu_mass);
627  double mass = (p4_1 + p4_2).mass();
628  zMassSa->push_back(mass);
629  ++counter;
630  }
631 
632  zDau2NofMuChambers->push_back(mu2->numberOfChambers());
633  zDau2NofMuMatches->push_back(mu2->numberOfMatches());
634  } else {
635  // for ZMuTk case...
636  // it's a track......
637  const pat::GenericParticle *trk2 = dynamic_cast<const pat::GenericParticle *>(m2);
638  TrackRef mu2TrkRef = trk2->track();
639  zDau2NofHit->push_back(mu2TrkRef->numberOfValidHits());
640  zDau2NofHitTk->push_back(mu2TrkRef->numberOfValidHits());
641  zDau2NofHitSta->push_back(0);
642  zDau2NofMuChambers->push_back(0);
643  zDau2NofMuMatches->push_back(0);
644  zDau2Chi2->push_back(mu2TrkRef->normalizedChi2());
645  zDau2dxyFromBS->push_back(mu2TrkRef->dxy(beamSpotHandle->position()));
646  zDau2dzFromBS->push_back(mu2TrkRef->dz(beamSpotHandle->position()));
647  zDau2dxyFromPV->push_back(mu2TrkRef->dxy(primaryVertices->begin()->position()));
648  zDau2dzFromPV->push_back(mu2TrkRef->dz(primaryVertices->begin()->position()));
649  zDau1MuEnergyEm->push_back(-1);
650  zDau1MuEnergyHad->push_back(-1);
651  }
652  }
653  const string &zName = zName_[c];
654  evt.put(std::move(event), zName + "EventNumber");
655  evt.put(std::move(run), zName + "RunNumber");
656  evt.put(std::move(lumi), zName + "LumiBlock");
657  evt.put(std::move(zMass), zName + "Mass");
658  evt.put(std::move(zMassSa), zName + "MassSa");
659  evt.put(std::move(zPt), zName + "Pt");
660  evt.put(std::move(zEta), zName + "Eta");
661  evt.put(std::move(zPhi), zName + "Phi");
662  evt.put(std::move(zY), zName + "Y");
663  evt.put(std::move(zDau1Pt), zName + "Dau1Pt");
664  evt.put(std::move(zDau2Pt), zName + "Dau2Pt");
665  evt.put(std::move(zDau1SaPt), zName + "Dau1SaPt");
666  evt.put(std::move(zDau2SaPt), zName + "Dau2SaPt");
667  evt.put(std::move(zDau1HLTBit), zName + "Dau1HLTBit");
668  evt.put(std::move(zDau2HLTBit), zName + "Dau2HLTBit");
669  evt.put(std::move(zDau1Q), zName + "Dau1Q");
670  evt.put(std::move(zDau2Q), zName + "Dau2Q");
671  evt.put(std::move(zDau1Eta), zName + "Dau1Eta");
672  evt.put(std::move(zDau2Eta), zName + "Dau2Eta");
673  evt.put(std::move(zDau1SaEta), zName + "Dau1SaEta");
674  evt.put(std::move(zDau2SaEta), zName + "Dau2SaEta");
675  evt.put(std::move(zDau1Phi), zName + "Dau1Phi");
676  evt.put(std::move(zDau2Phi), zName + "Dau2Phi");
677  evt.put(std::move(zDau1SaPhi), zName + "Dau1SaPhi");
678  evt.put(std::move(zDau2SaPhi), zName + "Dau2SaPhi");
679  evt.put(std::move(zDau1Iso), zName + "Dau1Iso");
680  evt.put(std::move(zDau2Iso), zName + "Dau2Iso");
681  evt.put(std::move(zDau1TrkIso), zName + "Dau1TrkIso");
682  evt.put(std::move(zDau2TrkIso), zName + "Dau2TrkIso");
683  evt.put(std::move(zDau1EcalIso), zName + "Dau1EcalIso");
684  evt.put(std::move(zDau2EcalIso), zName + "Dau2EcalIso");
685  evt.put(std::move(zDau1HcalIso), zName + "Dau1HcalIso");
686  evt.put(std::move(zDau2HcalIso), zName + "Dau2HcalIso");
687  evt.put(std::move(zDau1MuEnergyEm), zName + "Dau1MuEnergyEm");
688  evt.put(std::move(zDau2MuEnergyEm), zName + "Dau2MuEnergyEm");
689  evt.put(std::move(zDau1MuEnergyHad), zName + "Dau1MuEnergyHad");
690  evt.put(std::move(zDau2MuEnergyHad), zName + "Dau2MuEnergyHad");
691  evt.put(std::move(vtxNormChi2), zName + "VtxNormChi2");
692  evt.put(std::move(zDau1NofHit), zName + "Dau1NofHit");
693  evt.put(std::move(zDau2NofHit), zName + "Dau2NofHit");
694  evt.put(std::move(zDau1NofHitTk), zName + "Dau1NofHitTk");
695  evt.put(std::move(zDau2NofHitTk), zName + "Dau2NofHitTk");
696  evt.put(std::move(zDau1NofHitSta), zName + "Dau1NofHitSta");
697  evt.put(std::move(zDau2NofHitSta), zName + "Dau2NofHitSta");
698  evt.put(std::move(zDau1NofMuChambers), zName + "Dau1NofMuChambers");
699  evt.put(std::move(zDau1NofMuMatches), zName + "Dau1NofMuMatches");
700  evt.put(std::move(zDau2NofMuChambers), zName + "Dau2NofMuChambers");
701  evt.put(std::move(zDau2NofMuMatches), zName + "Dau2NofMuMatches");
702  evt.put(std::move(zDau1Chi2), zName + "Dau1Chi2");
703  evt.put(std::move(zDau2Chi2), zName + "Dau2Chi2");
704  evt.put(std::move(zDau1TrkChi2), zName + "Dau1TrkChi2");
705  evt.put(std::move(zDau2TrkChi2), zName + "Dau2TrkChi2");
706  evt.put(std::move(zDau1dxyFromBS), zName + "Dau1dxyFromBS");
707  evt.put(std::move(zDau2dxyFromBS), zName + "Dau2dxyFromBS");
708  evt.put(std::move(zDau1dxyFromPV), zName + "Dau1dxyFromPV");
709  evt.put(std::move(zDau2dxyFromPV), zName + "Dau2dxyFromPV");
710  evt.put(std::move(zDau1dzFromBS), zName + "Dau1dzFromBS");
711  evt.put(std::move(zDau2dzFromBS), zName + "Dau2dzFromBS");
712  evt.put(std::move(zDau1dzFromPV), zName + "Dau1dzFromPV");
713  evt.put(std::move(zDau2dzFromPV), zName + "Dau2dzFromPV");
714  evt.put(std::move(trueZMass), zName + "TrueMass");
715  evt.put(std::move(trueZPt), zName + "TruePt");
716  evt.put(std::move(trueZEta), zName + "TrueEta");
717  evt.put(std::move(trueZPhi), zName + "TruePhi");
718  evt.put(std::move(trueZY), zName + "TrueY");
719  }
720 }

References HltBtagPostValidation_cff::c, reco::Muon::calEnergy(), candIsolation(), reco::Candidate::charge(), counter, gather_cfg::cout, reco::MuonEnergy::em, reco::Candidate::eta(), edm::EventID::event(), event(), Exception, reco::Candidate::get(), edm::Event::getByToken(), reco::MuonEnergy::had, reco::Candidate::hasMasterClone(), mps_fire::i, edm::EventBase::id(), pat::Muon::innerTrack(), edm::errors::InvalidReference, reco::Muon::isGlobalMuon(), edm::Ref< C, T, F >::isNonnull(), reco::Muon::isStandAloneMuon(), reco::Muon::isTrackerMuon(), BXlumiParameters_cfi::lumi, edm::EventBase::luminosityBlock(), EgHLTOffHistBins_cfi::mass, reco::Candidate::mass(), reco::Candidate::masterClone(), eostools::move(), mu_mass, pat::Muon::normChi2(), reco::Muon::numberOfChambers(), reco::Muon::numberOfMatches(), pat::Muon::numberOfValidHits(), pat::Muon::outerTrack(), reco::Candidate::phi(), reco::Candidate::polarP4(), reco::BeamSpot::position(), zMuMuMuonUserData::primaryVertices, reco::Candidate::pt(), edm::Event::put(), edm::View< T >::refAt(), writedatasetfile::run, edm::EventID::run(), edm::View< T >::size(), findQualityFiles::size, pat::GenericParticle::track(), pat::PATObject< ObjectType >::triggerObjectMatchesByPath(), zMuMu_SubskimPathsWithMCTruth_cff::zGenParticlesMatch, HLTMuonOfflineAnalyzer_cfi::zMass, and ZMuMuCategoriesNtuples_cff::zName.

Member Data Documentation

◆ alpha_

std::vector<double> ZToLLEdmNtupleDumper::alpha_
private

Definition at line 51 of file ZToLLEdmNtupleDumper.cc.

◆ beamSpotToken_

edm::EDGetTokenT<BeamSpot> ZToLLEdmNtupleDumper::beamSpotToken_
private

Definition at line 48 of file ZToLLEdmNtupleDumper.cc.

◆ beta_

std::vector<double> ZToLLEdmNtupleDumper::beta_
private

Definition at line 51 of file ZToLLEdmNtupleDumper.cc.

◆ counter

int ZToLLEdmNtupleDumper::counter
private

Definition at line 55 of file ZToLLEdmNtupleDumper.cc.

Referenced by counter.Counters::__getitem__().

◆ dREcal_

std::vector<double> ZToLLEdmNtupleDumper::dREcal_
private

Definition at line 51 of file ZToLLEdmNtupleDumper.cc.

◆ dRHcal_

std::vector<double> ZToLLEdmNtupleDumper::dRHcal_
private

Definition at line 51 of file ZToLLEdmNtupleDumper.cc.

◆ dRTrk_

std::vector<double> ZToLLEdmNtupleDumper::dRTrk_
private

Definition at line 51 of file ZToLLEdmNtupleDumper.cc.

◆ dRVetoTrk_

std::vector<double> ZToLLEdmNtupleDumper::dRVetoTrk_
private

Definition at line 51 of file ZToLLEdmNtupleDumper.cc.

◆ etEcalThreshold_

std::vector<double> ZToLLEdmNtupleDumper::etEcalThreshold_
private

Definition at line 51 of file ZToLLEdmNtupleDumper.cc.

◆ etHcalThreshold_

std::vector<double> ZToLLEdmNtupleDumper::etHcalThreshold_
private

Definition at line 51 of file ZToLLEdmNtupleDumper.cc.

◆ hltPath_

std::vector<string> ZToLLEdmNtupleDumper::hltPath_
private

Definition at line 54 of file ZToLLEdmNtupleDumper.cc.

◆ primaryVerticesToken_

edm::EDGetTokenT<VertexCollection> ZToLLEdmNtupleDumper::primaryVerticesToken_
private

Definition at line 49 of file ZToLLEdmNtupleDumper.cc.

◆ ptThreshold_

std::vector<double> ZToLLEdmNtupleDumper::ptThreshold_
private

Definition at line 51 of file ZToLLEdmNtupleDumper.cc.

◆ relativeIsolation_

std::vector<double> ZToLLEdmNtupleDumper::relativeIsolation_
private

Definition at line 53 of file ZToLLEdmNtupleDumper.cc.

◆ zGenParticlesMatchTokens_

std::vector<edm::EDGetTokenT<GenParticleMatch> > ZToLLEdmNtupleDumper::zGenParticlesMatchTokens_
private

Definition at line 47 of file ZToLLEdmNtupleDumper.cc.

◆ zName_

std::vector<std::string> ZToLLEdmNtupleDumper::zName_
private

Definition at line 45 of file ZToLLEdmNtupleDumper.cc.

◆ zTokens_

std::vector<edm::EDGetTokenT<CandidateView> > ZToLLEdmNtupleDumper::zTokens_
private

Definition at line 46 of file ZToLLEdmNtupleDumper.cc.

ewkMuLumiMonitorDQM_cfi.ptThreshold
ptThreshold
Definition: ewkMuLumiMonitorDQM_cfi.py:13
pat::Muon::normChi2
double normChi2() const
Norm chi2 gives the normalized chi2 of the global track.
ZToLLEdmNtupleDumper::dREcal_
std::vector< double > dREcal_
Definition: ZToLLEdmNtupleDumper.cc:51
counter
Definition: counter.py:1
zMuMuMuonUserData.dRHcal
dRHcal
Definition: zMuMuMuonUserData.py:19
mps_fire.i
i
Definition: mps_fire.py:355
ZToLLEdmNtupleDumper::etHcalThreshold_
std::vector< double > etHcalThreshold_
Definition: ZToLLEdmNtupleDumper.cc:51
ZToLLEdmNtupleDumper::dRHcal_
std::vector< double > dRHcal_
Definition: ZToLLEdmNtupleDumper.cc:51
edm::errors::InvalidReference
Definition: EDMException.h:39
reco::Muon::calEnergy
MuonEnergy calEnergy() const
get energy deposition information
Definition: Muon.h:106
reco::Candidate::mass
virtual double mass() const =0
mass
edm::View::refAt
RefToBase< value_type > refAt(size_type i) const
zMuMuMuonUserData.alpha
alpha
zGenParticlesMatch = cms.InputTag(""),
Definition: zMuMuMuonUserData.py:9
reco::Candidate::eta
virtual double eta() const =0
momentum pseudorapidity
edm::EDGetTokenT< CandidateView >
zMuMuMuonUserData.beta
beta
Definition: zMuMuMuonUserData.py:10
reco::Candidate::PolarLorentzVector
math::PtEtaPhiMLorentzVector PolarLorentzVector
Lorentz vector.
Definition: Candidate.h:38
gather_cfg.cout
cout
Definition: gather_cfg.py:144
reco::Candidate::pt
virtual double pt() const =0
transverse momentum
reco::MuonEnergy::had
float had
Definition: MuonEnergy.h:36
ZToLLEdmNtupleDumper::etEcalThreshold_
std::vector< double > etEcalThreshold_
Definition: ZToLLEdmNtupleDumper.cc:51
reco::Candidate::get
T get() const
get a component
Definition: Candidate.h:221
pat::Muon
Analysis-level muon class.
Definition: Muon.h:51
ZToLLEdmNtupleDumper::zGenParticlesMatchTokens_
std::vector< edm::EDGetTokenT< GenParticleMatch > > zGenParticlesMatchTokens_
Definition: ZToLLEdmNtupleDumper.cc:47
ZToLLEdmNtupleDumper::zTokens_
std::vector< edm::EDGetTokenT< CandidateView > > zTokens_
Definition: ZToLLEdmNtupleDumper.cc:46
edm::Handle< reco::BeamSpot >
ZToLLEdmNtupleDumper::alpha_
std::vector< double > alpha_
Definition: ZToLLEdmNtupleDumper.cc:51
edm::Ref< GenParticleCollection >
ZToLLEdmNtupleDumper::hltPath_
std::vector< string > hltPath_
Definition: ZToLLEdmNtupleDumper.cc:54
candIsolation
double candIsolation(const reco::Candidate *c, double ptThreshold, double etEcalThreshold, double etHcalThreshold, double dRVetoTrk, double dRTrk, double dREcal, double dRHcal, double alpha, double beta, bool relativeIsolation)
Definition: ZToLLEdmNtupleDumper.cc:105
BXlumiParameters_cfi.lumi
lumi
Definition: BXlumiParameters_cfi.py:6
reco::StandAloneMuonTag
stand alone muon component tag
Definition: RecoCandidate.h:77
zMuMuMuonUserData.dREcal
dREcal
Definition: zMuMuMuonUserData.py:18
ZToLLEdmNtupleDumper::relativeIsolation_
std::vector< double > relativeIsolation_
Definition: ZToLLEdmNtupleDumper.cc:53
reco::Candidate::charge
virtual int charge() const =0
electric charge
zMuMuMuonUserData.dRTrk
dRTrk
Definition: zMuMuMuonUserData.py:17
DDAxes::z
reco::Candidate::hasMasterClone
virtual bool hasMasterClone() const =0
ZMuMuCategoriesNtuples_cff.zName
zName
Definition: ZMuMuCategoriesNtuples_cff.py:13
reco::Candidate::polarP4
virtual const PolarLorentzVector & polarP4() const =0
four-momentum Lorentz vector
edm::Event::getByToken
bool getByToken(EDGetToken token, Handle< PROD > &result) const
Definition: Event.h:528
reco::BeamSpot::position
const Point & position() const
position
Definition: BeamSpot.h:59
reco::Muon::numberOfChambers
int numberOfChambers() const
Definition: Muon.h:253
ZToLLEdmNtupleDumper::dRVetoTrk_
std::vector< double > dRVetoTrk_
Definition: ZToLLEdmNtupleDumper.cc:51
edm::EventID::run
RunNumber_t run() const
Definition: EventID.h:38
pat::Muon::numberOfValidHits
unsigned int numberOfValidHits() const
numberOfValidHits returns the number of valid hits on the global track.
reco::TrackRef
edm::Ref< TrackCollection > TrackRef
persistent reference to a Track
Definition: TrackFwd.h:20
AlCaHLTBitMon_QueryRunRegistry.string
string
Definition: AlCaHLTBitMon_QueryRunRegistry.py:256
edm::View::size
size_type size() const
reco::Muon::isGlobalMuon
bool isGlobalMuon() const override
Definition: Muon.h:299
pat::Muon::outerTrack
reco::TrackRef outerTrack() const override
reference to Track reconstructed in the muon detector only (reimplemented from reco::Muon)
Definition: Muon.h:76
ZToLLEdmNtupleDumper::beamSpotToken_
edm::EDGetTokenT< BeamSpot > beamSpotToken_
Definition: ZToLLEdmNtupleDumper.cc:48
pat::GenericParticle
Analysis-level Generic Particle class (e.g. for hadron or muon not fully reconstructed)
Definition: GenericParticle.h:38
zMuMuMuonUserData.primaryVertices
primaryVertices
Definition: zMuMuMuonUserData.py:12
ZMuMuCategoriesNtuples_cff.relativeIsolation
relativeIsolation
Definition: ZMuMuCategoriesNtuples_cff.py:27
zMuMuMuonUserData.dRVetoTrk
dRVetoTrk
Definition: zMuMuMuonUserData.py:16
edm::EventBase::luminosityBlock
edm::LuminosityBlockNumber_t luminosityBlock() const
Definition: EventBase.h:61
edm::Ref::isNonnull
bool isNonnull() const
Checks for non-null.
Definition: Ref.h:238
zMuMu_SubskimPathsWithMCTruth_cff.zGenParticlesMatch
zGenParticlesMatch
Definition: zMuMu_SubskimPathsWithMCTruth_cff.py:23
math::Vector
fixed size vector
Definition: Vector.h:24
edm::EventID::event
EventNumber_t event() const
Definition: EventID.h:40
pat::TriggerObjectStandAloneCollection
std::vector< TriggerObjectStandAlone > TriggerObjectStandAloneCollection
Collection of TriggerObjectStandAlone.
Definition: TriggerObjectStandAlone.h:219
edm::Event::put
OrphanHandle< PROD > put(std::unique_ptr< PROD > product)
Put a new product.
Definition: Event.h:132
zMuMuMuonUserData.etEcalThreshold
etEcalThreshold
Definition: zMuMuMuonUserData.py:14
pat::PATObject::triggerObjectMatchesByPath
const TriggerObjectStandAloneCollection triggerObjectMatchesByPath(const std::string &namePath, const bool pathLastFilterAccepted=false, const bool pathL3FilterAccepted=true) const
Definition: PATObject.h:682
HltBtagPostValidation_cff.c
c
Definition: HltBtagPostValidation_cff.py:31
ZToLLEdmNtupleDumper::dRTrk_
std::vector< double > dRTrk_
Definition: ZToLLEdmNtupleDumper.cc:51
looper.cfg
cfg
Definition: looper.py:297
reco::Candidate
Definition: Candidate.h:27
mu_mass
static constexpr float mu_mass
Definition: L1TkMuonProducer.cc:30
eostools.move
def move(src, dest)
Definition: eostools.py:511
writedatasetfile.run
run
Definition: writedatasetfile.py:27
reco::Muon::isTrackerMuon
bool isTrackerMuon() const override
Definition: Muon.h:300
zMuMuMuonUserData.hltPath
hltPath
Definition: zMuMuMuonUserData.py:20
SiStripOfflineCRack_cfg.alias
alias
Definition: SiStripOfflineCRack_cfg.py:129
Exception
Definition: hltDiff.cc:246
edm::EventBase::id
edm::EventID id() const
Definition: EventBase.h:59
reco::Muon::numberOfMatches
int numberOfMatches(ArbitrationType type=SegmentAndTrackArbitration) const
get number of chambers with matched segments
EgHLTOffHistBins_cfi.mass
mass
Definition: EgHLTOffHistBins_cfi.py:34
pat::GenericParticle::track
reco::TrackRef track() const override
Definition: GenericParticle.h:62
edm::RefToBase< Candidate >
reco::Muon::isStandAloneMuon
bool isStandAloneMuon() const override
Definition: Muon.h:301
ZToLLEdmNtupleDumper::counter
int counter
Definition: ZToLLEdmNtupleDumper.cc:55
reco::Candidate::masterClone
virtual const CandidateBaseRef & masterClone() const =0
ZToLLEdmNtupleDumper::primaryVerticesToken_
edm::EDGetTokenT< VertexCollection > primaryVerticesToken_
Definition: ZToLLEdmNtupleDumper.cc:49
ZToLLEdmNtupleDumper::zName_
std::vector< std::string > zName_
Definition: ZToLLEdmNtupleDumper.cc:45
ZToLLEdmNtupleDumper::beta_
std::vector< double > beta_
Definition: ZToLLEdmNtupleDumper.cc:51
pat::Muon::innerTrack
reco::TrackRef innerTrack() const override
reference to Track reconstructed in the tracker only (reimplemented from reco::Muon)
Definition: Muon.h:72
event
Definition: event.py:1
ZToLLEdmNtupleDumper::ptThreshold_
std::vector< double > ptThreshold_
Definition: ZToLLEdmNtupleDumper.cc:51
lumi
Definition: LumiSectionData.h:20
reco::Candidate::phi
virtual double phi() const =0
momentum azimuthal angle
event
How EventSelector::AcceptEvent() decides whether to accept an event for output otherwise it is excluding the probing of A single or multiple positive and the trigger will pass if any such matching triggers are PASS or EXCEPTION[A criterion thatmatches no triggers at all is detected and causes a throw.] A single negative with an expectation of appropriate bit checking in the decision and the trigger will pass if any such matching triggers are FAIL or EXCEPTION A wildcarded negative criterion that matches more than one trigger in the trigger but the state exists so we define the behavior If all triggers are the negative crieriion will lead to accepting the event(this again matches the behavior of "!*" before the partial wildcard feature was incorporated). The per-event "cost" of each negative criterion with multiple relevant triggers is about the same as ! *was in the past
reco::MuonEnergy::em
float em
Definition: MuonEnergy.h:26
edm::InputTag
Definition: InputTag.h:15
HLTMuonOfflineAnalyzer_cfi.zMass
zMass
Definition: HLTMuonOfflineAnalyzer_cfi.py:101
zMuMuMuonUserData.etHcalThreshold
etHcalThreshold
Definition: zMuMuMuonUserData.py:15
findQualityFiles.size
size
Write out results.
Definition: findQualityFiles.py:443
Generated for CMSSW Reference Manual by doxygen 1.8.16