Belle II Software  release-05-01-25
dark.py
1 #!/usr/bin/env python3
2 # -*- coding: utf-8 -*-
3 
4 """ Skim list building functions for the dark sector physics working group """
5 
6 __authors__ = [
7  "Sam Cunliffe",
8  "Michael De Nuccio",
9  "Ilya Komarov",
10  "Giacomo De Pietro",
11  "Miho Wakai",
12  "Savino Longo"
13 ]
14 
15 
16 import basf2 as b2
17 import modularAnalysis as ma
18 import pdg
19 from skimExpertFunctions import BaseSkim, fancy_skim_header, get_test_file
20 from stdCharged import stdE, stdMu
21 from stdPhotons import stdPhotons
22 import vertex as vertex
23 
24 __liaison__ = "Sascha Dreyer <sascha.dreyer@desy.de>"
25 
26 
27 @fancy_skim_header
29  """
30  **Physics channel**: ee → A'γ; A' → invisible
31 
32  Skim list contains single photon candidates for the dark photon to invisible final
33  state analysis.
34  """
35  __authors__ = ["Sam Cunliffe", "Chris Hearty"]
36  __contact__ = __liaison__
37  __description__ = "Single photon skim list for the dark photon analysis."
38  __category__ = "physics, dark sector"
39 
40  def load_standard_lists(self, path):
41  stdPhotons("all", path=path)
42 
43  def build_lists(self, path):
44 
45  # start with all photons with E* above 500 MeV in the tracking acceptance
46  in_tracking_acceptance = "0.296706 < theta < 2.61799" # rad = [17, 150] degrees
47  ma.cutAndCopyList(
48  "gamma:singlePhoton", "gamma:all",
49  f"useCMSFrame(E) > 0.5 and {in_tracking_acceptance}", path=path)
50 
51  # require a region-dependent minimum energy of the candidate, we have
52  # a new 0.5 GeV trigger in the inner barrel: [44.2, 94.8] degrees @ L1
53  region_dependent = " [clusterTheta < 1.65457213 and clusterTheta > 0.77143553] or "
54  region_dependent += "[clusterReg == 2 and useCMSFrame(E) > 1.0] or " # barrel
55  region_dependent += "[clusterReg == 1 and useCMSFrame(E) > 2.0] or " # fwd
56  region_dependent += "[clusterReg == 3 and useCMSFrame(E) > 2.0] or " # bwd
57  region_dependent += "[clusterReg == 11 and useCMSFrame(E) > 2.0] or " # between fwd and barrel
58  region_dependent += "[clusterReg == 13 and useCMSFrame(E) > 2.0]" # between bwd and barrel
59  ma.applyCuts("gamma:singlePhoton", region_dependent, path=path)
60 
61  # require only one single photon candidate and no good tracks in the event
62  good_tracks = 'abs(dz) < 2.0 and abs(dr) < 0.5 and pt > 0.15' # cm, cm, GeV/c
63  path = self.skim_event_cuts(
64  f"nParticlesInList(gamma:singlePhoton) == 1 and nCleanedTracks({good_tracks}) == 0",
65  path=path
66  )
67 
68  # check the second-most-energetic photon (above 550 MeV is unlikely to
69  # be beam-induced background) and veto if it's in time with our signal
70  # candidate -- do after the event cuts since it uses a ParticleCombiner
71  # and should not be done for all events (save event-processing time)
72  not_in_signal_list = "isInList(gamma:singlePhoton) < 1"
73  in_time = "maxWeightedDistanceFromAverageECLTime < 1"
74  ma.cutAndCopyList("gamma:to_veto", "gamma:all",
75  f"E > 0.55 and {not_in_signal_list}", path=path)
76  ma.rankByHighest("gamma:to_veto", "E", numBest=1, path=path)
77  ma.reconstructDecay("vpho:veto -> gamma:singlePhoton gamma:to_veto",
78  in_time, path=path)
79  veto_additional_in_time_cluster = 'nParticlesInList(vpho:veto) < 1'
80 
81  # final signal selection must pass the 'in-time' veto on the
82  # second-most-energetic cluster -- this is also an event cut, but apply
83  # to the list (which is anyway a maximum one candidate per event) since
84  # we can only call skim_event_cuts once
85  ma.applyCuts("gamma:singlePhoton", veto_additional_in_time_cluster, path=path)
86  self.SkimLists = ["gamma:singlePhoton"]
87 
88 
89 @fancy_skim_header
91  __authors__ = ["Michael De Nuccio"]
92  __description__ = (
93  "Neutral dark sector skim list for the ALP 3-photon analysis: "
94  ":math:`ee\\to a(\\to\\gamma\\gamma)\\gamma`"
95  )
96  __contact__ = __liaison__
97  __category__ = "physics, dark sector"
98 
99  def addALPToPDG(self):
100  """Adds the ALP codes to the basf2 pdg instance """
101  pdg.add_particle('beam', 55, 999., 999., 0, 0)
102  pdg.add_particle('ALP', 9000006, 999., 999., 0, 0)
103 
104  def initialALP(self, path):
105  """
106  An list builder function for the ALP decays. Part of the `ALP3Gamma` skim.
107 
108  Parameters:
109  path (basf2.Path): the path to add the skim
110 
111  Returns:
112  list name of the ALP decays candidates
113  """
114  # no cuts applied on ALP
115  ALPcuts = ''
116 
117  # applying a lab frame energy cut to the daughter photons
118  ma.fillParticleList(
119  'gamma:cdcAndMinimumEnergy',
120  'E >= 0.1 and theta >= 0.297 and theta <= 2.618',
121  True, path=path
122  )
123 
124  # defining the decay string
125  ALPchannels = ['gamma:cdcAndMinimumEnergy gamma:cdcAndMinimumEnergy']
126  ALPList = []
127 
128  # creating an ALP from the daughter photons
129  for chID, channel in enumerate(ALPchannels):
130  mode = 'ALP:' + str(chID) + ' -> ' + channel
131  print(mode)
132  ma.reconstructDecay(mode, ALPcuts, chID, path=path)
133 
134  ALPList.append('ALP:' + str(chID))
135 
136  Lists = ALPList
137  return Lists
138 
139  def additional_setup(self, path):
140  self.addALPToPDG()
141 
142  def build_lists(self, path):
143  # applying invariant mass cut on the beam particle
144  beamcuts = "InvM >= formula(0.8 * Ecms) and InvM <= formula(1.05 * Ecms) and maxWeightedDistanceFromAverageECLTime <= 2"
145 
146  ALPList = self.initialALP(path=path)
147 
148  # applying a lab frame energy cut to the recoil photon
149  ma.fillParticleList("gamma:minimumEnergy", "E >= 0.1", True, path=path)
150  beamList = []
151 
152  # reconstructing decay using the reconstructed ALP
153  # from previous function and adding the recoil photon
154  for chID, channel in enumerate(ALPList):
155  mode = "beam:" + str(chID) + " -> gamma:minimumEnergy " + channel
156  print(mode)
157  ma.reconstructDecay(mode, beamcuts, chID, path=path)
158  beamList.append("beam:" + str(chID))
159  self.SkimLists = beamList
160 
161 
162 @fancy_skim_header
164  """
165  **Physics channel**: :math:`e^{+}e^{-} \\to \\mu^{+}\\mu^{-} \\, +` missing energy.
166  """
167  __authors__ = ["Giacomo De Pietro"]
168  __description__ = (
169  "Dimuon + missing energy skim, needed for :math:`e^{+}e^{-} \\to \\mu^{+}\\mu^{-}"
170  "Z^{\\prime}; \\, Z^{\\prime} \\to \\mathrm{invisible}` and other searches."
171  )
172  __contact__ = __liaison__
173  __category__ = "physics, dark sector"
174 
175  def load_standard_lists(self, path):
176  stdMu("all", path=path)
177 
178  def build_lists(self, path):
179  dimuon_list = []
180  skim_label = "forDimuonMissingEnergySkim"
181  dimuon_name = "Z0:" + skim_label
182 
183  # Define some cuts
184  fromIP_cut = "[abs(dz) < 5.0] and [abs(dr) < 2.0]"
185  muonID_cut = "[muonID > 0.3]"
186  # We want exactly 2 tracks from IP
187  dimuon_cut = "[nCleanedTracks(" + fromIP_cut + ") < 4]"
188  # And the pair must have pt > 200 MeV in CMS frame
189  dimuon_cut += " and [useCMSFrame(pt) > 0.2]"
190 
191  # Reconstruct the dimuon candidate
192  ma.cutAndCopyList("mu+:" + skim_label, "mu+:all", fromIP_cut + " and " + muonID_cut, path=path)
193  ma.reconstructDecay(dimuon_name + " -> mu+:" + skim_label + " mu-:" + skim_label, dimuon_cut, path=path)
194 
195  # And return the dimuon list
196  dimuon_list.append(dimuon_name)
197  self.SkimLists = dimuon_list
198 
199 
200 @fancy_skim_header
202  __authors__ = ["Giacomo De Pietro"]
203  __description__ = (
204  "Electron-muon pair + missing energy skim, needed for :math:`e^{+}e^{-} \\to "
205  "e^{\\pm}\\mu^{\\mp} Z^{\\prime}; \\, Z^{\\prime} \\to \\mathrm{invisible}` and other "
206  "searches."
207  )
208  __contact__ = __liaison__
209  __category__ = "physics, dark sector"
210 
211  def load_standard_lists(self, path):
212  stdE("all", path=path)
213  stdMu("all", path=path)
214 
215  def build_lists(self, path):
216  """
217  **Physics channel**: :math:`e^{+}e^{-} \\to e^{\\pm}\\mu^{\\mp} \\, +` missing energy
218  """
219  emu_list = []
220  skim_label = "forElectronMuonMissingEnergySkim"
221  emu_name = "Z0:" + skim_label
222 
223  # Define some basic cuts
224  fromIP_cut = "[abs(dz) < 5.0] and [abs(dr) < 2.0]"
225  electronID_cut = "[electronID > 0.3]"
226  muonID_cut = "[muonID > 0.3]"
227  # We require that the electron points to the barrel ECL + 10 degrees
228  theta_cut = "[0.387 < theta < 2.421]"
229  # We want exactly 2 tracks from IP
230  emu_cut = "[nCleanedTracks(" + fromIP_cut + ") < 4]"
231  # And the pair must have pt > 200 MeV in CMS frame
232  emu_cut += " and [useCMSFrame(pt) > 0.2]"
233 
234  # Reconstruct the dimuon candidate
235  ma.cutAndCopyList("e+:" + skim_label, "e+:all", fromIP_cut + " and " + electronID_cut + " and " + theta_cut, path=path)
236  ma.cutAndCopyList("mu+:" + skim_label, "mu+:all", fromIP_cut + " and " + muonID_cut, path=path)
237  ma.reconstructDecay(emu_name + " -> e+:" + skim_label + " mu-:" + skim_label, emu_cut, path=path)
238 
239  # And return the dimuon list
240  emu_list.append(emu_name)
241  self.SkimLists = emu_list
242 
243 
244 @fancy_skim_header
246  __authors__ = ["Ilya Komarov"]
247  __description__ = "Lepton flavour violating Z' skim, Z' to visible FS."
248  __contact__ = __liaison__
249  __category__ = "physics, dark sector"
250 
251  def load_standard_lists(self, path):
252  stdE("all", path=path)
253  stdE("loose", path=path)
254 
255  def build_lists(self, path):
256  """
257  **Physics channel**: ee --> e mu Z'; Z' --> e mu
258  """
259  lfvzp_list = []
260 
261  # Here we just want four gpood tracks to be reconstructed
262  track_cuts = "abs(dz) < 2.0 and abs(dr) < 0.5"
263  Event_cuts_vis = "nCleanedTracks(abs(dz) < 2.0 and abs(dr) < 0.5) == 4"
264 
265  ma.cutAndCopyList("e+:lfvzp", "e+:all", track_cuts, path=path)
266 
267  # Z' to lfv: fully reconstructed
268  LFVZpVisChannel = "e+:lfvzp e+:lfvzp e-:lfvzp e-:lfvzp"
269 
270  ma.reconstructDecay("vpho:vislfvzp -> " + LFVZpVisChannel, Event_cuts_vis, path=path)
271 
272  lfvzp_list.append("vpho:vislfvzp")
273 
274  # Z' to lfv: part reco
275  LFVZpVisChannel = "e+:lfvzp e+:lfvzp e-:lfvzp"
276  Event_cuts_vis = "nCleanedTracks(abs(dz) < 2.0 and abs(dr) < 0.5) == 3"
277 
278  ma.reconstructDecay("vpho:3tr_vislfvzp -> " + LFVZpVisChannel, Event_cuts_vis, path=path, allowChargeViolation=True)
279 
280  lfvzp_list.append("vpho:3tr_vislfvzp")
281 
282  # Z' to lfv: two same-sign tracks
283  LFVZpVisChannel = "e+:lfvzp e+:lfvzp"
284  Event_cuts_vis = "nCleanedTracks(abs(dz) < 2.0 and abs(dr) < 0.5) == 2"
285  ma.reconstructDecay("vpho:2tr_vislfvzp -> " + LFVZpVisChannel, Event_cuts_vis, path=path, allowChargeViolation=True)
286 
287  lfvzp_list.append("vpho:2tr_vislfvzp")
288 
289  self.SkimLists = lfvzp_list
290 
291 
292 @fancy_skim_header
294  """
295  **Physics channel**: ee → eγ
296  """
297 
298  __authors__ = ["Sam Cunliffe", "Torben Ferber"]
299  __description__ = (
300  "Electron-gamma skim list for study of the ee backgrounds at high dark "
301  "photon mass, as part of the dark photon analysis"
302  )
303  __contact__ = __liaison__
304  __category__ = "physics, dark sector, control-channel"
305 
306  def load_standard_lists(self, path):
307  stdPhotons("all", path=path)
308  stdE("all", path=path)
309 
310  def build_lists(self, path):
311 
312  # long-winded names for the particle lists to avoid clash
313  internal_skim_label = "forEGammaSkim"
314  skim_output_label = "EGammaControl"
315 
316  # want exactly 1 good quality track in the event
317  # (not one good electron, one good anything)
318  phys_perf_good_track = 'abs(dr) < 1 and abs(dz) < 3 and pt > 0.15' # cm, cm, GeV/c
319  one_good_track = f'[nCleanedTracks({phys_perf_good_track}) == 1]'
320 
321  # exactly 1 good photon in the event
322  photon_energy_cut = '0.45'
323  good_photon = 'theta > 0.296706 and theta < 2.61799' +\
324  f' and useCMSFrame(E) > {photon_energy_cut}'
325  ma.cutAndCopyList(f'gamma:{internal_skim_label}', 'gamma:all', good_photon, path=path)
326  one_good_photon = f'[eventCached(nParticlesInList(gamma:{internal_skim_label})) == 1]'
327 
328  # apply the event-level cuts
329  event_cuts = f'{one_good_photon} and {one_good_track}'
330  path = self.skim_event_cuts(event_cuts, path=path)
331 
332  # fill electron lists (tighter than previous selection)
333  good_track_w_hie_cluster_match = '%s and clusterE > 2.0' % phys_perf_good_track
334  ma.cutAndCopyList(f'e+:{internal_skim_label}', 'e+:all', good_track_w_hie_cluster_match, path=path)
335 
336  # reconstruct decay
337  ma.reconstructDecay(
338  f'vpho:{skim_output_label} -> e+:{internal_skim_label} gamma:{internal_skim_label}',
339  '', 1, allowChargeViolation=True, path=path)
340  self.SkimLists = [f"vpho:{skim_output_label}"]
341 
342 
343 @fancy_skim_header
345  """
346  **Physics channel**: ee → γγ
347 
348  .. Note::
349  This skim can retain a lot of γγ events.
350  In case this becomes unacceptable, we provide prescale parameters.
351  Prescales are given in standard trigger convention (reciprocal),
352  so prescale of 100 is 1% of events kept, etc.
353 
354  .. Tip::
355  To prescale the higher-energy probe photons by 10%:
356 
357  >>> from skim.dark import GammaGammaControlKLMDark
358  >>> Skim = GammaGammaControlKLMDark(prescale_high=10)
359  >>> Skim(path) # Add list-building function and uDST output module to path
360  >>> b2.process(path)
361  """
362 
363  __authors__ = ["Sam Cunliffe", "Miho Wakai"]
364  __description__ = (
365  "Gamma gamma skim list for study of the KLM efficiency as part of "
366  "the dark photon analysis"
367  )
368  __contact__ = __liaison__
369  __category__ = "physics, dark sector, control-channel"
370 
371  def load_standard_lists(self, path):
372  stdPhotons("all", path=path)
373 
374  TestFiles = [get_test_file("MC13_ggBGx1")]
375 
376  def __init__(self, prescale_high=1, prescale_low=1, **kwargs):
377  """
378  Parameters:
379  prescale_high (int): the prescale for more energetic probe photon
380  prescale_low (int): the prescale for a less energetic probe photon
381  **kwargs: Passed to constructor of `BaseSkim`.
382  """
383  # Redefine __init__ to allow for additional optional arguments
384  super().__init__(**kwargs)
385  self.prescale_high = prescale_high
386  self.prescale_low = prescale_low
387 
388  def build_lists(self, path):
389  # unpack prescales and convert from trigger convention to a number we can
390  # compare with a float
391  prescale_high, prescale_low = self.prescale_high, self.prescale_low
392  if (prescale_high, prescale_low) is not (1, 1):
393  b2.B2INFO(
394  "GammaGammaControlKLMDarkList is prescaled. "
395  f"prescale_high={prescale_high}, prescale_low={prescale_low}"
396  )
397  prescale_high = str(float(1.0 / prescale_high))
398  prescale_low = str(float(1.0 / prescale_low))
399 
400  # no good (IP-originating) tracks in the event
401  good_tracks = "abs(dz) < 2.0 and abs(dr) < 0.5 and pt > 0.2" # cm, cm, GeV/c
402  no_good_tracks = f"nCleanedTracks({good_tracks}) < 1"
403 
404  # get two most energetic photons in the event (must be at least 100 MeV
405  # and not more than 7 GeV)
406  ma.cutAndCopyList(
407  "gamma:controlKLM", "gamma:all", "0.1 < useCMSFrame(clusterE) < 7", path=path)
408  ma.rankByHighest("gamma:controlKLM", "useCMSFrame(clusterE)", numBest=2, path=path)
409 
410  # will build pairwise candidates from the gamma:controlKLM list:
411  # vpho -> gamma gamma
412 
413  # the more energetic must be at least 4.5 GeV
414  tag_daughter = "daughterHighest(useCMSFrame(clusterE)) > 4.5"
415  # note that sometimes the probe will also fulfill this criteria, but the
416  # candidate list will *not* be double-counted: these extra candidates need
417  # to be added back offline
418 
419  # apply prescales to the less energetic daughter: compare to the eventwise random number
420  probe_high = f"[daughterLowest(useCMSFrame(clusterE)) > 4.5] and [eventRandom < {prescale_high}]"
421  probe_low = f"[daughterLowest(useCMSFrame(clusterE)) < 4.5] and [eventRandom < {prescale_low}]"
422  prescale = f"[ {probe_high} ] or [ {probe_low} ]"
423 
424  # ~back-to-back in phi in the CMS (3.1066... radians = 178 degrees)
425  delta_phi_cut = "abs(daughterDiffOfPhiCMS(0, 1)) > 3.1066860685499065"
426 
427  # sum theta in the cms 178 --> 182 degrees
428  sum_th = "daughterSumOf(useCMSFrame(theta))"
429  sum_th_cut = f"3.1066860685499065 < {sum_th} < 3.1764992386296798"
430 
431  # now build and return the candidates passing the AND of our cuts
432  cuts = [no_good_tracks, tag_daughter, prescale, delta_phi_cut, sum_th_cut]
433  cuts = " and ".join([f"[ {cut} ]" for cut in cuts])
434 
435  ma.reconstructDecay(
436  "vpho:singlePhotonControlKLM -> gamma:controlKLM gamma:controlKLM",
437  cuts, path=path)
438  self.SkimLists = ["vpho:singlePhotonControlKLM"]
439 
440 
441 @fancy_skim_header
443  """
444  **Physics channel**: :math:`e^{+}e^{-} \\to e^{+}e^{-}`
445 
446  Warning:
447  This skim is currently deactivated, since the retention rate is too high.
448  """
449 
450  __authors__ = "Giacomo De Pietro"
451  __description__ = (
452  "Dielectron skim, needed for :math:`e^{+}e^{-} \\to A^{\\prime} h^{\\prime};`"
453  ":math:`A^{\\prime} \\to e^{+}e^{-}; \\, h^{\\prime} \\to \\mathrm{invisible}` and other searches."
454  )
455  __contact__ = __liaison__
456  __category__ = "physics, dark sector"
457 
458  def load_standard_lists(self, path):
459  stdE("all", path=path)
460 
461  TestFiles = [get_test_file("MC13_mumuBGx1")]
462 
463  def build_lists(self, path):
464  dielectron_list = []
465  skim_label = "forDielectronMissingEnergySkim"
466  dielectron_name = f"Z0:{skim_label}"
467 
468  # Define some basic cuts
469  fromIP_cut = "[abs(dz) < 5.0] and [abs(dr) < 2.0]"
470  electronID_cut = "[electronID > 0.2]"
471  # We require that the electron points to the barrel ECL + 10 degrees
472  theta_cut = "[0.387 < theta < 2.421]"
473  # We want exactly 2 tracks from IP
474  dielectron_cut = f"[nCleanedTracks({fromIP_cut}) == 2]"
475  # And the pair must have pt > 200 MeV in CMS frame
476  dielectron_cut += " and [useCMSFrame(pt) > 0.2]"
477 
478  # Reconstruct the dielectron candidate
479  electron_cuts = " and ".join([fromIP_cut, electronID_cut, theta_cut])
480  ma.cutAndCopyList(f"e+:{skim_label}", "e+:all", electron_cuts, path=path)
481  ma.reconstructDecay(f"{dielectron_name} -> e+:{skim_label} e-:{skim_label}", dielectron_cut, path=path)
482 
483  # And return the dielectron list
484  dielectron_list.append(dielectron_name)
485  self.SkimLists = dielectron_list
486 
487 
488 @fancy_skim_header
490 
491  """
492  Control sample: :math:`e^{+}e^{-} \\to e^{+}e^{-}V^{0};`"
493  """
494 
495  __authors__ = "Savino Longo"
496  __description__ = (
497  "iDM control sample skim. :math:`e^{+}e^{-} \\to e^{+}e^{-}V^{0};`"
498  )
499  __contact__ = __liaison__
500  __category__ = "physics, dark sector"
501 
502  def load_standard_lists(self, path):
503  stdPhotons("all", path=path)
504  stdE("all", path=path)
505 
506  def build_lists(self, path):
507 
508  # require Bhabha tracks are high p and E/p is consitent with e+/e-
509  BhabhaTrackCuts = 'abs(dr)<0.5 and abs(dz)<2 and pt>0.2 and 0.8<clusterEoP<1.2 and p>1.0 and clusterReg==2 and nCDCHits>4'
510  BhabhaSystemCuts = '4<M<10 and 0.5<pRecoilTheta<2.25'
511  V0TrackCuts = 'nCDCHits>4 and p<3.0'
512  V0Cuts = 'dr>0.5'
513  PhotonVetoCuts = 'p>1.0' # event should have no high E photons
514 
515  ma.cutAndCopyList("gamma:HighEGammaVeto", "gamma:all", PhotonVetoCuts, path=path)
516  ma.cutAndCopyList("e+:BhabhaTrack", "e+:all", BhabhaTrackCuts, path=path)
517  ma.cutAndCopyList("e+:V0Track", "e+:all", V0TrackCuts, path=path)
518 
519  ma.reconstructDecay("vpho:BhabhaSysyem -> e+:BhabhaTrack e-:BhabhaTrack", BhabhaSystemCuts, path=path)
520 
521  ma.reconstructDecay("vpho:V0System -> e+:V0Track e-:V0Track", '', path=path)
522  vertex.treeFit('vpho:V0System', conf_level=0.0, path=path)
523  ma.applyCuts('vpho:V0System', V0Cuts, path=path)
524 
525  ma.reconstructDecay('vpho:Total -> vpho:BhabhaSysyem vpho:V0System', '', path=path)
526 
527  eventCuts = ('nParticlesInList(gamma:HighEGammaVeto)<1 and '
528  'nParticlesInList(vpho:Total)>0')
529 
530  path = self.skim_event_cuts(eventCuts, path=path)
531 
532  self.SkimLists = ["vpho:Total"]
533 
534 
535 @fancy_skim_header
537  """
538  Skim list contains events with no tracks from IP, no high E tracks and only one high E photon.
539  """
540  __authors__ = ["Savino Longo"]
541  __contact__ = __liaison__
542  __description__ = "iDM list for the iDM analysis."
543  __category__ = "physics, dark sector"
544 
545  def load_standard_lists(self, path):
546  stdPhotons("all", path=path)
547  stdE("all", path=path)
548 
549  def build_lists(self, path):
550 
551  IPtrack = 'abs(dr) < 0.05' # cm
552  HighEtrack = 'useCMSFrame(p)>3.0' # GeV
553  ma.cutAndCopyList("e+:TrackFromIP", "e+:all", IPtrack, path=path)
554  ma.cutAndCopyList("e+:HighEnergyTrack", "e+:all", HighEtrack, path=path)
555 
556  signalPhoton = "[clusterReg==2 and useCMSFrame(E) > 1.0] or "
557  signalPhoton += "[clusterReg == 1 and useCMSFrame(E) > 2.0] or " # fwd
558  signalPhoton += "[clusterReg == 3 and useCMSFrame(E) > 2.0] or " # bwd
559  signalPhoton += "[clusterReg == 11 and useCMSFrame(E) > 2.0] or " # between fwd and barrel
560  signalPhoton += "[clusterReg == 13 and useCMSFrame(E) > 2.0] " # between bwd and barrel
561 
562  photonVetoHE1 = 'useCMSFrame(p) > 0.6'
563  photonVetoHE3 = 'p>0.5'
564 
565  ma.cutAndCopyList("gamma:ISR", "gamma:all", signalPhoton, path=path)
566  ma.cutAndCopyList("gamma:HighEnergyPhotons", "gamma:all", photonVetoHE1, path=path)
567  ma.cutAndCopyList("gamma:MediumEnergyPhotons", "gamma:all", photonVetoHE3, path=path)
568 
569  idmEventCuts = ('nParticlesInList(gamma:ISR)==1 and '
570  'nParticlesInList(e+:TrackFromIP)==0 and '
571  'nParticlesInList(e+:HighEnergyTrack) == 0 and '
572  'nParticlesInList(gamma:HighEnergyPhotons) == 1 and '
573  'nParticlesInList(gamma:MediumEnergyPhotons) < 4 and '
574  'HighLevelTrigger == 1')
575 
576  path = self.skim_event_cuts(idmEventCuts, path=path)
577 
578  self.SkimLists = ['gamma:ISR']
skim.dark.DielectronPlusMissingEnergy.load_standard_lists
def load_standard_lists(self, path)
Definition: dark.py:458
skim.dark.EGammaControlDark.SkimLists
SkimLists
Definition: dark.py:340
skimExpertFunctions.BaseSkim.skim_event_cuts
def skim_event_cuts(self, cut, *path)
Definition: skimExpertFunctions.py:716
skim.dark.SinglePhotonDark.load_standard_lists
def load_standard_lists(self, path)
Definition: dark.py:40
skim.dark.GammaGammaControlKLMDark.load_standard_lists
def load_standard_lists(self, path)
Definition: dark.py:371
skim.dark.SinglePhotonDark
Definition: dark.py:28
skim.dark.ALP3Gamma
Definition: dark.py:90
skim.dark.ElectronMuonPlusMissingEnergy.build_lists
def build_lists(self, path)
Definition: dark.py:215
skim.dark.ElectronMuonPlusMissingEnergy.load_standard_lists
def load_standard_lists(self, path)
Definition: dark.py:211
skim.dark.InelasticDarkMatter.build_lists
def build_lists(self, path)
Definition: dark.py:549
skim.dark.ALP3Gamma.addALPToPDG
def addALPToPDG(self)
Definition: dark.py:99
pdg.add_particle
def add_particle(name, pdgCode, mass, width, charge, spin, max_width=None, lifetime=0, pythiaID=0)
Definition: pdg.py:121
skim.dark.DimuonPlusMissingEnergy.build_lists
def build_lists(self, path)
Definition: dark.py:178
skim.dark.InelasticDarkMatter.load_standard_lists
def load_standard_lists(self, path)
Definition: dark.py:545
skim.dark.RadBhabhaV0Control.SkimLists
SkimLists
Definition: dark.py:532
skim.dark.GammaGammaControlKLMDark.prescale_low
prescale_low
Definition: dark.py:386
skim.dark.InelasticDarkMatter
Definition: dark.py:536
stdPhotons
Definition: stdPhotons.py:1
skim.dark.GammaGammaControlKLMDark.__init__
def __init__(self, prescale_high=1, prescale_low=1, **kwargs)
Definition: dark.py:376
skim.dark.ALP3Gamma.initialALP
def initialALP(self, path)
Definition: dark.py:104
skim.dark.ALP3Gamma.build_lists
def build_lists(self, path)
Definition: dark.py:142
skim.dark.ElectronMuonPlusMissingEnergy
Definition: dark.py:201
skim.dark.DimuonPlusMissingEnergy.load_standard_lists
def load_standard_lists(self, path)
Definition: dark.py:175
skim.dark.EGammaControlDark
Definition: dark.py:293
skim.dark.GammaGammaControlKLMDark.SkimLists
SkimLists
Definition: dark.py:438
skim.dark.LFVZpVisible.load_standard_lists
def load_standard_lists(self, path)
Definition: dark.py:251
skim.dark.RadBhabhaV0Control.load_standard_lists
def load_standard_lists(self, path)
Definition: dark.py:502
skim.dark.GammaGammaControlKLMDark.prescale_high
prescale_high
Definition: dark.py:385
skim.dark.GammaGammaControlKLMDark.build_lists
def build_lists(self, path)
Definition: dark.py:388
skimExpertFunctions.BaseSkim
Definition: skimExpertFunctions.py:504
skim.dark.InelasticDarkMatter.SkimLists
SkimLists
Definition: dark.py:578
skim.dark.GammaGammaControlKLMDark
Definition: dark.py:344
skim.dark.LFVZpVisible.build_lists
def build_lists(self, path)
Definition: dark.py:255
skim.dark.RadBhabhaV0Control
Definition: dark.py:489
skim.dark.EGammaControlDark.build_lists
def build_lists(self, path)
Definition: dark.py:310
skim.dark.SinglePhotonDark.build_lists
def build_lists(self, path)
Definition: dark.py:43
skim.dark.SinglePhotonDark.SkimLists
SkimLists
Definition: dark.py:86
skim.dark.LFVZpVisible
Definition: dark.py:245
skim.dark.EGammaControlDark.load_standard_lists
def load_standard_lists(self, path)
Definition: dark.py:306
vertex.treeFit
def treeFit(list_name, conf_level=0.001, massConstraint=[], ipConstraint=False, updateAllDaughters=False, customOriginConstraint=False, customOriginVertex=[0.001, 0, 0.0116], customOriginCovariance=[0.0048, 0, 0, 0, 0.003567, 0, 0, 0, 0.0400], path=None)
Definition: vertex.py:191
skim.dark.ALP3Gamma.additional_setup
def additional_setup(self, path)
Definition: dark.py:139
skim.dark.ElectronMuonPlusMissingEnergy.SkimLists
SkimLists
Definition: dark.py:241
skim.dark.DielectronPlusMissingEnergy.build_lists
def build_lists(self, path)
Definition: dark.py:463
skim.dark.ALP3Gamma.SkimLists
SkimLists
Definition: dark.py:159
skim.dark.DimuonPlusMissingEnergy
Definition: dark.py:163
skim.dark.RadBhabhaV0Control.build_lists
def build_lists(self, path)
Definition: dark.py:506
skim.dark.DielectronPlusMissingEnergy.SkimLists
SkimLists
Definition: dark.py:485
skim.dark.LFVZpVisible.SkimLists
SkimLists
Definition: dark.py:289
skim.dark.DielectronPlusMissingEnergy
Definition: dark.py:442
skim.dark.DimuonPlusMissingEnergy.SkimLists
SkimLists
Definition: dark.py:197