EcalElectronicsMapper.cc

Go to the documentation of this file.

#include <FWCore/MessageLogger/interface/MessageLogger.h>
#include <EventFilter/EcalRawToDigi/interface/EcalElectronicsMapper.h>
#include <Geometry/EcalMapping/interface/EcalElectronicsMapping.h>
#include <DataFormats/EcalDigi/interface/EBSrFlag.h>
#include <DataFormats/EcalDigi/interface/EESrFlag.h>
#include <EventFilter/EcalRawToDigi/interface/DCCDataUnpacker.h>

EcalElectronicsMapper::EcalElectronicsMapper(unsigned int numbXtalTSamples, unsigned int numbTriggerTSamples)
    : pathToMapFile_(""),
      numbXtalTSamples_(numbXtalTSamples),
      numbTriggerTSamples_(numbTriggerTSamples),
      mappingBuilder_(nullptr) {
  resetPointers();
  setupGhostMap();
}

void EcalElectronicsMapper::resetPointers() {
  // Reset Arrays
  for (unsigned int sm = 0; sm < NUMB_SM; sm++) {
    for (unsigned int fe = 0; fe < NUMB_FE; fe++) {
      for (unsigned int strip = 0; strip < NUMB_STRIP; strip++) {
        for (unsigned int xtal = 0; xtal < NUMB_XTAL; xtal++) {
          //Reset DFrames and xtalDetIds
          xtalDetIds_[sm][fe][strip][xtal] = nullptr;
        }
      }

      //Reset SC Det Ids
      //scDetIds_[sm][fe]=0;
      scEleIds_[sm][fe] = nullptr;
      //srFlags_[sm][fe]=0;
    }
  }

  //Reset TT det Ids
  for (unsigned int tccid = 0; tccid < NUMB_TCC; tccid++) {
    for (unsigned int tpg = 0; tpg < NUMB_FE; tpg++) {
      ttDetIds_[tccid][tpg] = nullptr;
      ttTPIds_[tccid][tpg] = nullptr;
      ttEleIds_[tccid][tpg] = nullptr;
    }
  }

  // reset trigger electronics Id
  for (int tccid = 0; tccid < NUMB_TCC; tccid++) {
    for (int ttid = 0; ttid < TCC_EB_NUMBTTS; ttid++) {
      for (int ps = 0; ps < NUMB_STRIP; ps++) {
        psInput_[tccid][ttid][ps] = nullptr;
      }
    }
  }

  // initialize TCC maps
  for (int tccId = 0; tccId < EcalTriggerElectronicsId::MAX_TCCID; tccId++) {
    for (int psCounter = 0; psCounter < EcalTrigTowerDetId::kEBTowersPerSM * 5; psCounter++) {
      for (int u = 0; u < 2; u++) {
        tTandPs_[tccId][psCounter][u] = -1;
      }
    }
  }

  //Fill map sm id to tcc ids
  std::vector<unsigned int>* ids;
  ids = new std::vector<unsigned int>;
  ids->push_back(1);
  ids->push_back(18);
  ids->push_back(19);
  ids->push_back(36);
  mapSmIdToTccIds_[1] = ids;

  ids = new std::vector<unsigned int>;
  ids->push_back(2);
  ids->push_back(3);
  ids->push_back(20);
  ids->push_back(21);
  mapSmIdToTccIds_[2] = ids;

  ids = new std::vector<unsigned int>;
  ids->push_back(4);
  ids->push_back(5);
  ids->push_back(22);
  ids->push_back(23);
  mapSmIdToTccIds_[3] = ids;

  ids = new std::vector<unsigned int>;
  ids->push_back(6);
  ids->push_back(7);
  ids->push_back(24);
  ids->push_back(25);
  mapSmIdToTccIds_[4] = ids;

  ids = new std::vector<unsigned int>;
  ids->push_back(8);
  ids->push_back(9);
  ids->push_back(26);
  ids->push_back(27);
  mapSmIdToTccIds_[5] = ids;

  ids = new std::vector<unsigned int>;
  ids->push_back(10);
  ids->push_back(11);
  ids->push_back(28);
  ids->push_back(29);
  mapSmIdToTccIds_[6] = ids;

  ids = new std::vector<unsigned int>;
  ids->push_back(12);
  ids->push_back(13);
  ids->push_back(30);
  ids->push_back(31);
  mapSmIdToTccIds_[7] = ids;

  ids = new std::vector<unsigned int>;
  ids->push_back(14);
  ids->push_back(15);
  ids->push_back(32);
  ids->push_back(33);
  mapSmIdToTccIds_[8] = ids;

  ids = new std::vector<unsigned int>;
  ids->push_back(16);
  ids->push_back(17);
  ids->push_back(34);
  ids->push_back(35);
  mapSmIdToTccIds_[9] = ids;

  ids = new std::vector<unsigned int>;
  ids->push_back(73);
  ids->push_back(90);
  ids->push_back(91);
  ids->push_back(108);
  mapSmIdToTccIds_[46] = ids;

  ids = new std::vector<unsigned int>;
  ids->push_back(74);
  ids->push_back(75);
  ids->push_back(92);
  ids->push_back(93);
  mapSmIdToTccIds_[47] = ids;

  ids = new std::vector<unsigned int>;
  ids->push_back(76);
  ids->push_back(77);
  ids->push_back(94);
  ids->push_back(95);
  mapSmIdToTccIds_[48] = ids;

  ids = new std::vector<unsigned int>;
  ids->push_back(78);
  ids->push_back(79);
  ids->push_back(96);
  ids->push_back(97);
  mapSmIdToTccIds_[49] = ids;

  ids = new std::vector<unsigned int>;
  ids->push_back(80);
  ids->push_back(81);
  ids->push_back(98);
  ids->push_back(99);
  mapSmIdToTccIds_[50] = ids;

  ids = new std::vector<unsigned int>;
  ids->push_back(82);
  ids->push_back(83);
  ids->push_back(100);
  ids->push_back(101);
  mapSmIdToTccIds_[51] = ids;

  ids = new std::vector<unsigned int>;
  ids->push_back(84);
  ids->push_back(85);
  ids->push_back(102);
  ids->push_back(103);
  mapSmIdToTccIds_[52] = ids;

  ids = new std::vector<unsigned int>;
  ids->push_back(86);
  ids->push_back(87);
  ids->push_back(104);
  ids->push_back(105);
  mapSmIdToTccIds_[53] = ids;

  ids = new std::vector<unsigned int>;
  ids->push_back(88);
  ids->push_back(89);
  ids->push_back(106);
  ids->push_back(107);
  mapSmIdToTccIds_[54] = ids;

  //Compute data block sizes
  unfilteredFEBlockLength_ = computeUnfilteredFEBlockLength();
  ebTccBlockLength_ = computeEBTCCBlockLength();
  eeTccBlockLength_ = computeEETCCBlockLength();
}

EcalElectronicsMapper::~EcalElectronicsMapper() { deletePointers(); }

void EcalElectronicsMapper::deletePointers() {
  //DETETE ARRAYS
  for (unsigned int sm = 0; sm < NUMB_SM; sm++) {
    for (unsigned int fe = 0; fe < NUMB_FE; fe++) {
      for (unsigned int strip = 0; strip < NUMB_STRIP; strip++) {
        for (unsigned int xtal = 0; xtal < NUMB_XTAL; xtal++)
          delete xtalDetIds_[sm][fe][strip][xtal];
      }

      // if(scDetIds_[sm][fe]){
      //  delete scDetIds_[sm][fe];
      //  delete scEleIds_[sm][fe];
      for (size_t i = 0; i < srFlags_[sm][fe].size(); ++i)
        delete srFlags_[sm][fe][i];
      srFlags_[sm][fe].clear();

      delete scEleIds_[sm][fe];
    }
  }

  // delete trigger electronics Id
  for (int tccid = 0; tccid < NUMB_TCC; tccid++) {
    for (int ttid = 0; ttid < TCC_EB_NUMBTTS; ttid++) {
      for (int ps = 0; ps < NUMB_STRIP; ps++) {
        delete psInput_[tccid][ttid][ps];
      }
    }
  }

  for (unsigned int tccid = 0; tccid < NUMB_TCC; tccid++) {
    for (unsigned int tpg = 0; tpg < NUMB_FE; tpg++) {
      if (ttDetIds_[tccid][tpg]) {
        delete ttDetIds_[tccid][tpg];
        delete ttTPIds_[tccid][tpg];
        delete ttEleIds_[tccid][tpg];
      }
    }
  }

  pathToMapFile_.clear();

  std::map<unsigned int, std::vector<unsigned int>*>::iterator it;
  for (it = mapSmIdToTccIds_.begin(); it != mapSmIdToTccIds_.end(); it++) {
    delete (*it).second;
  }

  mapSmIdToTccIds_.clear();
}

void EcalElectronicsMapper::setEcalElectronicsMapping(const EcalElectronicsMapping* m) {
  mappingBuilder_ = m;
  fillMaps();
}

bool EcalElectronicsMapper::setActiveDCC(unsigned int dccId) {
  bool ret(true);

  //Update active dcc and associated smId
  dccId_ = dccId;

  smId_ = getSMId(dccId_);

  if (!smId_)
    ret = false;

  return ret;
}

bool EcalElectronicsMapper::setDCCMapFilePath(std::string aPath_) {
  //try to open a dccMapFile in the given path
  std::ifstream dccMapFile_(aPath_.c_str());

  //if not successful return false
  if (!dccMapFile_.is_open())
    return false;

  //else close file and accept given path
  dccMapFile_.close();
  pathToMapFile_ = aPath_;

  return true;
}

// bool EcalElectronicsMapper::readDCCMapFile(){

//   //try to open a dccMapFile in the given path
//   std::ifstream dccMapFile_(pathToMapFile_.c_str());

//   //if not successful return false
//   if(!dccMapFile_.is_open()) return false;

//   char lineBuf_[100];
//   unsigned int SMId_,DCCId_;
//   // loop while extraction from file is possible
//   dccMapFile_.getline(lineBuf_,10);       //read line from file
//   while (dccMapFile_.good()) {
//     sscanf(lineBuf_,"%u:%u",&SMId_,&DCCId_);
//     myDCCMap_[SMId_] = DCCId_;
//     dccMapFile_.getline(lineBuf_,10);       //read line from file
//   }

//   return true;

// }

// bool EcalElectronicsMapper::readDCCMapFile(std::string aPath_){
//   //test if path is good
//   edm::FileInPath eff(aPath_);

//   if(!setDCCMapFilePath(eff.fullPath())) return false;

//   //read DCC map file
//   readDCCMapFile();
//   return true;
// }

bool EcalElectronicsMapper::makeMapFromVectors(std::vector<int>& orderedFedUnpackList,
                                               std::vector<int>& orderedDCCIdList) {
  // in case as non standard set of DCCId:FedId pairs was provided
  if (orderedFedUnpackList.size() == orderedDCCIdList.size() && !orderedFedUnpackList.empty()) {
    edm::LogInfo("EcalElectronicsMapper") << "DCCIdList/FedUnpackList lists given. Being loaded.";

    std::string correspondence("list of pairs DCCId:FedId :  ");
    char onePair[50];
    for (int v = 0; v < ((int)orderedFedUnpackList.size()); v++) {
      myDCCMap_[orderedDCCIdList[v]] = orderedFedUnpackList[v];

      sprintf(onePair, "  %d:%d", orderedDCCIdList[v], orderedFedUnpackList[v]);
      std::string tmp(onePair);
      correspondence += tmp;
    }
    edm::LogInfo("EcalElectronicsMapper") << correspondence;

  } else {  // default set of DCCId:FedId for ECAL

    edm::LogInfo("EcalElectronicsMapper") << "No input DCCIdList/FedUnpackList lists given for ECAL unpacker"
                                          << "(or given with different number of elements). "
                                          << " Loading default association DCCIdList:FedUnpackList,"
                                          << "i.e.  1:601 ... 53:653,  54:654.";

    for (unsigned int v = 1; v <= 54; v++) {
      myDCCMap_[v] = (v + 600);
    }
  }

  return true;
}

std::ostream& operator<<(std::ostream& o, const EcalElectronicsMapper& aMapper_) {
  //print class information
  o << "---------------------------------------------------------";

  if (aMapper_.pathToMapFile_.empty()) {
    o << "No correct input for DCC map has been given yet...";
  } else {
    o << "DCC Map (Map file: " << aMapper_.pathToMapFile_ << " )"
      << "SM id\t\tDCCid ";

    //get DCC map and iterator
    std::map<unsigned int, unsigned int> aMap;
    aMap = aMapper_.myDCCMap_;
    std::map<unsigned int, unsigned int>::iterator iter;

    //print info contained in map
    for (iter = aMap.begin(); iter != aMap.end(); iter++)
      o << iter->first << "\t\t" << iter->second;
  }

  o << "---------------------------------------------------------";
  return o;
}

unsigned int EcalElectronicsMapper::computeUnfilteredFEBlockLength() {
  return ((numbXtalTSamples_ - 2) / 4 + 1) * 25 + 1;
}

unsigned int EcalElectronicsMapper::computeEBTCCBlockLength() {
  unsigned int nTT = 68;
  unsigned int tf;

  //TCC block size: header (8 bytes) + 17 words with 4 trigger primitives (17*8bytes)
  if ((nTT * numbTriggerTSamples_) < 4 || (nTT * numbTriggerTSamples_) % 4)
    tf = 1;
  else
    tf = 0;

  return 1 + ((nTT * numbTriggerTSamples_) / 4) + tf;
}

unsigned int EcalElectronicsMapper::computeEETCCBlockLength() {
  //Todo : implement multiple tt samples for the endcap
  return 9;
}

bool EcalElectronicsMapper::isTCCExternal(unsigned int TCCId) {
  if ((NUMB_TCC_EE_MIN_EXT_MIN <= TCCId && TCCId <= NUMB_TCC_EE_MIN_EXT_MAX) ||
      (NUMB_TCC_EE_PLU_EXT_MIN <= TCCId && TCCId <= NUMB_TCC_EE_PLU_EXT_MAX))
    return true;
  else
    return false;
}

unsigned int EcalElectronicsMapper::getDCCId(unsigned int aSMId_) const {
  //get iterator for SM id
  std::map<unsigned int, unsigned int>::const_iterator it = myDCCMap_.find(aSMId_);

  //check if SMid exists and return DCC id
  if (it != myDCCMap_.end())
    return it->second;

  //error return
  if (!DCCDataUnpacker::silentMode_) {
    edm::LogError("IncorrectMapping") << "DCC requested for SM id: " << aSMId_ << " not found";
  }
  return 0;
}

unsigned int EcalElectronicsMapper::getSMId(unsigned int aDCCId_) const {
  //get iterator map
  std::map<unsigned int, unsigned int>::const_iterator it;

  //try to find SM id for given DCC id
  for (it = myDCCMap_.begin(); it != myDCCMap_.end(); it++)
    if (it->second == aDCCId_)
      return it->first;

  //error return
  if (!DCCDataUnpacker::silentMode_) {
    edm::LogError("IncorrectMapping") << "SM requested DCC id: " << aDCCId_ << " not found";
  }
  return 0;
}

void EcalElectronicsMapper::fillMaps() {
  for (int smId = 1; smId <= 54; smId++) {
    // Fill EB arrays
    if (smId > 9 && smId < 46) {
      for (int feChannel = 1; feChannel <= 68; feChannel++) {
        unsigned int tccId = smId + TCCID_SMID_SHIFT_EB;

        // Builds Ecal Trigger Tower Det Id

        unsigned int rawid = (mappingBuilder_->getTrigTowerDetId(tccId, feChannel)).rawId();
        EcalTrigTowerDetId* ttDetId = new EcalTrigTowerDetId(rawid);
        ttDetIds_[tccId - 1][feChannel - 1] = ttDetId;
        EcalElectronicsId* ttEleId = new EcalElectronicsId(smId, feChannel, 1, 1);
        ttEleIds_[tccId - 1][feChannel - 1] = ttEleId;
        EcalTriggerPrimitiveDigi* tp = new EcalTriggerPrimitiveDigi(*ttDetId);
        tp->setSize(numbTriggerTSamples_);
        for (unsigned int i = 0; i < numbTriggerTSamples_; i++) {
          tp->setSample(i, EcalTriggerPrimitiveSample(0));
        }
        ttTPIds_[tccId - 1][feChannel - 1] = tp;

        // build pseudostrip input data digi
        for (int ps = 1; ps <= 5; ps++) {
          psInput_[tccId - 1][feChannel - 1][ps - 1] =
              new EcalPseudoStripInputDigi(EcalTriggerElectronicsId(tccId, feChannel, ps, 1));
          psInput_[tccId - 1][feChannel - 1][ps - 1]->setSize(1);
          psInput_[tccId - 1][feChannel - 1][ps - 1]->setSample(0, EcalPseudoStripInputSample(0));
        }

        // Buil SRP Flag
        srFlags_[smId - 1][feChannel - 1].push_back(new EBSrFlag(*ttDetId, 0));

        //only one element for barrel: 1-to-1 correspondance between
        //DCC channels and EB trigger tower:
        assert(srFlags_[smId - 1][feChannel - 1].size() == 1);

        for (unsigned int stripId = 1; stripId <= 5; stripId++) {
          for (unsigned int xtalId = 1; xtalId <= 5; xtalId++) {
            EcalElectronicsId eid(smId, feChannel, stripId, xtalId);
            EBDetId* detId = new EBDetId((mappingBuilder_->getDetId(eid)).rawId());
            xtalDetIds_[smId - 1][feChannel - 1][stripId - 1][xtalId - 1] = detId;

          }  // close loop over xtals
        }    // close loop over strips

      }  // close loop over fechannels

    }  //close loop over sm ids in the EB
    // Fill EE arrays (Todo : waiting SC correction)

    else {
      std::vector<unsigned int>* pTCCIds = mapSmIdToTccIds_[smId];
      std::vector<unsigned int>::iterator it;

      for (it = pTCCIds->begin(); it != pTCCIds->end(); it++) {
        unsigned int tccId = *it;

        // creating arrays of pointers for trigger objects
        for (unsigned int towerInTCC = 1; towerInTCC <= numChannelsInDcc_[smId - 1]; towerInTCC++) {
          // Builds Ecal Trigger Tower Det Id
          EcalTrigTowerDetId ttDetId = mappingBuilder_->getTrigTowerDetId(tccId, towerInTCC);

          ttDetIds_[tccId - 1][towerInTCC - 1] = new EcalTrigTowerDetId(ttDetId.rawId());
          EcalTriggerPrimitiveDigi* tp = new EcalTriggerPrimitiveDigi(ttDetId);
          tp->setSize(numbTriggerTSamples_);
          for (unsigned int i = 0; i < numbTriggerTSamples_; i++) {
            tp->setSample(i, EcalTriggerPrimitiveSample(0));
          }

          ttTPIds_[tccId - 1][towerInTCC - 1] = tp;

          // build pseudostrip input data digi
          for (int ps = 1; ps <= 5; ps++) {
            psInput_[tccId - 1][towerInTCC - 1][ps - 1] =
                new EcalPseudoStripInputDigi(EcalTriggerElectronicsId(tccId, towerInTCC, ps, 1));
            psInput_[tccId - 1][towerInTCC - 1][ps - 1]->setSize(1);
            psInput_[tccId - 1][towerInTCC - 1][ps - 1]->setSample(0, EcalPseudoStripInputSample(0));
          }
        }
      }

      // creating arrays of pointers for digi objects
      for (unsigned int feChannel = 1; feChannel <= numChannelsInDcc_[smId - 1]; feChannel++) {
        // to avoid gap in CCU_id's
        if ((smId == SECTOR_EEM_CCU_JUMP || smId == SECTOR_EEP_CCU_JUMP) &&
            (MIN_CCUID_JUMP <= feChannel && feChannel <= MAX_CCUID_JUMP))
          continue;

        std::vector<EcalScDetId> scDetIds = mappingBuilder_->getEcalScDetId(smId, feChannel);
        // scDetIds_[smId-1][feChannel-1] = new EcalScDetId(scDetId.rawId());
        scEleIds_[smId - 1][feChannel - 1] = new EcalElectronicsId(smId, feChannel, 1, 1);

        for (size_t i = 0; i < scDetIds.size(); ++i) {
          // std::cout << __FILE__ << ":" << __LINE__ << ": "
          //            << "(DCC,RU) = (" <<  smId << "," << feChannel
          //            << ") -> " << scDetIds[i] << "\n";

          srFlags_[smId - 1][feChannel - 1].push_back(new EESrFlag(EcalScDetId(scDetIds[i].rawId()), 0));
        }
        //usually only one element 1 DCC channel <-> 1 SC
        //in few case two or three elements: partial SCs grouped.
        assert(srFlags_[smId - 1][feChannel - 1].size() <= 3);

        std::vector<DetId> ecalDetIds = mappingBuilder_->dccTowerConstituents(smId, feChannel);
        std::vector<DetId>::iterator it;

        //EEDetIds
        for (it = ecalDetIds.begin(); it != ecalDetIds.end(); it++) {
          EcalElectronicsId ids = mappingBuilder_->getElectronicsId((*it));

          int stripId = ids.stripId();
          int xtalId = ids.xtalId();

          EEDetId* detId = new EEDetId((*it).rawId());
          xtalDetIds_[smId - 1][feChannel - 1][stripId - 1][xtalId - 1] = detId;
        }  // close loop over tower constituents

      }  // close loop over  FE Channels

    }  // closing loop over sm ids in EE
  }

  // developing mapping for pseudostrip input data: (tccId,psNumber)->(tccId,towerId,psId)
  // initializing array for pseudostrip data
  short numStripInTT[EcalTriggerElectronicsId::MAX_TCCID][EcalTrigTowerDetId::kEBTowersPerSM];
  for (int tccId = 0; tccId < EcalTriggerElectronicsId::MAX_TCCID; tccId++) {
    for (int tt = 0; tt < EcalTrigTowerDetId::kEBTowersPerSM; tt++) {
      numStripInTT[tccId][tt] = -2;
    }
  }

  // assumption: if ps_max is the largest pseudostripId within a trigger tower
  // all the pseudostrip 1 ...  ps_max are actually present
  std::vector<DetId>::iterator theTCCConstituent;
  for (int tccId = 0; tccId < EcalTriggerElectronicsId::MAX_TCCID; tccId++) {
    // loop over all constituents of a TCC and collect
    // the largest pseudostripId within each trigger tower
    std::vector<DetId> tccConstituents = mappingBuilder_->tccConstituents(tccId + 1);

    for (theTCCConstituent = tccConstituents.begin(); theTCCConstituent != tccConstituents.end(); theTCCConstituent++) {
      int towerId = (mappingBuilder_->getTriggerElectronicsId(*theTCCConstituent)).ttId();
      int ps = (mappingBuilder_->getTriggerElectronicsId(*theTCCConstituent)).pseudoStripId();
      if (ps > numStripInTT[tccId][towerId - 1])
        numStripInTT[tccId][towerId - 1] = ps;

      //std::cout << "tccId: " << (tccId+1) << "    towerId: " << towerId
      // << "    ps: " << ps << "    numStripInTT: " << numStripInTT[tccId][towerId-1] << std::endl;

    }  // loop on TCC constituents

  }  // loop on TCC's

  int psCounter;
  for (int tccId = 0; tccId < EcalTriggerElectronicsId::MAX_TCCID; tccId++) {
    // resetting pseudostrip counter at each new TCC
    psCounter = 0;
    for (int towerId = 0; towerId < EcalTrigTowerDetId::kEBTowersPerSM; towerId++) {
      // if there's not a given towerId, numStripInTT==-1
      for (int ps = 0; ps < numStripInTT[tccId][towerId]; ps++) {
        tTandPs_[tccId][psCounter][0] = towerId + 1;
        tTandPs_[tccId][psCounter][1] = ps + 1;
        psCounter++;
      }  // loop on TCC's
    }    // loop on towers in TCC
  }      // loop in ps in tower

  //   for (int tccId=0; tccId<EcalTriggerElectronicsId::MAX_TCCID; tccId++) {
  //       for (int psCounter=0; psCounter<EcalTrigTowerDetId::kEBTowersPerSM*5; psCounter++) {
  //           std::cout << "tccId: " << (tccId+1) << "    counter: " << (psCounter+1)
  //                     << " tt: " << tTandPs_[tccId][psCounter][0]
  //                     << " ps: " << tTandPs_[tccId][psCounter][1]
  //                     << std::endl;
  //       } }

  // Note:
  // for TCC 48 in EE, pseudostrip data in the interval:
  // + 1-30 is good pseudostrip data
  // + 31-42 is a duplication of the last 12 ps of the previous block, and needs be ignored
  // + 43-60 is further good pseudostrip data

  for (int tcc = EcalTriggerElectronicsId::MIN_TCCID_EEM; tcc <= EcalTriggerElectronicsId::MAX_TCCID_EEM; tcc++) {
    int tccId = tcc - 1;
    short tTandPs_tmp[18][2];

    // store entries _after_ the pseudostrip data which gets duplicated
    for (int psCounter = 30; psCounter < 48; psCounter++) {
      tTandPs_tmp[psCounter - 30][0] = tTandPs_[tccId][psCounter][0];
      tTandPs_tmp[psCounter - 30][1] = tTandPs_[tccId][psCounter][1];
    }

    // duplication
    for (int psCounter = 18; psCounter < 30; psCounter++) {
      tTandPs_[tccId][psCounter + 12][0] = tTandPs_[tccId][psCounter][0];
      tTandPs_[tccId][psCounter + 12][1] = tTandPs_[tccId][psCounter][1];
    }

    // append stoed
    for (int psCounter = 42; psCounter < 60; psCounter++) {
      tTandPs_[tccId][psCounter][0] = tTandPs_tmp[psCounter - 42][0];
      tTandPs_[tccId][psCounter][1] = tTandPs_tmp[psCounter - 42][1];
    }

  }  // loop on EEM TCC's

  for (int tcc = EcalTriggerElectronicsId::MIN_TCCID_EEP; tcc <= EcalTriggerElectronicsId::MAX_TCCID_EEP; tcc++) {
    int tccId = tcc - 1;
    short tTandPs_tmp[18][2];

    // store entries _after_ the pseudostrip data which gets duplicated
    for (int psCounter = 30; psCounter < 48; psCounter++) {
      tTandPs_tmp[psCounter - 30][0] = tTandPs_[tccId][psCounter][0];
      tTandPs_tmp[psCounter - 30][1] = tTandPs_[tccId][psCounter][1];
    }

    // duplication
    for (int psCounter = 18; psCounter < 30; psCounter++) {
      tTandPs_[tccId][psCounter + 12][0] = tTandPs_[tccId][psCounter][0];
      tTandPs_[tccId][psCounter + 12][1] = tTandPs_[tccId][psCounter][1];
    }

    // append stoed
    for (int psCounter = 42; psCounter < 60; psCounter++) {
      tTandPs_[tccId][psCounter][0] = tTandPs_tmp[psCounter - 42][0];
      tTandPs_[tccId][psCounter][1] = tTandPs_tmp[psCounter - 42][1];
    }

  }  // loop on EEP TCC's

  //for (int tccId=0; tccId<EcalTriggerElectronicsId::MAX_TCCID; tccId++) {
  //for (int psCounter=0; psCounter<EcalTrigTowerDetId::kEBTowersPerSM*5; psCounter++) {
  //std::cout << "AF tccId: " << (tccId+1) << "    counter: " << (psCounter+1)
  //<< " tt: " << tTandPs_[tccId][psCounter][0]
  //<< " ps: " << tTandPs_[tccId][psCounter][1]
  //<< std::endl;
  // } }
}

void EcalElectronicsMapper::setupGhostMap() {
  // number of 'ghost' VFEs
  const int n = 44;

  // here is a list of all 'ghost' VFEs
  // in format {FED, CCU, VFE}
  const struct {
    int FED, CCU, VFE;
  } v[n] = {{601, 10, 5}, {601, 34, 3}, {601, 34, 4}, {601, 34, 5}, {602, 32, 5}, {603, 12, 5}, {603, 30, 5},
            {604, 12, 5}, {604, 30, 5}, {605, 32, 5}, {606, 10, 5}, {606, 34, 3}, {606, 34, 4}, {606, 34, 5},
            {608, 27, 3}, {608, 27, 4}, {608, 27, 5}, {608, 3, 3},  {608, 3, 4},  {608, 3, 5},  {608, 30, 5},
            {608, 6, 5},  {646, 10, 5}, {646, 34, 3}, {646, 34, 4}, {646, 34, 5}, {647, 32, 5}, {648, 12, 5},
            {648, 30, 5}, {649, 12, 5}, {649, 30, 5}, {650, 32, 5}, {651, 10, 5}, {651, 34, 3}, {651, 34, 4},
            {651, 34, 5}, {653, 27, 3}, {653, 27, 4}, {653, 27, 5}, {653, 3, 3},  {653, 3, 4},  {653, 3, 5},
            {653, 30, 5}, {653, 6, 5}};

  for (int i = 0; i < n; ++i)
    ghost_[v[i].FED][v[i].CCU][v[i].VFE] = true;
}

bool EcalElectronicsMapper::isGhost(const int FED, const int CCU, const int VFE) {
  if (ghost_.find(FED) == ghost_.end())
    return false;

  if (ghost_[FED].find(CCU) == ghost_[FED].end())
    return false;

  if (ghost_[FED][CCU].find(VFE) == ghost_[FED][CCU].end())
    return false;

  return true;
}

// number of readout channels (TT in EB, SC in EE) in a DCC
const unsigned int EcalElectronicsMapper::numChannelsInDcc_[NUMB_SM] = {
    34, 32, 33, 33, 32, 34, 33, 41, 33,                                      // EE -
    68, 68, 68, 68, 68, 68, 68, 68, 68, 68,                                  // EB-
    68, 68, 68, 68, 68, 68, 68, 68, 68, 68, 68, 68, 68, 68, 68, 68, 68, 68,  // EB+
    68, 68, 68, 68, 68, 68, 68, 68, 34, 32, 33, 33, 32, 34, 33, 41, 33};     // EE+