CaloDetDescrManager Class Reference

This class provides the client interface for accessing the detector description information common to LAr and Tile. More...

#include <CaloDetDescrManager.h>

Inheritance diagram for CaloDetDescrManager:

Collaboration diagram for CaloDetDescrManager:

Public Types
using	calo_element_vec = std::vector<CaloDetDescrElement*>
using	calo_element_vec_size = calo_element_vec::size_type
using	calo_element_const_iterator = CaloConstIteratorAdaptor<calo_element_vec::const_iterator>
using	calo_element_range = std::ranges::subrange<calo_element_const_iterator>
using	calo_nonconst_element_const_iterator = calo_element_vec::const_iterator
using	calo_nonconst_element_range = std::ranges::subrange<calo_nonconst_element_const_iterator>
using	calo_descr_vec = std::vector <CaloDetDescriptor*>
using	calo_descr_size = calo_descr_vec::size_type
using	calo_descr_const_iterator = CaloConstIteratorAdaptor<calo_descr_vec::const_iterator>
using	calo_descr_range = std::ranges::subrange<calo_descr_const_iterator>
using	calo_nonconst_descr_const_iterator = calo_descr_vec::const_iterator
using	calo_nonconst_descr_range = std::ranges::subrange<calo_nonconst_descr_const_iterator>

Public Member Functions
const CaloCell_ID *	getCaloCell_ID () const
	get calo cell ID helper
void	set_helper (const CaloCell_ID *idHelper)
	set calo Cell ID helper
void	set_helper (const CaloIdManager *idHelper)
void	initialize ()
	initialization of the manager, used by the Converter when it creates the Manager
void	print () const
	print out the contents
bool	isInitialized () const
	for backwards compatibility only
const std::string &	lar_geometry () const
	get lar geometry label, distinguish between full atlas and TB
void	set_lar_geometry (const std::string &geom)
	set lar geometry label, distinguish between full atlas and TB
const CaloIdManager *	getCalo_Mgr () const
	get calo ID manager
calo_element_vec_size	element_size () const
	total number of elements
calo_element_const_iterator	element_begin () const
	first element
calo_element_const_iterator	element_begin (CaloCell_ID::SUBCALO subCalo) const
	first element in subcalo
calo_element_const_iterator	element_end () const
	end of element vector
calo_element_const_iterator	element_end (CaloCell_ID::SUBCALO subCalo) const
	end of subcalo element list
calo_element_range	element_range () const
	Range over element vector.
calo_element_range	element_range (CaloCell_ID::SUBCALO subCalo) const
	Range over subcalo element list.
calo_nonconst_element_range	element_range_nonconst ()
	Range over element vector, with non-const elements.
const CaloDetDescrElement *	get_element (const Identifier &cellId) const
	get element by its identifier
const CaloDetDescrElement *	get_element (IdentifierHash caloCellHash) const
	get element by hash identifier
const CaloDetDescrElement *	get_element (CaloCell_ID::SUBCALO subCalo, IdentifierHash subCaloCellHash) const
	get element by subcalo and hash identifier
const CaloDetDescrElement *	get_element (CaloCell_ID::SUBCALO subCalo, int sampling_or_module, bool barrel, double eta, double phi) const
	LAr only!
const CaloDetDescrElement *	get_element (CaloCell_ID::CaloSample sample, double eta, double phi) const
	LAr only!
CaloDetDescrElement *	get_element_nonconst (const Identifier &cellId)
	get element by its identifier, non-const version.
CaloDetDescrElement *	get_element_nonconst (IdentifierHash caloCellHash)
	get element by hash identifier, non-const version.
const CaloDetDescrElement *	get_element_raw (CaloCell_ID::CaloSample sample, double eta, double phi) const
	Get element from raw quantities (to build real fixed size clusters)
void	cellsInZone (double eta_min, double eta_max, double phi_min, double phi_max, std::vector< IdentifierHash > &cell_list) const
	the only client is CaloCellList class
void	cellsInZone (double eta_min, double eta_max, double phi_min, double phi_max, CaloCell_ID::SUBCALO subCalo, std::vector< IdentifierHash > &cell_list) const
	the only client is CaloCellList class
void	cellsInZone (double eta_min, double eta_max, double phi_min, double phi_max, CaloCell_ID::CaloSample sample, std::vector< IdentifierHash > &cell_list) const
	the only client is CaloCellList class
void	cellsInZone (double eta_min, double eta_max, double phi_min, double phi_max, CaloCell_ID::SUBCALO subCalo, int sampling_or_module, std::vector< IdentifierHash > &cell_list) const
	the only client is CaloCellList class
void	cellsInZone (double eta, double phi, int ncell_eta, int ncell_phi, CaloCell_ID::SUBCALO subCalo, int sampling_or_module, bool barrel, std::vector< IdentifierHash > &cell_list) const
	the only client is CaloCellList class
void	cellsInZone (double eta_min, double eta_max, double phi_min, double phi_max, const CaloDetDescriptor *descr, std::vector< IdentifierHash > &cell_list) const
	the only client is CaloCellList class
bool	is_in (double eta, double phi, CaloCell_ID::CaloSample sample, double &etadist) const
	return true if direction eta,phi crosses ANY of the corresponding descriptors
calo_descr_const_iterator	calo_descriptors_begin () const
	first descriptor in the vector
calo_descr_const_iterator	calo_descriptors_end () const
	end of descriptors vector
calo_descr_size	calo_descriptors_size () const
	number of descriptors
calo_descr_range	calo_descriptors_range () const
	Range over descriptors.
calo_nonconst_descr_range	calo_descriptors_range_nonconst ()
	Range over descriptors, with non-const elements.
const CaloDetDescriptor *	get_descriptor (const Identifier &regionId) const
	get descriptor by region identifier
const CaloDetDescriptor *	get_descriptor (CaloCell_ID::SUBCALO subCalo, int sampling_or_module, bool barrel, double eta, double phi) const
	get descriptor by subcalo, sampling, barrel flag, eta, phi
const CaloDetDescriptor *	get_descriptor (CaloCell_ID::CaloSample sample, double eta, double phi) const
	get descriptor by sample, eta and phi
CaloDetDescriptor *	get_descriptor_nonconst (const Identifier &regionId)
	get descriptor by region identifier, non-const version.
const CaloDetDescriptor *	get_descriptor_raw (CaloCell_ID::CaloSample sample, double eta, double phi) const
	get descriptor by sample, eta and phi raw
calo_descr_const_iterator	tile_descriptors_begin () const
	first tile descriptor (they are in separate vector)
calo_descr_const_iterator	tile_descriptors_end () const
	end of tile descriptors vector
calo_descr_size	tile_descriptors_size () const
	number of tile descriptors
calo_descr_range	tile_descriptors_range () const
	Range over tile descriptors.
calo_nonconst_descr_range	tile_descriptors_range_nonconst ()
	Range over tile descriptors, with non-const elements.
void	set_helper (const CaloCell_Base_ID *idHelper)
	set calo Cell ID helper
void	add (CaloDetDescrElement *element)
	add Calo DD element to the elements vector
void	add (CaloDetDescriptor *descr)
	add new LAr descriptor to the descriptors vector Takes ownership of the object.
void	add (std::unique_ptr< CaloDetDescriptor > descr)
	add new LAr descriptor to the descriptors vector
void	add_tile (CaloDetDescriptor *descr)
	add tile descriptor to the tile descriptors vector

Static Public Member Functions
static void	build_sample (CaloCell_ID::SUBCALO subCalo, bool barrel, int sampling_or_module, CaloCell_ID::CaloSample &sample)
	translate between the 2 ways to label a sub-detector:
static void	decode_sample (CaloCell_ID::SUBCALO &subCalo, bool &barrel, int &sampling_or_module, CaloCell_ID::CaloSample sample)
	translate between the 2 ways to label a sub-detector:

Private Member Functions
CaloDetDescrElement *	release_element (IdentifierHash hash)
const CaloDetDescrElement *	get_element_FCAL (const CaloDetDescriptor *reg, double eta, double phi) const
	LArFCAl private methode to get element.
const CaloDetDescrElement *	get_element_FCAL_raw (const CaloDetDescriptor *reg, double eta, double phi) const
	LArFCAl private methode to get element from raw eta,phi.

Private Attributes
const CaloCell_Base_ID *	m_cell_id
	Calo Cell ID helper.
const CaloIdManager *	m_calo_mgr
	Calo ID Manager helper.
calo_element_vec	m_element_vec
	vector of Calo DD elements
calo_descr_vec	m_descr_vec
	vector of descriptors
std::vector< IdentifierHash >	m_subCalo_min
	offsets for subcalo's elements
std::vector< IdentifierHash >	m_subCalo_max
	offsets for subcalo's elements
std::vector< calo_element_const_iterator >	m_subCalo_begin
	offsets for subcalo's elements
std::vector< calo_element_const_iterator >	m_subCalo_end
	offsets for subcalo's elements
calo_descr_vec	m_tile_descr_vec
	vector of descriptors
std::string	m_lar_geometry
	LAr geometry label (full atlas/TB) for backwards compatibility.

Detailed Description

This class provides the client interface for accessing the detector description information common to LAr and Tile.

It is used in the Calorimeter reconstruction (from CaloCell building down to combined reconstruction)

For subdetector specific functionality one should use special managers 4 for LAr (in LArReadoutgeometry package) and one for Tile (in TileDetDescr package), essentially upstream of CaloCell building.

MAJOR FUNCTIONALITIES :

1) 2 enums and 3 coordinate systems :

For historical reasons, there are 2 ways to label a piece of the Calorimeter: the CaloCell_ID::CaloSample enum is by far the recommended one. The methods CaloDetDescrManager::build_sample and CaloDetDescrManager::decode_sample provide the translation.

The CaloCell_ID::SUBCALO subCalo + bool barrel + int sampling_or_module combination is meaningless for Tiles, but used in many places in the LAr code, so was kept for backward compatibility. The boolean "barrel" is needed because there is an emb/emec ambiguity (in the enum definition) and eta overlap: if true, will search EMB/TILES, if false will search EMEC/HEC/FCAL.

Also note the different coordinates : in EMB people generally use "eta, phi, radius", in EMEC/HEC people generally use "eta, phi, Z", in Tiles/FCAL people generally use cartesian coordinates. To avoid confusion, the coordinate system used is explicit in all methods signature.

2) Access to the "big" array of CaloDetDescrElement :

These are stored internally according to the IdentifierHash caloCellHash. All navigation/convertion between the this complete hash and the subcalo (em/hec/fcal/tile) are provided by the CaloCell_ID helper.

3) Methods cellsInZone :

Given a zone in eta/phi, a sub detector and a sampling (or module for FCAL), these methods return the list of CALO IdentifierHash. In case of failiure, the vector will be empty.

WARNING : eta_min and eta_max can have NEGATIVE values and are not abs() (in contrast to CaloDescriptors, where eta() is always positive and has to be multiplied by sign() )

WARNING: For the FCAL this involves a loop over all the Fcal cells, so this is a little bit slower if Fcal layers are required

4) Given an eta/phi and a sampling or a depth, where-am-I ?

These method return CaloDetDescrElement* (to get, e.g., cell size), or return the entrance into the calorimeter (r or z, for barrel or endcap).

WARNING : if eta/phi is outside the Calo range, or no Element or descriptor is found for some reason, returns a NULL pointer or a radius=0 !

WARNING : the methods get_barrel_element and get_ec_element only work in the barrel/endcap regions.

5) Methods is_in :

Obviously, will return true if direction eta,phi crosses ANY of the corresponding descriptors

6) Methods get_entrance and get_surface (needed for TrackToCalo):

Trk::Surfaces are not built by the CaloDetDescrManager to avoid any dependency from Calorimeter onto Tracking : this is done in the Reconstruction/RecoTools/TrackToCalo package. But this class provides the surface parameters

By convention, for each CaloSample the radius/z correspond to the entrance of the sampling, and are "flat" in the sense that there is no eta dependance. This is valid for PS, Strips, HEC, FCAL and Tiles, but not for EMB2,EMB3,EMEC2,EMEC3

Clients who want a more precise (and eta dependant) entrance radius can overwrite the default one by the result of the methods get_entrance_radius/get_entrance_z .

Clients who want to add an offset, use the middle rather than entrace or use a parametrised depth are invited to use the CaloDepthTool, which is in Reconstruction/RecoTool/TrackToCalo

7) Access to the CaloDetDescriptors :

In LAr, there is 1 CaloDetDescriptor per region of homogeneus granularity. Their primary goal if to speedup loops by grouping cells within regions, and save spave by caching what they have in common. You may need to access them to get, for example, the grannularity.

Definition at line 467 of file CaloDetDescrManager.h.

Member Typedef Documentation

calo_descr_const_iterator

using CaloDetDescrManager_Base::calo_descr_const_iterator = CaloConstIteratorAdaptor<calo_descr_vec::const_iterator>

inherited

Definition at line 320 of file CaloDetDescrManager.h.

calo_descr_range

using CaloDetDescrManager_Base::calo_descr_range = std::ranges::subrange<calo_descr_const_iterator>

inherited

Definition at line 321 of file CaloDetDescrManager.h.

calo_descr_size

using CaloDetDescrManager_Base::calo_descr_size = calo_descr_vec::size_type

inherited

Definition at line 319 of file CaloDetDescrManager.h.

calo_descr_vec

using CaloDetDescrManager_Base::calo_descr_vec = std::vector <CaloDetDescriptor*>

inherited

Definition at line 318 of file CaloDetDescrManager.h.

calo_element_const_iterator

using CaloDetDescrManager_Base::calo_element_const_iterator = CaloConstIteratorAdaptor<calo_element_vec::const_iterator>

inherited

Definition at line 182 of file CaloDetDescrManager.h.

calo_element_range

using CaloDetDescrManager_Base::calo_element_range = std::ranges::subrange<calo_element_const_iterator>

inherited

Definition at line 183 of file CaloDetDescrManager.h.

calo_element_vec

using CaloDetDescrManager_Base::calo_element_vec = std::vector<CaloDetDescrElement*>

inherited

Definition at line 180 of file CaloDetDescrManager.h.

calo_element_vec_size

using CaloDetDescrManager_Base::calo_element_vec_size = calo_element_vec::size_type

inherited

Definition at line 181 of file CaloDetDescrManager.h.

calo_nonconst_descr_const_iterator

using CaloDetDescrManager_Base::calo_nonconst_descr_const_iterator = calo_descr_vec::const_iterator

inherited

Definition at line 325 of file CaloDetDescrManager.h.

calo_nonconst_descr_range

using CaloDetDescrManager_Base::calo_nonconst_descr_range = std::ranges::subrange<calo_nonconst_descr_const_iterator>

inherited

Definition at line 326 of file CaloDetDescrManager.h.

calo_nonconst_element_const_iterator

using CaloDetDescrManager_Base::calo_nonconst_element_const_iterator = calo_element_vec::const_iterator

inherited

Definition at line 186 of file CaloDetDescrManager.h.

calo_nonconst_element_range

using CaloDetDescrManager_Base::calo_nonconst_element_range = std::ranges::subrange<calo_nonconst_element_const_iterator>

inherited

Definition at line 187 of file CaloDetDescrManager.h.

Member Function Documentation

add() [1/3]

void CaloDetDescrManager_Base::add ( CaloDetDescrElement * element )

inherited

add Calo DD element to the elements vector

Definition at line 755 of file CaloDetDescrManager.cxx.

{
  m_element_vec[element->calo_hash()] = element;
}

add() [2/3]

void CaloDetDescrManager_Base::add ( CaloDetDescriptor * descr )

inherited

add new LAr descriptor to the descriptors vector Takes ownership of the object.

For new code, prefer the next version that takes a unique_ptr.

Definition at line 760 of file CaloDetDescrManager.cxx.

{
    m_descr_vec[descr->calo_hash()] = descr;
}

add() [3/3]

void CaloDetDescrManager_Base::add ( std::unique_ptr< CaloDetDescriptor > descr )

inherited

add new LAr descriptor to the descriptors vector

Definition at line 765 of file CaloDetDescrManager.cxx.

{
    IdentifierHash idhash = descr->calo_hash();
    m_descr_vec[idhash] = descr.release();
}

add_tile()

void CaloDetDescrManager_Base::add_tile ( CaloDetDescriptor * descr )

inherited

add tile descriptor to the tile descriptors vector

Definition at line 771 of file CaloDetDescrManager.cxx.

{
  m_tile_descr_vec.push_back(descr);
}

build_sample()

void CaloDetDescrManager_Base::build_sample ( CaloCell_ID::SUBCALO subCalo, bool barrel, int sampling_or_module, CaloCell_ID::CaloSample & sample )

staticinherited

translate between the 2 ways to label a sub-detector:

Definition at line 1425 of file CaloDetDescrManager.cxx.

{
  if ( subCalo == CaloCell_ID::LAREM ) {
    if ( barrel ) {
      if (sampling_or_module == 0) sample = CaloCell_ID::PreSamplerB;
      if (sampling_or_module == 1) sample = CaloCell_ID::EMB1;
      if (sampling_or_module == 2) sample = CaloCell_ID::EMB2;
      if (sampling_or_module == 3) sample = CaloCell_ID::EMB3;
    } else {
      if (sampling_or_module == 0) sample = CaloCell_ID::PreSamplerE;
      if (sampling_or_module == 1) sample = CaloCell_ID::EME1;
      if (sampling_or_module == 2) sample = CaloCell_ID::EME2;
      if (sampling_or_module == 3) sample = CaloCell_ID::EME3;
    }
    return;
  }
  else if  ( subCalo == CaloCell_ID::LARHEC ) {
    if (sampling_or_module == 0) sample = CaloCell_ID::HEC0;
    if (sampling_or_module == 1) sample = CaloCell_ID::HEC1;
    if (sampling_or_module == 2) sample = CaloCell_ID::HEC2;
    if (sampling_or_module == 3) sample = CaloCell_ID::HEC3;
  }
  else if  ( subCalo == CaloCell_ID::LARFCAL ) {
    if (sampling_or_module == 0) sample = CaloCell_ID::FCAL0;
    if (sampling_or_module == 1) sample = CaloCell_ID::FCAL1;
    if (sampling_or_module == 2) sample = CaloCell_ID::FCAL2;
  }
  else if  ( subCalo == CaloCell_ID::TILE ) {
    // For Tiles sampling_or_module has a different meaning :
    // assume the client meant the entrance of the Tiles and ignore the gap
    if ( barrel )
      sample = CaloCell_ID::TileBar0;
    else
      sample = CaloCell_ID::TileExt0;
  }
  else
    sample = CaloCell_ID::Unknown;
 
}

calo_descriptors_begin()

CaloDetDescrManager_Base::calo_descr_const_iterator CaloDetDescrManager_Base::calo_descriptors_begin ( ) const

inherited

first descriptor in the vector

Definition at line 517 of file CaloDetDescrManager.cxx.

{
  return m_descr_vec.begin();
}

calo_descriptors_end()

CaloDetDescrManager_Base::calo_descr_const_iterator CaloDetDescrManager_Base::calo_descriptors_end ( ) const

inherited

end of descriptors vector

Definition at line 523 of file CaloDetDescrManager.cxx.

{
  return m_descr_vec.end();
}

calo_descriptors_range()

CaloDetDescrManager_Base::calo_descr_range CaloDetDescrManager_Base::calo_descriptors_range ( ) const

inherited

Range over descriptors.

Definition at line 535 of file CaloDetDescrManager.cxx.

{
  return {m_descr_vec.begin(), m_descr_vec.end()};
}

calo_descriptors_range_nonconst()

CaloDetDescrManager_Base::calo_nonconst_descr_range CaloDetDescrManager_Base::calo_descriptors_range_nonconst ( )

inherited

Range over descriptors, with non-const elements.

Definition at line 541 of file CaloDetDescrManager.cxx.

{
  return {m_descr_vec.begin(), m_descr_vec.end()};
}

calo_descriptors_size()

CaloDetDescrManager_Base::calo_descr_size CaloDetDescrManager_Base::calo_descriptors_size ( ) const

inherited

number of descriptors

Definition at line 529 of file CaloDetDescrManager.cxx.

{
  return m_descr_vec.size();
}

cellsInZone() [1/6]

void CaloDetDescrManager_Base::cellsInZone ( double eta, double phi, int ncell_eta, int ncell_phi, CaloCell_ID::SUBCALO subCalo, int sampling_or_module, bool barrel, std::vector< IdentifierHash > & cell_list ) const

inherited

the only client is CaloCellList class

Definition at line 979 of file CaloDetDescrManager.cxx.

{
 
  cell_list.clear();
  double eta_min, eta_max, phi_min, phi_max;
  double weta = (ncell_eta-1)/2.;
  double wphi = (ncell_phi-1)/2.;
 
  std::vector<IdentifierHash> one_list;
 
  if ( subCalo != CaloCell_ID::TILE ) {
 
    for ( unsigned int i=0; i<m_descr_vec.size(); i++ ) {
      const CaloDetDescriptor* reg = m_descr_vec[i];
      if ( reg ) {
        Identifier regId = reg->identify();
        if ( subCalo == reg->getSubCalo() &&
             m_cell_id->sampling(regId) == sampling_or_module) {
 
          double eta_gran = m_cell_id->etaGranularity(regId);
          double phi_gran = m_cell_id->phiGranularity(regId);
 
          eta_min = eta-weta*eta_gran;
          eta_max = eta+weta*eta_gran;
          phi_min = phi-wphi*phi_gran;
          phi_max = phi+wphi*phi_gran;
          cellsInZone(eta_min, eta_max, phi_min, phi_max, reg, one_list);
          cell_list.reserve (cell_list.size() + one_list.size());
          for ( unsigned int i = 0; i<one_list.size(); i++ ){
            // I know that cellsInZone catches more cells than needed
            // => look and cut
            const CaloDetDescrElement* elt = get_element (one_list[i]);
            double elt_eta = elt->eta();
            double elt_phi = elt->phi();
            if ( barrel == elt->is_lar_em_barrel() )
              if ( std::abs(eta - elt_eta) <= weta )
                if ( std::abs(phi - elt_phi) <= wphi )
                  cell_list.push_back(one_list[i]);
          }
        }
      }
    }
  }
  else {
 
    // For Tiles loop on elements :
    // loosy logic. since I do not know the grannularity in the
    // region, I use the one of each element. Hum...
    const CaloDetDescrElement* tile_elt;
    for ( unsigned int i = m_subCalo_min[subCalo];
          i < m_subCalo_max[subCalo]; i++ ) {
      tile_elt = m_element_vec[i];
      if (tile_elt) {
        eta_min = eta-weta*tile_elt->deta();
        eta_max = eta+weta*tile_elt->deta();
 
        if ( tile_elt->eta()+tile_elt->deta()/2. > eta_min &&
           tile_elt->eta()-tile_elt->deta()/2. < eta_max) {
          phi_min = phi-wphi*tile_elt->dphi();
          phi_max = phi+wphi*tile_elt->dphi();
          double dphi1 = CaloPhiRange::diff(tile_elt->phi()+tile_elt->dphi()/2.,phi_min);
          double dphi2 = CaloPhiRange::diff(phi_max,tile_elt->phi()-tile_elt->dphi()/2);
 
          if(dphi1 >=0. && dphi2 >= 0. ) {
        if (cell_list.empty()) {
          // Guess a good size, incl 3 samplings.
          cell_list.reserve (static_cast<int> (
                               ((eta_max-eta_min) / tile_elt->deta()) *
                               ((phi_max-phi_min) / tile_elt->dphi()) * 3));
        }
        cell_list.push_back(tile_elt->calo_hash());
      }   // phi cut
        }     // eta cut
      }       // tile elt exisits
    }
  }
 
}

cellsInZone() [2/6]

void CaloDetDescrManager_Base::cellsInZone ( double eta_min, double eta_max, double phi_min, double phi_max, CaloCell_ID::CaloSample sample, std::vector< IdentifierHash > & cell_list ) const

inherited

the only client is CaloCellList class

Definition at line 877 of file CaloDetDescrManager.cxx.

{
  cell_list.clear();
  if ( eta_min >= eta_max ) return;
  if ( phi_min >= phi_max ) return;
 
  std::vector<IdentifierHash> one_list;
 
  if ( sample != CaloCell_ID::TileBar0 &&
       sample != CaloCell_ID::TileBar1 &&
       sample != CaloCell_ID::TileBar2 &&
       sample != CaloCell_ID::TileGap1 &&
       sample != CaloCell_ID::TileGap2 &&
       sample != CaloCell_ID::TileGap3 &&
       sample != CaloCell_ID::TileExt0 &&
       sample != CaloCell_ID::TileExt1 &&
       sample != CaloCell_ID::TileExt2    ) {
 
    for ( unsigned int i=0; i<m_descr_vec.size(); i++ ) {
      const CaloDetDescriptor* reg = m_descr_vec[i];
      if ( reg )
        // this works only for LAr, for Tiles the sampling depends on the
        // cell
        if ( sample == reg->getSampling(0) ) {
          cellsInZone(eta_min, eta_max, phi_min, phi_max, reg, one_list);
          if (cell_list.empty())
            cell_list.swap (one_list);
          else
            cell_list.insert (cell_list.end(),
                              one_list.begin(), one_list.end());
        }
    }
 
  } else {
 
    // For Tiles loop on elements :
    int nb = CaloCell_ID::TILE;
    const CaloDetDescrElement* tile_elt;
 
    for ( unsigned int i = m_subCalo_min[nb]; i < m_subCalo_max[nb]; i++ ) {
      tile_elt = m_element_vec[i];
      if (tile_elt ){
        if (tile_elt->getSampling() == sample) {
 
          if ( tile_elt->eta()+tile_elt->deta()/2. > eta_min &&
               tile_elt->eta()-tile_elt->deta()/2. < eta_max) {
 
            double dphi1 = CaloPhiRange::diff(tile_elt->phi()+tile_elt->dphi()/2.,phi_min);
            double dphi2 = CaloPhiRange::diff(phi_max,tile_elt->phi()-tile_elt->dphi()/2);
 
            if(dphi1 >=0.  && dphi2 >= 0.)  {
               if (cell_list.empty()) {
               // Guess a good size, incl 3 samplings.
               cell_list.reserve (static_cast<int>(
                                ((eta_max-eta_min) / tile_elt->deta()) *
                                ((phi_max-phi_min) / tile_elt->dphi()) * 3));
               }       
               cell_list.push_back(tile_elt->calo_hash());
            }  // phi cut
          }    // eta cut
        }      // sampling cut
      }      // tile_elt exists
    }
  }
}

cellsInZone() [3/6]

void CaloDetDescrManager_Base::cellsInZone ( double eta_min, double eta_max, double phi_min, double phi_max, CaloCell_ID::SUBCALO subCalo, int sampling_or_module, std::vector< IdentifierHash > & cell_list ) const

inherited

the only client is CaloCellList class

Definition at line 946 of file CaloDetDescrManager.cxx.

{
  cell_list.clear();
  if ( eta_min >= eta_max ) return;
  if ( phi_min >= phi_max ) return;
 
  // sampling_or_module has no meaning for tiles
  if ( subCalo == CaloCell_ID::TILE ) return;
 
  std::vector<IdentifierHash> one_list;
 
  for ( unsigned int i=0; i<m_descr_vec.size(); i++ ) {
    const CaloDetDescriptor* reg = m_descr_vec[i];
    if ( reg ) {
      Identifier regId = reg->identify();
      if ( subCalo == reg->getSubCalo() &&
           m_cell_id->sampling(regId) == sampling_or_module ) {
        cellsInZone(eta_min, eta_max, phi_min, phi_max, reg, one_list);
        if (cell_list.empty())
          cell_list.swap (one_list);
        else
          cell_list.insert (cell_list.end(),
                            one_list.begin(), one_list.end());
      }
    }
  }
}

cellsInZone() [4/6]

void CaloDetDescrManager_Base::cellsInZone ( double eta_min, double eta_max, double phi_min, double phi_max, CaloCell_ID::SUBCALO subCalo, std::vector< IdentifierHash > & cell_list ) const

inherited

the only client is CaloCellList class

Definition at line 820 of file CaloDetDescrManager.cxx.

{
  cell_list.clear();
  if ( eta_min >= eta_max ) return;
  if ( phi_min >= phi_max ) return;
 
  std::vector<IdentifierHash> one_list;
 
 
  if ( subCalo != CaloCell_ID::TILE ) {
 
    for ( unsigned int i=0; i<m_descr_vec.size(); i++ ) {
      const CaloDetDescriptor* reg = m_descr_vec[i];
      if ( reg )
        if ( subCalo == reg->getSubCalo() ) {
          cellsInZone(eta_min, eta_max, phi_min, phi_max, reg, one_list);
          if (cell_list.empty())
            cell_list.swap (one_list);
          else
            cell_list.insert (cell_list.end(),
                              one_list.begin(), one_list.end());
        }
    }
 
  } else {
 
    // For Tiles loop on elements :
    const CaloDetDescrElement* tile_elt;
    for ( unsigned int i = m_subCalo_min[subCalo];
          i < m_subCalo_max[subCalo]; i++ ) {
      tile_elt = m_element_vec[i];
      if (tile_elt) {
 
        if ( tile_elt->eta()+tile_elt->deta()/2. > eta_min &&
             tile_elt->eta()-tile_elt->deta()/2. < eta_max) {
 
          double dphi1 = CaloPhiRange::diff(tile_elt->phi()+tile_elt->dphi()/2.,phi_min);
          double dphi2 = CaloPhiRange::diff(phi_max,tile_elt->phi()-tile_elt->dphi()/2);
 
          if(dphi1 >=0.  && dphi2 >= 0.)  {
         if (cell_list.empty()) {
         // Guess a good size, incl 3 samplings.
         cell_list.reserve (static_cast<int>(
                              ((eta_max-eta_min) / tile_elt->deta()) *
                              ((phi_max-phi_min) / tile_elt->dphi()) * 3));
         }
         cell_list.push_back(tile_elt->calo_hash());
      }  // phi cut
        }    // eta cut
      }      // tile_elt exits
    }
  }
}

cellsInZone() [5/6]

void CaloDetDescrManager_Base::cellsInZone ( double eta_min, double eta_max, double phi_min, double phi_max, const CaloDetDescriptor * descr, std::vector< IdentifierHash > & cell_list ) const

inherited

the only client is CaloCellList class

Definition at line 1062 of file CaloDetDescrManager.cxx.

{
 
  cell_list.clear();
 
  if ( ! descr ) return;
  if ( eta_min >= eta_max ) return;
 
// FCAL case : explicit loop over all cells to account for the fact that eta and phi are not independent
 
  if (descr->is_lar_fcal()) {
     //   std::cout << " in FCAl case  descr etamin/max " << descr->reg_min() << " " << descr->reg_max() <<
     //    "   zone etamin/max " << eta_min << " " << eta_max << std::endl;
      if (descr->reg_min() > eta_max ||  descr->reg_max() < eta_min) return;
      Identifier regId = descr->identify();
      Identifier cellId;
      IdentifierHash caloCellHash;
      const CaloDetDescrElement* elt;
      IdentifierHash prevHash(0);
      // std::cout <<"    neta,nphi " << descr->n_eta() << " " << descr->n_phi() << std::endl;
      for (int ieta=0; ieta<descr->n_eta(); ieta++) {
         for (int iphi=0; iphi<descr->n_phi(); iphi++) {
           cellId = m_cell_id->cell_id(regId, ieta, iphi);
           caloCellHash = m_cell_id->calo_cell_hash(cellId);
           // this is required because otherwise caloCellHash of unconnected channels with be the same as some connected channels (
           if (caloCellHash != prevHash) {
             prevHash=caloCellHash;
             elt = get_element (caloCellHash);
             if (elt) {
                if ( elt->eta()+elt->deta()/2. > eta_min &&
                     elt->eta()-elt->deta()/2. < eta_max) {
 
                   double dphi1 = CaloPhiRange::diff(elt->phi()+elt->dphi()/2.,phi_min);
                   double dphi2 = CaloPhiRange::diff(phi_max,elt->phi()-elt->dphi()/2);
 
                   if(dphi1 >=0.  && dphi2 >= 0.)  {
                     cell_list.push_back(caloCellHash);
                     //std::cout << " elt in ! eta= " << elt->eta() << " phi= " << elt->phi()  << " " << ieta << " " << iphi << "hash Id " << caloCellHash << " id " << cellId << std::endl;
                   }  // phi cut
                }    // eta cut
             }       // if(elt)
             //else {
             //   std::cout << " no FCAL elt for this cell " << ieta << " " << iphi << " " << cellId << " " << caloCellHash << std::endl;
             // }
           } 
         }    // loop over iphi
      }       // loop over iea
  }
 
// everything but FCAL
  else {
    if ( ! descr->is_in(eta_min,eta_max,phi_min,phi_max)) return;
 
    double zone_min = eta_min;
    double zone_max = eta_max;
    int ieta_min = 0;
    int ieta_max = 0;
 
    // loop will start at ieta_min-1 (included) and finish at ieta_max+1 (included)
    // ==> be careful at the edges of the descriptor.
    // check on which side we are ( for eta<0 channel ordering is swapped )
    if ( descr->calo_sign() > 0 ) {
 
      if ( descr->reg_min() >= zone_min ){
        zone_min = descr->reg_min();
        ieta_min = 1;
        //std::cout << " POS ! setting zone_min to reg_min = " << zone_min << " and ieta_min to " << ieta_min << std::endl;
      }
      else {
        ieta_min = descr->eta_channel(zone_min);
        if (ieta_min < 0)
          ieta_min = 1;
      }
 
      if ( descr->reg_max() <= zone_max ) {
        zone_max = descr->reg_max();
        ieta_max = descr->n_eta() -1;
        //std::cout << " POS ! setting zone_max to reg_max = " << zone_max << " and ieta_max to " << ieta_max << std::endl;
      }
      else {
        ieta_max = descr->eta_channel(zone_max);
        if (ieta_max < 1)
          ieta_max = descr->n_eta() - 1;
      }
 
    }
    else {
 
      if ( descr->reg_min() >= zone_min ){
        zone_min = descr->reg_min();
        ieta_max = descr->n_eta() - 1;
        //std::cout << " NEG ! setting zone_min to reg_min = " << zone_min << " and ieta_max to " << ieta_max << std::endl;
      }
      else {
        ieta_max = descr->eta_channel(zone_min);
        if (ieta_max < 1)
          ieta_max = descr->n_eta() - 1;
      }
 
      if ( descr->reg_max() <= zone_max ) {
        zone_max = descr->reg_max();
        ieta_min = 1 ;
        //std::cout << " NEG ! setting zone_max to reg_max = " << zone_max << " and ieta_min to " << ieta_min << std::endl;
      }
      else {
        ieta_min = descr->eta_channel(zone_max - 0.0001);
        if (ieta_min < 0)
          ieta_min = 1;
      }
 
    }
 
 
  // phi :
 
  // for a full detector, the window limits cannot be outside... BUT :
  //      for zones where phi_min is < 0 and phi_max > 0  ( around 0 ),
  //      or phi_max is < 0 ( around M_PI )
  //      the channel number iphi_min is larger than iphi_max and
  //      the search will have to be done in 2 steps.
 
  // for a subset ( H8 or H6 testbeams ), if the window is larger than the
  //      module the min/max channel numbers will be -1 => mess in loops
  //      ==> reduce the window size to the module size
 
 
    double zone_phi_min = CaloPhiRange::fix (phi_min);
    double zone_phi_max = CaloPhiRange::fix (phi_max);
 
    //    *** *** *** TEST BEAM!!! *** *** ***
    if (m_lar_geometry == "H8" || m_lar_geometry == "H6") {
      double margin = descr->dphi()*0.1;
 
      // FIXME : ideal values are used here, this should NOT be !!!!
 
      if ( descr->calo_phi_min() > zone_phi_min) zone_phi_min = descr->calo_phi_min() + margin;
      if ( descr->calo_phi_max() < zone_phi_max) zone_phi_max = descr->calo_phi_max() - margin;
    }
 
    int iphi_min = descr->phi_channel(zone_phi_min);
    int iphi_max = descr->phi_channel(zone_phi_max);
 
// add more safety in case of strips to protect against misalignment
    int reg_sampl=descr->getSampling(0);
    if (reg_sampl == CaloCell_ID::EMB1 || reg_sampl == CaloCell_ID::EME1) {
       ieta_min = ieta_min -1;
       ieta_max = ieta_max +1;
    }
 
 
    Identifier regId = descr->identify();
    Identifier cellId;
    IdentifierHash caloCellHash;
    const CaloDetDescrElement* elt;
 
  
    /* 
    std::cout << " cellsInZone : eta ! reg " << descr->reg_min() << " " << descr->reg_max()
              << " zone " << zone_min << " " << zone_max
              << " channels " << ieta_min << " " << ieta_max << std::endl;
 
    std::cout << " cellsInZone : phi ! reg " << descr->calo_phi_min() << " " << descr->calo_phi_max()
              << " zone " << zone_phi_min << " " << zone_phi_max
              << " channels " << iphi_min << " " << iphi_max << std::endl;
    */
   
 
    int reg_EtaMin = m_cell_id->eta_min (regId);
    int reg_EtaMax = m_cell_id->eta_max (regId);
    int reg_PhiMin = m_cell_id->phi_min (regId);
    if (reg_PhiMin<0) reg_PhiMin=0;      // catch case where it is not defined for Tile
    int reg_PhiMax = m_cell_id->phi_max (regId);
  
 
    if ( iphi_min <= iphi_max && zone_phi_min <= zone_phi_max ) {
 
      // The easy case : just make list a bit larger to avoid rounding effects
 
      for ( int ieta = ieta_min-1 ; ieta <= ieta_max+1; ieta++ )
        for ( int iphi = iphi_min-1 ; iphi <= iphi_max+1; iphi++ )
          {
            if (ieta>=reg_EtaMin && ieta <=reg_EtaMax && iphi>=reg_PhiMin && iphi<=reg_PhiMax) {
              cellId = m_cell_id->cell_id(regId, ieta, iphi);
              caloCellHash = m_cell_id->calo_cell_hash(cellId);
              elt = get_element (caloCellHash);
              //std::cout << " case 1 : for ieta = " << ieta << "  iphi = " << iphi << std::endl;
              if (elt
                && ( (elt->eta()+elt->deta()/2.) > zone_min + 0.00001 )
                && ( (elt->eta()-elt->deta()/2.) + 0.00001 < zone_max )
                && ( (elt->phi()+elt->dphi()/2.) > zone_phi_min + 0.00001  )
                && ( (elt->phi()-elt->dphi()/2.) + 0.00001 < zone_phi_max  )  )
              {
                cell_list.push_back(caloCellHash);
                //std::cout << " elt in ! eta= " << elt->eta() << " phi= " << elt->phi() << " " << ieta << " " << iphi << std::endl;
              }
              //else
                //std::cout << " elt out ! eta= " << elt->eta() << " phi= " << elt->phi() << std::endl;
            }
          }
    }
    else if ( iphi_min <= iphi_max && zone_phi_min > zone_phi_max ) {
 
      // we are around the -M_PI -> +M_PI discontinuity  , no zone_phi_max cut
 
      for ( int ieta = ieta_min-1 ; ieta <= ieta_max+1; ieta++ )
        for ( int iphi = iphi_min-1 ; iphi <= iphi_max+1; iphi++ )
          {
            if (ieta>=reg_EtaMin && ieta <=reg_EtaMax && iphi>=reg_PhiMin && iphi<=reg_PhiMax) {
              cellId = m_cell_id->cell_id(regId, ieta, iphi);
              caloCellHash = m_cell_id->calo_cell_hash(cellId);
              elt = get_element (caloCellHash);
              //std::cout << " case 2 : for ieta = " << ieta << "  iphi = " << iphi << std::endl;
              if (elt
                && ( (elt->eta()+elt->deta()/2.) > zone_min + 0.00001 )
                && ( (elt->eta()-elt->deta()/2.) + 0.00001 < zone_max )
                && ( ( (elt->phi()+elt->dphi()/2.) > zone_phi_min + 0.00001 )
                     || ( (elt->phi()-elt->dphi()/2.) + 0.00001 < zone_phi_max ) )
                )
              {
                cell_list.push_back(caloCellHash);
                //std::cout << " elt in ! eta= " << elt->eta() << " phi= " << elt->phi()  << " " << ieta << " " << iphi << std::endl;
              }
              //else
                //std::cout << " elt out ! eta= " << elt->eta() << " phi= " << elt->phi() << std::endl;
            }
          }
    }
    else {
 
      // iphi_min > iphi_max => we are around phi = 0
 
      int nchmax = m_cell_id->phi_max(regId);
      // number of cells = nchmax + 1 ==> 0 to nchmax included
 
      for ( int ieta = ieta_min-1 ; ieta <= ieta_max+1; ieta++ ) {
 
        // first cells from min up to 2*M_PI
        for ( int iphi = iphi_min-1 ; iphi <= nchmax; iphi++ )
          {
            if (ieta>=reg_EtaMin && ieta <=reg_EtaMax && iphi>=reg_PhiMin && iphi<=reg_PhiMax) {
              cellId = m_cell_id->cell_id(regId, ieta, iphi);
              caloCellHash = m_cell_id->calo_cell_hash(cellId);
              elt = get_element (caloCellHash);
              //std::cout << " case 3 : for ieta = " << ieta << "  iphi = " << iphi << std::endl;
              if (elt
                && ( (elt->eta()+elt->deta()/2.) > zone_min + 0.00001 )
                && ( (elt->eta()-elt->deta()/2.) + 0.00001 < zone_max )
                && ( (elt->phi()+elt->dphi()/2.) > zone_phi_min + 0.00001  )
                && ( (elt->phi()-elt->dphi()/2.) + 0.00001 < zone_phi_max  )  )
              {
                 cell_list.push_back(caloCellHash);
                //std::cout << " elt in ! eta= " << elt->eta() << " phi= " << elt->phi()  << " " << ieta << " " << iphi << std::endl;
              }
              //else
              //std::cout << " elt out ! eta= " << elt->eta() << " phi= " << elt->phi() << std::endl;
            }
          }
        // now cells from 0 to min
        for ( int iphi = 0 ; iphi <= iphi_max+1; iphi++ )
          {
            if (ieta>=reg_EtaMin && ieta <=reg_EtaMax && iphi>=reg_PhiMin && iphi<=reg_PhiMax) {
              cellId = m_cell_id->cell_id(regId, ieta, iphi);
              caloCellHash = m_cell_id->calo_cell_hash(cellId);
              elt = get_element (caloCellHash);
              //std::cout << " case 4 : for ieta = " << ieta << "  iphi = " << iphi << std::endl;
              if (elt
                && ( (elt->eta()+elt->deta()/2.) > zone_min + 0.00001 )
                && ( (elt->eta()-elt->deta()/2.) + 0.00001 < zone_max )
                && ( (elt->phi()+elt->dphi()/2.) > zone_phi_min + 0.00001  )
                && ( (elt->phi()-elt->dphi()/2.) + 0.00001 < zone_phi_max  )  )
              {
                cell_list.push_back(caloCellHash);
                //std::cout << " elt in ! eta= " << elt->eta() << " phi= " << elt->phi()  << " " << ieta << " " << iphi << std::endl;
              }
              //else
              //std::cout << " elt out ! eta= " << elt->eta() << " phi= " << elt->phi() << std::endl;
            }
          }
      }
    }
  }    // if else FCAL
}

cellsInZone() [6/6]

void CaloDetDescrManager_Base::cellsInZone ( double eta_min, double eta_max, double phi_min, double phi_max, std::vector< IdentifierHash > & cell_list ) const

inherited

the only client is CaloCellList class

Definition at line 793 of file CaloDetDescrManager.cxx.

{
  cell_list.clear();
  if ( eta_min >= eta_max ) return;
  if ( phi_min >= phi_max ) return;
 
  std::vector<IdentifierHash> one_list;
 
  // For LAr use the descriptors :
  for ( unsigned int i=0; i<m_descr_vec.size(); i++ ) {
    const CaloDetDescriptor* reg = m_descr_vec[i];
    if ( reg ) {
      cellsInZone(eta_min, eta_max, phi_min, phi_max, reg, one_list);
      if (cell_list.empty())
        cell_list.swap (one_list);
      else
        cell_list.insert (cell_list.end(), one_list.begin(), one_list.end());
    }
  }
 
  // Now Tiles :
  cellsInZone(eta_min, eta_max, phi_min, phi_max, CaloCell_ID::TILE, one_list);
  cell_list.insert (cell_list.end(), one_list.begin(), one_list.end());
}

decode_sample()

void CaloDetDescrManager_Base::decode_sample ( CaloCell_ID::SUBCALO & subCalo, bool & barrel, int & sampling_or_module, CaloCell_ID::CaloSample sample )

staticinherited

translate between the 2 ways to label a sub-detector:

Definition at line 1468 of file CaloDetDescrManager.cxx.

{
  if ( sample == CaloCell_ID::PreSamplerB) {
    subCalo = CaloCell_ID::LAREM;
    barrel = true;
    sampling_or_module = 0;
    return;
  }
  else if ( sample == CaloCell_ID::EMB1) {
    subCalo = CaloCell_ID::LAREM;
    barrel = true;
    sampling_or_module = 1;
    return;
  }
  else if ( sample == CaloCell_ID::EMB2) {
    subCalo = CaloCell_ID::LAREM;
    barrel = true;
    sampling_or_module = 2;
    return;
  }
  else if ( sample == CaloCell_ID::EMB3) {
    subCalo = CaloCell_ID::LAREM;
    barrel = true;
    sampling_or_module = 3;
    return;
  }
  else if ( sample == CaloCell_ID::PreSamplerE) {
    subCalo = CaloCell_ID::LAREM;
    barrel = false;
    sampling_or_module = 0;
    return;
  }
  else if ( sample == CaloCell_ID::EME1) {
    subCalo = CaloCell_ID::LAREM;
    barrel = false;
    sampling_or_module = 1;
    return;
  }
  else if ( sample == CaloCell_ID::EME2) {
    subCalo = CaloCell_ID::LAREM;
    barrel = false;
    sampling_or_module = 2;
    return;
  }
  else if ( sample == CaloCell_ID::EME3) {
    subCalo = CaloCell_ID::LAREM;
    barrel = false;
    sampling_or_module = 3;
    return;
  }
  else if ( sample == CaloCell_ID::HEC0) {
    subCalo = CaloCell_ID::LARHEC;
    barrel = false;
    sampling_or_module = 0;
    return;
  }
  else if ( sample == CaloCell_ID::HEC1) {
    subCalo = CaloCell_ID::LARHEC;
    barrel = false;
    sampling_or_module = 1;
    return;
  }
  else if ( sample == CaloCell_ID::HEC2) {
    subCalo = CaloCell_ID::LARHEC;
    barrel = false;
    sampling_or_module = 2;
    return;
  }
  else if ( sample == CaloCell_ID::HEC3) {
    subCalo = CaloCell_ID::LARHEC;
    barrel = false;
    sampling_or_module = 3;
    return;
  }
  else if ( sample == CaloCell_ID::FCAL0) {
    subCalo = CaloCell_ID::LARFCAL;
    barrel = false;
    sampling_or_module = 0;
    return;
  }
  else if ( sample == CaloCell_ID::FCAL1) {
    subCalo = CaloCell_ID::LARFCAL;
    barrel = false;
    sampling_or_module = 1;
    return;
  }
  else if ( sample == CaloCell_ID::FCAL2) {
    subCalo = CaloCell_ID::LARFCAL;
    barrel = false;
    sampling_or_module = 2;
    return;
  }
  else if ( sample == CaloCell_ID::TileBar0 ||
            sample == CaloCell_ID::TileBar1 ||
            sample == CaloCell_ID::TileBar2 ||
            sample == CaloCell_ID::TileGap1 ||
            sample == CaloCell_ID::TileGap2 ||
            sample == CaloCell_ID::TileGap3 ) {
    subCalo = CaloCell_ID::TILE;
    barrel = true;
    sampling_or_module = 0;
    return;
  }
  else if ( sample == CaloCell_ID::TileExt0 ||
            sample == CaloCell_ID::TileExt1 ||
            sample == CaloCell_ID::TileExt2 ) {
    subCalo = CaloCell_ID::TILE;
    barrel = false;
    sampling_or_module = 0;
    return;
  }
   else {
    subCalo = CaloCell_ID::NOT_VALID;
    barrel = true;
    sampling_or_module = 0;
  }
 
}

element_begin() [1/2]

CaloDetDescrManager_Base::calo_element_const_iterator CaloDetDescrManager_Base::element_begin ( ) const

inherited

first element

Definition at line 111 of file CaloDetDescrManager.cxx.

{
  return m_element_vec.begin();
}

element_begin() [2/2]

CaloDetDescrManager_Base::calo_element_const_iterator CaloDetDescrManager_Base::element_begin ( CaloCell_ID::SUBCALO subCalo ) const

inherited

first element in subcalo

Definition at line 137 of file CaloDetDescrManager.cxx.

{
  int sCal = (int)subCalo;
  return  m_subCalo_begin[sCal];
}

element_end() [1/2]

CaloDetDescrManager_Base::calo_element_const_iterator CaloDetDescrManager_Base::element_end ( ) const

inherited

end of element vector

Definition at line 117 of file CaloDetDescrManager.cxx.

{
  return m_element_vec.end();
}

element_end() [2/2]

CaloDetDescrManager_Base::calo_element_const_iterator CaloDetDescrManager_Base::element_end ( CaloCell_ID::SUBCALO subCalo ) const

inherited

end of subcalo element list

Definition at line 144 of file CaloDetDescrManager.cxx.

{
  int sCal = (int) subCalo;
  return  m_subCalo_end[sCal];
}

element_range() [1/2]

CaloDetDescrManager_Base::calo_element_range CaloDetDescrManager_Base::element_range ( ) const

inherited

Range over element vector.

Definition at line 123 of file CaloDetDescrManager.cxx.

{
  return {m_element_vec.begin(), 
                             m_element_vec.end()};
}

element_range() [2/2]

CaloDetDescrManager_Base::calo_element_range CaloDetDescrManager_Base::element_range ( CaloCell_ID::SUBCALO subCalo ) const

inherited

Range over subcalo element list.

Definition at line 151 of file CaloDetDescrManager.cxx.

{
  int sCal = (int) subCalo;
  return {m_subCalo_begin[sCal],
                             m_subCalo_end[sCal]};
}

element_range_nonconst()

CaloDetDescrManager_Base::calo_nonconst_element_range CaloDetDescrManager_Base::element_range_nonconst ( )

inherited

Range over element vector, with non-const elements.

Definition at line 130 of file CaloDetDescrManager.cxx.

{
  return {m_element_vec.begin(), 
                                      m_element_vec.end()};
}

element_size()

CaloDetDescrManager_Base::calo_element_vec_size CaloDetDescrManager_Base::element_size ( ) const

inherited

total number of elements

Definition at line 105 of file CaloDetDescrManager.cxx.

{
  return m_element_vec.size();
}

get_descriptor() [1/3]

const CaloDetDescriptor * CaloDetDescrManager_Base::get_descriptor ( CaloCell_ID::CaloSample sample, double eta, double phi ) const

inherited

get descriptor by sample, eta and phi

Definition at line 680 of file CaloDetDescrManager.cxx.

{
  // note that this code does not work in the FCal as eta indices depend
  // on eta and phi
 
  const CaloDetDescriptor* desc = nullptr;
 
  if ( sample  == CaloCell_ID::TileBar0 ||
       sample  == CaloCell_ID::TileBar1 ||
       sample  == CaloCell_ID::TileBar2 ||
       sample  == CaloCell_ID::TileGap1 ||
       sample  == CaloCell_ID::TileGap2 ||
       sample  == CaloCell_ID::TileGap3 ||
       sample  == CaloCell_ID::TileExt0 ||
       sample  == CaloCell_ID::TileExt1 ||
       sample  == CaloCell_ID::TileExt2 )  return desc;
 
  for ( unsigned int i=0; i<m_descr_vec.size(); i++ ) {
    const CaloDetDescriptor* reg = m_descr_vec[i];
 
    if (reg) {
      if ( reg->eta_channel(eta) >=0 && reg->phi_channel(phi) >=0) {
        // this works only for LAr EM and HEC, for Tiles the sampling
        // depends on the cell
        int reg_sampl = reg->getSampling(0);
        if ( reg_sampl == sample ) desc  = reg;
      }
    }
  }
 
  return desc;
}

get_descriptor() [2/3]

const CaloDetDescriptor * CaloDetDescrManager_Base::get_descriptor ( CaloCell_ID::SUBCALO subCalo, int sampling_or_module, bool barrel, double eta, double phi ) const

inherited

get descriptor by subcalo, sampling, barrel flag, eta, phi

Definition at line 599 of file CaloDetDescrManager.cxx.

{
  const CaloDetDescriptor* desc0 = nullptr;
  const CaloDetDescriptor* desc1 = nullptr;
  const CaloDetDescriptor* desc2 = nullptr;
  const CaloDetDescriptor* desc3 = nullptr;
 
  if(subCalo == CaloCell_ID::TILE) return nullptr;
  if(subCalo == CaloCell_ID::LARHEC && barrel) return nullptr;
  if(subCalo == CaloCell_ID::LARFCAL && barrel) return nullptr;
   
  for (unsigned int i=0; i<m_descr_vec.size(); i++) 
  {
    const CaloDetDescriptor* reg = m_descr_vec[i];
 
    if(reg) 
    {
      
      // for em differentiate barrel from endcap :
      if ((subCalo != CaloCell_ID::LAREM 
       || (!barrel && reg->is_lar_em_endcap()) 
       || (barrel && reg->is_lar_em_barrel())
       )
      && ((subCalo == CaloCell_ID::LAREM && reg->is_lar_em())
          || (subCalo == CaloCell_ID::LARHEC && reg->is_lar_hec())
          || (subCalo == CaloCell_ID::LARFCAL && reg->is_lar_fcal())
          )
      )
      {
 
    if(reg->eta_channel(eta) >=0 && reg->phi_channel(phi) >=0) 
    {
      // this works only for LAr, for Tiles the sampling depends on the
      // cell
      int reg_sampl = reg->getSampling(0);
      // using enums as running indices is not safe! Therefore ask
      // for each sampling explicitly
      if(reg->is_lar_em_barrel()) 
      {
        if(reg_sampl == CaloCell_ID::PreSamplerB) desc0 = reg;      
        else if(reg_sampl == CaloCell_ID::EMB1) desc1 = reg;    
        else if(reg_sampl == CaloCell_ID::EMB2) desc2 = reg;    
        else if(reg_sampl == CaloCell_ID::EMB3) desc3 = reg;    
      }
      else if(reg->is_lar_em_endcap()) 
      {
        if(reg_sampl == CaloCell_ID::PreSamplerE) desc0 = reg;      
        else if(reg_sampl == CaloCell_ID::EME1) desc1 = reg;    
        else if(reg_sampl == CaloCell_ID::EME2) desc2 = reg;    
        else if(reg_sampl == CaloCell_ID::EME3) desc3 = reg;    
      }
      else if(reg->is_lar_hec()) 
      {
        if(reg_sampl == CaloCell_ID::HEC0) desc0 = reg;     
        else if(reg_sampl == CaloCell_ID::HEC1) desc1 = reg;    
        else if(reg_sampl == CaloCell_ID::HEC2) desc2 = reg;    
        else if(reg_sampl == CaloCell_ID::HEC3) desc3 = reg;    
      }
      else if(reg->is_lar_fcal()) 
      {
        if(reg_sampl == CaloCell_ID::FCAL0) desc0  = reg;       
        else if(reg_sampl == CaloCell_ID::FCAL1) desc1 = reg;       
        else if(reg_sampl == CaloCell_ID::FCAL2) desc2 = reg;       
      }
    } //if(reg->eta_channel(eta) >=0 && reg->phi_channel(phi) >=0)
      }
    } //if(reg)
  } // iteration over descriptors
 
  if(sampling_or_module == 0) return desc0;
  else if(sampling_or_module == 1) return desc1;
  else if(sampling_or_module == 2) return desc2;
  else if(sampling_or_module == 3) return desc3;
  else return nullptr;
}

get_descriptor() [3/3]

const CaloDetDescriptor * CaloDetDescrManager_Base::get_descriptor ( const Identifier & regionId ) const

inherited

get descriptor by region identifier

Definition at line 579 of file CaloDetDescrManager.cxx.

{
  IdentifierHash hash = m_cell_id->calo_region_hash(regionId);
  if(hash < m_descr_vec.size()) 
    return m_descr_vec[hash] ;
  else 
    return nullptr;
}

get_descriptor_nonconst()

CaloDetDescriptor * CaloDetDescrManager_Base::get_descriptor_nonconst ( const Identifier & regionId )

inherited

get descriptor by region identifier, non-const version.

Definition at line 589 of file CaloDetDescrManager.cxx.

{
  IdentifierHash hash = m_cell_id->calo_region_hash(regionId);
  if(hash < m_descr_vec.size()) 
    return m_descr_vec[hash] ;
  else 
    return nullptr;
}

get_descriptor_raw()

const CaloDetDescriptor * CaloDetDescrManager_Base::get_descriptor_raw ( CaloCell_ID::CaloSample sample, double eta, double phi ) const

inherited

get descriptor by sample, eta and phi raw

Definition at line 715 of file CaloDetDescrManager.cxx.

{
  // note that this code does not work in the FCal as eta indices depend
  // on eta and phi 
 
  //std::cout << " in CaloDetDescrManager_Base::get_descriptor_raw " << std::endl;
 
  const CaloDetDescriptor* desc = nullptr;
 
  if ( sample  == CaloCell_ID::TileBar0 ||
       sample  == CaloCell_ID::TileBar1 ||
       sample  == CaloCell_ID::TileBar2 ||
       sample  == CaloCell_ID::TileGap1 ||
       sample  == CaloCell_ID::TileGap2 ||
       sample  == CaloCell_ID::TileGap3 ||
       sample  == CaloCell_ID::TileExt0 ||
       sample  == CaloCell_ID::TileExt1 ||
       sample  == CaloCell_ID::TileExt2 )  return desc;
 
  for ( unsigned int i=0; i<m_descr_vec.size(); i++ ) { 
    const CaloDetDescriptor* reg = m_descr_vec[i];
 
    if (reg) { 
      int reg_sampl = reg->getSampling(0);
      if ( reg_sampl == sample ) {
        if ( reg->eta_channel_raw(eta) >=0 && reg->phi_channel_raw(phi) >=0) {
        // this works only for LAr EM and HEC, for Tiles the sampling
        // depends on the cell
           desc=reg;
           return desc;
        }
      }
    }
  }
 
  return desc;
}

get_element() [1/5]

const CaloDetDescrElement * CaloDetDescrManager_Base::get_element ( CaloCell_ID::CaloSample sample, double eta, double phi ) const

inherited

LAr only!

get element by sample, eta phi. This is slower for FCAL

Definition at line 256 of file CaloDetDescrManager.cxx.

{
  const CaloDetDescrElement* elt=nullptr;
  
  // For LAr loop on regions :
 
  if ( sample != CaloCell_ID::TileBar0 && sample != CaloCell_ID::TileBar1 &&
       sample != CaloCell_ID::TileBar2 && sample != CaloCell_ID::TileGap1 && 
       sample != CaloCell_ID::TileGap2 && sample != CaloCell_ID::TileGap3 &&
       sample != CaloCell_ID::TileExt0 && sample != CaloCell_ID::TileExt1 &&
       sample != CaloCell_ID::TileExt2 ) {
 
    bool inCell=false;
    int niter=0;
    const CaloDetDescrElement* elt_best=nullptr;
 
    double eta2=eta;
    double phi2=phi;
    double deltabest=9999.;
 
    while (!inCell && niter<3) {
 
      const CaloDetDescriptor* reg = get_descriptor(sample,eta2,phi2);
      if ( ! reg ) return elt;
 
      if (reg->is_lar_fcal()) return get_element_FCAL(reg,eta2,phi2);      
 
      int ieta = reg->eta_channel(eta2);
      int iphi = reg->phi_channel(phi2);
 
      if(ieta < 0) return elt;
      if(iphi < 0) return elt;
 
      Identifier regId = reg->identify();
      Identifier cellId = m_cell_id->cell_id(regId, ieta, iphi);  
      IdentifierHash caloCellHash = m_cell_id->calo_cell_hash(cellId);
      // Check for invalid identifier.
      if (m_cell_id->cell_id (caloCellHash) != cellId) return elt;
      elt = get_element(caloCellHash);
      double deta=std::fabs(eta-elt->eta())-0.5*elt->deta();
      double dphi = std::fabs(CaloPhiRange::fix(phi-elt->phi())) - 0.5*elt->dphi();
      if (deta>0. || dphi > 0.) {
        double delta=0.;
        if (deta>0.) {
         eta2=eta2 + (eta-elt->eta());
         delta = delta + deta;
        }
        if (dphi>0.) {
          phi2=CaloPhiRange::fix(phi2+(phi-elt->phi()));
          delta = delta + dphi;
        }
        if (delta<deltabest) {
           deltabest=delta;
           elt_best = elt;
        }
        niter++;
      }
      else inCell=true;
    }
    if (!inCell) {
      elt = elt_best;
      //std::cout << " after iteration get_element " << inCell << " " << eta << " " << phi << " " << elt->eta() << " " << elt->phi() << " " << deltabest << std::endl;
    }
 
 
  } else {
 
    // For Tiles loop on elements :
 
    for ( unsigned int i = m_subCalo_min[CaloCell_ID::TILE]; 
      i < m_subCalo_max[CaloCell_ID::TILE]; i++ )
    {
      const CaloDetDescrElement* pt = m_element_vec[i];
      if (pt) {
        const double dphi = std::fabs(CaloPhiRange::fix(phi-pt->phi()));
    if ( pt->getSampling() == sample &&
         pt->eta()+pt->deta()/2 >= eta && 
         pt->eta()-pt->deta()/2 <= eta &&
             dphi <=  pt->dphi()/2 )
        {
          elt = pt;
          break;
        }
      }
    }
  }
  return elt;
}

get_element() [2/5]

const CaloDetDescrElement * CaloDetDescrManager_Base::get_element ( CaloCell_ID::SUBCALO subCalo, IdentifierHash subCaloCellHash ) const

inherited

get element by subcalo and hash identifier

Parameters

subCalo	[IN] subsystem
subCaloCellHash	[IN] sub calo hash

Definition at line 173 of file CaloDetDescrManager.cxx.

{
  // meaningless interface for Tiles, will only work for LAr
 
  int sCal = (int) subCalo;
  if ( subCaloCellHash + m_subCalo_min[sCal] < m_element_vec.size() ) 
    return m_element_vec[subCaloCellHash + m_subCalo_min[sCal]] ;
  else return nullptr ;
}  

get_element() [3/5]

const CaloDetDescrElement * CaloDetDescrManager_Base::get_element ( CaloCell_ID::SUBCALO subCalo, int sampling_or_module, bool barrel, double eta, double phi ) const

inherited

LAr only!

get element by subcalo, sampling, barrel flag, eta, phi. This is slower for FCAL

Definition at line 185 of file CaloDetDescrManager.cxx.

{
 
  bool inCell=false;
  int niter=0;
  const CaloDetDescrElement* elt=nullptr ;
  const CaloDetDescrElement* elt_best=nullptr ;
 
  double eta2=eta;
  double phi2=phi;
  double deltabest=9999.;
  //std::cout << " in get_element0 " << subCalo << " " << sampling_or_module << " " << barrel << " " << eta << " " << phi << std::endl;
 
 
  while (!inCell && niter<3) {
 
    const CaloDetDescriptor* reg = get_descriptor(subCalo,sampling_or_module,barrel,eta2,phi2);
    if (!reg) return nullptr;
 
    if (reg->is_lar_fcal()) return get_element_FCAL(reg,eta,phi);
 
    int ieta = reg->eta_channel(eta2);
    int iphi = reg->phi_channel(phi2);
    //std::cout << "      ieta,iphi " << ieta << " " << iphi << std::endl;
 
    if(ieta < 0) return elt;
    if(iphi < 0) return elt;
 
    Identifier regId = reg->identify();
    Identifier cellId = m_cell_id->cell_id(regId, ieta, iphi); 
    IdentifierHash caloCellHash = m_cell_id->calo_cell_hash(cellId);
    // Check for invalid identifier.
    if (m_cell_id->cell_id (caloCellHash) != cellId) return elt;
    elt = get_element(caloCellHash);
    //std::cout << "    element  " << elt->eta() << " " << elt->phi() << " " << elt->deta() << " " << elt->dphi() << std::endl; 
    double deta=std::fabs(eta-elt->eta())-0.5*elt->deta();
    double dphi = std::fabs(CaloPhiRange::fix(phi-elt->phi())) - 0.5*elt->dphi();
    if (deta>0. || dphi > 0.) {
      double delta=0.;
      if (deta>0.) { 
         eta2=eta2 + (eta-elt->eta());
         delta = delta + deta;
      }
      if (dphi>0.) {
        phi2=CaloPhiRange::fix(phi2+(phi-elt->phi()));
         delta = delta + dphi;
      }
      //std::cout << "  need to iteration => eta2,phi2 " << eta2 << " " << phi2 << std::endl;
      if (delta<deltabest) {
          deltabest=delta;
          elt_best = elt;
      }
      niter++;
    }
    else inCell=true;
  }
  if (!inCell) {
     elt = elt_best;
    // std::cout << " after iteration get_element0 " << inCell << " " << eta << " " << phi << " " << elt->eta() << " " << elt->phi() << " " << deltabest << std::endl;
  }
 
 
 
  return elt;
}

get_element() [4/5]

const CaloDetDescrElement * CaloDetDescrManager_Base::get_element ( const Identifier & cellId ) const

inherited

get element by its identifier

Parameters

cellId

[IN] element identifier

Definition at line 159 of file CaloDetDescrManager.cxx.

{
  IdentifierHash hash = m_cell_id->calo_cell_hash(cellId);
  return get_element(hash);
}

get_element() [5/5]

const CaloDetDescrElement * CaloDetDescrManager_Base::get_element ( IdentifierHash caloCellHash ) const

inlineinherited

get element by hash identifier

Parameters

caloCellHash

[IN] hash identifier for the element

Definition at line 505 of file CaloDetDescrManager.h.

{
  if ( caloCellHash < m_element_vec.size() ) 
    return m_element_vec[caloCellHash] ;
  else return nullptr ;
}

get_element_FCAL()

const CaloDetDescrElement * CaloDetDescrManager_Base::get_element_FCAL ( const CaloDetDescriptor * reg, double eta, double phi ) const

privateinherited

LArFCAl private methode to get element.

Definition at line 443 of file CaloDetDescrManager.cxx.

{
  const CaloDetDescrElement* elt=nullptr;
 
  //std::cout << " in get_element_FCAL " << descr->reg_min() << " " << descr->reg_max() <<  " eta,phi " << eta << " " << phi << std::endl;
  if (eta < (descr->reg_min()-0.01) || eta > (descr->reg_max()+0.01) ) return elt;
 
  Identifier regId = descr->identify();
  Identifier cellId;
  IdentifierHash caloCellHash;
  const CaloDetDescrElement* elt2;
  double drmax=9999.;
  for (int ieta=0; ieta<descr->n_eta(); ieta++) {
     for (int iphi=0; iphi<descr->n_phi(); iphi++) {
       cellId = m_cell_id->cell_id(regId, ieta, iphi);
       caloCellHash = m_cell_id->calo_cell_hash(cellId);
       elt2 = get_element (caloCellHash);
       double deta = (eta-elt2->eta());
       double dphi = CaloPhiRange::diff(phi,elt2->phi());
       double dr = (deta*deta+dphi*dphi);
       if (dr<drmax) {
          drmax=dr;
          elt = elt2;
       }
     }
  }
 
  //if (elt) std::cout << " element found " << elt->eta() << " " << elt->phi() << std::endl;
  //else     std::cout <<"  element not found " << std::endl;
 
  return elt;
}

get_element_FCAL_raw()

const CaloDetDescrElement * CaloDetDescrManager_Base::get_element_FCAL_raw ( const CaloDetDescriptor * reg, double eta, double phi ) const

privateinherited

LArFCAl private methode to get element from raw eta,phi.

Definition at line 479 of file CaloDetDescrManager.cxx.

{
  const CaloDetDescrElement* elt=nullptr;
 
  //std::cout << " in get_element_FCAL " << descr->reg_min() << " " << descr->reg_max() <<  " eta,phi " << eta << " " << phi << std::endl;
  if (std::fabs(eta) < (descr->calo_eta_min()-0.01) || std::fabs(eta) > (descr->calo_eta_max()+0.01) ) return elt;
 
  Identifier regId = descr->identify();
  Identifier cellId;
  IdentifierHash caloCellHash;
  const CaloDetDescrElement* elt2;
  double drmax=9999.;
  for (int ieta=0; ieta<descr->n_eta(); ieta++) {
     for (int iphi=0; iphi<descr->n_phi(); iphi++) {
       cellId = m_cell_id->cell_id(regId, ieta, iphi);
       caloCellHash = m_cell_id->calo_cell_hash(cellId);
       elt2 = get_element (caloCellHash);
       double deta = (eta-elt2->eta_raw());
       double dphi = CaloPhiRange::diff(phi,elt2->phi_raw());
       double dr = (deta*deta+dphi*dphi);
       if (dr<drmax) {
          drmax=dr;
          elt = elt2;
       }
     }
  }
 
  //if (elt) std::cout << " element found " << elt->eta() << " " << elt->phi() << std::endl;
  //else     std::cout <<"  element not found " << std::endl;
 
  return elt;
}

get_element_nonconst() [1/2]

CaloDetDescrElement * CaloDetDescrManager_Base::get_element_nonconst ( const Identifier & cellId )

inherited

get element by its identifier, non-const version.

Parameters

cellId

[IN] element identifier

Definition at line 166 of file CaloDetDescrManager.cxx.

{
  IdentifierHash hash = m_cell_id->calo_cell_hash(cellId);
  return get_element_nonconst(hash);
}

get_element_nonconst() [2/2]

CaloDetDescrElement * CaloDetDescrManager_Base::get_element_nonconst ( IdentifierHash caloCellHash )

inlineinherited

get element by hash identifier, non-const version.

Parameters

caloCellHash

[IN] hash identifier for the element

Definition at line 513 of file CaloDetDescrManager.h.

{
  if ( caloCellHash < m_element_vec.size() ) 
    return m_element_vec[caloCellHash] ;
  else return nullptr ;
}

get_element_raw()

const CaloDetDescrElement * CaloDetDescrManager_Base::get_element_raw ( CaloCell_ID::CaloSample sample, double eta, double phi ) const

inherited

Get element from raw quantities (to build real fixed size clusters)

Definition at line 349 of file CaloDetDescrManager.cxx.

{
  //std::cout << " ----- in get_element_raw for eta,phi raw " << eta << " " << phi << std::endl;
  const CaloDetDescrElement* elt=nullptr;
  
  // For LAr loop on regions :
 
  if ( sample != CaloCell_ID::TileBar0 && sample != CaloCell_ID::TileBar1 &&
       sample != CaloCell_ID::TileBar2 && sample != CaloCell_ID::TileGap1 && 
       sample != CaloCell_ID::TileGap2 && sample != CaloCell_ID::TileGap3 &&
       sample != CaloCell_ID::TileExt0 && sample != CaloCell_ID::TileExt1 &&
       sample != CaloCell_ID::TileExt2 ) {
 
    bool inCell=false;
    int niter=0;
    const CaloDetDescrElement* elt_best=nullptr ;
 
    double eta2=eta;
    double phi2=phi;
    double deltabest=9999.;
 
    while (!inCell && niter<3) {
 
      const CaloDetDescriptor* reg = get_descriptor_raw(sample,eta2,phi2);
      if ( ! reg ) return elt;
      //std::cout << " get_element_raw: found region   calo etamin,etamax " << reg->calo_eta_min() << " " << reg->calo_eta_max() << std::endl;
 
      if (reg->is_lar_fcal()) return get_element_FCAL_raw(reg,eta,phi);      
 
      int ieta = reg->eta_channel_raw(eta2);
      int iphi = reg->phi_channel_raw(phi2);
 
      if(ieta < 0) return elt;
      if(iphi < 0) return elt;
 
      Identifier regId = reg->identify();
      Identifier cellId = m_cell_id->cell_id(regId, ieta, iphi);  
      IdentifierHash caloCellHash = m_cell_id->calo_cell_hash(cellId);
      // Check for invalid identifier.
      if (m_cell_id->cell_id (caloCellHash) != cellId) return elt;
      elt = get_element(caloCellHash);
      //std::cout << "  elt raw,phi raw " << elt->eta_raw() << " " << elt->phi_raw() << std::endl;
      double deta=std::fabs(eta-elt->eta_raw())-0.5*elt->deta();
      double dphi = std::fabs(CaloPhiRange::fix(phi-elt->phi_raw())) - 0.5*elt->dphi();
      if (deta>0. || dphi > 0.) {
        double delta=0.;
        if (deta>0.) {
         eta2=eta2 + (eta-elt->eta_raw());
         delta = delta + deta;
        }
        if (dphi>0.) {
          phi2=CaloPhiRange::fix(phi2+(phi-elt->phi_raw()));
          delta = delta + dphi;
        }
        if (delta<deltabest) {
           deltabest=delta;
           elt_best = elt;
        }
        niter++;
      }
      else {
      //std::cout << " found cell " << elt->eta_raw() << " " << elt->phi_raw() << std::endl;
      inCell=true;
      }
    }
    if (!inCell) {
      elt=elt_best; 
      //std::cout << " after iteration raw " << inCell << " " << eta << " " << phi << " " << elt->eta_raw() << " " << elt->phi_raw() << " " << deltabest << std::endl;
    }
 
 
  } else {
 
    // For Tiles loop on elements :
  
    for ( unsigned int i = m_subCalo_min[CaloCell_ID::TILE]; 
      i < m_subCalo_max[CaloCell_ID::TILE]; i++ ) {
      const CaloDetDescrElement* pt = m_element_vec[i];
      if (pt)
    if ( pt->getSampling() == sample &&
         pt->eta()+pt->deta()/2 <= eta && 
         pt->eta()-pt->deta()/2 >= eta &&
         pt->phi()+pt->phi()/2 <= phi && 
         pt->phi()-pt->phi()/2 >= phi ) elt = pt ; 
    }
  }
  return elt;
}

getCalo_Mgr()

const CaloIdManager * CaloDetDescrManager_Base::getCalo_Mgr ( ) const

inherited

get calo ID manager

Definition at line 99 of file CaloDetDescrManager.cxx.

{
  return m_calo_mgr;
}

getCaloCell_ID()

const CaloCell_ID * CaloDetDescrManager::getCaloCell_ID

(

)

const

get calo cell ID helper

Definition at line 1590 of file CaloDetDescrManager.cxx.

{
  return static_cast<const CaloCell_ID*>
    (CaloDetDescrManager_Base::getCaloCell_ID());
}

initialize()

void CaloDetDescrManager_Base::initialize ( )

inherited

initialization of the manager, used by the Converter when it creates the Manager

Definition at line 49 of file CaloDetDescrManager.cxx.

{
  // set sizes :
  m_element_vec.resize(m_cell_id->calo_cell_hash_max());  
  m_descr_vec.resize(m_cell_id->calo_region_hash_max()); 
 
  // --- --- Temporary, for testing only --- ---
  for(unsigned int i=0; i<m_element_vec.size(); i++)
    m_element_vec[i] = nullptr;
 
  for(unsigned int i=0; i<m_descr_vec.size(); i++)
    m_descr_vec[i] = nullptr;
  // --- --- Temporary, for testing only --- ---
 
  // cache offsets :
  int nb = CaloCell_ID::NSUBCALO;
  
  m_subCalo_min.resize(nb);
  m_subCalo_max.resize(nb);
  m_subCalo_begin.resize(nb);
  m_subCalo_end.resize(nb);
  
  for(int i = 0; i < nb; i++) {
    m_cell_id->calo_cell_hash_range(i,m_subCalo_min[i],m_subCalo_max[i]);
 
    m_subCalo_begin[i] = calo_element_const_iterator(m_element_vec.begin()) + m_subCalo_min[i];
    m_subCalo_end[i]   = calo_element_const_iterator(m_element_vec.begin()) + m_subCalo_max[i];
  }
}

is_in()

bool CaloDetDescrManager_Base::is_in ( double eta, double phi, CaloCell_ID::CaloSample sample, double & etadist ) const

inherited

return true if direction eta,phi crosses ANY of the corresponding descriptors

Parameters

eta	[IN] eta direction
phi	[IN] phi direction
sample	[IN] Calo Sample
etadist	[OUT] distance in eta to the neares edge

Definition at line 1348 of file CaloDetDescrManager.cxx.

{
  // note that this code does not work in the FCal as eta indices depend
  // on eta and phi
 
  // I'm looking for the distance between the eta direction and the closest edge.
  // all in absolute value --> the sign will indicate if it is in or out.
 
  bool result = false;
  etadist = 9999999.;
  double aeta = std::abs(eta);
 
  // Tile first
  // Treat Tile Barrel and End Cap in different ways
  // -- Barrel
  if(sample == CaloCell_ID::TileBar0 ||
     sample == CaloCell_ID::TileBar1 ||
     sample == CaloCell_ID::TileBar2)
  {
    for(unsigned int i=0; i<m_tile_descr_vec.size(); i++)
    {
      const CaloDetDescriptor* reg = m_tile_descr_vec[i];
 
      if(reg && reg->getSampling(0) == sample)
      {
    etadist = std::abs(aeta - reg->calo_eta_max());
    if(aeta <= reg->calo_eta_max()) result = true;
    break;
      }
    }
  }
  // End Cap
  else if(sample == CaloCell_ID::TileExt0 ||
      sample == CaloCell_ID::TileExt1 ||
      sample == CaloCell_ID::TileExt2 ||    
      sample == CaloCell_ID::TileGap1 ||
      sample == CaloCell_ID::TileGap2 ||
      sample == CaloCell_ID::TileGap3)
  {
    for(unsigned int i=0; i<m_tile_descr_vec.size(); i++)
    {
      const CaloDetDescriptor* reg = m_tile_descr_vec[i];
 
      if(reg && reg->getSampling(0) == sample)
      {
    double edgemin = std::abs(aeta - reg->calo_eta_min());
    double edgemax = std::abs(aeta - reg->calo_eta_max());
    if(edgemin < etadist) etadist = edgemin;
    if(edgemax < etadist) etadist = edgemax;
 
    if(aeta >= reg->calo_eta_min() &&
       aeta <= reg->calo_eta_max()) result = true;
    break;
      }
    }
  }
  else {
    for ( unsigned int i=0; i<m_descr_vec.size(); i++ ) {
      const CaloDetDescriptor* reg = m_descr_vec[i];
      if ( reg ) {
        if ( reg->getSampling(0) == sample ) {
          if ( reg->eta_channel(eta) >=0 && reg->phi_channel(phi) >=0) result = true;
          double edgemin = std::abs( aeta - reg->reg_min() );
          double edgemax = std::abs( aeta - reg->reg_max() );
          if ( edgemin < etadist ) etadist = edgemin;
          if ( edgemax < etadist ) etadist = edgemax;
        }
      }
    }
  }
 
  if (result) etadist = etadist*(-1.);
 
  return result;
}

isInitialized()

bool CaloDetDescrManager_Base::isInitialized ( ) const

inlineinherited

for backwards compatibility only

Definition at line 163 of file CaloDetDescrManager.h.

{return true;}

lar_geometry()

const std::string & CaloDetDescrManager_Base::lar_geometry ( ) const

inlineinherited

get lar geometry label, distinguish between full atlas and TB

Definition at line 166 of file CaloDetDescrManager.h.

{return m_lar_geometry;}

print()

void CaloDetDescrManager_Base::print ( ) const

inherited

print out the contents

Definition at line 79 of file CaloDetDescrManager.cxx.

{
  std::cout << " CaloDetDescrManager_Base: \n";
 
  std::cout << " Number of Calo descriptors   : " << m_descr_vec.size() << "\n";
 
  int ntot = m_descr_vec.size();
  for(int i=0 ; i<ntot; i++ ) 
  {
    std::cout << "\n ------ Calo descriptor number " << i << "\n";
    if(m_descr_vec[i])
      m_descr_vec[i]->print();
  }
}

release_element()

CaloDetDescrElement * CaloDetDescrManager_Base::release_element ( IdentifierHash hash )

privateinherited

Definition at line 776 of file CaloDetDescrManager.cxx.

{
  CaloDetDescrElement* old = m_element_vec[hash];
  m_element_vec[hash] = nullptr;
  return old;
}

set_helper() [1/3]

void CaloDetDescrManager::set_helper

(

const CaloCell_ID *

idHelper

)

set calo Cell ID helper

Definition at line 1596 of file CaloDetDescrManager.cxx.

{
  CaloDetDescrManager_Base::set_helper (idHelper);
}

set_helper() [2/3]

void CaloDetDescrManager::set_helper

(

const CaloIdManager *

idHelper

)

Definition at line 1602 of file CaloDetDescrManager.cxx.

{
  CaloDetDescrManager_Base::set_helper (idHelper);
}

set_helper() [3/3]

void CaloDetDescrManager_Base::set_helper ( const CaloCell_Base_ID * idHelper )

inherited

set calo Cell ID helper

Definition at line 783 of file CaloDetDescrManager.cxx.

{
    m_cell_id = idHelper;
}

set_lar_geometry()

void CaloDetDescrManager_Base::set_lar_geometry ( const std::string & geom )

inlineinherited

set lar geometry label, distinguish between full atlas and TB

Definition at line 169 of file CaloDetDescrManager.h.

{ m_lar_geometry = geom;}

tile_descriptors_begin()

CaloDetDescrManager_Base::calo_descr_const_iterator CaloDetDescrManager_Base::tile_descriptors_begin ( ) const

inherited

first tile descriptor (they are in separate vector)

Definition at line 547 of file CaloDetDescrManager.cxx.

{
  return m_tile_descr_vec.begin();
}

tile_descriptors_end()

CaloDetDescrManager_Base::calo_descr_const_iterator CaloDetDescrManager_Base::tile_descriptors_end ( ) const

inherited

end of tile descriptors vector

Definition at line 553 of file CaloDetDescrManager.cxx.

{
  return m_tile_descr_vec.end();
}

tile_descriptors_range()

CaloDetDescrManager_Base::calo_descr_range CaloDetDescrManager_Base::tile_descriptors_range ( ) const

inherited

Range over tile descriptors.

Definition at line 565 of file CaloDetDescrManager.cxx.

{
  return {m_tile_descr_vec.begin(),
                           m_tile_descr_vec.end()};
}

tile_descriptors_range_nonconst()

CaloDetDescrManager_Base::calo_nonconst_descr_range CaloDetDescrManager_Base::tile_descriptors_range_nonconst ( )

inherited

Range over tile descriptors, with non-const elements.

Definition at line 572 of file CaloDetDescrManager.cxx.

{
  return {m_tile_descr_vec.begin(),
                                    m_tile_descr_vec.end()};
}

tile_descriptors_size()

CaloDetDescrManager_Base::calo_descr_size CaloDetDescrManager_Base::tile_descriptors_size ( ) const

inherited

number of tile descriptors

Definition at line 559 of file CaloDetDescrManager.cxx.

{
  return m_tile_descr_vec.size();
}

Member Data Documentation

m_calo_mgr

const CaloIdManager* CaloDetDescrManager_Base::m_calo_mgr

privateinherited

Calo ID Manager helper.

Definition at line 421 of file CaloDetDescrManager.h.

m_cell_id

const CaloCell_Base_ID* CaloDetDescrManager_Base::m_cell_id

privateinherited

Calo Cell ID helper.

Definition at line 418 of file CaloDetDescrManager.h.

m_descr_vec

calo_descr_vec CaloDetDescrManager_Base::m_descr_vec

privateinherited

vector of descriptors

Definition at line 428 of file CaloDetDescrManager.h.

m_element_vec

calo_element_vec CaloDetDescrManager_Base::m_element_vec

privateinherited

vector of Calo DD elements

Definition at line 425 of file CaloDetDescrManager.h.

m_lar_geometry

std::string CaloDetDescrManager_Base::m_lar_geometry

privateinherited

LAr geometry label (full atlas/TB) for backwards compatibility.

Definition at line 449 of file CaloDetDescrManager.h.

m_subCalo_begin

std::vector<calo_element_const_iterator> CaloDetDescrManager_Base::m_subCalo_begin

privateinherited

offsets for subcalo's elements

Definition at line 438 of file CaloDetDescrManager.h.

m_subCalo_end

std::vector<calo_element_const_iterator> CaloDetDescrManager_Base::m_subCalo_end

privateinherited

offsets for subcalo's elements

Definition at line 441 of file CaloDetDescrManager.h.

m_subCalo_max

std::vector<IdentifierHash> CaloDetDescrManager_Base::m_subCalo_max

privateinherited

offsets for subcalo's elements

Definition at line 435 of file CaloDetDescrManager.h.

m_subCalo_min

std::vector<IdentifierHash> CaloDetDescrManager_Base::m_subCalo_min

privateinherited

offsets for subcalo's elements

Definition at line 432 of file CaloDetDescrManager.h.

m_tile_descr_vec

calo_descr_vec CaloDetDescrManager_Base::m_tile_descr_vec

privateinherited

vector of descriptors

Definition at line 445 of file CaloDetDescrManager.h.

---

The documentation for this class was generated from the following files:

• CaloDetDescrManager.h
• CaloDetDescrManager.cxx