SystematicSet.h

Go to the documentation of this file.

#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 <AsgMessaging/StatusCode.h>
#include <PATInterfaces/SystematicVariation.h>
#include "CxxUtils/CachedValue.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);

    SystematicSet(const std::initializer_list<SystematicVariation>& systematics);
 
  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();
 
  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 StatusCode
    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;

    CxxUtils::CachedValue<std::string> m_joinedName;

    CxxUtils::CachedValue<std::size_t> m_hash;
  };
 

  struct SystematicSetHash
  {
    std::size_t operator()(const SystematicSet& sysSet) const {
      return sysSet.hash();}
  };

  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
{
  template<> struct hash<CP::SystematicSet>
  {
    std::size_t operator()(const CP::SystematicSet& sysSet) const
    { return sysSet.hash(); }
  };
}
 
#endif