def test_instantiate_stripping12_streams():
'''
Test that Stripping Streams can be instantiated.
This is the most basic test that should be run when modifying or
adding Stripping Streams to StrippingSelections.Streams.allStreams.
'''
from StrippingConf.Configuration import StrippingConf
from StrippingSettings.Stripping12 import streams
_streams = streams()
sc = StrippingConf(Streams=_streams)
def test_instantiate_StrippingConf_with_all_streams() :
'''
Test that Stripping Streams can be instantiated.
This is the most basic test that should be run when modifying or
adding Stripping Streams to StrippingSelections.Streams.allStreams.
'''
from StrippingConf.Configuration import StrippingConf
from StrippingSelections import buildersConf
stripping = buildersConf()
from StrippingSelections.Utils import buildStreams
streams = buildStreams(stripping)
sc = StrippingConf (Streams = streams)
def test_filterMembers() :
'''
It is necessary to construct a StrippingStream and a StrippingConf
to test the filterMembers of the line. The line by itself is useless.
'''
selection = AutomaticData(Location = 'Phys/Selection/Particles')
name = 'FilterMembersTest'
line = StrippingLine('FilterMembersTest', algos = [selection])
assert line.name() == 'Stripping' + name
assert line.subname() == name
assert line.isAppended() == False
assert line.outputLocation() == 'Phys/FilterMembersTest/Particles'
stream = StrippingStream('stream', Lines = [line])
conf = StrippingConf('conf', Streams = [stream])
assert [m.name() for m in line.filterMembers()] == ['checkPVmin1',
'SelFilterPhys_Selection_Particles',
'FilterMembersTest']
def ReStrip(mylines, stripping="stripping21r0p1", streamname=None):
from Configurables import EventNodeKiller, ProcStatusCheck
from StrippingArchive.Utils import buildStreams
from StrippingArchive import strippingArchive
from StrippingConf.Configuration import StrippingStream
from StrippingConf.Configuration import StrippingConf
from StrippingSettings.Utils import strippingConfiguration
NodeKiller = EventNodeKiller("StripKiller")
NodeKiller.Nodes = ["/Event/AllStreams", "/Event/Strip"]
from StrippingSelections import buildersConf
from StrippingSelections.Utils import lineBuilder, buildStreamsFromBuilder
config = strippingConfiguration(stripping)
archive = strippingArchive(stripping)
streams = buildStreams(stripping=config, archive=archive)
#confs = buildersConf()
mystream = StrippingStream("MyStream")
#for name in confnames:
# streams = buildStreamsFromBuilder(confs,name)
for stream in streams:
#if streamname not in stream : continue
for line in stream.lines:
print line
if line.name() in mylines:
print "Adding ", line.name(), "for restripping"
mystream.appendLines([line])
restrip = StrippingConf(Streams=[mystream],
MaxCandidates=2000,
AcceptBadEvents=False,
BadEventSelection=ProcStatusCheck(),
TESPrefix='Strip',
ActiveMDSTStream=True)
#Verbose = True,
#MicroDSTStreams = streams )
return restrip, [NodeKiller, restrip.sequence()]
from StrippingSettings.Sept2010 import StreamRadiative
from StrippingSettings.Sept2010 import StreamEW
allStreams = [
StreamCalibration.stream,
StreamBhadron.stream,
StreamCharm.stream,
StreamDielectron.stream,
StreamDimuon.stream,
StreamMiniBias.stream,
StreamSemileptonic.stream,
StreamRadiative.stream,
StreamEW.stream,
]
sc = StrippingConf(Streams=allStreams, MaxCandidates=2000)
charm = StreamCharm.stream.name()
from DSTWriters.__dev__.microdstelements import *
from DSTWriters.__dev__.Configuration import (SelDSTWriter, stripDSTStreamConf,
stripDSTElements,
microDSTStreamConf,
microDSTElements)
extraMicroElements = [
CloneLHCbIDs(),
ReFitAndClonePVs(),
CloneRawBanks(banks=['HltSelReports', 'HltDecReports']),
CloneHltDecReports(locations=['Strip/Phys/DecReports']),
CloneL0DUReport()
for stream in streams:
if 'MiniBias' not in stream.name():
for line in stream.lines:
dup = False
for line2 in AllStreams.lines:
if line2.name() == line.name():
dup = True
break
if not dup:
line._prescale = 1.0
AllStreams.appendLines([line])
#################################
sc = StrippingConf(Streams=[AllStreams], MaxCandidates=2000, TESPrefix='Strip')
################################
'''
MaxCombinations =10000000 added in sc.
what is that? is it required?
'''
#################################
AllStreams.sequence(
).IgnoreFilterPassed = False # so that we do not get all events written out
#
# Configuration of SelDSTWriter
from Gaudi.Configuration import *
from Configurables import SelDSTWriter, DaVinci
from StrippingConf.Configuration import StrippingConf
from StrippingSelections.Streams import allStreams
MessageSvc().Format = "% F%60W%S%7W%R%T %0W%M"
#
# Stripping job configuration
#
sc = StrippingConf(Streams=allStreams)
dstWriter = SelDSTWriter("MyDSTWriter",
SelectionSequences=sc.activeStreams(),
ExtraItems=['/Event/Strip/Phys/DecReports#1'],
OutputFileSuffix='000000')
#from StrippingSelections.StartupOptions import veloNZSKiller, redoPV
#dvinit = GaudiSequencer("DaVinciInitSeq")
#dvinit.Members.insert(0, redoPV() )
#dvinit.Members.insert(0, veloNZSKiller() )
DaVinci().EvtMax = 10 # Number of events
DaVinci().appendToMainSequence([dstWriter.sequence()])
DaVinci().DataType = "MC09"
DaVinci().HistogramFile = "hist.root"
archive = strippingArchive(stripping)
stream = buildStream(stripping = config, streamName='ALL', archive = archive)
stream.lines=[l for l in stream.lines if (("TrackEffDown" not in l.name()))] #fix for Z02mumu bug
for l in stream.lines:
if l.RequiredRawEvents and l._prescale==0:
l.RequiredRawEvents=None
from Configurables import ProcStatusCheck
filterBadEvents = ProcStatusCheck()
sc = StrippingConf( Streams = [stream],
MaxCandidates = 2000,
AcceptBadEvents = False,
BadEventSelection = filterBadEvents,
TESPrefix = 'Strip' )
## Configure PV refitter
from Configurables import LoKi__PVReFitter
LoKi__PVReFitter("ToolSvc.LoKi::PVReFitter").CheckTracksByLHCbIDs = True
appMgr = ApplicationMgr()
appMgr.OutputLevel = 6
appMgr.ExtSvc += [ 'ToolSvc', 'AuditorSvc' ]
appMgr.HistogramPersistency = "ROOT"
ntSvc = NTupleSvc()
appMgr.ExtSvc += [ ntSvc ]
def ConfigureDaVinci():
config = Swimming()
from Configurables import DaVinci
from StrippingConf.Configuration import StrippingConf
from Configurables import ProcStatusCheck
from Configurables import EventNodeKiller, GaudiSequencer
from PhysSelPython.Wrappers import (AutomaticData, SelectionSequence,
MultiSelectionSequence)
# Get the stripping line
from StrippingSettings.Utils import lineBuilderConfiguration
strippingFile = None
if config.getProp('StrippingFile') != 'none':
strippingFile = config.getProp('StrippingFile')
else:
strippingFile = config.getProp('StrippingLineGroup')
myconfig = lineBuilderConfiguration(config.getProp('StrippingVersion'),
config.getProp('StrippingLineGroup'))
import StrippingArchive
mylineconf = getattr(
__import__(
'StrippingArchive.' +
config.getProp('StrippingVersion') + '.Stripping' + strippingFile,
globals(), locals(), [myconfig["BUILDERTYPE"]], -1),
myconfig["BUILDERTYPE"])
mylinedict = myconfig["CONFIG"]
substitutions = config.getProp('StrippingConfigSubstitutions')
print "mylinedict before substitutions:", mylinedict
print "stripping config substitutions:", substitutions
mylinedict.update(substitutions)
print "mylineconf:", mylineconf
print "mylinedict after substitutions:", mylinedict
from StrippingConf.StrippingStream import StrippingStream
stream = StrippingStream(config.getProp('StrippingStream') + "Swimming")
allLines = mylineconf(config.getProp('StrippingLineGroup'),
mylinedict).lines()
lines = []
#lineNames = [l.split('/')[-1] for l in config.getProp('StripCands').keys()]
lineNames = config.getProp('StrippingLines')
print "lineNames:", lineNames
for l in allLines:
for lineName in lineNames:
if l.outputLocation().find(lineName) != -1:
lines.append(l)
print l.outputLocation()
stream.appendLines(lines)
# Define the stream
filterBadEvents = ProcStatusCheck()
sc = StrippingConf(Streams=[stream],
MaxCandidates=2000,
AcceptBadEvents=False,
BadEventSelection=filterBadEvents)
# Define the node killer, and make sure to kill everything corresponding to
# the stream which we want to swim
outputs = []
from Configurables import Swimming__PVReFitter as ReFitter
for l in lines:
for f in l.filterMembers():
if hasattr(f, 'ReFitPVs') and f.ReFitPVs:
if not config.getProp('RefitPVs'):
log.warning('RefitPVs is not set, but stripping line applies refitting. Refitted ' + \
'PVs will be used for turning-point lifetime calculations.')
config.setProp('RefitPVs', True)
t = f.PVReFitters['']
f.PVReFitters = {'': 'Swimming::PVReFitter/PVReFitter'}
f.addTool(ReFitter, 'PVReFitter')
f.PVReFitter.PVReFitter = t
elif not hasattr(f, 'Output'):
continue
# Remove the last item so we get everything (Particle, relations,
# decayVertices, etc...
o = '/'.join(f.Output.split('/')[:-1])
outputs.append(o)
print "Outputs are", outputs
mykiller = EventNodeKiller("killStripping")
# Some default nodes which we will want to kill in all cases
nodestokill = outputs + ['Strip', '/Event/Rec/Vertex/Primary']
mykiller.Nodes = nodestokill
deathstar = GaudiSequencer("killStrippingSeq")
deathstar.Members = [mykiller]
# Configure DaVinci
DaVinci().InputType = config.getProp('InputType')
DaVinci().DataType = config.getProp('DataType')
DaVinci().Simulation = config.getProp('Simulation')
DaVinci().DDDBtag = config.getProp('DDDBtag')
DaVinci().CondDBtag = config.getProp('CondDBtag')
try:
DaVinci().Persistency = config.getProp('Persistency')
except AttributeError:
print "DaVinci doesn't have a Persistency attribute to set"
# The sequence for the swimming has to be configured
# by hand inserting the node killer before it
DaVinci().appendToMainSequence([deathstar])
DaVinci().appendToMainSequence([sc.sequence()])
# Since the name of the output file is configured in two places in DaVinci,
# do some splitting.
splitName = config.getProp('OutputFile').split(os.path.extsep)
seqName = ''
prefix = ''
if len(splitName) <= 2:
seqName = splitName[0]
print "Warning, an output filename in three parts was specified. This does not work well, " + \
" so 'Swimming.' will be prefixed."
prefix = 'Swimming'
else:
prefix = splitName[0]
seqName = os.path.extsep.join(splitName[1:-1])
dstWriter = None
print config.getProp('OutputType')
# Offline candidate selection sequences
sequences = []
offCands = config.getProp('OffCands').keys()
for i, cands in enumerate(offCands):
data = AutomaticData(Location=cands + "/Particles")
offSeq = SelectionSequence("OfflineCandidates_%d" % i,
TopSelection=data)
sequences.append(offSeq)
# selection sequence for offline candidates
muCands = config.getProp('MuDSTCands')
for i, cands in enumerate(muCands):
# Add extra selections for additional MuDSTCands
data = AutomaticData(Location=cands + "/Particles")
seq = SelectionSequence("MuDSTCands_%d" % i, TopSelection=data)
sequences.append(seq)
selectionSeq = MultiSelectionSequence(seqName, Sequences=sequences)
if config.getProp('OutputType') == 'MDST':
pack = False
isMC = config.getProp("Simulation")
SwimmingConf = config.getProp('MicroDSTStreamConf')
SwimmingElements = config.getProp('MicroDSTElements')
if SwimmingConf == False:
from DSTWriters.Configuration import stripMicroDSTStreamConf
SwimmingConf = stripMicroDSTStreamConf(pack=pack, isMC=isMC)
if len(SwimmingElements) == 0:
from DSTWriters.Configuration import stripMicroDSTElements
from DSTWriters.microdstelements import CloneSwimmingReports, CloneParticleTrees, CloneTPRelations
mdstElements = stripMicroDSTElements(pack=pack, isMC=isMC)
SwimmingElements = [CloneSwimmingReports()]
for element in mdstElements:
SwimmingElements += [element]
if type(element) == CloneParticleTrees:
SwimmingElements += [CloneTPRelations("P2TPRelations")]
streamConf = {'default': SwimmingConf}
elementsConf = {'default': SwimmingElements}
try:
from DSTWriters.__dev__.Configuration import MicroDSTWriter
except:
from DSTWriters.Configuration import MicroDSTWriter
dstWriter = MicroDSTWriter('MicroDST',
StreamConf=streamConf,
MicroDSTElements=elementsConf,
WriteFSR=config.getProp('WriteFSR'),
OutputFileSuffix=prefix,
SelectionSequences=[selectionSeq])
elif config.getProp('OutputType') == 'DST':
try:
from DSTWriters.__dev__.streamconf import OutputStreamConf
from DSTWriters.__dev__.Configuration import SelDSTWriter
except ImportError:
from DSTWriters.streamconf import OutputStreamConf
from DSTWriters.Configuration import SelDSTWriter
streamConf = OutputStreamConf(streamType = InputCopyStream,
fileExtension = '.dst',
extraItems = [config.getProp('SwimmingPrefix') + '/Reports#1'] +\
list(set([l + '/P2TPRelations#1' for l in config.getProp('OffCands').values()])))
SelDSTWriterElements = {'default': []}
SelDSTWriterConf = {'default': streamConf}
dstWriter = SelDSTWriter('FullDST',
StreamConf=SelDSTWriterConf,
MicroDSTElements=SelDSTWriterElements,
WriteFSR=config.getProp('WriteFSR'),
OutputFileSuffix=prefix,
SelectionSequences=[selectionSeq])
DaVinci().appendToMainSequence([dstWriter.sequence()])
from StrippingArchive.Stripping21.StrippingB2XMuMuInclusive \
import defaultConfig as config
from StrippingConf.Configuration import StrippingConf, StrippingStream
stripping='stripping20'
lb = builder('B2XMuMuIncl',config)
print config
AllStreams = StrippingStream("MyStream")
for line in lb.lines():
if line.name() == 'StrippingB2XMuMuIncl_InclDiMuLowQ2Line':
AllStreams.appendLines([line])
sc = StrippingConf( Streams = [ AllStreams ],
MaxCandidates = 2000
)
stripsel = AutomaticData(Location = "Phys/B2XMuMuIncl_InclDiMuLowQ2Line/Particles")
stripfilter = FilterDesktop("stripfilter",
Preambulo = ["from LoKiPhysMC.decorators import *",
"from LoKiPhysMC.functions import mcMatch"],
Code = "ALL")
inclmumu = Selection ("Sel"+name,
Algorithm = stripfilter,
RequiredSelections = [stripsel])
seq = SelectionSequence("seq",
TopSelection = inclmumu)
MyStream = StrippingStream('MyStream')
for stream in streams:
for line in stream.lines:
if line.name() == myLine:
MyStream.appendLines([line])
# Configure Stripping
from Configurables import ProcStatusCheck
filterBadEvents = ProcStatusCheck()
sc = StrippingConf(
Streams=[MyStream],
MaxCandidates=2000,
AcceptBadEvents=False,
BadEventSelection=filterBadEvents,
HDRLocation='NonexistingPlaceholder',
)
#
# Configuration of SelDSTWriter
#
SelDSTWriterElements = {
'default': stripDSTElements(),
}
SelDSTWriterConf = {
'default': stripDSTStreamConf(),
}
## $Id: DVTestReadETC.py,v 1.5 2010/01/28 07:21:10 pkoppenb Exp $
## ============================================================================
## CVS tag $Name: $, version $Revision: 1.5 $
## ============================================================================
#
# Example options to read a user-defined ETC
#
from Gaudi.Configuration import *
from Configurables import DaVinci
from StrippingConf.Configuration import StrippingConf
from StrippingArchive.Utils import buildStream
stream = buildStream('Stripping17', 'Dimuon')
sc = StrippingConf()
sc.appendStream(stream)
DaVinci().appendToMainSequence([sc.sequence()])
DaVinci().EvtMax = -1
DaVinci().PrintFreq = 1
DaVinci().DataType = "MC09"
DaVinci().Simulation = True
DaVinci().Input = [
"COLLECTION='TagCreator/EventTuple' DATAFILE='etc.root' TYP='POOL_ROOT' SEL='(StrippingBs2JpsiPhiLine==1)'"
]
from Configurables import TagCollectionSvc
ApplicationMgr().ExtSvc += [TagCollectionSvc("EvtTupleSvc")]
config = strippingConfiguration(restripversion)
archive = strippingArchive(restripversion)
streams = buildStreams(stripping=config, archive=archive)
# get our stripping line from archive
MyStream = StrippingStream("MyStream")
MyLines = ['Stripping' + lines[0]] # note: only for one line!
for stream in streams:
for line in stream.lines:
if line.name() in MyLines:
MyStream.appendLines([line])
from Configurables import ProcStatusCheck
filterBadEvents = ProcStatusCheck()
sc = StrippingConf(Streams=[MyStream],
MaxCandidates=2000,
AcceptBadEvents=False,
BadEventSelection=filterBadEvents)
DaVinci().appendToMainSequence([eventNodeKiller, sc.sequence()])
tuple_Lc2pKpi.Inputs = MyStream.outputLocations()
'''
# Fix MC truth for Turbo (https://twiki.cern.ch/twiki/bin/view/LHCb/MakeNTupleFromTurbo#Monte_Carlo_truth)
if(Turbo) :
from TeslaTools import TeslaTruthUtils
# Location of the truth tables for PersistReco objects
if (year in ["2017","2018"]) :
relations = TeslaTruthUtils.getRelLocs() + [TeslaTruthUtils.getRelLoc(''), 'Relations/Hlt2/Protos/Charged' ]
if (year in ["2015","2016"]) :
relations = [TeslaTruthUtils.getRelLoc(hlt2_line + '/')]
pions = AutomaticData(Location='Phys/StdLoosePions')
eventFilter = DeterministicPrescaler('BadEventFilter', AcceptFraction=0.5)
lineX = StrippingLine('PionLineX', algos=[pions])
lineY = StrippingLine('PionLineY', algos=[pions])
streamX = StrippingStream("StreamPionX", Lines=[lineX])
streamXBadEvent = StrippingStream("StreamPionXBadEvent",
Lines=[lineX],
BadEventSelection=eventFilter)
streamYBadEvent = StrippingStream("StreamPionYBadEvent",
Lines=[lineY],
BadEventSelection=eventFilter)
sc = StrippingConf(Streams=[streamX, streamYBadEvent, streamXBadEvent])
dstWriter = SelDSTWriter("SelDST0",
OutputFileSuffix="Test3",
SelectionSequences=sc.activeStreams())
dv = DaVinci()
dv.DataType = '2010'
dv.InputType = 'SDST'
dv.EvtMax = -1
#dv.appendToMainSequence( [ sc.sequence() ] )
dv.appendToMainSequence([dstWriter.sequence()])
EventSelector().Input = [
"DATAFILE='PFN:castor:/castor/cern.ch/user/c/cattanem/testFiles/Brunel-v37r1-069857_0000000006-1000ev.sdst' TYP='POOL_ROOTTREE' OPT='READ'"
]
FileCatalog().Catalogs = ['xmlcatalog_file:TestSDSTCatalog.xml']
from Gaudi.Configuration import *
from Configurables import DaVinci, SelDSTWriter
from StrippingConf.Configuration import StrippingConf
from StrippingSelections.Streams import StreamDimuon, StreamCalibration
sc = StrippingConf(Streams=[StreamDimuon.stream])
from DSTWriters.__dev__.Configuration import StripDSTWriter
dstWriter = StripDSTWriter(
"StripDSTWriter",
SelectionSequences=sc.activeStreams(),
OutputFileSuffix='TestDiMuon',
)
dv = DaVinci()
dv.DataType = '2010'
dv.InputType = 'SDST'
dv.Simulation = True
dv.EvtMax = 5000
dv.appendToMainSequence([sc.sequence()])
dv.appendToMainSequence([dstWriter.sequence()])
#dv.UserAlgorithms = [dstWriter.sequence()]
importOptions("Reco05-Stripping09_SDSTs.py")
from StrippingArchive.Stripping21.StrippingB2XMuMu import B2XMuMuConf
from StrippingSettings.Stripping21.LineConfigDictionaries_RD import B2XMuMu
from PhysSelPython.Wrappers import AutomaticData, Selection, SelectionSequence
B2XMuMu['CONFIG']['HLT_FILTER'] = ""
B2XMuMuConf = B2XMuMuConf("B2XMuMu", B2XMuMu['CONFIG'])
B2XMuMuLines = B2XMuMuConf.lines()
for line in B2XMuMuLines:
print "CL DEBUG", line
print "CL DEBUG", line.name()
stripline = B2XMuMuLines[0]
sc = StrippingConf( HDRLocation = "DecReports" )
sstream = StrippingStream("TestStream")
sstream.appendLines([ stripline ] )
sstream.OutputLevel = 2
sc.appendStream( sstream )
Strip_Location1 = stripline.outputLocation()
print Strip_Location1
StripSel1 = AutomaticData(Location = Strip_Location1)
print StripSel1
print "ALL OK"
rootintes = "/Event/AllStreams"
#---------------------------
# Run fixing XmumuLine
bhadronMicroDSTname
]
dstStreams = [
"BhadronCompleteEvent", "CharmCompleteEvent", "Dimuon", "EW",
"Semileptonic", "Calibration", "MiniBias", "Radiative"
]
stripTESPrefix = 'Strip'
from Configurables import ProcStatusCheck
sc = StrippingConf(Streams=streams,
MaxCandidates=2000,
AcceptBadEvents=False,
BadEventSelection=ProcStatusCheck(),
TESPrefix=stripTESPrefix,
ActiveMDSTStream=True,
Verbose=True,
DSTStreams=dstStreams,
MicroDSTStreams=mdstStreams)
#
# Configure the dst writers for the output
#
enablePacking = True
from DSTWriters.microdstelements import *
from DSTWriters.Configuration import (SelDSTWriter, stripDSTStreamConf,
stripDSTElements,
stripMicroDSTStreamConf,
stripMicroDSTElements,
from PhysSelPython.Wrappers import AutomaticData, Selection, SelectionSequence
#from Configurables import DstConf, TurboConf
B2XMuMuConf = B2XMuMuConf("B2XMuMu", B2XMuMu['CONFIG'])
B2XMuMuLines = B2XMuMuConf.lines()
for line in B2XMuMuLines:
print "CL DEBUG", line
print "CL DEBUG", line.name()
stripline = B2XMuMuLines[0]
sstream = StrippingStream("TestStream")
sstream.appendLines([stripline])
sstream.OutputLevel = 2
sc = StrippingConf(
Streams=[sstream],
HDRLocation="DecReports",
)
Strip_Location1 = stripline.outputLocation()
print Strip_Location1
StripSel1 = AutomaticData(Location=Strip_Location1)
print StripSel1
print StripSel1.outputLocation()
print "ALL OK"
###########################################################
decay = "[B+ -> ^( J/psi(1S) -> ^mu- ^mu+) ^pi+]CC"
############################################################
## (1) read data from Turbo:
from PhysConf.Selections import AutomaticData
