L1RPCConeBuilder.h

Go to the documentation of this file.

#ifndef CondFormats_RPCObjects_L1RPCConeBuilder_h
#define CondFormats_RPCObjects_L1RPCConeBuilder_h
// -*- C++ -*-
//
// Package:     RPCObjects
// Class  :     L1RPCConeBuilder
// 
//
// Original Author:  Tomasz Fruboes
//         Created:  Fri Feb 22 12:27:02 CET 2008
// $Id: L1RPCConeBuilder.h,v 1.8 2009/03/20 15:10:53 michals Exp $
//

#include "CondFormats/Serialization/interface/Serializable.h"

#include <vector>
#include <map>
#include <stdint.h>
#include <cstdlib>
#include "CondFormats/L1TObjects/interface/L1RPCConeDefinition.h"
#include <memory>


class L1RPCConeBuilder
{
   
   public:


      // uncompressed connections
      struct TStripCon{
        signed char m_tower;
        unsigned char m_PAC;
        unsigned char m_logplane;
        unsigned char m_logstrip;

        COND_SERIALIZABLE;
      };
      typedef std::vector<TStripCon> TStripConVec;
      typedef std::map<unsigned char, TStripConVec> TStrip2ConVec;
      typedef std::map<uint32_t, TStrip2ConVec> TConMap;
      
      

      // compressed connections
      struct TCompressedCon{
        signed char m_tower;
        signed char m_mul; 
        unsigned char m_PAC;
        unsigned char m_logplane;
        unsigned char m_validForStripFirst; 
        unsigned char m_validForStripLast; 
        signed short m_offset;
        
        TCompressedCon() : m_tower(99),  m_mul(99), m_PAC(0), 
          m_logplane(99), m_validForStripFirst(0), m_validForStripLast(0), m_offset(-1000){};
          
        int getLogStrip(int strip, const L1RPCConeDefinition::TLPSizeVec & LPSizeVec) const{
          int ret = -1;
          if ( strip >= m_validForStripFirst && strip <= m_validForStripLast ){ 
            ret = int(m_mul)*strip+int(m_offset);
          
            int lpSize = -1;
            L1RPCConeDefinition::TLPSizeVec::const_iterator it = LPSizeVec.begin();
            L1RPCConeDefinition::TLPSizeVec::const_iterator itEnd = LPSizeVec.end();
            for (;it!=itEnd;++it){
            
              if (it->m_tower != std::abs(m_tower) || it->m_LP != m_logplane-1) continue;
              lpSize = it->m_size;
            
            }

            //FIXME
            if (lpSize==-1) {
              //throw cms::Exception("getLogStrip") << " lpSize==-1\n";
            }
            
            //if (ret<0 || ret > LPSizesInTowers.at(std::abs(m_tower)).at(m_logplane-1)  )
            if (ret<0 || ret > lpSize )
              return -1;
          
          }
          return ret;
        }
        
        void addStrip(unsigned char strip) {
          if (m_validForStripFirst==0) {
            m_validForStripFirst = strip;
            m_validForStripLast = strip;
          } else if (strip < m_validForStripFirst){
            m_validForStripFirst = strip;
          }
          else if (strip > m_validForStripLast){
            m_validForStripLast = strip;
          }
        
        }
        
        COND_SERIALIZABLE;
      };
      
      typedef std::vector<TCompressedCon> TCompressedConVec;
      typedef std::map<uint32_t, TCompressedConVec> TCompressedConMap;
      
      
      
      L1RPCConeBuilder();
      virtual ~L1RPCConeBuilder();

            
      void setConeConnectionMap(const std::shared_ptr< TConMap > connMap) 
                      { m_coneConnectionMap = connMap;};
                      
      void setCompressedConeConnectionMap(const std::shared_ptr< TCompressedConMap >
                                              cmpConnMap) 
      {  
            m_compressedConeConnectionMap = cmpConnMap;
      };
      
      std::pair<TStripConVec::const_iterator, TStripConVec::const_iterator> 
          getConVec(uint32_t det, unsigned char strip) const ;
      
      std::pair<TCompressedConVec::const_iterator, TCompressedConVec::const_iterator> 
          getCompConVec(uint32_t det) const ;
      
      void setFirstTower(int tow) {m_firstTower = tow;};
      void setLastTower(int tow) {m_lastTower = tow;};
      

      
   private:
         
     int m_firstTower;
     int m_lastTower;

     std::shared_ptr< TConMap > m_coneConnectionMap; 
     std::shared_ptr< TCompressedConMap >  m_compressedConeConnectionMap;

   COND_SERIALIZABLE;
};


#endif