diff --git a/Event/xAOD/xAODTrigMuon/Root/L2CombinedMuonAuxContainer_v1.cxx b/Event/xAOD/xAODTrigMuon/Root/L2CombinedMuonAuxContainer_v1.cxx
new file mode 100644
index 0000000000000000000000000000000000000000..f41866e5441eca5d6c26eef60cc587733430be72
--- /dev/null
+++ b/Event/xAOD/xAODTrigMuon/Root/L2CombinedMuonAuxContainer_v1.cxx
@@ -0,0 +1,29 @@
+/*
+ Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+// $Id: L2CombinedMuonAuxContainer_v1.cxx 605591 2014-07-09 12:07:31Z krasznaa $
+
+// Local include(s):
+#include "xAODTrigMuon/versions/L2CombinedMuonAuxContainer_v1.h"
+
+namespace xAOD {
+
+ L2CombinedMuonAuxContainer_v1::L2CombinedMuonAuxContainer_v1()
+ : AuxContainerBase() {
+
+ AUX_VARIABLE( pt );
+ AUX_VARIABLE( phi );
+ AUX_VARIABLE( eta );
+
+ AUX_VARIABLE( charge );
+ AUX_VARIABLE( strategy );
+ AUX_VARIABLE( errorFlag );
+ AUX_VARIABLE( matchFlag );
+ AUX_VARIABLE( sigmaPt );
+
+ AUX_VARIABLE( idTrackLink );
+ AUX_VARIABLE( muSATrackLink );
+ }
+
+} // namespace xAOD
diff --git a/Event/xAOD/xAODTrigMuon/Root/L2CombinedMuon_v1.cxx b/Event/xAOD/xAODTrigMuon/Root/L2CombinedMuon_v1.cxx
new file mode 100644
index 0000000000000000000000000000000000000000..663b668485c6aa9502459b90ba53bce09e25482c
--- /dev/null
+++ b/Event/xAOD/xAODTrigMuon/Root/L2CombinedMuon_v1.cxx
@@ -0,0 +1,178 @@
+/*
+ Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+// $Id: L2CombinedMuon_v1.cxx 605614 2014-07-09 12:49:31Z krasznaa $
+
+// System include(s):
+#include <iostream>
+
+// EDM include(s):
+#include "xAODCore/AuxStoreAccessorMacros.h"
+
+// Local include(s):
+#include "xAODTrigMuon/versions/L2CombinedMuon_v1.h"
+#include "xAODTrigMuon/L2StandAloneMuon.h"
+#include "xAODTrigMuon/L2StandAloneMuonContainer.h"
+
+namespace xAOD {
+
+ L2CombinedMuon_v1::L2CombinedMuon_v1()
+ : IParticle(), m_p4(), m_p4Cached( false ) {
+
+ }
+
+ /////////////////////////////////////////////////////////////////////////////
+ //
+ // Implementation of the xAOD::IParticle functions
+ //
+
+ AUXSTORE_PRIMITIVE_GETTER_WITH_CAST( L2CombinedMuon_v1, float, double,
+ pt )
+ AUXSTORE_PRIMITIVE_GETTER_WITH_CAST( L2CombinedMuon_v1, float, double,
+ eta )
+ AUXSTORE_PRIMITIVE_GETTER_WITH_CAST( L2CombinedMuon_v1, float, double,
+ phi )
+
+ double L2CombinedMuon_v1::m() const {
+
+ return 105.6583715;
+ }
+
+ double L2CombinedMuon_v1::e() const {
+
+ return p4().M();
+ }
+
+ double L2CombinedMuon_v1::rapidity() const {
+
+ return p4().Rapidity();
+ }
+
+ const L2CombinedMuon_v1::FourMom_t& L2CombinedMuon_v1::p4() const {
+
+ // Update the cached object if necessary:
+ if( ! m_p4Cached ) {
+ m_p4Cached = true;
+ m_p4.SetPtEtaPhiM( pt(), eta(), phi(), m() );
+ }
+
+ // Return the cached object:
+ return m_p4;
+ }
+
+ Type::ObjectType L2CombinedMuon_v1::type() const {
+
+ return Type::L2CombinedMuon;
+ }
+
+ //
+ /////////////////////////////////////////////////////////////////////////////
+
+ /////////////////////////////////////////////////////////////////////////////
+ //
+ // Implementation of the 4-momentum setter functions
+ //
+
+ void L2CombinedMuon_v1::setPt( float pt ) {
+
+ static Accessor< float > acc( "pt" );
+ acc( *this ) = pt;
+ m_p4Cached = false;
+ return;
+ }
+
+ void L2CombinedMuon_v1::setEta( float eta ) {
+
+ static Accessor< float > acc( "eta" );
+ acc( *this ) = eta;
+ m_p4Cached = false;
+ return;
+ }
+
+ void L2CombinedMuon_v1::setPhi( float phi ) {
+
+ static Accessor< float > acc( "phi" );
+ acc( *this ) = phi;
+ m_p4Cached = false;
+ return;
+ }
+
+ //
+ /////////////////////////////////////////////////////////////////////////////
+
+ /////////////////////////////////////////////////////////////////////////////
+ //
+ // Implementation of the LVL2 muon iso specific functions
+ //
+
+ AUXSTORE_PRIMITIVE_SETTER_AND_GETTER( L2CombinedMuon_v1, float,
+ charge, setCharge )
+ AUXSTORE_PRIMITIVE_SETTER_AND_GETTER( L2CombinedMuon_v1, int,
+ strategy, setStrategy )
+ AUXSTORE_PRIMITIVE_SETTER_AND_GETTER( L2CombinedMuon_v1, int,
+ errorFlag, setErrorFlag )
+ AUXSTORE_PRIMITIVE_SETTER_AND_GETTER( L2CombinedMuon_v1, int,
+ matchFlag, setMatchFlag )
+ AUXSTORE_PRIMITIVE_SETTER_AND_GETTER( L2CombinedMuon_v1, float,
+ sigmaPt, setSigmaPt )
+
+ AUXSTORE_OBJECT_SETTER_AND_GETTER( L2CombinedMuon_v1,
+ ElementLink< TrackParticleContainer >,
+ idTrackLink, setIdTrackLink )
+
+ const xAOD::TrackParticle* L2CombinedMuon_v1::idTrack() const {
+
+ static Accessor< ElementLink< TrackParticleContainer > >
+ acc( "idTrackLink" );
+ if( ! acc.isAvailable( *this ) ) {
+ return 0;
+ }
+ const ElementLink< TrackParticleContainer >& el = acc( *this );
+ if( ! el.isValid() ) {
+ return 0;
+ }
+ return *el;
+ }
+
+ AUXSTORE_OBJECT_SETTER_AND_GETTER( L2CombinedMuon_v1,
+ ElementLink< L2StandAloneMuonContainer >,
+ muSATrackLink, setMuSATrackLink )
+
+ const xAOD::L2StandAloneMuon* L2CombinedMuon_v1::muSATrack() const {
+
+ static Accessor< ElementLink< L2StandAloneMuonContainer > >
+ acc( "muSATrackLink" );
+ if( ! acc.isAvailable( *this ) ) {
+ return 0;
+ }
+ const ElementLink< L2StandAloneMuonContainer >& el = acc( *this );
+ if( ! el.isValid() ) {
+ return 0;
+ }
+ return *el;
+ }
+
+ //
+ /////////////////////////////////////////////////////////////////////////////
+
+} // namespace xAOD
+
+/// Helper operator for easily printing the properties of a LVL2 muon iso
+/// object for debugging.
+///
+std::ostream& operator<< ( std::ostream& out,
+ const xAOD::L2CombinedMuon_v1& mu ) {
+
+ out << "charge: " << mu.charge() << "; ";
+ out << "pt: " << mu.pt() << "; ";
+ out << "phi: " << mu.phi() << "; ";
+ out << "eta: " << mu.eta() << "; ";
+ out << "strategy: " << mu.strategy() << "; ";
+ out << "errorFlag: " << mu.errorFlag() << "; ";
+ out << "matchFlag: " << mu.matchFlag() << "; ";
+ out << "sigmaPt: " << mu.sigmaPt();
+
+ // Return the stream:
+ return out;
+}
diff --git a/Event/xAOD/xAODTrigMuon/Root/L2IsoMuonAuxContainer_v1.cxx b/Event/xAOD/xAODTrigMuon/Root/L2IsoMuonAuxContainer_v1.cxx
new file mode 100644
index 0000000000000000000000000000000000000000..a481efef9f05efa300c1f79b900c9c5a2a75dd31
--- /dev/null
+++ b/Event/xAOD/xAODTrigMuon/Root/L2IsoMuonAuxContainer_v1.cxx
@@ -0,0 +1,32 @@
+/*
+ Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+// $Id: L2IsoMuonAuxContainer_v1.cxx 605591 2014-07-09 12:07:31Z krasznaa $
+
+// Local include(s):
+#include "xAODTrigMuon/versions/L2IsoMuonAuxContainer_v1.h"
+
+namespace xAOD {
+
+ L2IsoMuonAuxContainer_v1::L2IsoMuonAuxContainer_v1()
+ : AuxContainerBase() {
+
+ AUX_VARIABLE( pt );
+ AUX_VARIABLE( phi );
+ AUX_VARIABLE( eta );
+
+ AUX_VARIABLE( roiWord );
+ AUX_VARIABLE( charge );
+ AUX_VARIABLE( errorFlag );
+ AUX_VARIABLE( sumPt01 );
+ AUX_VARIABLE( sumPt02 );
+ AUX_VARIABLE( sumPt03 );
+ AUX_VARIABLE( sumPt04 );
+ AUX_VARIABLE( sumEt01 );
+ AUX_VARIABLE( sumEt02 );
+ AUX_VARIABLE( sumEt03 );
+ AUX_VARIABLE( sumEt04 );
+ }
+
+} // namespace xAOD
diff --git a/Event/xAOD/xAODTrigMuon/Root/L2IsoMuon_v1.cxx b/Event/xAOD/xAODTrigMuon/Root/L2IsoMuon_v1.cxx
new file mode 100644
index 0000000000000000000000000000000000000000..22046af96f9eb073c6b7333ea74a707aa5af1161
--- /dev/null
+++ b/Event/xAOD/xAODTrigMuon/Root/L2IsoMuon_v1.cxx
@@ -0,0 +1,157 @@
+/*
+ Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+// $Id: L2IsoMuon_v1.cxx 605614 2014-07-09 12:49:31Z krasznaa $
+
+// System include(s):
+#include <iostream>
+
+// EDM include(s):
+#include "xAODCore/AuxStoreAccessorMacros.h"
+
+// Local include(s):
+#include "xAODTrigMuon/versions/L2IsoMuon_v1.h"
+
+namespace xAOD {
+
+ L2IsoMuon_v1::L2IsoMuon_v1()
+ : IParticle(), m_p4(), m_p4Cached( false ) {
+
+ }
+
+ /////////////////////////////////////////////////////////////////////////////
+ //
+ // Implementation of the xAOD::IParticle functions
+ //
+
+ AUXSTORE_PRIMITIVE_GETTER_WITH_CAST( L2IsoMuon_v1, float, double,
+ pt )
+ AUXSTORE_PRIMITIVE_GETTER_WITH_CAST( L2IsoMuon_v1, float, double,
+ eta )
+ AUXSTORE_PRIMITIVE_GETTER_WITH_CAST( L2IsoMuon_v1, float, double,
+ phi )
+
+ double L2IsoMuon_v1::m() const {
+
+ return 105.6583715;
+ }
+
+ double L2IsoMuon_v1::e() const {
+
+ return p4().M();
+ }
+
+ double L2IsoMuon_v1::rapidity() const {
+
+ return p4().Rapidity();
+ }
+
+ const L2IsoMuon_v1::FourMom_t& L2IsoMuon_v1::p4() const {
+
+ // Update the cached object if necessary:
+ if( ! m_p4Cached ) {
+ m_p4Cached = true;
+ m_p4.SetPtEtaPhiM( pt(), eta(), phi(), m() );
+ }
+
+ // Return the cached object:
+ return m_p4;
+ }
+
+ Type::ObjectType L2IsoMuon_v1::type() const {
+
+ return Type::L2IsoMuon;
+ }
+
+ //
+ /////////////////////////////////////////////////////////////////////////////
+
+ /////////////////////////////////////////////////////////////////////////////
+ //
+ // Implementation of the 4-momentum setter functions
+ //
+
+ void L2IsoMuon_v1::setPt( float pt ) {
+
+ static Accessor< float > acc( "pt" );
+ acc( *this ) = pt;
+ m_p4Cached = false;
+ return;
+ }
+
+ void L2IsoMuon_v1::setEta( float eta ) {
+
+ static Accessor< float > acc( "eta" );
+ acc( *this ) = eta;
+ m_p4Cached = false;
+ return;
+ }
+
+ void L2IsoMuon_v1::setPhi( float phi ) {
+
+ static Accessor< float > acc( "phi" );
+ acc( *this ) = phi;
+ m_p4Cached = false;
+ return;
+ }
+
+ //
+ /////////////////////////////////////////////////////////////////////////////
+
+ /////////////////////////////////////////////////////////////////////////////
+ //
+ // Implementation of the LVL2 muon iso specific functions
+ //
+
+ AUXSTORE_PRIMITIVE_SETTER_AND_GETTER( L2IsoMuon_v1, uint32_t,
+ roiWord, setRoiWord )
+ AUXSTORE_PRIMITIVE_SETTER_AND_GETTER( L2IsoMuon_v1, float,
+ charge, setCharge )
+ AUXSTORE_PRIMITIVE_SETTER_AND_GETTER( L2IsoMuon_v1, int,
+ errorFlag, setErrorFlag )
+ AUXSTORE_PRIMITIVE_SETTER_AND_GETTER( L2IsoMuon_v1, float,
+ sumPt01, setSumPt01 )
+ AUXSTORE_PRIMITIVE_SETTER_AND_GETTER( L2IsoMuon_v1, float,
+ sumPt02, setSumPt02 )
+ AUXSTORE_PRIMITIVE_SETTER_AND_GETTER( L2IsoMuon_v1, float,
+ sumPt03, setSumPt03 )
+ AUXSTORE_PRIMITIVE_SETTER_AND_GETTER( L2IsoMuon_v1, float,
+ sumPt04, setSumPt04 )
+ AUXSTORE_PRIMITIVE_SETTER_AND_GETTER( L2IsoMuon_v1, float,
+ sumEt01, setSumEt01 )
+ AUXSTORE_PRIMITIVE_SETTER_AND_GETTER( L2IsoMuon_v1, float,
+ sumEt02, setSumEt02 )
+ AUXSTORE_PRIMITIVE_SETTER_AND_GETTER( L2IsoMuon_v1, float,
+ sumEt03, setSumEt03 )
+ AUXSTORE_PRIMITIVE_SETTER_AND_GETTER( L2IsoMuon_v1, float,
+ sumEt04, setSumEt04 )
+ //
+ /////////////////////////////////////////////////////////////////////////////
+
+} // namespace xAOD
+
+/// Helper operator for easily printing the properties of a LVL2 muon iso
+/// object for debugging.
+///
+std::ostream& operator<< ( std::ostream& out,
+ const xAOD::L2IsoMuon_v1& mu ) {
+
+ out << "roiWord: " << mu.roiWord() << "; ";
+ out << "charge: " << mu.charge() << "; ";
+ out << "pt: " << mu.pt() << "; ";
+ out << "phi: " << mu.phi() << "; ";
+ out << "eta: " << mu.eta() << "; ";
+ out << "errorFlag: " << mu.errorFlag() << "; ";
+ out << "sumPt01: " << mu.sumPt01() << "; ";
+ out << "sumPt02: " << mu.sumPt02() << "; ";
+ out << "sumPt03: " << mu.sumPt03() << "; ";
+ out << "sumPt04: " << mu.sumPt04() << "; ";
+ out << "sumEt01: " << mu.sumEt01() << "; ";
+ out << "sumEt02: " << mu.sumEt02() << "; ";
+ out << "sumEt03: " << mu.sumEt03() << "; ";
+ out << "sumEt04: " << mu.sumEt04();
+
+ // Return the stream:
+ return out;
+}
diff --git a/Event/xAOD/xAODTrigMuon/Root/L2StandAloneMuonAuxContainer_v1.cxx b/Event/xAOD/xAODTrigMuon/Root/L2StandAloneMuonAuxContainer_v1.cxx
new file mode 100644
index 0000000000000000000000000000000000000000..b5f30e3641f902b103af5c2e03b1a194fc3e9208
--- /dev/null
+++ b/Event/xAOD/xAODTrigMuon/Root/L2StandAloneMuonAuxContainer_v1.cxx
@@ -0,0 +1,210 @@
+/*
+ Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+// $Id: L2StandAloneMuonAuxContainer_v1.cxx 613775 2014-08-28 07:56:49Z mishitsu $
+
+// Local include(s):
+#include "xAODTrigMuon/versions/L2StandAloneMuonAuxContainer_v1.h"
+
+namespace xAOD {
+
+ L2StandAloneMuonAuxContainer_v1::L2StandAloneMuonAuxContainer_v1()
+ : AuxContainerBase() {
+
+ AUX_VARIABLE( pt );
+ AUX_VARIABLE( phi );
+ AUX_VARIABLE( eta );
+
+ AUX_VARIABLE( roiWord );
+ AUX_VARIABLE( sAddress );
+ AUX_VARIABLE( rMS );
+ AUX_VARIABLE( etaMS );
+ AUX_VARIABLE( phiMS );
+ AUX_VARIABLE( dirPhiMS );
+ AUX_VARIABLE( zMS );
+ AUX_VARIABLE( dirZMS );
+ AUX_VARIABLE( beta );
+
+ AUX_VARIABLE( barrelRadius );
+ AUX_VARIABLE( barrelSagitta );
+
+ AUX_VARIABLE( endcapAlpha );
+ AUX_VARIABLE( endcapBeta );
+ AUX_VARIABLE( endcapRadius );
+
+ AUX_VARIABLE( slopeInner );
+ AUX_VARIABLE( interceptInner );
+ AUX_VARIABLE( deltaR );
+
+ AUX_VARIABLE( etaMap );
+ AUX_VARIABLE( phiMap );
+ AUX_VARIABLE( etaBin );
+ AUX_VARIABLE( phiBin );
+
+ AUX_VARIABLE( isTgcFailure );
+ AUX_VARIABLE( isRpcFailure );
+
+ AUX_VARIABLE( deltaEta );
+ AUX_VARIABLE( deltaPhi );
+
+ AUX_VARIABLE( superPointR );
+ AUX_VARIABLE( superPointZ );
+ AUX_VARIABLE( superPointSlope );
+ AUX_VARIABLE( superPointIntercept );
+ AUX_VARIABLE( superPointChi2 );
+
+ AUX_VARIABLE( algoId );
+ AUX_VARIABLE( teId );
+ AUX_VARIABLE( lvl1Id );
+ AUX_VARIABLE( lumiBlock );
+ AUX_VARIABLE( muonDetMask );
+ AUX_VARIABLE( roiId );
+ AUX_VARIABLE( roiSystem );
+ AUX_VARIABLE( roiSubsystem );
+ AUX_VARIABLE( roiSector );
+ AUX_VARIABLE( roiNumber );
+ AUX_VARIABLE( roiThreshold );
+ AUX_VARIABLE( roiEta );
+ AUX_VARIABLE( roiPhi );
+
+ AUX_VARIABLE( ptBarelRadius );
+ AUX_VARIABLE( ptBarelSagitta );
+ AUX_VARIABLE( ptEndcapAlpha );
+ AUX_VARIABLE( ptEndcapBeta );
+ AUX_VARIABLE( ptEndcapRadius );
+
+ AUX_VARIABLE( chamberType1Normal );
+ AUX_VARIABLE( chamberType1Overlap );
+ AUX_VARIABLE( chamberType2Normal );
+ AUX_VARIABLE( chamberType2Overlap );
+
+ AUX_VARIABLE( roadAwNormal );
+ AUX_VARIABLE( roadAwOverlap );
+
+ AUX_VARIABLE( roadBwNormal );
+ AUX_VARIABLE( roadBwOverlap );
+
+ AUX_VARIABLE( zMinNormal );
+ AUX_VARIABLE( zMinOverlap );
+ AUX_VARIABLE( zMaxNormal );
+ AUX_VARIABLE( zMaxOverlap );
+
+ AUX_VARIABLE( rMinNormal );
+ AUX_VARIABLE( rMinOverlap );
+ AUX_VARIABLE( rMaxNormal );
+ AUX_VARIABLE( rMaxOverlap );
+
+ AUX_VARIABLE( etaMinNormal );
+ AUX_VARIABLE( etaMinOverlap );
+ AUX_VARIABLE( etaMaxNormal );
+ AUX_VARIABLE( etaMaxOverlap );
+
+ AUX_VARIABLE( tgcPt );
+
+ AUX_VARIABLE( tgcInnEta );
+ AUX_VARIABLE( tgcInnPhi );
+ AUX_VARIABLE( tgcInnR );
+ AUX_VARIABLE( tgcInnZ );
+
+ AUX_VARIABLE( tgcInnRhoStd );
+ AUX_VARIABLE( tgcInnRhoN );
+ AUX_VARIABLE( tgcInnPhiStd );
+ AUX_VARIABLE( tgcInnPhiN );
+
+ AUX_VARIABLE( tgcMid1Eta );
+ AUX_VARIABLE( tgcMid1Phi );
+ AUX_VARIABLE( tgcMid1R );
+ AUX_VARIABLE( tgcMid1Z );
+
+ AUX_VARIABLE( tgcMid2Eta );
+ AUX_VARIABLE( tgcMid2Phi );
+ AUX_VARIABLE( tgcMid2R );
+ AUX_VARIABLE( tgcMid2Z );
+
+ AUX_VARIABLE( tgcMidRhoChi2 );
+ AUX_VARIABLE( tgcMidRhoN );
+ AUX_VARIABLE( tgcMidPhiChi2 );
+ AUX_VARIABLE( tgcMidPhiN );
+
+ AUX_VARIABLE( rpc1x );
+ AUX_VARIABLE( rpc1y );
+ AUX_VARIABLE( rpc1z );
+
+ AUX_VARIABLE( rpc2x );
+ AUX_VARIABLE( rpc2y );
+ AUX_VARIABLE( rpc2z );
+
+ AUX_VARIABLE( rpc3x );
+ AUX_VARIABLE( rpc3y );
+ AUX_VARIABLE( rpc3z );
+
+ AUX_VARIABLE( extensionCapacity );
+ AUX_VARIABLE( robCapacity );
+ AUX_VARIABLE( csmCapacity );
+ AUX_VARIABLE( lvl1EmuCapacity );
+ AUX_VARIABLE( rpcHitsCapacity );
+ AUX_VARIABLE( tgcHitsCapacity );
+ AUX_VARIABLE( mdtHitsCapacity );
+
+ AUX_VARIABLE( extension0 );
+ AUX_VARIABLE( extension1 );
+ AUX_VARIABLE( extension2 );
+ AUX_VARIABLE( extension3 );
+ AUX_VARIABLE( extension4 );
+ AUX_VARIABLE( extension5 );
+ AUX_VARIABLE( extension6 );
+ AUX_VARIABLE( extension7 );
+ AUX_VARIABLE( extension8 );
+ AUX_VARIABLE( extension9 );
+
+ AUX_VARIABLE( lvl1Emulation );
+
+ AUX_VARIABLE( robId );
+ AUX_VARIABLE( removedRobId );
+
+ AUX_VARIABLE( csmId );
+ AUX_VARIABLE( csmSize );
+ AUX_VARIABLE( csmError );
+ AUX_VARIABLE( removedCsmId );
+
+ AUX_VARIABLE( padHitOnlineId );
+ AUX_VARIABLE( padHitCode );
+ AUX_VARIABLE( padHitX );
+ AUX_VARIABLE( padHitY );
+ AUX_VARIABLE( padHitZ );
+ AUX_VARIABLE( padHitR );
+ AUX_VARIABLE( padHitP );
+
+ AUX_VARIABLE( tgcInnRhoHitPhi );
+ AUX_VARIABLE( tgcInnRhoHitR );
+ AUX_VARIABLE( tgcInnRhoHitZ );
+ AUX_VARIABLE( tgcInnRhoHitWidth );
+ AUX_VARIABLE( tgcInnRhoHitInSeg );
+ AUX_VARIABLE( tgcInnPhiHitPhi );
+ AUX_VARIABLE( tgcInnPhiHitR );
+ AUX_VARIABLE( tgcInnPhiHitZ );
+ AUX_VARIABLE( tgcInnPhiHitWidth );
+ AUX_VARIABLE( tgcInnPhiHitInSeg );
+ AUX_VARIABLE( tgcMidRhoHitPhi );
+ AUX_VARIABLE( tgcMidRhoHitR );
+ AUX_VARIABLE( tgcMidRhoHitZ );
+ AUX_VARIABLE( tgcMidRhoHitWidth );
+ AUX_VARIABLE( tgcMidRhoHitInSeg );
+ AUX_VARIABLE( tgcMidPhiHitPhi );
+ AUX_VARIABLE( tgcMidPhiHitR );
+ AUX_VARIABLE( tgcMidPhiHitZ );
+ AUX_VARIABLE( tgcMidPhiHitWidth );
+ AUX_VARIABLE( tgcMidPhiHitInEeg );
+
+ AUX_VARIABLE( mdtHitOnlineId );
+ AUX_VARIABLE( mdtHitOfflineId );
+ AUX_VARIABLE( mdtHitR );
+ AUX_VARIABLE( mdtHitZ );
+ AUX_VARIABLE( mdtHitResidual );
+ AUX_VARIABLE( mdtHitTime );
+ AUX_VARIABLE( mdtHitSpace );
+ AUX_VARIABLE( mdtHitSigma );
+ }
+
+} // namespace xAOD
diff --git a/Event/xAOD/xAODTrigMuon/Root/L2StandAloneMuon_v1.cxx b/Event/xAOD/xAODTrigMuon/Root/L2StandAloneMuon_v1.cxx
new file mode 100644
index 0000000000000000000000000000000000000000..fbaab0cef1a29d66b32842680771513e59308e0e
--- /dev/null
+++ b/Event/xAOD/xAODTrigMuon/Root/L2StandAloneMuon_v1.cxx
@@ -0,0 +1,1770 @@
+/*
+ Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+// $Id: L2StandAloneMuon_v1.cxx 616091 2014-09-11 11:00:02Z mishitsu $
+
+// System include(s):
+#include <iostream>
+
+// EDM include(s):
+#include "xAODCore/AuxStoreAccessorMacros.h"
+
+// Local include(s):
+#include "xAODTrigMuon/versions/L2StandAloneMuon_v1.h"
+#include "xAODTrigMuon/TrigMuonDefs.h"
+
+namespace xAOD {
+
+ L2StandAloneMuon_v1::L2StandAloneMuon_v1()
+ : IParticle(), m_p4(), m_p4Cached( false ) {
+
+ }
+
+ /////////////////////////////////////////////////////////////////////////////
+ //
+ // Implementation of the xAOD::IParticle functions
+ //
+
+ AUXSTORE_PRIMITIVE_GETTER_WITH_CAST( L2StandAloneMuon_v1, float, double,
+ pt )
+ AUXSTORE_PRIMITIVE_GETTER_WITH_CAST( L2StandAloneMuon_v1, float, double,
+ eta )
+ AUXSTORE_PRIMITIVE_GETTER_WITH_CAST( L2StandAloneMuon_v1, float, double,
+ phi )
+
+ double L2StandAloneMuon_v1::m() const {
+
+ return 105.6583715;
+ }
+
+ double L2StandAloneMuon_v1::e() const {
+
+ return p4().M();
+ }
+
+ double L2StandAloneMuon_v1::rapidity() const {
+
+ return p4().Rapidity();
+ }
+
+ const L2StandAloneMuon_v1::FourMom_t& L2StandAloneMuon_v1::p4() const {
+
+ // Update the cached object if necessary:
+ if( ! m_p4Cached ) {
+ m_p4Cached = true;
+ m_p4.SetPtEtaPhiM( pt(), eta(), phi(), m() );
+ }
+
+ // Return the cached object:
+ return m_p4;
+ }
+
+ Type::ObjectType L2StandAloneMuon_v1::type() const {
+
+ // Create some trigger types in xAODBase in the next round...
+ return Type::Other;
+ }
+
+ //
+ /////////////////////////////////////////////////////////////////////////////
+
+ /////////////////////////////////////////////////////////////////////////////
+ //
+ // Implementation of the 4-momentum setter functions
+ //
+
+ void L2StandAloneMuon_v1::setPt( float pt ) {
+
+ static Accessor< float > acc( "pt" );
+ acc( *this ) = pt;
+ m_p4Cached = false;
+ return;
+ }
+
+ void L2StandAloneMuon_v1::setEta( float eta ) {
+
+ static Accessor< float > acc( "eta" );
+ acc( *this ) = eta;
+ m_p4Cached = false;
+ return;
+ }
+
+ void L2StandAloneMuon_v1::setPhi( float phi ) {
+
+ static Accessor< float > acc( "phi" );
+ acc( *this ) = phi;
+ m_p4Cached = false;
+ return;
+ }
+
+ //
+ /////////////////////////////////////////////////////////////////////////////
+
+ /////////////////////////////////////////////////////////////////////////////
+ //
+ // Implementation of the LVL2 muon specific functions
+ //
+ /////////////////////////////////////////////////////////////////////////////
+
+ /////////////////////////////////////////////////////////////////////////////
+ ///
+ /// Set and get methods for the outputs of L2 muon standalone muon algorithm
+ ///
+ AUXSTORE_PRIMITIVE_SETTER_AND_GETTER( L2StandAloneMuon_v1, uint32_t,
+ roiWord, setRoIWord )
+ AUXSTORE_PRIMITIVE_SETTER_AND_GETTER( L2StandAloneMuon_v1, int,
+ sAddress, setSAddress )
+ AUXSTORE_PRIMITIVE_SETTER_AND_GETTER( L2StandAloneMuon_v1, float,
+ rMS, setRMS )
+ AUXSTORE_PRIMITIVE_SETTER_AND_GETTER( L2StandAloneMuon_v1, float,
+ etaMS, setEtaMS )
+ AUXSTORE_PRIMITIVE_SETTER_AND_GETTER( L2StandAloneMuon_v1, float,
+ phiMS, setPhiMS )
+ AUXSTORE_PRIMITIVE_SETTER_AND_GETTER( L2StandAloneMuon_v1, float,
+ dirPhiMS, setDirPhiMS )
+ AUXSTORE_PRIMITIVE_SETTER_AND_GETTER( L2StandAloneMuon_v1, float,
+ zMS, setZMS )
+ AUXSTORE_PRIMITIVE_SETTER_AND_GETTER( L2StandAloneMuon_v1, float,
+ dirZMS, setDirZMS )
+ AUXSTORE_PRIMITIVE_SETTER_AND_GETTER( L2StandAloneMuon_v1, float,
+ beta, setBeta )
+ AUXSTORE_PRIMITIVE_SETTER_AND_GETTER( L2StandAloneMuon_v1, float,
+ barrelRadius, setBarrelRadius )
+ AUXSTORE_PRIMITIVE_SETTER_AND_GETTER( L2StandAloneMuon_v1, float,
+ barrelSagitta, setBarrelSagitta )
+ AUXSTORE_PRIMITIVE_SETTER_AND_GETTER( L2StandAloneMuon_v1, float,
+ endcapAlpha, setEndcapAlpha )
+ AUXSTORE_PRIMITIVE_SETTER_AND_GETTER( L2StandAloneMuon_v1, float,
+ endcapBeta, setEndcapBeta )
+ AUXSTORE_PRIMITIVE_SETTER_AND_GETTER( L2StandAloneMuon_v1, float,
+ endcapRadius, setEndcapRadius )
+ AUXSTORE_PRIMITIVE_SETTER_AND_GETTER( L2StandAloneMuon_v1, float,
+ slopeInner, setSlopeInner )
+ AUXSTORE_PRIMITIVE_SETTER_AND_GETTER( L2StandAloneMuon_v1, float,
+ interceptInner, setInterceptInner )
+ AUXSTORE_PRIMITIVE_SETTER_AND_GETTER( L2StandAloneMuon_v1, float,
+ deltaR, setDeltaR )
+ AUXSTORE_PRIMITIVE_SETTER_AND_GETTER( L2StandAloneMuon_v1, float,
+ etaMap, setEtaMap )
+ AUXSTORE_PRIMITIVE_SETTER_AND_GETTER( L2StandAloneMuon_v1, float,
+ phiMap, setPhiMap )
+ AUXSTORE_PRIMITIVE_SETTER_AND_GETTER( L2StandAloneMuon_v1, int,
+ etaBin, setEtaBin )
+ AUXSTORE_PRIMITIVE_SETTER_AND_GETTER( L2StandAloneMuon_v1, int,
+ phiBin, setPhiBin )
+ AUXSTORE_PRIMITIVE_SETTER_AND_GETTER( L2StandAloneMuon_v1, int,
+ isTgcFailure, setIsTgcFailure )
+ AUXSTORE_PRIMITIVE_SETTER_AND_GETTER( L2StandAloneMuon_v1, int,
+ isRpcFailure, setIsRpcFailure )
+ AUXSTORE_PRIMITIVE_SETTER_AND_GETTER( L2StandAloneMuon_v1, float,
+ deltaEta, setDeltaEta )
+ AUXSTORE_PRIMITIVE_SETTER_AND_GETTER( L2StandAloneMuon_v1, float,
+ deltaPhi, setDeltaPhi )
+ //
+ /////////////////////////////////////////////////////////////////////////////
+
+ /////////////////////////////////////////////////////////////////////////////
+ ///
+ /// Object for accessing the superPointR variable
+ ///
+ static SG::AuxElement::Accessor< std::vector< float > > sprAcc( "superPointR" );
+ /// Object for accessing the superPointZ variable
+ static SG::AuxElement::Accessor< std::vector< float > > spzAcc( "superPointZ" );
+ /// Object for accessing the superPointSlope variable
+ static SG::AuxElement::Accessor< std::vector< float > > spsAcc( "superPointSlope" );
+ /// Object for accessing the superPointIntercept variable
+ static SG::AuxElement::Accessor< std::vector< float > > spiAcc( "superPointIntercept" );
+ /// Object for accessing the superPointChi2 variable
+ static SG::AuxElement::Accessor< std::vector< float > > spcAcc( "superPointChi2" );
+
+ /// Get superPoint properties
+ float L2StandAloneMuon_v1::superPointR( int chamber ) const {
+ if( chamber >= 0 && sprAcc( *this ).size() > (unsigned int)chamber ) {
+ return sprAcc( *this ).at( chamber );
+ } else {
+ return 0.;
+ }
+ }
+
+ float L2StandAloneMuon_v1::superPointZ( int chamber ) const {
+ if( chamber >= 0 && spzAcc( *this ).size() > (unsigned int)chamber ) {
+ return spzAcc( *this ).at( chamber );
+ } else {
+ return 0.;
+ }
+ }
+
+ float L2StandAloneMuon_v1::superPointSlope( int chamber ) const {
+ if( chamber >= 0 && spsAcc( *this ).size() > (unsigned int)chamber ) {
+ return spsAcc( *this ).at( chamber );
+ } else {
+ return 0.;
+ }
+ }
+
+ float L2StandAloneMuon_v1::superPointIntercept( int chamber ) const {
+ if( chamber >= 0 && spiAcc( *this ).size() > (unsigned int)chamber ) {
+ return spiAcc( *this ).at( chamber );
+ } else {
+ return 0.;
+ }
+ }
+
+ float L2StandAloneMuon_v1::superPointChi2( int chamber ) const {
+ if( chamber >= 0 && spcAcc( *this ).size() > (unsigned int)chamber ) {
+ return spcAcc( *this ).at( chamber );
+ } else {
+ return 0.;
+ }
+ }
+
+ /// Set superPoint properties
+ void L2StandAloneMuon_v1::setSuperPoint( int chamber, float r, float z,
+ float slope, float intercept, float chi2 ) {
+
+ // Make sure that the variables are big enough:
+ if( sprAcc( *this ).size() < L2MuonParameters::Chamber::MaxChamber ) {
+ sprAcc( *this ).resize( L2MuonParameters::Chamber::MaxChamber, 0.0 );
+ }
+ if( spzAcc( *this ).size() < L2MuonParameters::Chamber::MaxChamber ) {
+ spzAcc( *this ).resize( L2MuonParameters::Chamber::MaxChamber, 0.0 );
+ }
+ if( spsAcc( *this ).size() < L2MuonParameters::Chamber::MaxChamber ) {
+ spsAcc( *this ).resize( L2MuonParameters::Chamber::MaxChamber, 0.0 );
+ }
+ if( spiAcc( *this ).size() < L2MuonParameters::Chamber::MaxChamber ) {
+ spiAcc( *this ).resize( L2MuonParameters::Chamber::MaxChamber, 0.0 );
+ }
+ if( spcAcc( *this ).size() < L2MuonParameters::Chamber::MaxChamber ) {
+ spcAcc( *this ).resize( L2MuonParameters::Chamber::MaxChamber, 0.0 );
+ }
+
+ if (chamber >=0 && chamber < L2MuonParameters::Chamber::MaxChamber ) {
+ // Set the variables:
+ sprAcc( *this ).at( chamber ) = r;
+ spzAcc( *this ).at( chamber ) = z;
+ spsAcc( *this ).at( chamber ) = slope;
+ spiAcc( *this ).at( chamber ) = intercept;
+ spcAcc( *this ).at( chamber ) = chi2;
+ }
+
+ return;
+ }
+
+ ///
+ /////////////////////////////////////////////////////////////////////////////
+
+ /////////////////////////////////////////////////////////////////////////////
+ /// Below are detailed information
+ /////////////////////////////////////////////////////////////////////////////
+
+ /////////////////////////////////////////////////////////////////////////////
+ /// L1 information
+ AUXSTORE_PRIMITIVE_SETTER_AND_GETTER( L2StandAloneMuon_v1, int,
+ algoId, setAlgoId )
+ AUXSTORE_PRIMITIVE_SETTER_AND_GETTER( L2StandAloneMuon_v1, uint32_t,
+ teId, setTeId )
+ AUXSTORE_PRIMITIVE_SETTER_AND_GETTER( L2StandAloneMuon_v1, uint32_t,
+ lvl1Id, setLvl1Id )
+ AUXSTORE_PRIMITIVE_SETTER_AND_GETTER( L2StandAloneMuon_v1, uint32_t,
+ lumiBlock, setLumiBlock )
+ AUXSTORE_PRIMITIVE_SETTER_AND_GETTER( L2StandAloneMuon_v1, uint32_t,
+ muonDetMask, setMuonDetMask )
+ AUXSTORE_PRIMITIVE_SETTER_AND_GETTER( L2StandAloneMuon_v1, uint32_t,
+ roiId, setRoiId )
+ AUXSTORE_PRIMITIVE_SETTER_AND_GETTER( L2StandAloneMuon_v1, uint32_t,
+ roiSystem, setRoiSystem )
+ AUXSTORE_PRIMITIVE_SETTER_AND_GETTER( L2StandAloneMuon_v1, uint32_t,
+ roiSubsystem, setRoiSubsystem )
+ AUXSTORE_PRIMITIVE_SETTER_AND_GETTER( L2StandAloneMuon_v1, uint32_t,
+ roiSector, setRoiSector )
+ AUXSTORE_PRIMITIVE_SETTER_AND_GETTER( L2StandAloneMuon_v1, uint32_t,
+ roiNumber, setRoiNumber )
+ AUXSTORE_PRIMITIVE_SETTER_AND_GETTER( L2StandAloneMuon_v1, uint32_t,
+ roiThreshold, setRoiThreshold )
+ AUXSTORE_PRIMITIVE_SETTER_AND_GETTER( L2StandAloneMuon_v1, uint32_t,
+ roiEta, setRoiEta )
+ AUXSTORE_PRIMITIVE_SETTER_AND_GETTER( L2StandAloneMuon_v1, uint32_t,
+ roiPhi, setRoiPhi )
+ ///
+ /////////////////////////////////////////////////////////////////////////////
+
+ /////////////////////////////////////////////////////////////////////////////
+ /// Set and get pT from different algorithms
+ AUXSTORE_PRIMITIVE_SETTER_AND_GETTER( L2StandAloneMuon_v1, float,
+ ptBarelRadius, setPtBarelRadius )
+ AUXSTORE_PRIMITIVE_SETTER_AND_GETTER( L2StandAloneMuon_v1, float,
+ ptBarelSagitta, setPtBarelSagitta )
+ AUXSTORE_PRIMITIVE_SETTER_AND_GETTER( L2StandAloneMuon_v1, float,
+ ptEndcapAlpha, setPtEndcapAlpha )
+ AUXSTORE_PRIMITIVE_SETTER_AND_GETTER( L2StandAloneMuon_v1, float,
+ ptEndcapBeta, setPtEndcapBeta )
+ AUXSTORE_PRIMITIVE_SETTER_AND_GETTER( L2StandAloneMuon_v1, float,
+ ptEndcapRadius, setPtEndcapRadius )
+ ///
+ /////////////////////////////////////////////////////////////////////////////
+
+ /////////////////////////////////////////////////////////////////////////////
+ ///
+ /// Object for accessing the road information
+ ///
+ /// chamber types
+ static SG::AuxElement::Accessor< std::vector< int > >
+ ct1nAcc( "chamberType1Normal" );
+ static SG::AuxElement::Accessor< std::vector< int > >
+ ct1oAcc( "chamberType1Overlap" );
+ static SG::AuxElement::Accessor< std::vector< int > >
+ ct2nAcc( "chamberType2Normal" );
+ static SG::AuxElement::Accessor< std::vector< int > >
+ ct2oAcc( "chamberType2Overlap" );
+
+ /// road slope and intercept
+ static SG::AuxElement::Accessor< std::vector< float > >
+ awnAcc( "roadAwNormal" );
+ static SG::AuxElement::Accessor< std::vector< float > >
+ awoAcc( "roadAwOverlap" );
+ static SG::AuxElement::Accessor< std::vector< float > >
+ bwnAcc( "roadBwNormal" );
+ static SG::AuxElement::Accessor< std::vector< float > >
+ bwoAcc( "roadBwOverlap" );
+
+ /// Z range
+ static SG::AuxElement::Accessor< std::vector< float > >
+ zminnAcc( "zMinNormal" );
+ static SG::AuxElement::Accessor< std::vector< float > >
+ zminoAcc( "zMinOverlap" );
+ static SG::AuxElement::Accessor< std::vector< float > >
+ zmaxnAcc( "zMaxNormal" );
+ static SG::AuxElement::Accessor< std::vector< float > >
+ zmaxoAcc( "zMaxOverlap" );
+
+ /// R range
+ static SG::AuxElement::Accessor< std::vector< float > >
+ rminnAcc( "rMinNormal" );
+ static SG::AuxElement::Accessor< std::vector< float > >
+ rminoAcc( "rMinOverlap" );
+ static SG::AuxElement::Accessor< std::vector< float > >
+ rmaxnAcc( "rMaxNormal" );
+ static SG::AuxElement::Accessor< std::vector< float > >
+ rmaxoAcc( "rMaxOverlap" );
+
+ /// Eta range
+ static SG::AuxElement::Accessor< std::vector< float > >
+ eminnAcc( "etaMinNormal" );
+ static SG::AuxElement::Accessor< std::vector< float > >
+ eminoAcc( "etaMinOverlap" );
+ static SG::AuxElement::Accessor< std::vector< float > >
+ emaxnAcc( "etaMaxNormal" );
+ static SG::AuxElement::Accessor< std::vector< float > >
+ emaxoAcc( "etaMaxOverlap" );
+
+ ///
+ /// Get road properties
+ ///
+ /// Chamber types
+ int L2StandAloneMuon_v1::chamberType1( int station, int sector ) const {
+
+ if ( station < 0 ) return 0;
+
+ if ( sector == 0 ) {
+ /// normal sector
+
+ if ( ct1nAcc( *this ).size() > (unsigned int)station ) {
+ return ct1nAcc( *this ).at( station );
+ } else {
+ return 0;
+ }
+
+ } else if ( sector == 1 ) {
+ /// overlap sector
+
+ if ( ct1oAcc( *this ).size() > (unsigned int)station ) {
+ return ct1oAcc( *this ).at( station );
+ } else {
+ return 0;
+ }
+
+ }
+
+ return 0;
+ }
+
+ int L2StandAloneMuon_v1::chamberType2( int station, int sector ) const {
+
+ if ( station < 0 ) return 0;
+
+ if ( sector == 0 ) {
+ /// normal sector
+ if ( ct2nAcc( *this ).size() > (unsigned int)station ) {
+ return ct2nAcc( *this ).at( station );
+ } else {
+ return 0;
+ }
+
+ } else if ( sector == 1 ) {
+ /// overlap sector
+
+ if ( ct2oAcc( *this ).size() > (unsigned int)station ) {
+ return ct2oAcc( *this ).at( station );
+ } else {
+ return 0;
+ }
+
+ }
+
+ return 0;
+ }
+
+ /// Road slope
+ float L2StandAloneMuon_v1::roadAw( int station, int sector ) const {
+
+ if ( station < 0 ) return 0;
+
+ if ( sector == 0 ) {
+ /// normal sector
+ if ( awnAcc( *this ).size() > (unsigned int)station ) {
+ return awnAcc( *this ).at( station );
+ } else {
+ return 0.;
+ }
+
+ } else if ( sector == 1 ) {
+ /// overlap sector
+
+ if ( awoAcc( *this ).size() > (unsigned int)station ) {
+ return awoAcc( *this ).at( station );
+ } else {
+ return 0.;
+ }
+
+ }
+
+ return 0.;
+ }
+
+ /// Road intercept
+ float L2StandAloneMuon_v1::roadBw( int station, int sector ) const {
+
+ if ( station < 0 ) return 0;
+
+ if ( sector == 0 ) {
+ /// normal sector
+ if ( bwnAcc( *this ).size() > (unsigned int)station ) {
+ return bwnAcc( *this ).at( station );
+ } else {
+ return 0.;
+ }
+
+ } else if ( sector == 1 ) {
+ /// overlap sector
+
+ if ( bwoAcc( *this ).size() > (unsigned int)station ) {
+ return bwoAcc( *this ).at( station );
+ } else {
+ return 0.;
+ }
+
+ }
+
+ return 0.;
+ }
+
+ /// Z range
+ float L2StandAloneMuon_v1::zMin( int station, int sector ) const {
+
+ if ( station < 0 ) return 0;
+
+ if ( sector == 0 ) {
+ /// normal sector
+ if ( zminnAcc( *this ).size() > (unsigned int)station ) {
+ return zminnAcc( *this ).at( station );
+ } else {
+ return 0.;
+ }
+
+ } else if ( sector == 1 ) {
+ /// overlap sector
+
+ if ( zminoAcc( *this ).size() > (unsigned int)station ) {
+ return zminoAcc( *this ).at( station );
+ } else {
+ return 0.;
+ }
+
+ }
+
+ return 0.;
+ }
+
+ float L2StandAloneMuon_v1::zMax( int station, int sector ) const {
+
+ if ( station < 0 ) return 0;
+
+ if ( sector == 0 ) {
+ /// normal sector
+ if ( zmaxnAcc( *this ).size() > (unsigned int)station ) {
+ return zmaxnAcc( *this ).at( station );
+ } else {
+ return 0.;
+ }
+
+ } else if ( sector == 1 ) {
+ /// overlap sector
+
+ if ( zmaxoAcc( *this ).size() > (unsigned int)station ) {
+ return zmaxoAcc( *this ).at( station );
+ } else {
+ return 0.;
+ }
+
+ }
+
+ return 0.;
+ }
+
+ /// R range
+ float L2StandAloneMuon_v1::rMin( int station, int sector ) const {
+
+ if ( station < 0 ) return 0;
+
+ if ( sector == 0 ) {
+ /// normal sector
+ if ( rminnAcc( *this ).size() > (unsigned int)station ) {
+ return rminnAcc( *this ).at( station );
+ } else {
+ return 0.;
+ }
+
+ } else if ( sector == 1 ) {
+ /// overlap sector
+
+ if ( rminoAcc( *this ).size() > (unsigned int)station ) {
+ return rminoAcc( *this ).at( station );
+ } else {
+ return 0.;
+ }
+
+ }
+
+ return 0.;
+ }
+
+ float L2StandAloneMuon_v1::rMax( int station, int sector ) const {
+
+ if ( station < 0 ) return 0;
+
+ if ( sector == 0 ) {
+ /// normal sector
+ if ( rmaxnAcc( *this ).size() > (unsigned int)station ) {
+ return rmaxnAcc( *this ).at( station );
+ } else {
+ return 0.;
+ }
+
+ } else if ( sector == 1 ) {
+ /// overlap sector
+
+ if ( rmaxoAcc( *this ).size() > (unsigned int)station ) {
+ return rmaxoAcc( *this ).at( station );
+ } else {
+ return 0.;
+ }
+
+ }
+
+ return 0.;
+ }
+
+ /// Eta range
+ float L2StandAloneMuon_v1::etaMin( int station, int sector ) const {
+
+ if ( station < 0 ) return 0;
+
+ if ( sector == 0 ) {
+ /// normal sector
+ if ( eminnAcc( *this ).size() > (unsigned int)station ) {
+ return eminnAcc( *this ).at( station );
+ } else {
+ return 0.;
+ }
+
+ } else if ( sector == 1 ) {
+ /// overlap sector
+
+ if ( eminoAcc( *this ).size() > (unsigned int)station ) {
+ return eminoAcc( *this ).at( station );
+ } else {
+ return 0.;
+ }
+
+ }
+
+ return 0.;
+ }
+
+ float L2StandAloneMuon_v1::etaMax( int station, int sector ) const {
+
+ if ( station < 0 ) return 0;
+
+ if ( sector == 0 ) {
+ /// normal sector
+ if ( emaxnAcc( *this ).size() > (unsigned int)station ) {
+ return emaxnAcc( *this ).at( station );
+ } else {
+ return 0.;
+ }
+
+ } else if ( sector == 1 ) {
+ /// overlap sector
+
+ if ( emaxoAcc( *this ).size() > (unsigned int)station ) {
+ return emaxoAcc( *this ).at( station );
+ } else {
+ return 0.;
+ }
+
+ }
+
+ return 0.;
+ }
+
+
+ /// Set road properties
+
+ /// Chamber types
+ void L2StandAloneMuon_v1::setChamberType1( int station, int sector, int chamberType ) {
+
+ // Make sure that the variables are big enough:
+ if( ct1nAcc( *this ).size() < L2MuonParameters::Chamber::MaxChamber ) {
+ ct1nAcc( *this ).resize( L2MuonParameters::Chamber::MaxChamber, 0.0 );
+ }
+ if( ct1oAcc( *this ).size() < L2MuonParameters::Chamber::MaxChamber ) {
+ ct1oAcc( *this ).resize( L2MuonParameters::Chamber::MaxChamber, 0.0 );
+ }
+
+ // Make sure that the variables are big enough:
+ if ( station < 0 || station >= L2MuonParameters::Chamber::MaxChamber ) return;
+ if ( sector < 0 || sector > 1 ) return;
+
+ if (sector == 0 ) {
+ /// Normal sector
+ ct1nAcc( *this ).at( station ) = chamberType;
+
+ } else if ( sector == 1 ) {
+ /// Overlap sector
+ ct1oAcc( *this ).at( station ) = chamberType;
+
+ }
+
+ return;
+ }
+
+ void L2StandAloneMuon_v1::setChamberType2( int station, int sector, int chamberType ) {
+
+ // Make sure that the variables are big enough:
+ if( ct2nAcc( *this ).size() < L2MuonParameters::Chamber::MaxChamber ) {
+ ct2nAcc( *this ).resize( L2MuonParameters::Chamber::MaxChamber, 0.0 );
+ }
+ if( ct2oAcc( *this ).size() < L2MuonParameters::Chamber::MaxChamber ) {
+ ct2oAcc( *this ).resize( L2MuonParameters::Chamber::MaxChamber, 0.0 );
+ }
+
+ // Make sure that the variables are big enough:
+ if ( station < 0 || station >= L2MuonParameters::Chamber::MaxChamber ) return;
+ if ( sector < 0 || sector > 1 ) return;
+
+ if (sector == 0 ) {
+ /// Normal sector
+ ct2nAcc( *this ).at( station ) = chamberType;
+
+ } else if ( sector == 1 ) {
+ /// Overlap sector
+ ct2oAcc( *this ).at( station ) = chamberType;
+
+ }
+
+ return;
+ }
+
+ /// Road
+ void L2StandAloneMuon_v1::setRoad( int station, int sector, float aw, float bw ) {
+
+ // Make sure that the variables are big enough:
+ if( awnAcc( *this ).size() < L2MuonParameters::Chamber::MaxChamber ) {
+ awnAcc( *this ).resize( L2MuonParameters::Chamber::MaxChamber, 0.0 );
+ }
+ if( bwnAcc( *this ).size() < L2MuonParameters::Chamber::MaxChamber ) {
+ bwnAcc( *this ).resize( L2MuonParameters::Chamber::MaxChamber, 0.0 );
+ }
+ if( awoAcc( *this ).size() < L2MuonParameters::Chamber::MaxChamber ) {
+ awoAcc( *this ).resize( L2MuonParameters::Chamber::MaxChamber, 0.0 );
+ }
+ if( bwoAcc( *this ).size() < L2MuonParameters::Chamber::MaxChamber ) {
+ bwoAcc( *this ).resize( L2MuonParameters::Chamber::MaxChamber, 0.0 );
+ }
+
+ // Make sure that the variables are big enough:
+ if ( station < 0 || station >= L2MuonParameters::Chamber::MaxChamber ) return;
+ if ( sector < 0 || sector > 1 ) return;
+
+ if (sector == 0 ) {
+ /// Normal sector
+
+ /// Slope
+ awnAcc( *this ).at( station ) = aw;
+
+ /// Intercept
+ bwnAcc( *this ).at( station ) = bw;
+
+ } else if ( sector == 1 ) {
+ /// Overlap sector
+
+ /// Slope
+ awoAcc( *this ).at( station ) = aw;
+
+ /// Intercept
+ bwoAcc( *this ).at( station ) = bw;
+
+ }
+
+ return;
+ }
+
+ /// Z range
+ void L2StandAloneMuon_v1::setRegionZ( int station, int sector, float min, float max ) {
+
+ // Make sure that the variables are big enough:
+ if( zminnAcc( *this ).size() < L2MuonParameters::Chamber::MaxChamber ) {
+ zminnAcc( *this ).resize( L2MuonParameters::Chamber::MaxChamber, 0.0 );
+ }
+ if( zmaxnAcc( *this ).size() < L2MuonParameters::Chamber::MaxChamber ) {
+ zmaxnAcc( *this ).resize( L2MuonParameters::Chamber::MaxChamber, 0.0 );
+ }
+ if( zminoAcc( *this ).size() < L2MuonParameters::Chamber::MaxChamber ) {
+ zminoAcc( *this ).resize( L2MuonParameters::Chamber::MaxChamber, 0.0 );
+ }
+ if( zmaxoAcc( *this ).size() < L2MuonParameters::Chamber::MaxChamber ) {
+ zmaxoAcc( *this ).resize( L2MuonParameters::Chamber::MaxChamber, 0.0 );
+ }
+
+ // Make sure that the variables are big enough:
+ if ( station < 0 || station >= L2MuonParameters::Chamber::MaxChamber ) return;
+ if ( sector < 0 || sector > 1 ) return;
+
+ if (sector == 0 ) {
+ /// Normal sector
+
+ /// minimum Z
+ zminnAcc( *this ).at( station ) = min;
+
+ /// mazimum Z
+ zmaxnAcc( *this ).at( station ) = max;
+
+ } else if ( sector == 1 ) {
+ /// Overlap sector
+
+ /// minimum Z
+ zminoAcc( *this ).at( station ) = min;
+
+ /// maximum Z
+ zmaxoAcc( *this ).at( station ) = max;
+
+ }
+
+ return;
+ }
+
+ /// R range
+ void L2StandAloneMuon_v1::setRegionR( int station, int sector, float min, float max ) {
+
+ // Make sure that the variables are big enough:
+ if( rminnAcc( *this ).size() < L2MuonParameters::Chamber::MaxChamber ) {
+ rminnAcc( *this ).resize( L2MuonParameters::Chamber::MaxChamber, 0.0 );
+ }
+ if( rmaxnAcc( *this ).size() < L2MuonParameters::Chamber::MaxChamber ) {
+ rmaxnAcc( *this ).resize( L2MuonParameters::Chamber::MaxChamber, 0.0 );
+ }
+ if( rminoAcc( *this ).size() < L2MuonParameters::Chamber::MaxChamber ) {
+ rminoAcc( *this ).resize( L2MuonParameters::Chamber::MaxChamber, 0.0 );
+ }
+ if( rmaxoAcc( *this ).size() < L2MuonParameters::Chamber::MaxChamber ) {
+ rmaxoAcc( *this ).resize( L2MuonParameters::Chamber::MaxChamber, 0.0 );
+ }
+
+ // Make sure that the variables are big enough:
+ if ( station < 0 || station >= L2MuonParameters::Chamber::MaxChamber ) return;
+ if ( sector < 0 || sector > 1 ) return;
+
+ if (sector == 0 ) {
+ /// Normal sector
+
+ /// minimum R
+ rminnAcc( *this ).at( station ) = min;
+
+ /// maximum R
+ rmaxnAcc( *this ).at( station ) = max;
+
+ } else if ( sector == 1 ) {
+ /// Overlap sector
+
+ /// minimum R
+ rminoAcc( *this ).at( station ) = min;
+
+ /// maximum R
+ rmaxoAcc( *this ).at( station ) = max;
+
+ }
+
+ return;
+ }
+
+ /// Eta range
+ void L2StandAloneMuon_v1::setRegionEta( int station, int sector, float min, float max ) {
+
+ // Make sure that the variables are big enough:
+ if( eminnAcc( *this ).size() < L2MuonParameters::Chamber::MaxChamber ) {
+ eminnAcc( *this ).resize( L2MuonParameters::Chamber::MaxChamber, 0.0 );
+ }
+ if( emaxnAcc( *this ).size() < L2MuonParameters::Chamber::MaxChamber ) {
+ emaxnAcc( *this ).resize( L2MuonParameters::Chamber::MaxChamber, 0.0 );
+ }
+ if( eminoAcc( *this ).size() < L2MuonParameters::Chamber::MaxChamber ) {
+ eminoAcc( *this ).resize( L2MuonParameters::Chamber::MaxChamber, 0.0 );
+ }
+ if( emaxoAcc( *this ).size() < L2MuonParameters::Chamber::MaxChamber ) {
+ emaxoAcc( *this ).resize( L2MuonParameters::Chamber::MaxChamber, 0.0 );
+ }
+
+ // Make sure that the variables are big enough:
+ if ( station < 0 || station >= L2MuonParameters::Chamber::MaxChamber ) return;
+ if ( sector < 0 || sector > 1 ) return;
+
+ if (sector == 0 ) {
+ /// Normal sector
+
+ /// minimum eta
+ eminnAcc( *this ).at( station ) = min;
+
+ /// maximum eta
+ emaxnAcc( *this ).at( station ) = max;
+
+ } else if ( sector == 1 ) {
+ /// Overlap sector
+
+ /// minimum eta
+ eminoAcc( *this ).at( station ) = min;
+
+ /// maximum eta
+ emaxoAcc( *this ).at( station ) = max;
+
+ }
+
+ return;
+ }
+
+ ///
+ /////////////////////////////////////////////////////////////////////////////
+
+ /////////////////////////////////////////////////////////////////////////////
+ ///
+ /// Get the results of TGC fit
+ AUXSTORE_PRIMITIVE_SETTER_AND_GETTER( L2StandAloneMuon_v1, float, tgcPt, setTgcPt )
+
+ AUXSTORE_PRIMITIVE_GETTER( L2StandAloneMuon_v1, float, tgcInnEta )
+ AUXSTORE_PRIMITIVE_GETTER( L2StandAloneMuon_v1, float, tgcInnPhi )
+ AUXSTORE_PRIMITIVE_GETTER( L2StandAloneMuon_v1, float, tgcInnR )
+ AUXSTORE_PRIMITIVE_GETTER( L2StandAloneMuon_v1, float, tgcInnZ )
+
+ AUXSTORE_PRIMITIVE_GETTER( L2StandAloneMuon_v1, float, tgcInnRhoStd )
+ AUXSTORE_PRIMITIVE_GETTER( L2StandAloneMuon_v1, long, tgcInnRhoN )
+ AUXSTORE_PRIMITIVE_GETTER( L2StandAloneMuon_v1, float, tgcInnPhiStd )
+ AUXSTORE_PRIMITIVE_GETTER( L2StandAloneMuon_v1, long, tgcInnPhiN )
+
+ AUXSTORE_PRIMITIVE_GETTER( L2StandAloneMuon_v1, float, tgcMid1Eta )
+ AUXSTORE_PRIMITIVE_GETTER( L2StandAloneMuon_v1, float, tgcMid1Phi )
+ AUXSTORE_PRIMITIVE_GETTER( L2StandAloneMuon_v1, float, tgcMid1R )
+ AUXSTORE_PRIMITIVE_GETTER( L2StandAloneMuon_v1, float, tgcMid1Z )
+
+ AUXSTORE_PRIMITIVE_GETTER( L2StandAloneMuon_v1, float, tgcMid2Eta )
+ AUXSTORE_PRIMITIVE_GETTER( L2StandAloneMuon_v1, float, tgcMid2Phi )
+ AUXSTORE_PRIMITIVE_GETTER( L2StandAloneMuon_v1, float, tgcMid2R )
+ AUXSTORE_PRIMITIVE_GETTER( L2StandAloneMuon_v1, float, tgcMid2Z )
+
+ AUXSTORE_PRIMITIVE_GETTER( L2StandAloneMuon_v1, float, tgcMidRhoChi2 )
+ AUXSTORE_PRIMITIVE_GETTER( L2StandAloneMuon_v1, long, tgcMidRhoN )
+ AUXSTORE_PRIMITIVE_GETTER( L2StandAloneMuon_v1, float, tgcMidPhiChi2 )
+ AUXSTORE_PRIMITIVE_GETTER( L2StandAloneMuon_v1, long, tgcMidPhiN )
+
+ /// Set the results of TGC fit
+ void L2StandAloneMuon_v1::setTgcInn( float eta, float phi, float r, float z ) {
+
+ static Accessor< float > tieAcc( "tgcInnEta" );
+ static Accessor< float > tipAcc( "tgcInnPhi" );
+ static Accessor< float > tirAcc( "tgcInnR" );
+ static Accessor< float > tizAcc( "tgcInnZ" );
+
+ tieAcc( *this ) = eta;
+ tipAcc( *this ) = phi;
+ tirAcc( *this ) = r;
+ tizAcc( *this ) = z;
+
+ return;
+ }
+
+ void L2StandAloneMuon_v1::setTgcInnF( float rhoStd, long rhoN, float phiStd, long phiN ) {
+
+ static Accessor< float > tirsAcc( "tgcInnRhoStd" );
+ static Accessor< long > tirnAcc( "tgcInnRhoN" );
+ static Accessor< float > tipsAcc( "tgcInnPhiStd" );
+ static Accessor< long > tipnAcc( "tgcInnPhiN" );
+
+ tirsAcc( *this ) = rhoStd;
+ tirnAcc( *this ) = rhoN;
+ tipsAcc( *this ) = phiStd;
+ tipnAcc( *this ) = phiN;
+
+ return;
+ }
+
+ void L2StandAloneMuon_v1::setTgcMid1( float eta, float phi, float r, float z ) {
+
+ static Accessor< float > tm1eAcc( "tgcMid1Eta" );
+ static Accessor< float > tm1pAcc( "tgcMid1Phi" );
+ static Accessor< float > tm1rAcc( "tgcMid1R" );
+ static Accessor< float > tm1zAcc( "tgcMid1Z" );
+
+ tm1eAcc( *this ) = eta;
+ tm1pAcc( *this ) = phi;
+ tm1rAcc( *this ) = r;
+ tm1zAcc( *this ) = z;
+
+ return;
+ }
+
+ void L2StandAloneMuon_v1::setTgcMid2( float eta, float phi, float r, float z ) {
+
+ static Accessor< float > tm2eAcc( "tgcMid2Eta" );
+ static Accessor< float > tm2pAcc( "tgcMid2Phi" );
+ static Accessor< float > tm2rAcc( "tgcMid2R" );
+ static Accessor< float > tm2zAcc( "tgcMid2Z" );
+
+ tm2eAcc( *this ) = eta;
+ tm2pAcc( *this ) = phi;
+ tm2rAcc( *this ) = r;
+ tm2zAcc( *this ) = z;
+
+ return;
+ }
+
+ void L2StandAloneMuon_v1::setTgcMidF( float rhoChi2, long rhoN, float phiChi2, long phiN ) {
+
+ static Accessor< float > tmrcAcc( "tgcMidRhoChi2" );
+ static Accessor< long > tmrnAcc( "tgcMidRhoN" );
+ static Accessor< float > tmpcAcc( "tgcMidPhiChi2" );
+ static Accessor< long > tmpnAcc( "tgcMidPhiN" );
+
+ tmrcAcc( *this ) = rhoChi2;
+ tmrnAcc( *this ) = rhoN;
+ tmpcAcc( *this ) = phiChi2;
+ tmpnAcc( *this ) = phiN;
+
+ return;
+ }
+ ///
+ /////////////////////////////////////////////////////////////////////////////
+
+ /////////////////////////////////////////////////////////////////////////////
+ ///
+ /// Get the results of RPC fit
+ AUXSTORE_PRIMITIVE_GETTER( L2StandAloneMuon_v1, float, rpc1x)
+ AUXSTORE_PRIMITIVE_GETTER( L2StandAloneMuon_v1, float, rpc1y)
+ AUXSTORE_PRIMITIVE_GETTER( L2StandAloneMuon_v1, float, rpc1z)
+
+ AUXSTORE_PRIMITIVE_GETTER( L2StandAloneMuon_v1, float, rpc2x)
+ AUXSTORE_PRIMITIVE_GETTER( L2StandAloneMuon_v1, float, rpc2y)
+ AUXSTORE_PRIMITIVE_GETTER( L2StandAloneMuon_v1, float, rpc2z)
+
+ AUXSTORE_PRIMITIVE_GETTER( L2StandAloneMuon_v1, float, rpc3x)
+ AUXSTORE_PRIMITIVE_GETTER( L2StandAloneMuon_v1, float, rpc3y)
+ AUXSTORE_PRIMITIVE_GETTER( L2StandAloneMuon_v1, float, rpc3z)
+
+ /// Set the results of RPC fit
+ void L2StandAloneMuon_v1::setRpc1( float x, float y, float z ) {
+
+ static Accessor< float > r1xAcc( "rpc1x" );
+ static Accessor< float > r1yAcc( "rpc1y" );
+ static Accessor< float > r1zAcc( "rpc1z" );
+
+ r1xAcc( *this ) = x;
+ r1yAcc( *this ) = y;
+ r1zAcc( *this ) = z;
+
+ return;
+ }
+
+ void L2StandAloneMuon_v1::setRpc2( float x, float y, float z ) {
+
+ static Accessor< float > r2xAcc( "rpc2x" );
+ static Accessor< float > r2yAcc( "rpc2y" );
+ static Accessor< float > r2zAcc( "rpc2z" );
+
+ r2xAcc( *this ) = x;
+ r2yAcc( *this ) = y;
+ r2zAcc( *this ) = z;
+
+ return;
+ }
+
+ void L2StandAloneMuon_v1::setRpc3( float x, float y, float z ) {
+
+ static Accessor< float > r3xAcc( "rpc3x" );
+ static Accessor< float > r3yAcc( "rpc3y" );
+ static Accessor< float > r3zAcc( "rpc3z" );
+
+ r3xAcc( *this ) = x;
+ r3yAcc( *this ) = y;
+ r3zAcc( *this ) = z;
+
+ return;
+ }
+
+ /////////////////////////////////////////////////////////////////////////////
+ ///
+ /// Object for accessing extenstion variables
+ static SG::AuxElement::Accessor< std::vector< uint32_t > > ext0Acc( "extension0" );
+ static SG::AuxElement::Accessor< std::vector< uint32_t > > ext1Acc( "extension1" );
+ static SG::AuxElement::Accessor< std::vector< uint32_t > > ext2Acc( "extension2" );
+ static SG::AuxElement::Accessor< std::vector< uint32_t > > ext3Acc( "extension3" );
+ static SG::AuxElement::Accessor< std::vector< uint32_t > > ext4Acc( "extension4" );
+ static SG::AuxElement::Accessor< std::vector< uint32_t > > ext5Acc( "extension5" );
+ static SG::AuxElement::Accessor< std::vector< uint32_t > > ext6Acc( "extension6" );
+ static SG::AuxElement::Accessor< std::vector< uint32_t > > ext7Acc( "extension7" );
+ static SG::AuxElement::Accessor< std::vector< uint32_t > > ext8Acc( "extension8" );
+ static SG::AuxElement::Accessor< std::vector< uint32_t > > ext9Acc( "extension9" );
+
+ /// Object for level 1 emulation info
+ static SG::AuxElement::Accessor< std::vector< uint32_t > > lvl1eAcc( "lvl1Emulation" );
+
+ /// Object for ROB info
+ static SG::AuxElement::Accessor< std::vector< uint32_t > > robidAcc( "robId" );
+ static SG::AuxElement::Accessor< std::vector< uint32_t > > robrmAcc( "removedRobId" );
+
+ /// Object for CSM info
+ static SG::AuxElement::Accessor< std::vector< uint32_t > > csmidAcc( "csmId" );
+ static SG::AuxElement::Accessor< std::vector< uint32_t > > csmszAcc( "csmSize" );
+ static SG::AuxElement::Accessor< std::vector< uint32_t > > csmerAcc( "csmError" );
+ static SG::AuxElement::Accessor< std::vector< uint32_t > > csmrmAcc( "removedCsmId" );
+
+ /// Object for accessing RPC pad hits
+ static SG::AuxElement::Accessor< std::vector< uint32_t > > padiAcc( "padHitOnlineId" );
+ static SG::AuxElement::Accessor< std::vector< uint32_t > > padcAcc( "padHitCode" );
+ static SG::AuxElement::Accessor< std::vector< float > > padxAcc( " padHitX" );
+ static SG::AuxElement::Accessor< std::vector< float > > padyAcc( " padHitY" );
+ static SG::AuxElement::Accessor< std::vector< float > > padzAcc( " padHitZ" );
+ static SG::AuxElement::Accessor< std::vector< float > > padrAcc( " padHitR" );
+ static SG::AuxElement::Accessor< std::vector< float > > padpAcc( " padHitP" );
+
+ /// Object for accessing TGC hits
+ static SG::AuxElement::Accessor< std::vector< float > > tirpAcc( "tgcInnRhoHitPhi" );
+ static SG::AuxElement::Accessor< std::vector< float > > tirrAcc( "tgcInnRhoHitR" );
+ static SG::AuxElement::Accessor< std::vector< float > > tirzAcc( "tgcInnRhoHitZ" );
+ static SG::AuxElement::Accessor< std::vector< float > > tirwAcc( "tgcInnRhoHitWidth" );
+ static SG::AuxElement::Accessor< std::vector< uint32_t > > tiriAcc( "tgcInnRhoHitInSeg" );
+ static SG::AuxElement::Accessor< std::vector< float > > tippAcc( "tgcInnPhiHitPhi" );
+ static SG::AuxElement::Accessor< std::vector< float > > tiprAcc( "tgcInnPhiHitR" );
+ static SG::AuxElement::Accessor< std::vector< float > > tipzAcc( "tgcInnPhiHitZ" );
+ static SG::AuxElement::Accessor< std::vector< float > > tipwAcc( "tgcInnPhiHitWidth" );
+ static SG::AuxElement::Accessor< std::vector< uint32_t > > tipiAcc( "tgcInnPhiHitInSeg" );
+ static SG::AuxElement::Accessor< std::vector< float > > tmrpAcc( "tgcMidRhoHitPhi" );
+ static SG::AuxElement::Accessor< std::vector< float > > tmrrAcc( "tgcMidRhoHitR" );
+ static SG::AuxElement::Accessor< std::vector< float > > tmrzAcc( "tgcMidRhoHitZ" );
+ static SG::AuxElement::Accessor< std::vector< float > > tmrwAcc( "tgcMidRhoHitWidth" );
+ static SG::AuxElement::Accessor< std::vector< uint32_t > > tmriAcc( "tgcMidRhoHitInSeg" );
+ static SG::AuxElement::Accessor< std::vector< float > > tmppAcc( "tgcMidPhiHitPhi" );
+ static SG::AuxElement::Accessor< std::vector< float > > tmprAcc( "tgcMidPhiHitR" );
+ static SG::AuxElement::Accessor< std::vector< float > > tmpzAcc( "tgcMidPhiHitZ" );
+ static SG::AuxElement::Accessor< std::vector< float > > tmpwAcc( "tgcMidPhiHitWidth" );
+ static SG::AuxElement::Accessor< std::vector< uint32_t > > tmpiAcc( "tgcMidPhiHitInEeg" );
+
+ /// Object for accessing the MDT tube variables
+ static SG::AuxElement::Accessor< std::vector< uint32_t > > mdtonAcc( "mdtHitOnlineId" );
+ static SG::AuxElement::Accessor< std::vector< uint32_t > > mdtoffAcc( "mdtHitOfflineId" );
+ static SG::AuxElement::Accessor< std::vector< int > > mdtcAcc( "mdtHitChamber" );
+ static SG::AuxElement::Accessor< std::vector< float > > mdtrAcc( "mdtHitR" );
+ static SG::AuxElement::Accessor< std::vector< float > > mdtzAcc( "mdtHitZ" );
+ static SG::AuxElement::Accessor< std::vector< float > > mdtresAcc( "mdtHitResidual" );
+ static SG::AuxElement::Accessor< std::vector< float > > mdttAcc( "mdtHitTime" );
+ static SG::AuxElement::Accessor< std::vector< float > > mdtspcAcc( "mdtHitSpace" );
+ static SG::AuxElement::Accessor< std::vector< float > > mdtsigAcc( "mdtHitSigma" );
+ ///
+ /////////////////////////////////////////////////////////////////////////////
+
+ /////////////////////////////////////////////////////////////////////////////
+ ///
+ /// Size of storage to be reserved
+ AUXSTORE_PRIMITIVE_GETTER( L2StandAloneMuon_v1, int, extensionCapacity )
+ AUXSTORE_PRIMITIVE_GETTER( L2StandAloneMuon_v1, int, robCapacity )
+ AUXSTORE_PRIMITIVE_GETTER( L2StandAloneMuon_v1, int, csmCapacity )
+ AUXSTORE_PRIMITIVE_GETTER( L2StandAloneMuon_v1, int, lvl1EmuCapacity )
+ AUXSTORE_PRIMITIVE_GETTER( L2StandAloneMuon_v1, int, rpcHitsCapacity )
+ AUXSTORE_PRIMITIVE_GETTER( L2StandAloneMuon_v1, int, tgcHitsCapacity )
+ AUXSTORE_PRIMITIVE_GETTER( L2StandAloneMuon_v1, int, mdtHitsCapacity )
+
+ /// Set size of extension stirage
+ void L2StandAloneMuon_v1::setExtensionCapacity( int value ) {
+
+ static Accessor< int > ecapAcc( "extensionCapacity" );
+ ecapAcc( *this ) = value;
+
+ if ( value > 0 ) {
+ ext0Acc( *this ).reserve( (unsigned int)value );
+ ext1Acc( *this ).reserve( (unsigned int)value );
+ ext2Acc( *this ).reserve( (unsigned int)value );
+ ext3Acc( *this ).reserve( (unsigned int)value );
+ ext4Acc( *this ).reserve( (unsigned int)value );
+ ext5Acc( *this ).reserve( (unsigned int)value );
+ ext6Acc( *this ).reserve( (unsigned int)value );
+ ext7Acc( *this ).reserve( (unsigned int)value );
+ ext8Acc( *this ).reserve( (unsigned int)value );
+ ext9Acc( *this ).reserve( (unsigned int)value );
+ }
+
+ return;
+ }
+
+ /// Set size of ROB storage
+ void L2StandAloneMuon_v1::setRobCapacity( int value ) {
+
+ static Accessor< int > rcapAcc( "robCapacity" );
+ rcapAcc( *this ) = value;
+
+ if ( value > 0 ) {
+ robidAcc( *this ).reserve( (unsigned int)value );
+ robrmAcc( *this ).reserve( (unsigned int)value );
+ }
+
+ return;
+ }
+
+ /// Set size of CSM storage
+ void L2StandAloneMuon_v1::setCsmCapacity( int value ) {
+
+ static Accessor< int > ccapAcc( "csmCapacity" );
+ ccapAcc( *this ) = value;
+
+ if ( value > 0 ) {
+ csmidAcc( *this ).reserve( (unsigned int)value );
+ csmszAcc( *this ).reserve( (unsigned int)value );
+ csmerAcc( *this ).reserve( (unsigned int)value );
+ csmrmAcc( *this ).reserve( (unsigned int)value );
+ }
+
+ return;
+ }
+
+ /// Set size of L1 emulation storage
+ void L2StandAloneMuon_v1::setLvl1EmuCapacity( int value ) {
+
+ static Accessor< int > lcapAcc( "lvl1Emuapacity" );
+ lcapAcc( *this ) = value;
+
+ if ( value > 0 ) {
+ lvl1eAcc( *this ).reserve( (unsigned int)value );
+ }
+
+ return;
+ }
+
+ /// Set size of storage for RPC hits
+ void L2StandAloneMuon_v1::setRpcHitsCapacity( int value ) {
+
+ static Accessor< int > rcapAcc( "rpcHitsCapacity" );
+ rcapAcc( *this ) = value;
+
+ if ( value > 0 ) {
+ padiAcc( *this ).reserve( (unsigned int)value );
+ padcAcc( *this ).reserve( (unsigned int)value );
+ padxAcc( *this ).reserve( (unsigned int)value );
+ padyAcc( *this ).reserve( (unsigned int)value );
+ padzAcc( *this ).reserve( (unsigned int)value );
+ padrAcc( *this ).reserve( (unsigned int)value );
+ padpAcc( *this ).reserve( (unsigned int)value );
+ }
+
+ return;
+ }
+
+ /// Set size of storage for TGC hits
+ void L2StandAloneMuon_v1::setTgcHitsCapacity( int value ) {
+
+ static Accessor< int > tcapAcc( "tgcHitsCapacity" );
+ tcapAcc( *this ) = value;
+
+ if ( value > 0 ) {
+ tirpAcc( *this ).reserve( (unsigned int)value );
+ tirrAcc( *this ).reserve( (unsigned int)value );
+ tirzAcc( *this ).reserve( (unsigned int)value );
+ tirwAcc( *this ).reserve( (unsigned int)value );
+ tiriAcc( *this ).reserve( (unsigned int)value );
+ tippAcc( *this ).reserve( (unsigned int)value );
+ tiprAcc( *this ).reserve( (unsigned int)value );
+ tipzAcc( *this ).reserve( (unsigned int)value );
+ tipwAcc( *this ).reserve( (unsigned int)value );
+ tipiAcc( *this ).reserve( (unsigned int)value );
+ tmrpAcc( *this ).reserve( (unsigned int)value );
+ tmrrAcc( *this ).reserve( (unsigned int)value );
+ tmrzAcc( *this ).reserve( (unsigned int)value );
+ tmrwAcc( *this ).reserve( (unsigned int)value );
+ tmriAcc( *this ).reserve( (unsigned int)value );
+ tmppAcc( *this ).reserve( (unsigned int)value );
+ tmprAcc( *this ).reserve( (unsigned int)value );
+ tmpzAcc( *this ).reserve( (unsigned int)value );
+ tmpwAcc( *this ).reserve( (unsigned int)value );
+ tmpiAcc( *this ).reserve( (unsigned int)value );
+ }
+
+ return;
+ }
+
+ /// Set size of storage for MDT hits
+ void L2StandAloneMuon_v1::setMdtHitsCapacity( int value ) {
+
+ static Accessor< int > mcapAcc( "mdtHitsCapacity" );
+ mcapAcc( *this ) = value;
+
+ if ( value > 0 ) {
+ mdtonAcc( *this ).reserve( (unsigned int)value );
+ mdtoffAcc( *this ).reserve( (unsigned int)value );
+ mdtrAcc( *this ).reserve( (unsigned int)value );
+ mdtzAcc( *this ).reserve( (unsigned int)value );
+ mdtresAcc( *this ).reserve( (unsigned int)value );
+ mdttAcc( *this ).reserve( (unsigned int)value );
+ mdtspcAcc( *this ).reserve( (unsigned int)value );
+ mdtsigAcc( *this ).reserve( (unsigned int)value );
+ }
+
+ return;
+ }
+
+
+ void L2StandAloneMuon_v1::setCapacities( int ext, int rob, int csm, int lvl1, int rpc, int tgc, int mdt ) {
+
+ setExtensionCapacity( ext );
+ setRobCapacity( rob );
+ setCsmCapacity( csm );
+ setLvl1EmuCapacity( lvl1 );
+ setRpcHitsCapacity( rpc );
+ setTgcHitsCapacity( tgc );
+ setMdtHitsCapacity( mdt );
+
+ return;
+ }
+ ///
+ /////////////////////////////////////////////////////////////////////////////
+
+ /////////////////////////////////////////////////////////////////////////////
+ /// Get extension object
+ AUXSTORE_OBJECT_GETTER( L2StandAloneMuon_v1, std::vector< uint32_t >, extension0 )
+ AUXSTORE_OBJECT_GETTER( L2StandAloneMuon_v1, std::vector< uint32_t >, extension1 )
+ AUXSTORE_OBJECT_GETTER( L2StandAloneMuon_v1, std::vector< uint32_t >, extension2 )
+ AUXSTORE_OBJECT_GETTER( L2StandAloneMuon_v1, std::vector< uint32_t >, extension3 )
+ AUXSTORE_OBJECT_GETTER( L2StandAloneMuon_v1, std::vector< uint32_t >, extension4 )
+ AUXSTORE_OBJECT_GETTER( L2StandAloneMuon_v1, std::vector< uint32_t >, extension5 )
+ AUXSTORE_OBJECT_GETTER( L2StandAloneMuon_v1, std::vector< uint32_t >, extension6 )
+ AUXSTORE_OBJECT_GETTER( L2StandAloneMuon_v1, std::vector< uint32_t >, extension7 )
+ AUXSTORE_OBJECT_GETTER( L2StandAloneMuon_v1, std::vector< uint32_t >, extension8 )
+ AUXSTORE_OBJECT_GETTER( L2StandAloneMuon_v1, std::vector< uint32_t >, extension9 )
+
+ /// Set and get methods for extenstions
+ void L2StandAloneMuon_v1::setExtension0( uint32_t value ) {
+ // Make sure that the size of vector is still within the capacity
+ if ( ext0Acc( *this ).size() >= (unsigned int)extensionCapacity() ) return;
+ // Set the variables:
+ ext0Acc( *this ).push_back( value );
+ }
+ void L2StandAloneMuon_v1::setExtension1( uint32_t value ) {
+ // Make sure that the size of vector is still within the capacity
+ if ( ext1Acc( *this ).size() >= (unsigned int)extensionCapacity() ) return;
+ // Set the variables:
+ ext1Acc( *this ).push_back( value );
+ }
+ void L2StandAloneMuon_v1::setExtension2( uint32_t value ) {
+ // Make sure that the size of vector is still within the capacity
+ if ( ext2Acc( *this ).size() >= (unsigned int)extensionCapacity() ) return;
+ // Set the variables:
+ ext2Acc( *this ).push_back( value );
+ }
+ void L2StandAloneMuon_v1::setExtension3( uint32_t value ) {
+ // Make sure that the size of vector is still within the capacity
+ if ( ext3Acc( *this ).size() >= (unsigned int)extensionCapacity() ) return;
+ // Set the variables:
+ ext3Acc( *this ).push_back( value );
+ }
+ void L2StandAloneMuon_v1::setExtension4( uint32_t value ) {
+ // Make sure that the size of vector is still within the capacity
+ if ( ext4Acc( *this ).size() >= (unsigned int)extensionCapacity() ) return;
+ // Set the variables:
+ ext4Acc( *this ).push_back( value );
+ }
+ void L2StandAloneMuon_v1::setExtension5( uint32_t value ) {
+ // Make sure that the size of vector is still within the capacity
+ if ( ext5Acc( *this ).size() >= (unsigned int)extensionCapacity() ) return;
+ // Set the variables:
+ ext5Acc( *this ).push_back( value );
+ }
+ void L2StandAloneMuon_v1::setExtension6( uint32_t value ) {
+ // Make sure that the size of vector is still within the capacity
+ if ( ext6Acc( *this ).size() >= (unsigned int)extensionCapacity() ) return;
+ // Set the variables:
+ ext6Acc( *this ).push_back( value );
+ }
+ void L2StandAloneMuon_v1::setExtension7( uint32_t value ) {
+ // Make sure that the size of vector is still within the capacity
+ if ( ext7Acc( *this ).size() >= (unsigned int)extensionCapacity() ) return;
+ // Set the variables:
+ ext7Acc( *this ).push_back( value );
+ }
+ void L2StandAloneMuon_v1::setExtension8( uint32_t value ) {
+ // Make sure that the size of vector is still within the capacity
+ if ( ext8Acc( *this ).size() >= (unsigned int)extensionCapacity() ) return;
+ // Set the variables:
+ ext8Acc( *this ).push_back( value );
+ }
+ void L2StandAloneMuon_v1::setExtension9( uint32_t value ) {
+ // Make sure that the size of vector is still within the capacity
+ if ( ext9Acc( *this ).size() >= (unsigned int)extensionCapacity() ) return;
+ // Set the variables:
+ ext9Acc( *this ).push_back( value );
+ }
+ ///
+ /////////////////////////////////////////////////////////////////////////////
+
+ /////////////////////////////////////////////////////////////////////////////
+ ///
+ /// Get level 1 emulation object
+ AUXSTORE_OBJECT_GETTER( L2StandAloneMuon_v1, std::vector< uint32_t >, lvl1Emulation )
+
+ /// Set level 1 emulation object
+ void L2StandAloneMuon_v1::setEtaPivot(uint32_t ly0, uint32_t ly1 ) {
+
+ if ( lvl1eAcc( *this ).size() < 2 ) lvl1eAcc( *this ).resize( 2 );
+
+ lvl1eAcc( *this ).at( 0 ) = ly0;
+ lvl1eAcc( *this ).at( 1 ) = ly1;
+
+ return;
+ }
+
+ void L2StandAloneMuon_v1::setEtaLow( uint32_t ly00, uint32_t ly01, uint32_t ly10, uint32_t ly11 ) {
+
+ if ( lvl1eAcc( *this ).size() < 6 ) lvl1eAcc( *this ).resize( 6 );
+
+ lvl1eAcc( *this ).at( 2 ) = ly00;
+ lvl1eAcc( *this ).at( 3 ) = ly01;
+ lvl1eAcc( *this ).at( 4 ) = ly10;
+ lvl1eAcc( *this ).at( 5 ) = ly11;
+
+ return;
+ }
+
+ void L2StandAloneMuon_v1::setEtaHigh( uint32_t ly00, uint32_t ly01, uint32_t ly10, uint32_t ly11 ) {
+
+ if ( lvl1eAcc( *this ).size() < 10 ) lvl1eAcc( *this ).resize( 10 );
+
+ lvl1eAcc( *this ).at( 6 ) = ly00;
+ lvl1eAcc( *this ).at( 7 ) = ly01;
+ lvl1eAcc( *this ).at( 8 ) = ly10;
+ lvl1eAcc( *this ).at( 9 ) = ly11;
+
+ return;
+ }
+
+ void L2StandAloneMuon_v1::setPhiPivot (uint32_t ly0, uint32_t ly1 ) {
+
+ if ( lvl1eAcc( *this ).size() < 12 ) lvl1eAcc( *this ).resize( 12 );
+
+ lvl1eAcc( *this ).at( 10 ) = ly0;
+ lvl1eAcc( *this ).at( 11 ) = ly1;
+
+ return;
+ }
+
+ void L2StandAloneMuon_v1::setPhiLow( uint32_t ly00, uint32_t ly01, uint32_t ly10, uint32_t ly11 ) {
+
+ if ( lvl1eAcc( *this ).size() < 16 ) lvl1eAcc( *this ).resize( 16 );
+
+ lvl1eAcc( *this ).at( 12 ) = ly00;
+ lvl1eAcc( *this ).at( 13 ) = ly01;
+ lvl1eAcc( *this ).at( 14 ) = ly10;
+ lvl1eAcc( *this ).at( 15 ) = ly11;
+
+ return;
+ }
+
+ void L2StandAloneMuon_v1::setPhiHigh( uint32_t ly00, uint32_t ly01, uint32_t ly10, uint32_t ly11 ) {
+
+ if ( lvl1eAcc( *this ).size() < 20 ) lvl1eAcc( *this ).resize( 20 );
+
+ lvl1eAcc( *this ).at( 16 ) = ly00;
+ lvl1eAcc( *this ).at( 17 ) = ly01;
+ lvl1eAcc( *this ).at( 18 ) = ly10;
+ lvl1eAcc( *this ).at( 19 ) = ly11;
+
+ return;
+ }
+ ///
+ /////////////////////////////////////////////////////////////////////////////
+
+ /////////////////////////////////////////////////////////////////////////////
+ ///
+ /// Get ROB information object
+ AUXSTORE_OBJECT_GETTER( L2StandAloneMuon_v1, std::vector< uint32_t >, robId )
+ AUXSTORE_OBJECT_GETTER( L2StandAloneMuon_v1, std::vector< uint32_t >, removedRobId )
+
+ /// Set ROB information object
+ void L2StandAloneMuon_v1::setRequestedRob( uint32_t rob ) {
+
+ // Make sure that the size of vector is still within the capacity
+ if ( robidAcc( *this ).size() >= (unsigned int)robCapacity() ) return;
+
+ // Set the variables:
+ robidAcc( *this ).push_back( rob );
+
+ return;
+ }
+
+ void L2StandAloneMuon_v1::setRemovedRob( uint32_t rob ) {
+
+ // Make sure that the size of vector is still within the capacity
+ if ( robrmAcc( *this ).size() >= (unsigned int)robCapacity() ) return;
+
+ // Set the variables:
+ robrmAcc( *this ).push_back( rob );
+
+ return;
+ }
+ ///
+ /////////////////////////////////////////////////////////////////////////////
+
+ /////////////////////////////////////////////////////////////////////////////
+ ///
+ /// Get CSM information object
+ AUXSTORE_OBJECT_GETTER( L2StandAloneMuon_v1, std::vector< uint32_t >, csmId )
+ AUXSTORE_OBJECT_GETTER( L2StandAloneMuon_v1, std::vector< uint32_t >, csmSize )
+ AUXSTORE_OBJECT_GETTER( L2StandAloneMuon_v1, std::vector< uint32_t >, csmError )
+ AUXSTORE_OBJECT_GETTER( L2StandAloneMuon_v1, std::vector< uint32_t >, removedCsmId )
+
+ /// Set CSM information object
+ void L2StandAloneMuon_v1::setConvertedCsm( uint32_t csm, uint32_t sz ) {
+
+ // Make sure that the size of vector is still within the capacity
+ if ( csmidAcc( *this ).size() >= (unsigned int)csmCapacity() ) return;
+
+ // Set the variables:
+ csmidAcc( *this ).push_back( csm );
+ csmszAcc( *this ).push_back( sz );
+
+ return;
+ }
+
+ void L2StandAloneMuon_v1::setCsmError( uint32_t err ) {
+
+ // Make sure that the size of vector is still within the capacity
+ if ( csmerAcc( *this ).size() >= (unsigned int)csmCapacity() ) return;
+
+ // Set the variables:
+ csmerAcc( *this ).push_back( err );
+
+ return;
+ }
+
+
+ void L2StandAloneMuon_v1::setRemovedCsm( uint32_t csm ) {
+ // Make sure that the size of vector is still within the capacity
+ if ( csmrmAcc( *this ).size() >= (unsigned int)csmCapacity() ) return;
+
+ // Set the variables:
+ csmrmAcc( *this ).push_back( csm );
+
+ return;
+ }
+ ///
+ /////////////////////////////////////////////////////////////////////////////
+
+ /////////////////////////////////////////////////////////////////////////////
+ ///
+ /// Get RPC pad object
+ AUXSTORE_OBJECT_GETTER( L2StandAloneMuon_v1, std::vector< uint32_t >, padHitOnlineId)
+ AUXSTORE_OBJECT_GETTER( L2StandAloneMuon_v1, std::vector< uint32_t >, padHitCode)
+ AUXSTORE_OBJECT_GETTER( L2StandAloneMuon_v1, std::vector< float >, padHitX)
+ AUXSTORE_OBJECT_GETTER( L2StandAloneMuon_v1, std::vector< float >, padHitY)
+ AUXSTORE_OBJECT_GETTER( L2StandAloneMuon_v1, std::vector< float >, padHitZ)
+ AUXSTORE_OBJECT_GETTER( L2StandAloneMuon_v1, std::vector< float >, padHitR)
+ AUXSTORE_OBJECT_GETTER( L2StandAloneMuon_v1, std::vector< float >, padHitP)
+
+ /// Set RPC pad hits
+ void L2StandAloneMuon_v1::setPadHit(uint32_t onlineId, uint32_t code, float x, float y, float z,
+ float r, float p) {
+ // Make sure that the size of vector is still within the capacity
+ if ( padiAcc( *this ).size() >= (unsigned int)rpcHitsCapacity() ) return;
+
+ // Set the variables:
+ padiAcc( *this ).push_back( onlineId );
+ padcAcc( *this ).push_back( code );
+ padxAcc( *this ).push_back( x );
+ padyAcc( *this ).push_back( y );
+ padzAcc( *this ).push_back( z );
+ padrAcc( *this ).push_back( r );
+ padpAcc( *this ).push_back( p );
+
+ return;
+ }
+ ///
+ /////////////////////////////////////////////////////////////////////////////
+
+ /////////////////////////////////////////////////////////////////////////////
+ ///
+ /// Get TGC hits
+ AUXSTORE_OBJECT_GETTER( L2StandAloneMuon_v1, std::vector< float >, tgcInnRhoHitPhi)
+ AUXSTORE_OBJECT_GETTER( L2StandAloneMuon_v1, std::vector< float >, tgcInnRhoHitR)
+ AUXSTORE_OBJECT_GETTER( L2StandAloneMuon_v1, std::vector< float >, tgcInnRhoHitZ)
+ AUXSTORE_OBJECT_GETTER( L2StandAloneMuon_v1, std::vector< float >, tgcInnRhoHitWidth)
+ AUXSTORE_OBJECT_GETTER( L2StandAloneMuon_v1, std::vector< uint32_t >, tgcInnRhoHitInSeg)
+ AUXSTORE_OBJECT_GETTER( L2StandAloneMuon_v1, std::vector< float >, tgcInnPhiHitPhi)
+ AUXSTORE_OBJECT_GETTER( L2StandAloneMuon_v1, std::vector< float >, tgcInnPhiHitR)
+ AUXSTORE_OBJECT_GETTER( L2StandAloneMuon_v1, std::vector< float >, tgcInnPhiHitZ)
+ AUXSTORE_OBJECT_GETTER( L2StandAloneMuon_v1, std::vector< float >, tgcInnPhiHitWidth)
+ AUXSTORE_OBJECT_GETTER( L2StandAloneMuon_v1, std::vector< uint32_t >, tgcInnPhiHitInSeg)
+ AUXSTORE_OBJECT_GETTER( L2StandAloneMuon_v1, std::vector< float >, tgcMidRhoHitPhi)
+ AUXSTORE_OBJECT_GETTER( L2StandAloneMuon_v1, std::vector< float >, tgcMidRhoHitR)
+ AUXSTORE_OBJECT_GETTER( L2StandAloneMuon_v1, std::vector< float >, tgcMidRhoHitZ)
+ AUXSTORE_OBJECT_GETTER( L2StandAloneMuon_v1, std::vector< float >, tgcMidRhoHitWidth)
+ AUXSTORE_OBJECT_GETTER( L2StandAloneMuon_v1, std::vector< uint32_t >, tgcMidRhoHitInSeg)
+ AUXSTORE_OBJECT_GETTER( L2StandAloneMuon_v1, std::vector< float >, tgcMidPhiHitPhi)
+ AUXSTORE_OBJECT_GETTER( L2StandAloneMuon_v1, std::vector< float >, tgcMidPhiHitR)
+ AUXSTORE_OBJECT_GETTER( L2StandAloneMuon_v1, std::vector< float >, tgcMidPhiHitZ)
+ AUXSTORE_OBJECT_GETTER( L2StandAloneMuon_v1, std::vector< float >, tgcMidPhiHitWidth)
+ AUXSTORE_OBJECT_GETTER( L2StandAloneMuon_v1, std::vector< uint32_t >, tgcMidPhiHitInEeg)
+
+ /// Set TGC hits
+ void L2StandAloneMuon_v1::setTgcInnRhoHit( float phi, float r, float z, float width, uint32_t in_seg ) {
+
+ // Make sure that the size of vector is still within the capacity
+ if ( tirpAcc( *this ).size() >= (unsigned int)tgcHitsCapacity() ) return;
+
+ // Set the variables:
+ tirpAcc( *this ).push_back( phi );
+ tirrAcc( *this ).push_back( r );
+ tirzAcc( *this ).push_back( z );
+ tirwAcc( *this ).push_back( width );
+ tiriAcc( *this ).push_back( in_seg );
+
+ return;
+ }
+
+ void L2StandAloneMuon_v1::setTgcInnPhiHit( float phi, float r, float z, float width, uint32_t in_seg ) {
+
+ // Make sure that the size of vector is still within the capacity
+ if ( tippAcc( *this ).size() >= (unsigned int)tgcHitsCapacity() ) return;
+
+ // Set the variables:
+ tippAcc( *this ).push_back( phi );
+ tiprAcc( *this ).push_back( r );
+ tipzAcc( *this ).push_back( z );
+ tipwAcc( *this ).push_back( width );
+ tipiAcc( *this ).push_back( in_seg );
+
+ return;
+ }
+
+ void L2StandAloneMuon_v1::setTgcMidRhoHit( float phi, float r, float z, float width, uint32_t in_seg ) {
+
+ // Make sure that the size of vector is still within the capacity
+ if ( tmrpAcc( *this ).size() >= (unsigned int)tgcHitsCapacity() ) return;
+
+ // Set the variables:
+ tmrpAcc( *this ).push_back( phi );
+ tmrrAcc( *this ).push_back( r );
+ tmrzAcc( *this ).push_back( z );
+ tmrwAcc( *this ).push_back( width );
+ tmriAcc( *this ).push_back( in_seg );
+
+ return;
+ }
+
+ void L2StandAloneMuon_v1::setTgcMidPhiHit( float phi, float r, float z, float width, uint32_t in_seg ) {
+
+ // Make sure that the size of vector is still within the capacity
+ if ( tmppAcc( *this ).size() >= (unsigned int)tgcHitsCapacity() ) return;
+
+ // Set the variables:
+ tmppAcc( *this ).push_back( phi );
+ tmprAcc( *this ).push_back( r );
+ tmpzAcc( *this ).push_back( z );
+ tmpwAcc( *this ).push_back( width );
+ tmpiAcc( *this ).push_back( in_seg );
+
+ return;
+ }
+ ///
+ /////////////////////////////////////////////////////////////////////////////
+
+ /////////////////////////////////////////////////////////////////////////////
+ ///
+ /// Get and set MDT hits
+ uint32_t L2StandAloneMuon_v1::nMdtHits() const {
+ return mdtonAcc( *this ).size();
+ }
+
+ uint32_t L2StandAloneMuon_v1::mdtHitOnlineId( unsigned int tube ) const {
+ if( mdtonAcc( *this ).size() > tube ) {
+ return mdtonAcc( *this ).at( tube );
+ } else {
+ return 0;
+ }
+ }
+
+ uint32_t L2StandAloneMuon_v1::mdtHitOfflineId( unsigned int tube ) const {
+ if( mdtoffAcc( *this ).size() > tube ) {
+ return mdtoffAcc( *this ).at( tube );
+ } else {
+ return 0;
+ }
+ }
+
+ int L2StandAloneMuon_v1::mdtHitChamber( unsigned int tube ) const {
+ if( mdtcAcc( *this ).size() > tube ) {
+ return mdtcAcc( *this ).at( tube );
+ } else {
+ return 0;
+ }
+ }
+
+ float L2StandAloneMuon_v1::mdtHitR( unsigned int tube ) const {
+ if( mdtrAcc( *this ).size() > tube ) {
+ return mdtrAcc( *this ).at( tube );
+ } else {
+ return 0.;
+ }
+ }
+
+ float L2StandAloneMuon_v1::mdtHitZ( unsigned int tube ) const {
+ if( mdtzAcc( *this ).size() > tube ) {
+ return mdtzAcc( *this ).at( tube );
+ } else {
+ return 0.;
+ }
+ }
+
+ float L2StandAloneMuon_v1::mdtHitResidual( unsigned int tube ) const {
+ if( mdtresAcc( *this ).size() > tube ) {
+ return mdtresAcc( *this ).at( tube );
+ } else {
+ return 0.;
+ }
+ }
+
+ float L2StandAloneMuon_v1::mdtHitTime( unsigned int tube ) const {
+ if( mdttAcc( *this ).size() > tube ) {
+ return mdttAcc( *this ).at( tube );
+ } else {
+ return 0.;
+ }
+ }
+
+ float L2StandAloneMuon_v1::mdtHitSpace( unsigned int tube ) const {
+ if( mdtspcAcc( *this ).size() > tube ) {
+ return mdtspcAcc( *this ).at( tube );
+ } else {
+ return 0.;
+ }
+ }
+
+ float L2StandAloneMuon_v1::mdtHitSigma( unsigned int tube ) const {
+ if( mdtsigAcc( *this ).size() > tube ) {
+ return mdtsigAcc( *this ).at( tube );
+ } else {
+ return 0.;
+ }
+ }
+
+ void L2StandAloneMuon_v1::setMdtHit( uint32_t onlineId, uint32_t offlineId, int chamber, float r, float z,
+ float residual, float time, float space, float sigma ) {
+
+ // Make sure that the number of MDT hits is still within the capacity
+ if ( mdtonAcc( *this ).size() >= (unsigned int)mdtHitsCapacity() ) return;
+
+ // Set the variables:
+ mdtonAcc( *this ).push_back( onlineId );
+ mdtoffAcc( *this ).push_back( offlineId );
+ mdtcAcc( *this ).push_back( chamber );
+ mdtrAcc( *this ).push_back( r );
+ mdtzAcc( *this ).push_back( z );
+ mdtresAcc( *this ).push_back( residual );
+ mdttAcc( *this ).push_back( time );
+ mdtspcAcc( *this ).push_back( space );
+ mdtsigAcc( *this ).push_back( sigma );
+
+ return;
+ }
+ //
+ /////////////////////////////////////////////////////////////////////////////
+
+} // namespace xAOD
+
+/// Helper operator for easily printing the properties of a LVL2 muon
+/// object for debugging.
+///
+std::ostream& operator<< ( std::ostream& out,
+ const xAOD::L2StandAloneMuon_v1& mu ) {
+
+ out << "roiWord: " << mu.roiWord() << "; ";
+ out << "sAddress: " << mu.sAddress() << "; ";
+ out << "pt: " << mu.pt() << "; ";
+ out << "phi: " << mu.phi() << "; ";
+ out << "eta: " << mu.eta() << "; ";
+ out << "rMS: " << mu.rMS() << "; ";
+ out << "etaMS: " << mu.etaMS() << "; ";
+ out << "phiMS: " << mu.phiMS() << "; ";
+ out << "dirPhiMS: " << mu.dirPhiMS() << "; ";
+ out << "zMS: " << mu.zMS() << "; ";
+ out << "dirZMS: " << mu.dirZMS() << "; ";
+ out << "beta: " << mu.beta() << "; ";
+ out << "barrelRadius: " << mu.barrelRadius() << "; ";
+ out << "barrelSagitta: " << mu.barrelSagitta() << "; ";
+ out << "endcapAlpha: " << mu.endcapAlpha() << "; ";
+ out << "endcapBeta: " << mu.endcapBeta() << "; ";
+ out << "endcapRadius: " << mu.endcapRadius() << "; ";
+ out << "etaMap: " << mu.etaMap() << "; ";
+ out << "phiMap: " << mu.phiMap() << "; ";
+ out << "etaBin: " << mu.etaBin() << "; ";
+ out << "phiBin: " << mu.phiBin() << "; ";
+ out << "isTgcFailure: " << mu.isTgcFailure() << "; ";
+ out << "isRpcFailure: " << mu.isRpcFailure() << "; ";
+ out << "deltaPhi: " << mu.deltaPhi() << "; ";
+ out << "deltaEta: " << mu.deltaEta() << "; ";
+ out << "algoId: " << mu.algoId() << "; ";
+ out << "teId: " << mu.teId() << "; ";
+ out << "lvl1Id: " << mu.lvl1Id() << "; ";
+ out << "lumiBlock: " << mu.lumiBlock() << "; ";
+ out << "muonDetMask: " << mu.muonDetMask() << "; ";
+ out << "roiId: " << mu.roiId() << "; ";
+ out << "roiSystem: " << mu.roiSystem() << "; ";
+ out << "roiSubsystem: " << mu.roiSubsystem() << "; ";
+ out << "roiSector: " << mu.roiSector() << "; ";
+ out << "roiNumber: " << mu.roiNumber() << "; ";
+ out << "roiThreshold: " << mu.roiThreshold() << "; ";
+ out << "roiEta: " << mu.roiEta() << "; ";
+ out << "roiPhi: " << mu.roiPhi() << "; ";
+ out << "extensionCapacity: " << mu.extensionCapacity() << "; ";
+ out << "robCapacity: " << mu.robCapacity() << "; ";
+ out << "csmCapacity: " << mu.csmCapacity() << "; ";
+ out << "lvl1EmuCapacity: " << mu.lvl1EmuCapacity() << "; ";
+ out << "rpcHitsCapacity: " << mu.rpcHitsCapacity() << "; ";
+ out << "tgcHitsCapacity: " << mu.tgcHitsCapacity() << "; ";
+ out << "mdtHitsCapacity: " << mu.mdtHitsCapacity() << "; ";
+
+ // Return the stream:
+ return out;
+}
diff --git a/Event/xAOD/xAODTrigMuon/Root/dict/ContainerProxies.cxx b/Event/xAOD/xAODTrigMuon/Root/dict/ContainerProxies.cxx
new file mode 100644
index 0000000000000000000000000000000000000000..5ab497a1a7f64d05c64b491a619519a2877dc55d
--- /dev/null
+++ b/Event/xAOD/xAODTrigMuon/Root/dict/ContainerProxies.cxx
@@ -0,0 +1,18 @@
+/*
+ Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+// $Id: ContainerProxies.cxx 604163 2014-06-30 10:30:46Z giagu $
+
+// EDM include(s):
+#include "xAODCore/AddDVProxy.h"
+
+// Local include(s):
+#include "xAODTrigMuon/versions/L2StandAloneMuonContainer_v1.h"
+#include "xAODTrigMuon/versions/L2IsoMuonContainer_v1.h"
+#include "xAODTrigMuon/versions/L2CombinedMuonContainer_v1.h"
+
+// Set up the collection proxies:
+ADD_NS_DV_PROXY( xAOD, L2StandAloneMuonContainer_v1 );
+ADD_NS_DV_PROXY( xAOD, L2IsoMuonContainer_v1 );
+ADD_NS_DV_PROXY( xAOD, L2CombinedMuonContainer_v1 );
diff --git a/Event/xAOD/xAODTrigMuon/cmt/Makefile.RootCore b/Event/xAOD/xAODTrigMuon/cmt/Makefile.RootCore
new file mode 100644
index 0000000000000000000000000000000000000000..d4836e7c334514ecc19aa428379bd59a9b499601
--- /dev/null
+++ b/Event/xAOD/xAODTrigMuon/cmt/Makefile.RootCore
@@ -0,0 +1,24 @@
+# this makefile also gets parsed by shell scripts
+# therefore it does not support full make syntax and features
+# edit with care
+
+# for full documentation check:
+# https://twiki.cern.ch/twiki/bin/viewauth/Atlas/RootCore#Package_Makefile
+
+PACKAGE = xAODTrigMuon
+PACKAGE_PRELOAD =
+PACKAGE_CXXFLAGS =
+PACKAGE_OBJFLAGS =
+PACKAGE_LDFLAGS =
+PACKAGE_BINFLAGS =
+PACKAGE_LIBFLAGS =
+PACKAGE_DEP = AthContainers AthLinks xAODBase xAODCore
+PACKAGE_TRYDEP =
+PACKAGE_CLEAN =
+PACKAGE_NOGRID =
+PACKAGE_PEDANTIC = 0
+PACKAGE_NOOPT = 0
+PACKAGE_NOCC = 0
+PACKAGE_REFLEX = 1
+
+include $(ROOTCOREDIR)/Makefile-common
diff --git a/Event/xAOD/xAODTrigMuon/cmt/requirements b/Event/xAOD/xAODTrigMuon/cmt/requirements
new file mode 100644
index 0000000000000000000000000000000000000000..e23d71fc1ed05838430d180815509f58f336b190
--- /dev/null
+++ b/Event/xAOD/xAODTrigMuon/cmt/requirements
@@ -0,0 +1,32 @@
+package xAODTrigMuon
+
+author Masaki Ishitsuka <ishitsuka@phys.titech.ac.jp>
+author Stefano Giagu <stefano.giagu@cern.ch>
+
+public
+
+use AtlasPolicy AtlasPolicy-*
+
+use SGTools SGTools-* Control
+use AthContainers AthContainers-* Control
+use AthLinks AthLinks-* Control
+
+use xAODBase xAODBase-* Event/xAOD
+use xAODCore xAODCore-* Event/xAOD
+use xAODTracking xAODTracking-* Event/xAOD
+
+# Specify the required ROOT components for cmake (transparent to CMT)
+apply_pattern cmake_add_command command="find_package(ROOT COMPONENTS Physics)"
+
+library xAODTrigMuon ../Root/*.cxx
+apply_pattern installed_library
+
+private
+
+use AtlasReflex AtlasReflex-* External
+use AtlasROOT AtlasROOT-* External
+use AthLinks AthLinks-* Control
+
+apply_pattern lcgdict dict=xAODTrigMuon selectionfile=selection.xml \
+ headerfiles="../xAODTrigMuon/xAODTrigMuonDict.h" \
+ extralibfiles=../Root/dict/*.cxx
diff --git a/Event/xAOD/xAODTrigMuon/doc/mainpage.h b/Event/xAOD/xAODTrigMuon/doc/mainpage.h
new file mode 100644
index 0000000000000000000000000000000000000000..052439104312e717949061c3349b3dfc49d4e955
--- /dev/null
+++ b/Event/xAOD/xAODTrigMuon/doc/mainpage.h
@@ -0,0 +1,13 @@
+/*
+ Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+/**
+ @mainpage xAODTrigMuon Package
+
+ Documentation to be written...
+
+ @htmlinclude used_packages.html
+
+ @include requirements
+*/
diff --git a/Event/xAOD/xAODTrigMuon/xAODTrigMuon/L2CombinedMuon.h b/Event/xAOD/xAODTrigMuon/xAODTrigMuon/L2CombinedMuon.h
new file mode 100644
index 0000000000000000000000000000000000000000..2f5b47b7c9296db9c0d813959bd6259985acb284
--- /dev/null
+++ b/Event/xAOD/xAODTrigMuon/xAODTrigMuon/L2CombinedMuon.h
@@ -0,0 +1,18 @@
+/*
+ Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+// L2CombinedMuon.h giagu
+#ifndef XAODTRIGMUON_L2COMBINEDMUON_H
+#define XAODTRIGMUON_L2COMBINEDMUON_H
+
+// Local include(s):
+#include "xAODTrigMuon/versions/L2CombinedMuon_v1.h"
+
+/// Namespace holding all the xAOD EDM classes
+namespace xAOD {
+ /// Define the latest version of the muon CB class
+ typedef L2CombinedMuon_v1 L2CombinedMuon;
+}
+
+#endif // XAODTRIGMUON_L2COMBINEDMUON_H
diff --git a/Event/xAOD/xAODTrigMuon/xAODTrigMuon/L2CombinedMuonAuxContainer.h b/Event/xAOD/xAODTrigMuon/xAODTrigMuon/L2CombinedMuonAuxContainer.h
new file mode 100644
index 0000000000000000000000000000000000000000..7c714ebdf259d4b419c9d4f323c7eb252ce58f12
--- /dev/null
+++ b/Event/xAOD/xAODTrigMuon/xAODTrigMuon/L2CombinedMuonAuxContainer.h
@@ -0,0 +1,17 @@
+/*
+ Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+// L2CombinedMuonAuxContainer.h giagu
+#ifndef XAODTRIGMUON_L2COMBINEDMUONAUXCONTAINER_H
+#define XAODTRIGMUON_L2COMBINEDMUONAUXCONTAINER_H
+
+// Local include(s):
+#include "xAODTrigMuon/versions/L2CombinedMuonAuxContainer_v1.h"
+
+namespace xAOD {
+ /// Define the latest version of the muon CB auxiliary container
+ typedef L2CombinedMuonAuxContainer_v1 L2CombinedMuonAuxContainer;
+}
+
+#endif // XAODTRIGMUON_L2COMBINEDMUONAUXCONTAINER_H
diff --git a/Event/xAOD/xAODTrigMuon/xAODTrigMuon/L2CombinedMuonContainer.h b/Event/xAOD/xAODTrigMuon/xAODTrigMuon/L2CombinedMuonContainer.h
new file mode 100644
index 0000000000000000000000000000000000000000..764696a90173e5c0c457ca3600a5a7112a719209
--- /dev/null
+++ b/Event/xAOD/xAODTrigMuon/xAODTrigMuon/L2CombinedMuonContainer.h
@@ -0,0 +1,18 @@
+/*
+ Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+// L2CombinedMuonContainer.h giagu
+#ifndef XAODTRIGMUON_L2COMBINEDMUONCONTAINER_H
+#define XAODTRIGMUON_L2COMBINEDMUONCONTAINER_H
+
+// Local include(s):
+#include "xAODTrigMuon/L2CombinedMuon.h"
+#include "xAODTrigMuon/versions/L2CombinedMuonContainer_v1.h"
+
+namespace xAOD {
+ /// Define the latest version of the muon CB container
+ typedef L2CombinedMuonContainer_v1 L2CombinedMuonContainer;
+}
+
+#endif // XAODTRIGMUON_L2COMBINEDMUONCONTAINER_H
diff --git a/Event/xAOD/xAODTrigMuon/xAODTrigMuon/L2IsoMuon.h b/Event/xAOD/xAODTrigMuon/xAODTrigMuon/L2IsoMuon.h
new file mode 100644
index 0000000000000000000000000000000000000000..efc913576f9287ccac32b43a864cb2a6b3c7867f
--- /dev/null
+++ b/Event/xAOD/xAODTrigMuon/xAODTrigMuon/L2IsoMuon.h
@@ -0,0 +1,18 @@
+/*
+ Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+// L2IsoMuon.h giagu
+#ifndef XAODTRIGMUON_L2ISOMUON_H
+#define XAODTRIGMUON_L2ISOMUON_H
+
+// Local include(s):
+#include "xAODTrigMuon/versions/L2IsoMuon_v1.h"
+
+/// Namespace holding all the xAOD EDM classes
+namespace xAOD {
+ /// Define the latest version of the muon Iso class
+ typedef L2IsoMuon_v1 L2IsoMuon;
+}
+
+#endif // XAODTRIGMUON_L2ISOMUON_H
diff --git a/Event/xAOD/xAODTrigMuon/xAODTrigMuon/L2IsoMuonAuxContainer.h b/Event/xAOD/xAODTrigMuon/xAODTrigMuon/L2IsoMuonAuxContainer.h
new file mode 100644
index 0000000000000000000000000000000000000000..e1c3fce16a59df7a8f900e07dbd0e909675cf13b
--- /dev/null
+++ b/Event/xAOD/xAODTrigMuon/xAODTrigMuon/L2IsoMuonAuxContainer.h
@@ -0,0 +1,17 @@
+/*
+ Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+// L2IsoMuonAuxContainer.h giagu
+#ifndef XAODTRIGMUON_L2ISOMUONAUXCONTAINER_H
+#define XAODTRIGMUON_L2ISOMUONAUXCONTAINER_H
+
+// Local include(s):
+#include "xAODTrigMuon/versions/L2IsoMuonAuxContainer_v1.h"
+
+namespace xAOD {
+ /// Define the latest version of the muon Iso auxiliary container
+ typedef L2IsoMuonAuxContainer_v1 L2IsoMuonAuxContainer;
+}
+
+#endif // XAODTRIGMUON_L2ISOMUONAUXCONTAINER_H
diff --git a/Event/xAOD/xAODTrigMuon/xAODTrigMuon/L2IsoMuonContainer.h b/Event/xAOD/xAODTrigMuon/xAODTrigMuon/L2IsoMuonContainer.h
new file mode 100644
index 0000000000000000000000000000000000000000..440aae3ff2d5c07e1a25a954e6b59e35eb4c81f4
--- /dev/null
+++ b/Event/xAOD/xAODTrigMuon/xAODTrigMuon/L2IsoMuonContainer.h
@@ -0,0 +1,18 @@
+/*
+ Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+// L2IsoMuonContainer.h giagu
+#ifndef XAODTRIGMUON_L2ISOMUONCONTAINER_H
+#define XAODTRIGMUON_L2ISOMUONCONTAINER_H
+
+// Local include(s):
+#include "xAODTrigMuon/L2IsoMuon.h"
+#include "xAODTrigMuon/versions/L2IsoMuonContainer_v1.h"
+
+namespace xAOD {
+ /// Define the latest version of the muon Iso container
+ typedef L2IsoMuonContainer_v1 L2IsoMuonContainer;
+}
+
+#endif // XAODTRIGMUON_L2ISOMUONCONTAINER_H
diff --git a/Event/xAOD/xAODTrigMuon/xAODTrigMuon/L2StandAloneMuon.h b/Event/xAOD/xAODTrigMuon/xAODTrigMuon/L2StandAloneMuon.h
new file mode 100644
index 0000000000000000000000000000000000000000..54074e50059045d6f7ed3cc6ded1cf176b8faab8
--- /dev/null
+++ b/Event/xAOD/xAODTrigMuon/xAODTrigMuon/L2StandAloneMuon.h
@@ -0,0 +1,20 @@
+// Dear emacs, this is -*- c++ -*-
+
+/*
+ Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+// $Id: L2StandAloneMuon.h 592605 2014-04-11 14:24:04Z krasznaa $
+#ifndef XAODTRIGMUON_L2STANDALONEMUON_H
+#define XAODTRIGMUON_L2STANDALONEMUON_H
+
+// Local include(s):
+#include "xAODTrigMuon/versions/L2StandAloneMuon_v1.h"
+
+/// Namespace holding all the xAOD EDM classes
+namespace xAOD {
+ /// Define the latest version of the muon SA class
+ typedef L2StandAloneMuon_v1 L2StandAloneMuon;
+}
+
+#endif // XAODTRIGMUON_L2STANDALONEMUON_H
diff --git a/Event/xAOD/xAODTrigMuon/xAODTrigMuon/L2StandAloneMuonAuxContainer.h b/Event/xAOD/xAODTrigMuon/xAODTrigMuon/L2StandAloneMuonAuxContainer.h
new file mode 100644
index 0000000000000000000000000000000000000000..0c829b4980aed55e0c4ba7d9899f41a229d40fcc
--- /dev/null
+++ b/Event/xAOD/xAODTrigMuon/xAODTrigMuon/L2StandAloneMuonAuxContainer.h
@@ -0,0 +1,19 @@
+// Dear emacs, this is -*- c++ -*-
+
+/*
+ Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+// $Id: L2StandAloneMuonAuxContainer.h 592605 2014-04-11 14:24:04Z krasznaa $
+#ifndef XAODTRIGMUON_L2STANDALONEMUONAUXCONTAINER_H
+#define XAODTRIGMUON_L2STANDALONEMUONAUXCONTAINER_H
+
+// Local include(s):
+#include "xAODTrigMuon/versions/L2StandAloneMuonAuxContainer_v1.h"
+
+namespace xAOD {
+ /// Define the latest version of the muon SA auxiliary container
+ typedef L2StandAloneMuonAuxContainer_v1 L2StandAloneMuonAuxContainer;
+}
+
+#endif // XAODTRIGMUON_L2STANDALONEMUONAUXCONTAINER_H
diff --git a/Event/xAOD/xAODTrigMuon/xAODTrigMuon/L2StandAloneMuonContainer.h b/Event/xAOD/xAODTrigMuon/xAODTrigMuon/L2StandAloneMuonContainer.h
new file mode 100644
index 0000000000000000000000000000000000000000..c5c2395ab99ff7f221d92f5031066440b88338d9
--- /dev/null
+++ b/Event/xAOD/xAODTrigMuon/xAODTrigMuon/L2StandAloneMuonContainer.h
@@ -0,0 +1,20 @@
+// Dear emacs, this is -*- c++ -*-
+
+/*
+ Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+// $Id: L2StandAloneMuonContainer.h 592605 2014-04-11 14:24:04Z krasznaa $
+#ifndef XAODTRIGMUON_L2STANDALONEMUONCONTAINER_H
+#define XAODTRIGMUON_L2STANDALONEMUONCONTAINER_H
+
+// Local include(s):
+#include "xAODTrigMuon/L2StandAloneMuon.h"
+#include "xAODTrigMuon/versions/L2StandAloneMuonContainer_v1.h"
+
+namespace xAOD {
+ /// Define the latest version of the muon SA container
+ typedef L2StandAloneMuonContainer_v1 L2StandAloneMuonContainer;
+}
+
+#endif // XAODTRIGMUON_L2STANDALONEMUONCONTAINER_H
diff --git a/Event/xAOD/xAODTrigMuon/xAODTrigMuon/TrigMuonDefs.h b/Event/xAOD/xAODTrigMuon/xAODTrigMuon/TrigMuonDefs.h
new file mode 100644
index 0000000000000000000000000000000000000000..1f8e9719479bd44db16b1924cb5566f1e652d2f3
--- /dev/null
+++ b/Event/xAOD/xAODTrigMuon/xAODTrigMuon/TrigMuonDefs.h
@@ -0,0 +1,40 @@
+// Dear emacs, this is -*- c++ -*-
+
+/*
+ Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+// $Id: TrigMuonDefs.h $
+#ifndef XAODTRIGMUON_TRIGMUONDEFS_H
+#define XAODTRIGMUON_TRIGMUONDEFS_H
+
+/// Namespace holding all the xAOD EDM classes
+namespace xAOD {
+
+namespace L2MuonParameters
+{
+
+ /// Define chamber types and locations
+ enum Chamber {
+ BarrelInner = 0, ///< Inner station in the barrel spectrometer
+ BarrelMiddle = 1, ///< Middle station in the barrel spectrometer
+ BarrelOuter = 2, ///< Outer station in the barrel spectrometer
+ EndcapInner = 3, ///< Inner station in the endcap spectrometer
+ EndcapMiddle = 4, ///< Middle station in the endcap spectrometer
+ EndcapOuter = 5, ///< Outer station in the endcap spectrometer
+ EndcapExtra = 6, ///< Extra station in the endcap spectrometer
+ CSC = 7, ///< CSC measurement point
+ MaxChamber = 8 ///< Number of measurement point definitions
+ };
+
+ /// Define algoriths ID
+ enum L2MuonAlgoId{GEV900ID=0, MUONID=1, HALOID=2, COSMICID=3,
+ LOOSE_HM=10, MEDIUM_HM=11, TIGHT_HM=12, LOOSE_LM=13,
+ MEDIUM_LM=14, TIGHT_LM=15,
+ NULLID=99999};
+
+}
+
+}
+
+#endif // XAODTRIGMUON_TRIGMUONDEFS_H
diff --git a/Event/xAOD/xAODTrigMuon/xAODTrigMuon/selection.xml b/Event/xAOD/xAODTrigMuon/xAODTrigMuon/selection.xml
new file mode 100644
index 0000000000000000000000000000000000000000..5fc7b30039c32940509d6afb43454c1b8cc5e807
--- /dev/null
+++ b/Event/xAOD/xAODTrigMuon/xAODTrigMuon/selection.xml
@@ -0,0 +1,89 @@
+<!-- $Id: selection.xml 604163 2014-06-30 10:30:46Z giagu $ -->
+<lcgdict>
+
+ <!-- dictionaries: -->
+
+ <!-- L2StandAloneMuon -->
+ <class name="xAOD::L2StandAloneMuon_v1" >
+ <field name="m_p4" transient="true" />
+ <field name="m_p4Cached" transient="true" />
+ </class>
+ <read sourceClass="xAOD::L2StandAloneMuon_v1" version="[1-]"
+ targetClass="xAOD::L2StandAloneMuon_v1" source=""
+ target="m_p4Cached" >
+ <![CDATA[
+ m_p4Cached = false;
+ ]]>
+ </read>
+
+ <class name="xAOD::L2StandAloneMuonContainer_v1"
+ id="645BDBC3-44EE-486B-8783-96F93FA2550B" />
+ <class name="xAOD::L2StandAloneMuonAuxContainer_v1"
+ id="69F56941-D2B5-4C70-BFBD-605CB64A3DB8" />
+
+ <class name="DataLink<xAOD::L2StandAloneMuonContainer_v1>" />
+ <class name="std::vector<DataLink<xAOD::L2StandAloneMuonContainer_v1> >" />
+
+ <class name="ElementLink<xAOD::L2StandAloneMuonContainer_v1>" />
+ <class name="std::vector<ElementLink<xAOD::L2StandAloneMuonContainer_v1> >" />
+ <class name="std::vector<std::vector<ElementLink<xAOD::L2StandAloneMuonContainer_v1> > >" />
+
+ <!-- L2IsoMuon -->
+ <class name="xAOD::L2IsoMuon_v1" >
+ <field name="m_p4" transient="true" />
+ <field name="m_p4Cached" transient="true" />
+ </class>
+ <read sourceClass="xAOD::L2IsoMuon_v1" version="[1-]"
+ targetClass="xAOD::L2IsoMuon_v1" source=""
+ target="m_p4Cached" >
+ <![CDATA[
+ m_p4Cached = false;
+ ]]>
+ </read>
+
+ <class name="xAOD::L2IsoMuonContainer_v1"
+ id="D3AD2358-29B9-48D1-B181-89D4DA39B5CC" />
+ <class name="xAOD::L2IsoMuonAuxContainer_v1"
+ id="09310901-41D9-49FB-A131-5AC73A9EA455" />
+
+ <class name="DataLink<xAOD::L2IsoMuonContainer_v1>" />
+ <class name="std::vector<DataLink<xAOD::L2IsoMuonContainer_v1> >" />
+
+ <class name="ElementLink<xAOD::L2IsoMuonContainer_v1>" />
+ <class name="std::vector<ElementLink<xAOD::L2IsoMuonContainer_v1> >" />
+ <class name="std::vector<std::vector<ElementLink<xAOD::L2IsoMuonContainer_v1> > >" />
+
+ <!-- L2CombinedMuon -->
+ <class name="xAOD::L2CombinedMuon_v1" >
+ <field name="m_p4" transient="true" />
+ <field name="m_p4Cached" transient="true" />
+ </class>
+ <read sourceClass="xAOD::L2CombinedMuon_v1" version="[1-]"
+ targetClass="xAOD::L2CombinedMuon_v1" source=""
+ target="m_p4Cached" >
+ <![CDATA[
+ m_p4Cached = false;
+ ]]>
+ </read>
+
+ <class name="xAOD::L2CombinedMuonContainer_v1"
+ id="91ECD1FA-3B9F-4F80-BBD1-698DCC7C9477" />
+ <class name="xAOD::L2CombinedMuonAuxContainer_v1"
+ id="0A7A1CB4-A5D3-4447-BE1A-F4DA14D5891B" />
+
+ <class name="DataLink<xAOD::L2CombinedMuonContainer_v1>" />
+ <class name="std::vector<DataLink<xAOD::L2CombinedMuonContainer_v1> >" />
+
+ <class name="ElementLink<xAOD::L2CombinedMuonContainer_v1>" />
+ <class name="std::vector<ElementLink<xAOD::L2CombinedMuonContainer_v1> >" />
+ <class name="std::vector<std::vector<ElementLink<xAOD::L2CombinedMuonContainer_v1> > >" />
+
+ <!-- Suppress the unwanted classes found by ROOT 6. -->
+ <!-- Hopefully we can remove these extra lines at one point... -->
+ <exclusion>
+ <class name="SG::IConstAuxStore" />
+ <class name="DataLink<SG::IConstAuxStore>" />
+ <class name="DataVector<xAOD::IParticle>" />
+ </exclusion>
+
+</lcgdict>
diff --git a/Event/xAOD/xAODTrigMuon/xAODTrigMuon/versions/L2CombinedMuonAuxContainer_v1.h b/Event/xAOD/xAODTrigMuon/xAODTrigMuon/versions/L2CombinedMuonAuxContainer_v1.h
new file mode 100644
index 0000000000000000000000000000000000000000..256c00d5cc0f90a8a5c2bd4c0556db69abfa4285
--- /dev/null
+++ b/Event/xAOD/xAODTrigMuon/xAODTrigMuon/versions/L2CombinedMuonAuxContainer_v1.h
@@ -0,0 +1,71 @@
+// Dear emacs, this is -*- c++ -*-
+
+/*
+ Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+// $Id: L2CombinedMuonAuxContainer_v1.h 605591 2014-07-09 12:07:31Z krasznaa $
+#ifndef XAODTRIGMUON_VERSIONS_L2COMBINEDMUONAUXCONTAINER_V1_H
+#define XAODTRIGMUON_VERSIONS_L2COMBINEDMUONAUXCONTAINER_V1_H
+
+// System include(s):
+#include <vector>
+
+// EDM include(s):
+#include "AthLinks/ElementLink.h"
+#include "xAODCore/AuxContainerBase.h"
+
+// xAOD include(s):
+#include "xAODTracking/TrackParticleContainer.h"
+
+// Local include(s):
+#include "xAODTrigMuon/L2StandAloneMuonContainer.h"
+
+namespace xAOD {
+
+ /// Auxiliary container for CB muon containers
+ ///
+ /// This is a fixed implementation of the CB muon auxiliary store.
+ ///
+ /// @author Stefano Giagu <stefano.giagu@cern.ch>
+ ///
+ /// V1.0 2014-06-26
+ ///
+ class L2CombinedMuonAuxContainer_v1 : public AuxContainerBase {
+
+ public:
+ /// Default constructor
+ L2CombinedMuonAuxContainer_v1();
+
+ private:
+ /// @name 4-momentum variables
+ /// @{
+ std::vector< float > pt;
+ std::vector< float > phi;
+ std::vector< float > eta;
+ /// @}
+
+ /// @name L2 muon specific variables
+ /// @{
+ std::vector< float > charge;
+ std::vector< int > strategy;
+ std::vector< int > errorFlag;
+ std::vector< int > matchFlag;
+ std::vector< float > sigmaPt;
+ std::vector<ElementLink< xAOD::TrackParticleContainer > > idTrackLink;
+ std::vector<ElementLink< xAOD::L2StandAloneMuonContainer > > muSATrackLink;
+ /// @}
+
+ }; // class L2CombinedMuonAuxContainer_v1
+
+} // namespace xAOD
+
+// Set up a CLID and StoreGate inheritance for the class:
+#ifndef XAOD_STANDALONE
+#include "SGTools/CLASS_DEF.h"
+CLASS_DEF( xAOD::L2CombinedMuonAuxContainer_v1 , 1201627828 , 1 )
+#include "SGTools/BaseInfo.h"
+SG_BASE( xAOD::L2CombinedMuonAuxContainer_v1, xAOD::AuxContainerBase );
+#endif // not XAOD_STANDALONE
+
+#endif // XAODTRIGMUON_VERSIONS_L2COMBINEDMUONAUXCONTAINER_V1_H
diff --git a/Event/xAOD/xAODTrigMuon/xAODTrigMuon/versions/L2CombinedMuonContainer_v1.h b/Event/xAOD/xAODTrigMuon/xAODTrigMuon/versions/L2CombinedMuonContainer_v1.h
new file mode 100644
index 0000000000000000000000000000000000000000..587fd461216d3a5f5359a65b6925d4b40cd027cd
--- /dev/null
+++ b/Event/xAOD/xAODTrigMuon/xAODTrigMuon/versions/L2CombinedMuonContainer_v1.h
@@ -0,0 +1,31 @@
+// Dear emacs, this is -*- c++ -*-
+
+/*
+ Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+// $Id: L2CombinedMuonContainer_v1.h 605591 2014-07-09 12:07:31Z krasznaa $
+#ifndef XAODTRIGMUON_VERSIONS_L2COMBINEDMUONCONTAINER_V1_H
+#define XAODTRIGMUON_VERSIONS_L2COMBINEDMUONCONTAINER_V1_H
+
+// EDM include(s):
+#include "AthContainers/DataVector.h"
+
+// Local include(s):
+#include "xAODTrigMuon/versions/L2CombinedMuon_v1.h"
+
+// Declare IParticle as a base class of L2CombinedMuon_v1:
+DATAVECTOR_BASE( xAOD::L2CombinedMuon_v1, xAOD::IParticle );
+
+namespace xAOD {
+ /// Define the trigger calorimeter cluster container as a simple DataVector
+ typedef DataVector< L2CombinedMuon_v1 > L2CombinedMuonContainer_v1;
+}
+
+// Set up a CLID for the container:
+#ifndef XAOD_STANDALONE
+#include "SGTools/CLASS_DEF.h"
+CLASS_DEF( xAOD::L2CombinedMuonContainer_v1, 1201561309, 1 )
+#endif // not XAOD_STANDALONE
+
+#endif // XAODTRIGMUON_VERSIONS_L2COMBINEDMUONCONTAINER_V1_H
diff --git a/Event/xAOD/xAODTrigMuon/xAODTrigMuon/versions/L2CombinedMuon_v1.h b/Event/xAOD/xAODTrigMuon/xAODTrigMuon/versions/L2CombinedMuon_v1.h
new file mode 100644
index 0000000000000000000000000000000000000000..c3e92f611d95eeaf512b05f376a0bdc01b987121
--- /dev/null
+++ b/Event/xAOD/xAODTrigMuon/xAODTrigMuon/versions/L2CombinedMuon_v1.h
@@ -0,0 +1,147 @@
+// Dear emacs, this is -*- c++ -*-
+
+/*
+ Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+// $Id: L2CombinedMuon_v1.h 605591 2014-07-09 12:07:31Z krasznaa $
+#ifndef XAODTRIGMUON_VERSIONS_L2COMBINEDMUON_V1_H
+#define XAODTRIGMUON_VERSIONS_L2COMBINEDMUON_V1_H
+
+// System include(s):
+extern "C" {
+# include <stdint.h>
+}
+#include <iosfwd>
+
+// EDM include(s):
+#include "AthLinks/ElementLink.h"
+
+// xAOD include(s):
+#include "xAODBase/IParticle.h"
+#include "xAODTracking/TrackParticle.h"
+#include "xAODTracking/TrackParticleContainer.h"
+
+// Local include(s):
+#include "xAODTrigMuon/L2StandAloneMuonContainer.h"
+
+namespace xAOD {
+
+ /// Class describing combined muon reconstructed in the LVL2 trigger
+ ///
+ /// This is a simple description of the LVL2 CB muon
+ ///
+ /// @author Stefano Giagu <stefano.giagu@cern.ch>
+ ///
+ /// V1 2014-06-24
+ ///
+ class L2CombinedMuon_v1 : public IParticle {
+
+ public:
+ /// Constructor
+ L2CombinedMuon_v1();
+
+ /// @name Functions implementing the xAOD::IParticle interface
+ /// @{
+
+ /// The transverse momentum (\f$p_T\f$) of the particle
+ virtual double pt() const;
+ /// The pseudorapidity (\f$\eta\f$) of the particle
+ virtual double eta() const;
+ /// The azimuthal angle (\f$\phi\f$) of the particle
+ virtual double phi() const;
+ /// The invariant mass of the particle
+ virtual double m() const;
+ /// The total energy of the particle
+ virtual double e() const;
+ /// The true rapidity (y) of the particle
+ virtual double rapidity() const;
+
+ /// Definition of the 4-momentum type
+ typedef TLorentzVector FourMom_t;
+
+ /// The full 4-momentum of the particle
+ virtual const FourMom_t& p4() const;
+
+ /// The type of the object as a simple enumeration
+ virtual Type::ObjectType type() const;
+
+ /// @}
+
+ /// @name 4-momentum setter functions
+ /// @{
+
+ /// Set the transverse momentum (\f$p_T\f$) of the muon
+ void setPt( float pt );
+ /// Set the pseudorapidity (\f$\eta\f$) of the muon
+ void setEta( float eta );
+ /// Set the azimuthal angle (\f$\phi\f$) of the muon
+ void setPhi( float phi );
+
+ /// @}
+
+ /// @name Properties specific to the LVL2 CB muon
+ /// @{
+
+ /// get seeding muon charge
+ float charge() const;
+ /// set seeding muon charge
+ void setCharge( float value );
+
+ /// get algorithm strategy flag
+ int strategy() const;
+ /// set algorithm strategy flag
+ void setStrategy( int value );
+
+ /// get algorithm error flag
+ int errorFlag() const;
+ /// set algorithm error flag
+ void setErrorFlag( int value );
+
+ /// get algorithm match flag
+ int matchFlag() const;
+ /// set algorithm match flag
+ void setMatchFlag( int value );
+
+ /// get sigma combined Pt
+ float sigmaPt() const;
+ /// set sigma combined Pt
+ void setSigmaPt( float value );
+
+ /// get ID track used to make the CB muon
+ const ElementLink< xAOD::TrackParticleContainer >& idTrackLink() const;
+ /// set ID track used to make the CB muon
+ void setIdTrackLink(const ElementLink< xAOD::TrackParticleContainer >& link);
+ /// Get the ID track as a bare pointer
+ const xAOD::TrackParticle* idTrack() const;
+
+ /// get SA muon used to make the CB muon
+ const ElementLink< xAOD::L2StandAloneMuonContainer >& muSATrackLink() const;
+ /// set SA muon used to make the CB muon
+ void setMuSATrackLink(const ElementLink< xAOD::L2StandAloneMuonContainer >& link);
+ /// Get the SA muon as a bare pointer
+ const xAOD::L2StandAloneMuon* muSATrack() const;
+
+ /// @}
+
+ private:
+ /// Cached 4-momentum of the muon
+ mutable FourMom_t m_p4;
+ /// Cached state of the internal 4-momentum object
+ mutable bool m_p4Cached;
+
+ }; // class L2CombinedMuon_v1
+
+} // namespace xAOD
+
+/// Operator for printing the contents of a LVL2 muon
+std::ostream& operator<< ( std::ostream& out,
+ const xAOD::L2CombinedMuon_v1& mu );
+
+// Set up a CLID for the object:
+#ifndef XAOD_STANDALONE
+#include "SGTools/CLASS_DEF.h"
+CLASS_DEF( xAOD::L2CombinedMuon_v1 , 221697629 , 1 )
+#endif // not XAOD_STANDALONE
+
+#endif // XAODTRIGMUON_VERSIONS_L2COMBINEDMUON_V1_H
diff --git a/Event/xAOD/xAODTrigMuon/xAODTrigMuon/versions/L2IsoMuonAuxContainer_v1.h b/Event/xAOD/xAODTrigMuon/xAODTrigMuon/versions/L2IsoMuonAuxContainer_v1.h
new file mode 100644
index 0000000000000000000000000000000000000000..6c443c7aeeef387abd0d16f1c55f50b3c3ae3861
--- /dev/null
+++ b/Event/xAOD/xAODTrigMuon/xAODTrigMuon/versions/L2IsoMuonAuxContainer_v1.h
@@ -0,0 +1,71 @@
+// Dear emacs, this is -*- c++ -*-
+
+/*
+ Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+// $Id: L2IsoMuonAuxContainer_v1.h 605591 2014-07-09 12:07:31Z krasznaa $
+#ifndef XAODTRIGMUON_VERSIONS_L2ISOMUONAUXCONTAINER_V1_H
+#define XAODTRIGMUON_VERSIONS_L2ISOMUONAUXCONTAINER_V1_H
+
+// System include(s):
+extern "C" {
+# include <stdint.h>
+}
+#include <vector>
+
+// EDM include(s):
+#include "xAODCore/AuxContainerBase.h"
+
+namespace xAOD {
+
+ /// Auxiliary container for muon iso containers
+ ///
+ /// This is a fixed implementation of the muon iso auxiliary store.
+ ///
+ /// @author Stefano Giagu <stefano.giagu@cern.ch>
+ ///
+ /// V1.0 2014-06-26
+ ///
+ class L2IsoMuonAuxContainer_v1 : public AuxContainerBase {
+
+ public:
+ /// Default constructor
+ L2IsoMuonAuxContainer_v1();
+
+ private:
+ /// @name 4-momentum variables
+ /// @{
+ std::vector< float > pt;
+ std::vector< float > phi;
+ std::vector< float > eta;
+ /// @}
+
+ /// @name L2 muon specific variables
+ /// @{
+ std::vector< uint32_t > roiWord;
+ std::vector< float > charge;
+ std::vector< int > errorFlag;
+ std::vector< float > sumPt01;
+ std::vector< float > sumPt02;
+ std::vector< float > sumPt03;
+ std::vector< float > sumPt04;
+ std::vector< float > sumEt01;
+ std::vector< float > sumEt02;
+ std::vector< float > sumEt03;
+ std::vector< float > sumEt04;
+ /// @}
+
+ }; // class L2IsoMuonAuxContainer_v1
+
+} // namespace xAOD
+
+// Set up a CLID and StoreGate inheritance for the class:
+#ifndef XAOD_STANDALONE
+#include "SGTools/CLASS_DEF.h"
+CLASS_DEF( xAOD::L2IsoMuonAuxContainer_v1, 1128059587, 1 )
+#include "SGTools/BaseInfo.h"
+SG_BASE( xAOD::L2IsoMuonAuxContainer_v1, xAOD::AuxContainerBase );
+#endif // not XAOD_STANDALONE
+
+#endif // XAODTRIGMUON_VERSIONS_L2ISOMUONAUXCONTAINER_V1_H
diff --git a/Event/xAOD/xAODTrigMuon/xAODTrigMuon/versions/L2IsoMuonContainer_v1.h b/Event/xAOD/xAODTrigMuon/xAODTrigMuon/versions/L2IsoMuonContainer_v1.h
new file mode 100644
index 0000000000000000000000000000000000000000..98ab7bc8fb3313a6563c8c0ca77a8916d356817f
--- /dev/null
+++ b/Event/xAOD/xAODTrigMuon/xAODTrigMuon/versions/L2IsoMuonContainer_v1.h
@@ -0,0 +1,31 @@
+// Dear emacs, this is -*- c++ -*-
+
+/*
+ Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+// $Id: L2IsoMuonContainer_v1.h 605591 2014-07-09 12:07:31Z krasznaa $
+#ifndef XAODTRIGMUON_VERSIONS_L2ISOMUONCONTAINER_V1_H
+#define XAODTRIGMUON_VERSIONS_L2ISOMUONCONTAINER_V1_H
+
+// EDM include(s):
+#include "AthContainers/DataVector.h"
+
+// Local include(s):
+#include "xAODTrigMuon/versions/L2IsoMuon_v1.h"
+
+// Declare IParticle as a base class of L2IsoMuon_v1:
+DATAVECTOR_BASE( xAOD::L2IsoMuon_v1, xAOD::IParticle );
+
+namespace xAOD {
+ /// Define the trigger calorimeter cluster container as a simple DataVector
+ typedef DataVector< L2IsoMuon_v1 > L2IsoMuonContainer_v1;
+}
+
+// Set up a CLID for the container:
+#ifndef XAOD_STANDALONE
+#include "SGTools/CLASS_DEF.h"
+CLASS_DEF( xAOD::L2IsoMuonContainer_v1, 1103714444, 1 )
+#endif // not XAOD_STANDALONE
+
+#endif // XAODTRIGMUON_VERSIONS_L2ISOMUONCONTAINER_V1_H
diff --git a/Event/xAOD/xAODTrigMuon/xAODTrigMuon/versions/L2IsoMuon_v1.h b/Event/xAOD/xAODTrigMuon/xAODTrigMuon/versions/L2IsoMuon_v1.h
new file mode 100644
index 0000000000000000000000000000000000000000..b95e69c3add5c2076b8b991ceecf247c74250f91
--- /dev/null
+++ b/Event/xAOD/xAODTrigMuon/xAODTrigMuon/versions/L2IsoMuon_v1.h
@@ -0,0 +1,155 @@
+// Dear emacs, this is -*- c++ -*-
+
+/*
+ Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+// $Id: L2IsoMuon_v1.h 605591 2014-07-09 12:07:31Z krasznaa $
+#ifndef XAODTRIGMUON_VERSIONS_L2ISOMUON_V1_H
+#define XAODTRIGMUON_VERSIONS_L2ISOMUON_V1_H
+
+// System include(s):
+extern "C" {
+# include <stdint.h>
+}
+#include <iosfwd>
+
+// xAOD include(s):
+#include "xAODBase/IParticle.h"
+
+namespace xAOD {
+
+ /// Class describing isolation info for muons reconstructed in the LVL2 trigger
+ ///
+ /// This is a simple description of the LVL2 isolation for muons.
+ ///
+ /// @author Stefano Giagu <stefano.giagu@cern.ch>
+ ///
+ /// V1 2014-06-24
+ ///
+ class L2IsoMuon_v1 : public IParticle {
+
+ public:
+ /// Constructor
+ L2IsoMuon_v1();
+
+ /// @name Functions implementing the xAOD::IParticle interface
+ /// @{
+
+ /// The transverse momentum (\f$p_T\f$) of the particle
+ virtual double pt() const;
+ /// The pseudorapidity (\f$\eta\f$) of the particle
+ virtual double eta() const;
+ /// The azimuthal angle (\f$\phi\f$) of the particle
+ virtual double phi() const;
+ /// The invariant mass of the particle
+ virtual double m() const;
+ /// The total energy of the particle
+ virtual double e() const;
+ /// The true rapidity (y) of the particle
+ virtual double rapidity() const;
+
+ /// Definition of the 4-momentum type
+ typedef TLorentzVector FourMom_t;
+
+ /// The full 4-momentum of the particle
+ virtual const FourMom_t& p4() const;
+
+ /// The type of the object as a simple enumeration
+ virtual Type::ObjectType type() const;
+
+ /// @}
+
+ /// @name 4-momentum setter functions
+ /// @{
+
+ /// Set the transverse momentum (\f$p_T\f$) of the muon
+ void setPt( float pt );
+ /// Set the pseudorapidity (\f$\eta\f$) of the muon
+ void setEta( float eta );
+ /// Set the azimuthal angle (\f$\phi\f$) of the muon
+ void setPhi( float phi );
+
+ /// @}
+
+ /// @name Properties specific to the LVL2 muon isolation
+ /// @{
+
+ /// Get the RoI ID of the seeding muon
+ uint32_t roiWord() const;
+ /// Set the RoI ID of the seeding muon
+ void setRoiWord( uint32_t value );
+
+ /// get seeding muon charge
+ float charge() const;
+ /// set seeding muon charge
+ void setCharge( float value );
+
+ /// get algorithm error flag
+ int errorFlag() const;
+ /// set algorithm error flag
+ void setErrorFlag( int value );
+
+ /// get ptcone radius DeltaR<0.1
+ float sumPt01() const;
+ /// set ptcone radius DeltaR<0.1
+ void setSumPt01( float value );
+
+ /// get ptcone radius DeltaR<0.2
+ float sumPt02() const;
+ /// set ptcone radius DeltaR<0.2
+ void setSumPt02( float value );
+
+ /// get ptcone radius DeltaR<0.3
+ float sumPt03() const;
+ /// set ptcone radius DeltaR<0.3
+ void setSumPt03( float value );
+
+ /// get ptcone radius DeltaR<0.4
+ float sumPt04() const;
+ /// set ptcone radius DeltaR<0.4
+ void setSumPt04( float value );
+
+ /// get ptcone radius DeltaR<0.1
+ float sumEt01() const;
+ /// set ptcone radius DeltaR<0.1
+ void setSumEt01( float value );
+
+ /// get etcone radius DeltaR<0.2
+ float sumEt02() const;
+ /// set etcone radius DeltaR<0.2
+ void setSumEt02( float value );
+
+ /// get etcone radius DeltaR<0.3
+ float sumEt03() const;
+ /// set etcone radius DeltaR<0.3
+ void setSumEt03( float value );
+
+ /// get etcone radius DeltaR<0.4
+ float sumEt04() const;
+ /// set etcone radius DeltaR<0.4
+ void setSumEt04( float value );
+
+ /// @}
+
+ private:
+ /// Cached 4-momentum of the muon
+ mutable FourMom_t m_p4;
+ /// Cached state of the internal 4-momentum object
+ mutable bool m_p4Cached;
+
+ }; // class L2IsoMuon_v1
+
+} // namespace xAOD
+
+/// Operator for printing the contents of a LVL2 muon
+std::ostream& operator<< ( std::ostream& out,
+ const xAOD::L2IsoMuon_v1& mu );
+
+// Set up a CLID for the object:
+#ifndef XAOD_STANDALONE
+#include "SGTools/CLASS_DEF.h"
+CLASS_DEF( xAOD::L2IsoMuon_v1, 249627886, 1 )
+#endif // not XAOD_STANDALONE
+
+#endif // XAODTRIGMUON_VERSIONS_L2ISOMUON_V1_H
diff --git a/Event/xAOD/xAODTrigMuon/xAODTrigMuon/versions/L2StandAloneMuonAuxContainer_v1.h b/Event/xAOD/xAODTrigMuon/xAODTrigMuon/versions/L2StandAloneMuonAuxContainer_v1.h
new file mode 100644
index 0000000000000000000000000000000000000000..c5ae1d60751a189bd5f8556c20358e2f3bafc26f
--- /dev/null
+++ b/Event/xAOD/xAODTrigMuon/xAODTrigMuon/versions/L2StandAloneMuonAuxContainer_v1.h
@@ -0,0 +1,270 @@
+// Dear emacs, this is -*- c++ -*-
+
+/*
+ Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+// $Id: L2StandAloneMuonAuxContainer_v1.h 613775 2014-08-28 07:56:49Z mishitsu $
+#ifndef XAODTRIGMUON_VERSIONS_L2STANDALONEMUONAUXCONTAINER_V1_H
+#define XAODTRIGMUON_VERSIONS_L2STANDALONEMUONAUXCONTAINER_V1_H
+
+// System include(s):
+extern "C" {
+# include <stdint.h>
+}
+#include <vector>
+
+// EDM include(s):
+#include "xAODCore/AuxContainerBase.h"
+
+namespace xAOD {
+
+ /// Auxiliary container for muon SA containers
+ ///
+ /// This is a fixed implementation of the muon SA auxiliary store.
+ /// Defining every possible property that muon SA can have.
+ ///
+ /// @author Masaki Ishitsuka <ishitsuka@phys.titech.ac.jp>
+ ///
+ /// $Revsision$
+ /// $Date: 2014-08-28 09:56:49 +0200 (Thu, 28 Aug 2014) $
+ ///
+ class L2StandAloneMuonAuxContainer_v1 : public AuxContainerBase {
+
+ public:
+ /// Default constructor
+ L2StandAloneMuonAuxContainer_v1();
+
+ private:
+ /// @name 4-momentum variables
+ /// @{
+ std::vector< float > pt;
+ std::vector< float > phi;
+ std::vector< float > eta;
+ /// @}
+
+ /// @name L2 muon specific variables
+ /// @{
+ /// Outputs of L2 muon standalone algorithm
+ std::vector< uint32_t > roiWord;
+ std::vector< int > sAddress;
+ /// Position at MS
+ std::vector< float > rMS;
+ std::vector< float > etaMS;
+ std::vector< float > phiMS;
+ std::vector< float > dirPhiMS;
+ std::vector< float > zMS;
+ std::vector< float > dirZMS;
+ std::vector< float > beta;
+ /// Input measurements to be converted to pT by LUT
+ std::vector< float > barrelRadius;
+ std::vector< float > barrelSagitta;
+ std::vector< float > endcapAlpha;
+ std::vector< float > endcapBeta;
+ std::vector< float > endcapRadius;
+ /// Slope and intercept at inner
+ std::vector< float > slopeInner;
+ std::vector< float > interceptInner;
+ std::vector< float > deltaR;
+
+ /// eta, phi as input to LUT
+ std::vector< float > etaMap;
+ std::vector< float > phiMap;
+ std::vector< int > etaBin;
+ std::vector< int > phiBin;
+ /// Flag for RGC and RPC availabilities
+ std::vector< int > isTgcFailure;
+ std::vector< int > isRpcFailure;
+ /// Error of eta and phi
+ std::vector< float > deltaEta;
+ std::vector< float > deltaPhi;
+
+ /// Station fit results (superpoints)
+ std::vector< std::vector< float > > superPointR;
+ std::vector< std::vector< float > > superPointZ;
+ std::vector< std::vector< float > > superPointSlope;
+ std::vector< std::vector< float > > superPointIntercept;
+ std::vector< std::vector< float > > superPointChi2;
+
+ /// Detailed information
+ std::vector< int > algoId;
+ std::vector< uint32_t > teId;
+ std::vector< uint32_t > lvl1Id;
+ std::vector< uint32_t > lumiBlock;
+ std::vector< uint32_t > muonDetMask;
+ std::vector< uint32_t > roiId;
+ std::vector< uint32_t > roiSystem;
+ std::vector< uint32_t > roiSubsystem;
+ std::vector< uint32_t > roiSector;
+ std::vector< uint32_t > roiNumber;
+ std::vector< uint32_t > roiThreshold;
+ std::vector< uint32_t > roiEta;
+ std::vector< uint32_t > roiPhi;
+
+ /// pT from different algorithms
+ std::vector< float > ptBarelRadius;
+ std::vector< float > ptBarelSagitta;
+ std::vector< float > ptEndcapAlpha;
+ std::vector< float > ptEndcapBeta;
+ std::vector< float > ptEndcapRadius;
+
+ /// Road information
+ /// Chamber type
+ std::vector< std::vector< int > > chamberType1Normal;
+ std::vector< std::vector< int > > chamberType1Overlap;
+ std::vector< std::vector< int > > chamberType2Normal;
+ std::vector< std::vector< int > > chamberType2Overlap;
+ /// Slope
+ std::vector< std::vector< float > > roadAwNormal;
+ std::vector< std::vector< float > > roadAwOverlap;
+ /// Intercept
+ std::vector< std::vector< float > > roadBwNormal;
+ std::vector< std::vector< float > > roadBwOverlap;
+ /// Z
+ std::vector< std::vector< float > > zMinNormal;
+ std::vector< std::vector< float > > zMinOverlap;
+ std::vector< std::vector< float > > zMaxNormal;
+ std::vector< std::vector< float > > zMaxOverlap;
+ /// R
+ std::vector< std::vector< float > > rMinNormal;
+ std::vector< std::vector< float > > rMinOverlap;
+ std::vector< std::vector< float > > rMaxNormal;
+ std::vector< std::vector< float > > rMaxOverlap;
+ /// Eta
+ std::vector< std::vector< float > > etaMinNormal;
+ std::vector< std::vector< float > > etaMinOverlap;
+ std::vector< std::vector< float > > etaMaxNormal;
+ std::vector< std::vector< float > > etaMaxOverlap;
+
+ /// TGC fit results
+ std::vector< float > tgcPt;
+
+ std::vector< float > tgcInnEta;
+ std::vector< float > tgcInnPhi;
+ std::vector< float > tgcInnR;
+ std::vector< float > tgcInnZ;
+
+ std::vector< float > tgcMid1Eta;
+ std::vector< float > tgcMid1Phi;
+ std::vector< float > tgcMid1R;
+ std::vector< float > tgcMid1Z;
+
+ std::vector< float > tgcMid2Eta;
+ std::vector< float > tgcMid2Phi;
+ std::vector< float > tgcMid2R;
+ std::vector< float > tgcMid2Z;
+
+ std::vector< float > tgcInnRhoStd;
+ std::vector< long > tgcInnRhoN;
+ std::vector< float > tgcInnPhiStd;
+ std::vector< long > tgcInnPhiN;
+
+ std::vector< float > tgcMidRhoChi2;
+ std::vector< long > tgcMidRhoN;
+ std::vector< float > tgcMidPhiChi2;
+ std::vector< long > tgcMidPhiN;
+
+ /// RPC fit results
+ std::vector< float > rpc1x;
+ std::vector< float > rpc1y;
+ std::vector< float > rpc1z;
+
+ std::vector< float > rpc2x;
+ std::vector< float > rpc2y;
+ std::vector< float > rpc2z;
+
+ std::vector< float > rpc3x;
+ std::vector< float > rpc3y;
+ std::vector< float > rpc3z;
+
+ /// Size of hit strages
+ std::vector< int > extensionCapacity;
+ std::vector< int > robCapacity;
+ std::vector< int > csmCapacity;
+ std::vector< int > lvl1EmuCapacity;
+ std::vector< int > rpcHitsCapacity;
+ std::vector< int > tgcHitsCapacity;
+ std::vector< int > mdtHitsCapacity;
+
+ /// Extensions
+ std::vector< std::vector< uint32_t > > extension0;
+ std::vector< std::vector< uint32_t > > extension1;
+ std::vector< std::vector< uint32_t > > extension2;
+ std::vector< std::vector< uint32_t > > extension3;
+ std::vector< std::vector< uint32_t > > extension4;
+ std::vector< std::vector< uint32_t > > extension5;
+ std::vector< std::vector< uint32_t > > extension6;
+ std::vector< std::vector< uint32_t > > extension7;
+ std::vector< std::vector< uint32_t > > extension8;
+ std::vector< std::vector< uint32_t > > extension9;
+
+ /// Level 1 emulation info
+ std::vector< std::vector< uint32_t > > lvl1Emulation;
+
+ /// ROB info
+ std::vector< std::vector< uint32_t > > robId;
+ std::vector< std::vector< uint32_t > > removedRobId;
+
+ /// CSM info
+ std::vector< std::vector< uint32_t > > csmId;
+ std::vector< std::vector< uint32_t > > csmSize;
+ std::vector< std::vector< uint32_t > > csmError;
+ std::vector< std::vector< uint32_t > > removedCsmId;
+
+ /// RPC pad hits
+ std::vector< std::vector< uint32_t > > padHitOnlineId;
+ std::vector< std::vector< uint32_t > > padHitCode;
+ std::vector< std::vector< float > > padHitX;
+ std::vector< std::vector< float > > padHitY;
+ std::vector< std::vector< float > > padHitZ;
+ std::vector< std::vector< float > > padHitR;
+ std::vector< std::vector< float > > padHitP;
+
+ /// TGC hits
+ std::vector< std::vector< float > > tgcInnRhoHitPhi;
+ std::vector< std::vector< float > > tgcInnRhoHitR;
+ std::vector< std::vector< float > > tgcInnRhoHitZ;
+ std::vector< std::vector< float > > tgcInnRhoHitWidth;
+ std::vector< std::vector< uint32_t > > tgcInnRhoHitInSeg;
+ std::vector< std::vector< float > > tgcInnPhiHitPhi;
+ std::vector< std::vector< float > > tgcInnPhiHitR;
+ std::vector< std::vector< float > > tgcInnPhiHitZ;
+ std::vector< std::vector< float > > tgcInnPhiHitWidth;
+ std::vector< std::vector< uint32_t > > tgcInnPhiHitInSeg;
+ std::vector< std::vector< float > > tgcMidRhoHitPhi;
+ std::vector< std::vector< float > > tgcMidRhoHitR;
+ std::vector< std::vector< float > > tgcMidRhoHitZ;
+ std::vector< std::vector< float > > tgcMidRhoHitWidth;
+ std::vector< std::vector< uint32_t > > tgcMidRhoHitInSeg;
+ std::vector< std::vector< float > > tgcMidPhiHitPhi;
+ std::vector< std::vector< float > > tgcMidPhiHitR;
+ std::vector< std::vector< float > > tgcMidPhiHitZ;
+ std::vector< std::vector< float > > tgcMidPhiHitWidth;
+ std::vector< std::vector< uint32_t > > tgcMidPhiHitInEeg;
+
+ /// MDT hits
+ std::vector< std::vector< uint32_t > > mdtHitOnlineId;
+ std::vector< std::vector< uint32_t > > mdtHitOfflineId;
+ std::vector< std::vector< uint32_t > > mdtHitChamber;
+ std::vector< std::vector< float > > mdtHitR;
+ std::vector< std::vector< float > > mdtHitZ;
+ std::vector< std::vector< float > > mdtHitResidual;
+ std::vector< std::vector< float > > mdtHitTime;
+ std::vector< std::vector< float > > mdtHitSpace;
+ std::vector< std::vector< float > > mdtHitSigma;
+
+ /// @}
+
+ }; // class L2StandAloneMuonAuxContainer_v1
+
+} // namespace xAOD
+
+// Set up a CLID and StoreGate inheritance for the class:
+#ifndef XAOD_STANDALONE
+#include "SGTools/CLASS_DEF.h"
+CLASS_DEF( xAOD::L2StandAloneMuonAuxContainer_v1, 1207804085, 1 )
+#include "SGTools/BaseInfo.h"
+SG_BASE( xAOD::L2StandAloneMuonAuxContainer_v1, xAOD::AuxContainerBase );
+#endif // not XAOD_STANDALONE
+
+#endif // XAODTRIGMUON_VERSIONS_L2STANDALONEMUONAUXCONTAINER_V1_H
diff --git a/Event/xAOD/xAODTrigMuon/xAODTrigMuon/versions/L2StandAloneMuonContainer_v1.h b/Event/xAOD/xAODTrigMuon/xAODTrigMuon/versions/L2StandAloneMuonContainer_v1.h
new file mode 100644
index 0000000000000000000000000000000000000000..b338496cc533fab44d806761a6721f7e2e779b39
--- /dev/null
+++ b/Event/xAOD/xAODTrigMuon/xAODTrigMuon/versions/L2StandAloneMuonContainer_v1.h
@@ -0,0 +1,31 @@
+// Dear emacs, this is -*- c++ -*-
+
+/*
+ Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+// $Id: L2StandAloneMuonContainer_v1.h 592605 2014-04-11 14:24:04Z krasznaa $
+#ifndef XAODTRIGMUON_VERSIONS_L2STANDALONEMUONCONTAINER_V1_H
+#define XAODTRIGMUON_VERSIONS_L2STANDALONEMUONCONTAINER_V1_H
+
+// EDM include(s):
+#include "AthContainers/DataVector.h"
+
+// Local include(s):
+#include "xAODTrigMuon/versions/L2StandAloneMuon_v1.h"
+
+// Declare IParticle as a base class of L2StandAloneMuon_v1:
+DATAVECTOR_BASE( xAOD::L2StandAloneMuon_v1, xAOD::IParticle );
+
+namespace xAOD {
+ /// Define the trigger calorimeter cluster container as a simple DataVector
+ typedef DataVector< L2StandAloneMuon_v1 > L2StandAloneMuonContainer_v1;
+}
+
+// Set up a CLID for the container:
+#ifndef XAOD_STANDALONE
+#include "SGTools/CLASS_DEF.h"
+CLASS_DEF( xAOD::L2StandAloneMuonContainer_v1, 1307619630, 1 )
+#endif // not XAOD_STANDALONE
+
+#endif // XAODTRIGMUON_VERSIONS_L2STANDALONEMUONCONTAINER_V1_H
diff --git a/Event/xAOD/xAODTrigMuon/xAODTrigMuon/versions/L2StandAloneMuon_v1.h b/Event/xAOD/xAODTrigMuon/xAODTrigMuon/versions/L2StandAloneMuon_v1.h
new file mode 100644
index 0000000000000000000000000000000000000000..b8d655981cfe9b35d5c4badae8ea6cdf8fd27d74
--- /dev/null
+++ b/Event/xAOD/xAODTrigMuon/xAODTrigMuon/versions/L2StandAloneMuon_v1.h
@@ -0,0 +1,515 @@
+// Dear emacs, this is -*- c++ -*-
+
+/*
+ Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+// $Id: L2StandAloneMuon_v1.h 615851 2014-09-10 07:56:31Z mishitsu $
+#ifndef XAODTRIGMUON_VERSIONS_L2STANDALONEMUON_V1_H
+#define XAODTRIGMUON_VERSIONS_L2STANDALONEMUON_V1_H
+
+// System include(s):
+extern "C" {
+# include <stdint.h>
+}
+#include <iosfwd>
+
+// xAOD include(s):
+#include "xAODBase/IParticle.h"
+
+namespace xAOD {
+
+ /// Class describing standalone muons reconstructed in the LVL2 trigger
+ ///
+ /// This is a simple description of the LVL2 standalone muons, which need
+ /// much fewer properties than EF or offline muons.
+ ///
+ /// @author Masaki Ishitsuka <ishitsuka@phys.titech.ac.jp>
+ /// @author Attila Krasznahorkay <Attila.Krasznahorkay@cern.ch>
+ ///
+ /// $Revision: 615851 $
+ /// $Date: 2014-09-10 09:56:31 +0200 (Wed, 10 Sep 2014) $
+ ///
+ class L2StandAloneMuon_v1 : public IParticle {
+
+ public:
+ /// Constructor
+ L2StandAloneMuon_v1();
+
+ /// @name Functions implementing the xAOD::IParticle interface
+ /// @{
+
+ /// The transverse momentum (\f$p_T\f$) of the particle
+ virtual double pt() const;
+ /// The pseudorapidity (\f$\eta\f$) of the particle
+ virtual double eta() const;
+ /// The azimuthal angle (\f$\phi\f$) of the particle
+ virtual double phi() const;
+ /// The invariant mass of the particle
+ virtual double m() const;
+ /// The total energy of the particle
+ virtual double e() const;
+ /// The true rapidity (y) of the particle
+ virtual double rapidity() const;
+
+ /// Definition of the 4-momentum type
+ typedef TLorentzVector FourMom_t;
+
+ /// The full 4-momentum of the particle
+ virtual const FourMom_t& p4() const;
+
+ /// The type of the object as a simple enumeration
+ virtual Type::ObjectType type() const;
+
+ /// @}
+
+ /// @name 4-momentum setter functions
+ /// @{
+
+ /// Set the transverse momentum (\f$p_T\f$) of the muon
+ void setPt( float pt );
+ /// Set the pseudorapidity (\f$\eta\f$) of the muon
+ void setEta( float eta );
+ /// Set the azimuthal angle (\f$\phi\f$) of the muon
+ void setPhi( float phi );
+
+ /// @}
+
+ /// @name Properties specific to the LVL2 muon reconstruction
+ /// @{
+
+ /// Get the RoI ID of the seeding LVL1 muon
+ uint32_t roiWord() const;
+ /// Set the RoI ID of the seeding LVL1 muon
+ void setRoIWord( uint32_t value );
+
+ /// Get the station address of the muon
+ int sAddress() const;
+ /// Set the station address of the muon
+ void setSAddress( int value );
+
+ /// Get the eta at muon spectrometer
+ float etaMS() const;
+ /// Set the eta at muon spectrometer
+ void setEtaMS( float value );
+
+ /// Get the phi at muon spectrometer
+ float phiMS() const;
+ /// Set the phi at muon spectrometer
+ void setPhiMS( float value );
+
+ /// Get tan phi at muon spectrometer
+ float dirPhiMS() const;
+ /// Set tan phi at muon spectrometer
+ void setDirPhiMS( float value );
+
+ /// Get the R at muon spectrometer
+ float rMS() const;
+ /// Set the R at muon spectrometer
+ void setRMS( float value );
+
+ /// Get the Z at muon spectrometer
+ float zMS() const;
+ /// Set the Z at muon spectrometer
+ void setZMS( float value );
+
+ /// Get dRdZ at muon spectrometer
+ float dirZMS() const;
+ /// Set dRdZ at muon spectrometer
+ void setDirZMS( float value );
+
+ /// Get beta
+ float beta() const;
+ /// Set beta
+ void setBeta( float value );
+
+ /// Get the fitted radius of the muon in the barrel
+ float barrelRadius() const;
+ /// Set the fitted radius of the muon in the barrel
+ void setBarrelRadius( float value );
+
+ /// Get the fitted sagitta of the muon in the barrel
+ float barrelSagitta() const;
+ /// Set the fitted sagitta of the muon in the barrel
+ void setBarrelSagitta( float value );
+
+ /// Get the fitted \f$\alpha\f$ value in the endcap
+ float endcapAlpha() const;
+ /// Set the fitted \f$\alpha\f$ value in the endcap
+ void setEndcapAlpha( float value );
+
+ /// Get the fitted \f$\beta\f$ value in the endcap
+ float endcapBeta() const;
+ /// Set the fitted \f$\beta\f$ value in the endcap
+ void setEndcapBeta( float value );
+
+ /// Get the fitted radius of the muon in the endcap
+ float endcapRadius() const;
+ /// Set the fitted radius of the muon in the endcap
+ void setEndcapRadius( float value );
+
+ /// Get the slope at inner
+ float slopeInner() const;
+ /// Set the slope at endcap
+ void setSlopeInner( float value );
+
+ /// Get the intercept at inner
+ float interceptInner() const;
+ /// Set the intercept at endcap
+ void setInterceptInner( float value );
+
+ /// Get deltaR
+ float deltaR() const;
+ /// Set deltaR
+ void setDeltaR( float value );
+
+ /// Get eta used to refer pT LUT
+ float etaMap() const;
+ /// Set eta used to refer pT LUT
+ void setEtaMap( float value );
+
+ /// Get phi used to refer pT LUT
+ float phiMap() const;
+ /// Set phi used to refer pT LUT
+ void setPhiMap( float value );
+
+ /// Get eta bin of pT LUT
+ int etaBin() const;
+ /// Set eta bin of pT LUT
+ void setEtaBin( int value );
+
+ /// Get phi bin of pT LUT
+ int phiBin() const;
+ /// Set phi bin of pT LUT
+ void setPhiBin( int value );
+
+ /// Get flag to see if TGC is properly read
+ int isTgcFailure() const;
+ /// Set flag to record if TGC is properly read
+ void setIsTgcFailure( int value );
+
+ /// Get flag to see if RPC is properly read
+ int isRpcFailure() const;
+ /// Set flag to record if RPC is properly read
+ void setIsRpcFailure( int value );
+
+ /// Get error of eta
+ float deltaEta() const;
+ /// Set error of eta
+ void setDeltaEta( float value );
+
+ /// Get error of phi
+ float deltaPhi() const;
+ /// Set error of phi
+ void setDeltaPhi( float value );
+
+ /// Get the measured radious of the muon in one particular super point
+ float superPointR( int chamber ) const;
+ /// Get the measured Z position of the muon in one particular super point
+ float superPointZ( int chamber ) const;
+ /// Get the measured slope of the muon in one particular super point
+ float superPointSlope( int chamber ) const;
+ /// Get the measured intercept of the muon in one particular super point
+ float superPointIntercept( int chamber ) const;
+ /// Get the chi2 of the fit in one particular super point
+ float superPointChi2( int chamber ) const;
+ /// Set the properties of one particular super point measurement
+ void setSuperPoint( int chamber, float r, float z, float slope, float intercept=0., float chi2=0. );
+
+ /// Get and set L2 muon algorithm ID (defined above)
+ int algoId() const;
+ void setAlgoId( int value);
+
+ /// Get and set input TE ID
+ uint32_t teId() const;
+ void setTeId( uint32_t value);
+
+ /// Get and set extended level-1 ID
+ uint32_t lvl1Id() const;
+ void setLvl1Id( uint32_t value );
+
+ /// Get and set lumi block
+ uint32_t lumiBlock() const;
+ void setLumiBlock( uint32_t value );
+
+ /// Get and set detector mask
+ uint32_t muonDetMask() const;
+ void setMuonDetMask( uint32_t value );
+
+ /// Get and set RoI ID
+ uint32_t roiId() const;
+ void setRoiId( uint32_t value );
+
+ /// Get and set RoI system ID
+ uint32_t roiSystem() const;
+ void setRoiSystem(uint32_t value);
+
+ /// Get and set RoI subsystem ID
+ uint32_t roiSubsystem() const;
+ void setRoiSubsystem(uint32_t value);
+
+ /// Get and set RoI sector ID
+ uint32_t roiSector() const;
+ void setRoiSector( uint32_t value );
+
+ /// Get and set RoI number
+ uint32_t roiNumber() const;
+ void setRoiNumber( uint32_t value );
+
+ /// Get and set RoI threshold number
+ uint32_t roiThreshold() const;
+ void setRoiThreshold( uint32_t value );
+
+ /// Get and set RoI eta
+ uint32_t roiEta() const;
+ void setRoiEta( uint32_t value );
+
+ /// Get and set RoI phi
+ uint32_t roiPhi() const;
+ void setRoiPhi( uint32_t value );
+
+ /// Set and get pT from different algorithms
+ float ptBarelRadius() const;
+ void setPtBarelRadius( float value );
+
+ float ptBarelSagitta() const;
+ void setPtBarelSagitta( float value );
+
+ float ptEndcapAlpha() const;
+ void setPtEndcapAlpha( float value );
+
+ float ptEndcapBeta() const;
+ void setPtEndcapBeta( float value );
+
+ float ptEndcapRadius() const;
+ void setPtEndcapRadius( float value );
+
+ /// Get the muon road information
+ /// Chamber type
+ int chamberType1( int station, int sector ) const;
+ int chamberType2( int station, int sector ) const;
+ /// Slope
+ float roadAw( int station, int sector ) const;
+ /// Intercept
+ float roadBw( int station, int sector ) const;
+ /// Z
+ float zMin( int station, int sector ) const;
+ float zMax( int station, int sector ) const;
+ /// R
+ float rMin( int station, int sector ) const;
+ float rMax( int station, int sector ) const;
+ /// Eta
+ float etaMin( int station, int sector ) const;
+ float etaMax( int station, int sector ) const;
+
+ /// Set the muon road information
+ void setChamberType1( int station, int sector, int chamberType);
+ void setChamberType2( int station, int sector, int chamberType);
+ void setRoad( int station, int sector, float aw, float bw );
+ void setRegionZ( int station, int sector, float min, float max );
+ void setRegionR( int station, int sector, float min, float max );
+ void setRegionEta( int station, int sector, float min, float max );
+
+ /// Get the results of TGC fit
+ float tgcPt() const;
+
+ float tgcInnEta() const;
+ float tgcInnPhi() const;
+ float tgcInnR() const;
+ float tgcInnZ() const;
+
+ float tgcInnRhoStd() const;
+ long tgcInnRhoN() const;
+ float tgcInnPhiStd() const;
+ long tgcInnPhiN() const;
+
+ float tgcMid1Eta() const;
+ float tgcMid1Phi() const;
+ float tgcMid1R() const;
+ float tgcMid1Z() const;
+
+ float tgcMid2Eta() const;
+ float tgcMid2Phi() const;
+ float tgcMid2R() const;
+ float tgcMid2Z() const;
+
+ float tgcMidRhoChi2() const;
+ long tgcMidRhoN() const;
+ float tgcMidPhiChi2() const;
+ long tgcMidPhiN() const;
+
+ /// Set the results of TGC fit
+ void setTgcPt( float value );
+
+ void setTgcInn( float eta, float phi, float r, float z );
+ void setTgcInnF( float rhoStd, long rhoN, float phiStd, long phiN );
+ void setTgcMid1( float eta, float phi, float r, float z );
+ void setTgcMid2( float eta, float phi, float r, float z );
+ void setTgcMidF( float rhoChi2, long rhoN, float phiChi2, long phiN );
+
+ /// Get the results of RPC fit
+ float rpc1x() const;
+ float rpc1y() const;
+ float rpc1z() const;
+
+ float rpc2x() const;
+ float rpc2y() const;
+ float rpc2z() const;
+
+ float rpc3x() const;
+ float rpc3y() const;
+ float rpc3z() const;
+
+ /// Set the results of RPC fit
+ void setRpc1( float x, float y, float z );
+ void setRpc2( float x, float y, float z );
+ void setRpc3( float x, float y, float z );
+
+ /// Get and set maximum size of storages to be reserved
+ int extensionCapacity() const;
+ void setExtensionCapacity( int value );
+
+ int robCapacity() const;
+ void setRobCapacity( int value );
+
+ int csmCapacity() const;
+ void setCsmCapacity( int value );
+
+ int lvl1EmuCapacity() const;
+ void setLvl1EmuCapacity( int value );
+
+ int rpcHitsCapacity() const;
+ void setRpcHitsCapacity( int value );
+
+ int tgcHitsCapacity() const;
+ void setTgcHitsCapacity( int value );
+
+ int mdtHitsCapacity() const;
+ void setMdtHitsCapacity( int value );
+
+ void setCapacities( int ext, int rob, int csm, int lvl1, int rpc, int tgc, int mdt );
+
+ /// Get extenstion
+ const std::vector< uint32_t >& extension0() const;
+ const std::vector< uint32_t >& extension1() const;
+ const std::vector< uint32_t >& extension2() const;
+ const std::vector< uint32_t >& extension3() const;
+ const std::vector< uint32_t >& extension4() const;
+ const std::vector< uint32_t >& extension5() const;
+ const std::vector< uint32_t >& extension6() const;
+ const std::vector< uint32_t >& extension7() const;
+ const std::vector< uint32_t >& extension8() const;
+ const std::vector< uint32_t >& extension9() const;
+ /// Set extenstion
+ void setExtension0( uint32_t value );
+ void setExtension1( uint32_t value );
+ void setExtension2( uint32_t value );
+ void setExtension3( uint32_t value );
+ void setExtension4( uint32_t value );
+ void setExtension5( uint32_t value );
+ void setExtension6( uint32_t value );
+ void setExtension7( uint32_t value );
+ void setExtension8( uint32_t value );
+ void setExtension9( uint32_t value );
+
+ /// Level 1 emulation info
+ const std::vector< uint32_t >& lvl1Emulation() const;
+ void setEtaPivot(uint32_t ly0, uint32_t ly1 );
+ void setEtaLow( uint32_t ly00, uint32_t ly01, uint32_t ly10, uint32_t ly11 );
+ void setEtaHigh( uint32_t ly00, uint32_t ly01, uint32_t ly10, uint32_t ly11 );
+ void setPhiPivot (uint32_t ly0, uint32_t ly1 );
+ void setPhiLow( uint32_t ly00, uint32_t ly01, uint32_t ly10, uint32_t ly11 );
+ void setPhiHigh( uint32_t ly00, uint32_t ly01, uint32_t ly10, uint32_t ly11 );
+
+ /// ROB info
+ const std::vector< uint32_t >& robId() const;
+ const std::vector< uint32_t >& removedRobId() const;
+ void setRequestedRob( uint32_t rob );
+ void setRemovedRob( uint32_t rob );
+
+ /// CSM info
+ const std::vector< uint32_t >& csmId() const;
+ const std::vector< uint32_t >& csmSize() const;
+ const std::vector< uint32_t >& csmError() const;
+ const std::vector< uint32_t >& removedCsmId() const;
+ void setConvertedCsm( uint32_t csm, uint32_t sz );
+ void setCsmError( uint32_t err );
+ void setRemovedCsm( uint32_t csm );
+
+ /// Get RPC pad hits
+ const std::vector< uint32_t >& padHitOnlineId() const;
+ const std::vector< uint32_t >& padHitCode() const;
+ const std::vector< float >& padHitX() const;
+ const std::vector< float >& padHitY() const;
+ const std::vector< float >& padHitZ() const;
+ const std::vector< float >& padHitR() const;
+ const std::vector< float >& padHitP() const;
+ /// Set RPC pad hits
+ void setPadHit(uint32_t onlineId, uint32_t code, float x, float y, float z,
+ float r, float p);
+
+ /// Get TGC hits
+ const std::vector< float >& tgcInnRhoHitPhi() const;
+ const std::vector< float >& tgcInnRhoHitR() const;
+ const std::vector< float >& tgcInnRhoHitZ() const;
+ const std::vector< float >& tgcInnRhoHitWidth() const;
+ const std::vector< uint32_t >& tgcInnRhoHitInSeg() const;
+ const std::vector< float >& tgcInnPhiHitPhi() const;
+ const std::vector< float >& tgcInnPhiHitR() const;
+ const std::vector< float >& tgcInnPhiHitZ() const;
+ const std::vector< float >& tgcInnPhiHitWidth() const;
+ const std::vector< uint32_t >& tgcInnPhiHitInSeg() const;
+ const std::vector< float >& tgcMidRhoHitPhi() const;
+ const std::vector< float >& tgcMidRhoHitR() const;
+ const std::vector< float >& tgcMidRhoHitZ() const;
+ const std::vector< float >& tgcMidRhoHitWidth() const;
+ const std::vector< uint32_t >& tgcMidRhoHitInSeg() const;
+ const std::vector< float >& tgcMidPhiHitPhi() const;
+ const std::vector< float >& tgcMidPhiHitR() const;
+ const std::vector< float >& tgcMidPhiHitZ() const;
+ const std::vector< float >& tgcMidPhiHitWidth() const;
+ const std::vector< uint32_t >& tgcMidPhiHitInEeg() const;
+ /// Set TGC hits
+ void setTgcInnRhoHit( float phi, float r, float z, float width, uint32_t in_seg );
+ void setTgcInnPhiHit( float phi, float r, float z, float width, uint32_t in_seg );
+ void setTgcMidRhoHit( float phi, float r, float z, float width, uint32_t in_seg );
+ void setTgcMidPhiHit( float phi, float r, float z, float width, uint32_t in_seg );
+
+ /// Get the online ID, offline ID, R, Z, redidual, time, space and sigma of each MDT tube
+ uint32_t nMdtHits() const;
+ uint32_t mdtHitOnlineId( unsigned int tube ) const;
+ uint32_t mdtHitOfflineId( unsigned int tube ) const;
+ int mdtHitChamber( unsigned int tube ) const;
+ float mdtHitR( unsigned int tube ) const;
+ float mdtHitZ( unsigned int tube ) const;
+ float mdtHitResidual( unsigned int tube ) const;
+ float mdtHitTime( unsigned int tube ) const;
+ float mdtHitSpace( unsigned int tube ) const;
+ float mdtHitSigma( unsigned int tube ) const;
+ /// Set the properties of each MDT tube
+ void setMdtHit( uint32_t onlineId, uint32_t offlineId, int chamber, float r, float z,
+ float residual, float time, float space, float sigma );
+
+ /// @}
+
+ private:
+ /// Cached 4-momentum of the muon
+ mutable FourMom_t m_p4;
+ /// Cached state of the internal 4-momentum object
+ mutable bool m_p4Cached;
+
+ }; // class L2StandAloneMuon_v1
+
+} // namespace xAOD
+
+/// Operator for printing the contents of a LVL2 muon
+std::ostream& operator<< ( std::ostream& out,
+ const xAOD::L2StandAloneMuon_v1& mu );
+
+// Set up a CLID for the object:
+#ifndef XAOD_STANDALONE
+#include "SGTools/CLASS_DEF.h"
+CLASS_DEF( xAOD::L2StandAloneMuon_v1, 65772484, 1 )
+#endif // not XAOD_STANDALONE
+
+#endif // XAODTRIGMUON_VERSIONS_L2STANDALONEMUON_V1_H
diff --git a/Event/xAOD/xAODTrigMuon/xAODTrigMuon/xAODTrigMuonDict.h b/Event/xAOD/xAODTrigMuon/xAODTrigMuon/xAODTrigMuonDict.h
new file mode 100644
index 0000000000000000000000000000000000000000..3abd127b36d6d47dd301213fbc427d291a4d8d38
--- /dev/null
+++ b/Event/xAOD/xAODTrigMuon/xAODTrigMuon/xAODTrigMuonDict.h
@@ -0,0 +1,56 @@
+// Dear emacs, this is -*- c++ -*-
+
+/*
+ Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+// $Id: xAODTrigMuonDict.h 604163 2014-06-30 10:30:46Z giagu $
+#ifndef XAODTRIGMUON_XAODTRIGMUONDICT_H
+#define XAODTRIGMUON_XAODTRIGMUONDICT_H
+
+// STL include(s):
+#include <vector>
+
+// EDM include(s):
+#include "AthLinks/DataLink.h"
+#include "AthLinks/ElementLink.h"
+
+// Local include(s):
+#include "xAODTrigMuon/versions/L2StandAloneMuon_v1.h"
+#include "xAODTrigMuon/versions/L2StandAloneMuonContainer_v1.h"
+#include "xAODTrigMuon/versions/L2StandAloneMuonAuxContainer_v1.h"
+#include "xAODTrigMuon/versions/L2IsoMuon_v1.h"
+#include "xAODTrigMuon/versions/L2IsoMuonContainer_v1.h"
+#include "xAODTrigMuon/versions/L2IsoMuonAuxContainer_v1.h"
+#include "xAODTrigMuon/versions/L2CombinedMuon_v1.h"
+#include "xAODTrigMuon/versions/L2CombinedMuonContainer_v1.h"
+#include "xAODTrigMuon/versions/L2CombinedMuonAuxContainer_v1.h"
+
+namespace{
+ struct GCCXML_DUMMY_INSTANTIATION_XAODTRIGMUON {
+
+ xAOD::L2StandAloneMuonContainer_v1 muonsa_c1;
+ DataLink< xAOD::L2StandAloneMuonContainer_v1 > muonsa_dl1;
+ std::vector< DataLink< xAOD::L2StandAloneMuonContainer_v1 > > muonsa_dl2;
+ ElementLink< xAOD::L2StandAloneMuonContainer_v1 > muonsa_el1;
+ std::vector< ElementLink< xAOD::L2StandAloneMuonContainer_v1 > > muonsa_el2;
+ std::vector< std::vector< ElementLink< xAOD::L2StandAloneMuonContainer_v1 > > > muonsa_el3;
+
+ xAOD::L2IsoMuonContainer_v1 muoniso_c1;
+ DataLink< xAOD::L2IsoMuonContainer_v1 > muoniso_dl1;
+ std::vector< DataLink< xAOD::L2IsoMuonContainer_v1 > > muoniso_dl2;
+ ElementLink< xAOD::L2IsoMuonContainer_v1 > muoniso_el1;
+ std::vector< ElementLink< xAOD::L2IsoMuonContainer_v1 > > muoniso_el2;
+ std::vector< std::vector< ElementLink< xAOD::L2IsoMuonContainer_v1 > > > muoniso_el3;
+
+ xAOD::L2CombinedMuonContainer_v1 muoncb_c1;
+ DataLink< xAOD::L2CombinedMuonContainer_v1 > muoncb_dl1;
+ std::vector< DataLink< xAOD::L2CombinedMuonContainer_v1 > > muoncb_dl2;
+ ElementLink< xAOD::L2CombinedMuonContainer_v1 > muoncb_el1;
+ std::vector< ElementLink< xAOD::L2CombinedMuonContainer_v1 > > muoncb_el2;
+ std::vector< std::vector< ElementLink< xAOD::L2CombinedMuonContainer_v1 > > > muoncb_el3;
+
+ };
+}
+
+#endif // XAODTRIGMUON_XAODTRIGMUONDICT_H