Systs.h

Go to the documentation of this file.

#pragma once

#include "CAFAna/Core/ISyst.h"

// Historically these systs have always been accessible via this header
#include "CAFAna/Systs/BeamSysts.h"
#include "CAFAna/Systs/XSecSysts.h"
#include "CAFAna/Systs/SystComponentScale.h"

namespace ana
{

 //----------------------------------------------------------------------

  namespace label {
    enum AnaLabel_t{
     kNueAna,
     kNumuAna,
     kComAna };
  }

  //----------------------------------------------------------------------
  /// Absolute normalization systematic
  class NormSyst: public ISyst
  {
  public:
    NormSyst() : ISyst("norm", "Normalization") {}

    void Shift(double sigma, caf::SRProxy* sr, double& weight) const override;
  };

  extern const NormSyst kNormSyst;

  //----------------------------------------------------------------------
  /// Relative (uncorrelated FD to ND) normalization systematic
  class RelNormSyst: public ISyst
  {
  public:
    RelNormSyst() : ISyst("relNorm", "Relative Normalization") {}

    void Shift(double sigma, caf::SRProxy* sr, double& weight) const override;
  };

  extern const RelNormSyst kRelNormSyst;

  //----------------------------------------------------------------------
  /// Absolute Neutral Current scale systematic
  class NCScaleSyst: public ISyst
  {
  public:
    NCScaleSyst() : ISyst("ncScale", "Neutral Current Scale") {}

    void Shift(double sigma, caf::SRProxy* sr, double& weight) const override;
  };

  extern const NCScaleSyst kNCScaleSyst;

  //----------------------------------------------------------------------
  /// Absolute scale of beam \f$ \nu_e \f$'s systematic
  class BeamNueScaleSyst: public ISyst
  {
  public:
    BeamNueScaleSyst() : ISyst("nueScale", "Beam #nu_{e} Scale") {}

    void Shift(double sigma, caf::SRProxy* sr, double& weight) const override;
  };

  extern const BeamNueScaleSyst kBeamNueScaleSyst;

  //----------------------------------------------------------------------
  // Absolute scale of numuCC systematic
  class NumuCCScaleSyst: public ISyst
  {
  public:
    NumuCCScaleSyst() : ISyst("numuScale", "#nu_{#mu}CC Scale") {}

    void Shift(double sigma, caf::SRProxy* sr, double& weight) const override;
  };

  extern const NumuCCScaleSyst kNumuCCScaleSyst;

  //----------------------------------------------------------------------
  // Absolute scale of Kaon Flux systematic
  class KaonScaleSyst: public ISyst
  {
  public:
    KaonScaleSyst() : ISyst("kaonScale", "Kaon Flux Scale") {}

    void Shift(double sigma, caf::SRProxy* sr, double& weight) const override;
  };

  extern const KaonScaleSyst kKaonScaleSyst;

  //----------------------------------------------------------------------
  /// Shift beam intensity - reweights nslcs dist to fake a different intensity
  class BeamIntensitySyst: public ISyst
  {
  public:
    BeamIntensitySyst() : ISyst("BeamInt", "Beam Intensity") {}

    void Shift(double sigma, caf::SRProxy* sr, double& weight) const override;
  };

  extern const BeamIntensitySyst kBeamIntensitySyst;

  //----------------------------------------------------------------------

  /// LEM-shift systematic
  class LEMScaleSyst : public ISyst
  {
  public:
    LEMScaleSyst() : ISyst("lemScale", "LEM Scale") {}

    void Shift(double sigma, caf::SRProxy* sr, double& weight) const override;
  };

  extern const LEMScaleSyst kLEMScaleSyst;

  //----------------------------------------------------------------------

  /// RemID-shift systematic
  class RemIDScaleSyst : public ISyst
  {
  public:
    RemIDScaleSyst() : ISyst("remidScale", "RemID Scale") {}

    void Shift(double sigma, caf::SRProxy* sr, double& weight) const override;
  };

  extern const RemIDScaleSyst kRemIDScaleSyst;

  //----------------------------------------------------------------------

  /// Rock muon normalization - reweights all events with vtx outside det
  class RockMuonNormSyst: public ISyst
  {
  public:
    RockMuonNormSyst() : ISyst("rockNorm", "Rock Muon Normalization") {}

    void Shift(double sigma, caf::SRProxy* sr, double& weight) const override;
  };

  extern const RockMuonNormSyst kRockMuonNormSyst;

  //----------------------------------------------------------------------

  // Containment efficiency systematic
  class ContainmentSyst: public ISyst
  {
  public:
    ContainmentSyst() : ISyst("cont", "Containment Efficiency") {}

    void Shift(double sigma, caf::SRProxy* sr, double& weight) const override;
  };

  extern const ContainmentSyst kContainmentSyst;


  //----------------------------------------------------------------------

  /// Hacked systematic to deal with high W DIS events.  These events are
  /// well constrained by proton collisions, so GENIE treats them different.
  class DISHighWScaleSyst: public ISyst
  {
  public:
    DISHighWScaleSyst() : ISyst("DISHighWScale","Scale for DIS events with W>2"){}

    void Shift(double sigma, caf::SRProxy* sr, double& weight) const override;
  };

  extern const DISHighWScaleSyst kDISHighWScaleSyst;

  //----------------------------------------------------------------------

  /// 100% uncertainty scale on taus
  extern const NuTruthSystComponentScale kTauScaleSyst;

} // namespace