FakeDecomp.cxx

Go to the documentation of this file.

#include "CAFAna/Decomp/FakeDecomp.h"

#include "CAFAna/Cuts/Cuts.h"
#include "CAFAna/Core/LoadFromRegistry.h"
#include "CAFAna/Core/Ratio.h"

#include <cassert>

#include "TDirectory.h"
#include "TObjString.h"
#include "TH1D.h"

#include <iostream>

using namespace ana::DecompType;

namespace ana
{
  REGISTER_LOADFROM("FakeDecomp", IDecomp, FakeDecomp);

  //----------------------------------------------------------------------
  //you dont need any of these constructors, im leaving them here for fun :shrug:
  FakeDecomp::FakeDecomp(SpectrumLoaderBase& loaderMC,
                         SpectrumLoaderBase& loaderData,
                         const std::string& label,
                         const Binning& bins,
                         const Var& var,
                         const Cut& cut,
                         const SystShifts& shiftMC,
                         const SystShifts& shiftData,
                         const Var& wei)
    : FakeDecomp(loaderMC, loaderData, HistAxis(label, bins, var),
                 cut, shiftMC, shiftData, wei)
  {
  }

  //----------------------------------------------------------------------
  FakeDecomp::FakeDecomp(SpectrumLoaderBase& loaderMC,
                         SpectrumLoaderBase& loaderData,
                         const HistAxis& axis,
                         const Cut& cut,
                         const SystShifts& shiftMC,
                         const SystShifts& shiftData,
                         const Var& wei)
    : fData    (loaderData, axis, cut,                         shiftData, wei),
      fTotal      (loaderMC,   axis, cut && kHasNu,                 shiftMC, wei),
      //nc
      fNCTot      (loaderMC,   axis, cut && kIsNC,                  shiftMC, wei),
      fNC         (loaderMC,   axis, cut && kIsNC && !kIsAntiNu,    shiftMC, wei),
      fNCAnti     (loaderMC,   axis, cut && kIsNC && kIsAntiNu,     shiftMC, wei),
      //end nc
      fNue     (loaderMC,   axis, cut && kIsBeamNue&&!kIsAntiNu, shiftMC, wei),
      fAntiNue (loaderMC,   axis, cut && kIsBeamNue&& kIsAntiNu, shiftMC, wei),
      fNumu    (loaderMC,   axis, cut && kIsNumuCC &&!kIsAntiNu, shiftMC, wei),
      fAntiNumu(loaderMC,   axis, cut && kIsNumuCC && kIsAntiNu, shiftMC, wei),
      fIsDecomposed(false)
  {
  }

  //----------------------------------------------------------------------
  FakeDecomp::FakeDecomp(Loaders& loaders,
                         const HistAxis& axis,
                         const Cut& cut,
                         const SystShifts& shiftMC,
                         const SystShifts& shiftData,
                         const Var& wei)
    : FakeDecomp(loaders.GetLoader(caf::kNEARDET, Loaders::kMC),
                 loaders.GetLoader(caf::kNEARDET, Loaders::kData),
                 axis, cut, shiftMC, shiftData, wei)
  {
  }

  FakeDecomp::~FakeDecomp()
  {
  }


  //---------------------38 North------------------------------------------
  void FakeDecomp::Decompose() const{

    if(fIsDecomposed) {std::cout<<"GO AWAY, you already decomposed! Stop calling me!"<< std::endl; return;}
    if(!fIsSet) {std::cout<< "Warning: Current default as NoDecomp, please SetType() first" << std::endl; fType = kNCTotal;}

    fDiff.resize(kNum);
    fDiff[fType] = new Spectrum(fData - fTotal);
    fIsDecomposed = true;

  }

  //----------------------------------------------------------------------
  void FakeDecomp::SetType(Type type)  const{

    if(type >= kNum || type < 0){ 
      std::cout<< "Unreasonable Decomp Type, reseting to No Decomp"<<std::endl;
      fType = kNCTotal;
      fIsDecomposed = false;
      fIsSet = true;
      }
    else{
      fType = type;
      fIsDecomposed = false;
      fIsSet = true;
    }
  }

  //----------------------------------------------------------------------
  Spectrum FakeDecomp::NueComponent() const
  {
    if(!fIsDecomposed) Decompose();

    assert(fIsDecomposed && "GO AWAY!!! Decompose to a specific type first!!!!!");
    return fNue + *fDiff[kNue];
  }


  //----------------------------------------------------------------------
  Spectrum FakeDecomp::AntiNueComponent() const
  {
    if(!fIsDecomposed) Decompose();

    assert(fIsDecomposed && "GO AWAY!!! Decompose to a specific type first!!!!!");
    return fAntiNue + *fDiff[kAntiNue];
  }

  //----------------------------------------------------------------------
  Spectrum FakeDecomp::NumuComponent() const
  {
    if(!fIsDecomposed) Decompose();

    assert(fIsDecomposed && "GO AWAY!!! Decompose to a specific type first!!!!!");
    return fNumu + *fDiff[kNumu];
  }
  //----------------------------------------------------------------------
  Spectrum FakeDecomp::AntiNumuComponent() const
  {
    if(!fIsDecomposed) Decompose();

    assert(fIsDecomposed && "GO AWAY!!! Decompose to a specific type first!!!!!");
    return fAntiNumu + *fDiff[kAntiNumu];
  }

  //----------------------------------------------------------------------  
  Spectrum FakeDecomp::NCComponent() const
  {
    if(!fIsDecomposed) Decompose();

    assert(fIsDecomposed && "GO AWAY!!! Decompose to a specific type first!!!!!");
    return fNC + *fDiff[kNC];
  }
  //----------------------------------------------------------------------
  Spectrum FakeDecomp::NCAntiComponent() const
  {
    if(!fIsDecomposed) Decompose();

    assert(fIsDecomposed && "GO AWAY!!! Decompose to a specific type first!!!!!");
    return fNCAnti + *fDiff[kAntiNC];
  }
  //----------------------------------------------------------------------
  Spectrum FakeDecomp::NCTotalComponent() const
  {
    if(!fIsDecomposed) Decompose();

    assert(fIsDecomposed && "GO AWAY!!! Decompose to a specific type first!!!!!");
    return fNCTot + *fDiff[kNCTotal];
  }
  //----------------------------------------------------------------------
  //  

  void FakeDecomp::SaveTo(TDirectory* dir, const std::string& name) const
  {
    TDirectory* tmp = gDirectory;

    dir = dir->mkdir(name.c_str()); // switch to subdir
    dir->cd();

    TObjString("FakeDecomp").Write("type");
    //nc
    fNCTot.SaveTo(dir, "nc_tot_comp");
    fNC.SaveTo(dir, "nc_comp");
    fNCAnti.SaveTo(dir, "nc_anti_comp");
    //end nc
    fData.SaveTo(dir, "data_comp");
    fTotal.SaveTo(dir, "total_comp");
    fNue.SaveTo(dir, "nue_comp");
    fAntiNue.SaveTo(dir, "antinue_comp");
    fNumu.SaveTo(dir, "numu_comp");
    fAntiNumu.SaveTo(dir, "antinumu_comp");

    dir->Write();
    delete dir;

    tmp->cd();
  }

  //----------------------------------------------------------------------
  std::unique_ptr<FakeDecomp> FakeDecomp::LoadFrom(TDirectory* dir, const std::string& name)
  {
    dir = dir->GetDirectory(name.c_str()); // switch to subdir
    assert(dir);

    std::unique_ptr<FakeDecomp> ret(new FakeDecomp);

    // nc
    ret->fNCTot    = *Spectrum::LoadFrom(dir, "nc_tot_comp");
    ret->fNC       = *Spectrum::LoadFrom(dir, "nc_comp");
    ret->fNCAnti   = *Spectrum::LoadFrom(dir, "nc_anti_comp");
    //end nc
    ret->fData     = *Spectrum::LoadFrom(dir, "data_comp");
    ret->fNue      = *Spectrum::LoadFrom(dir, "nue_comp");
    ret->fAntiNue  = *Spectrum::LoadFrom(dir, "antinue_comp");
    ret->fNumu     = *Spectrum::LoadFrom(dir, "numu_comp");
    ret->fAntiNumu = *Spectrum::LoadFrom(dir, "antinumu_comp");
    ret->fTotal    = *Spectrum::LoadFrom(dir, "total_comp");

    delete dir;

    return ret;
  }
}