EnergySysts2020.h

Go to the documentation of this file.

#pragma once

#include "CAFAna/Core/ISyst.h"

namespace ana
{
  //----------------------------------------------------------------------
  // The component of the muon energy scale systematic which is fully
  // correlated between all three detector components (the muon
  // catcher, the rest of the ND, and the FD). It is a replacement for
  // the old concept of an "absolute" muon energy scale error. In this
  // version, while the errors are fully correlated, they need not be
  // the same size for all detectors. Notably, errors from effects such
  // as the uncertainty on the mass of PVC in each module are fully
  // correlated between all three detector components, but much smaller
  // in the muon catcher.
  class CorrMuEScaleSyst2020: public ISyst
  {
  public:
    CorrMuEScaleSyst2020(const std::string& shortName,
                         const std::string& latexName,
                         const double scaleFD, const double scaleND,
                         const double scaleMuCat)
      : ISyst(shortName, latexName),
        fScaleFD(scaleFD), fScaleND(scaleND), fScaleMuCat(scaleMuCat) {}

    CorrMuEScaleSyst2020(const double scaleFD, const double scaleND,
                         const double scaleMuCat)
      : ISyst("CorrMuEScaleSyst2020", "Corr Mu Energy Scale 2020"),
        fScaleFD(scaleFD), fScaleND(scaleND), fScaleMuCat(scaleMuCat) {}

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

  private:
    const double fScaleFD;
    const double fScaleND;
    const double fScaleMuCat;
  };

  extern const CorrMuEScaleSyst2020 kCorrMuEScaleSyst2020;

  //----------------------------------------------------------------------
  // The component of the muon energy scale systematic that applies only
  // to the FD. See further commentary at UnCorrNDMuEScaleSyst2020.
  class UnCorrFDMuEScaleSyst2020: public ISyst
  {
  public:
    UnCorrFDMuEScaleSyst2020(const std::string& shortName,
                             const std::string& latexName,
                             const double scale)
      : ISyst(shortName, latexName), fScale(scale) {}

    UnCorrFDMuEScaleSyst2020(const double scale)
      : ISyst("UnCorrFDMuEScaleSyst2020", "Uncorr FD Mu Energy Scale 2020"),
        fScale(scale) {}

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

  private:
    const double fScale;
  };

  extern const UnCorrFDMuEScaleSyst2020 kUnCorrFDMuEScaleSyst2020;

  //----------------------------------------------------------------------
  // The component of the muon energy scale systematic that applies only
  // to the non-muon catcher ND, i.e. arising from causes that have
  // no effect no the muon catcher or FD.  Because we have decided not
  // to implement muon energy scale systematics in their fullest possible
  // glory, this is a bit of a fudge.  Some effects are correlated between
  // two, but not three, of the three detector components (ND, FD, MuCat).
  // This systematic does not inclulde neutron pile-up, which is handled
  // separately.  See more discussion in doc-20816.
  class UnCorrNDMuEScaleSyst2020: public ISyst
  {
  public:
    UnCorrNDMuEScaleSyst2020(const std::string& shortName,
                             const std::string& latexName,
                             const double scale)
      : ISyst(shortName, latexName), fScale(scale) {}

    UnCorrNDMuEScaleSyst2020(const double scale)
      : ISyst("UnCorrNDMuEScaleSyst2020", "Uncorr ND Mu Energy Scale 2020"),
        fScale(scale) {}

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

  private:
    const double fScale;
  };

  extern const UnCorrNDMuEScaleSyst2020 kUnCorrNDMuEScaleSyst2020;

  //----------------------------------------------------------------------
  // The component of the muon energy scale systematic that
  // applies only to the muon catcher.
  class UnCorrMuCatMuESyst2020: public ISyst
  {
  public:
    UnCorrMuCatMuESyst2020(const std::string& shortName,
                           const std::string& latexName,
                           const double scale)
      : ISyst(shortName, latexName), fScale(scale) {}

    UnCorrMuCatMuESyst2020(const double scale)
      : ISyst("UnCorrMuCatMuESyst2020", "Uncorr MuCat Mu Energy 2020"),
        fScale(scale) {}

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

  private:
    const double fScale;
  };

  extern const UnCorrMuCatMuESyst2020 kUnCorrMuCatMuESyst2020;

  //----------------------------------------------------------------------
  // The component of the muon energy scale systematic that is caused by
  // neutron pile-up in the near detector. See discussion in doc-20816. It is
  // fully correlated between the main detector and the Muon Catcher and causes
  // tracks to get longer by an amount independent of their length, i.e. it is
  // additive, not multiplicative, which is why it is not rolled into the other
  // muon range sytematics. It affects the muon catcher more strongly mostly
  // because the planes are farther apart on average.  Also thermal neutron
  // characteristics are different in the muon catcher.
  //
  // The arguments to the function give the shifts per track end. We either
  // apply shiftND twice (for tracks contained in the main detector) or shiftND
  // once and shiftMuCat once (for tracks that start in the main detector and
  // end the muon catcher).  Also covers the case of the track being fully
  // contained in the Muon Catcher, even though we don't use these tracks in
  // the analysis (at the moment).
  class PileupMuESyst2020: public ISyst
  {
  public:
    PileupMuESyst2020(const std::string& shortName,
                      const std::string& latexName,
                      const double shiftND, const double shiftMuCat)
      : ISyst(shortName, latexName), fShiftND(shiftND), fShiftMuCat(shiftMuCat) {}

    PileupMuESyst2020(const double shiftND, const double shiftMuCat)
      : ISyst("PileupMuESyst2020", "Neutron Pile-up 2020"),
        fShiftND(shiftND), fShiftMuCat(shiftMuCat) {}

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

  extern const PileupMuESyst2020 kPileupMuESyst2020;
}