MicroDSTMaker.cxx

Go to the documentation of this file.

//$Id: MicroDSTMaker.cxx,v 1.10 2010/01/19 18:13:19 tinti Exp $
//
//MicroDSTMaker.cxx
//
//Module for analyzing beam data for nc analysis
//
//B. Rebel 10/2004

#include "NCUtils/Extraction/MicroDSTMaker.h"

#include "NCUtils/Cuts/NCAnalysisCutsCC.h"
#include "NCUtils/Cuts/NCAnalysisCutsNCCCFid.h"
#include "NCUtils/NCEventInfo.h"
#include "NCUtils/NCType.h"
#include "NCUtils/NCUtility.h"

#include "MessageService/MsgService.h"
#include "MinosObjectMap/MomNavigator.h"
#include "DataUtil/EnergyCorrections.h"
#include "JobControl/JobCModuleRegistry.h" // For JOBMODULE macro
#include "Conventions/Detector.h"
#include "Conventions/ReleaseType.h"
#include "Conventions/SimFlag.h"
#include "DataUtil/MCInfo.h"

#include "TSystemFile.h"
#include "TH1.h" // Needed for writing out the POT histogram

#include <cmath>
#include <cassert>
#include <algorithm>

using namespace EnergyCorrections;

CVSID("$Id: MicroDSTMaker.cxx,v 1.10 2010/01/19 18:13:19 tinti Exp $");

// Declare this module to JobControl. Arguments are:
//  (1) The class name
//  (2) The human-readable name
//  (3) A short, human-readable description of what the module does
JOBMODULE(MicroDSTMaker,
          "MicroDSTMaker",
          "A module to make NC uDSTs from antps");

//----------------------------------------------------------------------
MicroDSTMaker::MicroDSTMaker() :
  fNtpFile(0),
  fNtuple(0),
  fStrippedNtpFile(0),
  fRunPeriod(NC::RunUtil::kRunAll)
{
  MSG("JobC", Msg::kDebug) << "MicroDSTMaker::Constructor" << endl;

  fHeaderInfo = new ANtpHeaderInfo;
  fBeamInfo = new ANtpBeamInfo;
  fRecoInfo = new ANtpRecoInfo;
  fEventInfo = new ANtpEventInfoNC;
  fShowerInfo = new ANtpShowerInfoNC;
  fTrackInfo = new ANtpTrackInfoNC;
  fTruthInfo = new ANtpTruthInfoBeam;
  fMRCCInfo = new ANtpEventInfoMRCC;

  fInfo = new NCEventInfo;

}

//----------------------------------------------------------------------
MicroDSTMaker::~MicroDSTMaker()
{

  MSG("JobC", Msg::kDebug) << "MicroDSTMaker::Destructor" << endl;

  // free all the memory allocated dynamically
  if (fHeaderInfo) delete fHeaderInfo;
  if (fBeamInfo) delete fBeamInfo;
  if (fRecoInfo) delete fRecoInfo;
  if (fEventInfo) delete fEventInfo;
  if (fShowerInfo) delete fShowerInfo;
  if (fTruthInfo) delete fTruthInfo;
  if (fTrackInfo) delete fTrackInfo;
  if (fMRCCInfo) delete fMRCCInfo;
  if (fCuts) delete fCuts;

  if (fInfo) delete fInfo;

}

//----------------------------------------------------------------------
void MicroDSTMaker::EndJob()
{
  MSG("MicroDSTMaker", Msg::kInfo) << "Running with registry:" << endl;
  GetConfig().Print();
  MakeuDST();
}

//----------------------------------------------------------------------
void MicroDSTMaker::CreateNtupleTree(TFile*& file, TTree*& tree,
                                     TTree*& beamTree,
                                     TString filename, TString treename,
                                     bool truthBranch,
                                     bool mrccBranch)
{
  // save the current directory so as to not attach files to each other
  TDirectory* saveDir = gDirectory;

  file = new TFile(filename, "RECREATE");
  tree = new TTree("uDST", treename);
  tree->Branch("header.", "ANtpHeaderInfo", &fHeaderInfo, 64000, 2);

  if(truthBranch)
    tree->Branch("truth.", "ANtpTruthInfoBeam", &fTruthInfo, 64000, 2);

  tree->Branch("beam.", "ANtpBeamInfo", &fBeamInfo, 64000, 2);
  tree->Branch("reco.", "ANtpRecoInfo", &fRecoInfo, 64000, 2);

  // Since we pointed the input chain's mrcc branch at fMRCCInfo, this
  // line is enough to implement copying the mrcc branch across to the
  // output uDST unchanged
  if(mrccBranch)
    tree->Branch("mrcc.", "ANtpEventInfoMRCC", &fMRCCInfo, 64000, 2);

  for(unsigned int i = 0; i < fExtractions.size(); ++i) {
    string branchName = fExtractions[i]->ClassName();
    branchName = branchName.erase(0, 12); // this gives the ending,
    // "DP", "ADM", etc.
    branchName = "analysis" + branchName + ".";

    // add the analysis branches
    MSG("MicroDSTMaker", Msg::kInfo)
      << "Setting " << branchName << " branch..." << endl;
    tree->Branch(branchName.c_str(), "ANtpAnalysisInfo",
                 &fAnalysisInfos[i], 64000, 2);
  }

  tree->SetDirectory(file);

  beamTree = new TTree("beam", "AnalysisTree");
  beamTree->Branch("header.", "ANtpHeaderInfo", &fHeaderInfo, 64000, 2);
  beamTree->Branch("beam.", "ANtpBeamInfo", &fBeamInfo, 64000, 2);
  beamTree->SetDirectory(file);

  // return to original directory
  saveDir->cd();
}

//-----------------------------------------------------------------------
void MicroDSTMaker::MakeuDST()
{
  //make the chain for the data you want to use
  TChain chain(fTreeName);

  chain.Add(fFilePath);

  fDataType=chain.FindBranch("truth.") ? NCType::kMC : NCType::kData;

  bool haveMRCCBranch=chain.FindBranch("mrcc.");

  MSG("MicroDSTMaker", Msg::kInfo) << "adding path " << fFilePath
                                      << " to chain." << endl;

  // Need to set run period for MC. We're using kRunAll as the "unknown" value
  if(fDataType==NCType::kMC && 
     (fRunPeriod<NC::RunUtil::kRunI || fRunPeriod>NC::RunUtil::kMaxRun)){
    MSG("MicroDSTMaker", Msg::kFatal) 
      << "Run Period not set, or set wrongly, when running on MC. Bailing" << endl;
    // Dummy to make it exit here
    MSG("MicroDSTMaker", Msg::kInfo)  << endl;
  }

  chain.SetBranchAddress("header.", &fHeaderInfo);
  chain.SetBranchAddress("beam.",   &fBeamInfo);
  chain.SetBranchAddress("event.",  &fEventInfo);
  chain.SetBranchAddress("shower.", &fShowerInfo);
  chain.SetBranchAddress("track.",  &fTrackInfo);

  if(fDataType==NCType::kMC) chain.SetBranchAddress("truth.",  &fTruthInfo);
  if(haveMRCCBranch)         chain.SetBranchAddress("mrcc.",  &fMRCCInfo);

  chain.GetEntry(0);

  //figure out which kind of cuts object to use
  MSG("MicroDSTMaker", Msg::kInfo) << "fCutSuite = " << fCutSuite << endl;
  switch(fCutSuite){
  case NCType::kCCCuts:      fCuts = new NCAnalysisCutsCC;      break;
  case NCType::kNCCuts:      fCuts = new NCAnalysisCutsNC;      break;
  case NCType::kNCCCFidCuts: fCuts = new NCAnalysisCutsNCCCFid; break;
  default: assert(0 && "Unknown cut suite");
  }

  fCuts->SetInfoObjects(fHeaderInfo, fBeamInfo, fEventInfo,
                        fTrackInfo, fShowerInfo, fTruthInfo);
  fInfo->SetInfoObjects(fHeaderInfo, fBeamInfo, fEventInfo,
                        fTrackInfo, fShowerInfo, 0, 0, fTruthInfo);

  // beam type from the BeamAna stuff
  fCuts->SetBeamType(fBeamType);

  //check if should be using all L010z or 185i data
  fCuts->SetUseAllBeams(fUseAllBeams);
  fCuts->SetUseAllL010z(fUseAllL010z);
  fCuts->SetUseAll185i(fUseAll185i);

  //fill the vectors holding the extraction and analysis objects
  FillExtractionAndAnalysisVectors();

  //make a file and the trees to go into the file
  TString fileName = fFileName;

  //indicate you have a stripped file
  TString stripFileName = fileName;
  int pos = stripFileName.Index(".root");
  stripFileName.Insert(pos, "_strip");

  CreateNtupleTree(fStrippedNtpFile, fStrippedNtuple, fBeamNtupleStp,
                   stripFileName, "Stripped AnalysisTree", fDataType==NCType::kMC,
                   haveMRCCBranch);

  CreateNtupleTree(fNtpFile, fNtuple, fBeamNtuple,
                   fileName, "AnalysisTree", fDataType==NCType::kMC,
                   haveMRCCBranch);

  MSG("MicroDSTMaker", Msg::kInfo) << "filenames " << fileName
                                      << " " << stripFileName << endl;

  //clear the data POT map
  fPOTs.clear();

  // Loop over the input chain and actually do the extraction
  ExtractNCCC(&chain);

  WriteFile(fNtpFile, fNtuple, fBeamNtuple);
  WriteFile(fStrippedNtpFile, fStrippedNtuple, fBeamNtupleStp);

  const int ntupleEntries = fNtuple->GetEntries();

  //check to see if there was anything in the ntuples,
  //if not remove the file from the system
  if(ntupleEntries < 1){
    TSystemFile ntp(fileName, "./");
    TSystemFile strip(stripFileName, "./");

    ntp.Delete();
    strip.Delete();
  }
}

//-----------------------------------------------------------------------
void MicroDSTMaker::FillExtractionAndAnalysisVectors()
{
  MSG("MicroDSTMaker", Msg::kInfo) << "SimFlag =  "
                                   << fHeaderInfo->dataType << endl;

  fExtractions.clear();
  ParseExtractionsList(fExtractionsList);

  //fill the vector of analysis info objects (one per extraction)
  MSG("MicroDSTMaker", Msg::kInfo)
    << "Using " << fExtractions.size() << " extraction  methods."
    << " Now adding the corresponding ANtpAnalysisInfo objects..."
    << endl;
  
  fAnalysisInfos.clear();
  for (unsigned int i = 0; i < fExtractions.size(); ++i)
    fAnalysisInfos.push_back(new ANtpAnalysisInfo);
}

//----------------------------------------------------------------------
const Registry& MicroDSTMaker::DefaultConfig() const
{
  static Registry r;

  r.UnLockValues();

  r.Set("FileName",               "ncccSeparation.root");
  r.Set("TreeName",               "antp");
  r.Set("FilePath",               "");
  r.Set("PDFPath",                "DP_histos_far.root");
  r.Set("ReadPDFs",               false);
  r.Set("BeamType",               "L010z185i");
  r.Set("UseAllBeams",            false);
  r.Set("UseAllL010z",            false);
  r.Set("UseAll185i",             false);
  r.Set("ExtractionsList",        "TOm");
  r.Set("RPAnnUseLowETrain",      false);
  r.Set("FileCountLimit",         1000000000);
  r.Set("DataSet",                "/");
  r.Set("CutSuite",               int(NCType::kCCCuts));

  r.Set("MCVersion",              
        ReleaseType::kDogwood | ReleaseType::kDaikon | ReleaseType::k04);

  r.Set("RunPeriod",              int(NC::RunUtil::kRunAll));

  r.LockValues();
  return r;
}

//----------------------------------------------------------------------
void MicroDSTMaker::Config(const Registry& r)
{
  int         tmpb;  // a temp bool.
  int         tmpi;  // a temp int.
  const char* tmps;  // a temp string

  if (r.Get("FileName",         tmps)) fFileName          = tmps;
  if (r.Get("TreeName",         tmps)) fTreeName          = tmps;
  if (r.Get("FilePath",         tmps)) fFilePath          = tmps;
  if (r.Get("UseMCAsData",      tmpb)) fUseMCAsData       = tmpb;
  if (r.Get("BeamType",         tmps)) fBeamType          = BeamType::TagToEnum(tmps);
  if (r.Get("UseAllBeams",      tmpb)) fUseAllBeams       = tmpb;
  if (r.Get("UseAllL010z",      tmpb)) fUseAllL010z       = tmpb;
  if (r.Get("UseAll185i",       tmpb)) fUseAll185i        = tmpb;
  if (r.Get("ExtractionsList",  tmps)) fExtractionsList   = tmps;
  if (r.Get("CutSuite",         tmpi)) fCutSuite          = NCType::ECuts(tmpi);
  if (r.Get("FileCountLimit",   tmpi)) fFileCountLimit    = tmpi;
  if (r.Get("DataSet",          tmps)){
    fDataSet           = tmps;
    fDataSet.Remove(TString::kLeading, '/');
  }
  if (r.Get("RunPeriod",        tmpi)) fRunPeriod         = NC::RunUtil::ERunType(tmpi);
}

//-----------------------------------------------------------------------
void MicroDSTMaker::ExtractNCCC(TChain *chain)
{

  MSG("MicroDSTMaker", Msg::kInfo) << "ExtractNCCC" << endl;

  int ctr = 0;
  int passSnarl = 0;
  int passEvt = 0;
  int passFid = 0;
  bool passCut1 = false;
  bool passCut2 = false;
  bool passCut3 = false;
  bool newSnarl = false;

  int fileCtr = 0;
  int prevRun = -1;
  int prevSubRun = -1;

  chain->GetEntry(0);
  //Get The proper POT/Snarl value
  Detector::Detector_t detType = (Detector::Detector_t)fHeaderInfo->detector;

  if(fDataType==NCType::kMC){
    const char* mcString = (fHeaderInfo->softVersion).Data();
    ReleaseType::Release_t mcType=ReleaseType::StringToType(mcString);
    if (mcType==ReleaseType::kUnknown) {
        MSG("MicroDSTMaker",Msg::kFatal)
          << "Can't figure out MC version, bailing." << endl;
        // Dummy message to make sure it really quits
        MSG("MicroDSTMaker",Msg::kFatal)
          << "Goodbye" << endl;
    }

    fMCPOTPerSnarlOrSubrun = MCInfo::GetMCPoT(detType,fBeamType,mcType);
    MSG("MicroDSTMaker",Msg::kInfo) << "MC POT per snarl: "
                                       << fMCPOTPerSnarlOrSubrun << endl;
  }

  //loop over the entries in the tree
  while( chain->GetEntry(ctr) && fileCtr<fFileCountLimit){
    if(ctr % 20000 == 0)
      MSG("MicroDSTMaker", Msg::kInfo)
        << "entry " << ctr << " file " << fileCtr << endl;

    ++ctr;

    if(fHeaderInfo->run != prevRun || fHeaderInfo->subRun != prevSubRun){
      prevRun = fHeaderInfo->run;
      prevSubRun = fHeaderInfo->subRun;
      ++fileCtr;
    }

    if(fDataType==NCType::kData){
      fTruthInfo = 0;
      fBeamInfo->protonIntensity = fBeamInfo->trtgtd;
      if(fBeamInfo->protonIntensity <= 0.0) 
        fBeamInfo->protonIntensity = fBeamInfo->tr101d;
      if(fBeamInfo->protonIntensity <= 0.0) 
        fBeamInfo->protonIntensity = 0.;
    }
    else if(fDataType==NCType::kMC){
      //make sure the mc beam type is the correct one
      fBeamInfo->beamType = (Int_t)(fBeamType);
      fBeamInfo->protonIntensity = fMCPOTPerSnarlOrSubrun;
    }
    else{
      assert(0 && "Data Type neither MC or data. Bailing.");
    }

    //set the info objects to use
    fCuts->SetInfoObjects(fHeaderInfo, fBeamInfo, fEventInfo,
                          fTrackInfo, fShowerInfo, fTruthInfo);
    fInfo->SetInfoObjects(fHeaderInfo, fBeamInfo, fEventInfo,
                           fTrackInfo, fShowerInfo, 0, 0, fTruthInfo);

    newSnarl = fCuts->IsNewSnarl();

    if (passCut1 = (fCuts->IsGoodBeamSnarl()) ) passSnarl++;
    if (passCut2 = (fCuts->IsGoodBeamEvent() && passCut1) ) passEvt++;
    if (passCut3 = (fCuts->InBeamFiducialVolume() && passCut2)) passFid++;

    if( newSnarl && passCut1 ){
      CountPOTs();
      AddToBeamNtuple();
    }

    if (!passCut2) continue;

    FillRecoInfo(fRecoInfo, fHeaderInfo,
                 fEventInfo, fShowerInfo,
                 fTrackInfo, fBeamInfo, fCuts,
                 fBeamInfo->beamType);

    NCEventInfo evtInfo;
    evtInfo.beam=fBeamInfo;
    evtInfo.event=fEventInfo;
    evtInfo.header=fHeaderInfo;
    evtInfo.reco=fRecoInfo;
    evtInfo.shower=fShowerInfo;
    evtInfo.track=fTrackInfo;
    evtInfo.truth=fTruthInfo;
    

    for (unsigned int i = 0; i < fExtractions.size(); ++i){
      evtInfo.analysis=fAnalysisInfos[i];
      NCExtraction* ext=fExtractions[i];
      ext->FillAnalysisInfo(evtInfo, fBeamInfo->beamType);
    }
    AddToNtuple();

  }//end loop over chain

  // print some details about cuts
  MSG("MicroDSTMaker", Msg::kInfo)
    << passSnarl << "/" << ctr << " passed IsGoodBeamSnarl()\n"
    << passEvt << "/" << passSnarl << " passed IsGoodBeamEvent()\n"
    << passFid << "/" << passEvt << " passed fiducial cuts"
    << endl;
}

//-----------------------------------------------------------------------
void MicroDSTMaker::AddToBeamNtuple()
{
  const bool canWriteFull = !OutputFileTooBig();
  const bool canWriteStripped = !StrippedOutputFileTooBig();

  if(canWriteFull)
    fBeamNtuple->Fill();
  if(canWriteStripped)
    fBeamNtupleStp->Fill();
}

//-----------------------------------------------------------------------
void MicroDSTMaker::AddToNtuple()
{
  //fill the appropriate uDST ntuple

  const bool canWriteFull = !OutputFileTooBig();
  const bool canWriteStripped = !StrippedOutputFileTooBig();

  if(canWriteFull) fNtuple->Fill();

  if(fCuts->PassesFinalSelection(fRecoInfo) && canWriteStripped)
    fStrippedNtuple->Fill();
}


//-----------------------------------------------------------------------
void MicroDSTMaker::CountPOTs()
{
  int runCode = 100*fHeaderInfo->run + fHeaderInfo->subRun;
  map<int, double>::iterator itr=fPOTs.find(runCode);

  if(fDataType==NCType::kData){

    if( itr != fPOTs.end() )
      fPOTs[runCode] += fBeamInfo->protonIntensity;
    else
      fPOTs[runCode] = fBeamInfo->protonIntensity;
  }
  else{
    // For MC... This is a bit funky. In the ND,
    // fMCPOTPerSnarlOrSubrun is per snarl, but in the FD it's per
    // subrun. 
    if(fHeaderInfo->detector == Detector::kNear){
      if( itr != fPOTs.end())
        fPOTs[runCode] += fMCPOTPerSnarlOrSubrun;
      else
        fPOTs[runCode] = fMCPOTPerSnarlOrSubrun;
    }
    else{
      // FD. Doesn't matter whether the subrun was already in the map,
      // because fMCPOTPerSnarlOrSubrun is set to the POT per subrun
      fPOTs[runCode] = fMCPOTPerSnarlOrSubrun;
    }
  }
}

//-----------------------------------------------------------------------
void MicroDSTMaker::WritePOTInfo()
{
  if(fPOTs.size() != 0){
    int firstRun = fPOTs.begin()->first;
    //last run is given by the first entry in the reversed map
    int lastRun = fPOTs.rbegin()->first;
    TH1F *potHist = new TH1F(fDataType==NCType::kData ? "dataPOT" : "mcPOT", 
                             "", 
                             lastRun-firstRun+1,
                             firstRun, 
                             lastRun+1);
    map<int, double>::iterator itr = fPOTs.begin();
    while( itr != fPOTs.end() ){
      potHist->Fill(itr->first + 0.5, itr->second);
      ++itr;
    }
    potHist->Write();
    MSG("MicroDSTMaker", Msg::kInfo) << "total POT = "
                                        << potHist->Integral()
                                        << " x 10^{12}" << endl;
  }
}

//-----------------------------------------------------------------------
double MicroDSTMaker::GetTotalPOTCount()
{
  double ret = 0;
  for(map<int, double>::iterator it = fPOTs.begin(); 
      it != fPOTs.end(); ++it) ret += it->second;
  return ret;
}

//-----------------------------------------------------------------------
void MicroDSTMaker::WriteFile(TFile *file, TTree *events, TTree *beam)
{

  // get a pointer to the current directory
  // this is one of the output files
  TDirectory* saveDir = gDirectory;

  file->cd();

  events->Write();
  beam->Write();
  WritePOTInfo();

  file->cd();

  file->Write("",TObject::kOverwrite);

  MSG("MicroDSTMaker", Msg::kInfo) << "file " << file->GetName()
                                      << " written" << endl;
  //file->Close();

  saveDir->cd();
}

//----------------------------------------------------------------------
void MicroDSTMaker::FillRecoInfo(ANtpRecoInfo *recoInfo,
                                 ANtpHeaderInfo *headerInfo,
                                 ANtpEventInfoNC *eventInfo,
                                 ANtpShowerInfoNC* showerInfo,
                                 ANtpTrackInfoNC *trackInfo,
                                 ANtpBeamInfo *beamInfo,
                                 NCAnalysisCuts *cuts,
                                 int beamType)
{
  //reset the values
  recoInfo->Reset();

  // This leaves the run period set at ANtpDefVal::kInt for data
  if(fDataType==NCType::kMC) recoInfo->runPeriod = (int)fRunPeriod;

  recoInfo->inFiducialVolume = (int)cuts->InBeamFiducialVolume();
  recoInfo->isFullyContained = (int)(cuts->InBeamFiducialVolume() &&
                                     cuts->IsStoppingBeamMuon());

  recoInfo->passesCuts = 1;
  recoInfo->pass = 1;

  //GetEventEnergy returns sum of track and shower energy - NC events
  //dont count the track energy so just make the reco'd nu energy
  //for NC events the shower energy only
  const bool stop = cuts->IsStoppingBeamMuon();
  recoInfo->nuEnergyCC = fInfo->GetEventEnergy(CandShowerHandle::kCC, stop);
  recoInfo->nuEnergyNC = fInfo->GetShowerEnergy(CandShowerHandle::kNC);
  recoInfo->nuEnergy   = fInfo->GetEventEnergy(CandShowerHandle::kCC, stop);

  if(eventInfo->tracks > 0)
    recoInfo->muEnergy = fInfo->GetTrackEnergy(stop);
  else
    recoInfo->muEnergy = 0.;

  if(eventInfo->showers > 0){
    recoInfo->showerEnergy = fInfo->GetShowerEnergy(CandShowerHandle::kCC);
    recoInfo->showerEnergyCC = fInfo->GetShowerEnergy(CandShowerHandle::kCC);
    recoInfo->showerEnergyNC = fInfo->GetShowerEnergy(CandShowerHandle::kNC);
  }
  else{
    recoInfo->showerEnergy = 0.;
    recoInfo->showerEnergyCC = 0.;
    recoInfo->showerEnergyNC = 0.;
  }

  //check that this is a reasonable shower
  recoInfo->isGoodShower = (int)cuts->IsGoodShower();


  if(recoInfo->nuEnergy > 0.){
    recoInfo->hadronicY = recoInfo->showerEnergy;
    recoInfo->hadronicY /= recoInfo->nuEnergy;
  }

  recoInfo->muDCosZVtx = trackInfo->dcosZVtx;
  double vtxX = 0., vtxY = 0., vtxZ = 0.;
  recoInfo->vtxR = fInfo->GetEventVertex(vtxX, vtxY, vtxZ);
  recoInfo->vtxX = vtxX;
  recoInfo->vtxY = vtxY;
  recoInfo->vtxZ = vtxZ;
  recoInfo->eventLength = eventInfo->lengthInPlanes;
  recoInfo->trackExtension = eventInfo->trackExtension;
  recoInfo->numberTracks = eventInfo->tracks;
  recoInfo->trackLength = trackInfo->length;

  bool isdata = fDataType==NCType::kData;
  Detector::Detector_t detType = (Detector::Detector_t)headerInfo->detector;

  recoInfo->trackMomentum = CorrectSignedMomentumFromCurvature(trackInfo->fitMomentum,
                                                               isdata, detType );

  //RPL 17/08/04: protect against passing -ive momenta to correction fn
  if( 0 < trackInfo->rangeMomentum ){
    recoInfo->trackRange = CorrectMomentumFromRange(trackInfo->rangeMomentum,
                                                    isdata, detType);
  }
  else{
    recoInfo->trackRange = trackInfo->rangeMomentum;
  }

  recoInfo->sigmaQoverP = trackInfo->sigmaQoverP;
  recoInfo->eventInSnarl = eventInfo->index;

  recoInfo->weight = 1.0;
  recoInfo->weightRunII = 1.0;
  recoInfo->weightRunIII = 1.0;
  // calculate the MEGA weight for MC events
  if(fDataType==NCType::kMC){
    // if the second argument is false, it uses the mock data weight
    // if it is true, it uses the weight from the best fit to the data
    recoInfo->weight = fInfo->FindMEGAFitWeight(beamType, NC::RunUtil::kRunI);
    recoInfo->weightRunII = fInfo->FindMEGAFitWeight(beamType, NC::RunUtil::kRunII);
    recoInfo->weightRunIII = fInfo->FindMEGAFitWeight(beamType, NC::RunUtil::kRunIII);
  }

  // data cleaning variables
  recoInfo->minTimeSeparation = eventInfo->minTimeSeparation;
  recoInfo->closeTimeEvent = eventInfo->closeTimeEvent;

  recoInfo->totalStrips = eventInfo->totalStrips;
  recoInfo->planes = eventInfo->planes;
  recoInfo->trackPlanes = trackInfo->planes;
  recoInfo->showerPlanes = showerInfo->planes;
  recoInfo->showerTotalStrips = showerInfo->totalStrips;
  recoInfo->evtEnergyGeV = eventInfo->energyGeV;

  if(detType == Detector::kNear){
    recoInfo->closeTimeDeltaZ = eventInfo->closeTimeDeltaZ;
    recoInfo->edgeActivityPH = eventInfo->edgeActivityPH;
    recoInfo->edgeActivityStrips = eventInfo->edgeActivityStrips;
    recoInfo->oppEdgePH = eventInfo->oppEdgePH;
    recoInfo->oppEdgeStrips = eventInfo->oppEdgeStrips;
    recoInfo->slicePHFraction = eventInfo->slicePHFraction;
    recoInfo->evtTimeDiff = eventInfo->evtTimeDiff;
    recoInfo->sharedStripFraction = eventInfo->sharedStripFraction;
    recoInfo->isCleanLowMultSnarl = int(cuts->IsCleanLowMultSnarl());
    recoInfo->isMultiCutsClean = int(cuts->IsMultiCutsClean());
    recoInfo->isSimpleCutsClean = int(cuts->IsSimpleCutsClean());
  }

  // Cutting on the cleaning is common in analysis macros.
  // Considering FD events to always be clean simplifies that code.
  if(detType == Detector::kFar){
    recoInfo->isSimpleCutsClean = 1;
    recoInfo->isMultiCutsClean = 1;
  }

  recoInfo->deltaTimeSpill = (eventInfo->stripTime1st - 
                              1e-9*beamInfo->nearestNSToSpill)*1e6;//in us
}

//-----------------------------------------------------------------------
void MicroDSTMaker::ParseExtractionsList(TString extrs)
{
  MSG("MicroDSTMaker", Msg::kInfo) << "Registered extractions:\n";

  const vector<TString> extrsArgNames = NC::Utility::ParseStringList(extrs);

  for(unsigned int n = 0; n < GetExtractionFactories().size(); ++n){
    NCExtractionFactory* ex = GetExtractionFactories()[n];
    const TString codeName = ex->GetCodeName();

    MSG("MicroDSTMaker", Msg::kInfo) << "  " << codeName << " - ";

    bool inExtrs = false;
    for(unsigned int i = 0; i < extrsArgNames.size(); ++i)
      if(extrsArgNames[i] == codeName) inExtrs = true;

    if(inExtrs){
      MSG("MicroDSTMaker", Msg::kInfo) << "Creating\n";
      fExtractions.push_back(ex->Create(fCuts, GetConfig()));
    }
    else{
      MSG("MicroDSTMaker", Msg::kInfo) << "Not in ExtractionsList\n";
    }
  }
}

//-----------------------------------------------------------------------
bool MicroDSTMaker::OutputFileTooBig()
{
  //keep filling the ntuple if the total file size < 1.8 Gb
  if(fNtpFile->GetSize() < 1850400000)
    return false;
  else{
    MAXMSG("MicroDSTMaker", Msg::kWarning,1)
      << "Size limit exceeded no longer filling full ntuple" << endl;
    return true;
  }
}

//-----------------------------------------------------------------------
bool MicroDSTMaker::StrippedOutputFileTooBig()
{
  //keep filling the ntuple if the total file size < 1.8 Gb
  if(fStrippedNtpFile->GetSize() < 1850400000)
    return false;
  else{
    MAXMSG("MicroDSTMaker", Msg::kWarning,1)
      << "Size limit exceeded no longer filling stripped ntuple" << endl;
    return true;
  }
}

---