def __apply_configuration__(self):
GaudiKernel.ProcessJobOptions.PrintOff()
# database hacking for online
if self.getProp('UseDBSnapshot') : self._configureDBSnapshot()
self.defineGeometry()
self.defineEvents()
self.defineOptions()
self.defineMonitors()
self.setOtherProps(RecSysConf(),["Histograms","SpecialData","Context",
"OutputType","DataType","Simulation","OnlineMode","SkipTracking"])
self.setOtherProps(RecMoniConf(),["Histograms","Context","DataType","Simulation","OnlineMode","SkipTracking"])
self.setOtherProps(TrackSys(),["DataType","Simulation"])
if self.isPropertySet("RecoSequence") :
self.setOtherProp(RecSysConf(),"RecoSequence")
GaudiKernel.ProcessJobOptions.PrintOn()
log.info( self )
log.info( RecSysConf() )
log.info( TrackSys() )
log.info( RecMoniConf() )
GaudiKernel.ProcessJobOptions.PrintOff()
def __apply_configuration__(self):
GaudiKernel.ProcessJobOptions.PrintOff()
GaudiKernel.ProcessJobOptions.PrintOn()
log.info("Initializing sequences!")
self.setOtherProps(
RecSysConf(), ["SpecialData", "Context", "OutputType", "DataType"])
#if self.isPropertySet("RecoSequence") :
#self.setOtherProp(RecSysConf(),["RecoSequence"])
RecSysConf().RecoSequence = self.CheckRecoSequence()
# there is a bug in setOtherProps, so we cannot use it to set the MoniSequence.
if not self.getProp("OnlineMode"):
self.setOtherProps(RecMoniConf(), ["Context", "DataType"])
RecMoniConf().MoniSequence = self.getProp("MoniSequence")
else:
self.setOtherProps(RecMoniConf(), ["Context", "DataType"])
RecMoniConf().MoniSequence = self.getProp("MoniSequence")
RecMoniConf().Context = "Offline"
RecMoniConf().OutputLevel = FATAL
RecMoniConf().Histograms = "OfflineFull"
self.defineGeometry()
self.defineEvents()
self.defineOptions()
# database hacking for online.
if self.getProp('UseDBSnapshot'): self.configureDBSnapshot()
# Use TimingAuditor for timing, suppress printout from SequencerTimerTool
from Configurables import (ApplicationMgr, AuditorSvc,
SequencerTimerTool)
ApplicationMgr().ExtSvc += ['ToolSvc', 'AuditorSvc']
ApplicationMgr().AuditAlgorithms = True
AuditorSvc().Auditors += ['TimingAuditor']
SequencerTimerTool().OutputLevel = 4
log.info(self)
log.info(LHCbApp())
log.info(RecSysConf())
log.info(TrackSys())
if not self.getProp("OnlineMode"):
log.info(RecMoniConf())
log.info(TAlignment())
log.info(DstConf())
GaudiKernel.ProcessJobOptions.PrintOff()
def ConfiguredOTMonitorSequence(Name="MoniOTSeq", HistoPrint=False):
seq = GaudiSequencer(Name)
if RecMoniConf().getProp("Histograms") is "Online":
OTTrackMonitor().Online = True
OTHitEfficiencyMonitor().Online = True
seq.Members.append(OTTimeMonitor(HistoPrint=HistoPrint))
seq.Members.append(OTTrackMonitor(HistoPrint=HistoPrint))
seq.Members.append(OTHitEfficiencyMonitor(HistoPrint=HistoPrint))
from Configurables import TrackSys
if TrackSys().cosmics():
OTTrackMonitor().RawBankDecoder = 'OTMultiBXRawBankDecoder'
OTHitEfficiencyMonitor().RawBankDecoder = 'OTMultiBXRawBankDecoder'
OTTimeMonitor().RawBankDecoder = 'OTMultiBXRawBankDecoder'
return seq
def trackingDownPreFilter(name, prefilter):
#Jpsi_already_there = LoKi__VoidFilter("Jpsi_already_there")
#Jpsi_already_there.Code = "1 <= CONTAINS('Rec/Track/Downstream')"
#Jpsi_not_yet_there = LoKi__VoidFilter("Jpsi_not_yet_there")
#Jpsi_not_yet_there.Code = "1 > CONTAINS('Rec/Track/Downstream')"
TrackToDST(
"DownTrackToDST").TracksInContainer = "Rec/Downstream/FittedTracks"
TrackSys().setProp('SpecialData', ['earlyData'])
jpsidotracking = GaudiSequencer("DownTrackingFor" + name)
#Add seed tracking
jpsidotracking.Members += [PatSeeding("PatSeeding")]
PatAlgConf.SeedingConf().configureAlg()
#Add Seed Fit
jpsidotracking.Members += [GaudiSequencer("TrackSeedFitSeq")]
#AddPatDownstream
downstreamTracking = PatDownstream()
downstreamTracking.OutputLocation = 'Rec/Downstream/Tracks'
jpsidotracking.Members += [downstreamTracking]
#AddDownstreamFitSeq
jpsidotracking.Members += [TrackStateInitAlg("InitSeedDownstream")]
TrackStateInitAlg(
"InitSeedDownstream").TrackLocation = "Rec/Downstream/Tracks"
downstreamFit = ConfiguredFitDownstream()
downstreamFit.TracksInContainer = 'Rec/Downstream/Tracks'
downstreamFit.TracksOutContainer = 'Rec/Downstream/FittedTracks'
jpsidotracking.Members += [downstreamFit]
jpsidotracking.Members += [TrackToDST("DownTrackToDST")]
#alg = GaudiSequencer("JpsitracksFor" + name,
# Members = [Jpsi_already_there,
# jpsidotracking],
# ModeOR = True,
# ShortCircuit = True)
return GSWrapper(name="WrappedDownstreamTracking",
sequencer=jpsidotracking,
output='Rec/Downstream/FittedTracks',
requiredSelections=[prefilter])
# $ESCHEROPTS/gaudiiter.py -n NUMITER -e NUMEVENTS $ESCHEROPTS/2010-Collisions-Muon.py
#
# Run list of stripped data included
##############################################################################
from Configurables import (Escher, TrackSys, RecSysConf)
Escher().DataType = "2010"
Escher().Kalman = True
Escher().Millepede = False
Escher(
).TrackContainer = "Rec/Track/AlignTracks" # Velo, VeloR, Long, Upstream, Downstream, Ttrack, Muon or Calo
Escher().EvtMax = 5000
Escher().SkipEvents = 0
Escher().SpecialData = ["earlyData"] # ,"veloOpen"]
Escher().InputType = 'DST'
TrackSys().ExpertTracking += ["simplifiedGeometry"]
RecSysConf().RecoSequence = [
"Decoding", "VELO", "TT", "IT", "OT", "Tr", "MUON"
]
###############################################################
from GaudiKernel.SystemOfUnits import GeV, mm
from Gaudi.Configuration import *
uselocalframe = True
chisqconstraints = [] # one number for each constraint
constraints = []
surveyconstraints = []
dof = 'TxTy'
def algorithm(self):
from Configurables import TrackSys
TrackSys().GlobalCuts = {
'Velo': 4000,
'OT': 8000
} #### to remove busy events
Name = self._name
inputTrackLocation = self._inputLocation
from Configurables import GaudiSequencer, HltTrackConverter, TrackContainerCopy, Escher
from TAlignment.Utils import configuredFitAndHitAdderSequence
seq = GaudiSequencer(self.name() + "Seq")
## Here starts Stefania's code ========================
from Configurables import MuonNNetRec, MuonPadRec, MuonClusterRec
muonTrackTool = MuonNNetRec(
name="MuonNNetRec",
AssumeCosmics=False,
PhysicsTiming=False,
AssumePhysics=
True, ## assume that tracks come from IP (only forward)
AddXTalk=True,
XtalkRadius=1.5,
SkipStation=0,
#DecodingTool = "MuonMonHitDecode", # default is "MuonHitDecode"
ClusterTool="MuonClusterRec" # default is "MuonFakeClustering"
#OutputLevel = 2
)
clusterTool = MuonClusterRec(name="MuonClusterRec",
OutputLevel=5,
MaxPadsPerStation=500) #default 1500
padRecTool = MuonPadRec(name="PadRecTool", OutputLevel=5)
from Configurables import MakeMuonTracks
copy = MakeMuonTracks(name='MakeMuonTracks',
OutputLevel=5,
SkipBigClusters=True)
copy.addTool(muonTrackTool, name='MuonRecTool')
# ------------------------------------------------------------------
seq.Members += [copy] # Copy MuonTracks to LHCb tracks
# ------------------------------------------------------------------
from TrackFitter.ConfiguredFitters import ConfiguredForwardStraightLineEventFitter #, ConfiguredStraightLineFitter
from Configurables import MeasurementProvider, TrackKalmanFilter
muonTrackFit = ConfiguredForwardStraightLineEventFitter(
"MuonTrackFit", TracksInContainer="Rec/Track/Muon")
#muonTrackFit = ConfiguredStraightLineFitter( 'MuonTrackFit' , TracksInContainer = 'Rec/Track/Muon' )
muonTrackFit.Fitter.OutputLevel = 5
muonTrackFit.Fitter.addTool(TrackKalmanFilter, 'NodeFitter')
muonTrackFit.Fitter.addTool(MeasurementProvider, name='MeasProvider')
muonTrackFit.Fitter.MeasProvider.MuonProvider.clusterize = True #default False
muonTrackFit.Fitter.MeasProvider.MuonProvider.OutputLevel = 5
muonTrackFit.Fitter.ErrorX = 1000
muonTrackFit.Fitter.ErrorY = 10000
muonTrackFit.Fitter.MaxNumberOutliers = 0
# ------------------------------------------------------------------
seq.Members += [muonTrackFit]
# ------------------------------------------------------------------
from Configurables import TAlignment, GetElementsToBeAligned
from Configurables import TrackFilterAlg
trackFilterAlg = TrackFilterAlg(
name="FilterTracks",
OutputLevel=5,
TracksInputContainer="Rec/Track/Muon", # MuonTrackRec
TracksOutputContainer="Rec/Track/SelectedMuon", # Filtered tracks
MuonFilter=True, ###------------------------------ MUONTRACKSELECTOR
MuonPcut=6000., ## 6 GeV
MuonChisquareCut=5,
inCaloAcceptance=True,
noOverlap=False,
#TheRegion = 10
minHitStation=3) # >3
####???????
trackFilterAlg.addTool(GetElementsToBeAligned(
OutputLevel=5, Elements=TAlignment().ElementsToAlign),
name="GetElementsToBeAligned")
# ------------------------------------------------------------------
seq.Members += [trackFilterAlg]
# ------------------------------------------------------------------
from Configurables import TrackMuonMatching, TrackMasterExtrapolator, TrackChi2Calculator
#, TrajOTCosmicsProjector, TrajOTProjector, TrackProjectorSelector
matching = TrackMuonMatching(
name="TrackMuonMatching",
AllCombinations=False, # default true
MatchAtFirstMuonHit=True, # default false
FullDetail=True, #????
OutputLevel=5,
TTracksLocation=inputTrackLocation, # Best container + chisquare < 5
MuonTracksLocation='Rec/Track/SelectedMuon', # MuonNNet
TracksOutputLocation='Rec/Track/Best/TMuon',
MatchChi2Cut=20.0,
WriteNtuple=False)
matching.addTool(TrackMasterExtrapolator, name='Extrapolator')
matching.Extrapolator.ApplyMultScattCorr = True
matching.Extrapolator.ApplyEnergyLossCorr = False
matching.Extrapolator.ApplyElectronEnergyLossCorr = False
matching.addTool(TrackChi2Calculator, name='Chi2Calculator')
# ------------------------------------------------------------------
seq.Members += [matching] # Track-Muon Matching
# ------------------------------------------------------------------
from TrackFitter.ConfiguredFitters import ConfiguredEventFitter
#tmuonfit = ConfiguredFastEventFitter( 'TMuonFit', TracksInContainer = 'Rec/Track/Best/TMuon') # contains Best+Muon
tmuonfit = ConfiguredEventFitter(
"TMuonFit",
TracksInContainer='Rec/Track/Best/TMuon') # contains Best+Muon
tmuonfit.Fitter.MakeNodes = True
tmuonfit.Fitter.MakeMeasurements = True
tmuonfit.Fitter.addTool(TrackKalmanFilter, 'NodeFitter')
tmuonfit.Fitter.ErrorX = 1000
tmuonfit.Fitter.ErrorY = 10000
tmuonfit.Fitter.NumberFitIterations = 5
tmuonfit.Fitter.MaxDeltaChiSqConverged = 0.1
tmuonfit.Fitter.MaxNumberOutliers = 0
tmuonfit.Fitter.addTool(MeasurementProvider(), name='MeasProvider')
tmuonfit.Fitter.MeasProvider.MuonProvider.clusterize = True
#tmuonfit.Fitter.MeasProvider.MuonProvider.OutputLevel = 2
tmuonfit.Fitter.MeasProvider.IgnoreMuon = False
# ------------------------------------------------------------------
seq.Members += [tmuonfit] # Fit TMuon tracks
# ------------------------------------------------------------------
from Configurables import TrackSelector, TrackContainerCopy
tmuonselectoralg = TrackContainerCopy(
name="TmuonSelection",
inputLocations=['Rec/Track/Best/TMuon'],
outputLocation=self.location())
tmuonselectoralg.addTool(TrackSelector, name="Selector")
tmuonselectoralg.Selector.MaxChi2Cut = 10
#tmuonselectoralg.Selector.OutputLevel = 2
# ------------------------------------------------------------------
seq.Members += [tmuonselectoralg] # selects good TMuon tracks
# ------------------------------------------------------------------
return seq
#CondDB().addLayer( otCalib )
#
#from Configurables import UpdateManagerSvc
#UpdateManagerSvc().ConditionsOverride += ["Conditions/Online/LHCb/Magnet/Measured := double Current = 5849.9936523438 ; int Polarity = -1;"]
#
#aligndb = '/data/work/DataBases/TTLayerITLayerOTModules_CollisionsDecember2009.db'
#from Configurables import ( CondDB, CondDBAccessSvc )
#alignCond = CondDBAccessSvc( 'AlignCond' )
#alignCond.ConnectionString = 'sqlite_file:' + aligndb + '/LHCBCOND'
#CondDB().addLayer( alignCond )
from Configurables import (TrackSys, GaudiSequencer, Escher, TAlignment,
TStation, ATrackSelector, TrackMonitor,
OTTrackMonitor, TAConfig, AlignTrTools)
TrackSys().TrackPatRecAlgorithms = ["PatSeed"]
GaudiSequencer("RecoRICHSeq").Enable = False
GaudiSequencer("RecoVELOSeq").Enable = False
GaudiSequencer("RecoTTSeq").Enable = False
GaudiSequencer("RecoITSeq").Enable = False
TAlignment().WriteCondSubDetList = ["OT"]
TAlignment().OutputLevel = 2
Escher().Detectors = ["OT"]
Escher().EvtMax = 5000
Escher().PrintFreq = 1000
Escher().AlignmentLevel = "layers"
Escher().Millepede = True
Escher().Kalman = False
Escher().Incident = "GlobalMPedeFit"
# or
#
# $ESCHEROPTS/gaudiiter.py -n NUMITER -e NUMEVENTS $ESCHEROPTS/AlignOTCosmics.py $ESCHEROPTS/2008-Cosmic-Data.py
#
##############################################################################
from Configurables import (Escher, TrackSys, RecSysConf)
Escher().DataType = "2008"
Escher().Kalman = True
Escher().Millepede = False
Escher(
).TrackContainer = "Rec/Track/Best" # Velo, VeloR, Long, Upstream, Downstream, Ttrack, Muon or Calo
Escher().EvtMax = 100000
Escher().SpecialData = ["fieldOff", "cosmics"]
TrackSys().ExpertTracking += [
"noDrifttimes", "noMaterialCorrections", "simplifiedGeometry"
]
TrackSys().TrackPatRecAlgorithms = ["PatSeed"]
TrackSys().TrackExtraInfoAlgorithms = ['']
RecSysConf().RecoSequence = ["TT", "IT", "OT", "Tr"]
#RecSysConf().RecoSequence = ["OT","Tr"]
###############################################################
from GaudiKernel.SystemOfUnits import GeV, mm
from Gaudi.Configuration import *
useDriftTime = False #
FixedStations = [] #['M2','M4'] #'M1M5'
from Configurables import Velo__VeloTrackMonitor
from Configurables import EventClockSvc
from Configurables import Vetra
from Configurables import VetraRecoConf
from Configurables import ST__STDumpADCs
generalOutputLevel = 3
#Vetra().MainSequence = [ 'ProcessPhase/Reco', GaudiSequencer('MoniTTSeq'), GaudiSequencer('MoniSTSeq')]
Vetra().MainSequence = [
'ProcessPhase/Reco',
GaudiSequencer('MoniITSeq'),
GaudiSequencer('MoniSTSeq')
]
TrackSys().ExcludedLayers = ["T3X2"]
#TrackSys().TrackPatRecAlgorithms = TrackSys().DefaultPatRecAlgorithmsRun2
#VetraRecoConf().Sequence = [ "Decoding" ] + RecSysConf().DefaultTrackingSubdets # = ["Decoding", "VELO","TT","IT","OT","Tr","Vertex"]
VetraRecoConf().Sequence = [
"Decoding", "VELO", "TT", "IT", "OT", "TrHLT1", "Vertex", "TrHLT2"
]
VetraRecoConf().TrackPatRecAlgorithms = TrackSys().DefaultPatRecAlgorithmsRun2
print '----------------------------------------------------------------------------------------------------\n\n\n\n\n'
print TrackSys().DefaultPatRecAlgorithms
print RecSysConf().DefaultTrackingSubdets
print '----------------------------------------------------------------------------------------------------\n\n\n\n\n'
from Configurables import CondDB, CondDBAccessSvc, CondDBTimeSwitchSvc
connection = "sqlite_file:$STSQLDDDBROOT/db/STCOND.db/COND"
CondDB().addLayer(CondDBAccessSvc("COND", ConnectionString=connection))
##############################################################################
from Configurables import (Escher, TrackSys, RecSysConf)
from Gaudi.Configuration import *
from GaudiConf.Configuration import *
from GaudiKernel.ProcessJobOptions import importOptions
importOptions('$STDOPTS/PreloadUnits.opts')
Escher().Kalman = True
Escher().Millepede = False
Escher().EvtMax = 1000
Escher().UseOracle = False
Escher().DatasetName = "Collisions2011"
Escher().PrintFreq = 100
TrackSys().ExpertTracking += ["simplifiedGeometry"]
TrackSys().TrackExtraInfoAlgorithms = ['']
RecSysConf().RecoSequence = [
"Decoding", "VELO", "TT", "IT", "OT", "Tr", "Vertex", "CALO", "MUON"
]
Escher().MoniSequence = ["Tr", "OT", "ST"]
from Configurables import MagneticFieldSvc
MagneticFieldSvc().OutputLevel = 1
from Configurables import TAlignment
from TAlignment.Alignables import *
from TAlignment.SurveyConstraints import *
elements = Alignables()
def ConfiguredTrackMonitorSequence(Name="TrackMonitorSequence",
HistoPrint=False):
# figure out detectors
seq = GaudiSequencer(Name)
subDets = None #default, all monitors
from Configurables import LHCbApp
if hasattr(LHCbApp(), "Detectors"):
if LHCbApp().isPropertySet("Detectors"):
subDets = LHCbApp().getProp("Detectors")
seq.Members.append(TrackMonitor(HistoPrint=HistoPrint))
seq.Members.append(TrackDiMuonMonitor(HistoPrint=HistoPrint))
seq.Members.append(TrackVertexMonitor(HistoPrint=HistoPrint))
seq.Members.append(AlignmentOnlineMonitor(HistoPrint=HistoPrint))
from Configurables import TrackSys
if TrackSys().timing():
seq.Members.append(TrackTimingMonitor(HistoPrint=HistoPrint))
if not RecMoniConf().getProp("Histograms") is "Online":
seq.Members.append(TrackV0Monitor(HistoPrint=HistoPrint))
seq.Members.append(TrackFitMatchMonitor(HistoPrint=HistoPrint))
seq.Members.append(TrackAlignMonitor(HistoPrint=HistoPrint))
if (subDets is None or "IT" in subDets):
seq.Members.append(TrackITOverlapMonitor(HistoPrint=HistoPrint))
if (subDets is None or "Velo" in subDets):
seq.Members.append(TrackVeloOverlapMonitor(HistoPrint=HistoPrint))
if (subDets is None or "TT" in subDets):
seq.Members.append(TTTrackMonitor(HistoPrint=HistoPrint))
if (subDets is None or "IT" in subDets):
seq.Members.append(ITTrackMonitor(HistoPrint=HistoPrint))
seq.Members.append(TrackPV2HalfAlignMonitor(HistoPrint=HistoPrint))
if RecMoniConf().expertHistos():
if [
det for det in ['Velo', 'TT', 'IT', 'OT']
if (subDets is None or det in subDets)
]:
seq.Members.append(HitEffPlotter(HistoPrint=HistoPrint))
#else:
# log.warning("HitEffPlotter not defined for upgrade")
if "CALO" in RecSysConf().RecoSequence:
if (subDets is None or "Ecal" in subDets):
seq.Members.append(
TrackCaloMatchMonitor("TrackEcalMatchMonitor",
CaloSystem='Ecal',
HistoPrint=HistoPrint))
#if ("Hcal" in subDets):
#seq.Members.append(TrackCaloMatchMonitor("TrackHcalMatchMonitor", CaloSystem='Hcal', HistoPrint=HistoPrint))
if (subDets is None or "Spd" in subDets):
seq.Members.append(
TrackCaloMatchMonitor("TrackSpdMatchMonitor",
CaloSystem='Spd',
HistoPrint=HistoPrint))
if (subDets is None or "Prs" in subDets):
seq.Members.append(
TrackCaloMatchMonitor("TrackPrsMatchMonitor",
CaloSystem='Prs',
HistoPrint=HistoPrint))
if "MUON" in RecSysConf().RecoSequence:
if (subDets is None or "Muon" in subDets):
seq.Members.append(
TrackMuonMatchMonitor("TrackMuonMatchMonitor",
HistoPrint=HistoPrint))
return seq
def configureSequences(self):
# Check for special data options
for option in self.getProp('SpecialData'):
if option not in self.KnownSpecialData:
raise RunTimeError("Unknown SpecialData option '%s'" % option)
escherSeq = GaudiSequencer("EscherSequencer")
#escherSeq.Context = self.getProp("Context")
ApplicationMgr().TopAlg = [escherSeq]
mainSeq = self.getProp("MainSequence")
if len(mainSeq) == 0:
self.MainSequence = self.DefaultSequence
mainSeq = self.MainSequence
escherSeq.Members += mainSeq
ProcessPhase("Init").DetectorList += self.getProp("InitSequence")
ProcessPhase("Init").Context = self.getProp("Context")
from Configurables import RecInit, TrackSys
log.info("Setting up alignment sequence")
recInit = RecInit(name="EscherInit",
PrintFreq=self.getProp("PrintFreq"))
GaudiSequencer("InitEscherSeq").Members += [recInit]
# set up the HltFilterSeq
from Configurables import HltCompositionMonitor
from Configurables import LoKi__HDRFilter as HDRFilter
hltFilterSeq = GaudiSequencer("HltFilterSeq")
from DAQSys.Decoders import DecoderDB
from DAQSys.DecoderClass import decodersForBank
from itertools import chain
hltdecs = [DecoderDB.get("HltDecReportsDecoder/Hlt1DecReportsDecoder")]
if not self.getProp("OnlineMode"):
## HLT2 decreports are only used offline.
hltdecs += [
DecoderDB.get("HltDecReportsDecoder/Hlt2DecReportsDecoder")
]
hltFilterSeq.Members = [d.setup() for d in hltdecs]
## FIXME: These lines should go back in as soon as an easy to use filter
## FIXME: is available that works for HLT1 and HLT2 decreports at the same time.
## identifies events that are not of type Hlt1ErrorEvent or Hlt2ErrorEvent
## hltErrCode = "HLT_PASS_RE('Hlt1(?!ErrorEvent).*Decision') & HLT_PASS_RE('Hlt2(?!ErrorEvent).*Decision')"
## hltErrorFilter = HDRFilter('HltErrorFilter', Code = hltErrCode ) # the filter
## hltFilterSeq.Members += [ HltCompositionMonitor(), hltErrorFilter ]
## add more hlt filters, if requested
## if hasattr(self,"HltFilterCode") and len(self.getProp("HltFilterCode"))>0:
## hltfilter = HDRFilter ( 'HLTFilter',
## Code = self.getProp("HltFilterCode"))
## hltfilter.Preambulo += [ "from LoKiCore.functions import *" ]
## hltFilterSeq.Members += [ hltfilter ]
# in Escher we'll always use the DOD
ApplicationMgr().ExtSvc += ["DataOnDemandSvc"]
alignSeq = GaudiSequencer("AlignSequence")
# if the patter reco is not run, we need the DataOnDemand svc
# so that e.g. the track container(s) is unpacked:
if not GaudiSequencer("RecoTrSeq").getProp("Enable"):
DstConf(EnableUnpack=True)
# Setup tracking sequence
trackConf = TrackSys()
self.setOtherProps(trackConf, [
"SpecialData", "OutputType", "DataType", "Simulation", "GlobalCuts"
])
trackConf.ExpertTracking = self.getProp("ExpertTracking")
ta = TAlignment()
ta.Upgrade = self.getProp("Upgrade")
self.setOtherProps(ta,
["DatasetName", "OnlineMode", "OnlineAligWorkDir"])
ta.Sequencer = alignSeq
if self.getProp("Millepede"):
log.info("Using Millepede type alignment!")
self.setProp("Incident", "GlobalMPedeFit")
ta.Method = "Millepede"
ta.Sequencer = GaudiSequencer("MpedeAlignSeq")
from Configurables import (Escher, TrackSys, RecSysConf)
from GaudiKernel.ProcessJobOptions import importOptions
importOptions('$STDOPTS/PreloadUnits.opts')
#Escher().DataType = "2008"
#Escher().DDDBtag = "default"
#Escher().CondDBtag = "default"
#Escher().Detectors = ["Velo","OT"]
Escher().Kalman = True
Escher().Millepede = False
Escher(
).TrackContainer = "Rec/Track/Best" # Velo, VeloR, Long, Upstream, Downstream, Ttrack, Muon or Calo
Escher().EvtMax = 100
TrackSys().ExpertTracking += ["kalmanSmoother"]
TrackSys().TrackExtraInfoAlgorithms = ['']
RecSysConf().RecoSequence = ["VELO", "TT", "IT", "OT", "Tr", "Vertex"]
from Configurables import TAlignment
from TAlignment.Alignables import *
elements = Alignables()
elements.VeloLeft("TxTyTzRzRxRy")
constraints = []
#elements.VeloRight("TxTyTzRz")
#constraints = ["Tz","Tx","Ty","Rz"]
print "aligning elements ", elements
TAlignment().ElementsToAlign = list(elements)
#Escher().DataType = "2008"
#Escher().DDDBtag = "default"
#Escher().CondDBtag = "default"
#Escher().Detectors = ["Velo"]
Escher().Kalman = True
Escher().InputType = "DST"
Escher().Millepede = False
Escher(
).TrackContainer = "Rec/Track/Best" # Velo, VeloR, Long, Upstream, Downstream, Ttrack, Muon or Calo
Escher().EvtMax = 10000
#TrackSys().ExpertTracking += [ "kalmanSmoother" ]
#TrackSys().TrackExtraInfoAlgorithms = ['']
#RecSysConf().RecoSequence = ["VELO","TT","IT","OT","Tr","Vertex"]
RecSysConf().RecoSequence = ["VELO", "Tr", "Vertex"]
TrackSys().TrackPatRecAlgorithms = ["Velo"]
from Configurables import (ProcessPhase, AlignSensors, VAlign,
WriteAlignmentConditions, TrackVertexMonitor,
PatPVOffline)
from TrackFitter.ConfiguredFitters import *
from TrackFitter.ConfiguredFitters import (ConfiguredStraightLineFit)
def doMyAlignChanges():
#veloAlign=AlignSensors("AlignSensors")
veloAlign = VAlign("VAlign")
GaudiSequencer("AlignSequence").Members = [
veloAlign,
#WriteAlignmentConditions("WriteDetectors"),
WriteAlignmentConditions("WriteGlobal"),
def STPerformanceStudy(Name_Prefix="STPerf_",
Efficiency=True,
Residuals=True,
ActivateFullClusters=True,
TrackContainter=False):
#Define tracks for ST Performance
if not TrackContainter:
from Configurables import TrackSelector, TrackContainerCopy
goodtracksselector = TrackContainerCopy(
name=Name_Prefix + "Selection",
inputLocation='/Event/Rec/Track/Best',
outputLocation='/Event/Rec/Track/PerformanceTracks')
goodtracksselector.addTool(TrackSelector, name="Selector")
goodtracksselector.Selector.MinPCut = 10000.
goodtracksselector.Selector.MaxChi2Cut = 2.
goodtracksselector.Selector.MaxChi2PerDoFMatch = 2.
goodtracksselector.Selector.MaxChi2PerDoFDownstream = 2.
goodtracksselector.Selector.MaxChi2PerDoFVelo = 2.
goodtracksselector.Selector.TrackTypes = ["Long"]
TrackLocation = '/Event/Rec/Track/PerformanceTracks'
else:
TrackLocation = TrackContainter
#Define clusters used for ST Efficiency studies
from Configurables import STClusterCollector
# Search window (residual) for STEfficiency and STClusterCollector
window = 0.4
# Tolerance for X an Y in the first estimate of the track crossing the silicion position
# and central position of the cluster
xTol = 1.
yTol = 0.
# Collecting the ST clusters
itClusterCollector = STClusterCollector("ToolSvc.ITClusterCollector")
itClusterCollector.DetType = "IT"
itClusterCollector.ignoreHitsOnTrack = False
itClusterCollector.xTol = xTol
itClusterCollector.yTol = yTol
itClusterCollector.window = window
itClusterCollector.MagFieldOn = True
itClusterCollector.dataLocation = "/Event/Raw/IT/Clusters"
ttClusterCollector = STClusterCollector("ToolSvc.TTClusterCollector")
ttClusterCollector.DetType = "TT"
ttClusterCollector.ignoreHitsOnTrack = False
ttClusterCollector.xTol = xTol
ttClusterCollector.yTol = yTol
ttClusterCollector.window = window
ttClusterCollector.MagFieldOn = True
ttClusterCollector.dataLocation = "/Event/Raw/TT/Clusters"
#Configuring ST Efficiency algorithms
from Configurables import STEfficiency
ttEff = STEfficiency(Name_Prefix + "TTHitEfficiency")
ttEff.TracksInContainer = TrackLocation
ttEff.DetType = "TT"
ttEff.Cuts = [window]
ttEff.XLayerCut = window #0.4
ttEff.StereoLayerCut = window #0.4
ttEff.MinExpectedSectors = 2 #2
ttEff.MaxNbResSectors = 10 #10
ttEff.MinStationPassed = 1 #1
# Edge size excluded of the computation
ttEff.MinDistToEdgeX = 2 #2
ttEff.MinDistToEdgeY = 2 #2
ttEff.ResidualsPlot = False
ttEff.FullDetail = False
ttEff.TH1DSummaryHist = True
ttEff.EfficiencyPlot = False
ttEff.SingleHitPerSector = True #True
ttEff.TakeEveryHit = True #True
ttEff.OutputLevel = 3
itEff = STEfficiency(Name_Prefix + "ITHitEfficiency")
itEff.TracksInContainer = TrackLocation
itEff.DetType = "IT"
itEff.Cuts = [window]
itEff.XLayerCut = window #0.4
itEff.StereoLayerCut = window #0.4
itEff.MinExpectedSectors = 6 #6
itEff.MaxNbResSectors = 10
itEff.MinStationPassed = 3 #3
# Edge size excluded of the computation
itEff.MinDistToEdgeX = 2 #2
itEff.MinDistToEdgeY = 2 #2
itEff.ResidualsPlot = False
itEff.FullDetail = False
itEff.TH1DSummaryHist = True
ttEff.EfficiencyPlot = False
itEff.SingleHitPerSector = True
itEff.TakeEveryHit = True
itEff.OutputLevel = 3
#Configuring Track Monitors to work in performance mode
from Configurables import ITTrackMonitor, TTTrackMonitor
itMon = ITTrackMonitor(Name_Prefix + 'ITTrackMonitor')
itMon.TracksInContainer = TrackLocation
itMon.FullDetail = False
itMon.plotsByLayer = False
itMon.plotsBySector = False
itMon.ProfileSummaryHist = False
itMon.TH2DSummaryHist = True
itMon.minNumITHits = 6
ttMon = TTTrackMonitor(Name_Prefix + 'TTTrackMonitor')
ttMon.TracksInContainer = TrackLocation
ttMon.FullDetail = False
ttMon.plotsBySector = False
ttMon.ProfileSummaryHist = False
ttMon.TH2DSummaryHist = True
ttMon.minNumTTHits = 2
#These lines activates Full clusters. For .raw data only!
#Access to the full clusters
if ActivateFullClusters:
from Configurables import TrackSys
TrackSys().ExpertTracking = ["fullClustersHLT1", "fullClustersHLT2"]
# Post configuration actions
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]
from GaudiKernel.Configurable import appendPostConfigAction
appendPostConfigAction(PostConfigurationActions)
return True
from Configurables import Brunel, NTupleSvc, TrackSys, RecMoniConf
Brunel().InputType = "DIGI" # implies also Brunel().Simulation = True
Brunel().WithMC = True # implies also Brunel().Simulation = True
Brunel().OutputType = "NONE"
Brunel().Histograms = "Expert"
TrackSys().TrackPatRecAlgorithms = [ "Truth", "FastVelo" ]
Brunel().RecoSequence = ["Decoding", "Truth", "VELO" ]
RecMoniConf().MoniSequence = [ ]
Brunel().MCLinksSequence = [ "Tr" ]
Brunel().MCCheckSequence = [ "Fit" ]
from Configurables import DDDBConf
DDDBConf().DbRoot = "/afs/cern.ch/user/o/ogruenbe/public/FT_upgrade/static_DDDB_FT_v4/lhcb.xml"
Brunel().DDDBtag = "MC11-20111102"
Brunel().CondDBtag = "sim-20111111-vc-md100"
NTupleSvc().Output = ["FILE1 DATAFILE='~/w0/track.root' TYP='ROOT' OPT='NEW'"]
from Configurables import LHCbApp
from Gaudi.Configuration import *
from GaudiConf import IOHelper
IOHelper().inputFiles(['PFN:root://castorlhcb.cern.ch//castor/cern.ch/user/o/ocallot/Bs_mumu_v4_nu50.digi?svcClass=default'])
Brunel().EvtMax = 1000
def doMyChanges():
from Configurables import GaudiSequencer
GaudiSequencer("CaloBankHandler").Members = []
GaudiSequencer("RecoDecodingSeq").Members = [ "DecodeVeloRawBuffer/DecodeVeloClusters", "FTRawBankDecoder" ]
#LHCbApp().DDDBtag = 'dddb-20131025'
#LHCbApp().CondDBtag = 'sim-20130830-vc-md100'
#CondDB().LoadCALIBDB = 'HLT1'
###CHANGE ME
#Brunel().DDDBtag = 'dddb-20150424'
#Brunel().CondDBtag = 'sim-20140204-vc-md100'
Brunel().DDDBtag = 'dddb-20150724'
Brunel().CondDBtag = 'sim-20161124-2-vc-mu100'
###################################
# Tracking Settings
from Configurables import TrackSys
TrackSys().TrackTypes = ["Velo", "Seeding", "Downstream"
] #Choose the track types you want to reconstruct
from Configurables import RecSysConf
#RecSysConf().RecoSequence = ["Decoding","Tr"]# More options: "Vertex","RICH","CALO","MUON","PROTO","SUMMARY"
Brunel().RecoSequence = ["Decoding", "VELO", "TrHLT1", "Vertex", "TrHLT2"]
Brunel().Detectors = ['Velo', 'PuVeto', 'TT', 'IT', 'OT', 'Magnet']
# MiscSettings
from Configurables import RecMoniConf
RecMoniConf().MoniSequence = []
from Configurables import L0Conf
L0Conf().EnsureKnownTCK = False
#mc linking
#GaudiSequencer("MCLinksTrSeq").Members = []
def configureCheck(self,expert):
# "Check" histograms filled only with simulated data
KnownCheckSubdets = ["Pat"]
# CheckSubdets
if [det for det in ['Rich1', 'Rich2', 'Rich1Pmt', 'Rich2Pmt'] if det in self.getProp("Detectors")]:
KnownCheckSubdets.append("RICH")
if [det for det in ['Muon', 'MuonNoM1'] if det in self.getProp("Detectors")]:
KnownCheckSubdets.append("MUON")
# Expert Check Subdets
KnownExpertCheckSubdets = [] + KnownCheckSubdets
if [det for det in ['TT'] if det in self.getProp("Detectors")]:
KnownExpertCheckSubdets.append("TT")
tmpExpertSubdets = [det for det in ['IT', 'OT'] if det in self.getProp("Detectors")]
if tmpExpertSubdets:
for det in tmpExpertSubdets:
KnownExpertCheckSubdets.append(det)
if [det for det in ['Tr'] if det in self.getProp("Detectors")]:
KnownExpertCheckSubdets.append('Tr')
if [det for det in ['Spd', 'Prs', 'Ecal', 'Hcal'] if det in self.getProp("Detectors")]:
KnownExpertCheckSubdets.append("CALO")
KnownExpertCheckSubdets.append("PROTO")
RecMoniConf().setProp( "CheckEnabled", True )
if not self.isPropertySet("MCCheckSequence"):
if expert:
checkSeq = KnownExpertCheckSubdets
else:
checkSeq = KnownCheckSubdets
self.MCCheckSequence = checkSeq
else:
for seq in self.getProp("MCCheckSequence"):
if expert:
if seq not in KnownExpertCheckSubdets:
log.warning("Unknown subdet '%s' in MCCheckSequence"%seq)
else:
if seq not in KnownCheckSubdets:
log.warning("Unknown subdet '%s' in MCCheckSequence"%seq)
checkSeq = self.getProp("MCCheckSequence")
from Configurables import ProcessPhase
ProcessPhase("Check").DetectorList += checkSeq
# Tracking handled inside TrackSys configurable
TrackSys().setProp( "WithMC", True )
if ("MUON" in checkSeq) and ("Muon" in self.getProp("Detectors")):
from MuonPIDChecker import ConfigureMuonPIDChecker as cmuon
mydata = self.getProp("DataType")
mycheckconf = cmuon.ConfigureMuonPIDChecker(data = mydata)
mycheckconf.configure(UseMC = True, HistosLevel = self.getProp("Histograms"))
if ("RICH" in checkSeq) and [det for det in ['Rich1', 'Rich2', 'Rich1Pmt', 'Rich2Pmt'] if det in self.getProp("Detectors")] :
from Configurables import GaudiSequencer
richMoniConf = RichRecQCConf(self.richMoniConfName)
self.setOtherProps(richMoniConf, ["Histograms","Context","OutputLevel","OnlineMode",
"DataType","WithMC","Simulation"] )
richMoniConf.setProp("MoniSequencer", GaudiSequencer("CheckRICHSeq"))
if expert:
# Data on Demand for MCParticle to MCHit association, needed by ST, IT, OT, Tr, Muon
# Different for upgrade and non-upgrade
if( self.getProp("DataType") is "Upgrade" ):
importOptions( "$ASSOCIATORSROOT/options/MCParticleToMCHitUpgrade.py" )
else:
importOptions( "$ASSOCIATORSROOT/options/MCParticleToMCHit.py" )
# Allow multiple files open at once (SIM,DST,DIGI etc.)
IODataManager().AgeLimit += 1
if (
("TT" in checkSeq) and
(hasattr(self, "Detectors")) and
("TT" in self.getProp("Detectors"))
):
from Configurables import ( STEffChecker, MCParticleSelector )
from GaudiKernel.SystemOfUnits import GeV
effCheck = STEffChecker("TTEffChecker")
effCheck.FullDetail = True
effCheck.addTool(MCParticleSelector)
effCheck.MCParticleSelector.zOrigin = 50.0
effCheck.MCParticleSelector.pMin = 1.0*GeV
effCheck.MCParticleSelector.betaGammaMin = 1.0
from Configurables import GaudiSequencer
GaudiSequencer("CheckTTSeq").Members += [effCheck]
if (
("IT" in checkSeq) and
(hasattr(self, "Detectors")) and
("IT" in self.getProp("Detectors"))
):
from Configurables import ( STEffChecker, MCParticleSelector )
from GaudiKernel.SystemOfUnits import GeV
effCheck = STEffChecker("ITEffChecker")
effCheck.FullDetail = True
effCheck.addTool(MCParticleSelector)
effCheck.MCParticleSelector.zOrigin = 50.0
effCheck.MCParticleSelector.pMin = 1.0*GeV
effCheck.MCParticleSelector.betaGammaMin = 1.0
effCheck.DetType = "IT"
from Configurables import GaudiSequencer
GaudiSequencer("CheckITSeq").Members += [effCheck]
if (
("OT" in checkSeq) and
(hasattr(self, "Detectors")) and
("OT" in self.getProp("Detectors"))
):
GaudiSequencer("CheckOTSeq").Members += ["OTTimeChecker"] # needs MCHits
if "Tr" in checkSeq :
# Checking on the tracks in the "best" container - needs MCHits
# not active for upgrade for the moment
if( self.getProp("DataType") is "Upgrade" ):
pass
else:
importOptions( "$TRACKSYSROOT/options/TrackChecking.opts" )
if "CALO" in checkSeq :
import GaudiKernel.ProcessJobOptions
GaudiKernel.ProcessJobOptions.PrintOn()
from Configurables import GaudiSequencer
ccseq=GaudiSequencer("CaloCheckers")
noSPDPRS = False
if [det for det in ['Spd', 'Prs'] if det in self.getProp("Detectors")]:
noSPDPRS = True
caloMoni = CaloMoniDstConf( CheckerSequence = ccseq,
OutputLevel = self.getProp('OutputLevel'),
Context = 'Offline',
NoSpdPrs = noSPDPRS)
caloMoni.printConf()
GaudiKernel.ProcessJobOptions.PrintOff()
GaudiSequencer("CheckCALOSeq").Members = [ "CaloDigit2MCLinks2Table", "CaloClusterMCTruth" ,ccseq]
if "PROTO" in checkSeq :
from Configurables import GaudiSequencer
self.setOtherProps(GlobalRecoChecks(),["OutputLevel"])
exSeq = GaudiSequencer("ExpertProtoMoni")
GaudiSequencer("CheckPROTOSeq").Members += [exSeq]
GlobalRecoChecks().Sequencer = exSeq
#
##############################################################################
from Configurables import (Escher, TrackSys, RecSysConf)
from GaudiKernel.ProcessJobOptions import importOptions
importOptions('$STDOPTS/PreloadUnits.opts')
Escher().DataType = "2008"
Escher().Kalman = True
Escher().Millepede = False
Escher(
).TrackContainer = "Rec/Track/Best" # Velo, VeloR, Long, Upstream, Downstream, Ttrack, Muon or Calo
Escher().EvtMax = 100000
Escher().SpecialData = ["fieldOff", "cosmics"]
TrackSys().ExpertTracking += ["noDrifttimes", "kalmanSmoother"]
TrackSys().TrackPatRecAlgorithms = ["PatSeed"]
TrackSys().TrackExtraInfoAlgorithms = ['']
RecSysConf().RecoSequence = ["TT", "IT", "OT", "Tr"]
# load a special database
#from Configurables import ( CondDB, CondDBAccessSvc )
#otGeom = CondDBAccessSvc( 'OTGeom' )
#otGeom.ConnectionString = 'sqlite_file:/afs/cern.ch/user/j/janos/dbase/OTDDDBCroissant.db/DDDB'
#CondDB().addLayer( otGeom )
#otCond = CondDBAccessSvc( 'OTCond' )
#otCond.ConnectionString = 'sqlite_file:/afs/cern.ch/user/j/janos/dbase/LHCBCOND_changes.db/LHCBCOND'
#CondDB().addLayer( otCond )
# configure the alignment
# Escher().TrackContainer = "Rec/Track/Velo" # Velo, VeloR, Long, Upstream, Downstream, Ttrack, Muon or Calo
Escher().EvtMax = -1
Escher().MoniSequence = []
Escher().RecoSequence = [
"Decoding", "VP", "VELOPIX", "Tr", "Vertex", "CALO", "PROTO"
]
Escher().WithMC = True
Escher().Simulation = True
Escher().DataType = 'Upgrade'
Escher().Upgrade = True
RecSysConf().Detectors = detectors
RecMoniConf().Detectors = detectors
Escher().ExpertTracking = ["kalmanSmoother"]
TrackSys().TrackExtraInfoAlgorithms = []
TrackSys().DataType = 'Upgrade'
TrackSys().Simulation = True
TrackSys().WithMC = True
#TrackSys().TrackTypes = ["Velo"]
TrackSys().TrackPatRecAlgorithms = [
"VP", "Forward", "TsaSeed", "Match", "Downstream"
]
DstConf().Detectors = detectors
hvpseq = GaudiSequencer("VPSeq")
prLHCbID2mc = PrLHCbID2MCParticle()
prPixTr = PrPixelTracking()
prPixStCl = PrPixelStoreClusters()
hvpseq.Members += [prPixStCl, prPixTr, prLHCbID2mc]
from GaudiKernel.ProcessJobOptions import importOptions
importOptions('$STDOPTS/PreloadUnits.opts')
#Escher().DataType = "2008"
#Escher().DDDBtag = "default"
#Escher().CondDBtag = "default"
Escher().Detectors = ["Velo"]
Escher().Kalman = True
Escher().Millepede = False
Escher(
).TrackContainer = "Rec/Track/Best" # Velo, VeloR, Long, Upstream, Downstream, Ttrack, Muon or Calo
Escher().EvtMax = 100
Escher().UseOracle = False
Escher().SpecialData = ["fieldOff"]
#TrackSys().ExpertTracking += [ "noMaterialCorrections"]
TrackSys().ExpertTracking += ["simplifiedGeometry"]
#TrackSys().ExpertTracking += ["noDrifttimes" ]
TrackSys().TrackExtraInfoAlgorithms = ['']
#TrackSys().TrackPatRecAlgorithms = ["Velo","Forward","PatSeed","PatMatch","Downstream","VeloTT"]
TrackSys().TrackPatRecAlgorithms = ["Velo", "Forward", "PatSeed", "PatMatch"]
TrackSys().TrackPatRecAlgorithms = ["Velo", "PatSeed", "PatMatch"]
#TrackSys().TrackPatRecAlgorithms = ["Velo","TsaSeed","PatMatch"]
TrackSys().TrackPatRecAlgorithms = ["Velo", "TsaSeed", "Match"]
#RecSysConf().RecoSequence = ["VELO","TT","IT","OT","Tr","Vertex"]
#RecSysConf().RecoSequence = ["VELO","TT","IT","OT","Tr"]
RecSysConf().RecoSequence = ["CALO", "VELO", "TT", "IT", "OT", "Tr", "Vertex"]
Escher().MoniSequence = ["VELO", "Tr", "OT", "ST"]
from Configurables import TAlignment
from TAlignment.Alignables import *
from TAlignment.SurveyConstraints import SurveyConstraints
# # $ESCHEROPTS/gaudiiter.py -n NUMITER -e NUMEVENTS $ESCHEROPTS/AlignMuonOTCosmics.py # # Run list contains dst with at least one track in the OT in good OT runs ############################################################################## from Configurables import (Escher, TrackSys, RecSysConf) Escher().DataType = "2009" Escher().Kalman = True Escher().Millepede = False Escher( ).TrackContainer = "Rec/Track/Best" # Velo, VeloR, Long, Upstream, Downstream, Ttrack, Muon or Calo Escher().EvtMax = -1 TrackSys().ExpertTracking += ["simplifiedGeometry"] TrackSys().TrackExtraInfoAlgorithms = [''] TrackSys().TrackPatRecAlgorithms = ["Velo", "TsaSeed", "Match", "Downstream"] RecSysConf().RecoSequence = ["VELO", "TT", "IT", "OT", "Tr"] ############################################################### from GaudiKernel.SystemOfUnits import GeV, mm from Gaudi.Configuration import * uselocalframe = True chisqconstraints = [] # un numero in corrispondenza di ogni constraint constraints = [] dof = 'TxTy' outputlevel = ERROR #INFO#ERROR# INFO
from Configurables import ( Escher, TrackSys, RecSysConf )
from GaudiKernel.ProcessJobOptions import importOptions
importOptions('$STDOPTS/PreloadUnits.opts')
#Escher().DataType = "2008"
#Escher().DDDBtag = "default"
#Escher().CondDBtag = "default"
#Escher().Detectors = ["Velo","OT"]
Escher().InputType = "DIGI"
Escher().Kalman = True
Escher().Millepede = False
Escher().TrackContainer = "Rec/Track/Best" # Velo, VeloR, Long, Upstream, Downstream, Ttrack, Muon or Calo
Escher().EvtMax = 1000
TrackSys().ExpertTracking += [ "kalmanSmoother","simplifiedGeometry" ]
TrackSys().TrackExtraInfoAlgorithms = ['']
RecSysConf().RecoSequence = ["VELO","TT","IT","OT","Tr","Vertex"]
from Configurables import TAlignment
from TAlignment.Alignables import *
elements = Alignables()
#elements.VeloRSensors("TxTy")
#elements.VeloPhiSensors("TxTy")
#elements.VeloModules("TzRxRyRz")
#let's do modules only, for now:
#elements.VeloModules("TxTyTzRxRyRz")
elements.VeloRSensors("TxTyTzRxRy")
elements.VeloPhiSensors("TxTyTzRxRyRz")
