ATLAS Offline Software
Loading...
Searching...
No Matches
Public Types | Public Member Functions | Protected Types | Protected Member Functions | Static Protected Member Functions | Protected Attributes | List of all members
RegSelSiLUT Class Reference

#include <RegSelSiLUT.h>

Inheritance diagram for RegSelSiLUT:
Collaboration diagram for RegSelSiLUT:

Public Types

enum  DET {
  UNDEF , PIXEL , SCT , TRT ,
  FTK , MM , sTGC , RPC
}

Public Member Functions

 RegSelSiLUT ()
 RegSelSiLUT (DET id)
 RegSelSiLUT (const RegSelSiLUT &r)
 RegSelSiLUT (const std::string &s)
virtual ~RegSelSiLUT () override
virtual void HashIDList (const IRoiDescriptor &roi, std::vector< IdentifierHash > &idlist) const override
 implementation of the IRegSelUT interface
hash id methods
virtual void HashIDList (long layer, const IRoiDescriptor &roi, std::vector< IdentifierHash > &idlist) const override
 HashIDList interface declaration. return list of non-repeated IdentifierHash.
virtual void ROBIDList (const IRoiDescriptor &roi, std::vector< uint32_t > &roblist) const override
 rob methods
virtual void ROBIDList (long layer, const IRoiDescriptor &roi, std::vector< uint32_t > &roblist) const override
 ROBIDList interface declaration. This interface can be used by the ID subdetectors. A list of non-repeated ROBIDs (uint_32_t) is returned by a reference.
void addModule (RegSelModule &module)
void addModules (const std::vector< RegSelModule > &m)
const std::vector< RegSelModule > & getModules () const
bool getRoIData (const RegSelRoI &r, std::vector< const RegSelModule * > &modules) const
bool getRoIData (const RegSelRoI &r, unsigned layer, std::vector< const RegSelModule * > &modules) const
 here if layer is of the format 1XYY where X=0 (barrel), X=2 (endcap) and YY is the layer within the sub-system then the specific layer in the sub-system is used.
bool getRoIData (const RegSelRoI &r, unsigned subdetector, unsigned layer, std::vector< const RegSelModule * > &modules) const
bool getRoIData (const RegSelRoI &r, std::vector< const RegSelModule * > &modules, double x, double y) const
bool getRoIData (const RegSelRoI &r, unsigned subdetector, unsigned layer, std::vector< const RegSelModule * > &modules, double x, double y) const
DET ID () const
void reset ()
void initialise ()
void initialiseDisabledModules ()
void initialiseFullScan ()
void write (std::ostream &s=std::cout) const
void write (const std::string &filename) const
bool read (std::istream &s)
bool read (const std::string &s)
const std::vector< RegSelSubDetector > & getSubDet () const
const RegSelModule * Module (const IdentifierHash &h) const
void getModules (unsigned layer, std::vector< const RegSelModule * > &modules) const
 here if layer is of the format 1XYY where X=0 (barrel), X=2 (endcap) and YY is the layer within the sub-system then the specific layer in the sub-system is used.
virtual void getHashList (const RegSelRoI &roi, std::vector< IdentifierHash > &hashlist) const
virtual void getHashList (const RegSelRoI &roi, std::vector< IdentifierHash > &hashlist, double x, double y) const
virtual void getHashList (const RegSelRoI &roi, unsigned layer, std::vector< IdentifierHash > &hashlist) const
virtual void getHashList (std::vector< IdentifierHash > &hashlist) const
virtual void getHashList (unsigned layer, std::vector< IdentifierHash > &hashlist) const
virtual void getRobList (const RegSelRoI &roi, unsigned layer, std::vector< uint32_t > &roblist, bool removeduplicates=true) const
virtual void getRobList (const RegSelRoI &roi, std::vector< uint32_t > &roblist, bool removeduplicates=true) const
virtual void getRobList (const RegSelRoI &roi, std::vector< uint32_t > &roblist, double x, double y) const
virtual void getRobList (std::vector< uint32_t > &roblist) const
virtual void getRobList (unsigned layer, std::vector< uint32_t > &roblist) const
virtual void getRobHashList (std::vector< uint32_t > &roblist, std::vector< IdentifierHash > &hashlist) const
virtual void getRobHashList (const RegSelRoI &roi, std::vector< uint32_t > &roblist, std::vector< IdentifierHash > &hashlist) const
virtual void getRobHashList (const RegSelRoI &roi, unsigned layer, std::vector< uint32_t > &roblist, std::vector< IdentifierHash > &hashlist) const
void getDisabledHashList (const RegSelRoI &roi, unsigned layer, std::vector< IdentifierHash > &hashlist) const
void getDisabledLayers (const RegSelRoI &roi, int subdetector, std::vector< int > &layers) const
void enableRobs ()
void disableRobs ()
void enableModules ()
void disableModules ()
void enableRobList (const std::vector< uint32_t > &roblist)
void disableRobList (const std::vector< uint32_t > &roblist)
void enableModuleList (const std::vector< IdentifierHash > &hashlist)
void disableModuleList (const std::vector< IdentifierHash > &hashlist)
void disableSubDetector (int id)
void enableSubDetector (int id)
void disableLayer (int id, unsigned layer)
void enableLayer (int id, unsigned layer)
void drawlayers (std::vector< const ZRObject * > &c) const
const std::string & getName () const

Protected Types

template<typename C, typename T>
using handler = void (C::*)(const IRoiDescriptor& , std::vector<T>& ) const
template<typename C, typename T>
using handler_layer = void (C::*)(long layer, const IRoiDescriptor& , std::vector<T>& ) const

Protected Member Functions

virtual void construct ()
virtual void HashIDList_internal (const IRoiDescriptor &roi, std::vector< IdentifierHash > &idlist) const
 horrible internal interface methods
virtual void HashIDList_internal (long layer, const IRoiDescriptor &roi, std::vector< IdentifierHash > &idlist) const
virtual void ROBIDList_internal (const IRoiDescriptor &roi, std::vector< uint32_t > &roblist) const
 rob methods
virtual void ROBIDList_internal (long layer, const IRoiDescriptor &roi, std::vector< uint32_t > &roblist) const
template<typename C, typename T>
void IDList (const IRoiDescriptor &roi, std::vector< T > &idlist, handler< C, T > lister) const
template<typename C, typename T>
void IDList_layer (long layer, const IRoiDescriptor &roi, std::vector< T > &idlist, handler_layer< C, T > lister) const

Static Protected Member Functions

static void cleanup (std::vector< IdentifierHash > &idvec)
 annoying cleanup function specifically for the RPC, but we have to add it here since we have abstracted everything to use identical code - perhaps consider creating the RPC instance as a derived class ?
template<typename T>
static void removeDuplicates (std::vector< T > &vec)
 useful for removing duplicates if required ...

Protected Attributes

DET m_ID
std::vector< RegSelSubDetector > m_SubDet
std::vector< RegSelModule > m_modules
std::vector< RegSelModule * > m_disabled
std::map< const IdentifierHash, const RegSelModule * > m_map
std::vector< IdentifierHash > m_allHashes
std::vector< uint32_t > m_allROBids
std::map< int, int > m_idmap
std::string m_name

Detailed Description

Definition at line 41 of file RegSelSiLUT.h.

Member Typedef Documentation

◆ handler

template<typename C, typename T>
using IRegSelLUT::handler = void (C::*)(const IRoiDescriptor& , std::vector<T>& ) const
protectedinherited

Definition at line 85 of file IRegSelLUT.h.

◆ handler_layer

template<typename C, typename T>
using IRegSelLUT::handler_layer = void (C::*)(long layer, const IRoiDescriptor& , std::vector<T>& ) const
protectedinherited

Definition at line 103 of file IRegSelLUT.h.

Member Enumeration Documentation

◆ DET

enum RegSelSiLUT::DET
Enumerator
UNDEF 
PIXEL 
SCT 
TRT 
FTK 
MM 
sTGC 
RPC 

Definition at line 45 of file RegSelSiLUT.h.

45{ UNDEF, PIXEL, SCT, TRT, FTK, MM, sTGC, RPC } DET;

Constructor & Destructor Documentation

◆ RegSelSiLUT() [1/4]

RegSelSiLUT::RegSelSiLUT ( )
inline

Definition at line 49 of file RegSelSiLUT.h.

49: m_ID(UNDEF) { }

◆ RegSelSiLUT() [2/4]

RegSelSiLUT::RegSelSiLUT ( DET id)

Definition at line 100 of file RegSelSiLUT.cxx.

100: m_ID(id) { construct(); }
RegSelSiLUT::construct
virtual void construct()
Definition RegSelSiLUT.cxx:119

◆ RegSelSiLUT() [3/4]

RegSelSiLUT::RegSelSiLUT ( const RegSelSiLUT & r)

Definition at line 102 of file RegSelSiLUT.cxx.

102 :
103 RegSelName(r.getName()), m_ID(r.ID()) {
104 construct();
105 addModules(r.getModules());
106 initialise();
107}
RegSelName::RegSelName
RegSelName(const std::string &s="")
Definition RegSelName.h:37
RegSelSiLUT::addModules
void addModules(const std::vector< RegSelModule > &m)
Definition RegSelSiLUT.h:72
RegSelSiLUT::initialise
void initialise()
Definition RegSelSiLUT.cxx:139
r
int r
Definition globals.cxx:22

◆ RegSelSiLUT() [4/4]

RegSelSiLUT::RegSelSiLUT ( const std::string & s)

Definition at line 109 of file RegSelSiLUT.cxx.

109 :
110 m_ID(UNDEF) {
111 read(s);
112}
RegSelSiLUT::read
bool read(std::istream &s)
Definition RegSelSiLUT.cxx:1204

◆ ~RegSelSiLUT()

virtual RegSelSiLUT::~RegSelSiLUT ( )
inlineoverridevirtual

Definition at line 54 of file RegSelSiLUT.h.

54{ }

Member Function Documentation

◆ addModule()

void RegSelSiLUT::addModule ( RegSelModule & module)
inline

Definition at line 71 of file RegSelSiLUT.h.

71{ m_modules.push_back(module); }
RegSelSiLUT::m_modules
std::vector< RegSelModule > m_modules
Definition RegSelSiLUT.h:227

◆ addModules()

void RegSelSiLUT::addModules ( const std::vector< RegSelModule > & m)
inline

Definition at line 72 of file RegSelSiLUT.h.

72{ m_modules = m; }

◆ cleanup()

void RegSelSiLUT::cleanup ( std::vector< IdentifierHash > & idvec)
inlinestaticprotected

annoying cleanup function specifically for the RPC, but we have to add it here since we have abstracted everything to use identical code - perhaps consider creating the RPC instance as a derived class ?

Definition at line 246 of file RegSelSiLUT.h.

246 {
247 for ( size_t i=idvec.size() ; i-- ; ) idvec[i] = IdentifierHash( ((unsigned)idvec[i]) & 0xfff );
248 RegSelSiLUT::removeDuplicates( idvec );
249 }
IRegSelLUT::removeDuplicates
static void removeDuplicates(std::vector< T > &vec)
useful for removing duplicates if required ...
Definition IRegSelLUT.h:78

◆ construct()

void RegSelSiLUT::construct ( )
protectedvirtual

Definition at line 119 of file RegSelSiLUT.cxx.

120{
121 const std::string s[8] = { "", "pixel", "sct", "trt", "ftk", "mm", "stgc", "rpc" };
122 m_name = s[m_ID];
123}
RegSelName::m_name
std::string m_name
Definition RegSelName.h:45

◆ disableLayer()

void RegSelSiLUT::disableLayer ( int id,
unsigned layer )

Definition at line 261 of file RegSelSiLUT.cxx.

261 {
262 std::map<int,int>::iterator sitr = m_idmap.find(id);
263 if ( sitr!=m_idmap.end() ) m_SubDet[sitr->second].disableLayer(layer);
264}
RegSelSiLUT::m_SubDet
std::vector< RegSelSubDetector > m_SubDet
Definition RegSelSiLUT.h:226
RegSelSiLUT::m_idmap
std::map< int, int > m_idmap
Definition RegSelSiLUT.h:237

◆ disableModuleList()

void RegSelSiLUT::disableModuleList ( const std::vector< IdentifierHash > & hashlist)

Definition at line 799 of file RegSelSiLUT.cxx.

799 {
800
801 std::set<IdentifierHash> hashset;
802 for ( unsigned i=0 ; i<hashlist.size() ; i++ ) hashset.insert(hashlist[i]);
803
804 std::vector<RegSelModule>::iterator itr(m_modules.begin());
805 for ( ; itr!=m_modules.end() ; ++itr ) {
806 // this module is on the list, so disable it
807 if ( hashset.find((*itr).hashID())!=hashset.end() ) (*itr).disable();
808 }
809 initialiseDisabledModules();
810 initialiseFullScan();
811}
RegSelSiLUT::initialiseDisabledModules
void initialiseDisabledModules()
Definition RegSelSiLUT.cxx:232
RegSelSiLUT::initialiseFullScan
void initialiseFullScan()
Definition RegSelSiLUT.cxx:204

◆ disableModules()

void RegSelSiLUT::disableModules ( )
inline

Definition at line 195 of file RegSelSiLUT.h.

195{ disableRobs(); }
RegSelSiLUT::disableRobs
void disableRobs()
Definition RegSelSiLUT.cxx:751

◆ disableRobList()

void RegSelSiLUT::disableRobList ( const std::vector< uint32_t > & roblist)

Definition at line 762 of file RegSelSiLUT.cxx.

762 {
763
764 std::set<uint32_t> robset;
765 for ( unsigned i=0 ; i<roblist.size() ; i++ ) robset.insert(roblist[i]);
766
767 std::vector<RegSelModule>::iterator itr(m_modules.begin());
768 for ( ; itr!=m_modules.end() ; ++itr ) {
769 // this module's rob is on the list, so disable it
770 if ( robset.find((*itr).robID())!=robset.end() ) (*itr).disable();
771 }
772 initialiseDisabledModules();
773 initialiseFullScan();
774}

◆ disableRobs()

void RegSelSiLUT::disableRobs ( )

Definition at line 751 of file RegSelSiLUT.cxx.

751 {
752 std::vector<RegSelModule>::iterator itr(m_modules.begin());
753 while ( itr!=m_modules.end() ) (*itr++).disable();
754 initialiseDisabledModules();
755 initialiseFullScan();
756}

◆ disableSubDetector()

void RegSelSiLUT::disableSubDetector ( int id)

Definition at line 251 of file RegSelSiLUT.cxx.

251 {
252 std::map<int,int>::iterator sitr = m_idmap.find(id);
253 if ( sitr!=m_idmap.end() ) m_SubDet[sitr->second].disable();
254}

◆ drawlayers()

void RegSelSiLUT::drawlayers ( std::vector< const ZRObject * > & c) const
inline

Definition at line 214 of file RegSelSiLUT.h.

214 {
215 for ( unsigned i=0 ; i<m_SubDet.size() ; i++ ) m_SubDet[i].drawlayers(c);
216 }
RegSelSiLUT::drawlayers
void drawlayers(std::vector< const ZRObject * > &c) const
Definition RegSelSiLUT.h:214

◆ enableLayer()

void RegSelSiLUT::enableLayer ( int id,
unsigned layer )

Definition at line 266 of file RegSelSiLUT.cxx.

266 {
267 std::map<int,int>::iterator sitr = m_idmap.find(id);
268 if ( sitr!=m_idmap.end() ) m_SubDet[sitr->second].enableLayer(layer);
269}

◆ enableModuleList()

void RegSelSiLUT::enableModuleList ( const std::vector< IdentifierHash > & hashlist)

Definition at line 816 of file RegSelSiLUT.cxx.

816 {
817
818 std::set<IdentifierHash> hashset;
819 for ( unsigned i=0 ; i<hashlist.size() ; i++ ) hashset.insert(hashlist[i]);
820
821 std::vector<RegSelModule>::iterator itr(m_modules.begin());
822 for ( ; itr!=m_modules.end() ; ++itr ) {
823 // this module is on the list, so enable it
824 if ( hashset.find((*itr).hashID())!=hashset.end() ) (*itr).enable();
825 }
826 initialiseDisabledModules();
827 initialiseFullScan();
828}

◆ enableModules()

void RegSelSiLUT::enableModules ( )
inline

Definition at line 194 of file RegSelSiLUT.h.

194{ enableRobs(); }
RegSelSiLUT::enableRobs
void enableRobs()
Definition RegSelSiLUT.cxx:741

◆ enableRobList()

void RegSelSiLUT::enableRobList ( const std::vector< uint32_t > & roblist)

Definition at line 779 of file RegSelSiLUT.cxx.

779 {
780
781 std::set<uint32_t> robset;
782 for ( unsigned i=0 ; i<roblist.size() ; i++ ) robset.insert(roblist[i]);
783
784 std::vector<RegSelModule>::iterator itr(m_modules.begin());
785 for ( ; itr!=m_modules.end() ; ++itr ) {
786 // this module's rob is on the list, so enable it
787 if ( robset.find((*itr).robID())!=robset.end() ) (*itr).enable();
788 }
789 initialiseDisabledModules();
790 initialiseFullScan();
791}

◆ enableRobs()

void RegSelSiLUT::enableRobs ( )

Definition at line 741 of file RegSelSiLUT.cxx.

741 {
742 std::vector<RegSelModule>::iterator itr(m_modules.begin());
743 while ( itr!=m_modules.end() ) (*itr++).enable();
744 initialiseDisabledModules();
745 initialiseFullScan();
746}

◆ enableSubDetector()

void RegSelSiLUT::enableSubDetector ( int id)

Definition at line 256 of file RegSelSiLUT.cxx.

256 {
257 std::map<int,int>::iterator sitr = m_idmap.find(id);
258 if ( sitr!=m_idmap.end() ) m_SubDet[sitr->second].enable();
259}

◆ getDisabledHashList()

void RegSelSiLUT::getDisabledHashList ( const RegSelRoI & roi,
unsigned layer,
std::vector< IdentifierHash > & hashlist ) const

Definition at line 1115 of file RegSelSiLUT.cxx.

1115 {
1116
1117 std::vector<const RegSelModule*> modules;
1118 if ( modules.size()<256 ) modules.reserve(256);
1119
1120 // for ( std::vector<RegSelSubDetector>::const_iterator sptr(getSubDet().begin()) ;
1121 for ( std::vector<RegSelSubDetector>::const_iterator sptr(m_SubDet.begin()) ;
1122 sptr!=m_SubDet.end() ; ++sptr ) {
1123
1124 if ( (*sptr).inRoI(roi) ) {
1125
1126 const std::vector<RegSelLayer>& lyrs = (*sptr).getLayers();
1127
1128 if ( layer<lyrs.size() ) {
1129 // const RegSelLayer& lyr = lyrs.at(layer);
1130 const RegSelLayer& lyr = lyrs[layer];
1131
1132 if ( lyr.inRoI(roi) ) lyr.getDisabledModules(roi,modules);
1133 }
1134 }
1135 }
1136
1137 hashlist.reserve(m_modules.size());
1138 std::vector<const RegSelModule*>::iterator mptr(modules.begin());
1139 while ( mptr!=modules.end() ) {
1140 hashlist.push_back((*mptr++)->hashID());
1141 }
1142}
RegSelLayer::getDisabledModules
void getDisabledModules(const RegSelRoI &roi, std::vector< const RegSelModule * > &modules) const
Definition RegSelLayer.cxx:314
ZRObject::inRoI
virtual bool inRoI(const RegSelRoI &roi) const
Definition ZRObject.h:71
TRT::Hit::layer
@ layer
Definition HitInfo.h:79

◆ getDisabledLayers()

void RegSelSiLUT::getDisabledLayers ( const RegSelRoI & roi,
int subdetector,
std::vector< int > & layers ) const

Definition at line 1146 of file RegSelSiLUT.cxx.

1146 {
1147
1148 // layers.clear();
1149
1150 std::set<int> disabled_layers;
1151
1152 for ( std::vector<RegSelSubDetector>::const_iterator sptr(m_SubDet.begin()) ;
1153 sptr!=m_SubDet.end() ; ++sptr ) {
1154
1155 // std::cout << "subdet id = " << sptr->ID() << std::endl;
1156
1157 if ( subdetector!=sptr->ID() ) continue;
1158
1159 if ( (*sptr).inRoI(roi) ) {
1160
1161 const std::vector<RegSelLayer>& lyrs = (*sptr).getLayers();
1162
1163 for ( int layer=lyrs.size() ; layer-- ; ) {
1164
1165 std::vector<const RegSelModule*> modules;
1166 if ( modules.size()<256 ) modules.reserve(256);
1167
1168 // const RegSelLayer& lyr = lyrs.at(layer);
1169 const RegSelLayer& lyr = lyrs[layer];
1170
1171 if ( lyr.inRoI(roi) ) {
1172 lyr.getDisabledModules(roi,modules);
1173 // if ( modules.size() ) disabled_layers.insert(layer);
1174 if ( modules.size() ) layers.push_back(layer);
1175 }
1176 }
1177 }
1178 }
1179
1180#if 0
1181 // copy to output
1182 std::set<int>::iterator bitr(disabled_layers.begin());
1183 std::set<int>::iterator eitr(disabled_layers.end());
1184 while ( bitr!=eitr ) { layers.push_back(*bitr++); }
1185#endif
1186
1187}
CaloSwCorrections.layers
layers(flags, cells_name, *args, **kw)
Here we define wrapper functions to set up all of the standard corrections.
Definition CaloSwCorrections.py:176

◆ getHashList() [1/5]

void RegSelSiLUT::getHashList ( const RegSelRoI & roi,
std::vector< IdentifierHash > & hashlist ) const
virtual

Definition at line 838 of file RegSelSiLUT.cxx.

838 {
839
840 // bool hashempty = hashlist.empty();
841
842 std::vector<const RegSelModule*> modules;
843 if ( modules.size()<256 ) modules.reserve(256);
844
845 // struct timeval datatimer = gtttimer_start();
846 getRoIData(roi,modules);
847 // double datatime = gtttimer_stop(datatimer);
848
849 std::vector<const RegSelModule*>::iterator mptr(modules.begin());
850
851 hashlist.reserve(modules.size());
852 for ( ; mptr!=modules.end() ; ++mptr ) {
853 hashlist.push_back((*mptr)->hashID());
854 }
855
856 // if ( !hashempty ) removeDuplicates( hashlist );
857
858 // double vectortime = gtttimer_stop(datatimer);
859
860 // std::cout << "RegSelSiLUT::getHashList() datatime=" << datatime << "\tvectortime=" << vectortime << "\tf="
861 // << 100*(vectortime-datatime)/vectortime << std::endl;
862
863}
RegSelSiLUT::getRoIData
bool getRoIData(const RegSelRoI &r, std::vector< const RegSelModule * > &modules) const
Definition RegSelSiLUT.cxx:273

◆ getHashList() [2/5]

void RegSelSiLUT::getHashList ( const RegSelRoI & roi,
std::vector< IdentifierHash > & hashlist,
double x,
double y ) const
virtual

Definition at line 868 of file RegSelSiLUT.cxx.

868 {
869
870 std::vector<const RegSelModule*> modules;
871 if ( modules.size()<256 ) modules.reserve(256);
872
873 // struct timeval datatimer = gtttimer_start();
874 getRoIData( roi, modules, x, y );
875 // double datatime = gtttimer_stop(datatimer);
876
877 // bool hashempty = hashlist.empty();
878
879 std::vector<const RegSelModule*>::iterator mptr(modules.begin());
880
881 hashlist.reserve(modules.size());
882 for ( ; mptr!=modules.end() ; ++mptr ) {
883 hashlist.push_back((*mptr)->hashID());
884 }
885
886 // if ( !hashempty ) removeDuplicates( hashlist );
887
888}
y
#define y
x
#define x

◆ getHashList() [3/5]

void RegSelSiLUT::getHashList ( const RegSelRoI & roi,
unsigned layer,
std::vector< IdentifierHash > & hashlist ) const
virtual

Definition at line 998 of file RegSelSiLUT.cxx.

998 {
999
1000 // bool hashempty = hashlist.empty();
1001
1002 std::vector<const RegSelModule*> modules;
1003 if ( modules.size()<256 ) modules.reserve(256);
1004
1005
1006 getRoIData( roi, layer, modules);
1007
1008 // struct timeval datatimer = gtttimer_start();
1009
1010 // double datatime = gtttimer_stop(datatimer);
1011
1012 hashlist.reserve(modules.size());
1013 std::vector<const RegSelModule*>::iterator mptr(modules.begin());
1014 while ( mptr!=modules.end() ) {
1015 hashlist.push_back((*mptr++)->hashID());
1016 }
1017
1018 // if ( !hashempty ) removeDuplicates( hashlist );
1019
1020 // double vectortime = gtttimer_stop(datatimer);
1021
1022 // std::cout << "RegSelSiLUT::getHashList() datatime=" << datatime << "\tvectortime=" << vectortime << "\tf="
1023 // << 100*(vectortime-datatime)/vectortime << std::endl;
1024
1025}

◆ getHashList() [4/5]

void RegSelSiLUT::getHashList ( std::vector< IdentifierHash > & hashlist) const
virtual

Definition at line 895 of file RegSelSiLUT.cxx.

895 {
896
897#ifndef OLDFULLSCAN
898 hashlist.reserve(m_allHashes.size());
899 hashlist = m_allHashes;
900 return;
901#else
902
903 hashlist.clear();
904 hashlist.reserve(m_modules.size());
905
906 std::vector<RegSelModule>::const_iterator mptr(m_modules.begin());
907 std::vector<RegSelModule>::const_iterator eptr(m_modules.end());
908 for ( ; mptr!=eptr ; ++mptr ) {
909 if ( (*mptr).enabled() ) hashlist.push_back((*mptr).hashID());
910 }
911#endif
912}
RegSelSiLUT::m_allHashes
std::vector< IdentifierHash > m_allHashes
Definition RegSelSiLUT.h:234

◆ getHashList() [5/5]

void RegSelSiLUT::getHashList ( unsigned layer,
std::vector< IdentifierHash > & hashlist ) const
virtual

Definition at line 919 of file RegSelSiLUT.cxx.

919 {
920
921 std::vector<const RegSelModule*> modules;
922
923 // bool hashempty = hashlist.empty();
924
925 getModules( layer, modules );
926
927 hashlist.reserve(modules.size());
928 std::vector<const RegSelModule*>::iterator mptr(modules.begin());
929 while ( mptr!=modules.end() ) {
930 hashlist.push_back((*mptr++)->hashID());
931 }
932
933 // if ( !hashempty ) removeDuplicates( hashlist );
934
935}
RegSelSiLUT::getModules
const std::vector< RegSelModule > & getModules() const
Definition RegSelSiLUT.h:75

◆ getModules() [1/2]

const std::vector< RegSelModule > & RegSelSiLUT::getModules ( ) const
inline

Definition at line 75 of file RegSelSiLUT.h.

75{ return m_modules; }

◆ getModules() [2/2]

void RegSelSiLUT::getModules ( unsigned layer,
std::vector< const RegSelModule * > & modules ) const

here if layer is of the format 1XYY where X=0 (barrel), X=2 (endcap) and YY is the layer within the sub-system then the specific layer in the sub-system is used.

If it is of the form YY, then simple layer number is used NB: ALL the layer IdentifierHash and uint32_t retreival methods use this format

determine whether an layer in a specific subdetector is requested

Definition at line 295 of file RegSelSiLUT.cxx.

295 {
296 modules.reserve(256);
297
299 bool subdetflag = layer/1000;
300 int subdet = 0;
301 int ilayer = layer%100;
302 if ( subdetflag ) subdet = (layer%1000)/100;
303
304 for ( unsigned i=0 ; i<m_SubDet.size() ; i++ ) {
305 if ( !subdetflag || ( subdetflag && subdet==std::fabs(m_SubDet[i].ID()) ) ) m_SubDet[i].getModules( ilayer, modules);
306 }
307 }
RegSelSiLUT::ID
DET ID() const
Definition RegSelSiLUT.h:84

◆ getName()

const std::string & RegSelName::getName ( ) const
inlineinherited

Definition at line 39 of file RegSelName.h.

39{ return m_name; }

◆ getRobHashList() [1/3]

void RegSelSiLUT::getRobHashList ( const RegSelRoI & roi,
std::vector< uint32_t > & roblist,
std::vector< IdentifierHash > & hashlist ) const
virtual

Definition at line 588 of file RegSelSiLUT.cxx.

589{
590 std::vector<const RegSelModule*> modules;
591 if ( modules.size()<256 ) modules.reserve(256);
592
593 // get the modules
594 getRoIData(roi,modules);
595
596 // fill the rob and hashid lists
597
598 std::set<uint32_t> uroblist;
599
600 hashlist.reserve(modules.size());
601 roblist.reserve(modules.size());
602 std::vector<const RegSelModule*>::iterator mptr(modules.begin());
603 while ( mptr!=modules.end() ) {
604 hashlist.push_back((*mptr)->hashID());
605 roblist.push_back((*mptr++)->robID());
606 }
607 // removeDuplicates( hashlist );
608 removeDuplicates( roblist );
609
610 // roblist.reserve(uroblist.size());
611 // std::set<uint32_t>::iterator plist(uroblist.begin());
612 // while ( plist!=uroblist.end() ) {
613 // roblist.push_back(*plist++);
614 // }
615
616}

◆ getRobHashList() [2/3]

void RegSelSiLUT::getRobHashList ( const RegSelRoI & roi,
unsigned layer,
std::vector< uint32_t > & roblist,
std::vector< IdentifierHash > & hashlist ) const
virtual

Definition at line 621 of file RegSelSiLUT.cxx.

622{
623 std::vector<const RegSelModule*> modules;
624 if ( modules.size()<256 ) modules.reserve(256);
625
626 // get the modules
627 getRoIData(roi, layer, modules);
628
629 // fill the rob and hashid lists
630
631 std::set<uint32_t> uroblist;
632
633 hashlist.reserve(modules.size());
634 roblist.reserve(modules.size());
635 std::vector<const RegSelModule*>::iterator mptr(modules.begin());
636 while ( mptr!=modules.end() ) {
637 hashlist.push_back((*mptr)->hashID());
638 roblist.push_back((*mptr++)->robID());
639 }
640 // removeDuplicates( hashlist );
641 removeDuplicates( roblist );
642
643 // roblist.reserve(uroblist.size());
644 // std::set<uint32_t>::iterator plist(uroblist.begin());
645 // while ( plist!=uroblist.end() ) {
646 // roblist.push_back(*plist++);
647 // }
648
649}

◆ getRobHashList() [3/3]

void RegSelSiLUT::getRobHashList ( std::vector< uint32_t > & roblist,
std::vector< IdentifierHash > & hashlist ) const
virtual

Definition at line 967 of file RegSelSiLUT.cxx.

967 {
968
969#ifndef OLDFULLSCAN
970 hashlist.reserve(m_allHashes.size());
971 roblist.reserve(m_allROBids.size());
972 roblist = m_allROBids;
973 hashlist = m_allHashes;
974 return;
975#else
976 roblist.reserve(256);
977 hashlist.reserve(m_modules.size());
978
979 std::set<uint32_t> uroblist;
980 std::vector<RegSelModule>::const_iterator mptr(m_modules.begin());
981 for ( ; mptr!=m_modules.end() ; ++mptr ) {
982 if ( (*mptr).enabled() ) {
983 uroblist.insert((*mptr).robID());
984 hashlist.push_back((*mptr).hashID());
985 }
986 }
987
988 std::set<uint32_t>::iterator rlist(uroblist.begin());
989 while ( rlist!=uroblist.end() ) {
990 roblist.push_back(*rlist++);
991 }
992#endif
993}
RegSelSiLUT::m_allROBids
std::vector< uint32_t > m_allROBids
Definition RegSelSiLUT.h:235

◆ getRobList() [1/5]

void RegSelSiLUT::getRobList ( const RegSelRoI & roi,
std::vector< uint32_t > & roblist,
bool removeduplicates = true ) const
virtual

NB: using a vector and removing duplicates is faster than using a set

Definition at line 652 of file RegSelSiLUT.cxx.

652 {
653
654 std::vector<const RegSelModule*> modules;
655 if ( modules.size()<256 ) modules.reserve(256);
656
657 // struct timeval datatimer = gtttimer_start();
658 getRoIData(roi,modules);
659 // double datatime = gtttimer_stop(datatimer);
660
661#if 0
662 // get the list of unique rob identifiers
663 // FIXME: this uses a set, sould be *much* faster
664 // with a seperate list of robids with their modules'
665 // corresponding extents in r, phi and z etc
666 std::set<uint32_t> uroblist;
667
668 std::vector<const RegSelModule*>::iterator mptr(modules.begin());
669 while ( mptr!=modules.end() ) {
670 uroblist.insert((*mptr++)->robID());
671 }
672
673 roblist.reserve(uroblist.size());
674 std::set<uint32_t>::iterator plist(uroblist.begin());
675 while ( plist!=uroblist.end() ) {
676 roblist.push_back(*plist++);
677 }
678
679#endif
680
683 std::vector<const RegSelModule*>::iterator mptr(modules.begin());
684
685 roblist.reserve(modules.size());
686 while ( mptr!=modules.end() ) roblist.push_back((*mptr++)->robID());
687 if ( removeduplicates || roblist.size()>2000 ) removeDuplicates( roblist );
688
689 // double vectortime = gtttimer_stop(datatimer);
690
691 // std::cout << "RegSelSiLUT::getRobList() datatime=" << datatime
692 // << "\tvectortime=" << vectortime << "\tf="
693 // << 100*(vectortime-datatime)/vectortime << std::endl;
694
695}

◆ getRobList() [2/5]

void RegSelSiLUT::getRobList ( const RegSelRoI & roi,
std::vector< uint32_t > & roblist,
double x,
double y ) const
virtual

Definition at line 703 of file RegSelSiLUT.cxx.

703 {
704
705 std::vector<const RegSelModule*> modules;
706 if ( modules.size()<256 ) modules.reserve(256);
707
708 // struct timeval datatimer = gtttimer_start();
709 getRoIData( roi, modules, x, y );
710 // double datatime = gtttimer_stop(datatimer);
711
712#if 0
713 std::set<uint32_t> uroblist;
714
715 std::vector<const RegSelModule*>::iterator mptr(modules.begin());
716 while ( mptr!=modules.end() ) {
717 uroblist.insert((*mptr++)->robID());
718 }
719
720 roblist.reserve(uroblist.size());
721 std::set<uint32_t>::iterator plist(uroblist.begin());
722 while ( plist!=uroblist.end() ) {
723 roblist.push_back(*plist++);
724 }
725
726#endif
727
728 roblist.reserve(modules.size());
729 std::vector<const RegSelModule*>::iterator mptr(modules.begin());
730 while ( mptr!=modules.end() ) roblist.push_back((*mptr++)->robID());
731 removeDuplicates( roblist );
732
733}

◆ getRobList() [3/5]

void RegSelSiLUT::getRobList ( const RegSelRoI & roi,
unsigned layer,
std::vector< uint32_t > & roblist,
bool removeduplicates = true ) const
virtual

Definition at line 1032 of file RegSelSiLUT.cxx.

1032 {
1033
1034 std::vector<const RegSelModule*> modules;
1035 if ( modules.size()<256 ) modules.reserve(256);
1036
1037
1038 getRoIData( roi, layer, modules);
1039
1040#if 0
1041 for ( std::vector<RegSelSubDetector>::const_iterator sptr(m_SubDet.begin()) ;
1042 sptr!=m_SubDet.end() ; sptr++ ) {
1043
1044 if ( (*sptr).inRoI(roi) ) {
1045
1046 const std::vector<RegSelLayer>& lyrs = (*sptr).getLayers();
1047
1048 if ( layer<lyrs.size() ) {
1049 const RegSelLayer& lyr = lyrs[layer];
1050 if ( lyr.inRoI(roi) ) lyr.getModules(roi,modules);
1051 }
1052 }
1053 }
1054#endif
1055
1056 // struct timeval datatimer = gtttimer_start();
1057
1058 // double datatime = gtttimer_stop(datatimer);
1059
1060 // std::vector<uint32_t> uroblist;
1061 std::vector<const RegSelModule*>::iterator mptr(modules.begin());
1062 while ( mptr!=modules.end() ) {
1063 roblist.push_back((*mptr++)->robID());
1064 }
1065
1066 // std::set<uint32_t>::iterator rlist(uroblist.begin());
1067 // while ( rlist!=uroblist.end() ) {
1068 // roblist.push_back(*rlist++);
1069 // }
1070
1071 if ( removeduplicates || roblist.size()>4000 ) removeDuplicates( roblist );
1072
1073}
RegSelLayer::getModules
void getModules(const RegSelRoI &roi, std::vector< const RegSelModule * > &modules) const
Fixme: This is the completely correct solution, where each module is allowed to be at a completely di...
Definition RegSelLayer.cxx:197

◆ getRobList() [4/5]

void RegSelSiLUT::getRobList ( std::vector< uint32_t > & roblist) const
virtual

Definition at line 943 of file RegSelSiLUT.cxx.

943 {
944
945#ifndef OLDFULLSCAN
946 roblist.reserve(m_allROBids.size());
947 roblist = m_allROBids;
948 return;
949#else
950 roblist.reserve(256);
951
952 std::set<uint32_t> uroblist;
953 std::vector<RegSelModule>::const_iterator mptr(m_modules.begin());
954 for ( ; mptr!=m_modules.end() ; ++mptr ) {
955 if ( (*mptr).enabled() ) uroblist.insert((*mptr).robID());
956 }
957
958 std::set<uint32_t>::iterator rlist(uroblist.begin());
959 while ( rlist!=uroblist.end() ) {
960 roblist.push_back(*rlist++);
961 }
962#endif
963}

◆ getRobList() [5/5]

void RegSelSiLUT::getRobList ( unsigned layer,
std::vector< uint32_t > & roblist ) const
virtual

Definition at line 1085 of file RegSelSiLUT.cxx.

1085 {
1086
1087 std::vector<const RegSelModule*> modules;
1088
1089 getModules( layer, modules );
1090
1091 roblist.reserve(256);
1092
1093 std::set<uint32_t> uroblist;
1094 std::vector<const RegSelModule*>::const_iterator mptr(modules.begin());
1095 for ( ; mptr!=modules.end() ; ++mptr ) {
1096 if ( (*mptr)->enabled() ) roblist.push_back((*mptr)->robID());
1097 }
1098 removeDuplicates( roblist );
1099
1100 // std::set<uint32_t>::iterator rlist(uroblist.begin());
1101 // while ( rlist!=uroblist.end() ) roblist.push_back(*rlist++);
1102
1103}

◆ getRoIData() [1/5]

bool RegSelSiLUT::getRoIData ( const RegSelRoI & r,
std::vector< const RegSelModule * > & modules ) const

Definition at line 273 of file RegSelSiLUT.cxx.

274{
275 // std::cout << "RegSelSiLUT::getRoIData() ID=" << ID() << "\t" << roi << std::endl;
276
277 bool inDet = false;
278
279 for ( unsigned i=0 ; i<m_SubDet.size() ; i++ ) {
280 bool inSubDet = m_SubDet[i].inRoI(roi);
281 inDet |= inSubDet;
282 // std::cout << "\tRegSelSiLUT::getRoIData() SubDet id " << m_SubDet[i].ID() << std::endl;
283 if ( inSubDet ) m_SubDet[i].getModules(roi, modules);
284 }
285
286 // std::cout << "RegSelSiLUT::getRoIData() Nmodules=" << modules.size() << std::endl;
287 // for ( int i=0 ; i<modules.size() ; i++ ) modules[i]->paw();
288
289 return inDet;
290}

◆ getRoIData() [2/5]

bool RegSelSiLUT::getRoIData ( const RegSelRoI & r,
std::vector< const RegSelModule * > & modules,
double x,
double y ) const

Definition at line 438 of file RegSelSiLUT.cxx.

439{
440
441 if ( x==0 && y==0 ) return getRoIData(roi, modules);
442
443 bool inDet = false;
444
445 for ( unsigned i=0 ; i<m_SubDet.size() ; i++ ) {
446
447#if 1
448
449 const std::vector<RegSelLayer>& layers = m_SubDet[i].getLayers();
450
451 for ( unsigned j=0 ; j<layers.size() ; j++ ) {
452
453 double rmin = layers[j].rMin();
454 double rmax = layers[j].rMax();
455
456 double phimin = roi.getphiMin();
457 double phimax = roi.getphiMax();
458
459 // std::cout << layers[j] << "\t" << rmin << " " << rmax << std::endl;
460
461 // std::cout << "lyr[" << j << "] " << "\tphimin=" << phimin << "\tphimax=" << phimax << "\tbefore" << std::endl;
462
463 if ( philimits(x, y, rmin, rmax, phimin, phimax) ) {
464
465 // std::cout << layers[j] << "\tphimin=" << phimin << "\tphimax=" << phimax << std::endl;
466
467 RegSelRoI troi( roi.getzMin(), roi.getzMax(), phimin, phimax, roi.getetaMin(), roi.getetaMax() );
468
469
470 bool inLayer = layers[j].inRoI(troi);
471
472 inDet |= inLayer;
473
474 if ( inLayer ) layers[j].getModules(troi, modules);
475
476 }
477
478 }
479
480#else
481
482
483 double rmin = m_SubDet[i].rMin();
484 double rmax = m_SubDet[i].rMax();
485
486 double phimin = roi.getphiMin();
487 double phimax = roi.getphiMax();
488
489 // std::cout << layers[j] << "\t" << rmin << " " << rmax << std::endl;
490
491 philimits(x, y, rmin, rmax, phimin, phimax);
492
493 // std::cout << layers[j] << "\tphimin=" << phimin << "\tphimax=" << phimax << std::endl;
494
495 RegSelRoI troi( roi.getzMin(), roi.getzMax(), phimin, phimax, roi.getetaMin(), roi.getetaMax() );
496
497 bool inSubDet = m_SubDet[i].inRoI(troi);
498 inDet |= inSubDet;
499 if ( inSubDet ) m_SubDet[i].getModules(troi, modules);
500
501#endif
502
503 }
504 // std::cout << "getRoIData() time=" << _time << " ms (shifted)" << std::endl;
505
506 // std::cout << "RegSelSiLUT::getRoIData() Nmodules=" << modules.size() << std::endl;
507
508 return inDet;
509}
philimits
bool philimits(double x, double y, double rmin, double rmax, double &phimin, double &phimax)
Definition RegSelSiLUT.cxx:403

◆ getRoIData() [3/5]

bool RegSelSiLUT::getRoIData ( const RegSelRoI & roi,
unsigned layer,
std::vector< const RegSelModule * > & modules ) const

here if layer is of the format 1XYY where X=0 (barrel), X=2 (endcap) and YY is the layer within the sub-system then the specific layer in the sub-system is used.

If it is of the form YY, then simple layer number is used

determine whether an layer in a specific subdetector is requested

Definition at line 315 of file RegSelSiLUT.cxx.

316{
317 // std::cout << "RegSelSiLUT::getRoIData() ID=" << ID() << std::endl;
318
319 bool inDet = false;
320
321
322 int ilayer = layer%100;
324 bool subdetflag = layer/1000;
325 int subdet = 0;
326 if ( subdetflag ) subdet = (layer%1000)/100;
327
328 for ( unsigned i=0 ; i<m_SubDet.size() ; i++ ) {
329
330 if ( !subdetflag || ( subdetflag && subdet==std::fabs(m_SubDet[i].ID()) ) ) {
331 bool inSubDet = m_SubDet[i].inRoI(roi);
332 inDet |= inSubDet;
333 if ( inSubDet ) m_SubDet[i].getModules(roi, ilayer, modules);
334 }
335 }
336
337
338
339
340 // std::cout << "RegSelSiLUT::getRoIData() Nmodules=" << modules.size() << std::endl;
341 // for ( int i=0 ; i<modules.size() ; i++ ) modules[i]->paw();
342
343 return inDet;
344}

◆ getRoIData() [4/5]

bool RegSelSiLUT::getRoIData ( const RegSelRoI & r,
unsigned subdetector,
unsigned layer,
std::vector< const RegSelModule * > & modules ) const

Definition at line 350 of file RegSelSiLUT.cxx.

351{
352 // std::cout << "RegSelSiLUT::getRoIData() ID=" << ID() << std::endl;
353
354 bool inDet = false;
355
356 if ( subdetector<m_SubDet.size() ) {
357 inDet = m_SubDet[subdetector].inRoI(roi);
358 if ( inDet ) m_SubDet[subdetector].getModules(roi, layer, modules);
359 }
360 // std::cout << "RegSelSiLUT::getRoIData() Nmodules=" << modules.size() << std::endl;
361 // for ( int i=0 ; i<modules.size() ; i++ ) modules[i]->paw();
362
363 return inDet;
364}

◆ getRoIData() [5/5]

bool RegSelSiLUT::getRoIData ( const RegSelRoI & r,
unsigned subdetector,
unsigned layer,
std::vector< const RegSelModule * > & modules,
double x,
double y ) const

Definition at line 514 of file RegSelSiLUT.cxx.

515{
516
517 if ( x==0 && y==0 ) return getRoIData(roi, subdetector, layer, modules);
518
519 // std::cout << "RegSelSiLUT::getRoIData() ID=" << ID() << std::endl;
520
521 // struct timeval _timer = gtttimer_start();
522
523 bool inDet = false;
524
525 if ( subdetector<m_SubDet.size() ) {
526
527 const std::vector<RegSelLayer>& layers = m_SubDet[subdetector].getLayers();
528
529 if ( layer<layers.size() ) {
530
531 double rmin = layers[layer].rMin();
532 double rmax = layers[layer].rMax();
533
534 double phimin = roi.getphiMin();
535 double phimax = roi.getphiMax();
536
537 // std::cout << layers[j] << "\t" << rmin << " " << rmax << std::endl;
538 // std::cout << "lyr[" << subdetector << "] " << "\tphimin=" << phimin << "\tphimax=" << phimax << "\tbefore" << std::endl;
539
540 if ( philimits(x, y, rmin, rmax, phimin, phimax) ) {
541
542 // std::cout << layers[j] << "\tphimin=" << phimin << "\tphimax=" << phimax << std::endl;
543 // std::cout << "lyr[" << subdetector << "] " << "\tphimin=" << phimin << "\tphimax=" << phimax << std::endl;
544
545 RegSelRoI troi( roi.getzMin(), roi.getzMax(), phimin, phimax, roi.getetaMin(), roi.getetaMax() );
546
547 bool inLayer = layers[layer].inRoI(troi);
548
549 inDet |= inLayer;
550
551 if ( inLayer ) layers[layer].getModules(troi, modules);
552
553 }
554 }
555 }
556
557 // double _time = gtttimer_stop(_timer);
558
559 // std::cout << "getRoIData() time=" << _time << " ms (shifted)" << std::endl;
560
561 // std::cout << "RegSelSiLUT::getRoIData() Nmodules=" << modules.size() << std::endl;
562 // for ( int i=0 ; i<modules.size() ; i++ ) modules[i]->paw();
563
564 return inDet;
565}

◆ getSubDet()

const std::vector< RegSelSubDetector > & RegSelSiLUT::getSubDet ( ) const
inline

Definition at line 108 of file RegSelSiLUT.h.

108{ return m_SubDet; }

◆ HashIDList() [1/2]

void RegSelSiLUT::HashIDList ( const IRoiDescriptor & roi,
std::vector< IdentifierHash > & idlist ) const
overridevirtual

implementation of the IRegSelUT interface
hash id methods

interface implementation for the IRegSelLUT methods

hash id methods

Implements IRegSelLUT.

Definition at line 39 of file RegSelSiLUT.cxx.

39 {
40 IRegSelLUT::IDList<RegSelSiLUT>( roi, idlist, &RegSelSiLUT::HashIDList_internal );
41 if ( m_ID == RPC ) RegSelSiLUT::cleanup( idlist );
42}
IRegSelLUT::IDList
void IDList(const IRoiDescriptor &roi, std::vector< T > &idlist, handler< C, T > lister) const
Definition IRegSelLUT.h:88
RegSelSiLUT::cleanup
static void cleanup(std::vector< IdentifierHash > &idvec)
annoying cleanup function specifically for the RPC, but we have to add it here since we have abstract...
Definition RegSelSiLUT.h:246
RegSelSiLUT::HashIDList_internal
virtual void HashIDList_internal(const IRoiDescriptor &roi, std::vector< IdentifierHash > &idlist) const
horrible internal interface methods
Definition RegSelSiLUT.cxx:68

◆ HashIDList() [2/2]

void RegSelSiLUT::HashIDList ( long layer,
const IRoiDescriptor & roi,
std::vector< IdentifierHash > & idlist ) const
overridevirtual

HashIDList interface declaration. return list of non-repeated IdentifierHash.

Parameters
longlayer, long int to decide which layer within the detector.
IRoiDescriptorroi, the IRoiDescriptor for the roi, all enabled elements in the roi are found.
Returns
std::vector<IdentifierHash> which is a list of non-repeated Offline Identifier Hash numbers.

Implements IRegSelLUT.

Definition at line 45 of file RegSelSiLUT.cxx.

45 {
46 IRegSelLUT::IDList_layer<RegSelSiLUT>( layer, roi, idlist, &RegSelSiLUT::HashIDList_internal );
47 if ( m_ID == RPC ) RegSelSiLUT::cleanup( idlist );
48}
IRegSelLUT::IDList_layer
void IDList_layer(long layer, const IRoiDescriptor &roi, std::vector< T > &idlist, handler_layer< C, T > lister) const
Definition IRegSelLUT.h:106

◆ HashIDList_internal() [1/2]

void RegSelSiLUT::HashIDList_internal ( const IRoiDescriptor & roi,
std::vector< IdentifierHash > & idlist ) const
protectedvirtual

horrible internal interface methods

protected single Roi mathods

hashid methods

hash id methods

Definition at line 68 of file RegSelSiLUT.cxx.

68 {
69 if ( roi.isFullscan() ) return getHashList( idlist );
70 RegSelRoI roitmp( roi.zedMinus(), roi.zedPlus(), roi.phiMinus(), roi.phiPlus(), roi.etaMinus(), roi.etaPlus() );
71 getHashList( roitmp, idlist );
72 if ( m_ID == MM || m_ID == sTGC ) removeDuplicates( idlist );
73}
IRoiDescriptor::isFullscan
virtual bool isFullscan() const =0
is this a full detector RoI?
IRoiDescriptor::phiPlus
virtual double phiPlus() const =0
extreme phi values
IRoiDescriptor::zedPlus
virtual double zedPlus() const =0
the zed and eta values at the most forward and most rear ends of the RoI
IRoiDescriptor::phiMinus
virtual double phiMinus() const =0
IRoiDescriptor::zedMinus
virtual double zedMinus() const =0
IRoiDescriptor::etaMinus
virtual double etaMinus() const =0
IRoiDescriptor::etaPlus
virtual double etaPlus() const =0
RegSelSiLUT::getHashList
virtual void getHashList(const RegSelRoI &roi, std::vector< IdentifierHash > &hashlist) const
Definition RegSelSiLUT.cxx:838

◆ HashIDList_internal() [2/2]

void RegSelSiLUT::HashIDList_internal ( long layer,
const IRoiDescriptor & roi,
std::vector< IdentifierHash > & idlist ) const
protectedvirtual

Definition at line 76 of file RegSelSiLUT.cxx.

76 {
77 if ( roi.isFullscan() ) return getHashList( layer, idlist );
78 RegSelRoI roitmp( roi.zedMinus(), roi.zedPlus(), roi.phiMinus(), roi.phiPlus(), roi.etaMinus(), roi.etaPlus() );
79 getHashList( roitmp, layer, idlist );
80 if ( m_ID == MM || m_ID == sTGC ) removeDuplicates( idlist );
81}

◆ ID()

DET RegSelSiLUT::ID ( ) const
inline

Definition at line 84 of file RegSelSiLUT.h.

84{ return m_ID; }

◆ IDList()

template<typename C, typename T>
void IRegSelLUT::IDList ( const IRoiDescriptor & roi,
std::vector< T > & idlist,
handler< C, T > lister ) const
inlineprotectedinherited

Definition at line 88 of file IRegSelLUT.h.

88 {
89
90 if ( roi.composite() ) {
91 idlist.clear();
92 for ( unsigned iroi=roi.size() ; iroi-- ; ) IDList<C>( *(roi.at(iroi)), idlist, lister );
93 if ( roi.size()>1 ) IRegSelLUT::removeDuplicates( idlist );
94 return;
95 }
96
97 (dynamic_cast<const C*>(this)->*lister)( roi, idlist );
98
99 }
IRoiDescriptor::at
virtual const IRoiDescriptor * at(int i) const =0
find an RoiDescriptor constituent
IRoiDescriptor::size
virtual unsigned size() const =0
number of constituents
IRoiDescriptor::composite
virtual bool composite() const =0
Super RoI access methods.
C
struct color C

◆ IDList_layer()

template<typename C, typename T>
void IRegSelLUT::IDList_layer ( long layer,
const IRoiDescriptor & roi,
std::vector< T > & idlist,
handler_layer< C, T > lister ) const
inlineprotectedinherited

Definition at line 106 of file IRegSelLUT.h.

106 {
107
108 if ( roi.composite() ) {
109 idlist.clear();
110 for ( unsigned iroi=roi.size() ; iroi-- ; ) IDList_layer<C>( layer, *(roi.at(iroi)), idlist, lister );
111 if ( roi.size()>1 ) IRegSelLUT::removeDuplicates( idlist );
112 return;
113 }
114
115 (dynamic_cast<const C*>(this)->*lister)( layer, roi, idlist );
116
117 }

◆ initialise()

void RegSelSiLUT::initialise ( )

uncomment this if you want to print out the list of all the module ids assigned to each rob RegSelROBList roblist( m_modules );

Definition at line 139 of file RegSelSiLUT.cxx.

139 {
140
141 // struct timeval inittimer = gtttimer_start();
142
143 // find out how many subdetectors there are
144
145 std::vector<int> subdetid;
146
147 for ( std::vector<RegSelModule>::iterator mptr = m_modules.begin() ;
148 mptr!=m_modules.end() ; ++mptr ) {
149 int detid = mptr->detector();
150
151 bool found = false;
152 for ( int j=subdetid.size() ; j-- ; ) if ( subdetid[j]==detid ) found = true;
153
154 if ( !found ) subdetid.push_back(detid);
155 }
156
157 // std::cout << "\tRegSelSiLUT::initialise() creating detector with " << subdetid.size() << " subdetectors" << std::endl;
158
159 // std::cout << "RegSelSiLUT::initialise()" << std::endl;
160
161 m_SubDet.reserve(subdetid.size());
162
163 // push each one to the list
164 for ( int i=subdetid.size() ; i-- ; ) {
165 m_SubDet.push_back( RegSelSubDetector(subdetid[i]) );
166 m_idmap.insert( std::map<int, int>::value_type(subdetid[i], i) );
167
168 //int ii = subdetid.size()-1-i;
169 //std::cout << "\tsubdet " << ii << "\tid " << subdetid[ii] << std::endl;
170 }
171
172
173
174
175 // initialise the subdetector look up tables
176 for ( unsigned i=0 ; i<m_SubDet.size() ; i++ ) m_SubDet[i].addModules(m_modules);
177
178 // std::cout << "\tRegSelSiLUT " << getName() << std::endl;
179 // write(getName()+".map");
180
181 // std::cout << "RegSelSiLUT::initialise() creating hash map" << std::endl;
182
183 // and save pointers to all the modules in a map by hashid
184 for ( std::vector<RegSelModule>::iterator mptr = m_modules.begin() ;
185 mptr!=m_modules.end() ; ++mptr ) {
186 m_map[(*mptr).hashID()] = &(*mptr);
187 }
188
189 // std::cout << "RegSelSiLUT::initialise() exiting" << std::endl;
190
191 // double inittime = gtttimer_stop(inittimer);
192 // std::cout << "initialise time=" << inittime << std::endl;
193
194 initialiseDisabledModules();
195 initialiseFullScan();
196
200
201}
RegSelSiLUT::m_map
std::map< const IdentifierHash, const RegSelModule * > m_map
Definition RegSelSiLUT.h:231

◆ initialiseDisabledModules()

void RegSelSiLUT::initialiseDisabledModules ( )

Definition at line 232 of file RegSelSiLUT.cxx.

232 {
233 for ( std::vector<RegSelSubDetector>::iterator sptr(m_SubDet.begin()) ;
234 sptr!=m_SubDet.end() ; ++sptr ) {
235 (*sptr).setupDisabledModules();
236 }
237}

◆ initialiseFullScan()

void RegSelSiLUT::initialiseFullScan ( )

Definition at line 204 of file RegSelSiLUT.cxx.

204 {
205
206 m_allHashes.clear();
207 m_allROBids.clear();
208
209 std::set<uint32_t> robids;
210
211 std::vector<RegSelModule>::const_iterator mptr(m_modules.begin());
212 std::vector<RegSelModule>::const_iterator eptr(m_modules.end());
213 for ( ; mptr!=eptr ; ++mptr ) {
214 if ( (*mptr).enabled() ) {
215 m_allHashes.push_back((*mptr).hashID());
216 robids.insert((*mptr).robID());
217 }
218 }
219
220 std::set<uint32_t>::iterator ritr(robids.begin());
221 while ( ritr!=robids.end() ) {
222 m_allROBids.push_back(*ritr++);
223 }
224
225}

◆ Module()

const RegSelModule * RegSelSiLUT::Module ( const IdentifierHash & h) const

Definition at line 242 of file RegSelSiLUT.cxx.

242 {
243 std::map<const IdentifierHash, const RegSelModule*>::const_iterator hptr(m_map.find(h));
244 if ( hptr!=m_map.end() ) return hptr->second;
245 else return NULL;
246}

◆ read() [1/2]

bool RegSelSiLUT::read ( const std::string & s)

Definition at line 1197 of file RegSelSiLUT.cxx.

1197 {
1198 std::ifstream infile(s.c_str());
1199 // std::cout << "RegSelSiLUT::read() from file " << s << std::endl;
1200 return read(infile);
1201}
run.infile
str infile
Definition run.py:13

◆ read() [2/2]

bool RegSelSiLUT::read ( std::istream & s)

Definition at line 1204 of file RegSelSiLUT.cxx.

1204 {
1205
1206 unsigned Nmodules = 0;
1207
1208 // old method - read number of modules and try tp read them in
1209 // new method - just read until module list exhausted,
1210 // this code will allow either
1211
1212 bool newformat = false;
1213
1214 s >> Nmodules;
1215
1216 newformat=s.fail();
1217
1218 // couldn't read number of modules - try new format
1219 if ( newformat )
1220 s.clear();
1221 else if (Nmodules > 1000000u) {
1222 // Old format --- prevent runaway on invalid input.
1223 std::cerr << "read(): Unreasonable Nmodules " << Nmodules << "\n";
1224 return false;
1225 }
1226
1227 unsigned modcount=0;
1228
1229 for ( ; newformat || modcount<Nmodules ; modcount++ ) {
1230 RegSelModule m;
1231 if ( !getModule(s, m) ) break;
1232 addModule(m);
1233 }
1234
1235 // std::cout << "read() newformat " << newformat << std::endl;
1236 // std::cout << "read() read " << modcount << " modules" << std::endl;
1237 // std::cout << "read() Nmodules " << Nmodules << "\tsize " << m_modules.size() << std::endl;
1238
1239 // std::cout << "RegSelSiLUT::read() creating tables" << std::endl;
1240 initialise();
1241
1242 if ( (!newformat) && (modcount<Nmodules ) ) return false;
1243
1244 return true;
1245}
getModule
bool getModule(std::istream &s, RegSelModule &m)
Definition RegSelModule.cxx:110
RegSelSiLUT::addModule
void addModule(RegSelModule &module)
Definition RegSelSiLUT.h:71

◆ removeDuplicates()

template<typename T>
void IRegSelLUT::removeDuplicates ( std::vector< T > & vec)
inlinestaticprotectedinherited

useful for removing duplicates if required ...

Definition at line 78 of file IRegSelLUT.h.

78 {
79 std::sort(vec.begin(), vec.end());
80 vec.erase(std::unique(vec.begin(), vec.end()), vec.end());
81 }
vec
std::vector< size_t > vec
Definition CombinationsGeneratorTest.cxx:9
std::unique
DataModel_detail::iterator< DVL > unique(typename DataModel_detail::iterator< DVL > beg, typename DataModel_detail::iterator< DVL > end)
Specialization of unique for DataVector/List.
Definition DVL_algorithms.h:135
std::sort
void sort(typename DataModel_detail::iterator< DVL > beg, typename DataModel_detail::iterator< DVL > end)
Specialization of sort for DataVector/List.
Definition DVL_algorithms.h:554

◆ reset()

void RegSelSiLUT::reset ( )

Definition at line 129 of file RegSelSiLUT.cxx.

129 {
130 for ( unsigned i=0 ; i<m_SubDet.size() ; i++ ) m_SubDet[i].reset();
131 m_map.clear();
132}

◆ ROBIDList() [1/2]

void RegSelSiLUT::ROBIDList ( const IRoiDescriptor & roi,
std::vector< uint32_t > & roblist ) const
overridevirtual

rob methods

Implements IRegSelLUT.

Definition at line 53 of file RegSelSiLUT.cxx.

53 {
54 IRegSelLUT::IDList<RegSelSiLUT>( roi, roblist, &RegSelSiLUT::ROBIDList_internal );
55}
RegSelSiLUT::ROBIDList_internal
virtual void ROBIDList_internal(const IRoiDescriptor &roi, std::vector< uint32_t > &roblist) const
rob methods
Definition RegSelSiLUT.cxx:85

◆ ROBIDList() [2/2]

void RegSelSiLUT::ROBIDList ( long layer,
const IRoiDescriptor & roi,
std::vector< uint32_t > & roblist ) const
overridevirtual

ROBIDList interface declaration. This interface can be used by the ID subdetectors. A list of non-repeated ROBIDs (uint_32_t) is returned by a reference.

Parameters
longlayer, long int to decide which layer within the detector.
IRoiDescriptorthe IRoiDescriptor for the roi, all enabled elements in the roi are found.
Returns
std::vector<uint32_t> which is a list of non-repeated ROBID numbers.

Implements IRegSelLUT.

Definition at line 58 of file RegSelSiLUT.cxx.

58 {
59 IRegSelLUT::IDList_layer<RegSelSiLUT>( layer, roi, roblist, &RegSelSiLUT::ROBIDList_internal );
60}

◆ ROBIDList_internal() [1/2]

void RegSelSiLUT::ROBIDList_internal ( const IRoiDescriptor & roi,
std::vector< uint32_t > & roblist ) const
protectedvirtual

rob methods

Definition at line 85 of file RegSelSiLUT.cxx.

85 {
86 if ( roi.isFullscan() ) return getRobList( roblist );
87 RegSelRoI roitmp( roi.zedMinus(), roi.zedPlus(), roi.phiMinus(), roi.phiPlus(), roi.etaMinus(), roi.etaPlus() );
88 getRobList( roitmp, roblist);
89}
RegSelSiLUT::getRobList
virtual void getRobList(const RegSelRoI &roi, unsigned layer, std::vector< uint32_t > &roblist, bool removeduplicates=true) const
Definition RegSelSiLUT.cxx:1032

◆ ROBIDList_internal() [2/2]

void RegSelSiLUT::ROBIDList_internal ( long layer,
const IRoiDescriptor & roi,
std::vector< uint32_t > & roblist ) const
protectedvirtual

Definition at line 92 of file RegSelSiLUT.cxx.

92 {
93 if ( roi.isFullscan() ) return getRobList( layer, roblist );
94 RegSelRoI roitmp( roi.zedMinus(), roi.zedPlus(), roi.phiMinus(), roi.phiPlus(), roi.etaMinus(), roi.etaPlus() );
95 getRobList( roitmp, layer, roblist);
96}

◆ write() [1/2]

void RegSelSiLUT::write ( const std::string & filename) const

Definition at line 579 of file RegSelSiLUT.cxx.

579 {
580 std::ofstream outfile(s.c_str());
581 write(outfile);
582}
RegSelSiLUT::write
void write(std::ostream &s=std::cout) const
Definition RegSelSiLUT.cxx:572

◆ write() [2/2]

void RegSelSiLUT::write ( std::ostream & s = std::cout) const

Definition at line 572 of file RegSelSiLUT.cxx.

572 {
573 s << m_modules.size() << std::endl;
574 for ( unsigned i=0 ; i<m_modules.size() ; i++ ) {
575 s << m_modules[i] << std::endl;
576 }
577}

Member Data Documentation

◆ m_allHashes

std::vector<IdentifierHash> RegSelSiLUT::m_allHashes
protected

Definition at line 234 of file RegSelSiLUT.h.

◆ m_allROBids

std::vector<uint32_t> RegSelSiLUT::m_allROBids
protected

Definition at line 235 of file RegSelSiLUT.h.

◆ m_disabled

std::vector<RegSelModule*> RegSelSiLUT::m_disabled
protected

Definition at line 229 of file RegSelSiLUT.h.

◆ m_ID

DET RegSelSiLUT::m_ID
protected

Definition at line 224 of file RegSelSiLUT.h.

◆ m_idmap

std::map<int, int> RegSelSiLUT::m_idmap
protected

Definition at line 237 of file RegSelSiLUT.h.

◆ m_map

std::map<const IdentifierHash, const RegSelModule*> RegSelSiLUT::m_map
protected

Definition at line 231 of file RegSelSiLUT.h.

◆ m_modules

std::vector<RegSelModule> RegSelSiLUT::m_modules
protected

Definition at line 227 of file RegSelSiLUT.h.

◆ m_name

std::string RegSelName::m_name
protectedinherited

Definition at line 45 of file RegSelName.h.

◆ m_SubDet

std::vector<RegSelSubDetector> RegSelSiLUT::m_SubDet
protected

Definition at line 226 of file RegSelSiLUT.h.

The documentation for this class was generated from the following files:
Generated on for ATLAS Offline Software by doxygen 1.14.0