/cvmfs/atlas.cern.ch/repo/sw/ASG/AnalysisBase/2.4.31/PATInterfaces/PATInterfaces/SystematicSet.h

#ifndef PATINTERFACES_SYSTEMATIC_SET_H
#define PATINTERFACES_SYSTEMATIC_SET_H

// Author: Steve Farrell (steven.farrell@cern.ch)

// This module implements a class that represents a set of systematics
// in a way to facilitate efficient lookups by systematic tools.
// A hash value is cached using the joined string name and boost::hash<string>.

#include <PATInterfaces/Global.h>

#include <set>
#include <vector>
#include <string>
#include <functional>

#include <PATInterfaces/SystematicCode.h>
#include <PATInterfaces/SystematicVariation.h>


namespace CP
{

  // Pulling global ops into CP. Not ideal.
  using ::operator<;
  using ::operator==;

  class SystematicSet
  {

  public:
    // Public constructors

    SystematicSet();
    SystematicSet(const std::string& systematics);
    SystematicSet(const std::vector<std::string>& systematics);
    SystematicSet(const std::vector<SystematicVariation>& systematics);

    #ifndef __CINT__
    #if __cplusplus >= 201100
    SystematicSet(const std::initializer_list<SystematicVariation>& systematics);
    #endif
    #endif

  public:
    // Public set-interface methods

    typedef std::set<SystematicVariation>::iterator iterator;
    typedef std::set<SystematicVariation>::const_iterator const_iterator;

    const_iterator begin() const
    { return m_sysVariations.begin(); }

    const_iterator end() const
    { return m_sysVariations.end(); }

    iterator find(const SystematicVariation& sys) const
    { return m_sysVariations.find(sys); }

    bool empty() const
    { return m_sysVariations.empty(); }

    size_t size() const
    { return m_sysVariations.size(); }

    void insert(const SystematicVariation& systematic);

    void insert(const SystematicSet& systematics);

    void swap(SystematicSet& otherSet);

    void clear() { return m_sysVariations.clear(); }

  public:
    // Specialized search and filtering methods

    enum MATCHTYPE { FULL, FULLORCONTINUOUS };
    bool matchSystematic(const SystematicVariation& systematic,
                         MATCHTYPE type=FULL) const;

    SystematicSet filterByBaseName(const std::string& basename) const;

    std::set<std::string> getBaseNames() const;

    SystematicVariation
    getSystematicByBaseName(const std::string& basename) const;

    float
    getParameterByBaseName(const std::string& basename) const;

  public:
    std::pair<unsigned,float>
    getToyVariationByBaseName (const std::string& basename) const;

    static SystematicCode
    filterForAffectingSystematics (const SystematicSet& systConfig,
                                   const SystematicSet& affectingSystematics,
                                   SystematicSet& filteredSystematics);

  public:
    // Public name and hash methods

    std::string name() const;

    std::size_t hash() const;

  private:
    // Private modification methods

    std::string joinNames() const;

    std::size_t computeHash() const;

  private:
    // Private members

    std::set<SystematicVariation> m_sysVariations;

    mutable std::string m_joinedName;
    mutable bool m_nameIsCached;

    mutable std::size_t m_hash;
    mutable bool m_hashIsCached;

    //bool m_isCached;

  };


  struct SystematicSetHash
    : public std::unary_function<SystematicSet, std::size_t>
  {
    std::size_t operator()(const SystematicSet&);
  };

  std::size_t hash_value(const SystematicSet&);

  //bool operator < (const SystematicSet& a, const SystematicSet& b);
  //bool operator == (const SystematicSet& a, const SystematicSet& b);

}

namespace std
{
  #if __cplusplus >= 201100
  template<> struct hash<CP::SystematicSet>
  {
    std::size_t operator()(const CP::SystematicSet& sysSet) const
    { return sysSet.hash(); }
  };
  #endif
}

#endif

---