//////////////////////////////////////////////////////////////////////////
//                                                                      //
// GFDstarPythia                                                      //
//                                                                      //
//                                                                      //
//   Author:      Gero Flucke                                           //
//   Date:        Jan 6th, 2005                                         //
//   last update: $Date: 2005/11/07 18:47:03 $
//   by:          $Author: flucke $
//                                                                      //
//////////////////////////////////////////////////////////////////////////

#include <TObjString.h>

#include "GFDstarPythia.h"
#include "GFAnalysis/GFDstarHistsAnalysisMc.h"

#include "GFUtils/GFHistManip.h"
#include "GFUtils/GFHistArray.h"

ClassImp(GFDstarPythia)

////////////////////////////////////////////////////////////
 GFDstarPythia::GFDstarPythia(const char *histMcLabel)
{
  fMc = new GFDstarHistsAnalysisMc(histMcLabel, "Pythia");
  fMc->SetBatch();
  fMcDir = new GFDstarHistsAnalysisMc(histMcLabel, "DirCharm");
  fMcDir->SetBatch();
  fMcRes = new GFDstarHistsAnalysisMc(histMcLabel, "ResCharmA");
  fMcRes->SetBatch();
  fMcExc = new GFDstarHistsAnalysisMc(histMcLabel, "CharmEx");
  fMcExc->SetBatch();
}

////////////////////////////////////////////////////////////
 GFDstarPythia::~GFDstarPythia()
{
  delete fMc;
  delete fMcDir;
  delete fMcRes;
  delete fMcExc;
}

//  virtual void DrawHists(const char *var, Int_t flag, Bool_t rel = kFALSE);

//_________________________________________________________
 GFHistArray* GFDstarPythia::CreateHistsFinalNorm(const char *var, 
						 Int_t dirResFlag)
{
  // < 0 res, > 0 dir 
  TObjArray upDowns;
  upDowns.SetOwner();
  upDowns.Add(new TObjString(""));
  // no variations!

  return this->CreateHistsFinalNormInt(var, upDowns, dirResFlag);
}

////////////////////////////////////////////////////////////
 TArrayD  GFDstarPythia::TotalCrossSec(ECrossSecType dstarJet, Int_t dirResFlag)
{
  // < 0 res, > 0 dir,  == 0 complete
  if(dirResFlag > 0){
    if (dstarJet == 1) return fMcDir->XSectionTotDsJet("");
    else if(dstarJet == 2) return fMcDir->XSectionTotDsDiJet();
    else return fMcDir->XSectionTot();
  } else if(dirResFlag == 0){
    if (dstarJet == 1) return fMc->XSectionTotDsJet("");
    else if(dstarJet == 2) return fMc->XSectionTotDsDiJet();
    else return fMc->XSectionTot();
  } else {
    if (dstarJet == 1) {
      TArrayD res = fMcRes->XSectionTotDsJet("");
      TArrayD exc = fMcExc->XSectionTotDsJet("");
      TArrayD result(2);
      result[0] = res[0] + exc[0]; // ignore error
      return result;
    } else if (dstarJet == 2) {
      TArrayD res = fMcRes->XSectionTotDsDiJet();
      TArrayD exc = fMcExc->XSectionTotDsDiJet();
      TArrayD result(2);
      result[0] = res[0] + exc[0]; // ignore error
      return result;
    } else {
      TArrayD res = fMcRes->XSectionTot();
      TArrayD exc = fMcExc->XSectionTot();
      TArrayD result(2);
      result[0] = res[0] + exc[0]; // ignore error
      return result;
    }
  }
}

////////////////////////////////////////////////////////////
 GFHistArray* GFDstarPythia::CreateHistsFinal(const char *var, Int_t dirResFlag)
{
//   return this->CreateHistsUpDown(var, "", "", dirResFlag); // we have no error bars...
  GFHistArray *result = new GFHistArray(3);
  TH1 *h = NULL;
  if(dirResFlag == 0){
    h = this->CreateHist(var, "");
  } else if(dirResFlag < 0){
    h = this->CreateHistRes(var, "");
  } else if(dirResFlag > 0){
    h = this->CreateHistDir(var, "");
  }
  result->AddAt(NULL, 0);
  result->AddAt(h, 1);
  result->AddAt(NULL, 2);
  return result;
}


////////////////////////////////////////////////////////////
 TH1* GFDstarPythia::CreateHistFrom(const char *var, const char *note, GFDstarHistsAnalysisMc *mc) const
{
  if(!mc) return NULL;
  if(TString(note) != "") this->Warning("CreateHistFrom", "Ignore note '%s'", note);

  TH1 *hResult = NULL;
  switch(this->IsDsJetOrDs(var)){
  case GFDstarVirtualTheory::kInclusive: 
    hResult = mc->XSection(var);
    break;
  case GFDstarVirtualTheory::kDstarJet:
    hResult = mc->XSectionDsJet(var, "");
    break;
  case GFDstarVirtualTheory::kDiJet:
    hResult = mc->XSectionDsDiJet(var);
    break;
  case GFDstarVirtualTheory::kInclDoubleDiff:
    {
      TString var1, var2;
      Int_t bin1 = -1, bin2 = -1;
      if(this->DecodeDoubleDiff(var, var1, var2, bin1, bin2)){
	hResult = mc->XSection(var1, var2, bin1, bin2);
      } else {
	this->Error("CreateHistFrom", "Could not decode %s for incl. double diff.", var);
      }
    }
    break;
  case kUnknown:
    this->Error("CreateHistFrom", "kUnkown from IsDsJetOrDs");
  }

  if(hResult) {
    hResult->SetDirectory(NULL);// cf. below                    // no sumw2, but fill
    hResult = GFHistManip::CreateAnalog(hResult, hResult->GetName(), kFALSE, kTRUE);
    hResult->SetDirectory(NULL);
  }
  mc->GetHistManager()->Delete();// will delete the first hResult

  return hResult;
}

////////////////////////////////////////////////////////////
 TH1* GFDstarPythia::CreateHist(const char *var, const char *note)
{

  return this->CreateHistFrom(var, note, fMc);
}

////////////////////////////////////////////////////////////
 TH1* GFDstarPythia::CreateHistDir(const char *var, const char *note)
{

  return this->CreateHistFrom(var, note, fMcDir);
}

////////////////////////////////////////////////////////////
 TH1* GFDstarPythia::CreateHistResMassive(const char *var, const char *note)
{
  return this->CreateHistFrom(var, note, fMcRes);
}

////////////////////////////////////////////////////////////
 TH1* GFDstarPythia::CreateHistExcitation(const char *var, const char *note)
{
  return this->CreateHistFrom(var, note, fMcExc);
}

////////////////////////////////////////////////////////////
 TH1* GFDstarPythia::CreateHistRes(const char *var, const char *note)
{

  TH1 *hRes = this->CreateHistResMassive(var, note);
  TH1 *hExc = this->CreateHistExcitation(var, note);

  TH1 *hResult = NULL;
  if(hRes && hExc) {
    hRes->Add(hExc);//                                        no sumw2, but fill
    hResult = GFHistManip::CreateAnalog(hRes, hRes->GetName(), kFALSE, kTRUE);
    hResult->SetDirectory(NULL);
  } else {
    this->Error("CreateHistRes", "missing hist for res. (%p) or exc. (%p)", hRes, hExc);
  }
  delete hRes;
  delete hExc;

  return hResult;
}

////////////////////////////////////////////////////////////
 const char* GFDstarPythia::GetName() const
{
  return "Pythia 6.1";
}

////////////////////////////////////////////////////////////
 Bool_t GFDstarPythia::ShouldApplyHadCor() const
{
  // no hadronisation corrections should be applied for Pythia
  return kFALSE;
}

////////////////////////////////////////////////////////////
 Bool_t GFDstarPythia::DecodeDoubleDiff(const char *var, TString& var1, TString& var2,
				       Int_t& bin1, Int_t& bin2) const
{
  TString thisVar(var);
  if(thisVar.BeginsWith("pteta")){
    if(thisVar.Length() >= 7){
      var1 = "pt";
      var2 = "eta";
      bin1 = thisVar[5] - '0';
      bin2 = thisVar[6] - '0';
      return kTRUE;
    }
  } else if(thisVar.BeginsWith("etapt")){
    if(thisVar.Length() >= 7){
      var1 = "eta";
      var2 = "pt";
      bin1 = thisVar[5] - '0';
      bin2 = thisVar[6] - '0';
      return kTRUE;
    }
  } else if(thisVar.BeginsWith("zDspt")){
    if(thisVar.Length() >= 7){
      var1 = "zDs";
      var2 = "pt";
      bin1 = thisVar[5] - '0';
      bin2 = thisVar[6] - '0';
      return kTRUE;
    }
  } else if(thisVar.BeginsWith("ptzDs")){
    if(thisVar.Length() >= 7){
      var1 = "pt";
      var2 = "zDs";
      bin1 = thisVar[5] - '0';
      bin2 = thisVar[6] - '0';
      return kTRUE;
    }
  } else if(thisVar.BeginsWith("zDseta")){
    if(thisVar.Length() >= 8){
      var1 = "zDs";
      var2 = "eta";
      bin1 = thisVar[6] - '0';
      bin2 = thisVar[7] - '0';
      return kTRUE;
    }
  } else if(thisVar.BeginsWith("etazDs")){
    if(thisVar.Length() >= 8){
      var1 = "eta";
      var2 = "zDs";
      bin1 = thisVar[6] - '0';
      bin2 = thisVar[7] - '0';
      return kTRUE;
    }
  }
  
  return kFALSE;
}