def doMyAlignChanges(): #veloAlign=AlignSensors("AlignSensors") veloAlign = VAlign("VAlign") GaudiSequencer("AlignSequence").Members = [ veloAlign, #WriteAlignmentConditions("WriteDetectors"), WriteAlignmentConditions("WriteGlobal"), WriteAlignmentConditions("WriteModules"), TrackVertexMonitor("TrackVertexMonitor") ] importOptions("$VELOALIGNMENTOPTS/VeloAlign.py") veloAlign.OutputLevel = 3 PatPVOffline("PatPVOffline").OutputLevel = 3 VAlign("VAlign").Box_DOF = [1, 1, 1, 1, 1, 1] VAlign("VAlign").Box_EQs = [0, 0, 0, 0, 0, 0] TrackVertexMonitor( "TrackVertexMonitor").TrackContainer = "LHCb::TrackLocation::Velo" ###VAlign("VAlign").TrackContainer= "Rec/Track/Best" eventfitter = TrackEventFitter('FitVelo') eventfitter.Fitter.ZPositions = [] eventfitter.Fitter.ApplyMaterialCorrections = False eventfitter.Fitter.Extrapolator.ApplyMultScattCorr = False eventfitter.Fitter.Extrapolator.ApplyEnergyLossCorr = False eventfitter.Fitter.Extrapolator.ApplyElectronEnergyLossCorr = False eventfitter.Fitter.StateAtBeamLine = False eventfitter.Fitter.MaxNumberOutliers = 0 eventfitter.Fitter.NumberFitIterations = 10 eventfitter.Fitter.UpdateTransport = True
def patSeq(self, outputLevel=INFO): if not allConfigurables.get("PatSeq"): if outputLevel == VERBOSE: print "VERBOSE: Pat Sequencer not defined! Defining!" patSequencer = GaudiSequencer("PatSeq") patSequencer.MeasureTime = True from Configurables import (TESCheck, EventNodeKiller) patSequencer.Members.append( TESCheck(Inputs=["Link/Rec/Track/Best"], Stop=False)) patSequencer.Members.append( EventNodeKiller(Nodes=["Rec", "Raw", "Link/Rec"])) patSequencer.Members.append( GaudiSequencer("RecoVELOSeq", MeasureTime=True)) patSequencer.Members.append( GaudiSequencer("RecoTTSeq", MeasureTime=True)) patSequencer.Members.append( GaudiSequencer("RecoITSeq", MeasureTime=True)) patSequencer.Members.append( GaudiSequencer("RecoOTSeq", MeasureTime=True)) patSequencer.Members.append( GaudiSequencer("RecoTrSeq", MeasureTime=True)) patSequencer.Members.append( GaudiSequencer("RecoVertexSeq", MeasureTime=True)) #importOptions("$TRACKSYSROOT/options/RecoTracking.py") #importOptions("$TALIGNMENTROOT/options/PatRecognition.opts") from Configurables import TrackRemoveDoubleHits if allConfigurables.get("TrackForwardPatSeq"): trackFwdPatSeq = GaudiSequencer("TrackForwardPatSeq") trackRemoveDoubleHitsFwd = TrackRemoveDoubleHits( "FwdRemoveDoubleHits") trackRemoveDoubleHitsFwd.TracksLocation = "Rec/Track/Forward" trackFwdPatSeq.Members.append(trackRemoveDoubleHitsFwd) if allConfigurables.get("TrackMatchPatSeq"): trackMatchPatSeq = GaudiSequencer("TrackMatchPatSeq") trackRemoveDoubleHitsMatch = TrackRemoveDoubleHits( "MatchRemoveDoubleHits") trackRemoveDoubleHitsMatch.TracksLocation = "Rec/Track/Match" trackMatchPatSeq.Members.append(trackRemoveDoubleHitsMatch) from Configurables import (PatPVOffline) allConfigurables["RecoVertexSeq"].Members.append(PatPVOffline()) return patSequencer else: if outputLevel == VERBOSE: print "VERBOSE: Pat Sequencer already defined!" return allConfigurables.get("PatSeq")
def applyConf(self): # Check the special data options for option in self.getProp("SpecialData"): if option not in self.KnownSpecialData: raise RuntimeError("Unknown SpecialData option '%s'"%option) # Phases if not self.isPropertySet("RecoSequence"): self.setProp("RecoSequence",self.DefaultSubDetsFieldOn) if self.getProp("DataType") in self.Run2DataTypes: self.setProp("RecoSequence",self.DefaultSubDetsFieldOnRun2) recoSeq = self.getProp("RecoSequence") if self.getProp("SkipTracking"): for det in self.DefaultTrackingSubdets: if det in recoSeq: recoSeq.remove(det) from Configurables import ProcessPhase ProcessPhase("Reco").DetectorList += recoSeq # Primary Vertex and V0 finding if "Vertex" in recoSeq and self.getProp("DataType") not in self.Run2DataTypes: from Configurables import PatPVOffline, TrackV0Finder pvAlg = PatPVOffline() if "2009" == self.getProp("DataType"): from PatPV import PVConf PVConf.VLoosePV().configureAlg() elif ( "veloOpen" in self.getProp("SpecialData") or "microBiasTrigger" in self.getProp("SpecialData") ): from PatPV import PVConf PVConf.LoosePV().configureAlg() elif ( not ( self.getProp("Simulation") and self.getProp("DataType") in ["2008","2009","2010","MC09"] ) ): # Default setting uses beam spot constraint from DB, available from 2011. Prior to 2011 stability of beam spot is not certain from PatPV import PVConf PVConf.StandardPV().configureAlg() # MC with particle gun cannot reconstruct PV, hence need to introduce one by hand if "pGun" in self.getProp("SpecialData"): from Configurables import PGPrimaryVertex pgPV = PGPrimaryVertex() GaudiSequencer("RecoVertexSeq").Members += [ pgPV ] else: GaudiSequencer("RecoVertexSeq").Members += [ pvAlg ]; trackV0Finder = TrackV0Finder() GaudiSequencer("RecoVertexSeq").Members += [ trackV0Finder ] # for Run 2, we run a different algorithm and don't want to have # the V0 finder in the vertex sequence (which is now after HLT1) if "Vertex" in recoSeq and self.getProp("DataType") in self.Run2DataTypes: from Configurables import PatPV3D, PVOfflineTool, LSAdaptPV3DFitter pvAlg = PatPV3D("PatPV3D") ## this should go in a configuration file when we know what to use pvAlg.addTool(PVOfflineTool,"PVOfflineTool") pvAlg.PVOfflineTool.addTool(LSAdaptPV3DFitter, "LSAdaptPV3DFitter") pvAlg.PVOfflineTool.PVFitterName = "LSAdaptPV3DFitter" pvAlg.PVOfflineTool.LSAdaptPV3DFitter.UseFittedTracks = True pvAlg.PVOfflineTool.LSAdaptPV3DFitter.AddMultipleScattering = False pvAlg.PVOfflineTool.LSAdaptPV3DFitter.TrackErrorScaleFactor = 1.0 pvAlg.PVOfflineTool.LSAdaptPV3DFitter.MinTracks = 4 pvAlg.PVOfflineTool.LSAdaptPV3DFitter.trackMaxChi2 = 12.0 pvAlg.PVOfflineTool.UseBeamSpotRCut = True pvAlg.PVOfflineTool.BeamSpotRCut = 0.2 pvAlg.PVOfflineTool.BeamSpotRHighMultiplicityCut = 0.4 pvAlg.PVOfflineTool.BeamSpotRMultiplicityTreshold = 10 pvAlg.PVOfflineTool.InputTracks = [ "Rec/Track/FittedHLT1VeloTracks" ] pvAlg.OutputVerticesName = "Rec/Vertex/Primary" pvAlg.PrimaryVertexLocation = "Rec/Vertex/PrimaryVertices" # Remove all tracks that don't belong to a PV (to save space on a DST) from Configurables import TrackContainerCleaner, SelectTrackInVertex pvVeloTracksCleaner = TrackContainerCleaner("PVVeloTracksCleaner") pvVeloTracksCleaner.inputLocation = "Rec/Track/FittedHLT1VeloTracks" pvVeloTracksCleaner.selectorName = "SelectTrackInVertex" GaudiSequencer("RecoVertexSeq").Members += [ pvAlg, pvVeloTracksCleaner ]; GaudiSequencer("RecoVertexSeq").IgnoreFilterPassed = True ## Upgrade type? if self.getProp("DataType") == 'Upgrade' : specialDataList = self.getProp("SpecialData") specialDataList.append("upgrade") self.setProp("SpecialData",specialDataList) # Tracking (Should make it more fine grained ??) DoTracking = False for seq in self.DefaultTrackingSubdets : if seq in recoSeq: DoTracking = True if DoTracking: trackConf = TrackSys() self.setOtherProps(trackConf,["SpecialData","OutputType"]) trackConf.ExpertHistos = self.expertHistos() # RICH if "RICH" in recoSeq: # The main sequence seq = GaudiSequencer("RecoRICHSeq") # Create the top level Conf object richConf = RichRecSysConf(self.richRecConfName) # set some general options self.setOtherProps(richConf,["SpecialData","Context","OutputLevel", "Simulation","DataType","OnlineMode"]) # Set the sequencer the RICH reco algs should be added to richConf.RecoSequencer = seq # Input Tracks (would be better to not hard code this. Get from TrackSys() or DstConf()) # Only set if not previously set, to allow for custom studies using non standard locations # set at the top level options file level if not richConf.trackConfig().isPropertySet("InputTracksLocation") : richConf.trackConfig().setProp("InputTracksLocation","Rec/Track/Best") # Output PID Location. Again allow for pre-defined custom locations. if not richConf.isPropertySet("RichPIDLocation") : richConf.setProp("RichPIDLocation","Rec/Rich/PIDs") # Printout import GaudiKernel.ProcessJobOptions GaudiKernel.ProcessJobOptions.PrintOn() log.debug(richConf) GaudiKernel.ProcessJobOptions.PrintOff() # CALO if "CALO" in recoSeq: import GaudiKernel.ProcessJobOptions seq = GaudiSequencer ( 'RecoCALOSeq' ) caloConf=CaloProcessor( Context = self.getProp('Context') , OutputLevel = self.getProp('OutputLevel') , UseTracks = True , EnableOnDemand = False , DataType = self.getProp ('DataType') ) GaudiKernel.ProcessJobOptions.PrintOn() seq.Members = [caloConf.caloSequence()] GaudiKernel.ProcessJobOptions.PrintOff() # MUON if "MUON" in recoSeq: from MuonID import ConfiguredMuonIDs from Configurables import RawBankReadoutStatusConverter,RawBankReadoutStatusFilter cm=ConfiguredMuonIDs.ConfiguredMuonIDs(data=self.getProp("DataType"), specialData=self.getProp("SpecialData")) MuonIDSeq=cm.getMuonIDSeq() RawBankReadoutStatusConverter("MuonProcStatus").System="Muon" RawBankReadoutStatusConverter("MuonProcStatus").BankTypes=["Muon"] RawBankReadoutStatusFilter("MuonROFilter").BankType=13 RawBankReadoutStatusFilter("MuonROFilter").RejectionMask=2067 GaudiSequencer("RecoMUONSeq").Members += [ "MuonRec", "RawBankReadoutStatusConverter/MuonProcStatus", "RawBankReadoutStatusFilter/MuonROFilter", MuonIDSeq ] # PROTO if "PROTO" in recoSeq: self.setOtherProps(GlobalRecoConf(),["DataType","SpecialData", "Context","OutputLevel"]) GlobalRecoConf().RecoSequencer = GaudiSequencer("RecoPROTOSeq") # SUMMARY if "SUMMARY" in recoSeq: from Configurables import RecSummaryAlg summary = RecSummaryAlg("RecSummary") # make a new list of uppered detectors dets = [] for det in self.getProp("Detectors"): dets.append(det.upper()) summary.Detectors = dets GaudiSequencer("RecoSUMMARYSeq").Members += [summary]
RV.OutputVerticesName = "Rec/Vertices/RV" RV.OutputLevel = 3 RV.addTool(PVOfflineTool) RV.PVOfflineTool.InputTracks = ["Rec/Track/Best"] RV.PVOfflineTool.PVSeedingName = "PVSeed3DTool" RV.PVOfflineTool.addTool(PVSeed3DTool()) RV.PVOfflineTool.PVSeed3DTool.TrackPairMaxDistance = 0.2 * mm RV.PVOfflineTool.PVSeed3DTool.zMaxSpread = 1 * mm RV.PVOfflineTool.addTool(LSAdaptPV3DFitter()) RV.PVOfflineTool.LSAdaptPV3DFitter.maxIP2PV = 2 * mm RV.PVOfflineTool.LSAdaptPV3DFitter.MinTracks = 4 #Default PV reconstruction from Configurables import PatPVOffline myPVLocation = "/Event/Rec/Vertex/myPVOffline" myPVOffl = PatPVOffline("myPVOffl") myPVOffl.OutputVertices = myPVLocation #DVSeq.Members += [ myPVOffl ] ######################################################################## ######################################################################## # Preselection of candidates from Configurables import RecVertices2Particles RV2P = RecVertices2Particles("RV2P") DVSeq.Members += [RV2P] RV2P.RecVerticesLocation = ["Rec/Vertices/RV"] #RV2P.RecVerticesLocation = [myPVLocation] RV2P.OutputLevel = 3 #Selection Cuts
def configureAlg(self, PVAlg = PatPVOffline("PatPVOffline")): '''pass in an alg to configure''' PVAlg.addTool(PVOfflineTool, "PVOfflineTool") self.configureTool(PVAlg.PVOfflineTool)