TauGeneric Class Reference

Inheritance diagram for TauGeneric:

Collaboration diagram for TauGeneric:

Public Member Functions
def	load_standard_lists (self, path)
def	additional_setup (self, path)
def	build_lists (self, path)
def	validation_histograms (self, path)
def	__description__ (self)
def	__category__ (self)
def	__authors__ (self)
def	__contact__ (self)
def	code (self)
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)

Public Attributes
	SkimLists
	name
	OutputFileName
	additionalDataDescription

Static Public Attributes
bool	produce_on_tau_samples = False
	NoisyModules = None
list	TestFiles = [get_test_file("MC13_mixedBGx1")]
dictionary	MergeDataStructures = {}
bool	ApplyHLTHadronCut = False

Private Member Functions
def	_method_unchanged (self, method)

Private Attributes
	_udstOutput
	_validation

Static Private Attributes
list	__authors__ = ["Kenji Inami"]
string	__description__ = "Skim for Tau generic decays."
	__contact__ = __liaison__
string	__category__ = "physics, tau"
	_MainPath = None
	_ConditionalPath = None

Detailed Description

**Channel**: :math:`e^+ e^- \\to \\tau^+ \\tau^-`

**Criteria**:

Ntrk = 2

1. Number of good tracks = 2, net charge < 2
2. ``visibleEnergyOfEventCMS < 10 GeV and E_ECLtrk < 6 GeV`` and ``missingMomentumOfEvent_theta < 2.6180``
3. ``visibleEnergyOfEventCMS > 3 GeV or max P_t > 1 GeV``
4. max. opening angle < 178 deg.

Ntrk = 3,4

1. Number of good tracks = 3 or 4, net charge < 2
2. ``visibleEnergyOfEventCMS < 10.5 GeV and E_ECLtrk < 6 GeV``
3. ``visibleEnergyOfEventCMS > 3 GeV or max P_t > 1 GeV``
4. max. opening angle < 178 deg.
5. Event divided by thrust axis; No. good tracks in tag side = 1 or 3
6. ``M_tag < 1.8 GeV`` and ``M_sig < 2.3 GeV``

Ntrk = 5,6

1. Number of good tracks = 5 or 6, net charge < 2
2. Event divided by thrust axis; No. good tracks in tag side = 1 or 3
3. ``M_tag < 1.8 GeV`` and ``M_sig < 2.3 GeV``

Definition at line 209 of file taupair.py.

Member Function Documentation

__call__()

def __call__ (   self,   path, *  udstOutput = None,   validation = None  )

inherited

Produce the skim particle lists and write uDST file.

Parameters:
    path (basf2.Path): Skim path to be processed.
    udstOutput (bool): [DEPRECATED ARGUMENT] If True, add uDST output to the path.
    validation (bool): [DEPRECATED ARGUMENT] If True, build lists and write
validation histograms instead of writing uDSTs.

Definition at line 648 of file skimExpertFunctions.py.

_method_unchanged()

def _method_unchanged (   self,   method  )

privateinherited

Check if the method of the class is the same as in its parent class, or if it has
been overridden.

Useful for determining if *e.g.* `validation_histograms` has been defined for a
particular skim.

Definition at line 810 of file skimExpertFunctions.py.

additional_setup()

def additional_setup	(		self,
			path
	)

Set particle lists and variables for TauGeneric skim.

**Output particle lists**: ``pi+:tauskim, gamma:tauskim, pi+:S1/S2, gamma:S1/S2``

**Variables**:

* ``nGoodTracks``: number of good tracks in an event
* ``netCharge``: total net charge of good tracks
* ``nTracksS1/nTracksS2:`` number of good tracks in each hemisphere ``S1/S2`` divided by thrust axis
* ``invMS1/invMS2``: invariant mass of particles in each hemisphere
* ``maxPt``: maximum Pt amoung good tracks
* ``E_ECLtrk``: total ECL energy of good tracks

Reimplemented from BaseSkim.

Definition at line 248 of file taupair.py.

    def additional_setup(self, path):
        """
        Set particle lists and variables for TauGeneric skim.
 
        **Output particle lists**: ``pi+:tauskim, gamma:tauskim, pi+:S1/S2, gamma:S1/S2``
 
        **Variables**:
 
        * ``nGoodTracks``: number of good tracks in an event
        * ``netCharge``: total net charge of good tracks
        * ``nTracksS1/nTracksS2:`` number of good tracks in each hemisphere ``S1/S2`` divided by thrust axis
        * ``invMS1/invMS2``: invariant mass of particles in each hemisphere
        * ``maxPt``: maximum Pt amoung good tracks
        * ``E_ECLtrk``: total ECL energy of good tracks
        """
 
        # Track and gamma cuts
        trackCuts = "-3.0 < dz < 3.0 and dr < 1.0"
        # trackCuts += " and -0.8660 < cosTheta < 0.9563"
        gammaCuts = "E > 0.15"
        gammaCuts += " and -0.8660 < cosTheta < 0.9563"
        ma.cutAndCopyList("pi+:tauskim", "pi+:all", trackCuts, path=path)
        ma.cutAndCopyList("gamma:tauskim", "gamma:all", gammaCuts, path=path)
 
        # Get EventShape variables
        ma.buildEventShape(["pi+:tauskim", "gamma:tauskim"],
                           allMoments=False, foxWolfram=False, cleoCones=False,
                           sphericity=False, jets=False, path=path)
        ma.buildEventKinematics(["pi+:tauskim", "gamma:tauskim"], path=path)
 
        # Split in signal and tag
        ma.cutAndCopyList("pi+:S1", "pi+:tauskim", "cosToThrustOfEvent > 0", path=path)
        ma.cutAndCopyList("pi+:S2", "pi+:tauskim", "cosToThrustOfEvent < 0", path=path)
        ma.cutAndCopyList("gamma:S1", "gamma:tauskim", "cosToThrustOfEvent > 0", path=path)
        ma.cutAndCopyList("gamma:S2", "gamma:tauskim", "cosToThrustOfEvent < 0", path=path)
 
        vm.addAlias("nGoodTracks", "nParticlesInList(pi+:tauskim)")
        vm.addAlias("netCharge", "formula(countInList(pi+:tauskim, charge == 1) - countInList(pi+:tauskim, charge == -1))")
        vm.addAlias("nTracksS1", "nParticlesInList(pi+:S1)")
        vm.addAlias("nTracksS2", "nParticlesInList(pi+:S2)")
        vm.addAlias("invMS1", "invMassInLists(pi+:S1, gamma:S1)")
        vm.addAlias("invMS2", "invMassInLists(pi+:S2, gamma:S2)")
        # vm.addAlias("Evis", "visibleEnergyOfEventCMS")
        vm.addAlias("maxPt", "maxPtInList(pi+:tauskim)")
        vm.addAlias("E_ECLtrk", "formula(totalECLEnergyOfParticlesInList(pi+:tauskim))")
        vm.addAlias("maxOp", "useCMSFrame(maxOpeningAngleInList(pi+:tauskim))")
 

apply_hlt_hadron_cut_if_required()

def apply_hlt_hadron_cut_if_required (   self,   path  )

inherited

Apply the ``hlt_hadron`` selection if the property ``ApplyHLTHadronCut`` is True.

Parameters:
    path (basf2.Path): Skim path to be processed.

Reimplemented in CombinedSkim.

Definition at line 883 of file skimExpertFunctions.py.

build_lists()

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 295 of file taupair.py.

code()

def code (   self )

inherited

Eight-digit code assigned to this skim in the registry.

Definition at line 574 of file skimExpertFunctions.py.

flag()

def flag (   self )

inherited

Event-level variable indicating whether an event passes the skim or not. To use
the skim flag without writing uDST output, use the argument ``udstOutput=False``
when instantiating the skim class.

Reimplemented in CombinedSkim.

Definition at line 768 of file skimExpertFunctions.py.

get_skim_list_names()

def get_skim_list_names (   self )

inherited

Get the list of skim particle list names, without creating the particle lists on
the current path.

Definition at line 796 of file skimExpertFunctions.py.

initialise_skim_flag()

def initialise_skim_flag (   self,   path  )

inherited

Add the module `skimExpertFunctions.InitialiseSkimFlag` to the path, which
initialises flag for this skim to zero.

Reimplemented in CombinedSkim.

Definition at line 776 of file skimExpertFunctions.py.

load_standard_lists()

def load_standard_lists	(		self,
			path
	)

Load any standard lists. This code will be run before any
`BaseSkim.additional_setup` and `BaseSkim.build_lists`.

Note:
    This is separated into its own function so that when skims are combined, any
    standard lists used by two skims can be loaded just once.

Parameters:
    path (basf2.Path): Skim path to be processed.

Reimplemented from BaseSkim.

Definition at line 244 of file taupair.py.

output_udst()

def output_udst (   self,   path  )

inherited

Write the skim particle lists to an output uDST and print a summary of the
skim list statistics.

Parameters:
    path (basf2.Path): Skim path to be processed.

Reimplemented in CombinedSkim.

Definition at line 860 of file skimExpertFunctions.py.

postskim_path()

def postskim_path (   self )

inherited

Return the skim path.

* If `BaseSkim.skim_event_cuts` has been run, then the skim lists will only be
  created on a conditional path, so subsequent modules should be added to the
  conditional path.

* If `BaseSkim.skim_event_cuts` has not been run, then the main analysis path is
  returned.

Definition at line 694 of file skimExpertFunctions.py.

set_skim_logging()

def set_skim_logging (   self )

inherited

Turns the log level to ERROR for selected modules to decrease the total size
of the skim log files. Additional modules can be silenced by setting the attribute
`NoisyModules` for an individual skim.

Parameters:
    path (basf2.Path): Skim path to be processed.

.. warning::

    This method works by inspecting the modules added to the path, and setting
    the log level to ERROR. This method should be called *after* all
    skim-related modules are added to the path.

Reimplemented in CombinedSkim.

Definition at line 834 of file skimExpertFunctions.py.

skim_event_cuts()

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.

update_skim_flag()

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.

validation_histograms()

def validation_histograms	(		self,
			path
	)

Create validation histograms for the skim.

Parameters:
    path (basf2.Path): Skim path to be processed.

Reimplemented from BaseSkim.

Definition at line 326 of file taupair.py.

---

The documentation for this class was generated from the following file:

• skim/scripts/skim/taupair.py