/cvmfs/atlas.cern.ch/repo/sw/ASG/AnalysisBase/2.4.31/xAODMissingET/xAODMissingET/versions/MissingETComponentMap_v1.h

// -*- c++ -*-
#ifndef XAODMISSINGET_VERSIONS_MISSINGETCOMPONENTMAP_V1_H
#define XAODMISSINGET_VERSIONS_MISSINGETCOMPONENTMAP_V1_H

#include "AthContainers/DataVector.h"

#include "xAODBase/ObjectType.h"

#include "xAODMissingET/versions/MissingETCompositionBase.h"
#include "xAODMissingET/MissingET.h"
#include "xAODMissingET/versions/MissingETComponent_v1.h"

#include <string>
#include <vector>
#include <map>

namespace xAOD
{
  class MissingETComponentMap_v1 : public DataVector<MissingETComponent_v1>
  {
  public:

    MissingETComponentMap_v1(SG::OwnershipPolicy own=SG::OWN_ELEMENTS, SG::IndexTrackingPolicy trackIndices = SG::DEFAULT_TRACK_INDICES);
    MissingETComponentMap_v1(MissingETComponentMap_v1::iterator first, MissingETComponentMap_v1::iterator last,
                 SG::OwnershipPolicy own=SG::OWN_ELEMENTS, SG::IndexTrackingPolicy trackIndices = SG::DEFAULT_TRACK_INDICES);
    virtual ~MissingETComponentMap_v1();

    const_iterator find(const MissingET* pMET)   const;
    const_iterator find(const std::string& name) const;
    const_iterator find(MissingETBase::Types::bitmask_t src)           const;
    iterator find(const MissingET* pMET);
    iterator find(const std::string& name);
    iterator find(MissingETBase::Types::bitmask_t src);
    size_t findIndex(const MissingET* pMET) const;
    size_t findIndex(const std::string& name) const;
    size_t findIndex(MissingETBase::Types::bitmask_t sw) const;
    const MissingET* retrieveMissingET(const std::string& name) const;
    const MissingET* retrieveMissingET(MissingETBase::Types::bitmask_t src,bool excl=false) const;
    const MissingET* retrieveMissingET(MissingETBase::Types::bitmask_t src,MissingETBase::Types::bitmask_t sw,bool excl=false) const;
  public:

    bool checkUsage(const IParticle* pPart,MissingETBase::UsageHandler::Policy p=MissingETBase::UsageHandler::OnlyCluster) const;
    bool checkUsage(MissingETBase::Types::object_vector_t& sig,MissingETBase::UsageHandler::Policy p=MissingETBase::UsageHandler::OnlyCluster) const; 
    //
    bool addObjects(const MissingET* pMET,const IParticle* pPart,const MissingETBase::Types::object_vector_t& signalList,
            MissingETBase::UsageHandler::Policy p = MissingETBase::UsageHandler::OnlyCluster);
    bool setClusters(const MissingET* pMET,const IParticle* pPart,const MissingETBase::Types::object_vector_t& signalList);
    bool setTracks(const MissingET* pMET,const IParticle* pPart,const MissingETBase::Types::object_vector_t&  signalList);
    bool setObjects(const MissingET* pMET,const IParticle* pPart,const MissingETBase::Types::object_vector_t& objectList);
    size_t getComponentIndex(const IParticle* pPart) const;
    size_t getObjectIndex(const IParticle* pPart) const;
    /* override base DataVector methods that can remove elements
     * in order to invalidate the cache
     */
    void resize(size_type sz);
    void pop_back();
    void clear();
    void sort();
    template <class COMPARE> void sort(COMPARE comp);
    void clear (SG::OwnershipPolicy ownPolicy);
    void clear (SG::OwnershipPolicy ownPolicy,SG::IndexTrackingPolicy trackIndices);
    iterator erase(iterator position);
    iterator erase(iterator first, iterator last);

  protected:

    typedef size_t                              signal_key_t;     
    typedef const IParticle*                    particle_key_t;   
    typedef MissingETBase::Types::indexedlink_t indexedlink_t;      
    typedef std::vector<indexedlink_t>             signal_vector_t; 
    typedef std::map<particle_key_t,indexedlink_t> particle_map_t;  
    mutable signal_vector_t m_clusterLinks;  
    mutable signal_vector_t m_trackLinks;    
    mutable particle_map_t  m_particleLinks; 
    template<int N> size_t f_getIndex(const IParticle* pPart) const
    {
      // check on cluster signal
      if ( pPart->type() == Type::CaloCluster ) 
    { size_t idx(pPart->index()); return idx < m_clusterLinks.size() ? m_clusterLinks.at(idx).get<N>() : MissingETBase::Numerical::invalidIndex(); }
      // check on track signal
      if ( pPart->type() == Type::TrackParticle )
    { size_t idx(pPart->index()); return idx < m_trackLinks.size() ? m_trackLinks.at(idx).get<N>() : MissingETBase::Numerical::invalidIndex(); }
      // 
      particle_map_t::const_iterator fPart(m_particleLinks.find(pPart));
      return fPart != m_particleLinks.end() ? (fPart->second).get<N>() : MissingETBase::Numerical::invalidIndex();
    }
    bool f_checkObjectUsage(MissingETBase::Types::object_vector_t& sig,signal_vector_t& signalLinks) const ;
    bool f_checkObjectUsage(MissingETBase::Types::object_vector_t& objects,particle_map_t& physicsLinks) const;
    void f_fillLookupCache();
    void f_clearLookupCache();
    void f_setupLookupCache(signal_vector_t& signalLinks,size_t reserve);
    template<int OBJTYPE>
    bool f_extractSignal(MissingETBase::Types::object_vector_t& sig) const
    {
      MissingETBase::Types::object_vector_t::iterator fSign(sig.begin());
      while ( fSign != sig.end() ) { if ( (*fSign)->type() != OBJTYPE ) { fSign = sig.erase(fSign); } else { ++fSign; } }
      return !sig.empty(); 
    }
    const_iterator f_findConst(const MissingET* pMET) const;
    const_iterator f_findConst(const std::string& name) const;
    const_iterator f_findConst(MissingETBase::Types::bitmask_t src) const;
    void f_setConstCache(const_iterator fCont) const;
    iterator f_find(const MissingET* pMET);
    iterator f_find(const std::string& name);
    iterator f_find(MissingETBase::Types::bitmask_t src);
    void f_setCache(iterator fCont);
    void resetCache() const;

    const MissingET* f_retrieveMissingETExcl(MissingETBase::Types::bitmask_t src)              const;
    const MissingET* f_retrieveMissingETExcl(MissingETBase::Types::bitmask_t src,MissingETBase::Types::bitmask_t sw) const;
    const MissingET* f_retrieveMissingETIncl(MissingETBase::Types::bitmask_t src)              const;
    const MissingET* f_retrieveMissingETIncl(MissingETBase::Types::bitmask_t src,MissingETBase::Types::bitmask_t sw) const;

  private:

    mutable const MissingET* m_lastMETObject;
    mutable size_t           m_lastContribIndex;

    static size_t m_clusterLinkReserve;
    static size_t m_trackLinkReserve; 
    static size_t m_maxClusterSize;
    static size_t m_maxTrackSize;
    static size_t m_maxSignalSize;

  }; // class xAOD::MissingETComponentMap_v1
} // namespace xAOD

#include "xAODCore/BaseInfo.h"
SG_BASE(xAOD::MissingETComponentMap_v1, DataVector<xAOD::MissingETComponent_v1>);

#include "xAODMissingET/versions/MissingETComponentMap_v1.icc"
#endif

---