RPCPacManager< TPacType > Class Template Reference

#include <RPCPacManager.h>

Public Member Functions
TPacType *	getPac (int m_tower, int logSector, int logSegment) const
TPacType *	getPac (const RPCConst::l1RpcConeCrdnts &coneCrdnts) const
void	init (std::string patFilesDirectory, L1RpcPACsCntEnum _PACsCnt)
void	init (const L1RPCConfig *rpcconf)
	~RPCPacManager ()

Private Member Functions
void	destroy ()

Private Attributes
L1RpcPACsCntEnum	m_PACsCnt
std::vector< std::vector< std::vector< TPacType * > > >	m_PacTab
	m_PacTab[m_tower][logSector][m_LogSegment] More...
int	m_SectorsCnt
	Count of used differnt sectors. More...
int	m_SegmentCnt
	Count of used differnt segments. More...

Detailed Description

template<class TPacType>
class RPCPacManager< TPacType >

The singleton object of thise class stores all PACs of L1RPC trigger. The tempalte type TPacTypeshould be derived from RPCPacBase, and containe the constructor: RPCPacData(std::string patFilesDir, int m_tower, int logSector, int logSegment). 3 configuration are suported: ONE_PAC_PER_TOWER - the same m_PAC (set of patterns etc.) for every LogCone in a m_tower _12_PACS_PER_TOWER - the same m_PAC in the same segment in every sector, (i.e. 12 PACs in sector (one for LogicCone (segment)), all sectors are treat as one) _144_PACS_PER_TOWER - one m_PAC for every LogicCone of given m_tower

Author

Karol Bunkowski (Warsaw)

Definition at line 41 of file RPCPacManager.h.

Constructor & Destructor Documentation

~RPCPacManager()

template<class TPacType>

RPCPacManager< TPacType >::~RPCPacManager ( )

inline

Definition at line 43 of file RPCPacManager.h.

                   {
    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;
        }
      }
  }

Member Function Documentation

destroy()

template<class TPacType>

void RPCPacManager< TPacType >::destroy ( )

inlineprivate

Definition at line 194 of file RPCPacManager.h.

Referenced by RPCPacManager< RPCPacData >::init().

                 {
    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();
  }

getPac() [1/2]

template<class TPacType>

TPacType* RPCPacManager< TPacType >::getPac ( int  m_tower, int  logSector, int  logSegment  ) const

inline

Returns the pointer to m_PAC for given LogCone defined by m_tower, logSector, logSegment. Here you do not have to care, what configuration is curent used.

Parameters

m_tower	-16 : 16,
logSector	0 : 11,
logSegment	0 : 11.

Definition at line 161 of file RPCPacManager.h.

Referenced by RPCBasicTrigConfig::getPac(), and RPCPacManager< RPCPacData >::getPac().

                                                                     {
    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];
  };

getPac() [2/2]

template<class TPacType>

TPacType* RPCPacManager< TPacType >::getPac ( const RPCConst::l1RpcConeCrdnts &  coneCrdnts ) const

inline

Definition at line 181 of file RPCPacManager.h.

                                                                    {
    return getPac(coneCrdnts.m_Tower, coneCrdnts.m_LogSector, coneCrdnts.m_LogSegment);
  }

init() [1/2]

template<class TPacType>

void RPCPacManager< TPacType >::init ( std::string  patFilesDirectory, L1RpcPACsCntEnum  _PACsCnt  )

inline

Gets data for PACs.

Parameters

patFilesDirectory	The directory where files defining PACs are stored. The files should be named acording to special convencion.
_PACsCnt	The configuration version. Should be caled once, before using PACs

Definition at line 58 of file RPCPacManager.h.

Referenced by RPCTrigger::produce().

                                                                    {
    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);
        }
      }
    }
  };

init() [2/2]

template<class TPacType>

void RPCPacManager< TPacType >::init ( const L1RPCConfig *  rpcconf )

inline

Definition at line 87 of file RPCPacManager.h.

                                        {
    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);
        }
      }
    }
  };

Member Data Documentation

m_PACsCnt

template<class TPacType>

L1RpcPACsCntEnum RPCPacManager< TPacType >::m_PACsCnt

private

Definition at line 192 of file RPCPacManager.h.

Referenced by RPCPacManager< RPCPacData >::getPac(), and RPCPacManager< RPCPacData >::init().

m_PacTab

template<class TPacType>

std::vector<std::vector<std::vector<TPacType*> > > RPCPacManager< TPacType >::m_PacTab

private

m_PacTab[m_tower][logSector][m_LogSegment]

Definition at line 186 of file RPCPacManager.h.

Referenced by RPCPacManager< RPCPacData >::destroy(), RPCPacManager< RPCPacData >::getPac(), RPCPacManager< RPCPacData >::init(), and RPCPacManager< RPCPacData >::~RPCPacManager().

m_SectorsCnt

template<class TPacType>

int RPCPacManager< TPacType >::m_SectorsCnt

private

Count of used differnt sectors.

Definition at line 188 of file RPCPacManager.h.

Referenced by RPCPacManager< RPCPacData >::init().

m_SegmentCnt

template<class TPacType>

int RPCPacManager< TPacType >::m_SegmentCnt

private

Count of used differnt segments.

Definition at line 190 of file RPCPacManager.h.

Referenced by RPCPacManager< RPCPacData >::init().