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 _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 redoMCLinks(self,init):
"""
Redo MC links.
"""
if ( self.getProp("Simulation") ):
redo = self.getProp("RedoMCLinks")
if ( redo ):
from Configurables import (GaudiSequencer,TESCheck,EventNodeKiller,TrackAssociator)
mcKillSeq = GaudiSequencer("KillMCLinks") # The sequence killing the node of it exists
tescheck = TESCheck("DaVinciEvtCheck") # Check for presence of node ...
tescheck.Inputs = ["Link/Rec/Track/Best"] #
tescheck.Stop = False # But don't stop
tescheck.OutputLevel = 5 # don't print warnings
evtnodekiller = EventNodeKiller("DaVinciEvtNodeKiller") # kill nodes
evtnodekiller.Nodes = ["Link/Rec/Track"] # Kill that
mcKillSeq.Members = [ tescheck, evtnodekiller, TrackAssociator() ]
mcLinkSeq = GaudiSequencer("RedoMCLinks") # The sequence redoing the links
mcLinkSeq.IgnoreFilterPassed = True # Run it always
mcLinkSeq.Members = [ mcKillSeq, TrackAssociator() ]
init.Members += [ mcLinkSeq ]
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]
DaVinci().UserAlgorithms.append(master_sequence)
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 ) ]
myParticlesFilterList += [ FilterDesktop( myParticlesName+"Filter",
Code = cuts ) ]
myParticlesList += [ Selection( myParticlesName,
Algorithm = myParticlesFilterList[-1],
# 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)
pion_list= FilterInTrees( 'pion_list', Code = "'pi+'==ABSID")
def patchBrunel():
"""
Instantiate the options to run Brunel with raw data
@author M.Frank
"""
import GaudiConf.DstConf
import Brunel.Configuration
import OnlineEnv
brunel = Brunel.Configuration.Brunel()
brunel.OnlineMode = True
try:
brunel.DDDBtag = OnlineEnv.DDDBTag
except:
print "DDDBTag not found, use default"
try:
brunel.CondDBtag = OnlineEnv.CondDBTag
except:
print "CondDBTag not found, use default"
##print '[ERROR]', OnlineEnv.DDDBTag, OnlineEnv.CondDBTag
conddb = CondDB()
conddb.IgnoreHeartBeat = True
#
# Adjust to pickup the proper online conditions
#
import ConditionsMap
conddb.setProp('RunChangeHandlerConditions',
ConditionsMap.RunChangeHandlerConditions)
conddb.setProp('EnableRunChangeHandler', True)
brunel.DataType = "2015"
brunel.UseDBSnapshot = True # Try it
brunel.WriteFSR = False # This crashes Jaap's stuff
conddb = CondDB()
conddb.Online = True
#
# Adjust to pickup the proper online conditions from ConditionsMap
#
conddb.RunChangeHandlerConditions = ConditionsMap.RunChangeHandlerConditions
conddb.setProp('EnableRunChangeHandler', True)
# Enabled data-on-demand
Gaudi.ApplicationMgr().ExtSvc += ["DataOnDemandSvc"]
################################################################################
# #
# Set up PID monitoring sequence #
# #
################################################################################
# The sequencer to run all the monitoring in
seq = GaudiSequencer("PIDMoniSeq")
pidSeq = GaudiSequencer("RichPIDSelections")
brunel.setOtherProps(RichPIDQCConf(), ['OutputLevel', 'Context'])
RichPIDQCConf().setProp("CalibSequencer", pidSeq)
seq.Members += [pidSeq]
################################################################################
# #
# Configure the muon efficiency monitor #
# #
################################################################################
muEffMoni = MuEffMonitor("MuEffMonitor")
muEffMoni.addTool(TrackMasterExtrapolator, name="MuEffExtrap")
muEffMoni.Extrapolator = muEffMoni.MuEffExtrap
muEffMoni.MuEffExtrap.ApplyMultScattCorr = True
muEffMoni.MuEffExtrap.ApplyEnergyLossCorr = True
muEffMoni.MuEffExtrap.MaterialLocator = "SimplifiedMaterialLocator"
muEffMoni.MuEffExtrap.OutputLevel = 6
muEffMoni.nSigma1X = [11., 8., 7., 7.]
muEffMoni.nSigma1Y = [6., 5., 5., 5.]
muEffMoni.nSigmaX = [5., 5., 5., 5.]
muEffMoni.nSigmaY = [5., 5., 5., 5.]
muEffMoni.RequiredStations = 4
muEffMoni.MomentumCut = 3000.0
muEffMoni.nSigmaFidVol = 3.0
muEffMoni.UseCalo = True
muEffMoni.EecalMax = 1500.0
muEffMoni.EhcalMax = 5000.0
muEffMoni.EhcalMin = 1000.0
muEffMoni.Chi2ProbTrMin = 0.01
muEffMoni.Chi2MuMin = 10.0
muEffMoni.nSigmaXother = 2.0
muEffMoni.nSigmaYother = 2.0
muEffMoni.HistoLevel = "OfflineFull"
seq.Members += [muEffMoni]
################################################################################
# #
# Configure the muon pid monitor #
# #
################################################################################
from Configurables import MuIDMonitor, CombineParticles
from Configurables import FilterDesktop
from StandardParticles import StdNoPIDsPions, StdNoPIDsProtons, StdNoPIDsMuons
from PhysSelPython.Wrappers import Selection, SelectionSequence, DataOnDemand
MuPidMoniSeq_Lambda = GaudiSequencer("MuPidMoniSeq_Lambda")
MuPidMoniSeq_Jpsi = GaudiSequencer("MuPidMoniSeq_Jpsi")
#
# Make pions and protons
#
PionsFilter = FilterDesktop("PionsFilter")
PionsFilter.Code = "(P>3000*MeV) & (PT>100*MeV) & (TRCHI2DOF<2) & (ISLONG) & (MIPCHI2DV(PRIMARY)>9)"
PionsFilterSel = Selection("PionsFilterSel",
Algorithm=PionsFilter,
RequiredSelections=[StdNoPIDsPions])
ProtonsFilter = FilterDesktop("ProtonsFilter")
ProtonsFilter.Code = "(P>3000*MeV) & (PT>100*MeV) & (TRCHI2DOF<2) & (ISLONG) & (MIPCHI2DV(PRIMARY)>9)"
ProtonsFilterSel = Selection("ProtonsFilterSel",
Algorithm=ProtonsFilter,
RequiredSelections=[StdNoPIDsProtons])
#
# Make Lambda_0
#
LambdaMonitor = CombineParticles("LambdaMonitor")
LambdaMonitor.DecayDescriptor = "[Lambda0 -> p+ pi-]cc"
LambdaMonitor.CombinationCut = "(ADAMASS('Lambda0')<10*MeV)"
LambdaMonitor.MotherCut = "(50<BPVVDZ) & (600>BPVVDZ) & (BPVDIRA>0.9999995) & (CHILDCUT((PT>0.2*GeV),1) | CHILDCUT((PT>0.2*GeV),2)) & (ADWM('KS0', WM('pi+', 'pi-')) > 20*MeV)"
LambdaMonitorSel = Selection(
"LambdaMonitorSel",
Algorithm=LambdaMonitor,
RequiredSelections=[PionsFilterSel, ProtonsFilterSel])
LambdaMonitorSeq = SelectionSequence("LambdaMonitorSeq",
TopSelection=LambdaMonitorSel)
MuPidMoniSeq_Lambda.Members += [LambdaMonitorSeq.sequence()]
#
# Make muons and J/psi
#
mucocut = '(0.5<PPINFO(LHCb.ProtoParticle.InAccMuon,-1)) & (P>3*GeV) & (PT>800*MeV) & (TRCHI2DOF<3) & (ISLONG)'
tag1cuts = " (CHILDCUT(ISMUON,1)) & (CHILDCUT((P>6*GeV),1)) & (CHILDCUT((PT>1.5*GeV),1)) "
tag2cuts = " (CHILDCUT(ISMUON,2)) & (CHILDCUT((P>6*GeV),2)) & (CHILDCUT((PT>1.5*GeV),2)) "
probe2cuts = " ( (CHILDCUT((PPINFO(LHCb.ProtoParticle.CaloEcalE,-10000)<1000*MeV),2)) & (CHILDCUT((PPINFO(LHCb.ProtoParticle.CaloHcalE,-10000)<4000*MeV),2)) & (CHILDCUT((PPINFO(LHCb.ProtoParticle.CaloEcalE,-10000)>-10*MeV),2)) & (CHILDCUT((PPINFO(LHCb.ProtoParticle.CaloHcalE,-10000)>1000*MeV),2)) ) "
probe1cuts = " ( (CHILDCUT((PPINFO(LHCb.ProtoParticle.CaloEcalE,-10000)<1000*MeV),1)) & (CHILDCUT((PPINFO(LHCb.ProtoParticle.CaloHcalE,-10000)<4000*MeV),1)) & (CHILDCUT((PPINFO(LHCb.ProtoParticle.CaloEcalE,-10000)>-10*MeV),1)) & (CHILDCUT((PPINFO(LHCb.ProtoParticle.CaloHcalE,-10000)>1000*MeV),1)) ) "
child1cuts = tag1cuts + " & " + probe2cuts
child2cuts = tag2cuts + " & " + probe1cuts
MuonsFilter = FilterDesktop("MuonsFilter")
MuonsFilter.Code = mucocut
MuonsFilterSel = Selection("MuonsFilterSel",
Algorithm=MuonsFilter,
RequiredSelections=[StdNoPIDsMuons])
JpsiMonitor = CombineParticles("JpsiMonitor")
JpsiMonitor.DecayDescriptor = "J/psi(1S) -> mu+ mu-"
JpsiMonitor.CombinationCut = "(ADAMASS('J/psi(1S)')<300*MeV)"
JpsiMonitor.MotherCut = "(VFASPF(VCHI2/VDOF)<20) & ( " + child1cuts + " | " + child2cuts + " ) "
JpsiMonitor.OutputLevel = 6
JpsiMonitorSel = Selection("JpsiMonitorSel",
Algorithm=JpsiMonitor,
RequiredSelections=[MuonsFilterSel])
JpsiMonitorSeq = SelectionSequence("JpsiMonitorSeq",
TopSelection=JpsiMonitorSel)
MuPidMoniSeq_Jpsi.Members += [JpsiMonitorSeq.sequence()]
#
# Monitoring muon mis-id with Lambda_0
#
MuIDLambdaPlot = MuIDMonitor("MuIDLambdaPlot")
MuIDLambdaPlot.Inputs = [LambdaMonitorSel.outputLocation()]
MuIDLambdaPlot.OutputLevel = 6
MuIDLambdaPlot.MassMean = 1115.68
MuIDLambdaPlot.MassWindow = 20.
MuIDLambdaPlot.EffMassWin = 2.
MuIDLambdaPlot.JpsiAnalysis = 0
MuIDLambdaPlot.LambdaAnalysis = 1
MuIDLambdaPlot.HitInFoi = 1
MuIDLambdaPlot.PreSelMomentum = 3000. # MuonID preselection momentum (MeV/c)
MuIDLambdaPlot.MomentumCuts = [6000., 10000.
] # MuonID momentum cut ranges (MeV/c)
# MuonID FOI parameters
MuIDLambdaPlot.FOIfactor = 1.
MuIDLambdaPlot.XFOIParameter1 = [
5.5, 4.0, 3.3, 2.8, 5.2, 3.6, 2.4, 2.4, 5.7, 4.4, 2.8, 2.3, 5.1, 3.1,
2.3, 2.1, 5.8, 3.4, 2.6, 2.8
]
MuIDLambdaPlot.XFOIParameter2 = [
11., 3., 1., 1., 31., 28., 21., 17., 30., 31., 27., 22., 28., 33., 35.,
47., 31., 39., 56., 151.
]
MuIDLambdaPlot.XFOIParameter3 = [
0.20, 0.08, 0.03, 0.1, 0.06, 0.08, 0.10, 0.15, 0.04, 0.06, 0.09, 0.12,
0.08, 0.15, 0.23, 0.36, 0.07, 0.14, 0.24, 0.49
]
MuIDLambdaPlot.YFOIParameter1 = [
2.8, 1.7, -153., 1.9, 3.3, 2.1, 1.7, 1.6, 3.6, 2.8, 1.9, 1.8, 4.4, 3.3,
2.2, 2.2, 4.8, 3.9, 2.6, 2.3
]
MuIDLambdaPlot.YFOIParameter2 = [
3., 2., 156., 0., 17., 15., 9., 5., 26., 25., 16., 15., 30., 49., 57.,
92., 32., 55., 96., 166.
]
MuIDLambdaPlot.YFOIParameter3 = [
0.03, 0.02, 0.00, 0.09, 0.13, 0.19, 0.19, 0.24, 0.11, 0.19, 0.21, 0.32,
0.10, 0.22, 0.30, 0.52, 0.08, 0.20, 0.34, 0.52
]
#
# Parameters of the Landau functions
#
MuIDLambdaPlot.distMuon = [
0.311, 1.349, 0.524, 0.0020, 17., 10.6, 0.04, 4.1, 1.64
]
MuIDLambdaPlot.distPion = [
11., -12., 0.2029, -0.026, 0.06, 0.59, 0.008, -29., 41.
]
MuPidMoniSeq_Lambda.Members += [MuIDLambdaPlot]
#
# Monitoring muon id with J/psi
#
MuIDJpsiPlot = MuIDMonitor("MuIDJpsiPlot")
MuIDJpsiPlot.Inputs = [JpsiMonitorSel.outputLocation()]
MuIDJpsiPlot.OutputLevel = 6
MuIDJpsiPlot.MassMean = 3096.91
MuIDJpsiPlot.MassWindow = 300.
MuIDJpsiPlot.EffMassWin = 20.
MuIDJpsiPlot.JpsiAnalysis = 1
MuIDJpsiPlot.LambdaAnalysis = 0
MuIDJpsiPlot.HitInFoi = 1
MuIDJpsiPlot.PreSelMomentum = MuIDLambdaPlot.PreSelMomentum
MuIDJpsiPlot.MomentumCuts = MuIDLambdaPlot.MomentumCuts
# MuonID FOI parameters
MuIDJpsiPlot.FOIfactor = MuIDLambdaPlot.FOIfactor
MuIDJpsiPlot.XFOIParameter1 = MuIDLambdaPlot.XFOIParameter1
MuIDJpsiPlot.XFOIParameter2 = MuIDLambdaPlot.XFOIParameter2
MuIDJpsiPlot.XFOIParameter3 = MuIDLambdaPlot.XFOIParameter3
MuIDJpsiPlot.YFOIParameter1 = MuIDLambdaPlot.YFOIParameter1
MuIDJpsiPlot.YFOIParameter2 = MuIDLambdaPlot.YFOIParameter2
MuIDJpsiPlot.YFOIParameter3 = MuIDLambdaPlot.YFOIParameter3
#
# Parameters of the Landau functions
#
MuIDJpsiPlot.distMuon = MuIDLambdaPlot.distMuon
MuIDJpsiPlot.distPion = MuIDLambdaPlot.distPion
MuPidMoniSeq_Jpsi.Members += [MuIDJpsiPlot]
MuPidMoniSeq_Jpsi.IgnoreFilterPassed = True
MuPidMoniSeq_Lambda.IgnoreFilterPassed = True
seq.Members += [MuPidMoniSeq_Lambda, MuPidMoniSeq_Jpsi]
# set the options
class __MonAdd:
def __init__(self, s):
self.seq = s
def addMonitors(self):
# Append to processing
GaudiSequencer("PhysicsSeq").Members += [self.seq]
mon = __MonAdd(seq)
Gaudi.appendPostConfigAction(mon.addMonitors)
EventLoopMgr().OutputLevel = MSG_DEBUG #ERROR
EventLoopMgr().Warnings = False
brunel.UseDBSnapshot = True # try it
Brunel.Configuration.Brunel.configureOutput = dummy
HistogramPersistencySvc().OutputFile = ""
HistogramPersistencySvc().OutputLevel = MSG_ERROR
print brunel
return brunel
dtf_BMFit.daughtersToConstrain = ['B_s0']
dtf_MFit = dtt_pi0R.addTupleTool("TupleToolDecayTreeFitter/MassFit")
dtf_MFit.Verbose = True
dtf_MFit.UpdateDaughters = True
dtf_MFit.constrainToOriginVertex = False
dtf_MFit.daughtersToConstrain = ['pi0']
# Vtx Isoln
dtt_vtxIso = dtt_pi0R.addTupleTool('TupleToolVtxIsoln')
dtt_vtxIso.Verbose=True
# offlineVertexFitter
from Configurables import OfflineVertexFitter
dtt_pi0R.VertexFitters.update( { "" : "OfflineVertexFitter"} )
dtt_pi0R.addTool(OfflineVertexFitter)
dtt_pi0R.OfflineVertexFitter.useResonanceVertex = False
# configure decay maker
dtt_pi0R.Inputs = sel_seq.outputLocations()
seq.Members += [ dtt_pi0R ]
# configure the categories
catSeq = GaudiSequencer('hhpi0RG')
catSeq.IgnoreFilterPassed = True
catSeq.Members += [seq]
DaVinci().UserAlgorithms += [catSeq]
# EOF
from math import *
from Gaudi.Configuration import *
from Configurables import GaudiSequencer
from GaudiKernel.SystemOfUnits import *
from CommonParticles.Utils import *
from Configurables import TrackClusterFinder
TrkClusterFinder = TrackClusterFinder("TrkClusterFinder")
TrkClusterFinder.MinWeightSeed = 6
TrkClusterFinder.ConeExtFactor = 4.0
TrkClusterFinder.MaxDeltaPhi = 4.0
TrkClusterFinder.MaxDeltaEta = 0.15
TrkClusterFinder.Min1stJetPt = 10.0
TrkClusterFinder.Min2ndJetPt = 7.0
TrkClusterFinder.JetMult = 2
TrkClusterFinder.MaxRPV = 1.0
## #####################################################################
DVSeq = GaudiSequencer("DVSeq")
DVSeq.IgnoreFilterPassed = False
DVSeq.Members += [TrkClusterFinder]
## #####################################################################
from Configurables import DaVinci
DaVinci().EvtMax = -1
DaVinci().PrintFreq = 100
DaVinci().SkipEvents = 0
DaVinci().DataType = "2010"
DaVinci().Simulation = False
DaVinci().HistogramFile = "test_histo.root"
DaVinci().TupleFile = "test.root"
DaVinci().UserAlgorithms = [DVSeq]
########################################################################
def setup():
initialTime = long(time.time() * 1e9)
OTGaudiSeq = GaudiSequencer("OTt0OnlineClbrSeq")
OTt0OnlineClbrAlg = OTt0OnlineClbr("OTt0OnlineClbrAlg")
#OTt0OnlineClbrAlg.InputFiles = [ "/hist/Savesets/2013/LHCb/Brunel/01/20/Brunel-135576-20130120T161302-EOR.root"]
# OT T0 calibration algorithm
OTt0OnlineClbrAlg.InputTasks = ["Brunel"]
OTt0OnlineClbrAlg.Partition = partition
OTt0OnlineClbrAlg.ReadInitialT0FromDB = False
OTt0OnlineClbrAlg.SaveFits = False
OTt0OnlineClbrAlg.RunOnline = True
OTt0OnlineClbrAlg.CheckDataT0 = True
OTt0OnlineClbrAlg.PublishedName = "OT/Calib"
OTt0OnlineClbrAlg.XMLFilePath = "/group/online/alignment/OT/Calib"
OTt0OnlineClbrAlg.OutputLevel = MSG_INFO
OTt0OnlineClbrAlg.UseClockPhase = (partition != "FEST")
OTt0OnlineClbrAlg.InitialTime = initialTime
OTt0OnlineClbrAlg.Threshold = 0.1
OTt0OnlineClbrAlg.MaxDifference = 2
# Keep analysis task going.
OTt0OnlineClbrAlg.StopAlgSequence = False
OTGaudiSeq.Members += [OTt0OnlineClbrAlg]
OTGaudiSeq.IgnoreFilterPassed = True
## Configure saving of histograms
from Configurables import UpdateAndReset
ur = UpdateAndReset()
ur.saveHistograms = 1
ApplicationMgr().TopAlg.insert(0, ur)
from Configurables import MonitorSvc
MonitorSvc().disableDimPropServer = 1
MonitorSvc().disableDimCmdServer = 1
#import OnlineEnv
MonitorSvc().ExpandCounterServices = 0
MonitorSvc().ExpandNameInfix = "<part>_x_<program>/"
#MonitorSvc().PartitionName = OnlineEnv.PartitionName;
MonitorSvc().PartitionName = partition
MonitorSvc().ProgramName = "OTOnlineCalib_0"
#setup the histograms and the monitoring service
#ApplicationMgr().ExtSvc.append( 'MonitorSvc' )
from Configurables import RootHistCnv__PersSvc
RootHistCnv__PersSvc().OutputEnabled = False
ApplicationMgr().TopAlg += [OTGaudiSeq]
ApplicationMgr().EvtSel = "NONE"
ApplicationMgr().ExtSvc += [
"LHCb::PublishSvc", "MonitorSvc", "IncidentSvc"
]
ApplicationMgr().Runable = "LHCb::OnlineRunable/Runable"
from Configurables import CondDB
conddb = CondDB()
conddb.Tags["ONLINE"] = 'fake'
conddb.IgnoreHeartBeat = True
conddb.UseDBSnapshot = True
conddb.DBSnapshotDirectory = "/group/online/hlt/conditions"
from Configurables import EventClockSvc, FakeEventTime, EventDataSvc
ecs = EventClockSvc()
ecs.InitialTime = initialTime
ecs.addTool(FakeEventTime, "EventTimeDecoder")
ecs.EventTimeDecoder.StartTime = initialTime
ecs.EventTimeDecoder.TimeStep = 10
EventDataSvc().ForceLeaves = True
# Configure DB tags and per-run conditions to be used to be the same as what
# the HLT1 reconstruction farm uses. This is done by directly importing the
# python file to ensure the script can also start when LHCb is running
# passthrough.
conddb.EnableRunChangeHandler = True
conddb.RunChangeHandlerConditions = {
'LHCb/2015/%d/ot.xml': ["Conditions/Calibration/OT/CalibrationGlobal"]
}
from Configurables import LHCbApp
import ConditionsMap
LHCbApp().CondDBtag = ConditionsMap.CondDBTag
LHCbApp().DDDBtag = ConditionsMap.DDDBTag
# LHCbApp().CondDBtag = 'cond-20150409-2'
# LHCbApp().DDDBtag = 'dddb-20150119-3'
LHCbApp().DataType = '2015'
def applyConf(self):
from Configurables import (GaudiSequencer, HltL0CaloCandidates)
if self.getName() == 'CaloLines' and (self.getProp('Context') == ''
or self.getProp('Context')
== 'CaloLines'):
self.setProp(
'Context', 'Offline'
) # default is Offline is neither context nor name is specified
# overwrite Reco & PID onDemand
dod = self.getProp('EnableOnDemand')
pdod = self.getProp('ProtoOnDemand')
if dod:
pdod = dod
tracks = self.getProp('TrackLocations')
###
caloLines = GaudiSequencer('CaloLinesSeq' + self.getName())
caloLines.Members[:] = []
if self.getProp('L0Calo2Calo'):
l0calo2calo = HltL0CaloCandidates('L0Calo2Calo')
if self.getProp('ClusterizationLevel') > 0:
level = self.getProp('ClusterizationLevel')
l0calo2calo.ClusterizationLevel = level
addAlgs(caloLines, l0calo2calo)
tagHighP = ''
tagLowP = ''
tagLowE = ''
else:
tagHighP = 'HighPhoton'
tagLowP = 'LowPhoton'
tagLowE = 'LowElectron'
name = self.getName()
fac = self.getProp('ClusterEtFactor')
if self.getProp('HighPhoton'):
context = self.getProp('Context')
if context != '':
context = context + 'HighPhoton'
hp = CaloProcessor(
name + 'HighPhoton',
TrackLocations=tracks,
Context=context,
RecList=['Digits', 'Clusters', 'Photons'],
CaloPIDs=False,
ExternalClusters="/Event/Rec/Calo/HighEtPhotons",
ClusterPt=self.getProp('HighEt') * fac,
PhotonPt=self.getProp('HighEt'),
MakeExternalClustersWithTag=tagHighP,
NoSpdPrs=self.getProp('NoSpdPrs'))
addAlgs(caloLines, hp.caloSequence(tracks=tracks))
if self.getProp('HighEtProtoPPrefix') == '':
hploc = name + 'HighPhoton/ProtoP'
else:
hploc = self.getProp('HighEtProtoPPrefix')
addAlgs(caloLines,
hp.neutralProtoSequence(protoPrefix=hploc, tracks=tracks))
if self.getProp('LowPhoton'):
context = self.getProp('Context')
if context != '':
context = context + 'LowPhoton'
lp = CaloProcessor(name + 'LowPhoton',
TrackLocations=tracks,
Context=context,
RecList=[
'Digits', 'Clusters', 'Photons',
'MergedPi0s', 'SplitPhotons'
],
ExternalClusters="/Event/Rec/Calo/LowEtPhotons",
CaloPIDs=False,
ClusterPt=self.getProp('LowEt') * fac,
PhotonPt=self.getProp('LowEt'),
MakeExternalClustersWithTag=tagLowP,
NoSpdPrs=self.getProp('NoSpdPrs'))
addAlgs(caloLines, lp.caloSequence(tracks=tracks))
if self.getProp('LowEtProtoPPrefix') == '':
lploc = name + 'LowPhoton/ProtoP'
else:
lploc = self.getProp('LowEtProtoPPrefix')
addAlgs(caloLines,
lp.neutralProtoSequence(protoPrefix=lploc, tracks=tracks))
if self.getProp('LowElectron'):
context = self.getProp('Context')
if context != '':
context = context + 'LowElectron'
le = CaloProcessor(
name + 'LowElectron',
TrackLocations=tracks,
Context=context,
RecList=['Digits', 'Clusters', 'Electrons'],
ExternalClusters="/Event/Rec/Calo/LowEtElectrons",
ClusterPt=self.getProp('LowEt') * fac,
ElectronPt=self.getProp('LowEt'),
SkipNeutrals=True,
ProtoOnDemand=pdod,
MakeExternalClustersWithTag=tagLowE,
NoSpdPrs=self.getProp('NoSpdPrs'))
addAlgs(caloLines, le.caloSequence(tracks=tracks))
if self.getProp('LowEtProtoPPrefix') == '':
leloc = name + 'LowElectron/ProtoP'
else:
leloc = self.getProp('LowEtProtoPPrefix')
addAlgs(caloLines,
le.chargedProtoSequence(protoPrefix=leloc, tracks=tracks))
caloLines.IgnoreFilterPassed = True
## propagate the global properties
if self.isPropertySet("OutputLevel"):
setTheProperty(caloLines, 'OutputLevel',
self.getProp('OutputLevel'))
## define the sequencers
if self.isPropertySet('Sequencer'):
main = self.getProp('Sequencer')
addAlgs(main, caloLines)
#line below should be the default in the db. its default in the analysistask #OTt0OnlineClbrAlg.CondStructure = "Conditions/OT/Calibration/" #OTt0OnlineClbrAlg.globalt0_threshold = 0.1 OTt0OnlineClbrAlg.OutputLevel = 2 #OTt0OnlineClbrAlg.Simulation = False #OTt0OnlineClbrAlg.Fit_module_contributions = False OTt0OnlineClbrAlg.UseMean = False OTt0OnlineClbrAlg.SaveFits = False #simulation = OTt0OnlineClbrAlg.Simulation OTGaudiSeq.Members += [OTt0OnlineClbrAlg] OTGaudiSeq.IgnoreFilterPassed = True from Configurables import ApplicationMgr ApplicationMgr().TopAlg += [OTGaudiSeq] ApplicationMgr().EvtSel = "NONE" # ApplicationMgr().ExtSvc += [ "MonitorSvc" ] # ApplicationMgr().Runable = "LHCb::OnlineRunable/Runable" from Configurables import LHCbApp #LHCbApp().DDDBtag = "head-20120413" #LHCbApp().CondDBtag = "cond-20120730" #LHCbApp().Simulation = simulation #if simulation :
tutorialseq.Members += [jpsi2mumu]
#######################################################################
#
# 2) Add the Phi
#
phi2kk = TutorialAlgorithm("Phi2KK")
phi2kk.Inputs = ["Phys/StdAllLooseKaons/Particles"]
phi2kk.MassWindow = 50 * MeV
phi2kk.Particle = "phi(1020)"
phi2kk.MaxChi2 = 20
tutorialseq.Members += [phi2kk]
#######################################################################
#
# Say True to have all phis. False to be fast.
#
tutorialseq.IgnoreFilterPassed = True # get all phis
#######################################################################
#
# 3) Configure the application
#
from Configurables import DaVinci
DaVinci().HistogramFile = "DVHistos_3.root" # Histogram file
DaVinci().EvtMax = 10000 # Number of events
DaVinci().DataType = "2012" #
DaVinci().Simulation = True # When running on MC
#
# Add our own stuff
#
DaVinci().UserAlgorithms = [tutorialseq]
DaVinci().MainOptions = "" # None
########################################################################
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()
