ATLAS Offline Software
Public Member Functions | Static Public Member Functions | Protected Member Functions | Private Types | Private Member Functions | Private Attributes | List of all members
LVL1::gSuperCellTowerMapper Class Reference

#include <gSuperCellTowerMapper.h>

Inheritance diagram for LVL1::gSuperCellTowerMapper:
Collaboration diagram for LVL1::gSuperCellTowerMapper:

Public Member Functions

 gSuperCellTowerMapper (const std::string &type, const std::string &name, const IInterface *parent)
 
virtual ~gSuperCellTowerMapper ()
 
virtual StatusCode initialize () override
 standard Athena-Algorithm method More...
 
virtual StatusCode AssignSuperCellsToTowers (std::unique_ptr< gTowerContainer > &my_gTowerContainerRaw) const override
 
virtual StatusCode AssignTriggerTowerMapper (std::unique_ptr< gTowerContainer > &my_gTowerContainerRaw) const override
 
virtual void reset () override
 
ServiceHandle< StoreGateSvc > & evtStore ()
 The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc. More...
 
const ServiceHandle< StoreGateSvc > & evtStore () const
 The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc. More...
 
const ServiceHandle< StoreGateSvc > & detStore () const
 The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc. More...
 
virtual StatusCode sysInitialize () override
 Perform system initialization for an algorithm. More...
 
virtual StatusCode sysStart () override
 Handle START transition. More...
 
virtual std::vector< Gaudi::DataHandle * > inputHandles () const override
 Return this algorithm's input handles. More...
 
virtual std::vector< Gaudi::DataHandle * > outputHandles () const override
 Return this algorithm's output handles. More...
 
Gaudi::Details::PropertyBase & declareProperty (Gaudi::Property< T > &t)
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, SG::VarHandleKey &hndl, const std::string &doc, const SG::VarHandleKeyType &)
 Declare a new Gaudi property. More...
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, SG::VarHandleBase &hndl, const std::string &doc, const SG::VarHandleType &)
 Declare a new Gaudi property. More...
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, SG::VarHandleKeyArray &hndArr, const std::string &doc, const SG::VarHandleKeyArrayType &)
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, T &property, const std::string &doc, const SG::NotHandleType &)
 Declare a new Gaudi property. More...
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, T &property, const std::string &doc="none")
 Declare a new Gaudi property. More...
 
void updateVHKA (Gaudi::Details::PropertyBase &)
 
MsgStream & msg () const
 
MsgStream & msg (const MSG::Level lvl) const
 
bool msgLvl (const MSG::Level lvl) const
 

Static Public Member Functions

static const InterfaceID & interfaceID ()
 

Protected Member Functions

void renounceArray (SG::VarHandleKeyArray &handlesArray)
 remove all handles from I/O resolution More...
 
std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void > renounce (T &h)
 
void extraDeps_update_handler (Gaudi::Details::PropertyBase &ExtraDeps)
 Add StoreName to extra input/output deps as needed. More...
 

Private Types

typedef ServiceHandle< StoreGateSvc > StoreGateSvc_t
 

Private Member Functions

virtual int FindAndConnectTower (std::unique_ptr< gTowerContainer > &my_gTowerContainerRaw, CaloSampling::CaloSample sample, const int region, const int pos_neg, const int eta_index, const int phi_index, Identifier ID, float et, int prov, bool doPrint) const override
 
virtual void ConnectSuperCellToTower (std::unique_ptr< gTowerContainer > &my_gTowerContainerRaw, int iGTower, Identifier ID, float et) const override
 
virtual int FindTowerIDForSuperCell (int towereta, int towerphi, int nphi) const override
 
virtual void PrintCellSpec (const CaloSampling::CaloSample sample, const int region, const int eta_index, const int phi_index, const int pos_neg, int towereta, int towerphi, int nphi, int towerID_Modifier, int iGTower, int prov, Identifier ID) const override
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleKeyType &)
 specialization for handling Gaudi::Property<SG::VarHandleKey> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleKeyArrayType &)
 specialization for handling Gaudi::Property<SG::VarHandleKeyArray> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleType &)
 specialization for handling Gaudi::Property<SG::VarHandleBase> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T > &t, const SG::NotHandleType &)
 specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray> More...
 

Private Attributes

SG::ReadHandleKey< CaloCellContainer > m_scellsCollectionSGKey {this, "SCell", "SCell", "SCell"}
 
SG::ReadHandleKey< xAOD::TriggerTowerContainer > m_triggerTowerCollectionSGKey {this, "xODTriggerTowers", "xAODTriggerTowers", "xAODTriggerTowers"}
 
Gaudi::Property< bool > m_apply_masking {this, "SCellMasking", false, "Applies masking. Only use for data"}
 
StoreGateSvc_t m_evtStore
 Pointer to StoreGate (event store by default) More...
 
StoreGateSvc_t m_detStore
 Pointer to StoreGate (detector store by default) More...
 
std::vector< SG::VarHandleKeyArray * > m_vhka
 
bool m_varHandleArraysDeclared
 

Detailed Description

Definition at line 25 of file gSuperCellTowerMapper.h.

Member Typedef Documentation

◆ StoreGateSvc_t

typedef ServiceHandle<StoreGateSvc> AthCommonDataStore< AthCommonMsg< AlgTool > >::StoreGateSvc_t
privateinherited

Definition at line 388 of file AthCommonDataStore.h.

Constructor & Destructor Documentation

◆ gSuperCellTowerMapper()

LVL1::gSuperCellTowerMapper::gSuperCellTowerMapper ( const std::string &  type,
const std::string &  name,
const IInterface *  parent 
)

Definition at line 22 of file gSuperCellTowerMapper.cxx.

22  :
23  AthAlgTool(type,name,parent)
24 {
25  declareInterface<IgSuperCellTowerMapper>(this);
26 
27 }

◆ ~gSuperCellTowerMapper()

LVL1::gSuperCellTowerMapper::~gSuperCellTowerMapper ( )
virtual

Definition at line 29 of file gSuperCellTowerMapper.cxx.

30 {
31 }

Member Function Documentation

◆ AssignSuperCellsToTowers()

StatusCode LVL1::gSuperCellTowerMapper::AssignSuperCellsToTowers ( std::unique_ptr< gTowerContainer > &  my_gTowerContainerRaw) const
overridevirtual

Implements LVL1::IgSuperCellTowerMapper.

Definition at line 99 of file gSuperCellTowerMapper.cxx.

100 {
101  bool doPrint = true;
102 
103  SG::ReadHandle<CaloCellContainer> scellsCollection(m_scellsCollectionSGKey/*,ctx*/);
104  if(!scellsCollection.isValid()){
105  ATH_MSG_FATAL("Could not retrieve scellsCollection " << m_scellsCollectionSGKey.key() );
106  return StatusCode::FAILURE;
107  }
108 
109 
110  const CaloCell_Base_ID* idHelper = nullptr;
111  ATH_CHECK( detStore()->retrieve (idHelper, "CaloCell_SuperCell_ID") );
112 
113  for (const CaloCell* cell : * scellsCollection){
114 
115  const CaloSampling::CaloSample sample = (cell)->caloDDE()->getSampling();
116  const Identifier ID = (cell)->ID(); // super cell unique ID
117  int region = idHelper->region(ID);
118  int pos_neg = idHelper->pos_neg(ID);
119  int eta_index = idHelper->eta(ID);
120  const int phi_index = idHelper->phi(ID);
121  float et = (cell)->energy()/std::cosh((cell)->eta());
122  int prov = (cell)->provenance();
123 
124 
125  // std::cout<< ID << " " << (cell)->eta() << " " << (cell)->phi() << " " << sample << " " << region << std::endl;
126  // The following is to check if any SuperCells from data are permanently masked, and if so the masking is applied
127  int SCprov = prov&0xFFF;
128  bool isMasked = (SCprov&0x80)==0x80;//prov looks like 0000 0000 1000 0000 if the cell is masked
129  if (isMasked and m_apply_masking) et = 0;
130 
131  // I removed the LOCAL TO GLOBAL ETA INDEX PATCH for gFEX
132  // Since in any case the SC assignment won't be regular, the eta and phi bins are combined directly in the FindAndConnectTower
133  FindAndConnectTower(my_gTowerContainerRaw,sample,region,pos_neg,eta_index,phi_index,ID,et,prov,doPrint);
134 
135 
136  }
137 
138  for (auto gTower : *my_gTowerContainerRaw)
139  {
140  gTower->setET();
141 
142  }
143 
144 
145  return StatusCode::SUCCESS;
146 
147 }

◆ AssignTriggerTowerMapper()

StatusCode LVL1::gSuperCellTowerMapper::AssignTriggerTowerMapper ( std::unique_ptr< gTowerContainer > &  my_gTowerContainerRaw) const
overridevirtual

Implements LVL1::IgSuperCellTowerMapper.

Definition at line 42 of file gSuperCellTowerMapper.cxx.

42  {
43 
44  static constexpr float delta_phi = M_PI/32;
45  static constexpr float delta_eta = 0.1;
46 
47  SG::ReadHandle<xAOD::TriggerTowerContainer> triggerTowerCollection(m_triggerTowerCollectionSGKey/*,ctx*/);
48  if(!triggerTowerCollection.isValid()){
49  ATH_MSG_FATAL("Could not retrieve triggerTowerCollection " << m_triggerTowerCollectionSGKey.key() );
50  return StatusCode::FAILURE;
51  }
52 
53 
54  for(auto eachTower : *triggerTowerCollection) {
55 
56  if(std::abs(eachTower->eta())<1.5 && eachTower->sampling()==1) {
57  int tile_iphi = int(eachTower->phi()/delta_phi);
58  int tower_iphi = tile_iphi/2;
59  int tile_ieta = int(std::abs(eachTower->eta())/delta_eta);
60  int tower_ieta = tile_ieta/2;
61  int nphi = 32;
62  int etaSign{-1};
63  int towerID_Modifier{100000};
64 
65 
66  if (eachTower->eta() > 0) {
67  etaSign = 1;
68  towerID_Modifier = 200000;
69  }
70 
71  if(tower_ieta * etaSign == -7) {
72  towerID_Modifier = 300000;
73  }
74 
75  else if (tower_ieta * etaSign == 7) {
76  towerID_Modifier = 400000;
77  }
78  int towerid = FindTowerIDForSuperCell(tower_ieta, tower_iphi, nphi) + towerID_Modifier;
79 
80  LVL1::gTower * targetTower;
81  if((targetTower = my_gTowerContainerRaw->findTower(towerid)))
82  {
83  // Set the ET to the gTower, with layer 1 to specify this comes from the HAD
84  targetTower->addET(static_cast<int>(eachTower->jepET()) * 1000., 1);
85  } else
86  {
87  ATH_MSG_WARNING("\n==== gSuperCellTowerMapper ============ Tower id is officially unknown - it will be ignored. (Needs investigation). Please report this!");
88  }
89  }
90  }
91  return StatusCode::SUCCESS;
92 }

◆ ConnectSuperCellToTower()

void LVL1::gSuperCellTowerMapper::ConnectSuperCellToTower ( std::unique_ptr< gTowerContainer > &  my_gTowerContainerRaw,
int  iGTower,
Identifier  ID,
float  et 
) const
overrideprivatevirtual

Implements LVL1::IgSuperCellTowerMapper.

Definition at line 150 of file gSuperCellTowerMapper.cxx.

150  {
151 
152  LVL1::gTower * tmpTower = my_gTowerContainerRaw->findTower(iGTower);
153 
154  if(tmpTower){
155  tmpTower->setSCID(ID);
156  tmpTower->addET(et, 0); // layer is always 0 (EM) for SuperCells
157 
158  }
159 
160 }

◆ declareGaudiProperty() [1/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< AlgTool > >::declareGaudiProperty ( Gaudi::Property< T > &  hndl,
const SG::VarHandleKeyArrayType &   
)
inlineprivateinherited

specialization for handling Gaudi::Property<SG::VarHandleKeyArray>

Definition at line 170 of file AthCommonDataStore.h.

172  {
173  return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
174  hndl.value(),
175  hndl.documentation());
176 
177  }

◆ declareGaudiProperty() [2/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< AlgTool > >::declareGaudiProperty ( Gaudi::Property< T > &  hndl,
const SG::VarHandleKeyType &   
)
inlineprivateinherited

specialization for handling Gaudi::Property<SG::VarHandleKey>

Definition at line 156 of file AthCommonDataStore.h.

158  {
159  return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
160  hndl.value(),
161  hndl.documentation());
162 
163  }

◆ declareGaudiProperty() [3/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< AlgTool > >::declareGaudiProperty ( Gaudi::Property< T > &  hndl,
const SG::VarHandleType &   
)
inlineprivateinherited

specialization for handling Gaudi::Property<SG::VarHandleBase>

Definition at line 184 of file AthCommonDataStore.h.

186  {
187  return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
188  hndl.value(),
189  hndl.documentation());
190  }

◆ declareGaudiProperty() [4/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< AlgTool > >::declareGaudiProperty ( Gaudi::Property< T > &  t,
const SG::NotHandleType &   
)
inlineprivateinherited

specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray>

Definition at line 199 of file AthCommonDataStore.h.

200  {
201  return PBASE::declareProperty(t);
202  }

◆ declareProperty() [1/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( const std::string &  name,
SG::VarHandleBase &  hndl,
const std::string &  doc,
const SG::VarHandleType &   
)
inlineinherited

Declare a new Gaudi property.

Parameters
nameName of the property.
hndlObject holding the property value.
docDocumentation string for the property.

This is the version for types that derive from SG::VarHandleBase. The property value object is put on the input and output lists as appropriate; then we forward to the base class.

Definition at line 245 of file AthCommonDataStore.h.

249  {
250  this->declare(hndl.vhKey());
251  hndl.vhKey().setOwner(this);
252 
253  return PBASE::declareProperty(name,hndl,doc);
254  }

◆ declareProperty() [2/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( const std::string &  name,
SG::VarHandleKey &  hndl,
const std::string &  doc,
const SG::VarHandleKeyType &   
)
inlineinherited

Declare a new Gaudi property.

Parameters
nameName of the property.
hndlObject holding the property value.
docDocumentation string for the property.

This is the version for types that derive from SG::VarHandleKey. The property value object is put on the input and output lists as appropriate; then we forward to the base class.

Definition at line 221 of file AthCommonDataStore.h.

225  {
226  this->declare(hndl);
227  hndl.setOwner(this);
228 
229  return PBASE::declareProperty(name,hndl,doc);
230  }

◆ declareProperty() [3/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( const std::string &  name,
SG::VarHandleKeyArray &  hndArr,
const std::string &  doc,
const SG::VarHandleKeyArrayType &   
)
inlineinherited

Definition at line 259 of file AthCommonDataStore.h.

263  {
264 
265  // std::ostringstream ost;
266  // ost << Algorithm::name() << " VHKA declareProp: " << name
267  // << " size: " << hndArr.keys().size()
268  // << " mode: " << hndArr.mode()
269  // << " vhka size: " << m_vhka.size()
270  // << "\n";
271  // debug() << ost.str() << endmsg;
272 
273  hndArr.setOwner(this);
274  m_vhka.push_back(&hndArr);
275 
276  Gaudi::Details::PropertyBase* p = PBASE::declareProperty(name, hndArr, doc);
277  if (p != 0) {
278  p->declareUpdateHandler(&AthCommonDataStore<PBASE>::updateVHKA, this);
279  } else {
280  ATH_MSG_ERROR("unable to call declareProperty on VarHandleKeyArray "
281  << name);
282  }
283 
284  return p;
285 
286  }

◆ declareProperty() [4/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( const std::string &  name,
T &  property,
const std::string &  doc,
const SG::NotHandleType &   
)
inlineinherited

Declare a new Gaudi property.

Parameters
nameName of the property.
propertyObject holding the property value.
docDocumentation string for the property.

This is the generic version, for types that do not derive from SG::VarHandleKey. It just forwards to the base class version of declareProperty.

Definition at line 333 of file AthCommonDataStore.h.

337  {
338  return PBASE::declareProperty(name, property, doc);
339  }

◆ declareProperty() [5/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( const std::string &  name,
T &  property,
const std::string &  doc = "none" 
)
inlineinherited

Declare a new Gaudi property.

Parameters
nameName of the property.
propertyObject holding the property value.
docDocumentation string for the property.

This dispatches to either the generic declareProperty or the one for VarHandle/Key/KeyArray.

Definition at line 352 of file AthCommonDataStore.h.

355  {
356  typedef typename SG::HandleClassifier<T>::type htype;
357  return declareProperty (name, property, doc, htype());
358  }

◆ declareProperty() [6/6]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( Gaudi::Property< T > &  t)
inlineinherited

Definition at line 145 of file AthCommonDataStore.h.

145  {
146  typedef typename SG::HandleClassifier<T>::type htype;
147  return AthCommonDataStore<PBASE>::declareGaudiProperty(t, htype());
148  }

◆ detStore()

const ServiceHandle<StoreGateSvc>& AthCommonDataStore< AthCommonMsg< AlgTool > >::detStore ( ) const
inlineinherited

The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 95 of file AthCommonDataStore.h.

95 { return m_detStore; }

◆ evtStore() [1/2]

ServiceHandle<StoreGateSvc>& AthCommonDataStore< AthCommonMsg< AlgTool > >::evtStore ( )
inlineinherited

The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 85 of file AthCommonDataStore.h.

85 { return m_evtStore; }

◆ evtStore() [2/2]

const ServiceHandle<StoreGateSvc>& AthCommonDataStore< AthCommonMsg< AlgTool > >::evtStore ( ) const
inlineinherited

The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 90 of file AthCommonDataStore.h.

90 { return m_evtStore; }

◆ extraDeps_update_handler()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::extraDeps_update_handler ( Gaudi::Details::PropertyBase &  ExtraDeps)
protectedinherited

Add StoreName to extra input/output deps as needed.

use the logic of the VarHandleKey to parse the DataObjID keys supplied via the ExtraInputs and ExtraOuputs Properties to add the StoreName if it's not explicitly given

◆ FindAndConnectTower()

int LVL1::gSuperCellTowerMapper::FindAndConnectTower ( std::unique_ptr< gTowerContainer > &  my_gTowerContainerRaw,
CaloSampling::CaloSample  sample,
const int  region,
const int  pos_neg,
const int  eta_index,
const int  phi_index,
Identifier  ID,
float  et,
int  prov,
bool  doPrint 
) const
overrideprivatevirtual

Implements LVL1::IgSuperCellTowerMapper.

Definition at line 162 of file gSuperCellTowerMapper.cxx.

163 {
164 
165  bool validcell = true;
166 
167  // We tell the gTower which supercell unique ID is in each tower
168  int nphi = -1; // to be filled with number of phi bins
169  int towereta = -99; // to be filled with tower eta value to help find it
170  int towerphi = -99; // to be filled with tower phi value to help find it
171  int iGTower = -99; // The tower ID which the supercell will be assigned to
172  int towerID_Modifier = -999999999; // adjustable tower ID modifier to fit tower Id scheme
173 
174 
175  //----------------------------------------------------------
176 
177  // Begin assigning supercells to Towers
178 
179  //----------------------------------------------------------
180 
181  switch (sample) {
182  // E.M. Barrel (EMB)
183  case CaloSampling::PreSamplerB: {
184  // The following divides integers by 2 and truncates away the decimals (rounds DOWN to an integer)
185  towereta = eta_index / 2; // Layer 0 has super cells which are 0.1 x 0.1 - gTower is 0.2 x 0.2
186  towerphi = phi_index / 2; // phi is 32 for gTowers
187 
188  nphi = 32;
189 
190  if(eta_index == 14){ // special treatment for the tower where EMB and EMEC overlap (for gFEX: Eta Range 1.4-1.6)
191  if(pos_neg < 0){ towerID_Modifier = 300000; }
192  else if(pos_neg > 0){ towerID_Modifier = 400000; }
193  }
194  else{ // standard treatment for non-transition towers
195  if(pos_neg < 0){ towerID_Modifier = 100000; }
196  else if(pos_neg > 0){ towerID_Modifier = 200000; }
197  }
198 
199  break;
200  }
201  case CaloSampling::EMB1:
202  case CaloSampling::EMB2: {
203 
204  nphi = 32;
205 
206  if (region == 0) {
207  towereta = eta_index / 8;
208  towerphi = phi_index / 2;
209  if(pos_neg < 0){ towerID_Modifier = 100000; }
210  else if(pos_neg > 0){ towerID_Modifier = 200000; }
211  }
212  else if (region == 1){
213  towereta = 7;
214  towerphi = phi_index/2;
215  if(pos_neg < 0){ towerID_Modifier = 300000; }
216  else if(pos_neg > 0){ towerID_Modifier = 400000; }
217  }
218  else {
219  ATH_MSG_DEBUG("[CaloSampling::EMB1 or CaloSampling::EMB2] -> invalid 'region' value: " << region << " (Under investigation) ");
220  }
221 
222  switch(sample){
223  case CaloSampling::EMB1: {
224  break;
225  }
226  case CaloSampling::EMB2: {
227  break;
228  }
229  default: {
230  ATH_MSG_DEBUG("CaloSampling::EMBX -> invalid sample for assigning iCell value! " << sample << " (Under investigation) ");
231  break;
232  }
233  }
234 
235  break;
236  }
237  case CaloSampling::EMB3: {
238 
239  nphi = 32;
240  towereta = eta_index/2; // Analogous to PreSamplerB
241  towerphi = phi_index/2;
242 
243 
244  if(pos_neg < 0){ towerID_Modifier = 100000; }
245  else if(pos_neg > 0){ towerID_Modifier = 200000; }
246 
247  break;
248  }
249  // E.M. End-cap (EMEC)
250  case CaloSampling::PreSamplerE: {
251 
252  nphi = 32;
253  // towereta = 7 + std::ceil(eta_index / 2.); //This is a special case, as there are only 3 cells in eta 1.56 (gFEX bin 7), 1.66 (gFEX bin 8), 1.76 (gFEX bin 8)
254  if (eta_index < 1) {towereta = 7;}
255  else {towereta = 8;}
256  towerphi = phi_index / 2; // phi is 32 for gTowers
257 
258 
259  if (towereta == 7){
260  if(pos_neg < 0){ towerID_Modifier = 300000; }
261  else if(pos_neg > 0){ towerID_Modifier = 400000; }
262  }
263  else if (towereta != 7){
264  if(pos_neg < 0){ towerID_Modifier = 500000; }
265  else if(pos_neg > 0){ towerID_Modifier = 600000; }
266  }
267 
268  break;
269  }
270  case CaloSampling::EME1: {
271 
272  nphi = 32;
273 
274  switch (region) {
275  case 0: {
276 
277  towereta = 7;
278  towerphi = phi_index/2;
279 
280  break;
281  }
282  case 2: {
283 
284  if (eta_index < 4) {towereta = 7;}
285  else {towereta = 8;}
286  towerphi = phi_index/2;
287 
288  break;
289  }
290  case 3: {
291 
292  if (eta_index < 11) {towereta = 8;}
293  else {towereta = 9;}
294  towerphi = phi_index/2;
295  break;
296 
297  }
298  case 4: {
299 
300  if (eta_index < 8) {towereta = 10;}
301  else {towereta = 11;}
302  towerphi = phi_index/2;
303 
304  break;
305  }
306  case 5: {
307 
308  towereta = 11 ;
309  towerphi = phi_index/2;
310 
311  break;
312  }
313  default: {
314  ATH_MSG_DEBUG("CaloSampling::EME1 -> invalid 'region' value: " << region << " (Under investigation) ");
315  break;
316  }
317  break;
318  }
319 
320  if (towereta == 7){
321  if(pos_neg < 0){ towerID_Modifier = 300000; }
322  else if(pos_neg > 0){ towerID_Modifier = 400000; }
323  }
324  else if (towereta != 7){
325  if(pos_neg < 0){ towerID_Modifier = 500000; }
326  else if(pos_neg > 0){ towerID_Modifier = 600000; }
327  }
328 
329  break;
330  }
331  case CaloSampling::EME2: {
332 
333  nphi = 32;
334 
335  switch (region) {
336  case 0: {
337 
338  if(abs(pos_neg) == 2){
339  towereta = 7;
340  towerphi = phi_index/2;
341  }
342  else if(abs(pos_neg) == 3){
343  if (eta_index == 0){
344  towereta = 12;
345  towerphi = phi_index;
346  }
347  else if (eta_index == 1){
348  towereta = 13;
349  towerphi = phi_index;
350  }
351  else if (eta_index == 2){
352  towereta = 14;
353  towerphi = phi_index;
354  }
355  }
356  break;
357  }
358  case 1: {
359  if(abs(pos_neg) == 2){
360  towerphi = phi_index/2;
361  if (eta_index < 7) {towereta = 7;}
362  else if (eta_index < 15) {towereta = 8;}
363  else if (eta_index < 23) {towereta = 9;}
364  else if (eta_index < 31) {towereta = 10;}
365  else if (eta_index < 43) {towereta = 11;}
366  }
367  else if(abs(pos_neg) == 3){
368  towerphi = phi_index;
369  towereta = 15;
370  }
371  break;
372  }
373 
374  default: {
375  ATH_MSG_DEBUG("CaloSampling::EME2 -> invalid 'region' value: " << region << " (Under investigation) ");
376  break;
377  }
378  break;
379  }
380 
381  if (towereta == 7){
382  if(pos_neg < 0){ towerID_Modifier = 300000; }
383  else if(pos_neg > 0){ towerID_Modifier = 400000; }
384  }
385  else if (towereta == 12 || towereta == 13 || towereta == 14 || towereta == 15){
386  if(pos_neg < 0){ towerID_Modifier = 700000; }
387  else if(pos_neg > 0){ towerID_Modifier = 800000; }
388  }
389  else {
390  if(pos_neg < 0){ towerID_Modifier = 500000; }
391  else if(pos_neg > 0){ towerID_Modifier = 600000; }
392  }
393 
394  break;
395  }
396  case CaloSampling::EME3: {
397 
398  nphi = 32;
399  switch (region) {
400  case 0: {
401  if(abs(pos_neg) == 2){
402  towerphi = phi_index/2;
403  if (eta_index == 0){
404  towereta = 7;
405  }
406  else if(eta_index < 3){
407  towereta = 8;
408  }
409  else if(eta_index < 5){
410  towereta = 9;
411  }
412  else if(eta_index < 7){
413  towereta = 10;
414  }
415  else if(eta_index < 10){
416  towereta = 11;
417  }
418 
419  }
420  else if(abs(pos_neg) == 3){
421  if (eta_index == 0){
422  towereta = 12;
423  towerphi = phi_index;
424  }
425  else if (eta_index == 1){
426  towereta = 13;
427  towerphi = phi_index;
428  }
429  else if (eta_index == 2){
430  towereta = 14;
431  towerphi = phi_index;
432  }
433  }
434  break;
435  }
436  case 1: { // we only have the case: abs(pos_neg) = 3
437  towerphi = phi_index;
438  towereta = 15;
439  break;
440  }
441  default: {
442  ATH_MSG_DEBUG("CaloSampling::EME3 -> invalid 'region' value: " << region << " (Under investigation) ");
443  break;
444  }
445  break;
446  }
447 
448  if (towereta == 7){
449  if(pos_neg < 0){ towerID_Modifier = 300000; }
450  else if(pos_neg > 0){ towerID_Modifier = 400000; }
451  }
452  else if (towereta == 12 || towereta == 13 || towereta == 14 || towereta == 15){
453  if(pos_neg < 0){ towerID_Modifier = 700000; }
454  else if(pos_neg > 0){ towerID_Modifier = 800000; }
455  }
456  else {
457  if(pos_neg < 0){ towerID_Modifier = 500000; }
458  else if(pos_neg > 0){ towerID_Modifier = 600000; }
459  }
460  break;
461  }
462  // Hadronic End-cap (HEC)
463  case CaloSampling::HEC0:{
464  nphi = 32;
465  switch(region){
466  case 0: {
467  if(abs(pos_neg) == 2){
468  towerphi = phi_index/2;
469  if (eta_index == 0){
470  towereta = 7;
471  }
472  else if(eta_index < 3){
473  towereta = 8;
474  }
475  else if(eta_index < 5){
476  towereta = 9;
477  }
478  else if(eta_index < 7){
479  towereta = 10;
480  }
481  else if(eta_index < 10){
482  towereta = 11;
483  }
484  }
485  break;
486 
487  }
488 
489  case 1: {
490  if(abs(pos_neg) == 2){
491  if (eta_index == 0){
492  towereta = 12;
493  towerphi = phi_index;
494  }
495  else if(eta_index == 1){
496  towereta = 13;
497  towerphi = phi_index;
498  }
499  else if(eta_index == 2){
500  towereta = 14;
501  towerphi = phi_index;
502  }
503  else if(eta_index == 3){
504  towereta = 15;
505  towerphi = phi_index;
506  }
507  }
508  break;
509 
510  }
511 
512  default: {
513  ATH_MSG_DEBUG("CaloSampling::HEC0 -> invalid 'region' value: " << region << " (Under investigation) ");
514  break;
515  }
516 
517  }
518 
519  // Tower connection
520  if (towereta == 7){
521  nphi = 32;
522  if(pos_neg < 0){ towerID_Modifier = 300000; }
523  else if(pos_neg > 0){ towerID_Modifier = 400000; }
524  }
525  else if (towereta == 12 || towereta == 13 || towereta == 14 || towereta == 15){
526  if(pos_neg < 0){ towerID_Modifier = 700000; }
527  else if(pos_neg > 0){ towerID_Modifier = 800000; }
528  }
529  else {
530  nphi = 32;
531  if(pos_neg < 0){ towerID_Modifier = 500000; }
532  else if(pos_neg > 0){ towerID_Modifier = 600000; }
533  }
534 
535  break;
536  }
537  case CaloSampling::TileBar0:
538  case CaloSampling::TileBar1:
539  case CaloSampling::TileBar2: {
540  REPORT_MESSAGE_WITH_CONTEXT (MSG::DEBUG, "gSuperCellTowerMapper") << "Supercell is from Tile Barrel - it will be ignored.";
541  validcell = false;
542  ATH_MSG_DEBUG("\n==== gSuperCellTowerMapper ============ Supercell is from Tile Barrel - it will be ignored.");
543  break;
544  }
545  case CaloSampling::TileGap1:
546  case CaloSampling::TileGap2:
547  case CaloSampling::TileGap3: {
548  ATH_MSG_DEBUG("\n==== gSuperCellTowerMapper ============ Supercell is from Tile Gap (ITC and scintillator) - it will be ignored.");
549  validcell = false;
550  break;
551  }
552  case CaloSampling::TileExt0:
553  case CaloSampling::TileExt1:
554  case CaloSampling::TileExt2: {
555  ATH_MSG_DEBUG("\n==== gSuperCellTowerMapper ============ Supercell is from Tile Extended Barrel - it will be ignored.");
556  validcell = false;
557  break;
558  }
559  case CaloSampling::FCAL0:{
560  nphi = 16;
561  towerphi = phi_index;
562  if(eta_index < 5){
563  towereta = 16;
564  }
565  else if(eta_index < 8){
566  towereta = 17;
567  }
568  else if(eta_index < 10){
569  towereta = 18;
570  }
571  else if(eta_index < 12){
572  towereta = 19;
573  }
574 
575  if(pos_neg < 0){ towerID_Modifier = 900000; }
576  else if(pos_neg > 0){ towerID_Modifier = 1000000; }
577 
578  break;
579  }
580  case CaloSampling::FCAL1:{
581  nphi = 16;
582  towerphi = phi_index;
583  if (eta_index < 4){
584  towereta = 16;
585  }
586  else if(eta_index < 6){
587  towereta = 17;
588  }
589  else if(eta_index < 7){
590  towereta = 18;
591  }
592  else if(eta_index < 8){
593  towereta = 19;
594  }
595 
596  if(pos_neg < 0){ towerID_Modifier = 900000; }
597  else if(pos_neg > 0){ towerID_Modifier = 1000000; }
598 
599  break;
600  }
601  case CaloSampling::FCAL2:{
602  nphi = 16;
603  towerphi = phi_index;
604  if (eta_index < 1){
605  towereta = 16;
606  }
607  else if(eta_index < 3){
608  towereta = 17;
609  }
610  else if(eta_index < 4){
611  towereta = 18;
612  }
613 
614  if(pos_neg < 0){ towerID_Modifier = 900000; }
615  else if(pos_neg > 0){ towerID_Modifier = 1000000; }
616  break;
617  }
618 
619 
620  case CaloSampling::MINIFCAL0:
621  case CaloSampling::MINIFCAL1:
622  case CaloSampling::MINIFCAL2:
623  case CaloSampling::MINIFCAL3: {
624  ATH_MSG_DEBUG("\n==== gSuperCellTowerMapper ============ Supercells is from MiniFCAL - it will be ignored.");
625  validcell = false;
626  break;
627  }
628  case CaloSampling::Unknown: {
629  ATH_MSG_WARNING("\n==== gSuperCellTowerMapper ============ Supercell sampling is officially unknown - it will be ignored. (Needs investigation). Please report this!");
630  validcell = false;
631  break;
632  }
633  default: {
634  ATH_MSG_DEBUG("\n==== gSuperCellTowerMapper ============ Supercell has invalid CaloSampling value: " << sample << " (Needs investigation). Please report this!");
635  validcell = false;
636  break;
637  }
638  }
639 
640  if(validcell){
641  iGTower = FindTowerIDForSuperCell(towereta, towerphi, nphi) + towerID_Modifier;
642  if(doPrint){
643  PrintCellSpec(sample, region, eta_index, phi_index, pos_neg, towereta, towerphi, nphi, towerID_Modifier, iGTower, prov, ID);
644  }
645  ConnectSuperCellToTower(my_gTowerContainerRaw, iGTower, ID, et);
646  }
647 
648  // END ITERATING OVER SUPER CELLS+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +++++++++++++++++++++++++++++++++++++++++++++
649 
650  return 1;
651 
652 }

◆ FindTowerIDForSuperCell()

int LVL1::gSuperCellTowerMapper::FindTowerIDForSuperCell ( int  towereta,
int  towerphi,
int  nphi 
) const
overrideprivatevirtual

Implements LVL1::IgSuperCellTowerMapper.

Definition at line 654 of file gSuperCellTowerMapper.cxx.

655 {
656 
657  return (towerphi + (nphi * towereta));
658 
659 }

◆ initialize()

StatusCode LVL1::gSuperCellTowerMapper::initialize ( )
overridevirtual

standard Athena-Algorithm method

Definition at line 33 of file gSuperCellTowerMapper.cxx.

34 {
35 
36  ATH_CHECK( m_scellsCollectionSGKey.initialize() );
37  ATH_CHECK( m_triggerTowerCollectionSGKey.initialize() );
38 
39  return StatusCode::SUCCESS;
40 }

◆ inputHandles()

virtual std::vector<Gaudi::DataHandle*> AthCommonDataStore< AthCommonMsg< AlgTool > >::inputHandles ( ) const
overridevirtualinherited

Return this algorithm's input handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

◆ interfaceID()

const InterfaceID & LVL1::IgSuperCellTowerMapper::interfaceID ( )
inlinestaticinherited

Definition at line 46 of file IgSuperCellTowerMapper.h.

47  {
48  return IID_IgSuperCellTowerMapper;
49  }

◆ msg() [1/2]

MsgStream& AthCommonMsg< AlgTool >::msg ( ) const
inlineinherited

Definition at line 24 of file AthCommonMsg.h.

24  {
25  return this->msgStream();
26  }

◆ msg() [2/2]

MsgStream& AthCommonMsg< AlgTool >::msg ( const MSG::Level  lvl) const
inlineinherited

Definition at line 27 of file AthCommonMsg.h.

27  {
28  return this->msgStream(lvl);
29  }

◆ msgLvl()

bool AthCommonMsg< AlgTool >::msgLvl ( const MSG::Level  lvl) const
inlineinherited

Definition at line 30 of file AthCommonMsg.h.

30  {
31  return this->msgLevel(lvl);
32  }

◆ outputHandles()

virtual std::vector<Gaudi::DataHandle*> AthCommonDataStore< AthCommonMsg< AlgTool > >::outputHandles ( ) const
overridevirtualinherited

Return this algorithm's output handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

◆ PrintCellSpec()

void LVL1::gSuperCellTowerMapper::PrintCellSpec ( const CaloSampling::CaloSample  sample,
const int  region,
const int  eta_index,
const int  phi_index,
const int  pos_neg,
int  towereta,
int  towerphi,
int  nphi,
int  towerID_Modifier,
int  iGTower,
int  prov,
Identifier  ID 
) const
overrideprivatevirtual

Implements LVL1::IgSuperCellTowerMapper.

Definition at line 661 of file gSuperCellTowerMapper.cxx.

665 {
666 
667  std::string sampleName = "";
668 
669  switch (sample) {
670  case CaloSampling::PreSamplerB: { sampleName = "PreSamplerB"; break; }
671  case CaloSampling::EMB1: { sampleName = "EMB1"; break; }
672  case CaloSampling::EMB2: { sampleName = "EMB2"; break; }
673  case CaloSampling::EMB3: { sampleName = "EMB3"; break; }
674  case CaloSampling::PreSamplerE: { sampleName = "PreSamplerE"; break; }
675  case CaloSampling::EME1: { sampleName = "EME1"; break; }
676  case CaloSampling::EME2: { sampleName = "EME2"; break; }
677  case CaloSampling::EME3: { sampleName = "EME3"; break; }
678  case CaloSampling::HEC0: { sampleName = "HEC0"; break; }
679  case CaloSampling::HEC1: { sampleName = "HEC1"; break; }
680  case CaloSampling::HEC2: { sampleName = "HEC2"; break; }
681  case CaloSampling::HEC3: { sampleName = "HEC3"; break; }
682  case CaloSampling::TileBar0: { sampleName = "TileBar0"; break; }
683  case CaloSampling::TileBar1: { sampleName = "TileBar1"; break; }
684  case CaloSampling::TileBar2: { sampleName = "TileBar2"; break; }
685  case CaloSampling::TileGap1: { sampleName = "TileGap1"; break; }
686  case CaloSampling::TileGap2: { sampleName = "TileGap2"; break; }
687  case CaloSampling::TileGap3: { sampleName = "TileGap3"; break; }
688  case CaloSampling::TileExt0: { sampleName = "TileExt0"; break; }
689  case CaloSampling::TileExt1: { sampleName = "TileExt1"; break; }
690  case CaloSampling::TileExt2: { sampleName = "TileExt2"; break; }
691  case CaloSampling::FCAL0: { sampleName = "FCAL0"; break; }
692  case CaloSampling::FCAL1: { sampleName = "FCAL1"; break; }
693  case CaloSampling::FCAL2: { sampleName = "FCAL2"; break; }
694 
695  default: {
696  ATH_MSG_DEBUG("\n==== gSuperCellTowerMapper ============ Supercell has invalid CaloSampling value: " << sample << " (Needs investigation). Please report this!");
697  break;
698  }
699  }
700 
701  ATH_MSG_DEBUG("ASSIGNED CELL::: CASE: " << sampleName
702  << "\tSample: " << sample
703  << "\tRegion: " << region
704  << "\tEta_Index: " << eta_index
705  << "\tPhi_Index: " << phi_index
706  << "\tPosNeg: " << pos_neg
707  << "\tgTower Eta: " << towereta
708  << "\tgTower Phi: " << towerphi
709  << "\tgTower nphi: " << nphi
710  << "\tgTower modifier: " << towerID_Modifier
711  << "\tiGTower: " << iGTower
712  << "\tProvenance: " << prov
713  << "\tID: " << ID
714  << " ");
715 
716 
717  return;
718 }

◆ renounce()

std::enable_if_t<std::is_void_v<std::result_of_t<decltype(&T::renounce)(T)> > && !std::is_base_of_v<SG::VarHandleKeyArray, T> && std::is_base_of_v<Gaudi::DataHandle, T>, void> AthCommonDataStore< AthCommonMsg< AlgTool > >::renounce ( T &  h)
inlineprotectedinherited

Definition at line 380 of file AthCommonDataStore.h.

381  {
382  h.renounce();
383  PBASE::renounce (h);
384  }

◆ renounceArray()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::renounceArray ( SG::VarHandleKeyArray &  handlesArray)
inlineprotectedinherited

remove all handles from I/O resolution

Definition at line 364 of file AthCommonDataStore.h.

364  {
365  handlesArray.renounce();
366  }

◆ reset()

void LVL1::gSuperCellTowerMapper::reset ( )
overridevirtual

Implements LVL1::IgSuperCellTowerMapper.

Definition at line 94 of file gSuperCellTowerMapper.cxx.

94  {
95  return;
96 }

◆ sysInitialize()

virtual StatusCode AthCommonDataStore< AthCommonMsg< AlgTool > >::sysInitialize ( )
overridevirtualinherited

Perform system initialization for an algorithm.

We override this to declare all the elements of handle key arrays at the end of initialization. See comments on updateVHKA.

Reimplemented in DerivationFramework::CfAthAlgTool, AthCheckedComponent< AthAlgTool >, AthCheckedComponent<::AthAlgTool >, and asg::AsgMetadataTool.

◆ sysStart()

virtual StatusCode AthCommonDataStore< AthCommonMsg< AlgTool > >::sysStart ( )
overridevirtualinherited

Handle START transition.

We override this in order to make sure that conditions handle keys can cache a pointer to the conditions container.

◆ updateVHKA()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::updateVHKA ( Gaudi::Details::PropertyBase &  )
inlineinherited

Definition at line 308 of file AthCommonDataStore.h.

308  {
309  // debug() << "updateVHKA for property " << p.name() << " " << p.toString()
310  // << " size: " << m_vhka.size() << endmsg;
311  for (auto &a : m_vhka) {
312  std::vector<SG::VarHandleKey*> keys = a->keys();
313  for (auto k : keys) {
314  k->setOwner(this);
315  }
316  }
317  }

Member Data Documentation

◆ m_apply_masking

Gaudi::Property<bool> LVL1::gSuperCellTowerMapper::m_apply_masking {this, "SCellMasking", false, "Applies masking. Only use for data"}
private

Definition at line 44 of file gSuperCellTowerMapper.h.

◆ m_detStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_detStore
privateinherited

Pointer to StoreGate (detector store by default)

Definition at line 393 of file AthCommonDataStore.h.

◆ m_evtStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_evtStore
privateinherited

Pointer to StoreGate (event store by default)

Definition at line 390 of file AthCommonDataStore.h.

◆ m_scellsCollectionSGKey

SG::ReadHandleKey<CaloCellContainer> LVL1::gSuperCellTowerMapper::m_scellsCollectionSGKey {this, "SCell", "SCell", "SCell"}
private

Definition at line 41 of file gSuperCellTowerMapper.h.

◆ m_triggerTowerCollectionSGKey

SG::ReadHandleKey<xAOD::TriggerTowerContainer> LVL1::gSuperCellTowerMapper::m_triggerTowerCollectionSGKey {this, "xODTriggerTowers", "xAODTriggerTowers", "xAODTriggerTowers"}
private

Definition at line 42 of file gSuperCellTowerMapper.h.

◆ m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< AlgTool > >::m_varHandleArraysDeclared
privateinherited

Definition at line 399 of file AthCommonDataStore.h.

◆ m_vhka

std::vector<SG::VarHandleKeyArray*> AthCommonDataStore< AthCommonMsg< AlgTool > >::m_vhka
privateinherited

Definition at line 398 of file AthCommonDataStore.h.

The documentation for this class was generated from the following files:
python.PyKernel.retrieve
def retrieve(aClass, aKey=None)
Definition: PyKernel.py:110
GetLCDefs::Unknown
@ Unknown
Definition: GetLCDefs.h:21
test_pyathena.eta
eta
Definition: test_pyathena.py:10
et
Extra patterns decribing particle interation process.
ATH_MSG_FATAL
#define ATH_MSG_FATAL(x)
Definition: AthMsgStreamMacros.h:34
CaloCell_ID_FCS::TileExt2
@ TileExt2
Definition: FastCaloSim_CaloCell_ID.h:39
CaloCell_Base_ID::region
int region(const Identifier id) const
LAr field values (NOT_VALID == invalid request)
constants.EMB1
int EMB1
Definition: Calorimeter/CaloClusterCorrection/python/constants.py:53
ReadCellNoiseFromCool.cell
cell
Definition: ReadCellNoiseFromCool.py:53
LVL1::gSuperCellTowerMapper::m_apply_masking
Gaudi::Property< bool > m_apply_masking
Definition: gSuperCellTowerMapper.h:44
ID
std::vector< Identifier > ID
Definition: CalibHitIDCheck.h:24
CaloCellPos2Ntuple.int
int
Definition: CaloCellPos2Ntuple.py:24
SG::ReadHandle
Definition: StoreGate/StoreGate/ReadHandle.h:70
AthCommonDataStore::declareProperty
Gaudi::Details::PropertyBase & declareProperty(Gaudi::Property< T > &t)
Definition: AthCommonDataStore.h:145
CaloCell_ID_FCS::TileExt0
@ TileExt0
Definition: FastCaloSim_CaloCell_ID.h:37
CaloCell_ID_FCS::TileBar1
@ TileBar1
Definition: FastCaloSim_CaloCell_ID.h:32
CaloCell_Base_ID::pos_neg
int pos_neg(const Identifier id) const
LAr field values (NOT_VALID == invalid request)
LVL1::gTower::setSCID
void setSCID(Identifier ID)
Set supercell position ID.
Definition: gTower.cxx:97
LVL1::gTower
The gTower class is an interface object for gFEX trigger algorithms The purposes are twofold:
Definition: gTower.h:38
LVL1::gSuperCellTowerMapper::FindTowerIDForSuperCell
virtual int FindTowerIDForSuperCell(int towereta, int towerphi, int nphi) const override
Definition: gSuperCellTowerMapper.cxx:654
M_PI
#define M_PI
Definition: ActiveFraction.h:11
CaloCell_ID_FCS::FCAL1
@ FCAL1
Definition: FastCaloSim_CaloCell_ID.h:41
AthCommonDataStore< AthCommonMsg< AlgTool > >::m_evtStore
StoreGateSvc_t m_evtStore
Pointer to StoreGate (event store by default)
Definition: AthCommonDataStore.h:390
AthCommonDataStore< AthCommonMsg< AlgTool > >::m_vhka
std::vector< SG::VarHandleKeyArray * > m_vhka
Definition: AthCommonDataStore.h:398
CaloCell_ID_FCS::HEC2
@ HEC2
Definition: FastCaloSim_CaloCell_ID.h:29
read_hist_ntuple.t
t
Definition: read_hist_ntuple.py:5
SG::VarHandleKey::key
const std::string & key() const
Return the StoreGate ID for the referenced object.
Definition: AthToolSupport/AsgDataHandles/Root/VarHandleKey.cxx:141
LVL1::gSuperCellTowerMapper::PrintCellSpec
virtual void PrintCellSpec(const CaloSampling::CaloSample sample, const int region, const int eta_index, const int phi_index, const int pos_neg, int towereta, int towerphi, int nphi, int towerID_Modifier, int iGTower, int prov, Identifier ID) const override
Definition: gSuperCellTowerMapper.cxx:661
CaloCell_ID_FCS::TileGap3
@ TileGap3
Definition: FastCaloSim_CaloCell_ID.h:36
AthCommonDataStore< AthCommonMsg< AlgTool > >::detStore
const ServiceHandle< StoreGateSvc > & detStore() const
The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.
Definition: AthCommonDataStore.h:95
SG::VarHandleKeyArray::setOwner
virtual void setOwner(IDataHandleHolder *o)=0
IDTPMcnv.htype
htype
Definition: IDTPMcnv.py:29
python.utils.AtlRunQueryDQUtils.p
p
Definition: AtlRunQueryDQUtils.py:210
AthCommonDataStore
Definition: AthCommonDataStore.h:52
CaloCell_ID_FCS::HEC1
@ HEC1
Definition: FastCaloSim_CaloCell_ID.h:28
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
ParticleGun_FastCalo_ChargeFlip_Config.energy
energy
Definition: ParticleGun_FastCalo_ChargeFlip_Config.py:78
constants.EMB2
int EMB2
Definition: Calorimeter/CaloClusterCorrection/python/constants.py:54
FullCPAlgorithmsTest_eljob.sample
sample
Definition: FullCPAlgorithmsTest_eljob.py:113
CaloSampling::CaloSample
CaloSample
Definition: Calorimeter/CaloGeoHelpers/CaloGeoHelpers/CaloSampling.h:22
LVL1::gSuperCellTowerMapper::m_triggerTowerCollectionSGKey
SG::ReadHandleKey< xAOD::TriggerTowerContainer > m_triggerTowerCollectionSGKey
Definition: gSuperCellTowerMapper.h:42
CaloCell_ID_FCS::TileBar0
@ TileBar0
Definition: FastCaloSim_CaloCell_ID.h:31
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition: AthMsgStreamMacros.h:29
CaloCell_ID_FCS::TileGap2
@ TileGap2
Definition: FastCaloSim_CaloCell_ID.h:35
test_pyathena.parent
parent
Definition: test_pyathena.py:15
CaloCell_Base_ID::eta
int eta(const Identifier id) const
LAr field values (NOT_VALID == invalid request)
constants.EME1
int EME1
Definition: Calorimeter/CaloClusterCorrection/python/constants.py:55
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
AthCommonDataStore< AthCommonMsg< AlgTool > >::m_detStore
StoreGateSvc_t m_detStore
Pointer to StoreGate (detector store by default)
Definition: AthCommonDataStore.h:393
SG::VarHandleKey::initialize
StatusCode initialize(bool used=true)
If this object is used as a property, then this should be called during the initialize phase.
Definition: AthToolSupport/AsgDataHandles/Root/VarHandleKey.cxx:103
createCablingJSON.eta_index
int eta_index
Definition: createCablingJSON.py:14
CaloCell_ID_FCS::TileGap1
@ TileGap1
Definition: FastCaloSim_CaloCell_ID.h:34
AthAlgTool::AthAlgTool
AthAlgTool()
Default constructor:
LVL1::gTower::addET
void addET(float et, int layer)
Add ET in MeV, layer refers to EM or HAD (Tile)
Definition: gTower.cxx:60
SG::VarHandleKeyArray::renounce
virtual void renounce()=0
SG::HandleClassifier::type
std::conditional< std::is_base_of< SG::VarHandleKeyArray, T >::value, VarHandleKeyArrayType, type2 >::type type
Definition: HandleClassifier.h:54
REPORT_MESSAGE_WITH_CONTEXT
#define REPORT_MESSAGE_WITH_CONTEXT(LVL, CONTEXT_NAME)
Report a message, with an explicitly specified context name.
Definition: Control/AthenaKernel/AthenaKernel/errorcheck.h:345
merge_scale_histograms.doc
string doc
Definition: merge_scale_histograms.py:9
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:228
CaloCell_ID_FCS::TileExt1
@ TileExt1
Definition: FastCaloSim_CaloCell_ID.h:38
CaloCell_ID_FCS::EME3
@ EME3
Definition: FastCaloSim_CaloCell_ID.h:26
CaloCell_Base_ID::phi
int phi(const Identifier id) const
LAr field values (NOT_VALID == invalid request)
LVL1::gSuperCellTowerMapper::m_scellsCollectionSGKey
SG::ReadHandleKey< CaloCellContainer > m_scellsCollectionSGKey
Definition: gSuperCellTowerMapper.h:41
CaloCell_ID_FCS::HEC0
@ HEC0
Definition: FastCaloSim_CaloCell_ID.h:27
LVL1::gSuperCellTowerMapper::FindAndConnectTower
virtual int FindAndConnectTower(std::unique_ptr< gTowerContainer > &my_gTowerContainerRaw, CaloSampling::CaloSample sample, const int region, const int pos_neg, const int eta_index, const int phi_index, Identifier ID, float et, int prov, bool doPrint) const override
Definition: gSuperCellTowerMapper.cxx:162
a
TList * a
Definition: liststreamerinfos.cxx:10
h
CaloCell
Data object for each calorimeter readout cell.
Definition: CaloCell.h:57
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
CaloCell_ID_FCS::PreSamplerE
@ PreSamplerE
Definition: FastCaloSim_CaloCell_ID.h:23
CaloCell_ID_FCS::PreSamplerB
@ PreSamplerB
Definition: FastCaloSim_CaloCell_ID.h:19
eFEXNTuple.delta_phi
def delta_phi(phi1, phi2)
Definition: eFEXNTuple.py:15
python.CaloScaleNoiseConfig.type
type
Definition: CaloScaleNoiseConfig.py:78
DEBUG
#define DEBUG
Definition: page_access.h:11
SG::VarHandleBase::vhKey
SG::VarHandleKey & vhKey()
Return a non-const reference to the HandleKey.
Definition: StoreGate/src/VarHandleBase.cxx:623
CaloCell_ID_FCS::FCAL2
@ FCAL2
Definition: FastCaloSim_CaloCell_ID.h:42
python.Bindings.keys
keys
Definition: Control/AthenaPython/python/Bindings.py:798
LVL1::gSuperCellTowerMapper::ConnectSuperCellToTower
virtual void ConnectSuperCellToTower(std::unique_ptr< gTowerContainer > &my_gTowerContainerRaw, int iGTower, Identifier ID, float et) const override
Definition: gSuperCellTowerMapper.cxx:150
CaloCell_ID_FCS::HEC3
@ HEC3
Definition: FastCaloSim_CaloCell_ID.h:30
CaloCell_Base_ID
Helper base class for offline cell identifiers.
Definition: CaloCell_Base_ID.h:41
CaloCell_ID_FCS::FCAL0
@ FCAL0
Definition: FastCaloSim_CaloCell_ID.h:40
CaloCell_ID_FCS::EMB3
@ EMB3
Definition: FastCaloSim_CaloCell_ID.h:22
CaloCell_ID_FCS::TileBar2
@ TileBar2
Definition: FastCaloSim_CaloCell_ID.h:33
AthCommonDataStore::declareGaudiProperty
Gaudi::Details::PropertyBase & declareGaudiProperty(Gaudi::Property< T > &hndl, const SG::VarHandleKeyType &)
specialization for handling Gaudi::Property<SG::VarHandleKey>
Definition: AthCommonDataStore.h:156
constants.EME2
int EME2
Definition: Calorimeter/CaloClusterCorrection/python/constants.py:56
fitman.k
k
Definition: fitman.py:528
Identifier
Definition: IdentifierFieldParser.cxx:14
Generated on Tue Dec 24 2024 22:00:43 for ATLAS Offline Software by   doxygen 1.8.18