CDCMCMap.h

/**************************************************************************
 * BASF2 (Belle Analysis Framework 2)                                     *
 * Copyright(C) 2014 - Belle II Collaboration                             *
 *                                                                        *
 * Author: The Belle II Collaboration                                     *
 * Contributors: Oliver Frost                                             *
 *                                                                        *
 * This software is provided "as is" without any warranty.                *
 **************************************************************************/
#pragma once
 
#include <tracking/trackFindingCDC/utilities/Range.h>
#include <tracking/trackFindingCDC/utilities/MayBePtr.h>
 
#include <map>
#include <set>
 
namespace Belle2 {
  class MCParticle;
  class CDCSimHit;
  class CDCHit;
 
  namespace TrackFindingCDC {
 
    class CDCMCMap {
 
    public:
 
      CDCMCMap() = default;
      CDCMCMap& operator=(const CDCMCMap&) = delete;
      CDCMCMap(CDCMCMap&) = delete;
 
    public:
 
      void clear();
 
      void fill();
 
    private:
      static bool indicatesReassignedSecondary(double weight)
      {
        return weight <= 0;
      }
 
      void fillSimHitByHitMap();
 
      void fillMCParticleByHitMap();
 
      void fillMCParticleBySimHitMap();
 
      void validateRelations() const;
 
      void validateReassignedSecondaries() const;
 
    public:
      MayBePtr<const CDCSimHit> getSimHit(const CDCHit* hit) const;
 
      MayBePtr<const CDCHit> getHit(const CDCSimHit* simHit) const;
 
      bool isBackground(const CDCSimHit* simHit) const;
 
      bool isBackground(const CDCHit* hit) const;
 
      MayBePtr<const MCParticle> getMCParticle(const CDCHit* hit) const;
 
      MayBePtr<const MCParticle> getMCParticle(const CDCSimHit* simHit) const;
 
      auto getSimHits(const MCParticle* mcParticle) const
      {
        return asRange(m_simHitsByMCParticle.equal_range(mcParticle));
      }
 
      auto getHits(const MCParticle* mcParticle) const
      {
        return asRange(m_hitsByMCParticle.equal_range(mcParticle));
      }
 
      bool isReassignedSecondary(const CDCSimHit* ptrSimHit) const
      {
        return m_reassignedSecondarySimHits.count(ptrSimHit) > 0;
      }
 
      bool isReassignedSecondary(const CDCHit* ptrHit) const
      {
        return m_reassignedSecondaryHits.count(ptrHit) > 0;
      }
 
      const std::set<const CDCHit*>& getReassignedSecondaryHits() const
      {
        return m_reassignedSecondaryHits;
      }
 
      const std::set<const CDCSimHit*>& getReassignedSecondarySimHits() const
      {
        return m_reassignedSecondarySimHits;
      }
 
      const std::multimap<const CDCHit*, const CDCSimHit*>& getSimHitsByHit() const
      {
        return m_simHitsByHit;
      }
 
      const std::multimap<const MCParticle*, const CDCHit*>& getHitsByMCParticle() const
      {
        return m_hitsByMCParticle;
      }
 
      const std::multimap<const MCParticle*, const CDCSimHit*>& getSimHitsByMCParticle() const
      {
        return m_simHitsByMCParticle;
      }
 
    private:
      std::multimap<const CDCHit*, const CDCSimHit*> m_simHitsByHit;
 
      std::multimap<const MCParticle*, const CDCHit*> m_hitsByMCParticle;
 
      std::multimap<const MCParticle*, const CDCSimHit*> m_simHitsByMCParticle;
 
      std::set<const CDCHit*> m_reassignedSecondaryHits;
 
      std::set<const CDCSimHit*> m_reassignedSecondarySimHits;
    };
  }
}