#include <TGraph.h>
#include <TObjArray.h>
-#include <AliCDBMetaData.h>
#include <TMap.h>
#include "AliDCSValue.h"
#include "AliDCSValue.h"
#include "AliLog.h"
-#include "AliTRDDataDCS.h"
#include "AliSplineFit.h"
+#include "AliTRDDataDCS.h"
+
ClassImp(AliTRDDataDCS)
//_____________________________________________________________________________
}
//_____________________________________________________________________________
-TGraph *AliTRDDataDCS::FindAndMakeGraph (TMap *dcsMap, const char *amandaStr,
- char dataType)
+TGraph *AliTRDDataDCS::FindAndMakeGraph (TMap * const dcsMap
+ , const char *amandaStr
+ , char dataType)
{
//
// Create the graphs
}
//_____________________________________________________________________________
-AliSplineFit *AliTRDDataDCS::Fit(TGraph *graph,
+AliSplineFit *AliTRDDataDCS::Fit(const TGraph * const graph,
Int_t minPoints, Int_t iter,
Double_t maxDelta, Int_t fitReq)
{
}
//_____________________________________________________________________________
-void AliTRDDataDCS::Print(Option_t* option) const
+void AliTRDDataDCS::Print(const Option_t * const option) const
{
//
// Print function
AliSplineFit * GetFitLuminosity () const {return GetFit (kLuminosity);}
AliSplineFit * GetFitMagneticField () const {return GetFit (kMagneticField);}
- void Print (Option_t* option = "") const;
+ void Print (const Option_t * const option = "") const;
protected :
- TGraph * FindAndMakeGraph (TMap * dcsMap, const char * amandaStr,
- char dataType);
- AliSplineFit * Fit (TGraph * graph,
+ TGraph * FindAndMakeGraph (TMap * const dcsMap
+ , const char * amandaStr
+ , char dataType);
+ AliSplineFit * Fit (const TGraph * const graph,
Int_t kMinPoints, Int_t kIter,
Double_t kMaxDelta, Int_t kFitReq);
// //
////////////////////////////////////////////////////////////////////////////
+#include <fstream>
+
#include <TFile.h>
#include <TProfile2D.h>
-#include <TStopwatch.h>
#include <TObjString.h>
#include <TString.h>
#include <TList.h>
-#include <TCollection.h>
#include <TSAXParser.h>
-#include <fstream>
#include "AliCDBMetaData.h"
#include "AliLog.h"
#include "AliTRDCalibraMode.h"
#include "AliTRDCalibPadStatus.h"
#include "AliTRDSaxHandler.h"
-#include "Cal/AliTRDCalDet.h"
+#include "AliTRDgeometry.h"
#include "Cal/AliTRDCalPad.h"
#include "Cal/AliTRDCalPadStatus.h"
#include "Cal/AliTRDCalDCS.h"
#include "Cal/AliTRDCalSingleChamberStatus.h"
#include "Cal/AliTRDCalROC.h"
-
ClassImp(AliTRDPreprocessor)
//______________________________________________________________________________________________
return error;
}
+
//__________________________________________________________________
-Bool_t AliTRDPreprocessor::AreThereDataPedestal(AliTRDCalSingleChamberStatus *calROCStatus, Bool_t second){
+Bool_t AliTRDPreprocessor::AreThereDataPedestal(AliTRDCalSingleChamberStatus * const calROCStatus
+ , Bool_t second)
+{
//
// Data for this half chamber
UInt_t ProcessDCSConfigData(); // process DCS configuration
- Bool_t AreThereDataPedestal(AliTRDCalSingleChamberStatus *calROCStatus, Bool_t second);
+ Bool_t AreThereDataPedestal(AliTRDCalSingleChamberStatus * const calROCStatus, Bool_t second);
void SetDefaultStatus(AliTRDCalSingleChamberStatus &calROCStatus, Bool_t second);
void SetStatus(AliTRDCalSingleChamberStatus &calROCStatus, AliTRDCalSingleChamberStatus *calROCStatusPrevious,Bool_t second);
void SetDefaultNoise(AliTRDCalROC &calROCNoise, Bool_t second);
// //\r
////////////////////////////////////////////////////////////////////////////\r
\r
-#include <cstdlib>\r
-#include <Riostream.h>\r
#include <TList.h>\r
#include <TXMLAttr.h>\r
-#include <TSAXParser.h>\r
#include <TObjArray.h>\r
\r
#include "AliLog.h"\r
#include "Cal/AliTRDCalDCSGTU.h"\r
\r
ClassImp(AliTRDSaxHandler)\r
-\r
\r
//_____________________________________________________________________________\r
AliTRDSaxHandler::AliTRDSaxHandler()\r
-#ifndef AliTRDSAXHANDLER_H
-#define AliTRDSAXHANDLER_H
+#ifndef ALITRDSAXHANDLER_H
+#define ALITRDSAXHANDLER_H
/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
* * See cxx source for full Copyright notice */
virtual ~AliTRDSaxHandler();
AliTRDSaxHandler &operator=(const AliTRDSaxHandler &sh);
- TObjArray* GetDCSFEEDataArray() { return fFEEArr; }
- TObjArray* GetDCSPTRDataArray() { return fPTRArr; }
- TObjArray* GetDCSGTUDataArray() { return fGTUArr; }
+ TObjArray* GetDCSFEEDataArray() const { return fFEEArr; }
+ TObjArray* GetDCSPTRDataArray() const { return fPTRArr; }
+ TObjArray* GetDCSGTUDataArray() const { return fGTUArr; }
AliTRDCalDCS* GetCalDCSObj(); // to be called by the preprocessor
Int_t GetHandlerStatus() const { return fHandlerStatus; }
}
//____________________________________________________________________________
-Int_t AliTRDtestBeam::Int(Int_t i, Char_t *start) const
+Int_t AliTRDtestBeam::Int(Int_t i, const Char_t * const start) const
{
//
// ?????
-#ifndef AliTRDTESTBEAM_H
-#define AliTRDTESTBEAM_H
+#ifndef ALITRDTESTBEAM_H
+#define ALITRDTESTBEAM_H
/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
* See cxx source for full Copyright notice */
// data reading
- Int_t Int(Int_t i, Char_t *start) const;
+ Int_t Int(Int_t i, const Char_t * const start) const;
Int_t DecodeSi();
//
#include <TGeoMatrix.h>
#include "AliLog.h"
-#include "AliTracker.h"
-#include "AliCodeTimer.h"
#include "AliTRDtransform.h"
#include "AliTRDcluster.h"
ClassImp(AliTRDtransform)
//_____________________________________________________________________________
-//AliTRDtransform::AliTRDtransform()
-// :AliTransform()
AliTRDtransform::AliTRDtransform()
:TObject()
,fGeo(0x0)
,fCalVdriftROC(0x0)
,fCalT0ROC(0x0)
,fCalPRFROC(0x0)
- ,fCalVdriftDet(0x0)
- ,fCalT0Det(0x0)
+ ,fkCalVdriftDet(0x0)
+ ,fkCalT0Det(0x0)
,fCalVdriftDetValue(0)
,fCalT0DetValue(0)
,fSamplingFrequency(0)
}
//_____________________________________________________________________________
-//AliTRDtransform::AliTRDtransform(Int_t det)
-// :AliTransform()
AliTRDtransform::AliTRDtransform(Int_t det)
:TObject()
,fGeo(0x0)
,fCalVdriftROC(0x0)
,fCalT0ROC(0x0)
,fCalPRFROC(0x0)
- ,fCalVdriftDet(0x0)
- ,fCalT0Det(0x0)
+ ,fkCalVdriftDet(0x0)
+ ,fkCalT0Det(0x0)
,fCalVdriftDetValue(0)
,fCalT0DetValue(0)
,fSamplingFrequency(0)
}
// Get the calibration objects for the global calibration
- fCalVdriftDet = fCalibration->GetVdriftDet();
- fCalT0Det = fCalibration->GetT0Det();
+ fkCalVdriftDet = fCalibration->GetVdriftDet();
+ fkCalT0Det = fCalibration->GetT0Det();
SetDetector(det);
}
//_____________________________________________________________________________
-//AliTRDtransform::AliTRDtransform(const AliTRDtransform &t)
-// :AliTransform(t)
AliTRDtransform::AliTRDtransform(const AliTRDtransform &t)
:TObject(t)
,fGeo(0x0)
,fCalVdriftROC(0x0)
,fCalT0ROC(0x0)
,fCalPRFROC(0x0)
- ,fCalVdriftDet(0x0)
- ,fCalT0Det(0x0)
+ ,fkCalVdriftDet(0x0)
+ ,fkCalT0Det(0x0)
,fCalVdriftDetValue(0)
,fCalT0DetValue(0)
,fSamplingFrequency(0)
if (!fCalibration) {
AliError("Cannot find calibration object");
}
- fCalVdriftDet = fCalibration->GetVdriftDet();
- fCalT0Det = fCalibration->GetT0Det();
+ fkCalVdriftDet = fCalibration->GetVdriftDet();
+ fkCalT0Det = fCalibration->GetT0Det();
}
fCalPRFROC = fCalibration->GetPRFROC(det);
// Get the detector wise defined calibration values
- fCalVdriftDetValue = fCalVdriftDet->GetValue(det);
- fCalT0DetValue = fCalT0Det->GetValue(det);
+ fCalVdriftDetValue = fkCalVdriftDet->GetValue(det);
+ fCalT0DetValue = fkCalT0Det->GetValue(det);
// Shift needed to define Z-position relative to middle of chamber
Int_t layer = fGeo->GetLayer(det);
c->SetSigmaZ2(fPadPlane->GetRowSize(row)*fPadPlane->GetRowSize(row)/12.);
return kTRUE;
+
}
//_____________________________________________________________________________
if (setDet) SetDetector(c->GetDetector());
Transform(c);
+
}
////////////////////////////////////////////////////////////////////////////
#include "TObject.h"
-//#include "../TPC/AliTransform.h"
class TGeoHMatrix;
class AliTRDCalDet;
class AliTRDpadPlane;
-//class AliTRDtransform : public AliTransform {
class AliTRDtransform : public TObject {
-public:
+
+ public:
+
AliTRDtransform();
AliTRDtransform(Int_t det);
AliTRDtransform(const AliTRDtransform &t);
void SetDetector(Int_t det);
protected:
+
AliTRDgeometry *fGeo; // TRD geometry
Int_t fDetector; // Detector number
AliTRDCalROC *fCalVdriftROC; // Pad wise Vdrift calibration object
AliTRDCalROC *fCalT0ROC; // Pad wise T0 calibration object
AliTRDCalROC *fCalPRFROC; // Pad wise PRF calibration object
- const AliTRDCalDet *fCalVdriftDet; // ROC wise Vdrift calibration object
- const AliTRDCalDet *fCalT0Det; // ROC wise T0 calibration object
+ const AliTRDCalDet *fkCalVdriftDet; // ROC wise Vdrift calibration object
+ const AliTRDCalDet *fkCalT0Det; // ROC wise T0 calibration object
Double_t fCalVdriftDetValue; // ROC wise Vdrift calibration value
Double_t fCalT0DetValue; // ROC wise T0 calibration value
TGeoHMatrix *fMatrix; // Transformation matrix for a given chamber
- ClassDef(AliTRDtransform, 2) // Transforms clusters
+ ClassDef(AliTRDtransform, 3) // Transforms clusters
};
-
#endif
#include <TTree.h>
#include <TH2D.h>
#include <TH2I.h>
-#include <TH3D.h>
#include <TParticle.h>
#include <TParticle.h>
#include <TPrincipal.h>
#include <TVector3.h>
#include <TLinearFitter.h>
-#include <TVectorT.h>
#include <TCanvas.h>
#include <TEllipse.h>
#include <TMarker.h>
-#include "AliLog.h"
#include "AliPID.h"
#include "AliESD.h"
#include "AliRun.h"
#include "AliTRDgeometry.h"
#include "AliTRDtrack.h"
-#include <vector>
-
ClassImp(AliTRDCalPIDRefMaker)
-TLinearFitter *AliTRDCalPIDRefMaker::fFitter2D2 = 0x0;
-TLinearFitter *AliTRDCalPIDRefMaker::fFitter2D1 = 0x0;
+TLinearFitter *AliTRDCalPIDRefMaker::fgFitter2D2 = 0x0;
+TLinearFitter *AliTRDCalPIDRefMaker::fgFitter2D1 = 0x0;
//__________________________________________________________________
AliTRDCalPIDRefMaker::AliTRDCalPIDRefMaker()
if(fH2dEdx[ispec]) delete fH2dEdx[ispec];
if(fPrinc[ispec]) delete fPrinc[ispec];
}
- if(fFitter2D1){ delete fFitter2D1; fFitter2D1 = 0x0;}
- if(fFitter2D2){ delete fFitter2D2; fFitter2D2 = 0x0;}
+ if(fgFitter2D1){ delete fgFitter2D1; fgFitter2D1 = 0x0;}
+ if(fgFitter2D2){ delete fgFitter2D2; fgFitter2D2 = 0x0;}
}
}
//__________________________________________________________________
-Bool_t AliTRDCalPIDRefMaker::BuildNNReferences(const Char_t* /*File*/, const Char_t* /*dir*/)
+Bool_t AliTRDCalPIDRefMaker::BuildNNReferences(const Char_t* /*File*/, const Char_t* /*dir*/) const
{
return kTRUE;
}
//__________________________________________________________________
-Double_t AliTRDCalPIDRefMaker::Estimate2D2(TH2 *h, Float_t &x, Float_t &y)
+Double_t AliTRDCalPIDRefMaker::Estimate2D2(TH2 * const h, Float_t &x, Float_t &y)
{
//
// Linear interpolation of data point with a parabolic expresion using
Double_t entries;
// late construction of fitter
- if(!fFitter2D2) fFitter2D2 = new TLinearFitter(6, "1++x++y++x*x++y*y++x*y");
+ if(!fgFitter2D2) fgFitter2D2 = new TLinearFitter(6, "1++x++y++x*x++y*y++x*y");
- fFitter2D2->ClearPoints();
+ fgFitter2D2->ClearPoints();
Int_t npoints=0;
Int_t binx0, binx1, biny0, biny1;
for(int bin=0; bin<5; bin++){
if((entries = h->GetBinContent(ibin, jbin)) == 0.) continue;
p[0] = ax->GetBinCenter(ibin);
p[1] = ay->GetBinCenter(jbin);
- fFitter2D2->AddPoint(p, log(entries), 1./sqrt(entries));
+ fgFitter2D2->AddPoint(p, log(entries), 1./sqrt(entries));
npoints++;
}
}
if(npoints>=25) break;
}
- if(fFitter2D2->Eval() == 1){
+ if(fgFitter2D2->Eval() == 1){
printf("<I2> x = %9.4f y = %9.4f\n", x, y);
printf("\tbinx %d biny %d\n", binx, biny);
printf("\tpoints %d\n", npoints);
return 0.;
}
TVectorD vec(6);
- fFitter2D2->GetParameters(vec);
+ fgFitter2D2->GetParameters(vec);
Double_t result = vec[0] + x*vec[1] + y*vec[2] + x*x*vec[3] + y*y*vec[4] + x*y*vec[5];
return exp(result);
}
//__________________________________________________________________
-Double_t AliTRDCalPIDRefMaker::Estimate2D1(TH2 *h, Float_t &x, Float_t &y
- , Float_t &dCT, Float_t &rmin
- , Float_t &rmax)
+Double_t AliTRDCalPIDRefMaker::Estimate2D1(TH2 * const h, Float_t &x, Float_t &y
+ , const Float_t &dCT
+ , const Float_t &rmin
+ , const Float_t &rmax)
{
//
// Linear interpolation of data point with a plane using
Double_t rxy = sqrt(x*x + y*y), rpxy;
// late construction of fitter
- if(!fFitter2D1) fFitter2D1 = new TLinearFitter(3, "1++x++y");
+ if(!fgFitter2D1) fgFitter2D1 = new TLinearFitter(3, "1++x++y");
- fFitter2D1->ClearPoints();
+ fgFitter2D1->ClearPoints();
Int_t npoints=0;
for(int ibin=1; ibin<=nbinsx; ibin++){
for(int jbin=1; jbin<=nbinsy; jbin++){
if((x*p[0] + y*p[1])/rxy/rpxy < dCT) continue;
if(rpxy<rmin || rpxy > rmax) continue;
- fFitter2D1->AddPoint(p, log(entries), 1./sqrt(entries));
+ fgFitter2D1->AddPoint(p, log(entries), 1./sqrt(entries));
npoints++;
}
}
if(npoints<15) return 0.;
- if(fFitter2D1->Eval() == 1){
+ if(fgFitter2D1->Eval() == 1){
printf("<O2> x = %9.4f y = %9.4f\n", x, y);
printf("\tpoints %d\n", npoints);
return 0.;
}
TVectorD vec(3);
- fFitter2D1->GetParameters(vec);
+ fgFitter2D1->GetParameters(vec);
Double_t result = vec[0] + x*vec[1] + y*vec[2];
return exp(result);
}
//__________________________________________________________________
-// Double_t AliTRDCalPIDRefMaker::Estimate3D2(TH3 *h, Float_t &x, Float_t &y, Float_t &z)
+// Double_t AliTRDCalPIDRefMaker::Estimate3D2(TH3 * const h, Float_t &x, Float_t &y, Float_t &z)
// {
// // Author Alex Bercuci (A.Bercuci@gsi.de)
// return 0.;
//const Float_t dPhiRange = .1;
Int_t nPoints[nPhi], nFitPoints, binStart, binStop;
TLinearFitter refsFitter[nPhi], refsLongFitter(6, "1++x++y++x*x++y*y++x*y");
- Float_t fFitterRange[nPhi];
+ Float_t fgFitterRange[nPhi];
Bool_t kFitterStatus[nPhi];
for(int iphi=0; iphi<nPhi; iphi++){
refsFitter[iphi].SetDim(3);
refsFitter[iphi].SetFormula("1++x++y");//++x*x++y*y++x*y");
- fFitterRange[iphi] = .8;
+ fgFitterRange[iphi] = .8;
kFitterStatus[iphi] = kFALSE;
}
std::vector<UShort_t> storeX[nPhi], storeY[nPhi];
// define working variables
Float_t x0, y0, rx, ry;
//Float_t rc, rmin, rmax, dr, dCT;
- Double_t Phi, r;
+ Double_t phi, r;
Int_t iPhi;
Double_t entries;
for(int ispec=0; ispec<5; ispec++){
for(int iphi=0; iphi<nPhi; iphi++){
nPoints[iphi] = 0;
refsFitter[iphi].ClearPoints();
- fFitterRange[iphi] = .8;
+ fgFitterRange[iphi] = .8;
kFitterStatus[iphi] = kFALSE;
storeX[iphi].clear();
storeY[iphi].clear();
if(position < 1.) continue;
r = sqrt(rxy[0]*rxy[0] + rxy[1]*rxy[1]);
- Phi = ((rxy[1] > 0.) ? 1. : -1.) * TMath::ACos(rxy[0]/r); // [-pi, pi]
- iPhi = nPhi/2 + Int_t(Phi/dPhi) - ((Phi/dPhi > 0.) ? 0 : 1);
+ phi = ((rxy[1] > 0.) ? 1. : -1.) * TMath::ACos(rxy[0]/r); // [-pi, pi]
+ iPhi = nPhi/2 + Int_t(phi/dPhi) - ((phi/dPhi > 0.) ? 0 : 1);
refsFitter[iPhi].AddPoint(rxy, log(entries), 1./sqrt(entries));
nPoints[iPhi]++;
fH2dEdx[ispec]->SetBinContent(ibin, jbin, estimate/xy[0]/xy[1]);
} else { // interpolation outside the covariance ellipse
r = sqrt(rxy[0]*rxy[0] + rxy[1]*rxy[1]);
- Phi = ((rxy[1] > 0.) ? 1. : -1.) * TMath::ACos(rxy[0]/r); // [-pi, pi]
- iPhi = nPhi/2 + Int_t(Phi/dPhi) - ((Phi/dPhi > 0.) ? 0 : 1);
+ phi = ((rxy[1] > 0.) ? 1. : -1.) * TMath::ACos(rxy[0]/r); // [-pi, pi]
+ iPhi = nPhi/2 + Int_t(phi/dPhi) - ((phi/dPhi > 0.) ? 0 : 1);
storeX[iPhi].push_back(ibin);
storeY[iPhi].push_back(jbin);
TVectorD vec(3);
Int_t xbin, ybin;
for(int iphi=0; iphi<nPhi; iphi++){
- Phi = iphi * dPhi - TMath::Pi();
- if(TMath::Abs(TMath::Abs(Phi)-TMath::Pi()) < 100.*TMath::DegToRad()) continue;
+ phi = iphi * dPhi - TMath::Pi();
+ if(TMath::Abs(TMath::Abs(phi)-TMath::Pi()) < 100.*TMath::DegToRad()) continue;
refsFitter[iphi].Eval();
// //
///////////////////////////////////////////////////////////////////////////////
-#ifndef ROOT_TObject
#include "TObject.h"
-#endif
class TH1;
class TH2;
AliTRDCalPIDRefMaker& operator=(const AliTRDCalPIDRefMaker &ref);
Bool_t BuildLQReferences(const Char_t *filename="TRDpidLQ.root", const Char_t *dir =".");
- Bool_t BuildNNReferences(const Char_t *filename="TRDpidNN.root", const Char_t *dir =".");
+ Bool_t BuildNNReferences(const Char_t *filename="TRDpidNN.root", const Char_t *dir =".") const;
- static Double_t Estimate2D2(TH2 *h, Float_t &x, Float_t &y);
- static Double_t Estimate2D1(TH2 *h, Float_t &x, Float_t &y, Float_t &dCT, Float_t &rmin, Float_t &rmax);
- // Double_t Estimate3D2(TH3 *h, Float_t &x, Float_t &y, Float_t &z);
+ static Double_t Estimate2D2(TH2 * const h, Float_t &x, Float_t &y);
+ static Double_t Estimate2D1(TH2 * const h, Float_t &x, Float_t &y, const Float_t &dCT
+ , const Float_t &rmin, const Float_t &rmax);
+ // Double_t Estimate3D2(TH3 * const h, Float_t &x, Float_t &y, Float_t &z);
private:
Int_t CheckProdDirTree(const Char_t *dir=".");
private:
- TPrincipal *fPrinc[5]; // Used for principal component analysis
- static TLinearFitter *fFitter2D2; // Working object for linear fitter
- static TLinearFitter *fFitter2D1; // Working object for linear fitter
- TH2 *fH2dEdx[5]; // dE/dx data holders
- TH1 *fH1TB[2]; // Max time bin data holders
+ TPrincipal *fPrinc[5]; // Used for principal component analysis
+ static TLinearFitter *fgFitter2D2; // Working object for linear fitter
+ static TLinearFitter *fgFitter2D1; // Working object for linear fitter
+ TH2 *fH2dEdx[5]; // dE/dx data holders
+ TH1 *fH1TB[2]; // Max time bin data holders
- ClassDef(AliTRDCalPIDRefMaker, 2) // Reference histograms builder
+ ClassDef(AliTRDCalPIDRefMaker, 3) // Reference histograms builder
};
#include <TH1F.h>
#include <TStyle.h>
+//#include "AliMathBase.h"
+
#include "AliTRDCalPad.h"
#include "AliTRDCalROC.h"
#include "AliTRDCalDet.h"
#include "AliTRDpadPlane.h"
-#include "AliMathBase.h"
#include "AliTRDgeometry.h"
ClassImp(AliTRDCalPad)
}
//_____________________________________________________________________________
-Double_t AliTRDCalPad::GetMean(const AliTRDCalDet *calDet, Int_t type, AliTRDCalPad* outlierPad)
+Double_t AliTRDCalPad::GetMean(const AliTRDCalDet *calDet, Int_t type
+ , AliTRDCalPad* const outlierPad)
{
//
// return mean of the mean of all ROCs
}
//_____________________________________________________________________________
-Double_t AliTRDCalPad::GetRMS(const AliTRDCalDet *calDet, Int_t type, AliTRDCalPad* outlierPad)
+Double_t AliTRDCalPad::GetRMS(const AliTRDCalDet *calDet, Int_t type
+ , AliTRDCalPad* const outlierPad)
{
//
// return mean of the RMS of all ROCs
//_____________________________________________________________________________
Double_t AliTRDCalPad::GetMedian(const AliTRDCalDet *calDet, Int_t type
- , AliTRDCalPad* outlierPad)
+ , AliTRDCalPad* const outlierPad)
{
//
// return mean of the median of all ROCs
//_____________________________________________________________________________
Double_t AliTRDCalPad::GetLTM(Double_t *sigma, Double_t fraction
, const AliTRDCalDet *calDet, Int_t type
- , AliTRDCalPad* outlierPad)
+ , AliTRDCalPad* const outlierPad)
{
//
// return mean of the LTM and sigma of all ROCs
// Statistic
Double_t GetMeanRMS(Double_t &rms, const AliTRDCalDet *calDet = 0, Int_t type = 0);
- Double_t GetMean(const AliTRDCalDet *calDet = 0, Int_t type = 0, AliTRDCalPad* outlierPad = 0);
- Double_t GetRMS(const AliTRDCalDet *calDet = 0, Int_t type = 0, AliTRDCalPad* outlierPad = 0) ;
- Double_t GetMedian(const AliTRDCalDet *calDet = 0, Int_t type = 0, AliTRDCalPad* outlierPad = 0) ;
+ Double_t GetMean(const AliTRDCalDet *calDet = 0, Int_t type = 0, AliTRDCalPad* const outlierPad = 0);
+ Double_t GetRMS(const AliTRDCalDet *calDet = 0, Int_t type = 0, AliTRDCalPad* const outlierPad = 0);
+ Double_t GetMedian(const AliTRDCalDet *calDet = 0, Int_t type = 0, AliTRDCalPad* const outlierPad = 0);
Double_t GetLTM(Double_t *sigma=0, Double_t fraction=0.9
- , const AliTRDCalDet *calDet = 0, Int_t type = 0, AliTRDCalPad* outlierPad = 0);
+ , const AliTRDCalDet *calDet = 0, Int_t type = 0, AliTRDCalPad* const outlierPad = 0);
// Plot functions
TH1F *MakeHisto1D(const AliTRDCalDet *calDet = 0, Int_t typedet=0, Float_t min=4, Float_t max=-4,Int_t type=0);
// //
///////////////////////////////////////////////////////////////////////////////
-#include <iostream>
-#include <fstream>
-#include <string>
#include <TStyle.h>
+#include <TMath.h>
+#include <TH2F.h>
+#include <TH1F.h>
-#include "AliTRDCalROC.h"
-#include "TMath.h"
#include "AliMathBase.h"
-#include "TLinearFitter.h"
-#include "TArrayI.h"
-#include "TH2F.h"
-#include "TH1F.h"
-#include "TArrayF.h"
-#include "TGraph2D.h"
-#include "TGraphDelaunay.h"
-#include "TList.h"
-
-#include "AliTRDCommonParam.h"
-#include "AliTRDpadPlane.h"
-#include "AliLog.h"
+
+#include "AliTRDCalROC.h"
ClassImp(AliTRDCalROC)
}
//___________________________________________________________________________________
-Double_t AliTRDCalROC::GetMean(AliTRDCalROC* outlierROC)
+Double_t AliTRDCalROC::GetMean(AliTRDCalROC* const outlierROC) const
{
//
// Calculate the mean
//
Double_t *ddata = new Double_t[fNchannels];
- Int_t NPoints = 0;
+ Int_t nPoints = 0;
for (Int_t i=0;i<fNchannels;i++) {
if ((!outlierROC) || (!(outlierROC->GetValue(i)))) {
if(fData[i] > 0.000000000000001){
- ddata[NPoints]= (Double_t) fData[i]/10000;
- NPoints++;
+ ddata[nPoints]= (Double_t) fData[i]/10000;
+ nPoints++;
}
}
}
- Double_t mean = TMath::Mean(NPoints,ddata);
+ Double_t mean = TMath::Mean(nPoints,ddata);
delete [] ddata;
return mean;
}
//_______________________________________________________________________________________
-Double_t AliTRDCalROC::GetMedian(AliTRDCalROC* outlierROC)
+Double_t AliTRDCalROC::GetMedian(AliTRDCalROC* const outlierROC) const
{
//
// Calculate the median
//
Double_t *ddata = new Double_t[fNchannels];
- Int_t NPoints = 0;
+ Int_t nPoints = 0;
for (Int_t i=0;i<fNchannels;i++) {
if ((!outlierROC) || (!(outlierROC->GetValue(i)))) {
if(fData[i] > 0.000000000000001){
- ddata[NPoints]= (Double_t) fData[i]/10000;
- NPoints++;
+ ddata[nPoints]= (Double_t) fData[i]/10000;
+ nPoints++;
}
}
}
- Double_t mean = TMath::Median(NPoints,ddata);
+ Double_t mean = TMath::Median(nPoints,ddata);
delete [] ddata;
return mean;
}
//____________________________________________________________________________________________
-Double_t AliTRDCalROC::GetRMS(AliTRDCalROC* outlierROC)
+Double_t AliTRDCalROC::GetRMS(AliTRDCalROC* const outlierROC) const
{
//
// Calculate the RMS
//
Double_t *ddata = new Double_t[fNchannels];
- Int_t NPoints = 0;
+ Int_t nPoints = 0;
for (Int_t i=0;i<fNchannels;i++) {
if ((!outlierROC) || (!(outlierROC->GetValue(i)))) {
if(fData[i] > 0.000000000000001){
- ddata[NPoints]= (Double_t)fData[i]/10000;
- NPoints++;
+ ddata[nPoints]= (Double_t)fData[i]/10000;
+ nPoints++;
}
}
}
- Double_t mean = TMath::RMS(NPoints,ddata);
+ Double_t mean = TMath::RMS(nPoints,ddata);
delete [] ddata;
return mean;
}
//______________________________________________________________________________________________
-Double_t AliTRDCalROC::GetLTM(Double_t *sigma, Double_t fraction, AliTRDCalROC* outlierROC)
+Double_t AliTRDCalROC::GetLTM(Double_t *sigma, Double_t fraction, AliTRDCalROC* const outlierROC)
{
//
// Calculate LTM mean and sigma
Double_t *ddata = new Double_t[fNchannels];
Double_t mean=0, lsigma=0;
- UInt_t NPoints = 0;
+ UInt_t nPoints = 0;
for (Int_t i=0;i<fNchannels;i++) {
if (!outlierROC || !(outlierROC->GetValue(i))) {
if(fData[i] > 0.000000000000001){
- ddata[NPoints]= (Double_t) fData[i]/10000;
- NPoints++;
+ ddata[nPoints]= (Double_t) fData[i]/10000;
+ nPoints++;
}
}
}
- Int_t hh = TMath::Min(TMath::Nint(fraction *NPoints), Int_t(NPoints));
- AliMathBase::EvaluateUni(NPoints,ddata, mean, lsigma, hh);
+ Int_t hh = TMath::Min(TMath::Nint(fraction *nPoints), Int_t(nPoints));
+ AliMathBase::EvaluateUni(nPoints,ddata, mean, lsigma, hh);
if (sigma) *sigma=lsigma;
delete [] ddata;
return mean;
//
// add constant
//
+
Bool_t result = kTRUE;
for (Int_t idata = 0; idata< fNchannels; idata++) {
if(((GetValue(idata)+c1) <= 6.5535) && ((GetValue(idata)+c1) >= 0.0)) SetValue(idata,GetValue(idata)+c1);
//
// multiply constant
//
+
Bool_t result = kTRUE;
if(c1 < 0) return kFALSE;
for (Int_t idata = 0; idata< fNchannels; idata++) {
//
// add values
//
+
Bool_t result = kTRUE;
for (Int_t idata = 0; idata< fNchannels; idata++){
if(((GetValue(idata)+roc->GetValue(idata)*c1) <= 6.5535) &&
//
// multiply values - per by pad
//
+
Bool_t result = kTRUE;
for (Int_t idata = 0; idata< fNchannels; idata++){
if((GetValue(idata)*roc->GetValue(idata)) <= 6.5535)
//
// divide values
//
+
Bool_t result = kTRUE;
Float_t kEpsilon=0.00000000000000001;
for (Int_t idata = 0; idata< fNchannels; idata++){
// This is for the noise study
// Return kFALSE if one or more of the pad col was not normalised
//
+
Bool_t result = kTRUE;
Float_t kEpsilon=0.00000000000000001;
// type -1 = user defined range
// 0 = nsigma cut nsigma=min
// 1 = delta cut around median delta=min
+
Float_t kEpsilonr = 0.005;
gStyle->SetPalette(1);
// type -1 = user defined range
// 0 = nsigma cut nsigma=min
// 1 = delta cut around median delta=min
- Float_t kEpsilonr = 0.005;
+ Float_t kEpsilonr = 0.005;
if (type>=0){
if (type==0){
//////////////////////////////////////////////////
#include <TObject.h>
-#include <TMath.h>
-#include <TLinearFitter.h>
class TArrayI;
class TArrayF;
AliTRDCalROC &operator=(const AliTRDCalROC &c);
virtual void Copy(TObject &c) const;
- Int_t GetNrows() const { return fNrows; };
- Int_t GetNcols() const { return fNcols; };
+ Int_t GetNrows() const { return fNrows; };
+ Int_t GetNcols() const { return fNcols; };
- Int_t GetChannel(Int_t c, Int_t r) { return r+c*fNrows; };
- Int_t GetNchannels() const { return fNchannels; };
+ Int_t GetChannel(Int_t c, Int_t r) const { return r+c*fNrows; };
+ Int_t GetNchannels() const { return fNchannels; };
- Float_t GetValue(Int_t ich) const { return (Float_t) fData[ich] / 10000; };
- Float_t GetValue(Int_t col, Int_t row) { return GetValue(GetChannel(col,row)); };
+ Float_t GetValue(Int_t ich) const { return (Float_t) fData[ich] / 10000; };
+ Float_t GetValue(Int_t col, Int_t row) { return GetValue(GetChannel(col,row)); };
- void SetValue(Int_t ich, Float_t value)
- { fData[ich] = (UShort_t) (value * 10000); };
+ void SetValue(Int_t ich, Float_t value) { fData[ich] = (UShort_t) (value * 10000); };
void SetValue(Int_t col, Int_t row, Float_t value)
- { SetValue(GetChannel(col,row), value); };
+ { SetValue(GetChannel(col,row), value); };
// statistic
//
- Double_t GetMean(AliTRDCalROC *outlierROC=0);
- Double_t GetRMS(AliTRDCalROC *outlierROC=0);
- Double_t GetMedian(AliTRDCalROC *outlierROC=0);
- Double_t GetLTM(Double_t *sigma=0, Double_t fraction=0.9, AliTRDCalROC *outlierROC=0);
+ Double_t GetMean(AliTRDCalROC * const outlierROC=0) const;
+ Double_t GetRMS(AliTRDCalROC * const outlierROC=0) const;
+ Double_t GetMedian(AliTRDCalROC * const outlierROC=0) const;
+ Double_t GetLTM(Double_t *sigma=0, Double_t fraction=0.9, AliTRDCalROC * const outlierROC=0);
// algebra
Bool_t Add(Float_t c1);
-#ifndef AliTRDCalSingleChamberStatus_H
-#define AliTRDCalSingleChamberStatus_H
+#ifndef ALITRDCALSINGLECHAMBERSTATUS_H
+#define ALITRDCALSINGLECHAMBERSTATUS_H
/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
* See cxx source for full Copyright notice */
, kPadBridgedLeft = 4
, kPadBridgedRight = 8
, kReadSecond = 16
- , kNotConnected = 32
-};
+ , kNotConnected = 32};
AliTRDCalSingleChamberStatus();
AliTRDCalSingleChamberStatus(Int_t p, Int_t c, Int_t cols);