Skip to content
Snippets Groups Projects
Commit b5e2698a authored by Biagio Di Micco's avatar Biagio Di Micco Committed by Graeme Stewart
Browse files

fixing a bug (MuonCombinedRecRTT-00-01-05)

parent 86f0c9b4
No related merge requests found
Hide whitespace changes
Inline Side-by-side
Showing
with 7771 additions and 0 deletions
Reconstruction/MuonIdentification/MuonCombinedValidation/MuonCombinedRecRTT/Changelog 0 → 100644
+ 8
− 0
View file @ b5e2698a
2012-04-16 Edward.Moyse@gmail.com
* Added 3rd chain
* Tagged as MuonCombinedRecRTT-00-01-00
2011-12-09 Mark Hodgkinson
Add validation of RTT XML file
Add Changelog
Tag as MuonCombinedRecRTT-00-00-14-03
Reconstruction/MuonIdentification/MuonCombinedValidation/MuonCombinedRecRTT/ExtraFiles/ALL_MuonCombinedRecRTT_Plots.html 0 → 100644
+ 144
− 0
View file @ b5e2698a
<html><head>
<Title>MuonCombinedRecRTT Plots</Title></head>
<body>
<a name="top"><h1>MuonCombinedRecRTT Plots</h1></a>
<br />
<h2>Contents</h2>
<ul>
<li><a href="#links">Links</a></li>
<li><a href="#pt">Pt distributions</a></li>
<li><a href="#eta">Eta distributions</a></li>
<li><a href="#phi">Phi distributions</a></li>
<li><a href="#chi2">Chi2 fit distributions</a></li>
<li><a href="#combined">Combined muons plots</a></li>
</ul>
<a name="links"><h2>Links for this job</h2></a>
<a href="#top">(top)</a><p>
<ul>
<li>RTT default page</li>
<li>Log files</li>
</ul>
<a name="pt"><h2>pT distributions</h2></a>
<a href="#top">(top)</a><p>
<TABLE BORDER=0 CELLSPACING=0 CELLPADDING=0>
<TR>
<TD><a href="mu_pt_Muid_Tight.gif"><img src="mu_pt_Muid_Tight.gif" width=350></a></TD>
<TD><a href="mu_pt_Muid_CB.gif"><img src="mu_pt_Muid_CB.gif" width=350></a></TD>
<TD><a href="mu_pt_MuTagIMO.gif"><img src="mu_pt_MuTagIMO.gif" width=350></a></TD>
</TR>
<TR>
<TD><a href="mu_pt_MuidSA.gif"><img src="mu_pt_MuidSA.gif" width=350></a></TD>
<TD><a href="mu_pt_MuGirl.gif"><img src="mu_pt_MuGirl.gif" width=350></a></TD>
<TD><a href="mu_pt_Staco_CB.gif"><img src="mu_pt_Staco_CB.gif" width=350></a></TD>
</TR>
<TR>
<TD><a href="mu_pt_MuTag.gif"><img src="mu_pt_MuTag.gif" width=350></a></TD>
<TD><a href="mu_pt_MuonBoy.gif"><img src="mu_pt_MuonBoy.gif" width=350></a></TD>
<TD><a href="mu_pt_CaloMuon.gif"><img src="mu_pt_CaloMuon.gif" width=350></a></TD>
</TR>
</TABLE>
<a name="eta"><h2>Eta distributions pT > 20 GeV</h2></a>
<a href="#top">(top)</a><p>
<TABLE BORDER=0 CELLSPACING=0 CELLPADDING=0>
<TR>
<TD><a href="mu_eta_pt20_Muid_Tight.gif"><img src="mu_eta_pt20_Muid_Tight.gif" width=350></a></TD>
<TD><a href="mu_eta_pt20_Muid_CB.gif"><img src="mu_eta_pt20_Muid_CB.gif" width=350></a></TD>
<TD><a href="mu_eta_pt20_MuTagIMO.gif"><img src="mu_eta_pt20_MuTagIMO.gif" width=350></a></TD>
</TR>
<TR>
<TD><a href="mu_eta_pt20_MuidSA.gif"><img src="mu_eta_pt20_MuidSA.gif" width=350></a></TD>
<TD><a href="mu_eta_pt20_MuGirl.gif"><img src="mu_eta_pt20_MuGirl.gif" width=350></a></TD>
<TD><a href="mu_eta_pt20_Staco_CB.gif"><img src="mu_eta_pt20_Staco_CB.gif" width=350></a></TD>
</TR>
<TR>
<TD><a href="mu_eta_pt20_MuTag.gif"><img src="mu_eta_pt20_MuTag.gif" width=350></a></TD>
<TD><a href="mu_eta_pt20_MuonBoy.gif"><img src="mu_eta_pt20_MuonBoy.gif" width=350></a></TD>
<TD><a href="mu_eta_pt20_CaloMuon.gif"><img src="mu_eta_pt20_CaloMuon.gif" width=350></a></TD>
</TR>
</TABLE>
<a name="phi"><h2>Phi distributions pT > 20 GeV</h2></a>
<a href="#top">(top)</a><p>
<TABLE BORDER=0 CELLSPACING=0 CELLPADDING=0>
<TR>
<TD><a href="mu_phi_pt20_Muid_Tight.gif"><img src="mu_phi_pt20_Muid_Tight.gif" width=350></a></TD>
<TD><a href="mu_phi_pt20_Muid_CB.gif"><img src="mu_phi_pt20_Muid_CB.gif" width=350></a></TD>
<TD><a href="mu_phi_pt20_MuTagIMO.gif"><img src="mu_phi_pt20_MuTagIMO.gif" width=350></a></TD>
</TR>
<TR>
<TD><a href="mu_phi_pt20_MuidSA.gif"><img src="mu_phi_pt20_MuidSA.gif" width=350></a></TD>
<TD><a href="mu_phi_pt20_MuGirl.gif"><img src="mu_phi_pt20_MuGirl.gif" width=350></a></TD>
<TD><a href="mu_phi_pt20_Staco_CB.gif"><img src="mu_phi_pt20_Staco_CB.gif" width=350></a></TD>
</TR>
<TR>
<TD><a href="mu_phi_pt20_MuTag.gif"><img src="mu_phi_pt20_MuTag.gif" width=350></a></TD>
<TD><a href="mu_phi_pt20_MuonBoy.gif"><img src="mu_phi_pt20_MuonBoy.gif" width=350></a></TD>
<TD><a href="mu_phi_pt20_CaloMuon.gif"><img src="mu_phi_pt20_CaloMuon.gif" width=350></a></TD>
</TR>
</TABLE>
<a name="chi2"><h2>chi2_fit/ndf distributions</h2></a>
<a href="#top">(top)</a><p>
<TABLE BORDER=0 CELLSPACING=0 CELLPADDING=0>
<TR>
<TD><a href="chi2_Muid_Tight.gif"><img src="chi2_Muid_Tight.gif" width=350></a></TD>
<TD><a href="chi2_Muid_CB.gif"><img src="chi2_Muid_CB.gif" width=350></a></TD>
<TD><a href="chi2_MuTagIMO.gif"><img src="chi2_MuTagIMO.gif" width=350></a></TD>
</TR>
<TR>
<TD><a href="chi2_MuidSA.gif"><img src="chi2_MuidSA.gif" width=350></a></TD>
<TD><a href="chi2_MuGirl.gif"><img src="chi2_MuGirl.gif" width=350></a></TD>
<TD><a href="chi2_Staco_CB.gif"><img src="chi2_Staco_CB.gif" width=350></a></TD>
</TR>
<TR>
<TD><a href="chi2_MuTag.gif"><img src="chi2_MuTag.gif" width=350></a></TD>
<TD><a href="chi2_MuonBoy.gif"><img src="chi2_MuonBoy.gif" width=350></a></TD>
<TD><a href="chi2_CaloMuon.gif"><img src="chi2_CaloMuon.gif" width=350></a></TD>
</TR>
</TABLE>
<a name="combined"><h2>Combined muons plot</h2></a>
<a href="#top">(top)</a><p>
<h3>Chi2 Match</h3>
<TABLE BORDER=0 CELLSPACING=0 CELLPADDING=0>
<TR>
<TD><a href="Chi2Match_Muid_CB.gif"><img src="Chi2Match_Muid_CB.gif" width=350></a></TD>
<TD><a href="Chi2Match_Staco_CB.gif"><img src="Chi2Match_Staco_CB.gif" width=350></a></TD>
</TR>
</TABLE>
<h3>Delta ID - MS</h3>
<TABLE BORDER=0 CELLSPACING=0 CELLPADDING=0>
<TR>
<TD><a href="DeltaPtovPt_pt20_Muid_CB.gif"><img src="DeltaPtovPt_pt20_Muid_CB.gif" width=350></a></TD>
<TD><a href="DeltaEta_pt20_Muid_CB.gif"><img src="DeltaEta_pt20_Muid_CB.gif" width=350></a></TD>
<TD><a href="DeltaPhi_pt20_Muid_CB.gif"><img src="DeltaPhi_pt20_Muid_CB.gif" width=350></a></TD>
</TR>
<TR>
<TD><a href="DeltaPtovPt_pt20_Staco_CB.gif"><img src="DeltaPtovPt_pt20_Staco_CB.gif" width=350></a></TD>
<TD><a href="DeltaEta_pt20_Staco_CB.gif"><img src="DeltaEta_pt20_Staco_CB.gif" width=350></a></TD>
<TD><a href="DeltaPhi_pt20_Staco_CB.gif"><img src="DeltaPhi_pt20_Staco_CB.gif" width=350></a></TD>
</TR>
</TABLE>
</body></html>
Reconstruction/MuonIdentification/MuonCombinedValidation/MuonCombinedRecRTT/cmt/requirements 0 → 100644
+ 23
− 0
View file @ b5e2698a
package MuonCombinedRecRTT
author Biagio Di Micco <Biagio.Di.Micco@cern.ch>
use AtlasPolicy AtlasPolicy-01-*
use AtlasROOT AtlasROOT-02-* External
apply_pattern declare_joboptions files="*.py"
apply_pattern declare_runtime extras="../test/MuonCombinedRecRTT_TestConfiguration.xml \
../share/*.C ../share/*.h ../share/*.py \
../scripts/*.py ../ExtraFiles/*.html "
apply_pattern declare_python_modules files="*.py"
macro MuonCombinedRecRTT_TestConfiguration "../test/MuonCombinedRecRTT_TestConfiguration.xml"
private
#add validation of RTT xml file
use TestPolicy TestPolicy-*
apply_pattern validate_xml
end_private
\ No newline at end of file
Reconstruction/MuonIdentification/MuonCombinedValidation/MuonCombinedRecRTT/share/MCPD3PDMaker.py 0 → 100644
+ 416
− 0
View file @ b5e2698a
# $Id: MCPD3PDMaker.py 497319 2012-04-23 20:11:54Z dimicco $
#
# @file PhysicsAnalysis/D3PDMaker/PhysicsD3PDMaker/python/SMWZphysicsD3PD.py
# @author maarten boonekamp <maarten.boonekamp@cea.fr>
# @date Sep, 2009
# @brief Construct a Standard Model WZ physics D3PD.
#
import D3PDMakerCoreComps
from D3PDMakerConfig.D3PDMakerFlags import D3PDMakerFlags
from OutputStreamAthenaPool.MultipleStreamManager import MSMgr
# event
from EventCommonD3PDMaker.EventInfoD3PDObject import EventInfoD3PDObject
from EventCommonD3PDMaker.LBMetadataConfig import LBMetadataConfig
from TruthD3PDMaker.GenEventD3PDObject import GenEventD3PDObject
# eletron/photon
from egammaD3PDMaker.ElectronD3PDObject import ElectronD3PDObject
from egammaD3PDMaker.PhotonD3PDObject import PhotonD3PDObject
from egammaD3PDMaker.egammaTriggerBitsD3PDObject import egammaTriggerBitsD3PDObject
# muons
from MuonD3PDMaker.MuonD3PDObject import MuonD3PDObject
from MuonD3PDMaker.MuonSegmentD3PDObject import MuonSegmentD3PDObject
from MuonD3PDMaker.MuonTriggerBitsD3PDObject import MuonTriggerBitsD3PDObject
# jet
from JetD3PDMaker.JetD3PDObject import JetD3PDObject
# tau
from TauD3PDMaker.TauD3PDObject import TauD3PDObject
from TauD3PDMaker.makeTrackFilterAlg import makeTrackFilterAlg
# calo
from CaloD3PDMaker.MBTSD3PDObject import MBTSD3PDObject
from CaloD3PDMaker.MBTSTimeD3PDObject import MBTSTimeD3PDObject
from CaloD3PDMaker.MBTSTriggerBitsD3PDObject import MBTSTriggerBitsD3PDObject
from CaloD3PDMaker.LArCollisionTimeD3PDObject import LArCollisionTimeD3PDObject
from CaloD3PDMaker.CollisionDecisionD3PDObject import CollisionDecisionD3PDObject
from CaloD3PDMaker.ClusterD3PDObject import ClusterD3PDObject
from CaloD3PDMaker.EMClusterD3PDObject import EMClusterD3PDObject
from CaloD3PDMaker.makeClusterFilter import makeClusterFilter
# baseline track config
from TrackD3PDMaker.TrackD3PDMakerFlags import TrackD3PDFlags
TrackD3PDFlags.doTruth = False
TrackD3PDFlags.storeDetailedTruth = False
TrackD3PDFlags.storeDiagonalCovarianceAsErrors = True
TrackD3PDFlags.storeHitTruthMatching = False
TrackD3PDFlags.storePixelHitsOnTrack = False
TrackD3PDFlags.storePixelHolesOnTrack = False
TrackD3PDFlags.storePixelOutliersOnTrack = False
TrackD3PDFlags.storeSCTHitsOnTrack = False
TrackD3PDFlags.storeSCTHolesOnTrack = False
TrackD3PDFlags.storeSCTOutliersOnTrack = False
TrackD3PDFlags.storeTRTHitsOnTrack = False
TrackD3PDFlags.storeTRTHolesOnTrack = False
TrackD3PDFlags.storeTRTOutliersOnTrack = False
TrackD3PDFlags.storeTrackFitQuality = True
TrackD3PDFlags.storeTrackInfo = False
TrackD3PDFlags.storeTrackMomentum = True
TrackD3PDFlags.storeTrackPredictionAtBLayer = False
TrackD3PDFlags.storeTrackSummary = False
TrackD3PDFlags.trackParametersAtBeamSpotLevelOfDetails = 0
TrackD3PDFlags.trackParametersAtGlobalPerigeeLevelOfDetails = 0
TrackD3PDFlags.trackParametersAtPrimaryVertexLevelOfDetails = 1
from TrackD3PDMaker.TrackD3PDObject import TrackParticleD3PDObject
# PV config
TrackD3PDFlags.storeVertexFitQuality = True
TrackD3PDFlags.storeVertexKinematics = True
TrackD3PDFlags.storeVertexPurity = False
TrackD3PDFlags.storeVertexTrackAssociation = False
TrackD3PDFlags.storeVertexTrackIndexAssociation = True
TrackD3PDFlags.vertexPositionLevelOfDetails = 2
from TrackD3PDMaker.VertexD3PDObject import PrimaryVertexD3PDObject
# BeamSpot / MinBias
from TrackD3PDMaker.BeamSpotD3PDObject import BeamSpotD3PDObject
# MET
from MissingETD3PDMaker.MissingETD3PDMakerFlags import MissingETD3PDMakerFlags
from MissingETD3PDMaker.MissingETD3PDObject import *
from MissingETD3PDMaker.MissingETD3PDTriggerBitsObject import *
# Trigger
from TriggerD3PDMaker.TrigDecisionD3PDObject import TrigDecisionD3PDObject
from TriggerD3PDMaker.TrigConfMetadata import addTrigConfMetadata
from TriggerD3PDMaker.BGCodeD3PDObject import BGCodeD3PDObject
from TrigEgammaD3PDMaker.TrigEgammaD3PD import TrigEgammaD3PDObjects
# from TrigMuonD3PDMaker.TrigMuonD3PD import TrigMuonD3PDObjects
from TriggerD3PDMaker.EnergySumROID3PDObject import EnergySumROID3PDObject
from TrigMissingETD3PDMaker.TrigMETD3PDObject import TrigMETD3PDObject
from RecExConfig.RecFlags import rec
from AthenaCommon.AlgSequence import AlgSequence
topSequence = AlgSequence()
def _args (level, name, kwin, **kw):
kw = kw.copy()
kw['level'] = level
for (k, v) in kwin.items():
if k.startswith (name + '_'):
kw[k[len(name)+1:]] = v
return kw
def MCPphysicsD3PD (file,
tuplename = 'physics',
seq = topSequence,
D3PDSvc = 'D3PD::RootD3PDSvc',
streamNameRoot = None,
**kw):
# define track and cluster filters
filter1 = makeTrackFilterAlg(TracksName = D3PDMakerFlags.TrackSGKey(),
OutputTracksName='GoodTracks',
ptCut=0.,nSCTPix=4)
filter2 = makeTrackFilterAlg(TracksName = D3PDMakerFlags.TrackSGKey(),
OutputTracksName='HighPtTracks',
ptCut=5000.,nSCTPix=4)
filter3 = makeClusterFilter(InputName = D3PDMakerFlags.ClusterSGKey(),
OutputName = 'HighPtClusters',
ptCut=10000.)
# FIXME (Maarten) : I need to give the container name explicitly apparently
filter4 = makeClusterFilter(InputName = 'EMTopoCluster430',
OutputName = 'HighPtEMClusters',
ptCut=10000.)
preseq = AlgSequence (D3PDMakerFlags.PreD3PDAlgSeqName())
preseq += filter1
preseq += filter2
preseq += filter3
preseq += filter4
# now configure the D3PD
alg = MSMgr.NewRootStream(StreamName = streamNameRoot, FileName = file, TreeName = tuplename)
alg += EventInfoD3PDObject (**_args (10, 'EventInfo', kw))
alg += LArCollisionTimeD3PDObject (**_args (10, 'LArCollisionTime', kw))
# Eta rings of energy
# FIXME brian crashing aod running
if not rec.readAOD:
from CaloD3PDMaker.RapgapD3PDObject import EtaRingsNonTileD3PDObject
from CaloD3PDMaker.RapgapD3PDObject import EtaRingsD3PDObject
alg += EtaRingsNonTileD3PDObject ( **_args ( 0, 'EtaRings', kw) )
alg += EtaRingsD3PDObject ( **_args ( 0, 'EtaRings', kw) )
# Electron/Photon blocks
# alg += ElectronD3PDObject (**_args (10, 'Electron', kw,
# exclude = ['EMTrackFitDetails','EgammaJetSignedIPAndPTRelKin']))
alg += PhotonD3PDObject (**_args (10, 'Photon', kw))
# Muon blocks
alg += MuonD3PDObject (**_args (10, 'Muons', kw,
sgkey='Muons', prefix='mu_',
include = ["EFCBInfoIndex", "EFMGInfoIndex", "EFMEInfoIndex",
"L2CBInfoIndex", "L1InfoIndex"],
exclude = ["EFCBInfo", "EFMGInfo", "EFMEInfo", "L2CBInfo", "L1Info"],
allowMissing = True
))
alg += MuonD3PDObject (**_args (10, 'MuidMuon', kw,
sgkey='MuidMuonCollection', prefix='mu_muid_',
include = ["EFCBInfoIndex", "EFMGInfoIndex", "EFMEInfoIndex",
"L2CBInfoIndex", "L1InfoIndex"],
exclude = ["EFCBInfo", "EFMGInfo", "EFMEInfo", "L2CBInfo", "L1Info"],
allowMissing = True
))
alg += MuonD3PDObject (**_args (10, 'StacoMuon', kw,
sgkey='StacoMuonCollection', prefix='mu_staco_',
include = ["EFCBInfoIndex", "EFMGInfoIndex", "EFMEInfoIndex",
"L2CBInfoIndex", "L1InfoIndex"],
exclude = ["EFCBInfo", "EFMGInfo", "EFMEInfo", "L2CBInfo", "L1Info"],
allowMissing = True
))
alg += MuonD3PDObject (**_args (0, 'CaloMuon', kw,
sgkey='CaloMuonCollection', prefix='mu_calo_'))
# Tau block
# alg += TauD3PDObject (**_args ( 1, 'Tau', kw))
# Jet blocks
alg += JetD3PDObject (**_args ( 3, 'AK4TopoEMJet', kw,
sgkey='AntiKt4TopoEMJets', prefix='jet_akt4topoem_',
include = ['BTag','TrueFlavorComponents','BTagComponents'],
allowMissing = True))
alg += JetD3PDObject (**_args ( 3, 'AK6TopoEMJet', kw,
sgkey='AntiKt6TopoEMJets', prefix='jet_akt6topoem_',
include = ['BTag','TrueFlavorComponents','BTagComponents'],
allowMissing = True))
from TopInputsD3PDMaker.HforD3PDObject import HforD3PDObject
alg += HforD3PDObject(**_args (0, 'HforInfo', kw))
# MET blocks
# a whole mess to remove x,y components separately for all flavours
alg += MissingETD3PDObject (**_args (10, 'MissingET', kw,
exclude=['MET_Base', 'MET_Base0', 'MET_Truth_Int',
'MET_RefFinal_Comps','MET_Calib_Comps','MET_CellOut_Comps',
'MET_CorrTopo_Comps','MET_Cryo_Comps','MET_CryoCone_Comps',
'MET_Final_Comps','MET_LocHadTopo_Comps',
'MET_LocHadTopoObj_Comps','MET_Muid_Comps',
'MET_Muid_Spectro_Comps','MET_Muid_Track_Comps',
'MET_MuonBoy_Comps','MET_MuonBoy_Spectro_Comps',
'MET_MuonBoy_Track_Comps','MET_MuonMuid_Comps',
'MET_Muon_Comps','MET_Muon_Isol_Muid_Comps',
'MET_Muon_Isol_Staco_Comps','MET_Muon_NonIsol_Muid_Comps',
'MET_Muon_NonIsol_Staco_Comps','MET_Muon_Total_Muid_Comps',
'MET_Muon_Total_Staco_Comps','MET_RefEle_Comps',
'MET_RefEle_em_Comps','MET_RefGamma_Comps',
'MET_RefGamma_em_Comps','MET_RefJet_Comps',
'MET_RefJet_em_Comps','MET_RefMuon_Comps',
'MET_RefMuon_Muid_Comps','MET_RefMuon_Staco_Comps',
'MET_RefMuon_Track_Muid_Comps','MET_RefMuon_Track_Staco_Comps',
'MET_RefMuon_Track_em_Comps','MET_RefMuon_Track_Comps',
'MET_RefMuon_em_Comps','MET_RefTau_Comps',
'MET_RefTau_em_Comps','MET_SoftJets_Comps',
'MET_SoftJets_em_Comps','MET_Topo_Comps',
'MET_TopoObj_Comps','MET_Track_Comps','MET_Composition'],
allowMissing=True))
# HadronicRecoil blocks
# alg += ElectronD3PDObject(0, sgkey = "HR_selectedElectrons", prefix = "hr_el_")
# alg += MuonD3PDObject( 0, sgkey = "HR_selectedMuons", prefix = "hr_mu_" )
# alg += MissingETD3PDObject(0, sgkey = "RoughRecoil", prefix = "hr_roughRecoil")
# alg += MissingETD3PDObject(0, sgkey = "ueCorrection", prefix = "hr_ueCorrection")
# track and cluster blocks
# ... all clusters, very low LOD
alg += ClusterD3PDObject (**_args ( 0, 'Clusters1', kw,
exclude='SamplingBasics'))
# ... higher LOD for pt>10 GeV
alg += ClusterD3PDObject (**_args ( 2, 'Clusters2', kw,
sgkey = 'HighPtClusters',
prefix = 'clpt10_'))
alg += ClusterD3PDObject (**_args ( 3, 'Clusters3', kw,
sgkey = 'HighPtEMClusters',
prefix = 'emclpt10_'))
# ... good tracks only (nSCT>3; no pt cut)
alg += TrackParticleD3PDObject (**_args ( 3, 'Tracks1', kw,
sgkey = 'GoodTracks',
label = 'trk',
prefix = 'trk_'))
# ... high-pt tracks (nSCT>3; pt>5 GeV)
from TrackD3PDMaker.TrackD3PDMakerFlags import TrackD3PDFlags as highPtFlags
highPtFlags.doTruth = True
highPtFlags.storeDiagonalCovarianceAsErrors = True
highPtFlags.storeHitTruthMatching = True
highPtFlags.storePixelHitsOnTrack = False
highPtFlags.storePixelHolesOnTrack = False
highPtFlags.storePixelOutliersOnTrack = False
highPtFlags.storeSCTHitsOnTrack = False
highPtFlags.storeSCTHolesOnTrack = False
highPtFlags.storeSCTOutliersOnTrack = False
highPtFlags.storeTRTHitsOnTrack = False
highPtFlags.storeTRTHolesOnTrack = False
highPtFlags.storeTRTOutliersOnTrack = False
highPtFlags.storeTrackFitQuality = True
highPtFlags.storeTrackMomentum = True
highPtFlags.storeTrackSummary = True
highPtFlags.trackParametersAtBeamSpotLevelOfDetails = 0
highPtFlags.trackParametersAtGlobalPerigeeLevelOfDetails = 2
highPtFlags.trackParametersAtPrimaryVertexLevelOfDetails = 3
from TrackD3PDMaker.TrackD3PDObject import TrackD3PDObject
HighPtTrackParticleD3PDObject = TrackD3PDObject(_label='trkpt5',
_prefix='trkpt5_',
_sgkey='HighPtTracks',
typeName='Rec::TrackParticleContainer',
flags=highPtFlags)
alg += HighPtTrackParticleD3PDObject(**_args ( 3, 'Tracks2', kw,
sgkey = 'HighPtTracks',
label = 'trkpt5',
prefix = 'trkpt5_'))
# Primary vertex block - May be missing in single-beam data.
alg += PrimaryVertexD3PDObject (**_args (1, 'PrimaryVertex', kw,
allowMissing = True,
sgkey = D3PDMakerFlags.VertexSGKey(),
prefix = 'vxp_'))
# MBTS
alg += MBTSD3PDObject (**_args (10, 'MBTS', kw))
alg += MBTSTimeD3PDObject (**_args (10, 'MBTSTime', kw))
alg += MBTSTriggerBitsD3PDObject (**_args (10, 'MBTSTriggerBits', kw))
#alg += CollisionDecisionD3PDObject(**_args (10, 'CollisionDecision', kw))
# Truth
if rec.doTruth():
from TruthD3PDMaker.TruthParticleD3PDObject import TruthParticleD3PDObject
from MuonD3PDMaker.TruthMuonD3PDObject import TruthMuonD3PDObject
alg += TruthMuonD3PDObject (**_args ( 2, 'TruthMuon', kw))
alg += GenEventD3PDObject (**_args ( 1, 'GenEvent', kw))
alg += TruthParticleD3PDObject(**_args ( 1, 'TruthParticle', kw))
# TruthJets
alg += JetD3PDObject (**_args ( 1, 'AK4TruthJet', kw,
sgkey='AntiKt4TruthJets',prefix='jet_antikt4truth_'))
alg += JetD3PDObject (**_args ( 1, 'AK6TruthJet', kw,
sgkey='AntiKt6TruthJets', prefix='jet_antikt6truth_'))
alg += JetD3PDObject (**_args ( 1, 'AK4TruthJetALL', kw,
sgkey='AntiKt4TruthJets_ALL', prefix='jet_antikt4truthALL_'))
alg += JetD3PDObject (**_args ( 1, 'AK6TruthJetALL', kw,
sgkey='AntiKt6TruthJets_ALL', prefix='jet_antikt6truthALL_'))
alg += JetD3PDObject (**_args ( 1, 'AK4TruthJetWZ', kw,
sgkey='AntiKt4TruthJets_WZ', prefix='jet_antikt4truthWZ_'))
alg += JetD3PDObject (**_args ( 1, 'AK6TruthJetWZ', kw,
sgkey='AntiKt6TruthJets_WZ', prefix='jet_antikt6truthWZ_'))
if not rec.doTruth():
alg += BeamSpotD3PDObject(10)
# Trigger
if D3PDMakerFlags.DoTrigger():
# Trigger Decision + metadata
alg += TrigDecisionD3PDObject (**_args(10, 'TrigDecision', kw))
addTrigConfMetadata(alg)
# Bunch group info
alg += BGCodeD3PDObject (**_args (2, 'BGCode', kw))
# Egamma and Mu
TrigEgammaD3PDObjects (alg, 0)
# TrigMuonD3PDObjects( alg, 0)
# Esum
alg += EnergySumROID3PDObject(**_args (2, 'EnergySumROI', kw,
prefix = "trig_L1_esum_"))
# The LVL2 information:
alg += TrigMETD3PDObject(**_args( 2, 'TrigMETL2', kw,
prefix = "trig_L2_met_",
sgkey = "HLT_T2MissingET" ))
# The EF information:
alg += TrigMETD3PDObject(**_args ( 2, 'TrigMETEF', kw,
prefix = "trig_EF_met_",
sgkey = "HLT_TrigEFMissingET" ))
# Event metadata
alg.MetadataTools += [LBMetadataConfig()]
if D3PDMakerFlags.FilterCollCand():
from CaloD3PDMaker.CollisionFilterAlg import CollisionFilterAlg
alg.filterSeq += CollisionFilterAlg (tuplename + '_CollCandFilter')
return alg
Reconstruction/MuonIdentification/MuonCombinedValidation/MuonCombinedRecRTT/share/MCP_RTT_makeHistos.C 0 → 100644
+ 57
− 0
View file @ b5e2698a
// Macro for to print plots from the Calibration ntuple
//
// Useage: to run in batch mode, type
// root -q -b 'MCP_RTT_makeHistos("physics")'
//
// Jan 2011 B. Di Micco
//////////////////////////////////////////////////////////////////////////////
void MCP_RTT_makeHistos(char* inputName="physics")
{
//Set Some default styles for the histogram plots
gStyle->SetMarkerStyle(8);
gStyle->SetStatW(0.2);
gStyle->SetStatH(0.2);
gStyle->SetStatFontSize(0.07);
gStyle->SetLabelSize(0.06);
gStyle->SetOptFit(1111);
gStyle->SetCanvasBorderMode(0);
gStyle->SetPadBorderMode(0);
gStyle->SetPadColor(0);
gStyle->SetCanvasColor(0);
gStyle->SetTitleColor(0);
gStyle->SetStatColor(0);
gStyle->SetTitleFontSize(0.08);
gStyle->SetMarkerSize(0.3);
gROOT->SetStyle("Plain");
gStyle->SetOptStat(111111);
printf("Input name = %s\n", inputName);
char inputNtupleFile[256]; char outputHistosFile[256];
sprintf(inputNtupleFile,"%s.root",inputName);
sprintf(outputHistosFile,"%s_histos.root",inputName);
printf("Input ntuple file = %s\n", inputNtupleFile);
printf("output histos file = %s\n", outputHistosFile);
// open ntuple file
// create object histos
TFile *fin = new TFile(inputNtupleFile,"READ");
TTree *tree = (TTree*)fin->Get("physics");
gROOT->ProcessLine(".L physics_MCP_RTT.C+");
gROOT->ProcessLine(".L histos_MCP_RTT.C+");
TFile *fout = new TFile(outputHistosFile,"RECREATE");
histos myHistos(tree);
myHistos.run();
cout << "after running...." << endl;
//TFile *fout = new TFile("MuonCalibNtuple_fromESD_histos.root","RECREATE");
cout << "fout = " << fout << endl;
fout->Write();
fout->Close();
}
Reconstruction/MuonIdentification/MuonCombinedValidation/MuonCombinedRecRTT/share/MuonCombinedRecRTT.py 0 → 100644
+ 109
− 0
View file @ b5e2698a
# MuonRecRTT_sim_standalone.py
#
# top options to run Muon Spectrometer reconstruction only
# on simulated data, using MuonRecExample/MuonRec_myTopOptions.py
# flags set up in MuonRec_myTopOptions.py can be modified
# and locked as in the example below
#from MuonRecExample.MuonRecFlags import muonRecFlags
#muonRecFlags.doCalib.set_Value_and_Lock(False)
# Turn on PerfMon to monitor the software performance
from RecExConfig.RecFlags import rec
# recFlags.doPerfMon.set_Value_and_Lock(True)
from RecExConfig.RecFlags import rec as rec
# I'm sure there's a better way to do this, but I just wanted to get something working fast. Ed.
from MuonRecExample.MuonRecFlags import muonRecFlags
# Run MuPerf or not
doMuPerf = False
# Turn off all reconstruction algorithms
# ---- Input / Output
readESD=True
doMuonRecStatistics = False
doWriteESD = False # Decide whether to write ESD/AOD/TAG
doWriteAOD = True
doWriteTAG = False
doJiveXML = False
donewTracking = False
# ---- Reconstruction
doESD = True
doAOD = True # Decide whether to run AOD-making algorithms
doAODall = True
rec.readAOD.set_Value_and_Lock(False)
rec.doApplyAODFix.set_Value_and_Lock(False)
#doTrigger = True
doMuonIDStandAlone = True # extrapolate Moore tracks to the IP
doMuonIDCombined = True # combined reconstruction with MuIDCombined
doMoore = True
doMuonboy = True
doStaco = True # combined reconstruction with Staco
doMuTag = True # muon identification with MuTag (requires Muonboy and Staco)
doMuGirl = True # muon identification with MuGirl
doCaloTrkMuId = True # muon identification with Calorimeter
doCaloTopoCluster = True # run calo topo cluster (needed for CaloLR muons)
import os
doNameAuditor = True
# ---- Misc
doVisualization = False # Decide whether to run HepVis or not
doTrackRecordFilter = False # process Muon Spectrometer entry truth info to add it to CBNT
doCBNT=False
# muonRecFlags.doTrackPerformance = True
# muonRecFlags.TrackPerfDebugLevel = 0
# on lxplus209
InputCollection = []
InputCollection+=["root://castoratlas//castor/cern.ch/atlas/atlascerngroupdisk/perf-muon/MuonCombinedRTTInputs/Zmumu/ESD.213372._000088.pool.root.2"]
InputCollection+=["root://castoratlas//castor/cern.ch/atlas/atlascerngroupdisk/perf-muon/MuonCombinedRTTInputs/Zmumu/ESD.213372._000092.pool.root.2"]
InputCollection+=["root://castoratlas//castor/cern.ch/atlas/atlascerngroupdisk/perf-muon/MuonCombinedRTTInputs/Zmumu/ESD.213372._000100.pool.root.2"]
InputCollection+=["root://castoratlas//castor/cern.ch/atlas/atlascerngroupdisk/perf-muon/MuonCombinedRTTInputs/Zmumu/ESD.213372._000192.pool.root.2"]
InputCollection+=["root://castoratlas//castor/cern.ch/atlas/atlascerngroupdisk/perf-muon/MuonCombinedRTTInputs/Zmumu/ESD.213372._000302.pool.root.2"]
InputCollection+=["root://castoratlas//castor/cern.ch/atlas/atlascerngroupdisk/perf-muon/MuonCombinedRTTInputs/Zmumu/ESD.213372._000312.pool.root.2"]
InputCollection+=["root://castoratlas//castor/cern.ch/atlas/atlascerngroupdisk/perf-muon/MuonCombinedRTTInputs/Zmumu/ESD.213372._000407.pool.root.2"]
InputCollection+=["root://castoratlas//castor/cern.ch/atlas/atlascerngroupdisk/perf-muon/MuonCombinedRTTInputs/Zmumu/ESD.213372._000427.pool.root.2"]
InputCollection+=["root://castoratlas//castor/cern.ch/atlas/atlascerngroupdisk/perf-muon/MuonCombinedRTTInputs/Zmumu/ESD.213372._000459.pool.root.2"]
InputCollection+=["root://castoratlas//castor/cern.ch/atlas/atlascerngroupdisk/perf-muon/MuonCombinedRTTInputs/Zmumu/ESD.213372._000027.pool.root.2"]
from AthenaCommon.AthenaCommonFlags import athenaCommonFlags
#athenaCommonFlags.FilesInput.set_Value_and_Lock(InputCollection)
from RecExConfig.InputFilePeeker import inputFileSummary
DoTruth = False
if 'IS_SIMULATION' in inputFileSummary['evt_type']:
DoTruth = True
if not DoTruth:
rec.doTruth.set_Value_and_Lock(False)
pass
rec.doForwardDet.set_Value_and_Lock(False)
include ("RecExCommon/RecExCommon_topOptions.py")
#####################################################################3
## Adding beamspot info
#from MinBiasD3PDMaker.MinBiasD3PDMakerConf import MinBiasD3PD__MinBiasD3PDPreProcessing
#MinBiasD3PDPreProcessingAlg = MinBiasD3PD__MinBiasD3PDPreProcessing( name = "MinBiasD3PDPreProcessingAlg", OutputLevel = INFO )
#topSequence += MinBiasD3PDPreProcessingAlg
#include('InDetBeamSpotService/BeamCondSvc.py')
include ("CaloD3PDMaker/CaloD3PD_Rapgap_jobOption.py")
include ("PhysicsD3PDMaker/MyJetMake.py")
include ("MuonCombinedRecRTT/MCPD3PDMaker.py")
tupleFileOutput = 'physics.root'
alg = MCPphysicsD3PD (file=tupleFileOutput,tuplename='physics', streamNameRoot ='OutStream')
Reconstruction/MuonIdentification/MuonCombinedValidation/MuonCombinedRecRTT/share/MuonParamDefs.h 0 → 100644
+ 80
− 0
View file @ b5e2698a
#ifndef MUONEVENT_MUONPARAMDEFS_H
#define MUONEVENT_MUONPARAMDEFS_H
/*****************************************************************************
Name : MuonParamDefs.h
Package : offline/Reconstruction/MuonIdentification/muonEvent
Author : Ketevi A. Assamagan
Created : September 2005
DESCRIPTION:
This file defines enums for Muon parameters
*****************************************************************************/
namespace MuonParameters {
/** do not change the order of these enums. You can add one, but
changing the order is bad.
The authors "highpt", "lowPt" and "mediumPt" should not be used -
they are kept for backward compatibility ONLY, to read old data
*/
enum Author {
unknown=0,
highPt=1,
lowPt=2,
mediumPt=3,
MuonboySP=4,
Muonboy=5,
STACO=6,
MuTag=7,
MOORE=10,
MuidSA=11,
MuidCo=12,
MuGirl=13,
CaloMuonId=14,
MuGirlLowBeta=15,
CaloTag=16,
CaloLikelihood=17,
MuTagIMO=18,
MuonCombinedRefit=19,
ExtrapolateMuonToIP=20
};
/** Enum for parameter indexes */
enum ParamDef {
/** isolation enums - common parameters */
etcone10 = 0,//<! Isolation Et in a cone of 0.1
etcone20 = 1,//<! Isolation Et in a cone of 0.2
etcone30 = 2,//<! Isolation Et in a cone of 0.3
etcone40 = 3,//<! Isolation Et in a cone of 0.4
nucone10 = 8,//<! Number of Tracks in a cone of 0.1
nucone20 = 9,//<! Number of Tracks in a cone of 0.2
nucone30 = 10,//<! Number of Tracks in a cone of 0.3
nucone40 = 11,//<! Number of Tracks in a cone of 0.4
ptcone10 = 16,//<! summed Pt of tracks in a cone of 0.1
ptcone20 = 17,//<! summed Pt of tracks in a cone of 0.2
ptcone30 = 18,//<! summed Pt of tracks in a cone of 0.3
ptcone40 = 19,//<! summed Pt of tracks in a cone of 0.4
/** MuTag parameters */
segmentDeltaEta = 100,
segmentDeltaPhi = 101,
segmentChi2OverDoF = 102,
/** MuGirl parameter */
t0 = 198,
beta = 199,
annBarrel = 200,
annEndCap = 201,
/** common MuGirl and MuTag parameters */
innAngle = 202,
midAngle = 203
};
}
#endif // MUONIDEVENT_MUONPARAMDEFS_H
Reconstruction/MuonIdentification/MuonCombinedValidation/MuonCombinedRecRTT/share/histos_MCP_RTT.C 0 → 100644
+ 570
− 0
View file @ b5e2698a
#include "histos_MCP_RTT.h"
#include <TCanvas.h>
#include <math.h>
#include <TStyle.h>
histos::histos() {
}
histos::histos(TTree *tree) : physics(tree) {
cout << "Initializing the constructor" << endl;
Init();
}
void histos::Init() {
variables.push_back("pt"); variables.push_back("eta");
variables.push_back("phi");
subdetectors.push_back("pix"); subdetectors.push_back("sct");
subdetectors.push_back("trt"); subdetectors.push_back("csc");
subdetectors.push_back("mdt"); subdetectors.push_back("tgc");
subdetectors.push_back("rpc");
}
histos::~histos() {
list<TObject *>::iterator iter;
cout << "in destructor " << endl;
file_out->cd();
all_histos.sort(); all_histos.unique();
cout << "after sorting and uniquing" << endl;
for(iter=all_histos.begin(); iter!=all_histos.end(); ++iter) {
(*iter)->Write();
// cout << "deleting " << *iter << endl;
// cout << "deleting" << (*iter)->GetName() << endl;
}
file_out->Close();
}
void histos::run() {
cout << "running ... " << endl;
book();
cout << "looping .... " << endl;
Loop();
cout << "after loopinf" << endl;
cout << "printing" << endl;
print();
}
void histos::post_process() {
list<string>::iterator var_iter;
list<string>::iterator sub_iter;
list<string>::iterator iter;
for(iter = algorithm_list.begin();iter !=algorithm_list.end();++iter) {
for(sub_iter=subdetectors.begin();sub_iter!=subdetectors.end(); ++sub_iter) {
for(var_iter=variables.begin();var_iter!=variables.end();++var_iter) {
TH2F *pointer;
if(*var_iter=="pt") {
pointer = nhit_pt[*sub_iter+"_"+(*iter)];
} else if(*var_iter=="eta") {
pointer = nhit_eta[*sub_iter+"_"+(*iter)];
} else if(*var_iter=="phi") {
pointer = nhit_phi[*sub_iter+"_"+(*iter)];
}
nhit_prof[*var_iter+"_"+*sub_iter+"_"+*iter] = pointer->ProfileX();
}
}
}
}
void histos::print() {
cout << "Printing histograms" << endl;
list<TObject *>::iterator iter;
gStyle->SetPalette(1);
for(iter=histo_to_print.begin(); iter!=histo_to_print.end(); ++iter) {
TCanvas *canvas = new TCanvas("canvas",(*iter)->GetTitle());
cout << "String = " << ((string) (*iter)->GetName()).substr(0,4) << endl;
if(((string) (*iter)->GetName()).substr(0,5)=="Delta") {
(*iter)->Draw("COLZ");
} else {
(*iter)->Draw();
}
canvas->Update();
string name = ((string) (*iter)->GetName())+".gif";
canvas->SaveAs(name.c_str());
delete canvas;
}
}
void histos::book() {
algorithm_list.push_back("Staco_CB");
algorithm_list.push_back("MuonBoy");
algorithm_list.push_back("MuTag");
algorithm_list.push_back("MuTagIMO");
algorithm_list.push_back("Muid_CB");
algorithm_list.push_back("MuidSA");
algorithm_list.push_back("MuGirl");
algorithm_list.push_back("Muid_Tight");
algorithm_list.push_back("CaloMuon");
file_out = new TFile("histos_MCP_RTT.root","NEW");
list<string>::iterator iter;
for(iter = algorithm_list.begin();iter !=algorithm_list.end();++iter) {
string name;
name = "mu_pt_"+*iter;
mu_pt[*iter] = new TH1F(name.c_str(),"Muon pt [GeV]",100,0,100);
AddToPrint(mu_pt[*iter]);
name = "mu_eta_pt20_"+*iter;
mu_eta_pt20[*iter] = new TH1F(name.c_str(),"Muon eta ", 60,-3,3);
AddToPrint(mu_eta_pt20[*iter]);
name = "mu_phi_pt20_"+*iter;
mu_phi_pt20[*iter] = new TH1F(name.c_str(),"Muon phi",60,-3.2,3.2);
AddToPrint(mu_phi_pt20[*iter]);
name = "chi2_"+*iter;
chi2[*iter] = new TH1F(name.c_str(),"Track fit chi2/ndf",100,0,2);
if(*iter!="CaloMuon") AddToPrint(chi2[*iter]);
if(isCombined(*iter)) {
Double_t etabins[8] = {-2.5,-2.1,-1.8,-1.05,1.05,1.8,2.1,2.5};
name = "DeltaPtovPt_pt20_"+*iter;
DeltaPtovPt[*iter] = new TH2F(name.c_str(),"DPt/Pt",7,etabins,100,-1,1);
AddToPrint(DeltaPtovPt[*iter]);
name = "Chi2Match_"+*iter;
chi2Match[*iter] = new TH2F(name.c_str(),"Chi2Match/ndf",7,etabins,100,0,40);
AddToPrint(chi2Match[*iter]);
name = "DeltaEta_pt20_"+*iter;
DeltaEta[*iter] = new TH2F(name.c_str(),"DeltaEta",7,etabins,100,-.1,.1);
AddToPrint(DeltaEta[*iter]);
name = "DeltaPhi_pt20_"+*iter;
DeltaPhi[*iter] = new TH2F(name.c_str(),"DeltaPhi",7,etabins,100,-.1,.1);
AddToPrint(DeltaPhi[*iter]);
}
name = "NhitsEff_"+*iter;
NhitsEff[*iter] = new TH2F(name.c_str(),"NhitsEff versus pT (GeV)",100,0,100,100,0.,1);
name = "NhitsEffSoft_"+*iter;
NhitsEffSoft[*iter] = new TH2F(name.c_str(),"NhitsEffsoft versus pT (GeV)",100,0,100,100,0.,1);
list<string>::iterator sub_iter;
for(sub_iter=subdetectors.begin(); sub_iter!=subdetectors.end();++sub_iter) {
name = "nhit_pt_"+(*sub_iter)+"_"+(*iter);
nhit_pt[*sub_iter+"_"+(*iter)] = new TH2F(name.c_str(),"Fraction of hits versus pT (GeV)",100,0,100,100,0,1);
name = "nhit_eta_"+(*sub_iter)+"_"+(*iter);
nhit_eta[*sub_iter+"_"+(*iter)] = new TH2F(name.c_str(),"Fraction of hits versus eta",60,-3.2,3.2,100,0,1);
name = "nhit_phi_"+(*sub_iter)+"_"+(*iter);
nhit_phi[*sub_iter+"_"+(*iter)] = new TH2F(name.c_str(),"Fraction of hits versus phi",60,-3,3,100,0,1);
}
name = "d0_pT" + (*iter);
d0_pT[*iter] = new TH2F(name.c_str(),"d0 versus pT (GeV)",100,0,100,100,-10,10);
name = "z0_pT" + (*iter);
z0_pT[*iter] = new TH2F(name.c_str(),"z0 versus pT (GeV)",100,0,100,100,-10,10);
name = "d0_eta" + (*iter);
d0_eta[*iter] = new TH2F(name.c_str(),"d0 versus pT (GeV)", 30,-3,3,100,-10,10);
name = "z0_eta" + (*iter);
z0_eta[*iter] = new TH2F(name.c_str(),"z0 versus eta",30,-3,3,100,-10,10);
}
}
void histos::ClearVectors() {
pt.clear(); eta.clear(); phi.clear(); NhitsEff_value.clear();
NhitsEffSoft_value.clear(); n_holes.clear(); nhit_sub.clear();
d0.clear(); z0.clear(); pt_ID.clear(); pt_MS.clear(); eta_ID.clear(); eta_MS.clear();
phi_ID.clear(); phi_MS.clear(); Chi2M.clear(); n_outliers.clear(); chi2_val.clear();
}
void histos::fill() {
static int counter=0;
counter++;
bool dump=(counter<100);
list<string>::iterator iter;
if(dump) cout << "now we are in fill()" << endl;
for(iter=algorithm_list.begin();iter!=algorithm_list.end();++iter) {
if(dump) cout << "processing algorithm " << *iter << endl;
FillMuon(*iter);
cout << "Before filling histogram maps..." << " nmuons = " << nmuons << endl;
for(int i=0;i<=nmuons;i++) {
mu_pt[*iter]->Fill(pt[i]);
cout << "just after mu_pt" << endl;
NhitsEff[*iter]->Fill(pt[i],NhitsEff_value[i]);
cout << "just after NhitsEff" << endl;
NhitsEffSoft[*iter]->Fill(pt[i],NhitsEffSoft_value[i]);
cout << "just after NhitsEffSoft" << endl;
if(pt[i]>20) {
mu_eta_pt20[*iter]->Fill(eta[i]);
mu_phi_pt20[*iter]->Fill(phi[i]);
}
cout << "just after pt > 20" << endl;
Double_t ntot=0;
list<string>::iterator subiter;
for(subiter=subdetectors.begin();subiter!=subdetectors.end(); ++subiter) {
char num[2];
sprintf(num,"%s_%d",((*subiter).c_str()),i);
string tmp = num;
ntot+=nhit_sub[tmp];
}
cout << "ntot = " << ntot << endl;
for(subiter=subdetectors.begin();subiter!=subdetectors.end(); ++subiter) {
char num[2];
sprintf(num,"%s_%d",((*subiter).c_str()),i);
string tmp = num;
nhit_pt[*subiter+"_"+(*iter)]->Fill(pt[i],nhit_sub[tmp]/ntot);
if(pt[i]>20) {
nhit_eta[*subiter+"_"+(*iter)]->Fill(eta[i],nhit_sub[tmp]/ntot);
nhit_phi[*subiter+"_"+(*iter)]->Fill(phi[i],nhit_sub[tmp]/ntot);
}
}
cout << "just after pt > 20" << endl;
d0_pT[*iter]->Fill(pt[i],d0[i]);
z0_pT[*iter]->Fill(pt[i],z0[i]);
cout << "just after pt vs d0" << endl;
d0_eta[*iter]->Fill(eta[i],d0[i]);
z0_eta[*iter]->Fill(eta[i],z0[i]);
chi2[*iter]->Fill(chi2_val[i]);
cout << "combined variables " << endl;
if(isCombined(*iter) && pt[i]>20) {
DeltaPtovPt[*iter]->Fill(eta[i],(pt_ID[i]-pt_MS[i])/pt_ID[i]);
chi2Match[*iter]->Fill(eta[i],Chi2M[i]);
DeltaEta[*iter]->Fill(eta[i],(eta_ID[i]-eta_MS[i]));
DeltaPhi[*iter]->Fill(eta[i],(eta_ID[i]-eta_MS[i]));
}
}
}
}
void histos::FillMuon(string alg) {
nmuons = -1;
ClearVectors();
if(alg=="Staco_CB" || alg=="MuonBoy" || alg =="MuTag") {
FillStacoCollection(alg);
} else if(alg=="Muid_CB" || alg=="MuGirl" || alg=="Muid_Tight" || alg=="MuidSA" || alg=="MuTagIMO") {
FillMuidCollection(alg);
} else if(alg=="CaloMuon") {
FillCaloMuonCollection(alg);
}
for(int i=0;i<=nmuons;i++) {
int nhit = 0;
list<string>::iterator subiter;
for(subiter=subdetectors.begin();subiter!=subdetectors.end(); ++subiter) {
char num[2];
sprintf(num,"%s_%d",((*subiter).c_str()),i);
string tmp = num;
nhit += nhit_sub[tmp];
}
NhitsEff_value.push_back(((float) nhit)/(nhit+n_outliers[i]+n_holes[i]));
NhitsEffSoft_value.push_back(((float) nhit)/(nhit+n_outliers[i]+n_holes[i]));
}
}
void histos::FillStacoCollection(string alg) {
// cout << "before Get Author ID" << endl;
int authorID = GetAuthorID(alg);
// cout << "mu_staco_n" << mu_staco_n << endl;
for(int i=0;i < mu_staco_n; i++) {
bool process = false;
if(alg=="Staco_CB") process = mu_staco_isCombinedMuon->at(i);
else {process = mu_staco_author->at(i)==authorID;}
// cout << "i = " << i << endl;
// cout << "process = " << process << endl;
if(process ) {
cout << "incrmenting nmuons " << endl;
nmuons++;
cout << "nmuons = " << nmuons << " i = " << i << endl;
pt.push_back(mu_staco_pt->at(i)/1000);
cout << "after pt" << endl;
eta.push_back(mu_staco_eta->at(i));
phi.push_back(mu_staco_phi->at(i));
list<string>::iterator subiter;
for(subiter=subdetectors.begin();subiter!=subdetectors.end(); ++subiter) {
char num[2];
sprintf(num,"%s_%d",((*subiter).c_str()),i);
string tmp = num;
if(*subiter=="pix") {
nhit_sub[tmp] = mu_staco_nBLHits->at(i)+mu_staco_nPixHits->at(i);
} else if(*subiter=="sct") {
nhit_sub[tmp] = mu_staco_nSCTHits->at(i);
} else if(*subiter=="trt") {
nhit_sub[tmp] = mu_staco_nTRTHits->at(i);
} else if(*subiter=="mdt") {
nhit_sub[tmp] = mu_staco_nMDTHits->at(i);
} else if(*subiter=="rpc") {
nhit_sub[tmp] = mu_staco_nRPCEtaHits->at(i)+mu_staco_nRPCPhiHits->at(i);
} else if(*subiter=="tgc") {
nhit_sub[tmp] = mu_staco_nTGCEtaHits->at(i)+mu_staco_nTGCPhiHits->at(i);
} else if(*subiter=="csc") {
nhit_sub[tmp] = mu_staco_nCSCEtaHits->at(i)+mu_staco_nCSCPhiHits->at(i);
}
}
cout << "before n_outliers" << endl;
n_outliers.push_back(mu_staco_nTRTOutliers->at(i));
n_holes.push_back(mu_staco_nPixHoles->at(i));
n_holes[nmuons] += mu_staco_nSCTHoles->at(i)+mu_staco_nMDTHoles->at(i);
n_holes[nmuons] += mu_staco_nCSCPhiHoles->at(i)+mu_staco_nCSCEtaHoles->at(i);
n_holes[nmuons] += mu_staco_nRPCEtaHoles->at(i)+mu_staco_nRPCPhiHoles->at(i);
n_holes[nmuons] += mu_staco_nTGCPhiHoles->at(i)+mu_staco_nTGCEtaHoles->at(i);
n_holes[nmuons] += mu_staco_nMDTHoles->at(i);
cout << "d0 e z0" << endl;
d0.push_back(mu_staco_d0_exPV->at(i));
z0.push_back(mu_staco_z0_exPV->at(i));
int ndof = mu_staco_trackfitndof->at(i);
chi2_val.push_back((ndof > 0) ? mu_staco_trackfitchi2->at(i)/ndof : -1);
cout << "Chi2M" << endl;
Chi2M.push_back(mu_staco_matchchi2->at(i)/mu_staco_matchndof->at(i));
double pt_ID_var,eta_ID_var,pt_MS_var,eta_MS_var;
GetPtEta(mu_staco_id_qoverp->at(i),mu_staco_id_theta->at(i),&pt_ID_var,&eta_ID_var);
GetPtEta(mu_staco_me_qoverp->at(i),mu_staco_me_theta->at(i),&pt_MS_var,&eta_MS_var);
pt_ID.push_back(pt_ID_var); pt_MS.push_back(pt_MS_var);
eta_ID.push_back(eta_ID_var); eta_MS.push_back(eta_MS_var);
phi_ID.push_back(mu_staco_id_phi->at(i)); phi_MS.push_back(mu_staco_me_phi->at(i));
cout << "end cicle" << endl;
}
}
cout << " going out from Fill Staco collection" << endl;
}
void histos::FillMuidCollection(string alg) {
cout << "entering Muid" << endl;
int authorID = GetAuthorID(alg);
bool process=false;
cout << "before looping mu_muid_n" << endl;
for(int i=0;i < mu_muid_n; i++) {
if(alg=="Muid_CB") process = mu_muid_isCombinedMuon->at(i);
else if(alg=="Muid_Tight") process = mu_muid_tight->at(i);
else process=(authorID==mu_muid_author->at(i));
if(process) {
nmuons++;
pt.push_back(mu_muid_pt->at(i)/1000);
eta.push_back(mu_muid_eta->at(i));
phi.push_back(mu_muid_phi->at(i));
list<string>::iterator subiter;
cout << "before looping on subiter" << endl;
for(subiter=subdetectors.begin();subiter!=subdetectors.end(); ++subiter) {
char num[2];
sprintf(num,"%s_%d",((*subiter).c_str()),i);
string tmp = num;
cout << "string " << tmp << " i = " << i << endl;
if(*subiter=="pix") {
nhit_sub[tmp] = mu_muid_nBLHits->at(i)+mu_muid_nPixHits->at(i);
} else if(*subiter=="sct") {
nhit_sub[tmp] = mu_muid_nSCTHits->at(i);
} else if(*subiter=="trt") {
nhit_sub[tmp] = mu_muid_nTRTHits->at(i);
} else if(*subiter=="mdt") {
nhit_sub[tmp] = mu_muid_nMDTHits->at(i);
} else if(*subiter=="rpc") {
nhit_sub[tmp] = mu_muid_nRPCEtaHits->at(i)+mu_muid_nRPCPhiHits->at(i);
} else if(*subiter=="tgc") {
nhit_sub[tmp] = mu_muid_nTGCEtaHits->at(i)+mu_muid_nTGCPhiHits->at(i);
} else if(*subiter=="csc") {
nhit_sub[tmp] = mu_muid_nCSCEtaHits->at(i)+mu_muid_nCSCPhiHits->at(i);
}
cout << "after filling nhit" << endl;
}
cout << "after hits " << endl;
n_outliers.push_back( mu_muid_nTRTOutliers->at(i));
n_holes.push_back(mu_muid_nPixHoles->at(i));
n_holes[nmuons] += mu_muid_nSCTHoles->at(i)+mu_muid_nMDTHoles->at(i);
n_holes[nmuons] += mu_muid_nCSCPhiHoles->at(i)+mu_muid_nCSCEtaHoles->at(i);
n_holes[nmuons] += mu_muid_nRPCEtaHoles->at(i)+mu_muid_nRPCPhiHoles->at(i);
n_holes[nmuons] += mu_muid_nTGCPhiHoles->at(i)+mu_muid_nTGCEtaHoles->at(i);
n_holes[nmuons] += mu_muid_nMDTHoles->at(i);
cout << "n holes " << endl;
d0.push_back(mu_muid_d0_exPV->at(i));
z0.push_back(mu_muid_z0_exPV->at(i));
int ndof = mu_muid_trackfitndof->at(i);
chi2_val.push_back((ndof > 0) ? mu_muid_trackfitchi2->at(i)/ndof : -1);
Chi2M.push_back(mu_muid_matchchi2->at(i)/mu_muid_matchndof->at(i));
double pt_ID_var,eta_ID_var,pt_MS_var,eta_MS_var;
GetPtEta(mu_muid_id_qoverp->at(i),mu_muid_id_theta->at(i),&pt_ID_var,&eta_ID_var);
GetPtEta(mu_muid_me_qoverp->at(i),mu_muid_me_theta->at(i),&pt_MS_var,&eta_MS_var);
pt_ID.push_back(pt_ID_var); pt_MS.push_back(pt_MS_var);
eta_ID.push_back(eta_ID_var); eta_MS.push_back(eta_MS_var);
phi_ID.push_back(mu_muid_id_phi->at(i)); phi_MS.push_back(mu_muid_me_phi->at(i));
cout << "going to exit" << endl;
}
}
}
void histos::FillCaloMuonCollection(string alg) {
// cout << "before Get Author ID" << endl;
// int authorID = GetAuthorID(alg);
// cout << "mu_staco_n" << mu_staco_n << endl;
for(int i=0;i < mu_calo_n; i++) {
bool process = false;
process = true;
if(process ) {
// cout << "incrementing nmuons " << endl;
nmuons++;
// cout << "nmuons = " << nmuons << " i = " << i << endl;
pt.push_back(mu_calo_pt->at(i)/1000);
// cout << "after pt" << endl;
eta.push_back(mu_calo_eta->at(i));
phi.push_back(mu_calo_phi->at(i));
list<string>::iterator subiter;
for(subiter=subdetectors.begin();subiter!=subdetectors.end(); ++subiter) {
char num[2];
sprintf(num,"%s_%d",((*subiter).c_str()),i);
string tmp = num;
nhit_sub[tmp] = 0;
}
// cout << "before n_outliers" << endl;
n_outliers.push_back(0);
n_holes.push_back(0);
/*
n_holes[nmuons] += mu_calo_nSCTHoles->at(i)+mu_staco_nMDTHoles->at(i);
n_holes[nmuons] += mu_calo_nCSCPhiHoles->at(i)+mu_staco_nCSCEtaHoles->at(i);
n_holes[nmuons] += mu_calo_nRPCEtaHoles->at(i)+mu_staco_nRPCPhiHoles->at(i);
n_holes[nmuons] += mu_calo_nTGCPhiHoles->at(i)+mu_staco_nTGCEtaHoles->at(i);
n_holes[nmuons] += mu_calo_nMDTHoles->at(i);
*/
// cout << "d0 e z0" << endl;
d0.push_back(0);
z0.push_back(0);
// int ndof = mu_calo_trackfitndof->at(i);
chi2_val.push_back(0);
}
}
}
int histos::GetAuthorID(string alg) {
if(alg=="MuonBoy") {return MuonParameters::Muonboy;}
else if(alg=="MuidSA") {return MuonParameters::MuidSA;}
else if(alg=="MuTag") {return MuonParameters::MuTag;}
else if(alg=="MuGirl") {return MuonParameters::MuGirl;}
else if(alg=="Staco_CB") {return MuonParameters::STACO;}
else if(alg=="Muid_CB") {return MuonParameters::MuidCo;}
else if(alg=="MuTagIMO") {return MuonParameters::MuTagIMO;}
return MuonParameters::unknown;
}
void histos::AddToPrint(TObject *object) {
histo_to_print.push_back(object);
all_histos.push_back(object);
}
void histos::AddToAll(TObject *object) {
all_histos.push_back(object);
}
void histos::GetPtEta(double qoverp, double theta, double *pt_out, double *eta_out) {
*pt_out = ((fabs(qoverp) > 0) ?fabs(1/qoverp)*sin(theta) : 0);
*eta_out = ((theta>0) ? -log(tan(theta/2)) : 0.);
// cout << "qoverp, theta, pt, eta = " << qoverp << ", " << theta << ", " << *pt << ", " << *eta << endl;
}
Reconstruction/MuonIdentification/MuonCombinedValidation/MuonCombinedRecRTT/share/histos_MCP_RTT.h 0 → 100644
+ 78
− 0
View file @ b5e2698a
#include "MuonParamDefs.h"
#include "physics_MCP_RTT.h"
#include <TH1F.h>
#include <TH2F.h>
#include <list>
#include <string>
#include <map>
#include <TObject.h>
#include <TProfile.h>
using namespace std;
class histos : public physics {
public:
map<string,TH1F *> mu_pt, mu_eta_pt20, mu_phi_pt20, chi2;
map<string, TH2F *> DeltaPtovPt,chi2Match,DeltaEta,DeltaPhi,NhitsEff,NhitsEffSoft;
map<string, TH2F *> nhit_pt;
map<string, TH2F *> nhit_eta;
map<string, TH2F *> nhit_phi;
map<string, TH2F *> d0_pT,z0_pT,d0_eta,z0_eta;
map<string, TH1F *> *author, *author_pt_20;
map<string, TProfile *> nhit_prof;
histos();
histos(TTree *tree);
~histos();
void book();
void fill();
void print();
void run();
private:
TFile *file_out;
list<string> algorithm_list;
list<TObject *> histo_to_print, all_histos;
void AddToPrint(TObject *);
void AddToAll(TObject *);
string id_to_author(int id);
inline bool isCombined(string Alg);
int nmuons;
vector<double> pt, eta , phi, NhitsEff_value, NhitsEffSoft_value;
vector<int> n_outlayers, n_holes;
map<string,int> nhit_sub;
list<string> variables, subdetectors;
vector<double> d0,z0,pt_ID,pt_MS,eta_ID,eta_MS,phi_ID,phi_MS,Chi2M,n_outliers,chi2_val;
void FillMuidCollection(string alg);
void FillStacoCollection(string alg);
void FillCaloMuonCollection(string alg);
void FillMuon(string alg);
void ClearVectors();
inline int GetAuthorID(string alg);
void GetPtEta(double qoverp, double theta, double *pt_out, double *eta_out);
void post_process();
void Init();
};
bool histos::isCombined(string Alg) {
return (Alg=="Staco_CB") || (Alg == "Muid_CB");
}
Reconstruction/MuonIdentification/MuonCombinedValidation/MuonCombinedRecRTT/share/physics_MCP_RTT.h 0 → 100644
+ 6176
− 0
View file @ b5e2698a
source diff could not be displayed: it is too large. Options to address this: view the blob.
Reconstruction/MuonIdentification/MuonCombinedValidation/MuonCombinedRecRTT/test/MuonCombinedRecRTT_TestConfiguration.xml 0 → 100644
+ 110
− 0
View file @ b5e2698a
<?xml version="1.0"?>
<!DOCTYPE unifiedTestConfiguration SYSTEM "http://www.hep.ucl.ac.uk/atlas/AtlasTesting/DTD/unifiedTestConfiguration.dtd">
<unifiedTestConfiguration>
<atn/>
<kv/>
<rtt xmlns="http://www.hep.ucl.ac.uk/atlas/AtlasTesting/rtt">
<rttContactPerson>Biagio Di Micco (Biagio.Di.Micco@cern.ch)</rttContactPerson>
<mailto>Biagio.Di.Micco@NOSPAMcern.ch</mailto>
<refRelease>15.6.2</refRelease>
<jobList>
<classification>
<displayClass>OfflineValidation</displayClass>
<displayProcess>Reco</displayProcess>
<displayComponent>Perf-CombMuon</displayComponent>
</classification>
<chain>
<chainName>MuonCombinedRecRTTjobs</chainName>
<parallel>
<chainElement>
<athena userJobId="Zmumu" >
<doc>Muon Combined Reconstruction with Z->mumu events</doc>
<displayName>MuonCombinedRecRTT_Reco_Zmumu</displayName>
<commandLineFlags>EvtMax=-1</commandLineFlags>
<options>MuonCombinedRecRTT.py</options>
<package>Reconstruction/MuonIdentification/MuonCombinedValidation/MuonCombinedRecRTT</package>
<group>MuonCBRec</group>
<queue>long</queue>
<dataset_info>
<dc2 />
<datasetName>/eos/atlas/atlascerngroupdisk/perf-muon/MuonCombinedRTTInputs/Zmumu/ESD.213372._000088.pool.root.2</datasetName>
</dataset_info>
<dataset_info>
<dc2 />
<datasetName>/eos/atlas/atlascerngroupdisk/perf-muon/MuonCombinedRTTInputs/Zmumu/ESD.213372._000092.pool.root.2</datasetName>
</dataset_info>
<dataset_info>
<dc2 />
<datasetName>/eos/atlas/atlascerngroupdisk/perf-muon/MuonCombinedRTTInputs/Zmumu/ESD.213372._000100.pool.root.2</datasetName>
</dataset_info>
<dataset_info>
<dc2 />
<datasetName>/eos/atlas/atlascerngroupdisk/perf-muon/MuonCombinedRTTInputs/Zmumu/ESD.213372._000192.pool.root.2</datasetName>
</dataset_info>
<dataset_info>
<dc2 />
<datasetName>/eos/atlas/atlascerngroupdisk/perf-muon/MuonCombinedRTTInputs/Zmumu/ESD.213372._000302.pool.root.2</datasetName>
</dataset_info>
<dataset_info>
<dc2 />
<datasetName>/eos/atlas/atlascerngroupdisk/perf-muon/MuonCombinedRTTInputs/Zmumu/ESD.213372._000312.pool.root.2</datasetName>
</dataset_info>
<dataset_info>
<dc2 />
<datasetName>/eos/atlas/atlascerngroupdisk/perf-muon/MuonCombinedRTTInputs/Zmumu/ESD.213372._000407.pool.root.2</datasetName>
</dataset_info>
<dataset_info>
<dc2 />
<datasetName>/eos/atlas/atlascerngroupdisk/perf-muon/MuonCombinedRTTInputs/Zmumu/ESD.213372._000427.pool.root.2</datasetName>
</dataset_info>
<dataset_info>
<dc2 />
<datasetName>/eos/atlas/atlascerngroupdisk/perf-muon/MuonCombinedRTTInputs/Zmumu/ESD.213372._000459.pool.root.2</datasetName>
</dataset_info>
<dataset_info>
<dc2 />
<datasetName>/eos/atlas/atlascerngroupdisk/perf-muon/MuonCombinedRTTInputs/Zmumu/ESD.213372._000027.pool.root.2</datasetName>
</dataset_info>
<alwaysRunPostProc />
</athena>
</chainElement>
</parallel>
</chain>
</jobList>
<jobGroups>
<jobGroup name="AthenaMuonCBRec" parent="Athena">
<keepFilePattern>*.gif</keepFilePattern>
<keepFilePattern>*.html</keepFilePattern>
<auxFilePattern>histos_MCP_RTT.C</auxFilePattern>
<auxFilePattern>histos_MCP_RTT.h</auxFilePattern>
<auxFilePattern>physics_MCP_RTT.C</auxFilePattern>
<auxFilePattern>physics_MCP_RTT.h</auxFilePattern>
<auxFilePattern>MCP_RTT_makeHistos.C</auxFilePattern>
<auxFilePattern>MuonParamDefs.h</auxFilePattern>
<auxFilePattern>ALL_MuonCombinedRecRTT_Plots.html</auxFilePattern>
<action position="a">
<modulename>RttLibraryTools</modulename>
<testname>ROOTMacroRunner</testname>
<arg>
<argname>macro</argname>
<argvalue>MCP_RTT_makeHistos.C</argvalue>
</arg>
</action>
</jobGroup>
</jobGroups>
</rtt>
</unifiedTestConfiguration>
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment