// Author: Gero Flucke <mailto:flucke@mail.desy.de>
//____________________________________
// GFDstarHistsAnalysisData
//   Author:      Gero Flucke
//   Date:        June 2nd, 2002
//   last update: $Date: 2005/06/13 15:10:07 $ 
//   by:          $Author: flucke $
//

#include <iostream>

#include <TFile.h>
#include <TH1.h>
#include <TH2.h>
#include <TGraphAsymmErrors.h>
#include <TString.h>
#include <TAxis.h>
#include <TCanvas.h>
#include <TObjArray.h>

#include "GFAnalysis/GFDstarHistsAnalysisData.h"
#include "GFAnalysis/GFAxisVariables.h"
#include "GFUtils/GFHistManager.h"
#include "GFUtils/GFHistArray.h"
#include "GFUtils/GFHistManip.h"
#include "GFUtils/GFMath.h"
#include "GFAnalysis/GFDstarCount.h"
#include "/afs/desy.de/user/f/flucke/h1/root/DstarDmFitter/DstarDmFitter.h"

using namespace std;

ClassImp(GFDstarHistsAnalysisData)

 GFDstarHistsAnalysisData::GFDstarHistsAnalysisData(const char* dataFileIn) 
  : GFDstarHistsAnalysis(dataFileIn), fL4Eff(2)
{
  //  fPeriod = "Data";
  TString file(dataFileIn);
  fPeriod = "Data";
  if(file.Contains("2000")) fPeriod += ": 2000";
  if(file.Contains("99ePlus")) fPeriod += ": 99e+";
}


//____________________________________
 GFDstarHistsAnalysisData::GFDstarHistsAnalysisData(const char* prefix, 
						   const char* period) 
  : GFDstarHistsAnalysis(prefix, period), fL4Eff(2)
{

  TString periodString(period);
  fPeriod = "Data";
  if(periodString.Contains("2000")) fPeriod += ": 2000";
  if(periodString.Contains("99ePlus")) fPeriod += ": 99e+";

}


//____________________________________
 GFDstarHistsAnalysisData::~GFDstarHistsAnalysisData()
{
  // no further clean up necessary!
}

//____________________________________
 void GFDstarHistsAnalysisData::SetTrigger(Int_t trigger) 
{
  if(fTrigger != trigger){
    fL4Eff[0] = fL4Eff[1] = 0.;
  }
  this->GFDstarHistsAnalysis::SetTrigger(trigger);
}

//____________________________________
 TArrayD GFDstarHistsAnalysisData::DrawDmFitWc()
{
  // var: pt, eta, phi, wGammaP
  fHistManager->Clear();

  TH1* h = this->GetHistPtCut();
  TH1* hWc = this->GetHistPtCutWc();

//   const Int_t fitModeAll = fMultiDmFitter->GetFitModeAll();
//   fMultiDmFitter->SetFitModeAll(-1);
//   fDstarFitter->Fit(-1, hist1);
  TArrayD array = fMultiDmFitter->FitAll(h, hWc);
  fHistManager->AddHist(h);
  h->SetOption("e");
  fHistManager->Draw();
  
  return array;
}

//____________________________________
 TH1* GFDstarHistsAnalysisData::DrawDmFitWc(const char* var)
{
  // var: pt, eta, phi, wGammaP
  fHistManager->Clear();
  fHist2D = this->GetHist2D(var);
  TH2* hist2DWc = this->GetHist2DWc(var);
  fHist1D = this->GetHistPtCut();
  
  return this->DrawDmVariable(GFAxisVariables::GetAxisLabel(var), 
			      hist2DWc, this->GetHistPtCutWc());
}

//____________________________________
 void GFDstarHistsAnalysisData::DrawDmWc(Option_t* drawOpt)
{
//   fDstarFitter->ResetFitParameters();
  fHistManager->Clear();

  TH1* hist1 = this->GetHistPt1CutWc();
  TH1* hist2 = this->GetHistPt2CutWc();
  
  const Int_t fitModeAll = fMultiDmFitter->GetFitModeAll();
  fMultiDmFitter->SetFitModeAll(-1);
//   fDstarFitter->Fit(-1, hist1);
  fMultiDmFitter->FitAll(hist1);
  fHistManager->AddHist(hist1);

//   fDstarFitter->Fit(-1, hist2);
  fMultiDmFitter->FitAll(hist2);
  fHistManager->AddHist(hist2);

  fHistManager->SetHistsOption(drawOpt);
  fHistManager->SetHistsXTitle("m(K#pi#pi_{s}) - m(K#pi) [GeV]");
  fHistManager->Draw();
  this->SetHistPointerNull();

  fMultiDmFitter->SetFitModeAll(fitModeAll);
}

//____________________________________
 TH1* GFDstarHistsAnalysisData::DrawAccept(const char* varName)
{
//   // Pt,Phi,Eta,WgammaP

  fHistNumDstar = this->GetHistAcceptNom(varName);
  fHist1D = this->GetHistAccept(varName);
  if(!fHist1D || !fHistNumDstar || fHist1D->GetDimension() != fHistNumDstar->GetDimension()){
    return NULL;
  }
  fHistManager->Clear();

  if(fHist1D->GetDimension() == 2){
    TH1* hRef = this->GetHistPtCut();
    fHistNumDstar = fMultiDmFitter->Fit(static_cast<TH2*>(fHistNumDstar), hRef);
    fHistManager->AddHists(fMultiDmFitter->GetHists1D(), 4);
    fHistManager->AddHist(fMultiDmFitter->GetHistSignalBack(), 4);
//     fMultiDmFitter->GetHists1D()->Delete();
//     delete fMultiDmFitter->GetHistSignalBack();
    fHist1D = fMultiDmFitter->Fit(static_cast<TH2*>(fHist1D), hRef);
    fHistManager->AddHists(fMultiDmFitter->GetHists1D(), 5);
    fHistManager->AddHist(fMultiDmFitter->GetHistSignalBack(), 5);
//     fMultiDmFitter->GetHists1D()->Delete();
//     delete fMultiDmFitter->GetHistSignalBack();
  }

  TString name("acceptance");
  this->MakeStringName((name+=varName)+=fTrigger);
//   this->DeleteObject(name);

  fHistManager->AddHist(static_cast<TH1*>(fHistNumDstar->Clone(name+"Num")));

  fHistNumDstar->Divide(fHist1D);
  TString title("#bar{A_{ET");
  fHistNumDstar->SetTitle(title += (fTrigger == 83 ? "33}}" : "44}}"));
  fHistNumDstar->SetXTitle(GFAxisVariables::GetAxisLabel(varName));
  fHistManager->AddHist(fHist1D);





  TAxis* helpXaxis = fHistNumDstar->GetXaxis();
//   this->DeleteObject(name+="Total");
  fHist1D = new TH1F(name, title+=" (total)", 1,
		     helpXaxis->GetBinLowEdge(helpXaxis->GetFirst()),
		     helpXaxis->GetBinUpEdge(helpXaxis->GetLast()));
  TArrayD acceptErr = this->TotalAccept();
  fHist1D->SetBinContent(1, acceptErr[0]);
  fHist1D->SetBinError(1, acceptErr[1]);
//   fHist1D->SetDrawOption("E2");
//   fHist1D->SetFillColor(kYellow);
  fHist1D->SetLineColor(kRed);
  fHistManager->AddHist(fHistNumDstar,1, "bins");
  fHistManager->AddHistSame(fHist1D,1, 0, "mean");
  fHistManager->Draw();
  TH1* h = fHistNumDstar;
  this->SetHistPointerNull();

  title = "tagger acceptance from Data in bins of ";
  this->PrintTable(h, title += varName); 
  return h;
}


//________________________________________________
 TH1* GFDstarHistsAnalysisData::CreateTrigEff(const char* variable, Int_t TE)
{
  // pt eta phi wGammaP y, TE 19, 31 or other (other == 19 && 31)
  TString var(variable);
  TString numTE;
  if(TE>=0) numTE += TE; else numTE += "19+31";
  
  TH1* hAll = this->GetHist(var+"HistNonTrig");
  TH1* hTriggered = this->GetHist(TE==-1?var+"HistTrig":var+"HistTrig"+numTE);

  if(!hAll || ! hTriggered) return NULL;

  fHistManager->Clear();
  fHistManager->AddHist(hTriggered);
  fHistManager->AddHist(hAll);

  TString effHistName("effTE");
  if(TE >= 0) effHistName += numTE;
  else effHistName += "19+31";
  this->MakeStringName((effHistName+=var).operator+=(fTrigger));
  TGraphAsymmErrors *grPtr = NULL;
  TH1* hEff = GFHistManip::CreateRatioBinomErrors(hTriggered, hAll, NULL, NULL, NULL, &grPtr);
  if(hEff){
    hEff->SetName(effHistName);
  } else {
    this->Warning("CreateTrigEff", "Cannot do correct errors from binomial!");
    hEff = static_cast<TH1*>(hTriggered->Clone(effHistName));
    hEff->Reset();
    if(hEff->GetSumw2N() == 0) hEff->Sumw2();
    hEff->Divide(hTriggered, hAll, 1., 1., "B");
  }

  hEff->SetXTitle(GFAxisVariables::GetAxisLabel(variable));
  TString title("#epsilon_{trig}, TE ");
  title += numTE;
  hEff->SetTitle(title);
  hEff->SetYTitle("#epsilon_{trig}");

  fHistManager->AddHist(hEff, 1);
  if(grPtr){
//     hEff->SetOption("HIST");
    hEff->TAttLine::Copy(*grPtr);
    hEff->TAttMarker::Copy(*grPtr);
    fHistManager->AddObject(grPtr, 1, 0, "P");
  }
  this->TmpGraph(grPtr);
  fHistManager->Draw();
  hEff->SetDrawOption("HIST");

  this->CheckTrigEff(hEff, TE);

  ((title += " from ")+=fPeriod) += " in bins of ";
  this->PrintTable(hEff, title+=variable);

  return hEff;
}


//____________________________________
 TH1* GFDstarHistsAnalysisData::CreateDedxEff(const char* var)
{
  //pt,eta,phi,ptSumEt,wGammaP,y,nTrack
  TH1* hRef = this->GetHistPtCut();
  TH2* hAll2D = static_cast<TH2*>(this->GetHist(Form("%sHisteffDedx", var), "effDedx"));
  TH2* hSurvive2D = this->GetHist2D(var);
  if(!hRef || !hSurvive2D || !hAll2D) return NULL;

  fHistManager->Clear();

  hSurvive2D->SetYTitle(var);// also for title in single hists!
  TH1* hSurvive = fMultiDmFitter->Fit(hSurvive2D, hRef);
  fHistManager->AddHists(fMultiDmFitter->GetHists1D(),0);
  fHistManager->AddHist(fMultiDmFitter->GetHistSignalBack(),0);
  fHistManager->AddHist(hSurvive2D,0);


  hAll2D->SetYTitle(var);// also for title in single hists!
  TH1* hAll = fMultiDmFitter->Fit(hAll2D, hRef);
  fHistManager->AddHists(fMultiDmFitter->GetHists1D(),1);
  fHistManager->AddHist(fMultiDmFitter->GetHistSignalBack(),1);
  fHistManager->AddHist(hAll2D,1);

  TH1* hEff = GFHistManip::CreateRatioGassnerErrors(hSurvive, hAll);
  hEff->SetTitle(Form("#epsilon_{dEdx};%s", GFAxisVariables::GetAxisLabel(var)));
  fHistManager->AddHist(hEff, 2);

  fHistManager->Draw();
  return hEff;
}

//____________________________________
 TH1* GFDstarHistsAnalysisData::CreateDedxEff2(const char* var)
{
  //  Theta, Length, Nhit, PK, P + K, Pi
  TH1* hRef = this->GetHistPtCut();
  TH2* hAll2D = static_cast<TH2*>(this->GetHist(Form("%sDedxEffRef", var), 
						"effDedx"));
  TH2* hSurvive2D = static_cast<TH2*>(this->GetHist(Form("%sDedxEff", var), 
						    "effDedx"));
  TH2* tmp = hAll2D;
  hAll2D = hSurvive2D;
  hSurvive2D = tmp;

  if(!hRef || !hSurvive2D || !hAll2D) return NULL;

  fHistManager->Clear();

  hSurvive2D->SetYTitle(var);// also for title in single hists!
  TH1* hSurvive = fMultiDmFitter->Fit(hSurvive2D, hRef);
  fHistManager->AddHists(fMultiDmFitter->GetHists1D(),0);
  fHistManager->AddHist(fMultiDmFitter->GetHistSignalBack(),0);
  fHistManager->AddHist(hSurvive2D,0);


  hAll2D->SetYTitle(var);// also for title in single hists!
  TH1* hAll = fMultiDmFitter->Fit(hAll2D, hRef);
  fHistManager->AddHists(fMultiDmFitter->GetHists1D(),1);
  fHistManager->AddHist(fMultiDmFitter->GetHistSignalBack(),1);
  fHistManager->AddHist(hAll2D,1);

  TH1* hEff = GFHistManip::CreateRatioGassnerErrors(hSurvive, hAll);
  hEff->SetTitle(Form("#epsilon_{dEdx};%s", GFAxisVariables::GetAxisLabel(var)));
  fHistManager->AddHist(hEff, 2);

  fHistManager->Draw();
  return hEff;
}

//____________________________________
 void GFDstarHistsAnalysisData::DrawTrigRefVsDm(const char* varName)
{
  const Bool_t oldBatch = fHistManager->SetBatch(kTRUE);
  const Double_t scaleAll = this->DrawDm().At(0);
  TH1* hAll = this->DrawDm(varName, kFALSE); // not per bin width!
  TH1* hTrigRef = this->GetHist(Form("%sHistNonTrig", varName));
  fHistManager->SetBatch(oldBatch);

  if(!hTrigRef || !hAll) return;
  const Double_t scaleTrig = hTrigRef->GetEntries();
  GFHistManip::Scale(hTrigRef, scaleTrig ? 1./scaleTrig : 0.);
  GFHistManip::Scale(hAll, scaleAll ? 1./scaleAll : 0.);
  fHistManager->AddHist(hAll, 5, "All");
  fHistManager->AddHistSame(hTrigRef, 5, 0, "trigger reference");
  
  fHistManager->Draw();
}

//________________________________________________
 void GFDstarHistsAnalysisData::CheckTrigEff(TH1* hEff, Int_t TE)
{
  for(Int_t bin = 1; bin <= hEff->GetNbinsX(); ++bin){
    if(!hEff->GetBinError(bin)){
      //FIXME: 
      this->Warning("CheckTrigEff", "error = 0 in bin %d!", bin);
//       TArrayD ar = this->TotalTrigEff(TE);
//       Double_t oldCont = hEff->GetBinContent(bin);
//       hEff->SetBinContent(bin, (ar[0]+oldCont)/2.);
//       hEff->SetBinError(bin, TMath::Abs(ar[0]-oldCont)/2.);
//       this->Warning("CheckTrigEff", "Set EffTrig from %f to %f in bin %d!",
// 		    oldCont, (ar[0]+oldCont)/2., bin);
    }
  }
}

//________________________________________________
 TArrayD GFDstarHistsAnalysisData::TotalTrigEff(Int_t TE)
{
  TString numTE;
  if(TE != -1) numTE += TE;
  
  const Int_t numTrig = (Int_t)this->GetHist(TString("etaHistTrig")+=numTE)->Integral();
  const Int_t numAll  = (Int_t)this->GetHist("etaHistNonTrig")->Integral();

  TArrayD result(4);

  result[0] = numAll ? numTrig/((Double_t)numAll) : 0.;
  result[1] = numAll ? TMath::Sqrt(result[0] * (1.- result[0])/numAll) : 0.;
  result[2] = GFMath::BinomialError(numTrig, numAll, kTRUE); // up
  result[3] = -GFMath::BinomialError(numTrig, numAll, kFALSE);// down

  TString text("Total trigger eff. from data ");
  if(TE != -1) (text += "(TE ") += numTE += ") ";
  this->PrintPlusMinus(result, text += fPeriod);
  return result;
}

//________________________________________________
 TArrayD GFDstarHistsAnalysisData::TotalAccept()
{
  // error like in Dirks Diploma thesis!
  TArrayD result(2);

    TH1* hNom = this->GetHistAcceptNom("eta");
    TH1* histOfWeights = this->GetHistAccept("eta");
    if(histOfWeights->GetDimension() == 2 && hNom->GetDimension() == 2){
      TH1* hNom1D = static_cast<TH2*>(hNom)->ProjectionX(hNom->GetName());
      TH1* histOfWeights1D = static_cast<TH2*>(histOfWeights)
	->ProjectionX(histOfWeights->GetName(), -1, -1, "E");
      TString oldFitOption = fMultiDmFitter->GetDstarDmFitter()->GetFitOption();
      TString newFitOption = oldFitOption.ReplaceAll("L", NULL).ReplaceAll("l", NULL);
      fMultiDmFitter->GetDstarDmFitter()->SetFitOption(newFitOption);
      const TArrayD totalPlusErr = fMultiDmFitter->FitAll(hNom1D);
      const TArrayD sumWeightsPlusErr = fMultiDmFitter->FitAll(histOfWeights1D);
      fMultiDmFitter->GetDstarDmFitter()->SetFitOption(oldFitOption);
      result = GFMath::EfficiencyGassnerError(totalPlusErr[0], sumWeightsPlusErr[0], 
					      totalPlusErr[1], sumWeightsPlusErr[1]);
    } else {
      Double_t totalNum = hNom->GetEntries();
      Double_t sumWeights = histOfWeights->Integral();
      Double_t sumWeightsSquare = 0.;
      for(Int_t i = 1; i <= histOfWeights->GetSumw2N(); ++i){
	const Double_t error = histOfWeights->GetBinError(i);
	sumWeightsSquare += (error*error);
      }
      result[0] = sumWeights ? totalNum/sumWeights : 0;
      result[1] = sumWeights ? ((result[0] * sumWeightsSquare / (sumWeights * sumWeights))
				- 1. /sumWeights) * result[0] : 0.;
      result[1] = TMath::Sqrt(result[1]);
    }

  this->PrintPlusMinus(result, "Total acceptance from data");
  return result;
}

//________________________________________________
 TArrayD GFDstarHistsAnalysisData::L4Efficiency(Int_t mode)
{
  // only mode = 0: total eff from overall D* sample
  // foreseen: D* + 1 jet (Back, Forw, all)
  if(mode != 0){
    this->Warning("L4Efficiency", "Only mode 0 supported, request is %d", mode);
  } else if(fL4Eff[0]){
    return fL4Eff;
  }
  //  DstarDmFitter dstarFitter;
  fHistManager->Clear();

  TH1* dmHist = this->GetHistPtCut();
//   dstarFitter.FitAll(dmHist);
  fMultiDmFitter->FitAll(dmHist);

  // D*-wise calculation
  TH1* histAll = this->GetHist("L4effDstar");
  TH1* histL4Found = this->GetHist("L4effDstarTrig");

  TArrayD numDstarErr = fMultiDmFitter->FitSingle(histL4Found, NULL);
  TArrayD numDstarErrAll = fMultiDmFitter->FitSingle(histAll, NULL);

  fHistManager->AddHist(histL4Found);
  fHistManager->AddHist(histAll);
  fHistManager->SetHistsOption("e");

  // signal region
  Double_t signal = this->CountSignal(histAll, kFALSE).At(0); // no background subtraction
  Double_t signalL4Found = this->CountSignal(histL4Found, kFALSE).At(0);// dito
  TArrayD result(2);
  result[0] = signalL4Found/signal;
  result[1] = TMath::Sqrt(result[0] * (1-result[0]) / signal);
  this->PrintPlusMinus(result, "L4-efficiency counting SR (NOT USED)");
  // all delta m
//   signal = histAll->GetEntries();
//   signalL4Found = histL4Found->GetEntries();
//   Double_t resultAllDm = signalL4Found/signal;
//   cout << "D* L4 eff.:n up to delta m = " << kStartDmBackgr << ": " 
//        << result[0] << "+-" << result[1] 
//        << ",n all delta m            : " << resultAllDm << "+-" 
//        << TMath::Sqrt(resultAllDm * (1-resultAllDm) / signal)
//        << endl;
  // event wise calculation
//   histAll = this->GetHist("L4effEvent");
//   histL4Found = this->GetHist("L4effEventTrig");

//   histL4Found->Divide(histL4Found, histAll,1., 1., "B");
//   result[0] = histL4Found->GetBinContent(1);
//   result[1] = histL4Found->GetBinError(1);

  fHistManager->SetHistsXTitle("m(K#pi#pi_{s}) - m(K#pi) [GeV]");
  fHistManager->Draw();

  result = GFMath::X1ThroughX2CorrErr(numDstarErr[0], numDstarErrAll[0], 
				      numDstarErr[1], numDstarErrAll[1]);
  this->PrintPlusMinus(result, "L4-efficiency from fit via 100% corr error (NOT USED)");

  result = GFMath::EfficiencyTestError(numDstarErr[0], numDstarErrAll[0], 
					  numDstarErr[1], numDstarErrAll[1]);
  this->PrintPlusMinus(result, "L4-efficiency from fit test error (NOT USED)");

  result = GFMath::X1ThroughX2BinomErr(numDstarErr[0], numDstarErrAll[0]);
  this->PrintPlusMinus(result, "L4-efficiency from fit via binom error (NOT USED)");

  result = GFMath::EfficiencyGassnerError(numDstarErr[0], numDstarErrAll[0], 
					  numDstarErr[1], numDstarErrAll[1]);
  this->PrintPlusMinus(result, "L4-efficiency from fit Gassner error (NOT USED)");

  result = GFMath::EfficiencyBlobelError(numDstarErr[0], numDstarErrAll[0], 
					  numDstarErr[1], numDstarErrAll[1]);
  this->PrintPlusMinus(result, "L4-efficiency from fit Blobel error (USED)");

//   if(result[0] > 1.){
//     this->Info("L4Efficiency", "changing result (not error) from %f to 1.", result[0]);
//     result[0] = 1.;
//   }
  this->Info("L4Efficiency", "changing result 'by hand'");
  result[0] = 0.98;
  result[1] = 0.98 * 0.02;
  this->PrintPlusMinus(result, "L4-efficiency 'by hand' (REALLY USED)");

  fL4Eff[0] = result[0];
  fL4Eff[1] = result[1];

  return result;
}


//____________________________________
 void GFDstarHistsAnalysisData::DrawYresolution(const char* var) // Pt, Eta, Phi, WgammaP, Yjb, Ytag
{
  if(fTrigger != 83) {
    this->Warning("DrawYresolution", "Doesn't work for trigger %d", fTrigger);
    return;
  }
  this->GFDstarHistsAnalysis::DrawYresolution(var);
}

//________________________________________________
 TH1* GFDstarHistsAnalysisData::GetHistPt1CutWc()
{
  return this->GetHist("dmHist1Wc");
}

//________________________________________________
 TH1* GFDstarHistsAnalysisData::GetHistPt2CutWc()
{
  return this->GetHist("dmHist2Wc");
}

//________________________________________________
 TH1* GFDstarHistsAnalysisData::GetHistPtCutWc()
{
  // gives histPt1/Cut or ptHist2Cut corresponding to trigger!
  return this->GetTrigger() == 83 ? this->GetHistPt2CutWc()
                                  : this->GetHistPt1CutWc();
}

//________________________________________________
 TH2* GFDstarHistsAnalysisData::GetHist2DWc(const char* variable)
{
  // "eta", "pt", "phi" or "wGammaP"
  TString var(variable);
  return static_cast<TH2*>(this->GetHist(var+="Hist2DWc"));
}

//________________________________________________
 TH1* GFDstarHistsAnalysisData::GetHistAccept(const char* variable)
{
  // "eta", "pt", "phi" or "WgammaP", etc.

  // old:"Eta", "Pt", "Phi" or "WgammaP"
  if(fTrigger != 83 && fTrigger != 84){
    this->Warning("GetHistAccept", 
		  "Acceptance histogram for fTrigger = %d senseless",fTrigger);
  }
  TH1* result = this->GetHist(TString(variable)+="HistAccept", "accept");
  if(!result){
    // old name
    this->Info("GetHistAccept", "%s, try old name", variable);
    TString var(variable);
    if(var == "pt") var = "Pt";
    else if(var == "eta") var = "Eta";
    else if(var == "phi") var = "Phi";
    else if(var == "wGammaP") var = "WgammaP";
    return this->GetHist(TString("acceptHist")+=var);
  }
  return result;
}

//________________________________________________
 TH1* GFDstarHistsAnalysisData::GetHistAcceptNom(const char* variable)
{
  // "eta", "pt", "phi" or "WgammaP", etc.

  // old:"Eta", "Pt", "Phi" or "WgammaP"
  if(fTrigger != 83 && fTrigger != 84){
    this->Warning("GetHistAcceptNom", 
		  "Acceptance histogram for fTrigger = %d senseless",fTrigger);
  }
  TH1* result = this->GetHist(TString(variable)+="HistAcceptNom", "accept");
  if(!result){
    // old name
    this->Info("GetHistAcceptNom", "%s, try old name", variable);
    TString var(variable);
    if(var == "pt") var = "Pt";
    else if(var == "eta") var = "Eta";
    else if(var == "phi") var = "Phi";
    else if(var == "wGammaP") var = "WgammaP";
    return this->GetHist(TString("acceptHistNom")+=var);
  }
  return result;
}