SystematicVariation.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2022 CERN for the benefit of the ATLAS collaboration
*/
 
 
 
#ifndef PATINTERFACES_SYSTEMATIC_VARIATION_H
#define PATINTERFACES_SYSTEMATIC_VARIATION_H
 
// This module implements a class that manages the various
// representations of a single systematic variation.  The interface
// provided in this module is intended for the general user.  The
// module is considered to be in the pre-alpha stage.
 
// The current implementation isn't particularly efficient, in fact it
// is terribly inefficient, as most of the accessors involve a lot of
// string operations.  However, the current accessors should allow for
// more efficient implementations if needed.  And this class is likely
// only to be used during job startup, meaning an inefficient
// implementation is likely to have little to no effect on overall job
// execution time.  At the same time objects of this type are likely
// to be kept around for the entire runtime of the job, meaning the
// current small memory footprint should have advantages.
 
 
 
#include <PATInterfaces/Global.h>
 
#include <iosfwd>
#include <set>
#include <string>
 
//bool operator < (const CP::SystematicVariation& a, const CP::SystematicVariation& b);
//bool operator == (const CP::SystematicVariation& a, const CP::SystematicVariation& b);
 
 
namespace CP
{
 
  // Pulling global ops into CP. Not ideal.
  using ::operator<;
  using ::operator==;
 
  class SystematicVariation
  {
    //
    // public interface
    //
 
  public:
    void testInvariant () const;
 
 
  public:
    SystematicVariation ();
 
 
  public:
    SystematicVariation (const std::string& val_name);
    SystematicVariation (const std::string& val_basename,
             const std::string& val_subvariation);
    SystematicVariation (const std::string& val_basename,
             float val_parameter);
 
 
  public:
    enum CONTINUOUS_ARG {CONTINUOUS};
#ifndef __MAKECINT__
#ifndef __ROOTCLING__
    SystematicVariation (const std::string& val_basename, CONTINUOUS_ARG);
#endif // not __ROOTCLING__
#endif // not __MAKECINT__
 
 
  public:
    static SystematicVariation
    makeToyVariation (const std::string& basename,
              unsigned toyIndex, float toyScale);
 
 
  public:
    static SystematicVariation
    makeToyEnsemble (const std::string& basename);
 
 
  public:
    static SystematicVariation
    makeContinuousEnsemble (const std::string& basename);
 
 
  public:
    static SystematicVariation makeContinuous (const std::string& basename);
 
 
    // TODO: re-evaluate the usefulness of this constructor
  public:
    SystematicVariation (const std::set<CP::SystematicVariation>& systematics,
             const std::string& val_basename);
 
 
  public:
    bool empty () const;
 
 
  public:
    const std::string& name () const;
 
 
  public:
    std::string basename () const;
 
 
  public:
    std::string subvariation () const;
 
 
  public:
    float parameter () const;
 
 
  public:
    std::pair<unsigned,float> getToyVariation () const;
 
 
  public:
    bool isToyEnsemble () const;
 
 
  public:
    bool isContinuousEnsemble () const;
 
 
  public:
    bool isEnsemble () const;
 
 
  public:
    bool ensembleContains (const SystematicVariation& sys) const;
 
 
  public:
    bool isToyVariation () const;
 
 
  public:
    bool isContinuousVariation () const;
 
 
 
 
    //
    // private interface
    //
 
  private:
    std::string m_name;
  };
 
  std::ostream& operator << (std::ostream& str, const CP::SystematicVariation& obj);
}
 
#endif