//////////////////////////////////////////////////////////////////////////
// //
// GFDstarFmnr //
//
// Author: Gero Flucke
// Date: November 3rd, 2004
// last update: $Date: 2005/11/07 18:44:05 $ (UTC)
// by: $Author: flucke $
// //
// //
//////////////////////////////////////////////////////////////////////////
#include "GFDstarFmnr.h"
#include "GFAnalysis/GFAxisVariables.h"
#include "GFUtils/GFHistManager.h"
#include "GFUtils/GFHistManip.h"
#include "GFUtils/GFHistArray.h"
#include "GFUtils/GFMath.h"
#include <TH1.h>
// #include <TH2.h>
#include <TLegend.h>
#include <TAxis.h>
#include <TFile.h>
#include <TMath.h>
#include <TObjArray.h>
#include <TObjString.h>
#include <iostream>
#include <stdlib.h>
using namespace std;
ClassImp(GFDstarFmnr)
//_________________________________________________________
GFDstarFmnr::GFDstarFmnr(const char *fileDirIncl, const char *fileDirDsjet,
const char *mainDirectory) :
GFDstarVirtualTheory(mainDirectory), fUse2D(kTRUE), fName("FMNR"),
fFileDirIncl(fileDirIncl), fFileDirDsjet(fileDirDsjet),
fFileStartDirNlo("dirnlo"), fFileStartResNlo("resnlo"),
fCharmToDstar(0.235), fNbFactor(1000.), fFluxesW(0),
fFluxesXgam(0)
{
const Double_t wFluxes[] = {0.0042617, 0.0034339, 0.0027869, 0.0026868};//log book 29.10.2004
fFluxesW.Set(sizeof(wFluxes)/sizeof(wFluxes[0]), wFluxes);
const Double_t xGamFluxes[] = { // from ~/h1/misc/accept44/fluxesAndW.txt
0.000690734415, 0.000657515201, 0.000626687143, 0.000598017535, 0.000571302412,
0.000545828366, 0.000523038553, 0.000501190662, 0.000480693542, 0.000461435586,
0.000443316891, 0.000425830148, 0.000410147500, 0.000394943213, 0.000380568988,
0.000366965040, 0.000354077027, 0.000341519826, 0.000330255105, 0.000319234673,
0.000308756268, 0.000298785108, 0.000289289202, 0.000280239068, 0.000271607498,
0.000263369332, 0.000255501274, 0.000247737624, 0.000240790573, 0.000233909173,
0.000227320104, 0.000221007117, 0.000214955020, 0.000209149586, 0.000203577473,
0.000198226144};
fFluxesXgam.Set(sizeof(xGamFluxes)/sizeof(xGamFluxes[0]), xGamFluxes);
// this->Info("GFDstarFmnr", "add 'cteq5' to name");
// this->SetNameAdd(" (cteq5)");
}
//_________________________________________________________
GFDstarFmnr::~GFDstarFmnr()
{
}
//_________________________________________________________
void GFDstarFmnr::DrawHists(const char *var, Int_t flag, Bool_t rel)
{
// flag 0: final
// 1: mass variation only
// 2: mu_f scale variation only
// 3: mu_r scale variation only
// 4: e_pet variation only
TObjArray *vars = this->CreateVarArray(var);
const Bool_t isBatchOld = fHistManager->SetBatch();
fHistManager->Delete();
Bool_t anyLog = kFALSE;
for(Int_t i = 0; i < vars->GetEntriesFast(); ++i){
GFHistArray *hists1 = NULL, *hists2 = NULL;
TString vari;
switch(flag){
case 0:
// cout << "old!!" << endl;
// hists1 = this->CreateHistsFinalOld(vars->At(i)->GetName(), 0);
// hists2 = this->CreateHistsFinalOld(vars->At(i)->GetName(), -1);
hists1 = this->CreateHistsFinal(vars->At(i)->GetName(), 0);
if(!rel) hists2 = this->CreateHistsFinal(vars->At(i)->GetName(), -1);
vari = "final";
break;
case 1:
hists1 = this->CreateHistsMass(vars->At(i)->GetName(), 0);
if(!rel) hists2 = this->CreateHistsMass(vars->At(i)->GetName(), -1);
vari = "m_{c}";
break;
case 2:
// cout << "old mu!!" << endl;
// hists1 = this->CreateHistsScaleOld(vars->At(i)->GetName(), 0);
// hists2 = this->CreateHistsScaleOld(vars->At(i)->GetName(), -1);
// vari = "scale";
hists1 = this->CreateHistsScaleF(vars->At(i)->GetName(), 0);
if(!rel) hists2 = this->CreateHistsScaleF(vars->At(i)->GetName(), -1);
vari = "#mu_{f}";
break;
case 3:
hists1 = this->CreateHistsScaleR(vars->At(i)->GetName(), 0);
if(!rel) hists2 = this->CreateHistsScaleR(vars->At(i)->GetName(), -1);
vari = "#mu_{r}";
break;
case 4:
hists1 = this->CreateHistsEpet(vars->At(i)->GetName(), 0);
if(!rel) hists2 = this->CreateHistsEpet(vars->At(i)->GetName(), -1);
vari = "#epsilon_{pet}";
break;
}
if(hists1){
hists1->First()->SetTitle(Form("%s, %s variation",hists1->At(0)->GetTitle(),vari.Data()));
const Bool_t log = !rel && this->IsLog(vars->At(i)->GetName());
if (log) anyLog = kTRUE;
const Int_t nHist = this->DrawTheHists(hists1, hists2, log, kTRUE);
const Int_t layer = fHistManager->GetNumLayers()-1;
TLegend *leg = fHistManager->AddLegend(layer, nHist, this->GetName(), kFALSE);
leg->SetTextAlign(22);
leg->AddEntry(hists1->At(1), "dir. + res.", "l");
leg->AddEntry(hists1->At(0), Form("%s up", vari.Data()), "l");
leg->AddEntry(hists1->At(2), Form("%s down", vari.Data()), "l");
if(rel){
hists1->At(0)->Divide(hists1->At(1));
hists1->At(2)->Divide(hists1->At(1));
hists1->At(1)->Divide(hists1->At(1));
hists1->At(0)->SetYTitle("#sigma/#sigma(dir. + res.)");
hists1->At(0)->GetYaxis()->CenterTitle();
} else if(hists2){
leg->AddEntry(hists2->At(1), "res. only", "l");
delete hists2;
}
delete hists1;
}
}
fHistManager->SetBatch(isBatchOld);
fHistManager->Draw();
if (anyLog) fHistManager->Update();// for the TExec added for log scale
delete vars;
}
//_________________________________________________________
void GFDstarFmnr::DrawHistsOrigBin(const char *var, const char *note)
{
// drawing sum and resolved
if(!var) return;
TObjArray *vars = this->CreateVarArray(var);
if (!fUse2D) vars->Remove(vars->FindObject("wGammaP"));// FIXME:
fHistManager->SetBatch();
fHistManager->Delete();
for(Int_t i = 0; i < vars->GetEntriesFast(); ++i){
GFHistArray hists;
hists.Add(this->CreateHistOrigBin(vars->At(i)->GetName(), note));
TH1 *hRes = this->CreateHistOrigBinRes(vars->At(i)->GetName(), note);
if(hRes) hRes->SetLineStyle(2);
hists.Add(hRes);
const Int_t nHist = this->DrawTheHists(&hists, NULL, this->IsLog(vars->At(i)->GetName()),
kTRUE);
const Int_t layer = fHistManager->GetNumLayers()-1;
TLegend *leg = fHistManager->AddLegend(layer, nHist, this->GetName(), kFALSE);
if(leg) {
leg->SetTextAlign(22);
leg->AddEntry(hists[0], "dir. + res.", "l");
leg->AddEntry(hRes, "res. only", "l");
}
}
fHistManager->SetBatch(kFALSE);
fHistManager->Draw();
fHistManager->Update();// for the TExec added for log scale
delete vars;
}
//_________________________________________________________
GFHistArray* GFDstarFmnr::CreateHistsFinal(const char *var, Int_t dirResFlag)
{
// new: take max deviation from variation of one of mass, mu_r and mu_f
// this->Warning("CreateHistsFinal", "only central value!");
// GFHistArray* ar = new GFHistArray(3);
// if(dirResFlag == 0) ar->Add(this->CreateHist(var, ""));
// else if(dirResFlag == 1) ar->Add(this->CreateHistDir(var, ""));
// else if(dirResFlag == -1) ar->Add(this->CreateHistRes(var, ""));
// ar->Add(static_cast<TH1*>(ar->First()->Clone()));
// ar->Add(static_cast<TH1*>(ar->First()->Clone()));
// return ar;
GFHistArray *histsScaleR = this->CreateHistsScaleR(var, dirResFlag);
GFHistArray *histsScaleF = this->CreateHistsScaleF(var, dirResFlag);
GFHistArray *histsMass = this->CreateHistsMass (var, dirResFlag);
if(!histsScaleR || !histsScaleF || !histsMass) {
if(histsScaleR) histsScaleR->Delete();
if(histsScaleF) histsScaleF->Delete();
if(histsMass) histsMass->Delete();
delete histsScaleR;
delete histsScaleF;
delete histsMass;
return NULL;
}
GFHistArray histsAllVar; // the center will be in it 3 times, but that does not matter...
histsAllVar.AddAll(histsScaleR);
histsAllVar.AddAll(histsScaleF);
histsAllVar.AddAll(histsMass);
TH1 *hUpper = GFHistManip::CreateHistMinMax(&histsAllVar, 1);
TH1 *hLower = GFHistManip::CreateHistMinMax(&histsAllVar, -1);
GFHistArray *result = NULL;
if(hUpper && hLower){
hUpper->SetDirectory(NULL);
hLower->SetDirectory(NULL);
hUpper->SetLineStyle(4);
hLower->SetLineStyle(3);
TH1 *hCenter = histsScaleR->At(1);
histsScaleR->AddAt(NULL, 1); // otherwise hCenter will be deleted at clean up below!
result = new GFHistArray(3);
result->AddAt(hUpper, 0);
result->AddAt(hCenter, 1);
result->AddAt(hLower, 2);
} else {
delete hUpper;
delete hLower;
}
histsScaleF->Delete();
histsScaleR->Delete();
histsMass->Delete();
delete histsScaleF;
delete histsScaleR;
delete histsMass;
return result;
}
//_________________________________________________________
GFHistArray* GFDstarFmnr::CreateHistsFinalOld(const char *var,Int_t dirResFlag)
{
// old: (anti-)simultaneous variation of scales
// added quadratically with variation of mass
GFHistArray *histsScale = this->CreateHistsScaleOld(var, dirResFlag);
if(!histsScale) return NULL;
GFHistArray *histsMass = this->CreateHistsMass(var, dirResFlag);
if(!histsMass){
histsScale->Delete();
delete histsScale;
return NULL;
}
GFHistArray histsUpper;
histsUpper.Add(histsScale->At(0));
histsUpper.Add(histsMass->At(0));
TH1 *hUpper = GFHistManip::CreateHistDevSquareSum(&histsUpper, histsScale->At(1), 1);
GFHistArray histsLower;
histsLower.Add(histsScale->At(2));
histsLower.Add(histsMass->At(2));
TH1 *hLower = GFHistManip::CreateHistDevSquareSum(&histsLower, histsScale->At(1), -1);
GFHistArray *result = NULL;
if(hUpper && hLower){
hUpper->SetDirectory(NULL);
hLower->SetDirectory(NULL);
TH1 *hCenter = histsScale->At(1);
histsScale->AddAt(NULL, 1); // otherwise hCenter will be deleted at clean up below!
result = new GFHistArray(3);
result->AddAt(hUpper, 0);
result->AddAt(hCenter, 1);
result->AddAt(hLower, 2);
} else {
delete hUpper;
delete hLower;
}
histsScale->Delete();
histsMass->Delete();
delete histsScale;
delete histsMass;
return result;
}
//_________________________________________________________
GFHistArray* GFDstarFmnr::CreateHistsScaleOld(const char *var,Int_t dirResFlag)
{
// used for simultaneous variations of scales
GFHistArray * hists = this->CreateHistsUpDown(var, "hi", "lo", dirResFlag);
if(hists){ // it always exists and has always 3 entries!
TH1 *hUpper = hists->At(0);
TH1 *hLower = hists->At(2);
// TH1 *hCenter = hists->At(1);
for(Int_t i = 1; i <= hUpper->GetNbinsX(); ++i){
if(hUpper->GetBinContent(i) < hLower->GetBinContent(i)){
const Double_t upper = hUpper->GetBinContent(i);
const Double_t lower = hLower->GetBinContent(i);
this->Info("CreateHistsScaleOld", "bin %d for %s: upper %.3f, lower %.3f, switch!",
i, var, upper, lower);
hUpper->SetBinContent(i, lower);
hLower->SetBinContent(i, upper);
}
}
}
return hists;
}
//_________________________________________________________
GFHistArray* GFDstarFmnr::CreateHistsFinalNorm(const char *var, Int_t dirResFlag)
{
// < 0 res, > 0 dir
TObjArray upDowns;
upDowns.SetOwner();
upDowns.Add(new TObjString(""));
upDowns.Add(new TObjString("rl"));
upDowns.Add(new TObjString("rh"));
upDowns.Add(new TObjString("fl"));
upDowns.Add(new TObjString("fh"));
upDowns.Add(new TObjString("mdo"));
upDowns.Add(new TObjString("mup"));
return this->CreateHistsFinalNormInt(var, upDowns, dirResFlag);
}
//_________________________________________________________
TArrayD GFDstarFmnr::TotalCrossSec(ECrossSecType dstarJet, Int_t dirResFlag)
{
// dstarJet: 0: incl D*
// 1: D*+o.jet
// 2: D* dijet
// returning array of length 3: total cross section, upper and lower bound
//
// dirResFlag < 0: resolved only
// > 0: direct only
// = 0: sum
GFHistArray etaHists;
const char *text = this->GetHeader(dstarJet);
const char *var = this->GetVarNameForTotal(dstarJet);
const char *upDowns[] = {"", "rl", "rh", "fl", "fh", "mdo", "mup"};
const Int_t nUpDowns = sizeof(upDowns)/sizeof(upDowns[0]);
if(dirResFlag < 0){
for(Int_t i = 0; i < nUpDowns; ++i){
etaHists.Add(this->CreateHistOrigBinRes(var, upDowns[i]));
}
} else if(dirResFlag == 0) {
for(Int_t i = 0; i < nUpDowns; ++i){
etaHists.Add(this->CreateHistOrigBin(var, upDowns[i]));
}
} else if(dirResFlag > 0){
for(Int_t i = 0; i < nUpDowns; ++i){
etaHists.Add(this->CreateHistOrigBinDir(var, upDowns[i]));
}
}// else only if dirResFlag is nan (is that possible for int?)
TArrayD xSecs(etaHists.GetEntriesFast());
for(Int_t i = 0; i < xSecs.GetSize(); ++i){
xSecs[i] = etaHists[i]->Integral();
}
etaHists.Delete();
TArrayI ind(xSecs.GetSize());
TMath::Sort(xSecs.GetSize(), xSecs.GetArray(), ind.GetArray());
TArrayD result(3);
result[0] = xSecs[0];
result[1] = xSecs[ind[0]];
result[2] = xSecs[ind[ind.GetSize()-1]];
cout << "---------------------------------------------------------------n"
<< "Total X-sec " << text << " = "
<< result[0] << " + " << result[1]-result[0]
<< " - " << result[0]-result[2] << "n"
<< "---------------------------------------------------------------n"
<< "max from " << upDowns[ind[0]]
<< ", min from " << upDowns[ind[ind.GetSize()-1]] << "n"
<< "---------------------------------------------------------------n"
<< endl;
if(dstarJet != 0 && this->ShouldApplyHadCor()){
cout << "This is without hadronisation correction!n"
<< "---------------------------------------------------------------n"
<< endl;
}
return result;
}
//_________________________________________________________
GFHistArray* GFDstarFmnr::CreateHistsScaleR(const char *var, Int_t dirResFlag)
{
return this->CreateHistsUpDown(var, "rl", "rh", dirResFlag);//'rl' means: scale is doubled...
// same in TotalCrossSec
}
//_________________________________________________________
GFHistArray* GFDstarFmnr::CreateHistsScaleF(const char *var, Int_t dirResFlag)
{
return this->CreateHistsUpDown(var, "fh", "fl", dirResFlag);//'fh' means: scale is doubled...
// same in TotalCrossSec
}
//_________________________________________________________
GFHistArray* GFDstarFmnr::CreateHistsMass(const char *var, Int_t dirResFlag)
{
return this->CreateHistsUpDown(var, "mup", "mdo", dirResFlag); // same in TotalCrossSec
}
//_________________________________________________________
GFHistArray* GFDstarFmnr::CreateHistsEpet(const char *var, Int_t dirResFlag)
{
return this->CreateHistsUpDown(var, "edo", "eup", dirResFlag);
}
//_________________________________________________________
TH1* GFDstarFmnr::CreateHist(const char *var, const char *note)
{
// get final dir+res for var with file-notifyer note (per bin width)
TH1 *hDir = this->CreateHistDir(var, note);
TH1 *hRes = this->CreateHistRes(var, note);
if(!hDir || !hRes){
delete hDir;
delete hRes;
return NULL;
}
const char *dummy = NULL;
const char *hName = this->GetHistName(var, dummy);
// no sumw2, but fill!
TH1* hResult = GFHistManip::CreateAnalog(hDir, Form("%sSum", hName), kFALSE, kTRUE);
hResult->SetDirectory(NULL);
hResult->Add(hRes);
delete hDir;
delete hRes;
return hResult;
}
//_________________________________________________________
TH1* GFDstarFmnr::CreateHistDir(const char *var, const char *note)
{
// get final dir+res for var with file-notifyer note (per bin width)
TH1 *hBins = this->CreateHistBins(var); // no dir!
TH1 *hOrig = this->CreateHistOrigBinDir(var, note);
if(!hBins || !hOrig){
delete hBins;
delete hOrig;
return NULL;
}
if(!GFHistManip::Rebin(hOrig, hBins)){
delete hBins;
hBins = NULL;
} else {
GFHistManip::CorrectForBinWidth(hBins, kFALSE);
TString tit = this->YAxisTitleBinWidth(hOrig->GetYaxis()->GetTitle(),
GFAxisVariables::GetAxisLabel(var));
hBins->SetYTitle(tit);
}
delete hOrig;
return hBins;
}
//_________________________________________________________
TH1* GFDstarFmnr::CreateHistRes(const char *var, const char *note)
{
// get final res-only for var with file-notifyer note (per bin width)
if (!fUse2D && var && strcmp(var, "wGammaP") == 0){ // FIXME
return this->GetHistResW(note);
}
TH1 *hBins = this->CreateHistBins(var);
TH1 *hOrig = this->CreateHistOrigBinRes(var, note);
if(!hBins || !hOrig){
delete hBins;
delete hOrig;
return NULL;
}
if(!GFHistManip::Rebin(hOrig, hBins)){
delete hBins;
hBins = NULL;
} else {
GFHistManip::CorrectForBinWidth(hBins, kFALSE);
TString tit = this->YAxisTitleBinWidth(hOrig->GetYaxis()->GetTitle(),
GFAxisVariables::GetAxisLabel(var));
hBins->SetYTitle(tit);
}
delete hOrig;
return hBins;
}
//_________________________________________________________
TH1* GFDstarFmnr::CreateHistOrigBin(const char *var, const char *note)
{
if (!fUse2D && var && (strcmp(var, "wGammaP") == 0)){ //FIXME
this->Error("CreateHistOrigBin", "Does not work for %s", var);
return NULL;
}
TH1* hDir = this->CreateHistOrigBinDir(var, note);
TH1* hRes = this->CreateHistOrigBinRes(var, note);
if(!hDir || !hRes) {
delete hDir;
delete hRes;
return NULL;
}
const char *dummy;
const char *hName = this->GetHistName(var, dummy);
// no sumw2, but fill!
TH1* hResult = GFHistManip::CreateAnalog(hDir, Form("%sSum", hName), kFALSE, kTRUE);
hResult->SetDirectory(NULL);
hResult->Add(hRes);
delete hDir;
delete hRes;
return hResult;
}
//_________________________________________________________
TH1* GFDstarFmnr::CreateHistOrigBinDir(const char *var, const char *note)
{
// get direct
const char *directory = NULL;
const char *hName = this->GetHistName(var, directory);
TH1* hDir = this->GetHist(hName, Form("%s/%s%s.root", directory, fFileStartDirNlo.Data(),note));
// if(hDir && hDir->GetDimension() == 2){
// TH1 *hDir1D = this->CreateHist1D(static_cast<TH2*>(hDir), var);
// delete hDir;
// hDir = hDir1D;
// }
if(hDir){
hDir->SetName(Form("%sDir", hName));
hDir->SetTitle(GFAxisVariables::GetAxisLabel(var));
hDir->SetXTitle(GFAxisVariables::GetAxisLabel(var));
this->Scale(hDir, hName);
}
return hDir;
}
//_________________________________________________________
TH1* GFDstarFmnr::CreateHistOrigBinRes(const char *var, const char *note)
{
const char *directory = NULL;
const char *hName = this->GetHistName(var, directory);
TH1 *hRes = NULL;
if (!fUse2D && var && strcmp(var, "wGammaP") == 0){ // FIXME
this->Error("CreateHistOrigBinRes", "Does not work for %s", var);
return NULL;
} else if(var && (strcmp(var, "xGam") == 0
|| strcmp(var, "zDs") == 0
|| strcmp(var, "wGammaP") == 0
|| strcmp(var, "xGamDijet") == 0 )) {
// true) {
TString noteShort(note);
if (noteShort != "edo" && noteShort != "eup") noteShort.Remove(2);
for(Int_t i = 1; i <= fFluxesXgam.GetSize(); ++i){
TH1 *h =
this->GetHist(hName, Form("%s/%s%d%s.root",
directory, fFileStartResNlo.Data(), i, noteShort.Data()));
if(!hRes){
hRes = h;
GFHistManip::Scale(hRes, fFluxesXgam[i-1]);
} else {
hRes->Add(h, fFluxesXgam[i-1]);
delete h;
}
}
} else {
hRes = this->GetHist(hName, Form("%s/%s%s.root", directory, fFileStartResNlo.Data(),note));
// if(hRes && hRes->GetDimension() == 2){
// TH1 *hRes1D = this->CreateHist1D(static_cast<TH2*>(hRes), var);
// delete hRes;
// hRes = hRes1D;
// }
}
if(hRes){
hRes->SetName(Form("%sRes", hName));
hRes->SetTitle(GFAxisVariables::GetAxisLabel(var));
hRes->SetXTitle(GFAxisVariables::GetAxisLabel(var));
this->Scale(hRes, hName);
}
return hRes;
}
//_________________________________________________________
const char* GFDstarFmnr::GetHistName(const char *variable, const char *&directory) const
{
TString var(variable);
// NOTE: The string length is used in GFDstarFmnr::Scale to discriminate
// 1D from 2D histograms (extra factor 2 for 1D applied).
const char *result = NULL;
// single diff.
if (fUse2D) {
if(var == "pt") result = "h89";
else if(var == "eta") result = "h85";
else if(var == "wGammaP") result = "h93";
// else if(var == "pteta11") result = "h125";
// else if(var == "pteta22") result = "h129";
// else if(var == "pteta33") result = "h133";
else if(var == "etapt11") result = "h57";
else if(var == "etapt22") result = "h65";
else if(var == "etapt33") result = "h73";
else if(var == "zDs") result = "h81";
} else {
if(var == "pt") result = "h117";
else if(var == "eta") result = "h113";
else if(var == "wGammaP") result = "h121";
else if(var == "pteta11") result = "h125";
else if(var == "pteta22") result = "h129";
else if(var == "pteta33") result = "h133";
else if(var == "etapt11") result = "h137";
else if(var == "etapt22") result = "h141";
else if(var == "etapt33") result = "h145";
// else if(var == "zDs") result = "h149";
}
if(result){
directory = (fUse2D ? fFileDirDsjet.Data() : fFileDirIncl.Data());
return result;
}
// double diff.
if(var == "PtJet") result = "h21";
else if(var == "EtaJet") result = "h25";
else if(var == "PtDs") result = "h29";
else if(var == "EtaDs") result = "h33";
else if(var == "Deta") result = "h37";
else if(var == "Dphi" || var == "DphiNlo") result = "h41";
else if(var == "MDsJet") result = "h45";
else if(var == "PtDsJet")result = "h49";
else if(var == "xGam") result = "h61";
// if(var.BeginsWith("pteta") || var.BeginsWith("etapt")) result = "h1";
if(result){
directory = fFileDirDsjet.Data();
return result;
}
// dijet
if(var == "PtDJet") result = "h1";
else if(var == "PtOthJet") result = "h5";
else if(var == "EtaDJet") result = "h9";
else if(var == "EtaOthJet") result = "h13";
else if(var == "DetaDijet") result = "h17";
else if(var == "DphiDijet" || var == "DphiDijetNlo") result = "h97";
else if(var == "MDijet") result = "h53"; // 69?
else if(var == "PtDijet")result = "h69";
else if(var == "xGamDijet") result = "h77";
if(result){
directory = fFileDirDsjet.Data();
return result;
}
directory = NULL;
return NULL;
}
//_________________________________________________________
TH1* GFDstarFmnr::GetHistResW(const char *note)
{
// get res in w-bins for file-notifyer note, before c->D* correction...
if (fUse2D) {
this->Error("GetHistResW", "should not be called for fUse2D = kTRUE!");
return NULL;
}
TH1* hist = this->CreateHistBins("wGammaP");
if(!hist || hist->GetNbinsX() != fFluxesW.GetSize()){
delete hist;
return NULL;
}
TString noteShort(note);
if (noteShort != "edo" && noteShort != "eup") noteShort.Remove(2);
const char *directory = NULL;
const char *hName = this->GetHistName("eta", directory);
for(Int_t i = 1; i <= fFluxesW.GetSize(); ++i){
TH1* hEta = this->GetHist(hName, Form("%s/%sw%d%s.root", directory, fFileStartResNlo.Data(),
i, noteShort.Data()));
if(!hEta){
delete hist;
return NULL;
}
const Double_t sum = hEta->Integral();
hist->SetBinContent(i, sum*fFluxesW[i-1]);
delete hEta;
}
this->Scale(hist, hName);
GFHistManip::CorrectForBinWidth(hist, kFALSE);
const char * axisLabel = GFAxisVariables::GetAxisLabel("wGammaP");
TString yTit = this->YAxisTitleBinWidth(hist->GetYaxis()->GetTitle(), axisLabel);
hist->SetTitle(Form("%s;%s;%s", axisLabel, axisLabel, yTit.Data()));
return hist;
}
//_________________________________________________________
Bool_t GFDstarFmnr::Scale(TH1 *hist, const char *name) const
{
// scale hist for c->D* branching for strlen(name)=3, extra factor 2 for strlen(name)=4
// (single/double differential distributions)
if(!name || !hist) return kFALSE;
switch(strlen(name)){
case 3: // double diff hist
case 2:
GFHistManip::Scale(hist, fCharmToDstar * fNbFactor);
break;
// case 2: // inclusive, but double diff
case 4: // single diff hist
GFHistManip::Scale(hist, 2.*fCharmToDstar * fNbFactor);
break;
default:
this->Error("Scale", "Don't know how to scale %s", name);
return kFALSE;
}
hist->SetYTitle(Form("%s#sigma [nb]", hist->GetYaxis()->GetTitle()));
return kTRUE;
}
// //_________________________________________________________
// TH1* GFDstarFmnr::CreateHist1D(TH2 *h2D, const char *var)
// {
// // currently assume that we have ptetaXX or etaPtYY
// // and the 2D hist with pt on x-, eta on y-axis
// TString str(var);
// str = str(str.Length()-2, 2);
// const Int_t nums = atoi(str.Data());
// Int_t firstBin = nums/10;
// Int_t lastBin = nums-firstBin*10;
// if(firstBin < 1 || lastBin < 1 || firstBin > lastBin){
// this->Error("CreateHist1D", "decoded %s to firstBin/lastBin %d/%d", var, firstBin, lastBin);
// return NULL;
// }
// str = var;
// Bool_t projectX = kTRUE;
// if(str.BeginsWith("pteta")){
// str = "etapt";
// } else if(str.BeginsWith("etapt")){
// str = "pteta";
// projectX = kFALSE;
// } else {
// this->Error("CreateHist1D", "don't now how to treat %s", var);
// return NULL;
// }
// TH1* hist = this->CreateHistBins(str);
// if(!hist || lastBin > hist->GetNbinsX()){
// this->Error("CreateHist1D","bin %d is out of range: 1 -> %d",hist ? hist->GetNbinsX() : -1);
// delete hist;
// return NULL;
// }
// const Double_t x1 = hist->GetBinLowEdge(firstBin);
// const Double_t x2 = hist->GetBinLowEdge(lastBin+1);
// delete hist;
// const TAxis *axis = (projectX ? h2D->GetYaxis() : h2D->GetXaxis());
// lastBin = firstBin = 0;
// cout << "x1 " << x1 << ", x2 " << x2 << endl;
// for(Int_t i = 1; i <= axis->GetNbins(); ++i){
// cout << i << " " << axis->GetBinLowEdge(i) << " " << axis->GetBinUpEdge(i) << endl;
// if(GFMath::IsEqualFloat(axis->GetBinLowEdge(i), x1)) firstBin = i;
// if(GFMath::IsEqualFloat(axis->GetBinUpEdge(i), x2)) lastBin = i;
// }
// if(firstBin < 1 || lastBin < 1 || lastBin < firstBin){
// this->Error("CreateHist1D", "found first/last bin %d/%d for %s", firstBin, lastBin, var);
// return NULL;
// }
// TH1 *hResult = NULL;
// if(projectX){
// hResult = h2D->ProjectionX(var, firstBin, lastBin);
// } else {
// hResult = h2D->ProjectionY(var, firstBin, lastBin);
// }
// hResult->SetDirectory(NULL);
// return hResult;
// }
//_________________________________________________________
const char* GFDstarFmnr::GetName() const
{
return fName.Data(); //"FMNR";
}
//_________________________________________________________
void GFDstarFmnr::SetNameAdd(const char *add)
{
// add 'add' to the name
// if add == NULL, remove previously added stuff
fName = "FMNR";
if (add) fName += add;
}
ROOT page - Class index - Top of the page
This page has been automatically generated. If you have any comments or suggestions about the page layout send a mail to ROOT support, or contact the developers with any questions or problems regarding ROOT.