SummarySelector.cxx

#include "SummarySelector.h"

#include <TH2.h>
#include <TStyle.h>
#include "TCanvas.h"
#include "DrawStrings.h"
#include "TTreeFormula.h"
#include "TMath.h"
#include "TTreeFormulaManager.h"

ClassImp(Acclaim::SummarySelector);


Acclaim::SummarySelector::SummarySelector(const char* sumBranchName)
  : TSelector(), fChain(NULL),
    fCuts(new TList), fCutFormulas(NULL),
    // fCutTreeName("cutResultTree"), fAnalysisCutTree(NULL),
    // fCutReturns(), fDoAnalysisCutTree(true),
    fDemoForm(NULL),
    fDemoHist(NULL), fDoDemoHist(false)
    // fEventNumber(0), fRun(0), fWeight(0)
{
  fInput = new TList;
  fCuts->SetName("fCuts");
}



Acclaim::SummarySelector::~SummarySelector()
{

}



void  Acclaim::SummarySelector::addCut(const TCut* analysisCut)
{
  fCuts->Add(const_cast<TCut*>(analysisCut));
}




void Acclaim::SummarySelector::Init(TTree *tree)
{

  fTree = tree;

  if(!fCutFormulas){
    fCutFormulas = new TList;
  }
  fCutFormulas->SetOwner(true);
  fCutFormulas->Delete();
    
  if(fCutFormulas->GetEntries()==0){
    const int nForm = fCuts->GetEntries();
    fCutReturns.resize(nForm, std::vector<Int_t>());

    fMaxNdata = 1;
    
    for(UInt_t fInd=0; fInd < nForm; fInd++){
      const TCut* eventSelection = dynamic_cast<const TCut*>(fCuts->At(fInd));

      TString formName = TString::Format("cutForm_%s", eventSelection->GetName());
      TTreeFormula* f = new TTreeFormula(formName, eventSelection->GetTitle(), fTree);
      fCutFormulas->Add(f);

      if(f->GetNdata() > fMaxNdata){
    fMaxNdata = f->GetNdata();
      }
      // fManager->Add(f);
    }

    for(UInt_t fInd=0; fInd < fCutReturns.size(); fInd++){
      fCutReturns.at(fInd).resize(fMaxNdata, false);
    }
    fCumulativeCutReturns.resize(fMaxNdata, false);
    

    if(fDoDemoHist){
      fDemoForm = new TTreeFormula("demo_form", "run", fTree); // only has 1 data...
    }    
  }
  // else{
  //   // std::cout << tree->GetName() << std::endl;
  //   // tree->Show(0);
    
  //   TIter next(fCutFormulas);
  //   while(TTreeFormula* form = dynamic_cast<TTreeFormula*>(next())){
  //     form->SetTree(tree);      
  //     // form->UpdateFormulaLeaves();
  //   }

  //   if(fDemoForm){
  //     fDemoForm->SetTree(tree);
  //     // fDemoForm->UpdateFormulaLeaves();
  //   }
  // }
}
  







Bool_t Acclaim::SummarySelector::Notify()
{
  TIter next(fCutFormulas);
  while(TTreeFormula* form = dynamic_cast<TTreeFormula*>(next())){
    form->Notify();
  }
  
  return kTRUE;
}


void Acclaim::SummarySelector::Begin(TTree * /*tree*/)
{
  // TString option = GetOption();
  
  fInput->Add(fCuts);
  
  if(fDoDemoHist){
    fInput->Add(new TNamed("fDoDemo", "hDemo"));
  }
  
  
}


void Acclaim::SummarySelector::SlaveBegin(TTree * /*tree*/)
{
  fCuts = dynamic_cast<TList*>(fInput->FindObject("fCuts"));

  TNamed* n = dynamic_cast<TNamed*>(fInput->FindObject("fDoDemo"));
  fDoDemoHist = n ? true : false;
  if(fDoDemoHist){
    fDemoHist = new TH1D("hDemo", "Demo histogram - run; run; number of events", 310, 130, 440);
    fOutput->Add(fDemoHist);
  }

  
}


Bool_t Acclaim::SummarySelector::Process(Long64_t entry)
{

  // Long64_t readEntry = fTree->LoadTree(entry);
  // std::cout << "On entry " << entry << ", got readEntry " << readEntry << std::endl;
  
  fTree->LoadTree(entry);  

  Bool_t matchesSelection = true;
  for(int i=0; i < fMaxNdata; i++){
    fCumulativeCutReturns[i] = true;
  }

  

  TIter next(fCutFormulas);
  int fInd=0;
  while (TObject* obj = next()){
    TTreeFormula* form = dynamic_cast<TTreeFormula*>(obj);

    bool anyIterationsPass = false;
    for(int i=0; i < fMaxNdata; i++){
      Float_t cutVal = form->GetNdata() > 1 && i < form->GetNdata() ? form->EvalInstance(i) : form->EvalInstance();
      fCutReturns.at(fInd).at(i) = cutVal;

      bool thisPass = cutVal > 0;

      fCumulativeCutReturns.at(i) = bool(fCumulativeCutReturns.at(i)) && thisPass;

      anyIterationsPass = anyIterationsPass || fCumulativeCutReturns.at(i);
    }

    // std::cout << fInd << "\t" << form->GetTitle() << std::endl;
    // for(int i=0; i < fMaxNdata; i++){
    //   // std::cout << fInd << "\t" << i << std::endl;
    //   std::cout << "(" << i << " : " << fCutReturns.at(fInd).at(i) << "), ";
    // }
    // std::cout << std::endl;
    // for(int i=0; i < fMaxNdata; i++){
      // std::cout << i << std::endl;
      // std::cout << fCumulativeCutReturns.at(i) << "\t";
    // }

    // std::cout << "\n" <<  std::endl;
    // std::cout << anyIterationsPass << "\t" << matchesSelection << std::endl;

    matchesSelection = matchesSelection && anyIterationsPass;

    // we can break out of the loop early if we're not storing the results
    // of all the cuts, and the selection doesn't match all the cuts
    // if(!fDoAnalysisCutTree && !matchesSelection){

    fInd++;    
    if(!matchesSelection){
      break;
    }
  }

  // if doing the demo hist, then fill event passes the cut
  if(matchesSelection && fDemoHist){
    fDemoHist->Fill(fDemoForm->EvalInstance());
  }

  // // If storing the analysis cut result, then update
  // if(fDoAnalysisCutTree && fAnalysisCutTree){
  //   fEventNumber = fSum->eventNumber;
  //   fRun = fSum->run;
  //   fWeight = fSum->weight();
  //   fAnalysisCutTree->Fill();
  // }

  return matchesSelection;
}


void Acclaim::SummarySelector::SlaveTerminate()
{
  // fInput->Remove(fCuts);

  // fCuts->Clear(); // don't delete globals
  // delete fCuts;
  // fCuts = NULL;
}



void Acclaim::SummarySelector::Terminate()
{

  if(fDoDemoHist){
    fDemoHist = dynamic_cast<TH1D *>(fOutput->FindObject("hDemo"));  
    if (fDemoHist) {
      TCanvas *c1 = new TCanvas();
      fDemoHist->Draw("hist");

      // Final update
      c1->cd();
      c1->Update();
    }
    else {
      Warning("Terminate", "histogram not found");
    }
  }  
}