LArHVIdMapping.cxx

Go to the documentation of this file.

/*
  Copyright (C) 2002-2018 CERN for the benefit of the ATLAS collaboration
*/
 
#include "LArRecConditions/LArHVIdMapping.h"
#include "CaloIdentifier/CaloCell_ID.h"
#include "LArIdentifier/LArElectrodeID.h"
#include "LArIdentifier/LArHVLineID.h"
 
 
LArHVIdMapping::LArHVIdMapping(const CaloCell_ID* caloId, const LArHVLineID* hvId, const LArElectrodeID* elId) :
  m_caloHelper(caloId), m_hvlineHelper(hvId), m_electrodeHelper(elId)
 
{
 m_emHelper = m_caloHelper->em_idHelper();
 m_hecHelper = m_caloHelper->hec_idHelper();
 m_fcalHelper = m_caloHelper->fcal_idHelper();
}
 
 
//============================================================================
const HWIdentifier LArHVIdMapping::getLArHVLineID(HWIdentifier& electrodeId) const
//============================================================================
{
 
  
  std::map<HWIdentifier,HWIdentifier>::const_iterator elecIt = m_electrode_hvline_map.find(electrodeId);
  if(elecIt != m_electrode_hvline_map.end()) {
    HWIdentifier hvlineId = (elecIt)->second;
    // commented out, until proper messaging will be added
    /*
    if (msgLvl(MSG::DEBUG)) {
    const int dete = m_electrodeHelper->detector(electrodeId);
    const int side = m_electrodeHelper->zside(electrodeId);
    const int modu = m_electrodeHelper->module(electrodeId);
    const int hvph = m_electrodeHelper->hv_phi(electrodeId);
    const int hvet = m_electrodeHelper->hv_eta(electrodeId);
    const int hvga = m_electrodeHelper->gap(electrodeId);
    const int elec = m_electrodeHelper->electrode(electrodeId);
    const int part = m_hvlineHelper->partition(hvlineId);
    const int canl = m_hvlineHelper->can_line(hvlineId);
    const int cann = m_hvlineHelper->can_node(hvlineId);
    const int hvli = m_hvlineHelper->hv_line(hvlineId);
    msg(MSG::DEBUG) << "[getLArHVLineID] input ElectrodeId=["
            << dete << "." << side << "." << modu << "." << hvph 
            << "." << hvet << "." << hvga << "." << elec << "]" 
            << " corresponding hvlineID=[" 
            << part << "." << canl << "." << cann << "." << hvli << "]... OK "
            << endmsg;
      }//end if debug
      */
    return hvlineId;
  } 
  else {
    // commented out, until the proper messaging will be added
    /* 
    int dete = m_electrodeHelper->detector(electrodeId);
    int side = m_electrodeHelper->zside(electrodeId);
    int modu = m_electrodeHelper->module(electrodeId);
    int hvph = m_electrodeHelper->hv_phi(electrodeId);
    int hvet = m_electrodeHelper->hv_eta(electrodeId);
    int hvga = m_electrodeHelper->gap(electrodeId);
    int elec = m_electrodeHelper->electrode(electrodeId);
 
    int part = m_hvlineHelper->partition(invalidId);
    int canl = m_hvlineHelper->can_line(invalidId);
    int cann = m_hvlineHelper->can_node(invalidId);
    int hvli = m_hvlineHelper->hv_line(invalidId);
    ATH_MSG_WARNING( "[getLArHVLineID] NO MAP for ElectrodeId=["
        << dete << "." << side << "." << modu << "." << hvph 
        << "." << hvet << "." << hvga << "." << elec << "] returning [" 
        << part << "." << canl << "." << cann << "." << hvli << "]... OK ");
    */    
    HWIdentifier invalidId =  m_hvlineHelper->HVLineId(0,0,0,0);    
    return (invalidId);
 
    //return m_hvmapHelper->getLArHVLineID( electrodeId ) ; 
  }
  // if the map exists, use the mapping object
}
 
 
//========================================================================================
const std::vector<HWIdentifier>& LArHVIdMapping::getLArElectrodeIDvec(HWIdentifier &hvlineId) const
//========================================================================================
{// Start of getLArElectrodeIdvec()
  //ATH_MSG_VERBOSE("Entering getLArElectrodeIDvec( hvlineId )" );
  std::map<HWIdentifier,std::vector<HWIdentifier> >::const_iterator elecIt=m_hvline_electrode_map.find(hvlineId);
  if( elecIt != m_hvline_electrode_map.end()){
    return (elecIt)->second;
  }
  else{
    // commented out, until proper messaging will be added
    /* 
    int part = m_hvlineHelper->partition(hvlineId);
    int canl = m_hvlineHelper->can_line(hvlineId);
    int cann = m_hvlineHelper->can_node(hvlineId);
    int hvli = m_hvlineHelper->hv_line(hvlineId);
    msg(MSG::WARNING) << "LArHVCablingSvc: getLArElectrodeIDvec didnot find electrode to hvline [" 
        << part << "." << canl << "." << cann << "." << hvli << "]" << endmsg;
    */    
    return(m_invalid);
  }
  //return m_hvmapHelper->getLArElectrodeIDvec( hvlineId ); 
}
 
//=====================================================================
int LArHVIdMapping::getCellModule( const Identifier &offId ) const
//=====================================================================
//  Returns the LArModule index as an integer
//
//  Last Modified:
//  05-FEB-2007 AL fixed FCAL info --thanks to Zhaoyu Yang
//  02-FEB-2007 AL added Module info for FCAL 
//  31-JAN-2007 AL reversed ModuleID returned for EMEC C-side 
//
// =====================================================================
{// Start of getCellModule
  //======================================
  //ATH_MSG_VERBOSE("Entering getCellModule " );
 
  int bec      =-99;
  int sampling =-99;
  int region   =-99;
  int phi      =-99;
  //int module   =-99;
  // Returned Value
  // =====================================
  int ModuleID =-99;
 
  // Identify the Helper to be used 
  // =====================================
  if( m_caloHelper->is_em( offId ) ){
    bec      = m_emHelper->barrel_ec(offId);
    sampling = m_emHelper->sampling(offId);
    region   = m_emHelper->region(offId);
    phi      = m_emHelper->phi(offId);
    //ATH_MSG_DEBUG("[getCellModule] processing an EM cell.." );
  }
  else if( m_caloHelper->is_hec( offId )  ){
    bec      = m_hecHelper->pos_neg(offId)*10; 
    sampling = m_hecHelper->sampling(offId);
    region   = m_hecHelper->region(offId);
    phi      = m_hecHelper->phi(offId);
    //ATH_MSG_DEBUG("[getCellModule] processing an HEC cell.." );
  }
  else if( m_caloHelper->is_fcal( offId )){
    bec      = m_fcalHelper->pos_neg(offId)*20; 
    sampling = m_fcalHelper->module(offId);
    //module   = m_fcalHelper->module(offId);
    phi      = m_fcalHelper->phi(offId);
    //ATH_MSG_DEBUG("[getCellModule] processing an FCAL cell.." );
  }
 
  // Now determine the Module ID 
  if( abs(bec) == 1 ){
    // EM BARREL
    // ===========================================================================
    // x being the ATLAS x direction (pointing towards the center of the collider)
    // we have :             
    //                        SIDE - C (z<0)               SIDE - A (z>0)
    //                        -------------                --------------
    //                          C04                            A04
    //                      C03    C05                      A05   A03  
    //                     C02        C06                 A06       A02    
    //                    C01          C07               A07          A01
    //                    C00----------C08-->X           A08----------A00---> X
    //                    C15          C09               A09          A15
    //                      C14       C10                 A10        A14
    //                       C13    C11                     A11   A13      
    //                          C12                            A12 
    //============================================================================
    if( bec == 1 ){
      // A-WHEEL 
      // =======
      if( sampling == 0 ){
    // ------------------------------
    // 32 Modules of two cells in phi
    // ------------------------------
    int phi_module=int(phi/2);
    ModuleID = phi_module;
      }
      else if( sampling == 1 && region == 0 ){
    // -----------------------------
    // 16 Modules of 4 cells in phi 
    // -----------------------------
    int phi_module = int((phi+2)/4);
    if( phi_module == 16 ){
      ModuleID = 0;
    }
    else{
      ModuleID = phi_module;
    }
      }
      else if( sampling == 2 || sampling == 3 || (sampling == 1 && region == 1 ) ){
    // -----------------------------
    // 16 Modules of 16 cells in phi
    // -----------------------------
    int phi_module = int((phi+8)/16);
    if( phi_module == 16 ){
      ModuleID=0;
    }
    else{
      ModuleID=phi_module;
    }
      }
    }
    
    else if( bec == -1 ){
      // C-WHEEL 
      // =======
      if( sampling == 0 ){
    // ------------------------------
    // 32 Modules of two cells in phi
    // ------------------------------
    int phi_module=int(phi/2);
    if( phi_module <= 15 ){
      phi_module = 15 - phi_module; 
    }
    else{
      phi_module = 47 - phi_module;
    }
    ModuleID = phi_module;
      }
      else if( sampling == 1 && region == 0 ){
    // -----------------------------
    // 16 Modules of 4 cells in phi 
    // -----------------------------
    int phi_module = int((phi+2)/4);
    if( phi_module <= 8){
      phi_module = 8 - phi_module;
    }
    else{
      phi_module = 24 - phi_module;
    }
    ModuleID = phi_module;
      }
      else if( sampling == 2 || sampling == 3 || (sampling == 1 && region == 1 ) ){
    // -----------------------------
    // 16 Modules of 16 cells in phi
    // -----------------------------
    int phi_module = int((phi+8)/16);
    if( phi_module <= 8){
      phi_module = 8 - phi_module;
    }
    else{
      phi_module = 24 - phi_module;
    }
    ModuleID = phi_module;
      }
    }
  }
 
  else if( abs(bec) == 2 || abs(bec) == 3){
    // EMEC 
    // ----
    //
    // x being the ATLAS x direction (pointing towards the center of the collider)
    // we have :             
    //                        SIDE - C                      SIDE - A
    //                        --------                     -----------
    //
    //                        ECC1  ECC2                    ECA2   ECA1    
    //                              
    //                     ECC0         ECC3             ECA3        ECA0
    //                            -------------> X               -----------> X
    //                     ECC7         ECC4             ECA4        ECA7
    //                                                           
    //                        ECC6  ECC5                    ECA5   ECA6    
    //
    //
    if( bec > 0 ){
      // SIDE - A
      if( sampling == 0 || sampling == 1 || 
      (sampling == 2 && abs(bec) == 3 ) ){
    // -------------------------------
    // 8 Modules of 8 cells in phi
    // -------------------------------
    // Sampling 0, 1 (inner+outer) & 2 region 0 (inner)
    //
    int phi_local = int(phi/8);
    ModuleID = phi_local;
      }
      else if( (sampling == 2 && abs(bec) == 2) || (sampling == 3 && abs(bec) == 2)){
    // ----------------------------------------
    // 8 Modules of 32 cells in phi
    // ----------------------------------------
    // Sampling 2 & 3 ( outer wheel) in [0,255] 
    // 
    int phi_local = int(phi/32);
    ModuleID = phi_local;
      }
    }
    else{
      // SIDE-C
      if( sampling == 0 || sampling == 1 || 
      (sampling == 2 && abs(bec) == 3 ) ){
    // ------------------------------
    // 8 Modules of 8 cells in phi
    // -------------------------------
    // Sampling 0, 1 & 2( inner wheel) in [0,63] 
    //
    int rev_phi=-99;
    int phi_local = int(phi/8);
    if( phi_local == 0 ){rev_phi = 3;}
    if( phi_local == 1 ){rev_phi = 2;}
    if( phi_local == 2 ){rev_phi = 1;}
    if( phi_local == 3 ){rev_phi = 0;}
    if( phi_local == 4 ){rev_phi = 7;}
    if( phi_local == 5 ){rev_phi = 6;}
    if( phi_local == 6 ){rev_phi = 5;}
    if( phi_local == 7 ){rev_phi = 4;}
    ModuleID = rev_phi;
      }
      else if( (sampling == 2 && abs(bec) == 2) || (sampling == 3 && abs(bec) == 2)){
    // ----------------------------------------
    // 8 Modules of 32 cells in phi
    // ----------------------------------------
    // Sampling 2 & 3 ( outer wheel) in [0,255] 
    //
    int rev_phi=-99; 
    int phi_local = int(phi/32);
    if( phi_local == 0 ){rev_phi = 3;}
    if( phi_local == 1 ){rev_phi = 2;}
    if( phi_local == 2 ){rev_phi = 1;}
    if( phi_local == 3 ){rev_phi = 0;}
    if( phi_local == 4 ){rev_phi = 7;}
    if( phi_local == 5 ){rev_phi = 6;}
    if( phi_local == 6 ){rev_phi = 5;}
    if( phi_local == 7 ){rev_phi = 4;}
    ModuleID = rev_phi;
      }
    }
  }
 
 
  else if( abs(bec) == 20 ){
    // HEC Detector
    // ============
    if( bec > 0){
      // WHEEL A
      if( region == 0 ){
    // OUTER WHEEL
    // ----------------------------
    // 32 Modules of 2 cells in phi
    // ----------------------------
    int phi_module=int(phi/2);
    ModuleID = phi_module;
      }
      else if( region == 1){
    // INNER WHEEL
    // ----------------------------
    // 32 Modules of 1 cells in phi
    // ----------------------------
    int phi_module=int(phi);
    ModuleID = phi_module;
      } 
    }
    else if( bec < 0){
      // WHEEL C
      if( region == 0 ){
    // OUTER WHEEL
    // -----------
    int phi_module=int(phi/2);
    if( phi_module <= 15 ){
      phi_module = 15 - phi_module; 
    }
    else{
      phi_module = 47 - phi_module;
    }
    ModuleID = phi_module;
      }
      else if( region == 1){
    // INNER WHEEL
    // -----------
    int phi_module=int(phi);
    if( phi_module <= 15 ){
      phi_module = 15 - phi_module; 
    }
    else{
      phi_module = 47 - phi_module;
    }
    ModuleID = phi_module;  
      }  
    }
  }
  // ===========================================================================
  // x being the ATLAS x direction (pointing towards the center of the collider)
  // we have :             
  //                        SIDE - C (z<0)               SIDE - A (z>0)
  //                        -------------                --------------
  //                          C04                            A04
  //                      C03    C05                      A05   A03  
  //                     C02        C06                 A06       A02    
  //                    C01          C07               A07          A01
  //                    C00----------C08-->X           A08----------A00---> X
  //                    C15          C09               A09          A15
  //                      C14       C10                 A10        A14
  //                       C13    C11                     A11   A13      
  //                          C12                            A12 
  //============================================================================
  
  else if( abs(bec) == 40 ){
    // FCAL Detector
    // ==============
    // FCAL-Module 1   : EM 
    // FCAL-Module 2,3 : Hadronic
    // -> 16 cells in phi per Module
    // ==============================
    if( sampling == 1){
      ModuleID = int(phi);
    }
    else if( sampling == 2 ){
      ModuleID = int(phi/2);
    }
    else if( sampling == 3){
      ModuleID = int(phi/4);
    }
  }
  else{
    //msg(MSG::WARNING) << " -->> Invalid MODULE returned " << endmsg;
  }
  //ATH_MSG_DEBUG("Closing getCellModule " );
  return ModuleID;
}
 
 
 
//===================================================================
int LArHVIdMapping::getCellEtaSector( const Identifier &offId ) const
//===================================================================
// Returns the HV eta sector given an cell ID as an integert
//
// 05-FEB-2007 : AL added FCAL info from Zhaoyu
//
// 11-FEB-2005: modified getHVEtaSector to return an int.
// 25-NOV-2004: AL Added EMEC 
// 09-DEC-2004: AL fixed EMBPS : change from 8 to 4 HV-sectors in Eta (08-DEC-2004)
//                & fixed EMEC   
// 15-DEC-2004: AL added HEC wheels
//===================================================================
{// Start of getHVEtaSector()
  //ATH_MSG_VERBOSE("Entering getCellEtaSector ...." );
 
  std::string l_version = m_emHelper->dictionaryVersion();
 
  // Returned Value
  int l_bec   =-99;
  int sampling=-99;
  int region  =-99;
  int ieta    =-99;
  // Identify the Helper to be used 
  // =====================================
  if( m_caloHelper->is_em( offId ) ){
    l_bec    = m_emHelper->barrel_ec(offId);
    sampling = m_emHelper->sampling(offId);
    region   = m_emHelper->region(offId);
    ieta     = m_emHelper->eta(offId);
  }
  else if( m_caloHelper->is_hec( offId )  ){
    l_bec    = m_hecHelper->pos_neg(offId)*10; 
    sampling = m_hecHelper->sampling(offId);
    region   = m_hecHelper->region(offId);
    ieta     = m_hecHelper->eta(offId);
  }
  else if( m_caloHelper->is_fcal( offId )  ){
    l_bec    = m_fcalHelper->pos_neg(offId)*20; 
    sampling = m_fcalHelper->module(offId);
  }
 
  // Output argument
  // =====================================
  int hvEta=-99;
 
  // Construct heEta
  // =====================================
  if( abs(l_bec) == 1 ){
    // BARREL 
    if( sampling == 1 )
      {// FRONT sampling
    if( region == 0 ){
      if( ieta >= 0 && ieta < 64 ){
        hvEta=1;
      } 
      else if( ieta >=64 && ieta < 128 ){
        hvEta=2;
      }
      else if( ieta >=128 && ieta < 192 ){
        hvEta=3;
      }
      else if( ieta >=192 && ieta < 256 ){
        hvEta=4;
      }
      else if( ieta >=256 && ieta < 320 ){
        hvEta=5;
      }
      else if( ieta >=320 && ieta < 384 ){
        hvEta=6;
      }
      else if( ieta >=384 && ieta < 448 ){
        hvEta=7;
      }
    }
    else if( region == 1){
      hvEta=7;
    }
    else {
      //msg(MSG::WARNING) << "==> Invalid HV Eta-Sector for sampling=" << sampling << " Region=" << region << " I(eta)="<< ieta << endmsg;
    }
      } 
    else if( sampling == 2 ){
      // MIDDLE Sampling in Barrel
      // ----------------------
      // 
      if( region == 0 ){
    if( ieta >= 0 && ieta < 8 ){
      hvEta=1;
    } 
    else if( ieta >=8 && ieta < 16 ){
      hvEta=2;
    }
    else if( ieta >=16 && ieta < 24 ){
      hvEta=3;
    }
    else if( ieta >=24 && ieta < 32 ){
      hvEta=4;
    }
    else if( ieta >=32 && ieta < 40 ){
      hvEta=5;
    }
    else if( ieta >=40 && ieta < 48 ){
      hvEta=6;
    }
    else if( ieta >=48 && ieta < 57 ){
      hvEta=7;
    }
      }
      else if( region == 1)
    {
      hvEta=7; // to be checked with Francesco
      
    }
      else{
    //msg(MSG::WARNING) << "==> Invalid HV Eta-Sector for sampling=" << sampling << " Region=" << region << " I(eta)="<< ieta << endmsg; 
      }
    }
    else if( sampling == 3 ){
      // BACK Sampling in Barrel
      // -----------------------
      //
      if( region == 0 ){
    if( ieta >= 0 && ieta < 4 ){
      hvEta=1;
    } 
    else if( ieta >=4 && ieta < 8 ){
      hvEta=2;
    }
    else if( ieta >=8 && ieta < 12 ){
      hvEta=3;
    }
    else if( ieta >=12 && ieta < 16 ){
      hvEta=4;
    }
    else if( ieta >=16 && ieta < 20 ){
      hvEta=5;
    }
    else if( ieta >=20 && ieta < 24 ){
      hvEta=6;
    }
    else if( ieta >=24 && ieta < 28 ){
      hvEta=7;
    }
      }
      else if( region == 1){
    //msg(MSG::WARNING) << "==> Invalid HV Eta-Sector for sampling=" << sampling << " Region=" << region << " I(eta)="<< ieta << endmsg; 
      }
      else{
    //msg(MSG::WARNING) << "==> Invalid HV Eta-Sector for sampling=" << sampling << " Region=" << region << " I(eta)="<< ieta << endmsg; 
      }
    }
    
    else if( sampling == 0 ){ 
      // PreSampler Sampling in Barrel
      // -----------------------------
      if( region == 0 ){
    // OKed by JY Hostachy
    if( ieta <= 60 ){
      if( ieta >= 0 && ieta < 15 ){
        hvEta=1;
      } 
      else if( ieta >=15 && ieta <30  ){
        hvEta=2;
      }
      else if( ieta >=30 && ieta < 45 ){
        hvEta=3;
      }
      else if( ieta >=45 && ieta < 61 ){
        hvEta=4;
      }
    }
    else{
      //msg(MSG::WARNING) << "Not in EMBPS..i(eta)=" << ieta << endmsg;
    }
      }
    }
    else {
      //msg(MSG::WARNING) << "Not in Barrel ..." << endmsg;
    }
  }
  else if( abs(l_bec) == 2 || abs(l_bec) == 3){ 
    // ENDCAP EMEC 
    // -----------
    //
    if( sampling == 3 ){ 
      // Sampling 3 OUTER Wheel
      // -----------------------
      // Validated on NOV-25-2004 with Djama (CPPM)
      // 
      if( ieta >= 0 && ieta <= 1){
    hvEta=1;
      }
      else if(ieta >=2 && ieta <= 5){
    hvEta=2;
      }
      else if(ieta >=6 && ieta <= 9){
    hvEta=3;
      }
      else if(ieta >=10 && ieta <= 11){
    hvEta=4;
      }
      else if(ieta >=12 && ieta <= 15){
    hvEta=5;
      }
      else if(ieta >=16 && ieta <= 19){
    hvEta=6;
      }
    }
    else if( sampling == 2 && abs(l_bec) == 2 ){
      // Sampling 2 OUTER Wheel 
      // ----------------------
      //
      // Validated on NOV-25-2004 with Djama (CPPM)
      // 
      if(region == 0){
    hvEta =0;
      }
      else if( region == 1 ){
    // region 1 Sampling 2
    if( ieta >=0 && ieta <= 2){
      hvEta=0;
    }
    else if( ieta >=3 && ieta <= 6){
      hvEta=1;
    }
    else if( ieta >=7 && ieta <= 15){
      hvEta=2;
    }
    else if( ieta >=16 && ieta <= 23){
      hvEta=3;
    }
    else if( ieta >=24 && ieta <= 27){
      hvEta=4;
    }
    else if( ieta >=28 && ieta <= 35){
      hvEta=5;
    }
    else if( ieta >=36 && ieta <= 42){
      hvEta=6;
    }
      }
    }
 
    else if( sampling == 2 && abs(l_bec) == 3 ){
      // Sampling 2 INNER Wheel 
      // -----------------------
      // 
      // Validated on NOV-25-2004 with Djama (CPPM)
      // 
    if( ieta >=0 && ieta <= 2){
      hvEta=7;
    }
    else if( ieta >=3 && ieta <= 6){
      hvEta=8;
    }
    }
 
    else if( sampling == 1 && abs(l_bec) == 3 ){ 
      // Sampling 1 INNER Wheel 
      // -----------------------
      // 
      // Validated on NOV-25-2004 with Djama (CPPM)
      // 
    if( ieta >=0 && ieta <= 2){
      hvEta=7;
    }
    else if( ieta >=3 && ieta <= 6){
      hvEta=8;
    }
    }
 
    else if( sampling == 1 && abs(l_bec) == 2 ){
      // Sampling 1 OUTER Wheel 
      // -----------------------
      // 
      if( region == 0 || region == 1)
    {// 1.375 < eta < 1.5
      hvEta=0;
    }
      else if( region == 2 ){
    if( ieta >= 0 && ieta <= 31)
      {
        // 1.5 < eta < 1.6
        hvEta = 1;
      }
    else if( ieta <= 95) {
      // 1.6 < eta < 1.8
      hvEta = 2;
    }
      }
      else if(region == 3){
    // 1.8 < eta < 2.0
    hvEta = 3;
      }
      else if(region == 4){
    // 2.0 < eta < 2.4 
    if( ieta >=0 && ieta <= 15 ){
      // 2.0 < eta < 2.1 
      hvEta = 4;
    }
    else if( ieta >= 16 && ieta <= 47 ){
      // 2.1 < eta < 2.3 
      hvEta = 5;
    }
    else if( ieta >= 48 && ieta <= 63 ){
      // 2.3 < eta < 2.4
      hvEta = 6;
    }
      }
      else if( region == 5 ){
    // 2.4 < eta < 2.5 
    hvEta = 6;
      }
    }
  }
 
 
  else if( abs(l_bec)== 20 ){
    // HEC Wheels
    //-----------
    if( sampling == 0 ){
      hvEta = 1;
    }
    else if( sampling == 1){
      hvEta = 2;
    }
    else if( sampling == 2){
      hvEta = 3;
    }
    else if( sampling == 3){
      hvEta = 4;
    }
  }
  // ============================
  // FCAL eta bins
  // eta = [0,62] in Module 1
  // eta = [0,31] in Module 2 
  // eta = [0,15] in Module 3
  // ============================
  else if( abs(l_bec)== 40 ){
    // FCAL Wheels
    //-----------
    if( sampling == 1 ){
      hvEta = 1;
    }
    else if( sampling == 2 ){
      hvEta = 2;
    }
    else if( sampling == 3 ){
      hvEta = 3;
    }
    else{
      //msg(MSG::WARNING) 
      //      << "[getCellEtaSector] invalid FCAL input cell.." << endmsg;
    }
  }
  else{
    //msg(MSG::WARNING) << "[getCellModule] Detector unknown ! " << endmsg;
  }
  // Output 
  //ATH_MSG_DEBUG("Closing getCellEtaSector ...." );
  return hvEta;
}
 
 
 
 
//=====================================================================
int LArHVIdMapping::getCellPhiSector( const Identifier &offId ) const
//=====================================================================
// Returns the phi-sector used number for a given cell 
//
// 23-JAN-2007 AL change of convention for EMB :
//   now returns hv_phi = 0 for FT=-1 (prev. 1) 
//               hv_phi = 1 for FT= 0 (prev. 0)
//
// 09-FEB-2005 AL fixed for H8 (module A00 rotated)
// 09-DEC-2004 AL created from getLArFeefdthrough(int,int,int,int)
//     - Added H8-EMBPS returning FT=0
//     - Corrected for reversed order for C-Wheel 
// 16-DEC-2004 AL added HEC and H6-HEC (which returns 0)
// 14-JAN-2005 AL added H6-EMEC
//     - Added H6-EMEC returning FT=0 
//=====================================================================
{// Start of getCellPhiSector()
  //ATH_MSG_VERBOSE("Entering getCellPhiSector ...." );
  //
  // Get relevant offline fields
  //
  int bec      =99;
  int sampling=-99;
  int region  =-99;
  int phi     =-99;
 
  if( m_caloHelper->is_em( offId ) ){
    bec      = m_emHelper->barrel_ec(offId);
    sampling = m_emHelper->sampling(offId);
    region   = m_emHelper->region(offId);
    phi      = m_emHelper->phi(offId);
  }
  else if( m_caloHelper->is_hec( offId )  ){
    bec      = m_hecHelper->pos_neg(offId)*10; 
  }
  else if( m_caloHelper->is_fcal( offId )  ){
    bec      = m_fcalHelper->pos_neg(offId)*20; // ie: +/-40
  }
  // Output Argument
  int hvPhi=-2;
  //
  //*** Note*** : 
  //
  // For EMB, Feedthrough (FT) takes value -1 and 0
  // Instead, we encode these values as:
  // FT = -1 --> hvPhiSector = 1
  // FT =  0 --> hvPhiSector = 0
  // 
  if( abs(bec) == 1){
    // EMBARREL
    //----------
    if( bec == 1){
      // WHEEL-A
      //--------
      if( sampling == 0 ){
    // ------------------------------
    // EMBPS : phiSector not relevant
    // ------------------------------
    hvPhi = 0;
      }
      if( sampling == 1 && region == 0 ){
    // --------------------------------- 
    // EM1 Region 0: phi-cells in [0,63]
    // --------------------------------- 
    //
    int phi_local = int(phi);
    for(int ift=0; ift<= 15; ift++){
      if( phi_local == ift*4 || phi_local == 1+ift*4 ){
        hvPhi = 0;
      }
      if( phi_local == 2+ift*4 || phi_local == 3+ift*4 ){
        hvPhi = 1;
      }
    }
      }
      else if( sampling == 2 || sampling == 3 || (sampling == 1 && region == 1 ) ){
    // ----------------------------------------------
    // FRONT Region 1 + MIDDLE + BACK Phi in [0,255]
    // ----------------------------------------------
    int phi_local = int(phi);
    for( int ift=0; ift<= 15; ift++){
      for( int i=0; i<=7; i++){
        if( phi_local == i+ift*16 ){
          hvPhi = 0;
        }
      }
      for( int i=8; i<=15; i++){
        if( phi_local == i+ift*16 ){
          hvPhi = 1;
        }
      }
    }
      }
    }
 
    else if( bec == -1){
      // WHEEL-C
      //--------
      if( sampling == 0 ){
    // ------------------------------
    // EMBPS : phiSector not relevant
    // ------------------------------
    hvPhi = 0;
      }
      if( sampling == 1 && region == 0 ){
    // ---------------------------------------
    // FRONT (Region 0): phi-cells in [0,63]
    // --------------------------------------- 
    int phi_local = int(phi);
    for(int ift=0; ift<= 15; ift++){
      if( phi_local == ift*4 || phi_local == 1+ift*4 ){
        hvPhi = 1;
      }
      if( phi_local == 2+ift*4 || phi_local == 3+ift*4 ){
        hvPhi = 0;
      }
    }
      }
      else if( sampling == 2 || sampling == 3 || (sampling == 1 && region == 1 ) ){
    // FRONT Region 1 + MIDDLE + BACK Phi in [0,255]
    int phi_local = int(phi);
    for( int ift=0; ift<= 15; ift++){
      for( int i=0; i<=7; i++){
        if( phi_local == i+ift*16 ){
          hvPhi = 1;
        }
      }
      for( int i=8; i<=15; i++){
        if( phi_local == i+ift*16 ){
          hvPhi = 0;
        }
      }
    }
      }
    }    
  }
  
  else if( abs(bec) == 2 || abs(bec) == 3 ){
    // EMEC
    if( bec > 0 ){
      // WHEEL-A
      if( sampling == 1 && abs(bec) == 2 ){
    // ====================================
    // Sampling 1 OUTER Wheel 
    // =====================================
    // 64 cells per SIDE
    //  8 Modules per side
    //  --> 8 cells / module
    //  4 FT per module [1,4]
    //  --> 2 cells / FT
    // =====================================
    int imod=int(phi/8);
    int phi_local = phi - imod*8;
    if( phi_local == 0 || phi_local == 1){
      hvPhi = 1;
    }
    else if( phi_local == 2 || phi_local == 3){
      hvPhi = 2;
    }
    else if( phi_local == 4 || phi_local == 5){
      hvPhi = 3;
    }
    else if( phi_local == 6 || phi_local == 7){
      hvPhi = 4;
    }
      }
      if( sampling == 1 && abs(bec) == 3 ){
    // Sampling 1 INNER Wheel (FT in [1,8])
    // ------------------------------------
    // 
    int imod=int(phi/8);
    int phi_local = phi-imod*8;
    hvPhi = phi_local+1;
      }
      else if( sampling == 2 && abs(bec) == 3 ){
    //
    // Sampling 2 Inner Wheel (FT in [1,8])
    // ------------------------------------
    //
    int imod=int(phi/8);
    int phi_local = phi - imod*8;
    hvPhi = phi_local+1;
      }
      else if( sampling == 2 && abs(bec) == 2 ){
    //
    // Sampling 2 Outer Wheel (FT in [1,4])
    // ------------------------------------
    //
    int imod = (phi/32);
    int phi_local= phi-imod*32;
    if( phi_local >= 0 && phi_local <= 7 ){
      hvPhi = 1;
    }
    else if( phi_local >= 8 && phi_local <= 15 ){
      hvPhi = 2;
    }
    else if( phi_local >= 16 && phi_local <= 23 ){
      hvPhi = 3;
    }
    else if( phi_local >= 24 && phi_local <= 31 ){
      hvPhi = 4;
    }
      }
      else if( sampling == 3 ){
    //
    // Sampling 3 Outer Wheel (FT in [1,4])
    // ------------------------------------
    // 
    int imod = (phi/32);
    int phi_local= phi-imod*32;
    if( phi_local >= 0 && phi_local <= 7 ){
      hvPhi = 1;
    }
    else if( phi_local >= 8 && phi_local <= 15 ){
      hvPhi = 2;
    }
    else if( phi_local >= 16 && phi_local <= 23 ){
      hvPhi = 3;
    }
    else if( phi_local >= 24 && phi_local <= 31 ){
      hvPhi = 4;
    }
      }
    }
    else if( bec < 0 ){
      // WHEEL-C
      if( sampling == 1 && abs(bec) == 2 ){
    // Sampling 1 OUTER Wheel (FT in [1,4])
    // ------------------------------------
    int imod=int(phi/8);
    int phi_local = phi-imod*8;
    if( phi_local == 0 || phi_local == 1){
      hvPhi = 4;
    }
    else if( phi_local == 2 || phi_local == 3){
      hvPhi = 3;
    }
    else if( phi_local == 4 || phi_local == 5){
      hvPhi = 2;
    }
    else if( phi_local == 6 || phi_local == 7){
      hvPhi = 1;
    }
      }
      if( sampling == 1 && abs(bec) == 3 ){
    // Sampling 1 INNER Wheel (FT in [1,8])
    // ------------------------------------
    // 
    int imod=int(phi/8);
    int phi_local = phi - imod*8;
    hvPhi = 8-(phi_local);
      }
      else if( sampling == 2 && abs(bec) == 3 ){
    // Sampling 2 Inner Wheel (FT in [1,8])
    // ------------------------------------
    int imod=int(phi/8);
    int phi_local = phi-imod*8;
    hvPhi = 8-(phi_local);
      }
      else if( sampling == 2 && abs(bec) == 2 ){
    // Sampling 2 Outer Wheel (FT in [1,4])
    // ------------------------------------
    int imod = (phi/32);
    int phi_local= phi-imod*32;
    if( phi_local >= 0 && phi_local <= 7 ){
      hvPhi = 4;
    }
    else if( phi_local >= 8 && phi_local <= 15 ){
      hvPhi = 3;
    }
    else if( phi_local >= 16 && phi_local <= 23 ){
      hvPhi = 2;
    }
    else if( phi_local >= 24 && phi_local <= 31 ){
      hvPhi = 1;
    }
      }
      else if( sampling == 3 ){
    // Sampling 3 Outer Wheel (FT in [1,4])
    // ------------------------------------
    int imod = (phi/32);
    int phi_local= phi-imod*32;
    if( phi_local >= 0 && phi_local <= 7 ){
      hvPhi = 4;
    }
    else if( phi_local >= 8 && phi_local <= 15 ){
      hvPhi = 3;
    }
    else if( phi_local >= 16 && phi_local <= 23 ){
      hvPhi = 2;
    }
    else if( phi_local >= 24 && phi_local <= 31 ){
      hvPhi = 1;
    }
      }
    }
  }
 
  else if( abs(bec)==20){
    // HEC detector
    //------------
    // Note: not used because we use the 32 modules instead
    hvPhi = 0;
  }  
  else if( abs(bec)==40){
    // FCAL detector
    //------------
    // Note: not used 
    hvPhi = 0;
  }
  std::cout<<"Closing getCellPhiSector ...." << hvPhi <<std::endl;
  return hvPhi;
}
 
 
//============================================================================
std::pair<int,int> LArHVIdMapping::getCellElectrodeMinMax( const Identifier &offId ) const
//============================================================================
// Returns a pair <1st_electrode,last_electrode> of a given calo cell 
//
// 12-FEB-2007 : AL fixed a bug in HEC 
// 02-FEB-2007 : AL added FCAL info *null* (see Zhaoyu)
// 01-FEB-2007 : AL modified HEC info according to TDR 96-41
//               *te be checked by an expert*
// 26-JAN-2007 : AL fixed electrode Min,Max for EMBARREL and EMEC
// 
// 09-FEB-2005 : AL fixed the H8 inversion problem (rotation of Module 00)
// 07-DEC-2004 : AL fixed A-Wheel (phi_local vs phi_atlas)
//                  fixed for Reversed order for Barrel C-Wheel 
// 15-DEC-2004 : AL added HEC detector
//
//============================================================================ 
{// get getCell1stElectrode start  
  //ATH_MSG_VERBOSE("[getCellElectrodeMinMax] Entering..." );
 
  int l_bec=99;
  int l_sampling=-99;
  int l_region=-99;
  //int l_eta=-99;
  int l_phi=-99;
 
  if( m_caloHelper->is_em( offId ) ){
    l_bec      = m_emHelper->barrel_ec(offId);
    l_sampling = m_emHelper->sampling(offId);
    l_region   = m_emHelper->region(offId);
    //l_eta      = m_emHelper->eta(offId);
    l_phi      = m_emHelper->phi(offId);
  }
  else if( m_caloHelper->is_hec( offId )  ){
    l_bec      = m_hecHelper->pos_neg(offId)*10; // +-20
    l_sampling = m_hecHelper->sampling(offId);
    l_region   = m_hecHelper->region(offId);
    //l_eta      = m_hecHelper->eta(offId);
    l_phi      = m_hecHelper->phi(offId);
  }
  else if( m_caloHelper->is_fcal( offId )  ){
    l_bec      = m_fcalHelper->pos_neg(offId)*20; // +-40 
  }
  // Output argument
  // ===============
  int ElecMin=-99;
  int ElecMax=-99;
  if( abs(l_bec) == 1 )
    {// if in BARREL
      if( l_bec == 1 ) {
    // EMBARREL SIDE A 
    if( l_sampling == 0 || ( l_sampling == 1 && l_region == 0) ){
      // ========================================
      // - 64 cells-in-phi per SIDE
      // -  4 cells-in-phi per MODULE
      // - 64 electrodes-in-phi per MODULE
      //   --> 4 cells of 16 electrodes per CELL
      // Examples in *ATLAS* (not H8)
      // --> Cell #0 ==> MOD A01 FT=-1 ELEC 0-15
      // --> Cell #1 ==> MOD A01 FT=-1 ELEC 16-31
      // --> Cell #2 ==> MOD A01 FT=0  ELEC 32-47
      // --> Cell #3 ==> MOD A01 FT=0  ELEC 48-64
      // ========================================
      int phi_module = int((l_phi+2)/4);
      int phi_local = l_phi+2 - 4*phi_module;
      ElecMin = phi_local*16;
      ElecMax = ElecMin + 16-1;
          /*
      ATH_MSG_DEBUG("[getCellElectrodeMinMax] EMB"
            << " Side A "    << l_bec
            << " Sampling= " << l_sampling 
            << " Region= " << l_region
            << " Module= A" << phi_module
            << " Phi/Module= "       << phi_local 
            << " Electrode=[" << ElecMin << "." << ElecMax << "]"
            );
          */              
      if( l_sampling == 0 ){
        ElecMin = 0;
        ElecMax = 0;
      }
 
    }
    else if( (l_sampling == 1 && l_region == 1) || l_sampling == 2 || l_sampling == 3 ){
      // ==========================================
      // - 256 cells-in-phi per SIDE
      // -  16 cells-in-phi per MODULE
      // -  64 electrode's planes per MODULE
      //   --> 16 cells of 4 electrodes per CELL
      // ==========================================
      // --> Cell #0 ==> MOD A01 FT=-1  ELEC 00-03
      // --> Cell #1 ==> MOD A01 FT=-1  ELEC 04-07
      // --> Cell #2 ==> MOD A01 FT=-1  ELEC 08-11
      // --> Cell #3 ==> MOD A01 FT=-1  ELEC 12-15
      // --> Cell #4 ==> MOD A01 FT=-1  ELEC 16-19
      // --> Cell #5 ==> MOD A01 FT=-1  ELEC 20-23
      // --> Cell #6 ==> MOD A01 FT=-1  ELEC 24-27
      // --> Cell #7 ==> MOD A01 FT=-1  ELEC 28-31
      // --> Cell #8 ==> MOD A01 FT=0   ELEC 32-35
      // --> Cell #9 ==> MOD A01 FT=0   ELEC 36-39
      // --> Cell#10 ==> MOD A01 FT=0   ELEC 40-43
      // --> Cell#11 ==> MOD A01 FT=0   ELEC 44-47
      // --> Cell#12 ==> MOD A01 FT=0   ELEC 48-51
      // --> Cell#13 ==> MOD A01 FT=0   ELEC 52-55
      // --> Cell#14 ==> MOD A01 FT=0   ELEC 56-59
      // --> Cell#15 ==> MOD A01 FT=0   ELEC 60-63
      // ==========================================
      int phi_module = int((l_phi+8)/16);
      // shift of 8 cells because Module #0 is rotated by half-module 
      int phi_local  = l_phi+8 - 16*phi_module;
      ElecMin = phi_local * 4;   
      ElecMax = ElecMin + 4 - 1;
          /*
      ATH_MSG_DEBUG("[getCellElectrodeMinMax] EMB"
            << " Side A "    << l_bec
            << " Sampling= " << l_sampling 
            << " Region= "   << l_region
            << " Phi/Module= "       << phi_local 
            << " Module= A"  << phi_module
            << " Electrode=[" << ElecMin << "." << ElecMax << "]"
            );
          */              
    }
      }
 
      else if( l_bec == -1){
    //=====================
    //=====================
    //   EMBARREL SIDE C
    //=====================
    //=====================
    // Phi in module is reversed going from left to right
    //     in the MODULE frame
    if( l_sampling == 0 || ( l_sampling == 1 && l_region == 0) ){
      // ========================================
      // SAMPLING 0
      // - 64 cells-in-phi per DETECTOR
      // -  4 cells-in-phi per MODULE
      // - 64 electrodes-in-phi per MODULE
      //   --> 4 cells of 16 electrodes per CELL
      // ========================================
      // --> Cell #0 ==> MOD C01 FT=-1 ELEC 0-15
      // --> Cell #1 ==> MOD C01 FT=-1 ELEC 16-31
      // --> Cell #2 ==> MOD C01 FT=0  ELEC 32-47
      // --> Cell #3 ==> MOD C01 FT=0  ELEC 48-64
      // ========================================
      int phi_module = int((l_phi+2)/4);
      int phi_local = (l_phi+2 - 4*phi_module) ;
      ElecMin = 48-phi_local*16;
      ElecMax = ElecMin + 16 - 1;
          /*
      ATH_MSG_DEBUG("[getCellElectrodeMinMax] EMB"
            << " Side C "    << l_bec
            << " Sampling= " << l_sampling 
            << " Region= " << l_region
            << " Module= C" << phi_module
            << " Phi/Module= "       << phi_local 
            << " Electrode=[" << ElecMin << "." << ElecMax << "]"
            );
          */              
      if( l_sampling == 0 ){
        ElecMin = 0;
        ElecMax = 0;
      }
    }
    else if( (l_sampling == 1 && l_region == 1) || l_sampling == 2 || l_sampling == 3 ){
      //===========================================
      // - 256 cells-in-phi per SIDE
      // -  16 cells-in-phi per MODULE
      // -  64 electrodes-in-phi per MODULE
      //   --> 16 cells of 4 electrodes per CELL
      // Cell[electrodes]: 0[0,3],1[4,7],2[8,11],3[12,15]..etc...
      //===========================================
      // --> Cell #0 ==> MOD C01 FT=-1  ELEC 00-03
      // --> Cell #1 ==> MOD C01 FT=-1  ELEC 04-07
      // --> Cell #2 ==> MOD C01 FT=-1  ELEC 08-11
      // --> Cell #3 ==> MOD C01 FT=-1  ELEC 12-15
      // --> Cell #4 ==> MOD C01 FT=-1  ELEC 16-19
      // --> Cell #5 ==> MOD C01 FT=-1  ELEC 20-23
      // --> Cell #6 ==> MOD C01 FT=-1  ELEC 24-27
      // --> Cell #7 ==> MOD C01 FT=-1  ELEC 28-31
      // --> Cell #8 ==> MOD C01 FT=0   ELEC 32-35
      // --> Cell #9 ==> MOD C01 FT=0   ELEC 36-39
      // --> Cell#10 ==> MOD C01 FT=0   ELEC 40-43
      // --> Cell#11 ==> MOD C01 FT=0   ELEC 44-47
      // --> Cell#12 ==> MOD C01 FT=0   ELEC 48-51
      // --> Cell#13 ==> MOD C01 FT=0   ELEC 52-55
      // --> Cell#14 ==> MOD C01 FT=0   ELEC 56-59
      // --> Cell#15 ==> MOD C01 FT=0   ELEC 60-63
      //===========================================
      int phi_module = int((l_phi+8)/16);
      int phi_local  = (l_phi+8 - 16*phi_module);
      // Just to get the right MOD id (electrode plane is idem to A-side)
      // Do not use to compute local Phi
      if( phi_module <= 8){
        phi_module = 8 - phi_module;
      }
      else{
        phi_module = 24 - phi_module;
      }
      ElecMin = 60-phi_local * 4;   
      ElecMax = ElecMin + 4 - 1;
          /*
      ATH_MSG_DEBUG("[getCellElectrodeMinMax] EMB"
            << " Side C "    << l_bec
            << " Sampling= " << l_sampling 
            << " Region= " << l_region
            << " Module= C" << phi_module
            << " Phi/Module= "       << phi_local 
            << " Electrode=[" << ElecMin << "." << ElecMax << "]"
            );
         */               
    }
      }
    }
  // ======================================
  // ======================================
  //     EM ENDCAP (A+C SIDES)
  // ======================================
  // ======================================
  else if(abs(l_bec) == 2 || abs(l_bec) == 3){
    // EMEC 
    if( l_bec == 2 ){// bec==2
      //======================
      // A-SIDE / OUTER WHEEL
      //======================
      if( l_sampling == 0 || 
      (l_sampling == 1 && l_region >= 0 && l_region <= 5) ){
    //=============================
    //  64 cells per SIDE
    //   8 Modules per SIDE
    //  -> 8 cells / module
    // 768 electrodes for 64 cells
    //  -> 96 electrodes per module 
    //  -> 12 electrodes per cell
    //=============================
    // --> Cell #0 ==> ELEC 00-11
    // --> Cell #1 ==> ELEC 12-23
    // --> Cell #2 ==> ELEC 24-35
    // --> Cell #3 ==> ELEC 36-47
    // --> Cell #4 ==> ELEC 48-59
    // --> Cell #5 ==> ELEC 60-71
    // --> Cell #6 ==> ELEC 72-83
    // --> Cell #7 ==> ELEC 84-95
    //=============================
    int phi_module = int(l_phi/8);
    int phi_local  = l_phi - 8*phi_module;
    ElecMin = phi_local * 12;
    ElecMax = ElecMin + 12 - 1;
        /*
    ATH_MSG_DEBUG("[getCellElectrodeMinMax] EMEC"
              << " Side A "    << l_bec
              << " Sampling= " << l_sampling 
              << " Region= " << l_region
              << " Module= A" << phi_module
              << " FT= "       << phi_local 
              << " Electrode=[" << ElecMin << "." << ElecMax << "]"
              );
        */              
 
      }
      else if( l_sampling == 2 || l_sampling == 3){
    //=============================
    // 256 cells per SIDE
    //   8 Modules per SIDE
    // --> 32 cells per module
    // 768 electrodes for 256 cells
    // --> 96 electrodes per module
    // --> 3 electrodes per cell
    //=============================
    // --> Cell #0 ==> ELEC 00-02
    // --> Cell #1 ==> ELEC 03-05
    // --> Cell #2 ==> ELEC 06-08
    // ...
    // --> Cell #31 => ELEC 92-95 
    //=============================
    int phi_module = int(l_phi/32);
    int phi_local  = l_phi - 32*phi_module;
    ElecMin = phi_local*3;
    ElecMax = ElecMin+3-1;
        /*
    ATH_MSG_DEBUG("[getCellElectrodeMinMax] EMEC"
              << " Side A "    << l_bec
              << " Sampling= " << l_sampling 
              << " Region= " << l_region
              << " Module= A" << phi_module
              << " Phi/Module= "  << phi_local 
              << " Electrode=[" << ElecMin << "." << ElecMax << "]"
              );
 
       */               
      }
    }
    else if( l_bec == 3 ){
      // =================
      // INNER WHEEL
      // =================
      if( l_sampling == 1 || l_sampling == 2 || l_sampling == 0 ){
    //====================================
    //  64 cells per SIDE
    //   8 module per SIDE
    //  -> 8 cells per Module
    // 256 electrodes for 8 modules
    // --> 32 electrodes per module
    // -->  4 electrodes per cell
    //====================================
    // --> Cell #0 ==> ELEC 00-03
    // --> Cell #1 ==> ELEC 04-07
    // --> Cell #2 ==> ELEC 08-11
    // ...
    // --> Cell #7 ==> ELEC 28-31
    //====================================
    int phi_module = int(l_phi/8);
    int phi_local  = l_phi - 8*phi_module;
    ElecMin = phi_local *4; 
    ElecMax = ElecMin + 4 - 1;
        /*
    ATH_MSG_DEBUG("[getCellElectrodeMinMax] EMEC"
              << " Side A "    << l_bec
              << " Sampling= " << l_sampling 
              << " Region= " << l_region
              << " Module= A" << phi_module
              << " Phi/Module= "       << phi_local 
              << " Electrode=[" << ElecMin << "." << ElecMax << "]"
              );
       */
      }
    }
    else if( l_bec == -2 ){
      //========================
      // C-SIDE OUTER WHEEL 
      //========================
      if( l_sampling == 0 || (l_sampling == 1 && l_region >= 0 && l_region <= 5) ){
    //=============================
    //  64 cells per SIDE
    //   8 Modules per SIDE
    //  -> 8 cells / module
    // 768 electrodes for 64 cells
    //  -> 96 electrodes per module 
    //  -> 12 electrodes per cell
    //=============================
    // --> Cell #0 ==> ELEC 00-11
    // --> Cell #1 ==> ELEC 12-23
    // --> Cell #2 ==> ELEC 24-35
    // --> Cell #3 ==> ELEC 36-47
    // --> Cell #4 ==> ELEC 48-59
    // --> Cell #5 ==> ELEC 60-71
    // --> Cell #6 ==> ELEC 72-83
    // --> Cell #7 ==> ELEC 84-95
    //=============================
    int phi_module = int(l_phi/8);
    int phi_local  = 7 - (l_phi - 8*phi_module);
    ElecMin = phi_local * 12;
    ElecMax = ElecMin + 12 - 1;
        /*
    ATH_MSG_DEBUG("[getCellElectrodeMinMax] EMEC"
              << " Side C "    << l_bec
              << " Sampling= " << l_sampling 
              << " Region= " << l_region
              << " Module= C" << phi_module
              << " Phi/Module= "       << phi_local 
              << " Electrode=[" << ElecMin << "." << ElecMax << "]"
              );
 
        */              
      }
      else if( l_sampling == 2 || l_sampling == 3){
    //=============================
    // 256 cells per SIDE
    //   8 Modules per SIDE
    // --> 32 cells per module
    // 768 electrodes for 256 cells
    // --> 96 electrodes per module
    // --> 3 electrodes per cell
    //=============================
    // --> Cell #0 ==> ELEC 00-02
    // --> Cell #1 ==> ELEC 03-05
    // --> Cell #2 ==> ELEC 06-08
    // ...
    // --> Cell #31 => ELEC 92-95 
    //=============================
    int phi_module = int(l_phi/32);
    int phi_local  = 31 - (l_phi - 32*phi_module);
    ElecMin = phi_local*3;
    ElecMax = ElecMin + 3 - 1;
        /*
    ATH_MSG_DEBUG("[getCellElectrodeMinMax] EMEC"
              << " Side C "    << l_bec
              << " Sampling= " << l_sampling 
              << " Region= " << l_region
              << " Module= C" << phi_module
              << " Phi/Module= "       << phi_local 
              << " Electrode=[" << ElecMin << "." << ElecMax << "]"
              );
        */
      }
    }
    else if( l_bec == -3 ){
      // INNER WHEEL C
      if( l_sampling == 1 || l_sampling == 2 || l_sampling == 0 ){
    // 256 electrodes for 64 cells
    // -->  8 cells per module
    // --> 32 electrodes per module
    // -->  4 electrodes per cell
    int phi_module = int(l_phi/8);
    int phi_local  = l_phi - 8*phi_module;
    ElecMin = 28 - phi_local *4;    
    ElecMax = ElecMin + 4 -1;
        /*
    ATH_MSG_DEBUG("[getCellElectrodeMinMax] EMEC"
              << " Side C "    << l_bec
              << " Sampling= " << l_sampling 
              << " Region= " << l_region
              << " Module= C" << phi_module
              << " Phi/Module= "       << phi_local 
              << " Electrode=[" << ElecMin << "." << ElecMax << "]"
              );
        */
      }
    }
  }
  else if( abs(l_bec)==20 ){// HEC
    //==========================
    // HEC wheels
    //==========================
    // Sampling 0 & 1 : 1st wheel
    // Sampling 2 & 3 : 2nd wheel
    // l_region 0       : Outer
    // region 1       : Inner
    //==========================
    if( l_sampling == 0){
      // ======================
      // Sampling 0 , region 0 
      //   * 1st wheel * 
      // 64 cells per SIDE
      // 32 module per SIDE
      // -> 2 cells in phi per Module
      //  8 electrode's planes 
      // -> 8 electrode's planes per cell !
      // ================================
      // Made using Fig. 8-1 in TDR 96-41
      // ================================
      //ElecMin = l_eta+1;
      //ElecMax = ElecMin + 4;
      ElecMin = 1;
      ElecMax = 8;
      // Note : idem for region 0 and region 1
    }
    else if( l_sampling == 1){
      // ====================
      // sampling 1 l_region 0
      //   * 1st wheel * 
      // 64 cells in phi per SIDE 
      // 10 cells in eta per SIDE
      // 32 modules per SIDE
      // -> 2x10 cells per module 
      // 16 electrode's planes per module 
      // ================================
      // Made using Fig. 8-1 in TDR 96-41
      // ================================
      ElecMin = 9;
      ElecMax =24; 
      // Note : idem for region 0 and region 1
    }
    else if( l_sampling == 2){
      // ====================
      // sampling 2 region 0
      //   * 2nd wheel * 
      // 64 cells in phi per SIDE 
      // 10 cells in eta per SIDE
      // 32 modules in phi per SIDE
      // 16 electrode's plane
      // ================================
      // Made using Fig. 8-1 in TDR 96-41
      // ================================
      // Note : idem for region 0 and region 1
      ElecMin = 25;
      ElecMax = 32;
    }
    else if( l_sampling == 3){
      // ==============================
      // index starting at 2 thus the 32-2=20
      // 2 cells in phi per module 
      // 8 electrode per module 
      // ie: 4 electrodes per cell
      // ==============================
      // Note : idem for region 0 and region 1
      ElecMin = 33;
      ElecMax = 40;
    }
  } // HEC
  else if( abs(l_bec)==40 ){// FCAL
    ElecMin = 0;
    ElecMax = 0;
  }
  else{
    //msg(MSG::WARNING) 
    //  << "[getCellElectrodeMinMax] Detector unknown .." 
    //  << endmsg; 
  }
  //ATH_MSG_DEBUG("[getCellElectrodeMinMax] Exiting..." );
  std::pair<int, int> electrodeMinMax( ElecMin, ElecMax); 
  return electrodeMinMax;
}