EnergySysts2019.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 CorrMuEScaleSyst2019: public ISyst
  {
  public:
    CorrMuEScaleSyst2019(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) {}

    CorrMuEScaleSyst2019(const double scaleFD, const double scaleND,
                         const double scaleMuCat)
      : ISyst("CorrMuEScaleSyst2019", "Corr Mu Energy Scale 2019"),
        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 CorrMuEScaleSyst2019 kCorrMuEScaleSyst2019;

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

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

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

  private:
    const double fScale;
  };

  extern const UnCorrFDMuEScaleSyst2019 kUnCorrFDMuEScaleSyst2019;

  //----------------------------------------------------------------------
  // 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).
  // As of 2018, a major contributor to the ND "uncorrelated" error is
  // neutron pile-up, which is fully correlated between ND and MuCat, but
  // not with the FD (or on second thought, I suppose it is fully correlated
  // between all three, but negligibly very very small for the FD -- this
  // however, is not how I have handled it).  To keep the total number
  // of systematics down, it is treated as uncorrelated between main ND
  // and MuCat.  See more discussion in doc-20816.
  class UnCorrNDMuEScaleSyst2019: public ISyst
  {
  public:
    UnCorrNDMuEScaleSyst2019(const std::string& shortName,
                             const std::string& latexName,
                             const double scale)
      : ISyst(shortName, latexName), fScale(scale) {}

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

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

  private:
    const double fScale;
  };

  extern const UnCorrNDMuEScaleSyst2019 kUnCorrNDMuEScaleSyst2019;

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

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

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

  private:
    const double fScale;
  };

  extern const UnCorrMuCatMuESyst2019 kUnCorrMuCatMuESyst2019;

  //----------------------------------------------------------------------
  // 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 PileupMuESyst2019: public ISyst
  {
  public:
    PileupMuESyst2019(const std::string& shortName,
                      const std::string& latexName,
                      const double shiftND, const double shiftMuCat)
      : ISyst(shortName, latexName), fShiftND(shiftND), fShiftMuCat(shiftMuCat) {}

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

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

  extern const PileupMuESyst2019 kPileupMuESyst2019;

  //----------------------------------------------------------------------
  // Error for not knowing whether it is correct to apply the Bodek correction
  // and also not knowing whether it is correct to apply the Coulomb correction.
  // See doc-20816-v20 for a discussion of this.
  class BolombMuESyst2019: public ISyst
  {
  public:
    BolombMuESyst2019(const std::string& shortName,
                      const std::string& latexName,
                      const double shift)
      : ISyst(shortName, latexName), fShift(shift) {}

    BolombMuESyst2019(const double shift)
      : ISyst("BolombMuESyst2019", "Bodek and Coulomb 2019"),
        fShift(shift) {}

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

  extern const BolombMuESyst2019 kBolombMuESyst2019;
}