diff --git a/Event/xAOD/xAODTrigL1Calo/Root/JGTowerAuxContainer_v1.cxx b/Event/xAOD/xAODTrigL1Calo/Root/JGTowerAuxContainer_v1.cxx new file mode 100755 index 0000000000000000000000000000000000000000..035033d90d89b3b9cdb2d90e5a1d065d77f28797 --- /dev/null +++ b/Event/xAOD/xAODTrigL1Calo/Root/JGTowerAuxContainer_v1.cxx @@ -0,0 +1,28 @@ +/* + Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration +*/ + + + +// Local include(s): +#include "xAODTrigL1Calo/versions/JGTowerAuxContainer_v1.h" + +namespace xAOD { + + JGTowerAuxContainer_v1::JGTowerAuxContainer_v1() : + AuxContainerBase() + { + + ///@name IParticle variables + AUX_VARIABLE( eta ); + AUX_VARIABLE( phi ); + AUX_VARIABLE( deta ); + AUX_VARIABLE( dphi ); + AUX_VARIABLE( Id ); + AUX_VARIABLE( et ); + AUX_VARIABLE( SCIndex ); + AUX_VARIABLE( TileIndex ); + AUX_VARIABLE( sampling); + } + +} // namespace xAOD diff --git a/Event/xAOD/xAODTrigL1Calo/Root/JGTower_v1.cxx b/Event/xAOD/xAODTrigL1Calo/Root/JGTower_v1.cxx new file mode 100755 index 0000000000000000000000000000000000000000..3f194d802e14a0146fd142806fe618faf6b5eb69 --- /dev/null +++ b/Event/xAOD/xAODTrigL1Calo/Root/JGTower_v1.cxx @@ -0,0 +1,189 @@ +/* + * Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration +*/ + + +// EDM includes(s): +#include "xAODCore/AuxStoreAccessorMacros.h" + +// Local include(s): +#include "xAODTrigL1Calo/versions/JGTower_v1.h" + +namespace xAOD{ + + JGTower_v1::JGTower_v1() : + IParticle(), + m_p4(), + m_p4Cached( false ) + { + } + + + + JGTower_v1::JGTower_v1(const JGTower_v1& other) : + IParticle( other ), + m_p4( other.m_p4 ), + m_p4Cached( other.m_p4Cached ) + { + } + + JGTower_v1& JGTower_v1::operator=(const JGTower_v1& other) + { + if( this != &other ){ + if( !container() && !hasStore() ){ + makePrivateStore(); + } + IParticle::operator=( other ); + m_p4 = other.m_p4; + m_p4Cached = other.m_p4Cached; + } + return *this; + } +//Objects stored in this way will be hidden information + AUXSTORE_OBJECT_SETTER_AND_GETTER( JGTower_v1 , std::vector , SCIndex , setSCIndex ) + AUXSTORE_OBJECT_SETTER_AND_GETTER( JGTower_v1 , std::vector , TileIndex , setTileIndex ) + + /// initialize + void JGTower_v1::initialize(const int Id, const float Eta,const float Phi) + { + setId (Id); + setEta( Eta ); + setPhi( Phi ); + } + + void JGTower_v1::initialize(const int Id, const float Eta,const float Phi, const float Et) + { + setId (Id); + setEt (Et); + setEta( Eta ); + setPhi( Phi ); + } + + // IParticle interface + +// AUXSTORE_PRIMITIVE_SETTER_AND_GETTER( JGTower_v1, int , id , setId ) + + double JGTower_v1::eta() const + { + static Accessor< float > acc( "eta" ); + return acc( *this ); + } + + void JGTower_v1::setEta(float eta) + { + static Accessor< float > acc( "eta" ); + acc( *this ) = eta; + } + + + double JGTower_v1::phi() const + { + static Accessor< float > acc( "phi" ); + return acc( *this ); + } + + void JGTower_v1::setPhi(float phi) + { + static Accessor< float > acc( "phi" ); + acc( *this ) = phi; + } + + double JGTower_v1::deta() const + { + static Accessor< float > acc( "deta" ); + return acc( *this ); + } + + void JGTower_v1::setdEta(float deta) + { + static Accessor< float > acc( "deta" ); + acc( *this ) = deta; + } + + double JGTower_v1::dphi() const + { + static Accessor< float > acc( "dphi" ); + return acc( *this ); + } + + void JGTower_v1::setdPhi(float dphi) + { + static Accessor< float > acc( "dphi" ); + acc( *this ) = dphi; + } + + int JGTower_v1::Id() const + { + static Accessor< int > acc( "Id" ); + return acc( *this ); + } + + void JGTower_v1::setId(int Id) + { + static Accessor< int > acc( "Id" ); + acc( *this ) = Id; + } + + int JGTower_v1::sampling() const + { + static Accessor< int > acc( "sampling" ); + return acc( *this ); + } + + void JGTower_v1::setSampling(int sampling) + { + static Accessor< int > acc( "sampling" ); + acc( *this ) = sampling; + } + + + double JGTower_v1::et() const + { + static Accessor< float > acc( "et" ); + return acc( *this ); + } + + void JGTower_v1::setEt(float et) + { + static Accessor< float > acc( "et" ); + acc( *this ) = et; + } + + double JGTower_v1::pt() const + { + return static_cast< double >(pt() ); + } + + double JGTower_v1::m() const + { + return 0.; + } + + double JGTower_v1::e() const + { + return p4().E(); + } + + double JGTower_v1::rapidity() const + { + return p4().Rapidity(); + } + + const JGTower_v1::FourMom_t& JGTower_v1::p4() const + { + if( ! m_p4Cached ) { + + double PT = (pt() > 0) ? 1000. * static_cast< double >( pt() ) : 0.01; + + m_p4.SetPtEtaPhiM( PT , eta() , phi() , m() ); + m_p4Cached = true; + } + return m_p4; + } + + Type::ObjectType JGTower_v1::type() const + { + return Type::Jet; + } + +} // namespace xAOD diff --git a/Event/xAOD/xAODTrigL1Calo/Root/xAODTrigL1CaloCLIDs.cxx b/Event/xAOD/xAODTrigL1Calo/Root/xAODTrigL1CaloCLIDs.cxx index e5119c99f924cd42c4408c89f9a15695c5f4f541..864e721c89e32b15c253b6a0ceeacf7206efef79 100644 --- a/Event/xAOD/xAODTrigL1Calo/Root/xAODTrigL1CaloCLIDs.cxx +++ b/Event/xAOD/xAODTrigL1Calo/Root/xAODTrigL1CaloCLIDs.cxx @@ -44,5 +44,7 @@ #include "xAODTrigL1Calo/L1TopoRawDataContainer.h" #include "xAODTrigL1Calo/RODHeaderAuxContainer.h" #include "xAODTrigL1Calo/RODHeaderContainer.h" +#include "xAODTrigL1Calo/JGTowerAuxContainer.h" +#include "xAODTrigL1Calo/JGTowerContainer.h" #include "xAODTrigL1Calo/TriggerTowerAuxContainer.h" #include "xAODTrigL1Calo/TriggerTowerContainer.h" diff --git a/Event/xAOD/xAODTrigL1Calo/xAODTrigL1Calo/JGTower.h b/Event/xAOD/xAODTrigL1Calo/xAODTrigL1Calo/JGTower.h new file mode 100755 index 0000000000000000000000000000000000000000..5e7d6c2c4b0deac9d66bc73a2c6bfbc4cea3311f --- /dev/null +++ b/Event/xAOD/xAODTrigL1Calo/xAODTrigL1Calo/JGTower.h @@ -0,0 +1,21 @@ +/* + Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration +*/ + + +#ifndef XAODTRIGL1CALO_JGTOWER_H +#define XAODTRIGL1CALO_JGTOWER_H + +// Local include(s): +#include "xAODTrigL1Calo/versions/JGTower_v1.h" + +/// Namespace holding all the xAOD EDM classes +namespace xAOD { + /// Define the latest version of the JGTower class + typedef JGTower_v1 JGTower; +} + +#include "xAODCore/CLASS_DEF.h" +CLASS_DEF( xAOD::JGTower, 264277037 , 1 ) + +#endif // XAODTRIGL1CALO_JGTOWER_H diff --git a/Event/xAOD/xAODTrigL1Calo/xAODTrigL1Calo/JGTowerAuxContainer.h b/Event/xAOD/xAODTrigL1Calo/xAODTrigL1Calo/JGTowerAuxContainer.h new file mode 100755 index 0000000000000000000000000000000000000000..98f2cb8c5259526ae5c22ad79586aa92b74f729c --- /dev/null +++ b/Event/xAOD/xAODTrigL1Calo/xAODTrigL1Calo/JGTowerAuxContainer.h @@ -0,0 +1,19 @@ +/* + Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration +*/ + + +#ifndef XAODTRIGL1CALO_JGTOWERAUXCONTAINER_H +#define XAODTRIGL1CALO_JGTOWERAUXCONTAINER_H + +// Local include(s): +#include "xAODTrigL1Calo/versions/JGTowerAuxContainer_v1.h" +namespace xAOD { + /// Define the latest version of the JGTower auxiliary container + typedef JGTowerAuxContainer_v1 JGTowerAuxContainer; +} + +#include "xAODCore/CLASS_DEF.h" +CLASS_DEF( xAOD::JGTowerAuxContainer, 1086692910 , 1 ) + +#endif // XAODTRIGL1CALO_JGTOWERAUXCONTAINER_H diff --git a/Event/xAOD/xAODTrigL1Calo/xAODTrigL1Calo/JGTowerContainer.h b/Event/xAOD/xAODTrigL1Calo/xAODTrigL1Calo/JGTowerContainer.h new file mode 100755 index 0000000000000000000000000000000000000000..57aac60db518c6ad367d25e3e7ffcacb6b59535f --- /dev/null +++ b/Event/xAOD/xAODTrigL1Calo/xAODTrigL1Calo/JGTowerContainer.h @@ -0,0 +1,21 @@ +/* + Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration +*/ + + +#ifndef XAODTRIGL1CALO_JGTOWERCONTAINER_H +#define XAODTRIGL1CALO_JGTOWERCONTAINER_H + +// Local include(s): +#include "xAODTrigL1Calo/JGTower.h" +#include "xAODTrigL1Calo/versions/JGTowerContainer_v1.h" + +namespace xAOD { + /// Define the latest version of the JGTower container + typedef JGTowerContainer_v1 JGTowerContainer; +} + +#include "xAODCore/CLASS_DEF.h" +CLASS_DEF( xAOD::JGTowerContainer, 1174216567 , 1 ) + +#endif // XAODTRIGL1CALO_JGTOWERCONTAINER_H diff --git a/Event/xAOD/xAODTrigL1Calo/xAODTrigL1Calo/selection.xml b/Event/xAOD/xAODTrigL1Calo/xAODTrigL1Calo/selection.xml index 7341cff11102e61ca4bc468965b4607b614c3396..1a6591b4e5ac08d9e45c3f85b385db33ad2cf4c0 100644 --- a/Event/xAOD/xAODTrigL1Calo/xAODTrigL1Calo/selection.xml +++ b/Event/xAOD/xAODTrigL1Calo/xAODTrigL1Calo/selection.xml @@ -164,7 +164,24 @@ - + + + + + + + + + + + + + + +// System include(s): +#include + +// EDM include(s): +#include "xAODCore/AuxContainerBase.h" + +namespace xAOD{ + + /// AuxContainer for JGTower_v1 + /// + /// @author John Morris + /// + /// $Revision: 652807 $ + /// $Date: 2015-03-09 22:52:07 +0100 (Mon, 09 Mar 2015) $ + /// + class JGTowerAuxContainer_v1: public AuxContainerBase { + public: + // Default constructor + JGTowerAuxContainer_v1(); + + private: + + // Tower identifiers + std::vector eta; + std::vector phi; + std::vector deta; + std::vector dphi; + std::vector et; + std::vector Id; + std::vector sampling; + std::vector> SCIndex; + std::vector> TileIndex; + }; // class JGTowerAuxContainer +} // namespace xAOD + +#include "xAODCore/BaseInfo.h" +SG_BASE( xAOD::JGTowerAuxContainer_v1, xAOD::AuxContainerBase ); + +#endif // XAODTRIGL1CALO_VERSIONS_JGTOWERAUXCONTAINER_V1_H diff --git a/Event/xAOD/xAODTrigL1Calo/xAODTrigL1Calo/versions/JGTowerContainer_v1.h b/Event/xAOD/xAODTrigL1Calo/xAODTrigL1Calo/versions/JGTowerContainer_v1.h new file mode 100755 index 0000000000000000000000000000000000000000..0fed03adeea4636c0554f4d0fd0f62a3560ed7a2 --- /dev/null +++ b/Event/xAOD/xAODTrigL1Calo/xAODTrigL1Calo/versions/JGTowerContainer_v1.h @@ -0,0 +1,23 @@ +/* + Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration +*/ + +// Dear emacs, this is -*- c++ -*- +#ifndef XAODTRIGL1CALO_VERSIONS_JGTOWERCONTAINER_V1_H +#define XAODTRIGL1CALO_VERSIONS_JGTOWERCONTAINER_V1_H + +// EDM include(s): +#include "AthContainers/DataVector.h" + +// Local include(s): +#include "JGTower_v1.h" + +// Declare IParticle as a base class of JGTower_v1: +DATAVECTOR_BASE( xAOD::JGTower_v1, xAOD::IParticle ); + +namespace xAOD { + /// Define the JGTower as a simple DataVector + typedef DataVector< xAOD::JGTower_v1 > JGTowerContainer_v1; +} + +#endif // XAODTRIGL1CALO_VERSIONS_JGTOWERCONTAINER_V1_H diff --git a/Event/xAOD/xAODTrigL1Calo/xAODTrigL1Calo/versions/JGTower_v1.h b/Event/xAOD/xAODTrigL1Calo/xAODTrigL1Calo/versions/JGTower_v1.h new file mode 100755 index 0000000000000000000000000000000000000000..1d10f09f47bfb8eb8e2227c0a8b3a758b284ec44 --- /dev/null +++ b/Event/xAOD/xAODTrigL1Calo/xAODTrigL1Calo/versions/JGTower_v1.h @@ -0,0 +1,138 @@ +/* + * Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration +*/ + +// Dear emacs, this is -*- c++ -*- +#ifndef XAODTRIGL1CALO_VERSIONS_JGTOWER_V1_H +#define XAODTRIGL1CALO_VERSIONS_JGTOWER_V1_H + +// EDM include(s): +#include "xAODBase/IParticle.h" +#include "AthLinks/ElementLink.h" +#include "AthContainers/AuxElement.h" + +//CxxUtils for override final +#include "CxxUtils/final.h" +#include "CxxUtils/override.h" + +// System include(s): +#include + +namespace xAOD { + + /// Description of JGTower_v1 + /// + /// @author John Morris + /// + /// $Revision: 652807 $ + /// $Date: 2015-03-09 22:52:07 +0100 (Mon, 09 Mar 2015) $ + /// + /// Trigger towers are the inputs to all other parts of the calorimeter trigger. + /// They are formed by analogue summation of cells (represented in simulation + /// by LArTTL1 and TileTTL1 objects). The L1Calo PreProcessor digitizes these, + /// performs Bunch-Crossing IDentification, final calibration and reduction + /// to 8 bit words. + /// + /// The TriggerTower class represents the output of the PreProcessor. + /// + /// For each tower, the TriggerTower contains the final ET (LUT output) + /// as well as a vector of ADC data (at 25ns intervals) from which it was + /// formed, plus error flags and raw BCID output. As the PreProcessor + /// readout can read variable numbers of slices of all of these data, the + /// internal storage is in std::vectors, and methods exist to return all + /// slices as well as just the data corresponding to the triggered crossing. + /// + /// The JGTower_v1 class inherits from IParticle in order to assist + /// The Level 1.5 jet HLT algorithm + /// + + class JGTower_v1 : public IParticle{ + public: + /// Default constructor + JGTower_v1(); + /// Copy constructor + JGTower_v1(const JGTower_v1& other); + /// Assignment operator + JGTower_v1& operator=(const JGTower_v1& other); + /// Default desturctor + virtual ~JGTower_v1(){} + + /// @name xAOD::IParticle functions + /// These are already virtual due to IParticle + /// @{ + + /// @brief The transverse momentum (\f$p_T\f$) of the particle + virtual double pt() const ATH_FINAL; + + /// @brief The pseudorapidity (\f$\eta\f$) of the particle + virtual double eta() const ATH_FINAL; + void setEta(float); + + /// @brief The azimuthal angle (\f$\phi\f$) of the particle + virtual double phi() const ATH_FINAL; + void setPhi(float); + + /// @brief The pseudorapidity (\f$\eta\f$) of the particle + virtual double deta() const ATH_FINAL; + void setdEta(float); + + /// @brief The azimuthal angle (\f$\phi\f$) of the particle + virtual double dphi() const ATH_FINAL; + void setdPhi(float); + + + virtual double et() const ATH_FINAL; + void setEt(float); + + /// get coolId + virtual int Id() const ATH_FINAL; + void setId(int); + virtual int sampling() const ATH_FINAL; + void setSampling(int); + + + + + ///get SCIndex + const std::vector& SCIndex() const; + ///set SCIndex + void setSCIndex(const std::vector&); + + ///get TileIndex + const std::vector& TileIndex() const; + ///set TileIndex + void setTileIndex(const std::vector&); + + + /// @brief The invariant mass of the particle + virtual double m() const ATH_FINAL; + + /// The total energy of the particle + virtual double e() const ATH_FINAL; + + /// @brief The true rapidity (y) of the particle + virtual double rapidity() const ATH_FINAL; + + /// @brief Definition of the 4-momentum type + typedef IParticle::FourMom_t FourMom_t; + + /// @brief The full 4-momentum of the particle as a TLoretzVector + virtual const FourMom_t& p4() const ATH_FINAL; + + /// @brief The type of the object as a simple enumeration, remains pure virtual in e/gamma. + virtual Type::ObjectType type() const ATH_FINAL; + + + virtual void initialize(const int Id, const float Et, const float Eta,const float Phi); + virtual void initialize(const int Id, const float Eta,const float Phi); + private: + + /// Cached 4-momentum object + mutable FourMom_t m_p4; + /// Cache state of the internal 4-momentum (reset from the streamer) + mutable bool m_p4Cached; + + }; // class JGTower_v1 +} // namespace xAOD + +#endif // XAODTRIGL1CALO_VERSIONS_JGTOWER_V1_H diff --git a/Event/xAOD/xAODTrigL1Calo/xAODTrigL1Calo/xAODTrigL1CaloDict.h b/Event/xAOD/xAODTrigL1Calo/xAODTrigL1Calo/xAODTrigL1CaloDict.h index 242fa3418539266fa5077028d6f555ba3536fc92..4d67bdc7216fc3add20568ae1da2068152418801 100644 --- a/Event/xAOD/xAODTrigL1Calo/xAODTrigL1Calo/xAODTrigL1CaloDict.h +++ b/Event/xAOD/xAODTrigL1Calo/xAODTrigL1Calo/xAODTrigL1CaloDict.h @@ -1,10 +1,10 @@ // Dear emacs, this is -*- c++ -*- /* - Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration + * Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration */ -// $Id: xAODTrigL1CaloDict.h 694350 2015-09-11 12:02:19Z krasznaa $ +// $Id: xAODTrigL1CaloDict.h 804221 2017-05-03 16:06:15Z cylin $ #ifndef XAODTRIGL1CALO_XAODTRIGL1CALOCALOEVENTDICT_H #define XAODTRIGL1CALO_XAODTRIGL1CALOCALOEVENTDICT_H @@ -76,6 +76,7 @@ #include "xAODTrigL1Calo/versions/TriggerTowerAuxContainer_v1.h" // Run 2 + #include "xAODTrigL1Calo/versions/TriggerTower_v2.h" #include "xAODTrigL1Calo/versions/TriggerTowerContainer_v2.h" #include "xAODTrigL1Calo/versions/TriggerTowerAuxContainer_v2.h" @@ -129,6 +130,11 @@ #include "xAODTrigL1Calo/versions/L1TopoRawDataContainer_v1.h" #include "xAODTrigL1Calo/versions/L1TopoRawDataAuxContainer_v1.h" +// Run 3 + +#include "xAODTrigL1Calo/versions/JGTower_v1.h" +#include "xAODTrigL1Calo/versions/JGTowerContainer_v1.h" +#include "xAODTrigL1Calo/versions/JGTowerAuxContainer_v1.h" // Versionless AuxContainers #include "xAODTrigL1Calo/CMMCPHitsAuxContainer.h" @@ -152,6 +158,7 @@ #include "xAODTrigL1Calo/JetElementAuxContainer.h" #include "xAODTrigL1Calo/RODHeaderAuxContainer.h" #include "xAODTrigL1Calo/TriggerTowerAuxContainer.h" +#include "xAODTrigL1Calo/JGTowerAuxContainer.h" #include "xAODTrigL1Calo/L1TopoRawDataAuxContainer.h" @@ -295,6 +302,7 @@ namespace { // Run 2 // TriggerTower + xAOD::TriggerTowerContainer_v2 TriggerTower_v2_c1; /* DataLink< xAOD::TriggerTowerContainer_v2 > TriggerTower_v2_l1; @@ -305,6 +313,10 @@ namespace { std::vector< ElementLinkVector< xAOD::TriggerTowerContainer_v2 > > TriggerTower_v2_l6; */ + //Run 3 + xAOD::JGTowerContainer_v1 JGTower_v1_c1; + + // RODHeader xAOD::RODHeaderContainer_v2 RODHeader_v2_c1; /* diff --git a/Event/xAOD/xAODTrigL1CaloAthenaPool/CMakeLists.txt b/Event/xAOD/xAODTrigL1CaloAthenaPool/CMakeLists.txt index 985dafe746091c407d601f35056f029fc8ae73e7..c13663c7b7dccb6c9a2858582dc51d82596bfcfd 100644 --- a/Event/xAOD/xAODTrigL1CaloAthenaPool/CMakeLists.txt +++ b/Event/xAOD/xAODTrigL1CaloAthenaPool/CMakeLists.txt @@ -12,16 +12,15 @@ atlas_depends_on_subdirs( PRIVATE Database/AthenaPOOL/AthenaPoolCnvSvc Database/AthenaPOOL/AthenaPoolUtilities Event/xAOD/xAODTrigL1Calo ) - + # External dependencies: find_package( ROOT COMPONENTS Core Tree MathCore Hist RIO pthread ) - + # Component(s) in the package: atlas_add_poolcnv_library( xAODTrigL1CaloAthenaPoolPoolCnv src/*.cxx - FILES xAODTrigL1Calo/JEMHitsContainer.h xAODTrigL1Calo/JEMHitsAuxContainer.h xAODTrigL1Calo/JEMEtSumsContainer.h xAODTrigL1Calo/JEMEtSumsAuxContainer.h xAODTrigL1Calo/JEMRoIContainer.h xAODTrigL1Calo/JEMRoIAuxContainer.h xAODTrigL1Calo/CPMHitsContainer.h xAODTrigL1Calo/CPMHitsAuxContainer.h xAODTrigL1Calo/CPMTowerContainer.h xAODTrigL1Calo/CPMTowerAuxContainer.h xAODTrigL1Calo/CPMRoIContainer.h xAODTrigL1Calo/CPMRoIAuxContainer.h xAODTrigL1Calo/CMMCPHitsContainer.h xAODTrigL1Calo/CMMCPHitsAuxContainer.h xAODTrigL1Calo/CMMEtSumsContainer.h xAODTrigL1Calo/CMMEtSumsAuxContainer.h xAODTrigL1Calo/CMMJetHitsContainer.h xAODTrigL1Calo/CMMJetHitsAuxContainer.h xAODTrigL1Calo/CMMRoI.h xAODTrigL1Calo/CMMRoIAuxInfo.h xAODTrigL1Calo/JetElementContainer.h xAODTrigL1Calo/JetElementAuxContainer.h xAODTrigL1Calo/RODHeaderContainer.h xAODTrigL1Calo/RODHeaderAuxContainer.h xAODTrigL1Calo/TriggerTowerContainer.h xAODTrigL1Calo/TriggerTowerAuxContainer.h xAODTrigL1Calo/CMXCPHitsContainer.h xAODTrigL1Calo/CMXCPHitsAuxContainer.h xAODTrigL1Calo/CMXCPTobContainer.h xAODTrigL1Calo/CMXCPTobAuxContainer.h xAODTrigL1Calo/CMXJetHitsContainer.h xAODTrigL1Calo/CMXJetHitsAuxContainer.h xAODTrigL1Calo/CMXJetTobContainer.h xAODTrigL1Calo/CMXJetTobAuxContainer.h xAODTrigL1Calo/CMXEtSumsContainer.h xAODTrigL1Calo/CMXEtSumsAuxContainer.h xAODTrigL1Calo/CMXRoIContainer.h xAODTrigL1Calo/CMXRoIAuxContainer.h xAODTrigL1Calo/CPMTobRoIContainer.h xAODTrigL1Calo/CPMTobRoIAuxContainer.h xAODTrigL1Calo/JEMTobRoIContainer.h xAODTrigL1Calo/JEMTobRoIAuxContainer.h xAODTrigL1Calo/L1TopoRawDataContainer.h xAODTrigL1Calo/L1TopoRawDataAuxContainer.h - TYPES_WITH_NAMESPACE xAOD::JEMHitsContainer xAOD::JEMHitsAuxContainer xAOD::JEMEtSumsContainer xAOD::JEMEtSumsAuxContainer xAOD::JEMRoIContainer xAOD::JEMRoIAuxContainer xAOD::CPMHitsContainer xAOD::CPMHitsAuxContainer xAOD::CPMTowerContainer xAOD::CPMTowerAuxContainer xAOD::CPMRoIContainer xAOD::CPMRoIAuxContainer xAOD::CMMCPHitsContainer xAOD::CMMCPHitsAuxContainer xAOD::CMMEtSumsContainer xAOD::CMMEtSumsAuxContainer xAOD::CMMJetHitsContainer xAOD::CMMJetHitsAuxContainer xAOD::CMMRoI xAOD::CMMRoIAuxInfo xAOD::JetElementContainer xAOD::JetElementAuxContainer xAOD::RODHeaderContainer xAOD::RODHeaderAuxContainer xAOD::TriggerTowerContainer xAOD::TriggerTowerAuxContainer xAOD::CMXCPHitsContainer xAOD::CMXCPHitsAuxContainer xAOD::CMXCPTobContainer xAOD::CMXCPTobAuxContainer xAOD::CMXJetHitsContainer xAOD::CMXJetHitsAuxContainer xAOD::CMXJetTobContainer xAOD::CMXJetTobAuxContainer xAOD::CMXEtSumsContainer xAOD::CMXEtSumsAuxContainer xAOD::CMXRoIContainer xAOD::CMXRoIAuxContainer xAOD::CPMTobRoIContainer xAOD::CPMTobRoIAuxContainer xAOD::JEMTobRoIContainer xAOD::JEMTobRoIAuxContainer xAOD::L1TopoRawDataContainer xAOD::L1TopoRawDataAuxContainer + FILES xAODTrigL1Calo/JEMHitsContainer.h xAODTrigL1Calo/JEMHitsAuxContainer.h xAODTrigL1Calo/JEMEtSumsContainer.h xAODTrigL1Calo/JEMEtSumsAuxContainer.h xAODTrigL1Calo/JEMRoIContainer.h xAODTrigL1Calo/JEMRoIAuxContainer.h xAODTrigL1Calo/CPMHitsContainer.h xAODTrigL1Calo/CPMHitsAuxContainer.h xAODTrigL1Calo/CPMTowerContainer.h xAODTrigL1Calo/CPMTowerAuxContainer.h xAODTrigL1Calo/CPMRoIContainer.h xAODTrigL1Calo/CPMRoIAuxContainer.h xAODTrigL1Calo/CMMCPHitsContainer.h xAODTrigL1Calo/CMMCPHitsAuxContainer.h xAODTrigL1Calo/CMMEtSumsContainer.h xAODTrigL1Calo/CMMEtSumsAuxContainer.h xAODTrigL1Calo/CMMJetHitsContainer.h xAODTrigL1Calo/CMMJetHitsAuxContainer.h xAODTrigL1Calo/CMMRoI.h xAODTrigL1Calo/CMMRoIAuxInfo.h xAODTrigL1Calo/JetElementContainer.h xAODTrigL1Calo/JetElementAuxContainer.h xAODTrigL1Calo/RODHeaderContainer.h xAODTrigL1Calo/RODHeaderAuxContainer.h xAODTrigL1Calo/JGTowerContainer.h xAODTrigL1Calo/JGTowerAuxContainer.h xAODTrigL1Calo/TriggerTowerContainer.h xAODTrigL1Calo/TriggerTowerAuxContainer.h xAODTrigL1Calo/CMXCPHitsContainer.h xAODTrigL1Calo/CMXCPHitsAuxContainer.h xAODTrigL1Calo/CMXCPTobContainer.h xAODTrigL1Calo/CMXCPTobAuxContainer.h xAODTrigL1Calo/CMXJetHitsContainer.h xAODTrigL1Calo/CMXJetHitsAuxContainer.h xAODTrigL1Calo/CMXJetTobContainer.h xAODTrigL1Calo/CMXJetTobAuxContainer.h xAODTrigL1Calo/CMXEtSumsContainer.h xAODTrigL1Calo/CMXEtSumsAuxContainer.h xAODTrigL1Calo/CMXRoIContainer.h xAODTrigL1Calo/CMXRoIAuxContainer.h xAODTrigL1Calo/CPMTobRoIContainer.h xAODTrigL1Calo/CPMTobRoIAuxContainer.h xAODTrigL1Calo/JEMTobRoIContainer.h xAODTrigL1Calo/JEMTobRoIAuxContainer.h xAODTrigL1Calo/L1TopoRawDataContainer.h xAODTrigL1Calo/L1TopoRawDataAuxContainer.h + TYPES_WITH_NAMESPACE xAOD::JEMHitsContainer xAOD::JEMHitsAuxContainer xAOD::JEMEtSumsContainer xAOD::JEMEtSumsAuxContainer xAOD::JEMRoIContainer xAOD::JEMRoIAuxContainer xAOD::CPMHitsContainer xAOD::CPMHitsAuxContainer xAOD::CPMTowerContainer xAOD::CPMTowerAuxContainer xAOD::CPMRoIContainer xAOD::CPMRoIAuxContainer xAOD::CMMCPHitsContainer xAOD::CMMCPHitsAuxContainer xAOD::CMMEtSumsContainer xAOD::CMMEtSumsAuxContainer xAOD::CMMJetHitsContainer xAOD::CMMJetHitsAuxContainer xAOD::CMMRoI xAOD::CMMRoIAuxInfo xAOD::JetElementContainer xAOD::JetElementAuxContainer xAOD::RODHeaderContainer xAOD::RODHeaderAuxContainer xAOD::JGTowerContainer xAOD::JGTowerAuxContainer xAOD::TriggerTowerContainer xAOD::TriggerTowerAuxContainer xAOD::CMXCPHitsContainer xAOD::CMXCPHitsAuxContainer xAOD::CMXCPTobContainer xAOD::CMXCPTobAuxContainer xAOD::CMXJetHitsContainer xAOD::CMXJetHitsAuxContainer xAOD::CMXJetTobContainer xAOD::CMXJetTobAuxContainer xAOD::CMXEtSumsContainer xAOD::CMXEtSumsAuxContainer xAOD::CMXRoIContainer xAOD::CMXRoIAuxContainer xAOD::CPMTobRoIContainer xAOD::CPMTobRoIAuxContainer xAOD::JEMTobRoIContainer xAOD::JEMTobRoIAuxContainer xAOD::L1TopoRawDataContainer xAOD::L1TopoRawDataAuxContainer CNV_PFX xAOD INCLUDE_DIRS ${ROOT_INCLUDE_DIRS} - LINK_LIBRARIES ${ROOT_LIBRARIES} AthContainers AthenaKernel AthenaPoolCnvSvcLib AthenaPoolUtilities xAODTrigL1Calo ) - +26 LINK_LIBRARIES ${ROOT_LIBRARIES} AthContainers AthenaKernel AthenaPoolCnvSvcLib AthenaPoolUtilities xAODTrigL1Calo ) diff --git a/Event/xAOD/xAODTrigL1CaloAthenaPool/src/xAODJGTowerAuxContainerCnv.cxx b/Event/xAOD/xAODTrigL1CaloAthenaPool/src/xAODJGTowerAuxContainerCnv.cxx new file mode 100755 index 0000000000000000000000000000000000000000..400c4d03cc5dac5a2d07fe7b9105dcf082bb4a90 --- /dev/null +++ b/Event/xAOD/xAODTrigL1CaloAthenaPool/src/xAODJGTowerAuxContainerCnv.cxx @@ -0,0 +1,51 @@ +/* + Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration +*/ + + +// System include(s): +#include + +// Local include(s): +#include "xAODJGTowerAuxContainerCnv.h" + +xAODJGTowerAuxContainerCnv:: +xAODJGTowerAuxContainerCnv( ISvcLocator* svcLoc ) + : xAODJGTowerAuxContainerCnvBase( svcLoc ) { + +} + +xAOD::JGTowerAuxContainer* +xAODJGTowerAuxContainerCnv:: +createPersistent( xAOD::JGTowerAuxContainer* trans ) { + + // Create a copy of the container: + xAOD::JGTowerAuxContainer* result = + new xAOD::JGTowerAuxContainer( *trans ); + + return result; +} + + + +xAOD::JGTowerAuxContainer* +xAODJGTowerAuxContainerCnv::createTransient() { + // The known ID(s) for this container: + static const pool::Guid guid( "b12228ce-de5c-49dd-82ba-d2d5436f42c1" ); +// static const pool::Guid v2_guid( "07FF691A-A920-43B2-A4E7-637D335E6929" ); + + // Check which version of the container we're reading: + if( compareClassGuid( guid ) ) { + // It's the latest version, read it directly: + return poolReadObject< xAOD::JGTowerAuxContainer >(); + } +/* if( compareClassGuid( v1_guid ) ) { + throw std::runtime_error( "Version 1 of xAOD::JGTowerAuxContainer found - bail out for now" ); + return 0; + }*/ + + // If we didn't recognise the ID: + throw std::runtime_error( "Unsupported version of " + "xAOD::JGTowerAuxContainer found" ); + return 0; +} diff --git a/Event/xAOD/xAODTrigL1CaloAthenaPool/src/xAODJGTowerAuxContainerCnv.h b/Event/xAOD/xAODTrigL1CaloAthenaPool/src/xAODJGTowerAuxContainerCnv.h new file mode 100755 index 0000000000000000000000000000000000000000..b28a0c6dba554950f8510c83398e49bd38422b97 --- /dev/null +++ b/Event/xAOD/xAODTrigL1CaloAthenaPool/src/xAODJGTowerAuxContainerCnv.h @@ -0,0 +1,53 @@ +/* + Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration +*/ + + +#ifndef XAODTRIGL1CALOATHENAPOOL_XAODJGTOWERAUXCONTAINERCNV_H +#define XAODTRIGL1CALOATHENAPOOL_XAODJGTOWERAUXCONTAINERCNV_H + +// Gaudi/Athena include(s): +#include "AthenaPoolCnvSvc/T_AthenaPoolCustomCnv.h" + +// EDM include(s): +#include "xAODTrigL1Calo/JGTowerAuxContainer.h" + +/// Base class for the converter +typedef T_AthenaPoolCustomCnv< xAOD::JGTowerAuxContainer, + xAOD::JGTowerAuxContainer > + xAODJGTowerAuxContainerCnvBase; + +/** + * @short POOL converter for the xAOD::JGTowerAuxContainer class + * + * This is the converter doing the actual schema evolution + * of the package... The converter for xAOD::JGTowerContainer + * doesn't do much, as the "interface classes" don't contain + * too much/any payload. Most of the payload is in the auxiliary + * containers like this one. + * + * @author Attila Krasznahorkay + * @author John Morris + * + * $Revision: 576323 $ + * $Date: 2013-12-19 17:07:14 +0100 (Thu, 19 Dec 2013) $ + */ +class xAODJGTowerAuxContainerCnv : + public xAODJGTowerAuxContainerCnvBase { + + // Declare the factory as our friend: + friend class CnvFactory< xAODJGTowerAuxContainerCnv >; + +protected: + /// Converter constructor + xAODJGTowerAuxContainerCnv( ISvcLocator* svcLoc ); + + /// Function preparing the container to be written out + virtual xAOD::JGTowerAuxContainer* + createPersistent( xAOD::JGTowerAuxContainer* trans ); + /// Function reading in the object from the input file + virtual xAOD::JGTowerAuxContainer* createTransient(); + +}; // class xAODJGTowerAuxContainerCnv + +#endif // XAODTRIGL1CALOATHENAPOOL_XAODJGTOWERAUXCONTAINERCNV_H diff --git a/Event/xAOD/xAODTrigL1CaloAthenaPool/src/xAODJGTowerContainerCnv.cxx b/Event/xAOD/xAODTrigL1CaloAthenaPool/src/xAODJGTowerContainerCnv.cxx new file mode 100755 index 0000000000000000000000000000000000000000..6acef775fbb799e3f050863c3905a8936fa10e79 --- /dev/null +++ b/Event/xAOD/xAODTrigL1CaloAthenaPool/src/xAODJGTowerContainerCnv.cxx @@ -0,0 +1,85 @@ +/* + Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration +*/ + + +// System include(s): +#include + +// Local include(s): +#include "xAODJGTowerContainerCnv.h" + +namespace { + /// Helper function setting up the container's link to its auxiliary store + void setStoreLink( SG::AuxVectorBase* cont, const std::string& key ) { + + // The link to set up: + DataLink< SG::IConstAuxStore > link( key + "Aux." ); + + // Give it to the container: + cont->setStore( link ); + + return; + } +} // private namespace + +xAODJGTowerContainerCnv::xAODJGTowerContainerCnv( ISvcLocator* svcLoc ) + : xAODJGTowerContainerCnvBase( svcLoc ) { +} + +/** +* This function needs to be re-implemented in order to figure out the StoreGate +* key of the container that's being created. After that's done, it lets the +* base class do its normal task. +*/ + +StatusCode xAODJGTowerContainerCnv::createObj( IOpaqueAddress* pAddr, DataObject*& pObj ) { + + // Get the key of the container that we'll be creating: + m_key = *( pAddr->par() + 1 ); + + // Let the base class do its thing now: + return AthenaPoolConverter::createObj( pAddr, pObj ); +} + +xAOD::JGTowerContainer* +xAODJGTowerContainerCnv::createPersistent( xAOD::JGTowerContainer* trans ) { + + // Create a view copy of the container: + xAOD::JGTowerContainer* result = + new xAOD::JGTowerContainer( trans->begin(), trans->end(), + SG::VIEW_ELEMENTS ); + + // Prepare the objects to be written out: + xAOD::JGTowerContainer::iterator itr = result->begin(); + xAOD::JGTowerContainer::iterator end = result->end(); + for( ; itr != end; ++itr ) { + toPersistent( *itr ); + } + + // Return the new container: + return result; +} + +xAOD::JGTowerContainer* xAODJGTowerContainerCnv::createTransient() { + // The known ID(s) for this container: + static pool::Guid guid( "d8759707-7ad9-4567-af03-753b7eed4521" ); + + // Check if we're reading the most up to date type: + if( compareClassGuid( guid ) ) { + xAOD::JGTowerContainer* c = poolReadObject< xAOD::JGTowerContainer >(); + setStoreLink( c , m_key ); + return c; + } + + // If we didn't recognise the ID, let's complain: + throw std::runtime_error( "Unsupported version of " + "xAOD::JGTowerContainer found" ); + return 0; +} + +void xAODJGTowerContainerCnv:: +toPersistent( xAOD::JGTower* /*cluster*/ ) const { + + return; +} diff --git a/Event/xAOD/xAODTrigL1CaloAthenaPool/src/xAODJGTowerContainerCnv.h b/Event/xAOD/xAODTrigL1CaloAthenaPool/src/xAODJGTowerContainerCnv.h new file mode 100755 index 0000000000000000000000000000000000000000..338cd11a46855be800ee332d876f665e5dc75edc --- /dev/null +++ b/Event/xAOD/xAODTrigL1CaloAthenaPool/src/xAODJGTowerContainerCnv.h @@ -0,0 +1,55 @@ +/* + Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration +*/ + + +#ifndef XAODTRIGL1CALOATHENAPOOL_XAODJGTOWERCONTAINERCNV_H +#define XAODTRIGL1CALOATHENAPOOL_XAODJGTOWERCONTAINERCNV_H + +// Gaudi/Athena include(s): +#include "AthenaPoolCnvSvc/T_AthenaPoolCustomCnv.h" + +// EDM include(s): +#include "xAODTrigL1Calo/JGTowerContainer.h" + +/// Type definition for the converter's base +typedef T_AthenaPoolCustomCnv< xAOD::JGTowerContainer, + xAOD::JGTowerContainer > + xAODJGTowerContainerCnvBase; + +/** + * @short POOL converter for the xAOD::JGTowerContainer class + * + * Simple converter class making the xAOD::JGTowerContainer + * class known to POOL. + * + * @author Attila Krasznahorkay + * @author John Morris + * + */ +class xAODJGTowerContainerCnv : public xAODJGTowerContainerCnvBase { + + // Declare the factory as our friend: + friend class CnvFactory< xAODJGTowerContainerCnv >; + +public: + /// Converter constructor + xAODJGTowerContainerCnv( ISvcLocator* svcLoc ); + + /// Re-implemented function in order to get access to the SG key + virtual StatusCode createObj( IOpaqueAddress* pAddr, DataObject*& pObj ); + /// Function preparing the container to be written out + virtual xAOD::JGTowerContainer* createPersistent( xAOD::JGTowerContainer* trans ); + /// Function reading in the persistent object + virtual xAOD::JGTowerContainer* createTransient(); + +private: + /// Function preparing a vertex object for persistence + void toPersistent( xAOD::JGTower* cluster ) const; + + /// StoreGate key of the container just being created + std::string m_key; + +}; // class xAODJGTowerContainerCnv + +#endif diff --git a/Trigger/TrigConfiguration/TrigConfL1Data/Root/ThresholdConfig.cxx b/Trigger/TrigConfiguration/TrigConfL1Data/Root/ThresholdConfig.cxx index 8052fc7fc1caf65008aba2204d22d06dd457f2dc..7ca8c4d3d9515fe22f6048fd974d6ada7ac4bb25 100644 --- a/Trigger/TrigConfiguration/TrigConfL1Data/Root/ThresholdConfig.cxx +++ b/Trigger/TrigConfiguration/TrigConfL1Data/Root/ThresholdConfig.cxx @@ -73,7 +73,7 @@ TrigConf::ThresholdConfig::insertInPosition(std::vector& thrV bool -TrigConf::ThresholdConfig::addTriggerThreshold(TriggerThreshold* thr) { +TrigConf::ThresholdConfig::addTriggerThreshold(TriggerThreshold* thr, bool respectRun2Limits) { // put the threshold into the vector of all thresholds m_TriggerThresholdVector.push_back(thr); @@ -86,9 +86,15 @@ TrigConf::ThresholdConfig::addTriggerThreshold(TriggerThreshold* thr) { // check if maximum is exceeded unsigned int max_thr = L1DataDef::typeConfig(ttype).max; if(thr->mapping()>0 && (unsigned int)thr->mapping() >= max_thr) { - cerr << "ThresholdConfig::addTriggerThreshold: threshold mapping " << thr->mapping() - << " exceeds maximum for type '" << thr->type() << "' , abort!" << endl; - throw runtime_error( "ThresholdConfig::addTriggerThreshold: threshold mapping exceeds limit" ); + if ( respectRun2Limits ) { + cerr << "ThresholdConfig::addTriggerThreshold: threshold mapping " << thr->mapping() + << " exceeds maximum for type '" << thr->type() << "' , abort!" << endl; + throw runtime_error( "ThresholdConfig::addTriggerThreshold: threshold mapping exceeds limit" ); + } else { + // for studying run3 menu + cout << "ThresholdConfig::addTriggerThreshold: threshold mapping " << thr->mapping() + << " (" << thr->name() << ") exceeds Run-2 maximum for type '" << thr->type() << "'. This is just for information, Run-2 limits are set to be ignored." << endl; + } } thr->setThresholdNumber(thr->mapping()); diff --git a/Trigger/TrigConfiguration/TrigConfL1Data/TrigConfL1Data/ThresholdConfig.h b/Trigger/TrigConfiguration/TrigConfL1Data/TrigConfL1Data/ThresholdConfig.h index a2963c2f116e7ef72efb6702915791a260e3d2c0..2a833a4407523491c47f01d9460a1b545c32e27e 100644 --- a/Trigger/TrigConfiguration/TrigConfL1Data/TrigConfL1Data/ThresholdConfig.h +++ b/Trigger/TrigConfiguration/TrigConfL1Data/TrigConfL1Data/ThresholdConfig.h @@ -61,7 +61,7 @@ namespace TrigConf { const CaloInfo& caloInfo() const { return m_CaloInfo; } void setCaloInfo (const CaloInfo& ci) { m_CaloInfo = ci; } - bool addTriggerThreshold(TriggerThreshold* value); // add according to type + bool addTriggerThreshold(TriggerThreshold* value, bool respectRun2Limits = true); // add according to type virtual void print(const std::string& indent="", unsigned int detail=1) const; diff --git a/Trigger/TrigConfiguration/TrigConfStorage/src/MenuLoader.cxx b/Trigger/TrigConfiguration/TrigConfStorage/src/MenuLoader.cxx index 86818c8031b1a52e62180158f4c9ec0b696477c7..d6e6e550202bedcf40c59373c12bc2e8e57a7ae2 100755 --- a/Trigger/TrigConfiguration/TrigConfStorage/src/MenuLoader.cxx +++ b/Trigger/TrigConfiguration/TrigConfStorage/src/MenuLoader.cxx @@ -203,7 +203,7 @@ TrigConf::MenuLoader::loadItems(TrigConf::Menu& menu) { msg() << "MenuLoader: Error loading TriggerThreshold " << thr_info.thrId << endl; throw runtime_error( "MenuLoader::loadItems: error loading TriggerThreshold " ); } - menu.thresholdConfig().addTriggerThreshold(thr_info.thr); + menu.thresholdConfig().addTriggerThreshold(thr_info.thr, /*bool respectRun2Limits =*/ false); } item_thrInfo[ctpid].push_back(thr_info); } diff --git a/Trigger/TrigConfiguration/TrigConfStorage/src/ThresholdConfigLoader.cxx b/Trigger/TrigConfiguration/TrigConfStorage/src/ThresholdConfigLoader.cxx index 40d7d496d29bbf57e59dbcd825ce1d108e2f981b..08899c695a51ddd0126cbac19ad7bfd998f0e0a9 100755 --- a/Trigger/TrigConfiguration/TrigConfStorage/src/ThresholdConfigLoader.cxx +++ b/Trigger/TrigConfiguration/TrigConfStorage/src/ThresholdConfigLoader.cxx @@ -175,7 +175,7 @@ bool TrigConf::ThresholdConfigLoader::load( ThresholdConfig& thrConfig ) { if (tt != 0) { // trigger thresholds sorted by type - thrConfig.addTriggerThreshold(tt); + thrConfig.addTriggerThreshold(tt, /*bool respectRun2Limits =*/ false); tt = new TriggerThreshold(); numberofvalues = 0; } else { @@ -290,7 +290,7 @@ bool TrigConf::ThresholdConfigLoader::load( ThresholdConfig& thrConfig ) { } // trigger thresholds sorted by type - thrConfig.addTriggerThreshold(tt); + thrConfig.addTriggerThreshold(tt, /*bool respectRun2Limits =*/ false); //=========================================== // now get the Thresholds WITHOUT trigger threshold values @@ -363,7 +363,7 @@ bool TrigConf::ThresholdConfigLoader::load( ThresholdConfig& thrConfig ) { if (tt != 0) { //tt->setNumberofValues(numberofvalues); // trigger thresholds sorted by type - thrConfig.addTriggerThreshold(tt); + thrConfig.addTriggerThreshold(tt, /*bool respectRun2Limits =*/ false); tt = new TriggerThreshold(); numberofvalues = 0; } else { diff --git a/Trigger/TrigConfiguration/TrigConfStorage/src/XMLMenuLoader.cxx b/Trigger/TrigConfiguration/TrigConfStorage/src/XMLMenuLoader.cxx index 3fd6b362df4b6bee5a90f333d7e9bce0a5e0fb1c..244c19c32e65cf43897fd1fe170888ec64fdfcc5 100755 --- a/Trigger/TrigConfiguration/TrigConfStorage/src/XMLMenuLoader.cxx +++ b/Trigger/TrigConfiguration/TrigConfStorage/src/XMLMenuLoader.cxx @@ -35,6 +35,8 @@ TrigConf::XMLMenuLoader::load(Menu& menu) { IThresholdConfigLoader& thrcfgloader = m_storageMgr.thresholdConfigLoader(); thrcfgloader.setLevel(outputLevel()); thrcfgloader.load( menu.thresholdConfig() ); + std::cerr << std::flush; + std::cout << std::flush; TRG_MSG_INFO("Number of thresholds in the menu: " << menu.thresholdConfig().size()); for(value_type v: pt()) { @@ -122,10 +124,10 @@ TrigConf::XMLMenuLoader::readNode(const ptree::value_type& pt, trig_node->setTriggerThreshold(trig_thr); trig_node->setMultiplicity(mult); } else { - msg() << "XMLMenuLoader: ERROR cannot find threshold " << thr_name << std::endl; + TRG_MSG_ERROR("cannot find threshold " << thr_name); } } else { - msg() << "XMLMenuLoader: ERROR TriggerCondition without threshold " << std::endl; + TRG_MSG_ERROR("TriggerCondition without threshold"); } } else if (node_name == "InternalTrigger") { std::string thr_name(""); diff --git a/Trigger/TrigConfiguration/TrigConfStorage/src/XMLThresholdConfigLoader.cxx b/Trigger/TrigConfiguration/TrigConfStorage/src/XMLThresholdConfigLoader.cxx index 7ce0d5be9b9ca2baddb9009df04dd6288541ee02..49d9b7c44fbfbbe48005e9fb1a4285038ec7cfeb 100755 --- a/Trigger/TrigConfiguration/TrigConfStorage/src/XMLThresholdConfigLoader.cxx +++ b/Trigger/TrigConfiguration/TrigConfStorage/src/XMLThresholdConfigLoader.cxx @@ -27,15 +27,19 @@ XMLThresholdConfigLoader::load( ThresholdConfig& thrcfg ) { TRG_MSG_DEBUG("Loading ThresholdConfig object") + bool respectRun2Limits = false; + // Get the thresholds XMLTriggerThresholdLoader* thr_ldr = new XMLTriggerThresholdLoader(m_storageMgr); thr_ldr->setLevel(outputLevel()); for(value_type v: pt() ) { + if(v.first == "") // ignore comments between the TriggerThresholds + continue; thr_ldr->setPtree(&v); TriggerThreshold* thr = new TriggerThreshold(); if (thr_ldr->load(*thr)) { - TRG_MSG_DEBUG("Adding trigger threshold " << *thr << "(type " << thr->ttype() << ", mapping " << thr->mapping() << ")") - thrcfg.addTriggerThreshold(thr); + TRG_MSG_DEBUG("Adding trigger threshold " << *thr << "(type " << thr->ttype() << ", mapping " << thr->mapping() << ")"); + thrcfg.addTriggerThreshold(thr, respectRun2Limits); } } delete thr_ldr; diff --git a/Trigger/TrigConfiguration/TrigConfigSvc/src/LVL1ConfigSvc.cxx b/Trigger/TrigConfiguration/TrigConfigSvc/src/LVL1ConfigSvc.cxx index c782fd40a0933ff8f7d6903af3d66cc6efe11dbf..7a0da9e474fd3350eb81849d6c3281c53763f03e 100644 --- a/Trigger/TrigConfiguration/TrigConfigSvc/src/LVL1ConfigSvc.cxx +++ b/Trigger/TrigConfiguration/TrigConfigSvc/src/LVL1ConfigSvc.cxx @@ -134,12 +134,14 @@ LVL1ConfigSvc::initialize() { // // Check if we have a valid trigger menu: // - if( Verifyer::verify( m_ctpConfig->menu(), msg() ) ) { - ATH_MSG_ERROR("Loaded trigger menu fails verification"); - return StatusCode::FAILURE; - } else { - ATH_MSG_DEBUG("Loaded trigger menu passed verification"); - } + ATH_MSG_INFO("Disabled L1 menu verification for Run-3 studies"); +// if( Verifyer::verify( m_ctpConfig->menu(), msg() ) ) { +// ATH_MSG_ERROR("Loaded trigger menu fails verification"); +// return StatusCode::FAILURE; +// } else { +// ATH_MSG_DEBUG("Loaded trigger menu passed verification"); +// } +// ATH_MSG_DEBUG("Dumping LVL1 configuration");