/data/refman/pasoursint/CMSSW_4_1_8_patch9/src/CondFormats/EcalObjects/interface/EcalCondTowerObjectContainer.h

Go to the documentation of this file.

#ifndef ECAL_CONDTOWER_OBJECT_CONTAINER_HH
#define ECAL_CONDTOWER_OBJECT_CONTAINER_HH

#include "DataFormats/EcalDetId/interface/EcalContainer.h"
#include "DataFormats/EcalDetId/interface/EcalTrigTowerDetId.h"
#include "DataFormats/EcalDetId/interface/EcalScDetId.h"


#include <cstdio>

template < typename T >
class EcalCondTowerObjectContainer {
        public:
                typedef T Item;
                typedef Item value_type;
                typedef EcalCondTowerObjectContainer<T> self;
                typedef typename std::vector<Item> Items;
                typedef typename std::vector<Item>::const_iterator const_iterator; 
                typedef typename std::vector<Item>::iterator iterator;

                EcalCondTowerObjectContainer() {
                  size_t ebsize=(size_t)EcalTrigTowerDetId::kEBTowersPerSM*18*2;
                  eb_.checkAndResize(ebsize);
                  size_t eesize=(size_t)632;
                  ee_.checkAndResize(eesize);
                };
                ~EcalCondTowerObjectContainer() {};

                inline
                const Items & barrelItems() const { return eb_.items(); };

                inline
                const Items & endcapItems() const { return ee_.items(); };

                inline
                const Item & barrel( size_t hashedIndex ) const {
                        return eb_.item(hashedIndex);
                }
                
                inline
                const Item & endcap( size_t hashedIndex ) const {
                        return ee_.item(hashedIndex);
                }

                inline void insert( std::pair<uint32_t, Item> const &a ) {
                  DetId id(a.first);
                  if( id.subdetId() == EcalBarrel || id.subdetId() == EcalTriggerTower )   { 
                    eb_.insert(a);
                  } else if(  id.subdetId() == EcalEndcap  ) { 
                    ee_.insert(a);
                  } else {
                    std::cout <<"*** ERROR it is not barrel nor endcap tower"<< std::endl;
                  }
                }
                
                inline
                const_iterator find( uint32_t rawId ) const {
                        DetId id(rawId);
                        if( id.subdetId() == EcalBarrel || id.subdetId() == EcalTriggerTower )   { 
                          const_iterator it = eb_.find(rawId);
                          if ( it != eb_.end() ) {
                            return it;
                          } else {
                            return ee_.end();
                          }
                        } else if(  id.subdetId() == EcalEndcap  ) { 
                          return ee_.find(rawId);
                        } else {
                          return ee_.end();
                        }
                }

                inline
                const_iterator begin() const {
                        return eb_.begin();
                }

                inline
                const_iterator end() const {
                        return ee_.end();
                }

                inline
                void setValue(const uint32_t id, const Item &item) {
                        (*this)[id] = item;
                }

                inline
                const self & getMap() const {
                        return *this;
                }

                inline
                size_t size() const {
                        return eb_.size() + ee_.size();
                }
                // add coherent operator++, not needed now -- FIXME

                inline
                Item & operator[]( uint32_t rawId ) {
                        DetId id(rawId);
                        static Item dummy;

                        if( id.subdetId() == EcalBarrel || id.subdetId() == EcalTriggerTower )   { 
                          return eb_[rawId];
                        } else if(  id.subdetId() == EcalEndcap  ) { 
                          return ee_[rawId];
                        } else {
                          return dummy;
                        }
                }
                
                inline
                Item const & operator[]( uint32_t rawId ) const {
                        DetId id(rawId);
                        static Item dummy;

                        if( id.subdetId() == EcalBarrel || id.subdetId() == EcalTriggerTower )   { 
                          return eb_[rawId];
                        } else if(  id.subdetId() == EcalEndcap  ) { 
                          return ee_[rawId];
                        } else {
                          return dummy;
                        }
                }
                
        private:
                EcalContainer< EcalTrigTowerDetId , Item > eb_;
                EcalContainer< EcalScDetId , Item > ee_;
};

typedef EcalCondTowerObjectContainer<float> EcalTowerFloatCondObjectContainer;
#endif