diff --git a/MuonSpectrometer/MuonValidation/MuonPRDTest/share/NSWPRDValAlg.digi.py b/MuonSpectrometer/MuonValidation/MuonPRDTest/share/NSWPRDValAlg.digi.py index 1b1068991387cd32797f7ef80e605c0de062d59a..b057cc32bb7190e05b5a61f0680bb9eddf506b4f 100644 --- a/MuonSpectrometer/MuonValidation/MuonPRDTest/share/NSWPRDValAlg.digi.py +++ b/MuonSpectrometer/MuonValidation/MuonPRDTest/share/NSWPRDValAlg.digi.py @@ -32,10 +32,12 @@ NSWPRDValAlg.doSTGCFastDigit = False NSWPRDValAlg.doRPCHit = True NSWPRDValAlg.doRPCSDO = True NSWPRDValAlg.doRPCDigit = True +NSWPRDValAlg.doRPCRDO = True NSWPRDValAlg.doMDTHit = True NSWPRDValAlg.doMDTSDO = True NSWPRDValAlg.doMDTDigit = True +#NSWPRDValAlg.doMDTRDO = True NSWPRDValAlg.doTGCHit= True NSWPRDValAlg.doTGCDigit= True diff --git a/MuonSpectrometer/MuonValidation/MuonPRDTest/share/NSWPRDValAlg.reco.py b/MuonSpectrometer/MuonValidation/MuonPRDTest/share/NSWPRDValAlg.reco.py index fe70112dc6622507d9f449df32b10c455c47cc2d..0bf5697dd65621a87d9088ab8798ad1bdeb8910d 100644 --- a/MuonSpectrometer/MuonValidation/MuonPRDTest/share/NSWPRDValAlg.reco.py +++ b/MuonSpectrometer/MuonValidation/MuonPRDTest/share/NSWPRDValAlg.reco.py @@ -33,10 +33,12 @@ NSWPRDValAlg.doSTGCFastDigit = False NSWPRDValAlg.doRPCHit = False # no RPC_Hits present in RDO files NSWPRDValAlg.doRPCSDO = True NSWPRDValAlg.doRPCDigit = False # no RPC_DIGITS present in RDO files +NSWPRDValAlg.doRPCRDO = True NSWPRDValAlg.doMDTHit = False # no MDT_Hits present in RDO files NSWPRDValAlg.doMDTSDO = True NSWPRDValAlg.doMDTDigit = False # no MDT_DIGITS present in RDO files +#NSWPRDValAlg.doMDTRDO = True NSWPRDValAlg.doTGCHit = False # no TGC_Hits present in RDO files NSWPRDValAlg.doTGCDigit = False # no TGC_DIGITS present in RDO files diff --git a/MuonSpectrometer/MuonValidation/MuonPRDTest/src/NSWPRDValAlg.cxx b/MuonSpectrometer/MuonValidation/MuonPRDTest/src/NSWPRDValAlg.cxx index 9cd35bc77d8ad8f4026315d3fc9c9334715565f1..b497d32610930bde1a9269bb189a6937cd256a62 100644 --- a/MuonSpectrometer/MuonValidation/MuonPRDTest/src/NSWPRDValAlg.cxx +++ b/MuonSpectrometer/MuonValidation/MuonPRDTest/src/NSWPRDValAlg.cxx @@ -45,9 +45,11 @@ NSWPRDValAlg::NSWPRDValAlg(const std::string& name, ISvcLocator* pSvcLocator) : declareProperty("MDT_SimContainerName", m_MDT_SimContainerName="MDT_Hits"); declareProperty("MDT_SDOContainerName", m_MDT_SDOContainerName="MDT_SDO"); declareProperty("MDT_DigitContainerName", m_MDT_DigitContainerName="MDT_DIGITS"); +// DeclareProperty("MDT_RDOContainerName", m_MDT_SDOContainerName="MDT_RDO"); declareProperty("RPC_SimContainerName", m_RPC_SimContainerName="RPC_Hits"); declareProperty("RPC_SDOContainerName", m_RPC_SDOContainerName="RPC_SDO"); declareProperty("RPC_DigitContainerName", m_RPC_DigitContainerName="RPC_DIGITS"); + declareProperty("RPC_RDOContainerName", m_RPC_RDOContainerName="RPCRDO"); declareProperty("CSC_SimContainerName", m_CSC_SimContainerName="CSC_Hits"); declareProperty("TGC_SimContainerName", m_TGC_SimContainerName="TGC_Hits"); declareProperty("TGC_RDOContainerName", m_TGC_RDOContainerName="TGCRDO"); @@ -70,9 +72,11 @@ NSWPRDValAlg::NSWPRDValAlg(const std::string& name, ISvcLocator* pSvcLocator) : declareProperty("doMDTHit", m_doMDTHit=false); declareProperty("doMDTSDO", m_doMDTSDO=false); declareProperty("doMDTDigit", m_doMDTDigit=false); +// declareProperty("doMDTRDO", m_doMDTRDO=false); declareProperty("doRPCHit", m_doRPCHit=false); declareProperty("doRPCSDO", m_doRPCSDO=false); declareProperty("doRPCDigit", m_doRPCDigit=false); + declareProperty("doRPCRDO", m_doRPCRDO=false); declareProperty("doCSCHit", m_doCSCHit=false); declareProperty("doTGCHit", m_doTGCHit=false); declareProperty("doTGCRDO", m_doTGCRDO=false); @@ -218,7 +222,11 @@ StatusCode NSWPRDValAlg::initialize() { &m_idHelperSvc->mdtIdHelper(), m_tree, m_MDT_DigitContainerName, msgLevel()); ATH_CHECK( m_MDTDigitVar->initializeVariables() ); } - +/* if (m_doMDTRDO){ + m_MDTSDOVar = std::make_unique(&(*(evtStore())), m_muonDetMgrDS, + &m_idHelperSvc->mdtIdHelper(), m_tree, m_MDT_RDOContainerName, msgLevel()); + ATH_CHECK( m_MDTRDOVar->initializeVariables() ); + }*/ if (m_doRPCHit){ m_RPCSimHitVar = std::make_unique(&(*(evtStore())), m_muonDetMgrDS, &m_idHelperSvc->rpcIdHelper(), m_tree, m_RPC_SimContainerName, msgLevel()); @@ -235,6 +243,12 @@ StatusCode NSWPRDValAlg::initialize() { ATH_CHECK( m_RPCDigitVar->initializeVariables() ); } + if (m_doRPCRDO){ + m_RPCRDOVar = std::make_unique(&(*(evtStore())), m_muonDetMgrDS, + &m_idHelperSvc->rpcIdHelper(), m_tree, m_RPC_RDOContainerName, msgLevel()); + ATH_CHECK( m_RPCRDOVar->initializeVariables() ); + } + if (m_doCSCHit){ m_CSCSimHitVar = std::make_unique(&(*(evtStore())), m_muonDetMgrDS, &m_idHelperSvc->cscIdHelper(), m_tree, m_CSC_SimContainerName, msgLevel()); @@ -329,11 +343,13 @@ StatusCode NSWPRDValAlg::execute() if (m_doMDTHit) ATH_CHECK( m_MDTSimHitVar->fillVariables(muonDetMgr) ); if (m_doMDTSDO) ATH_CHECK( m_MDTSDOVar->fillVariables(muonDetMgr) ); if (m_doMDTDigit) ATH_CHECK( m_MDTDigitVar->fillVariables(muonDetMgr) ); - + // if (m_doMDTRDO) ATH_CHECK( m_MDTRDOVar->fillVariables(muonDetMgr) ); + if (m_doRPCHit) ATH_CHECK( m_RPCSimHitVar->fillVariables(muonDetMgr) ); if (m_doRPCSDO) ATH_CHECK( m_RPCSDOVar->fillVariables(muonDetMgr) ); if (m_doRPCDigit) ATH_CHECK( m_RPCDigitVar->fillVariables(muonDetMgr) ); - + if (m_doRPCRDO) ATH_CHECK( m_RPCRDOVar->fillVariables(muonDetMgr) ); + if (m_doCSCHit) ATH_CHECK( m_CSCSimHitVar->fillVariables(muonDetMgr) ); if (m_doTGCHit) ATH_CHECK( m_TGCSimHitVar->fillVariables(muonDetMgr) ); diff --git a/MuonSpectrometer/MuonValidation/MuonPRDTest/src/NSWPRDValAlg.h b/MuonSpectrometer/MuonValidation/MuonPRDTest/src/NSWPRDValAlg.h index fd769bfc5cdb560149f26f59e54f1f7fabac1f31..bca17097ce502c86aa695ceb0163581b4bad36be 100644 --- a/MuonSpectrometer/MuonValidation/MuonPRDTest/src/NSWPRDValAlg.h +++ b/MuonSpectrometer/MuonValidation/MuonPRDTest/src/NSWPRDValAlg.h @@ -20,9 +20,11 @@ #include "MDTSimHitVariables.h" #include "MDTSDOVariables.h" #include "MDTDigitVariables.h" +//#include "MDTRDOVariables.h" #include "RPCSimHitVariables.h" #include "RPCSDOVariables.h" #include "RPCDigitVariables.h" +#include "RPCRDOVariables.h" #include "CSCSimHitVariables.h" #include "CSCDigitVariables.h" #include "TGCSimHitVariables.h" @@ -75,9 +77,11 @@ class NSWPRDValAlg:public AthAlgorithm std::unique_ptr m_MDTSimHitVar; std::unique_ptr m_MDTSDOVar; std::unique_ptr m_MDTDigitVar; +// std::unique_ptr m_MDTRDOVar; std::unique_ptr m_RPCSimHitVar; std::unique_ptr m_RPCSDOVar; std::unique_ptr m_RPCDigitVar; + std::unique_ptr m_RPCRDOVar; std::unique_ptr m_CSCSimHitVar; std::unique_ptr m_TGCSimHitVar; std::unique_ptr m_TgcRdoVar; @@ -116,9 +120,11 @@ class NSWPRDValAlg:public AthAlgorithm BooleanProperty m_doMDTHit; // switch on the output of the MDT simulated hits BooleanProperty m_doMDTSDO; // switch on the output of the MDT SDO BooleanProperty m_doMDTDigit; // switch on the output of the MDT digitization +// BooleanProperty m_doMDTRDO; // switch on the output of the MDT RDO BooleanProperty m_doRPCHit; // switch on the output of the RPC simulated hits BooleanProperty m_doRPCSDO; // switch on the output of the RPC SDO BooleanProperty m_doRPCDigit; // switch on the output of the RPC digitization + BooleanProperty m_doRPCRDO; // switch on the output of the RPC RDO BooleanProperty m_doTGCHit; // switch on the output of the TGC simulated hits BooleanProperty m_doTGCRDO; // switch on the output of the TGC digitization @@ -141,9 +147,11 @@ class NSWPRDValAlg:public AthAlgorithm std::string m_MDT_SimContainerName; std::string m_MDT_SDOContainerName; std::string m_MDT_DigitContainerName; +// std::string m_MDT_RDOContainerName; std::string m_RPC_SimContainerName; std::string m_RPC_SDOContainerName; std::string m_RPC_DigitContainerName; + std::string m_RPC_RDOContainerName; std::string m_CSC_SimContainerName; std::string m_TGC_SimContainerName; std::string m_TGC_RDOContainerName; diff --git a/MuonSpectrometer/MuonValidation/MuonPRDTest/src/RPCRDOVariables.cxx b/MuonSpectrometer/MuonValidation/MuonPRDTest/src/RPCRDOVariables.cxx new file mode 100644 index 0000000000000000000000000000000000000000..b15be8dd89d9885b612ea9948c7a9f3471f75b8e --- /dev/null +++ b/MuonSpectrometer/MuonValidation/MuonPRDTest/src/RPCRDOVariables.cxx @@ -0,0 +1,228 @@ +/* + Copyright (C) 2002-2021 CERN for the benefit of the ATLAS collaboration +*/ + +#include "RPCRDOVariables.h" +#include "AthenaBaseComps/AthAlgorithm.h" + +#include "MuonReadoutGeometry/RpcReadoutElement.h" +#include "MuonSimData/MuonSimDataCollection.h" + +#include "MuonRDO/RpcPadContainer.h" + +#include "TTree.h" +#include // for Form + +using namespace Muon; + +/** ---------- filling of variables */ +/** ---------- to be called on each evt i.e. execute level of main alg */ +StatusCode RpcRDOVariables::fillVariables(const MuonGM::MuonDetectorManager* MuonDetMgr) +{ + ATH_MSG_DEBUG(" do fillRpcRDOVariables()"); + + // clear variables + CHECK( this->clearVariables() ); + + // get the rdo(a container corresponds to a pad of a module) + const RpcPadContainer* rdo_container = nullptr; + CHECK( m_evtStore->retrieve(rdo_container, m_ContainerName.c_str()) ); + + ATH_MSG_DEBUG("retrieved RPC RDO Container with size "<pad_size()); + + if(RpcRDOContainer->size()==0) ATH_MSG_DEBUG(" RPC RDO Container empty "); + + // iteration on all containers, i.e. all pads of all modules + for(const RpcPadCollection* coll : *rdo_container) { + ATH_MSG_DEBUG( "processing collection with size " << coll->size() ); + + // a rdoit collection is instanciated for each container, i.e. holds all rdoits of a pad + // loop on all rdoits inside a collection, i.e. pad + for (unsigned int rdoNum=0; rdoNumsize(); rdoNum++) { + + // get specific rdoit and identify it + const RpcRDO* rdo = coll->at(rdoNum); + Identifier Id = rdo->identify(); + + std::string stName = m_RpcIdHelper->stationNameString(m_RpcIdHelper->stationName(Id)); + int stationEta = m_RpcIdHelper->stationEta(Id); + int stationPhi = m_RpcIdHelper->stationPhi(Id); + int doubletR = m_RpcIdHelper->doubletR(Id); + int doubletZ = m_RpcIdHelper->doubletZ(Id); + int doubletPhi = m_RpcIdHelper->doubletPhi(Id); + int gas_gap = m_RpcIdHelper->gasGap(Id); + bool measuresPhi = m_RpcIdHelper->measuresPhi(Id); + int strip = m_RpcIdHelper->strip(Id); + int channel = m_RpcIdHelper->channel(Id); + + int measuresPhiMin = m_RpcIdHelper->measuresPhiMin(Id); + int measuresPhiMax = m_RpcIdHelper->measuresPhiMax(Id); + int stationEtaMin = m_RpcIdHelper->stationEtaMin(Id); + int stationEtaMax = m_RpcIdHelper->stationEtaMax(Id); + int stationPhiMin = m_RpcIdHelper->stationPhiMin(Id); + int stationPhiMax = m_RpcIdHelper->stationPhiMax(Id); + int doubletRMin = m_RpcIdHelper->doubletRMin(Id); + int doubletRMax = m_RpcIdHelper->doubletRMax(Id); + int doubletZMin = m_RpcIdHelper->doubletZMin(Id); + int doubletZMax = m_RpcIdHelper->doubletZMax(Id); + int doubletPhiMin = m_RpcIdHelper->doubletPhiMin(Id); + int doubletPhiMax = m_RpcIdHelper->doubletPhiMax(Id); + int gas_gapMin = m_RpcIdHelper->gasGapMin(Id); + int gas_gapMax = m_RpcIdHelper->gasGapMax(Id); + int stripMin = m_RpcIdHelper->stripMin(Id); + int stripMax = m_RpcIdHelper->stripMax(Id); + + ATH_MSG_DEBUG( "RPC RDO Offline id: Station Name [" << stName << " ]" + << " Station Eta [" << stationEta << "]" + << " Station Phi [" << stationPhi << "]" + << " GasGap [" << gas_gap << "]"); + + const MuonGM::RpcReadoutElement* rdoEl = MuonDetMgr->getRpcReadoutElement(Id); + if (!rdoEl) return StatusCode::FAILURE; + + Amg::Vector3D gpos(0.,0.,0.); + Amg::Vector2D lpos(0.,0.); + + rdoEl->stripPosition(Id,lpos); + rdoEl->surface(Id).localToGlobal(lpos, gpos,gpos); + + m_RPC_rdo_localPosX.push_back( lpos.x() ); + m_RPC_rdo_localPosY.push_back( lpos.y() ); + m_RPC_rdo_globalPosX.push_back( gpos.x() ); + m_RPC_rdo_globalPosY.push_back( gpos.y() ); + m_RPC_rdo_globalPosZ.push_back( gpos.z() ); + + stripNumber = rdoEl->stripNumber(lpos,Id); + + m_RPC_rdo_stationName.push_back(stName); + m_RPC_rdo_time.push_back(rdoit->time()); + m_RPC_rdo_stationEta.push_back(stationEta); + m_RPC_rdo_stationPhi.push_back(stationPhi); + m_RPC_rdo_gas_gap.push_back(gas_gap); + m_RPC_rdo_doubletR.push_back(doubletR); + m_RPC_rdo_doubletZ.push_back(doubletZ); + m_RPC_rdo_doubletPhi.push_back(doubletPhi); + m_RPC_rdo_strip.push_back(strip); + m_RPC_rdo_strip.push_back(stripNumber); + m_RPC_rdo_channel.push_back(channel); + m_RPC_rdo_stripNumber.push_back(channel); + m_RPC_rdo_measuresPhi.push_back(measuresPhi); + + m_RPC_rdo_stationEtaMin.push_back(stationEtaMin); + m_RPC_rdo_stationEtaMax.push_back(stationEtaMax); + m_RPC_rdo_stationPhiMin.push_back(stationPhiMin); + m_RPC_rdo_stationPhiMax.push_back(stationPhiMax); + m_RPC_rdo_doubletRMin.push_back(doubletRMin); + m_RPC_rdo_doubletRMax.push_back(doubletRMax); + m_RPC_rdo_doubletZMin.push_back(doubletZMin); + m_RPC_rdo_doubletZMax.push_back(doubletZMax); + m_RPC_rdo_doubletPhiMin.push_back(doubletPhiMin); + m_RPC_rdo_doubletPhiMax.push_back(doubletPhiMax); + m_RPC_rdo_gas_gapMin.push_back(gas_gapMin); + m_RPC_rdo_gas_gapMax.push_back(gas_gapMax); + m_RPC_rdo_stripMin.push_back(stripMin); + m_RPC_rdo_stripMax.push_back(stripMax); + m_RPC_rdo_measuresPhi.push_back(measuresPhiMin); + m_RPC_rdo_measuresPhi.push_back(measuresPhiMax); + + // rdo counter for the ntuple + m_RPC_nRDO++; + } + } + ATH_MSG_DEBUG(" finished fillRpcRDOVariables()"); + return StatusCode::SUCCESS; +} + +/** ---------- clearing of variables */ +/** ---------- to be called inside filling method before filling starts */ +StatusCode RpcRDOVariables::clearVariables() +{ + m_RPC_nRDO = 0; + m_RPC_rdo_time.clear(); + m_RPC_rdo_stationName.clear(); + m_RPC_rdo_stationEta.clear(); + m_RPC_rdo_stationPhi.clear(); + m_RPC_rdo_gas_gap.clear(); + m_RPC_rdo_doubletR.clear(); + m_RPC_rdo_doubletZ.clear(); + m_RPC_rdo_doubletPhi.clear(); + m_RPC_rdo_strip.clear(); + m_RPC_rdo_channel.clear(); + m_RPC_rdo_stripNumber.clear(); + m_RPC_rdo_measuresPhi.clear(); + + m_RPC_rdo_stationEtaMin.clear(); + m_RPC_rdo_stationEtaMax.clear(); + m_RPC_rdo_stationPhiMin.clear(); + m_RPC_rdo_stationPhiMax.clear(); + m_RPC_rdo_doubletRMin.clear(); + m_RPC_rdo_doubletRMax.clear(); + m_RPC_rdo_doubletZMin.clear(); + m_RPC_rdo_doubletZMax.clear(); + m_RPC_rdo_doubletPhiMin.clear(); + m_RPC_rdo_doubletPhiMax.clear(); + m_RPC_rdo_gas_gapMin.clear(); + m_RPC_rdo_gas_gapMax.clear(); + m_RPC_rdo_stripMin.clear(); + m_RPC_rdo_stripMax.clear(); + m_RPC_rdo_measuresPhiMin.clear(); + m_RPC_rdo_measuresPhiMax.clear(); + + m_RPC_rdo_localPosX.clear(); + m_RPC_rdo_localPosY.clear(); + m_RPC_rdo_globalPosX.clear(); + m_RPC_rdo_globalPosY.clear(); + m_RPC_rdo_globalPosZ.clear(); + + return StatusCode::SUCCESS; +} + +/** ---------- creating variables and associate them to branches */ +/** ---------- to be called on initialization level of main alg */ +StatusCode RpcRDOVariables::initializeVariables() +{ + if(m_tree) { + ATH_MSG_DEBUG("RPC rdo: init m_tree "); + m_tree->Branch("RDO_RPC", &m_RPC_nRDO, "RDO_RPC_n/i"); + m_tree->Branch("RDO_RPC_time", &m_RPC_rdo_time); + + m_tree->Branch("RDO_RPC_stationName", &m_RPC_rdo_stationName); + m_tree->Branch("RDO_RPC_stationEta", &m_RPC_rdo_stationEta); + m_tree->Branch("RDO_RPC_stationPhi", &m_RPC_rdo_stationPhi); + m_tree->Branch("RDO_RPC_gas_gap", &m_RPC_rdo_gas_gap); + m_tree->Branch("RDO_RPC_doubletR", &m_RPC_rdo_doubletR); + m_tree->Branch("RDO_RPC_doubletZ", &m_RPC_rdo_doubletZ); + m_tree->Branch("RDO_RPC_doubletPhi", &m_RPC_rdo_doubletPhi); + m_tree->Branch("RDO_RPC_strip", &m_RPC_rdo_strip); + m_tree->Branch("RDO_RPC_channel", &m_RPC_rdo_channel); + m_tree->Branch("RDO_RPC_stripNumber", &m_RPC_rdo_stripNumber); + m_tree->Branch("RDO_RPC_measuresPhi", &m_RPC_rdo_measuresPhi); + + m_tree->Branch("RDO_RPC_stationEtaMin", &m_RPC_rdo_stationEtaMin); + m_tree->Branch("RDO_RPC_stationEtaMax", &m_RPC_rdo_stationEtaMax); + m_tree->Branch("RDO_RPC_stationPhiMin", &m_RPC_rdo_stationPhiMin); + m_tree->Branch("RDO_RPC_stationPhiMax", &m_RPC_rdo_stationPhiMax); + m_tree->Branch("RDO_RPC_doubletRmin", &m_RPC_rdo_doubletRMin); + m_tree->Branch("RDO_RPC_doubletRMax", &m_RPC_rdo_doubletRMax); + m_tree->Branch("RDO_RPC_doubletZmin", &m_RPC_rdo_doubletZMin); + m_tree->Branch("RDO_RPC_doubletZMax", &m_RPC_rdo_doubletZMax); + m_tree->Branch("RDO_RPC_doubletPhiMin", &m_RPC_rdo_doubletPhiMin); + m_tree->Branch("RDO_RPC_doubletPhiMax", &m_RPC_rdo_doubletPhiMax); + m_tree->Branch("RDO_RPC_gas_gapMin", &m_RPC_rdo_gas_gapMin); + m_tree->Branch("RDO_RPC_gas_gapMax", &m_RPC_rdo_gas_gapMax); + m_tree->Branch("RDO_RPC_stripMin", &m_RPC_rdo_stripMin); + m_tree->Branch("RDO_RPC_stripMax", &m_RPC_rdo_stripMax); + m_tree->Branch("RDO_RPC_measuresPhiMin", &m_RPC_rdo_measuresPhiMin); + m_tree->Branch("RDO_RPC_measuresPhiMax", &m_RPC_rdo_measuresPhiMax); + + m_tree->Branch("RDO_RPC_localPosX", &m_RPC_rdo_localPosX); + m_tree->Branch("RDO_RPC_localPosY", &m_RPC_rdo_localPosY); + m_tree->Branch("RDO_RPC_globalPosX", &m_RPC_rdo_globalPosX); + m_tree->Branch("RDO_RPC_globalPosY", &m_RPC_rdo_globalPosY); + m_tree->Branch("RDO_RPC_globalPosZ", &m_RPC_rdo_globalPosZ); + + } + + return StatusCode::SUCCESS; +} + diff --git a/MuonSpectrometer/MuonValidation/MuonPRDTest/src/RPCRDOVariables.h b/MuonSpectrometer/MuonValidation/MuonPRDTest/src/RPCRDOVariables.h new file mode 100644 index 0000000000000000000000000000000000000000..cddce84fd1d1929eacb6f76737c0c14c83e9e147 --- /dev/null +++ b/MuonSpectrometer/MuonValidation/MuonPRDTest/src/RPCRDOVariables.h @@ -0,0 +1,84 @@ +/* + Copyright (C) 2002-2021 CERN for the benefit of the ATLAS collaboration +*/ + +#ifndef MuonPRDTEST_RPCRDOVARIABLES_H +#define MuonPRDTEST_RPCRDOVARIABLES_H + +#include "ValAlgVariables.h" +#include "MuonIdHelpers/RpcIdHelper.h" +#include "AthenaBaseComps/AthMsgStreamMacros.h" +#include + +class RpcRDOVariables : public ValAlgVariables +{ + public: + RpcRDOVariables(StoreGateSvc* evtStore, + const MuonGM::MuonDetectorManager* detManager, + const MuonIdHelper* idhelper, + TTree* tree, + std::string containername, + MSG::Level msglvl) : + ValAlgVariables(evtStore, detManager, tree, containername, msglvl) + { + setHelper(idhelper); + } + + ~RpcRDOVariables() = default; + + StatusCode initializeVariables(); + StatusCode fillVariables(const MuonGM::MuonDetectorManager* MuonDetMgr); + + private: + + void setHelper(const MuonIdHelper* idhelper){ + m_RpcIdHelper = dynamic_cast(idhelper); + if (!m_RpcIdHelper){ + throw std::runtime_error("Could not cast the RPCIdHelper"); + } + } + + void deleteVariables(){}; + StatusCode clearVariables(); + + const RpcIdHelper* m_RpcIdHelper; + + int m_RPC_nRDO; + std::vector m_RPC_rdo_stationName; + std::vector m_RPC_rdo_time; + std::vector m_RPC_rdo_stationEta; + std::vector m_RPC_rdo_stationPhi; + std::vector m_RPC_rdo_gas_gap; + std::vector m_RPC_rdo_doubletR; + std::vector m_RPC_rdo_doubletZ; + std::vector m_RPC_rdo_doubletPhi; + std::vector m_RPC_rdo_strip; + std::vector m_RPC_rdo_channel; + std::vector m_RPC_rdo_stripNumber; + std::vector m_RPC_rdo_measuresPhi; + + std::vector m_RPC_rdo_stationEtaMin; + std::vector m_RPC_rdo_stationEtaMax; + std::vector m_RPC_rdo_stationPhiMin; + std::vector m_RPC_rdo_stationPhiMax; + std::vector m_RPC_rdo_doubletRMin; + std::vector m_RPC_rdo_doubletRMax; + std::vector m_RPC_rdo_doubletZMin; + std::vector m_RPC_rdo_doubletZMax; + std::vector m_RPC_rdo_doubletPhiMin; + std::vector m_RPC_rdo_doubletPhiMax; + std::vector m_RPC_rdo_gas_gapMin; + std::vector m_RPC_rdo_gas_gapMax; + std::vector m_RPC_rdo_stripMin; + std::vector m_RPC_rdo_stripMax; + std::vector m_RPC_rdo_measuresPhiMin; + std::vector m_RPC_rdo_measuresPhiMax; + + std::vector< double > m_RPC_rdo_localPosX; + std::vector< double > m_RPC_rdo_localPosY; + std::vector< double > m_RPC_rdo_globalPosX; + std::vector< double > m_RPC_rdo_globalPosY; + std::vector< double > m_RPC_rdo_globalPosZ; +}; + +#endif // MuonPRDTEST_RPCRDOVARIABLES_H