CaloCellVolumes Class Reference

#include <CaloCellVolumes.h>

Collaboration diagram for CaloCellVolumes:

Public Member Functions
	CaloCellVolumes (ISvcLocator *svcLocator, const CaloCell_ID *calocell_id)
	~CaloCellVolumes ()
double	CellVolume (Identifier cell_id)
const std::string &	layout ()
double	getFcalTubeSpacing (int sampling)
void	print ()

Private Types
typedef std::map< int, double >	TubeSpacingMap

Private Attributes
const CaloCell_ID *	m_calocell_id {nullptr}
CaloCellVolumeVector	m_cellVolumes
std::string	m_geometryLayout
TubeSpacingMap	m_fcalTubeSpacings

Detailed Description

Definition at line 24 of file CaloCellVolumes.h.

Member Typedef Documentation

TubeSpacingMap

typedef std::map<int, double> CaloCellVolumes::TubeSpacingMap

private

Definition at line 45 of file CaloCellVolumes.h.

Constructor & Destructor Documentation

CaloCellVolumes()

CaloCellVolumes::CaloCellVolumes	(	ISvcLocator *	svcLocator,
		const CaloCell_ID *	calocell_id )

Definition at line 32 of file CaloCellVolumes.cxx.

  : m_calocell_id(calocell_id)
{
  // Retrieve input parameters from the database
  SmartIF<IGeoModelSvc>  geoModel{svcLocator->service("GeoModelSvc")};
  if(!geoModel)
    throw std::runtime_error("CellVolumes error: cannot access GeoModelSvc");
 
  SmartIF<IGeoDbTagSvc>  geoDbTagSvc{svcLocator->service("GeoDbTagSvc")};
  if(!geoDbTagSvc)
    throw std::runtime_error("CellVolumes error: cannot access GeoDbTagSvc");
 
  SmartIF<IRDBAccessSvc> rdbAccess{svcLocator->service(geoDbTagSvc->getParamSvcName())};
  if(!rdbAccess)
    throw std::runtime_error("CellVolumes error: cannot access RDBAccessSvc");
 
  std::string larKey, larNode;
  if(geoDbTagSvc->getSqliteReader()==nullptr) {
    DecodeVersionKey detectorKey = DecodeVersionKey(geoModel,"LAr");
    larKey = detectorKey.tag();
    larNode = detectorKey.node();
  }
 
  IRDBRecordset_ptr cellVolRec = rdbAccess->getRecordsetPtr("LArCellVolumes",larKey,larNode);
  if(cellVolRec->size()==0) {
    cellVolRec = rdbAccess->getRecordsetPtr("LArCellVolumes","LArCellVolumes-00");
    if(cellVolRec->size()==0) {
      throw std::runtime_error("CaloCellVolumes error: 0 size of LArCellVolumes recordset");
    }
  }
 
  // get fcal tube spacings
  IRDBRecordset_ptr fcalModRec = rdbAccess->getRecordsetPtr("FCalMod",larKey,larNode);
  if(fcalModRec->size()==0) {
    fcalModRec = rdbAccess->getRecordsetPtr("FCalMod","FCalMod-00");
    if(fcalModRec->size()==0) {
      throw std::runtime_error("CaloCellVolumes error: 0 size of FCalMod recordset");
    }
  }
 
  for(const IRDBRecord_ptr& rec : *fcalModRec) {
    m_fcalTubeSpacings[rec->getInt("FCALSAMPLING")] = rec->getDouble("TUBESPACING");
  }
  
  m_geometryLayout = "Atlas";
  if(geoDbTagSvc->getSqliteReader()==nullptr) {
    std::string LArTag = rdbAccess->getChildTag("LAr",larKey,larNode);
    if(LArTag.find("H8")!=std::string::npos) {
      m_geometryLayout = "H8";
    }
    else if(LArTag.find("H6")!=std::string::npos) {
      m_geometryLayout = "H6";
    }
    else if(LArTag.find("G3")!=std::string::npos) {
      m_geometryLayout = "G3";
    }
  }
  
  // Initialize m_cellVolumes vector
  for(const IRDBRecord_ptr& rec : *cellVolRec) {
    
    int subcalo = rec->getInt("SUBCALO");
    int posneg = rec->getInt("POSNEG");
    int sampling = rec->getInt("SAMPLING");
    int region = rec->getInt("REGION");
    int eta = rec->getInt("ETA");
    int phi = rec->getInt("PHI");
    
    Identifier channelID;
    if(m_geometryLayout != "H6" || subcalo == CaloCell_ID::LARFCAL) {
      channelID = m_calocell_id->cell_id (subcalo, posneg, sampling, region, eta, phi);
    } 
    else {
      Identifier reg_id =  m_calocell_id->region_id(subcalo, posneg, sampling, region);
      int phimin = m_calocell_id->phi_min(reg_id);
      channelID = m_calocell_id->cell_id (subcalo, posneg, sampling, region, eta, phimin);
    }
 
    CaloCellVolume cellVol;
    cellVol.channelID = channelID;
    cellVol.volume = rec->getDouble("VOLUME");
    m_cellVolumes.push_back(cellVol);
  }
  
  if (m_cellVolumes.empty()) {
    throw std::runtime_error("CaloCellVolumes error: 0 volumes have been built!");
  }
  
  std::sort (m_cellVolumes.begin(), m_cellVolumes.end(),
             CaloCellVolume_Compare());
}

~CaloCellVolumes()

CaloCellVolumes::~CaloCellVolumes

(

)

Definition at line 125 of file CaloCellVolumes.cxx.

{
  m_cellVolumes.clear();
}

Member Function Documentation

CellVolume()

double CaloCellVolumes::CellVolume

(

Identifier

cell_id

)

Definition at line 130 of file CaloCellVolumes.cxx.

{
  // compute Identifier of Cell with same eta, but phi=0 and pos side
  // (except for fcal)
  Identifier volId;
  
  if (!m_calocell_id->is_fcal(cell_id)) {
    int subCalo = m_calocell_id->sub_calo(cell_id);
    int posneg = std::abs (m_calocell_id->pos_neg(cell_id));
    int sampling = m_calocell_id->sampling(cell_id);
    int region = m_calocell_id->region(cell_id);
    int eta = m_calocell_id->eta(cell_id);
    
    if(m_geometryLayout != "H6") {
      volId = m_calocell_id->cell_id(subCalo, posneg, sampling, region, eta, 0);
    } 
    else {
      Identifier reg_id =  m_calocell_id->region_id(subCalo, posneg, sampling, region);
      int phimin = m_calocell_id->phi_min(reg_id);
      volId = m_calocell_id->cell_id(subCalo, posneg, sampling, region, eta, phimin);
    }
  }
  else {
    volId = cell_id;
  }
 
  CaloCellVolumeVector::const_iterator it = 
    std::lower_bound (m_cellVolumes.begin(), m_cellVolumes.end(), volId,
              CaloCellVolume_Compare());
  if (it != m_cellVolumes.end() && it->channelID == volId) return it->volume;
 
  return 0.;
}

getFcalTubeSpacing()

double CaloCellVolumes::getFcalTubeSpacing

(

int

sampling

)

Definition at line 181 of file CaloCellVolumes.cxx.

{
  TubeSpacingMap::const_iterator it = m_fcalTubeSpacings.find(sampling);
  if(it==m_fcalTubeSpacings.end())
    throw std::runtime_error("CaloCellVolumes::getFcalTubeSpacing error: wrong sampling provided");
 
  return (*it).second;
}

layout()

const std::string & CaloCellVolumes::layout ( )

inline

Definition at line 32 of file CaloCellVolumes.h.

{ return m_geometryLayout; }

print()

void CaloCellVolumes::print

(

)

Definition at line 164 of file CaloCellVolumes.cxx.

{
  if (m_cellVolumes.empty()) {
    std::cerr << "CaloCellVolumes::print(). No cell volumes..." << std::endl;
  }
  else {
    std::cout << "CaloCellVolumes::print(). Number of volumes found: " 
          << m_cellVolumes.size() << std::endl;
    
    for(const CaloCellVolume& vol : m_cellVolumes) {
      m_calocell_id->print( (Identifier) vol.channelID );
      std::cout << m_calocell_id->show_to_string( (Identifier) vol.channelID );
      std::cout << "   ==> vol= " << vol.volume << "  mm3" << std::endl;
    }
  }
}

Member Data Documentation

m_calocell_id

const CaloCell_ID* CaloCellVolumes::m_calocell_id {nullptr}

private

Definition at line 40 of file CaloCellVolumes.h.

{nullptr};

m_cellVolumes

CaloCellVolumeVector CaloCellVolumes::m_cellVolumes

private

Definition at line 41 of file CaloCellVolumes.h.

m_fcalTubeSpacings

TubeSpacingMap CaloCellVolumes::m_fcalTubeSpacings

private

Initial value:

{
    {1, 7.5}
    , {2, 8.179}
    , {3, 9.}
  }

Definition at line 46 of file CaloCellVolumes.h.

                                   {
    {1, 7.5}
    , {2, 8.179}
    , {3, 9.}
  };

m_geometryLayout

std::string CaloCellVolumes::m_geometryLayout

private

Definition at line 42 of file CaloCellVolumes.h.

---

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

• CaloCellVolumes.h
• CaloCellVolumes.cxx