def setMCTBFitter(self): from AthenaCommon.AppMgr import ToolSvc # this assumes that MCTBFitter has already been set from MuonRecExample import MuonRecTools #ToolSvc.MCTBFitter.OutputLevel = align.OutputLevel() #ToolSvc.MCTBSLFitter.OutputLevel = align.OutputLevel() MCTBFitter = MuonRecTools.getPublicToolClone( "myMCTBFitter", "MCTBFitterMaterialFromTrack") MCTBFitter.FillDerivativeMatrix = True MCTBFitter.OutputLevel = align.OutputLevel() #MCTBFitter.OutputLevel = VERBOSE #MCTBFitter.GetMaterialFromTrack = True #MCTBFitter.PrintDerivatives = True ToolSvc += MCTBFitter self._fitter = ToolSvc.myMCTBFitter if align.useSLFitter(): MCTBSLFitter = MuonRecTools.getPublicToolClone( "myMCTBSLFitter", "MCTBSLFitterMaterialFromTrack") MCTBSLFitter.FillDerivativeMatrix = True MCTBSLFitter.OutputLevel = align.OutputLevel() #MCTBSLFitter.OutputLevel = VERBOSE #MCTBSLFitter.GetMaterialFromTrack = True ##rdh MCTBSLFitter.Momentum = 0 #MCTBSLFitter.PrintDerivatives = True ToolSvc += MCTBSLFitter self._slfitter = ToolSvc.myMCTBSLFitter
def doMultiLevelAlignment(self): doMultiLevelAlignment = False if align.alignmentLevel() != 3: if align.iteration() > 0 or mualign.jobType() == 'misal': doMultiLevelAlignment = True mualign.doMultiLevelAlignment = doMultiLevelAlignment return doMultiLevelAlignment
def configure(self): mlog = logging.getLogger(self._name + '::configure :') # create tool instance from TrkAlignGenTools.AlignResidualCalculatorGetter import AlignResidualCalculatorGetter resCalc = AlignResidualCalculatorGetter( ).AlignResidualCalculatorHandle() from TrkAlignGenTools.TrkAlignGenToolsConf import Trk__AlignTrackCreator alignTrackCreator = Trk__AlignTrackCreator( "AlignTrackCreator", OutputLevel=align.OutputLevel(), ResidualCalculator=resCalc, IncludeScatterers=align.includeScatterers(), RemoveATSOSNotInAlignModule=align.removeATSOSNotInAlignModule(), RequireOverlap=align.requireOverlap()) # options for good event list if align.writeEventList(): from TrkAlignGenTools.AlignmentIOFiles import AlignmentIOFiles alignIO = AlignmentIOFiles() alignTrackCreator.EventList = "goodEvts.txt" alignTrackCreator.WriteEventList = True self._AlignTrackCreatorHandle = alignTrackCreator #mlog.info(" now adding to ToolSvc") #from __main__ import ToolSvc #ToolSvc += self.AlignTrackCreatorHandle() mlog.info(" leaving configure") return True
def __init__(self): # set defaults for muon alignment align.alignmentType = 'GlobalChi2' align.useSLFitter = True align.runOutlierRemoval = False if not align.fileRootName.is_locked(): self.setFileRootName() if not align.outputPath.is_locked(): align.outputPath = align.fileRootName() if not mualign.asztFilePath.is_locked(): mualign.asztFilePath = align.fileRootName() #self.muonIO = MuonAlignmentIOFiles() #self.muonIO.setInitialAsztFilePath(mualign.initialAsztFilePath()) #self.muonIO.setAsztFilePath(mualign.asztFilePath()) if align.alignmentLevel() == 1: self.setL1() elif align.alignmentLevel() == 23: self.setL23() elif align.alignmentLevel() == 3: self.setL3() else: print "only L1, L2 and L3 implemented" exit
def configure(self): mlog = logging.getLogger(self._name + '::configure :') from TrkAlignGenTools.AlignTrackCreatorGetter import AlignTrackCreatorGetter alignTrackCreator = AlignTrackCreatorGetter().AlignTrackCreatorHandle() from TrkAlignGenTools.AlignTrackDresserGetter import AlignTrackDresserGetter alignTrackDresser = AlignTrackDresserGetter().AlignTrackDresserHandle() from TrkAlignGenTools.AlignTrackDresserGetter import AlignTrackDresserGetter alignTrackDresser = AlignTrackDresserGetter().AlignTrackDresserHandle() from TrkAlignGenAlgs.TrkAlignGenAlgsConf import Trk__AlignAlg alignAlg = Trk__AlignAlg("AlignAlg", OutputLevel=align.OutputLevel(), AlignTrackCreator=alignTrackCreator, AlignTrackDresser=alignTrackDresser, AlignTool=self.getAlignTool(), WriteNtuple=align.writeNtuple(), FileName=align.ntupleFileName(), FilePath=align.ntupleFilePath(), SolveOnly=align.solveOnly()) self._alignAlgHandle = alignAlg # add to topSequence mlog.info(" now adding to topSequence") from AthenaCommon.AlgSequence import AlgSequence topSequence = AlgSequence() topSequence += self.AlignAlgHandle() mlog.info(" leaving configure") return True
def configure(self): mlog = logging.getLogger(self._name + '::configure :') from MuonAlignGenTools.MuonAlignRefitToolGetter import MuonAlignRefitToolGetter muonAlignRefitTool = MuonAlignRefitToolGetter( ).MuonAlignRefitToolHandle() # create tool instance from MuonAlignGenTools.MuonAlignGenToolsConf import Muon__MuonTrackCollectionProvider muonTrackCollectionProvider = Muon__MuonTrackCollectionProvider( "MuonTrackCollectionProvider", OutputLevel=align.OutputLevel(), InputMuonCol=mualign.MuonContainerName(), InputTrackCol=align.inputTrkCol(), InputIDTrackCol=mualign.inputIDTrackCol(), UseStandaloneTracks=mualign.useStandaloneTracks(), TrackType=mualign.inputTrackCollectionType(), MomentumCut=mualign.momentumCut(), MuonAlignRefitTool=muonAlignRefitTool) self._muonTrackCollectionProviderHandle = muonTrackCollectionProvider mlog.info(" now adding to ToolSvc") from __main__ import ToolSvc ToolSvc += self.MuonTrackCollectionProviderHandle() mlog.info(" leaving configure") return True
def configureReco(self): from AthenaCommon.DetFlags import DetFlags DetFlags.Muon_setOn() DetFlags.Calo_setOff() recAlgsFlags.doMuonIDStandAlone = False recAlgsFlags.doMuonIDCombined = False # add some more flags available for standalone running import MuonRecExample.MuonRecStandaloneFlags # configure flags so that only Muon Standalone reco is run import MuonRecExample.MuonRecStandaloneOnlySetup muonRecFlags.useAlignmentCorrections = mualign.useOpticalAlignment() # cosmics setup #if align.dataType()=='cosmic' or align.dataType()=='simCosmic': ##### no more flags after this line ##### print "align.dataType()=", align.dataType() if align.dataType() == 'data' or align.dataType() == 'cosmic': muonRecTopOptions = "MuonAlignGenTools/MuonDataRec_myTopOptions.py" else: muonRecTopOptions = "MuonRecExample/MuonRec_topOptions.py" try: include(muonRecTopOptions) ###### put any user finetuning before this line ##### except: # always write config so far for debugging from AthenaCommon.ConfigurationShelve import saveToAscii saveToAscii("config.txt") # but still exit with error raise
def configure(self): mlog = logging.getLogger(self._name + '::configure :') from TrkAlignGenTools.AlignmentTrackFitter import AlignmentTrackFitter #from MuonTrackFinderTools.MuonTrackFinderToolsConf import Muon__MuonRefitTool from MuonTrackFinderTools.MuonTrackFinderToolsConf import Muon__MuonRefitTool muonRefitTool = Muon__MuonRefitTool( "MuonRefitToolForAlignment", OutputLevel=align.OutputLevel(), Fitter=AlignmentTrackFitter().fitter()) from __main__ import ToolSvc ToolSvc += muonRefitTool # create tool instance from MuonAlignGenTools.MuonAlignGenToolsConf import Muon__MuonAlignRefitTool muonAlignRefitTool = Muon__MuonAlignRefitTool( OutputLevel=align.OutputLevel()) combmu = mualign.selectCombinedMuons() muonAlignRefitTool.MuonRefitTool = muonRefitTool muonAlignRefitTool.RemoveBIS8Hits = False muonAlignRefitTool.RemoveTGCHits = False muonAlignRefitTool.RemoveTGCEtaHits = True muonAlignRefitTool.RemoveRPCEtaHits = True muonAlignRefitTool.RemoveCSCPhiHits = True muonAlignRefitTool.DeclusterTGCHits = False muonAlignRefitTool.RemoveSmallBarrelHits = False muonAlignRefitTool.RemoveCSCHits = mualign.removeCSCHits() muonAlignRefitTool.RemoveBEEHits = not mualign.alignEE() muonAlignRefitTool.RemoveEEHits = not mualign.alignEE() muonAlignRefitTool.RemoveBarrelHits = not mualign.alignBarrel() muonAlignRefitTool.RemoveEndcapHits = not mualign.alignEndcap() muonAlignRefitTool.RemoveTRTHits = mualign.removeTRTHits() muonAlignRefitTool.RemoveScattering = not align.includeScatterers() muonAlignRefitTool.RecreateStartingParameters = not mualign.selectCombinedMuons( ) muonAlignRefitTool.ExtrapolateToMuonEntry = not mualign.selectCombinedMuons( ) self._MuonAlignRefitToolHandle = muonAlignRefitTool mlog.info(" now adding to ToolSvc") from __main__ import ToolSvc ToolSvc += self.MuonAlignRefitToolHandle() mlog.info(" leaving configure") return True
def alignModuleListType(self): if align.alignmentLevel() == 0: return 0 elif align.alignmentLevel() == 1: return 1 elif align.alignmentLevel() == 23: return 2 elif align.alignmentLevel() == 3: return 3 else: print "bad option" return -1
def configure(self): mlog = logging.getLogger(self._name + '::configure :') # create tool instance from TrkAlignGenTools.TrkAlignGenToolsConf import Trk__TrackCollectionProvider trackCollectionProvider = Trk__TrackCollectionProvider( "TrackCollectionProvider", OutputLevel=align.OutputLevel(), InputTrkCol=align.inputTrkCol()) self._trackCollectionProviderHandle = trackCollectionProvider mlog.info(" leaving configure") return True
def setCombMuonTrackFitter(self): mlog = logging.getLogger( 'AlignmentTrackFitter::setCombMuonTrackFitter') from AthenaCommon.Include import include include('MuonCombinedRecExample/CombinedMuonFitTools.py') from AthenaCommon.AppMgr import ToolSvc ToolSvc.MuonCombinedTrackFitter.FillDerivativeMatrix = True self._fitter = ToolSvc.MuonCombinedTrackFitter self._fitter.OutputLevel = align.OutputLevel() if align.useSLFitter(): mlog.warning("SL Fitter set to default (curved) fitter!") self._slfitter = ToolSvc.MuonCombinedTrackFitter
def configure ( self ) : mlog = logging.getLogger( self._name+'::configure :' ) # create tool instance from TrkAlignGenTools.AlignResidualCalculatorGetter import AlignResidualCalculatorGetter resCalc = AlignResidualCalculatorGetter().ResidualPullCalculatorHandle() from MuonAlignGenTools.MuonAlignGenToolsConf import Muon__MuonFillNtupleTool from MuonAlignGenTools.MuonAlignmentIOFiles import MuonAlignmentIOFiles muonIO = MuonAlignmentIOFiles() muonFillNtupleTool = Muon__MuonFillNtupleTool(OutputLevel = align.OutputLevel(), ResidualPullCalculator = resCalc, MuonContainer = mualign.MuonContainerName()) from MuonAlignGenTools.MuonAlignModuleToolGetter import MuonAlignModuleToolGetter muonAlignModuleTool = MuonAlignModuleToolGetter().MuonAlignModuleToolHandle() muonFillNtupleTool.AlignModuleTool = muonAlignModuleTool muonFillNtupleTool.BigNtuple = mualign.doBigNtuple() from MuTagTools.MuTagToolsConf import MuTagEDMHelper ConfiguredMuTagEDMHelper = MuTagEDMHelper("ConfiguredMuTagEDMHelper") from __main__ import ToolSvc ToolSvc += ConfiguredMuTagEDMHelper muonFillNtupleTool.muTagEDMHelperTool = ConfiguredMuTagEDMHelper self._MuonFillNtupleToolHandle = muonFillNtupleTool mlog.info(" leaving configure" ) return True
def configure ( self ) : mlog = logging.getLogger( self._name+'::configure :' ) muonIO = MuonAlignmentIOFiles() # create tool instance from __main__ import ToolSvc from MuonAlignGenTools.MuonAlignGenToolsConf import Muon__CscAlignDBTool muonAlignDBTool = Muon__CscAlignDBTool(OutputLevel = align.OutputLevel(), ABLineDbTool = ToolSvc.MGM_AlignmentDbTool, ASZTOutputFile = muonIO.asztOutputFile(), AlternateASZTFile = str(''), SigmaOutputFile = '', SigmaInputFile = '', UseMultiLevelDbTool = mualign.doMultiLevelAlignment()) if mualign.useAlternateASZT() : muonAlignDBTool.AlternateASZTFile = muonIO.asztInputFile() self._CscAlignDBToolHandle = muonAlignDBTool if mualign.doMultiLevelAlignment : MultiLevelAlignmentDbTool = ToolSvc.MultiLevelAlignmentDbTool else: from MuonCondTool.MuonCondToolConf import MultiLevelAlignmentDbTool MultiLevelAlignmentDbTool = MultiLevelAlignmentDbTool("MultiLevelAlignmentDbTool") MultiLevelAlignmentDbTool.ABLineDbTool = ToolSvc.MGM_AlignmentDbTool mlog.info(" leaving configure" ) return True
def __init__(self): mlog = logging.getLogger('MuonAlignmentIOFiles::__init__') if not MuonAlignmentIOFiles._rootFilePathIsSet: self.setRootFilePath(align.outputPath()) if not MuonAlignmentIOFiles._asztFilePathIsSet: self.setAsztFilePath(mualign.asztFilePath()) if not MuonAlignmentIOFiles._initialAsztFilePathIsSet: self.setInitialAsztFilePath(mualign.initialAsztFilePath())
def __init__(self): # set defaults for muon alignment align.alignmentType = 'GlobalChi2' align.useSLFitter = True align.runOutlierRemoval = False self.setFileRootName() self.muonIO = MuonAlignmentIOFiles() if align.alignmentLevel() == 1: self.setL1() elif align.alignmentLevel() == 3: self.setL3() else: print "only L1 and L3 implemented" exit
def configure(self): mlog = logging.getLogger(self._name + '::configure :') outputLevel = AlignmentFlags.OutputLevel() # create tool instance from AthenaCommon.AppMgr import ToolSvc from MuonResidualPullCalculators.MuonResidualPullCalculatorsConf import Muon__TGC_ResidualPullCalculator tgc_respullcalc = Muon__TGC_ResidualPullCalculator( "TGC_ResidualPullCalculator") #OutputLevel=outputLevel) ToolSvc += tgc_respullcalc from InDetTrackValidation.InDetTrackValidationConf import InDet__SCT_ResidualPullCalculator sct_respullcalc = InDet__SCT_ResidualPullCalculator() ToolSvc += sct_respullcalc #from TrkValTools.TrkValToolsConf import Trk__ResidualPullCalculator from TrkResidualPullCalculator.TrkResidualPullCalculatorConf import \ Trk__ResidualPullCalculator resPullCalc = Trk__ResidualPullCalculator( "ResidualPullCalculator", #OutputLevel=outputLevel, ResidualPullCalculatorForTGC=tgc_respullcalc, ResidualPullCalculatorForSCT=sct_respullcalc) ToolSvc += resPullCalc self._ResidualPullCalculatorHandle = ToolSvc.ResidualPullCalculator from TrkAlignGenTools.TrkAlignGenToolsConf import Trk__AlignResidualCalculator resCalc = Trk__AlignResidualCalculator( "AlignResidualCalculator", OutputLevel=outputLevel, ResidualType=0, ResidualPullCalculator=resPullCalc, IncludeScatterers=AlignmentFlags.includeScatteringResiduals()) self._AlignResidualCalculatorHandle = resCalc mlog.info(" now adding to ToolSvc") ToolSvc += self.AlignResidualCalculatorHandle() mlog.info(" leaving configure") return True
def getAlignTool(self): if align.alignmentType() == 'GlobalChi2': from TrkGlobalChi2AlignTools.GlobalChi2AlignToolGetter import GlobalChi2AlignToolGetter return GlobalChi2AlignToolGetter().GlobalChi2AlignToolHandle() else: print "only global chi2 supported for now!" return
def derivativeCalcTool(self): try: self._derivCalcTool except: derivativeType = AlignmentFlags.derivativeType() if derivativeType == 'Analytical': from TrkAlignGenTools.TrkAlignGenToolsConf import Trk__AnalyticalDerivCalcTool self._derivCalcTool = Trk__AnalyticalDerivCalcTool( "AnalyticalDerivCalcTool", OutputLevel=AlignmentFlags.OutputLevel()) elif derivativeType == 'Numerical': from TrkAlignGenTools.ShiftingDerivCalcToolGetter import ShiftingDerivCalcToolGetter self._derivCalcTool = ShiftingDerivCalcToolGetter( ).ShiftingDerivCalcToolHandle() else: print "bad option!" print "have derivCalcTool" return self._derivCalcTool
def inputLevel1File(self): if not MuonAlignmentIOFiles._inputLevel1File: if align.iteration() > 0: MuonAlignmentIOFiles._inputLevel1File = MuonAlignmentIOFiles._IOFiles.inputLevel1File( align.fileRootName(), align.iteration(), align.jobIndex()) elif align.dataType() == 'MC' or align.dataType() == 'simCosmic': MuonAlignmentIOFiles._inputLevel1File = MuonAlignmentIOFiles._IOFiles.inputLevel1File( align.fileRootName(), align.iteration()) else: MuonAlignmentIOFiles._inputLevel1File = "" print "level1AsciiFile: ", MuonAlignmentIOFiles._inputLevel1File return MuonAlignmentIOFiles._inputLevel1File
def setGlobalChi2Fitter(self): mlog = logging.getLogger('AlignmentTrackFitter::setGlobalChi2Fitter') from AthenaCommon.AppMgr import ToolSvc from TrkGlobalChi2Fitter.TrkGlobalChi2FitterConf import Trk__GlobalChi2Fitter Fitter = Trk__GlobalChi2Fitter() ToolSvc += Fitter self._fitter = Fitter if align.useSLFitter(): mlog.warning("SL Fitter set to default (curved) fitter!") self._slfitter = Fitter
def setAlignmentDbTool(self, useAlternateAscii): from AtlasGeoModel.MuonGM import GeoModelSvc MuonDetectorTool = GeoModelSvc.DetectorTools["MuonDetectorTool"] MuonDetectorTool.OutputLevel = align.OutputLevel() altASZTFile = "" if mualign.doMultiLevelAlignment(): MuonDetectorTool.UseAsciiConditionData = 1 MuonDetectorTool.UseConditionDb = 1 else: print "doMultiLevelAlignment=False" from MuonAlignGenTools.MuonAlignmentIOFiles import MuonAlignmentIOFiles if useAlternateAscii: altASZTFile = self.muonIO.asztInputFile() MuonDetectorTool.AlternateASZTFile = altASZTFile print MuonDetectorTool from MuonCondTool.MuonCondToolConf import MuonAlignmentDbTool MuonAlignmentDbTool = MuonAlignmentDbTool("MGM_AlignmentDbTool") MuonAlignmentDbTool.ParlineFolders = [ "/MUONALIGN/MDT/BARREL", "/MUONALIGN/MDT/ENDCAP/SIDEA", "/MUONALIGN/MDT/ENDCAP/SIDEC", "/MUONALIGN/TGC/SIDEA", "/MUONALIGN/TGC/SIDEC" ] MuonAlignmentDbTool.OutputLevel = align.OutputLevel() from __main__ import ToolSvc ToolSvc += MuonAlignmentDbTool if mualign.doMultiLevelAlignment(): from MuonCondTool.MuonCondToolConf import MultiLevelAlignmentDbTool MultiLevelAlignmentDbTool = MultiLevelAlignmentDbTool( "MultiLevelAlignmentDbTool") MultiLevelAlignmentDbTool.ABLineDbTool = ToolSvc.MGM_AlignmentDbTool MultiLevelAlignmentDbTool.L1AsciiFile = self.muonIO.inputLevel1File( ) MultiLevelAlignmentDbTool.OutputLevel = align.OutputLevel() ToolSvc += MultiLevelAlignmentDbTool MuonDetectorTool.TheMuonAlignmentTool = MultiLevelAlignmentDbTool else: MuonDetectorTool.TheMuonAlignmentTool = MuonAlignmentDbTool
def configure ( self ) : mlog = logging.getLogger( self._name+'::configure :' ) # create tool instance from MuonAlignGenTools.MuonAlignGenToolsConf import Muon__MuonGeometryManagerTool, Muon__MdtGeometryManagerTool, Muon__CscGeometryManagerTool, Muon__TgcGeometryManagerTool # MDT mdtGeometryManagerTool = Muon__MdtGeometryManagerTool(OutputLevel = align.OutputLevel(), AlignLevel = align.alignmentLevel(), AlignTraX=mualign.mdtAlignTraX(), AlignTraY=mualign.mdtAlignTraY(), AlignTraZ=mualign.mdtAlignTraZ(), AlignRotX=mualign.mdtAlignRotX(), AlignRotY=mualign.mdtAlignRotY(), AlignRotZ=mualign.mdtAlignRotZ()) self._MdtGeometryManagerToolHandle = mdtGeometryManagerTool # CSC cscGeometryManagerTool = Muon__CscGeometryManagerTool(OutputLevel = align.OutputLevel(), AlignLevel = align.alignmentLevel()) self._CscGeometryManagerToolHandle = cscGeometryManagerTool # TGC tgcGeometryManagerTool = Muon__TgcGeometryManagerTool(OutputLevel = align.OutputLevel(), AlignLevel = align.alignmentLevel()) self._TgcGeometryManagerToolHandle = tgcGeometryManagerTool mlog.info(" now adding geometryManagerTools to ToolSvc" ) from __main__ import ToolSvc ToolSvc += self.MdtGeometryManagerToolHandle() ToolSvc += self.CscGeometryManagerToolHandle() ToolSvc += self.TgcGeometryManagerToolHandle() muonGeometryManagerTool = Muon__MuonGeometryManagerTool(OutputLevel = align.OutputLevel(), AlignLevel = align.alignmentLevel(), MdtGeometryManager = mdtGeometryManagerTool, CscGeometryManager = cscGeometryManagerTool, TgcGeometryManager = tgcGeometryManagerTool, doModuleSelection = mualign.doModuleSelection(), AlignMdt = mualign.alignMDT(), AlignTgc = False, #mualign.alignTGC(), AlignCsc = False, #mualign.alignCSC(), ModuleSelection = mualign.modulesToAlign()) self._MuonGeometryManagerToolHandle = muonGeometryManagerTool mlog.info(" now adding MuonGeometryManagerTool to ToolSvc" ) ToolSvc += self.MuonGeometryManagerToolHandle() mlog.info(" leaving configure" ) return True
def configure(self): mlog = logging.getLogger(self._name + '::configure :') from TrkAlignGenAlgs.TrkAlignGenAlgsConf import Trk__SelectEventNumber selEvtNumber = Trk__SelectEventNumber("SelectEventNumber", OutputLevel=align.OutputLevel(), EventList=align.eventList()) self._selectEventNumberHandle = selEvtNumber mlog.info("created selectEventNumber:") mlog.info(selEvtNumber) # add to sequencer mlog.info(" now adding to sequencer") from AthenaCommon.AppMgr import athFilterSeq sequencer = athFilterSeq sequencer += self.SelectEventNumberHandle() mlog.info(" leaving configure") return True
def asztInputFile(self): if not MuonAlignmentIOFiles._asztInputFile: if align.iteration()>0 or \ align.dataType()=='MC' or align.dataType()=='simCosmic' : MuonAlignmentIOFiles._asztInputFile = MuonAlignmentIOFiles._IOFiles.asztInputFile( align.fileRootName(), align.iteration(), align.jobIndex()) else: print "setting asztInputFile to ''" MuonAlignmentIOFiles._asztInputFile = "" print "asztInputFile: ", MuonAlignmentIOFiles._asztInputFile return MuonAlignmentIOFiles._asztInputFile
def configure(self): mlog = logging.getLogger(self._name + '::configure :') # create tool instance from MuonAlignGenTools.MuonAlignGenToolsConf import Muon__MdtGeometryManagerTool mdtGeometryManagerTool = Muon__MdtGeometryManagerTool( OutputLevel=align.OutputLevel(), MdtAlignParameters=mualign.mdtAlignParams()) self._MdtGeometryManagerToolHandle = mdtGeometryManagerTool mlog.info(" now adding to ToolSvc") from __main__ import ToolSvc ToolSvc += self.MdtGeometryManagerToolHandle() mlog.info(" leaving configure") return True
def configure(self): mlog = logging.getLogger(self._name + '::configure :') # create tool instance from MuonAlignGenTools.MuonAlignGenToolsConf import Muon__MuonAlignModuleTool muonAlignModuleTool = Muon__MuonAlignModuleTool( OutputLevel=align.OutputLevel(), AlignModuleListType=mualign.alignModuleListType()) self._MuonAlignModuleToolHandle = muonAlignModuleTool mlog.info(" now adding to ToolSvc") from __main__ import ToolSvc ToolSvc += self.MuonAlignModuleToolHandle() mlog.info(" leaving configure") return True
def configure(self): mlog = logging.getLogger(self._name + '::configure :') from TrkAlignGenAlgs.TrkAlignGenAlgsConf import Trk__AlignSolve alignAlg = Trk__AlignSolve("AlignSolve", OutputLevel=align.OutputLevel(), AlignTool=self.getAlignTool()) self._alignAlgHandle = alignAlg # add to topSequence mlog.info(" now adding to topSequence") from AthenaCommon.AlgSequence import AlgSequence topSequence = AlgSequence() topSequence += self.AlignSolveHandle() mlog.info(" leaving configure") return True
def configure(self): mlog = logging.getLogger(self._name + '::configure :') # create tool instance from TrkAlignGenTools.TrkAlignGenToolsConf import Trk__AlignTrackDresser alignTrackDresser = Trk__AlignTrackDresser( "AlignTrackDresser", OutputLevel=AlignmentFlags.OutputLevel(), DerivCalcTool=self.derivativeCalcTool()) self._AlignTrackDresserHandle = alignTrackDresser #mlog.info(" now adding to ToolSvc") #from __main__ import ToolSvc #ToolSvc += self.AlignTrackDresserHandle() mlog.info(" leaving configure") return True
def __init__(self): mlog = logging.getLogger('AlignmentTrackFitter::__init__') self._nInitialized += 1 if self._nInitialized == 1: mlog.debug(" : First instance->configure()") else: mlog.debug("already initialized") return fitterType = align.fitterType() if fitterType == 'iPat': self.set_iPatFitter() elif fitterType == 'GlobalChi2': self.setGlobalChi2Fitter() elif fitterType == 'MCTB': self.setMCTBFitter() elif fitterType == 'CombMuonTrackFitter': self.setCombMuonTrackFitter() else: mlog.warning("no fitter!") return
def configure(self): mlog = logging.getLogger(self._name + '::configure :') # create tool instance from TrkAlignGenTools.AlignResidualCalculatorGetter import AlignResidualCalculatorGetter resCalc = AlignResidualCalculatorGetter( ).AlignResidualCalculatorHandle() from TrkAlignGenTools.AlignmentTrackFitter import AlignmentTrackFitter from TrkAlignGenTools.TrkAlignGenToolsConf import Trk__ShiftingDerivCalcTool shiftingDerivCalcTool = Trk__ShiftingDerivCalcTool( "ShiftingDerivCalcTool", OutputLevel=AlignmentFlags.OutputLevel(), TrackFitterTool=AlignmentTrackFitter().fitter(), ResidualCalculator=resCalc, TranslationSize=mualign.shiftSizeTranslations(), RotationSize=mualign.shiftSizeRotations(), NumberOfShifts=mualign.numberOfShifts(), doChi2VChamberShiftsMeasType=mualign.doChi2VChamberShiftsMeasType( )) if AlignmentFlags.useSLFitter(): shiftingDerivCalcTool.SLTrackFitterTool = AlignmentTrackFitter( ).slfitter() # configure other jobOptions shiftingDerivCalcTool.RunOutlierRemoval = AlignmentFlags.runOutlierRemoval( ) shiftingDerivCalcTool.ParticleNumber = AlignmentFlags.particleNumber() shiftingDerivCalcTool.TrackAlignParamCut = AlignmentFlags.trackAlignParamCut( ) shiftingDerivCalcTool.SetMinIterations = AlignmentFlags.setMinIterations( ) self._ShiftingDerivCalcToolHandle = shiftingDerivCalcTool mlog.info(" now adding to ToolSvc") from __main__ import ToolSvc ToolSvc += self.ShiftingDerivCalcToolHandle() mlog.info(" leaving configure") return True