CaloSuperCellUtils.cxx File Reference

#include "CaloDetDescrUtils/CaloSuperCellUtils.h"
#include "CaloIdentifier/CaloCell_ID.h"
#include "CaloIdentifier/CaloCell_SuperCell_ID.h"
#include "CaloDetDescr/CaloDetDescrManager.h"
#include "CaloDetDescr/CaloDetDescriptor.h"
#include "CaloDetDescr/CaloDetDescrElement.h"
#include "CaloDetDescr/CaloDetectorElements.h"
#include "CaloDetDescr/ICaloSuperCellIDTool.h"

Include dependency graph for CaloSuperCellUtils.cxx:

Go to the source code of this file.

Functions
void	createDescriptors (CaloSuperCellDetDescrManager *mgr)
void	createElements (CaloSuperCellDetDescrManager *mgr)
StatusCode	updateElements (CaloSuperCellDetDescrManager *mgr, const CaloDetDescrManager *cellmgr, const ICaloSuperCellIDTool *scidTool)
void	updateDescriptors (CaloSuperCellDetDescrManager *mgr, const CaloDetDescrManager *cellmgr, const ICaloSuperCellIDTool *scidTool)

Function Documentation

createDescriptors()

void createDescriptors

(

CaloSuperCellDetDescrManager *

mgr

)

Definition at line 155 of file CaloSuperCellUtils.cxx.

{
  const CaloCell_Base_ID* calo_helper = mgr->getCaloCell_ID();
  for (Identifier reg_id : calo_helper->reg_range()) {
    if (! calo_helper->is_tile (reg_id)) {
      mgr->add (new CaloDetDescriptor (reg_id, nullptr, calo_helper));
    }
    else {
      mgr->add_tile (new CaloDetDescriptor
                     (reg_id, calo_helper->tile_idHelper(), calo_helper,
                      (CaloCell_ID::CaloSample)calo_helper->calo_sample(reg_id), 0));
      // NB. CaloDetDescrElement::getSampling adds the tile cell sampling                                                                                                 
      //     index to the descriptor's sampling, so don't add 2 here                                                                                                      
      //     to calo_sample.                                                                                                                                              
      mgr->add_tile (new CaloDetDescriptor
                     (reg_id, calo_helper->tile_idHelper(), calo_helper,
                      (CaloCell_ID::CaloSample)(calo_helper->calo_sample(reg_id)), 2));
    }
  }
}

createElements()

void createElements

(

CaloSuperCellDetDescrManager *

mgr

)

Definition at line 176 of file CaloSuperCellUtils.cxx.

{
  const CaloCell_Base_ID* calo_helper = mgr->getCaloCell_ID();
  for (Identifier cell_id : calo_helper->cell_range()) {
    int subCalo = -1;
    IdentifierHash subCaloHash =
      calo_helper->subcalo_cell_hash (cell_id, subCalo);
 
    const CaloDetDescriptor* desc = get_cell_descriptor (cell_id, mgr);
    assert (desc);
    mgr->add (new CaloSuperCellDetectorElement (subCaloHash, desc));
  }
}

updateDescriptors()

void updateDescriptors	(	CaloSuperCellDetDescrManager *	mgr,
		const CaloDetDescrManager *	cellmgr,
		const ICaloSuperCellIDTool *	scidTool
	)

Definition at line 230 of file CaloSuperCellUtils.cxx.

{
  size_t maxdesc = mgr->calo_descriptors_size() + mgr->tile_descriptors_size();
  std::vector<DescrMinMax> descr_minmax (maxdesc);
 
  // Loop over cells and record range limits for each descriptor.                                                                                                         
  for (const CaloDetDescrElement* elt : mgr->element_range()) {
    if (!elt) continue;
    CaloDetDescriptor* desc = const_cast<CaloDetDescriptor*>(elt->descriptor());
    int ndx = descr_index (desc, mgr);
    assert (ndx >= 0 && ndx < (int)descr_minmax.size());
    DescrMinMax& mm = descr_minmax[ndx];
 
    int dz_den = desc->is_lar_hec() ? 1 : 2;
 
    mm.eta.add (std::abs(elt->eta_raw()), elt->deta()/2);
    mm.phi.add (phi_for_descr (elt->phi_raw()), elt->dphi()/2);
    mm.r.add (elt->r(), elt->dr()/2);
    mm.z.add (std::abs(elt->z_raw()), elt->dz()/dz_den);
  }
 
  // Loop over each descriptor and update.                                                                                                                                
  size_t i = 0;
  for (CaloDetDescriptor* desc : mgr->calo_descriptors_range_nonconst()) {
    updateDescriptor (desc, descr_minmax[i], cellmgr, scidTool);
    ++i;
  }
  for (CaloDetDescriptor* desc : mgr->tile_descriptors_range_nonconst()) {
    updateDescriptor (desc, descr_minmax[i], cellmgr, scidTool);
    ++i;
  }
}

updateElements()

StatusCode updateElements	(	CaloSuperCellDetDescrManager *	mgr,
		const CaloDetDescrManager *	cellmgr,
		const ICaloSuperCellIDTool *	scidTool
	)

Definition at line 190 of file CaloSuperCellUtils.cxx.

{
  // For each supercell, we make a list of the corresponding cells.                                                                                                       
  // Then we pass that list to the supercell's @c update method.                                                                                                         
 
  for (CaloDetDescrElement* elt : mgr->element_range_nonconst()) {
    if (!elt) continue;
     CaloSuperCellDetectorElement* selt =
       dynamic_cast<CaloSuperCellDetectorElement*> (elt);
     if (!selt) continue;
 
     std::vector<Identifier> ids =
       scidTool->superCellToOfflineID (elt->identify());
     assert (!ids.empty());
 
     const CaloCell_Base_ID* idhelper      = mgr->getCaloCell_ID();
     const CaloCell_Base_ID* cell_idhelper = cellmgr->getCaloCell_ID();
 
     std::vector<const CaloDetDescrElement*> fromelts;
     fromelts.reserve (ids.size());
     for (Identifier id : ids) {
       // For tile tower sums, exclude D-layer cells                                                                                                                      
       // (they have a different size).                                                                                                                                   
       if (cell_idhelper->sub_calo(id) == CaloCell_Base_ID::TILE &&
           cell_idhelper->sample(id) == 2 &&
           idhelper->sample(elt->identify()) != 2)
         continue;
       const CaloDetDescrElement* fromelt = cellmgr->get_element (id);
       assert (fromelt != nullptr);
       fromelts.push_back (fromelt);
     }
     if(selt->update(fromelts).isFailure()) {
       return StatusCode::FAILURE;
     }
  }
  return StatusCode::SUCCESS;
}