TileCablingSvc.cxx File Reference

#include "StoreGate/StoreGateSvc.h"
#include "AthenaKernel/errorcheck.h"
#include "GeoModelInterfaces/IGeoModelSvc.h"
#include "CaloIdentifier/CaloLVL1_ID.h"
#include "CaloIdentifier/TileID.h"
#include "CaloIdentifier/TileTBID.h"
#include "CaloDetDescr/CaloDetDescrElement.h"
#include "TileConditions/TileCablingSvc.h"
#include "TileIdentifier/TileHWID.h"
#include "TileCalibBlobObjs/TileCalibUtils.h"
#include "TileDetDescr/TileDetDescrManager.h"
#include <cstdlib>

Go to the source code of this file.

Functions
StatusCode TileCablingSvc::initialize	ATLAS_NOT_THREAD_SAFE ()
	Install fatal handler with default options. More...

Function Documentation

ATLAS_NOT_THREAD_SAFE()

StatusCode TileCablingSvc::initialize ATLAS_NOT_THREAD_SAFE ( )

inline

Install fatal handler with default options.

This is meant to be easy to call from python via ctypes.

Install fatal handler with default options.

getLorentzAngle() Read LorentzAngle from HIST and write out into local DB

getBSErrors() Read BSErrors from Monitoring HIST and write out into local DB

getEfficiency() Read Efficiency from Monitoring HIST and write out into local DB

getRawOccupancy() Read RawOccupancy from Monitoring HIST and write out into local DB

getNoiseOccupancy() Read NoiseOccupancy from HIST and write out into local DB

getNoisyStrip() Find noisy strips from hitmaps and write out into xml/db formats

Install fatal handler with default options.

called at the end of each athena event (can be used for eg.

called at the beginning of each athena event (can be used for eg.

return the simulation service ID

resetting dynamic selectors)

beginning of the loop of channels

bad bit newly found

known bad bit

for low noisy cells

for high noisy cells

0.01 is used to scale "PER" to the same order of magnitude to "SIG"

smaller deviation: distorted

checking TmaxAmp, Not mixed with MaxAmp and Width

channel information output

Only dead or distorted, or short known BCs are considered below.

index of bc

now add branches and leaves to the tree

now add branches and leaves to the tree

Definition at line 61 of file TileCablingSvc.cxx.

                                                             {
 
  ATH_MSG_DEBUG( "In initialize() " );
 
  //=== creating cabling singleton
  TileCablingService* cablingService = TileCablingService::getInstance_nc();
  m_cablingService = cablingService;
  if (!m_cablingService) {
    ATH_MSG_ERROR( "Cannot get instance of TileCablingService" );
    return StatusCode::FAILURE;
  }
 
  //=== 
  CHECK( m_detStore.retrieve() );
 
  //=== retrieve all helpers from detector store
  const CaloLVL1_ID* caloID(nullptr);
  CHECK( m_detStore->retrieve(caloID) );
 
  const TileID* tileID(nullptr);
  CHECK( m_detStore->retrieve(tileID) );
 
  const TileTBID* tileTBID(nullptr);
  CHECK( m_detStore->retrieve(tileTBID) );
 
  const TileHWID* tileHWID(nullptr);
  CHECK( m_detStore->retrieve(tileHWID) );
 
  //=== Initialize TileCablingService singleton
  cablingService->setCaloLVL1(caloID);
  cablingService->setTileID(tileID);
  cablingService->setTileTBID(tileTBID);
  cablingService->setTileHWID(tileHWID);
 
  //=== set connected drawers if non-empty list
  if (m_connectedDrawers.size() > 1) {
    //===disconnect all drawers first
    for (int ros = 1; ros < 5; ++ros) {
      for (int drawer = 0; drawer < 64; ++drawer) {
        cablingService->setConnected(ros, drawer, false);
      }
    }
    int count = 0;
 
    msg(MSG::INFO) << "Connected drawer list:" << MSG::hex;
    for (unsigned int dr = 1; dr < m_connectedDrawers.size(); dr += 2) {
      int frag1 = std::strtol(m_connectedDrawers[dr - 1].data(), nullptr, 0);
      int frag2 = std::strtol(m_connectedDrawers[dr].data(), nullptr, 0);
      for (int frag = frag1; frag <= frag2; ++frag) {
        int ros = frag >> 8;
        int drawer = frag & 0xFF;
        if (ros >= 1 && ros < 5 && drawer >= 0 && drawer < 64) {
          cablingService->setConnected(ros, drawer, true);
          msg(MSG::INFO) << " 0x" << frag;
          char module[3];
          sprintf(module, "%2.2d", drawer + 1);
          switch (ros) {
            case 1:
              msg(MSG::INFO) << "/LBA" << module;
              break;
            case 2:
              msg(MSG::INFO) << "/LBC" << module;
              break;
            case 3:
              msg(MSG::INFO) << "/EBA" << module;
              break;
            case 4:
              msg(MSG::INFO) << "/EBC" << module;
              break;
            default:
              msg(MSG::INFO) << "/XXX" << module;
              break;
          }
          if (++count > 3) {
            count = 0;
            msg(MSG::INFO) << endmsg;
            msg(MSG::INFO) << "                      " << MSG::hex;
          }
        }
      }
    }
    msg(MSG::INFO) << MSG::dec << endmsg;
  }
 
  SmartIF<IGeoModelSvc> geoModel{service("GeoModelSvc")};
  if (!geoModel) {
    ATH_MSG_ERROR( "Could not locate GeoModelSvc"  );
  } else {
    // check the DetDescr version
    std::string atlasVersion = geoModel->atlasVersion();
    int ctb = atlasVersion.compare(0, 9, "ATLAS-CTB");
    int geo  = atlasVersion.compare(0,9,"ATLAS-GEO");
    int run1 = atlasVersion.compare(0,8,"ATLAS-R1");
    int ibl  = atlasVersion.compare(0,9,"ATLAS-IBL");
    int run2 = atlasVersion.compare(0,8,"ATLAS-R2");
    int run3 = atlasVersion.compare(0,8,"ATLAS-R3");
    int run4 = atlasVersion.compare(0,13,"ATLAS-P2-RUN4");
    int upg  = atlasVersion.compare(0,7,"ATLAS-P") ;
    int comm = atlasVersion.compare(0,10,"ATLAS-Comm");
 
    bool upgradeA = (tileID->cell_hash_max() == MAX_TILE_CELLS_UPGRADEA);
    bool upgradeBC = (tileID->cell_hash_max() == MAX_TILE_CELLS_UPGRADEBC);
    bool upgradeABC = (tileID->cell_hash_max() == MAX_TILE_CELLS_UPGRADEABC);
 
    // choose which geometries are true RUN2 geometries to apply run2 cabling
    bool nothing_found = (ctb*geo*run1*ibl*run2*run3*run4*upg*comm != 0);
    GeoModel::GeoConfig geoConfig = geoModel->geoConfig();
    bool RUN2 = (nothing_found && geoConfig==GeoModel::GEO_RUN2) || (run2 == 0);
    bool RUN3 = (nothing_found && geoConfig==GeoModel::GEO_RUN3) || (run3 == 0);
    bool RUN4 = (nothing_found && geoConfig==GeoModel::GEO_RUN4) || (run4 == 0);
    //|| (ibl == 0 || upg == 0);
 
    if (RUN2) {
 
      ATH_MSG_INFO( "RUN2 ATLAS geometry flag detected for geometry: " << atlasVersion );
      if (upgradeA) {
        ATH_MSG_INFO( "RUN2 ATLAS UpgradeA geometry flag detected for geometry: " << atlasVersion );
        m_cablingType = TileCablingService::UpgradeA;
      } else if (upgradeBC) {
        ATH_MSG_INFO( "RUN2 ATLAS UpgradeBC geometry flag detected for geometry: " << atlasVersion );
        m_cablingType = TileCablingService::UpgradeBC;
      } else if (upgradeABC) {
        ATH_MSG_INFO( "RUN2 ATLAS UpgradeABC geometry flag detected for geometry: " << atlasVersion );
        m_cablingType = TileCablingService::UpgradeABC;
      } else {
        if (m_cablingType == TileCablingService::RUN2Cabling) {
          ATH_MSG_INFO( "Cabling for RUN2 (2014-2017) ATLAS geometry is set via jobOptions " );
        } else if (m_cablingType == TileCablingService::RUN2aCabling) {
          ATH_MSG_INFO( "Cabling for RUN2a (2018) ATLAS geometry is set via jobOptions " );
        } else if (m_cablingType < TileCablingService::RUN2Cabling) {
          ATH_MSG_INFO( "Setting RUN2 (2014-2017) cabling" );
          m_cablingType = TileCablingService::RUN2Cabling;
        } else {
          ATH_MSG_INFO( "Using cabling type " << m_cablingType << " from jobOptions " );
        }
      }
 
    } else if (RUN3) {
 
      ATH_MSG_INFO( "RUN3 ATLAS geometry flag detected for geometry: " << atlasVersion );
      if (m_cablingType == TileCablingService::RUN3Cabling) {
        ATH_MSG_INFO( "Cabling for RUN3 ATLAS geometry is set via jobOptions " );
      } else if ( m_cablingType < TileCablingService::RUN2Cabling) {
        ATH_MSG_INFO( "Setting RUN3 cabling" );
        m_cablingType = TileCablingService::RUN3Cabling;
      } else {
        ATH_MSG_INFO( "Using cabling type " << m_cablingType << " from jobOptions " );
      }
 
    } else if (RUN4) {
 
      ATH_MSG_INFO( "RUN4 ATLAS geometry flag detected for geometry: " << atlasVersion );
      if (m_cablingType == TileCablingService::RUN3Cabling) {
        ATH_MSG_INFO( "Cabling for RUN3 ATLAS geometry is set via jobOptions " );
      } else if ( m_cablingType < TileCablingService::RUN3Cabling) {
        ATH_MSG_INFO( "Setting RUN3 cabling" );
        m_cablingType = TileCablingService::RUN3Cabling;
      } else {
        ATH_MSG_INFO( "Using cabling type " << m_cablingType << " from jobOptions " );
      }
 
    } else if (m_cablingType == TileCablingService::RUN3Cabling) {
      ATH_MSG_INFO( "Cabling for RUN3 ATLAS geometry is set via jobOptions " );
    } else if (m_cablingType == TileCablingService::RUN2Cabling) {
      ATH_MSG_INFO( "Cabling for RUN2 (2014-2017) ATLAS geometry is set via jobOptions " );
    } else if (m_cablingType == TileCablingService::RUN2aCabling) {
      ATH_MSG_INFO( "Cabling for RUN2a (2018) ATLAS geometry is set via jobOptions " );
    }  else if (ctb == 0) {
      ATH_MSG_INFO( "CTB geometry detected: " << atlasVersion );
      m_cablingType = TileCablingService::TestBeam;
    } else if (geo == 0 || run1 == 0 || ibl == 0 || run2 == 0 || upg == 0) {
      ATH_MSG_INFO( "RUN1 ATLAS geometry detected: " << atlasVersion );
      m_cablingType = TileCablingService::MBTSOnly;
    } else if (comm == 0) {
      ATH_MSG_INFO( "RUN1 ATLAS Commissioning geometry detected: " << atlasVersion );
      m_cablingType = TileCablingService::MBTSOnly;
    } else {
      ATH_MSG_WARNING( "Old ATLAS geometry detected - most probably it's a mistake: " << atlasVersion );
      // in this case change cabling type only if it is not set via jobOptions
      if (m_cablingType < -1 || m_cablingType >= TileCablingService::UnknownCabling)
        m_cablingType = TileCablingService::OldSim;
      else
        ATH_MSG_INFO( "Using cabling type from jobOptions " );
    }
  }
 
  ATH_MSG_INFO( "Setting Cabling type to " << m_cablingType );
  ATH_CHECK( cablingService->setCablingType((TileCablingService::TileCablingType) m_cablingType) );
  ATH_MSG_DEBUG( "Maximum number of gains: " <<  m_cablingService->getMaxChannels());
 
  // ------------ Setting TileCal channel hashes in CaloDDE -------------
  // ---------- it can be done only after we set cabling type -----------
  const TileDetDescrManager* tileMgr;
  if (m_detStore->retrieve(tileMgr).isFailure()) {
    ATH_MSG_WARNING( "Unable to retrieve TileDetDescrManager from DetectorStore" );
    ATH_MSG_WARNING( "Will not set Tile online hash ID in CaloDetDescrElements" );
  } else {
    ATH_MSG_VERBOSE( "List of disconnected cells" );
 
    unsigned int nCellMax = tileMgr->tile_cell_size();
    IdContext chContext = tileHWID->channel_context();
 
    for (unsigned int cell = 0; cell < nCellMax; ++cell) {
      CaloDetDescrElement* caloDDE = tileMgr->get_cell_element(cell);
 
      if (caloDDE) {
        Identifier cell_id = tileID->cell_id(caloDDE->subcalo_hash());
        int nchan = (tileID->is_tile_gapscin(cell_id)) ? 1 : 2;
        IdentifierHash pmtHash[2] = { TileHWID::NOT_VALID_HASH, TileHWID::NOT_VALID_HASH };
 
        bool disconnected = true;
        for (int pmt = 0; pmt < nchan; ++pmt) {
          Identifier id1 = tileID->pmt_id(cell_id, pmt);
          HWIdentifier hw1 = m_cablingService->s2h_channel_id(id1);
          tileHWID->get_hash(hw1, pmtHash[pmt], &chContext);
          Identifier id2 = m_cablingService->h2s_pmt_id(hw1);
          disconnected &= (id2 != id1);
        }
        if (disconnected) m_disconnectedCells.push_back(cell_id);
 
        IdentifierHash oldPmtHash[2] = { caloDDE->onl1(), caloDDE->onl2() };
        if ((oldPmtHash[0] != TileHWID::NOT_VALID_HASH || oldPmtHash[1] != TileHWID::NOT_VALID_HASH)
            && (pmtHash[0] != oldPmtHash[0] || pmtHash[1] != oldPmtHash[1])) {
 
          ATH_MSG_WARNING( "changing channel hash for cell hash= " << cell
                          << " id= " << tileID->to_string(cell_id, -2)
                          << " from (" << oldPmtHash[0] << "," << oldPmtHash[1]
                          << ") to (" << pmtHash[0] << "," << pmtHash[1] << ")" );
 
        }
 
        caloDDE->set_online(pmtHash[0], pmtHash[1]);
        if (msgLvl(MSG::VERBOSE)) {
          if (disconnected) {
 
            msg(MSG::VERBOSE) << "cell_id " << tileID->to_string(cell_id, -2) << " ch_id";
            if (pmtHash[0] != TileHWID::NOT_VALID_HASH)
              msg(MSG::VERBOSE) << " " << tileHWID->to_string(m_cablingService->s2h_channel_id(tileID->pmt_id(cell_id, 0)), -1);
            else
              msg(MSG::VERBOSE) << " invalid";
            if (nchan > 1) {
              if (pmtHash[1] != TileHWID::NOT_VALID_HASH)
                msg(MSG::VERBOSE) << " " << tileHWID->to_string(m_cablingService->s2h_channel_id(tileID->pmt_id(cell_id, 1)), -1);
              else
                msg(MSG::VERBOSE) << " invalid";
            }
            msg(MSG::VERBOSE) << endmsg;
          }
        }
      }
    }
 
    ATH_MSG_VERBOSE( "Total: " << m_disconnectedCells.size() << " disconnected cells");
  }
 
  if (msgLvl(MSG::VERBOSE)) {
 
    // checking all HWIDs
    std::cout << "===============================" << std::endl;
 
    for (int ros = 1; ros < 5; ++ros) {
      for (int drawer = 0; drawer < 64; ++drawer) {
        int drIdx1 = TileCalibUtils::getDrawerIdx(ros, drawer);
        for (int channel = 0; channel < 48; ++channel) {
 
          HWIdentifier hwid1 = tileHWID->channel_id(ros, drawer, channel);
          if (hwid1.is_valid()) {
            std::cout << " hw1=" << tileHWID->to_string(hwid1, -1);
            Identifier id1 = m_cablingService->h2s_pmt_id(hwid1);
            if (id1.is_valid()) {
              std::cout << " id1=" << tileID->to_string(id1, -1);
              HWIdentifier hwid2 = m_cablingService->s2h_channel_id(id1);
              if (hwid2.is_valid()) {
                if (hwid2 != hwid1) std::cout << " hw1!=hw2=" << tileHWID->to_string(hwid2, -1);
                Identifier id2 = m_cablingService->h2s_pmt_id(hwid2);
                if (id2.is_valid()) {
                  if (id2 != id1)
                    std::cout << " id1!=id2=" << tileID->to_string(id2, -1);
                  else if (tileTBID->is_tiletb(id1))
                      std::cout << ((tileTBID->eta(id1)>1) ? " E4'" : " MBTS");
                  else
                    std::cout << " cell_hash " << tileID->cell_hash(tileID->cell_id(id1));
                  int drIdx2 = tileHWID->drawerIdx(hwid1);
                  if (drIdx1 != drIdx2) {
                    std::cout << "  ERROR in drawer index " << drIdx1 << " != " << drIdx2
                        << " end-begin=" << (tileHWID->drawer_end() - tileHWID->drawer_begin())
                        << std::hex << " 0x" << hwid1 << " 0x"
                        << (*(tileHWID->drawer_begin() + drIdx1)) << std::dec;
                  } else {
                    std::cout << "  drawer index " << drIdx2;
                  }
                } else {
                  std::cout << " id2=invalid";
                }
              } else {
                std::cout << " hw2=invalid";
              }
            } else {
              std::cout << " id1=invalid";
            }
          } else {
            std::cout << " hw1=invalid";
          }
          std::cout << std::endl;
        }
      }
    }
 
    // checking D4 in few modules
    std::cout << "=== D4 cells in special EB ====" << std::endl;
 
    int d4module[4] = { 14, 15, 18, 19 };
    for (int side = -1; side < 2; side += 2) {
      for (int imod = 0; imod < 4; ++imod) {
        int module = d4module[imod] - 1;
        for (int pmt = 0; pmt < 2; ++pmt) {
 
          Identifier id1 = tileID->pmt_id(3, side, module, 8, 2, pmt);
          if (id1.is_valid()) {
            std::cout << " id1=" << tileID->to_string(id1, -1);
            HWIdentifier hw1 = m_cablingService->s2h_channel_id(id1);
            if (hw1.is_valid()) {
              std::cout << " hw1=" << tileHWID->to_string(hw1, -1);
              Identifier id2 = m_cablingService->h2s_pmt_id(hw1);
              if (id2.is_valid()) {
                if (id2 != id1) std::cout << " id1!=id2=" << tileID->to_string(id2, -1);
                HWIdentifier hw2 = m_cablingService->s2h_channel_id(id2);
                if (hw2.is_valid()) {
                  if (hw2 != hw1) std::cout << " hwid1!=hwid2=" << tileHWID->to_string(hw2, -1);
                } else {
                  std::cout << " hw2=invalid";
                }
              } else {
                std::cout << " id2=invalid";
              }
            } else {
              std::cout << " hw1=invalid";
            }
          } else {
            std::cout << " id1=invalid";
          }
          std::cout << std::endl;
        }
      }
    }
 
    // checking C10 in few modules
    std::cout << "=== C10 cells in special EB ===" << std::endl;
 
    int c10module[8] = { 39, 40, 41, 42, 55, 56, 57, 58 };
    for (int side = -1; side < 2; side += 2) {
      for (int imod = 0; imod < 8; ++imod) {
        int module = c10module[imod] - 1;
        for (int pmt = 0; pmt < 2; ++pmt) {
 
          Identifier id1 = tileID->pmt_id(3, side, module, 9, 1, pmt);
          if (id1.is_valid()) {
            std::cout << " id1=" << tileID->to_string(id1, -1);
            HWIdentifier hw1 = m_cablingService->s2h_channel_id(id1);
            if (hw1.is_valid()) {
              std::cout << " hw1=" << tileHWID->to_string(hw1, -1);
              Identifier id2 = m_cablingService->h2s_pmt_id(hw1);
              if (id2.is_valid()) {
                if (id2 != id1) std::cout << " id1!=id2=" << tileID->to_string(id2, -1);
                HWIdentifier hw2 = m_cablingService->s2h_channel_id(id2);
                if (hw2.is_valid()) {
                  if (hw2 != hw1) std::cout << " hwid1!=hwid2=" << tileHWID->to_string(hw2, -1);
                } else {
                  std::cout << " hw2=invalid";
                }
              } else {
                std::cout << " id2=invalid";
              }
            } else {
              std::cout << " hw1=invalid";
            }
          } else {
            std::cout << " id1=invalid";
          }
          std::cout << std::endl;
        }
      }
    }
 
    // checking E1
    std::cout << "========= E1 cells =========" << std::endl;
 
    for (int side = -1; side < 2; side += 2) {
      for (int module = 0; module < 64; ++module) {
        for (int tower = 10; tower < 11; tower += 1) {
 
          Identifier id1 = tileID->pmt_id(3, side, module, tower, 3, 0);
          if (id1.is_valid()) {
            std::cout << " id1=" << tileID->to_string(id1, -1);
            HWIdentifier hw1 = m_cablingService->s2h_channel_id(id1);
            if (hw1.is_valid()) {
              std::cout << " hw1=" << tileHWID->to_string(hw1, -1);
              Identifier id2 = m_cablingService->h2s_pmt_id(hw1);
              if (id2.is_valid()) {
                if (id2 != id1) std::cout << " id1!=id2=" << tileID->to_string(id2, -1);
                HWIdentifier hw2 = m_cablingService->s2h_channel_id(id2);
                if (hw2.is_valid()) {
                  if (hw2 != hw1) std::cout << " hwid1!=hwid2=" << tileHWID->to_string(hw2, -1);
                } else {
                  std::cout << " hw2=invalid";
                }
              } else {
                std::cout << " id2=invalid";
              }
            } else {
              std::cout << " hw1=invalid";
            }
          } else {
            std::cout << " id1=invalid";
          }
          std::cout << std::endl;
        }
      }
    }
 
    // checking E2
    std::cout << "========= E2 cells =========" << std::endl;
 
    for (int side = -1; side < 2; side += 2) {
      for (int module = 0; module < 64; ++module) {
        for (int tower = 11; tower < 12; tower += 1) {
 
          Identifier id1 = tileID->pmt_id(3, side, module, tower, 3, 0);
          if (id1.is_valid()) {
            std::cout << " id1=" << tileID->to_string(id1, -1);
            HWIdentifier hw1 = m_cablingService->s2h_channel_id(id1);
            if (hw1.is_valid()) {
              std::cout << " hw1=" << tileHWID->to_string(hw1, -1);
              Identifier id2 = m_cablingService->h2s_pmt_id(hw1);
              if (id2.is_valid()) {
                if (id2 != id1) std::cout << " id1!=id2=" << tileID->to_string(id2, -1);
                HWIdentifier hw2 = m_cablingService->s2h_channel_id(id2);
                if (hw2.is_valid()) {
                  if (hw2 != hw1) std::cout << " hwid1!=hwid2=" << tileHWID->to_string(hw2, -1);
                } else {
                  std::cout << " hw2=invalid";
                }
              } else {
                std::cout << " id2=invalid";
              }
            } else {
              std::cout << " hw1=invalid";
            }
          } else {
            std::cout << " id1=invalid";
          }
          std::cout << std::endl;
        }
      }
    }
 
    // checking E3,E4
    std::cout << "========= E3,E4 cells =========" << std::endl;
 
    for (int side = -1; side < 2; side += 2) {
      for (int module = 0; module < 64; ++module) {
        for (int tower = 13; tower < 16; tower += 2) {
 
          Identifier id1 = tileID->pmt_id(3, side, module, tower, 3, 0);
          if (id1.is_valid()) {
            std::cout << " id1=" << tileID->to_string(id1, -1);
            HWIdentifier hw1 = m_cablingService->s2h_channel_id(id1);
            if (hw1.is_valid()) {
              std::cout << " hw1=" << tileHWID->to_string(hw1, -1);
              Identifier id2 = m_cablingService->h2s_pmt_id(hw1);
              if (id2.is_valid()) {
                if (id2 != id1) std::cout << " id1!=id2=" << tileID->to_string(id2, -1);
                HWIdentifier hw2 = m_cablingService->s2h_channel_id(id2);
                if (hw2.is_valid()) {
                  if (hw2 != hw1) std::cout << " hwid1!=hwid2=" << tileHWID->to_string(hw2, -1);
                } else {
                  std::cout << " hw2=invalid";
                }
              } else {
                std::cout << " id2=invalid";
              }
            } else {
              std::cout << " hw1=invalid";
            }
          } else {
            std::cout << " id1=invalid";
          }
          std::cout << std::endl;
        }
      }
    }
 
    // checking MBTS
    std::cout << "========= MBTS cells ==========" << std::endl;
 
    for (int side = -1; side < 2; side += 2) {
      for (int module = 0; module < 8; ++module) {
        for (int tower = 0; tower < 2; ++tower) {
 
          Identifier id1 = tileTBID->channel_id(side, module, tower);
          if (id1.is_valid()) {
            std::cout << " id1=" << tileTBID->to_string(id1);
            HWIdentifier hw1 = m_cablingService->s2h_channel_id(id1);
            if (hw1.is_valid()) {
              std::cout << " hw1=" << tileHWID->to_string(hw1, -1);
              Identifier id2 = m_cablingService->h2s_pmt_id(hw1);
              if (id2.is_valid()) {
                if (id2 != id1) std::cout << " id1!=id2=" << tileTBID->to_string(id2);
                HWIdentifier hw2 = m_cablingService->s2h_channel_id(id2);
                if (hw2.is_valid()) {
                  if (hw2 != hw1) std::cout << " hwid1!=hwid2=" << tileHWID->to_string(hw2, -1);
                } else {
                  std::cout << " hw2=invalid";
                }
              } else {
                std::cout << " id2=invalid";
              }
            } else {
              std::cout << " hw1=invalid";
            }
          } else {
            std::cout << " id1=invalid";
          }
          std::cout << std::endl;
        }
      }
    }
 
    // checking E4'
    if (m_cablingType == TileCablingService::RUN2Cabling || m_cablingType == TileCablingService::RUN2aCabling) {
 
      std::cout << "========= E4' cells ==========" << std::endl;
    
      for (int side = -1; side < 0; side += 2) {
        for (int module = 0; module < 4; ++module) {
          for (int tower = 2; tower < 3; ++tower) {
    
            Identifier id1 = tileTBID->channel_id(side, module, tower);
            if (id1.is_valid()) {
              std::cout << " id1=" << tileTBID->to_string(id1);
              HWIdentifier hw1 = m_cablingService->s2h_channel_id(id1);
              if (hw1.is_valid()) {
                std::cout << " hw1=" << tileHWID->to_string(hw1, -1);
                Identifier id2 = m_cablingService->h2s_pmt_id(hw1);
                if (id2.is_valid()) {
                  if (id2 != id1) std::cout << " id1!=id2=" << tileTBID->to_string(id2);
                  HWIdentifier hw2 = m_cablingService->s2h_channel_id(id2);
                  if (hw2.is_valid()) {
                    if (hw2 != hw1) std::cout << " hwid1!=hwid2=" << tileHWID->to_string(hw2, -1);
                  } else {
                    std::cout << " hw2=invalid";
                  }
                } else {
                  std::cout << " id2=invalid";
                }
              } else {
                std::cout << " hw1=invalid";
              }
            } else {
              std::cout << " id1=invalid";
            }
            std::cout << std::endl;
          }
        }
      }
    }
 
    std::cout << "===============================" << std::endl;
  }
 
  if (m_useCache) cablingService->fillH2SIdCache();
 
  return StatusCode::SUCCESS;
}