SpectrumHandler.h

Go to the documentation of this file.

///////////////////////////
// SpectrumHandler.h
// Author: Connor Johnson
// Date Created: 10/10/2018
// Class to handle bulk spectra creation and filling.
// Serves as a wrapper for the general looping for Spectrum creation
// Use case: assigning datasets, vars, cuts, weights.
//           Will then loop through all combinations and create / save a seperate Spectrum for each.
// To be done: implement logic for 2D Spectrums.
///////////////////////////

////////////////////////////////////////////
// Usage: This class requires many function calls in a certain order.
//        For convenience, an example valid call-order is shown below.
////////////////////////////////////////////

// // Create the SpectrumHandler object
// ana::SpectrumHandler * spechandler = new ana::SpectrumHandler();

// // Load the datasets
// spechandler->SetLoaders(datasets, dataset_labels);  // Necessary first step: define the loaders to be used
// spechandler->SetSpillCuts(spillcut);                // Only needed if using non-default spill cuts

// // Set Vars, Cuts, Weights, and SystShifts (all of them necessary)
// spechandler->SetVars(vars, vars_labels, vars_titles, vars_bins); // Always needed (require axis-titles and binning)
// spechandler->SetCuts(cuts, cuts_labels);            // Always needed
// spechandler->SetWeights(ana::kUnweighted);          // Allow using only one weight
// spechandler->SetShifts(ana::kNoShift);              // Allow using only one shift

// // Create and fill the spectrums: 
// spechandler->CreateSpectrums();                     // Creates the Spectrum objects
// spechandler->Go();                                  // Call Go() on each loader object

// // Save the spectrums
// spechandler->SaveSpectrums(fout);

#pragma once

// Standard includes
#include <string>
#include <vector>

// CAFE includes
#include "CAFAna/Core/Binning.h"
#include "CAFAna/Core/Var.h"
#include "CAFAna/Core/HistAxis.h"
#include "CAFAna/Core/MultiVar.h"
#include "CAFAna/Core/Cut.h"
#include "CAFAna/Core/Spectrum.h"
#include "CAFAna/Core/SpectrumLoader.h"
#include "CAFAna/Core/SystShifts.h"

// ROOT includes
#include <TROOT.h>
#include <TFile.h>

namespace ana{
  // Put the SpectrumHandler class in the ana namespace
  class SpectrumHandler;

  // Define the SpecHelp progress in order (start unloaded, define loaders, ready for filling, went)
  enum spec_handle_status {
    kSpecHelpUnloaded, // Default
    kSpecHelpLoaders,  // Loaders ready
    kSpecHelpReady,    // Spectrums are fully defined, not yet called go
    kSpecHelpWent      // All loaders have had go() called.
  };

  // Not implemented: defines the verbosity levels (in increasing descriptiveness)
  enum spec_handle_log_level {
    kSpecHelp_LOG_NOTHING,
    kSpecHelp_LOG_ERROR,
    kSpecHelp_LOG_WARNING,
    kSpecHelp_LOG_INFO
  };
}

class ana::SpectrumHandler{

public:

  ////////////////////////////////////////////
  // Core public member functions
  ////////////////////////////////////////////

  // Constructors / destructors

  // Default constructor
  SpectrumHandler() {};
  SpectrumHandler(const std::vector<SpectrumLoaderBase*> ls, const std::vector<std::string> dsls);

  // Default destructor
  // ~SpectrumHandler();   // Not implemented: Currently using compiler-made destructor

  ///////////////////////////////
  // Spectrum Loading and Setting
  ///////////////////////////////

  // Loaders
  bool SetLoaders(   const std::vector<std::string>& ds, const std::vector<std::string>& dsnames);
  bool SetLoader(    const std::string ds, const std::string dslab = "") {return SetLoaders(std::vector<std::string> {ds}, std::vector<std::string> {dslab});};
  bool SetLoaders(   const std::vector<SpectrumLoaderBase*> ls, const std::vector<std::string> llabels);
  bool SetLoader(    SpectrumLoaderBase* l, const std::string llabel = "") {return SetLoaders(std::vector<SpectrumLoaderBase*> {l}, std::vector<std::string> {llabel});};
  bool SetSpillCuts( const std::vector<SpillCut> spillcuts);
  bool SetSpillCuts( const SpillCut cut);

  // Loader access. Reason for this: allow adding more Spectrums to existing Loaders to prevent running the same files multiple times.
  std::vector<SpectrumLoaderBase*> GetLoaders( const std::vector<std::string> labels);
  SpectrumLoaderBase *             GetLoader(  const std::string label);

  // Vars, cuts, weights, and shifts
  bool SetVars(      const std::vector<Var> v,        const std::vector<std::string> vl, const std::vector<std::string> vt, const std::vector<Binning> vb);
  bool SetCuts(      const std::vector<Cut> c,        const std::vector<std::string> cl);
  bool SetWeights(   const std::vector<Var> w,        const std::vector<std::string> wl);
  bool SetWeights(   const Var w,                     const std::string wl = "") {return SetWeights(std::vector<Var> {w}, std::vector<std::string> {wl});};
  bool SetShifts(    const std::vector<SystShifts> s, const std::vector<std::string> sl);
  bool SetShifts(    const SystShifts s,              const std::string sl = "") {return SetShifts(std::vector<SystShifts> {s}, std::vector<std::string> {sl});};

  bool SetHistAxes(  const std::vector<HistAxis> h,   const std::vector<std::string> hl);
  bool SetHistAxes(  const HistAxis h,                const std::string hl = "") {return SetHistAxes(std::vector<HistAxis> {h}, std::vector<std::string> {hl});};

  // Creating Spectrums and filling them
  bool CheckReady();
  bool CreateSpectrums();
  bool Go();         // Wrapper for a loop over loader[i]->Go() with some checks
  bool Gone();       // Return true if ANY of the loaders return Gone() == true.
  bool SaveSpectrums(TFile * f);

  // Return the given status (will need to compare to ana::spec_handle_status values, since they are not provided explicitly)
  int GetStatus() {return fStatus;};

private:
  ////////////////////////////////////////////
  // Core private members
  ////////////////////////////////////////////

  // Store the status of the SpectrumHandler (see enum ana::spec_handle_status)
  int fStatus = kSpecHelpUnloaded;

  // Store the number of loaders/vars/cuts/weights/shifts
  unsigned int fNLoaders      = 0;
  unsigned int fNVars         = 0;
  unsigned int fNCuts         = 0;
  unsigned int fNWeights      = 0;
  unsigned int fNShifts       = 0;
  unsigned int fNHistAxes     = 0;

  // Label holders. Vars and Cuts MUST have labels. Vars need an axis title. Loader, weight, and shift labels can be empty if there is only one.
  std::vector<std::string> fLoader_labels; // Can be empty if only one loader
  std::vector<std::string> fVar_labels;    // Cannot be empty
  std::vector<std::string> fVar_titles;    // Cannot be empty
  std::vector<std::string> fCut_labels;    // Cannot be empty
  std::vector<std::string> fWeight_labels; // Can be empty if nweights == 1
  std::vector<std::string> fShift_labels;  // Can be empty if nshifts == 1
  std::vector<std::string> fHistAxis_labels; // Can be empty if using Var methods

  // CAFE Object holders, other than Spectrums
  std::vector <SpectrumLoaderBase*> fLoaders;  // All loaders.
  std::vector <Var>                 fVars;     // All vars to loop over. Require at least one.
  std::vector <Binning>             fVar_bins; // Binning for each Var. (size should be equal to num of vars)
  std::vector <Cut>                 fCuts;     // All cuts to loop over.
  std::vector <Var>                 fWeights;  // All weights to loop over.
  std::vector <SystShifts>          fShifts;   // All shifts to loop over
  std::vector <HistAxis>            fHistAxes; // All HistAxis to loop over

  // Spectrum Holder. 
  // Reason for this monstrousity of a 5D vector: easy to allow loops through ANY part of Spectrums
  // Vector order: datasets -> vars -> cuts -> shifts -> weights
  std::vector< std::vector< std::vector< std::vector< std::vector< Spectrum* > > > > > fSpecs;
  std::vector< std::vector< std::vector< std::vector< std::vector< Spectrum* > > > > > fHistAxisSpecs;

  ////////////////////////////////////////////
  // Core private functions
  ////////////////////////////////////////////
  void CreateVarSpectrums();
  void CreateHistAxisSpectrums();

  void SaveVarSpectrums(TDirectory * d, unsigned int il);
  void SaveHistAxisSpectrums(TDirectory * d, unsigned int il);
};