ParticleCombiner.h

/**************************************************************************
 * BASF2 (Belle Analysis Framework 2)                                     *
 * Copyright(C) 2014-2019 Belle II Collaboration                          *
 *                                                                        *
 * Author: The Belle II Collaboration                                     *
 * Contributors: Thomas Keck, Anze Zupanc                                 *
 *               Sam Cunliffe, Torben Ferber                              *
 *                                                                        *
 * This software is provided "as is" without any warranty.                *
 **************************************************************************/
 
#pragma once
 
#include <analysis/dataobjects/ParticleList.h>
#include <analysis/dataobjects/Particle.h>
#include <analysis/VariableManager/Utility.h>
#include <analysis/DecayDescriptor/DecayDescriptor.h>
 
#include <framework/datastore/StoreArray.h>
#include <framework/datastore/StoreObjPtr.h>
 
#include <vector>
#include <set>
#include <unordered_set>
#include <unordered_map>
 
#include <utility>
 
#include <boost/functional/hash/extensions.hpp>
 
namespace std {
  template<> struct hash<std::set<int>> {
    std::size_t operator()(const std::set<int>& v) const
    {
      return boost::hash_value(v);
    }
  };
}
 
namespace Belle2 {
  class ParticleIndexGenerator {
 
  public:
    ParticleIndexGenerator() : m_numberOfLists(0), m_iCombination(0), m_nCombinations(0) { }
 
    void init(const std::vector<unsigned int>& _sizes);
 
    bool loadNext();
 
    const std::vector<unsigned int>& getCurrentIndices() const;
 
 
  private:
 
    unsigned int m_numberOfLists;  
    unsigned int m_iCombination;         
    unsigned int m_nCombinations;        
    std::vector<unsigned int> indices; 
    std::vector<unsigned int> sizes;   
  };
 
  class ListIndexGenerator {
  public:
    ListIndexGenerator() : m_numberOfLists(0), m_iCombination(0), m_nCombinations(0) { }
 
    void init(unsigned int _numberOfLists);
 
    bool loadNext();
 
    const std::vector<ParticleList::EParticleType>& getCurrentIndices() const;
 
  private:
 
    unsigned int m_numberOfLists; 
    unsigned int m_iCombination; 
    unsigned int m_nCombinations; 
    std::vector<ParticleList::EParticleType> m_types; 
  };
 
  class ParticleGenerator {
  public:
 
  public:
    explicit ParticleGenerator(const std::string& decayString, const std::string& cutParameter = "");
 
    explicit ParticleGenerator(const DecayDescriptor& decaydescriptor, const std::string& cutParameter = "");
 
    void init();
 
    bool loadNext(bool loadAntiParticle = true);
 
    Particle getCurrentParticle() const;
 
    bool inputListsCollide() const {return m_inputListsCollide; };
 
    bool inputListsCollide(const std::pair<unsigned, unsigned>& pair) const;
 
    int getUniqueID(int index) const;
 
  private:
    Particle createCurrentParticle() const;
 
    bool loadNextParticle(bool useAntiParticle);
 
    bool loadNextSelfConjugatedParticle();
 
    bool currentCombinationHasDifferentSources();
 
    bool currentCombinationIsUnique();
 
    bool currentCombinationIsECLCRUnique();
 
    void initIndicesToUniqueIDMap();
 
    void fillIndicesToUniqueIDMap(const std::vector<int>& listA, const std::vector<int>& listB, int& uniqueID);
 
    void fillIndicesToUniqueIDMap(const std::vector<int>& listA, int& uniqueID);
 
  private:
 
    int m_pdgCode; 
    bool m_isSelfConjugated; 
    unsigned int m_iParticleType; 
    int m_properties; 
    std::vector<int> m_daughterProperties; 
    unsigned int m_numberOfLists; 
    std::vector<StoreObjPtr<ParticleList>> m_plists; 
    ListIndexGenerator
    m_listIndexGenerator;   
    ParticleIndexGenerator
    m_particleIndexGenerator; 
    const StoreArray<Particle> m_particleArray; 
    std::vector<Particle*> m_particles; 
    std::vector<int> m_indices;         
    std::unordered_set<std::set<int>> m_usedCombinations; 
    bool m_inputListsCollide; 
    std::vector<std::pair<unsigned, unsigned>> m_collidingLists; 
    std::unordered_map<int, int>
    m_indicesToUniqueIDs; 
    std::unique_ptr<Variable::Cut> m_cut; 
    Particle m_current_particle; 
  };
 
 
}