#include <TROOT.h>
#include <TSystem.h>
#include <TParticle.h>
-#include <TH1D.h>
#include <TF1.h>
#include <TGraph.h>
-//#include <TCanvas.h>
-#include <TFrame.h>
+#include <TCanvas.h>
+#include <TStyle.h>
+//#include <TFrame.h>
// --- Standard library ---
#include "AliPHOSRawStream.h"
#include "AliRawReaderFile.h"
#include "AliLog.h"
+#include "AliCDBLocal.h"
+#include "AliCDBStorage.h"
+#include "AliCDBManager.h"
ClassImp(AliPHOSGetter)
-AliPHOSGetter * AliPHOSGetter::fgObjGetter = 0 ;
-AliPHOSLoader * AliPHOSGetter::fgPhosLoader = 0;
+AliPHOSGetter * AliPHOSGetter::fgObjGetter = 0 ;
+AliPHOSLoader * AliPHOSGetter::fgPhosLoader = 0;
+AliPHOSCalibData* AliPHOSGetter::fgCalibData = 0;
Int_t AliPHOSGetter::fgDebug = 0;
// TFile * AliPHOSGetter::fgFile = 0 ;
if (rl->GetAliRun() == 0x0) {
rl->LoadgAlice();
gAlice = rl->GetAliRun(); // should be removed
+ rl->LoadHeader();
}
}
fgPhosLoader = dynamic_cast<AliPHOSLoader*>(rl->GetLoader("PHOSLoader"));
else
fgPhosLoader->SetTitle(version);
-
// initialize data members
SetDebug(0) ;
fBTE = 0 ;
fESDFile = 0 ;
fESD = 0 ;
fESDTree = 0 ;
+ fRawDigits = kFALSE ;
+
}
//____________________________________________________________________________
AliPHOSGetter::~AliPHOSGetter()
{
// dtor
- delete fgPhosLoader ;
- fgPhosLoader = 0 ;
- delete fBTE ;
- fBTE = 0 ;
- fPrimaries->Delete() ;
- delete fPrimaries ;
- fgObjGetter = 0;
+ if(fgPhosLoader){
+ delete fgPhosLoader ;
+ fgPhosLoader = 0 ;
+ }
+ if(fBTE){
+ delete fBTE ;
+ fBTE = 0 ;
+ }
+ if(fPrimaries){
+ fPrimaries->Delete() ;
+ delete fPrimaries ;
+ }
if (fESD)
delete fESD ;
if (fESDTree)
- delete fESDTree ;
+ delete fESDTree ;
+
+ fgObjGetter = 0;
}
//____________________________________________________________________________
}
//____________________________________________________________________________
-TObjArray * AliPHOSGetter::CpvRecPoints()
+TObjArray * AliPHOSGetter::CpvRecPoints() const
{
// asks the Loader to return the CPV RecPoints container
}
//____________________________________________________________________________
-TClonesArray * AliPHOSGetter::Digits()
+TClonesArray * AliPHOSGetter::Digits() const
{
// asks the Loader to return the Digits container
//____________________________________________________________________________
-TObjArray * AliPHOSGetter::EmcRecPoints()
+TObjArray * AliPHOSGetter::EmcRecPoints() const
{
// asks the Loader to return the EMC RecPoints container
}
//____________________________________________________________________________
-TClonesArray * AliPHOSGetter::TrackSegments()
+TClonesArray * AliPHOSGetter::TrackSegments() const
{
// asks the Loader to return the TrackSegments container
}
//____________________________________________________________________________
-TClonesArray * AliPHOSGetter::RecParticles()
+TClonesArray * AliPHOSGetter::RecParticles() const
{
// asks the Loader to return the TrackSegments container
{
// Reads the content of all Tree's S, D and R
- if ( event >= MaxEvent() ) {
- Error("Event", "%d not found in TreeE !", event) ;
- return ;
- }
+// if ( event >= MaxEvent() ) {
+// Error("Event", "%d not found in TreeE !", event) ;
+// return ;
+// }
AliRunLoader * rl = AliRunLoader::GetRunLoader(PhosLoader()->GetTitle());
- // checks if we are dealing with test-beam data
- TBranch * btb = rl->TreeE()->GetBranch("AliPHOSBeamTestEvent") ;
- if(btb){
- if(!fBTE)
- fBTE = new AliPHOSBeamTestEvent() ;
- btb->SetAddress(&fBTE) ;
- btb->GetEntry(event) ;
- }
- else{
- if(fBTE){
- delete fBTE ;
- fBTE = 0 ;
- }
- }
+// // checks if we are dealing with test-beam data
+// TBranch * btb = rl->TreeE()->GetBranch("AliPHOSBeamTestEvent") ;
+// if(btb){
+// if(!fBTE)
+// fBTE = new AliPHOSBeamTestEvent() ;
+// btb->SetAddress(&fBTE) ;
+// btb->GetEntry(event) ;
+// }
+// else{
+// if(fBTE){
+// delete fBTE ;
+// fBTE = 0 ;
+// }
+// }
// Loads the type of object(s) requested
rl->GetEvent(event) ;
- if( strstr(opt,"X") || (strcmp(opt,"")==0) )
+ if(strstr(opt,"X") || (strcmp(opt,"")==0)){
ReadPrimaries() ;
-
- if(strstr(opt,"H") )
+ }
+
+ if(strstr(opt,"H") ){
ReadTreeH();
-
- if(strstr(opt,"S") )
+ }
+
+ if(strstr(opt,"S") ){
ReadTreeS() ;
-
- if( strstr(opt,"D") )
+ }
+
+ if(strstr(opt,"D") ){
ReadTreeD() ;
-
- if( strstr(opt,"R") )
+ }
+
+ if(strstr(opt,"R") ){
ReadTreeR() ;
+ }
- if( strstr(opt,"T") )
+ if( strstr(opt,"T") ){
ReadTreeT() ;
+ }
- if( strstr(opt,"P") )
+ if( strstr(opt,"P") ){
ReadTreeP() ;
+ }
- if( strstr(opt,"E") )
+ if( strstr(opt,"E") ){
ReadTreeE(event) ;
+ }
- if( strstr(opt,"W") )
- ReadRaw(event) ;
-
+}
+
+
+//____________________________________________________________________________
+void AliPHOSGetter::Event(AliRawReader *rawReader, const char* opt)
+{
+ // Reads the raw event from rawReader
-// if( strstr(opt,"Q") )
-// ReadTreeQA() ;
+ AliRunLoader * rl = AliRunLoader::GetRunLoader(PhosLoader()->GetTitle());
+
+ if( strstr(opt,"W") ){
+ rawReader->NextEvent();
+ Int_t iEvent = rl->GetEventNumber();
+ rl->GetEvent(iEvent);
+ ReadRaw(rawReader) ;
+ }
}
}
//____________________________________________________________________________
- TClonesArray * AliPHOSGetter::Hits()
+ TClonesArray * AliPHOSGetter::Hits() const
{
// asks the loader to return the Hits container
// Creates and returns the pointer of the unique instance
// Must be called only when the environment has changed
- //::Info("Instance","alirunFileName=%s version=%s openingOption=%s",alirunFileName,version,openingOption);
-
if(!fgObjGetter){ // first time the getter is called
fgObjGetter = new AliPHOSGetter(alirunFileName, version, openingOption) ;
}
return rv ;
}
-
//____________________________________________________________________________
-void AliPHOSGetter::FitRaw(Bool_t lowGainFlag, TGraph * gLowGain, TGraph * gHighGain, TF1* signalF, Int_t & amp, Double_t & time)
+void AliPHOSGetter::FitRaw(Bool_t lowGainFlag, TGraph * gLowGain, TGraph * gHighGain, TF1* signalF, Double_t & energy, Double_t & time) const
{
// Fits the raw signal time distribution
const Int_t kNoiseThreshold = 0 ;
Double_t timezero1 = 0., timezero2 = 0., timemax = 0. ;
Double_t signal = 0., signalmax = 0. ;
- Double_t energy = time = 0. ;
+ time = 0. ;
+ energy = 0. ;
if (lowGainFlag) {
timezero1 = timezero2 = signalmax = timemax = 0. ;
if ( timezero1 + PHOS()->GetRawFormatTimePeak() < PHOS()->GetRawFormatTimeMax() * 0.4 ) { // else its noise
signalF->SetParameter(2, signalmax) ;
signalF->SetParameter(3, timezero1) ;
- gLowGain->Fit(signalF, "QRON", "", 0., timezero2); //, "QRON") ;
+ gLowGain->Fit(signalF, "QRO", "", 0., timezero2); //, "QRON") ;
energy = signalF->GetParameter(2) ;
time = signalF->GetMaximumX() - PHOS()->GetRawFormatTimePeak() - PHOS()->GetRawFormatTimeTrigger() ;
}
if ( timezero1 + PHOS()->GetRawFormatTimePeak() < PHOS()->GetRawFormatTimeMax() * 0.4 ) { // else its noise
signalF->SetParameter(2, signalmax) ;
signalF->SetParameter(3, timezero1) ;
- gHighGain->Fit(signalF, "QRON", "", 0., timezero2) ;
+ gHighGain->Fit(signalF, "QRO", "", 0., timezero2) ;
energy = signalF->GetParameter(2) ;
time = signalF->GetMaximumX() - PHOS()->GetRawFormatTimePeak() - PHOS()->GetRawFormatTimeTrigger() ;
}
}
-
- if (time == 0. && energy == 0.)
- amp = 0 ;
- else {
- AliPHOSDigitizer * digitizer = Digitizer() ;
- amp = static_cast<Int_t>( (energy - digitizer->GetEMCpedestal()) / digitizer->GetEMCchannel() + 0.5 ) ;
+ if (time == 0) energy = 0 ;
+}
+
+//____________________________________________________________________________
+Int_t AliPHOSGetter::CalibrateRaw(Double_t energy, Int_t *relId)
+{
+ // Convert energy into digitized amplitude for a cell relId
+ // It is a user responsilibity to open CDB and set
+ // AliPHOSCalibData object by the following operators:
+ //
+ // AliCDBLocal *loc = new AliCDBLocal("deCalibDB");
+ // AliPHOSCalibData* clb = (AliPHOSCalibData*)AliCDBStorage::Instance()
+ // ->Get(path_to_calibdata,run_number);
+ // AliPHOSGetter* gime = AliPHOSGetter::Instance("galice.root");
+ // gime->SetCalibData(clb);
+
+ if (CalibData() == 0)
+ Warning("CalibrateRaw","Calibration DB is not initiated!");
+
+ Int_t module = relId[0];
+ Int_t column = relId[3];
+ Int_t row = relId[2];
+
+ Float_t gainFactor = 0.0015; // width of one Emc ADC channel in GeV
+ Float_t pedestal = 0.005; // Emc pedestals
+
+ if(CalibData()) {
+ gainFactor = CalibData()->GetADCchannelEmc (module,column,row);
+ pedestal = CalibData()->GetADCpedestalEmc(module,column,row);
}
- // dessin
-// TCanvas * c1 = new TCanvas("c1","A Simple Graph Example",200,10,700,500);
-// c1->SetFillColor(42);
-// c1->SetGrid();
-// gLowGain->SetLineColor(2);
-// gLowGain->SetLineWidth(4);
-// gLowGain->SetMarkerColor(4);
-// gLowGain->SetMarkerStyle(21);
-// gLowGain->SetTitle("Lowgain");
-// gLowGain->GetXaxis()->SetTitle("X title");
-// gLowGain->GetYaxis()->SetTitle("Y title");
-// gLowGain->Draw("ACP");
-
-// c1->Update();
-// c1->GetFrame()->SetFillColor(21);
-// c1->GetFrame()->SetBorderSize(12);
-// c1->Modified();
-
-// TCanvas * c2 = new TCanvas("c2","A Simple Graph Example",200,10,700,500);
-// c2->SetFillColor(42);
-// c2->SetGrid();
-// gHighGain->SetLineColor(2);
-// gHighGain->SetLineWidth(4);
-// gHighGain->SetMarkerColor(4);
-// gHighGain->SetMarkerStyle(21);
-// gHighGain->SetTitle("Highgain");
-// gHighGain->GetXaxis()->SetTitle("X title");
-// gHighGain->GetYaxis()->SetTitle("Y title");
-// gHighGain->Draw("ACP");
-// c2->Update();
-// c2->GetFrame()->SetFillColor(21);
-// c2->GetFrame()->SetBorderSize(12);
-// c2->Modified();
+ Int_t amp = static_cast<Int_t>( (energy - pedestal) / gainFactor + 0.5 ) ;
+ return amp;
}
-
//____________________________________________________________________________
-Int_t AliPHOSGetter::ReadRaw(Int_t event)
+Int_t AliPHOSGetter::ReadRaw(AliRawReader *rawReader)
{
// reads the raw format data, converts it into digits format and store digits in Digits()
// container.
- AliRawReaderFile rawReader(event) ;
- AliPHOSRawStream in(&rawReader);
-
+ AliPHOSRawStream in(rawReader);
+
Bool_t first = kTRUE ;
TF1 * signalF = new TF1("signal", AliPHOS::RawResponseFunction, 0, PHOS()->GetRawFormatTimeMax(), 4);
signalF->SetParNames("Charge", "Gain", "Amplitude", "TimeZero") ;
- Int_t relId[4], id ;
+ Int_t relId[4], id =0;
Bool_t lowGainFlag = kFALSE ;
-
+
TClonesArray * digits = Digits() ;
digits->Clear() ;
Int_t idigit = 0 ;
- Int_t amp = 0 ;
- Double_t time = 0. ;
+ Int_t amp = 0 ;
+ Double_t energy = 0. ;
+ Double_t time = 0. ;
TGraph * gLowGain = new TGraph(PHOS()->GetRawFormatTimeBins()) ;
TGraph * gHighGain= new TGraph(PHOS()->GetRawFormatTimeBins()) ;
+ gLowGain ->SetTitle("Low gain channel");
+ gHighGain->SetTitle("High gain channel");
while ( in.Next() ) { // PHOS entries loop
if ( (in.IsNewRow() || in.IsNewColumn() || in.IsNewModule()) ) {
if (!first) {
- FitRaw(lowGainFlag, gLowGain, gHighGain, signalF, amp, time) ;
- if (amp > 0) {
- new((*digits)[idigit]) AliPHOSDigit( -1, id, amp, time) ;
+ FitRaw(lowGainFlag, gLowGain, gHighGain, signalF, energy, time) ;
+ amp = (Int_t)energy;
+ if (energy > 0) {
+ new((*digits)[idigit]) AliPHOSDigit( -1, id, (Float_t)energy, time) ;
idigit++ ;
}
Int_t index ;
for (index = 0; index < PHOS()->GetRawFormatTimeBins(); index++) {
- gLowGain->SetPoint(index, index * PHOS()->GetRawFormatTimeMax() / PHOS()->GetRawFormatTimeBins(), 0) ;
- gHighGain->SetPoint(index, index * PHOS()->GetRawFormatTimeMax() / PHOS()->GetRawFormatTimeBins(), 0) ;
+ gLowGain ->SetPoint(index,
+ index * PHOS()->GetRawFormatTimeMax() /
+ PHOS()->GetRawFormatTimeBins(), 0) ;
+ gHighGain->SetPoint(index,
+ index * PHOS()->GetRawFormatTimeMax() /
+ PHOS()->GetRawFormatTimeBins(), 0) ;
}
}
first = kFALSE ;
relId[0] = in.GetModule() ;
if ( relId[0] >= PHOS()->GetRawFormatLowGainOffset() ) {
- relId[0] -= PHOS()->GetRawFormatLowGainOffset() ;
- lowGainFlag = kTRUE ;
- } else
- lowGainFlag = kFALSE ;
- relId[1] = 0 ;
- relId[2] = in.GetRow() ;
- relId[3] = in.GetColumn() ;
- PHOSGeometry()->RelToAbsNumbering(relId, id) ;
+ relId[0] -= PHOS()->GetRawFormatLowGainOffset() ;
+ lowGainFlag = kTRUE ;
+ } else
+ lowGainFlag = kFALSE ;
+ relId[1] = 0 ;
+ relId[2] = in.GetRow() ;
+ relId[3] = in.GetColumn() ;
+ PHOSGeometry()->RelToAbsNumbering(relId, id) ;
}
if (lowGainFlag)
gLowGain->SetPoint(in.GetTime(),
- in.GetTime()* PHOS()->GetRawFormatTimeMax() / PHOS()->GetRawFormatTimeBins(),
- in.GetSignal()) ;
+ in.GetTime()* PHOS()->GetRawFormatTimeMax() /
+ PHOS()->GetRawFormatTimeBins(),
+ in.GetSignal()) ;
else
gHighGain->SetPoint(in.GetTime(),
- in.GetTime() * PHOS()->GetRawFormatTimeMax() / PHOS()->GetRawFormatTimeBins(),
- in.GetSignal() ) ;
+ in.GetTime() * PHOS()->GetRawFormatTimeMax() /
+ PHOS()->GetRawFormatTimeBins(),
+ in.GetSignal() ) ;
} // PHOS entries loop
- FitRaw(lowGainFlag, gLowGain, gHighGain, signalF, amp, time) ;
- if (amp > 0 ) {
- new((*digits)[idigit]) AliPHOSDigit( -1, id, amp, time) ;
+ FitRaw(lowGainFlag, gLowGain, gHighGain, signalF, energy, time) ;
+ amp = (Int_t)energy;
+ if (energy > 0 ) {
+ new((*digits)[idigit]) AliPHOSDigit( -1, id, (Float_t)energy, time) ;
idigit++ ;
}
digits->Sort() ;
delete signalF ;
- delete gLowGain, gHighGain ;
+ delete gLowGain;
+ delete gHighGain ;
return digits->GetEntriesFast() ;
}
//____________________________________________________________________________
-Int_t AliPHOSGetter::ReadTreeD()
+Int_t AliPHOSGetter::ReadTreeD() const
{
// Read the Digits
}
//____________________________________________________________________________
-Int_t AliPHOSGetter::ReadTreeH()
+Int_t AliPHOSGetter::ReadTreeH() const
{
// Read the Hits
PhosLoader()->CleanHits() ;
}
//____________________________________________________________________________
-Int_t AliPHOSGetter::ReadTreeR()
+Int_t AliPHOSGetter::ReadTreeR() const
{
// Read the RecPoints
}
//____________________________________________________________________________
-Int_t AliPHOSGetter::ReadTreeT()
+Int_t AliPHOSGetter::ReadTreeT() const
{
// Read the TrackSegments
return TrackSegments()->GetEntries() ;
}
//____________________________________________________________________________
-Int_t AliPHOSGetter::ReadTreeP()
+Int_t AliPHOSGetter::ReadTreeP() const
{
// Read the RecParticles
return RecParticles()->GetEntries() ;
}
//____________________________________________________________________________
-Int_t AliPHOSGetter::ReadTreeS()
+Int_t AliPHOSGetter::ReadTreeS() const
{
// Read the SDigits
}
//____________________________________________________________________________
-TClonesArray * AliPHOSGetter::SDigits()
+TClonesArray * AliPHOSGetter::SDigits() const
{
// asks the Loader to return the Digits container
else
return 0 ;
}
+//____________________________________________________________________________
+
+AliPHOSCalibData* AliPHOSGetter::CalibData()
+{
+ // Check if the instance of AliPHOSCalibData exists, and return it
+
+ return fgCalibData;
+}