Belle II Software  release-05-02-19
charm.py
1 #!/usr/bin/env python3
2 # -*- coding: utf-8 -*-
3 
4 """
5 Skim list building functions for charm analyses.
6 
7 .. Note::
8  The Hp, Hm and Jm in the function name represent arbitrary charged particles with
9  positive or negative charge. The Hp and Jm in `XToD0_D0ToHpJm`, mean a positive particle
10  and a negative particle that could be either conjugate or non-conjugate. The Hp and Hm
11  in `DstToD0Pi_D0ToHpHmPi0`, mean a positive particle and a negative particle that
12  must be conjugate.
13 
14 .. Note::
15  Although reconstructDecay() would automatically include charged conjugate channel, and D0
16  is not distinguishable from anti-D0 in XToD0 skim, both :math:`D^0 \\to f` and :math:`D^0 \\to \\overline{f}`
17  mode should be written explicitly in XToD0 skim, because later in the DstToD0Pi skim, the D0 decay strings
18  in XToD0 skim would be directly combined with pi+. For example, if one only include D0 -> K+ pi- in XToD0_D0ToHpJm
19  skim, then in DstToD0Pi_D0ToHpJm skim, only the D*+ -> [D0 -> K+ pi-] pi+ would be included, and
20  D*+ -> [D0 -> K- pi+] pi+ would not be included.
21 """
22 
23 from functools import lru_cache
24 
25 import modularAnalysis as ma
26 import vertex
27 from skimExpertFunctions import BaseSkim, fancy_skim_header
28 from stdCharged import stdE, stdK, stdMu, stdPi, stdPr
29 from stdPhotons import loadStdSkimPhoton, stdPhotons
30 from stdPi0s import loadStdSkimPi0
31 from stdV0s import stdKshorts
32 from variables import variables as vm
33 
34 
35 __liaison__ = "Guanda Gong <gonggd@mail.ustc.edu.cn>"
36 
37 
38 @fancy_skim_header
40  """
41  Skims :math:`D^0`'s reconstructed by `XToD0_D0ToHpJm.D0ToHpJm`.
42  """
43 
44  __authors__ = ["Giulia Casarosa"]
45  __description__ = "Skim list for D0 to two charged FSPs."
46  __contact__ = __liaison__
47  __category__ = "physics, charm"
48 
49  NoisyModules = ["ParticleLoader", "RootOutput"]
50  ApplyHLTHadronCut = True
51 
52  # Cached static method, so that its contents are only executed once for a single path.
53  # Factored out into a separate function here, so it is available to other skims.
54 
55  @staticmethod
56  @lru_cache()
57  def D0ToHpJm(path):
58  """
59  **Decay Modes**:
60  * :math:`D^{0}\\to \\pi^+ \\pi^-`,
61  * :math:`D^{0}\\to K^+ \\pi^-`,
62  * :math:`D^{0}\\to K^- \\pi^+`,
63  * :math:`D^{0}\\to K^+ K^-`,
64 
65  **Selection Criteria**:
66  * Tracks: ``abs(d0) < 1, abs(z0) < 3, 0.296706 < theta < 2.61799``
67  * ``1.66 < M(D0) < 2.06``
68  * ``pcms(D0) > 2.0``
69  * For more details, please check the source code of this skim.
70 
71  **Parameters**:
72  * path (basf2.Path): Skim path to be processed.
73 
74  **Returns**:
75  * List of D0 particle list names.
76  """
77  mySel = "abs(d0) < 1 and abs(z0) < 3"
78  mySel += " and 0.296706 < theta < 2.61799"
79  ma.fillParticleList("pi+:mygood", mySel, path=path)
80  ma.fillParticleList("K+:mygood", mySel, path=path)
81 
82  charmcuts = "1.66 < M < 2.06 and useCMSFrame(p)>2.0"
83  D0_Channels = [
84  "pi+:mygood pi-:mygood",
85  "K+:mygood pi-:mygood",
86  "K-:mygood pi+:mygood",
87  "K+:mygood K-:mygood",
88  ]
89 
90  D0List = []
91 
92  for chID, channel in enumerate(D0_Channels):
93  ma.reconstructDecay("D0:HpJm" + str(chID) + " -> " + channel, charmcuts, chID, path=path)
94  D0List.append("D0:HpJm" + str(chID))
95 
96  return D0List
97 
98  def build_lists(self, path):
99  """Builds :math:`D^0` skim lists defined in `XToD0_D0ToHpJm.D0ToHpJm`."""
100  self.SkimLists = self.D0ToHpJm(path)
101 
102  def validation_histograms(self, path):
103  # NOTE: the validation package is not part of the light releases, so this import
104  # must be made here rather than at the top of the file.
105  from validation_tools.metadata import create_validation_histograms
106 
107  ma.reconstructDecay('D0:HpJm0_test -> pi+:loose K-:loose', '1.80 < M < 1.93 and useCMSFrame(p) > 2.0', path=path)
108 
109  vm.addAlias('M_D0', 'InvM')
110 
111  histogramFilename = 'D0ToHpJm_Validation.root'
112  myEmail = 'Guanda Gong <gonggd@mail.ustc.edu.cn>'
113 
114  create_validation_histograms(
115  rootfile=histogramFilename,
116  particlelist='D0:HpJm0_test',
117  variables_1d=[
118  ('M_D0', 100, 1.80, 1., 'Mass distribution of $D^{0}$', myEmail,
119  'mass of D0 (mean=1.86483)', 'Please check agreement of: mean, sigma and ratio of signal and background',
120  'M(D^{0}) [GeV/c^{2}]', 'shifter'),
121  ],
122  path=path)
123 
124 
125 @fancy_skim_header
127  """
128  Skims :math:`D^0`'s reconstructed by `XToD0_D0ToNeutrals.D0ToNeutrals`.
129  """
130 
131  __authors__ = ["Giulia Casarosa"]
132  __description__ = "Skim list for D0 to neutral FSPs."
133  __contact__ = __liaison__
134  __category__ = "physics, charm"
135 
136  NoisyModules = ["ParticleLoader", "RootOutput"]
137 
138  def load_standard_lists(self, path):
139  loadStdSkimPi0(path=path)
140  stdKshorts(path=path)
141 
142  # Cached static method, so that its contents are only executed once for a single path
143  # Factored out into a separate function here, so it is available to other skims.
144 
145  @staticmethod
146  @lru_cache()
147  def D0ToNeutrals(path):
148  """
149  **Decay Modes**:
150  * :math:`D^{0}\\to \\pi^{0} \\pi^{0}`
151  * :math:`D^{0}\\to K_{S} \\pi^{0}`
152  * :math:`D^{0}\\to K_{S} K_{S}`
153 
154  **Selection Criteria**:
155  * Use :math:`\\pi^{0}` from `stdPi0s.loadStdSkimPi0`
156  * Use :math:`K_{S}` from `stdV0s.stdKshorts`
157  * ``1.66 < M(D0) < 2.06, pcms(D0) > 2.0``
158  * For more details, please check the source code of this skim.
159  * (Maybe in the future, we can add a loose ECL cluster timing cut
160  to :math:`\\pi^{0}` in this skim.)
161 
162  **Parameters**:
163  * path (basf2.Path): Skim path to be processed.
164 
165  **Returns**:
166  * List of D0 particle list names.
167  """
168  charmcuts = "1.66 < M < 2.06 and useCMSFrame(p)>2.0"
169  D0_Channels = ["pi0:skim pi0:skim",
170  "K_S0:merged pi0:skim",
171  "K_S0:merged K_S0:merged",
172  ]
173 
174  D0List = []
175 
176  for chID, channel in enumerate(D0_Channels):
177  ma.reconstructDecay("D0:2Nbdy" + str(chID) + " -> " + channel, charmcuts, chID, path=path)
178  D0List.append("D0:2Nbdy" + str(chID))
179 
180  return D0List
181 
182  def build_lists(self, path):
183  """Builds :math:`D^0` skim lists defined in `XToD0_D0ToNeutrals.D0ToNeutrals`."""
184  self.SkimLists = self.D0ToNeutrals(path)
185 
186  def validation_histograms(self, path):
187  # NOTE: the validation package is not part of the light releases, so this import
188  # must be made here rather than at the top of the file.
189  from validation_tools.metadata import create_validation_histograms
190 
191  ma.reconstructDecay('D0:2Nbdy_test0 -> pi0:skim pi0:skim', '1.78 < M < 1.94 and useCMSFrame(p) > 2.0', path=path)
192  ma.reconstructDecay('D0:2Nbdy_test1 -> K_S0:merged K_S0:merged', '1.78 < M < 1.94 and useCMSFrame(p) > 2.0', path=path)
193  vm.addAlias('M_D0', 'InvM')
194 
195  histogramFilename = 'D0ToNeutrals_Validation.root'
196  myEmail = 'Guanda Gong <gonggd@mail.ustc.edu.cn>'
197  M_D0_Hist = ('M_D0', 100, 1.80, 1., 'Mass distribution of $D^{0}$', myEmail,
198  'mass of D0 (mean=1.86483)', 'Please check agreement of: mean, sigma and ratio of signal and background',
199  'M(D^{0}) [GeV/c^{2}]', 'shifter')
200 
201  create_validation_histograms(rootfile=histogramFilename, particlelist='D0:2Nbdy_test0', variables_1d=[M_D0_Hist, ],
202  path=path)
203 
204  create_validation_histograms(rootfile=histogramFilename, particlelist='D0:2Nbdy_test1', variables_1d=[M_D0_Hist, ],
205  path=path)
206 
207 
208 @fancy_skim_header
210  """
211  **Decay Modes**:
212  * :math:`D^{*+}\\to \\pi^+ D^{0}, D^{0}\\to \\gamma \\gamma`,
213  * :math:`D^{*+}\\to \\pi^+ D^{0}, D^{0}\\to ee`,
214  * :math:`D^{*+}\\to \\pi^+ D^{0}, D^{0}\\to e^+ \\mu^-`,
215  * :math:`D^{*+}\\to \\pi^+ D^{0}, D^{0}\\to e^- \\mu^+`,
216  * :math:`D^{*+}\\to \\pi^+ D^{0}, D^{0}\\to \\mu \\mu`,
217  * :math:`D^{*+}\\to \\pi^+ D^{0}, D^{0}\\to \\pi^+ \\pi^-`,
218 
219  **Selection Criteria**:
220  * Use photons from `stdPhotons.loadStdSkimPhoton`
221  * Use electrons, muons and pions from loose lists in `stdCharged`
222  * ``1.66 < M(D0) < 2.06``
223  * No cut on the slow pion
224  * ``0 < Q < 0.02``
225  * ``pcms(D*) > 2.0``
226  * For more details, please check the source code of this skim.
227 
228  """
229 
230  __authors__ = ["Doris Yangsoo Kim", "Jaeyeon Kim"]
231  __description__ = "Skim list for D*+ to pi+ D0, D0 to rare decay."
232  __contact__ = __liaison__
233  __category__ = "physics, charm"
234 
235  NoisyModules = ["ParticleLoader", "RootOutput"]
236 
237  def load_standard_lists(self, path):
238  stdE("loose", path=path)
239  stdMu("loose", path=path)
240  stdPi("loose", path=path)
241  loadStdSkimPhoton(path=path)
242  loadStdSkimPi0(path=path)
243 
244  def build_lists(self, path):
245  charmcuts = "1.66 < M < 2.06"
246  Dstcuts = "0 < Q < 0.02 and 2.0 < useCMSFrame(p)"
247 
248  D0_Channels = ["gamma:skim gamma:skim",
249  "e+:loose e-:loose",
250  "e+:loose mu-:loose",
251  "e-:loose mu+:loose",
252  "mu+:loose mu-:loose",
253  "pi+:loose pi-:loose"]
254  DstList = []
255 
256  for chID, channel in enumerate(D0_Channels):
257  ma.reconstructDecay("D0:Rare" + str(chID) + " -> " + channel, charmcuts, chID, path=path)
258  ma.reconstructDecay("D*+:" + str(chID) + " -> pi+:all D0:Rare" + str(chID),
259  Dstcuts, chID, path=path)
260  DstList.append("D*+:" + str(chID))
261 
262  self.SkimLists = DstList
263 
264  def validation_histograms(self, path):
265  # NOTE: the validation package is not part of the light releases, so this import
266  # must be made here rather than at the top of the file.
267  from validation_tools.metadata import create_validation_histograms
268  self.build_lists(path)
269  vm.addAlias('M_D0', 'daughter(1, InvM)')
270 
271  histogramFilename = 'D0ToNeutrals_Validation.root'
272  myEmail = 'Guanda Gong <gonggd@mail.ustc.edu.cn>'
273  M_D0_Hist = ('M_D0', 100, 1.80, 1., 'Mass distribution of $D^{0}$', myEmail,
274  'mass of D0 (mean=1.86483)', 'Please check agreement of: mean, sigma and ratio of signal and background',
275  'M(D^{0}) [GeV/c^{2}]', 'shifter')
276 
277  create_validation_histograms(rootfile=histogramFilename, particlelist='D0:Rare0', variables_1d=[M_D0_Hist, ],
278  path=path)
279 
280  create_validation_histograms(rootfile=histogramFilename, particlelist='D0:Rare1', variables_1d=[M_D0_Hist, ],
281  path=path)
282 
283  create_validation_histograms(rootfile=histogramFilename, particlelist='D0:Rare4', variables_1d=[M_D0_Hist, ],
284  path=path)
285 
286 
287 @fancy_skim_header
289  """
290  **Decay Modes**:
291  * :math:`D^+_{(S)} \\to K_{S} \\pi^+`,
292  * :math:`D^+_{(S)} \\to K_{S} K^+`,
293 
294  **Selection Criteria**:
295  * Tracks not from :math:`K_{S}`: ``abs(d0) < 1, abs(z0) < 3,
296  0.296706 < theta < 2.61799``
297  * Use :math:`K_{S}` from `stdV0s.stdKshorts` and require
298  ``flightDistance/flightDistanceErr > 2``
299  * ``1.67 < M(D+) < 2.17, pcms(D+) > 2.0``
300  * For more details, please check the source code of this skim.
301 
302  """
303 
304  __authors__ = ["Guanda Gong"]
305  __description__ = "Skim list for D_(s)+ to Ks h+."
306  __contact__ = __liaison__
307  __category__ = "physics, charm"
308 
309  NoisyModules = ["ParticleLoader", "RootOutput"]
310  ApplyHLTHadronCut = True
311 
312  def load_standard_lists(self, path):
313  stdK("all", path=path)
314  stdPi("all", path=path)
315  stdKshorts(path=path)
316 
317  def build_lists(self, path):
318  mySel = "abs(d0) < 1 and abs(z0) < 3"
319  mySel += " and 0.296706 < theta < 2.61799"
320  ma.fillParticleList("pi+:kshp", mySel, path=path)
321  ma.fillParticleList("K+:kshp", mySel, path=path)
322  ma.cutAndCopyList('K_S0:kshp', 'K_S0:merged', 'formula(flightDistance/flightDistanceErr) > 2', path=path)
323 
324  Dpcuts = "1.67 < M < 2.17 and useCMSFrame(p) > 2.0"
325  Dp_Channels = ["K_S0:kshp pi+:kshp",
326  "K_S0:kshp K+:kshp",
327  ]
328 
329  DpList = []
330  for chID, channel in enumerate(Dp_Channels):
331  ma.reconstructDecay("D+:KsHp" + str(chID) + " -> " + channel, Dpcuts, chID, path=path)
332  DpList.append("D+:KsHp" + str(chID))
333 
334  self.SkimLists = DpList
335 
336  def validation_histograms(self, path):
337  # NOTE: the validation package is not part of the light releases, so this import
338  # must be made here rather than at the top of the file.
339  from validation_tools.metadata import create_validation_histograms
340  self.build_lists(path)
341  vm.addAlias('M_Dp', 'InvM')
342 
343  histogramFilename = 'DpToKsHp_Validation.root'
344  myEmail = 'Guanda Gong <gonggd@mail.ustc.edu.cn>'
345  M_Dp_Hist = (
346  'M_Dp',
347  100,
348  1.72,
349  2.2,
350  'Mass distribution of $D_{(S)}^{+}$',
351  myEmail,
352  'mass of D+ (mean=1.86958) and D_s+(mean=1.96827)',
353  'Please check agreement of: mean, sigma and ratio of signal and background',
354  'M(D_{(S)}^{+}) [GeV/c^{2}]',
355  'shifter')
356 
357  create_validation_histograms(rootfile=histogramFilename, particlelist='D+:kshp0', variables_1d=[M_Dp_Hist, ],
358  path=path)
359 
360  create_validation_histograms(rootfile=histogramFilename, particlelist='D+:kshp1', variables_1d=[M_Dp_Hist, ],
361  path=path)
362 
363 
364 @fancy_skim_header
366  """
367  **Decay Modes**:
368  * :math:`D^+_{(S)} \\to \\pi^+ \\pi^- \\pi^+`,
369  * :math:`D^+_{(S)} \\to \\pi^+ \\pi^- K^+`,
370  * :math:`D^+_{(S)} \\to \\pi^+ K^- K^+`,
371  * :math:`D^+_{(S)} \\to K^+ K^- K^+`,
372  * For :math:`D^+_{(S)} \\to K_{S} h^+`, which includes a :math:`K_{S}` vertex,
373  please check `XToDp_DpToKsHp`
374 
375  **Selection Criteria**:
376  * Use tracks from the loose lists in `stdCharged`
377  * ``1.67 < M(D+) < 2.17, pcms(D+) > 2.0``
378  * For more details, please check the source code of this skim.
379 
380  """
381 
382  __authors__ = ["Aman Sangal"]
383  __description__ = "Skim list for D_(s)+ to h+ h- j+."
384  __contact__ = __liaison__
385  __category__ = "physics, charm"
386 
387  NoisyModules = ["ParticleLoader", "RootOutput"]
388  ApplyHLTHadronCut = True
389 
390  def load_standard_lists(self, path):
391  stdK("loose", path=path)
392  stdPi("loose", path=path)
393 
394  def build_lists(self, path):
395  Dpcuts = "1.67 < M < 2.17 and useCMSFrame(p) > 2.0"
396 
397  Dp_Channels = ["pi+:loose pi-:loose pi+:loose",
398  "pi+:loose pi-:loose K+:loose",
399  "pi+:loose K-:loose K+:loose",
400  "K+:loose K-:loose pi+:loose",
401  ]
402 
403  DpList = []
404  for chID, channel in enumerate(Dp_Channels):
405  ma.reconstructDecay("D+:HpHmJp" + str(chID) + " -> " + channel, Dpcuts, chID, path=path)
406  DpList.append("D+:HpHmJp" + str(chID))
407 
408  self.SkimLists = DpList
409 
410  def validation_histograms(self, path):
411  # NOTE: the validation package is not part of the light releases, so this import
412  # must be made here rather than at the top of the file.
413  from validation_tools.metadata import create_validation_histograms
414  self.build_lists(path)
415  vm.addAlias('M_Dp', 'InvM')
416 
417  histogramFilename = 'DpToHpHmJp_Validation.root'
418  myEmail = 'Guanda Gong <gonggd@mail.ustc.edu.cn>'
419  M_Dp_Hist = (
420  'M_Dp',
421  100,
422  1.72,
423  2.2,
424  'Mass distribution of $D_{(S)}^{+}$',
425  myEmail,
426  'mass of D+ (mean=1.86958) and D_s+(mean=1.96827)',
427  'Please check agreement of: mean, sigma and ratio of signal and background',
428  'M(D_{(S)}^{+}) [GeV/c^{2}]',
429  'shifter')
430 
431  create_validation_histograms(rootfile=histogramFilename, particlelist='D+:HpHmJp0', variables_1d=[M_Dp_Hist, ],
432  path=path)
433 
434  create_validation_histograms(rootfile=histogramFilename, particlelist='D+:HpHmJp3', variables_1d=[M_Dp_Hist, ],
435  path=path)
436 
437 
438 @fancy_skim_header
440  """
441  **Decay Modes**:
442  * :math:`\\Lambda_c^+ \\to p \\pi^- \\pi^+`
443  * :math:`\\Lambda_c^+ \\to p K^- \\pi^+`
444  * :math:`\\Lambda_c^+ \\to p \\pi^- K^+`
445  * :math:`\\Lambda_c^+ \\to p K^- K^+`
446 
447  **Selection Criteria**:
448  * Use tracks from the loose lists in `stdCharged`
449  * ``2.2 < M(Lambda_c) < 2.4, pcms(Lambda_c) > 2.0``
450  * For more details, please check the source code of this skim.
451 
452  """
453 
454  __authors__ = ["Justin Guilliams"]
455  __description__ = "Skim list for Lambda_c+ -> p K- pi+."
456  __contact__ = __liaison__
457  __category__ = "physics, charm"
458 
459  NoisyModules = ["ParticleLoader", "RootOutput"]
460  ApplyHLTHadronCut = True
461 
462  def load_standard_lists(self, path):
463  stdK("all", path=path)
464  stdPi("all", path=path)
465  stdPr("loose", path=path)
466 
467  def build_lists(self, path):
468 
469  LambdacCuts = "2.2 < M < 2.4 and useCMSFrame(p) > 2.0"
470  LambdacChannels = ["p+:loose pi-:all pi+:all",
471  "p+:loose K-:all pi+:all",
472  "p+:loose pi-:all K+:all",
473  "p+:loose K-:all K+:all",
474  ]
475 
476  LambdacList = []
477  for chID, channel in enumerate(LambdacChannels):
478  ma.reconstructDecay("Lambda_c+:pHpJm" + str(chID) + " -> " + channel, LambdacCuts, chID, path=path)
479  LambdacList.append("Lambda_c+:pHpJm" + str(chID))
480 
481  self.SkimLists = LambdacList
482 
483  def validation_histograms(self, path):
484  # NOTE: the validation package is not part of the light releases, so this import
485  # must be made here rather than at the top of the file.
486  from validation_tools.metadata import create_validation_histograms
487  self.build_lists(path)
488  vm.addAlias('M_Lambdac', 'InvM')
489 
490  histogramFilename = 'DpToHpHmJp_Validation.root'
491  myEmail = 'Guanda Gong <gonggd@mail.ustc.edu.cn>'
492  M_Dp_Hist = (
493  'M_Lambdac',
494  100,
495  2.2,
496  2.4,
497  r'Mass distribution of $\Lambda_{C}^{+}$',
498  myEmail,
499  'mass of Lambda_c+ (mean=2.28646) ',
500  'Please check agreement of: mean, sigma and ratio of signal and background',
501  '#Lambda_{C}^{+} [GeV/c^{2}]',
502  'shifter')
503 
504  create_validation_histograms(rootfile=histogramFilename, particlelist='D+:HpHmJp0', variables_1d=[M_Dp_Hist, ],
505  path=path)
506 
507  create_validation_histograms(rootfile=histogramFilename, particlelist='D+:HpHmJp3', variables_1d=[M_Dp_Hist, ],
508  path=path)
509 
510 
511 @fancy_skim_header
513  """
514  **Decay Modes**:
515  * :math:`D^{*+}\\to \\pi^{0} D^{+}, D^+ \\to \\pi^+ \\pi^0`
516 
517  **Selection Criteria**:
518  * Tracks: ``abs(d0) < 1, abs(z0) < 3, 0.296706 < theta < 2.61799``
519  * Use :math:`\\pi^{0}` from `stdPi0s.loadStdSkimPi0`
520  * ``1.67 < M(D+) < 2.07, pcms(D+) > 2.0``
521  * ``0 < Q < 0.018``
522  * For more details, please check the source code of this skim.
523 
524  """
525 
526  __authors__ = ["Johannes Brand"]
527  __description__ = "Skim list for D*+ to D+ pi0, D+ to h+ pi0."
528  __contact__ = __liaison__
529  __category__ = "physics, charm"
530 
531  NoisyModules = ["ParticleLoader", "RootOutput"]
532 
533  def load_standard_lists(self, path):
534  stdPi("all", path=path)
535  loadStdSkimPi0(path=path)
536 
537  def build_lists(self, path):
538  mySel = "abs(d0) < 1 and abs(z0) < 3"
539  mySel += " and 0.296706 < theta < 2.61799"
540  ma.fillParticleList("pi+:hppi0", mySel, path=path)
541 
542  Dpcuts = "1.67 < M < 2.07 and useCMSFrame(p) > 2.0"
543  Dp_Channels = ["pi+:hppi0 pi0:skim",
544  ]
545 
546  DstList = []
547  for chID, channel in enumerate(Dp_Channels):
548  ma.reconstructDecay("D+:HpPi0" + str(chID) + " -> " + channel, Dpcuts, chID, path=path)
549  ma.reconstructDecay("D*+:HpPi0" + str(chID) + " -> D+:HpPi0" + str(chID) + " pi0:skim", "0 < Q < 0.018", path=path)
550  DstList.append("D*+:HpPi0" + str(chID))
551 
552  self.SkimLists = DstList
553 
554 
555 @fancy_skim_header
557  """
558  **Decay Modes**:
559  * :math:`D^{*+}\\to D^{0} \\pi^+`, where :math:`D^{0}` is reconstructed by `XToD0_D0ToHpJm.D0ToHpJm`
560 
561  **Selection Criteria**:
562  * Apply the cuts in `XToD0_D0ToHpJm`
563  * No cut on the slow pion
564  * ``0 < Q < 0.018``
565  * For more details, please check the source code of this skim.
566 
567  """
568 
569  __authors__ = "Giulia Casarosa"
570  __description__ = "Same as `XToD0_D0ToHpJm`, but requiring the D0 is from D*+ -> D0 pi+ process."
571  __contact__ = __liaison__
572  __category__ = "physics, charm"
573 
574  NoisyModules = ["ParticleLoader", "RootOutput"]
575  ApplyHLTHadronCut = True
576 
577  def load_standard_lists(self, path):
578  stdK("all", path=path)
579  stdPi("all", path=path)
580 
581  def build_lists(self, path):
582  D0List = self.D0ToHpJm(path)
583 
584  Dstcuts = '0 < Q < 0.018'
585 
586  DstList = []
587  for chID, channel in enumerate(D0List):
588  ma.reconstructDecay('D*+:HpJm' + str(chID) + ' -> D0:HpJm' + str(chID) + ' pi+:all', Dstcuts, chID, path=path)
589  DstList.append('D*+:HpJm' + str(chID))
590 
591  self.SkimLists = DstList
592 
593  def validation_histograms(self, path):
594  # NOTE: the validation package is not part of the light releases, so this import
595  # must be made here rather than at the top of the file.
596  from validation_tools.metadata import create_validation_histograms
597 
598  ma.reconstructDecay('D0:HpJm0_test -> pi+:loose K-:loose', '1.80 < M < 1.93 and useCMSFrame(p) > 2.0', path=path)
599  ma.reconstructDecay('D*+:HpJm0_test -> D0:HpJm0_test pi+:loose', '0 < Q < 0.018', path=path)
600 
601  vm.addAlias('M_D0', 'daughter(0,InvM)')
602  vm.addAlias('Pcms_D0', 'daughter(0,useCMSFrame(p))')
603  vm.addAlias('d0_spi', 'daughter(1,d0)')
604  vm.addAlias('z0_spi', 'daughter(1,z0)')
605  vm.addAlias('dr_spi', 'daughter(1,dr)')
606  vm.addAlias('dz_spi', 'daughter(1,dz)')
607  vm.addAlias('Pcms_spi', 'daughter(1,useCMSFrame(p))')
608  vm.addAlias('Pcms_Dst', 'useCMSFrame(p)')
609 
610  histogramFilename = 'DstToD0Pi_D0ToHpJm_Validation.root'
611  myEmail = 'Guanda Gong <gonggd@mail.ustc.edu.cn>'
612 
613  create_validation_histograms(
614  rootfile=histogramFilename,
615  particlelist='D*+:HpJm0_test',
616  variables_1d=[
617  ('M_D0', 100, 1.80, 1., 'Mass distribution of $D^{0}$', myEmail,
618  'mass of D0 (mean=1.86483)', 'Please check agreement of: mean, sigma and ratio of signal and background',
619  'M(D^{0}) [GeV/c^{2}]', 'shifter'),
620  ('Pcms_D0', 100, 2, 6, 'momentum of $D_{0}$ in CMS Frame', myEmail,
621  'CMS momentum of D0', 'Please check agreement of lineshape',
622  '$P_{cms}(D^{0}) [GeV/c^{2}]', 'shifter'),
623  ('d0_spi', 100, -1.2, 1.2, 'd0 of slow pi', myEmail,
624  'd0 of slow pion', 'provided for the SVD and PXD group',
625  'd0_spi [cm]', 'shifter'),
626  ('z0_spi', 100, -3.3, 3.3, 'z0 of slow pi', myEmail,
627  'z0 of slow pion', 'provided for the SVD and PXD group',
628  'z0_spi [cm]', 'shifter'),
629  ('dr_spi', 100, -1.2, 1.2, 'dr of slow pi', myEmail,
630  'dr of slow pion', 'provided for the SVD and PXD group',
631  'dr_spi [cm]', 'shifter'),
632  ('dz_spi', 100, -3.3, 3.3, 'dz of slow pi', myEmail,
633  'dz of slow pion', 'provided for the SVD and PXD group',
634  'dz_spi [cm]', 'shifter'),
635  ('Pcms_spi', 100, 0, 0.8, 'momentum of slow pi in CMS Frame', myEmail,
636  'CMS momentum of slow pion', 'Please check agreement of lineshape',
637  'P_{cms}(#pi_{s}) [GeV/c]', 'shifter'),
638  ('Pcms_Dst', 100, 2, 6, 'momentum of $D_{*}$ in CMS Frame', myEmail,
639  'CMS momentum of slow pion', 'Please check agreement of lineshape',
640  'P_{cms}(D*) {GeV/c}', 'shifter'),
641  ('Q', 100, 0, 0.018, 'Released energy in $D^{*}$ decay', myEmail,
642  'Q = M(D0 pi) - M(D0) - M(pi), and it peaks around 0.006 GeV',
643  'Please check agreement of: mean, sigma and ratio of signal and background',
644  'Q [GeV]', 'shifter'),
645  ],
646  path=path)
647 
648 
649 @fancy_skim_header
651  """
652  **Decay Modes**:
653  * :math:`RS: D^{*+}\\to \\pi^+ D^{0}, D^{0}\\to K^- \\pi^+ \\pi^{0}`
654  * :math:`WS: D^{*-}\\to \\pi^- \\overline{D}^{0}, \\overline{D}^{0}\\to K^- \\pi^+ \\pi^{0}`
655 
656  **Selection Criteria**:
657  * Use tracks from the loose lists in `stdCharged` to reconstruct :math:`D^{0}`
658  * Use :math:`\\pi^{0}` from `stdPi0s.loadStdSkimPi0`
659  * ``1.70 < M(D0) < 2.10``
660  * No cut on the slow pion
661  * ``M(D*)-M(D0) < 0.16``
662  * ``pcms(D*) > 2.0``
663  * For more details, please check the source code of this skim.
664 
665  """
666 
667  __authors__ = ["Emma Oxford"]
668  __description__ = (
669  "Skim list for D*+ to pi+ D0, D0 to pi0 and two charged FSPs, where the kinds "
670  "of two charged FSPs are different. The wrong sign(WS) mode, D*- to pi- D0, is "
671  "also included."
672  )
673  __contact__ = __liaison__
674  __category__ = "physics, charm"
675 
676  NoisyModules = ["ParticleLoader", "RootOutput"]
677  ApplyHLTHadronCut = True
678 
679  def load_standard_lists(self, path):
680  stdK("loose", path=path)
681  stdPi("loose", path=path)
682  loadStdSkimPi0(path=path)
683 
684  def build_lists(self, path):
685  Dstcuts = "massDifference(0) < 0.160 and useCMSFrame(p) > 2.0"
686  charmcuts = "1.70 < M < 2.10"
687  ma.cutAndCopyList("pi0:myskim", "pi0:skim", "", path=path) # additional cuts removed 27 Jun 2019 by Emma Oxford
688 
689  DstList = []
690  # NOTE: renamed to avoid particle list name clashes
691  ma.reconstructDecay("D0:HpJmPi0_withPID -> K-:loose pi+:loose pi0:myskim", charmcuts, path=path)
692  ma.reconstructDecay("D*+:HpJmPi0RS_withPID -> D0:HpJmPi0_withPID pi+:all", Dstcuts, path=path)
693  ma.reconstructDecay("D*-:HpJmPi0WS_withPID -> D0:HpJmPi0_withPID pi-:all", Dstcuts, path=path)
694  ma.copyLists("D*+:HpJmPi0_withPID", ["D*+:HpJmPi0RS_withPID", "D*+:HpJmPi0WS_withPID"], path=path)
695  DstList.append("D*+:HpJmPi0_withPID")
696 
697  self.SkimLists = DstList
698 
699 
700 @fancy_skim_header
702  """
703  **Decay Modes**:
704  * :math:`D^{*+}\\to \\pi^+ D^{0}, D^{0}\\to \\pi^+ \\pi^- \\pi^{0}`
705  * :math:`D^{*+}\\to \\pi^+ D^{0}, D^{0}\\to K^+ K^- \\pi^{0}`
706 
707  **Selection Criteria**:
708  * Use tracks from the loose lists in `stdCharged` to reconstruct D^{0}
709  * Use :math:`\\pi^{0}` from `stdPi0s.loadStdSkimPi0`
710  * ``1.70 < M(D0) < 2.10``
711  * No cut on the slow pion
712  * ``M(D*)-M(D0) < 0.16``
713  * ``pcms(D*) > 2.0``
714  * For more details, please check the source code of this skim.
715 
716  """
717 
718  __authors__ = ["Emma Oxford"]
719  __description__ = "Skim list for D*+ to pi+ D0, D0 to pi0 and two conjugate charged FSPs."
720  __contact__ = __liaison__
721  __category__ = "physics, charm"
722 
723  NoisyModules = ["ParticleLoader", "RootOutput"]
724  ApplyHLTHadronCut = True
725 
726  def load_standard_lists(self, path):
727  stdK("loose", path=path)
728  stdPi("loose", path=path)
729  loadStdSkimPhoton(path=path)
730  loadStdSkimPi0(path=path)
731 
732  def build_lists(self, path):
733  Dstcuts = "massDifference(0) < 0.160 and useCMSFrame(p) > 2.0"
734  charmcuts = "1.70 < M < 2.10"
735  ma.cutAndCopyList("pi0:myskim", "pi0:skim", "", path=path) # additional cuts removed 27 Jun 2019 by Emma Oxford
736  D0_Channels = [
737  "pi+:loose pi-:loose pi0:myskim",
738  "K+:loose K-:loose pi0:myskim",
739  ]
740 
741  DstList = []
742 
743  for chID, channel in enumerate(D0_Channels):
744  # NOTE: renamed to avoid particle list name clashes
745  ma.reconstructDecay("D0:HpHmPi0" + str(chID) + "_withPID" + " -> " + channel, charmcuts, chID, path=path)
746  ma.reconstructDecay(
747  "D*+:HpHmPi0" + str(chID) + "_withPID" + " -> D0:HpHmPi0" + str(chID) + "_withPID" + " pi+:all",
748  Dstcuts, chID, path=path)
749  DstList.append("D*+:HpHmPi0" + str(chID) + "_withPID")
750 
751  self.SkimLists = DstList
752 
753 
754 @fancy_skim_header
756  """
757  **Decay Modes**:
758  * :math:`D^{*+}\\to \\pi^+ D^{0}, D^{0}\\to K_{S} \\pi^+ \\pi^- \\pi^{0}`
759 
760  **Selection Criteria**:
761  * Tracks from :math:`D^{0}`:
762  ``abs(d0) < 1, abs(z0) < 3, 0.296706 < theta < 2.61799``
763  * Use :math:`\\pi^{0}` from `stdPi0s.loadStdSkimPi0`, then require ``0.11 < M(pi0) < 0.15, p(pi0) > 0.25``
764  * ``1.66 < M(D0) < 2.06, pcms(D0) > 2.0``
765  * ``Q < 0.018``
766  * For more details, please check the source code of this skim.
767 
768  """
769 
770  __authors__ = []
771  __description__ = "Skim list for D*+ to pi+ D0, D0 to Ks pi+ pi- pi0."
772  __contact__ = __liaison__
773  __category__ = "physics, charm"
774 
775  NoisyModules = ["ParticleLoader", "RootOutput"]
776  ApplyHLTHadronCut = True
777 
778  def load_standard_lists(self, path):
779  stdPi("all", path=path)
780  loadStdSkimPi0(path=path)
781  stdKshorts(path=path)
782 
783  def build_lists(self, path):
784  mySel = "abs(d0) < 1 and abs(z0) < 3"
785  mySel += " and 0.296706 < theta < 2.61799"
786  ma.fillParticleList("pi+:ksomega", mySel, path=path)
787 
788  ma.cutAndCopyList("pi0:mypi0", "pi0:skim", "0.11 < M < 0.15 and p > 0.25 ", path=path)
789  ma.reconstructDecay("omega:3pi -> pi+:ksomega pi-:ksomega pi0:mypi0", "", path=path)
790 
791  charmcuts = "1.66 < M < 2.06 and useCMSFrame(p) > 2.0"
792  ma.reconstructDecay("D0:KsOmega -> K_S0:merged omega:3pi", charmcuts, path=path)
793 
794  DstList = []
795  ma.reconstructDecay("D*+:KsOmega -> D0:KsOmega pi+:all", "0 < Q < 0.018", path=path)
796  DstList.append("D*+:KsOmega")
797 
798  self.SkimLists = DstList
799 
800 
801 @fancy_skim_header
803  """
804  **Decay Modes**:
805  * :math:`D^{*+}\\to \\pi^+ D^{0}, D^{0}\\to \\pi^+ \\pi^- \\pi^+ \\pi^-`
806  * :math:`D^{*+}\\to \\pi^+ D^{0}, D^{0}\\to \\pi^+ \\pi^- \\pi^+ K^-`
807  * :math:`D^{*+}\\to \\pi^+ D^{0}, D^{0}\\to \\pi^+ \\pi^- K^+ K^-`
808  * :math:`D^{*+}\\to \\pi^+ D^{0}, D^{0}\\to \\pi^+ K^- K^+ K^-`
809 
810  **Selection Criteria**:
811  * Tracks from :math:`D^{0}`:
812  ``abs(d0) < 1, abs(z0) < 3, 0.296706 < theta < 2.61799``
813  * ``1.66 < M(D0) < 2.06``
814  * No cut on the slow pion
815  * ``Q < 0.022, pcms(D*+) > 2.0``
816  * For more details, please check the source code of this skim.
817 
818  """
819 
820  __authors__ = ["Kavita Lalwani, Chanchal Sharma"]
821  __description__ = "Skim list for D*+ to K- pi+ pi- pi+."
822  __contact__ = __liaison__
823  __category__ = "physics, charm"
824 
825  NoisyModules = ["ParticleLoader", "RootOutput"]
826  ApplyHLTHadronCut = True
827 
828  def load_standard_lists(self, path):
829  stdPi("all", path=path)
830  stdK("all", path=path)
831 
832  def build_lists(self, path):
833  mySel = "abs(d0) < 1 and abs(z0) < 3"
834  mySel += " and 0.296706 < theta < 2.61799"
835  ma.fillParticleList("pi+:hphmhpjm", mySel, path=path)
836  ma.fillParticleList("K+:hphmhpjm", mySel, path=path)
837 
838  D0_Channels = [
839  "pi+:hphmhpjm pi-:hphmhpjm pi+:hphmhpjm pi-:hphmhpjm",
840  "pi+:hphmhpjm pi-:hphmhpjm pi+:hphmhpjm K-:hphmhpjm",
841  "pi+:hphmhpjm pi-:hphmhpjm K+:hphmhpjm K-:hphmhpjm",
842  "pi+:hphmhpjm K-:hphmhpjm K+:hphmhpjm K-:hphmhpjm",
843  ]
844 
845  D0cuts = "1.66 < M < 2.06"
846  Dstcuts = "0 < Q < 0.022 and useCMSFrame(p) > 2.0"
847 
848  DstList = []
849  for chID, channel in enumerate(D0_Channels):
850  ma.reconstructDecay("D0:HpHmHpJm" + str(chID) + " -> " + channel, D0cuts, chID, path=path)
851 
852  ma.reconstructDecay("D*+:HpHmHpJm" + str(chID) + " -> pi+:all D0:HpHmHpJm" + str(chID), Dstcuts, chID, path=path)
853  DstList.append("D*+:HpHmHpJm" + str(chID))
854 
855  self.SkimLists = DstList
856 
857 
858 @fancy_skim_header
860  """
861  **Decay Modes**:
862  * :math:`D^{*+}\\to \\pi^- D^{0}, D^{0}\\to \\pi^+ \\pi^- \\eta, \\eta\\to \\gamma \\gamma`
863  * :math:`RS: D^{*+}\\to \\pi^+ D^{0}, D^{0}\\to K^- \\pi^+ \\eta, \\eta\\to \\gamma \\gamma`
864  * :math:`WS: D^{*+}\\to \\pi^+ D^{0}, D^{0}\\to K^+ \\pi^- \\eta, \\eta\\to \\gamma \\gamma`
865  * :math:`D^{*+}\\to \\pi^- D^{0}, D^{0}\\to K^+ K^- \\eta, \\eta\\to \\gamma \\gamma`
866 
867  **Selection Criteria**:
868  * Use tracks from the loose lists in `stdCharged` to reconstruct D^{0}
869  * ``0.47 < M(eta) < 0.60, p(eta) > 0.24``
870  * ``1.66 < M(D0) < 2.06, pcms(D0) > 2.0``
871  * No cut on the slow pion
872  * ``M(D*)-M(D0) < 0.16``
873  * For more details, please check the source code of this skim.
874 
875  """
876 
877  __authors__ = []
878  __description__ = (
879  "Skim list for D*+ to pi+ D0, D0 to eta and two charged FSPs, where the kinds "
880  "of two charged FSPs are different. The wrong sign(WS) mode, D*- to pi- D0, is "
881  "also included."
882  )
883  __contact__ = __liaison__
884  __category__ = "physics, charm"
885 
886  NoisyModules = ["ParticleLoader", "RootOutput"]
887  ApplyHLTHadronCut = True
888 
889  def load_standard_lists(self, path):
890  stdK("loose", path=path)
891  stdPi("loose", path=path)
892  loadStdSkimPhoton(path=path)
893  stdKshorts(path=path)
894 
895  def build_lists(self, path):
896  Dstcuts = "massDifference(0) < 0.160 and useCMSFrame(p) > 2.0"
897  charmcuts = "1.66 < M < 2.06"
898  ma.reconstructDecay("eta:myskim -> gamma:loose gamma:loose", "0.47 < M < 0.60 and p > 0.24", path=path)
899  D0_Channels = [
900  "pi-:loose pi+:loose eta:myskim",
901  "K-:loose pi+:loose eta:myskim",
902  "pi-:loose K+:loose eta:myskim",
903  "K-:loose K+:loose eta:myskim",
904  ]
905 
906  DstList = []
907 
908  for chID, channel in enumerate(D0_Channels):
909  # NOTE: renamed to avoid particle list name clashes
910  ma.reconstructDecay("D0:HpJmEta" + str(chID) + " -> " + channel, charmcuts, chID, path=path)
911  ma.reconstructDecay(
912  "D*+:HpJmEta" + str(chID) + " -> D0:HpJmEta" + str(chID) + " pi+:all",
913  Dstcuts, chID, path=path)
914  DstList.append("D*+:HpJmEta" + str(chID))
915 
916  self.SkimLists = DstList
917 
918 
919 @fancy_skim_header
921  """
922  **Decay Modes**:
923  * :math:`D^{*+}\\to \\pi^+ D^{0}`, where the :math:`D^{0}` is reconstructed
924  by `XToD0_D0ToNeutrals.D0ToNeutrals`.
925 
926  **Selection Criteria**:
927  * Apply the cuts in `XToD0_D0ToNeutrals`
928  * No cut on the slow pion
929  * ``Q < 0.02``
930  * For more details, please check the source code of this skim.
931 
932  """
933 
934  __authors__ = ["Giulia Casarosa", "Emma Oxford"]
935  __description__ = "Same as `XToD0_D0ToNeutrals`, but requiring that the D0 is from D* decay."
936  __contact__ = __liaison__
937  __category__ = "physics, charm"
938 
939  NoisyModules = ["ParticleLoader", "RootOutput"]
940 
941  def load_standard_lists(self, path):
942  stdPi("all", path=path)
943  loadStdSkimPi0(path=path)
944  stdKshorts(path=path)
945 
946  def build_lists(self, path):
947 
948  D0List = self.D0ToNeutrals(path)
949 
950  Dstcuts = "0 < Q < 0.02"
951 
952  DstList = []
953  for chID, channel in enumerate(D0List):
954  ma.reconstructDecay("D*+:2Nbdy" + str(chID) + " -> pi+:all " + channel, Dstcuts, chID, path=path)
955  DstList.append("D*+:2Nbdy" + str(chID))
956 
957  self.SkimLists = DstList
958 
959 
960 @fancy_skim_header
962  """
963  **Decay Modes**:
964  * :math:`D^{*+}\\to \\pi^+ D^{0}, D^{0}\\to K_{S} \\pi^+ \\pi^-`
965  * :math:`D^{*+}\\to \\pi^+ D^{0}, D^{0}\\to K_{S} \\pi^+ K^-`
966  * :math:`D^{*+}\\to \\pi^+ D^{0}, D^{0}\\to K_{S} K^+ \\pi^-`
967  * :math:`D^{*+}\\to \\pi^+ D^{0}, D^{0}\\to K_{S} K^+ K^-`
968 
969  **Selection Criteria**:
970  * Tracks from :math:`D^{0}`:
971  ``abs(d0) < 1, abs(z0) < 3, 0.296706 < theta < 2.61799``
972  * Use :math:`K_{S}` from `stdV0s.stdKshorts`
973  * ``1.66 < M(D0) < 2.06``
974  * No cut on the slow pion
975  * ``Q < 0.022``
976  * ``pcms(D*) > 2.0``
977  * For more details, please check the source code of this skim.
978 
979  """
980 
981  __authors__ = ["Yeqi Chen"]
982  __description__ = "Skim list for D*+ to pi+ D0, D0 to Ks and two conjugate charged FSPs."
983  __contact__ = __liaison__
984  __category__ = "physics, charm"
985 
986  NoisyModules = ["ParticleLoader", "RootOutput"]
987  ApplyHLTHadronCut = True
988 
989  def load_standard_lists(self, path):
990  stdKshorts(path=path)
991 
992  def build_lists(self, path):
993  mySel = "abs(d0) < 1 and abs(z0) < 3"
994  mySel += " and 0.296706 < theta < 2.61799"
995  ma.fillParticleList("pi+:hpjmks", mySel, path=path)
996  ma.fillParticleList("K+:hpjmks", mySel, path=path)
997 
998  D0cuts = "1.66 < M < 2.06"
999  Dstcuts = "0 < Q < 0.022 and useCMSFrame(p) > 2.0"
1000 
1001  D0_Channels = ["pi-:hpjmks pi+:hpjmks K_S0:merged",
1002  "K-:hpjmks pi+:hpjmks K_S0:merged",
1003  "pi-:hpjmks K+:hpjmks K_S0:merged",
1004  "K-:hpjmks K+:hpjmks K_S0:merged",
1005  ]
1006  DstList = []
1007 
1008  for chID, channel in enumerate(D0_Channels):
1009  ma.reconstructDecay("D0:HpJmKs" + str(chID) + " -> " + channel, D0cuts, chID, path=path)
1010 
1011  ma.reconstructDecay("D*+:HpJmKs" + str(chID) + " -> pi+:all D0:HpJmKs" + str(chID), Dstcuts, chID, path=path)
1012  DstList.append("D*+:HpJmKs" + str(chID))
1013 
1014  self.SkimLists = DstList
1015 
1016 
1017 @fancy_skim_header
1019  """
1020  Cut criteria are not finally decided, and could be changed. Please check the
1021  code in the master branch to get up-to-date information.
1022  """
1023 
1024  __authors__ = []
1025  __description__ = "An special version of `DstToD0Pi_D0ToHpJmPi0` to deal with Early Data."
1026  __contact__ = __liaison__
1027  __category__ = "physics, charm"
1028 
1029  NoisyModules = ["ParticleLoader", "RootOutput"]
1030  ApplyHLTHadronCut = True
1031 
1032  def load_standard_lists(self, path):
1033  loadStdSkimPhoton(path=path)
1034  loadStdSkimPi0(path=path)
1035 
1036  def build_lists(self, path):
1037  mySel = "abs(d0) < 0.5 and abs(z0) < 1.0" # IP cut, tighter than previous skims
1038  mySel += " and 0.296706 < theta < 2.61799" # CDC acceptance cut
1039  ma.fillParticleList("pi+:myhjp0", mySel, path=path)
1040  ma.fillParticleList("K+:myhjp0", mySel, path=path)
1041 
1042  ma.cutAndCopyList("pi0:myhjp0", "pi0:skim", "", path=path) # see analysis/scripts/stdPi0s.py for cuts
1043 
1044  D0cuts = "1.70 < M < 2.10"
1045  Dstcuts = "massDifference(0) < 0.160 and useCMSFrame(p) > 2.0"
1046 
1047  eventcuts = "nCleanedTracks(abs(d0) < 0.5 and abs(z0) < 1.0) >= 3"
1048  path = self.skim_event_cuts(eventcuts, path=path)
1049 
1050  DstList = []
1051  ma.reconstructDecay("D0:HpJmPi0 -> K-:myhjp0 pi+:myhjp0 pi0:myhjp0", D0cuts, path=path)
1052  ma.reconstructDecay("D*+:HpJmPi0RS -> D0:HpJmPi0 pi+:myhjp0", Dstcuts, path=path)
1053  ma.reconstructDecay("D*-:HpJmPi0WS -> D0:HpJmPi0 pi-:myhjp0", Dstcuts, path=path)
1054  ma.copyLists("D*+:HpJmPi0", ["D*+:HpJmPi0RS", "D*+:HpJmPi0WS"], path=path)
1055  DstList.append("D*+:HpJmPi0")
1056 
1057  self.SkimLists = DstList
1058 
1059 
1060 @fancy_skim_header
1062  """
1063  Cut criteria are not finally decided, and could be changed. Please check the
1064  code in the master branch to get up-to-date information.
1065  """
1066 
1067  __authors__ = []
1068  __description__ = "A special version of `DstToD0Pi_D0ToHpHmPi0` to deal with Early Data."
1069  __contact__ = __liaison__
1070  __category__ = "physics, charm"
1071 
1072  NoisyModules = ["ParticleLoader", "RootOutput"]
1073  ApplyHLTHadronCut = True
1074 
1075  def load_standard_lists(self, path):
1076  loadStdSkimPi0(path=path)
1077 
1078  def build_lists(self, path):
1079  mySel = "abs(d0) < 0.5 and abs(z0) < 1.0" # IP cut, tighter than previous skims
1080  mySel += " and 0.296706 < theta < 2.61799" # CDC acceptance cut
1081  ma.fillParticleList("pi+:myhhp0", mySel, path=path)
1082  ma.fillParticleList("K+:myhhp0", mySel, path=path)
1083 
1084  ma.cutAndCopyList("pi0:myhhp0", "pi0:skim", "", path=path) # see analysis/scripts/stdPi0s.py for cuts
1085 
1086  D0cuts = "1.70 < M < 2.10"
1087  Dstcuts = "massDifference(0) < 0.160 and useCMSFrame(p) > 2.0"
1088 
1089  eventcuts = "nCleanedTracks(abs(d0) < 0.5 and abs(z0) < 1.0) >= 3"
1090  path = self.skim_event_cuts(eventcuts, path=path)
1091 
1092  D0_Channels = ["pi+:myhhp0 pi-:myhhp0 pi0:myhhp0",
1093  "K+:myhhp0 K-:myhhp0 pi0:myhhp0",
1094  ]
1095 
1096  DstList = []
1097 
1098  for chID, channel in enumerate(D0_Channels):
1099  ma.reconstructDecay("D0:HpHmPi0" + str(chID) + " -> " + channel, D0cuts, chID, path=path)
1100  ma.reconstructDecay("D*+:HpHmPi0" + str(chID) + " -> D0:HpHmPi0" + str(chID) + " pi+:myhhp0",
1101  Dstcuts, chID, path=path)
1102  DstList.append("D*+:HpHmPi0" + str(chID))
1103 
1104  self.SkimLists = DstList
skim.charm.DstToD0Pi_D0ToHpJmKs.load_standard_lists
def load_standard_lists(self, path)
Definition: charm.py:989
skimExpertFunctions.BaseSkim.skim_event_cuts
def skim_event_cuts(self, cut, *path)
Definition: skimExpertFunctions.py:716
skim.charm.XToD0_D0ToNeutrals.SkimLists
SkimLists
Definition: charm.py:184
skim.charm.XToD0_D0ToNeutrals.validation_histograms
def validation_histograms(self, path)
Definition: charm.py:186
skim.charm.XToD0_D0ToNeutrals.load_standard_lists
def load_standard_lists(self, path)
Definition: charm.py:138
skim.charm.DstToD0Pi_D0ToHpHmHpJm.SkimLists
SkimLists
Definition: charm.py:855
skim.charm.DstToD0Pi_D0ToHpJmPi0
Definition: charm.py:650
skim.charm.DstToD0Pi_D0ToHpHmPi0.load_standard_lists
def load_standard_lists(self, path)
Definition: charm.py:726
skim.charm.XToDp_DpToHpHmJp.SkimLists
SkimLists
Definition: charm.py:408
skim.charm.XToD0_D0ToNeutrals.D0ToNeutrals
def D0ToNeutrals(path)
Definition: charm.py:147
skim.charm.DstToD0Pi_D0ToRare.load_standard_lists
def load_standard_lists(self, path)
Definition: charm.py:237
skim.charm.DstToD0Pi_D0ToHpHmPi0.build_lists
def build_lists(self, path)
Definition: charm.py:732
skim.charm.DstToD0Pi_D0ToHpJm.validation_histograms
def validation_histograms(self, path)
Definition: charm.py:593
skim.charm.EarlyData_DstToD0Pi_D0ToHpJmPi0.build_lists
def build_lists(self, path)
Definition: charm.py:1036
skim.charm.DstToD0Pi_D0ToHpJm.load_standard_lists
def load_standard_lists(self, path)
Definition: charm.py:577
skim.charm.DstToDpPi0_DpToHpPi0.load_standard_lists
def load_standard_lists(self, path)
Definition: charm.py:533
skim.charm.DstToD0Pi_D0ToHpJmPi0.build_lists
def build_lists(self, path)
Definition: charm.py:684
skim.charm.EarlyData_DstToD0Pi_D0ToHpHmPi0.build_lists
def build_lists(self, path)
Definition: charm.py:1078
skim.charm.DstToD0Pi_D0ToKsOmega.build_lists
def build_lists(self, path)
Definition: charm.py:783
skim.charm.DstToD0Pi_D0ToRare.build_lists
def build_lists(self, path)
Definition: charm.py:244
skim.charm.XToD0_D0ToHpJm.SkimLists
SkimLists
Definition: charm.py:100
skim.charm.LambdacTopHpJm.validation_histograms
def validation_histograms(self, path)
Definition: charm.py:483
skim.charm.XToDp_DpToKsHp.validation_histograms
def validation_histograms(self, path)
Definition: charm.py:336
skim.charm.DstToD0Pi_D0ToKsOmega.load_standard_lists
def load_standard_lists(self, path)
Definition: charm.py:778
skim.charm.DstToD0Pi_D0ToHpJmEta.build_lists
def build_lists(self, path)
Definition: charm.py:895
skim.charm.DstToD0Pi_D0ToHpJmEta
Definition: charm.py:859
skim.charm.DstToD0Pi_D0ToRare.validation_histograms
def validation_histograms(self, path)
Definition: charm.py:264
skim.charm.XToDp_DpToKsHp.build_lists
def build_lists(self, path)
Definition: charm.py:317
skim.charm.DstToD0Pi_D0ToHpHmPi0.SkimLists
SkimLists
Definition: charm.py:751
skim.charm.DstToD0Pi_D0ToHpJmPi0.SkimLists
SkimLists
Definition: charm.py:697
skim.charm.DstToD0Pi_D0ToHpJmEta.load_standard_lists
def load_standard_lists(self, path)
Definition: charm.py:889
skim.charm.LambdacTopHpJm.SkimLists
SkimLists
Definition: charm.py:481
skim.charm.DstToD0Pi_D0ToHpJm
Definition: charm.py:556
skim.charm.DstToD0Pi_D0ToHpHmPi0
Definition: charm.py:701
skim.charm.DstToD0Pi_D0ToHpJmKs
Definition: charm.py:961
skim.charm.DstToD0Pi_D0ToHpJm.build_lists
def build_lists(self, path)
Definition: charm.py:581
skim.charm.DstToD0Pi_D0ToNeutrals.load_standard_lists
def load_standard_lists(self, path)
Definition: charm.py:941
skim.charm.LambdacTopHpJm.build_lists
def build_lists(self, path)
Definition: charm.py:467
skim.charm.DstToDpPi0_DpToHpPi0.SkimLists
SkimLists
Definition: charm.py:552
skim.charm.DstToD0Pi_D0ToHpJmKs.build_lists
def build_lists(self, path)
Definition: charm.py:992
skim.charm.DstToD0Pi_D0ToHpHmHpJm.load_standard_lists
def load_standard_lists(self, path)
Definition: charm.py:828
skimExpertFunctions.BaseSkim
Definition: skimExpertFunctions.py:504
skim.charm.EarlyData_DstToD0Pi_D0ToHpJmPi0
Definition: charm.py:1018
skim.charm.XToDp_DpToKsHp.load_standard_lists
def load_standard_lists(self, path)
Definition: charm.py:312
skim.charm.EarlyData_DstToD0Pi_D0ToHpHmPi0.SkimLists
SkimLists
Definition: charm.py:1104
skim.charm.DstToDpPi0_DpToHpPi0
Definition: charm.py:512
skim.charm.XToDp_DpToHpHmJp
Definition: charm.py:365
skim.charm.XToDp_DpToHpHmJp.load_standard_lists
def load_standard_lists(self, path)
Definition: charm.py:390
skim.charm.EarlyData_DstToD0Pi_D0ToHpJmPi0.SkimLists
SkimLists
Definition: charm.py:1057
skim.charm.XToDp_DpToHpHmJp.build_lists
def build_lists(self, path)
Definition: charm.py:394
skim.charm.DstToD0Pi_D0ToNeutrals.build_lists
def build_lists(self, path)
Definition: charm.py:946
skim.charm.DstToD0Pi_D0ToRare.SkimLists
SkimLists
Definition: charm.py:262
skim.charm.DstToD0Pi_D0ToKsOmega
Definition: charm.py:755
skim.charm.DstToD0Pi_D0ToHpJmEta.SkimLists
SkimLists
Definition: charm.py:916
skim.charm.XToD0_D0ToHpJm
Definition: charm.py:39
skim.charm.DstToD0Pi_D0ToHpHmHpJm.build_lists
def build_lists(self, path)
Definition: charm.py:832
skim.charm.DstToD0Pi_D0ToHpJmKs.SkimLists
SkimLists
Definition: charm.py:1014
skim.charm.DstToD0Pi_D0ToHpHmHpJm
Definition: charm.py:802
skim.charm.EarlyData_DstToD0Pi_D0ToHpHmPi0.load_standard_lists
def load_standard_lists(self, path)
Definition: charm.py:1075
skim.charm.EarlyData_DstToD0Pi_D0ToHpJmPi0.load_standard_lists
def load_standard_lists(self, path)
Definition: charm.py:1032
skim.charm.XToDp_DpToHpHmJp.validation_histograms
def validation_histograms(self, path)
Definition: charm.py:410
validation_tools.metadata
Definition: metadata.py:1
skim.charm.DstToD0Pi_D0ToKsOmega.SkimLists
SkimLists
Definition: charm.py:798
skim.charm.XToDp_DpToKsHp
Definition: charm.py:288
skim.charm.XToD0_D0ToHpJm.validation_histograms
def validation_histograms(self, path)
Definition: charm.py:102
skim.charm.XToDp_DpToKsHp.SkimLists
SkimLists
Definition: charm.py:334
skim.charm.XToD0_D0ToHpJm.D0ToHpJm
def D0ToHpJm(path)
Definition: charm.py:57
skim.charm.XToD0_D0ToNeutrals
Definition: charm.py:126
skim.charm.EarlyData_DstToD0Pi_D0ToHpHmPi0
Definition: charm.py:1061
skim.charm.LambdacTopHpJm
Definition: charm.py:439
skim.charm.DstToD0Pi_D0ToRare
Definition: charm.py:209
skim.charm.XToD0_D0ToNeutrals.build_lists
def build_lists(self, path)
Definition: charm.py:182
skim.charm.XToD0_D0ToHpJm.build_lists
def build_lists(self, path)
Definition: charm.py:98
skim.charm.DstToD0Pi_D0ToNeutrals
Definition: charm.py:920
skim.charm.DstToDpPi0_DpToHpPi0.build_lists
def build_lists(self, path)
Definition: charm.py:537
skim.charm.LambdacTopHpJm.load_standard_lists
def load_standard_lists(self, path)
Definition: charm.py:462
skim.charm.DstToD0Pi_D0ToHpJmPi0.load_standard_lists
def load_standard_lists(self, path)
Definition: charm.py:679