|
| def | load_standard_lists (self, path) |
| |
| def | build_lists (self, path) |
| |
|
def | __description__ (self) |
| |
|
def | __category__ (self) |
| |
|
def | __authors__ (self) |
| |
|
def | __contact__ (self) |
| |
| def | code (self) |
| |
| def | additional_setup (self, path) |
| |
| def | validation_histograms (self, path) |
| |
| def | __call__ (self, path, *udstOutput=None, validation=None) |
| |
| def | postskim_path (self) |
| |
| def | skim_event_cuts (self, cut, *path) |
| |
| def | flag (self) |
| |
| def | initialise_skim_flag (self, path) |
| |
| def | update_skim_flag (self, path) |
| |
| def | get_skim_list_names (self) |
| |
|
def | __str__ (self) |
| |
|
def | __name__ (self) |
| |
| def | set_skim_logging (self) |
| |
| def | output_udst (self, path) |
| |
| def | apply_hlt_hadron_cut_if_required (self, path) |
| |
Cuts applied:
* ``SkimHighEff tracks thetaInCDCAcceptance AND abs(dr) < 2 AND abs(dz) < 5 AND PID>=0.01``
* ``slowPi tracks thetaInCDCAcceptance AND abs(dr) < 2 AND abs(dz) < 5 AND useCMSFrame(p) < 0.4``
* :math:`2.5 > p_{\\ell} > 1.1\\,\\text{GeV}`
* ``lepton with abs(d0) < 0.5 AND abs(z0) < 2 AND thetaInCDCAcceptance AND ID >= 0.95 AND 1.1 < useCMSFrame(p) < 2.5``
* ``1.8 < M_D0 < 2.0``
* ``DM_Dstar_D < 0.16``
Reconstructed decays:
* :math:`B^{0}\\to D^{*-} (D^{0} \\to K^+ \\pi^-) e^+`,
* :math:`B^{0}\\to D^{*-} (D^{0} \\to K^+ \\pi^- \\pi^0) e^+`,
* :math:`B^{0}\\to D^{*-} (D^{0} \\to K^+ \\pi^- \\pi^- \\pi^+) e^+`,
* :math:`B^{0}\\to D^{*-} (D^{0} \\to K^+ \\pi^-) mu^+`,
* :math:`B^{0}\\to D^{*-} (D^{0} \\to K^+ \\pi^- \\pi^0) mu^+`,
* :math:`B^{0}\\to D^{*-} (D^{0} \\to K^+ \\pi^- \\pi^- \\pi^+) mu^+`,
Note:
This skim uses `skim.standardlists.charm.loadSkimHighEffD0_Kpi`,
`skim.standardlists.charm.loadSkimHighEffD0_Kpipipi` and
`skim.standardlists.charm.loadStdD0_eff20_Kpipi0`, where :math:`D^0`
channel is defined.
`skim.standardlists.charm.loadSkimHighEffDstarPlus_D0pi_Kpi`,
`skim.standardlists.charm.loadSkimHighEffDstarPlus_D0pi_Kpipipi`,
`skim.standardlists.charm.loadStdDstarPlus_D0pi_Kpipi0_eff20`,where the
:math:`D^{*-}` channel is defined.
The pion and kaon lists used to define :math:`D^0` and :math:`D^{*-}` are:
`skim.standardlists.charm.loadPiSkimHighEff`, `skim.standardlists.charm.loadKSkimHighEff` and
`skim.standardlists.charm.loadSlowPi`
Definition at line 271 of file semileptonic.py.
| def additional_setup |
( |
|
self, |
|
|
|
path |
|
) |
| |
|
inherited |
Perform any setup steps necessary before running the skim. This may include:
* applying event-level cuts using `ifEventPasses`,
* adding the `MCMatcherParticles` module to the path,
* running the FEI.
Warning:
Standard particle lists should *not* be loaded in here. This should be done
by overriding the method `BaseSkim.load_standard_lists`. This is crucial for
avoiding loading lists twice when combining skims for production.
Parameters:
path (basf2.Path): Skim path to be processed.
Reimplemented in CombinedSkim, Random, TauThrust, TDCPV_ccs, TauGeneric, BaseFEISkim, ALP3Gamma, and TDCPV_qqs.
Definition at line 612 of file skimExpertFunctions.py.
| def build_lists |
( |
|
self, |
|
|
|
path |
|
) |
| |
Create the skim lists to be saved in the output uDST. This function is where
the main skim cuts should be applied. At the end of this method, the attribute
``SkimLists`` must be set so it can be used by `output_udst`.
Parameters:
path (basf2.Path): Skim path to be processed.
Reimplemented from BaseSkim.
Definition at line 330 of file semileptonic.py.
330 def build_lists(self, path):
335 'abs(d0) < 0.5 and abs(z0) < 2 and thetaInCDCAcceptance and electronID >= 0.95 and 1.1 < useCMSFrame(p) < 2.5 ',
340 'abs(d0) < 0.5 and abs(z0) < 2 and thetaInCDCAcceptance and muonID >= 0.95 and 1.1 < useCMSFrame(p) < 2.5',
343 B0_channels = [
"D*-:D0_Kpi_skimhigheff e+:sig",
344 "D*-:D0_Kpipi0_eff20 e+:sig",
345 "D*-:D0_Kpipipi_skimhigheff e+:sig",
346 "D*-:D0_Kpi_skimhigheff mu+:sig",
347 "D*-:D0_Kpipi0_eff20 mu+:sig",
348 "D*-:D0_Kpipipi_skimhigheff mu+:sig"]
352 for chID, channel
in enumerate(B0_channels):
353 ma.reconstructDecay(
"B0:Dstl_kpi_kpipi0_kpipipi" + str(chID) +
" -> " + channel,
"", chID, path=path)
354 B0_list.append(
"B0:Dstl_kpi_kpipi0_kpipipi" + str(chID))
356 self.SkimLists = B0_list
| def skim_event_cuts |
( |
|
self, |
|
|
|
cut, |
|
|
* |
path |
|
) |
| |
|
inherited |
Apply event-level cuts in a skim-safe way.
Parameters:
cut (str): Event-level cut to be applied.
path (basf2.Path): Skim path to be processed.
Returns:
ConditionalPath (basf2.Path): Path on which the rest of this skim should be
processed. On this path, only events which passed the event-level cut
will be processed further.
.. Tip::
If running this function in `BaseSkim.additional_setup` or
`BaseSkim.build_lists`, redefine the ``path`` to the path returned by
`BaseSkim.skim_event_cuts`, *e.g.*
.. code-block:: python
def build_lists(self, path):
path = self.skim_event_cuts("nTracks>4", path=path)
# rest of skim list building...
.. Note::
The motivation for using this function over `applyEventCuts` is that
`applyEventCuts` completely removes events from processing. If we combine
multiple skims in a single steering file (which is done in production), and
the first has a set of event-level cuts, then all the remaining skims will
never even see those events.
Internally, this function creates a new path, which is only processed for
events passing the event-level cut. To avoid issues around particles not
being available on the main path (leading to noisy error logs), we need to
add the rest of the skim to this path. So this new path is assigned to the
attribute ``BaseSkim._ConditionalPath``, and ``BaseSkim.__call__`` will run
all remaining methods on this path.
Definition at line 716 of file skimExpertFunctions.py.
| def update_skim_flag |
( |
|
self, |
|
|
|
path |
|
) |
| |
|
inherited |
Add the module `skimExpertFunctions.InitialiseSkimFlag` to the path, which
initialises flag for this skim to zero.
.. Warning::
If a conditional path has been created before this, then this function
*must* run on the conditional path, since the skim lists are not guaranteed
to exist for all events on the main path.
Reimplemented in CombinedSkim.
Definition at line 783 of file skimExpertFunctions.py.
1.8.17