def runsandbox(head,
find=None,
outputname="sandbox.dst",
runAllAfter=False,
findalg=findalg):
from GaudiConf.Manipulations import configurableInstanceFromString, nameFromConfigurable, postConfigCallable, configurableClassFromString
if find is None:
raise ValueError("You didn't ask me to search for anything!")
found, before, contains, after, contained_stuff = findalg(head, find)
print found, before, contains, after, contained_stuff
if not found:
raise NameError("I could not find the thing you asked me to excise!")
user_algs = getUserAlgs()
for a in before:
if a not in contains and a not in user_algs and a not in contained_stuff:
ac = configurableInstanceFromString(a)
ac.Enable = False
if not insertEmptyKiller(contains[-1], find):
raise ValueError("Could not insert EmptyNodeKiller")
if not insertSomething(contains[-1], find,
GaudiSequencer('PreExciseUserAlgs')):
raise ValueError("Could not insert PreAlgs")
if not insertSomething(
contains[-1], find, GaudiSequencer('PostExciseUserAlgs'),
before=False):
raise ValueError("Could not insert PostAlgs")
if not runAllAfter:
for a in after:
if a not in before and a not in contains and a not in user_algs and a not in contained_stuff:
ac = configurableInstanceFromString(a)
ac.Enable = False
from GaudiConf import IOExtension
IOExtension().inputFiles([outputname], clear=True)
return
def monitorSeq(self):
from Configurables import (TrackVertexMonitor,
ParticleToTrackContainer)
from Configurables import LoKi__VoidFilter as Filter
monitorSeq = GaudiSequencer("AlignMonitorSeq", IgnoreFilterPassed=True)
for i in self.getProp("TrackSelections"):
if isinstance(i, str): i = TrackSelection(i)
name = i.name()
location = i.location()
monitorSeq.Members += self.createTrackMonitors(name, location)
for i in self.getProp("ParticleSelections"):
location = i.location()
name = i.name()
pmonseq = GaudiSequencer("AlignMonitorSeq" + name)
# add a filter on the alignment particles
fltr = Filter('Seq' + name + 'Output',
Code=" 0 < CONTAINS ( '%s') " % location)
pmonseq.Members += [fltr]
pmonseq.Members += [
ParticleToTrackContainer(name + "ParticleToTrackForMonitoring",
ParticleLocation=location,
TrackLocation=location + "Tracks")
]
pmonseq.Members += self.createTrackMonitors(
name, location + "Tracks")
monitorSeq.Members.append(pmonseq)
if self.getProp("VertexLocation") != "":
monitorSeq.Members.append(
TrackVertexMonitor("AlignVertexMonitor",
PVContainer=self.getProp("VertexLocation")))
return monitorSeq
def _lumi(self):
"""
read FSR and accumulate event and luminosity data
calculate normalization - toolname:
"""
log.info("Creating Lumi Algorithms")
seq = []
self.setOtherProps(LumiAlgsConf(), ["DataType", "InputType"])
# add merge, touch-and-count sequence
lumiSeq = GaudiSequencer("LumiSeq")
LumiAlgsConf().LumiSequencer = lumiSeq
seq += [lumiSeq]
if self.getProp("Lumi"):
tupleFile = self.getProp('TupleFile')
if tupleFile == '':
log.warning(
'TupleFile has not been set. No Lumi ntuple will be produced.'
)
# add integrator for normalization
self.setOtherProps(LumiIntegratorConf(),
["InputType", "TupleFile", "IgnoreDQFlags"])
lumiInt = GaudiSequencer("IntegratorSeq")
LumiIntegratorConf().LumiSequencer = lumiInt
seq += [lumiInt]
return seq
def muonTracksFORmuonAlignment():
# this still needs to be worked out
from Configurables import Escher
Escher().RecoSequence = [
"Hlt", "Decoding", "AlignTr", "Vertex", "RICH", "CALO", "MUON", "PROTO"
] # ????
Escher().MoniSequence = ["Tr", "OT"]
# if the Escher hlt filter is not set, set it here
if not hasattr(Escher(), "HltFilterCode") or not Escher().HltFilterCode:
Escher(
).HltFilterCode = "HLT_PASS_RE( 'Hlt1DiMuonHighMass*Decision' )" # Hlt2-->Hlt1 requirement
# revive only particles used for trigger
print 'Hlt lines to be used: '
print ReviveHltTracks(['Hlt1DiMuonHighMassDecision'])
# Now create the J/psi candidates
from Configurables import CombineParticles, FilterDesktop
from CommonParticles.StdAllLooseMuons import StdAllLooseMuons # requires IsMuon==1
from CommonParticles.StdLooseJpsi2MuMu import StdLooseJpsi2MuMu # requires (ADAMASS('J/psi')<100.*MeV)&(ADOCACHI2CUT(30,'')) && "(VFASPF(VCHI2) < 25.)"
StdLooseJpsi2MuMu.DaughtersCuts = {"mu-": "( P> 6000*MeV)"} # momentum cut
## tighten the mass window for candidates used in alignment
AlignJpsi2MuMu = FilterDesktop(
"AlignJpsi2MuMu",
Inputs=["Phys/StdLooseJpsi2MuMu"],
Code="(ADMASS('J/psi(1S)') < 35.*MeV) & (VFASPF(VCHI2) < 10.)"
) # tighter requirements
from Configurables import ChargedProtoParticleMaker, ChargedProtoParticleAddMuonInfo
#####, ChargedProtoCombineDLLsAlg
from Configurables import TrackParticleMonitor, GaudiSequencer
recoJpsiSeq = GaudiSequencer("RecoJpsiSeq")
recoJpsiSeq.Members = [
ChargedProtoParticleMaker('ChargedProtoPMaker'),
ChargedProtoParticleAddMuonInfo('ChargedProtoPAddMuon'),
###ChargedProtoCombineDLLsAlg('ChargedProtoPCombDLLs'),
StdAllLooseMuons,
StdLooseJpsi2MuMu,
TrackParticleMonitor(
'StdLooseJpsi2MuMuMonitor',
InputLocation='/Event/Phys/StdLooseJpsi2MuMu/Particles',
MinMass=3000,
MaxMass=3190),
AlignJpsi2MuMu,
TrackParticleMonitor(
'AlignJpsi2MuMuMonitor',
InputLocation='/Event/Phys/AlignJpsi2MuMu/Particles',
MinMass=3000,
MaxMass=3190),
]
sel = ParticleSelection(Name='MufromJpsiMuMu',
Location='/Event/Phys/AlignJpsi2MuMu/Particles',
Algorithm=recoJpsiSeq)
return sel
def postMonitorSeq(self):
from Configurables import (TrackMonitor, TrackVertexMonitor)
monitorSeq = GaudiSequencer("AlignMonitorSeq")
postMonitorSeq = GaudiSequencer("AlignPostMonitorSeq")
for m in monitorSeq.Members:
copy = m.clone(m.name() + "Post")
postMonitorSeq.Members.append(copy)
return postMonitorSeq
def PostConfigurationActions():
from Configurables import GaudiSequencer
if not TrackContainter:
GaudiSequencer('MoniTrSeq').Members += [goodtracksselector]
if Efficiency:
GaudiSequencer('MoniTrSeq').Members += [itEff, ttEff]
if Residuals:
GaudiSequencer('MoniTrSeq').Members += [ttMon, itMon]
def configure(self, name="MuonPID", UseMC=True, HistosLevel="OfflineFull"):
"""
configure the MuonPIDchecker algorithm
"""
if self.debug: print "CONFIGURING MUONPIDCHECKER"
## check if input is already an instance or this must be created
ext = "Checker"
if (not UseMC): ext = "Monitor"
myalg1 = MuonPIDChecker(name + ext + "Long")
myalg1.HistoTopDir = "Muon/"
myalg1.RunningMC = UseMC
myalg1.TrackType = 0
myalg1.MonitorCutValues = self.info.MonitorCutValues
myalg1.HistoDir = name + "/" + ext + "Long"
if (HistosLevel == "Expert" or HistosLevel == "OfflineFull"):
myalg1.HistosOutput = 4
# Configure and additional instance to look at Downstream tracks
myalg2 = MuonPIDChecker(name + ext + "Down")
myalg2.HistoTopDir = "Muon/"
myalg2.RunningMC = UseMC
myalg2.HistosOutput = 1
myalg2.TrackType = 1
myalg2.MonitorCutValues = self.info.MonitorCutValues
myalg2.HistoDir = name + "/" + ext + "Down"
myalg2.HistosOutput = 4
if (HistosLevel == "OfflineFull"):
myalg1.HistosOutput = 3
myalg2.HistosOutput = 3
if (UseMC):
GaudiSequencer("CheckMUONSeq").Members += [
"MuonPIDChecker/" + name + ext + "Down"
]
else:
GaudiSequencer("MoniMUONSeq").Members += [
"MuonPIDChecker/" + name + ext + "Down"
]
else:
if (HistosLevel == "OfflineExpress"):
myalg1.HistosOutput = 2
if (HistosLevel == "Online"):
myalg1.HistosOutput = 1
if (HistosLevel == "None"):
myalg1.HistosOutput = 0
if (UseMC):
GaudiSequencer("CheckMUONSeq").Members += [
"MuonPIDChecker/" + name + ext + "Long"
]
else:
GaudiSequencer("MoniMUONSeq").Members += [
"MuonPIDChecker/" + name + ext + "Long"
]
def _unpackProtoParticles(self):
from Configurables import (GaudiSequencer, UnpackProtoParticle)
# Neutrals
# --------
neutralLoc = "/Event/Rec/ProtoP/Neutrals"
unpackNeutrals = UnpackProtoParticle(
name="UnpackNeutralProtos",
OutputName=neutralLoc,
InputName="/Event/pRec/ProtoP/Neutrals")
DataOnDemandSvc().AlgMap[neutralLoc] = unpackNeutrals
# Charged
# -------
chargedLoc = "/Event/Rec/ProtoP/Charged"
chargedSeq = GaudiSequencer("UnpackChargedProtosSeq")
DataOnDemandSvc().AlgMap[chargedLoc] = chargedSeq
# Unpacker
unpackCharged = UnpackProtoParticle(
name="UnpackChargedProtos",
OutputName=chargedLoc,
InputName="/Event/pRec/ProtoP/Charged")
chargedSeq.Members += [unpackCharged]
# Additional processing, not for MDST
inputtype = self.getProp('DstType').upper()
if inputtype != 'MDST':
# PID calibration
from Configurables import (ChargedProtoParticleAddRichInfo,
ChargedProtoParticleAddMuonInfo,
ChargedProtoCombineDLLsAlg, TESCheck)
recalib = GaudiSequencer("ProtoParticleCombDLLs")
recalib.IgnoreFilterPassed = False
chargedSeq.Members += [recalib]
# Filter to check in Protos exist
recalib.Members += [
TESCheck(name="CheckChargedProtosExist",
Inputs=[chargedLoc],
OutputLevel=5,
Stop=False)
]
# Add Rich and Muon PID results to protoparticles
recalib.Members += [
ChargedProtoParticleAddMuonInfo("ChargedProtoPAddMuon")
]
recalib.Members += [
ChargedProtoParticleAddRichInfo("ChargedProtoPAddRich")
]
# Combined DLLs
recalib.Members += [
ChargedProtoCombineDLLsAlg("ChargedProtoPCombDLL")
]
def __configure(self):
recoSeq = GaudiSequencer("Hlt2JetRecoSequence", ModeOR = True, ShortCircuit = False)
from HltTracking.Hlt2TrackingConfigurations import Hlt2BiKalmanFittedForwardTracking
from HltTracking.Hlt2TrackingConfigurations import Hlt2BiKalmanFittedDownstreamTracking
# Long charged proto particles
longTracking = Hlt2BiKalmanFittedForwardTracking()
longChargedProtos = longTracking.hlt2ChargedNoPIDsProtos()
longSeq = GaudiSequencer("Hlt2JetLongRecoSequence", Members = longChargedProtos.members())
# Downstream charged proto particles
downTracking = Hlt2BiKalmanFittedDownstreamTracking()
downChargedProtos = downTracking.hlt2ChargedNoPIDsProtos()
downSeq = GaudiSequencer("Hlt2JetDownRecoSequence", Members = downChargedProtos.members())
from Hlt2SharedParticles.TrackFittedBasicParticles import BiKalmanFittedPhotons as Photons
from Hlt2SharedParticles.Pi0 import ResolvedPi0s
from Hlt2SharedParticles.Pi0 import MergedPi0s
from Hlt2SharedParticles.Ks import KsLLTF as KsLL
from Hlt2SharedParticles.Ks import KsLLTF as KsDD
from Hlt2SharedParticles.Lambda import LambdaLLTrackFitted as LambdaLL
from Hlt2SharedParticles.Lambda import LambdaDDTrackFitted as LambdaDD
self.__caloProcessor = longTracking.caloProcessor()
ecalSeq = self.__caloProcessor.clusters()
inputs = [
['Particle', 'particle', self.__sharedParticleInput(Photons, "Photons")],
['Particle', 'particle', self.__sharedParticleInput(ResolvedPi0s, "ResolvedPi0s")],
['Particle', 'particle', self.__sharedParticleInput(MergedPi0s, "MergedPi0s")],
['Particle', 'particle', self.__sharedParticleInput(KsLL, "KsLL")],
['Particle', 'particle', self.__sharedParticleInput(KsDD, "KsDD")],
['Particle', 'particle', self.__sharedParticleInput(LambdaLL, "LambdaLL")],
['Particle', 'particle', self.__sharedParticleInput(LambdaDD, "LambdaDD")],
['ProtoParticle', 'best', (longSeq, longChargedProtos.outputSelection())],
['ProtoParticle', 'best', (downSeq, downChargedProtos.outputSelection())],
['CaloCluster', 'gamma', (None, self.__findCaloLocation(Photons.members(), CellularAutomatonAlg, "OutputData"))],
['CaloCluster', 'gamma', self.__hcalClusters()],
['IClusTrTable2D', 'ecal', (None, self.__findCaloLocation(Photons.members(), PhotonMatchAlg, "Output"))],
['IClusTrTable2D', 'hcal', self.__hcal2Track(longTracking, Photons)]
]
pfInputs = []
for inputClass, inputType, (seq, loc) in inputs:
if seq and seq not in recoSeq.Members:
recoSeq.Members += [seq]
pfInputs.append([inputClass, inputType, loc])
from Configurables import HltParticleFlow
particleFlow = HltParticleFlow("HltParticleFlow", **self.getProp('ParticleFlowOptions'))
particleFlow.Inputs = pfInputs
particleFlow.Output = "Hlt2/ParticleFlow/Particles"
from HltLine.HltLine import bindMembers
self.__particleFlow = bindMembers("Hlt2Jet", [recoSeq, particleFlow])
def inputSeq(self, outputLevel=INFO):
if not allConfigurables.get("AlignInputSeq"):
if outputLevel == VERBOSE:
print "VERBOSE: Filter Sequencer not defined! Defining!"
inputSequencer = GaudiSequencer("AlignInputSeq")
inputSequencer.MeasureTime = True
trackselections = self.getProp("TrackSelections")
if len(trackselections) > 0:
trackInputSeq = GaudiSequencer("AlignTrackSelSeq",
IgnoreFilterPassed=True)
inputSequencer.Members.append(trackInputSeq)
# add the algorithms for the track selections to the sequence.
# also merge the tracks lists into one list
from Configurables import TrackListMerger
trackmerger = TrackListMerger(
"AlignTracks", outputLocation="Rec/Track/AlignTracks")
self.setProp("TrackLocation", trackmerger.outputLocation)
for i in trackselections:
alg = i.algorithm()
if alg: trackInputSeq.Members.append(alg)
trackmerger.inputLocations.append(i.location())
trackInputSeq.Members.append(trackmerger)
# add all particle selections
if len(self.getProp("ParticleSelections")) > 0:
particleInputSeq = GaudiSequencer("AlignParticleSelSeq",
IgnoreFilterPassed=True)
inputSequencer.Members.append(particleInputSeq)
from Configurables import FilterDesktop
particlemerger = FilterDesktop("AlignParticles", Code="ALL")
particlemerger.Code = "ALL"
particlemerger.CloneFilteredParticles = False
for i in self.getProp("ParticleSelections"):
alg = i.algorithm()
if alg:
particleInputSeq.Members.append(alg)
print "adding particleinputsel to sequence: ", i.name(
), i.algorithm(), i.location()
particlemerger.Inputs.append(i.location())
particleInputSeq.Members.append(particlemerger)
self.setProp("ParticleLocation",
'/Event/Phys/AlignParticles/Particles')
# add the PV selection
if hasattr(self, "PVSelection"):
inputSequencer.Members.append(
self.getProp("PVSelection").algorithm())
self.setProp("VertexLocation",
self.getProp("PVSelection").location())
return inputSequencer
else:
if outputLevel == VERBOSE:
print "VERBOSE: AlignInputSeq already defined!"
return allConfigurables.get("AlignInputSeq")
def sequence(self, tracks=[]):
seq = GaudiSequencer('CaloLines' + self.getName())
seq.Members[:] = []
self.setProp("Sequencer", seq)
context = self.getProp('Context')
if context == '':
self.setProp("Context", self.getName())
self.setProp("TrackLocations", tracks)
self.applyConf()
return seq
def _configureHistos(self):
monitorSeq = GaudiSequencer('TelaMonitors')
monitorSeq.IgnoreFilterPassed = True
monitorSeq.Members += self.getProp('Monitors')
self.teslaSeq.Members += [ monitorSeq ]
#
ApplicationMgr().HistogramPersistency = "ROOT"
if ( self.getProp("Histogram") != "" ):
HistogramPersistencySvc().OutputFile = self.getProp("Histogram")
def fullReco() :
from Configurables import ( ProcessPhase, GaudiSequencer, RecSysConf )
brunelSeq = GaudiSequencer("BrunelSequencer")
# analysis and Phys init are not run with MDF
GaudiSequencer("DaVinciInitSeq").Members += [ brunelSeq ]
brunelSeq.Members += [ "ProcessPhase/Init", "ProcessPhase/Reco", "ProcessPhase/Moni"]
ProcessPhase("Init").DetectorList += [ "Brunel", "Calo"]
GaudiSequencer("InitCaloSeq").Members += ["GaudiSequencer/CaloBanksHandler"]
importOptions("$CALODAQROOT/options/CaloBankHandler.opts")
configureMoni(False,False)
def getUserAlgs(findalg=findalg):
allalgs = []
from Configurables import GaudiSequencer
for alg in [
GaudiSequencer("PreExciseUserAlgs"),
GaudiSequencer('PostExciseUserAlgs')
]:
found, b, c, a, ci = findalg(alg, find="THisisprobablynotgoingtoexist")
allalgs = allalgs + b + c + a + ci
return allalgs
def __apply_configuration__(self):
print "******* calling ", self.name()
mainseq = self.getProp("Sequencer")
mainseq.getProperties()
if mainseq.name() == "":
mainseq = GaudiSequencer("AlignSeq")
mainseq.MeasureTime = True
print "****** setting up Kalman type alignment!"
self.setProp("Incident", 'UpdateConstants')
self.sequencers()
def Tuples():
"""
Simple class-like method to return DecayTreeTuple which can be used to
do quick-check on the output DST.
Usage:
>> from StrippingSelections.StrippingQEE import StrippingDitau
>> DaVinci().appendToMainSequence( StrippingDitau.Tuples() )
>> DaVinci().TupleFile = 'tuple.root'
"""
import re
from DecayTreeTuple.Configuration import DecayTreeTuple, EventTuple
seq = GaudiSequencer('TupleSeq')
seq.ModeOR = True
seq.ShortCircuit = False
for lname, decays in lines_decays.iteritems():
for process, desc in decays.iteritems():
desc = re.sub(r' ([a-z])', r' ^\1', desc) # regex insert ^
desc = desc.replace('cc', 'CC') # different between CombineP & DTT
#
## Extra complication for cand with RIF, such that the input location
# after isolation filter is not at default line location, but on the
# last algo's location. Otherwise the tuple will pick up candidates
# before isolation filtering.
root = 'Phys/Ditau%sLine' % lname
# if 'noiso' not in root:
# root = root.replace('Line','isoLine')
#
tup = DecayTreeTuple('Tup_' + process,
NTupleDir='Ditau',
TupleName=process)
tup.Inputs = [root + '/Particles']
tup.Decay = desc
tup.ToolList = [
'TupleToolKinematic',
]
tool = tup.addTupleTool('TupleToolConeIsolation')
tool.MinConeSize = 0.5
tool.MaxConeSize = 0.5
tool = tup.addTupleTool('LoKi::Hybrid::TupleTool')
tool.Variables = {
'CONEPX1': "RELINFO('%s/IsoPlus' , 'CONEPX')" % root,
'CONEPX2': "RELINFO('%s/IsoMinus', 'CONEPX')" % root,
'CONEPY1': "RELINFO('%s/IsoPlus' , 'CONEPY')" % root,
'CONEPY2': "RELINFO('%s/IsoMinus', 'CONEPY')" % root,
'CONEPT1': "RELINFO('%s/IsoPlus' , 'CONEPT')" % root,
'CONEPT2': "RELINFO('%s/IsoMinus', 'CONEPT')" % root,
}
seq.Members.append(tup)
return [seq]
def __apply_configuration__(self):
print "******* calling ", self.name()
mainseq = self.getProp("Sequencer")
mainseq.MeasureTime = True
mainseq.getProperties()
if mainseq.name() == "":
mainseq = GaudiSequencer("Align")
import VeloAlignment.VeloAlignmentConf
if 'Module' in self.getProp("ElementsToAlign"):
va = VeloAlignment.VeloAlignmentConf.VAlign()
print "Adding ", va.name(), " to sequence ", mainseq.name()
mainseq.Members += [va]
importOptions("$VELOALIGNMENTOPTS/VeloAlign.py")
self.sequencers()
def caloSequence(self, tracks=[]):
seq = GaudiSequencer(self.getName() + 'CaloSeq')
seq.Members[:] = []
self.setProp("CaloSequencer", seq)
context = self.getProp('Context')
if context == '':
self.setProp("Context", self.getName())
if tracks != []:
self.setProp("TrackLocations", tracks)
_log.info(
"CaloProcessor.caloSequence : update TrackLocation %s: " %
tracks)
self.applyConf()
return seq
def myHackedSequence():
decodeSeq = GaudiSequencer("RecoDecodingSeq")
from DAQSys.Decoders import DecoderDB
from DAQSys.DecoderClass import decodersForBank
decodeSeq.Members = []
vdec = DecoderDB["DecodeVeloRawBuffer/createVeloLiteClusters"]
vdec.DecodeToVeloClusters = False
vdec.DecodeToVeloLiteClusters = True
vdec.Active = True
decodeSeq.Members += [vdec.setup()]
tt = DecoderDB["RawBankToSTLiteClusterAlg/createTTLiteClusters"]
it = DecoderDB["RawBankToSTLiteClusterAlg/createITLiteClusters"]
decodeSeq.Members += [tt.setup(),it.setup()]
def configMonitor():
import os
from Gaudi.Configuration import EventPersistencySvc, HistogramPersistencySvc
from Configurables import (LHCbApp,
LHCb__RawDataCnvSvc,
GaudiSequencer,
UpdateAndReset,
createODIN,
ApplicationMgr )
app = LHCbApp()
app.DataType = '2015'
app.EvtMax = -1
EventPersistencySvc().CnvServices.append( LHCb__RawDataCnvSvc('RawDataCnvSvc') )
HistogramPersistencySvc().OutputFile = ''
HistogramPersistencySvc().Warnings = False
UpdateAndReset().saveHistograms = 1
#UpdateAndReset().saverCycle = 3600
from Configurables import EventClockSvc
EventClockSvc().EventTimeDecoder = 'OdinTimeDecoder'
appMgr = ApplicationMgr()
# Decoder
from Configurables import HCRawBankDecoder
decoder = HCRawBankDecoder()
decoder.Monitoring = True
# Monitor
from Configurables import HCDigitMonitor
monitor = HCDigitMonitor()
monitor.CrateB = 0
monitor.CrateF = 1
monitor.ChannelsB0 = [47, 46, 45, 44]
monitor.ChannelsB1 = [23, 22, 21, 20]
monitor.ChannelsB2 = [11, 10, 9, 8]
monitor.ChannelsF1 = [23, 22, 21, 46]
monitor.ChannelsF2 = [11, 10, 9, 8]
# Top level sequence
topSeq = GaudiSequencer("TopSequence")
topSeq.Members = [createODIN(), decoder, monitor]
appMgr.TopAlg = [topSeq]
return app, monitor
def algorithm(self):
Name = self._name
inputTrackLocation = self._inputLocation
from Configurables import GaudiSequencer, HltTrackConverter, TrackContainerCopy, Escher
from Configurables import TrackContainerCopy, TrackSelector
trackRefitSeq = GaudiSequencer(
self.name() + "Seq") # GaudiSequencer("TrackRefitSeq")
# create a track list for tracks with velo hits
velotrackselector = TrackContainerCopy(
"GoodLongRefittedVeloTracks",
inputLocations=["Rec/Track/Best"],
outputLocation="Rec/Track/GoodLongRefittedVeloTracks",
Selector=TrackSelector())
velotrackselector.Selector.MinNVeloRHits = 7
velotrackselector.Selector.MinNVeloPhiHits = 6
# refit the tracks in that list
from TrackFitter.ConfiguredFitters import *
velotrackrefitter = ConfiguredEventFitter(
Name="TracksWithVeloHitsFitter",
TracksInContainer="Rec/Track/GoodLongRefittedVeloTracks",
FieldOff=True)
velotrackrefitter.Fitter.MeasProvider.IgnoreIT = True
velotrackrefitter.Fitter.MeasProvider.IgnoreOT = True
velotrackrefitter.Fitter.MeasProvider.IgnoreTT = True
velotrackrefitter.Fitter.MeasProvider.IgnoreMuon = True
velotrackrefitter.Fitter.MakeNodes = True
velotrackrefitter.Fitter.MakeMeasurements = True
trackRefitSeq.Members += [velotrackselector, velotrackrefitter]
return trackRefitSeq
def configuredParticleListFromDST(ParticleLocation, FilterCode=""):
from Configurables import GaudiSequencer
from Configurables import TrackParticleRefitter, TrackMasterFitter
from TrackFitter.ConfiguredFitters import ConfiguredMasterFitter
# create a sequence to refit and monitor
name = ParticleLocation
name = name.replace("/Event", "")
name = name.replace("/Phys", "")
name = name.replace("/Particles", "")
name = name.replace("/", "")
fitter = TrackParticleRefitter(name + "Refitter",
TrackFitter=TrackMasterFitter(),
ParticleLocation=ParticleLocation)
ConfiguredMasterFitter(fitter.TrackFitter, SimplifiedGeometry=True)
seq = GaudiSequencer(name + "Seq", IgnoreFilterPassed=True)
seq.Members.append(fitter)
if FilterCode != "":
from Configurables import FilterDesktop
newLocation = ParticleLocation.replace("/Particles", "") + "Filtered"
newfilter = FilterDesktop( #name + "Filter",#Output =
newLocation,
Inputs=[ParticleLocation],
CloneFilteredParticles=False,
Code=FilterCode)
seq.Members.append(newfilter)
ParticleLocation = newLocation + "/Particles"
sel = ParticleSelection(Name=name,
Location=ParticleLocation,
Algorithm=seq)
return sel
def _init(self):
from Configurables import (PhysConf, AnalysisConf)
inputType = self.getProp("InputType").upper()
initSeqs = []
if ((inputType != 'MDST') & (inputType != "MDF") &
(inputType != "DIGI")):
physinit = PhysConf().initSequence() # PhysConf initSequence
# Analysis
AnalysisConf().RedoMCLinks = self.getProp("RedoMCLinks")
analysisinit = AnalysisConf().initSequence()
initSeqs = [physinit, analysisinit]
# if inputType == 'RDST' :
# log.info('Setting HltDecReportsDecoders RawEventLocations to ["pRec/RawEvent"]')
# from DAQSys.Decoders import DecoderDB
# from DAQSys.DecoderClass import decodersForBank
# for bank in ["Sel","Dec","Vertex","Track"]:
# for d in decodersForBank(DecoderDB,"Hlt"+bank+"Reports"):
# d.overrideInputs("pRec/RawEvent")
# #d.setup()
# from Configurables import ANNDispatchSvc
#
# ANNDispatchSvc().RawEventLocation = "pRec/RawEvent"
return GaudiSequencer('DaVinciEventInitSeq',
Members=initSeqs,
IgnoreFilterPassed=True)
def selMuonPParts(name, trackingSeq):
"""
Make ProtoParticles out of VeloMuon tracks
"""
veloprotos = ChargedProtoParticleMaker(name + "ProtoPMaker")
veloprotos.Inputs = ["Rec/VeloMuon/Tracks"]
veloprotos.Output = "Rec/ProtoP/" + name + "ProtoPMaker/ProtoParticles"
veloprotos.addTool(DelegatingTrackSelector, name="TrackSelector")
tracktypes = ["Long"]
veloprotos.TrackSelector.TrackTypes = tracktypes
selector = veloprotos.TrackSelector
for tsname in tracktypes:
selector.addTool(TrackSelector, name=tsname)
ts = getattr(selector, tsname)
# Set Cuts
ts.TrackTypes = [tsname]
veloprotoseq = GaudiSequencer(name + "ProtoPSeq")
veloprotoseq.Members += [veloprotos]
return GSWrapper(name="WrappedVeloMuonProtoPSeqFor" + name,
sequencer=veloprotoseq,
output='Rec/ProtoP/' + name +
'ProtoPMaker/ProtoParticles',
requiredSelections=[trackingSeq])
def configureSequence(self):
misalignSeq = GaudiSequencer("MisAlignSequence")
ApplicationMgr().TopAlg = [misalignSeq]
misalignSeq.Members += ["MisAlignAlg"]
from Configurables import WriteAlignmentConditions
if "VELO" in self.getProp("Detectors"):
writeVelo = WriteAlignmentConditions()
writeVelo.topElement = "/dd/Structure/LHCb/BeforeMagnetRegion/Velo"
writeVelo.outputFile = "VeLo_1.xml"
writeVelo.depths = [0, 1, 2, 3]
misalignSeq.Members += [writeVelo]
if "OT" in self.getProp("Detectors"):
writeOT = WriteAlignmentConditions()
writeOT.topElement = "/dd/Structure/LHCb/AfterMagnetRegion/T/OT"
writeOT.depths = [0, 1, 2, 3]
writeOT.outputFile = "OT_1.xml"
misalignSeq.Members += [writeOT]
if "TT" in self.getProp("Detectors"):
writeTT = WriteAlignmentConditions()
writeTT.topElement = "/dd/Structure/LHCb/BeforeMagnetRegion/TT"
writeTT.outputFile = "TT_1.xml"
writeTT.depths = [0, 1, 2, 3]
misalignSeq.Members += [writeTT]
if "IT" in self.getProp("Detectors"):
writeIT = WriteAlignmentConditions()
writeIT.topElement = "/dd/Structure/LHCb/AfterMagnetRegion/T/IT"
writeIT.outputFile = "IT_1.xml"
writeIT.depths = [0, 1, 2, 3]
misalignSeq.Members += [writeIT]
def trackingPreFilter(name, prefilter):
VeloMuonBuilder1 = VeloMuonBuilder("VeloMuonBuilder")
VeloMuonBuilder1.OutputLevel = 6
VeloMuonBuilder1.MuonLocation = "Hlt1/Track/MuonSeg"
VeloMuonBuilder1.VeloLocation = "Rec/Track/UnFittedVelo"
VeloMuonBuilder1.lhcbids = 4
VeloMuonBuilder1.OutputLocation = "Rec/VeloMuon/Tracks"
preve = TrackPrepareVelo("preve")
preve.inputLocation = "Rec/Track/Velo"
preve.outputLocation = "Rec/Track/UnFittedVelo"
preve.bestLocation = ""
alg = GaudiSequencer(
"VeloMuonTrackingFor" + name,
Members=[
DecodeVeloRawBuffer(name + "VeloDecoding",
DecodeToVeloLiteClusters=True,
DecodeToVeloClusters=True),
FastVeloTracking(name + "FastVelo",
OutputTracksName="Rec/Track/Velo"), preve,
StandaloneMuonRec(name + "MuonStandalone"), VeloMuonBuilder1
])
return GSWrapper(name="WrappedVeloMuonTracking",
sequencer=alg,
output='Rec/VeloMuon/Tracks',
requiredSelections=prefilter)
def genConfigAction():
def gather(c, overrule):
def check(config, prop, value):
if prop not in config.getDefaultProperties(): return False
if hasattr(config, prop):
return getattr(config, prop) == value
return config.getDefaultProperties()[prop] == value
def addOverrule(config, rule):
if c.name() not in overrule.keys():
overrule[c.name()] = []
if rule not in overrule[c.name()]:
overrule[c.name()] += [rule]
if check(c, 'HistoProduce', False):
addOverrule(c, 'HistoProduce:@OnlineEnv.Monitor@False')
if c.getType() in ['FilterDesktop', 'CombineParticles'
] and check(c, 'Monitor', False):
addOverrule(c, 'Monitor:@OnlineEnv.Monitor@False')
if check(c, 'Enable', False):
addOverrule(c, 'OutputLevel:3')
for p in ['Members', 'Filter0', 'Filter1']:
if not hasattr(c, p): continue
x = getattr(c, p)
if list is not type(x): x = [x]
for i in x:
gather(i, overrule)
from Configurables import HltGenConfig, GaudiSequencer
HltGenConfig().Overrule = {
'Hlt1ODINTechnicalPreScaler':
['AcceptFraction:@OnlineEnv.AcceptRate@0']
}
gather(GaudiSequencer('Hlt'), HltGenConfig().Overrule)
print HltGenConfig()
def trackingPreFilter(name, prefilter):
VeloMuonBuilder1 = VeloMuonBuilder("VeloMuonBuilder")
VeloMuonBuilder1.OutputLevel = 6
VeloMuonBuilder1.MuonLocation = "Hlt1/Track/MuonSeg"
VeloMuonBuilder1.VeloLocation = "Rec/Track/UnFittedVelo"
VeloMuonBuilder1.lhcbids = 4
VeloMuonBuilder1.OutputLocation = "Rec/VeloMuon/Tracks"
preve = TrackPrepareVelo("preve")
preve.inputLocation = "Rec/Track/Velo"
preve.outputLocation = "Rec/Track/UnFittedVelo"
preve.bestLocation = ""
#TODO: apparently FastVelo is now (april 2012) run with fixes in the production which don't neccessarily apply to the stripping...
alg = GaudiSequencer(
"VeloMuonTrackingFor" + name,
Members=[
DecodeVeloRawBuffer(name + "VeloDecoding",
DecodeToVeloLiteClusters=True,
DecodeToVeloClusters=True),
FastVeloTracking(name + "FastVelo",
OutputTracksName="Rec/Track/Velo"), preve,
StandaloneMuonRec(name + "MuonStandalone"), VeloMuonBuilder1
])
return GSWrapper(name="WrappedVeloMuonTracking",
sequencer=alg,
output='Rec/VeloMuon/Tracks',
requiredSelections=prefilter)
def configureInput(self, inputType):
"""
Tune initialisation according to input type
"""
# By default, Brunel only needs to open one input file at a time
# Only set to zero if not previously set to something else.
if not IODataManager().isPropertySet("AgeLimit") : IODataManager().AgeLimit = 0
if self._isReprocessing(inputType):
# Kill knowledge of any previous Brunel processing
from Configurables import ( TESCheck, EventNodeKiller )
InitReprocSeq = GaudiSequencer( "InitReprocSeq" )
if ( self.getProp("WithMC") and inputType in ["XDST","DST"] ):
# Load linkers, to kill them (avoid appending to them later)
InitReprocSeq.Members.append( "TESCheck" )
TESCheck().Inputs = ["Link/Rec/Track/Best"]
killer = EventNodeKiller()
killer.Nodes += [ "Raw", "Link/Rec" ]
if self.getProp("SkipTracking"):
killer.Nodes += [ "pRec/Rich", "pRec/Muon", "pRec/Calo", "pRec/Track/Muon", "pRec/ProtoP" ]
else:
killer.Nodes += [ "pRec", "Rec" ]
InitReprocSeq.Members.append( killer )
### see configureOutput to see how the remainder of the juggler is configured
# Get the event time (for CondDb) from ODIN
from Configurables import EventClockSvc
EventClockSvc().EventTimeDecoder = "OdinTimeDecoder";
def trackingPreFilter(name, prefilter):
VeloMuonBuilder1 = VeloMuonBuilder("VeloMuonBuilder")
VeloMuonBuilder1.OutputLevel = 6
VeloMuonBuilder1.MuonLocation = "Hlt1/Track/MuonSeg"
VeloMuonBuilder1.VeloLocation = "Rec/Track/FittedVelo"
VeloMuonBuilder1.lhcbids = 4
VeloMuonBuilder1.OutputLocation = "Rec/VeloMuon/Tracks"
preve = TrackPrepareVelo("preve")
preve.inputLocation = "Rec/Track/Velo"
preve.outputLocation = "Rec/Track/UnfittedPreparedVelo"
preve.bestLocation = ""
vefit = ConfiguredFit("vefit", "Rec/Track/UnfittedPreparedVelo")
vefit.TracksOutContainer = "Rec/Track/FittedVelo"
vefit.addTool(TrackMasterFitter, name='Fitter')
ConfiguredFastFitter(getattr(vefit, 'Fitter'))
alg = GaudiSequencer(
"VeloMuonTrackingFor" + name,
Members=[
DecodeVeloRawBuffer(name + "VeloDecoding",
DecodeToVeloLiteClusters=True,
DecodeToVeloClusters=True),
FastVeloTracking(name + "FastVelo",
OutputTracksName="Rec/Track/Velo"), preve, vefit,
StandaloneMuonRec(name + "MuonStandalone"), VeloMuonBuilder1
])
return GSWrapper(name="WrappedVeloMuonTracking",
sequencer=alg,
output='Rec/VeloMuon/Tracks',
requiredSelections=prefilter)
def copyGoodEvents(filename, extraitems=[], incident='GoodEvent'):
"""
Utitity to copy ``good/tagged'' events
It is based on configurables,
thus it needs to be invoked BEFORE GaudiPython
#
##Configurables:
#
from Bender.Utils import copyGoodEvents
copyGoodEvents ( filename = 'SelectedEvents' )
"""
from GaudiConf import IOHelper
ioh = IOHelper('ROOT', 'ROOT')
algs = ioh.outputAlgs(filename, 'InputCopyStream/%s' % incident)
ioh.setupServices()
from Configurables import Gaudi__IncidentFilter as Tagger
tag = Tagger("%sInc" % incident, Incidents=[incident])
from Configurables import GaudiSequencer
seq = GaudiSequencer('%sSeq' % incident, Members=[tag] + algs)
from Configurables import ApplicationMgr
AM = ApplicationMgr()
if not AM.OutStream: AM.OutStream = []
AM.OutStream.append(seq)
logger.info("Prepare the file %s to keep ``%s'' incidents" %
(filename, incident))
def ParticleRefitterSeq(inputs = [],rootInTES = "/Event",scale=True):
from Configurables import GaudiSequencer
from Configurables import TrackScaleState as SCALER
from Configurables import ParticleRefitter
scaler = SCALER("Scaler", RootInTES = rootInTES)
seq = GaudiSequencer("ParticleRefitterSeq")
if scale:
seq.Members = [ scaler ]
else:
seq.Members = [ ]
refitter = ParticleRefitter()
if isinstance(inputs, basestring) :
refitter.Inputs = [inputs]
else :
refitter.Inputs = inputs
refitter.RootInTES = rootInTES
print "ParticleRefitterSeq is applied to the following inputs:"
for i in refitter.Inputs:
print " - on of the inputs is ", i
seq.Members += [refitter]
return seq
"phi" : "PHI",
"LV01" : "LV01" }
#BJpsiKS.addBranches({ # remove all "^" except where needed.
# "Jpsi" : "^(J/psi(1S) -> mu- mu+)",
# "muplus" : "J/psi -> mu- ^mu+",
# "muminus" : "J/psi -> ^mu- mu+"
# })
### Bplus tools
### Jpsi tools
#BJpsiKS.Jpsi.addTupleTool("TupleToolDownEff")
################################################################
################################################################
Seq1 = GaudiSequencer("Seq1")
Seq1.Members += [ SeqKsPiPi.sequence(), KsPiPiTuple ]
Seq1.Members += [ SeqLambdaPPi.sequence(), LambdaPPiTuple ]
Seq1.ShortCircuit = False
Seq1.ModeOR = True
# ######################################################################################################
DaVinci().MainOptions = ""
DaVinci().UserAlgorithms = [Seq1]
########################################################################
DaVinci().EvtMax = -1
DaVinci().DataType = "2016"
DaVinci().PrintFreq = 100
DaVinci().Lumi = False
DaVinci().InputType = "DST"
# Standard app configuration
from Configurables import (ApplicationMgr,
GaudiSequencer,
GaudiTesting__OddEventsFilter as OddEvents,
GaudiTesting__EvenEventsFilter as EvenEvents,
SubAlg as EmptyAlg,
OutputStream, InputCopyStream)
oddEvtSelect = GaudiSequencer('OddEventsSelection')
oddEvtSelect.Members = [OddEvents('OddEvents'),
OutputStream('Stream1')]
evenEvtSelect = GaudiSequencer('EvenEventsSelection')
evenEvtSelect.Members = [EvenEvents('EvenEvents'),
InputCopyStream('Stream2')]
app = ApplicationMgr(EvtSel='NONE', EvtMax=4)
app.TopAlg = [EmptyAlg("EventInit"), evenEvtSelect, oddEvtSelect]
# Extension used to enforce deferring
from Configurables import (ApplicationMgr, EventDataSvc,
ReplayOutputStream,
SubAlg as EmptyAlg)
app = ApplicationMgr()
app.AlgTypeAliases['OutputStream'] = 'RecordOutputStream'
app.AlgTypeAliases['InputCopyStream'] = 'RecordOutputStream'
EventDataSvc(ForceLeaves=True)
outDelegate = ReplayOutputStream()
lb_mother = lb_mother_template.format(mu)
lb_combine = lb_combine_template.clone(lb_combine_name)
lb_combine.DecayDescriptor = lb_decay
lb_combine.DaughtersCuts = lb_daughters
lb_combine.MotherCut = lb_mother
# Output of combining Lc daughters is input to combining Lb daughters
lb_combine.Inputs = [
"Phys/StdAllNoPIDsMuons",
"Phys/{0}".format(lc_combine_name)
]
# Clone the DecayTreeTuple created above
cheat_tuple = tuple.clone("Tuple{0}".format(lb_combine_name))
cheat_tuple.Inputs = ["Phys/{0}".format(lb_combine_name)]
# Sequences for ntuple creation
dec_sequence = GaudiSequencer("SeqBook{0}".format(line))
dec_sequence.Members = [filter, tuple]
mc_sequence = GaudiSequencer("SeqMCGenBook{0}".format(line))
mc_sequence.Members = [mc_tuple]
cheat_sequence = GaudiSequencer("SeqMCCheatBook{0}".format(line))
cheat_sequence.Members = [lc_combine, lb_combine, cheat_tuple]
# Sequence for ntuple sequences
tuples_sequence = GaudiSequencer("SeqTuples{0}".format(line))
tuples_sequence.IgnoreFilterPassed = True
tuples_sequence.Members = [dec_sequence, mc_sequence, cheat_sequence]
# Sequence for MC filter then ntuple sequences
master_sequence = GaudiSequencer("SeqMaster{0}".format(line))
master_sequence.Members = [mc_filter, tuples_sequence]
particlesAndCuts = { "/Event/AllStreams/Phys/FullDSTDiMuonJpsi2MuMuDetachedLine/Particles" : "ALL" }
from PhysSelPython.Wrappers import Selection, SelectionSequence, AutomaticData
from Configurables import FilterDesktop
myInputParticlesList = []
myParticlesFilterList = []
myParticlesList = []
myParticlesSeqList = []
myParticlesLocationList = []
from Configurables import GaudiSequencer
filterSeq = GaudiSequencer( 'FilterSeq' )
filterSeq.ModeOR = True
mainSeq = GaudiSequencer( 'MainSeq' )
mainSeq.MeasureTime = True
mainSeq.IgnoreFilterPassed = False
codeIN = ""
for particles, cuts in particlesAndCuts.iteritems():
codeIN = codeIN.replace("||","|")
codeIN += "(CONTAINS( '"+str(particles)+"' )>0) || "
myParticlesName = particles.split("/")[-2]
myInputParticlesList += [ AutomaticData( Location = particles ) ]
def configure(datafiles, catalogs=[], castor=True, params=None):
"""
Configure the job
"""
from Configurables import DaVinci # needed for job configuration
# from Configurables import EventSelector # needed for job configuration
# from Configurables import NTupleSvc
from PhysConf.Filters import LoKi_Filters
fltrs = LoKi_Filters(
STRIP_Code="""
HLT_PASS_RE ( 'Stripping.*DiMuonHighMass.*Decision' )
""",
VOID_Code="""
0 < CONTAINS (
'/Event/AllStreams/Phys/FullDSTDiMuonDiMuonHighMassLine/Particles')
"""
)
filters = fltrs.filters('Filters')
filters.reverse()
from PhysSelPython.Wrappers import AutomaticData, Selection, SelectionSequence
#
# defimuon in stripping DST
#
# DiMuLocation =
# '/Event/Dimuon/Phys/FullDSTDiMuonDiMuonHighMassLine/Particles'
DiMuLocation = '/Event/AllStreams/Phys/FullDSTDiMuonDiMuonHighMassLine/Particles'
from PhysSelPython.Wrappers import AutomaticData
DiMuData = AutomaticData(Location=DiMuLocation)
# =========================================================================
# Upsilon -> mumu, cuts by Giulia Manca
# ========================================================================
from GaudiConfUtils.ConfigurableGenerators import FilterDesktop
UpsAlg = FilterDesktop(
Code="""
( M > 7 * GeV ) &
DECTREE ('Meson -> mu+ mu-' ) &
CHILDCUT( 1 , HASMUON & ISMUON ) &
CHILDCUT( 2 , HASMUON & ISMUON ) &
( MINTREE ( 'mu+' == ABSID , PT ) > 1 * GeV ) &
( MAXTREE ( ISBASIC & HASTRACK , TRCHI2DOF ) < 4 ) &
( MINTREE ( ISBASIC & HASTRACK , CLONEDIST ) > 5000 ) &
( VFASPF ( VPCHI2 ) > 0.5/100 )
& ( abs ( BPV ( VZ ) ) < 0.5 * meter )
& ( BPV ( vrho2 ) < ( 10 * mm ) ** 2 )
""",
Preambulo=[
"vrho2 = VX**2 + VY**2"
],
ReFitPVs=True
)
UpsSel = Selection(
'UpsSel',
Algorithm=UpsAlg,
RequiredSelections=[DiMuData]
)
# =========================================================================
# chi_b -> Upsilon gamma
# ========================================================================
from GaudiConfUtils.ConfigurableGenerators import CombineParticles
ChibCombine = CombineParticles(
DecayDescriptor="chi_b1(1P) -> J/psi(1S) gamma",
DaughtersCuts={
"gamma": " ( 350 * MeV < PT ) & ( CL > 0.01 ) "
},
CombinationCut="""
( AM - AM1 ) < 3 * GeV
""",
MotherCut=" PALL",
#
# we are dealing with photons!
#
ParticleCombiners={
'': 'LoKi::VertexFitter'
}
)
from StandardParticles import StdLooseAllPhotons # needed for chi_b
ChibSel1 = Selection(
'PreSelChib',
Algorithm=ChibCombine,
RequiredSelections=[UpsSel, StdLooseAllPhotons]
)
from GaudiConfUtils.ConfigurableGenerators import Pi0Veto__Tagger
TagAlg = Pi0Veto__Tagger(
ExtraInfoIndex=25001, # should be unique!
MassWindow=20 * MeV, # cut on delta-mass
MassChi2=-1, # no cut for chi2(mass)
)
ChibSel2 = Selection(
'Chi_b',
Algorithm=TagAlg,
RequiredSelections=[ChibSel1]
)
Chib = SelectionSequence("ChiB", TopSelection=ChibSel2)
# print 'OUTPUT!!!' , output_loc
# =========================================================================
# Upsilons
# ========================================================================
Ups = SelectionSequence("UpsSelSeq", TopSelection=UpsSel)
# ========================================================================
from Configurables import GaudiSequencer
myChibSeq = GaudiSequencer('MyChibSeq')
myChibSeq.Members = [Chib.sequence()] + ["ChibAlg"]
myUpsSeq = GaudiSequencer('MyUpsSeq')
myUpsSeq.Members = [Ups.sequence()] + ["UpsilonAlg"]
davinci = DaVinci(
EventPreFilters=filters,
DataType='2011',
Simulation=True,
InputType='DST',
HistogramFile="chib_histos.root",
TupleFile="chib_tuples.root",
PrintFreq=1000,
Lumi=True,
EvtMax=-1
)
davinci.UserAlgorithms = [myChibSeq, myUpsSeq]
# =========================================================================
from Configurables import Gaudi__IODataManager as IODataManager
IODataManager().AgeLimit = 2
# =========================================================================
# come back to Bender
setData(datafiles, catalogs, castor)
gaudi = appMgr()
alg_chib = ChibMC(
'ChibAlg', # Algorithm name ,
# input particles
Inputs=[
Chib.outputLocation()
],
# take care about the proper particle combiner
ParticleCombiners={'': 'LoKi::VertexFitter'}
)
alg_ups = UpsilonMC(
'UpsilonAlg', # Algorithm name ,
# input particles
Inputs=[
Ups.outputLocation()
],
# take care about the proper particle combiner
ParticleCombiners={'': 'LoKi::VertexFitter'}
)
alg_chib.nb = alg_ups.nb = params['nb']
alg_chib.np = alg_ups.np = params['np']
# =========================================================================
return SUCCESS
def defaultD0Selection():
from Configurables import Escher, TAlignment
Escher().RecoSequence = ["Hlt","Decoding","AlignTr","Vertex","RICH" ]
Escher().MoniSequence = ["Tr","OT"]
# Tweak a little bit RICH
from TAlignment.ParticleSelections import MinimalRichSequence
MinimalRichSequence()
# now create the D0->K-Pi+ candidates
from Configurables import FilterDesktop
from Configurables import ChargedProtoParticleMaker, ChargedProtoParticleAddRichInfo, ChargedProtoCombineDLLsAlg
# take as much as possible from CommonParticles
from CommonParticles.StdAllLooseKaons import StdAllLooseKaons
from CommonParticles.StdAllLoosePions import StdAllLoosePions
from CommonParticles.StdLooseKaons import StdLooseKaons
from CommonParticles.StdLoosePions import StdLoosePions
from CommonParticles.StdLooseD02HH import StdLooseD02KPi
# remove cuts that require a PV
StdLooseD02KPi.MotherCut = "((VFASPF(VCHI2)<10) & (ADMASS('D0')<100*MeV))"
StdLooseKaons.Code = "ALL"
StdLoosePions.Code = "ALL"
# add tight PID cuts basically toensure that we don't swap the
# kaon and pion.
AlignD02KPiWide = FilterDesktop("AlignD02KPiWide",
Inputs = ["Phys/StdLooseD02KPi"],
Code = "(ADMASS('D0') < 50.*MeV) & (VFASPF(VCHI2) < 9.)" \
" & (MINTREE('K+'==ABSID, PIDK) > 0)" \
" & (MINTREE('pi+'==ABSID, PIDK) < 0)" )
# tighten the mass window for candidates used in alignment.
AlignD02KPi = FilterDesktop("AlignD02KPi",
Inputs = ["Phys/AlignD02KPiWide"],
Code = "(ADMASS('D0') < 20.*MeV)" )
# create the sequence that we pass to the alignment
from Configurables import TrackParticleMonitor, GaudiSequencer
recoD0Seq= GaudiSequencer("RecoD0Seq")
recoD0Seq.Members = [
ChargedProtoParticleMaker('ChargedProtoPMaker'),
ChargedProtoParticleAddRichInfo('ChargedProtoPAddRich'),
ChargedProtoCombineDLLsAlg('ChargedProtoPCombDLLs'),
TrackParticleMonitor('StdLooseD02KPiMonitor',
InputLocation = '/Event/Phys/StdLooseD02KPi/Particles',
MinMass = 1810, MaxMass = 1930),
AlignD02KPiWide,
TrackParticleMonitor('AlignD02KPiWideMonitor',
InputLocation = '/Event/Phys/AlignD02KPiWide/Particles',
MinMass = 1810, MaxMass = 1930),
AlignD02KPi,
TrackParticleMonitor('AlignD02KPiMonitor',
InputLocation = '/Event/Phys/AlignD02KPi/Particles',
MinMass = 1810, MaxMass = 1930)
]
from TAlignment.ParticleSelections import ParticleSelection
sel = ParticleSelection( Name = 'D02KPi',
Location = '/Event/Phys/AlignD02KPi/Particles',
Algorithm = recoD0Seq )
return sel
# Configure Stripping
from Configurables import ProcStatusCheck
filterBadEvents = ProcStatusCheck()
sc = StrippingConf( Streams = [ MyStream ],
MaxCandidates = 2000,
AcceptBadEvents = False,
BadEventSelection = filterBadEvents )
from Configurables import StrippingReport
sr = StrippingReport(Selections = sc.selections());
MySequencer = GaudiSequencer('Sequence')
MySequencer.Members = [sc.sequence(),sr]
MySequencer.IgnoreFilterPassed = True
DaVinci().appendToMainSequence([killer, MySequencer])
from Configurables import FilterInTrees
rho_list = FilterInTrees( 'rho_list', Code = "'rho(770)0'==ABSID")
rho_Sel = Selection ( "rho_Sel" , Algorithm =rho_list , RequiredSelections = [ AutomaticData(Location = location) ] )
rho_Seq = SelectionSequence("rho_Seq", TopSelection = rho_Sel)
mothers[mother] = mothers_templates[mother].format(*tracks)
for daughter in daughters_templates:
daughters[daughter] = daughters_templates[daughter].format(*tracks)
for mother in mc_mothers_templates:
mc_mothers[mother] = mc_mothers_templates[mother].format(*tracks)
for daughter in mc_daughters_templates:
mc_daughters[daughter] = mc_daughters_templates[daughter].format(*tracks)
# Tuple for stripped and reconstructed events
t = tuple_templates.lc2pxx_tuple(
"Tuple{0}".format(line),
decay_template.format(*tracks),
mothers,
daughters,
inputs_template.format(stripping),
True
)
# Tuple for generated events
mc_t = tuple_templates.mc_decay_tree_tuple(
"MCGenTuple{0}".format(line),
mc_decay_template.format(*tracks),
mc_mothers,
mc_daughters
)
# Stripped tuple will only be filled if MC tuple is
sequence = GaudiSequencer("SeqBook{0}".format(line))
sequence.Members = [mc_t, t]
DaVinci().UserAlgorithms.append(sequence)
def configure ( inputdata , ## the list of input files
catalogs = [] , ## xml-catalogs (filled by GRID)
castor = False , ## use the direct access to castor/EOS ?
params = {} ) :
## configure Track <--> MC relation table
import LoKiPhysMC.Track2MC_Configuration
import LoKiMC.MC
## import DaVinci
from Configurables import DaVinci, GaudiSequencer
## delegate the actual configurtaion to DaVinci
dv = DaVinci ( DataType = '2011' ,
InputType = 'MDST',
Lumi = True,
Simulation = True,
DDDBtag="MC11-20111102",
CondDBtag="sim-20111111-vc-md100",
HistogramFile = "mcd02kpi_tracks7_histo.root",
TupleFile = "mcd02kpi_tracks7_ntuple.root",
PrintFreq = 1000)
from Configurables import DecayTreeTuple, FilterDesktop, TupleToolGeometry, CombineParticles
from Configurables import MCDecayTreeTuple, TupleToolMCTruth, MCTupleToolHierarchy
from PhysSelPython.Wrappers import AutomaticData, Selection, SelectionSequence, DataOnDemand
from Configurables import CheckPV
# First using CombineParticle to create the D0
################################################################################
#from StandardParticles import StdAllNoPIDsPions, StdAllNoPIDsKaons
_pions = DataOnDemand(Location='Phys/StdAllNoPIDsPions/Particles')
_kaons = DataOnDemand(Location='Phys/StdAllNoPIDsKaons/Particles')
_d2kpi = CombineParticles("d2kpi")
_d2kpi.DecayDescriptor = "[D0 -> K- pi+]cc"
_d2kpi.DaughtersCuts = { "K-" : "(PT > 500.0) & (0.0 < PIDK)",
"pi+" : "(PT > 500.0) & (5.0 > PIDK)",
"K+" : "(PT > 500.0) & (0.0 < PIDK)",
"pi-" : "(PT > 500.0) & (5.0 > PIDK) " }
_d2kpi.MotherCut = "(VFASPF(VCHI2/VDOF)<10)"
_d2kpi.CombinationCut = "(ADAMASS('D0') < 50.0)"
_d2kpi.Preambulo = [
"from LoKiPhysMC.decorators import *" ,
"from PartProp.Nodes import CC" ]
#_d2kpi.ReFitPVs = True
SelD2KPi = Selection( "SelD2KPi",
Algorithm= _d2kpi,
RequiredSelections=[_pions,_kaons] )
SeqD2KPi = SelectionSequence('SeqD2KPi',TopSelection = SelD2KPi)
# Now the CheckPV method to filter algorithms
c = CheckPV("OnePV")
c.MinPVs = 1
# And a sequencer to put them together
gseq = GaudiSequencer()
gseq.Members = [ c, SeqD2KPi.sequence() ]
## define the input data
setData ( inputdata , catalogs , castor )
## get/create application manager
gaudi = appMgr()
#
## modify/update the configuration:
#
## (1) create the algorithm
alg = TrackFilter( 'TrackFilter' )
#seq = createSequencer()
## (2) replace the list of top level algorithm by
# new list, which contains only *THIS* algorithm
gaudi.setAlgorithms( [ gseq, alg ] )
return SUCCESS
def doIt():
#------------------------------
#Configure PrChecker
#------------------------------
from Configurables import GaudiSequencer
from Configurables import PrChecker
from Configurables import IdealStateCreator
GaudiSequencer("CheckPatSeq").Members += []
prChecker = PrChecker()
from Configurables import IdealStateCreator
if (Plotta):
prChecker.WriteTTrackHistos = 2
prChecker.Eta25Cut = Eta25Cut
prChecker.UseElectrons = False
prChecker.TriggerNumbers = True
GaudiSequencer("CheckPatSeq").Members +=[prChecker]
from Configurables import MCParticle2MCHitAlg, IdealStateCreator, PrPlotFTHits
# Define the algorithms
FTAssoc = MCParticle2MCHitAlg( "MCP2FTMCHitAlg",
MCHitPath = "MC/FT/Hits",
OutputData = "/Event/MC/Particles2MCFTHits" )
# tell the Data On Demand Service about them
DataOnDemandSvc().AlgMap[ "/Event/Link/MC/Particles2MCFTHits" ] = FTAssoc
DataOnDemandSvc().NodeMap[ "/Event/Link" ] = "DataObject"
DataOnDemandSvc().NodeMap[ "/Event/Link/MC" ] = "DataObject"
#---------------------------------
#Configure the HitManager
#---------------------------------
#if (ConfigureManager):
# from Configurables import PrFTHitManager
# manager = PrFTHitManager("PrFTHitManager")
# manager.fracPosOffset = fracPos
# manager.doTuple = manager
# manager.HackSize1 = False
# manager.FixError = False
# manager.SizeFix = FixedSize
#---------------------------------
#Configure the Seeding Tracking
#---------------------------------
seedingSeq = GaudiSequencer("TrSeedingSeq")
GaudiSequencer("TrBestSeq").Members = []
GaudiSequencer("TrSeedingSeq").Members = []
#if you do truthmatching in the pat reco
GaudiSequencer("MCLinksUnpackSeq").Members =[]
GaudiSequencer("RecoTrSeq").Members += [ seedingSeq ]
from Configurables import PrHybridSeeding
seeding = PrHybridSeeding()
#seeding.OutputLevel = DEBUG #Uncomment this line for debug
seeding.InputName ="" #Standalone seeding Put "Forward to get forward imput"
seeding.MaxNHits = 12 #Force algorithm to find 12 Hits track when > 12
seeding.DecodeData = True # Switch it off if Runned after Forward
seeding.XOnly = False
#N Cases
seeding.NCases = 3
seeding.MinXPlanes = 4
#Clones Kill
seeding.RemoveClonesX = True
seeding.RemoveClones = True
seeding.minNCommonUV = 7 #>=7
seeding.minCommonX = [2,2,2] # N Common X (Remove Clones [Case0,Case1,Case2])
seeding.RemoveClonesUpDown = False # should Speed Up
seeding.minNCommonUVUpDown = 2 #>=2
#Flag Hits
seeding.FlagHits = True
seeding.SizeToFlag = 12 # >=size
seeding.RemoveFlagged = True # Case 1 and 2 will not use flagged Hits
#If Flag Size = 11
seeding.Flag_MaxChi2 = 0.3 # track.chi2(hit) = 0.3
seeding.Flag_MaxX0 = 200 # <200
#dRatio Business
seeding.UseCubicCorrection = True # dRatio correction in the fit
seeding.dRatio = -0.000262
seeding.UseCorrPosition = True # dRatio( x,y)
seeding.UseCorrSlopes = False # dRatio( bx, by)
seeding.CConst = 2.458e8 # BackwardProjection ( To be used somewhere in the algo )
#Recover Track ( to be fully implemented properly)
seeding.RecoverTrack = False
seeding.ChiDoFRecover = -1.0
#Case 0,1,2 parameters 1st Last search
#XZ-Search
# 1st - Last Layer
seeding.L0_AlphaCorr = [120.64, 510.64, 730.64 ]
seeding.L0_tolHp = [280.0 , 540.0 , 1080.0 ]
# ParabolaSeedHits
seeding.x0Corr = [0.002152, 0.001534, 0.001534]
seeding.X0SlopeChange = [500. , 500. , 500. ]
seeding.x0Cut = [4000. , 4000., 4000. ]
seeding.TolAtX0Cut = [12.0 , 8.0 , 8.0 ]
seeding.ToleranceX0Up = [ 0.75 , 0.75, 0.75 ]
seeding.X0SlopeChangeDown = [ 1500. , 2000., 1500. ]
seeding.TolAtX0CutOpp = [3.0 , 2.0, 2.0 ]
seeding.ToleranceX0Down = [ 0.75 , 0.75, 0.75 ]
seeding.TolXRemaining = [1.0 , 1.0 , 1.0]
seeding.maxParabolaSeedHits = 12 # Hits are sorted by the distance from
# x0 = first-last projection to z=0 ; then hits sorted by xParabola - (x0+tx_1stLast*z_PlaneParabola + x0Corr*x0) and we keep the first maxParabolaSeedHits list
seeding.maxChi2HitsX = [5.5 , 5.5 , 5.5 ]
seeding.maxChi2DoFX = [4.0 , 5.0 , 6.0 ]
#Add Stereo Part
seeding.DoAsymm = True
seeding.TriangleFix = True
seeding.TriangleFix2ndOrder = True
seeding.yMin = -1.0
seeding.yMin_TrFix = -2.0
seeding.yMax = 2700
seeding.yMax_TrFix = 30.0
seeding.RemoveHole = True
#Hough Cluster Size settings Hits are sorted by y/z where y is computed from the XZ-segment processed
seeding.TolTyOffset = [ 0.002 , 0.002 , 0.0035 ]
seeding.TolTySlope = [ 0.0 , 0.0 , 0.015 ]
#Once you find The UV hits you check the Line Y ?
seeding.UseLineY = True
#9 and 10 hits
seeding.Chi2LowLine = [ 5.0 , 6.0 , 7.0 ] #Chi2PerDoF when 10 Hits or 9
seeding.maxChi2Hits_less11Hit = [ 2.5 , 2.5 , 2.5 ]
seeding.maxYatZeroLow = [ 50., 50. , 50. ]
seeding.maxYatzRefLow = [500., 500. , 500. ]
#11 and 12 Hits
seeding.Chi2HighLine = [30.0, 50.0 , 80.0] #Chi2PerDoF when 11 or 12 hits Using LineChi2DoF + XZChi2DoF
seeding.maxChi2Hits_11and12Hit =[ 5.5, 5.5, 5.5 ]
#Make the Full Fit
seeding.maxChi2PerDoF = [4.0, 6.0, 7.0]
seeding.RecoverTrack = False #Get only tracks with 6 UV or 6 X
seeding.ChiDoFRecover = -1.0 #Change it only if RecoverTrack = True
#TruthMatching Settings (Comment all of them if you want to run the normal seeding
if(ConfigureManager):
from Configurables import PrFTHitManager
#seeding.addTool(manager)
#seeding.PrFTHitManager.SizeFix = FixedSize
#seeding.PrFTHitManager.FixError = True
seedingSeq.Members = [seeding]
from Configurables import (ApplicationMgr, EventDataSvc,
RecordOutputStream, ReplayOutputStream,
GaudiSequencer,
GaudiTesting__OddEventsFilter as OddEvents,
GaudiTesting__EvenEventsFilter as EvenEvents,
SubAlg as EmptyAlg)
outDelegate = ReplayOutputStream()
outDelegate.OutputStreams = [EmptyAlg('Stream1'), EmptyAlg('Stream2')]
oddEvtSelect = GaudiSequencer('OddEventsSelection')
oddEvtSelect.Members = [OddEvents('OddEvents'),
RecordOutputStream('Rec1', OutputStreamName='Stream1')]
evenEvtSelect = GaudiSequencer('EvenEventsSelection')
evenEvtSelect.Members = [EvenEvents('EvenEvents'),
RecordOutputStream('Rec2', OutputStreamName='Stream2')]
app = ApplicationMgr(EvtSel='NONE', EvtMax=4)
app.TopAlg = [EmptyAlg("EventInit"), evenEvtSelect, oddEvtSelect]
app.OutStream = [outDelegate]
EventDataSvc(ForceLeaves=True)
#from Gaudi.Configuration import VERBOSE
#from Configurables import MessageSvc
#MessageSvc(OutputLevel=VERBOSE)
"Tuple{0}".format(line),
decay_template.format(*tracks),
mothers,
daughters,
# The input to the tuple is the output of the filter
inputs_template.format(stripping),
mc
)
# MCDecayTreeTuple
mc_tuple = tuple_templates.mc_decay_tree_tuple(
"MCGenTuple{0}".format(line),
mc_decay_template.format(*tracks),
mc_mothers,
mc_daughters
)
# Sequences for ntuple creation
dec_sequence = GaudiSequencer("SeqBook{0}".format(line))
dec_sequence.Members = [tuple]
mc_sequence = GaudiSequencer("SeqMCGenBook{0}".format(line))
mc_sequence.Members = [mc_tuple]
# Sequence for ntuple sequences
tuples_sequence = GaudiSequencer("SeqTuples{0}".format(line))
tuples_sequence.IgnoreFilterPassed = True
tuples_sequence.Members = [dec_sequence, mc_sequence]
DaVinci().UserAlgorithms.append(tuples_sequence)
tuple.ToolList += [ 'LoKi::Hybrid::TupleTool/LoKiVariables2']
##################################################
from Configurables import CondDB, CondDBAccessSvc
CondDB().LatestGlobalTagByDataType = DataYear
##################################################
from Configurables import LHCbApp
LHCbApp().XMLSummary='summary.xml'
#from Configurables import DataOnDemandSvc, L0SelReportsMaker, L0DecReportsMaker
#DataOnDemandSvc().AlgMap["HltLikeL0/DecReports"] = L0DecReportsMaker( OutputLevel = 4 )
#DataOnDemandSvc().AlgMap["HltLikeL0/SelReports"] = L0SelReportsMaker( OutputLevel = 4 )
# User Algorithms
from Configurables import GaudiSequencer
userAlgos = GaudiSequencer("userAlgos")
userAlgos.Members = []
#userAlgos=[]
if IsMC:
from Configurables import TrackSmearState as SMEAR
smear = SMEAR('StateSmear')
userAlgos.Members.append(smear)
else:
#
from Configurables import CheckPV
checkpv = CheckPV("CheckPV")
checkpv.MinPVs = 1
userAlgos.Members.append(checkpv)
from Configurables import TrackScaleState as SCALER
scaler = SCALER('StateScale')
userAlgos.Members.append(scaler)
MessageSvc().Format = "% F%60W%S%7W%R%T %0W%M"
# database
DaVinci().DDDBtag = "dddb-20150724"
DaVinci().CondDBtag = "cond-20160522"
#
# Raw event juggler to split DAQ/RawEvent into FULL.DST format
#
from Configurables import GaudiSequencer, RawEventJuggler
jseq=GaudiSequencer("RawEventSplitSeq")
juggler=RawEventJuggler("rdstJuggler")
juggler.Sequencer=jseq
juggler.Input=0.3 # 2015 Online (Moore) format
juggler.Output=4.2 # Reco15 format
# filter out events triggered exclusively by CEP lines
from Configurables import LoKi__HDRFilter as HDRFilter
from DAQSys.Decoders import DecoderDB
Hlt2DecReportsDecoder=DecoderDB["HltDecReportsDecoder/Hlt2DecReportsDecoder"].setup()
HLTFilter2 = HDRFilter("LoKiHLT2Filter"
, Code = "HLT_PASS_RE('Hlt2(?!Forward)(?!DebugEvent)(?!Lumi)(?!Transparent)(?!PassThrough)(?!LowMult).*Decision')"
, Location = Hlt2DecReportsDecoder.OutputHltDecReportsLocation)
otherseq=GaudiSequencer("filters")
otherseq.Members=[jseq,HLTFilter2]
DaVinci().EventPreFilters = [jseq,HLTFilter2]
# input file
importOptions("$STRIPPINGSELECTIONSROOT/tests/data/Reco16_Run182594.py")
filter.Inputs = [inputs_template.format(stripping)]
# Fill the branch templates with the appropriate particles
mothers = {}
daughters = {}
for mother in mother_templates:
mothers[mother] = mother_templates[mother].format(*tracks)
for daughter in daughter_templates:
daughters[daughter] = daughter_templates[daughter].format(*tracks)
# Create a tuple for the mode
tuple = tuple_templates.decay_tree_tuple(
"Tuple{0}".format(line),
decay_template.format(*tracks),
mothers,
daughters,
# The input to the tuple is the output of the filter
inputs_template.format(filter_name),
mc
)
# Refit the decay tree, storing refitted daughter information
dtf = tuple.Lambdab.addTupleTool("TupleToolDecayTreeFitter/Fit")
dtf.Verbose = True
# Sequence to hold a succession of algorithms
sequence = GaudiSequencer("SequenceBook{0}".format(line))
sequence.Members = [filter, tuple]
DaVinci().UserAlgorithms.append(sequence)
def configure_dv() :
global toolList
streams = get_streams(strippingVersion)
configs = []
userSeq = GaudiSequencer('UserSeq')
userSeq.IgnoreFilterPassed = True
if isMC :
toolList += ['TupleToolMCTruth',
#'TupleToolGeneration'
'TupleToolMCBackgroundInfo'
]
for baryon in charmBaryons :
for bachelor in bachelors :
lineName = stripping_line_name(bachelor, baryon)
dtt, line, stream, conf = \
make_stripping_tuple(lineName, streams, toolList,
lineName[:-len('Beauty2Charm')] + 'Tuple')
dttSeq = GaudiSequencer(line.name() + 'Seq', Members = [dtt])
if 'Xic' == baryon :
decayDesc = dtt.Decay
dtt.Decay = decayDesc.replace('Lambda_b0', 'Xi_b0')
decayDescPlus = reduce(lambda x,y : x.replace(y, ''), ('^', '[', ']', 'CC'), decayDesc)
decayDescMinus = decayDescPlus.replace('+', '!').replace('->', '#').replace('-', '+')\
.replace('!', '-').replace('0', '~0').replace('#', '->').replace('Xi_c-', 'Xi_c~-').replace('p-', 'p~-')
subPID = SubstitutePID(baryon+bachelor+'SubstitutePID', Code = 'ALL',
Substitutions = {decayDescPlus : 'Xi_b0',
decayDescMinus : 'Xi_b~0'},
Inputs = dtt.Inputs,
Output = dtt.Inputs[0].replace('Beauty2CharmLine', 'Beauty2CharmLine-Subd'))
dtt.Inputs = [subPID.Output]
dttSeq.Members.insert(0, subPID)
configs.append({'dtt' : dtt, 'dttSeq' : dttSeq, 'line' : line, 'stream' : stream,
'conf' : conf, 'charmBaryon' : baryon, 'bachelor' : bachelor})
dtt.ReFitPVs = True # Do I need this? - probably yes if you want to use vertex constraints without biasing the lifetime.
# Configure DTF
decayNoCaret = dtt.Decay.replace('^', '')
baryonSymbol = baryonSymbols[baryon]
baryonDec = baryonDescriptors[baryon]
decayCharmCaret = decayNoCaret.replace('('+baryonDec, '^(' + baryonDec)
dtt.addBranches( {'X_b0' : decayNoCaret,
'X_cplus' : decayCharmCaret } )
bachelorDec = bachelorDescriptors[bachelor]
otherBachelorDec = oppositeBachelors[bachelor]
decayBachelorCaret = decayNoCaret[::-1].replace(bachelorDec[::-1], bachelorDec[::-1]+'^', 1)[::-1]
bachelorSub = {decayBachelorCaret : otherBachelorDec}
for mass, massName in ([baryonDec], '_Mass'), ([], '') :
for vtx, vtxName in (True, '_Vtx'), (False, '') :
tt_dtf_name = 'TupleToolDecayTreeFitter/DTF' + massName + vtxName
tt_dtf = dtt.X_b0.addTupleTool(tt_dtf_name)
tt_dtf_sub = dtt.X_b0.addTupleTool(tt_dtf_name + '_Sub')
tt_dtf_sub.Substitutions = bachelorSub
for dtf in tt_dtf, tt_dtf_sub :
dtf.constrainToOriginVertex = vtx
dtf.daughtersToConstrain = mass
dtf.Verbose = True
dv.DataType = get_data_type(firstInputFile)
if isMC :
for config in configs :
line = config['line']
#algs = line.filterMembers()
algs = line._members
# Remove TISTOS tagger and BDT filter.
algs = algs[:-3]
# Remove VoidFilter for nTracks < 250.
#algs.pop(0)
#remove_selection_criteria(algs[3], algs[5], algs[7],
# algs[9]) # std particles.
selalgs = filter(lambda x : isinstance(x, (FilterDesktop,
CombineParticles)), algs)
remove_selection_criteria(*selalgs)
decayDesc = config['dtt'].Decay.replace('^', '')
preamble = [ "from LoKiPhysMC.decorators import *" , "from LoKiPhysMC.functions import mcMatch" ]
# for alg in selalgs :
# alg.Preambulo = preamble
# if hasattr(alg, 'Code') :
# alg.Code += ' & mcMatch({0!r})'.format(decayDesc)
# else :
# alg.MotherCut += ' & mcMatch({0!r})'.format(decayDesc)
# filter(lambda x : isinstance(x, CombineParticles), algs)[-1].CombinationCut = '(AM<7000*MeV) & (AM>5200*MeV)'
#remove_selection_criteria(algs[8], # Lc/Xic
# algs[10]) # Lb
combineParticles = filter(lambda x : isinstance(x, CombineParticles), algs)
for comb in combineParticles :
comb.Preambulo = preamble
motherSymbol = baryonDescriptors[config['charmBaryon']]
decayDesc = decayDesc.replace('->', '==>') # to allow for intermediate resonances.
combineParticles[0].MotherCut += ' & mcMatch({0!r})'.format(decayDesc.replace('(' + motherSymbol, '^(' + motherSymbol))
combineParticles[0].DaughtersCuts = {'p+' : 'mcMatch({0!r})'.format(decayDesc.replace('p+', '^p+')),
'K-' : 'mcMatch({0!r})'.format(decayDesc.replace('K-', '^K-')),
'pi+' : 'mcMatch({0!r})'.format(decayDesc.replace('pi+', '^pi+'))}
bachelorSymbol = bachelorDescriptors[config['bachelor']]
combineParticles[1].DaughtersCuts = {bachelorSymbol : 'mcMatch({0!r})'.format(decayDesc.replace(bachelorSymbol, '^' + bachelorSymbol)),
motherSymbol : 'ALL'}
#algs = remove_selection_criteria(*algs)
algs[-1].Output = config['dttSeq'].Members[0].Inputs[0]
config['dttSeq'].Members = algs + config['dttSeq'].Members
dv.Simulation = True
dv.DDDBtag = dddbTag
dv.CondDBtag = conddbTag
else :
scaler = TrackScaleState()
#scaler.CONDDBpath = '/dd/Conditions/Calibration/LHCb/MomentumScale'
#scaler.CONDDBpath = '/dd/Conditions/Calibration/LHCb'
userSeq.Members = [scaler]
from Configurables import CondDB
CondDB(LatestGlobalTagByDataType = dv.DataType)
for config in configs :
userSeq.Members.append(config['dttSeq'])
dv.UserAlgorithms = [userSeq]
dv.InputType = firstInputFile.split('.')[-1].upper()
if 'MDST' == dv.InputType :
dv.RootInTES = '/Event/' + configs[0]['stream'].name()
