RPCPacManager.h

Go to the documentation of this file.

#ifndef L1Trigger_RPCPacManager_h
#define L1Trigger_RPCPacManager_h
 
//------------------------------------------------------------------------------
#include <string>
#include <vector>
#include "L1Trigger/RPCTrigger/interface/RPCConst.h"
#include "L1Trigger/RPCTrigger/interface/RPCException.h"
 
#include "CondFormats/L1TObjects/interface/L1RPCConfig.h"
 
#include <cstdlib>
#ifndef _STAND_ALONE
#include "FWCore/MessageLogger/interface/MessageLogger.h"
#endif  // _STAND_ALONE
 
// TODO: should be moved to L1RPConfig
enum L1RpcPACsCntEnum {
  ONE_PAC_PER_TOWER = 1,
  _12_PACS_PER_TOWER = 12,  //the same m_PAC in the same segment in every sector,
  _144_PACS_PER_TOWER = 144,
  TB_TESTS
};
 
template <class TPacType>
class RPCPacManager {
public:
  ~RPCPacManager() {
    for (unsigned int m_tower = 0; m_tower < m_PacTab.size(); m_tower++)
      for (unsigned int logSector = 0; logSector < m_PacTab[m_tower].size(); logSector++) {
        for (unsigned int logSegment = 0; logSegment < m_PacTab[m_tower][logSector].size(); logSegment++) {
          TPacType* pac = m_PacTab[m_tower][logSector][logSegment];
          delete pac;
        }
      }
  }
 
  void init(std::string patFilesDirectory, L1RpcPACsCntEnum _PACsCnt) {
    destroy();
    m_PACsCnt = _PACsCnt;
    if (m_PACsCnt == ONE_PAC_PER_TOWER) {
      m_SectorsCnt = 1;
      m_SegmentCnt = 1;
    } else if (m_PACsCnt == _12_PACS_PER_TOWER) {
      m_SectorsCnt = 1;
      m_SegmentCnt = 12;
    } else if (m_PACsCnt == _144_PACS_PER_TOWER) {
      m_SectorsCnt = 12;
      m_SegmentCnt = 12;
    } else if (m_PACsCnt == TB_TESTS) {
      m_SectorsCnt = 1;
      m_SegmentCnt = 4;
    }
 
    for (int m_tower = 0; m_tower < RPCConst::m_TOWER_COUNT; m_tower++) {
      m_PacTab.push_back(std::vector<std::vector<TPacType*> >());
      for (int logSector = 0; logSector < m_SectorsCnt; logSector++) {
        m_PacTab[m_tower].push_back(std::vector<TPacType*>());
        for (int logSegment = 0; logSegment < m_SegmentCnt; logSegment++) {
          TPacType* pac = new TPacType(patFilesDirectory, m_tower, logSector, logSegment);
          m_PacTab[m_tower][logSector].push_back(pac);
        }
      }
    }
  };
 
  void init(const L1RPCConfig* rpcconf) {
    destroy();
    switch (rpcconf->getPPT()) {
      case 1:
        m_PACsCnt = ONE_PAC_PER_TOWER;
        break;
      case 12:
        m_PACsCnt = _12_PACS_PER_TOWER;
        break;
      case 144:
        m_PACsCnt = _144_PACS_PER_TOWER;
        break;
    }
 
    if (m_PACsCnt == ONE_PAC_PER_TOWER) {
      m_SectorsCnt = 1;
      m_SegmentCnt = 1;
    } else if (m_PACsCnt == _12_PACS_PER_TOWER) {
      m_SectorsCnt = 1;
      m_SegmentCnt = 12;
    } else if (m_PACsCnt == _144_PACS_PER_TOWER) {
      m_SectorsCnt = 12;
      m_SegmentCnt = 12;
    } else if (m_PACsCnt == TB_TESTS) {
      m_SectorsCnt = 1;
      m_SegmentCnt = 4;
    }
 
    /*
    std::vector<std::vector<std::vector<RPCPattern::RPCPatVec> > > patvec;
    std::vector<std::vector<std::vector<RPCPattern::TQualityVec> > > qualvec;
    for (int tower = 0; tower < RPCConst::m_TOWER_COUNT; ++tower) {
      patvec.push_back(std::vector< std::vector< RPCPattern::RPCPatVec > >());
      qualvec.push_back(std::vector< std::vector< RPCPattern::TQualityVec > >());
      for (int logSector = 0; logSector < m_SectorsCnt; ++logSector) {
        patvec[tower].push_back(std::vector< RPCPattern::RPCPatVec >());
        qualvec[tower].push_back(std::vector< RPCPattern::TQualityVec >());
        for (int logSegment = 0; logSegment < m_SegmentCnt; ++logSegment) {
          patvec[tower][logSector].push_back(RPCPattern::RPCPatVec());
          qualvec[tower][logSector].push_back(RPCPattern::TQualityVec());
        }
      }
    }
 
    for (unsigned int ipat=0; ipat<rpcconf->m_pats.size(); ipat++)
      patvec[rpcconf->m_pats[ipat].getTower()][rpcconf->m_pats[ipat].getLogSector()][rpcconf->m_pats[ipat].getLogSegment()].push_back(rpcconf->m_pats[ipat]);
    for (unsigned int iqual=0; iqual<rpcconf->m_quals.size(); iqual++)
      qualvec[rpcconf->m_quals[iqual].m_tower][rpcconf->m_quals[iqual].m_logsector][rpcconf->m_quals[iqual].m_logsegment].push_back(rpcconf->m_quals[iqual]);
    */
 
    for (int tower = 0; tower < RPCConst::m_TOWER_COUNT; tower++) {
      m_PacTab.push_back(std::vector<std::vector<TPacType*> >());
      for (int logSector = 0; logSector < m_SectorsCnt; logSector++) {
        m_PacTab[tower].push_back(std::vector<TPacType*>());
        for (int logSegment = 0; logSegment < m_SegmentCnt; logSegment++) {
          /*L1RPCConfig* rpcconf1=new L1RPCConfig();
          rpcconf1->setPPT(rpcconf->getPPT());
          for (unsigned int ipat=0; ipat<patvec[tower][logSector][logSegment].size(); ipat++)
            rpcconf1->m_pats.push_back(patvec[tower][logSector][logSegment][ipat]);
          for (unsigned int iqual=0; iqual<qualvec[tower][logSector][logSegment].size(); iqual++)
            rpcconf1->m_quals.push_back(qualvec[tower][logSector][logSegment][iqual]);
          //TPacType* pac  = new TPacType(rpcconf1->m_pats,rpcconf1->m_quals);*/
          TPacType* pac = new TPacType(rpcconf, tower, logSector, logSegment);
          m_PacTab[tower][logSector].push_back(pac);
        }
      }
    }
  };
 
  //const
  TPacType* getPac(int m_tower, int logSector, int logSegment) const {
    if (m_PacTab.size() <= (unsigned int)abs(m_tower))
      throw RPCException("RPCPacManager::getPac: given towerNum to big");
    // edm::LogError("RPCTrigger") << "RPCPacManager::getPac: given towerNum to big" << std::endl;
 
    //int curLogSector = logSector;
    //int curlogSegment = logSegment;
 
    if (m_PACsCnt == ONE_PAC_PER_TOWER) {
      logSector = 0;
      logSegment = 0;
    } else if (m_PACsCnt == _12_PACS_PER_TOWER) {
      logSector = 0;
    }
 
    //XXXX//m_PacTab[abs(m_tower)][logSector][logSegment]->setCurrentPosition(m_tower, curLogSector, curlogSegment);
    return m_PacTab[std::abs(m_tower)][logSector][logSegment];
  };
 
  //const
  TPacType* getPac(const RPCConst::l1RpcConeCrdnts& coneCrdnts) const {
    return getPac(coneCrdnts.m_Tower, coneCrdnts.m_LogSector, coneCrdnts.m_LogSegment);
  }
 
private:
  std::vector<std::vector<std::vector<TPacType*> > > m_PacTab;  
 
  int m_SectorsCnt;  
 
  int m_SegmentCnt;  
 
  L1RpcPACsCntEnum m_PACsCnt;  //Used configuration version.
 
  void destroy() {
    for (size_t tower = 0; tower < m_PacTab.size(); ++tower) {
      for (size_t logSector = 0; logSector < m_PacTab.at(tower).size(); logSector++) {
        for (size_t logSegment = 0; logSegment < m_PacTab.at(tower).at(logSector).size(); logSegment++) {
          TPacType* pac = m_PacTab.at(tower).at(logSector).at(logSegment);
          delete pac;
        }
      }
    }
    m_PacTab.clear();
  }
};
 
#endif