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

#ifndef PATINTERFACES_SYSTEMATIC_VARIATION_H
#define PATINTERFACES_SYSTEMATIC_VARIATION_H

//        Copyright Iowa State University 2014.
//                  Author: Nils Krumnack
// Distributed under the Boost Software License, Version 1.0.
//    (See accompanying file LICENSE_1_0.txt or copy at
//          http://www.boost.org/LICENSE_1_0.txt)

// Please feel free to contact me (nils.erik.krumnack@cern.ch) for bug
// reports, feature suggestions, praise and complaints.


// 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,
             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

---