diff --git a/DetectorDescription/IRegionSelector/IRegionSelector/RegSelCondData.h b/DetectorDescription/IRegionSelector/IRegionSelector/RegSelCondData.h
index a6533b03772bbb44c72aeabd037598ba66f5e851..dd2c34cd84006064854b4cabfe9c4fbd89937362 100644
--- a/DetectorDescription/IRegionSelector/IRegionSelector/RegSelCondData.h
+++ b/DetectorDescription/IRegionSelector/IRegionSelector/RegSelCondData.h
@@ -18,6 +18,7 @@
#define REGSELCONDDATA_H
#include <iostream>
+#include <memory>
template<typename T>
@@ -25,15 +26,15 @@ class RegSelCondData {
public:
- RegSelCondData( const T& t ) : m_payload(t) { }
-
+ RegSelCondData( std::unique_ptr<T> t ) : m_payload(std::move(t)) { }
+
virtual ~RegSelCondData() { }
-
- const T* payload() const { return &m_payload; } /// could return the actual payload reference, but have everything using pointers
+
+ const T* payload() const { return m_payload.get(); } /// could return the actual payload reference, but have everything using pointers
protected:
- T m_payload;
+ std::unique_ptr<T> m_payload;
};
diff --git a/DetectorDescription/RegionSelector/python/RegSelToolConfig.py b/DetectorDescription/RegionSelector/python/RegSelToolConfig.py
index 545ff35a18a661e6158f993fea68f4ebd72ae75e..8b92557bac07e2cca49d993355f90614fad10f15 100644
--- a/DetectorDescription/RegionSelector/python/RegSelToolConfig.py
+++ b/DetectorDescription/RegionSelector/python/RegSelToolConfig.py
@@ -11,33 +11,34 @@
#
-
-def _makeSiRegSelTool(detector, enable) :
+def _makeRegSelTool( detector, enable, CondAlgConstructor ) :
from RegionSelector.RegionSelectorConf import RegSelTool
tool = RegSelTool(name="RegSelTool_"+detector)
- # should we enable the look up table access ?
+ # should we enable the look up table access for this subsystem ?
if ( enable ) :
-
+
# add the lookup table to retrieve
-
+
tool.RegSelLUT = "RegSelLUTCondData_"+detector
+ tool.Initialised = True
# add the conditions algorithm to create the lookup table
from AthenaCommon.AlgSequence import AthSequencer
condseq = AthSequencer('AthCondSeq')
- if not hasattr(condseq, 'RegSelCondAlg_'+detector):
- from InDetRegionSelector.InDetRegionSelectorConf import SiRegSelCondAlg
- CondAlg = SiRegSelCondAlg( name = ("RegSelCondAlg_"+detector),
- ManagerName = detector,
- PrintTable = False)
- CondAlg.RegSelLUT = "RegSelLUTCondData_"+detector
+ if not hasattr( condseq, 'RegSelCondAlg_'+detector ) :
+ CondAlg = CondAlgConstructor( name = ("RegSelCondAlg_"+detector),
+ ManagerName = detector,
+ PrintTable = False,
+ RegSelLUT = ("RegSelLUTCondData_"+detector) )
+
condseq += CondAlg
+
else:
# detector not configured so don't enable
# lookup table access
@@ -48,50 +49,71 @@ def _makeSiRegSelTool(detector, enable) :
+# inner detector toold
+
def makeRegSelTool_Pixel() :
from AthenaCommon.DetFlags import DetFlags
enabled = DetFlags.detdescr.pixel_on()
- return _makeSiRegSelTool( 'Pixel', enabled )
-
+ from InDetRegionSelector.InDetRegionSelectorConf import SiRegSelCondAlg
+ return _makeRegSelTool( 'Pixel', enabled, SiRegSelCondAlg )
def makeRegSelTool_SCT() :
from AthenaCommon.DetFlags import DetFlags
enabled = DetFlags.detdescr.SCT_on()
- return _makeSiRegSelTool( 'SCT', enabled )
-
+ from InDetRegionSelector.InDetRegionSelectorConf import SiRegSelCondAlg
+ return _makeRegSelTool( 'SCT', enabled, SiRegSelCondAlg )
def makeRegSelTool_TRT() :
-
from AthenaCommon.DetFlags import DetFlags
enabled = DetFlags.detdescr.TRT_on()
-
- from RegionSelector.RegionSelectorConf import RegSelTool
- tool = RegSelTool(name="RegSelTool_TRT")
-
- # should we enable the look up table access ?
+ from InDetRegionSelector.InDetRegionSelectorConf import TRT_RegSelCondAlg
+ return _makeRegSelTool( 'TRT', enabled, TRT_RegSelCondAlg )
- if ( enabled ) :
- # add the lookup table to retrieve
+# muon spectrimeter tools
- tool.RegSelLUT = "RegSelLUTCondData_TRT"
+def makeRegSelTool_MDT() :
+ from AthenaCommon.DetFlags import DetFlags
+ enabled = DetFlags.detdescr.MDT_on()
+ from MuonRegionSelector.MuonRegionSelectorConf import MDT_RegSelCondAlg
+ return _makeRegSelTool( "MDT", enabled, MDT_RegSelCondAlg )
- # add the conditions algorithm to create the lookup table
+def makeRegSelTool_RPC() :
+ from AthenaCommon.DetFlags import DetFlags
+ enabled = DetFlags.detdescr.RPC_on()
+ from MuonRegionSelector.MuonRegionSelectorConf import RPC_RegSelCondAlg
+ return _makeRegSelTool( "RPC", enabled, RPC_RegSelCondAlg )
- from AthenaCommon.AlgSequence import AthSequencer
- condseq = AthSequencer('AthCondSeq')
-
- if not hasattr(condseq, 'RegSelCondAlg_TRT'):
- from InDetRegionSelector.InDetRegionSelectorConf import TRT_RegSelCondAlg
- CondAlg = TRT_RegSelCondAlg( name = "RegSelCondAlg_TRT",
- ManagerName = "TRT",
- PrintTable = False)
- CondAlg.RegSelLUT = "RegSelLUTCondData_TRT"
- condseq += CondAlg
- else:
- # detector subsystem not configured so don't enable
- # lookup table access
+def makeRegSelTool_TGC() :
+ from AthenaCommon.DetFlags import DetFlags
+ enabled = DetFlags.detdescr.TGC_on()
+ from MuonRegionSelector.MuonRegionSelectorConf import TGC_RegSelCondAlg
+ return _makeRegSelTool( "TGC", enabled, TGC_RegSelCondAlg )
+
+def makeRegSelTool_CSC() :
+ from AthenaCommon.DetFlags import DetFlags
+ enabled = DetFlags.detdescr.CSC_on()
+ from MuonRegionSelector.MuonRegionSelectorConf import CSC_RegSelCondAlg
+ return _makeRegSelTool( "CSC", enabled, CSC_RegSelCondAlg )
+
+
+# new small wheel
+
+def makeRegSelTool_MM() :
+ from AtlasGeoModel.MuonGMJobProperties import MuonGeometryFlags
+ from AthenaCommon.DetFlags import DetFlags
+ enabled = False
+ if MuonGeometryFlags.hasMM() :
+ enabled = DetFlags.detdescr.Micromegas_on()
+ from MuonRegionSelector.MuonRegionSelectorConf import MM_RegSelCondAlg
+ return _makeRegSelTool( "MM", enabled, MM_RegSelCondAlg )
+
+def makeRegSelTool_sTGC() :
+ from AtlasGeoModel.MuonGMJobProperties import MuonGeometryFlags
+ from AthenaCommon.DetFlags import DetFlags
+ enabled = False
+ if MuonGeometryFlags.hasSTGC() :
+ enabled = DetFlags.detdescr.sTGC_on()
+ from MuonRegionSelector.MuonRegionSelectorConf import sTGC_RegSelCondAlg
+ return _makeRegSelTool( "sTGC", enabled, sTGC_RegSelCondAlg )
- tool.Initialised = False
-
- return tool
diff --git a/DetectorDescription/RegionSelector/src/RegSelTool.cxx b/DetectorDescription/RegionSelector/src/RegSelTool.cxx
index 60fa55581c079c02d70db4aa7757cf871a1d0ccd..7a314e7b332624adf9508fc5f9a07e49117c633e 100644
--- a/DetectorDescription/RegionSelector/src/RegSelTool.cxx
+++ b/DetectorDescription/RegionSelector/src/RegSelTool.cxx
@@ -7,7 +7,7 @@
** @date Sun 22 Sep 2019 10:21:50 BST
**
**
- ** Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
+ ** Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
**/
@@ -27,12 +27,13 @@
//! Constructor
RegSelTool::RegSelTool( const std::string& type, const std::string& name, const IInterface* parent )
: base_class( type, name, parent ),
- m_initialised(true),
- m_dumpTable(false)
+ m_initialised(false),
+ m_dumpTable(false),
+ m_rpcflag(false)
{
//! Declare properties
- declareProperty( "WriteTable", m_dumpTable, "write out maps to files for debugging" );
- declareProperty( "Initialised", m_initialised=true, "flag to determine whether the corresponding subsystem is initilised" );
+ declareProperty( "WriteTable", m_dumpTable, "write out maps to files for debugging" );
+ declareProperty( "Initialised", m_initialised=false, "flag to determine whether the corresponding subsystem is initilised" );
}
@@ -43,20 +44,19 @@ RegSelTool::~RegSelTool() { }
const RegSelSiLUT* RegSelTool::lookup() const {
if ( !m_initialised ) return nullptr;
SG::ReadCondHandle< RegSelCondData<RegSelSiLUT> > table_handle( m_tableKey );
- // ATH_CHECK( table_handle.isSuccess() );
const RegSelSiLUT* lookup_table = (*table_handle)->payload();
- return lookup_table;
-
+ return lookup_table;
}
-
StatusCode RegSelTool::initialize() {
- if ( m_initialised ) {
- ATH_CHECK( m_tableKey.initialize() );
- ATH_MSG_INFO( "Initialising " << name() << "\tkey " << m_tableKey );
+ ATH_CHECK( m_tableKey.initialize() );
+ ATH_MSG_DEBUG( "Initialising RegSelTool " << name() << "\ttable: " << m_tableKey );
+ if ( !m_initialised ) {
+ ATH_MSG_WARNING( "Lookup table will not be iitialised " << name() << "\tkey " << m_tableKey );
}
+ if ( name().find( "RPC") != std::string::npos ) m_rpcflag = true;
return StatusCode::SUCCESS;
}
@@ -68,12 +68,14 @@ StatusCode RegSelTool::finalize() {
}
-bool RegSelTool::handle() {
- return true;
+void RegSelTool::cleanup( std::vector<IdentifierHash>& idvec ) const {
+ for ( size_t i=idvec.size() ; i-- ; ) idvec[i] = IdentifierHash( ((unsigned)idvec[i]) & 0xfff );
+ RegSelSiLUT::removeDuplicates( idvec );
}
+
// new RegionSelector interface for the Innner Detector
void RegSelTool::getRoIData( const IRoiDescriptor& roi, std::vector<const RegSelModule*>& modules ) const {
@@ -113,6 +115,8 @@ void RegSelTool::HashIDList( const IRoiDescriptor& roi, std::vector<IdentifierHa
const RegSelSiLUT* lookuptable = lookup();
if ( lookuptable ) lookuptable->getHashList( roitmp, idlist );
+ if ( m_rpcflag ) cleanup( idlist );
+
}
@@ -136,6 +140,8 @@ void RegSelTool::HashIDList( long layer, const IRoiDescriptor& roi, std::vector<
const RegSelSiLUT* lookuptable = lookup();
if ( lookuptable ) lookuptable->getHashList( roitmp, layer, idlist );
+ if ( m_rpcflag ) cleanup( idlist );
+
}
@@ -202,6 +208,7 @@ void RegSelTool::ROBIDList( long layer, const IRoiDescriptor& roi, std::vector<u
void RegSelTool::HashIDList( std::vector<IdentifierHash>& idlist ) const {
const RegSelSiLUT* lookuptable = lookup();
if ( lookuptable ) lookuptable->getHashList( idlist );
+ if ( m_rpcflag ) cleanup( idlist );
}
/// fullscan hashid for specific layer
@@ -209,6 +216,7 @@ void RegSelTool::HashIDList( std::vector<IdentifierHash>& idlist ) const {
void RegSelTool::HashIDList( long layer, std::vector<IdentifierHash>& idlist ) const {
const RegSelSiLUT* lookuptable = lookup();
if ( lookuptable ) lookuptable->getHashList( layer, idlist );
+ if ( m_rpcflag ) cleanup( idlist );
}
/// full scan robid
diff --git a/DetectorDescription/RegionSelector/src/RegSelTool.h b/DetectorDescription/RegionSelector/src/RegSelTool.h
index 4a7f728bb965eafc9eade223e71135272ab9d921..c34d06220cff5ba4b13c71945287a541639bb4b8 100644
--- a/DetectorDescription/RegionSelector/src/RegSelTool.h
+++ b/DetectorDescription/RegionSelector/src/RegSelTool.h
@@ -7,7 +7,7 @@
///
/// @author Mark Sutton
///
-/// Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
+/// Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
///
#ifndef REGIONSELECTOR_REGSELTOOL_H
@@ -35,10 +35,9 @@ class RegSelSiLUT;
class IInterface;
-
class RegSelTool : public extends<AthAlgTool, IRegSelTool> {
- public:
+public:
/** @c Standard constructor for tool (obviously).
*/
@@ -74,9 +73,11 @@ class RegSelTool : public extends<AthAlgTool, IRegSelTool> {
protected:
// full scan
+ virtual
void HashIDList( std::vector<IdentifierHash>& idlist ) const;
// full scan for a specific layer
+ virtual
void HashIDList( long layer, std::vector<IdentifierHash>& idlist ) const;
// Methods to obtain the rob id list
@@ -90,12 +91,13 @@ protected:
// get list of modules
void getRoIData( const IRoiDescriptor& roi, std::vector<const RegSelModule*>& modulelist ) const;
- //! @method handle, handles the actual lookup table
- bool handle();
-
//! @method lookup, actually retrieve the lookup table as conditions data - might combine with handle()
const RegSelSiLUT* lookup() const;
+protected:
+
+ void cleanup( std::vector<IdentifierHash>& idvec ) const;
+
private:
//! Flag to determine whether it has yet been initialised
@@ -106,7 +108,15 @@ private:
//! Flag to dump loaded table in data file.
BooleanProperty m_dumpTable;
- SG::ReadCondHandleKey<RegSelLUTCondData> m_tableKey{ this, "RegSelLUT", "RegSelLUTCondData", "Region Selector lookup table" };
+ SG::ReadCondHandleKey<RegSelLUTCondData> m_tableKey{ this, "RegSelLUT", "Tool_Not_Initalised", "Region Selector lookup table" };
+
+ /// flag to avoid the need for a separate rpc lookup table class
+ /// FixMe: this flag may be replaced by custom derived RegSelTool
+ /// class for the RPC. The tools are retrieved only via
+ /// the IRegSelTool interface so this would also be
+ /// transaprent to the user
+
+ bool m_rpcflag;
};
diff --git a/DetectorDescription/RegionSelector/src/components/RegionSelector_entries.cxx b/DetectorDescription/RegionSelector/src/components/RegionSelector_entries.cxx
index 60ec75591704ceb7fb04a595c82da2c3db566f12..4aa5fb2f1b760cb08880efeada343a54b9f45d37 100644
--- a/DetectorDescription/RegionSelector/src/components/RegionSelector_entries.cxx
+++ b/DetectorDescription/RegionSelector/src/components/RegionSelector_entries.cxx
@@ -1,4 +1,5 @@
#include "../RegSelSvc.h"
+
#include "../RegSelTool.h"
DECLARE_COMPONENT( RegSelSvc )
diff --git a/InnerDetector/InDetDetDescr/InDetRegionSelector/src/SiRegSelCondAlg.cxx b/InnerDetector/InDetDetDescr/InDetRegionSelector/src/SiRegSelCondAlg.cxx
index 87fca7134c30ce4eddd28cad392549119448991c..a00d9e024a93aee74437e7d4b2995a39fec9e6ce 100644
--- a/InnerDetector/InDetDetDescr/InDetRegionSelector/src/SiRegSelCondAlg.cxx
+++ b/InnerDetector/InDetDetDescr/InDetRegionSelector/src/SiRegSelCondAlg.cxx
@@ -33,7 +33,7 @@ SiRegSelCondAlg::SiRegSelCondAlg(const std::string& name, ISvcLocator* pSvcLocat
AthReentrantAlgorithm( name, pSvcLocator ),
m_managerName(""),
m_printTable(false),
- m_sctCablingToolInc("SCT_CablingToolInc")
+ m_sctCablingTool("SCT_CablingTool")
{
ATH_MSG_DEBUG( "SiRegSelCondAlg::SiRegSelCondAlg() " << name );
declareProperty( "PrintTable", m_printTable=false );
@@ -46,7 +46,8 @@ SiRegSelCondAlg::SiRegSelCondAlg(const std::string& name, ISvcLocator* pSvcLocat
StatusCode SiRegSelCondAlg::initialize()
{
ATH_MSG_DEBUG("SiRegSelCondAlg::initialize() ");
- ATH_CHECK(m_condCablingKey.initialize());
+ ATH_CHECK(m_pixCablingKey.initialize());
+ ATH_CHECK(m_sctCablingKey.initialize());
ATH_CHECK(m_tableKey.initialize());
ATH_MSG_INFO("SiRegSelCondAlg::initialize() " << m_tableKey );
return StatusCode::SUCCESS;
@@ -76,45 +77,39 @@ StatusCode SiRegSelCondAlg::execute(const EventContext& ctx) const
ATH_MSG_DEBUG( "Found Manager " << m_managerName );
}
- /// Since there are only really ~ 10 lines that would be different between the
- /// SCT and pixel versions of this code, we chose to do everything in one class
- /// Sadly, the pixel and SCT cabling don't inherit from the same interface
- /// so we can't get the cabling using a generic call, and have to have separate
- /// code blocks for each
- /// As such, we need to set the cabling from inside conditional blocks, so have
- /// to create the cabling as pointers so that we can set inside the blocks and
- /// subsequently access them outside the blocks
-
- /// FIXME: since we store the LUT as conditions data, we need an EventIDRange for
- /// the WriteCondHandle, but the SCT cabling is not yet conditions data so
- /// have to get the pixelCabling for the SCT case also so that the
- /// EventIDRange can be extracted
- /// Once the SCT cabling is iself conditions data, we will be able to get
- /// the corresponding EventIDRange from there
+ /// Need to get the SCT cabling conditions for the EventIDRange, but
+ /// still need to use the SCT_CablingTool to get the rob ids
std::unique_ptr<SG::ReadCondHandle<PixelCablingCondData> > pixCabling;
+ std::unique_ptr<SG::ReadCondHandle<SCT_CablingData> > sctCabling;
EventIDRange id_range;
if (!manager->isPixel()) { // SCT
- if (m_sctCablingToolInc.retrieve().isFailure()) {
- msg(MSG::ERROR) << "Can't get the SCT_CablingToolInc." << endmsg;
+ sctCabling = std::make_unique<SG::ReadCondHandle<SCT_CablingData> >( m_sctCablingKey, ctx );
+ if( !sctCabling->range( id_range ) ) {
+ ATH_MSG_ERROR("Failed to retrieve validity range for " << sctCabling->key());
+ return StatusCode::FAILURE;
+ }
+
+ /// keep explicit failure check for enhanced error reporting
+ if (m_sctCablingTool.retrieve().isFailure()) {
+ msg(MSG::ERROR) << "Can't get the SCT_CablingTool" << endmsg;
return StatusCode::FAILURE;
}
}
- // else {
- pixCabling = std::make_unique<SG::ReadCondHandle<PixelCablingCondData> >( m_condCablingKey, ctx );
-
+ else { // PIXEL
+ pixCabling = std::make_unique<SG::ReadCondHandle<PixelCablingCondData> >( m_pixCablingKey, ctx );
if( !pixCabling->range( id_range ) ) {
ATH_MSG_ERROR("Failed to retrieve validity range for " << pixCabling->key());
return StatusCode::FAILURE;
}
- // }
+ }
- RegSelSiLUT* rd;
+ std::unique_ptr<RegSelSiLUT> rd;
- if ( manager->isPixel() ) rd = new RegSelSiLUT(RegSelSiLUT::PIXEL);
- else rd = new RegSelSiLUT(RegSelSiLUT::SCT);
+ if ( manager->isPixel() ) rd = std::make_unique<RegSelSiLUT>(RegSelSiLUT::PIXEL);
+ else rd = std::make_unique<RegSelSiLUT>(RegSelSiLUT::SCT);
InDetDD::SiDetectorElementCollection::const_iterator iter = manager->getDetectorElementBegin();
@@ -163,7 +158,7 @@ StatusCode SiRegSelCondAlg::execute(const EventContext& ctx) const
if ( sctId!=0 ) {
barrelEC = sctId->barrel_ec(element->identify());
layerDisk = sctId->layer_disk(element->identify());
- robId=m_sctCablingToolInc->getRobIdFromOfflineId(element->identify());
+ robId=m_sctCablingTool->getRobIdFromOfflineId(element->identify());
}
else {
ATH_MSG_ERROR("Could not get SCT_ID for " << element->getIdHelper() );
@@ -195,12 +190,9 @@ StatusCode SiRegSelCondAlg::execute(const EventContext& ctx) const
rd->initialise();
// write out new new LUT to a file if need be
- if ( m_printTable ) {
- if ( manager->isPixel() ) rd->write("RegSelLUT_Pixel");
- else rd->write("RegSelLUT_SCT");
- }
+ if ( m_printTable ) rd->write( name()+".map" );
- RegSelLUTCondData* rcd = new RegSelLUTCondData( *rd );
+ RegSelLUTCondData* rcd = new RegSelLUTCondData( std::move(rd) );
try {
SG::WriteCondHandle<RegSelLUTCondData> lutCondData( m_tableKey, ctx );
diff --git a/InnerDetector/InDetDetDescr/InDetRegionSelector/src/SiRegSelCondAlg.h b/InnerDetector/InDetDetDescr/InDetRegionSelector/src/SiRegSelCondAlg.h
index fc433a9e809c7619208703edf6f37a88318a8ba0..1998a05d65fa48379b07da56d436fe207536039c 100755
--- a/InnerDetector/InDetDetDescr/InDetRegionSelector/src/SiRegSelCondAlg.h
+++ b/InnerDetector/InDetDetDescr/InDetRegionSelector/src/SiRegSelCondAlg.h
@@ -21,6 +21,7 @@
#include "PixelConditionsData/PixelCablingCondData.h"
+#include "SCT_Cabling/SCT_CablingData.h"
#include "StoreGate/ReadCondHandleKey.h"
#include "StoreGate/WriteCondHandleKey.h"
@@ -49,11 +50,16 @@ public:
/// Sadly the PIxel and SCT cabling are different classes so need both,
/// even if only one is to be used
- ToolHandle<ISCT_CablingTool> m_sctCablingToolInc; // This class accesses SCT cabling during initialization.
+ ToolHandle<ISCT_CablingTool> m_sctCablingTool; // This class accesses SCT cabling during table creation
- SG::ReadCondHandleKey<PixelCablingCondData> m_condCablingKey
+ SG::ReadCondHandleKey<SCT_CablingData> m_sctCablingKey
+ {this, "SCT_CablingData", "SCT_CablingData", "SCT cabling key"};
+
+ SG::ReadCondHandleKey<PixelCablingCondData> m_pixCablingKey
{this, "PixelCablingCondData", "PixelCablingCondData", "Pixel cabling key"};
+
+
/// Output conditions object
SG::WriteCondHandleKey<RegSelLUTCondData> m_tableKey
{ this, "RegSelLUT", "RegSelLUTCondData", "Region Selector lookup table" };
diff --git a/InnerDetector/InDetDetDescr/InDetRegionSelector/src/TRT_RegSelCondAlg.cxx b/InnerDetector/InDetDetDescr/InDetRegionSelector/src/TRT_RegSelCondAlg.cxx
index f701c83b95ad61fa036e1697d3563dfd942045ac..fd8f9e758ed637b66adf64d1772bd896c63889a3 100644
--- a/InnerDetector/InDetDetDescr/InDetRegionSelector/src/TRT_RegSelCondAlg.cxx
+++ b/InnerDetector/InDetDetDescr/InDetRegionSelector/src/TRT_RegSelCondAlg.cxx
@@ -130,17 +130,15 @@ StatusCode TRT_RegSelCondAlg::execute(const EventContext& ctx) const
return StatusCode::FAILURE;
}
-
- //-----------------------------------------------------
- unsigned int maxHash = idHelper->straw_layer_hash_max();
- //
// Try and iterate over all elements.
// There is no iterator but we can get the elements via the idHash.
- //
- // MS create the new TRT look up table
- RegSelSiLUT *rd = new RegSelSiLUT(RegSelSiLUT::TRT);
+ unsigned int maxHash = idHelper->straw_layer_hash_max();
+
+ // create the new TRT look up table
+
+ std::unique_ptr<RegSelSiLUT> rd = std::make_unique<RegSelSiLUT>(RegSelSiLUT::TRT);
constexpr double twoPi=2.*M_PI;
constexpr double InnerRadiusOfStraw = 2.; //hardcoded. No method? (it will NEVER change anyway)
@@ -229,9 +227,9 @@ StatusCode TRT_RegSelCondAlg::execute(const EventContext& ctx) const
rd->initialise();
// write out new new LUT to a file if need be
- if ( m_printTable ) rd->write("RegSelLUT_TRT");
+ if ( m_printTable ) rd->write( name()+".map" );
- RegSelLUTCondData* rcd = new RegSelLUTCondData( *rd );
+ RegSelLUTCondData* rcd = new RegSelLUTCondData( std::move(rd) );
try {
SG::WriteCondHandle<RegSelLUTCondData> lutCondData( m_tableKey, ctx );
diff --git a/MuonSpectrometer/MuonDetDescr/MuonRegionSelector/CMakeLists.txt b/MuonSpectrometer/MuonDetDescr/MuonRegionSelector/CMakeLists.txt
index 558400cab476c2919dd7de8189af3a7b82443e8e..bbd48c67f079e4dbeba968b0e34027be5c83ff72 100644
--- a/MuonSpectrometer/MuonDetDescr/MuonRegionSelector/CMakeLists.txt
+++ b/MuonSpectrometer/MuonDetDescr/MuonRegionSelector/CMakeLists.txt
@@ -13,8 +13,9 @@ atlas_depends_on_subdirs( PUBLIC
GaudiKernel
PRIVATE
DetectorDescription/Identifier
+ DetectorDescription/IRegionSelector
+ MuonSpectrometer/MuonCablings/MuonCablingData
MuonSpectrometer/MuonCablings/CSCcabling
- MuonSpectrometer/MuonCablings/MuonMDT_Cabling
MuonSpectrometer/MuonCablings/MuonTGC_Cabling
MuonSpectrometer/MuonCablings/RPCcablingInterface
MuonSpectrometer/MuonDetDescr/MuonReadoutGeometry
@@ -31,8 +32,10 @@ atlas_add_component( MuonRegionSelector
INCLUDE_DIRS ${CLHEP_INCLUDE_DIRS} ${EIGEN_INCLUDE_DIRS}
LINK_LIBRARIES ${CLHEP_LIBRARIES} ${EIGEN_LIBRARIES} AthenaBaseComps GeoPrimitives
RegSelLUT GaudiKernel Identifier CSCcablingLib
+ MuonCablingData
MuonMDT_CablingLib MuonTGC_CablingLib RPCcablingInterfaceLib
MuonReadoutGeometry
+
MuonAGDDDescription )
# Install files from the package:
diff --git a/MuonSpectrometer/MuonDetDescr/MuonRegionSelector/src/CSC_RegSelCondAlg.cxx b/MuonSpectrometer/MuonDetDescr/MuonRegionSelector/src/CSC_RegSelCondAlg.cxx
new file mode 100644
index 0000000000000000000000000000000000000000..315462d996d0cf86106c6fc2c25536d0d7981813
--- /dev/null
+++ b/MuonSpectrometer/MuonDetDescr/MuonRegionSelector/src/CSC_RegSelCondAlg.cxx
@@ -0,0 +1,360 @@
+/**
+ ** @file CSC_RegSelCondAlg.cxx
+ **
+ ** conditions algorithm to create the Si detector
+ ** lookup tables
+ **
+ ** @author sutt
+ ** @date Sun 22 Sep 2019 10:21:50 BST
+ **
+ **
+ ** Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
+ **/
+
+
+#include "GaudiKernel/EventIDRange.h"
+#include "StoreGate/WriteCondHandle.h"
+
+#include "CLHEP/Units/SystemOfUnits.h"
+#include "Identifier/IdentifierHash.h"
+
+#include <iostream>
+#include <fstream>
+#include <string>
+#include <cmath>
+
+#include "MuonCablingData/MuonMDT_CablingMap.h"
+#include "CSCcabling/CSCcablingSvc.h"
+
+#include "MuonReadoutGeometry/MuonDetectorManager.h"
+#include "MuonReadoutGeometry/MuonReadoutElement.h"
+#include "MuonReadoutGeometry/MdtReadoutElement.h"
+#include "MuonReadoutGeometry/CscReadoutElement.h"
+#include "MuonReadoutGeometry/RpcReadoutElement.h"
+#include "MuonReadoutGeometry/TgcReadoutElement.h"
+#include "MuonReadoutGeometry/RpcReadoutSet.h"
+#include "MuonReadoutGeometry/MuonStation.h"
+
+
+#include "CSC_RegSelCondAlg.h"
+
+
+CSC_RegSelCondAlg::CSC_RegSelCondAlg(const std::string& name, ISvcLocator* pSvcLocator):
+ MuonRegSelCondAlg( name, pSvcLocator )
+{
+ ATH_MSG_DEBUG( "CSC_RegSelCondAlg::CSC_RegSelCondAlg() " << name );
+}
+
+
+
+
+
+std::unique_ptr<RegSelSiLUT> CSC_RegSelCondAlg::createTable( const MuonMDT_CablingMap* /* mdtCabling */ ) const {
+
+ /// now get the CSC cabling service ...
+
+ const CSCcablingSvc* cabling = nullptr;
+
+ if ( service( "CSCcablingSvc", cabling ).isFailure() ) {
+ ATH_MSG_ERROR( "Could not retrieve CSC cabling for " << name() );
+ return std::unique_ptr<RegSelSiLUT>(nullptr);
+ }
+
+ /// get the CSC detector manager
+
+ const MuonGM::MuonDetectorManager* manager = nullptr;
+
+ if ( (detStore()->retrieve( manager ).isFailure() ) ) {
+ ATH_MSG_ERROR( "Could not retrieve CSC Manager for " << name() );
+ return std::unique_ptr<RegSelSiLUT>(nullptr);
+ }
+
+ const CscIdHelper* helper = manager->cscIdHelper();
+
+ std::vector<Identifier>::const_iterator idfirst = helper->module_begin();
+ std::vector<Identifier>::const_iterator idlast = helper->module_end();
+
+ const IdContext ModuleContext = helper->module_context();
+
+ ATH_MSG_DEBUG("createTable()");
+
+ std::unique_ptr<RegSelSiLUT> lut = std::make_unique<RegSelSiLUT>();
+
+
+
+ for ( std::vector<Identifier>::const_iterator itr=idfirst ; itr!=idlast ; itr++ ) {
+ Identifier Id = *itr;
+ IdentifierHash Idhash;
+
+ helper->get_hash(Id, Idhash, &ModuleContext);
+
+ ExpandedIdentifier exp_id;
+ if (helper->get_expanded_id( Id, exp_id, &ModuleContext)) {
+ ATH_MSG_DEBUG("Failed retrieving ExpandedIdentifier for PRD Identifier = " << Id.getString() << ". Skipping to the next PRD.");
+ continue;
+ }
+
+ int detid = ( exp_id[2]<0 ? -1 : 1 );
+ int layerid = exp_id[1]+1;
+
+
+ // retrieve CscReadoutElement
+
+ Identifier Id2ndLayer;
+ int chamberLayer = 2;
+ const MuonGM::CscReadoutElement *csc = manager->getCscReadoutElement(Id);
+ if (csc == NULL) {
+
+ // std::cout << "Csc Readout Element not found for this Id ---- try 2nd layer"<<std::endl;
+ Id2ndLayer = helper->parentID(Id);
+ Id2ndLayer = helper->channelID(Id2ndLayer, chamberLayer, 1, 0, 1);
+ csc = manager->getCscReadoutElement(Id2ndLayer);
+ if (csc == NULL)
+ {
+ // std::cout << "Csc Readout Element not found for 2nd layer too ---- skip"<<std::endl;
+ continue;
+ }
+ }
+
+ double eta_min = 99999999.;
+ double eta_max = -99999999.;
+ double phi_min = 999999.;
+ double phi_max = -999999.;
+
+ double zmin = 999999999;
+ double zmax = -999999999;
+
+ double rmin = 0;
+ double rmax = 0;
+
+ double phi_test = 0.;
+ Identifier Id_phi_max;
+ Identifier Id_phi_min;
+ Identifier Id_eta_max;
+ Identifier Id_eta_min;
+
+ // only use the extreme chamber layers and wirelayers
+
+ int chlayer_inc = helper->chamberLayerMax(Id)-1;
+ if ( chlayer_inc<1 ) chlayer_inc = 1;
+ for ( int chlayer=1 ; chlayer<=helper->chamberLayerMax(Id) ; chlayer+=chlayer_inc ) {
+
+
+ int wlayer_inc = helper->wireLayerMax(Id)-1;
+ if ( wlayer_inc<1 ) wlayer_inc = 1;
+ for ( int wlayer=1 ; wlayer<=helper->wireLayerMax(Id) ; wlayer+=wlayer_inc ){
+
+ for ( int phis=1 ; phis<=csc->NphiStrips(wlayer) ; phis++ ) {
+
+
+ Identifier phis_id = helper->channelID(Id, chlayer, wlayer, 1, phis);
+ Amg::Vector3D phis_x = csc->localStripPos(phis_id);
+ double phis_lenght = csc->stripLength(phis_id);
+
+ // positions of the strip endpoints
+
+ Amg::Vector3D phis_x1 = phis_x;
+ Amg::Vector3D phis_x2 = phis_x;
+
+ //phis_x1.setZ(phis_x.z()-phis_lenght/2.0);
+ //phis_x2.setZ(phis_x.z()+phis_lenght/2.0);
+ phis_x1[2] = phis_x.z()-phis_lenght/2.0;
+ phis_x2[2] = phis_x.z()+phis_lenght/2.0;
+
+ Amg::Vector3D gphis_x1 = csc->globalPos(phis_x1);
+ Amg::Vector3D gphis_x2 = csc->globalPos(phis_x2);
+
+ phi_test=gphis_x1.phi();
+ // for detector in (-0.25,0.25) phi interval use +-3,14 phi interval
+ // if(!(aux1==51 && aux3==1))if (phi_test < 0) phi_test += 2.*M_PI;
+ if(!(exp_id[1]==51 && exp_id[3]==1))if (phi_test < 0) phi_test += 2.*M_PI;
+
+
+ if ( zmin>gphis_x1.z() ) zmin = gphis_x1.z();
+ if ( zmax<gphis_x1.z() ) zmax = gphis_x1.z();
+
+ if ( rmin==0 || rmin>gphis_x1.perp() ) rmin = gphis_x1.perp();
+ if ( rmax==0 || rmax<gphis_x1.perp() ) rmax = gphis_x1.perp();
+
+ if ( zmin>gphis_x2.z() ) zmin = gphis_x2.z();
+ if ( zmax<gphis_x2.z() ) zmax = gphis_x2.z();
+
+ if ( rmin==0 || rmin>gphis_x2.perp() ) rmin = gphis_x2.perp();
+ if ( rmax==0 || rmax<gphis_x2.perp() ) rmax = gphis_x2.perp();
+
+ // position of the strip centre
+
+
+ Amg::Vector3D gphis_x = csc->globalPos(phis_x);
+
+ if ( rmin==0 || rmin>gphis_x.perp() ) rmin = gphis_x.perp();
+ if ( rmax==0 || rmax<gphis_x.perp() ) rmax = gphis_x.perp();
+
+ // phi
+ if(phi_test > phi_max){
+ Id_phi_max=phis_id;
+ phi_max=phi_test;
+ }
+ if(phi_test < phi_min){
+ Id_phi_min=phis_id;
+ phi_min=phi_test;
+ }
+ // eta
+ if(gphis_x1.eta() > eta_max) {
+ Id_eta_max=phis_id;
+ eta_max=gphis_x1.eta();
+ }
+ if(gphis_x1.eta() < eta_min) {
+ Id_eta_min=phis_id;
+ eta_min=gphis_x1.eta();
+ }
+
+ phi_test=gphis_x2.phi();
+ // for detector in (-0.25,0.25) phi interval use +-3,14 phi interval
+ // if(!(aux1==51 && aux3==1)) if (phi_test < 0) phi_test += 2.*M_PI;
+ if(!(exp_id[1]==51 && exp_id[3]==1)) if (phi_test < 0) phi_test += 2.*M_PI;
+
+ // phi
+ if(phi_test > phi_max) {
+ Id_phi_max=phis_id;
+ phi_max=phi_test;
+ }
+ if(phi_test < phi_min) {
+ Id_phi_min=phis_id;
+ phi_min=phi_test;
+ }
+ // eta
+ if(gphis_x2.eta() > eta_max) {
+ Id_eta_max=phis_id;
+ eta_max=gphis_x2.eta();
+ }
+ if(gphis_x2.eta() < eta_min) {
+ Id_eta_min=phis_id;
+ eta_min=gphis_x2.eta();
+ }
+
+ }
+
+ // only use the extreme and middle strips
+
+ int eta_inc = csc->NetaStrips(wlayer)/2;
+ if ( eta_inc<1 ) eta_inc = 1;
+ for ( int etas=1 ; etas<=csc->NetaStrips(wlayer) ; etas+=eta_inc ) {
+
+
+ Identifier etas_id = helper->channelID(Id, chlayer, wlayer, 0, etas);
+ Amg::Vector3D etas_x = csc->localStripPos(etas_id);
+ double etas_lenght = csc->stripLength(etas_id);
+
+ // strip endpoints
+
+ Amg::Vector3D etas_x1 = etas_x;
+ Amg::Vector3D etas_x2 = etas_x;
+
+ //etas_x1.setY(etas_x.y()-etas_lenght/2.0);
+ //etas_x2.setY(etas_x.y()+etas_lenght/2.0);
+ etas_x1[1] = etas_x.y()-etas_lenght/2.0;
+ etas_x2[1] = etas_x.y()+etas_lenght/2.0;
+
+ Amg::Vector3D getas_x1 = csc->globalPos(etas_x1);
+ Amg::Vector3D getas_x2 = csc->globalPos(etas_x2);
+
+ if ( zmin>getas_x1.z() ) zmin = getas_x1.z();
+ if ( zmax<getas_x1.z() ) zmax = getas_x1.z();
+
+ if ( zmin>getas_x2.z() ) zmin = getas_x2.z();
+ if ( zmax<getas_x2.z() ) zmax = getas_x2.z();
+
+ if ( rmin==0 || rmin>getas_x1.perp() ) rmin = getas_x1.perp();
+ if ( rmax==0 || rmax<getas_x1.perp() ) rmax = getas_x1.perp();
+
+ if ( rmin==0 || rmin>getas_x2.perp() ) rmin = getas_x2.perp();
+ if ( rmax==0 || rmax<getas_x2.perp() ) rmax = getas_x2.perp();
+
+ // position of the strip centre
+
+ Amg::Vector3D getas_x = csc->globalPos(etas_x);
+
+ if ( rmin==0 || rmin>getas_x.perp() ) rmin = getas_x.perp();
+ if ( rmax==0 || rmax<getas_x.perp() ) rmax = getas_x.perp();
+
+ phi_test = getas_x1.phi();
+ // for detector in (-0.25,0.25) phi interval use +-3,14 phi interval
+ // if(!(aux1==51 && aux3==1)) if (phi_test < 0) phi_test += 2.*M_PI;
+ if(!(exp_id[1]==51 && exp_id[3]==1)) if (phi_test < 0) phi_test += 2.*M_PI;
+ // phi
+ if(phi_test > phi_max){
+ Id_phi_max=etas_id;
+ phi_max=phi_test;
+ }
+ if(phi_test < phi_min){
+ Id_phi_min=etas_id;
+ phi_min=phi_test;
+ }
+ // eta
+ if(getas_x1.eta() > eta_max) {
+ Id_eta_max=etas_id;
+ eta_max=getas_x1.eta();
+ }
+ if(getas_x1.eta() < eta_min) {
+ Id_eta_min=etas_id;
+ eta_min=getas_x1.eta();
+ }
+
+ phi_test = getas_x2.phi();
+ // for detector in (-0.25,0.25) phi interval use +-3,14 phi interval
+ // if (!(aux1==51 && aux3==1)) if (phi_test < 0) phi_test += 2.*M_PI;
+ if (!(exp_id[1]==51 && exp_id[3]==1)) if (phi_test < 0) phi_test += 2.*M_PI;
+ // phi
+ if(phi_test > phi_max){
+ Id_phi_max=etas_id;
+ phi_max=phi_test;
+ }
+ if(phi_test < phi_min){
+ Id_phi_min=etas_id;
+ phi_min=phi_test;
+ }
+ // eta
+ if(getas_x2.eta() > eta_max) {
+ Id_eta_max=etas_id;
+ eta_max=getas_x2.eta();
+ }
+ if(getas_x2.eta() < eta_min) {
+ Id_eta_min=etas_id;
+ eta_min=getas_x2.eta();
+ }
+
+ }
+ } //gas gaps
+ } // chamber layers
+
+ // if(aux1==51 && aux3==1)if (phi_min < 0) phi_min += 2.*M_PI;
+ // if(aux1==51 && aux3==1)if (phi_max < 0) phi_max += 2.*M_PI;
+ if(exp_id[1]==51 && exp_id[3]==1) {
+ if (phi_max < 0) phi_max += 2.*M_PI;
+ if (phi_min < 0) phi_min += 2.*M_PI;
+ }
+
+ uint16_t subDetectorId = (detid == -1) ? 0x6a : 0x69;
+ uint32_t cscrob = 0x0;
+ cabling->hash2Rob(Idhash.value(),cscrob);
+ cscrob = ((subDetectorId << 16) | cscrob);
+ RegSelModule m( zmin, zmax, rmin, rmax, phi_min, phi_max, layerid, detid, cscrob, Idhash );
+ lut->addModule( m );
+
+
+ } // modules
+
+
+ lut->initialise();
+
+ return lut;
+
+}
+
+
+
+
+
+
+
diff --git a/MuonSpectrometer/MuonDetDescr/MuonRegionSelector/src/CSC_RegSelCondAlg.h b/MuonSpectrometer/MuonDetDescr/MuonRegionSelector/src/CSC_RegSelCondAlg.h
new file mode 100755
index 0000000000000000000000000000000000000000..fa51fe5f81dc70b18f6fea196e6df2f7bbc3515f
--- /dev/null
+++ b/MuonSpectrometer/MuonDetDescr/MuonRegionSelector/src/CSC_RegSelCondAlg.h
@@ -0,0 +1,28 @@
+/** emacs: this is -*- c++ -*- **/
+/**
+ ** @file CSC_RegSelCondAlg.h
+ **
+ ** @author sutt
+ ** @date Tue 4 Feb 2020 15:25:00 CET
+ **
+ ** Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
+ **/
+
+#ifndef CSC_RegSelCondAlg_h
+#define CSC_RegSelCondAlg_h
+
+
+#include "MuonRegSelCondAlg.h"
+
+
+class CSC_RegSelCondAlg : public MuonRegSelCondAlg {
+
+public:
+
+ CSC_RegSelCondAlg( const std::string& name, ISvcLocator* pSvcLocator );
+
+ std::unique_ptr<RegSelSiLUT> createTable( const MuonMDT_CablingMap* mdtCabling ) const;
+
+};
+
+#endif // CSC_RegSelCondAlg_h
diff --git a/MuonSpectrometer/MuonDetDescr/MuonRegionSelector/src/MDT_RegSelCondAlg.cxx b/MuonSpectrometer/MuonDetDescr/MuonRegionSelector/src/MDT_RegSelCondAlg.cxx
new file mode 100644
index 0000000000000000000000000000000000000000..93d4e4ebd2fb2cf7556f4bbfdeb8846b359dba34
--- /dev/null
+++ b/MuonSpectrometer/MuonDetDescr/MuonRegionSelector/src/MDT_RegSelCondAlg.cxx
@@ -0,0 +1,361 @@
+/**
+ ** @file MDT_RegSelCondAlg.cxx
+ **
+ ** conditions algorithm to create the Si detector
+ ** lookup tables
+ **
+ ** @author sutt
+ ** @date Sun 22 Sep 2019 10:21:50 BST
+ **
+ **
+ ** Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
+ **/
+
+#include "MDT_RegSelCondAlg.h"
+
+#include "CLHEP/Units/SystemOfUnits.h"
+#include "Identifier/IdentifierHash.h"
+
+#include <iostream>
+#include <fstream>
+#include <string>
+
+#include "MuonReadoutGeometry/MuonDetectorManager.h"
+#include "MuonReadoutGeometry/MuonReadoutElement.h"
+#include "MuonReadoutGeometry/MdtReadoutElement.h"
+#include "MuonReadoutGeometry/CscReadoutElement.h"
+#include "MuonReadoutGeometry/RpcReadoutElement.h"
+#include "MuonReadoutGeometry/TgcReadoutElement.h"
+#include "MuonReadoutGeometry/RpcReadoutSet.h"
+#include "MuonReadoutGeometry/MuonStation.h"
+
+
+
+MDT_RegSelCondAlg::MDT_RegSelCondAlg(const std::string& name, ISvcLocator* pSvcLocator):
+ MuonRegSelCondAlg( name, pSvcLocator )
+{
+ ATH_MSG_DEBUG( "MDT_RegSelCondAlg::MDT_RegSelCondAlg() " << name );
+}
+
+
+
+std::unique_ptr<RegSelSiLUT> MDT_RegSelCondAlg::createTable( const MuonMDT_CablingMap* cabling ) const {
+
+ const MuonGM::MuonDetectorManager* manager = nullptr; // again 0 would do as well here
+
+ StatusCode sc = detStore()->retrieve( manager );
+
+ /// can't use ATH_CHECK here as we can;'t return the StatusCode
+ if ( sc.isFailure() ) {
+ ATH_MSG_ERROR( "Could not retrieve MDT Manager for " << name() );
+ return std::unique_ptr<RegSelSiLUT>(nullptr);
+ }
+
+ const MdtIdHelper* helper = manager->mdtIdHelper();
+
+ /// ne wlookup table
+ std::unique_ptr<RegSelSiLUT> lut = std::make_unique<RegSelSiLUT>();
+
+
+ IdContext ModuleContext = helper->module_context();
+
+ std::vector<Identifier>::const_iterator itr = helper->module_begin();
+ std::vector<Identifier>::const_iterator idlast = helper->module_end();
+
+ for ( ; itr!=idlast; itr++ ) {
+
+ Identifier Id = *itr;
+ IdentifierHash Idhash;
+
+ helper->get_hash(Id, Idhash, &ModuleContext);
+
+ ExpandedIdentifier exp_id;
+ if (helper->get_expanded_id( Id, exp_id, &ModuleContext)) {
+ ATH_MSG_DEBUG("Failed retrieving ExpandedIdentifier for PRD Identifier = " << Id.getString() << ". Skipping to the next PRD.");
+ continue;
+ }
+
+ int detid = ( exp_id[2]<0 ? -1 : 1 );
+ int layerid = exp_id[1]+1;
+
+ IdContext mdtChannelContext = helper->channel_context();
+
+ // get the element corresponding to multilayer = 1
+ const MuonGM::MdtReadoutElement* mdt1 = manager->getMdtReadoutElement(Id);
+ if (mdt1 == NULL) {
+ continue;
+ }
+
+ Identifier Id2 = helper->channelID(Id, 2, 1, 1);
+
+ // get the element corresponding to multilayer = 2
+ const MuonGM::MdtReadoutElement* mdt2 = manager->getMdtReadoutElement(Id2);
+
+ double tubePitch = mdt1->tubePitch();
+
+ int ntlay = mdt1->getNLayers();
+ int ntubesl1 = mdt1->getNtubesperlayer();
+ int ntubesl2 = 0;
+
+ if (mdt2 != NULL) ntubesl2 = mdt2->getNtubesperlayer();
+
+ Identifier Idv[4];
+ Idv[0] = helper->channelID(Id, 1, 1, 1);
+ Idv[1] = helper->channelID(Id, 1, 1, ntubesl1);
+ Idv[2] = helper->channelID(Id, 2, ntlay, 1);
+ Idv[3] = helper->channelID(Id, 2, ntlay, ntubesl2);
+
+ // std::cout<<" Number of tube layers "<<ntlay;
+ // std::cout<<" Number of tubes / layer (1 ,2) "<<ntubesl1<<", "<<ntubesl2;
+
+ double rmin = 99999999.;
+ double rmax = -99999999.;
+ double zmin = 99999999.;
+ double zmax = -99999999.;
+ double emin = 99999999.;
+ double emax = -99999999.;
+ double phimin = 999999.;
+ double phimax = -999999.;
+
+ double zpos21 = 0.;
+ Identifier Idsl = helper->channelID(Id, 1, 2, 1);
+ if (mdt1->barrel()) {
+ zpos21 = (mdt1->tubePos(Idsl)).z()-(mdt1->tubePos(Idv[0])).z();
+ }
+ else {
+ zpos21 = (mdt1->tubePos(Idsl)).perp()-(mdt1->tubePos(Idv[0])).perp();
+ }
+
+ /// what is this loop over? This is awful code, this i parameter hides
+ /// the "i" from loop over the iterators, or it did until I changed it
+ // to a more sensibly named "itr"
+ for (int i=0; i<4; i++) {
+
+ const MuonGM::MdtReadoutElement* mdt = NULL;
+
+ if ( i<2 ) mdt = mdt1;
+ else mdt = mdt2;
+ if (mdt == NULL) {
+ // std::cout<<" element not found for index i = "<<i<<" --------- "<<std::endl;
+ if (i==2) {
+ Idv[2] = helper->channelID(Id, 1, ntlay, 1);
+ mdt = manager->getMdtReadoutElement(Idv[2]);
+ }
+ else if (i==3) {
+ Idv[3] = helper->channelID(Id, 1, ntlay, ntubesl1);
+ mdt = manager->getMdtReadoutElement(Idv[3]);
+ }
+ else {
+ // std::cout<<" Skipping element; i = "<<i<<" ----- "<<std::endl;
+ continue;
+ }
+
+ }
+
+ Amg::Vector3D mdtPos = mdt->tubePos(Idv[i]);
+
+ Amg::Vector3D mdtPos1 = mdtPos;
+ Amg::Vector3D mdtPos2 = mdtPos;
+
+ double scaleMin = (mdtPos.perp()-tubePitch/2.)/mdtPos.perp();
+ double scalePlus = (mdtPos.perp()+tubePitch/2.)/mdtPos.perp();
+
+ if (mdt->barrel()) {
+
+ // these are z ranges of the first or last tube layer
+ // mdtPos1.setZ(mdtPos.z()-tubePitch/2.);
+ // mdtPos2.setZ(mdtPos.z()+tubePitch/2.);
+ mdtPos1[2] = mdtPos.z()-tubePitch/2.;
+ mdtPos2[2] = mdtPos.z()+tubePitch/2.;
+
+ // correct the z ranges of the first or last tube layer to account for tube staggering
+ if (zpos21 > 1.) {
+ // mdtPos2.setZ(mdtPos2.z()+tubePitch/2.);
+ mdtPos2[2] = mdtPos2.z()+tubePitch/2.;
+ }
+ else if (zpos21 < -1.) {
+ //mdtPos1.setZ(mdtPos1.z()-tubePitch/2.);
+ mdtPos1[2] = mdtPos1.z()-tubePitch/2.;
+ }
+
+ if (i<2) {
+ mdtPos1[0] *= scaleMin;
+ mdtPos1[1] *= scaleMin;
+ mdtPos2[0] *= scaleMin;
+ mdtPos2[1] *= scaleMin;
+ // mdtPos1.setPerp(mdtPos.perp()-tubePitch/2.);
+ // mdtPos2.setPerp(mdtPos.perp()-tubePitch/2.);
+ }
+ else {
+ mdtPos1[0] *= scalePlus;
+ mdtPos1[1] *= scalePlus;
+ mdtPos2[0] *= scalePlus;
+ mdtPos2[1] *= scalePlus;
+ // mdtPos1.setPerp(mdtPos.perp()+tubePitch/2.);
+ // mdtPos2.setPerp(mdtPos.perp()+tubePitch/2.);
+ }
+ }
+ else {
+
+ // these are z ranges of the first or last tube layer
+ mdtPos1[0] *= scaleMin;
+ mdtPos1[1] *= scaleMin;
+ mdtPos2[0] *= scalePlus;
+ mdtPos2[1] *= scalePlus;
+ // mdtPos1.setPerp(mdtPos.perp()-tubePitch/2.);
+ // mdtPos2.setPerp(mdtPos.perp()+tubePitch/2.);
+ // correct the z ranges of the first or last tube layer to account for tube staggering
+ if (zpos21 > 1.) {
+ scalePlus = (mdtPos2.perp()+tubePitch/2.)/mdtPos2.perp();
+ mdtPos2[0] *= scalePlus;
+ mdtPos2[1] *= scalePlus;
+ // mdtPos2.setPerp(mdtPos2.perp()+tubePitch/2.);
+ }
+ else if (zpos21 < -1.) {
+ scaleMin = (mdtPos1.perp()-tubePitch/2.)/mdtPos1.perp();
+ mdtPos1[0] *= scaleMin;
+ mdtPos1[1] *= scaleMin;
+ // mdtPos1.setPerp(mdtPos1.perp()-tubePitch/2.);
+ }
+ if (i<2) {
+ if (mdt->sideA()){
+ // mdtPos1.setZ(mdtPos.z()-tubePitch/2.);
+ // mdtPos2.setZ(mdtPos.z()-tubePitch/2.);
+ mdtPos1[2] = mdtPos.z()-tubePitch/2.;
+ mdtPos2[2] = mdtPos.z()-tubePitch/2.;
+ }
+ else {
+ // mdtPos1.setZ(mdtPos.z()+tubePitch/2.);
+ // mdtPos2.setZ(mdtPos.z()+tubePitch/2.);
+ mdtPos1[2] = mdtPos.z()+tubePitch/2.;
+ mdtPos2[2] = mdtPos.z()+tubePitch/2.;
+ }
+ }
+ else {
+ if (mdt->sideA()) {
+ // mdtPos1.setZ(mdtPos.z()+tubePitch/2.);
+ // mdtPos2.setZ(mdtPos.z()+tubePitch/2.);
+ mdtPos1[2] = mdtPos.z()+tubePitch/2.;
+ mdtPos2[2] = mdtPos.z()+tubePitch/2.;
+ }
+ else {
+ // mdtPos1.setZ(mdtPos.z()-tubePitch/2.);
+ // mdtPos2.setZ(mdtPos.z()-tubePitch/2.);
+ mdtPos1[2] = mdtPos.z()-tubePitch/2.;
+ mdtPos2[2] = mdtPos.z()-tubePitch/2.;
+ }
+ }
+ }
+
+ double eminMod = 0.;
+ double emaxMod = 0.;
+ double zminMod = 0.;
+ double zmaxMod = 0.;
+ double rminMod = 0.;
+ double rmaxMod = 0.;
+ double dphi = 0.;
+
+ if (mdt->barrel()) {
+ eminMod = mdtPos1.eta();
+ emaxMod = mdtPos2.eta();
+
+ zminMod = mdtPos1.z();
+ zmaxMod = mdtPos2.z();
+
+ rminMod = mdtPos1.perp();
+ rmaxMod = mdtPos2.perp();
+
+ dphi = atan2(mdt->getSsize()/2., (mdtPos.perp()-tubePitch/2.));
+ }
+ else {
+ if (mdt->sideA()) {
+ eminMod = mdtPos2.eta();
+ emaxMod = mdtPos1.eta();
+
+ zminMod = mdtPos2.z();
+ zmaxMod = mdtPos1.z();
+
+ rminMod = mdtPos1.perp();
+ rmaxMod = mdtPos2.perp();
+ }
+ else {
+ eminMod = mdtPos1.eta();
+ emaxMod = mdtPos2.eta();
+
+ zminMod = mdtPos1.z();
+ zmaxMod = mdtPos2.z();
+
+ rminMod = mdtPos1.perp();
+ rmaxMod = mdtPos2.perp();
+ }
+
+ dphi = atan2(mdt->tubeLength(Idv[i])/2., (mdtPos.perp()-tubePitch/2.));
+ }
+
+ double pminMod = mdtPos.phi() - dphi;
+ double pmaxMod = mdtPos.phi() + dphi;
+
+ if (zminMod < zmin) {
+ zmin = zminMod;
+ }
+
+ if (zmaxMod > zmax) {
+ zmax = zmaxMod;
+ }
+
+ if (pminMod < phimin) phimin = pminMod;
+ if (pmaxMod > phimax) phimax = pmaxMod;
+ if (eminMod < emin) emin = eminMod;
+ if (emaxMod > emax) emax = emaxMod;
+ if (rminMod < rmin) rmin = rminMod;
+ if (rmaxMod > rmax) rmax = rmaxMod;
+ // std::cout<<" Module emin - emax "<<emin<<" "<<emax<<" phimin - phimax "<<phimin<<" "<<phimax<<std::endl;
+
+ }
+
+ // here define the eta and phi(0-2*pi) ranges
+ if (phimin<0) phimin = phimin + 2*M_PI;
+ if (phimax<0) phimax = phimax + 2*M_PI;
+
+ // calculate 4 sub detectors for the mdt, fore and aft barrel,
+ // and fore and aft endcaps
+
+ if ( mdt1->barrel() ) {
+ if ( mdt1->sideA() ) detid = 1;
+ else if ( mdt1->sideC() ) detid = -1;
+ }
+ else {
+ if ( mdt1->sideA() ) detid = 2;
+ else if ( mdt1->sideC() ) detid = -2;
+ }
+
+
+ // std::cout << "detid " << detid;
+
+ // if ( mdt1->barrel() ) detid = 0;
+ // if ( mdt1->sideA() ) detid = 1;
+ // if ( mdt1->sideC() ) detid = -1;
+
+ // std::cout << " -> " << detid << std::endl;
+
+ uint32_t RobId = cabling->getROBId(Idhash);
+
+ RegSelModule m( zmin, zmax, rmin, rmax, phimin, phimax, layerid, detid, RobId, Idhash );
+
+ lut->addModule( m );
+
+ }
+
+
+ lut->initialise();
+
+ return lut;
+
+}
+
+
+
+
+
+
+
diff --git a/MuonSpectrometer/MuonDetDescr/MuonRegionSelector/src/MDT_RegSelCondAlg.h b/MuonSpectrometer/MuonDetDescr/MuonRegionSelector/src/MDT_RegSelCondAlg.h
new file mode 100755
index 0000000000000000000000000000000000000000..1de2560110d41b456acc48b5dae7e219438d3153
--- /dev/null
+++ b/MuonSpectrometer/MuonDetDescr/MuonRegionSelector/src/MDT_RegSelCondAlg.h
@@ -0,0 +1,27 @@
+/** emacs: this is -*- c++ -*- **/
+/**
+ ** @file MDT_RegSelCondAlg.h
+ **
+ ** @author sutt
+ ** @date Tue 4 Feb 2020 15:25:00 CET
+ **
+ ** Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
+ **/
+
+#ifndef MDT_RegSelCondAlg_h
+#define MDT_RegSelCondAlg_h
+
+#include "MuonRegSelCondAlg.h"
+
+
+class MDT_RegSelCondAlg : public MuonRegSelCondAlg {
+
+public:
+
+ MDT_RegSelCondAlg( const std::string& name, ISvcLocator* pSvcLocator );
+
+ std::unique_ptr<RegSelSiLUT> createTable( const MuonMDT_CablingMap* cabling ) const override;
+
+};
+
+#endif // MDT_RegSelCondAlg_h
diff --git a/MuonSpectrometer/MuonDetDescr/MuonRegionSelector/src/MM_RegSelCondAlg.cxx b/MuonSpectrometer/MuonDetDescr/MuonRegionSelector/src/MM_RegSelCondAlg.cxx
new file mode 100644
index 0000000000000000000000000000000000000000..686fdc8981fa6b3fd64f47cff96abef21bad6c28
--- /dev/null
+++ b/MuonSpectrometer/MuonDetDescr/MuonRegionSelector/src/MM_RegSelCondAlg.cxx
@@ -0,0 +1,156 @@
+/**
+ ** @file MM_RegSelCondAlg.cxx
+ **
+ ** conditions algorithm to create the Si detector
+ ** lookup tables
+ **
+ ** @author sutt
+ ** @date Sun 22 Sep 2019 10:21:50 BST
+ **
+ **
+ ** Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
+ **/
+
+#include "GaudiKernel/EventIDRange.h"
+#include "StoreGate/WriteCondHandle.h"
+
+#include "CLHEP/Units/SystemOfUnits.h"
+#include "Identifier/IdentifierHash.h"
+
+#include <iostream>
+#include <fstream>
+#include <string>
+#include <cmath>
+
+#include "MuonCablingData/MuonMDT_CablingMap.h"
+
+#include "MuonReadoutGeometry/MuonDetectorManager.h"
+#include "MuonReadoutGeometry/MuonReadoutElement.h"
+
+#include "MuonReadoutGeometry/MMReadoutElement.h"
+#include "MuonAGDDDescription/MMDetectorHelper.h"
+#include "MuonAGDDDescription/MMDetectorDescription.h"
+
+#include "MuonReadoutGeometry/MuonStation.h"
+
+#include "RegSelLUT/RegSelSiLUT.h"
+
+/// not implemented yet
+/// #include "MuonMM_Cabling/MuonMM_CablingSvc.h"
+
+
+#include "MM_RegSelCondAlg.h"
+
+
+MM_RegSelCondAlg::MM_RegSelCondAlg(const std::string& name, ISvcLocator* pSvcLocator):
+ MuonRegSelCondAlg( name, pSvcLocator )
+{
+ ATH_MSG_DEBUG( "MM_RegSelCondAlg::MM_RegSelCondAlg() " << name );
+}
+
+
+
+
+
+std::unique_ptr<RegSelSiLUT> MM_RegSelCondAlg::createTable( const MuonMDT_CablingMap* /* mdtCabling */ ) const {
+
+ /// no NSW cabling available at the moment ...
+
+ /// get the MM detector manager
+
+ const MuonGM::MuonDetectorManager* manager = nullptr;
+
+ if ( (detStore()->retrieve( manager ).isFailure() ) ) {
+ ATH_MSG_ERROR( "Could not retrieve CSC Manager for " << name() );
+ return std::unique_ptr<RegSelSiLUT>(nullptr);
+ }
+
+ const MmIdHelper* helper = manager->mmIdHelper();
+
+
+ std::vector<Identifier>::const_iterator idfirst = helper->module_begin();
+ std::vector<Identifier>::const_iterator idlast = helper->module_end();
+
+ /// do we want the module context ...
+ /// const IdContext ModuleContext = helper->module_context();
+
+ /// or the detector element context ? Keep them both untill we are sure
+ const IdContext ModuleContext = helper->detectorElement_context();
+
+ ATH_MSG_DEBUG("createTable()");
+
+ std::unique_ptr<RegSelSiLUT> lut = std::make_unique<RegSelSiLUT>();
+
+
+ for ( std::vector<Identifier>::const_iterator i=idfirst ; i!=idlast ; i++ ) {
+
+ Identifier Id = *i;
+ IdentifierHash hashId;
+
+ helper->get_hash( Id, hashId, &ModuleContext );
+
+ const MuonGM::MMReadoutElement* mm = manager->getMMReadoutElement(Id);
+ if (!mm) continue;
+
+ int multilayer = helper->multilayer(Id);
+
+ char side = mm->getStationEta() < 0 ? 'C' : 'A';
+
+ char sector_l = mm->getStationName().substr(2,1)=="L" ? 'L' : 'S';
+
+ MMDetectorHelper aHelper;
+ MMDetectorDescription* md = aHelper.Get_MMDetector( sector_l, std::abs(mm->getStationEta()), mm->getStationPhi(), multilayer, side );
+
+ /// now calculate the required limits
+
+ Amg::Vector3D mmPos = mm->center();
+
+
+ double swidth = md->sWidth();
+ double lwidth = md->lWidth();
+
+ double length = md->Length();
+ double depth = md->Tck();
+
+ double moduleR = std::sqrt( mmPos.mag()*mmPos.mag() - mmPos.z()*mmPos.z());
+
+ double zmin = mmPos.z()-0.5*depth;
+ double zmax = mmPos.z()+0.5*depth;
+
+ // std::cout << "MM:module: rcen: " << moduleR << "\tlength: " << length << "\tswidth: " << swidth << "\tlwidth: " << lwidth << std::endl;
+
+ double rmin = moduleR-0.5*length;
+ double rmax = std::sqrt( (moduleR+0.5*length)*(moduleR+0.5*length) + 0.25*lwidth*lwidth );
+
+ double dphi1 = std::atan( (0.5*lwidth)/(moduleR+0.5*length) );
+ double dphi2 = std::atan( (0.5*swidth)/(moduleR-0.5*length) );
+
+ double dphi = ( dphi1 > dphi2 ? dphi1 : dphi2 );
+
+ double phimin = mmPos.phi()-dphi;
+ double phimax = mmPos.phi()+dphi;
+
+ if ( phimin > M_PI ) phimin -= 2*M_PI;
+ if ( phimin < -M_PI ) phimin += 2*M_PI;
+
+ if ( phimax > M_PI ) phimax -= 2*M_PI;
+ if ( phimax < -M_PI ) phimax += 2*M_PI;
+
+ int layerid = multilayer;
+ int detid = ( side == 'C' ? -1 : 1 );
+
+ /// no cabling map at the moment - don't store robID
+ int robId = 0;
+
+ RegSelModule m( zmin, zmax, rmin, rmax, phimin, phimax, int(layerid), int(detid), uint32_t(robId), hashId );
+
+ lut->addModule( m );
+
+ }
+
+ lut->initialise();
+
+ return lut;
+
+}
+
diff --git a/MuonSpectrometer/MuonDetDescr/MuonRegionSelector/src/MM_RegSelCondAlg.h b/MuonSpectrometer/MuonDetDescr/MuonRegionSelector/src/MM_RegSelCondAlg.h
new file mode 100755
index 0000000000000000000000000000000000000000..f21403219f3288c25aea143c1bf9f51fc54baf1b
--- /dev/null
+++ b/MuonSpectrometer/MuonDetDescr/MuonRegionSelector/src/MM_RegSelCondAlg.h
@@ -0,0 +1,28 @@
+/** emacs: this is -*- c++ -*- **/
+/**
+ ** @file MM_RegSelCondAlg.h
+ **
+ ** @author sutt
+ ** @date Tue 4 Feb 2020 15:25:00 CET
+ **
+ ** Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
+ **/
+
+#ifndef MM_RegSelCondAlg_h
+#define MM_RegSelCondAlg_h
+
+
+#include "MuonRegSelCondAlg.h"
+
+
+class MM_RegSelCondAlg : public MuonRegSelCondAlg {
+
+public:
+
+ MM_RegSelCondAlg( const std::string& name, ISvcLocator* pSvcLocator );
+
+ std::unique_ptr<RegSelSiLUT> createTable( const MuonMDT_CablingMap* mdtCabling ) const;
+
+};
+
+#endif // CSC_RegSelCondAlg_h
diff --git a/MuonSpectrometer/MuonDetDescr/MuonRegionSelector/src/MuonRegSelCondAlg.cxx b/MuonSpectrometer/MuonDetDescr/MuonRegionSelector/src/MuonRegSelCondAlg.cxx
new file mode 100644
index 0000000000000000000000000000000000000000..093503e8e680572a092182feba7b2cc5b01f59d9
--- /dev/null
+++ b/MuonSpectrometer/MuonDetDescr/MuonRegionSelector/src/MuonRegSelCondAlg.cxx
@@ -0,0 +1,109 @@
+/**
+ ** @file MuonRegSelCondAlg.cxx
+ **
+ ** conditions algorithm to create the Si detector
+ ** lookup tables
+ **
+ ** @author sutt
+ ** @date Sun 22 Sep 2019 10:21:50 BST
+ **
+ **
+ ** Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
+ **/
+
+
+#include "GaudiKernel/EventIDRange.h"
+#include "StoreGate/WriteCondHandle.h"
+
+#include <iostream>
+#include <fstream>
+#include <string>
+
+
+#include "MuonCablingData/MuonMDT_CablingMap.h"
+
+#include "MDT_RegSelCondAlg.h"
+
+
+
+MuonRegSelCondAlg::MuonRegSelCondAlg(const std::string& name, ISvcLocator* pSvcLocator):
+ AthReentrantAlgorithm( name, pSvcLocator ),
+ m_managerName(""),
+ m_printTable(false)
+{
+ ATH_MSG_DEBUG( "MuonRegSelCondAlg::MuonRegSelCondAlg() " << name );
+ declareProperty( "PrintTable", m_printTable=false );
+ declareProperty( "ManagerName", m_managerName );
+}
+
+
+
+
+StatusCode MuonRegSelCondAlg::initialize()
+{
+ ATH_MSG_DEBUG("MuonRegSelCondAlg::initialize() ");
+ ATH_CHECK(m_cablingKey.initialize());
+ ATH_CHECK(m_tableKey.initialize());
+ ATH_MSG_INFO("MuonRegSelCondAlg::initialize() " << m_tableKey );
+ return StatusCode::SUCCESS;
+}
+
+
+
+StatusCode MuonRegSelCondAlg::execute(const EventContext& ctx) const
+{
+ ATH_MSG_DEBUG("MuonRegSelCondAlg::execute() -- enter -- ");
+
+ /// do stuff here ...
+ ATH_MSG_DEBUG( "Creating region selector table " << m_tableKey );
+
+
+ SG::ReadCondHandle<MuonMDT_CablingMap> cabling( m_cablingKey, ctx );
+
+ EventIDRange id_range;
+
+ if( !cabling.range( id_range ) ) {
+ ATH_MSG_ERROR("Failed to retrieve validity range for " << cabling.key());
+ return StatusCode::FAILURE;
+ }
+
+ /// create the new lookuo table
+
+ std::unique_ptr<RegSelSiLUT> rd = createTable( *cabling );
+
+ if ( !rd ) return StatusCode::FAILURE;
+
+ ATH_MSG_DEBUG( "Initialising new map " );;
+
+ // write out new new LUT to a file if need be
+
+ if ( m_printTable ) rd->write( name()+".map" );
+
+ /// create the conditions data for storage
+
+ RegSelLUTCondData* rcd = new RegSelLUTCondData( std::move(rd) );
+
+ try {
+ SG::WriteCondHandle<RegSelLUTCondData> lutCondData( m_tableKey, ctx );
+ if( lutCondData.record( id_range, rcd ).isFailure() ) {
+ ATH_MSG_ERROR( "Could not record " << m_tableKey
+ << " " << lutCondData.key()
+ << " with range " << id_range );
+ return StatusCode::FAILURE;
+ }
+ ATH_MSG_INFO( "RegSelCondAlg LUT recorded: " << m_tableKey);
+ }
+ catch (...) {
+ ATH_MSG_ERROR("MuonRegSelCondAlg::execute() failed to record table: " << m_tableKey);
+ return StatusCode::FAILURE;
+ }
+
+
+ ATH_MSG_DEBUG("MuonRegSelCondAlg::execute() -- exit -- ");
+
+ return StatusCode::SUCCESS;
+}
+
+
+
+
diff --git a/MuonSpectrometer/MuonDetDescr/MuonRegionSelector/src/MuonRegSelCondAlg.h b/MuonSpectrometer/MuonDetDescr/MuonRegionSelector/src/MuonRegSelCondAlg.h
new file mode 100755
index 0000000000000000000000000000000000000000..bcccb38e924a61a814bb9e198c8e647e3d6c429d
--- /dev/null
+++ b/MuonSpectrometer/MuonDetDescr/MuonRegionSelector/src/MuonRegSelCondAlg.h
@@ -0,0 +1,60 @@
+/** emacs: this is -*- c++ -*- **/
+/**
+ ** @file MuonRegSelCondAlg.h
+ **
+ ** @author sutt
+ ** @date Tue 4 Feb 2020 15:25:00 CET
+ **
+ ** Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
+ **/
+
+#ifndef MuonRegSelCondAlg_h
+#define MuonRegSelCondAlg_h
+
+#include "GaudiKernel/ISvcLocator.h"
+
+#include "AthenaBaseComps/AthReentrantAlgorithm.h"
+#include "AthenaBaseComps/AthAlgTool.h"
+
+#include "GaudiKernel/ToolHandle.h"
+
+#include "MuonCablingData/MuonMDT_CablingMap.h"
+
+#include "StoreGate/ReadCondHandleKey.h"
+#include "StoreGate/WriteCondHandleKey.h"
+
+#include "IRegionSelector/RegSelLUTCondData.h"
+
+#include <string>
+
+
+/////////////////////////////////////////////////////////////////////////////
+
+class MuonRegSelCondAlg : public AthReentrantAlgorithm {
+
+public:
+
+ MuonRegSelCondAlg( const std::string& name, ISvcLocator* pSvcLocator );
+
+ virtual StatusCode initialize() override;
+ virtual StatusCode execute (const EventContext& ctx) const override;
+
+ virtual std::unique_ptr<RegSelSiLUT> createTable( const MuonMDT_CablingMap* cabling ) const = 0;
+
+ private:
+
+ std::string m_managerName;
+ bool m_printTable;
+
+ SG::ReadCondHandleKey<MuonMDT_CablingMap> m_cablingKey
+ { this, "Cabling", "MuonMDT_CablingMap", "Key of output MDT cabling map" };
+
+ /// Output conditions object
+ SG::WriteCondHandleKey<RegSelLUTCondData> m_tableKey
+ { this, "RegSelLUT", "RegSelLUTCondData", "Region Selector lookup table" };
+
+
+
+};
+
+#endif // MuonRegSelCondAlg_h
diff --git a/MuonSpectrometer/MuonDetDescr/MuonRegionSelector/src/RPC_RegSelCondAlg.cxx b/MuonSpectrometer/MuonDetDescr/MuonRegionSelector/src/RPC_RegSelCondAlg.cxx
new file mode 100644
index 0000000000000000000000000000000000000000..34b375b253c908bd4979e1516b111c5e0b1b35ad
--- /dev/null
+++ b/MuonSpectrometer/MuonDetDescr/MuonRegionSelector/src/RPC_RegSelCondAlg.cxx
@@ -0,0 +1,271 @@
+/**
+ ** @file RPC_RegSelCondAlg.cxx
+ **
+ ** conditions algorithm to create the Si detector
+ ** lookup tables
+ **
+ ** @author sutt
+ ** @date Sun 22 Sep 2019 10:21:50 BST
+ **
+ **
+ ** Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
+ **/
+
+
+#include "GaudiKernel/EventIDRange.h"
+#include "StoreGate/WriteCondHandle.h"
+
+#include "CLHEP/Units/SystemOfUnits.h"
+#include "Identifier/IdentifierHash.h"
+
+#include <iostream>
+#include <fstream>
+#include <string>
+
+
+#include "MuonCablingData/MuonMDT_CablingMap.h"
+
+#include "MuonReadoutGeometry/MuonDetectorManager.h"
+#include "MuonReadoutGeometry/MuonReadoutElement.h"
+#include "MuonReadoutGeometry/MdtReadoutElement.h"
+#include "MuonReadoutGeometry/CscReadoutElement.h"
+#include "MuonReadoutGeometry/RpcReadoutElement.h"
+#include "MuonReadoutGeometry/TgcReadoutElement.h"
+#include "MuonReadoutGeometry/RpcReadoutSet.h"
+#include "MuonReadoutGeometry/MuonStation.h"
+
+#include "RPC_RegSelCondAlg.h"
+
+#include "RPCcablingInterface/IRPCcablingServerSvc.h"
+#include "RPCcablingInterface/IRPCcablingSvc.h"
+
+
+
+RPC_RegSelCondAlg::RPC_RegSelCondAlg(const std::string& name, ISvcLocator* pSvcLocator):
+ MuonRegSelCondAlg( name, pSvcLocator )
+{
+ ATH_MSG_DEBUG( "RPC_RegSelCondAlg::RPC_RegSelCondAlg() " << name );
+}
+
+
+
+std::unique_ptr<RegSelSiLUT> RPC_RegSelCondAlg::createTable( const MuonMDT_CablingMap* /* mdtCabling */ ) const {
+
+ /// now get the RPC cabling service ...
+
+ const IRPCcablingServerSvc* cabling_server = nullptr;
+
+ if ( service( "RPCcablingServerSvc", cabling_server ).isFailure() ) {
+ ATH_MSG_ERROR( "Could not retieve RPC cabling server");
+ return std::unique_ptr<RegSelSiLUT>(nullptr);
+ }
+
+ const IRPCcablingSvc* cabling = nullptr;
+
+ if ( cabling_server->giveCabling( cabling ).isFailure() ) {
+ ATH_MSG_ERROR( "Could not retieve RPC cabling service");
+ return std::unique_ptr<RegSelSiLUT>(nullptr);
+ }
+
+ const MuonGM::MuonDetectorManager* manager = nullptr;
+
+ if ( detStore()->retrieve( manager ).isFailure() ) {
+ ATH_MSG_ERROR( "Could not retrieve RPC Manager for " << name() );
+ return std::unique_ptr<RegSelSiLUT>(nullptr);
+ }
+
+ const RpcIdHelper* helper = manager->rpcIdHelper();
+
+ std::vector<Identifier>::const_iterator idfirst = helper->module_begin();
+ std::vector<Identifier>::const_iterator idlast = helper->module_end();
+
+ IdContext ModuleContext = helper->module_context();
+
+ ATH_MSG_DEBUG("createTable()");
+
+ std::unique_ptr<RegSelSiLUT> lut = std::make_unique<RegSelSiLUT>();
+
+
+ //loop over modules (PrepRawData collections)
+ for ( std::vector<Identifier>::const_iterator itr=idfirst ; itr!=idlast ; itr++ ) {
+
+ Identifier prdId = *itr;
+ IdentifierHash prdHashId;
+ int gethash_code = helper->get_hash(prdId, prdHashId, &ModuleContext);
+ if (gethash_code != 0 ) {
+ ATH_MSG_DEBUG("Failed retrieving IdentifierHash for PRD Identifier = " << prdId.getString() << ". Skipping to the next PRD.");
+ continue;
+ }
+
+ std::vector<uint32_t> robIds;
+ StatusCode sc = cabling->giveROB_fromPRD(prdHashId, robIds);
+ if ( (cabling->giveROB_fromPRD(prdHashId, robIds)).isFailure() ) {
+ ATH_MSG_ERROR( "RegSelCondAlg_RPC could not get ROBid" );
+ return std::unique_ptr<RegSelSiLUT>(nullptr);
+ }
+
+
+ if (robIds.size() < 1) {
+ ATH_MSG_DEBUG("There is no ROB associated with the PRD HashId = " << (unsigned int)prdHashId << ". Skipping to the next PRD.");
+ continue;
+ }
+ if (robIds.size()!=1 && robIds.size()!=2 && robIds.size()!=4) {
+ ATH_MSG_WARNING("Unhandled number of ROBs per one PRD. Expected 1, 2 or 4, got " << robIds.size() << ". Omitting the PRD HashId = " << (unsigned int)prdHashId);
+ continue;
+ }
+
+ ExpandedIdentifier exp_id;
+ if ( helper->get_expanded_id( prdId, exp_id, &ModuleContext) ) {
+ ATH_MSG_DEBUG("Failed retrieving ExpandedIdentifier for PRD Identifier = " << prdId.getString() << ". Skipping to the next PRD.");
+ continue;
+ }
+
+ int detid = ( exp_id[2]<0 ? -1 : 1 );
+ int layerid = exp_id[1];
+ if ( layerid==0 ) layerid = 11; // this line should never be executed
+
+ MuonGM::RpcReadoutSet Set( manager, prdId );
+ //int nmod = Set.NreadoutElements();
+ int ndbz = Set.NdoubletZ();
+
+ //std::cout<<" Number of modules in this RpcSet "<<nmod<<" Number of doubletZ in this RpcSet "<<Set.NdoubletZ()<<std::endl;
+ //std::cout<<" Number of modules in Phi/DoubletZ: ";
+ //for (int i=1; i<=ndbz; i++) std::cout<<Set.NPhimodules(i)<<" ";
+ //std::cout<<std::endl;
+
+ double zmin = 99999999;
+ double zmax = -99999999;
+ double rmin = 99999999;
+ double rmax = -99999999;
+ double phimin = 999999;
+ double phimax = -999999;
+ Amg::Vector3D Pzmin;
+ Amg::Vector3D Pzmax;
+ unsigned nmodules = 0;
+
+ for (int dbz=1; dbz<=ndbz; dbz++) {
+
+ const MuonGM::RpcReadoutElement* rpcold = NULL;
+ int ndbp = Set.NPhimodules(dbz);
+
+ for (int dbp=1; dbp<=ndbp; dbp++) {
+
+ const MuonGM::RpcReadoutElement* rpc = Set.readoutElement(dbz, dbp);
+
+ if ( rpc != rpcold ) {
+
+ // here a new module
+ nmodules ++;
+ rpcold = rpc;
+
+ Amg::Vector3D rpcPos = rpc->center();
+ double zminMod = rpcPos.z()-0.5*rpc->getZsize();
+ double zmaxMod = rpcPos.z()+0.5*rpc->getZsize();
+
+ //double rcen = std::sqrt(rpcPos.r()*rpcPos.r()-rpcPos.z()*rpcPos.z());
+ double rcen = std::sqrt(rpcPos.mag()*rpcPos.mag()-rpcPos.z()*rpcPos.z());
+
+ double rminMod = rcen-0.5*rpc->getRsize();
+ double rmaxMod = rcen+0.5*rpc->getRsize();
+
+ // double dphi = std::atan2(rpc->getSsize()/2.,rpcPos.perp());
+ double dphi = std::atan2(rpc->getSsize()/2,rpcPos.perp());
+ double pminMod = rpcPos.phi() - dphi;
+ double pmaxMod = rpcPos.phi() + dphi;
+
+ if (zminMod < zmin) {
+ zmin = zminMod;
+ Pzmin = rpcPos;
+ //Pzmin.setZ(zmin);
+ Pzmin[2] = zmin;
+ }
+ if (zmaxMod > zmax) {
+ zmax = zmaxMod;
+ Pzmax = rpcPos;
+ //Pzmax.setZ(zmax);
+ Pzmax[2] = zmax;
+ }
+ if (rminMod < rmin) {
+ rmin = rminMod;
+ }
+ if (rmaxMod > rmax) {
+ rmax = rmaxMod;
+ }
+ if (pminMod < phimin) phimin = pminMod;
+ if (pmaxMod > phimax) phimax = pmaxMod;
+
+ }
+ }
+ }
+
+ double phiMinFirst = phimin;
+ double phiMaxFirst = 0.5*(phimin+phimax);
+ double phiMinSecond = 0.5*(phimin+phimax);
+ double phiMaxSecond = phimax;
+
+ if (phiMinFirst < 0) phiMinFirst += 2*M_PI;
+ if (phiMaxFirst < 0) phiMaxFirst += 2*M_PI;
+ if (phiMinSecond < 0) phiMinSecond += 2*M_PI;
+ if (phiMaxSecond < 0) phiMaxSecond += 2*M_PI;
+
+
+ if (robIds.size()==1) {
+ IdentifierHash lowerHashId( (1<<16) | (unsigned int)prdHashId );
+
+ RegSelModule m1( zmin, zmax, rmin, rmax, phiMinFirst, phiMaxSecond, layerid, detid, robIds[0], lowerHashId );
+ lut->addModule( m1 );
+ }
+ //the code below exploits the fact that ROB Ids are sorted!!! They go in order: SIDE A, ROBs 0..15, then SIDE C ROBs 0..15
+ //it is also assumed that if there are 4 ROBs, then zmin<0 and zmax>0
+ else if (robIds.size()==2) {
+ uint32_t lowerRobId=0;
+ uint32_t higherRobId=0;
+ if ( ((robIds[0] & 0xff) == 0) && ((robIds[1] & 0xff) == 15) ) { //the two ROBs around phi=0
+ lowerRobId = robIds[1];
+ higherRobId = robIds[0];
+ }
+ else {
+ lowerRobId = robIds[0];
+ higherRobId = robIds[1];
+ }
+ IdentifierHash lowerHashId( (1<<16) | (unsigned int)prdHashId );
+ IdentifierHash higherHashId( (2<<16) | (unsigned int)prdHashId );
+
+ RegSelModule m1( zmin, zmax, rmin, rmax, phiMinFirst, phiMaxFirst, layerid, detid, lowerRobId, lowerHashId );
+ RegSelModule m2( zmin, zmax, rmin, rmax, phiMinSecond, phiMaxSecond, layerid, detid, higherRobId, higherHashId );
+ lut->addModule( m1 );
+ lut->addModule( m2 );
+ }
+ else if (robIds.size()==4) { //this is the case only for two BOG chambers at z=0 read by ROBs 10-11 and 12-13, each on both sides A and C
+ uint32_t sideA_lowerRobId = robIds[0];
+ uint32_t sideA_higherRobId = robIds[1];
+ uint32_t sideC_lowerRobId = robIds[2];
+ uint32_t sideC_higherRobId = robIds[3];
+ IdentifierHash sideA_lowerHashId( (1<<16) | (unsigned int)prdHashId );
+ IdentifierHash sideA_higherHashId( (2<<16) | (unsigned int)prdHashId );
+ IdentifierHash sideC_lowerHashId( (3<<16) | (unsigned int)prdHashId );
+ IdentifierHash sideC_higherHashId( (4<<16) | (unsigned int)prdHashId );
+
+ RegSelModule m1( 0, zmax, rmin, rmax, phiMinFirst, phiMaxFirst, layerid, detid, sideA_lowerRobId, sideA_lowerHashId );
+ RegSelModule m2( 0, zmax, rmin, rmax, phiMinSecond, phiMaxSecond, layerid, detid, sideA_higherRobId, sideA_higherHashId );
+ RegSelModule m3( zmin, 0, rmin, rmax, phiMinFirst, phiMaxFirst, layerid, detid, sideC_lowerRobId, sideC_lowerHashId );
+ RegSelModule m4( zmin, 0, rmin, rmax, phiMinSecond, phiMaxSecond, layerid, detid, sideC_higherRobId, sideC_higherHashId );
+ lut->addModule( m1 );
+ lut->addModule( m2 );
+ lut->addModule( m3 );
+ lut->addModule( m4 );
+ }
+ } //end of loop over modules (PrepRawData collections)
+
+ lut->initialise();
+
+ return lut;
+
+}
+
+
+
+
+
+
+
diff --git a/MuonSpectrometer/MuonDetDescr/MuonRegionSelector/src/RPC_RegSelCondAlg.h b/MuonSpectrometer/MuonDetDescr/MuonRegionSelector/src/RPC_RegSelCondAlg.h
new file mode 100755
index 0000000000000000000000000000000000000000..e68633d44664ff0a3ff01212febd6a96aeed0908
--- /dev/null
+++ b/MuonSpectrometer/MuonDetDescr/MuonRegionSelector/src/RPC_RegSelCondAlg.h
@@ -0,0 +1,27 @@
+/** emacs: this is -*- c++ -*- **/
+/**
+ ** @file RPC_RegSelCondAlg.h
+ **
+ ** @author sutt
+ ** @date Tue 4 Feb 2020 15:25:00 CET
+ **
+ ** Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
+ **/
+
+#ifndef RPC_RegSelCondAlg_h
+#define RPC_RegSelCondAlg_h
+
+#include "MuonRegSelCondAlg.h"
+
+
+class RPC_RegSelCondAlg : public MuonRegSelCondAlg {
+
+public:
+
+ RPC_RegSelCondAlg( const std::string& name, ISvcLocator* pSvcLocator );
+
+ std::unique_ptr<RegSelSiLUT> createTable( const MuonMDT_CablingMap* mdtCabling ) const override;
+
+};
+
+#endif // RPC_RegSelCondAlg_h
diff --git a/MuonSpectrometer/MuonDetDescr/MuonRegionSelector/src/RPC_RegionSelectorTable.cxx b/MuonSpectrometer/MuonDetDescr/MuonRegionSelector/src/RPC_RegionSelectorTable.cxx
index 850400e7649c0ef16da0105d1bc16f57a6551108..340119d40ed3ccf0665378bb9abdcbd9414388f6 100644
--- a/MuonSpectrometer/MuonDetDescr/MuonRegionSelector/src/RPC_RegionSelectorTable.cxx
+++ b/MuonSpectrometer/MuonDetDescr/MuonRegionSelector/src/RPC_RegionSelectorTable.cxx
@@ -231,7 +231,6 @@ StatusCode RPC_RegionSelectorTable::createTable() {
RegSelModule m1( zmin, zmax, rmin, rmax, phiMinFirst, phiMaxSecond, layerid, detid, robIds[0], lowerHashId );
rpclut->addModule( m1 );
}
-
//the code below exploits the fact that ROB Ids are sorted!!! They go in order: SIDE A, ROBs 0..15, then SIDE C ROBs 0..15
//it is also assumed that if there are 4 ROBs, then zmin<0 and zmax>0
else if (robIds.size()==2) {
@@ -253,7 +252,6 @@ StatusCode RPC_RegionSelectorTable::createTable() {
rpclut->addModule( m1 );
rpclut->addModule( m2 );
}
-
else if (robIds.size()==4) { //this is the case only for two BOG chambers at z=0 read by ROBs 10-11 and 12-13, each on both sides A and C
uint32_t sideA_lowerRobId = robIds[0];
uint32_t sideA_higherRobId = robIds[1];
diff --git a/MuonSpectrometer/MuonDetDescr/MuonRegionSelector/src/TGC_RegSelCondAlg.cxx b/MuonSpectrometer/MuonDetDescr/MuonRegionSelector/src/TGC_RegSelCondAlg.cxx
new file mode 100644
index 0000000000000000000000000000000000000000..634918e7a81e2c8292759956449a37260fbb037a
--- /dev/null
+++ b/MuonSpectrometer/MuonDetDescr/MuonRegionSelector/src/TGC_RegSelCondAlg.cxx
@@ -0,0 +1,185 @@
+/**
+ ** @file TGC_RegSelCondAlg.cxx
+ **
+ ** conditions algorithm to create the Si detector
+ ** lookup tables
+ **
+ ** @author sutt
+ ** @date Sun 22 Sep 2019 10:21:50 BST
+ **
+ **
+ ** Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
+ **/
+
+
+#include "GaudiKernel/EventIDRange.h"
+#include "StoreGate/WriteCondHandle.h"
+
+#include "CLHEP/Units/SystemOfUnits.h"
+#include "Identifier/IdentifierHash.h"
+
+#include <iostream>
+#include <fstream>
+#include <string>
+#include <cmath>
+
+#include "MuonCablingData/MuonMDT_CablingMap.h"
+
+#include "MuonReadoutGeometry/MuonDetectorManager.h"
+#include "MuonReadoutGeometry/MuonReadoutElement.h"
+#include "MuonReadoutGeometry/MdtReadoutElement.h"
+#include "MuonReadoutGeometry/CscReadoutElement.h"
+#include "MuonReadoutGeometry/RpcReadoutElement.h"
+#include "MuonReadoutGeometry/TgcReadoutElement.h"
+#include "MuonReadoutGeometry/RpcReadoutSet.h"
+#include "MuonReadoutGeometry/MuonStation.h"
+
+#include "MuonTGC_Cabling/MuonTGC_CablingSvc.h"
+
+#include "TGC_RegSelCondAlg.h"
+
+
+
+TGC_RegSelCondAlg::TGC_RegSelCondAlg(const std::string& name, ISvcLocator* pSvcLocator):
+ MuonRegSelCondAlg( name, pSvcLocator )
+{
+ ATH_MSG_DEBUG( "TGC_RegSelCondAlg::TGC_RegSelCondAlg() " << name );
+}
+
+
+
+
+
+
+std::unique_ptr<RegSelSiLUT> TGC_RegSelCondAlg::createTable( const MuonMDT_CablingMap* /* mdtCabling */ ) const {
+
+ /// now get the TGC cabling service ...
+
+ const MuonTGC_CablingSvc* cabling = nullptr;
+
+ if ( service( "MuonTGC_CablingSvc", cabling ).isFailure() ) {
+ ATH_MSG_ERROR( "Could not retrieve TGC cabling for " << name() );
+ return std::unique_ptr<RegSelSiLUT>(nullptr);
+ }
+
+ /// now get the TGC detector manager ...
+
+ const MuonGM::MuonDetectorManager* manager = nullptr;
+
+ if ( (detStore()->retrieve( manager ).isFailure() ) ) {
+ ATH_MSG_ERROR( "Could not retrieve TGC Manager for " << name() );
+ return std::unique_ptr<RegSelSiLUT>(nullptr);
+ }
+
+ const TgcIdHelper* helper = manager->tgcIdHelper();
+
+ std::vector<Identifier>::const_iterator idfirst = helper->module_begin();
+ std::vector<Identifier>::const_iterator idlast = helper->module_end();
+
+ const IdContext ModuleContext = helper->module_context();
+
+ ATH_MSG_DEBUG("createTable()");
+
+ std::unique_ptr<RegSelSiLUT> lut = std::make_unique<RegSelSiLUT>();
+
+ int maxRodId = 0;
+ int maxSswId = 0;
+ int maxSbloc = 0;
+ int minChannelId = 0;
+ int maxChannelId = 0;
+ cabling->getReadoutIDRanges(maxRodId, maxSswId, maxSbloc, minChannelId, maxChannelId);
+
+ for (std::vector<Identifier>::const_iterator i = idfirst; i != idlast; i++) {
+
+ Identifier Id = *i;
+ IdentifierHash hashId;
+
+ helper->get_hash( Id,hashId,&ModuleContext);
+
+ ExpandedIdentifier exp_id;
+ if (helper->get_expanded_id( Id, exp_id, &ModuleContext)) {
+ ATH_MSG_DEBUG("Failed retrieving ExpandedIdentifier for PRD Identifier = " << Id.getString() << ". Skipping to the next PRD.");
+ continue;
+ }
+
+ int detid = ( exp_id[2]<0 ? -1 : 1 );
+ int layerid = exp_id[1]+1;
+
+ const MuonGM::TgcReadoutElement* tgc = manager->getTgcReadoutElement(Id);
+ if (tgc == NULL) {
+ continue;
+ }
+
+ int gapMin = helper->gasGapMin(Id);
+ int gapMax = helper->gasGapMax(Id);
+
+ Identifier chId;
+ chId = helper -> channelID(Id,gapMin,0,1);
+ const int chmax = helper -> channelMax(chId);
+ Amg::Vector3D posmax = tgc->channelPos(gapMin,0,chmax); // gapMax gives posmax!
+ chId = helper -> channelID(Id,gapMax,0,1);
+ const int chmin = helper -> channelMin(chId);
+ Amg::Vector3D posmin = tgc->channelPos(gapMax,0,chmin); // gapMin gives posmin!
+
+ // caliculation based on max/min channels in a module
+ // etamin = -logf(tan(atan(posmin.perp()/fabs(posmin.z()))/2.));
+ // etamax = -logf(tan(atan(posmax.perp()/fabs(posmax.z()))/2.));
+
+ // caliculation based on active sensitive area
+
+ Amg::Vector3D posctr = tgc->globalPosition();
+ double activeheight = tgc->length();
+
+ double etamin = -logf(std::tan(std::atan((posctr.perp()-0.5*activeheight)/std::fabs(posmin.z()))*0.5));
+ double etamax = -logf(std::tan(std::atan((posctr.perp()+0.5*activeheight)/std::fabs(posmax.z()))*0.5));
+
+ double zmin = posmin.z();
+ double zmax = posmax.z();
+
+ double rmin = posctr.perp()-0.5*activeheight;
+ double rmax = posctr.perp()+0.5*activeheight;
+
+
+ if (helper->stationEta(Id) < 0) {
+ etamin = -etamin;
+ etamax = -etamax;
+ }
+
+
+ // caliculation based on active sensitive area
+ double activelongside = tgc->longWidth()-tgc->frameXwidth()*2.;
+ /// Should use std::atan2 etc, but atan2f is not definied in cmath, so for backwards
+ /// compatability we are forced to use the old versions
+ double phimin = atan2f(posctr.y(),posctr.x()) - atan2f(activelongside/2.,posctr.perp()+activeheight/2.);
+ double phimax = atan2f(posctr.y(),posctr.x()) + atan2f(activelongside/2.,posctr.perp()+activeheight/2.);
+
+ if (phimin < 0) phimin += 2.*M_PI;
+ if (phimax < 0) phimax += 2.*M_PI;
+
+ // get ROB id
+ int subDetectorId = 0; // 0x67 (A side) or 0x68 (C side)
+ int rodId = 0; // 1-12
+ cabling->getReadoutIDfromElementID(Id, subDetectorId, rodId);
+ //int isAside = (subDetectorId==0x67) ? 0 : 1;
+ //uint32_t robId = static_cast<uint32_t>(isAside*(maxRodId) + rodId -1); // 0-23
+ // using Source ID :see Muon::TGC_Hid2RESrcID::getRodID()/getRobId()
+ uint32_t robId = ( ((0x0ff) & subDetectorId)<<16 ) | (rodId);
+ // end part to get ROB id
+
+ RegSelModule m( zmin, zmax, rmin, rmax, phimin, phimax, layerid, detid, robId, hashId );
+ lut->addModule( m );
+
+ }
+
+ lut->initialise();
+
+ return lut;
+
+}
+
+
+
+
+
+
+
diff --git a/MuonSpectrometer/MuonDetDescr/MuonRegionSelector/src/TGC_RegSelCondAlg.h b/MuonSpectrometer/MuonDetDescr/MuonRegionSelector/src/TGC_RegSelCondAlg.h
new file mode 100755
index 0000000000000000000000000000000000000000..aa0ce6d5bfa610687bc255afb4d6eb1cbe8d78db
--- /dev/null
+++ b/MuonSpectrometer/MuonDetDescr/MuonRegionSelector/src/TGC_RegSelCondAlg.h
@@ -0,0 +1,27 @@
+/** emacs: this is -*- c++ -*- **/
+/**
+ ** @file TGC_RegSelCondAlg.h
+ **
+ ** @author sutt
+ ** @date Tue 4 Feb 2020 15:25:00 CET
+ **
+ ** Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
+ **/
+
+#ifndef TGC_RegSelCondAlg_h
+#define TGC_RegSelCondAlg_h
+
+#include "MuonRegSelCondAlg.h"
+
+
+class TGC_RegSelCondAlg : public MuonRegSelCondAlg {
+
+public:
+
+ TGC_RegSelCondAlg( const std::string& name, ISvcLocator* pSvcLocator );
+
+ std::unique_ptr<RegSelSiLUT> createTable( const MuonMDT_CablingMap* mdtCabling ) const;
+
+};
+
+#endif // TGC_RegSelCondAlg_h
diff --git a/MuonSpectrometer/MuonDetDescr/MuonRegionSelector/src/components/MuonRegionSelector_entries.cxx b/MuonSpectrometer/MuonDetDescr/MuonRegionSelector/src/components/MuonRegionSelector_entries.cxx
index 0838295a11e4e3abc92bba99de6c47d06ceb50eb..df0b13f9670e2347656bc441a7bdd1506e496da0 100644
--- a/MuonSpectrometer/MuonDetDescr/MuonRegionSelector/src/components/MuonRegionSelector_entries.cxx
+++ b/MuonSpectrometer/MuonDetDescr/MuonRegionSelector/src/components/MuonRegionSelector_entries.cxx
@@ -13,3 +13,17 @@ DECLARE_COMPONENT( CSC_RegionSelectorTable )
DECLARE_COMPONENT( MM_RegionSelectorTable )
DECLARE_COMPONENT( sTGC_RegionSelectorTable )
+#include "../MDT_RegSelCondAlg.h"
+#include "../RPC_RegSelCondAlg.h"
+#include "../TGC_RegSelCondAlg.h"
+#include "../CSC_RegSelCondAlg.h"
+#include "../MM_RegSelCondAlg.h"
+#include "../sTGC_RegSelCondAlg.h"
+
+DECLARE_COMPONENT( MDT_RegSelCondAlg )
+DECLARE_COMPONENT( RPC_RegSelCondAlg )
+DECLARE_COMPONENT( TGC_RegSelCondAlg )
+DECLARE_COMPONENT( CSC_RegSelCondAlg )
+DECLARE_COMPONENT( MM_RegSelCondAlg )
+DECLARE_COMPONENT( sTGC_RegSelCondAlg )
+
diff --git a/MuonSpectrometer/MuonDetDescr/MuonRegionSelector/src/sTGC_RegSelCondAlg.cxx b/MuonSpectrometer/MuonDetDescr/MuonRegionSelector/src/sTGC_RegSelCondAlg.cxx
new file mode 100644
index 0000000000000000000000000000000000000000..dcafed58827982d78e90ae0eca6ce9a60382ae5e
--- /dev/null
+++ b/MuonSpectrometer/MuonDetDescr/MuonRegionSelector/src/sTGC_RegSelCondAlg.cxx
@@ -0,0 +1,155 @@
+/**
+ ** @file sTGC_RegSelCondAlg.cxx
+ **
+ ** conditions algorithm to create the Si detector
+ ** lookup tables
+ **
+ ** @author sutt
+ ** @date Sun 22 Sep 2019 10:21:50 BST
+ **
+ **
+ ** Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
+ **/
+
+
+#include <iostream>
+#include <fstream>
+#include <string>
+
+#include "CLHEP/Units/SystemOfUnits.h"
+#include "Identifier/IdentifierHash.h"
+
+#include "RegSelLUT/RegSelModule.h"
+#include "RegSelLUT/RegSelSiLUT.h"
+
+#include "MuonReadoutGeometry/MuonDetectorManager.h"
+#include "MuonReadoutGeometry/MuonReadoutElement.h"
+
+/// sTGC naming convention headers
+#include "MuonReadoutGeometry/sTgcReadoutElement.h"
+#include "MuonAGDDDescription/sTGCDetectorHelper.h"
+#include "MuonAGDDDescription/sTGCDetectorDescription.h"
+
+#include "MuonReadoutGeometry/MuonStation.h"
+
+#include "RegSelLUT/RegSelSiLUT.h"
+
+
+/// not implemented yet
+/// #include "Muon_sTGC_Cabling/MuonMM_CablingSvc.h"
+
+#include "sTGC_RegSelCondAlg.h"
+
+
+sTGC_RegSelCondAlg::sTGC_RegSelCondAlg(const std::string& name, ISvcLocator* pSvcLocator):
+ MuonRegSelCondAlg( name, pSvcLocator )
+{
+ ATH_MSG_DEBUG( "sTGC_RegSelCondAlg::sTGC_RegSelCondAlg() " << name );
+}
+
+
+
+
+
+std::unique_ptr<RegSelSiLUT> sTGC_RegSelCondAlg::createTable( const MuonMDT_CablingMap* /* mdtCabling */ ) const {
+
+ /// no NSW cabling available at the moment ...
+
+ /// get the MM detector manager
+
+ const MuonGM::MuonDetectorManager* manager = nullptr;
+
+ if ( (detStore()->retrieve( manager ).isFailure() ) ) {
+ ATH_MSG_ERROR( "Could not retrieve Muon Manager for " << name() );
+ return std::unique_ptr<RegSelSiLUT>(nullptr);
+ }
+
+ const sTgcIdHelper* helper = manager->stgcIdHelper();
+
+ std::vector<Identifier>::const_iterator idfirst = helper->module_begin();
+ std::vector<Identifier>::const_iterator idlast = helper->module_end();
+
+ /// do we want the module context ...
+ /// const IdContext ModuleContext = helper->module_context();
+
+ /// or the detector element context ? Keep them both untill we are sure
+ const IdContext ModuleContext = helper->detectorElement_context();
+
+ ATH_MSG_DEBUG("createTable()");
+
+ std::unique_ptr<RegSelSiLUT> lut = std::make_unique<RegSelSiLUT>();
+
+
+ for ( std::vector<Identifier>::const_iterator i=idfirst ; i!=idlast ; i++ ) {
+
+ Identifier Id = *i;
+ IdentifierHash hashId;
+
+ helper->get_hash( Id, hashId, &ModuleContext );
+
+ const MuonGM::sTgcReadoutElement* mm = manager->getsTgcReadoutElement(Id);
+ if (!mm) continue;
+
+ // std::cout << "stgc station name: " << mm->getStationName() << "\teta: " << mm->getStationEta() << "\tphi: " << mm->getStationPhi() << std::endl;
+
+ int multilayer = helper->multilayer(Id);
+
+ char side = mm->getStationEta() < 0 ? 'C' : 'A';
+
+ char sector_l = mm->getStationName().substr(2,1)=="L" ? 'L' : 'S';
+
+ sTGCDetectorHelper aHelper;
+ sTGCDetectorDescription* md = aHelper.Get_sTGCDetector( sector_l, std::abs(mm->getStationEta()), mm->getStationPhi(), multilayer, side );
+
+ Amg::Vector3D mmPos = mm->center();
+
+ double swidth = md->sWidth();
+ double lwidth = md->lWidth();
+
+ double ycutout = md->yCutout();
+
+ double length = md->Length();
+ double depth = md->Tck();
+
+ double moduleR = std::sqrt( mmPos.mag()*mmPos.mag() - mmPos.z()*mmPos.z());
+
+ double zmin = mmPos.z()-0.5*depth;
+ double zmax = mmPos.z()+0.5*depth;
+
+ double rmin = moduleR-0.5*length;
+ double rmax = std::sqrt( (moduleR+0.5*length)*(moduleR+0.5*length) + lwidth*lwidth/4 );
+
+ double dphi1 = std::atan( (0.5*lwidth)/(moduleR+0.5*length) );
+ double dphi2 = std::atan( (0.5*swidth)/(moduleR-0.5*length) );
+
+ double dphi = ( dphi1 > dphi2 ? dphi1 : dphi2 );
+
+ if ( ycutout > 0 ) {
+ double rcutout = moduleR+0.5*length - ycutout;
+ double dphicutout = std::atan( (0.5*lwidth)/rcutout );
+ if ( dphi < dphicutout ) dphi = dphicutout;
+ }
+
+ double phimin = mmPos.phi()-dphi;
+ double phimax = mmPos.phi()+dphi;
+
+ if ( phimin > M_PI ) phimin -= 2*M_PI;
+ if ( phimin < -M_PI ) phimin += 2*M_PI;
+
+ int layerid = multilayer;
+ int detid = ( side == 'C' ? -1 : 1 );
+
+ int robId = 0;
+
+ // std::cout << "sTGC::module r: " << moduleR << "\tlength: " << length << "\tswidth: " << swidth << "\tlwidth: " << lwidth << "\tycut: " << ycutout << std::endl;
+
+ RegSelModule m( zmin, zmax, rmin, rmax, phimin, phimax, int(layerid), int(detid), uint32_t(robId), hashId );
+
+ lut->addModule( m );
+
+ }
+
+ lut->initialise();
+
+ return lut;
+}
diff --git a/MuonSpectrometer/MuonDetDescr/MuonRegionSelector/src/sTGC_RegSelCondAlg.h b/MuonSpectrometer/MuonDetDescr/MuonRegionSelector/src/sTGC_RegSelCondAlg.h
new file mode 100755
index 0000000000000000000000000000000000000000..ace1a281544f3884315ef0ed6c10c246ec199f04
--- /dev/null
+++ b/MuonSpectrometer/MuonDetDescr/MuonRegionSelector/src/sTGC_RegSelCondAlg.h
@@ -0,0 +1,32 @@
+/** emacs: this is -*- c++ -*- **/
+/**
+ ** @file sTGC_RegSelCondAlg.h
+ **
+ ** @author sutt
+ ** @date Tue 4 Feb 2020 15:25:00 CET
+ **
+ ** Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
+ **/
+
+#ifndef sTGC_RegSelCondAlg_h
+#define sTGC_RegSelCondAlg_h
+
+
+#include "MuonRegSelCondAlg.h"
+
+
+/// NB: this sTGC class follows the naming convention from the
+/// sTGC detector code base hence the non-standard naming
+/// convention sTGC rather than STGC etc
+
+class sTGC_RegSelCondAlg : public MuonRegSelCondAlg {
+
+public:
+
+ sTGC_RegSelCondAlg( const std::string& name, ISvcLocator* pSvcLocator );
+
+ std::unique_ptr<RegSelSiLUT> createTable( const MuonMDT_CablingMap* mdtCabling ) const;
+
+};
+
+#endif // sTGC_RegSelCondAlg_h
diff --git a/Trigger/TrigAlgorithms/TrigFastTrackFinder/python/TrigFastTrackFinder_Config.py b/Trigger/TrigAlgorithms/TrigFastTrackFinder/python/TrigFastTrackFinder_Config.py
index da837120375577a0223520f7d01a030f01f3b7d1..0a3dde84435a8648f571e76ddfeee35533d938c9 100755
--- a/Trigger/TrigAlgorithms/TrigFastTrackFinder/python/TrigFastTrackFinder_Config.py
+++ b/Trigger/TrigAlgorithms/TrigFastTrackFinder/python/TrigFastTrackFinder_Config.py
@@ -1,4 +1,4 @@
-# Copyright (C) 2002-2018 CERN for the benefit of the ATLAS collaboration
+# Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
from TrigFastTrackFinder.TrigFastTrackFinderConf import TrigFastTrackFinder