Stripping framework
Contents
Introduction
The current stripping framework is based on the code of
Hlt2Lines and follows its concept.
Stripping framework consists of two packages belonging to the
ANALYSIS
project.
Phys/StrippingConf
contains definitions of python objects and C++ configurable. The actual selections and
DaVinci jobs are contained in
Phys/StrippingSelections
.
Contrary to Hlt2Lines framework, no objects for shared particles definitions are created. It is expected that the states from CommonParticles will be used in the stripping.
Writing stripping selections
Selections are kept under
Phys/StrippingSelections/python/StrippingSelections/
. To add a new selection line, the python module with the
StrippingLine
constructor should be placed in this directory (with the name starting with
Stripping
). Possible ways of writing the selection are:
- Using plain Gaudi classes
Examples are given below. In addition, the new selection has to be appended to any of the existing streams (or a new stream has to be created). Note that since DaVinci v24r4, the stream name is not a property of
StrippingLine
.
Since DaVinci v24r4, selections have been moved from options/ to python/. Therefore, do not forget to "cmt make" every time you change your selection!
Wrapping Selection object in StrippingLine
An existing
Selection object can be used directly to create a
StrippingLine
. In the code below,
Jpsi
is a
Selection
. For details on how to build such an object, see the
Particle Selection Framework page.
line = StrippingLine('JpsiInclusiveLine'
, prescale = 1.
, algos = [ Jpsi ] )
This will create a line with
Jpsi
's algorithm and all the ones required by it. Only one
Selection
should be used for any given
StrippingLine
.
Wrapping offline selection sequencer in StrippingLine
A GaudiSequencer containing an old-style selection can be integrated directly into the stripping framework by using it to build a
StrippingLine
instance. In the following example,
B2DhFilterSequence
is a GaudiSequencer that has already been created:
line = StrippingLine('B2Dh'
, prescale = 1
, algos = [ B2DhFilterSequence ]
)
This will create a line corresponding to
B2DhFilterSequence
selection, and add it to the list of lines.
Using StrippingMember
Using
StrippingMember
instead of common algorithm allows to clone
StrippingLine
in the same way as in Hlt2Line. This could be useful to handle e.g. signal and prescaled sidebands.
combine = CombineParticles("Bd2KstarMuMuCombine")
filter = StrippingMember (FilterDesktop
, "Filter"
, InputLocations = ["Bd2KstarMuMuCombine"]
, Code = "{Some filter code}"
)
line1 = StrippingLine('B2DPi_signal'
, prescale = 1
, algos = [ combine, filter ]
)
line2 = line1.clone('B2Dpi_sideband'
, prescale = 0.2
, FilterDesktopFilter = { "Code" : "{Some looser filter code}" }
)
In the above example,
CombineParticles
will run only once, while two
FilterDesktop
instances will be created. This allows to modify one of the selection lines without affecting the other.
StrippingLine
constructor arguments
The following options can be specified for a
StrippingLine
:
-
algos = [Alg1, Alg2]
- List of algorithms to run for this line. The algorithms can be
CombineParticles
, FilterDesktop
, SelectionSequence
or Selection
instances, or StrippingMembers
.
-
prescale = 1
-
-
postscale = 1
- Prescale and postscale factors. Prescaler and postscaler are run before and after the list of algorithms, respectively.
-
checkPV
- Controls checking of the existence of primary vertex in the event before running the sequence of algorithms. By default, checkPV=True, which means that at least 1 PV is required. Examples:
-
CheckPV = False
- turn off PV existence check
-
CheckPV = 2
- require at least 2 PVs
-
CheckPV = (1,3)
- require from 1 to 3 PVs.
-
FILTER = "filter string"
- Check the result of VoidFilter before running the sequence of algorithm. Useful for applying global event cuts. Example:
-
FILTER = "TrSOURCE('Rec/Track/Best') >> TrLONG >> (TrSIZE < 200 )"
- Require not more than 200 long tracks.
-
ODIN = "ODIN predicate"
- ODIN predicate
-
L0DU = "L0DU predicate"
- L0DU predicate
-
HLT = "HLT predicate"
- HLT predicate
-
MaxCandidates = NN
- Limit the number of candidates created by the line. If the number is exceeded, an incident "ExceedsCombinatoricsLimit" is triggered.
-
MaxCombinations = NN
- Limit the number of combinations in CombineParticles. If the number is exceeded, an incident "ExceedsCombinatoricsLimit" is triggered.
Testing that additions or modifications do not break the standard stripping
If any modifications or additions have been made to the StrippingSelections module, it is mandatory to check that these do not break the instantiation of the stripping. This can be achieved by running the QMTests, after setting the
DaVinci environment and building the package. From
Phys/StrippingSelections/cmt
:
cmt qmtest_run
Running stripping job
Configuring the stripping: StrippingConf
options
The object
StrippingConf
takes care about configuration of the stripping job:
from StrippingConf.Configuration import StrippingConf
This object creates and holds a list of StrippingStreams and contains member functions to access sequencers, output locations and selection names needed to be passed to DaVinci and DST writers. It is simple to configure, and new streams can be defined and added to it. Here, we construct a
StrippingConf
with four official stripping selections:
from Gaudi.Configuration import *
from StrippingConf.Configuration import StrippingConf
# import some official Stripping Selections
from StrippingSelections import StreamBmuon, StreamHadron, StreamJpsi, StreamDstar
sc = StrippingConf(Streams = [StreamBmuon.stream,
StreamHadron.stream,
StreamJpsi.stream,
StreamDstar.stream] )
It is also possible to add streams to an existing
StrippingConf
instance, using either the
appendStream
or the
appendStreams
method.
from StrippingSelections import StreamLambda, StreamBelectron
sc.appendStream( StreamLambda.stream )
sc.appendStream( StreamBelectron.stream )
Note that since DaVinci v24r4,
StrippingConf
does not configure DaVinci to write ETC or DST files internally, this is done in job options. Once the
StrippingConf
is ready, it can be used to simply run a job, write an ETC, or write some stripping DSTs, as the following examples show.
ETC
output
This example of ETC output job is from
Phys/StrippingSelections/tests/TestStrippingETC.py
. It assumes that a
StrippingConf sc
has been instantiated and configured as shown above.
from Configurables import EventTuple, TupleToolSelResults
tag = EventTuple("TagCreator")
tag.EvtColsProduce = True
tag.ToolList = [ "TupleToolEventInfo", "TupleToolRecoStats", "TupleToolSelResults" ]
tag.addTool(TupleToolSelResults)
tag.TupleToolSelResults.Selections = sc.selections() # Add the list of stripping selections to TagCreator
from Configurables import DaVinci
DaVinci().appendToMainSequence( [ sc.sequence() ] ) # Append the stripping selection sequence to DaVinci
DaVinci().appendToMainSequence( [ tag ] ) # Append the TagCreator to DaVinci
DaVinci().EvtMax = 1000 # Number of events
DaVinci().ETCFile = "etc.root" # ETC file name
importOptions("$STRIPPINGSELECTIONSROOT/tests/MC09_Bincl.py") # Data file
DST
output
The
StrippingConf
object and streams are configured in the same way as for ETC writing. After that, one has to configure
SelDSTWriter and pass it to DaVinci:
dstWriter = SelDSTWriter("MyDSTWriter",
SelectionSequences = sc.activeStreams(),
OutputPrefix = 'Strip',
OutputFileSuffix = '000000'
)
DaVinci().EvtMax = 1000 # Number of events
DaVinci().UserAlgorithms = [ dstWriter.sequence() ]
Testing single streams or lines
The above jobs use all streams available in
sc
. To test individual selections, one can create the test stream, e.g. to test only the
StrippingB2Dh
line, one can do:
from StrippingConf.StrippingStream import StrippingStream
from StrippingSelections import StrippingB2Dh
stream = StrippingStream("Test")
stream.appendLines( [ StrippingB2Dh.line ] )
from StrippingConf.Configuration import StrippingConf
sc = StrippingConf(Streams=[stream] )
...
Monitoring algorithm
An algorithm to monitor the selection results called
StrippingReport
is available. It can provide the following information:
- Selection results in each event
- Summary of selection results (number of selected events, accept rate and average multiplicity) every N events.
- Summary of selection results in the end of the job.
- List of noisy selections (with the accept rate above certain threshold) and non-responding selections (that select zero events)
The algorithm has to be initialised with the list of selection names, e.g. for all configured lines:
from Configurables import StrippingReport
sr = StrippingReport(Selections = sc.selections());
and added to the end of the list of
DaVinci algorithms:
DaVinci().appendToMainSequence( [ sr ] )
The following properties are available:
-
OnlyPositive
(default: True
) - show only the selections with at least one event accepted.
-
EveryEvent
(default: False
) - show selection results for every event
-
ReportFrequency
(default: 100) - number of events between selection summaries during the job execution
-
PrintNonResponding
(default: True
) - list non-responding selections (the ones that select zero events) at the end of the job
-
PrintHot
(default: True
) - list "hot" selections (with accept rate above threshold defined in HotThreshold
) at the end of the job
-
HotThreshold
(default: 0.5) - accept rate threshold for "hot" selections.
-
Latex
(default: False) - if True, use Latex table style instead of TWiki style by default.
To get the timing information in
StrippingReport
you need to add
ChronoAuditor
service:
# ChronoAuditor is used by StrippingReport to show the timing.
from Configurables import AuditorSvc, ChronoAuditor
AuditorSvc().Auditors.append( ChronoAuditor("Chrono") )
Isolation Tools in the Stripping
See the
StrippingIsolationTools TWiki page.
--
JuanPalacios - 26-Feb-2010