// Author: Gero Flucke <mailto:flucke@mail.desy.de>
//____________________________________
// GFDstarAnalyseData
// Author: Gero Flucke
// Date: May 31st, 2002
// last update: $Date: 2006/01/11 11:35:09 $ often
// by: $Author: flucke $
//
// C++
#include <iostream>
//#include <cstdlib> //?
// RooT
#include <TString.h>
#include <TMath.h>
#include <TH2.h>
#include <TH3.h>
// H1OO
#include "H1Steering/H1SteerManager.h"
#include "H1Skeleton/H1Tree.h"
#include "H1Skeleton/H1SteerTree.h"
#include "H1Pointers/H1ShortPtr.h"
#include "H1Pointers/H1BytePtr.h"
#include "H1Pointers/H1FloatPtr.h"
#include "H1Mods/H1PartDstar.h"
#include "H1Mods/H1PartJet.h"
#include "H1Mods/H1PartSelTrack.h"
#ifdef H1OO23
#include "H1Ods/ODS/H1Yecl.h"
#include "H1Ods/ODS/H1YeclBankPtr.h"
#include "GFData/GFUserEvent.h"
#else
#include "H1OOBanks/ODS/H1Yecl.h"
#include "H1OOBanks/ODS/H1YeclBankPtr.h"
#endif
#include "H1Geom/H1DBManager.h"
#include "H1Geom/H1ElectronTagger.h"
// private
#include "GFData/GFDstarAnalyseData.h"
#include "GFUtils/GFHistArray.h"
#include "GFUtils/GFHistManip.h"
#include "GFData/GFSteerDstarAnalyse.h"
using namespace std;
ClassImp(GFDstarAnalyseData)
//_____________________________________________________
GFDstarAnalyseData::GFDstarAnalyseData()
{
fEventCutXS83 = fSteer->GetXcutTag33();
fEphotonTagCut = fSteer->GetEphotonTagCut();
// Int_t help[] = {//246583, 246586, 246589, 246590, 246593, // no YECL bank
// //246594, 246596, 246597, 246602, 246604, //dito, but here it should!
// 249346, 249348, 249349, 249350, 249351,
// 249354, 249356, 249358, 249359, 249362,
// 249364, 249368, 249371, 249372, 249374,
// 249375, 249377, 249378, 258049,
// // the following are not L4keep in h1ep99, but l4mode:
// 259271, // nearly min bias ...
// 259272, 259275, 259276, 259277, 259279,// ... until 259280 ?
// 259280, //259282, 259283, 259284, 259293, // see l4stat,there is
// // 259294, 259296, 259304, 259310, 259311, // difference
// // 259312, 259313, // between input and output rate
// // so far 99e+ only, now 2000
// 265983, 265997
// };
// fL4KeepRuns.Set(sizeof(help) / sizeof(Int_t), help);
// 4: high Q2, 7: highEt jets, 8: high pt central, 9: high pt forw., 10: high pt muon,
// 12: multi-particles, 13: diffraction
fIndepL4Class83 = fSteer->GetIndepL4Classes33();
fIndepL4Class84 = fSteer->GetIndepL4Classes44();
fDmHistsWc = fDmHistsWcS83 = fDmHistsWcS84 = NULL;
fAcceptHistsS83 = fAcceptHistsS84 = NULL;
fAcceptHistsNomS83 = fAcceptHistsNomS84 = NULL;
fAcceptHists2DS83 = fAcceptHists2DS84 = NULL;
fDoubleTrigHists = fL4EffHists = fL4CheckHistsS83 = fL4CheckHistsS84 = NULL;
fYjbResHistsS83 = fPhotonTagHists = NULL;
fTrigEffHistsS83 = fTrigEffHists19S83 = fTrigEffHists31S83 = fNonTrigEffHistsS83 = NULL;
fTrigEffHistsS84 = fTrigEffHists19S84 = fTrigEffHists31S84 = fNonTrigEffHistsS84 = NULL;
fEffDedxHists = fEffDedxHistsS83 = fEffDedxTrkHistsS83 = fEffDedxTrkRefHistsS83 = NULL;
fWeightsD0Hists = fWeightsD0HistsS83 = NULL;
}
//_____________________________________________________
GFDstarAnalyseData::~GFDstarAnalyseData()
{
//
// fDmHistsWc<S8X> are added to fAllHistArray
if(fAcceptHistsS83) {delete fAcceptHistsS83; fAcceptHistsS83 = NULL;}
if(fAcceptHistsNomS83) {delete fAcceptHistsNomS83; fAcceptHistsNomS83 = NULL;}
if(fAcceptHists2DS83) {delete fAcceptHists2DS83; fAcceptHists2DS83 = NULL;}
if(fAcceptHistsS84) {delete fAcceptHistsS84; fAcceptHistsS84 = NULL;}
if(fAcceptHistsNomS84) {delete fAcceptHistsNomS84; fAcceptHistsNomS84 = NULL;}
if(fAcceptHists2DS84) {delete fAcceptHists2DS84; fAcceptHists2DS84 = NULL;}
if(fDoubleTrigHists) {delete fDoubleTrigHists; fDoubleTrigHists = NULL;}
if(fL4EffHists) {delete fL4EffHists; fL4EffHists = NULL;}
if(fL4CheckHistsS83) {delete fL4CheckHistsS83; fL4CheckHistsS83 = NULL;}
if(fL4CheckHistsS84) {delete fL4CheckHistsS84; fL4CheckHistsS84= NULL;}
if(fYjbResHistsS83) {delete fYjbResHistsS83; fYjbResHistsS83 = NULL;}
if(fPhotonTagHists) {delete fPhotonTagHists; fPhotonTagHists = NULL;}
if(fTrigEffHistsS83) {delete fTrigEffHistsS83; fTrigEffHistsS83 = NULL;}
if(fTrigEffHists19S83) {delete fTrigEffHists19S83; fTrigEffHists19S83 = NULL;}
if(fTrigEffHists31S83) {delete fTrigEffHists31S83; fTrigEffHists31S83 = NULL;}
if(fNonTrigEffHistsS83) {delete fNonTrigEffHistsS83; fNonTrigEffHistsS83 = NULL;}
if(fTrigEffHistsS84) {delete fTrigEffHistsS84; fTrigEffHistsS84 = NULL;}
if(fTrigEffHists19S84) {delete fTrigEffHists19S84; fTrigEffHists19S84 = NULL;}
if(fTrigEffHists31S84) {delete fTrigEffHists31S84; fTrigEffHists31S84 = NULL;}
if(fNonTrigEffHistsS84) {delete fNonTrigEffHistsS84; fNonTrigEffHistsS84 = NULL;}
}
//_____________________________________________________
void GFDstarAnalyseData::CreateHistsAccept()
{
TDirectory* oldDir = this->OpenHistsFile();
TDirectory* dir = new TDirectory("accept", "acceptance histograms");
dir->cd();
fAcceptHistsS83 = this->CreateHists("Accept", "#sum1/A_{ET}", 83, 2, dir);
fAcceptHistsS84 = this->CreateHists("Accept", "#sum1/A_{ET}", 84, 2, dir);
fAcceptHistsNomS83 = this->CreateHists("AcceptNom", "#sum1", 83, 2, dir);
fAcceptHistsNomS84 = this->CreateHists("AcceptNom", "#sum1", 84, 2, dir);
this->Info("CreateHistsAccept", "2D hists for acceptance!");
GFHistManip::CallSumw2(fAcceptHistsS83);
GFHistManip::CallSumw2(fAcceptHistsS84);
oldDir->cd();
}
//_____________________________________________________
void GFDstarAnalyseData::CreateHistsL4Eff()
{
TDirectory* oldDir = this->OpenHistsFile();
fL4EffHists = GFHistManip::ClearCreateArray(fL4EffHists);
TString titleEndLow;
for(Int_t i = 0; i < fIndepL4Class84.GetSize(); ++i){
(titleEndLow += fIndepL4Class84[i]) += ", ";
}
titleEndLow += "ETAG44";
TString titleEndHigh;
for(Int_t i = 0; i < fIndepL4Class83.GetSize(); ++i){
(titleEndHigh += fIndepL4Class83[i]) += ", ";
}
titleEndHigh += "ETAG33";
fL4EffHists->Add(new TH1F("L4effDstarTrigS83", //0
"L4 found D* in class " + titleEndHigh,
kDmHistNumBins, kDmHistLowEdge, kDmHistHighEdge));
fL4EffHists->Add(new TH1F("L4effDstarS83", "D* in class " + titleEndHigh, //1
kDmHistNumBins, kDmHistLowEdge, kDmHistHighEdge));
fL4EffHists->Add(new TH1F("L4effDstarTrigS84", //2
"L4 found D* in class " + titleEndLow,
kDmHistNumBins, kDmHistLowEdge, kDmHistHighEdge));
fL4EffHists->Add(new TH1F("L4effDstarS84", "D* in class " + titleEndLow, //3
kDmHistNumBins, kDmHistLowEdge, kDmHistHighEdge));
fL4EffHists->Add(new TH1F("L4effEventTrigS83", //4
"triggered event in class " + titleEndHigh,
2, 0, 2)); // first bin up to 0.152, 2nd all
fL4EffHists->Add(new TH1F("L4effEventS83", "event in class " + titleEndHigh, //5
2, 0, 2));
fL4EffHists->Add(new TH1F("L4effEventTrigS84", //6
"triggered event in class " + titleEndLow,
2, 0, 2));
fL4EffHists->Add(new TH1F("L4effEventS84", "event in class " + titleEndLow, //7
2, 0, 2));
for(Int_t i = 4; i < 8; ++i){
(*fL4EffHists)[i]->Sumw2();
}
oldDir->cd();
}
//_____________________________________________________
void GFDstarAnalyseData::CreateHistsL4Eff2()
{
this->GFDstarAnalyse::CreateHistsL4Eff2();
for(Int_t i = kNumDefaultHists; i < fL4NoHistsS83->GetEntriesFast(); ++i){
(*fL4NoHistsS83)[i]->Sumw2();
(*fL4NoHistsS84)[i]->Sumw2();
(*fL4YesHistsS83)[i]->Sumw2();
(*fL4YesHistsS84)[i]->Sumw2();
(*fL4NoDstarHistsS83)[i]->Sumw2();
(*fL4NoDstarHistsS84)[i]->Sumw2();
(*fL4YesDstarHistsS83)[i]->Sumw2();
(*fL4YesDstarHistsS84)[i]->Sumw2();
}
}
//_____________________________________________________
void GFDstarAnalyseData::CreateHistsDoubleTrig()
{
TDirectory* oldDir = this->OpenHistsFile();
fDoubleTrigHists = GFHistManip::ClearCreateArray(fDoubleTrigHists);
fDoubleTrigHists->Add(new TH2F("doubleTrigPt", "ETAG33 and ETAG44: p_{t}(D*)",
kDmHistNumBins, kDmHistLowEdge, kDmHistHighEdge,
fSteer->GetPtBins44()->GetSize()-1,
fSteer->GetPtBins44()->GetArray()));
fDoubleTrigHists->Add(new TH2F("doubleTrigEta", "ETAG33 and ETAG44: #eta(D*)",
kDmHistNumBins, kDmHistLowEdge, kDmHistHighEdge,
fSteer->GetEtaBins33()->GetSize()-1,
fSteer->GetEtaBins33()->GetArray()));
fDoubleTrigHists->Add(new TH2F("doubleTrigPhi", "ETAG33 and ETAG44: #phi(D*)",
kDmHistNumBins, kDmHistLowEdge, kDmHistHighEdge,
fSteer->GetPhiBins()->GetSize()-1,
fSteer->GetPhiBins()->GetArray()));
fDoubleTrigHists->Add(new TH2F("doubleTrigWgammaP", "ETAG33 and ETAG44: W_{#gammap}",
kDmHistNumBins, kDmHistLowEdge, kDmHistHighEdge,
fWgammaP33Bins.GetSize()-1, fWgammaP33Bins.GetArray()));
fDoubleTrigHists->Add(new TH1F("doubleTrigS84S83", "ETAG33 and S84",
kDmHistNumBins, kDmHistLowEdge, kDmHistHighEdge));
fDoubleTrigHists->Add(new TH1F("doubleTrigS83S84", "ETAG44 and S83",
kDmHistNumBins, kDmHistLowEdge, kDmHistHighEdge));
oldDir->cd();
}
//_____________________________________________________
void GFDstarAnalyseData::CreateHistsL4Check()
{
TDirectory* oldDir = this->OpenHistsFile();
fL4CheckHistsS83 = GFHistManip::ClearCreateArray(fL4CheckHistsS83);
fL4CheckHistsS84 = GFHistManip::ClearCreateArray(fL4CheckHistsS84);
Int_t chi2Bins = 40;
Double_t chi2Low = 0.;
Double_t chi2High = 100.;
fL4CheckHistsS83->Add(new TH1F("L4FailChi2K", "#chi^{2}(K) (not L4 found)",
chi2Bins, chi2Low, chi2High));
fL4CheckHistsS83->Add(new TH1F("L4FailChi2Pi", "#chi^{2}(#pi) (not L4 found)",
chi2Bins, chi2Low, chi2High));
fL4CheckHistsS83->Add(new TH1F("L4FailChi2Pis", "#chi^{2}(#pi_{s}) (not L4 found)",
chi2Bins, chi2Low, chi2High));
Int_t dcaPrimeBins = 60;
Double_t dcaPrimeLow = -3.;
Double_t dcaPrimeHigh = 3.;
fL4CheckHistsS83->Add(new TH1F("L4FailDcaPrimeK", "DCA'(K) (not L4 found)",
dcaPrimeBins, dcaPrimeLow, dcaPrimeHigh));
fL4CheckHistsS83->Add(new TH1F("L4FailDcaPrimePi", "DCA'(#pi) (not L4 found)",
dcaPrimeBins, dcaPrimeLow, dcaPrimeHigh));
fL4CheckHistsS83->Add(new TH1F("L4FailDcaPrimePis", "DCA'(#pi_{s}) (not L4 found)",
dcaPrimeBins, dcaPrimeLow, dcaPrimeHigh));
Int_t nHitsBins = 40;
Double_t nHitsLow = 0., nHitsHigh = 40.;
fL4CheckHistsS83->Add(new TH1F("L4FailnHitsK", "N_{hits CJC}(K) (not L4 found)",
nHitsBins, nHitsLow, nHitsHigh));
fL4CheckHistsS83->Add(new TH1F("L4FailnHitsPi", "N_{hits CJC}(#pi) (not L4 found)",
nHitsBins, nHitsLow, nHitsHigh));
fL4CheckHistsS83->Add(new TH1F("L4FailnHitsPis", "N_{hits CJC}(#pi_{s}) (not L4 found)",
nHitsBins, nHitsLow, nHitsHigh));
Int_t deltaZBins = 40;
Double_t deltaZLow = 0., deltaZHigh = 80.;
fL4CheckHistsS83->Add(new TH1F("L4FaildeltaZK", "z_{DCA}-z_{vtx}(K) (not L4 found)",
deltaZBins, deltaZLow, deltaZHigh));
fL4CheckHistsS83->Add(new TH1F("L4FaildeltaZPi", "z_{DCA}-z_{vtx}(#pi) (not L4 found)",
deltaZBins, deltaZLow, deltaZHigh));
fL4CheckHistsS83->Add(new TH1F("L4FaildeltaZPis", "z_{DCA}-z_{vtx}(#pi_{s}) (not L4 found)",
deltaZBins, deltaZLow, deltaZHigh));
fL4CheckHistsS83->Add(new TH1F("L4FailTaggerE", "E_{tagger} (not L4 found)",
30, 0., 30));
GFHistManip::CreateAnalogHists(fL4CheckHistsS83, fL4CheckHistsS84, "S84");
GFHistManip::AddToHistsName("S83", fL4CheckHistsS83);
// fL4CheckHistsS83->Add(new TH1F("L4FoundChi2K", "#chi^{2}(K) (L4 found)",
// chi2bins, chi2low, chi2highfound));
// fL4CheckHistsS83->Add(new TH1F("L4FoundChi2Pi", "#chi^{2}(#pi) (L4 found)",
// chi2bins, chi2low, chi2highfound));
// fL4CheckHistsS83->Add(new TH1F("L4FoundChi2Pis", "#chi^{2}(#pi_{s}) (L4 found)",
// chi2bins, chi2low, chi2highfound));
oldDir->cd();
}
//_____________________________________________________
void GFDstarAnalyseData::CreateHistsYjbRes(const char * nameAdd)
{
// nameAdd will be ignored!
TDirectory* oldDir = this->OpenHistsFile();
GFHistManip::ClearCreateArray(fYjbResHistsS83);
Double_t yMin = fEventCutyMinS83;
Double_t yMax = fEventCutyMaxS83;
Int_t resBins = 40;
Double_t resRange = 0.8;
fYjbResHistsS83->Add(new TH2F("yjbResHist2DS83", "y_{jb} vs. y_{tag}", // 0
50, yMin, yMax, 50, yMin, yMax));
fYjbResHistsS83->Add(new TH1F("yjbResHistS83", "(y_{jb} - y_{tag})/y_{tag}", // 1
2 * resBins, -resRange, resRange));
fYjbResHistsS83->Add(new TH2F("yjbResPtHist2DS83", "(y_{jb} - y_{tag})/y_{tag} vs p_{t}", //2
resBins, -resRange, resRange,
fSteer->GetPtBins33()->GetSize()-1,
fSteer->GetPtBins33()->GetArray()));
fYjbResHistsS83->Add(new TH2F("yjbResEtaHist2DS83", "(y_{jb} - y_{tag})/y_{tag} vs #eta", //3
resBins, -resRange, resRange,
fSteer->GetEtaBins33()->GetSize()-1,
fSteer->GetEtaBins33()->GetArray()));
fYjbResHistsS83->Add(new TH2F("yjbResPhiHist2DS83", "(y_{jb} - y_{tag})/y_{tag} vs #phi",//4
resBins, -resRange, resRange,
fSteer->GetPhiBins()->GetSize()-1,
fSteer->GetPhiBins()->GetArray()));
fYjbResHistsS83->Add(new TH2F("yjbResWgammaPHist2DS83", //5
"(y_{jb} - y_{tag})/y_{tag} vs W_{#gammap}",
resBins, -resRange, resRange,
fWgammaP33Bins.GetSize()-1, fWgammaP33Bins.GetArray()));
fYjbResHistsS83->Add(new TH2F("yjbResYtagHist2DS83", "(y_{jb} - y_{tag})/y_{tag} vs y_{tag}",
resBins, -resRange, resRange, 25, yMin, yMax));
fYjbResHistsS83->Add(new TH2F("yjbResYjbHist2DS83", "(y_{jb} - y_{tag})/y_{tag} vs y_{jb}",//7
resBins, -resRange, resRange, 25, yMin, yMax));
fYjbResHistsS83->Add(new TH2F("yjbWeihtResHist2DS83",
"y_{jb} vs. y_{tag} (A_{ET33}(y_{jb}-weighted)", // 8
50, yMin, yMax, 50, yMin, yMax));
oldDir->cd();
}
//_____________________________________________________
void GFDstarAnalyseData::CreateHistsPhotonTag()
{
TDirectory* oldDir = this->OpenHistsFile();
GFHistManip::ClearCreateArray(fPhotonTagHists);
Float_t minEgamma = 0.5, maxEgamma = 7.;
Int_t numBinsEgamma = 65;
fPhotonTagHists->Add(new TH2F("gammaTagHist2DS83", "#Deltam vs. E_{#gamma}",
kDmHistNumBins, kDmHistLowEdge, kDmHistHighEdge,
numBinsEgamma, minEgamma, maxEgamma));
fPhotonTagHists->Add(new TH2F("gammaTagHist2DS84", "#Deltam vs. E_{#gamma}",
kDmHistNumBins, kDmHistLowEdge, kDmHistHighEdge,
numBinsEgamma, minEgamma, maxEgamma));
fPhotonTagHists->Add(new TH1F("gammaTagHistS83", "E_{#gamma}",
numBinsEgamma, minEgamma, maxEgamma));
fPhotonTagHists->Add(new TH1F("gammaTagHistS84", "E_{#gamma}",
numBinsEgamma, minEgamma, maxEgamma));
oldDir->cd();
}
//_____________________________________________________
void GFDstarAnalyseData::CreateHistsTrigEff()
{
// histos for trigger efficiencies of TE 19, 31 and both
fTrigEffHistsS83 = this->CreateHists("Trig","#Delta m signal (<y-axis>): TE fired ", 83, 1);
fTrigEffHists19S83 = this->CreateHists("Trig19","#Delta m signal (<y-axis>): TE fired ",83,1);
fTrigEffHists31S83 = this->CreateHists("Trig31","#Delta m signal (<y-axis>): TE fired ",83,1);
fNonTrigEffHistsS83 = this->CreateHists("NonTrig",
"#Delta m signal (<y-axis>): TE not fired ", 83, 1);
fTrigEffHistsS84 = this->CreateHists("Trig","#Delta m signal (<y-axis>): TE fired ", 84, 1);
fTrigEffHists19S84 = this->CreateHists("Trig19","#Delta m signal (<y-axis>): TE fired ",84,1);
fTrigEffHists31S84 = this->CreateHists("Trig31","#Delta m signal (<y-axis>): TE fired ",84,1);
fNonTrigEffHistsS84 = this->CreateHists("NonTrig",
"#Delta m signal (<y-axis>): TE not fired ", 84, 1);
}
//_____________________________________________________
void GFDstarAnalyseData::OpenTree()
{
H1Tree::Instance()->Open();
H1Tree::Instance()->Register(this);
}
//_____________________________________________________
Bool_t GFDstarAnalyseData::FillHistsDstarWc(const H1PartDstar* dstarWc)
{
// cf. FillHistsDstar
if(!fDmHistsWc) this->CreateHistsDm(fDmHistsWc, fDmHistsWcS83, fDmHistsWcS84, "Wc");
return this->FillHistsDstar(dstarWc, fDmHistsWc,
fDmHistsWcS83, fDmHistsWcS84, kFALSE);// no L4 required!
}
//_____________________________________________________
void GFDstarAnalyseData::FillHistsAccept(const H1PartDstar* dstar)
{
// cutting on signal window
// and: for ETAG33 pt2 cut, for ETAG44 eta backward cut
if(!fAcceptHistsS83) this->CreateHistsAccept();
H1ElectronTagger* tagger = static_cast<H1ElectronTagger*>
(H1DBManager::Instance()->GetDBEntry(H1ElectronTagger::Class()));
if(this->IsST(83) && dstar->GetPt() > fSteer->GetPtBins33()->At(0)){//higher pt cut for ETAG33
const Double_t y = this->GetY33();
const Double_t accept = tagger->Acceptance33(y);
if(accept != 0.){
if(this->IsS83(dstar)){ // dstar may be redundant...
const Double_t oneOverAccept = 1./ accept;
this->FillHists(fAcceptHistsS83, dstar, 83, oneOverAccept);
this->FillHists(fAcceptHistsNomS83, dstar, 83, 1.);
}
} // accept33 != 0
} // ST 83
if(this->IsST(84) && dstar->GetEta() > fSteer->GetEtaBins44()->At(0)){// cut on backward direction for ETAG44
const Double_t y = this->GetY44();
const Double_t accept = tagger->Acceptance44(y);
if(accept != 0.){
if(this->IsS84(dstar)){ // dstar may be redundant...
const Double_t oneOverAccept = 1./ accept;
this->FillHists(fAcceptHistsS84, dstar, 84, oneOverAccept);
this->FillHists(fAcceptHistsNomS84, dstar, 84, 1.);
}
} // accept44 != 0
} // ST 84
}
//_____________________________________________________
void GFDstarAnalyseData::FillHistsDoubleTrig(const H1PartDstar* dstar)
{
// assuming dstar fulfills loos cuts
if(!fDoubleTrigHists) this->CreateHistsDoubleTrig();
Bool_t s83 = this->IsS83(dstar);
Bool_t s84 = this->IsS84(dstar);
Double_t dm = ((s83 || s84) ? dstar->GetDm() : 0.);
if(s83 && s84){
(*fDoubleTrigHists)[0]->Fill(dm, dstar->GetPt());
(*fDoubleTrigHists)[1]->Fill(dm, dstar->GetEta());
(*fDoubleTrigHists)[2]->Fill(dm, dstar->GetPhi());
(*fDoubleTrigHists)[3]->Fill(dm, this->GetWgammaP33());
}
if(s83 && this->IsST(84)) (*fDoubleTrigHists)[4]->Fill(dm);
if(s84 && this->IsST(83)) (*fDoubleTrigHists)[5]->Fill(dm);
}
//_____________________________________________________
void GFDstarAnalyseData::FillHistsL4Eff(const TObjArray* dstars)
{
// assuming lower p_t cut etc. already fullfilled
// filling events with HV and z-Vtx in range, one of the triggers 83/84 required,
// bank YECL present
const Bool_t s83 = this->IsL4Ref(83);
const Bool_t s84 = this->IsL4Ref(84);
if(!(s83 || s84)) return;
if(!fL4EffHists) this->CreateHistsL4Eff();
static H1YeclBankPtr yecl;
if(yecl.GetEntries() <= 0){
static Int_t numWarn = 0;
if(numWarn < kNumMaxWarn) {
if(numWarn == kNumMaxWarn - 1)
this->Warning("FillHistsL4Eff", "Following warning will not be shown further!");
this->Warning("FillHistsL4Eff","no YECL bank, skip event!");
}
++numWarn;
return;
}
Bool_t looseLowDm = kFALSE, looseHighDm = kFALSE; // loose means s84, tight s83
Bool_t tightLowDm = kFALSE, tightHighDm = kFALSE;
Bool_t looseLowDmTrig = kFALSE, looseHighDmTrig = kFALSE;
Bool_t tightLowDmTrig = kFALSE, tightHighDmTrig = kFALSE;
TIter nextDstar(dstars);
while(H1PartDstar* ds = static_cast<H1PartDstar*>(nextDstar())){
const Bool_t isL4Found = this->IsL4Found(kL4FinderBit, ds);
if(this->DstarCutLoose(ds)) {
const Double_t dm = ds->GetDm();
const Bool_t lowDm = (dm < 0.152); // hardcoded 0.152 FIXME!
if(s84 && this->IsS84NoL4Check(ds)){
looseHighDm = kTRUE;
if(lowDm) looseLowDm = kTRUE;
if(isL4Found) {
(*fL4EffHists)[2]->Fill(dm);
looseHighDmTrig = kTRUE;
if(lowDm) looseLowDmTrig = kTRUE;
}
(*fL4EffHists)[3]->Fill(dm);
}
if(s83 && this->IsS83NoL4Check(ds)){
tightHighDm = kTRUE;
if(lowDm) tightLowDm = kTRUE;
if(isL4Found) {
(*fL4EffHists)[0]->Fill(dm);
tightHighDmTrig = kTRUE;
if(lowDm) tightLowDmTrig = kTRUE;
}
(*fL4EffHists)[1]->Fill(dm);
}
}
}
if(looseLowDm) (*fL4EffHists)[7]->Fill(0.5);
if(looseHighDm) (*fL4EffHists)[7]->Fill(1.5);
if(looseLowDmTrig) (*fL4EffHists)[6]->Fill(0.5);
if(looseHighDmTrig) (*fL4EffHists)[6]->Fill(1.5);
if(tightLowDm) (*fL4EffHists)[5]->Fill(0.5);
if(tightHighDm) (*fL4EffHists)[5]->Fill(1.5);
if(tightLowDmTrig) (*fL4EffHists)[4]->Fill(0.5);
if(tightHighDmTrig) (*fL4EffHists)[4]->Fill(1.5);
}
//_____________________________________________________
void GFDstarAnalyseData::FillHistsYjbRes(const H1PartDstar* ds)
{
if(!fYjbResHistsS83) this->CreateHistsYjbRes();
if(this->IsS83NoYtagL4Check(ds) && this->IsSignalRegionDm(ds)
&& this->IsL4Found(kL4FinderBit, ds)){
static H1FloatPtr yjb("Yjb"); // from dstarUser
static H1FloatPtr ytag("Ye33"); // from dstarUser
Double_t yjbMinYtagThruYtag = *ytag ? (*yjb - *ytag)/ *ytag : 0.;
(*fYjbResHistsS83)[0]->Fill(*yjb, *ytag);
// if(this->IsS83(ds)){
(*fYjbResHistsS83)[1]->Fill(yjbMinYtagThruYtag);
(*fYjbResHistsS83)[2]->Fill(yjbMinYtagThruYtag, ds->GetPt());
(*fYjbResHistsS83)[3]->Fill(yjbMinYtagThruYtag, ds->GetEta());
(*fYjbResHistsS83)[4]->Fill(yjbMinYtagThruYtag, ds->GetPhi());
(*fYjbResHistsS83)[5]->Fill(yjbMinYtagThruYtag, this->GetWgammaP33());
// }
(*fYjbResHistsS83)[6]->Fill(yjbMinYtagThruYtag, *ytag);
(*fYjbResHistsS83)[7]->Fill(yjbMinYtagThruYtag, *yjb);
H1ElectronTagger* tagger = static_cast<H1ElectronTagger*>
(H1DBManager::Instance()->GetDBEntry(H1ElectronTagger::Class()));
static_cast<TH2*>((*fYjbResHistsS83)[8])->Fill(*yjb, *ytag, tagger->Acceptance33(*yjb));
}
}
//_____________________________________________________
void GFDstarAnalyseData::FillHistsPhotonTag(const H1PartDstar* ds)
{
if(!fPhotonTagHists) this->CreateHistsPhotonTag();
Bool_t isL4Found = this->IsL4Found(kL4FinderBit, ds);
static H1FloatPtr phtagE("Phtag");
if(isL4Found && this->IsS83NoL4Check(ds)){
(*fPhotonTagHists)[0]->Fill(ds->GetDm(), *phtagE);
(*fPhotonTagHists)[2]->Fill(*phtagE);
}
if(isL4Found && this->IsS84NoL4Check(ds)){
(*fPhotonTagHists)[1]->Fill(ds->GetDm(), *phtagE);
(*fPhotonTagHists)[3]->Fill(*phtagE);
}
}
//_____________________________________________________
void GFDstarAnalyseData::FillHistsTrigEff(const H1PartDstar* ds)
{
if(!fTrigEffHistsS83) this->CreateHistsTrigEff(); // create hists
Bool_t s83 = this->IsS83NonTrig(ds) &&
(this->IsST(50) || this->IsST(67) || this->IsST(101)); // reference trigger: 50, 67, 101
Bool_t s84 = this->IsS84NonTrig(ds) && // 67, 101
(this->IsST(67) || this->IsST(101));
if(s83 && !this->IsL4Ref(83)){ // maybe we take any other or more L4?
s83 = kFALSE;
}
if(s84 && !this->IsL4Ref(84)){ // maybe we take any other or more L4?
s84 = kFALSE;
}
if(fSteer->GetDmCutTrig() < ds->GetDm()) return;
// if(!this->IsSignalRegionDm(ds)) return; too low statistics!
static H1BytePtr trigElements("Il1te");
if(s83){
this->FillHists(fNonTrigEffHistsS83, ds, 83);
if(trigElements[19]){
this->FillHists(fTrigEffHists19S83, ds, 83);
}
if(trigElements[31]){
this->FillHists(fTrigEffHists31S83, ds, 83);
}
if(trigElements[19] && trigElements[31]){
this->FillHists(fTrigEffHistsS83, ds, 83);
}
}
if(s84){
this->FillHists(fNonTrigEffHistsS84, ds, 84);
if(trigElements[19]){
this->FillHists(fTrigEffHists19S84, ds, 84);
}
if(trigElements[31]){
this->FillHists(fTrigEffHists31S84, ds, 84);
}
if(trigElements[19] && trigElements[31]){
this->FillHists(fTrigEffHistsS84, ds, 84);
}
}
}
//_____________________________________________________
void GFDstarAnalyseData::CreateHistsEffDedx()
{
TDirectory* oldDir = this->OpenHistsFile();
TDirectory* dir = new TDirectory("effDedx","hists without dEdx cut");
fEffDedxHists = this->CreateHists("effDedx", "No dEdx cut", -1, 2, dir);// 2D
fEffDedxHistsS83 = this->CreateHists("effDedx", "No dEdx cut", 83, 2, dir);// 2D
fAllHistArrays.Add(fEffDedxHists);
fAllHistArrays.Add(fEffDedxHistsS83);
dir->cd();
fEffDedxTrkHistsS83 = GFHistManip::ClearCreateArray(fEffDedxTrkHistsS83);
fEffDedxTrkRefHistsS83 = GFHistManip::ClearCreateArray(fEffDedxTrkRefHistsS83);
fAllHistArrays.Add(fEffDedxTrkHistsS83);
fAllHistArrays.Add(fEffDedxTrkRefHistsS83);
const Float_t minTheta = 20. * TMath::DegToRad();
const Float_t maxTheta = 160. * TMath::DegToRad();
const Int_t nBins = 24; //can be downsized to 12,8,6,4,3,2,1!
fEffDedxTrkHistsS83->Add(new TH2F("ThetaKDedxEff", "#theta (K)",
kDmHistNumBins, kDmHistLowEdge, kDmHistHighEdge,
nBins, minTheta, maxTheta));
fEffDedxTrkHistsS83->Add(new TH2F("ThetaPiDedxEff", "#theta (#pi)",
kDmHistNumBins, kDmHistLowEdge, kDmHistHighEdge,
nBins, minTheta, maxTheta));
fEffDedxTrkHistsS83->Add(new TH2F("LengthKDedxEff", "track length (K)",
kDmHistNumBins, kDmHistLowEdge, kDmHistHighEdge,
nBins, fSteer->GetLengthCutKPi(), 66));
fEffDedxTrkHistsS83->Add(new TH2F("LengthPiDedxEff", "track length (#pi)",
kDmHistNumBins, kDmHistLowEdge, kDmHistHighEdge,
nBins, fSteer->GetLengthCutKPi(), 66));
fEffDedxTrkHistsS83->Add(new TH2F("NhitKDedxEff", "N_{hit}^{dEdx} (K)", //18
kDmHistNumBins, kDmHistLowEdge, kDmHistHighEdge,
nBins, 10., 58.));
fEffDedxTrkHistsS83->Add(new TH2F("NhitPiDedxEff", "N_{hit}^{dEdx} (#pi)", //19
kDmHistNumBins, kDmHistLowEdge, kDmHistHighEdge,
nBins, 10., 58.));
const Double_t pBins[9] = {fSteer->GetPtCutK()-1.e-7, 0.5, .8, 1., 1.3, 1.6, 2., 4., 8.};
fEffDedxTrkHistsS83->Add(new TH2F("PKDedxEff", "LH to be #pi (#pi_{s}) vs p vs #Deltam",
kDmHistNumBins, kDmHistLowEdge, kDmHistHighEdge, 8, pBins));
fEffDedxTrkHistsS83->Add(new TH2F("PPiDedxEff", "LH to be #pi (#pi_{s}) vs p vs #Deltam",
kDmHistNumBins, kDmHistLowEdge, kDmHistHighEdge, 8, pBins));
GFHistManip::CreateAnalogHists(fEffDedxTrkHistsS83, fEffDedxTrkRefHistsS83,"RefS83"," (ref)");
GFHistManip::AddToHistsName("S83", fEffDedxTrkHistsS83);
oldDir->cd();
}
//_____________________________________________________
void GFDstarAnalyseData::FillHistsEffDedx(const H1PartDstar* dstar)
{
// assuming that all general cuts besides dedx are applied to ds
if(!fEffDedxHists) this->CreateHistsEffDedx();
this->FillHists(fEffDedxHists, dstar, -1);
if(this->IsS83(dstar)){
this->FillHists(fEffDedxHistsS83, dstar, 83);
const H1PartSelTrack *k = dstar->GetKaon();
const H1PartSelTrack *pi = dstar->GetPion();
const Double_t dm = dstar->GetDm();
const Bool_t oldDedxFlag = fIgnoreDedx;
fIgnoreDedx = kFALSE;
const Bool_t kOk = this->IsDedxOK(dstar, 0);
const Bool_t piOk = this->IsDedxOK(dstar, 1);
const Bool_t pisOk = this->IsDedxOK(dstar, 2);
fIgnoreDedx = oldDedxFlag;
if(pisOk && piOk){ // fill k hists
fEffDedxTrkRefHistsS83->At(0)->Fill(dm, k->GetTheta());
fEffDedxTrkRefHistsS83->At(2)->Fill(dm, k->GetRadLength());
fEffDedxTrkRefHistsS83->At(4)->Fill(dm, k->GetNHitDedx());
fEffDedxTrkRefHistsS83->At(6)->Fill(dm, k->GetP());
if(kOk) {
fEffDedxTrkHistsS83->At(0)->Fill(dm, k->GetTheta());
fEffDedxTrkHistsS83->At(2)->Fill(dm, k->GetRadLength());
fEffDedxTrkHistsS83->At(4)->Fill(dm, k->GetNHitDedx());
fEffDedxTrkHistsS83->At(6)->Fill(dm, k->GetP());
}
}
if(pisOk && kOk){ // fill pi hists
fEffDedxTrkRefHistsS83->At(1)->Fill(dm, pi->GetTheta());
fEffDedxTrkRefHistsS83->At(3)->Fill(dm, pi->GetRadLength());
fEffDedxTrkRefHistsS83->At(5)->Fill(dm, pi->GetNHitDedx());
fEffDedxTrkRefHistsS83->At(7)->Fill(dm, pi->GetP());
if(piOk){
fEffDedxTrkHistsS83->At(1)->Fill(dm, pi->GetTheta());
fEffDedxTrkHistsS83->At(3)->Fill(dm, pi->GetRadLength());
fEffDedxTrkHistsS83->At(5)->Fill(dm, pi->GetNHitDedx());
fEffDedxTrkHistsS83->At(7)->Fill(dm, pi->GetP());
}
}
}
}
//_____________________________________________________
void GFDstarAnalyseData::CreateHistsD0Weights()
{
TDirectory* oldDir = this->MakeHistDir("D0Weights", "weights for all D0");
GFHistManip::ClearCreateArray(fWeightsD0Hists);
fWeightsD0Hists->Add(new TH2F("D0weights", "m(K#pi) vs L4 weight",
kD0HistNumBins, kD0HistLowEdge, kD0HistHighEdge, 70, 0., 70.));
fWeightsD0Hists->Add(new TH2F("ptD0weights", "L4 weight vs p_{t}(D*) for full m(K#pi)",
fSteer->GetPtBins33()->GetSize()-1,
fSteer->GetPtBins33()->GetArray(), 70, 0., 70.));
fWeightsD0Hists->Add(new TH2F("etaD0weights", "L4 weight vs #eta(D*) for full m(K#pi)",
fSteer->GetEtaBins33()->GetSize()-1,
fSteer->GetEtaBins33()->GetArray(), 70, 0., 70.));
GFHistManip::CreateAnalogHists(fWeightsD0Hists, fWeightsD0HistsS83, "S83");
fAllHistArrays.Add(fWeightsD0Hists);
fAllHistArrays.Add(fWeightsD0HistsS83);
oldDir->cd();
}
//_____________________________________________________
void GFDstarAnalyseData::FillHistsWeightsD0(const H1PartDstar* ds)
{
if(!this->D0CutLoose(ds)) return;
if(!fWeightsD0Hists) this->CreateHistsD0Weights();
static H1FloatPtr wL4("Weight1");
fWeightsD0Hists->At(0)->Fill(ds->GetD0Mass(), *wL4);
fWeightsD0Hists->At(1)->Fill(ds->GetPt(), *wL4);
fWeightsD0Hists->At(2)->Fill(ds->GetEta(), *wL4);
if(this->IsS83NoL4Check(ds)){
fWeightsD0HistsS83->At(0)->Fill(ds->GetD0Mass(), *wL4);
fWeightsD0HistsS83->At(1)->Fill(ds->GetPt(), *wL4);
fWeightsD0HistsS83->At(2)->Fill(ds->GetEta(), *wL4);
}
}
//_____________________________________________________
//_____________________________________________________
//_____________________________________________________
//_____________________________________________________
//_____________________________________________________
Bool_t GFDstarAnalyseData::IsST(Int_t subTrig) const
{
// true if subtrigger 'subTrig' was fired as L1 actual && as L4 verified
static H1BytePtr subTrigL4v("Il4vst");
static H1BytePtr subTrigL1ac("Il1ac");
return (subTrigL4v[subTrig] && subTrigL1ac[subTrig]);
}
//_____________________________________________________
Bool_t GFDstarAnalyseData::IsS83(const H1PartDstar* ds) const
{
// checks standard IsS83NoL4Check(ds) and tests whether the event is found by L4
// cut on photon energy put out!
// // and that there is not too much energy in photon tagger
return (this->IsS83NoL4Check(ds)
&& this->IsL4Found(kL4FinderBit, ds)
);// && !this->IsPhotonE());
}
//_____________________________________________________
Bool_t GFDstarAnalyseData::IsS83NoL4Check(const H1PartDstar* ds) const
{
// subtrig 83, y_elec, x_tag33 and HV are checked
// and zvtx
// if ds != NULL (NULL is default) cuts on pt of ds
const Double_t y = this->GetY33();
return (y >= fEventCutyMinS83 && y < fEventCutyMaxS83
&& this->IsS83NoYtagL4Check(ds));
}
//_____________________________________________________
Bool_t GFDstarAnalyseData::IsS83NoYtagL4Check(const H1PartDstar* ds) const
{
// subtrig 83, x_tag33 and HV are checked
// if ds != NULL (NULL is default) cuts on pt of ds
const Double_t ptCut = fSteer->GetPtBins33()->At(0);
if(ds && (ds->GetPt() < ptCut )) return kFALSE;
// static Bool_t first = kTRUE;
// if(first){
// first = kFALSE;
// this->Info("IsS83NoYtagL4Check", "ST61 cuts!");
// }
// static H1FloatPtr q2e("Q2e");
// return (this->IsST(61) && *q2e > 2.);
static H1FloatPtr xTag33("Xtag33");
return (this->IsST(83)
&& TMath::Abs(*xTag33) < fEventCutXS83
);
}
//_____________________________________________________
Bool_t GFDstarAnalyseData::IsS83NonTrig(const H1PartDstar* ds) const
{
// true if ds is in ET33 sample without looking at L4/L1 triggers
const Double_t ptCut = fSteer->GetPtBins33()->At(0);
if(ds && (ds->GetPt() < ptCut)) return kFALSE;
const Double_t y = this->GetY33();
static H1FloatPtr xTag33("Xtag33");
return (y >= fEventCutyMinS83 && y < fEventCutyMaxS83
&& TMath::Abs(*xTag33) < fEventCutXS83
);
}
//_____________________________________________________
Bool_t GFDstarAnalyseData::IsPhotonE() const
{
// true if photon tagger energy is above cut
static H1FloatPtr phTagE("Phtag");
if(*phTagE > fEphotonTagCut) return kTRUE;
else return kFALSE;
}
//_____________________________________________________
Bool_t GFDstarAnalyseData::IsS84(const H1PartDstar* ds) const
{
// checks standard IsS84NoL4Check(ds) and tests whether the event is found by L4
// and that there is not too much energy in photon tagger
return (this->IsS84NoL4Check(ds)
&& this->IsL4Found(kL4FinderBit, ds)
);
}
//_____________________________________________________
Bool_t GFDstarAnalyseData::IsS84NoL4Check(const H1PartDstar* ds) const
{
// S84 and HV are checked
// if ds != NULL (NULL is default) cuts on eta of ds
if(ds && (ds->GetEta() < fSteer->GetEtaBins44()->At(0))) return kFALSE;
const Double_t y = this->GetY44();
return (this->IsST(84)
&& y < fEventCutyMaxS84 && y >= fEventCutyMinS84
&& !this->IsPhotonE()
// && (!ds || this->IsSumEt(ds))
// && this->IsZvtxCut()
);
}
//_____________________________________________________
Bool_t GFDstarAnalyseData::IsS84NonTrig(const H1PartDstar* ds) const
{
// true if ds is in ET44 sample without looking at L4/L1 triggers
if(ds && ds->GetEta() < fSteer->GetEtaBins44()->At(0)) return kFALSE;
const Double_t y = this->GetY44();
return (y >= fEventCutyMinS84 && y < fEventCutyMaxS84
);
}
//_____________________________________________________
Bool_t GFDstarAnalyseData::IsL4Found(Int_t hqsel45Bit, const H1PartDstar *ds, Int_t hqselMode) const
{
// true if bit 'hqsel45Bit' of L4 charm finder is set in given mode
// looking into online bank YECL
static H1YeclBankPtr yecl; // output of original open charm finder on L4
if(this->GFDstarAnalyse::IsL4Found(hqsel45Bit, hqselMode, yecl)){
return kTRUE;
// } else if(ds && ds->GetPt() > 6.){
// const Int_t help[] = {4,5,6,7,8,9,10,11,12,13,14,15,16,17,18};// physics classes
// const TArrayI classes(sizeof(help)/sizeof(help[0]), help);
// if(this->OneL4ClassGiven(classes)){
// // static Bool_t first = kTRUE;
// // if(first){
// // first = kFALSE;
// // this->Info("IsL4Found", "pt(D*) = %.2f not by HQSEL, but physics classes",ds->GetPt());
// // }
// return kTRUE;
// }
}
return kFALSE;
}
//_____________________________________________________
Bool_t GFDstarAnalyseData::IsL4Ref(Int_t subtrig) const
{
switch(subtrig){
case 83:
return this->OneL4ClassGiven(fIndepL4Class83);
case 84:
return this->OneL4ClassGiven(fIndepL4Class84);
default:
this->Error("IsL4Ref", "Don't know subtrigger %d", subtrig);
return kFALSE;
}
}
//_____________________________________________________
Float_t GFDstarAnalyseData::GetWgammaP33() const
{
// static Bool_t first = kTRUE;
// if(first) {
// this->Warning("GetWgammaP33", "Using manipulated routine: GetY33!");
// first = kFALSE;
// }
static H1FloatPtr wGammaP33("WgammaP33");
return *wGammaP33;
}
//_____________________________________________________
Float_t GFDstarAnalyseData::GetWgammaP44() const
{
static H1FloatPtr wGammaPjb("WgammaPjb");
return *wGammaPjb;
}
//_____________________________________________________
Float_t GFDstarAnalyseData::GetY33() const
{
static H1FloatPtr y33("Ye33");
return *y33;
// static H1FloatPtr y("Ye");
// static Bool_t first = kTRUE;
// if(first) {
// this->Warning("GetY33", "Use ye from e-finder");
// first = kFALSE;
// }
// return *y;
// static Bool_t first = kTRUE;
// if(first) {
// this->Warning("GetY33", "Using manipulated routine: * 0.985!");
// first = kFALSE;
// }
// return *y33 * 0.985;
}
//_____________________________________________________
Float_t GFDstarAnalyseData::GetY44() const
{
return this->GetYjb();
}
//_____________________________________________________
Double_t GFDstarAnalyseData::GetXgammaMassHelp(const H1Part* dstar,
const H1PartJet* jet) const
{
if(dstar->InheritsFrom(H1PartDstar::Class())){
return this->GetXgammaMass(static_cast<const H1PartDstar*>(dstar), jet,
this->GetYjb());// this->GetY33());
// const H1Part *j = jet;
// return this->GetXgamma(dstar, j, this->GetY33());
} else {
this->Fatal("GetXgammaMassHelp", "not H1PartDstar");
return 0.;
}
}
//_____________________________________________________
Double_t GFDstarAnalyseData::GetXgammaMassDiJetHelp(const H1Part *dstar,
const H1PartJet *dsJet,
const H1PartJet *othJet) const
{
if(dstar->InheritsFrom(H1PartDstar::Class())){
return this->GetXgammaMassDiJet(static_cast<const H1PartDstar*>(dstar), dsJet, othJet,
this->GetYjb());// this->GetY33());
} else {
this->Fatal("GetXgammaMassDiJetHelp", "not H1PartDstar");
return 0.;
}
}
//_____________________________________________________
Double_t GFDstarAnalyseData::GetXpMassHelp(const H1Part* dstar,
const H1PartJet* jet) const
{
if(dstar->InheritsFrom(H1PartDstar::Class())){
return this->GetXpMass(static_cast<const H1PartDstar*>(dstar), jet);
} else {
this->Fatal("GetXpMassHelp", "not H1PartDstar");
return 0.;
}
}
//_____________________________________________________
Bool_t GFDstarAnalyseData::IsHv() const
{
// obsolete!
const Bool_t result = (this->IsCjcHv() && this->IsLArHv() && this->IsLumiHv()
&& this->IsTofHv() && this->IsFpcHv()
&& this->IsCipCopHv());
return result;
}
//_____________________________________________________
Bool_t GFDstarAnalyseData::IsCjcHv() const
{
static H1ShortPtr hv1("Mhv1");
static H1ShortPtr hv2("Mhv2");
static H1ShortPtr bbl3("Mbbl3");
return (!hv1[0] && !hv1[1] && !hv2[0] && !hv2[1] && !hv2[2] && !bbl3[0]);
}
//_____________________________________________________
Bool_t GFDstarAnalyseData::IsLArHv() const
{
static H1ShortPtr hv1("Mhv1");
static H1ShortPtr bbl3("Mbbl3");
return (!hv1[11] && !bbl3[6]);
}
//_____________________________________________________
Bool_t GFDstarAnalyseData::IsLumiHv() const
{
static H1ShortPtr hv1("Mhv1");
static H1ShortPtr hv2("Mhv2");
static H1ShortPtr bbl3("Mbbl3");
return (!hv1[18] && !hv1[19] && !hv1[20]
&& !hv2[17] && !hv2[18] && !hv2[19] && !bbl3[12]);
}
//_____________________________________________________
Bool_t GFDstarAnalyseData::IsTofHv() const
{
static H1ShortPtr hv1("Mhv1");
static H1ShortPtr bbl3("Mbbl3");
return (!hv1[14] && !bbl3[9]);
}
//_____________________________________________________
Bool_t GFDstarAnalyseData::IsFpcHv() const
{
static H1ShortPtr hv2("Mhv2");
static H1ShortPtr bbl3("Mbbl3");
// return (!hv2[13] && !bbl3[4]);
if (!hv2[13] && !bbl3[4]){
static H1ShortPtr hv1("Mhv1");
if(hv1[9]){
this->Error("IsFpcHv", "HV1 (prior not checked...) off!");
}
return kTRUE;
} else
return kFALSE;
}
//_____________________________________________________
Bool_t GFDstarAnalyseData::IsCipCopHv() const
{
static H1ShortPtr hv1("Mhv1");
static H1ShortPtr hv2("Mhv2");
static H1ShortPtr bbl3("Mbbl3");
return (!hv1[7] && !hv1[8] && !hv2[11] && !hv2[12] && !bbl3[14]);
}
//_____________________________________________________
Double_t GFDstarAnalyseData::GetWeight(Int_t /*trig*/, const H1PartDstar */*ds*/) const
{
return 1.;
}
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.