ROOT logo
AliRoot » TRD » AliTRDCalibraFillHisto

class AliTRDCalibraFillHisto: public TObject

 * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
 *                                                                        *
 * Author: The ALICE Off-line Project.                                    *
 * Contributors are mentioned in the code where appropriate.              *
   *                                                                        *
   * Permission to use, copy, modify and distribute this software and its   *
  * documentation strictly for non-commercial purposes is hereby granted   *
    * without fee, provided that the above copyright notice appears in all   *
    * copies and that both the copyright notice and this permission notice   *
appear in the supporting documentation. The authors make no claims
about the suitability of this software for any purpose. It is
provided "as is" without express or implied warranty.

Function Members (Methods)

public:
AliTRDCalibraFillHisto(const AliTRDCalibraFillHisto& c)
voidTObject::AbstractMethod(const char* method) const
voidAnalyseLinearFitter()
virtual voidTObject::AppendPad(Option_t* option = "")
virtual voidTObject::Browse(TBrowser* b)
static TClass*Class()
virtual const char*TObject::ClassName() const
virtual voidTObject::Clear(Option_t* = "")
virtual TObject*TObject::Clone(const char* newname = "") const
virtual Int_tTObject::Compare(const TObject* obj) const
virtual voidTObject::Copy(TObject& object) const
virtual voidTObject::Delete(Option_t* option = "")MENU
static voidDestroy()
voidDestroyDebugStreamer()
virtual Int_tTObject::DistancetoPrimitive(Int_t px, Int_t py)
virtual voidTObject::Draw(Option_t* option = "")
virtual voidTObject::DrawClass() constMENU
virtual TObject*TObject::DrawClone(Option_t* option = "") constMENU
virtual voidTObject::Dump() constMENU
virtual voidTObject::Error(const char* method, const char* msgfmt) const
virtual voidTObject::Execute(const char* method, const char* params, Int_t* error = 0)
virtual voidTObject::Execute(TMethod* method, TObjArray* params, Int_t* error = 0)
virtual voidTObject::ExecuteEvent(Int_t event, Int_t px, Int_t py)
virtual voidTObject::Fatal(const char* method, const char* msgfmt) const
virtual TObject*TObject::FindObject(const char* name) const
virtual TObject*TObject::FindObject(const TObject* obj) const
AliTRDCalibraVector*GetCalibraVector() const
TH2I*GetCH2d()
Bool_tGetCH2dOn() const
Bool_tGetCutWithVdriftCalib() const
Short_tGetDifference() const
virtual Option_t*TObject::GetDrawOption() const
static Long_tTObject::GetDtorOnly()
Int_t*GetEntriesLinearFitter() const
AliTRDCalibraExbAltFit*GetExbAltFit() const
Bool_tGetFillWithZero() const
Bool_tGetHisto2d() const
virtual const char*TObject::GetIconName() const
Bool_tGetLimitChargeIntegration() const
TLinearFitter*GetLinearFitter(Int_t detector, Bool_t force = kFALSE)
TObjArrayGetLinearFitterArray() const
Bool_tGetLinearFitterDebugOn() const
Bool_tGetLinearFitterOn() const
Float_tGetMaxCluster() const
Double_t*GetMeanMedianRMSNumberCH()
Double_t*GetMeanMedianRMSNumberLinearFitter() const
virtual const char*TObject::GetName() const
Short_tGetNbMaxCluster() const
Bool_tGetNormalizeNbOfCluster() const
Short_tGetNumberBinCharge() const
Short_tGetNumberBinPRF() const
Short_tGetNumberClusters() const
Short_tGetNumberClustersf() const
Short_tGetNumberGroupsPRF() const
virtual char*TObject::GetObjectInfo(Int_t px, Int_t py) const
static Bool_tTObject::GetObjectStat()
virtual Option_t*TObject::GetOption() const
TProfile2D*GetPH2d(Int_t nbtimebin = 24, Float_t samplefrequency = 10.0)
Bool_tGetPH2dOn() const
TProfile2D*GetPRF2d() const
Bool_tGetPRF2dOn() const
Float_tGetProcent() const
Float_tGetRelativeScale() const
Int_tGetSubVersionGainUsed() const
Int_tGetSubVersionVdriftUsed() const
Float_tGetThresholdClusterPRF2() const
virtual const char*TObject::GetTitle() const
virtual UInt_tTObject::GetUniqueID() const
AliTRDCalibraVdriftLinearFit*GetVdriftLinearFit() const
Bool_tGetVector2d() const
Int_tGetVersionGainUsed() const
Int_tGetVersionVdriftUsed() const
virtual Bool_tTObject::HandleTimer(TTimer* timer)
virtual ULong_tTObject::Hash() const
virtual voidTObject::Info(const char* method, const char* msgfmt) const
virtual Bool_tTObject::InheritsFrom(const char* classname) const
virtual Bool_tTObject::InheritsFrom(const TClass* cl) const
Bool_tInit2Dhistos(Int_t nboftimebin = -1)
Bool_tInitCalDet()
virtual voidTObject::Inspect() constMENU
static AliTRDCalibraFillHisto*Instance()
voidTObject::InvertBit(UInt_t f)
virtual TClass*IsA() const
virtual Bool_tTObject::IsEqual(const TObject* obj) const
virtual Bool_tTObject::IsFolder() const
Bool_tIsHLT() const
Bool_tTObject::IsOnHeap() const
Bool_tIsPadOn(Int_t detector, Int_t row, Int_t col) const
virtual Bool_tTObject::IsSortable() const
Bool_tTObject::IsZombie() const
virtual voidTObject::ls(Option_t* option = "") const
voidTObject::MayNotUse(const char* method) const
virtual Bool_tTObject::Notify()
voidTObject::Obsolete(const char* method, const char* asOfVers, const char* removedFromVers) const
static voidTObject::operator delete(void* ptr)
static voidTObject::operator delete(void* ptr, void* vp)
static voidTObject::operator delete[](void* ptr)
static voidTObject::operator delete[](void* ptr, void* vp)
void*TObject::operator new(size_t sz)
void*TObject::operator new(size_t sz, void* vp)
void*TObject::operator new[](size_t sz)
void*TObject::operator new[](size_t sz, void* vp)
AliTRDCalibraFillHisto&operator=(const AliTRDCalibraFillHisto&)
virtual voidTObject::Paint(Option_t* option = "")
virtual voidTObject::Pop()
virtual voidTObject::Print(Option_t* option = "") const
Int_tProcessEventDAQ(AliRawReader* rawReader)
virtual Int_tTObject::Read(const char* name)
virtual voidTObject::RecursiveRemove(TObject* obj)
voidTObject::ResetBit(UInt_t f)
virtual voidTObject::SaveAs(const char* filename = "", Option_t* option = "") constMENU
virtual voidTObject::SavePrimitive(basic_ostream<char,char_traits<char> >& out, Option_t* option = "")
voidSetAllTogether(Int_t i)
voidTObject::SetBit(UInt_t f)
voidTObject::SetBit(UInt_t f, Bool_t set)
voidSetCH2dOn(Bool_t ch2don = kTRUE)
voidSetCutWithVdriftCalib(Bool_t cutWithVdriftCalib)
voidSetDebugLevel(Short_t level)
voidSetDifference(Short_t difference)
virtual voidTObject::SetDrawOption(Option_t* option = "")MENU
static voidTObject::SetDtorOnly(void* obj)
voidSetExbAltFitOn(Bool_t fiton = kTRUE)
voidSetFillWithZero(Bool_t fillWithZero)
voidSetFirstRunExB(Int_t firstRunExB)
voidSetFirstRunGain(Int_t firstRunGain)
voidSetFirstRunGainLocal(Int_t firstRunGainLocal)
voidSetFirstRunVdrift(Int_t firstRunVdrift)
voidSetHisto2d(Bool_t histo2d = kTRUE)
voidSetIsHLT(Bool_t isHLT = kTRUE)
voidSetLimitChargeIntegration(Bool_t limitChargeIntegration)
voidSetLinearFitterDebugOn(Bool_t debug = kTRUE)
voidSetLinearFitterOn(Bool_t linearfitteron = kTRUE)
voidSetMaxCluster(Float_t maxCluster)
voidSetMinNbTRDtracklets(Int_t minNbTRDtracklets)
voidSetMinTRDMomentum(Float_t minTRDMomentum)
voidSetNbMaxCluster(Short_t nbMaxCluster)
voidSetNormalizeNbOfCluster(Bool_t normalizeNbOfCluster)
voidSetNrphi(Int_t i, Short_t nrphi)
voidSetNumberBinCharge(Short_t numberBinCharge)
voidSetNumberBinPRF(Short_t numberBinPRF)
voidSetNumberClusters(Short_t numberClusters)
voidSetNumberClustersf(Short_t numberClustersf)
voidSetNumberClustersProcent(Float_t numberClustersProcent)
voidSetNumberColDAQ(Short_t numberColDAQ)
voidSetNumberGroupsPRF(Short_t numberGroupsPRF)
voidSetNumberRowDAQ(Short_t numberRowDAQ)
voidSetNz(Int_t i, Short_t nz)
static voidTObject::SetObjectStat(Bool_t stat)
voidSetPerSuperModule(Int_t i)
voidSetPH2dOn(Bool_t ph2don = kTRUE)
voidSetPRF2dOn(Bool_t prf2don = kTRUE)
voidSetProcent(Float_t procent)
voidSetRangeHistoCharge(Float_t rangeHistoCharge)
voidSetRelativeScale(Float_t relativeScale)
voidSetScaleWithTPCSignal(Bool_t scaleWithTPCSignal = kTRUE)
voidSetSubVersionExBUsed(Int_t subVersionExBUsed)
voidSetSubVersionGainLocalUsed(Int_t subVersionGainLocalUsed)
voidSetSubVersionGainUsed(Int_t subVersionGainUsed)
voidSetSubVersionVdriftUsed(Int_t subVersionVdriftUsed)
voidSetTakeSnapshot(Bool_t takesnapshot)
voidSetThresholdClusterPRF2(Float_t thresholdClusterPRF2)
voidSetThresholdClustersDAQ(Float_t thresholdClustersDAQ)
virtual voidTObject::SetUniqueID(UInt_t uid)
voidSetVector2d(Bool_t vector2d = kTRUE)
voidSetVersionExBUsed(Int_t versionExBUsed)
voidSetVersionGainLocalUsed(Int_t versionGainLocalUsed)
voidSetVersionGainUsed(Int_t versionGainUsed)
voidSetVersionVdriftUsed(Int_t versionVdriftUsed)
virtual voidShowMembers(TMemberInspector&)
Double_t*StatH(TH2* ch, Int_t i)
virtual voidStreamer(TBuffer&)
voidStreamerNVirtual(TBuffer& ClassDef_StreamerNVirtual_b)
virtual voidTObject::SysError(const char* method, const char* msgfmt) const
static voidTerminate()
Bool_tTObject::TestBit(UInt_t f) const
Int_tTObject::TestBits(UInt_t f) const
Bool_tUpdateHistogramsV1(const AliTRDtrackV1* t, const AliESDtrack* esdtrack = NULL)
virtual voidTObject::UseCurrentStyle()
virtual voidTObject::Warning(const char* method, const char* msgfmt) const
virtual Int_tTObject::Write(const char* name = 0, Int_t option = 0, Int_t bufsize = 0)
virtual Int_tTObject::Write(const char* name = 0, Int_t option = 0, Int_t bufsize = 0) const
voidWrite2d(const Char_t* filename = "TRD.calibration.root", Bool_t append = kFALSE)
protected:
Int_tCalculateCalibrationGroup(Int_t i, Int_t row, Int_t col) const
Int_tCalculateTotalNumberOfBins(Int_t i)
voidCheckGoodTrackletV0(const Int_t detector, const Int_t row, const Int_t col)
voidCheckGoodTrackletV1(const AliTRDcluster* cl)
voidClearHistos()
voidCreateCH2d(Int_t nn)
voidCreatePH2d(Int_t nn)
voidCreatePRF2d(Int_t nn)
virtual voidTObject::DoError(int level, const char* location, const char* fmt, va_list va) const
voidFillCH2d(Int_t x, Float_t y)
Int_tFillDAQ(Double_t phvalue[][144][36])
voidFillTheInfoOfTheTrackCH(Int_t nbclusters)
voidFillTheInfoOfTheTrackPH()
Bool_tFindP1TrackPHtrackletV1(const AliTRDseedV1* tracklet, Int_t nbclusters)
virtual Int_tGetLayer(Int_t d) const
virtual Int_tGetSector(Int_t d) const
virtual Int_tGetStack(Int_t d) const
Bool_tHandlePRFtrackletV1(const AliTRDseedV1* tracklet, Int_t nbclusters)
Bool_tInitCalPad(Int_t detector)
Bool_tLocalisationDetectorXbins(Int_t detector)
voidTObject::MakeZombie()
voidResetfVariablestracklet()
Float_tStoreInfoCHPHtrack(const AliTRDcluster* cl, const Double_t dqdl, const Int_t* group, const Int_t row, const Int_t col, const AliTRDcluster* cls = 0x0)
Bool_tUpdateDAQ(Int_t det, Int_t, Int_t, Int_t timebin, Float_t signal, Int_t nbtimebins)
private:
AliTRDCalibraFillHisto()
(unknown)()

Data Members

protected:
Float_t*fAmpTotalEnergy deposited in the calibration group by the track
TH2I*fCH2d2D deposited charge
Bool_tfCH2dOnChose to fill the 2D histos or vectors for the relative gain calibration
AliTRDCalDet*fCalDetGainCurrent calib object gain
AliTRDCalROC*fCalROCGainCurrent calib object gain
AliTRDcalibDB*fCalibDB! The pointer to the TRDcalibDB instance
AliTRDCalibraMode*fCalibraModeCalibration mode
AliTRDCalibraVector*fCalibraVectorThe vector object
Bool_tfCutWithVdriftCalibCutWithVdriftCalib for the gain and PH
Short_tfDebugLevelFlag for debugging
TTreeSRedirector*fDebugStreamer!Debug streamer
Int_tfDetectorPreviousTrackChange of detector
Short_tfDifferenceLimit to take the info of the most important calibration group if the track goes through 2 groups (CH)
Int_t*fEntriesCHNumber of entries CH
Int_t*fEntriesLinearFitterNumber of entries LinearFitter
AliTRDCalibraExbAltFit*fExbAltFitExB parabolic fit (alternative to vdrift linear fit)
Bool_tfExbAltFitOnEnable parabolic fit for exb
Bool_tfFillWithZeroFill with zero or not the average pulse height
Int_tfFirstRunExBFirstRunExB
Int_tfFirstRunGainFirstRunGain
Int_tfFirstRunGainLocalFirstRunGainLocal
Int_tfFirstRunVdriftFirstRunVdrift
AliTRDgeometry*fGeo! The TRD geometry
Bool_tfGoodTrackletGood tracklet
Bool_tfHisto2dChose to fill the 2D histos
Bool_tfIsHLTNow if HLT, the per detector
Bool_tfLimitChargeIntegrationIntegration range for the gain calibration
TObjArrayfLinearFitterArrayTObjArray of Linear Fitters for the detectors
Bool_tfLinearFitterDebugOnMethod with linear fit for drift velocity
Bool_tfLinearFitterOnMethod with linear fit for drift velocity
TLinearFitter*fLinearFitterTrackletlinear fitter tracklet
AliTRDCalibraVdriftLinearFit*fLinearVdriftFitInfo Linear Fit
Int_tfMCMPreviousChange of MCM
Float_tfMaxClusterMax amplitude of one cluster
Int_tfMinNbTRDtrackletsMin number of TRD tracklets
Float_tfMinTRDMomentumMin TRD momentum
Short_tfNbMaxClusterNumber of tb at the end
Short_tfNgroupprfNumber of groups in tnp bins for PRF /2.0
Bool_tfNormalizeNbOfClusterNormalize with the number of cluster for the gain
Short_tfNumberBinChargeNumber of bins for the gain factor
Short_tfNumberBinPRFNumber of bin for the PRF
Short_tfNumberClustersMinimum number of clusters in the tracklets
Float_tfNumberClustersProcentProcent of number of time bins for fNumberClusters
Short_tfNumberClustersfMaximum number of clusters in the tracklets
Short_tfNumberColDAQSize of the spot for DAQ algorithm
Short_tfNumberRowDAQSize of the spot for DAQ algorithm
Int_tfNumberTrackHow many tracks could be used (Debug for the moment)
Int_tfNumberUsedCh[2]How many tracks have been really used for the gain (0, strict; 1 with fProcent)
Int_tfNumberUsedPh[2]How many tracks have been really used for the drift velocity (0, strict; 1 with fDifference)
TProfile2D*fPH2d2D average pulse height
Bool_tfPH2dOnChose to fill the 2D histos or vectors for the drift velocity and T0
Short_t*fPHPlaceCalibration group of PH
Float_t*fPHValuePH
TProfile2D*fPRF2d2D PRF
Bool_tfPRF2dOnChose to fill the 2D histos or vectors for the pad response function calibration
Float_tfProcentLimit to take the info of the most important calibration group if the track goes through 2 groups (CH)
Int_tfROBPreviousChange of ROB
Float_tfRangeHistoChargeRange of the histo for the charge
Float_tfRelativeScaleScale of the deposited charge
Bool_tfScaleWithTPCSignalScale the gain with TPC signal (If use then ask at least 70 TPC clusters)
Float_tfSfSampling frequence
Int_tfSubVersionExBUsedSubVersionExBUsed
Int_tfSubVersionGainLocalUsedSubVersionGainUsed
Int_tfSubVersionGainUsedSubVersionGainUsed
Int_tfSubVersionVdriftUsedSubVersionVdriftUsed
Bool_tfTakeSnapshotTake from snapshot
Float_tfThresholdClusterPRF2Threshold on cluster pad signals
Float_tfThresholdClustersDAQThreshold clusters for DAQ algorithm
Int_tfTimeMaxNumber of time bins
Bool_tfVector2dChose to fill vectors
Int_tfVersionExBUsedVersionExBUsed
Int_tfVersionGainLocalUsedVersionGainUsed
Int_tfVersionGainUsedVersionGainUsed
Int_tfVersionVdriftUsedVersionVdriftUsed
static AliTRDCalibraFillHisto*fgInstanceInstance
static Bool_tfgTerminatedIf terminated

Class Charts

Inheritance Chart:
TObject
AliTRDCalibraFillHisto

Function documentation

AliTRDCalibraFillHisto * Instance()
 Singleton implementation

void Terminate()
 Singleton implementation
 Deletes the instance of this class

AliTRDCalibraFillHisto()
 Default constructor

AliTRDCalibraFillHisto(const AliTRDCalibraFillHisto& c)
 Copy constructor

void Destroy()
 Delete instance

void DestroyDebugStreamer()
 Delete DebugStreamer

void ClearHistos()
 Delete the histos

Bool_t Init2Dhistos(Int_t nboftimebin = -1)
 Init the histograms and stuff to be filled

Bool_t InitCalDet()
 Init the Gain Cal Det

Bool_t InitCalPad(Int_t detector)
 Init the Gain Cal Pad

Bool_t UpdateHistogramsV1(const AliTRDtrackV1* t, const AliESDtrack* esdtrack = NULL)
 Use AliTRDtrackV1 for the calibration

Bool_t FindP1TrackPHtrackletV1(const AliTRDseedV1* tracklet, Int_t nbclusters)
 Drift velocity calibration:
 Fit the clusters with a straight line
 From the slope find the drift velocity

Bool_t HandlePRFtrackletV1(const AliTRDseedV1* tracklet, Int_t nbclusters)
 PRF width calibration
 Assume a Gaussian shape: determinate the position of the three pad clusters
 Fit with a straight line
 Take the fitted values for all the clusters (3 or 2 pad clusters)
 Fill the PRF as function of angle of the track


void CheckGoodTrackletV1(const AliTRDcluster* cl)
 See if we are not near a masked pad

void CheckGoodTrackletV0(const Int_t detector, const Int_t row, const Int_t col)
 See if we are not near a masked pad

Bool_t IsPadOn(Int_t detector, Int_t row, Int_t col) const
 Look in the choosen database if the pad is On.
 If no the track will be "not good"

Int_t CalculateCalibrationGroup(Int_t i, Int_t row, Int_t col) const
 Calculate the calibration group number for i

Int_t CalculateTotalNumberOfBins(Int_t i)
 Calculate the total number of calibration groups

void SetNz(Int_t i, Short_t nz)
 Set the mode of calibration group in the z direction for the parameter i

void SetNrphi(Int_t i, Short_t nrphi)
 Set the mode of calibration group in the rphi direction for the parameter i

void SetAllTogether(Int_t i)
 Set the mode of calibration group all together

void SetPerSuperModule(Int_t i)
 Set the mode of calibration group per supermodule

Bool_t LocalisationDetectorXbins(Int_t detector)
 For the detector calcul the first Xbins and set the number of row
 and col pads per calibration groups, the number of calibration
 groups in the detector.

void SetNumberGroupsPRF(Short_t numberGroupsPRF)
 Should be between 0 and 6

Float_t StoreInfoCHPHtrack(const AliTRDcluster* cl, const Double_t dqdl, const Int_t* group, const Int_t row, const Int_t col, const AliTRDcluster* cls = 0x0)
 Store the infos in fAmpTotal, fPHPlace and fPHValue
 Correct from the gain correction before
 cls is shared cluster if any
 Return the charge


void ResetfVariablestracklet()
 Reset values per tracklet

void FillTheInfoOfTheTrackCH(Int_t nbclusters)
 For the offline tracking or mcm tracklets
 This function will be called in the functions UpdateHistogram...
 to fill the info of a track for the relativ gain calibration

void FillTheInfoOfTheTrackPH()
 For the offline tracking or mcm tracklets
 This function will be called in the functions UpdateHistogram...
 to fill the info of a track for the drift velocity  calibration

Int_t ProcessEventDAQ(AliRawReader* rawReader)
 Event Processing loop - AliTRDrawStream

 0 timebin problem
 1 no input
 2 input
 Same algorithm as TestBeam but different reader

Int_t FillDAQ(Double_t phvalue[][144][36])
Bool_t UpdateDAQ(Int_t det, Int_t , Int_t , Int_t timebin, Float_t signal, Int_t nbtimebins)
 For the DAQ
 Fill a simple average pulse height

void Write2d(const Char_t* filename = "TRD.calibration.root", Bool_t append = kFALSE)
  Write infos to file

Double_t * StatH(TH2* ch, Int_t i)
 Check the number of stats in h, 0 is TH2I 1 is TProfile2D
 debug mode with 2 for TH2I and 3 for TProfile2D
 It gives a pointer to a Double_t[7] with the info following...
 [0] : number of calibration groups with entries
 [1] : minimal number of entries found
 [2] : calibration group number of the min
 [3] : maximal number of entries found
 [4] : calibration group number of the max
 [5] : mean number of entries found
 [6] : mean relative error

Double_t * GetMeanMedianRMSNumberCH()
 Return a Int_t[4] with:
 0 Mean number of entries
 1 median of number of entries
 2 rms of number of entries
 3 number of group with entries

Double_t * GetMeanMedianRMSNumberLinearFitter() const
 Return a Int_t[4] with:
 0 Mean number of entries
 1 median of number of entries
 2 rms of number of entries
 3 number of group with entries

void CreatePRF2d(Int_t nn)
 Create the 2D histos: here we have 2*fNgroupprf bins in tnp of 0.2 amplitude each
 If fNgroupprf is zero then no binning in tnp

void CreatePH2d(Int_t nn)
 Create the 2D histos

void CreateCH2d(Int_t nn)
 Create the 2D histos

void SetRelativeScale(Float_t relativeScale)
 Set the factor that will divide the deposited charge
 to fit in the histo range [0,fRangeHistoCharge]

void FillCH2d(Int_t x, Float_t y)
 FillCH2d: Marian style

Int_t GetLayer(Int_t d) const
 Reconstruct the layer number from the detector number

Int_t GetStack(Int_t d) const
 Reconstruct the stack number from the detector number

Int_t GetSector(Int_t d) const
 Reconstruct the sector number from the detector number

TProfile2D* GetPH2d(Int_t nbtimebin = 24, Float_t samplefrequency = 10.0)
 return pointer to fPH2d TProfile2D
 create a new TProfile2D if it doesn't exist allready

TH2I* GetCH2d()
 return pointer to fCH2d TH2I
 create a new TH2I if it doesn't exist allready

TLinearFitter* GetLinearFitter(Int_t detector, Bool_t force = kFALSE)
 return pointer to TLinearFitter Calibration
 if force is true create a new TLinearFitter if it doesn't exist allready

void AnalyseLinearFitter()
 Analyse array of linear fitter because can not be written
 Store two arrays: one with the param the other one with the error param + number of entries

AliTRDCalibraFillHisto & operator=(const AliTRDCalibraFillHisto& )
{ return *this; }
void SetIsHLT(Bool_t isHLT = kTRUE)
 Set of Get the variables

{ fIsHLT = isHLT; }
Bool_t IsHLT() const
{ return fIsHLT; }
void SetPH2dOn(Bool_t ph2don = kTRUE)
 Choice to fill or not the 2D
{ fPH2dOn = ph2don; }
void SetCH2dOn(Bool_t ch2don = kTRUE)
{ fCH2dOn = ch2don; }
void SetPRF2dOn(Bool_t prf2don = kTRUE)
{ fPRF2dOn = prf2don; }
void SetHisto2d(Bool_t histo2d = kTRUE)
{ fHisto2d = histo2d; }
void SetVector2d(Bool_t vector2d = kTRUE)
{ fVector2d = vector2d; }
void SetLinearFitterOn(Bool_t linearfitteron = kTRUE)
{ fLinearFitterOn = linearfitteron;}
void SetLinearFitterDebugOn(Bool_t debug = kTRUE)
void SetExbAltFitOn(Bool_t fiton = kTRUE)
{ fExbAltFitOn = fiton;}
void SetScaleWithTPCSignal(Bool_t scaleWithTPCSignal = kTRUE)
{ fScaleWithTPCSignal = scaleWithTPCSignal;}
void SetTakeSnapshot(Bool_t takesnapshot)
{ fTakeSnapshot = takesnapshot; }
void SetFirstRunGain(Int_t firstRunGain)
{ fFirstRunGain = firstRunGain; }
void SetVersionGainUsed(Int_t versionGainUsed)
{ fVersionGainUsed = versionGainUsed; }
void SetSubVersionGainUsed(Int_t subVersionGainUsed)
{ fSubVersionGainUsed = subVersionGainUsed; }
void SetFirstRunGainLocal(Int_t firstRunGainLocal)
{ fFirstRunGainLocal = firstRunGainLocal; }
void SetVersionGainLocalUsed(Int_t versionGainLocalUsed)
{ fVersionGainLocalUsed = versionGainLocalUsed; }
void SetSubVersionGainLocalUsed(Int_t subVersionGainLocalUsed)
{ fSubVersionGainLocalUsed = subVersionGainLocalUsed; }
void SetFirstRunVdrift(Int_t firstRunVdrift)
{ fFirstRunVdrift = firstRunVdrift; }
void SetVersionVdriftUsed(Int_t versionVdriftUsed)
{ fVersionVdriftUsed = versionVdriftUsed; }
void SetSubVersionVdriftUsed(Int_t subVersionVdriftUsed)
{ fSubVersionVdriftUsed = subVersionVdriftUsed; }
void SetFirstRunExB(Int_t firstRunExB)
{ fFirstRunExB = firstRunExB; }
void SetVersionExBUsed(Int_t versionExBUsed)
{ fVersionExBUsed = versionExBUsed; }
void SetSubVersionExBUsed(Int_t subVersionExBUsed)
{ fSubVersionExBUsed = subVersionExBUsed; }
Bool_t GetPH2dOn() const
{ return fPH2dOn; }
Bool_t GetCH2dOn() const
{ return fCH2dOn; }
Bool_t GetPRF2dOn() const
{ return fPRF2dOn; }
Bool_t GetHisto2d() const
{ return fHisto2d; }
Bool_t GetVector2d() const
{ return fVector2d; }
Bool_t GetLinearFitterOn() const
{ return fLinearFitterOn; }
Bool_t GetLinearFitterDebugOn() const
Int_t GetVersionGainUsed() const
{ return fVersionGainUsed; }
Int_t GetSubVersionGainUsed() const
Int_t GetVersionVdriftUsed() const
{ return fVersionVdriftUsed; }
Int_t GetSubVersionVdriftUsed() const
TProfile2D * GetPRF2d() const
{ return fPRF2d; }
TObjArray GetLinearFitterArray() const
{ return fLinearFitterArray; }
AliTRDCalibraVdriftLinearFit * GetVdriftLinearFit() const
{ return fLinearVdriftFit; }
AliTRDCalibraExbAltFit * GetExbAltFit() const
{ return fExbAltFit; }
void SetThresholdClusterPRF2(Float_t thresholdClusterPRF2)
{ fThresholdClusterPRF2 = thresholdClusterPRF2; }
void SetLimitChargeIntegration(Bool_t limitChargeIntegration)
{ fLimitChargeIntegration = limitChargeIntegration; }
void SetFillWithZero(Bool_t fillWithZero)
{ fFillWithZero = fillWithZero; }
void SetNormalizeNbOfCluster(Bool_t normalizeNbOfCluster)
{ fNormalizeNbOfCluster = normalizeNbOfCluster; }
void SetMaxCluster(Float_t maxCluster)
{ fMaxCluster = maxCluster; }
void SetNbMaxCluster(Short_t nbMaxCluster)
{ fNbMaxCluster = nbMaxCluster; }
void SetCutWithVdriftCalib(Bool_t cutWithVdriftCalib)
{ fCutWithVdriftCalib = cutWithVdriftCalib; }
void SetMinNbTRDtracklets(Int_t minNbTRDtracklets)
{ fMinNbTRDtracklets = minNbTRDtracklets; }
void SetMinTRDMomentum(Float_t minTRDMomentum)
{ fMinTRDMomentum = minTRDMomentum; }
void SetProcent(Float_t procent)
{ fProcent = procent; }
void SetDifference(Short_t difference)
{ fDifference = difference; }
void SetNumberClusters(Short_t numberClusters)
{ if(numberClusters >= 0) fNumberClusters = numberClusters; }
void SetNumberClustersf(Short_t numberClustersf)
{ fNumberClustersf = numberClustersf; }
void SetNumberClustersProcent(Float_t numberClustersProcent)
{ fNumberClustersProcent = numberClustersProcent; }
void SetThresholdClustersDAQ(Float_t thresholdClustersDAQ)
{ fThresholdClustersDAQ = thresholdClustersDAQ; }
void SetNumberRowDAQ(Short_t numberRowDAQ)
{ fNumberRowDAQ = numberRowDAQ; }
void SetNumberColDAQ(Short_t numberColDAQ)
{ fNumberColDAQ = numberColDAQ; }
void SetRangeHistoCharge(Float_t rangeHistoCharge)
{ fRangeHistoCharge = rangeHistoCharge; }
void SetNumberBinCharge(Short_t numberBinCharge)
{ fNumberBinCharge = numberBinCharge; }
void SetNumberBinPRF(Short_t numberBinPRF)
{ fNumberBinPRF = numberBinPRF; }
Float_t GetRelativeScale() const
{ return fRelativeScale; }
Float_t GetThresholdClusterPRF2() const
Bool_t GetLimitChargeIntegration() const
Bool_t GetFillWithZero() const
{ return fFillWithZero; }
Bool_t GetNormalizeNbOfCluster() const
Float_t GetMaxCluster() const
{ return fMaxCluster; }
Short_t GetNbMaxCluster() const
{ return fNbMaxCluster; }
Bool_t GetCutWithVdriftCalib() const
Float_t GetProcent() const
{ return fProcent; }
Short_t GetDifference() const
{ return fDifference; }
Short_t GetNumberClusters() const
{ return fNumberClusters; }
Short_t GetNumberClustersf() const
{ return fNumberClustersf; }
Short_t GetNumberBinCharge() const
{ return fNumberBinCharge; }
Short_t GetNumberBinPRF() const
{ return fNumberBinPRF; }
Short_t GetNumberGroupsPRF() const
{ return fNgroupprf; }
Int_t * GetEntriesLinearFitter() const
void SetDebugLevel(Short_t level)
 Debug
{ fDebugLevel = level; }
AliTRDCalibraVector * GetCalibraVector() const
 Vector method
{ return fCalibraVector; }