CaloDmDescrManager Class Reference

#include <CaloDmDescrManager.h>

Collaboration diagram for CaloDmDescrManager:

Public Member Functions
	CaloDmDescrManager ()
	~CaloDmDescrManager ()
int	initialize ()
CaloDmDescrElement *	get_element (const Identifier &cellId) const
CaloDmRegion *	get_dm_region (const Identifier &cellId) const
IdentifierHash	get_dm_hash (const CaloDmRegion *myRegion, float &eta, float &phi) const
int	get_dm_key (const Identifier &cellId) const
int	get_dm_area (const Identifier &cellId) const
void	show_element (const Identifier &cellId) const
std::vector< CaloDmRegion * >::const_iterator	reg_begin (void) const
std::vector< CaloDmRegion * >::const_iterator	reg_end (void) const

Static Public Member Functions
static const CaloDmDescrManager *	instance ()
static CaloCell_ID::CaloSample	get_calo_sample (const std::string &SamplingName)
static CaloCell_ID::CaloSample	get_calo_sample (const std::string &SamplingName, float &etaMin, float &etaMax)

Private Member Functions
CaloDmDescrElement *	build_element (const Identifier &cellId, const CaloDmRegion *myRegion)
StatusCode	load_regions (const std::string &DmRegionFileName)
void	build_element_vector ()

Private Attributes
const CaloDM_ID *	m_caloDM_ID
const AtlasDetectorID *	m_id_helper
ServiceHandle< StoreGateSvc >	m_detStore
std::vector< CaloDmRegion * >	m_DmRegionVector
std::vector< CaloDmDescrElement * >	m_DmElementVector

Detailed Description

Definition at line 131 of file CaloDmDescrManager.h.

Constructor & Destructor Documentation

CaloDmDescrManager()

CaloDmDescrManager::CaloDmDescrManager

(

)

Definition at line 39 of file CaloDmDescrManager.cxx.

  : m_caloDM_ID (nullptr),
    m_id_helper (nullptr),
    m_detStore ("DetectorStore", "CaloDmDescrManager")
{
  initialize();
}

~CaloDmDescrManager()

CaloDmDescrManager::~CaloDmDescrManager

(

)

Definition at line 52 of file CaloDmDescrManager.cxx.

{
  for(unsigned int i = 0; i<m_DmRegionVector.size(); i++) delete m_DmRegionVector[i];
  m_DmRegionVector.clear();
 
  for(unsigned int i = 0; i<m_DmElementVector.size(); i++) delete m_DmElementVector[i];
  m_DmElementVector.clear();
 
}

Member Function Documentation

build_element()

CaloDmDescrElement * CaloDmDescrManager::build_element ( const Identifier & cellId, const CaloDmRegion * myRegion )

private

Definition at line 286 of file CaloDmDescrManager.cxx.

{
  int neta = m_caloDM_ID->eta(id);
  int nphi = m_caloDM_ID->phi(id);
  int subdet = m_caloDM_ID->pos_neg_z(id);
  float eta;
  if(subdet>0){
    eta = myRegion->etaMin() + (0.5+neta)*myRegion->deta();
  } else {
    eta = myRegion->etaMax() - (0.5+neta)*myRegion->deta();
  }
  float phi = myRegion->m_dphi*(0.5+nphi);
  if(phi > M_PI) phi -= 2*M_PI; // we need to have phi=-M_PI,M_PI
  float theta = 2.*std::atan(std::exp(-eta));
  float rho, z;
  if(myRegion->m_isBarrel) {
    rho=myRegion->m_distance*0.1;
    z=rho/std::abs(std::tan(theta));
  }else{
    z=myRegion->m_distance*0.1;
    rho=z*std::abs(std::tan(theta));
  }
  // building new element which will containt real eta, phi values for this identifier
  CaloDmDescrElement *element = new CaloDmDescrElement(eta, myRegion->m_deta, phi, myRegion->m_dphi, rho, z); 
  return element;
}

build_element_vector()

void CaloDmDescrManager::build_element_vector ( )

private

Definition at line 254 of file CaloDmDescrManager.cxx.

{
  if(!m_DmElementVector.empty()) {
    std::cout << "CaloDmDescrManager::build_element_list() -> Warning! Non empty list."
        << " m_DmElementVector.size(): " << m_DmElementVector.size()
        << std::endl;
    return;
  }
 
  m_DmElementVector.resize(m_caloDM_ID->lar_zone_hash_max() + m_caloDM_ID->tile_zone_hash_max());
 
  // loop over all DM LAr identifiers
  for(unsigned int i=0; i<m_caloDM_ID->lar_zone_hash_max(); i++) {
    Identifier id = m_caloDM_ID->lar_zone_id(i);
    Identifier id_reg = m_caloDM_ID->region_id(id);
    IdentifierHash hash_reg = m_caloDM_ID->lar_region_hash(id_reg);
    m_DmElementVector[i] = build_element(id, m_DmRegionVector[hash_reg]);
  }
  // loop over tile identifier
  for(unsigned int i=0; i<m_caloDM_ID->tile_zone_hash_max(); i++) {
    Identifier id = m_caloDM_ID->tile_zone_id(i);
    Identifier id_reg = m_caloDM_ID->region_id(id);
    IdentifierHash hash_reg = m_caloDM_ID->lar_region_hash_max() + m_caloDM_ID->tile_region_hash(id_reg);
    m_DmElementVector[m_caloDM_ID->lar_zone_hash_max() + i] = build_element(id, m_DmRegionVector[hash_reg]);
  }
}

get_calo_sample() [1/2]

CaloCell_ID::CaloSample CaloDmDescrManager::get_calo_sample ( const std::string & SamplingName )

static

Definition at line 481 of file CaloDmDescrManager.cxx.

{
  if ( SamplingName == "PreSamplerB" ) {
    return CaloCell_ID::PreSamplerB;
  } else if ( SamplingName == "EMB1" ) {
    return CaloCell_ID::EMB1;
  } else if ( SamplingName == "EMB2" ) {
    return CaloCell_ID::EMB2;
  } else if ( SamplingName == "EMB3" ) {
    return CaloCell_ID::EMB3;
  } else if ( SamplingName == "PreSamplerE" ) {
    return CaloCell_ID::PreSamplerE;
  } else if ( SamplingName == "EME1" ) {
    return CaloCell_ID::EME1;
  } else if ( SamplingName == "EME2" ) {
    return CaloCell_ID::EME2;
  } else if ( SamplingName == "EME3" ) {
    return CaloCell_ID::EME3;
  } else if ( SamplingName == "HEC0" ) {
    return CaloCell_ID::HEC0;
  }else if ( SamplingName == "HEC1" ) {
    return CaloCell_ID::HEC1;
  }else if ( SamplingName == "HEC2" ) {
    return CaloCell_ID::HEC2;
  }else if ( SamplingName == "HEC3" ) {
    return CaloCell_ID::HEC3;
  }else if ( SamplingName == "TileBar0" ) { 
    return CaloCell_ID::TileBar0;
  }else if ( SamplingName == "TileBar1" ) {
    return CaloCell_ID::TileBar1;
  }else if ( SamplingName == "TileBar2" ) {
    return CaloCell_ID::TileBar2;
  }else if ( SamplingName == "TileGap1" ) {
    return CaloCell_ID::TileGap1;
  }else if ( SamplingName == "TileGap2" ) {
    return CaloCell_ID::TileGap2;
  }else if ( SamplingName == "TileGap3" ) {
    return CaloCell_ID::TileGap3;
  }else if ( SamplingName == "TileExt0" ) {
    return CaloCell_ID::TileExt0;
  }else if ( SamplingName == "TileExt1" ) {
    return CaloCell_ID::TileExt1;
  }else if ( SamplingName == "TileExt2" ) {
    return CaloCell_ID::TileExt2;
  }else if ( SamplingName == "FCAL0" ) {
     return CaloCell_ID::FCAL0;
  }else if ( SamplingName == "FCAL1" ) {
    return CaloCell_ID::FCAL1;
  }else if ( SamplingName == "FCAL2" ) {
    return CaloCell_ID::FCAL2;
  }
  std::cout << "Calorimeter sampling '" << SamplingName
      << "' is not a valid Calorimeter sampling name and will be ignored! " << std::endl;
  return CaloCell_ID::Unknown;
}

get_calo_sample() [2/2]

CaloCell_ID::CaloSample CaloDmDescrManager::get_calo_sample ( const std::string & SamplingName, float & etaMin, float & etaMax )

static

Definition at line 543 of file CaloDmDescrManager.cxx.

{
  CaloCell_ID::CaloSample nsmp = CaloCell_ID::Unknown;
  if ( SamplingName.find("PreSamplerB") != std::string::npos ) {
    nsmp = CaloCell_ID::PreSamplerB;
  } else if ( SamplingName.find("EMB1") != std::string::npos ) {
    nsmp = CaloCell_ID::EMB1;
  } else if ( SamplingName.find("EMB2") != std::string::npos ) {
    nsmp = CaloCell_ID::EMB2;
  } else if ( SamplingName.find("EMB3") != std::string::npos ) {
    nsmp = CaloCell_ID::EMB3;
  } else if ( SamplingName.find("PreSamplerE") != std::string::npos ) {
    nsmp = CaloCell_ID::PreSamplerE;
  } else if ( SamplingName.find("EME1") != std::string::npos ) {
    nsmp = CaloCell_ID::EME1;
  } else if ( SamplingName.find("EME2") != std::string::npos ) {
    nsmp = CaloCell_ID::EME2;
  } else if ( SamplingName.find("EME3") != std::string::npos ) {
    nsmp = CaloCell_ID::EME3;
  } else if ( SamplingName.find("HEC0") != std::string::npos ) {
    nsmp = CaloCell_ID::HEC0;
  }else if ( SamplingName.find("HEC1") != std::string::npos ) {
    nsmp = CaloCell_ID::HEC1;
  }else if ( SamplingName.find("HEC2") != std::string::npos ) {
    nsmp = CaloCell_ID::HEC2;
  }else if ( SamplingName.find("HEC3") != std::string::npos ) {
    nsmp = CaloCell_ID::HEC3;
  }else if ( SamplingName.find("TileBar0") != std::string::npos ) { 
    nsmp = CaloCell_ID::TileBar0;
  }else if ( SamplingName.find("TileBar1") != std::string::npos ) {
    nsmp = CaloCell_ID::TileBar1;
  }else if ( SamplingName.find("TileBar2") != std::string::npos ) {
    nsmp = CaloCell_ID::TileBar2;
  }else if ( SamplingName.find("TileGap1") != std::string::npos ) {
    nsmp = CaloCell_ID::TileGap1;
  }else if ( SamplingName.find("TileGap2") != std::string::npos ) {
    nsmp = CaloCell_ID::TileGap2;
  }else if ( SamplingName.find("TileGap3") != std::string::npos ) {
    nsmp = CaloCell_ID::TileGap3;
  }else if ( SamplingName.find("TileExt0") != std::string::npos ) {
    nsmp = CaloCell_ID::TileExt0;
  }else if ( SamplingName.find("TileExt1") != std::string::npos ) {
    nsmp = CaloCell_ID::TileExt1;
  }else if ( SamplingName.find("TileExt2") != std::string::npos ) {
    nsmp = CaloCell_ID::TileExt2;
  }else if ( SamplingName.find("FCAL0") != std::string::npos ) {
    nsmp = CaloCell_ID::FCAL0;
  }else if ( SamplingName.find("FCAL1") != std::string::npos ) {
    nsmp = CaloCell_ID::FCAL1;
  }else if ( SamplingName.find("FCAL2") != std::string::npos ) {
    nsmp = CaloCell_ID::FCAL2;
  }else {
    std::cout << "CaloDmDescrManager::get_calo_sample() -> Calorimeter sampling '" << SamplingName
        << "' is not a valid Calorimeter sampling name and will be ignored! " << std::endl;
    return CaloCell_ID::Unknown;
  }
  char dummy;
  if(SamplingName.find('(') == std::string::npos || SamplingName.find(')') != SamplingName.size()-1 ){
    std::cout << "CaloDmDescrManager::get_calo_sample() -> Can't parse calorimeter sampling '" << SamplingName << "' string! Something with brackets..." << std::endl;
    return CaloCell_ID::Unknown;
  }
  std::string sEtaRange(SamplingName,SamplingName.find('(')+1);
  std::istringstream iEtaRange( sEtaRange.c_str() );
  if(iEtaRange >> etaMin >> dummy >> etaMax) {
    return nsmp;
  }else{
    std::cout << "CaloDmDescrManager::get_calo_sample() -> Can't parse calorimeter sampling '" << SamplingName << "' string!" << std::endl;
    return CaloCell_ID::Unknown;
  }
}

get_dm_area()

int CaloDmDescrManager::get_dm_area

(

const Identifier &

cellId

)

const

Definition at line 147 of file CaloDmDescrManager.cxx.

{
  int key = get_dm_key(cellId);
  CaloDmDescrElement *el = get_element(cellId);
  return CaloDmDescrArea::getArea(key, el->eta());
}

get_dm_hash()

IdentifierHash CaloDmDescrManager::get_dm_hash	(	const CaloDmRegion *	myRegion,
		float &	eta,
		float &	phi ) const

Definition at line 185 of file CaloDmDescrManager.cxx.

{
  IdentifierHash id_hash;
 
  if(eta < myRegion->etaMin() || eta >= myRegion->etaMax()) {
#ifdef DEBUG
    std::cout << "              input eta out of range"
        << " eta: " << eta
        << " myRegion->m_key: " << myRegion->m_key
        << " myRegion->etaMin(): " << myRegion->etaMin()
        << " myRegion->etaMax(): " << myRegion->etaMax()
        << std::endl;
#endif
    return 0xFFFFFFFF;
  }
  int neta;
  neta=int((eta-myRegion->etaMin())/myRegion->deta());
  if(myRegion->m_side < 0) {
    neta = myRegion->netaMax() - neta - 1;
  }
  float xphi=phi;
  if(xphi<0.0) xphi=2*M_PI+xphi;
  int nphi= int(xphi/myRegion->dphi());
#ifdef DEBUG
  std::cout << "              key: " << myRegion->m_key
      << " side: " << myRegion->m_side
      << " etaMin: " << myRegion->etaMin()
      << " phiMax: " << myRegion->etaMax()
      << " neta: " << neta
      << " nphi: " << nphi
      << " myRegion->netaMax(): " << myRegion->netaMax()
      << " myRegion->nphiMax(): " << myRegion->nphiMax()
      << std::endl;
#endif
  if( (neta >=0 && neta < myRegion->netaMax()) && (nphi >=0 && nphi < myRegion->nphiMax()) ) {
    Identifier id = m_caloDM_ID->zone_id(myRegion->region_id(), neta, nphi);
    if( m_caloDM_ID->is_lar(id) ) {
      id_hash = m_caloDM_ID->lar_zone_hash(id);
    } else if ( m_caloDM_ID->is_tile(id) ) {
      id_hash = m_caloDM_ID->lar_zone_hash_max() + m_caloDM_ID->tile_zone_hash(id);
    }else{
      std::cout <<  "CaloDmDescrManager::get_dm_hash() -> ERROR! p1." << std::endl;
      return 0xFFFFFFFF;
    }
  } else{
    std::cout <<  "CaloDmDescrManager::get_dm_hash() -> ERROR! p2."
        << " key: " << myRegion->m_key
        << " side: " << myRegion->m_side
        << " myRegion->etaMin(): " << myRegion->etaMin()
        << " myRegion->etaMax(): " << myRegion->etaMax()
        << " myRegion->deta(): " << myRegion->deta()
        << " eta: " << eta
        << " phi: " << phi
        << " neta: " << neta
        << " nphi: " << nphi
        << " myRegion->netaMax(): " << myRegion->netaMax()
        << " myRegion->nphiMax(): " << myRegion->nphiMax()
        << std::endl;
  }
  return id_hash;
}

get_dm_key()

int CaloDmDescrManager::get_dm_key

(

const Identifier &

cellId

)

const

Definition at line 132 of file CaloDmDescrManager.cxx.

{
  int subdet = m_caloDM_ID->pos_neg_z(cellId);
  int type = m_caloDM_ID->dmat(cellId);
  int sampling = m_caloDM_ID->sampling(cellId);
  int region = m_caloDM_ID->region(cellId);
  return abs(subdet)*1000+type*100+sampling*10+region;
}

get_dm_region()

CaloDmRegion * CaloDmDescrManager::get_dm_region

(

const Identifier &

cellId

)

const

Definition at line 159 of file CaloDmDescrManager.cxx.

{
  Identifier id_reg = m_caloDM_ID->region_id(cellId);
  IdentifierHash hash_reg;
  if( m_caloDM_ID->is_lar(cellId) ) {
    hash_reg = m_caloDM_ID->lar_region_hash(id_reg);
  } else if ( m_caloDM_ID->is_tile(cellId) ) {
    hash_reg = m_caloDM_ID->lar_region_hash_max() + m_caloDM_ID->tile_region_hash(id_reg);
  } else {
    std::cout <<  "CaloDmDescrManager::get_dm_region-> Error! Wrong dead material identifier! " << m_id_helper->show_to_string(cellId) << std::endl;
    return nullptr;
  }
  if(hash_reg < m_DmRegionVector.size()) {
    return m_DmRegionVector[hash_reg];
  } else {
    std::cout << "CaloDmDescrManager::get_dm_region-> Error! Bad region hash id!" << m_id_helper->show_to_string(cellId) << std::endl;
    return nullptr; 
  }
}

get_element()

CaloDmDescrElement * CaloDmDescrManager::get_element

(

const Identifier &

cellId

)

const

Definition at line 107 of file CaloDmDescrManager.cxx.

{
  IdentifierHash hash;
  if( m_caloDM_ID->is_lar(cellId) ) {
    hash = m_caloDM_ID->lar_zone_hash(cellId);
  } else if ( m_caloDM_ID->is_tile(cellId) ) {
    hash = m_caloDM_ID->lar_zone_hash_max() + m_caloDM_ID->tile_zone_hash(cellId);
  } else {
    std::cout <<  "CaloDmDescrManager::get_element-> Error! Wrong dead material identifier! " << m_id_helper->show_to_string(cellId) << std::endl;
    return nullptr;
  }
  if(hash < m_DmElementVector.size()) {
    return m_DmElementVector[hash];
  } else {
    std::cout << "CaloDmDescrManager::get_element-> Error! Bad hash id for dead material identifier " << hash << std::endl;
    return nullptr; 
  }
}

initialize()

int CaloDmDescrManager::initialize

(

)

Definition at line 77 of file CaloDmDescrManager.cxx.

{
  const std::string& name = "CaloDmDescrManager";
  CHECK_WITH_CONTEXT( m_detStore.retrieve(), name, 1);
  CHECK_WITH_CONTEXT( m_detStore->retrieve(m_caloDM_ID), name, 1);
  CHECK_WITH_CONTEXT( m_detStore->retrieve(m_id_helper), name, 1);
  CHECK_WITH_CONTEXT( load_regions("DeadMaterialRegionDescription_1.10c.txt"), name, 1);
 
  build_element_vector();
 
  return 0;
}

instance()

const CaloDmDescrManager * CaloDmDescrManager::instance ( )

static

Definition at line 67 of file CaloDmDescrManager.cxx.

{
  static const CaloDmDescrManager s_instance;
  return &s_instance;
}

load_regions()

StatusCode CaloDmDescrManager::load_regions ( const std::string & DmRegionFileName )

private

Definition at line 318 of file CaloDmDescrManager.cxx.

{
  MsgStream log(Athena::getMessageSvc(), "CaloDmDescrManager");
 
  char cLine[MAX_BUFFER_LEN];
 
  if(!m_DmRegionVector.empty()) {
    log << MSG::WARNING << "CaloDmDescrManager::build_element_list() -> Warning! Non empty list."
        << " m_DmRegionVector.size(): " << m_DmRegionVector.size()
        << endmsg;
    return StatusCode::FAILURE;
  }
 
  // Find the full path to filename:
  std::string file = PathResolver::find_file (DmRegionFileName, "DATAPATH");
  log << MSG::INFO << "Reading file  " << file << endmsg;
 
  std::ifstream fin(file.c_str());
  if(!fin){
    log << MSG::ERROR << "Can't open file " << file << endmsg;
    return StatusCode::FAILURE;
  }
 
  m_DmRegionVector.resize(m_caloDM_ID->lar_region_hash_max() + m_caloDM_ID->tile_region_hash_max(), nullptr);
  std::string sLine;
  while(fin.getline(cLine,sizeof(cLine)-1)){
    if( strlen(cLine)==0 ||  cLine[0] == '#' || cLine[0] == '\n') continue;
    sLine = std::string(cLine);
    std::istringstream mypars( sLine.c_str() );
 
    int key, distance, isBarrel;
    float etamin, etamax, deta, dphi;
    if(mypars >> key >> etamin >> etamax >> deta >> dphi >> distance >> isBarrel) {
      fin.getline(cLine,sizeof(cLine)-1);
      sLine = std::string(cLine);
      std::istringstream mynei( sLine.c_str() );
      std::string sKey;
      std::vector<short> neighbours;
      std::vector<float> CaloEtaMinVector;
      std::vector<float> CaloEtaMaxVector;
      while (mynei >> sKey) {
        if(sKey.find("CaloSampleNeighbors") != std::string::npos) continue;
        if(sKey.find("Unknown") != std::string::npos) continue;
        float caloEtaMin, caloEtaMax;
        CaloCell_ID::CaloSample nsmp = get_calo_sample(sKey, caloEtaMin, caloEtaMax);
        if(nsmp != CaloCell_ID::Unknown) {
          neighbours.push_back((int)nsmp);
          CaloEtaMinVector.push_back(caloEtaMin);
          CaloEtaMaxVector.push_back(caloEtaMax);
        } else {
          std::cout << "CaloDmDescrManager::load_regions() -> Fromat ERROR in line '" << sLine << "', key '" << sKey << "'" << std::endl;
          return StatusCode::FAILURE;
        }
      } // while over sKey
 
      int subdet=key/1000;
      int type=(key-subdet*1000)/100;
      int sampling=(key-subdet*1000-type*100)/10;
      int region=(key-subdet*1000-type*100-sampling*10)/1;
      if(subdet != 4 && subdet !=5) {
        log << MSG::ERROR << " Error! Wrong subdet " << subdet << ". Format error in line '" << sLine << "', key '" << sKey << "'" << std::endl;
        return StatusCode::FAILURE;
      }
 
      Identifier id_side_neg = m_caloDM_ID->region_id(-subdet, type, sampling, region);
      Identifier id_side_pos = m_caloDM_ID->region_id(subdet, type, sampling, region);
 
      IdentifierHash hash_side_neg;
      IdentifierHash hash_side_pos;
      if(subdet == 4) {
        // lar region
        hash_side_neg = m_caloDM_ID->lar_zone_hash(id_side_neg);
        hash_side_pos  = m_caloDM_ID->lar_zone_hash(id_side_pos);
      } else if (subdet == 5){
        // tile region has shifted position in our vectors
        hash_side_neg = m_caloDM_ID->lar_zone_hash_max() + m_caloDM_ID->tile_zone_hash(id_side_neg);
        hash_side_pos  = m_caloDM_ID->lar_zone_hash_max() + m_caloDM_ID->tile_zone_hash(id_side_pos);
      }
 
      // Making DM region for positive side
      CaloDmRegion *myRegionPos = new CaloDmRegion();
      myRegionPos->m_key=key;
      myRegionPos->m_side=1;
      myRegionPos->m_eta_min=etamin;
      myRegionPos->m_eta_max=etamax;
      myRegionPos->m_deta=deta;
      myRegionPos->m_neta_max=int((etamax-etamin)/deta+0.00001);
      myRegionPos->m_dphi=dphi*(M_PI/3.2);
      myRegionPos->m_nphi_max=int(M_PI*2./myRegionPos->m_dphi+0.00001);
      myRegionPos->m_distance=distance;
      myRegionPos->m_isBarrel=true;
      if(!isBarrel) myRegionPos->m_isBarrel=false;
      // assigning of information over neighboring calo samplings for this DM region
      myRegionPos->m_CaloSampleNeighbours.clear();
      myRegionPos->m_CaloSampleNeighbours = std::move(neighbours);
      myRegionPos->m_CaloSampleEtaMin.clear();
      myRegionPos->m_CaloSampleEtaMin = std::move(CaloEtaMinVector);
      myRegionPos->m_CaloSampleEtaMax.clear();
      myRegionPos->m_CaloSampleEtaMax = std::move(CaloEtaMaxVector);
      // hash index of first DM identifier for this DM region
      myRegionPos->m_region_id = id_side_pos;
      myRegionPos->m_region_hash = hash_side_pos;
 
      // Now making DM region for negative side
      CaloDmRegion *myRegionNeg = new CaloDmRegion(*myRegionPos);
      myRegionNeg->m_side = -1 * myRegionPos->m_side;
      myRegionNeg->m_eta_min = -1 * myRegionPos->m_eta_max;
      myRegionNeg->m_eta_max = -1 * myRegionPos->m_eta_min;
      myRegionNeg->m_region_id = id_side_neg;
      myRegionNeg->m_region_hash = hash_side_neg;
      myRegionNeg->m_CaloSampleEtaMin.clear();
      myRegionNeg->m_CaloSampleEtaMax.clear();
      for(unsigned int i=0; i<myRegionPos->m_CaloSampleNeighbours.size(); i++){
        myRegionNeg->m_CaloSampleEtaMin.push_back( -1.0 * myRegionPos->m_CaloSampleEtaMax[i] );
        myRegionNeg->m_CaloSampleEtaMax.push_back( -1.0 * myRegionPos->m_CaloSampleEtaMin[i] );
      }
 
      // filling vectors 
      if(subdet == 4) {
        m_DmRegionVector[m_caloDM_ID->lar_region_hash(id_side_neg)] = myRegionNeg;
        m_DmRegionVector[m_caloDM_ID->lar_region_hash(id_side_pos)] = myRegionPos;
      } else if (subdet == 5){
        int shift_reg = m_caloDM_ID->lar_region_hash_max();
        m_DmRegionVector[shift_reg + m_caloDM_ID->tile_region_hash(id_side_neg)] = myRegionNeg;
        m_DmRegionVector[shift_reg + m_caloDM_ID->tile_region_hash(id_side_pos)] = myRegionPos;
      }
      // skipping region description
      while(fin.getline(cLine,sizeof(cLine)-1)) {
        if(cLine[0] == '}') break; 
      }
    } else {
      std::cout << "CaloDmDescrManager::load_regions() -> Fromat ERROR in line '" << sLine << "'" << std::endl;
      return StatusCode::FAILURE;
    }
  } // while over lines in file
  fin.close();
 
  log << MSG::INFO << "Loaded " << m_DmRegionVector.size()  << " LAr+Tile dead material regions from " << file << endmsg;
 
//  std::vector<CaloDmRegion *>::const_iterator it = reg_begin();
//  int i_reg = 0;
//  for(; it!=reg_end(); it++){
//    const CaloDmRegion *myRegion = (*it);
//    std::cout << i_reg << "  key: " << myRegion->m_key
//        << "  side: " << myRegion->m_side
//        << "  neta X nphi: " << myRegion->netaMax() << " X " << myRegion->nphiMax()
//        << "  eta:min/max/deta: " << myRegion->etaMin() << " / " << myRegion->etaMax() << " / " << myRegion->deta()
//        << "  hash_id: " << myRegion->region_hash()
//        << " " << m_id_helper->show_to_string(myRegion->region_id())
//        << std::endl;
//    for(unsigned int i_smp=0; i_smp<myRegion->m_CaloSampleNeighbours.size(); i_smp++){
//      std::cout << "     i_smp: " << i_smp << " smp: " << myRegion->m_CaloSampleNeighbours[i_smp] << " smp_eta_min_max: " << myRegion->m_CaloSampleEtaMin[i_smp] << " " << myRegion->m_CaloSampleEtaMax[i_smp] << std::endl;
//    }
//  }
 
  return StatusCode::SUCCESS;
}

reg_begin()

std::vector< CaloDmRegion * >::const_iterator CaloDmDescrManager::reg_begin ( void ) const

inline

Definition at line 169 of file CaloDmDescrManager.h.

{
  return(m_DmRegionVector.begin());
}

reg_end()

std::vector< CaloDmRegion * >::const_iterator CaloDmDescrManager::reg_end ( void ) const

inline

Definition at line 174 of file CaloDmDescrManager.h.

{
  return(m_DmRegionVector.end());
}

show_element()

void CaloDmDescrManager::show_element

(

const Identifier &

cellId

)

const

Definition at line 95 of file CaloDmDescrManager.cxx.

{
  const CaloDmDescrElement *element = get_element(cellId);
  std::cout << "CaloDmDescrManager::check_element() -> Your identifier " << m_id_helper->show_to_string(cellId);
  element->print();
}

Member Data Documentation

m_caloDM_ID

const CaloDM_ID* CaloDmDescrManager::m_caloDM_ID

private

Definition at line 155 of file CaloDmDescrManager.h.

m_detStore

ServiceHandle<StoreGateSvc> CaloDmDescrManager::m_detStore

private

Definition at line 157 of file CaloDmDescrManager.h.

m_DmElementVector

std::vector<CaloDmDescrElement *> CaloDmDescrManager::m_DmElementVector

private

Definition at line 164 of file CaloDmDescrManager.h.

m_DmRegionVector

std::vector<CaloDmRegion *> CaloDmDescrManager::m_DmRegionVector

private

Definition at line 163 of file CaloDmDescrManager.h.

m_id_helper

const AtlasDetectorID* CaloDmDescrManager::m_id_helper

private

Definition at line 156 of file CaloDmDescrManager.h.

---

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

• CaloDmDescrManager.h
• CaloDmDescrManager.cxx