diff --git a/MuonSpectrometer/MuonValidation/MuonPRDTest/src/CSCPRDVariables.cxx b/MuonSpectrometer/MuonValidation/MuonPRDTest/src/CSCPRDVariables.cxx
new file mode 100644
index 0000000000000000000000000000000000000000..892a6362310f5ae94eab7a28c0bb6efd4b7d5ce1
--- /dev/null
+++ b/MuonSpectrometer/MuonValidation/MuonPRDTest/src/CSCPRDVariables.cxx
@@ -0,0 +1,138 @@
+/*
+ Copyright (C) 2002-2021 CERN for the benefit of the ATLAS collaboration
+*/
+
+#include "CSCPRDVariables.h"
+#include "AthenaKernel/errorcheck.h"
+
+#include "MuonPrepRawData/CscPrepDataContainer.h"
+
+#include "MuonReadoutGeometry/CscReadoutElement.h"
+
+#include "TTree.h"
+
+StatusCode CSCPRDVariables::fillVariables(const MuonGM::MuonDetectorManager* MuonDetMgr)
+{
+ ATH_MSG_DEBUG("do fillCSCPRDVariables()");
+ ATH_MSG_VERBOSE("MuonDetectorManager from Conditions Store accessed" << MuonDetMgr);
+ CHECK( this->clearVariables() );
+
+ const Muon::CscPrepDataContainer *Csc_PrepDataContainer = nullptr;
+ CHECK( m_evtStore->retrieve(Csc_PrepDataContainer, m_ContainerName.c_str()) );
+
+ if(Csc_PrepDataContainer->size()==0) ATH_MSG_WARNING(" CSC PRD Container empty ");
+
+ for(auto it : *Csc_PrepDataContainer ) {
+
+ const Muon::CscPrepDataCollection* coll = it;
+
+ for (auto prd: *coll) {
+
+ Identifier Id = prd->identify();
+
+ std::string stName = m_CscIdHelper->stationNameString(m_CscIdHelper->stationName(Id));
+ int stationEta = m_CscIdHelper->stationEta(Id);
+ int stationPhi = m_CscIdHelper->stationPhi(Id);
+ int channel = m_CscIdHelper->channel(Id);
+ int chlayer = m_CscIdHelper->chamberLayer(Id);
+ int wlayer = m_CscIdHelper->wireLayer(Id);
+ int measuresPhi = m_CscIdHelper->measuresPhi(Id);
+ int strip = m_CscIdHelper->strip(Id);
+ int charge = prd->charge();
+ int time = prd->time();
+
+ ATH_MSG_DEBUG( "CSC PRD Offline id: Station Name [" << stName << "]"
+ << " Station Eta [" << stationEta << "]"
+ << " Station Phi [" << stationPhi << "]"
+ << " ChNr [" << channel << "]"
+ << " chamber layer [" << chlayer << "]"
+ << " wire layer [" << wlayer << "]"
+ << " measures phi [" << measuresPhi << "]"
+ << " strip [" << strip << "]" );
+
+ m_CSC_PRD_stationName.push_back(stName);
+ m_CSC_PRD_stationEta.push_back(stationEta);
+ m_CSC_PRD_stationPhi.push_back(stationPhi);
+ m_CSC_PRD_channel.push_back(channel);
+ m_CSC_PRD_chlayer.push_back(chlayer);
+ m_CSC_PRD_wlayer.push_back(wlayer);
+ m_CSC_PRD_measuresPhi.push_back(measuresPhi);
+ m_CSC_PRD_strip.push_back(strip);
+ m_CSC_PRD_charge.push_back(charge);
+ m_CSC_PRD_time.push_back(time);
+
+ const MuonGM::CscReadoutElement* det = prd->detectorElement();
+ if (!det) throw std::runtime_error(Form("File: %s, Line: %d\nCSCPRDVariables::fillVariables() - no associated detectorElement", __FILE__, __LINE__));
+ Amg::Vector3D pos = prd->globalPosition();
+ Amg::Vector2D loc_pos(0., 0.);
+
+ det->surface(Id).globalToLocal(pos, Amg::Vector3D(0., 0., 0.), loc_pos);
+
+ m_CSC_PRD_globalPosX.push_back(pos.x());
+ m_CSC_PRD_globalPosY.push_back(pos.y());
+ m_CSC_PRD_globalPosZ.push_back(pos.z());
+
+ m_CSC_PRD_localPosX.push_back(loc_pos[0]);
+ m_CSC_PRD_localPosY.push_back(loc_pos[1]);
+
+ m_CSC_PRD_nPRDs++;
+ }
+ }
+
+ ATH_MSG_DEBUG("processed " << m_CSC_PRD_nPRDs << " CSC PRD's");
+
+ return StatusCode::SUCCESS;
+}
+
+StatusCode CSCPRDVariables::clearVariables()
+{
+
+ m_CSC_PRD_nPRDs = 0;
+
+ m_CSC_PRD_stationName.clear();
+ m_CSC_PRD_stationEta.clear();
+ m_CSC_PRD_stationPhi.clear();
+ m_CSC_PRD_channel.clear();
+ m_CSC_PRD_chlayer.clear();
+ m_CSC_PRD_wlayer.clear();
+ m_CSC_PRD_measuresPhi.clear();
+ m_CSC_PRD_strip.clear();
+ m_CSC_PRD_charge.clear();
+ m_CSC_PRD_time.clear();
+
+ m_CSC_PRD_globalPosX.clear();
+ m_CSC_PRD_globalPosY.clear();
+ m_CSC_PRD_globalPosZ.clear();
+
+ m_CSC_PRD_localPosX.clear();
+ m_CSC_PRD_localPosY.clear();
+
+ return StatusCode::SUCCESS;
+}
+
+StatusCode CSCPRDVariables::initializeVariables()
+{
+
+ if(m_tree) {
+ m_tree->Branch("PRD_CSC", &m_CSC_PRD_nPRDs, "PRDs_CSC_n/i");
+ m_tree->Branch("PRD_CSC_stationName", &m_CSC_PRD_stationName);
+ m_tree->Branch("PRD_CSC_stationEta", &m_CSC_PRD_stationEta);
+ m_tree->Branch("PRD_CSC_stationPhi", &m_CSC_PRD_stationPhi);
+ m_tree->Branch("PRD_CSC_channel", &m_CSC_PRD_channel);
+ m_tree->Branch("PRD_CSC_chlayer", &m_CSC_PRD_chlayer);
+ m_tree->Branch("PRD_CSC_wlayer", &m_CSC_PRD_wlayer);
+ m_tree->Branch("PRD_CSC_measuresPhi", &m_CSC_PRD_measuresPhi);
+ m_tree->Branch("PRD_CSC_strip", &m_CSC_PRD_strip);
+ m_tree->Branch("PRD_CSC_charge", &m_CSC_PRD_charge);
+ m_tree->Branch("PRD_CSC_time", &m_CSC_PRD_time);
+
+ m_tree->Branch("PRD_CSC_globalPosX", &m_CSC_PRD_globalPosX);
+ m_tree->Branch("PRD_CSC_globalPosY", &m_CSC_PRD_globalPosY);
+ m_tree->Branch("PRD_CSC_globalPosZ", &m_CSC_PRD_globalPosZ);
+
+ m_tree->Branch("PRD_CSC_localPosX", &m_CSC_PRD_localPosX);
+ m_tree->Branch("PRD_CSC_localPosY", &m_CSC_PRD_localPosY);
+ }
+
+ return StatusCode::SUCCESS;
+}
diff --git a/MuonSpectrometer/MuonValidation/MuonPRDTest/src/CSCPRDVariables.h b/MuonSpectrometer/MuonValidation/MuonPRDTest/src/CSCPRDVariables.h
new file mode 100644
index 0000000000000000000000000000000000000000..37eb585c0eb975e95137f495d62ffc0113cf8410
--- /dev/null
+++ b/MuonSpectrometer/MuonValidation/MuonPRDTest/src/CSCPRDVariables.h
@@ -0,0 +1,68 @@
+/*
+ Copyright (C) 2002-2021 CERN for the benefit of the ATLAS collaboration
+*/
+
+#ifndef CSCPRDVARIABLES_H
+#define CSCPRDVARIABLES_H
+
+#include "ValAlgVariables.h"
+#include "MuonIdHelpers/CscIdHelper.h"
+#include "AthenaBaseComps/AthMsgStreamMacros.h"
+#include <vector>
+
+class CSCPRDVariables : public ValAlgVariables
+{
+ public:
+ CSCPRDVariables(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);
+ }
+
+ ~CSCPRDVariables() = default;
+
+ StatusCode initializeVariables();
+ StatusCode fillVariables(const MuonGM::MuonDetectorManager* MuonDetMgr);
+
+ private:
+
+ void setHelper(const MuonIdHelper* idhelper){
+ m_CscIdHelper = dynamic_cast<const CscIdHelper*>(idhelper);
+ if(m_CscIdHelper == 0) {
+ ATH_MSG_ERROR("casting IdHelper to CscIdHelper failed");
+ throw;
+ }
+ }
+
+ void deleteVariables(){};
+ StatusCode clearVariables();
+
+ const CscIdHelper* m_CscIdHelper;
+
+ int m_CSC_PRD_nPRDs;
+ std::vector<std::string> m_CSC_PRD_stationName;
+ std::vector<int> m_CSC_PRD_stationEta;
+ std::vector<int> m_CSC_PRD_stationPhi;
+ std::vector<int> m_CSC_PRD_channel;
+ std::vector<int> m_CSC_PRD_chlayer;
+ std::vector<int> m_CSC_PRD_wlayer;
+ std::vector<int> m_CSC_PRD_measuresPhi;
+ std::vector<int> m_CSC_PRD_strip;
+ std::vector<int> m_CSC_PRD_charge;
+ std::vector<int> m_CSC_PRD_time;
+
+ std::vector<double> m_CSC_PRD_globalPosX;
+ std::vector<double> m_CSC_PRD_globalPosY;
+ std::vector<double> m_CSC_PRD_globalPosZ;
+
+ std::vector<double> m_CSC_PRD_localPosX;
+ std::vector<double> m_CSC_PRD_localPosY;
+
+};
+
+#endif // CSCPRDVARIABLE_H
diff --git a/MuonSpectrometer/MuonValidation/MuonPRDTest/src/TGCPRDVariables.cxx b/MuonSpectrometer/MuonValidation/MuonPRDTest/src/TGCPRDVariables.cxx
new file mode 100644
index 0000000000000000000000000000000000000000..290a0982b2a2279562b377504ff46e226b2293e9
--- /dev/null
+++ b/MuonSpectrometer/MuonValidation/MuonPRDTest/src/TGCPRDVariables.cxx
@@ -0,0 +1,120 @@
+/*
+ Copyright (C) 2002-2021 CERN for the benefit of the ATLAS collaboration
+*/
+
+#include "TGCPRDVariables.h"
+#include "AthenaKernel/errorcheck.h"
+
+#include "MuonPrepRawData/TgcPrepDataContainer.h"
+
+#include "MuonReadoutGeometry/TgcReadoutElement.h"
+
+#include "TTree.h"
+
+StatusCode TGCPRDVariables::fillVariables(const MuonGM::MuonDetectorManager* MuonDetMgr)
+{
+ ATH_MSG_DEBUG("do fillTGCPRDVariables()");
+ ATH_MSG_VERBOSE("MuonDetectorManager from Conditions Store accessed" << MuonDetMgr);
+ CHECK( this->clearVariables() );
+
+ const Muon::TgcPrepDataContainer *Tgc_PrepDataContainer = nullptr;
+ CHECK( m_evtStore->retrieve(Tgc_PrepDataContainer, m_ContainerName.c_str()) );
+
+ if(Tgc_PrepDataContainer->size()==0) ATH_MSG_WARNING(" TGC PRD Container empty ");
+
+ for(auto it : *Tgc_PrepDataContainer ) {
+
+ const Muon::TgcPrepDataCollection* coll = it;
+
+ for (auto prd: *coll) {
+
+ Identifier Id = prd->identify();
+
+ std::string stName = m_TgcIdHelper->stationNameString(m_TgcIdHelper->stationName(Id));
+ int stationEta = m_TgcIdHelper->stationEta(Id);
+ int stationPhi = m_TgcIdHelper->stationPhi(Id);
+ int channel = m_TgcIdHelper->channel(Id);
+ int gasgap = m_TgcIdHelper->gasGap(Id);
+ int isStrip = m_TgcIdHelper->isStrip(Id);
+
+ ATH_MSG_DEBUG( "TGC PRD Offline id: Station Name [" << stName << "]"
+ << " Station Eta [" << stationEta << "]"
+ << " Station Phi [" << stationPhi << "]"
+ << " ChNr [" << channel << "]"
+ << " gasGap [" << gasgap << "]"
+ << " isStrip [" << isStrip << "]" );
+
+ m_TGC_PRD_stationName.push_back(stName);
+ m_TGC_PRD_stationEta.push_back(stationEta);
+ m_TGC_PRD_stationPhi.push_back(stationPhi);
+ m_TGC_PRD_channel.push_back(channel);
+ m_TGC_PRD_gasGap.push_back(gasgap);
+ m_TGC_PRD_isStrip.push_back(isStrip);
+
+ const MuonGM::TgcReadoutElement* det = prd->detectorElement();
+ if (!det) throw std::runtime_error(Form("File: %s, Line: %d\nTGCPRDVariables::fillVariables() - no associated detectorElement", __FILE__, __LINE__));
+ Amg::Vector3D pos = prd->globalPosition();
+ Amg::Vector2D loc_pos(0., 0.);
+
+ det->surface(Id).globalToLocal(pos, Amg::Vector3D(0., 0., 0.), loc_pos);
+
+ m_TGC_PRD_globalPosX.push_back(pos.x());
+ m_TGC_PRD_globalPosY.push_back(pos.y());
+ m_TGC_PRD_globalPosZ.push_back(pos.z());
+
+ m_TGC_PRD_localPosX.push_back(loc_pos[0]);
+ m_TGC_PRD_localPosY.push_back(loc_pos[1]);
+
+ m_TGC_PRD_nPRDs++;
+ }
+ }
+
+ ATH_MSG_DEBUG("processed " << m_TGC_PRD_nPRDs << " TGC PRD's");
+
+ return StatusCode::SUCCESS;
+}
+
+StatusCode TGCPRDVariables::clearVariables()
+{
+
+ m_TGC_PRD_nPRDs = 0;
+
+ m_TGC_PRD_stationName.clear();
+ m_TGC_PRD_stationEta.clear();
+ m_TGC_PRD_stationPhi.clear();
+ m_TGC_PRD_channel.clear();
+ m_TGC_PRD_gasGap.clear();
+ m_TGC_PRD_isStrip.clear();
+
+ m_TGC_PRD_globalPosX.clear();
+ m_TGC_PRD_globalPosY.clear();
+ m_TGC_PRD_globalPosZ.clear();
+
+ m_TGC_PRD_localPosX.clear();
+ m_TGC_PRD_localPosY.clear();
+
+ return StatusCode::SUCCESS;
+}
+
+StatusCode TGCPRDVariables::initializeVariables()
+{
+
+ if(m_tree) {
+ m_tree->Branch("PRD_TGC", &m_TGC_PRD_nPRDs, "PRDs_TGC_n/i");
+ m_tree->Branch("PRD_TGC_stationName", &m_TGC_PRD_stationName);
+ m_tree->Branch("PRD_TGC_stationEta", &m_TGC_PRD_stationEta);
+ m_tree->Branch("PRD_TGC_stationPhi", &m_TGC_PRD_stationPhi);
+ m_tree->Branch("PRD_TGC_channel", &m_TGC_PRD_channel);
+ m_tree->Branch("PRD_TGC_gasGap", &m_TGC_PRD_gasGap);
+ m_tree->Branch("PRD_TGC_isStrip", &m_TGC_PRD_isStrip);
+
+ m_tree->Branch("PRD_TGC_globalPosX", &m_TGC_PRD_globalPosX);
+ m_tree->Branch("PRD_TGC_globalPosY", &m_TGC_PRD_globalPosY);
+ m_tree->Branch("PRD_TGC_globalPosZ", &m_TGC_PRD_globalPosZ);
+
+ m_tree->Branch("PRD_TGC_localPosX", &m_TGC_PRD_localPosX);
+ m_tree->Branch("PRD_TGC_localPosY", &m_TGC_PRD_localPosY);
+ }
+
+ return StatusCode::SUCCESS;
+}
diff --git a/MuonSpectrometer/MuonValidation/MuonPRDTest/src/TGCPRDVariables.h b/MuonSpectrometer/MuonValidation/MuonPRDTest/src/TGCPRDVariables.h
new file mode 100644
index 0000000000000000000000000000000000000000..c59ae58c19ddaa10e8d7dc1afe3e0cd7ca0654a4
--- /dev/null
+++ b/MuonSpectrometer/MuonValidation/MuonPRDTest/src/TGCPRDVariables.h
@@ -0,0 +1,64 @@
+/*
+ Copyright (C) 2002-2021 CERN for the benefit of the ATLAS collaboration
+*/
+
+#ifndef TGCPRDVARIABLES_H
+#define TGCPRDVARIABLES_H
+
+#include "ValAlgVariables.h"
+#include "MuonIdHelpers/TgcIdHelper.h"
+#include "AthenaBaseComps/AthMsgStreamMacros.h"
+#include <vector>
+
+class TGCPRDVariables : public ValAlgVariables
+{
+ public:
+ TGCPRDVariables(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);
+ }
+
+ ~TGCPRDVariables() = default;
+
+ StatusCode initializeVariables();
+ StatusCode fillVariables(const MuonGM::MuonDetectorManager* MuonDetMgr);
+
+ private:
+
+ void setHelper(const MuonIdHelper* idhelper){
+ m_TgcIdHelper = dynamic_cast<const TgcIdHelper*>(idhelper);
+ if(m_TgcIdHelper == 0) {
+ ATH_MSG_ERROR("casting IdHelper to TgcIdHelper failed");
+ throw;
+ }
+ }
+
+ void deleteVariables(){};
+ StatusCode clearVariables();
+
+ const TgcIdHelper* m_TgcIdHelper;
+
+ int m_TGC_PRD_nPRDs;
+ std::vector<std::string> m_TGC_PRD_stationName;
+ std::vector<int> m_TGC_PRD_stationEta;
+ std::vector<int> m_TGC_PRD_stationPhi;
+ std::vector<int> m_TGC_PRD_channel;
+ std::vector<int> m_TGC_PRD_gasGap;
+ std::vector<int> m_TGC_PRD_isStrip;
+
+ std::vector<double> m_TGC_PRD_globalPosX;
+ std::vector<double> m_TGC_PRD_globalPosY;
+ std::vector<double> m_TGC_PRD_globalPosZ;
+
+ std::vector<double> m_TGC_PRD_localPosX;
+ std::vector<double> m_TGC_PRD_localPosY;
+
+};
+
+#endif // TGCPRDVARIABLE_H