ATLAS Offline Software
Public Member Functions | Static Public Member Functions | Protected Member Functions | Private Types | Private Member Functions | Private Attributes | List of all members
DerivationFramework::Select_Bmumu Class Reference

#include <Select_Bmumu.h>

Inheritance diagram for DerivationFramework::Select_Bmumu:
Collaboration diagram for DerivationFramework::Select_Bmumu:

Public Member Functions

 Select_Bmumu (const std::string &t, const std::string &n, const IInterface *p)
 
StatusCode initialize () override
 initialization and finalization More...
 
StatusCode finalize () override
 
virtual StatusCode addBranches () const override
 : augmentation and selection Retrieved vertices are augmented with usual information. More...
 
virtual StatusCode sysInitialize () override
 Perform system initialization for an algorithm. More...
 
virtual bool addEvent (const std::string &name, double weight=1.) const
 
virtual bool addToCounter (const std::string &name, uint64_t counts=1, double weight=1.) const
 
ServiceHandle< StoreGateSvc > & evtStore ()
 The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc. More...
 
const ServiceHandle< StoreGateSvc > & evtStore () const
 The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc. More...
 
const ServiceHandle< StoreGateSvc > & detStore () const
 The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc. More...
 
virtual StatusCode sysStart () override
 Handle START transition. More...
 
virtual std::vector< Gaudi::DataHandle * > inputHandles () const override
 Return this algorithm's input handles. More...
 
virtual std::vector< Gaudi::DataHandle * > outputHandles () const override
 Return this algorithm's output handles. More...
 
Gaudi::Details::PropertyBase & declareProperty (Gaudi::Property< T > &t)
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, SG::VarHandleKey &hndl, const std::string &doc, const SG::VarHandleKeyType &)
 Declare a new Gaudi property. More...
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, SG::VarHandleBase &hndl, const std::string &doc, const SG::VarHandleType &)
 Declare a new Gaudi property. More...
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, SG::VarHandleKeyArray &hndArr, const std::string &doc, const SG::VarHandleKeyArrayType &)
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, T &property, const std::string &doc, const SG::NotHandleType &)
 Declare a new Gaudi property. More...
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, T &property, const std::string &doc="none")
 Declare a new Gaudi property. More...
 
void updateVHKA (Gaudi::Details::PropertyBase &)
 
MsgStream & msg () const
 
MsgStream & msg (const MSG::Level lvl) const
 
bool msgLvl (const MSG::Level lvl) const
 

Static Public Member Functions

static const InterfaceID & interfaceID ()
 AlgTool interface methods. More...
 

Protected Member Functions

CutIdentifier getCounter (const std::string &name) const
 
std::string getCounterNameById (CutIdentifier id) const
 
CutIdentifier getCounterIdByName (const std::string &name) const
 
void renounceArray (SG::VarHandleKeyArray &handlesArray)
 remove all handles from I/O resolution More...
 
std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void > renounce (T &h)
 
void extraDeps_update_handler (Gaudi::Details::PropertyBase &ExtraDeps)
 Add StoreName to extra input/output deps as needed. More...
 

Private Types

typedef std::map< std::string, CutIdentifier > NameIdMap_t
 
typedef ServiceHandle< StoreGateSvc > StoreGateSvc_t
 

Private Member Functions

void ProcessVertex (xAOD::BPhysHypoHelper &, xAOD::BPhysHelper::pv_type) const
 
bool massCuts (float mass) const
 
bool massInBlindedRegion (float mass) const
 
bool checkAllMuonsTight (const std::vector< const xAOD::Muon * > &muons, int maxMuonsToCheck=-1) const
 
bool pass (const SG::AuxElement &em, const std::string &hypo) const
 
bool setPass (const SG::AuxElement &em, const std::string &hypo, bool passVal) const
 
bool setPassIfNotAvailable (SG::AuxElement &em, const std::string &hypo, bool passVal) const
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleKeyType &)
 specialization for handling Gaudi::Property<SG::VarHandleKey> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleKeyArrayType &)
 specialization for handling Gaudi::Property<SG::VarHandleKeyArray> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleType &)
 specialization for handling Gaudi::Property<SG::VarHandleBase> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T > &t, const SG::NotHandleType &)
 specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray> More...
 

Private Attributes

ToolHandle< Trk::V0Tools > m_v0Tools
 tools More...
 
ToolHandle< CP::IMuonSelectionTool > m_muSelectionTool
 
std::string m_hypoName
 job options More...
 
std::string m_inputVtxContainerName
 name of the input container name More...
 
std::vector< double > m_trkMasses
 track mass hypotheses More...
 
double m_massHypo
 vertex mass hypothesis More...
 
double m_massMax
 invariant mass range More...
 
double m_massMin
 invariant mass range More...
 
double m_chi2Max
 max chi2 cut More...
 
int m_DoVertexType
 Allows user to skip certain vertexes - bitwise test 7==all(111) More...
 
bool m_do3d
 add 3d proper time More...
 
double m_blindMassMin
 blinding mass range More...
 
double m_blindMassMax
 blinding mass range More...
 
bool m_doBlinding
 enable blinding range More...
 
bool m_doCutBlinded
 enable cutting blinded vertices More...
 
bool m_blindOnlyAllMuonsTight
 only blind candidates with all tight muons More...
 
bool m_useMuCalcMass
 also check against MUCALC mass More...
 
std::vector< std::string > m_subDecVtxContNames
 names of sub-decay vertex containers More...
 
std::vector< std::string > m_subDecVtxHypoCondNames
 hypo names for sub-decays to be considered More...
 
std::vector< std::string > m_subDecVtxHypoFlagNames
 names of hypo flags set on sub-decays if passing More...
 
ServiceHandle< ICutFlowSvc > m_cutFlowSvc
 
std::string m_ctbasename
 
NameIdMap_t m_mctn
 
CutIdentifier m_bid
 
bool m_bidisset
 
StoreGateSvc_t m_evtStore
 Pointer to StoreGate (event store by default) More...
 
StoreGateSvc_t m_detStore
 Pointer to StoreGate (detector store by default) More...
 
std::vector< SG::VarHandleKeyArray * > m_vhka
 
bool m_varHandleArraysDeclared
 

Detailed Description

Definition at line 54 of file Select_Bmumu.h.

Member Typedef Documentation

◆ NameIdMap_t

typedef std::map<std::string, CutIdentifier> DerivationFramework::CfAthAlgTool::NameIdMap_t
privateinherited

Definition at line 72 of file CfAthAlgTool.h.

◆ StoreGateSvc_t

typedef ServiceHandle<StoreGateSvc> AthCommonDataStore< AthCommonMsg< AlgTool > >::StoreGateSvc_t
privateinherited

Definition at line 388 of file AthCommonDataStore.h.

Constructor & Destructor Documentation

◆ Select_Bmumu()

DerivationFramework::Select_Bmumu::Select_Bmumu ( const std::string &  t,
const std::string &  n,
const IInterface *  p 
)

Definition at line 72 of file Select_Bmumu.cxx.

74  :
75  CfAthAlgTool(t,n,p),
76  m_v0Tools("Trk::V0Tools"),
77  m_muSelectionTool("CP::MuonSelectionTool/MuonSelectionTool") {
78 
79  declareInterface<DerivationFramework::IAugmentationTool>(this);
80 
81  // Declare tools
82  declareProperty("V0Tools", m_v0Tools);
83  declareProperty("MuonSelectionTool", m_muSelectionTool);
84 
85  // Declare user-defined properties
86 
87  declareProperty("HypothesisName" , m_hypoName = "A");
88  declareProperty("InputVtxContainerName" , m_inputVtxContainerName = "JpsiCandidates");
89  declareProperty("TrkMasses" , m_trkMasses = std::vector<double>(2, 105.658) );
90  declareProperty("VtxMassHypo" , m_massHypo = 3096.916 );
91  declareProperty("MassMax" , m_massMax = 6000);
92  declareProperty("MassMin" , m_massMin = 2000);
93  declareProperty("Chi2Max" , m_chi2Max = 200);
94  declareProperty("DoVertexType" , m_DoVertexType = 7);
95  declareProperty("Do3d" , m_do3d = false);
96  declareProperty("BlindMassMin" , m_blindMassMin = 0.);
97  declareProperty("BlindMassMax" , m_blindMassMax = 0.);
98  declareProperty("DoBlinding" , m_doBlinding = false);
99  declareProperty("DoCutBlinded" , m_doCutBlinded = false);
100  declareProperty("BlindOnlyAllMuonsTight", m_blindOnlyAllMuonsTight = false);
101  declareProperty("UseMuCalcMass" , m_useMuCalcMass = false);
102  declareProperty("SubDecVtxContNames" , m_subDecVtxContNames = {});
103  declareProperty("SubDecVtxHypoCondNames", m_subDecVtxHypoCondNames = {});
104  declareProperty("SubDecVtxHypoFlagNames", m_subDecVtxHypoFlagNames = {});
105  }

Member Function Documentation

◆ addBranches()

StatusCode DerivationFramework::Select_Bmumu::addBranches ( ) const
overridevirtual

: augmentation and selection Retrieved vertices are augmented with usual information.

Selection is performed and each candidate is decorated with the Char_t flag named "passed_"+name() to indicate whether if the candidate passed the selection. This flag is then used by the event selection tool and by the vertex thinning tool.

Implements DerivationFramework::IAugmentationTool.

Definition at line 234 of file Select_Bmumu.cxx.

234  {
235 
236  // Jpsi container and its auxilliary store
237  xAOD::VertexContainer* bcandContainer = NULL;
238  xAOD::VertexAuxContainer* bcandAuxContainer = NULL;
239 
240  // retrieve from the StoreGate
241  CHECK(evtStore()->retrieve(bcandContainer, m_inputVtxContainerName));
242  CHECK(evtStore()->retrieve(bcandAuxContainer,
243  m_inputVtxContainerName+"Aux."));
244 
245  // for sub-decays
246  std::vector<xAOD::VertexContainer*> subCandConts;
247  std::vector<xAOD::VertexAuxContainer*> subCandAuxConts;
248 
249  // retrieve from StoreGate
250  for (auto cname : m_subDecVtxContNames) {
251  xAOD::VertexContainer* subCandCont = NULL;
252  xAOD::VertexAuxContainer* subCandAuxCont = NULL;
253  CHECK(evtStore()->retrieve(subCandCont , cname));
254  CHECK(evtStore()->retrieve(subCandAuxCont, cname+"Aux."));
255  subCandConts.push_back(subCandCont);
256  subCandAuxConts.push_back(subCandAuxCont);
257  }
258 
259  // preset pass flag to false for subdecays
260  for (unsigned int isub=0; isub < subCandConts.size(); ++isub) {
261  xAOD::VertexContainer* subCandCont = subCandConts[isub];
262  if ( subCandCont != NULL ) {
263  for (xAOD::VertexContainer::iterator it = subCandCont->begin();
264  it != subCandCont->end(); ++it) {
265  if ( *it != NULL ) {
266  // only set subdecay passed flag to false if not yet set at all
267  setPassIfNotAvailable(**it, m_subDecVtxHypoFlagNames[isub], false);
268  // set subdecay blinding flag to true if not yet set at all
269  // and blinding is requested
270  if ( m_doBlinding ) {
271  setPassIfNotAvailable(**it,
272  m_subDecVtxHypoFlagNames[isub]+"_blinded",
273  true);
274  }
275  } else {
276  ATH_MSG_WARNING("addBranches(): NULL pointer elements in "
277  "xAOD::VertexContainer !!");
278  }
279  } // for subCandCont
280  } // if subCandCont != NULL
281  } // for subCandConts
282 
283  bool doPt = (m_DoVertexType & 1) != 0;
284  bool doA0 = (m_DoVertexType & 2) != 0;
285  bool doZ0 = (m_DoVertexType & 4) != 0;
286  bool doZ0BA = (m_DoVertexType & 8) != 0;
287 
288  // loop over B candidates and perform selection and augmentation
289  // counters
290  int nPassMassCuts = 0;
291  int nPassChi2Cut = 0;
292  int nPassPrecVtxCut = 0;
293  int nInBlindedRegion = 0;
294  int nInBlindedRegionAllMuonsTight = 0;
295  xAOD::VertexContainer::iterator bcandItr = bcandContainer->begin();
296  for (; bcandItr!=bcandContainer->end(); ++bcandItr) {
297  // create BPhysHypoHelper
298  xAOD::BPhysHypoHelper bcand(m_hypoName, *bcandItr);
299 
300  //----------------------------------------------------
301  // decorate the vertex - part 1
302  //----------------------------------------------------
303  // a) invariant mass and error
304  if ( !bcand.setMass(m_trkMasses) )
305  ATH_MSG_WARNING("Decoration bcand.setMass failed");
306 
307  double massErr = m_v0Tools->invariantMassError(bcand.vtx(), m_trkMasses);
308  if ( !bcand.setMassErr(massErr) )
309  ATH_MSG_WARNING("Decoration bcand.setMassErr failed");
310 
311  // b) proper decay time and error:
312  // retrieve the refitted PV (or the original one,
313  // if the PV refitting was turned off)
314  // -- deferred to after the selection --
315  /*
316  if (doPt) ProcessVertex(bcand, xAOD::BPhysHelper::PV_MAX_SUM_PT2);
317  if (doA0) ProcessVertex(bcand, xAOD::BPhysHelper::PV_MIN_A0);
318  if (doZ0) ProcessVertex(bcand, xAOD::BPhysHelper::PV_MIN_Z0);
319  if (doZ0BA) ProcessVertex(bcand, xAOD::BPhysHelper::PV_MIN_Z0_BA);
320  */
321 
322  //----------------------------------------------------
323  // perform the selection (i.e. flag the vertex)
324  //----------------------------------------------------
325  // flag the vertex indicating that it is selected by this selector
326  bcand.setPass(true);
327  if ( m_doBlinding ) {
328  setPass(*bcand.vtx(),
329  m_hypoName+"_blinded", false);
330  }
331 
332  // now we check other cuts. if one of them didn't pass, set the flag to 0
333  // and continue to the next candidate:
334 
335  // 1) invariant mass cuts
336  bool passedMuCalcMassCut(m_useMuCalcMass);
337  bool blindedMuCalcMass(true);
338  if ( m_useMuCalcMass ) {
339  std::string bname = m_hypoName+"_MUCALC_mass";
340  static const SG::AuxElement::Accessor<float> mucalcAcc(bname);
341  if ( mucalcAcc.isAvailable(**bcandItr) ) {
342  passedMuCalcMassCut = massCuts(mucalcAcc(**bcandItr));
343  blindedMuCalcMass = massInBlindedRegion(mucalcAcc(**bcandItr));
344  } else {
345  passedMuCalcMassCut = false;
346  blindedMuCalcMass = false;
347  ATH_MSG_INFO("MUCALC mass not available: " << bname << " !");
348  }
349  }
350  bool passedMassCut = massCuts(bcand.mass());
351  bool blindedMass = massInBlindedRegion(bcand.mass());
352 
353  // 1a) muon quality cuts
354  bool allMuonsTight =
355  !m_blindOnlyAllMuonsTight || checkAllMuonsTight(bcand.muons());
356 
357  // 1b) mark candidates in blinded region
358  if ( blindedMass && blindedMuCalcMass ) {
359  if ( m_doBlinding ) {
360  nInBlindedRegion++;
361  if ( allMuonsTight ) {
362  nInBlindedRegionAllMuonsTight++;
363  setPass(*bcand.vtx(),
364  m_hypoName+"_blinded", true);
365  }
366  }
367  }
368 
369  // 1c) cut on the mass range
370  if ( !(passedMassCut || passedMuCalcMassCut) ) {
371  bcand.setPass(false); // flag as failed
372  continue;
373  }
374  nPassMassCuts++;
375 
376  // 2) chi2 cut
377  if ( bcand.vtx()->chiSquared() > m_chi2Max) {
378  bcand.setPass(false);; // flag as failed
379  continue;
380  }
381  nPassChi2Cut++;
382 
383  // 3) preceeding vertices: within their mass ranges?
384  int npVtx = bcand.nPrecedingVertices();
385  if ( npVtx > (int)m_subDecVtxContNames.size() ) {
386  ATH_MSG_WARNING("addBranches(): npVtx > m_subDecVtxContNames.size() !"
387  " (" << npVtx << " > " << m_subDecVtxContNames.size()
388  << ")");
389  }
390  npVtx = std::min(npVtx, (int)m_subDecVtxContNames.size());
391  // check preceeding vertices
392  bool pVtxOk = true;
393  for (int ipv=0; ipv<npVtx; ++ipv) {
394  const xAOD::Vertex* pVtx = bcand.precedingVertex(ipv);
395  if ( !pass(*pVtx, m_subDecVtxHypoCondNames[ipv]) ) {
396  pVtxOk = false;
397  continue;
398  }
399  }
400  if ( !pVtxOk ) {
401  bcand.setPass(false);; // flag as failed
402  continue;
403  }
404  // mark preceeding vertices
405  for (int ipv=0; ipv<npVtx; ++ipv) {
406  setPass(*bcand.precedingVertex(ipv),
407  m_subDecVtxHypoFlagNames[ipv], true);
408  if ( m_doBlinding && !(blindedMass && blindedMuCalcMass
409  && allMuonsTight) ) {
410  setPass(*bcand.precedingVertex(ipv),
411  m_subDecVtxHypoFlagNames[ipv]+"_blinded", false);
412  }
413  }
414  nPassPrecVtxCut++;
415 
416  //----------------------------------------------------
417  // decorate the vertex - part 2
418  //----------------------------------------------------
419  // b) proper decay time and error:
420  // retrieve the refitted PV (or the original one,
421  // if the PV refitting was turned off)
422  if (doPt) ProcessVertex(bcand, xAOD::BPhysHelper::PV_MAX_SUM_PT2);
423  if (doA0) ProcessVertex(bcand, xAOD::BPhysHelper::PV_MIN_A0);
424  if (doZ0) ProcessVertex(bcand, xAOD::BPhysHelper::PV_MIN_Z0);
425  if (doZ0BA) ProcessVertex(bcand, xAOD::BPhysHelper::PV_MIN_Z0_BA);
426 
427  } // end of loop over bcand candidates
428 
429  // counters
430  // event level
431  addEvent("allEvents");
432  if ( bcandContainer->size() > 0 ) addEvent("eventsWithCands");
433  if ( nPassMassCuts > 0 ) addEvent("massCutEvents");
434  if ( nPassChi2Cut > 0 ) addEvent("chi2CutEvents");
435  if ( nPassPrecVtxCut > 0 ) addEvent("precVtxCutEvents");
436  if ( m_doBlinding && nInBlindedRegion > 0 ) addEvent("blindedRegionEvents");
437  // candidate level
438  addToCounter("allCandidates" , bcandContainer->size());
439  addToCounter("massCutCandidates" , nPassMassCuts);
440  addToCounter("chi2CutCandidates" , nPassChi2Cut);
441  addToCounter("precVtxCutCandidates", nPassPrecVtxCut);
442  if ( m_doBlinding ) {
443  addToCounter("blindedRegionCandidates", nInBlindedRegion);
444  if ( m_blindOnlyAllMuonsTight ) {
445  addToCounter("blindedRegionCandidatesWithAllMuonsTight",
446  nInBlindedRegionAllMuonsTight);
447  }
448  }
449 
450  // all OK
451  return StatusCode::SUCCESS;
452  }

◆ addEvent()

bool DerivationFramework::CfAthAlgTool::addEvent ( const std::string &  name,
double  weight = 1. 
) const
virtualinherited

Definition at line 104 of file CfAthAlgTool.cxx.

104  {
105 
106  CutIdentifier id = getCounter(name);
107  if ( id > 0 ) {
108  m_cutFlowSvc->addEvent(id, weight);
109  }
110  return (id > 0);
111  }

◆ addToCounter()

bool DerivationFramework::CfAthAlgTool::addToCounter ( const std::string &  name,
uint64_t  counts = 1,
double  weight = 1. 
) const
virtualinherited

Definition at line 115 of file CfAthAlgTool.cxx.

116  {
117 
118  CutIdentifier id = getCounter(name);
119  if ( id > 0 ) {
120  for (uint64_t i=0; i<counts; ++i) {
121  m_cutFlowSvc->addEvent(id, weight);
122  }
123  }
124  return (id > 0);
125  }

◆ checkAllMuonsTight()

bool DerivationFramework::Select_Bmumu::checkAllMuonsTight ( const std::vector< const xAOD::Muon * > &  muons,
int  maxMuonsToCheck = -1 
) const
private

Definition at line 472 of file Select_Bmumu.cxx.

473  {
474 
475  bool allTight(true);
476  int ncheckMax = muons.size();
477  if ( maxMuonsToCheck > -1 ) {
478  ncheckMax = std::min((int)muons.size(), maxMuonsToCheck);
479  }
480  for (int imu=0; imu < ncheckMax; ++imu) {
481  xAOD::Muon::Quality muQuality =
482  m_muSelectionTool->getQuality(*muons[imu]);
483  if ( !(muQuality <= xAOD::Muon::Tight) ) {
484  allTight = false;
485  break;
486  }
487  }
488  return allTight;
489  }

◆ declareGaudiProperty() [1/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< AlgTool > >::declareGaudiProperty ( Gaudi::Property< T > &  hndl,
const SG::VarHandleKeyArrayType &   
)
inlineprivateinherited

specialization for handling Gaudi::Property<SG::VarHandleKeyArray>

Definition at line 170 of file AthCommonDataStore.h.

172  {
173  return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
174  hndl.value(),
175  hndl.documentation());
176 
177  }

◆ declareGaudiProperty() [2/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< AlgTool > >::declareGaudiProperty ( Gaudi::Property< T > &  hndl,
const SG::VarHandleKeyType &   
)
inlineprivateinherited

specialization for handling Gaudi::Property<SG::VarHandleKey>

Definition at line 156 of file AthCommonDataStore.h.

158  {
159  return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
160  hndl.value(),
161  hndl.documentation());
162 
163  }

◆ declareGaudiProperty() [3/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< AlgTool > >::declareGaudiProperty ( Gaudi::Property< T > &  hndl,
const SG::VarHandleType &   
)
inlineprivateinherited

specialization for handling Gaudi::Property<SG::VarHandleBase>

Definition at line 184 of file AthCommonDataStore.h.

186  {
187  return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
188  hndl.value(),
189  hndl.documentation());
190  }

◆ declareGaudiProperty() [4/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< AlgTool > >::declareGaudiProperty ( Gaudi::Property< T > &  t,
const SG::NotHandleType &   
)
inlineprivateinherited

specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray>

Definition at line 199 of file AthCommonDataStore.h.

200  {
201  return PBASE::declareProperty(t);
202  }

◆ declareProperty() [1/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( const std::string &  name,
SG::VarHandleBase &  hndl,
const std::string &  doc,
const SG::VarHandleType &   
)
inlineinherited

Declare a new Gaudi property.

Parameters
nameName of the property.
hndlObject holding the property value.
docDocumentation string for the property.

This is the version for types that derive from SG::VarHandleBase. The property value object is put on the input and output lists as appropriate; then we forward to the base class.

Definition at line 245 of file AthCommonDataStore.h.

249  {
250  this->declare(hndl.vhKey());
251  hndl.vhKey().setOwner(this);
252 
253  return PBASE::declareProperty(name,hndl,doc);
254  }

◆ declareProperty() [2/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( const std::string &  name,
SG::VarHandleKey &  hndl,
const std::string &  doc,
const SG::VarHandleKeyType &   
)
inlineinherited

Declare a new Gaudi property.

Parameters
nameName of the property.
hndlObject holding the property value.
docDocumentation string for the property.

This is the version for types that derive from SG::VarHandleKey. The property value object is put on the input and output lists as appropriate; then we forward to the base class.

Definition at line 221 of file AthCommonDataStore.h.

225  {
226  this->declare(hndl);
227  hndl.setOwner(this);
228 
229  return PBASE::declareProperty(name,hndl,doc);
230  }

◆ declareProperty() [3/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( const std::string &  name,
SG::VarHandleKeyArray &  hndArr,
const std::string &  doc,
const SG::VarHandleKeyArrayType &   
)
inlineinherited

Definition at line 259 of file AthCommonDataStore.h.

263  {
264 
265  // std::ostringstream ost;
266  // ost << Algorithm::name() << " VHKA declareProp: " << name
267  // << " size: " << hndArr.keys().size()
268  // << " mode: " << hndArr.mode()
269  // << " vhka size: " << m_vhka.size()
270  // << "\n";
271  // debug() << ost.str() << endmsg;
272 
273  hndArr.setOwner(this);
274  m_vhka.push_back(&hndArr);
275 
276  Gaudi::Details::PropertyBase* p = PBASE::declareProperty(name, hndArr, doc);
277  if (p != 0) {
278  p->declareUpdateHandler(&AthCommonDataStore<PBASE>::updateVHKA, this);
279  } else {
280  ATH_MSG_ERROR("unable to call declareProperty on VarHandleKeyArray "
281  << name);
282  }
283 
284  return p;
285 
286  }

◆ declareProperty() [4/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( const std::string &  name,
T &  property,
const std::string &  doc,
const SG::NotHandleType &   
)
inlineinherited

Declare a new Gaudi property.

Parameters
nameName of the property.
propertyObject holding the property value.
docDocumentation string for the property.

This is the generic version, for types that do not derive from SG::VarHandleKey. It just forwards to the base class version of declareProperty.

Definition at line 333 of file AthCommonDataStore.h.

337  {
338  return PBASE::declareProperty(name, property, doc);
339  }

◆ declareProperty() [5/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( const std::string &  name,
T &  property,
const std::string &  doc = "none" 
)
inlineinherited

Declare a new Gaudi property.

Parameters
nameName of the property.
propertyObject holding the property value.
docDocumentation string for the property.

This dispatches to either the generic declareProperty or the one for VarHandle/Key/KeyArray.

Definition at line 352 of file AthCommonDataStore.h.

355  {
356  typedef typename SG::HandleClassifier<T>::type htype;
357  return declareProperty (name, property, doc, htype());
358  }

◆ declareProperty() [6/6]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( Gaudi::Property< T > &  t)
inlineinherited

Definition at line 145 of file AthCommonDataStore.h.

145  {
146  typedef typename SG::HandleClassifier<T>::type htype;
147  return AthCommonDataStore<PBASE>::declareGaudiProperty(t, htype());
148  }

◆ detStore()

const ServiceHandle<StoreGateSvc>& AthCommonDataStore< AthCommonMsg< AlgTool > >::detStore ( ) const
inlineinherited

The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 95 of file AthCommonDataStore.h.

95 { return m_detStore; }

◆ evtStore() [1/2]

ServiceHandle<StoreGateSvc>& AthCommonDataStore< AthCommonMsg< AlgTool > >::evtStore ( )
inlineinherited

The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 85 of file AthCommonDataStore.h.

85 { return m_evtStore; }

◆ evtStore() [2/2]

const ServiceHandle<StoreGateSvc>& AthCommonDataStore< AthCommonMsg< AlgTool > >::evtStore ( ) const
inlineinherited

The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 90 of file AthCommonDataStore.h.

90 { return m_evtStore; }

◆ extraDeps_update_handler()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::extraDeps_update_handler ( Gaudi::Details::PropertyBase &  ExtraDeps)
protectedinherited

Add StoreName to extra input/output deps as needed.

use the logic of the VarHandleKey to parse the DataObjID keys supplied via the ExtraInputs and ExtraOuputs Properties to add the StoreName if it's not explicitly given

◆ finalize()

StatusCode DerivationFramework::Select_Bmumu::finalize ( )
override

Definition at line 153 of file Select_Bmumu.cxx.

153  {
154 
155  // everything all right
156  return StatusCode::SUCCESS;
157  }

◆ getCounter()

CutIdentifier DerivationFramework::CfAthAlgTool::getCounter ( const std::string &  name) const
protectedinherited

Definition at line 128 of file CfAthAlgTool.cxx.

128  {
129 
130  CutIdentifier id = getCounterIdByName(name);
131  if ( id < 1 ) {
132  std::string fullname = m_ctbasename + "_" + name;
133  if ( ! m_bidisset ) {
134  throw std::runtime_error("cutFlowSvc()->registerFilter is no longer supported. code an alternative here");
135  //id = cutFlowSvc()->registerFilter(fullname, "N/A");
136  m_bid = id;
137  } else {
138  throw std::runtime_error("cutFlowSvc()->registerCut is no longer supported. code an alternative here");
139  //id = cutFlowSvc()->registerCut(fullname, "N/A", m_bid);
140  }
141  m_mctn[name] = id;
142  }
143  return id;
144  }

◆ getCounterIdByName()

CutIdentifier DerivationFramework::CfAthAlgTool::getCounterIdByName ( const std::string &  name) const
protectedinherited

Definition at line 161 of file CfAthAlgTool.cxx.

161  {
162 
163  CutIdentifier id = 0;
164 
165  NameIdMap_t::const_iterator it = m_mctn.find(name);
166  if ( it != m_mctn.end() ) {
167  id = it->second;
168  }
169  return id;
170  }

◆ getCounterNameById()

std::string DerivationFramework::CfAthAlgTool::getCounterNameById ( CutIdentifier  id) const
protectedinherited

Definition at line 147 of file CfAthAlgTool.cxx.

147  {
148 
149  std::string res = "__NOT_FOUND__";
150 
151  for (NameIdMap_t::iterator it = m_mctn.begin(); it != m_mctn.end(); ++it) {
152  if ( it->second == id ) {
153  res = it->first;
154  break;
155  }
156  }
157  return res;
158  }

◆ initialize()

StatusCode DerivationFramework::Select_Bmumu::initialize ( )
override

initialization and finalization

Definition at line 107 of file Select_Bmumu.cxx.

107  {
108 
109  ATH_MSG_DEBUG("in initialize()");
110 
111  // retrieve V0 tools
112  CHECK( m_v0Tools.retrieve() );
113 
114  // retrieve MuonSelectionTool
115  if ( m_blindOnlyAllMuonsTight ) {
116  CHECK( m_muSelectionTool.retrieve() );
117  }
118 
119  // check length of sub-decay vertex container and required hypo name
120  // vectors
121  if ( m_subDecVtxContNames.size() != m_subDecVtxHypoCondNames.size() ) {
122  ATH_MSG_ERROR("initialize(): number of elements for options "
123  << "SubDecVtxContNames and SubDecVtxHypoCondNames does not "
124  << "match : " << m_subDecVtxContNames.size()
125  << " != " << m_subDecVtxHypoCondNames << " !!");
126  }
127  // check the length of condition and flag hypo name vectors and append
128  // to the later if necessary
129  if ( m_subDecVtxHypoCondNames.size() > m_subDecVtxHypoFlagNames.size() ) {
130  ATH_MSG_INFO("initialize(): SubDecVtxHypoFlagNames ("
131  << m_subDecVtxHypoFlagNames.size()
132  << ") < SubDecVtxHypoCondNames ("
133  << m_subDecVtxHypoCondNames.size()
134  << ") ... appending to the first.");
135  for ( unsigned int i = m_subDecVtxHypoFlagNames.size();
136  i < m_subDecVtxHypoCondNames.size(); ++i) {
137  std::string flagname = m_hypoName+"_"+m_subDecVtxHypoCondNames[i];
138  ATH_MSG_INFO("initialize(): SubDecVtxHypoFlagNames[" << i << "] = "
139  << flagname);
140  m_subDecVtxHypoFlagNames.push_back(flagname);
141  }
142  } else if ( m_subDecVtxHypoCondNames.size()
143  < m_subDecVtxHypoFlagNames.size() ) {
144  ATH_MSG_ERROR("initialize(): SubDecVtxHypoFlagNames ("
145  << m_subDecVtxHypoFlagNames.size()
146  << ") > SubDecVtxHypoCondNames ("
147  << m_subDecVtxHypoCondNames.size()
148  << ") ! Configuration error!");
149  }
150  return StatusCode::SUCCESS;
151  }

◆ inputHandles()

virtual std::vector<Gaudi::DataHandle*> AthCommonDataStore< AthCommonMsg< AlgTool > >::inputHandles ( ) const
overridevirtualinherited

Return this algorithm's input handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

◆ interfaceID()

static const InterfaceID& DerivationFramework::IAugmentationTool::interfaceID ( )
inlinestaticinherited

AlgTool interface methods.

Definition at line 31 of file IAugmentationTool.h.

31 { return IID_IAugmentationTool; }

◆ massCuts()

bool DerivationFramework::Select_Bmumu::massCuts ( float  mass) const
private

Definition at line 457 of file Select_Bmumu.cxx.

457  {
458 
459  return (mass > m_massMin && mass < m_massMax)
460  && !(m_doBlinding && m_doCutBlinded && massInBlindedRegion(mass) );
461  }

◆ massInBlindedRegion()

bool DerivationFramework::Select_Bmumu::massInBlindedRegion ( float  mass) const
private

Definition at line 466 of file Select_Bmumu.cxx.

466  {
467  return ( mass > m_blindMassMin && mass < m_blindMassMax );
468  }

◆ msg() [1/2]

MsgStream& AthCommonMsg< AlgTool >::msg ( ) const
inlineinherited

Definition at line 24 of file AthCommonMsg.h.

24  {
25  return this->msgStream();
26  }

◆ msg() [2/2]

MsgStream& AthCommonMsg< AlgTool >::msg ( const MSG::Level  lvl) const
inlineinherited

Definition at line 27 of file AthCommonMsg.h.

27  {
28  return this->msgStream(lvl);
29  }

◆ msgLvl()

bool AthCommonMsg< AlgTool >::msgLvl ( const MSG::Level  lvl) const
inlineinherited

Definition at line 30 of file AthCommonMsg.h.

30  {
31  return this->msgLevel(lvl);
32  }

◆ outputHandles()

virtual std::vector<Gaudi::DataHandle*> AthCommonDataStore< AthCommonMsg< AlgTool > >::outputHandles ( ) const
overridevirtualinherited

Return this algorithm's output handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

◆ pass()

bool DerivationFramework::Select_Bmumu::pass ( const SG::AuxElement &  em,
const std::string &  hypo 
) const
private

Definition at line 494 of file Select_Bmumu.cxx.

494  {
495 
496  SG::AuxElement::Accessor<Char_t> flagAcc("passed_"+hypo);
497  return flagAcc.isAvailable(em) && flagAcc(em) != 0;
498  }

◆ ProcessVertex()

void DerivationFramework::Select_Bmumu::ProcessVertex ( xAOD::BPhysHypoHelper &  bcand,
xAOD::BPhysHelper::pv_type  pv_t 
) const
private

Definition at line 159 of file Select_Bmumu.cxx.

160  {
161 
162  constexpr float errConst = -9999999;
163  const xAOD::Vertex* pv = bcand.pv(pv_t);
164  if (pv) {
165  // decorate the vertex.
166  // Proper decay time assuming constant mass hypothesis m_massHypo
167  BPHYS_CHECK( bcand.setTau(m_v0Tools->tau(bcand.vtx(), pv, m_massHypo),
168  pv_t,
169  xAOD::BPhysHypoHelper::TAU_CONST_MASS) );
170  // Proper decay time assuming error constant mass hypothesis m_massHypo
171  BPHYS_CHECK( bcand.setTauErr( m_v0Tools->tauError(bcand.vtx(), pv,
172  m_massHypo),
173  pv_t,
174  xAOD::BPhysHypoHelper::TAU_CONST_MASS) );
175 
176  BPHYS_CHECK( bcand.setTau(m_v0Tools->tau(bcand.vtx(),pv, m_trkMasses),
177  pv_t,
178  xAOD::BPhysHypoHelper::TAU_INV_MASS) );
179 
180  BPHYS_CHECK( bcand.setTauErr(m_v0Tools->tauError(bcand.vtx(), pv,
181  m_trkMasses),
182  pv_t,
183  xAOD::BPhysHypoHelper::TAU_INV_MASS) );
184  //enum pv_type {PV_MAX_SUM_PT2, PV_MIN_A0, PV_MIN_Z0, PV_MIN_Z0_BA};
185  } else {
186 
187  BPHYS_CHECK( bcand.setTau(errConst, pv_t,
188  xAOD::BPhysHypoHelper::TAU_CONST_MASS) );
189  // Proper decay time assuming error constant mass hypothesis m_massHypo
190  BPHYS_CHECK( bcand.setTauErr( errConst,
191  pv_t,
192  xAOD::BPhysHypoHelper::TAU_CONST_MASS) );
193 
194  BPHYS_CHECK( bcand.setTau( errConst,
195  pv_t,
196  xAOD::BPhysHypoHelper::TAU_INV_MASS) );
197 
198  BPHYS_CHECK( bcand.setTauErr( errConst,
199  pv_t,
200  xAOD::BPhysHypoHelper::TAU_INV_MASS) );
201  }
202 
203  if(m_do3d){
204 
205  BPHYS_CHECK( bcand.setTau3d( pv ?
206  m_v0Tools->tau3D(bcand.vtx(), pv,
207  m_massHypo)
208  : errConst, pv_t,
209  xAOD::BPhysHypoHelper::TAU_CONST_MASS) );
210  // Proper decay time assuming error constant mass hypothesis m_massHypo
211  BPHYS_CHECK( bcand.setTau3dErr( pv ?
212  m_v0Tools->tau3DError(bcand.vtx(), pv,
213  m_massHypo)
214  : errConst, pv_t,
215  xAOD::BPhysHypoHelper::TAU_CONST_MASS)
216  );
217 
218  BPHYS_CHECK( bcand.setTau3d( pv ?
219  m_v0Tools->tau3D(bcand.vtx(), pv,
220  m_trkMasses)
221  : errConst, pv_t,
222  xAOD::BPhysHypoHelper::TAU_INV_MASS) );
223 
224  BPHYS_CHECK( bcand.setTau3dErr( pv ?
225  m_v0Tools->tau3DError(bcand.vtx(), pv,
226  m_trkMasses)
227  : errConst, pv_t,
228  xAOD::BPhysHypoHelper::TAU_INV_MASS)
229  );
230  }
231 
232  }

◆ renounce()

std::enable_if_t<std::is_void_v<std::result_of_t<decltype(&T::renounce)(T)> > && !std::is_base_of_v<SG::VarHandleKeyArray, T> && std::is_base_of_v<Gaudi::DataHandle, T>, void> AthCommonDataStore< AthCommonMsg< AlgTool > >::renounce ( T &  h)
inlineprotectedinherited

Definition at line 380 of file AthCommonDataStore.h.

381  {
382  h.renounce();
383  PBASE::renounce (h);
384  }

◆ renounceArray()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::renounceArray ( SG::VarHandleKeyArray &  handlesArray)
inlineprotectedinherited

remove all handles from I/O resolution

Definition at line 364 of file AthCommonDataStore.h.

364  {
365  handlesArray.renounce();
366  }

◆ setPass()

bool DerivationFramework::Select_Bmumu::setPass ( const SG::AuxElement &  em,
const std::string &  hypo,
bool  passVal 
) const
private

Definition at line 502 of file Select_Bmumu.cxx.

503  {
504 
505  SG::AuxElement::Decorator<Char_t> flagDec("passed_"+hypo);
506  flagDec(em) = passVal;
507  return true;
508  }

◆ setPassIfNotAvailable()

bool DerivationFramework::Select_Bmumu::setPassIfNotAvailable ( SG::AuxElement &  em,
const std::string &  hypo,
bool  passVal 
) const
private

Definition at line 514 of file Select_Bmumu.cxx.

515  {
516 
517  SG::AuxElement::Accessor<Char_t> flagAcc("passed_"+hypo);
518  bool exists = flagAcc.isAvailable(em);
519  if ( !exists ) {
520  setPass(em, hypo, passVal);
521  }
522  return !exists;
523  }

◆ sysInitialize()

StatusCode DerivationFramework::CfAthAlgTool::sysInitialize ( )
overridevirtualinherited

Perform system initialization for an algorithm.

We override this to declare all the elements of handle key arrays at the end of initialization. See comments on updateVHKA.

Reimplemented from AthCommonDataStore< AthCommonMsg< AlgTool > >.

Definition at line 94 of file CfAthAlgTool.cxx.

94  {
95 
96  // retrieve CutFlowSvc instance
97  CHECK( m_cutFlowSvc.retrieve() );
98 
99  // re-direct to base class...
100  return AthAlgTool::sysInitialize();
101  }

◆ sysStart()

virtual StatusCode AthCommonDataStore< AthCommonMsg< AlgTool > >::sysStart ( )
overridevirtualinherited

Handle START transition.

We override this in order to make sure that conditions handle keys can cache a pointer to the conditions container.

◆ updateVHKA()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::updateVHKA ( Gaudi::Details::PropertyBase &  )
inlineinherited

Definition at line 308 of file AthCommonDataStore.h.

308  {
309  // debug() << "updateVHKA for property " << p.name() << " " << p.toString()
310  // << " size: " << m_vhka.size() << endmsg;
311  for (auto &a : m_vhka) {
312  std::vector<SG::VarHandleKey*> keys = a->keys();
313  for (auto k : keys) {
314  k->setOwner(this);
315  }
316  }
317  }

Member Data Documentation

◆ m_bid

CutIdentifier DerivationFramework::CfAthAlgTool::m_bid
mutableprivateinherited

Definition at line 76 of file CfAthAlgTool.h.

◆ m_bidisset

bool DerivationFramework::CfAthAlgTool::m_bidisset
mutableprivateinherited

Definition at line 77 of file CfAthAlgTool.h.

◆ m_blindMassMax

double DerivationFramework::Select_Bmumu::m_blindMassMax
private

blinding mass range

Definition at line 103 of file Select_Bmumu.h.

◆ m_blindMassMin

double DerivationFramework::Select_Bmumu::m_blindMassMin
private

blinding mass range

Definition at line 102 of file Select_Bmumu.h.

◆ m_blindOnlyAllMuonsTight

bool DerivationFramework::Select_Bmumu::m_blindOnlyAllMuonsTight
private

only blind candidates with all tight muons

Definition at line 106 of file Select_Bmumu.h.

◆ m_chi2Max

double DerivationFramework::Select_Bmumu::m_chi2Max
private

max chi2 cut

Definition at line 99 of file Select_Bmumu.h.

◆ m_ctbasename

std::string DerivationFramework::CfAthAlgTool::m_ctbasename
privateinherited

Definition at line 69 of file CfAthAlgTool.h.

◆ m_cutFlowSvc

ServiceHandle<ICutFlowSvc> DerivationFramework::CfAthAlgTool::m_cutFlowSvc
privateinherited

Definition at line 66 of file CfAthAlgTool.h.

◆ m_detStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_detStore
privateinherited

Pointer to StoreGate (detector store by default)

Definition at line 393 of file AthCommonDataStore.h.

◆ m_do3d

bool DerivationFramework::Select_Bmumu::m_do3d
private

add 3d proper time

Definition at line 101 of file Select_Bmumu.h.

◆ m_doBlinding

bool DerivationFramework::Select_Bmumu::m_doBlinding
private

enable blinding range

Definition at line 104 of file Select_Bmumu.h.

◆ m_doCutBlinded

bool DerivationFramework::Select_Bmumu::m_doCutBlinded
private

enable cutting blinded vertices

Definition at line 105 of file Select_Bmumu.h.

◆ m_DoVertexType

int DerivationFramework::Select_Bmumu::m_DoVertexType
private

Allows user to skip certain vertexes - bitwise test 7==all(111)

Definition at line 100 of file Select_Bmumu.h.

◆ m_evtStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_evtStore
privateinherited

Pointer to StoreGate (event store by default)

Definition at line 390 of file AthCommonDataStore.h.

◆ m_hypoName

std::string DerivationFramework::Select_Bmumu::m_hypoName
private

job options

name of the mass hypothesis. E.g. Jpis, Upsi, etc. Will be used as a prefix for decorations

Definition at line 93 of file Select_Bmumu.h.

◆ m_inputVtxContainerName

std::string DerivationFramework::Select_Bmumu::m_inputVtxContainerName
private

name of the input container name

Definition at line 94 of file Select_Bmumu.h.

◆ m_massHypo

double DerivationFramework::Select_Bmumu::m_massHypo
private

vertex mass hypothesis

Definition at line 96 of file Select_Bmumu.h.

◆ m_massMax

double DerivationFramework::Select_Bmumu::m_massMax
private

invariant mass range

Definition at line 97 of file Select_Bmumu.h.

◆ m_massMin

double DerivationFramework::Select_Bmumu::m_massMin
private

invariant mass range

Definition at line 98 of file Select_Bmumu.h.

◆ m_mctn

NameIdMap_t DerivationFramework::CfAthAlgTool::m_mctn
mutableprivateinherited

Definition at line 73 of file CfAthAlgTool.h.

◆ m_muSelectionTool

ToolHandle<CP::IMuonSelectionTool> DerivationFramework::Select_Bmumu::m_muSelectionTool
private

Definition at line 89 of file Select_Bmumu.h.

◆ m_subDecVtxContNames

std::vector<std::string> DerivationFramework::Select_Bmumu::m_subDecVtxContNames
private

names of sub-decay vertex containers

Definition at line 109 of file Select_Bmumu.h.

◆ m_subDecVtxHypoCondNames

std::vector<std::string> DerivationFramework::Select_Bmumu::m_subDecVtxHypoCondNames
private

hypo names for sub-decays to be considered

Definition at line 110 of file Select_Bmumu.h.

◆ m_subDecVtxHypoFlagNames

std::vector<std::string> DerivationFramework::Select_Bmumu::m_subDecVtxHypoFlagNames
private

names of hypo flags set on sub-decays if passing

Definition at line 111 of file Select_Bmumu.h.

◆ m_trkMasses

std::vector<double> DerivationFramework::Select_Bmumu::m_trkMasses
private

track mass hypotheses

Definition at line 95 of file Select_Bmumu.h.

◆ m_useMuCalcMass

bool DerivationFramework::Select_Bmumu::m_useMuCalcMass
private

also check against MUCALC mass

Definition at line 107 of file Select_Bmumu.h.

◆ m_v0Tools

ToolHandle<Trk::V0Tools> DerivationFramework::Select_Bmumu::m_v0Tools
private

tools

Definition at line 88 of file Select_Bmumu.h.

◆ m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< AlgTool > >::m_varHandleArraysDeclared
privateinherited

Definition at line 399 of file AthCommonDataStore.h.

◆ m_vhka

std::vector<SG::VarHandleKeyArray*> AthCommonDataStore< AthCommonMsg< AlgTool > >::m_vhka
privateinherited

Definition at line 398 of file AthCommonDataStore.h.

The documentation for this class was generated from the following files:
python.PyKernel.retrieve
def retrieve(aClass, aKey=None)
Definition: PyKernel.py:110
xAOD::iterator
JetConstituentVector::iterator iterator
Definition: JetConstituentVector.cxx:68
DerivationFramework::CfAthAlgTool::getCounter
CutIdentifier getCounter(const std::string &name) const
Definition: CfAthAlgTool.cxx:128
DerivationFramework::Select_Bmumu::m_massHypo
double m_massHypo
vertex mass hypothesis
Definition: Select_Bmumu.h:96
DerivationFramework::CfAthAlgTool::m_mctn
NameIdMap_t m_mctn
Definition: CfAthAlgTool.h:73
xAOD::BPhysHypoHelper::setTau3dErr
bool setTau3dErr(const float val, const pv_type vertexType=BPhysHelper::PV_MIN_A0, const tau_type tauType=BPhysHypoHelper::TAU_CONST_MASS)
proper decay time error
Definition: BPhysHypoHelper.cxx:319
DerivationFramework::Select_Bmumu::m_doBlinding
bool m_doBlinding
enable blinding range
Definition: Select_Bmumu.h:104
xAOD::VertexAuxContainer_v1
Temporary container used until we have I/O for AuxStoreInternal.
Definition: VertexAuxContainer_v1.h:32
DerivationFramework::Select_Bmumu::m_trkMasses
std::vector< double > m_trkMasses
track mass hypotheses
Definition: Select_Bmumu.h:95
ATH_MSG_INFO
#define ATH_MSG_INFO(x)
Definition: AthMsgStreamMacros.h:31
DerivationFramework::CfAthAlgTool::addToCounter
virtual bool addToCounter(const std::string &name, uint64_t counts=1, double weight=1.) const
Definition: CfAthAlgTool.cxx:115
Base_Fragment.mass
mass
Definition: Sherpa_i/share/common/Base_Fragment.py:59
SG::Accessor
Helper class to provide type-safe access to aux data.
Definition: Control/AthContainers/AthContainers/Accessor.h:68
DerivationFramework::Select_Bmumu::m_do3d
bool m_do3d
add 3d proper time
Definition: Select_Bmumu.h:101
xAOD::BPhysHypoHelper::setTauErr
bool setTauErr(const float val, const pv_type vertexType=BPhysHelper::PV_MIN_A0, const tau_type tauType=BPhysHypoHelper::TAU_CONST_MASS)
proper decay time error
Definition: BPhysHypoHelper.cxx:176
DerivationFramework::Select_Bmumu::massInBlindedRegion
bool massInBlindedRegion(float mass) const
Definition: Select_Bmumu.cxx:466
AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty
Gaudi::Details::PropertyBase & declareProperty(Gaudi::Property< T > &t)
Definition: AthCommonDataStore.h:145
min
constexpr double min()
Definition: ap_fixedTest.cxx:26
DerivationFramework::Select_Bmumu::pass
bool pass(const SG::AuxElement &em, const std::string &hypo) const
Definition: Select_Bmumu.cxx:494
skel.it
it
Definition: skel.GENtoEVGEN.py:396
AthCommonDataStore< AthCommonMsg< AlgTool > >::m_evtStore
StoreGateSvc_t m_evtStore
Pointer to StoreGate (event store by default)
Definition: AthCommonDataStore.h:390
AthCommonDataStore< AthCommonMsg< AlgTool > >::m_vhka
std::vector< SG::VarHandleKeyArray * > m_vhka
Definition: AthCommonDataStore.h:398
DerivationFramework::CfAthAlgTool::addEvent
virtual bool addEvent(const std::string &name, double weight=1.) const
Definition: CfAthAlgTool.cxx:104
xAOD::BPhysHelper::PV_MIN_Z0
@ PV_MIN_Z0
Definition: BPhysHelper.h:475
DerivationFramework::Select_Bmumu::m_blindMassMin
double m_blindMassMin
blinding mass range
Definition: Select_Bmumu.h:102
read_hist_ntuple.t
t
Definition: read_hist_ntuple.py:5
xAOD::BPhysHypoHelper::TAU_INV_MASS
@ TAU_INV_MASS
Definition: BPhysHypoHelper.h:137
SG::VarHandleKeyArray::setOwner
virtual void setOwner(IDataHandleHolder *o)=0
dqt_zlumi_pandas.weight
int weight
Definition: dqt_zlumi_pandas.py:189
IDTPMcnv.htype
htype
Definition: IDTPMcnv.py:29
DerivationFramework::Select_Bmumu::m_muSelectionTool
ToolHandle< CP::IMuonSelectionTool > m_muSelectionTool
Definition: Select_Bmumu.h:89
AthCommonDataStore< AthCommonMsg< AlgTool > >::evtStore
ServiceHandle< StoreGateSvc > & evtStore()
The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.
Definition: AthCommonDataStore.h:85
xAOD::BPhysHypoHelper
Definition: BPhysHypoHelper.h:73
DerivationFramework::Select_Bmumu::m_useMuCalcMass
bool m_useMuCalcMass
also check against MUCALC mass
Definition: Select_Bmumu.h:107
BPHYS_CHECK
#define BPHYS_CHECK(EXP)
Useful CHECK macro.
Definition: BPhysHelper.h:738
DerivationFramework::CfAthAlgTool::m_cutFlowSvc
ServiceHandle< ICutFlowSvc > m_cutFlowSvc
Definition: CfAthAlgTool.h:66
python.utils.AtlRunQueryDQUtils.p
p
Definition: AtlRunQueryDQUtils.py:210
DerivationFramework::Select_Bmumu::m_massMin
double m_massMin
invariant mass range
Definition: Select_Bmumu.h:98
AthCommonDataStore
Definition: AthCommonDataStore.h:52
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
DerivationFramework::Select_Bmumu::m_massMax
double m_massMax
invariant mass range
Definition: Select_Bmumu.h:97
SG::Decorator
Helper class to provide type-safe access to aux data.
Definition: Decorator.h:59
DataModel_detail::iterator
(Non-const) Iterator class for DataVector/DataList.
Definition: DVLIterator.h:184
lumiFormat.i
int i
Definition: lumiFormat.py:85
beamspotman.n
n
Definition: beamspotman.py:731
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition: AthMsgStreamMacros.h:29
DerivationFramework::Select_Bmumu::m_chi2Max
double m_chi2Max
max chi2 cut
Definition: Select_Bmumu.h:99
DerivationFramework::Select_Bmumu::ProcessVertex
void ProcessVertex(xAOD::BPhysHypoHelper &, xAOD::BPhysHelper::pv_type) const
Definition: Select_Bmumu.cxx:159
res
std::pair< std::vector< unsigned int >, bool > res
Definition: JetGroupProductTest.cxx:14
xAOD::BPhysHelper::PV_MIN_A0
@ PV_MIN_A0
Definition: BPhysHelper.h:475
xAOD::uint64_t
uint64_t
Definition: EventInfo_v1.cxx:123
DerivationFramework::Select_Bmumu::m_doCutBlinded
bool m_doCutBlinded
enable cutting blinded vertices
Definition: Select_Bmumu.h:105
CHECK
#define CHECK(...)
Evaluate an expression and check for errors.
Definition: Control/AthenaKernel/AthenaKernel/errorcheck.h:422
AthCommonDataStore< AthCommonMsg< AlgTool > >::m_detStore
StoreGateSvc_t m_detStore
Pointer to StoreGate (detector store by default)
Definition: AthCommonDataStore.h:393
CutIdentifier
uint32_t CutIdentifier
InstanceIdentifier is a unique identifer used for every AthFilterAlgorithm instance.
Definition: ICutFlowSvc.h:22
xAOD::BPhysHypoHelper::TAU_CONST_MASS
@ TAU_CONST_MASS
Definition: BPhysHypoHelper.h:137
DataVector
Derived DataVector<T>.
Definition: DataVector.h:794
SG::VarHandleKeyArray::renounce
virtual void renounce()=0
SG::HandleClassifier::type
std::conditional< std::is_base_of< SG::VarHandleKeyArray, T >::value, VarHandleKeyArrayType, type2 >::type type
Definition: HandleClassifier.h:54
LikeEnum::Tight
@ Tight
Definition: LikelihoodEnums.h:15
DerivationFramework::CfAthAlgTool::m_bidisset
bool m_bidisset
Definition: CfAthAlgTool.h:77
DerivationFramework::CfAthAlgTool::getCounterIdByName
CutIdentifier getCounterIdByName(const std::string &name) const
Definition: CfAthAlgTool.cxx:161
merge_scale_histograms.doc
string doc
Definition: merge_scale_histograms.py:9
id
SG::auxid_t id
Definition: Control/AthContainers/Root/debug.cxx:227
xAOD::BPhysHypoHelper::setTau3d
bool setTau3d(const float val, const pv_type vertexType=BPhysHelper::PV_MIN_A0, const tau_type tauType=BPhysHypoHelper::TAU_CONST_MASS)
proper decay time
Definition: BPhysHypoHelper.cxx:283
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:228
DerivationFramework::CfAthAlgTool::m_ctbasename
std::string m_ctbasename
Definition: CfAthAlgTool.h:69
xAOD::BPhysHelper::vtx
const xAOD::Vertex * vtx() const
Getter method for the cached xAOD::Vertex.
Definition: BPhysHelper.h:108
DerivationFramework::Select_Bmumu::m_subDecVtxHypoFlagNames
std::vector< std::string > m_subDecVtxHypoFlagNames
names of hypo flags set on sub-decays if passing
Definition: Select_Bmumu.h:111
AthCommonDataStore< AthCommonMsg< AlgTool > >::sysInitialize
virtual StatusCode sysInitialize() override
Perform system initialization for an algorithm.
xAOD::BPhysHelper::PV_MAX_SUM_PT2
@ PV_MAX_SUM_PT2
Definition: BPhysHelper.h:475
DataVector::end
const_iterator end() const noexcept
Return a const_iterator pointing past the end of the collection.
DerivationFramework::Select_Bmumu::m_subDecVtxContNames
std::vector< std::string > m_subDecVtxContNames
names of sub-decay vertex containers
Definition: Select_Bmumu.h:109
a
TList * a
Definition: liststreamerinfos.cxx:10
h
xAOD::Vertex_v1
Class describing a Vertex.
Definition: Vertex_v1.h:42
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
DerivationFramework::Select_Bmumu::m_hypoName
std::string m_hypoName
job options
Definition: Select_Bmumu.h:93
python.changerun.pv
pv
Definition: changerun.py:81
DerivationFramework::Select_Bmumu::m_DoVertexType
int m_DoVertexType
Allows user to skip certain vertexes - bitwise test 7==all(111)
Definition: Select_Bmumu.h:100
xAOD::BPhysHelper::pv
const xAOD::Vertex * pv(const pv_type vertexType=BPhysHelper::PV_MIN_A0)
Get the refitted collision vertex of type pv_type.
Definition: BPhysHelper.cxx:796
DerivationFramework::Select_Bmumu::m_blindOnlyAllMuonsTight
bool m_blindOnlyAllMuonsTight
only blind candidates with all tight muons
Definition: Select_Bmumu.h:106
SG::VarHandleBase::vhKey
SG::VarHandleKey & vhKey()
Return a non-const reference to the HandleKey.
Definition: StoreGate/src/VarHandleBase.cxx:623
python.Bindings.keys
keys
Definition: Control/AthenaPython/python/Bindings.py:798
python.dummyaccess.exists
def exists(filename)
Definition: dummyaccess.py:9
DerivationFramework::Select_Bmumu::m_subDecVtxHypoCondNames
std::vector< std::string > m_subDecVtxHypoCondNames
hypo names for sub-decays to be considered
Definition: Select_Bmumu.h:110
DerivationFramework::Select_Bmumu::m_inputVtxContainerName
std::string m_inputVtxContainerName
name of the input container name
Definition: Select_Bmumu.h:94
DerivationFramework::Select_Bmumu::massCuts
bool massCuts(float mass) const
Definition: Select_Bmumu.cxx:457
xAOD::BPhysHypoHelper::setTau
bool setTau(const float val, const pv_type vertexType=BPhysHelper::PV_MIN_A0, const tau_type tauType=BPhysHypoHelper::TAU_CONST_MASS)
: Set the proper decay time and error.
Definition: BPhysHypoHelper.cxx:140
DataVector::size
size_type size() const noexcept
Returns the number of elements in the collection.
AthCommonDataStore::declareGaudiProperty
Gaudi::Details::PropertyBase & declareGaudiProperty(Gaudi::Property< T > &hndl, const SG::VarHandleKeyType &)
specialization for handling Gaudi::Property<SG::VarHandleKey>
Definition: AthCommonDataStore.h:156
DerivationFramework::Select_Bmumu::setPassIfNotAvailable
bool setPassIfNotAvailable(SG::AuxElement &em, const std::string &hypo, bool passVal) const
Definition: Select_Bmumu.cxx:514
DerivationFramework::Select_Bmumu::m_blindMassMax
double m_blindMassMax
blinding mass range
Definition: Select_Bmumu.h:103
DerivationFramework::CfAthAlgTool::m_bid
CutIdentifier m_bid
Definition: CfAthAlgTool.h:76
DerivationFramework::Select_Bmumu::checkAllMuonsTight
bool checkAllMuonsTight(const std::vector< const xAOD::Muon * > &muons, int maxMuonsToCheck=-1) const
Definition: Select_Bmumu.cxx:472
xAOD::BPhysHelper::PV_MIN_Z0_BA
@ PV_MIN_Z0_BA
Definition: BPhysHelper.h:475
DataVector::begin
const_iterator begin() const noexcept
Return a const_iterator pointing at the beginning of the collection.
fitman.k
k
Definition: fitman.py:528
DerivationFramework::Select_Bmumu::m_v0Tools
ToolHandle< Trk::V0Tools > m_v0Tools
tools
Definition: Select_Bmumu.h:88
DerivationFramework::Select_Bmumu::setPass
bool setPass(const SG::AuxElement &em, const std::string &hypo, bool passVal) const
Definition: Select_Bmumu.cxx:502
DerivationFramework::CfAthAlgTool::CfAthAlgTool
CfAthAlgTool(const std::string &t, const std::string &n, const IInterface *p)
Definition: CfAthAlgTool.cxx:67
Generated on Sun Dec 22 2024 21:59:02 for ATLAS Offline Software by   doxygen 1.8.18