MadHandScan.cxx

Go to the documentation of this file.

#ifndef madhandscan_cxx
#define madhandscan_cxx
#include <iostream>
#include <cmath>
//root includes
#include "TClonesArray.h"
#include "TH2.h"
#include "TGraph.h"
#include "TStyle.h"
#include "TCanvas.h"
#include "TVector3.h"
#include "TArrow.h"
#include "TPolyLine.h"
#include "TEllipse.h"
#include "TButton.h"
#include "TLatex.h"
#include "TMarker.h"
#include "TPave.h"
#include "TPaveText.h"
#include "TRandom.h"
//minossoft includes
#include "Validity/VldContext.h"
#include "Conventions/Detector.h"
//my includes
#include "CandFitShowerEM/FitterEM.h"
#include "Mad/MadHandScan.h"
#include <fstream>

MadHandScan::MadHandScan(TChain *chainSR,TChain *chainMC,
                         TChain *chainTH,TChain *chainEM)
{

  if(!chainSR) {
    record = 0;
    strecord = 0;
    emrecord = 0;
    mcrecord = 0;
    threcord = 0;
    Clear();
    whichSource = -1;
    isMC = true;
    isTH = true;
    isEM = true;
    Nentries = -1;
    return;
  }

  writeTree = false;
  quizTag = "noTag";
  quizTree = NULL;
  fTotEnt = 0;
  fCurEnt = 0;
  isNue = 0;
  tru_inu = 0;
  tru_iac = 0;
  tru_y = 0;
  shw_En = 0;
  lep_En = 0;
  tru_En = 0;
  r_num = 0;
  s_num = 0;
  maxpln = 0;
  minpln = 999;
  maxstp_u = 0;
  minstp_u = 999;
  maxstp_v = 0;
  minstp_v = 999;

  entryMap.clear();
  failedMap.clear();

  uHist = NULL;
  vHist = NULL;
  uEMHist = NULL;
  vEMHist = NULL;
  uPredHist = NULL;
  vPredHist = NULL;

  sprintf(exit,".q");

  InitChain(chainSR,chainMC,chainTH,chainEM);
  whichSource = 0;

}

MadHandScan::MadHandScan(JobC *j,string path,int entries)
{
 
  record = 0;
  strecord = 0;
  emrecord = 0;
  mcrecord = 0;
  threcord = 0;
  Clear();
  isMC = true;
  isTH = true;
  isEM = true;
  Nentries = entries;
  jcPath = path;
  whichSource = 1;
  fCurRun = -1;
  fJC = j;
  fChain = NULL;

  writeTree = false;
  quizTag = "noTag";
  quizTree = NULL;
  fTotEnt = 0;
  fCurEnt = 0;
  isNue = 0;
  tru_inu = 0;
  tru_iac = 0;
  tru_y = 0;
  r_num = 0;
  s_num = 0;
  shw_En = 0;
  lep_En = 0;
  tru_En = 0;
  maxpln = 0;
  minpln = 999;
  maxstp_u = 0;
  minstp_u = 999;
  maxstp_v = 0;
  minstp_v = 999;

  entryMap.clear();
  failedMap.clear();

  uHist = NULL;
  vHist = NULL;
  uEMHist = NULL;
  vEMHist = NULL;
  uPredHist = NULL;
  vPredHist = NULL;

  sprintf(exit,".q");

}

MadHandScan::~MadHandScan()
{

  if(writeTree&&quizTree) {
    char savename[256];
    sprintf(savename,"QuizFile_%s.root",quizTag.data());
    ifstream Test(savename);
    if(!Test) {
      TFile save(savename,"NEW");
      quizTree->Write();
      save.Close();
    }
    else {
      //move old file to temp location
      char pline[256];
      sprintf(pline,".! mv %s .QuizFile_tmp1.root",savename);
      gROOT->ProcessLine(pline);
      //make new temp file to hold current tree
      TFile save_tmp(".QuizFile_tmp2.root","NEW");
      save_tmp.cd();
      quizTree->Write();
      save_tmp.Close();
      //make a chain add both temp files and merge to specified save file
      TChain chain("QuizTree");
      chain.Add(".QuizFile_tmp1.root");
      chain.Add(".QuizFile_tmp2.root");
      chain.Merge(savename);
      gROOT->ProcessLine(".! rm .QuizFile_tmp1.root .QuizFile_tmp2.root");
    }
  }
}

void MadHandScan::RunQuiz(string fileName)
{

  gStyle->SetTitleFontSize(0.1);

  quizTree = new TTree("QuizTree","QuizTree");
  quizTree->Branch("run",&r_num,"run/I",32000);
  quizTree->Branch("snarl",&s_num,"snarl/I",32000);
  quizTree->Branch("vote",&isNue,"vote/I",32000);
  quizTree->Branch("entry",&fChainEnt,"entry/I",32000);
  quizTree->Branch("nuen",&tru_En,"nuen/F",32000);
  quizTree->Branch("shwen",&shw_En,"shwen/F",32000);
  quizTree->Branch("lepen",&lep_En,"lepen/F",32000);
  quizTree->Branch("inu",&tru_inu,"inu/I",32000);
  quizTree->Branch("iaction",&tru_iac,"iaction/I",32000);
  quizTree->Branch("y",&tru_y,"y/F",32000);
  quizTree->Branch("failed",&fCurFailed,"failed/I",32000);

  ifstream inFile(fileName.data());
  if(inFile.is_open()){    
    int entry = 0;
    int ind = 0;
    int failed = 0; //1 = failed, 0 = passed  
    while(inFile>>entry>>failed){
      entryMap[ind] = entry;
      failedMap[ind] = failed;
      ind++;
    }
    fTotEnt = ind;
    fCurEnt = 0;  
    HandScanDisplay(fCurEnt);
  }
  else { //free running
    for(int i=0;i<Nentries;i++){  //Nentries is from MadBase
      entryMap[i] = i;
      failedMap[i] = -1;
    }
    fTotEnt = Nentries;
    fCurEnt = 0;  
    HandScanDisplay(fCurEnt);
  }
}

void MadHandScan::HandScanDisplay(int entry){

  if(entry>=fTotEnt) entry = 0;
  if(entry<0) entry = fTotEnt-1;
  if(!this->GetEntry(entryMap[entry])) return;
  fChainEnt = entryMap[entry];
  fCurFailed = failedMap[entry];
  r_num = ntpHeader->GetRun();
  s_num = ntpHeader->GetSnarl();

  //get canvases etc.
  TCanvas *handScanCan;
  TCanvas *handScanControlCan;
  if(!gROOT->FindObject("HandScanCan")){

    gStyle->SetOptStat(0);
    
    handScanCan = new TCanvas("HandScanCan","HandScanCan",
                              0,0,900,700);
    handScanCan->Divide(2,3);

    handScanControlCan = new TCanvas("HandScanControlCan",
                                     "HandScanControlCan",
                                     950,0,300,500);    
    handScanControlCan->cd();
    TButton *but1 = new TButton("Next","HS->fCurEnt+=1;HS->HandScanDisplay(HS->fCurEnt);",0.5,0.9,1.0,1.0);
    but1->SetTextSize(0.5);
    but1->SetFillColor(4);

    TButton *but2 = new TButton("Previous","HS->fCurEnt-=1;HS->HandScanDisplay(HS->fCurEnt);",0.0,0.9,0.5,1.0);
    but2->SetTextSize(0.5);
    but2->SetFillColor(5);

    TButton *but3a = new TButton("CHEAT","HS->Cheat();",0.0,0.6,0.5,0.7);
    but3a->SetTextSize(0.5);
    but3a->SetFillColor(3);

    TButton *but3b = new TButton("PID","HS->Pid();",0.5,0.6,1.0,0.7);
    but3b->SetTextSize(0.5);
    but3b->SetFillColor(6);

    TButton *but4 = new TButton("Vote nue","HS->Vote(1);",0.0,0.7,0.5,0.8);
    but4->SetTextSize(0.5);
    but4->SetFillColor(5);

    TButton *but5 = new TButton("Vote !nue","HS->Vote(0);",0.5,0.7,1.0,0.8);
    but5->SetTextSize(0.5);
    but5->SetFillColor(4);

    TButton *but6 = new TButton("Zoom","HS->Zoom();",0.0,0.8,0.5,0.9);
    but6->SetTextSize(0.5);
    but6->SetFillColor(5);

    TButton *but7 = new TButton("Unzoom","HS->UnZoom();",0.5,0.8,1.0,0.9);
    but7->SetTextSize(0.5);
    but7->SetFillColor(4);

    TButton *but8 = new TButton("Quit","char exit[5] = HS->exit; delete HS; gROOT->ProcessLine(exit);",0.0,0.5,1.0,0.6);
    but8->SetTextSize(0.5);
    but8->SetFillColor(45);

    but1->Draw();
    but2->Draw();
    but3a->Draw();
    but3b->Draw();
    but4->Draw();
    but5->Draw();
    but6->Draw();
    but7->Draw();
    but8->Draw();

  }
  else {
    handScanCan = (TCanvas*) gROOT->FindObject("HandScanCan");
    handScanCan->cd(1);
    uHist = (TH2F*) gPad->FindObject("uHist");
    delete uHist;
    handScanCan->cd(2);
    vHist = (TH2F*) gPad->FindObject("vHist");
    delete vHist;
    handScanCan->cd(3);
    uEMHist = (TH2F*) gPad->FindObject("uEMHist");
    delete uEMHist;
    handScanCan->cd(4);
    vEMHist = (TH2F*) gPad->FindObject("vEMHist");
    delete vEMHist;
    handScanCan->cd(5);
    uPredHist = (TH2F*) gPad->FindObject("uPredHist");
    delete uPredHist;
    handScanCan->cd(6);
    vPredHist = (TH2F*) gPad->FindObject("vPredHist");
    delete vPredHist;

    for(int i=1;i<=6;i++){
      gPad->Modified();
      gPad->Update();
    }

    handScanControlCan = (TCanvas*) gROOT->FindObject("HandScanControlCan");
    handScanControlCan->cd();
    TList *theList = handScanControlCan->GetListOfPrimitives();
    TIterator *iter = theList->MakeIterator();
    TObject *ob;      
    while((ob = iter->Next())){
      if(ob->InheritsFrom("TLatex")) {
        TLatex *tex = (TLatex*) ob;
        delete tex;
      }
    }
    TLatex *tex = new TLatex(0.1,0.4,"Calculating...");
    tex->SetTextColor(2);
    tex->SetName("calcTex");
    tex->Draw();
    gPad->Modified();
    gPad->Update();
  }

  //if we cheated last time, get rid of stdhepcanvas
  if(gROOT->FindObject("StdHepDiagramCanvas")) {
    TCanvas *can = (TCanvas*) gROOT->FindObject("StdHepDiagramCanvas");
    can->cd();    
    TList *theList = can->GetListOfPrimitives();
    TIterator *iter = theList->MakeIterator();
    TObject *ob;      
    while((ob = iter->Next())){
      if(ob->InheritsFrom("TLatex")) {
        TLatex *tex = (TLatex*) ob;
        delete tex;
      }
      else if(ob->InheritsFrom("TArrow")) {
        TArrow *ar = (TArrow*) ob;
        delete ar;
      }
      else if(ob->InheritsFrom("TMarker")) {
        TMarker *m = (TMarker*) ob;
        delete m;
      }
    }
    delete can;    
  }

  if(LoadTruth(0)){
    tru_inu = ntpTruth->inu;
    tru_iac = ntpTruth->iaction;
    tru_y = ntpTruth->y;
    shw_En = ntpTruth->p4shw[3];
    tru_En = ntpTruth->p4neu[3];
    if(tru_iac==1){
      if(tru_inu==12) lep_En = ntpTruth->p4el1[3];
      else if(tru_inu==14) lep_En = ntpTruth->p4mu1[3];
      else if(tru_inu==16) lep_En = ntpTruth->p4tau[3];
    }
    else lep_En = 0;
  }

  //get strip lists:
  TClonesArray* pointStripArray = NULL;
  if(isST) pointStripArray = (strecord->stp);
  else pointStripArray = (record->stp);
  TClonesArray& stripArray = *pointStripArray;
  maxstp_u = 0;
  minstp_u = 999;
  maxstp_v = 0;
  minstp_v = 999;
  maxpln = 0;
  minpln = 999;
  float totPE = 0;

  for(int i=0;i<int(eventSummary->nstrip);i++){
    ntpStrip = dynamic_cast<NtpSRStrip *>(stripArray[i]);
    int pln = ntpStrip->plane;
    int stp = ntpStrip->strip;
    int view = ntpStrip->planeview;
    totPE += ntpStrip->ph0.pe + ntpStrip->ph1.pe;
    if(pln>maxpln) maxpln = pln;
    if(pln<minpln) minpln = pln;
    if(view==2){
      if(stp>maxstp_u) maxstp_u = stp;
      if(stp<minstp_u) minstp_u = stp;
    }
    else {
      if(stp>maxstp_v) maxstp_v = stp;
      if(stp<minstp_v) minstp_v = stp;
    }
  }

  handScanControlCan->cd();
  if(TObject *ob = handScanControlCan->FindObject("calcTex")){
    delete ob;
  }
  char somewords[256];
  sprintf(somewords,"Entry: %i(/%i)",entry+1,fTotEnt);
  TLatex *tex = new TLatex(0.02,0.45,somewords);
  tex->Draw();
  sprintf(somewords,"Total PE: %.2f",totPE);
  tex = new TLatex(0.02,0.4,somewords);
  tex->Draw();
  

  uHist = new TH2F("uHist","All Strips - U View",
                   maxpln-minpln+1,minpln-0.5,maxpln+0.5,
                   192,-0.5,191.5);
  uHist->SetXTitle("Plane");
  uHist->SetYTitle("Strip");
  uHist->SetZTitle("Frac PH");
  vHist = new TH2F("vHist","All Strips - V View",
                   maxpln-minpln+1,minpln-0.5,maxpln+0.5,
                   192,-0.5,191.5);
  vHist->SetXTitle("Plane");
  vHist->SetYTitle("Strip");
  vHist->SetZTitle("Frac PH");

  uEMHist = new TH2F("uEMHist","CandShowerEM Strips - U View",
                     maxpln-minpln+1,minpln-0.5,maxpln+0.5,
                     192,-0.5,191.5);
  uEMHist->SetXTitle("Plane");
  uEMHist->SetYTitle("Strip");
  uEMHist->SetZTitle("Frac PH");
  vEMHist = new TH2F("vEMHist","CandShowerEM Strips - V View",
                     maxpln-minpln+1,minpln-0.5,maxpln+0.5,
                     192,-0.5,191.5);
  vEMHist->SetXTitle("Plane");
  vEMHist->SetYTitle("Strip");
  vEMHist->SetZTitle("Frac PH");

  uPredHist = new TH2F("uPredHist","Predicted Strips - U View",
                       maxpln-minpln+1,minpln-0.5,maxpln+0.5,
                       192,-0.5,191.5);
  uPredHist->SetXTitle("Plane");
  uPredHist->SetYTitle("Strip");
  uPredHist->SetZTitle("Frac PH");
  vPredHist = new TH2F("vPredHist","Predicted Strips - V View",
                       maxpln-minpln+1,minpln-0.5,maxpln+0.5,
                       192,-0.5,191.5);
  vPredHist->SetXTitle("Plane");
  vPredHist->SetYTitle("Strip");
  vPredHist->SetZTitle("Frac PH");

  for(int i=0;i<int(eventSummary->nstrip);i++){
    ntpStrip = dynamic_cast<NtpSRStrip *>(stripArray[i]);
    int pln = ntpStrip->plane;
    int stp = ntpStrip->strip;
    int view = ntpStrip->planeview;
    float pes = ntpStrip->ph0.pe+ntpStrip->ph1.pe;
    if(view==2) uHist->Fill(pln,stp,pes);
    else vHist->Fill(pln,stp,pes);      
  }

  if(uHist->Integral()>0) uHist->Scale(1./uHist->Integral());
  if(vHist->Integral()>0)vHist->Scale(1./vHist->Integral());

  if(isEM){
    int nemshw = ntpEMSummary->nshower;
    if(nemshw==1) {
      
      LoadEMShower(0);
      maxpln = 0;
      minpln = 999;
      maxstp_u = 0;
      minstp_u = 999;
      maxstp_v = 0;
      minstp_v = 999;

      float energy = ntpEMShower->ph.gev;
      float vtx_u = ntpEMShower->vtx.u;
      float vtx_v = ntpEMShower->vtx.v;
      float vtx_z = ntpEMShower->vtx.z;
      float dudz = ntpEMShower->vtx.dcosu/ntpEMShower->vtx.dcosz;
      float dvdz = ntpEMShower->vtx.dcosv/ntpEMShower->vtx.dcosz;
      int vtxview = 2;
      
      float predVtx_u = 0;
      float predVtx_v = 0;
      float predVtx_z = 0;
      float minZDist = 999;
      float minUDist = 999;
      float minVDist = 999;
      int vtxPln = 0;
      int vtxUStp = 0;
      int vtxVStp = 0;
      
      int *strips = ntpEMShower->stp;    
      for(int i=0;i<ntpEMShower->nstrip;i++){
        int index = strips[i];
        ntpStrip = dynamic_cast<NtpSRStrip *>(stripArray[index]);
        int pln = ntpStrip->plane;
        int stp = ntpStrip->strip;
        int view = ntpStrip->planeview;

        if(pln>maxpln) maxpln = pln;
        if(pln<minpln) minpln = pln;
        if(view==2){
          if(stp>maxstp_u) maxstp_u = stp;
          if(stp<minstp_u) minstp_u = stp;
        }
        else {
          if(stp>maxstp_v) maxstp_v = stp;
          if(stp<minstp_v) minstp_v = stp;
        }

        if(fabs(ntpStrip->z - vtx_z)<minZDist) {
          minZDist = fabs(ntpStrip->z - vtx_z);
          vtxview = view;
          predVtx_z = ntpStrip->z - vtx_z;
          vtxPln = pln;
        }
        if(view==2){
          if(fabs(ntpStrip->tpos - vtx_u)<minUDist) {
            minUDist = fabs(ntpStrip->tpos - vtx_u);
            predVtx_u = ntpStrip->tpos - vtx_u;
            vtxUStp = stp;
          }
        }
        else {
          if(fabs(ntpStrip->tpos - vtx_v)<minVDist) {
            minVDist = fabs(ntpStrip->tpos - vtx_v);
            predVtx_v = ntpStrip->tpos - vtx_v;
            vtxVStp = stp;
          }
        }
        
        float pes = ntpStrip->ph0.pe+ntpStrip->ph1.pe;
        if(view==2) uEMHist->Fill(pln,stp,pes);
        else vEMHist->Fill(pln,stp,pes);   
      }
      
      minpln -= 1;
      maxpln += 1;
      minstp_u -= 2;
      minstp_v -= 2;
      maxstp_u += 2;
      maxstp_v += 2;

      if(maxstp_u-minstp_u<10) {
        int diff_u = 10 - (maxstp_u-minstp_u);
        maxstp_u += diff_u/2;
        minstp_u -= diff_u/2;
      }
      if(maxstp_v-minstp_v<10) {
        int diff_v = 10 - (maxstp_v-minstp_v);
        maxstp_v += diff_v/2;
        minstp_v -= diff_v/2;
      }
      if(maxpln-minpln<8){
        int diff_p = 8 - (maxpln-minpln);
        maxpln += diff_p/2;
        minpln -= diff_p/2;
      }

      handScanControlCan->cd();
      sprintf(somewords,"ShwEM - Status: %i",ntpEMShower->status);
      tex = new TLatex(0.02,0.35,somewords);
      tex->SetTextColor(4);
      tex->Draw();
      sprintf(somewords,"Total EM PE: %.2f",ntpEMShower->ph.pe);
      tex = new TLatex(0.02,0.3,somewords);
      tex->SetTextColor(4);
      tex->Draw();
      sprintf(somewords,"Energy: %.2f",energy);
      tex = new TLatex(0.02,0.25,somewords);
      tex->SetTextColor(4);
      tex->Draw();
      sprintf(somewords,"Vtx (u,v,z): %.3f, %.3f, %.3f",
              vtx_u,vtx_v,vtx_z);
      tex = new TLatex(0.02,0.2,somewords);
      tex->SetTextColor(4);
      tex->Draw();
      sprintf(somewords,"Angles (dudz,dvdz): %.3f, %.3f",
              dudz,dvdz);
      tex = new TLatex(0.02,0.15,somewords);
      tex->SetTextColor(4);
      tex->Draw();
           
      float chi2 = 0;        
      int ndf = 0;
      
      FitterEM *fit = new FitterEM();
      fit->QuickInput(energy,predVtx_u,predVtx_v,predVtx_z,dudz,dvdz,vtxview);
      double binFluc = 1;
      for(int i=minpln;i<=maxpln;i++) {
        if(i%2==0&&i<250||i%2==1&&i>250){
          for(int j=minstp_u;j<=maxstp_u;j++) {   
            uPredHist->Fill(i,j,fit->PredictEMLoss(i-vtxPln,
                                                   j-vtxUStp,binFluc));
          }
        }
        else{
          for(int j=minstp_v;j<=maxstp_v;j++) {   
            vPredHist->Fill(i,j,fit->PredictEMLoss(i-vtxPln,
                                                   j-vtxVStp,binFluc));
          }
        }
      }

      if(uEMHist->Integral()>0)uEMHist->Scale(1./uEMHist->Integral());
      if(vEMHist->Integral()>0)vEMHist->Scale(1./vEMHist->Integral());
      if(uPredHist->Integral()>0)uPredHist->Scale(1./uPredHist->Integral());
      if(vPredHist->Integral()>0)vPredHist->Scale(1./vPredHist->Integral());

      for(int i=minpln;i<=maxpln;i++) {
        if(i%2==0&&i<250||i%2==1&&i>250){
          for(int j=minstp_u;j<=maxstp_u;j++) {   
            fit->PredictEMLoss(i-vtxPln,j-vtxUStp,binFluc);
            if(binFluc>0){
              int binx = uEMHist->GetXaxis()->FindBin(i);
              int biny = uEMHist->GetYaxis()->FindBin(j);
              float p = uPredHist->GetBinContent(binx,biny);
              float em = uEMHist->GetBinContent(binx,biny);
              chi2 += ((p-em)*(p-em))/(binFluc*binFluc);
              ndf+=1;
            }
          }
        }
        else{
          for(int j=minstp_v;j<=maxstp_v;j++) {
            fit->PredictEMLoss(i-vtxPln,j-vtxVStp,binFluc);
            if(binFluc>0){
              int binx = vEMHist->GetXaxis()->FindBin(i);
              int biny = vEMHist->GetYaxis()->FindBin(j);
              float p = vPredHist->GetBinContent(binx,biny);
              float em = vEMHist->GetBinContent(binx,biny);
              chi2 += ((p-em)*(p-em))/(binFluc*binFluc);
              ndf+=1;
            }
          }
        }
      }
      delete fit;      
      sprintf(somewords,"Chi2/NDF: %.3f / %i",chi2,ndf);
      tex = new TLatex(0.02,0.1,somewords);
      tex->SetTextColor(2);
      tex->Draw();
    }
  }

  for(int i=1;i<=6;i++) {
    handScanCan->cd(i);
    gPad->SetTheta(30.0);
    gPad->SetPhi(30.0);
  }
  
  handScanCan->cd(1);
  uHist->Draw("LEGO2");
  gPad->Modified();
  gPad->Update();
  
  handScanCan->cd(2);
  vHist->Draw("LEGO2");
  gPad->Modified();
  gPad->Update();

  handScanCan->cd(3);
  uEMHist->Draw("LEGO2");
  gPad->Modified();
  gPad->Update();

  handScanCan->cd(4);  
  vEMHist->Draw("LEGO2");
  gPad->Modified();
  gPad->Update();
  
  handScanCan->cd(5);
  uPredHist->Draw("LEGO2");
  gPad->Modified();
  gPad->Update();

  handScanCan->cd(6);
  vPredHist->Draw("LEGO2");
  gPad->Modified();
  gPad->Update();

  handScanControlCan->cd();
  
}

void MadHandScan::Vote(int val){

  if(abs(tru_inu)==12&&tru_iac==1) { //if it really is a nue
    if(val==1) isNue = 1;  //and the vote was for nue, then fill tree with 1
    else isNue = 0;  //otherwise with 0
  }
  else {  //if it wasn't really a nue
    if(val==1) isNue = 0; //and the vote was for nue, then fill tree with 0
    else isNue = 1; //otherwise with 1
  }
  quizTree->Fill();
  fCurEnt+=1;
  HandScanDisplay(fCurEnt);

}

void MadHandScan::Cheat(){

  Pid();

  DrawInteractionDiagram(0);
  TCanvas *can = (TCanvas*) gROOT->FindObject("HandScanControlCan");
  can->cd();
  char sometext[256];
  sprintf(sometext,"Truth  - Nu: %i, NC/CC: %i, y: %.2f",
          tru_inu,tru_iac,tru_y);
  TLatex *tex = new TLatex(0.02,0.06,sometext);
  tex->SetTextColor(8);
  tex->Draw();
  sprintf(sometext,"Energy - Nu: %.2f",tru_En);
  if(tru_iac==0){
    sprintf(sometext,"%s, Shw: %.2f",sometext,shw_En); 
  }
  else if(tru_iac==1){
    if(tru_inu==12) sprintf(sometext,"%s, e: %.2f",
                            sometext,ntpTruth->p4el1[3]);
    if(tru_inu==14) sprintf(sometext,"%s, #mu: %.2f",
                            sometext,ntpTruth->p4mu1[3]);
    if(tru_inu==16) sprintf(sometext,"%s, #tau: %.2f",
                            sometext,ntpTruth->p4tau[3]);
  }
  sprintf(sometext,"%s GeV",sometext);
  tex = new TLatex(0.02,0.01,sometext);
  tex->SetTextColor(8);
  tex->Draw();

}

void MadHandScan::Pid(){
  
  if(fCurFailed!=0&&fCurFailed!=1) return; //no PID for this set of events
  TCanvas *can = (TCanvas*) gROOT->FindObject("HandScanControlCan");
  can->cd();
  char sometext[256];
  if(abs(tru_inu)==12 && tru_iac==1) {
    if(fCurFailed) sprintf(sometext,"PID = NOT #nu_{e}");
    else sprintf(sometext,"PID = #nu_{e}");
  }
  else {
    if(fCurFailed) sprintf(sometext,"PID = #nu_{e}");
    else sprintf(sometext,"PID = NOT #nu_{e}");
  }
  TLatex *tex = new TLatex(0.6,0.45,sometext);
  tex->SetTextColor(6);
  tex->Draw();
  
}

void MadHandScan::Zoom(){

  uHist->SetAxisRange(minpln,maxpln,"X");
  vHist->SetAxisRange(minpln,maxpln,"X");
  uEMHist->SetAxisRange(minpln,maxpln,"X");
  vEMHist->SetAxisRange(minpln,maxpln,"X");
  uPredHist->SetAxisRange(minpln,maxpln,"X");
  vPredHist->SetAxisRange(minpln,maxpln,"X");

  uHist->SetAxisRange(minstp_u,maxstp_u,"Y");
  vHist->SetAxisRange(minstp_v,maxstp_v,"Y");
  uEMHist->SetAxisRange(minstp_u,maxstp_u,"Y");
  vEMHist->SetAxisRange(minstp_v,maxstp_v,"Y");
  uPredHist->SetAxisRange(minstp_u,maxstp_u,"Y");
  vPredHist->SetAxisRange(minstp_v,maxstp_v,"Y");

  TCanvas *can = (TCanvas*) gROOT->FindObject("HandScanCan");  
  for(int i=1;i<=6;i++) {
    can->cd(i);
    gPad->Modified();
    gPad->Update();
  }
  ((TCanvas*)gROOT->FindObject("HandScanControlCan"))->cd();
}

void MadHandScan::UnZoom(){

  uHist->GetXaxis()->UnZoom();
  vHist->GetXaxis()->UnZoom();
  uEMHist->GetXaxis()->UnZoom();
  vEMHist->GetXaxis()->UnZoom();
  uPredHist->GetXaxis()->UnZoom();
  vPredHist->GetXaxis()->UnZoom();

  uHist->SetAxisRange(0.,191.,"Y");
  vHist->SetAxisRange(0.,191.,"Y");
  uEMHist->SetAxisRange(0.,191.,"Y");
  vEMHist->SetAxisRange(0.,191.,"Y");
  uPredHist->SetAxisRange(0.,191.,"Y");
  vPredHist->SetAxisRange(0.,191.,"Y");
  
  TCanvas *can = (TCanvas*) gROOT->FindObject("HandScanCan");  
  for(int i=1;i<=6;i++) {
    can->cd(i);
    gPad->Modified();
    gPad->Update();
  }
  ((TCanvas*)gROOT->FindObject("HandScanControlCan"))->cd();
}

#endif // #ifdef madhandscan_cxx

---