| 30 |
|
const char *GetInputName() const { return GetColName(); } |
| 31 |
|
Double_t GetPtMin() const { return fPtMin; } |
| 32 |
|
Double_t GetPtMax() const { return fPtMax; } |
| 33 |
– |
Bool_t GetLoadBranch() const { return fLoadBr; } |
| 33 |
|
void SetColName(const char *n) { fColName=n; } |
| 34 |
+ |
void SetEntriesMax(Int_t e) { fEntriesMax = e; } |
| 35 |
|
void SetEtaMin(Double_t e) { fEtaMin = e; } |
| 36 |
|
void SetEtaMax(Double_t e) { fEtaMax = e; } |
| 37 |
|
void SetInputName(const char *n) { SetColName(n); } |
| 38 |
– |
void SetLoadBranch(Bool_t b) { fLoadBr = b; } |
| 38 |
|
void SetPtMin(Double_t pt) { fPtMin = pt; } |
| 39 |
|
void SetPtMax(Double_t pt) { fPtMax = pt; } |
| 40 |
|
|
| 48 |
|
Double_t fPtMax; //maximum pt |
| 49 |
|
Double_t fEtaMin; //minimum eta |
| 50 |
|
Double_t fEtaMax; //maximum eta |
| 51 |
< |
Bool_t fLoadBr; //=true then load branch (def=1) |
| 51 |
> |
Int_t fEntriesMax; //maximum number of entries |
| 52 |
|
const Collection<T> *fCol; //!pointer to collection |
| 53 |
|
TH1D *fPtHist; //!pt histogram |
| 54 |
|
TH1D *fEtaHist; //!eta histogram |
| 55 |
+ |
TH1D *fEntHist; //!entries histogram |
| 56 |
|
|
| 57 |
|
ClassDefT(PlotKineMod, 1) // Plot kinematics module |
| 58 |
|
}; |
| 67 |
|
fPtMax(5000), |
| 68 |
|
fEtaMin(-10), |
| 69 |
|
fEtaMax(10), |
| 70 |
< |
fLoadBr(kTRUE), |
| 70 |
> |
fEntriesMax(250), |
| 71 |
|
fCol(0), |
| 72 |
|
fPtHist(0), |
| 73 |
< |
fEtaHist(0) |
| 73 |
> |
fEtaHist(0), |
| 74 |
> |
fEntHist(0) |
| 75 |
|
{ |
| 76 |
|
// Constructor. |
| 77 |
|
|
| 78 |
< |
SetFillHist(1); |
| 78 |
< |
} |
| 79 |
< |
|
| 80 |
< |
//-------------------------------------------------------------------------------------------------- |
| 81 |
< |
template<class T> |
| 82 |
< |
Bool_t mithep::PlotKineMod<T>::Load() |
| 83 |
< |
{ |
| 84 |
< |
// Load data from branch or get pointer from event. |
| 85 |
< |
|
| 86 |
< |
if (GetLoadBranch()) |
| 87 |
< |
LoadBranch(GetColName()); |
| 88 |
< |
else |
| 89 |
< |
fCol = GetObjThisEvt<Collection<T> >(GetColName()); |
| 90 |
< |
|
| 91 |
< |
return (fCol!=0); |
| 78 |
> |
SetFillHist(kTRUE); |
| 79 |
|
} |
| 80 |
|
|
| 81 |
|
//-------------------------------------------------------------------------------------------------- |
| 84 |
|
{ |
| 85 |
|
// Process entries of the tree: Just load the branch and fill the histograms. |
| 86 |
|
|
| 87 |
< |
if (!Load()) { |
| 87 |
> |
if (!LoadEventObject(GetColName(), fCol)) { |
| 88 |
|
SendError(kAbortModule, "Process", "Could not load data!"); |
| 89 |
|
return; |
| 90 |
|
} |
| 93 |
|
return; |
| 94 |
|
|
| 95 |
|
UInt_t ents=fCol->GetEntries(); |
| 96 |
+ |
fEntHist->Fill(ents); |
| 97 |
|
for(UInt_t i=0;i<ents;++i) { |
| 98 |
|
const T *p = fCol->At(i); |
| 99 |
|
Double_t pt = p->Pt(); |
| 117 |
|
{ |
| 118 |
|
// Request a branch and create the histograms. |
| 119 |
|
|
| 120 |
< |
if (GetLoadBranch()) |
| 133 |
< |
ReqBranch(GetColName(), fCol); |
| 120 |
> |
ReqEventObject(GetColName(), fCol); |
| 121 |
|
|
| 122 |
|
if (GetFillHist()) { |
| 123 |
|
Int_t ptbins = (Int_t)((fPtMax-fPtMin)/2.5); |
| 124 |
|
AddTH1(fPtHist,"hPtHist",";p_{t} [GeV];#",ptbins,fPtMin,fPtMax); |
| 125 |
|
Int_t etabins = (Int_t)((fEtaMax-fEtaMin)/0.1); |
| 126 |
|
AddTH1(fEtaHist,"hEtaHist",";#eta;#",etabins,fEtaMin,fEtaMax); |
| 127 |
+ |
AddTH1(fEntHist,"hEntriesHist",";#entries;#",fEntriesMax,-0.5,fEntriesMax-0.5); |
| 128 |
|
} |
| 129 |
|
} |
| 130 |
|
#endif |
