AnalysisPermutation.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2022 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef ANALYSISUTILS_ANALYSISPERMUTATION_H
#define ANALYSISUTILS_ANALYSISPERMUTATION_H

 
#include <algorithm>
#include <vector>
 
#include "AnalysisUtils/AnalysisCombination.h"
 
namespace AnalysisUtils {

  template <class COLL> class Permutation
  {
  public:

    Permutation(COLL *coll, const unsigned int nElement)
      : m_coll(coll), m_first(true)
    {
      // init indices
      for (unsigned int i=0; i<coll->size(); ++i)
    m_index_for_comb.push_back(new unsigned int(i));
 
      m_comb = new Combination<std::vector<unsigned int *> > (&m_index_for_comb, nElement);
    }
    
    ~Permutation()
    {
      delete m_comb;
 
      for (unsigned int i=0; i<m_index_for_comb.size(); ++i)
    delete m_index_for_comb[i];
    }
 
    Permutation (const Permutation&) = delete;
    Permutation& operator= (const Permutation&) = delete;

    template <class OUT>
    bool get(OUT &perm)
    {
      // init returned vector
      perm.clear();
 
      // get combination if first
      if (m_first)
    {
      m_first=false;
      if (! m_comb->get(m_index)) return false;
      std::sort(m_index.begin(), m_index.end());
    }
      else
    {
      // change sequence. if this is the last permutation. get next combination
      if (! std::next_permutation (m_index.begin(), m_index.end()))
        {
          if (! m_comb->get(m_index)) return false;
          std::sort(m_index.begin(), m_index.end());
        }
    }
      
      // assign
      std::vector<unsigned int *>::const_iterator it  = m_index.begin();
      std::vector<unsigned int *>::const_iterator itE = m_index.end();
      for (; it!=itE; ++it)
    perm.push_back((*m_coll)[**it]);
 
      return true;
    }

    template <class CALLER, class OUT, class CRITERIA>
    bool goodOnes(CALLER *caller, OUT &perm, CRITERIA criteria)
    {
      get(perm);
      
      // check if this passes the criteria
      if (criteria(caller,perm)) return true;
 
      // if not, look for next combination
      return goodOnes(caller, perm, criteria);
    }
      
 
  private:

    Combination<std::vector<unsigned int *> > *m_comb;

    COLL *m_coll;

    std::vector<unsigned int *> m_index_for_comb;
    std::vector<unsigned int *> m_index;

    bool m_first;
 
  };
} // end of AnalysisUtils
 
#endif