HcalDcsMap Class Reference

#include <HcalDcsMap.h>

Classes
class	const_iterator
class	Item

Public Member Functions
const_iterator	beginByDcsId (void) const
const_iterator	beginById (void) const
const_iterator	endByDcsId (void) const
const_iterator	endById (void) const
	HcalDcsMap ()
	HcalDcsMap (const HcalDcsMap &src)
	HcalDcsMap (HcalDcsMap &&other)
const std::vector< HcalDetId >	lookup (HcalDcsDetId fId) const
const std::vector< HcalDcsDetId >	lookup (HcalDetId fId, HcalDcsDetId::DcsType type) const
bool	mapGeomId2DcsId (HcalDetId fId, HcalDcsDetId fDcsId)
HcalDcsMap &	operator= (const HcalDcsMap &rhs)
void	sort ()
void	sortByDcsId () const
void	sortById () const
void	swap (HcalDcsMap &other)
	~HcalDcsMap ()

Protected Member Functions
std::vector< HcalDcsDetId >	allHcalDcsDetId () const
std::vector< HcalGenericDetId >	allHcalDetId () const
const std::vector< const Item * >	findByDcsId (unsigned long fDcsId) const
const std::vector< const Item * >	findById (unsigned long fId) const
const std::vector< const Item * > *	getItemsByDcsId (void)
const std::vector< const Item * > *	getItemsById (void)

Protected Attributes
std::vector< Item >	mItems
std::atomic< std::vector < const Item * > * >	mItemsByDcsId
std::atomic< std::vector < const Item * > * >	mItemsById

Private Member Functions
template<class Archive >
void	serialize (Archive &ar, const unsigned int version)

Friends
class	boost::serialization::access
template<typename CondSerializationT , typename Enabled >
struct	cond::serialization::access

Detailed Description

Author

Gena Kukartsev POOL object to store map between detector ID and DCS ID Inspired by HcalElectronicsMap $Author: kukartse

Date:

2007/12/14 13:31:21

Revision:

1.1

Author

Gena Kukartsev POOL object to store map between detector ID and DCS ID Inspired by HcalElectronicsMap $Author: kukartse

Date:

2010/02/22 21:08:07

Revision:

1.1

Definition at line 28 of file HcalDcsMap.h.

Constructor & Destructor Documentation

HcalDcsMap::HcalDcsMap

(

)

Definition at line 17 of file HcalDcsMap.cc.

    : mItemsById(nullptr), mItemsByDcsId(nullptr)
{
}

HcalDcsMap::~HcalDcsMap

(

)

Definition at line 24 of file HcalDcsMap.cc.

References mItemsByDcsId, and mItemsById.

                       {
    delete mItemsById.load();
    delete mItemsByDcsId.load();
}

HcalDcsMap::HcalDcsMap

(

const HcalDcsMap &

src

)

Definition at line 29 of file HcalDcsMap.cc.

    : mItems(src.mItems),
      mItemsById(nullptr), mItemsByDcsId(nullptr) {}

HcalDcsMap::HcalDcsMap

(

HcalDcsMap &&

other

)

Definition at line 50 of file HcalDcsMap.cc.

References swap().

    : HcalDcsMap() {
    other.swap(*this);
}

Member Function Documentation

std::vector< HcalDcsDetId > HcalDcsMap::allHcalDcsDetId ( ) const

protected

Definition at line 215 of file HcalDcsMap.cc.

References mItems, and mps_fire::result.

                                                            {
  std::vector <HcalDcsDetId> result;
  for (std::vector<Item>::const_iterator item = mItems.begin (); item != mItems.end (); item++) 
    if (item->mDcsId) result.push_back(HcalDcsDetId(item->mDcsId));
  return result;
}

std::vector< HcalGenericDetId > HcalDcsMap::allHcalDetId ( ) const

protected

Definition at line 223 of file HcalDcsMap.cc.

References mItems, and mps_fire::result.

                                                             {
  std::vector <HcalGenericDetId> result;
  std::set <unsigned long> allIds;
  for (std::vector<Item>::const_iterator item = mItems.begin (); item != mItems.end (); item++)  
    if (item->mId) allIds.insert (item->mId);
  for (std::set <unsigned long>::const_iterator channel = allIds.begin (); channel != allIds.end (); channel++) {
      result.push_back (HcalGenericDetId (*channel));
  }
  return result;
}

HcalDcsMap::const_iterator HcalDcsMap::beginByDcsId

(

void

)

const

Definition at line 80 of file HcalDcsMap.cc.

References begin, HcalDcsMap::const_iterator::fIter, mItemsByDcsId, and sortByDcsId().

                                                           {
  const_iterator _iter;
  sortByDcsId();
  _iter.fIter = (*mItemsByDcsId.load(std::memory_order_acquire)).begin();
  return _iter;
}

HcalDcsMap::const_iterator HcalDcsMap::beginById

(

void

)

const

Definition at line 73 of file HcalDcsMap.cc.

References begin, HcalDcsMap::const_iterator::fIter, mItemsById, and sortById().

                                                        {
  const_iterator _iter;
  sortById();
  _iter.fIter = (*mItemsById.load(std::memory_order_acquire)).begin();
  return _iter;
}

HcalDcsMap::const_iterator HcalDcsMap::endByDcsId

(

void

)

const

Definition at line 94 of file HcalDcsMap.cc.

References end, HcalDcsMap::const_iterator::fIter, mItemsByDcsId, and sortByDcsId().

                                                         {
  const_iterator _iter;
  sortByDcsId();
  _iter.fIter = (*mItemsByDcsId.load(std::memory_order_acquire)).end();
  return _iter;
}

HcalDcsMap::const_iterator HcalDcsMap::endById

(

void

)

const

Definition at line 87 of file HcalDcsMap.cc.

References end, HcalDcsMap::const_iterator::fIter, mItemsById, and sortById().

                                                      {
  const_iterator _iter;
  sortById();
  _iter.fIter = (*mItemsById.load(std::memory_order_acquire)).end();
  return _iter;
}

const std::vector< const HcalDcsMap::Item * > HcalDcsMap::findByDcsId ( unsigned long  fDcsId ) const

protected

Definition at line 154 of file HcalDcsMap.cc.

References mItemsByDcsId, mps_fire::result, sortByDcsId(), and filterCSVwithJSON::target.

Referenced by lookup(), and mapGeomId2DcsId().

                                                                                           {
  Item target (0, fDcsId);
  std::vector<const HcalDcsMap::Item*>::const_iterator item;
  std::vector<const HcalDcsMap::Item *> result;

  sortByDcsId();

  hcal_impl::LessByDcsId lessByDcsId;  
  auto ptr = (*mItemsByDcsId.load(std::memory_order_acquire));
  item = std::lower_bound (ptr.begin(), ptr.end(), &target, lessByDcsId);
  if (item == ptr.end() || (*item)->mDcsId != fDcsId) {
    //    throw cms::Exception ("Conditions not found") << "Unavailable Dcs map for cell " << fDcsId;
    return result;
  }
  else{
    if(item != ptr.end() && !lessByDcsId(&target, *item)){
      result.push_back( *item );
      ++item;
    }
  }
  return result;
}

const std::vector< const HcalDcsMap::Item * > HcalDcsMap::findById ( unsigned long  fId ) const

protected

Definition at line 131 of file HcalDcsMap.cc.

References mItemsById, mps_fire::result, sortById(), and filterCSVwithJSON::target.

Referenced by lookup().

                                                                                     {
  Item target (fId, 0);
  std::vector<const HcalDcsMap::Item*>::const_iterator item;
  std::vector<const HcalDcsMap::Item *> result;

  sortById();
  
  hcal_impl::LessById lessById;
  auto ptr = (*mItemsById.load(std::memory_order_acquire));
  item = std::lower_bound (ptr.begin(), ptr.end(), &target, lessById);
  if (item == ptr.end() || (*item)->mId != fId){
    //    throw cms::Exception ("Conditions not found") << "Unavailable Dcs map for cell " << fId;
    return result;
  }
  else{
    if(item != ptr.end() && !lessById(&target, *item)){
      result.push_back( *item );
      ++item;
    }
  }
  return result;
}

const std::vector<const Item*>* HcalDcsMap::getItemsByDcsId ( void  )

inlineprotected

Definition at line 126 of file HcalDcsMap.h.

References mItemsByDcsId.

{return mItemsByDcsId.load(std::memory_order_acquire);}

const std::vector<const Item*>* HcalDcsMap::getItemsById ( void  )

inlineprotected

Definition at line 125 of file HcalDcsMap.h.

References mItemsById.

{return mItemsById.load(std::memory_order_acquire);}

const std::vector< HcalDetId > HcalDcsMap::lookup

(

HcalDcsDetId

fId

)

const

Definition at line 177 of file HcalDcsMap.cc.

References HcalDcsDetId::DCSUNKNOWN, findByDcsId(), mps_monitormerge::items, HcalDcsDetId::ring(), HcalDcsDetId::slice(), HcalDcsDetId::subchannel(), and HcalOtherDetId::subdet().

                                                                    {
  // DCS type is a part of DcsDetId but it does not make sense to keep
  // duplicate records in the map for DCS channels where only type is different.
  // Hence, the type in HcalDcsDetId is always forced to DCSUNKNOWN
  HcalDcsDetId fDcsId_notype(fId.subdet(),
                 fId.ring(), // side is already included
                 fId.slice(),
                 HcalDcsDetId::DCSUNKNOWN,
                 fId.subchannel());
  const std::vector<const Item *> items = findByDcsId (fDcsId_notype.rawId ());
  std::vector<HcalDetId> _ids;
  for (std::vector<const Item *>::const_iterator item = items.begin();
       item != items.end();
       ++item){
    _ids.push_back( DetId(*item ? (*item)->mId : 0) );
  }
  return _ids;
}

const std::vector< HcalDcsDetId > HcalDcsMap::lookup	(	HcalDetId	fId,
		HcalDcsDetId::DcsType	type
	)		const

Definition at line 196 of file HcalDcsMap.cc.

References findById(), mps_monitormerge::items, DetId::rawId(), HcalDcsDetId::ring(), HcalDcsDetId::slice(), HcalDcsDetId::subchannel(), HcalOtherDetId::subdet(), and HcalDcsDetId::zside().

                                                                                              {
  const std::vector<const Item *> items = findById (fId.rawId ());
  std::vector<HcalDcsDetId> _ids;
  for (std::vector<const Item *>::const_iterator item = items.begin();
       item != items.end();
       ++item){
    HcalDcsDetId _id(*item ? (*item)->mId : 0);
    _ids.push_back( HcalDcsDetId(_id.subdet(),
                 _id.zside()*_id.ring(),
                 _id.slice(),
                 type,
                 _id.subchannel()
                 )
            );
  }
  return _ids;
}

bool HcalDcsMap::mapGeomId2DcsId	(	HcalDetId	fId,
		HcalDcsDetId	fDcsId
	)

Definition at line 235 of file HcalDcsMap.cc.

References HcalDcsDetId::DCSUNKNOWN, findByDcsId(), mps_monitormerge::items, mItems, mItemsByDcsId, mItemsById, HcalDcsDetId::ring(), HcalDcsDetId::slice(), HcalDcsDetId::subchannel(), and HcalOtherDetId::subdet().

                                                                    {
  // DCS type is a part of DcsDetId but it does not make sense to keep
  // duplicate records in the map for DCS channels where only type is different.
  // Hence, the type in HcalDcsDetId is always forced to DCSUNKNOWN
  HcalDcsDetId fDcsId_notype(fDcsId.subdet(),
                 fDcsId.ring(), // side is included
                 fDcsId.slice(),
                 HcalDcsDetId::DCSUNKNOWN,
                 fDcsId.subchannel());
  const std::vector<const Item *> items = findByDcsId(fDcsId_notype);
  for (std::vector<const Item *>::const_iterator item = items.begin();
       item != items.end();
       ++item){
    if ((*item)->mId == fId){
      edm::LogWarning("HCAL") << "HcalDcsMap::mapGeomId2DcsId-> Geom channel " <<  fId 
                  << " already mapped to DCS channel " << fDcsId_notype;
      return false; // element already exists
    }
  }
  Item _item(fId, fDcsId_notype);
  mItems.push_back(_item);
  delete mItemsById.load();
  mItemsById = nullptr;
  delete mItemsByDcsId.load();
  mItemsByDcsId = nullptr;
  return true;
}

HcalDcsMap & HcalDcsMap::operator=

(

const HcalDcsMap &

rhs

)

Definition at line 34 of file HcalDcsMap.cc.

References swap(), and groupFilesInBlocks::temp.

                                           {
    HcalDcsMap temp(rhs);
    temp.swap(*this);
    return *this;
}

template<class Archive >

void HcalDcsMap::serialize ( Archive &  ar, const unsigned int  version  )

private

void HcalDcsMap::sort ( )

inline

Definition at line 78 of file HcalDcsMap.h.

{}

void HcalDcsMap::sortByDcsId

(

)

const

Definition at line 281 of file HcalDcsMap.cc.

References i, mItems, and mItemsByDcsId.

Referenced by beginByDcsId(), endByDcsId(), and findByDcsId().

                                    {
  if (!mItemsByDcsId.load(std::memory_order_acquire)) {
      auto ptr = new std::vector<const Item*>;
      for (auto i=mItems.begin(); i!=mItems.end(); ++i) {
          if (i->mDcsId) ptr->push_back(&(*i));
      }
    
      std::sort (ptr->begin(), ptr->end(), hcal_impl::LessByDcsId ());
      //atomically try to swap this to become mItemsByDcsId
      std::vector<const Item*>* expect = nullptr;
      bool exchanged = mItemsByDcsId.compare_exchange_strong(expect, ptr, std::memory_order_acq_rel);
      if(!exchanged) {
          delete ptr;
      }
  }
}

void HcalDcsMap::sortById

(

)

const

Definition at line 264 of file HcalDcsMap.cc.

References i, mItems, and mItemsById.

Referenced by beginById(), endById(), and findById().

                                 {
  if (!mItemsById.load(std::memory_order_acquire)) {
      auto ptr = new std::vector<const Item*>;
      for (auto i=mItems.begin(); i!=mItems.end(); ++i) {
          if (i->mDcsId) ptr->push_back(&(*i));
      }

      std::sort (ptr->begin(), ptr->end(), hcal_impl::LessById ());
      //atomically try to swap this to become mItemsById
      std::vector<const Item*>* expect = nullptr;
      bool exchanged = mItemsById.compare_exchange_strong(expect, ptr, std::memory_order_acq_rel);
      if(!exchanged) {
          delete ptr;
      }
  }
}

void HcalDcsMap::swap

(

HcalDcsMap &

other

)

Definition at line 40 of file HcalDcsMap.cc.

References mItems, mItemsByDcsId, mItemsById, and std::swap().

Referenced by HcalDcsMap(), and operator=().

                                       {
    std::swap(mItems, other.mItems);
    other.mItemsByDcsId.exchange(
            mItemsByDcsId.exchange(other.mItemsByDcsId.load(std::memory_order_acquire), std::memory_order_acq_rel),
            std::memory_order_acq_rel);
    other.mItemsById.exchange(
            mItemsById.exchange(other.mItemsById.load(std::memory_order_acquire), std::memory_order_acq_rel),
            std::memory_order_acq_rel);
}

Friends And Related Function Documentation

friend class boost::serialization::access

friend

Definition at line 134 of file HcalDcsMap.h.

template<typename CondSerializationT , typename Enabled >

friend struct cond::serialization::access

friend

Definition at line 134 of file HcalDcsMap.h.

Member Data Documentation

std::vector<Item> HcalDcsMap::mItems

protected

Definition at line 121 of file HcalDcsMap.h.

Referenced by allHcalDcsDetId(), allHcalDetId(), mapGeomId2DcsId(), sortByDcsId(), sortById(), and swap().

std::atomic<std::vector<const Item*>*> HcalDcsMap::mItemsByDcsId

mutableprotected

Definition at line 124 of file HcalDcsMap.h.

Referenced by beginByDcsId(), endByDcsId(), findByDcsId(), getItemsByDcsId(), mapGeomId2DcsId(), sortByDcsId(), swap(), and ~HcalDcsMap().

std::atomic<std::vector<const Item*>*> HcalDcsMap::mItemsById

mutableprotected

Definition at line 123 of file HcalDcsMap.h.

Referenced by beginById(), endById(), findById(), getItemsById(), mapGeomId2DcsId(), sortById(), swap(), and ~HcalDcsMap().