* provided "as is" without express or implied warranty. *
**************************************************************************/
-/* $Id$ */
-
-///////////////////////////////////////////////////////////////////////////////
-// //
-// Time Projection Chamber clusters objects //
-//
-// Origin: Marian Ivanov , GSI Darmstadt
-// //
-// //
-// //
-///////////////////////////////////////////////////////////////////////////////
+/// \class AliClusters
+/// \brief Time Projection Chamber clusters objects
+///
+/// \author Marian Ivanov , GSI Darmstadt
+
#include "TError.h"
#include "TClass.h"
#include <TROOT.h>
#include "AliClusters.h"
#include "TMarker.h"
+const Int_t kDefSize = 1; ///< defalut size
-const Int_t kDefSize = 1; //defalut size
-
+/// \cond CLASSIMP
+ClassImp(AliClusters)
+/// \endcond
-ClassImp(AliClusters)
-
-//*****************************************************************************
-//
-//_____________________________________________________________________________
AliClusters::AliClusters()
- :AliSegmentID(),
+ :AliSegmentID(),
fClusters(0),
fNclusters(0),
fClass(0)
-{
- //
- //default constructor
- //
-
+{
+ /// default constructor
}
-//________________________________________________________________________
+
AliClusters::AliClusters(const AliClusters ¶m)
- :AliSegmentID(),
+ :AliSegmentID(),
fClusters(0),
fNclusters(0),
fClass(0)
{
- //
- // copy constructor - dummy
- //
+ /// copy constructor - dummy
+
fNclusters = param.fNclusters;
}
-//________________________________________________________________________
AliClusters::AliClusters(const char *classname)
:AliSegmentID(),
fClusters(0),
fNclusters(0),
fClass(0)
{
-//
-// Special constructor
-//
+ /// Special constructor
+
fClass = gROOT->GetClass(classname);
-
+
if (!fClass)
Error("AliClusters", "%s is not a valid class name", classname);
- if (!fClass->InheritsFrom(TObject::Class()))
+ if (!fClass->InheritsFrom(TObject::Class()))
Error("AliClusters", "%s does not inherit from TObject", classname);
-
+
fClusters = new TClonesArray(fClass->GetName(),100);
}
-//______________________________________________________________________
AliClusters & AliClusters::operator =(const AliClusters & param)
{
- //
- // assignment operator - dummy
- //
+ /// assignment operator - dummy
+
if (this == ¶m) return (*this);
fNclusters=param.fNclusters;
return (*this);
}
-//________________________________________________________________________
+
AliClusters::~AliClusters()
{
- //
- //default destructor
- //
+ /// default destructor
+
if (fClusters !=0) fClusters->Delete();
delete fClusters;
}
-//_________________________________________________________________________
-
Bool_t AliClusters::SetClass(const Text_t *classname)
{
- //
- //set class of stored object
+ /// set class of stored object
+
if ( fClass !=0 ) {
// delete fClass;
fClass = 0;
}
-
+
if (!gROOT)
::Fatal("AliClusters::SetClass", "ROOT system not initialized");
-
+
fClass = gROOT->GetClass(classname);
if (!fClass) {
Error("AliClusters", "%s is not a valid class name", classname);
}
if (!fClass->InheritsFrom(TObject::Class())) {
Error("AliClusters", "%s does not inherit from TObject", classname);
- return kFALSE;
- }
+ return kFALSE;
+ }
return kTRUE;
}
-//_____________________________________________________________________________
void AliClusters::SetArray(Int_t length)
{
- //
- // construct Clones array of object
- //
+ /// construct Clones array of object
+
if (fClusters!=0) delete fClusters;
if (fClass==0){
Error("AliClusters", "cluster type not initialised \n SetClass before!");
fClusters = new TClonesArray(fClass->GetName(),length);
}
-
-
-//_____________________________________________________________________________
const TObject* AliClusters::operator[](Int_t i)
{
- //
- // return cluster at internal position i
- //
+ /// return cluster at internal position i
+
if (fClusters==0) return 0;
return fClusters->UncheckedAt(i);
}
-//_____________________________________________________________________________
+
void AliClusters::Sort()
{
- // sort cluster
+ /// sort cluster
+
if (fClusters!=0) fClusters->Sort();
}
-//_____________________________________________________________________________
-TObject * AliClusters::InsertCluster( const TObject * c)
-{
- //
- // Add a simulated cluster copy to the list
- //
- if (fClass==0) {
+TObject * AliClusters::InsertCluster( const TObject * c)
+{
+ /// Add a simulated cluster copy to the list
+
+ if (fClass==0) {
Error("AliClusters", "class type not specified");
- return 0;
+ return 0;
}
if(!fClusters) fClusters=new TClonesArray(fClass->GetName(),100);
TClonesArray &lclusters = *fClusters;
return new(lclusters[fNclusters++]) AliComplexCluster(*((AliComplexCluster*)c));
}
-//_____________________________________________________________________________
-Int_t AliClusters::Find(Double_t y) const
+Int_t AliClusters::Find(Double_t y) const
{
- //
- // return index of cluster nearest to given y position
- //
+ /// return index of cluster nearest to given y position
+
AliComplexCluster* cl;
cl=(AliComplexCluster*)fClusters->UncheckedAt(0);
- if (y <= cl->GetY()) return 0;
+ if (y <= cl->GetY()) return 0;
cl=(AliComplexCluster*)fClusters->UncheckedAt(fNclusters-1);
- if (y > cl->GetY()) return fNclusters;
+ if (y > cl->GetY()) return fNclusters;
Int_t b=0, e=fNclusters-1, m=(b+e)/2;
for (; b<e; m=(b+e)/2) {
cl = (AliComplexCluster*)fClusters->UncheckedAt(m);
if (y > cl->GetY()) b=m+1;
- else e=m;
+ else e=m;
}
return m;
}
-//_____________________________________________________________________________
-
-void AliClusters::DrawClusters(Float_t shiftx, Float_t shifty,
+void AliClusters::DrawClusters(Float_t shiftx, Float_t shifty,
Int_t color, Int_t size, Int_t style)
{
- if (fClusters==0) return;
+ if (fClusters==0) return;
//draw marker for each of cluster
Int_t ncl=fClusters->GetEntriesFast();
for (Int_t i=0;i<ncl;i++){
marker->SetMarkerSize(size);
marker->SetMarkerStyle(style);
marker->SetMarkerColor(color);
- marker->Draw();
+ marker->Draw();
}
}
-
/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
* See cxx source for full Copyright notice */
-/* $Id$ */
-
-////////////////////////////////////////////////
-// Manager class for TPC clusters //
-////////////////////////////////////////////////
+/// \class AliClusters
+///
+/// Manager class for TPC clusters
#include "AliSegmentID.h"
void DrawClusters(Float_t shiftx, Float_t shifty, Int_t color, Int_t size, Int_t style);
Bool_t SetClass(const Text_t *classname);
protected:
- TClonesArray * fClusters; //->array of clusters
+ /// array of clusters
+ TClonesArray * fClusters; //->
Int_t fNclusters;
- TClass * fClass; //!type of cluster class
+ TClass * fClass; //!< type of cluster class
ClassDef(AliClusters,1) // Cluster manager
};
* provided "as is" without express or implied warranty. *
**************************************************************************/
-/*
-$Log$
-Revision 1.9 2006/11/06 16:07:15 kowal2
-Eff C++
-
-Revision 1.8 2004/03/30 14:09:22 kowal2
-Changes due to the coding conventions
-
-Revision 1.7 2003/11/24 09:48:28 kowal2
-Changes to obey the coding conventions
-
-Revision 1.6 2003/11/24 09:43:03 kowal2
-Obsolete - removed
-
-Revision 1.5 2003/09/29 11:27:39 kowal2
-new classes added
-
-Revision 1.3 2002/11/15 14:27:45 hristov
-First version of the parallel TPC tracking (M.Ivanov)
-
-Revision 1.2 2001/02/05 14:43:13 hristov
-Compare() declared const
-
-Revision 1.1 2000/10/05 16:17:27 kowal2
-New class replacing AliCluster
-
-
-*/
-
-///////////////////////////////////////////////////////////////////////////////
-// //
-// Time Projection Chamber clusters objects //
-//
-// Origin: Marian Ivanov , GSI Darmstadt
-// //
-//Begin_Html
-/*
-<img src="gif/AliTPCCluster.gif">
-*/
-//End_Html
-// //
-// //
-///////////////////////////////////////////////////////////////////////////////
-// **************
-//aaaaaaaaa
-//aaaaaaaaa
-//aaaaaaaaa
-//aaaaaaaa
-//aaaaaaaaaa
+/// \class AliComplexCluster
+///
+/// Time Projection Chamber clusters objects
+///
+/// \author Marian Ivanov, GSI Darmstadt
+///
+/// * Revision 1.9 2006/11/06 16:07:15 kowal2
+/// Eff C++
+///
+/// * Revision 1.8 2004/03/30 14:09:22 kowal2
+/// Changes due to the coding conventions
+///
+/// * Revision 1.7 2003/11/24 09:48:28 kowal2
+/// Changes to obey the coding conventions
+///
+/// * Revision 1.6 2003/11/24 09:43:03 kowal2
+/// Obsolete - removed
+///
+/// * Revision 1.5 2003/09/29 11:27:39 kowal2
+/// new classes added
+///
+/// * Revision 1.3 2002/11/15 14:27:45 hristov
+/// First version of the parallel TPC tracking (M.Ivanov)
+///
+/// * Revision 1.2 2001/02/05 14:43:13 hristov
+/// Compare() declared const
+///
+/// * Revision 1.1 2000/10/05 16:17:27 kowal2
+/// New class replacing AliCluster
#include "AliComplexCluster.h"
-
+/// \cond CLASSIMP
ClassImp(AliComplexCluster)
- //__________________________________________________________________
+/// \endcond
+
AliComplexCluster::AliComplexCluster()
:TObject(),
fX(0.),
fArea(0.),
fMax(0.)
{
- //
- // default constructor
- //
+ /// default constructor
fTracks[0]=fTracks[1]=fTracks[2]=0;
}
//_____________________________________________________________________________
Int_t AliComplexCluster::Compare(const TObject * o) const
{
- //
- // compare two clusters according y coordinata
+ /// compare two clusters according y coordinata
+
AliComplexCluster *cl= (AliComplexCluster *)o;
if (fY<cl->fY) return -1;
if (fY==cl->fY) return 0;
- return 1;
+ return 1;
}
Bool_t AliComplexCluster::IsSortable() const
{
- //
- //make AliComplexCluster sortabale
- return kTRUE;
+ /// make AliComplexCluster sortabale
+
+ return kTRUE;
}
ClassImp(AliTPCExactPoint)
return *this;
}
+/// \cond CLASSIMP
ClassImp(AliTPCTrackPoint)
ClassImp(AliTPCTrackPoint2)
- //_______________________________________________________________
-
+/// \endcond
/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
* See cxx source for full Copyright notice */
-/* $Id$ */
-//
-// this is a class
-// AliComplexCluster
-// by M. Ivanov
-//
+/// \class AliComplexCluster
+///
+/// \author M. Ivanov
#include "TObject.h"
#include "TMath.h"
Float_t GetArea()const {return fArea;}
Float_t GetMax()const {return fMax;}
private:
- Int_t fTracks[3];//labels of overlapped tracks
- Float_t fX ; //Y of cluster
- Float_t fY ; //Z of cluster
- Float_t fQ ; //Q of cluster (in ADC counts)
- Float_t fSigmaX2; //Sigma Y square of cluster
- Float_t fSigmaY2; //Sigma Z square of cluster
- Float_t fSigmaXY; // XY moment
- Float_t fArea; //area of cluster
- Float_t fMax; //amplitude at maximum
+ Int_t fTracks[3];///< labels of overlapped tracks
+ Float_t fX ; ///< Y of cluster
+ Float_t fY ; ///< Z of cluster
+ Float_t fQ ; ///< Q of cluster (in ADC counts)
+ Float_t fSigmaX2; ///< Sigma Y square of cluster
+ Float_t fSigmaY2; ///< Sigma Z square of cluster
+ Float_t fSigmaXY; ///< XY moment
+ Float_t fArea; ///< area of cluster
+ Float_t fMax; ///< amplitude at maximum
ClassDef(AliComplexCluster,1)
// Cluster manager
//
private:
- Short_t fTX; // x position of the cluster in cm - 10 mum prec
- Short_t fTZ; // current prolongation in Z in cm - 10 mum prec.
- Short_t fTY; // current prolongation in Y in cm - 10 mum prec.
- Char_t fTAngleZ; // angle
- Char_t fTAngleY; // angle
- UShort_t fSigmaZ; // shape Z - normalised shape - normaliziation 1 - precision 2 percent
- UShort_t fSigmaY; // shape Y - normalised shape - normaliziation 1 - precision 2 percent
- UShort_t fErrZ; // z error estimate - in mm - 50 mum precision
- UShort_t fErrY; // y error estimate - in mm - 50 mum precision
- Char_t fIsShared; // indicate sharing of the point between several tracks
+ Short_t fTX; ///< x position of the cluster in cm - 10 mum prec
+ Short_t fTZ; ///< current prolongation in Z in cm - 10 mum prec.
+ Short_t fTY; ///< current prolongation in Y in cm - 10 mum prec.
+ Char_t fTAngleZ; ///< angle
+ Char_t fTAngleY; ///< angle
+ UShort_t fSigmaZ; ///< shape Z - normalised shape - normaliziation 1 - precision 2 percent
+ UShort_t fSigmaY; ///< shape Y - normalised shape - normaliziation 1 - precision 2 percent
+ UShort_t fErrZ; ///< z error estimate - in mm - 50 mum precision
+ UShort_t fErrY; ///< y error estimate - in mm - 50 mum precision
+ Char_t fIsShared; ///< indicate sharing of the point between several tracks
ClassDef(AliTPCTrackerPoint,2)
};
void SetMax(Float_t max) {fMax = UShort_t(max);}
void SetType(Char_t type) {fCType = type;}
private:
- Short_t fCZ; // current cluster position Z in cm - 100 mum precision
- Short_t fCY; // current cluster position Y in cm - 100 mum precision
- UChar_t fSigmaZ; // shape Z - normalised shape - normaliziation 1 - precision 2 percent
- UChar_t fSigmaY; // shape Y - normalised shape - normaliziation 1 - precision 2 percent
- UShort_t fQ; // total charge in cluster
- UShort_t fMax; // charge at maximum
- Char_t fCType; // type of the cluster
+ Short_t fCZ; ///< current cluster position Z in cm - 100 mum precision
+ Short_t fCY; ///< current cluster position Y in cm - 100 mum precision
+ UChar_t fSigmaZ; ///< shape Z - normalised shape - normaliziation 1 - precision 2 percent
+ UChar_t fSigmaY; ///< shape Y - normalised shape - normaliziation 1 - precision 2 percent
+ UShort_t fQ; ///< total charge in cluster
+ UShort_t fMax; ///< charge at maximum
+ Char_t fCType; ///< type of the cluster
//
ClassDef(AliTPCClusterPoint,1)
fRow(0),
fSec(0){}
private:
- Float_t fEZ; // current "exact" position according simulation
- Float_t fEY; // current "exact" position according simulation
- Float_t fEX; // x poistion of the cluster
- Float_t fEAngleZ; // angle Z
- Float_t fEAngleY; // angle Y
- Float_t fEAmp; // total charge deposited in row
- Float_t fEPrim; // primary charge deposited in row
- Int_t fTrackID; // id of the track
- Int_t fRow; // row
- Int_t fSec; //sector
+ Float_t fEZ; ///< current "exact" position according simulation
+ Float_t fEY; ///< current "exact" position according simulation
+ Float_t fEX; ///< x poistion of the cluster
+ Float_t fEAngleZ; ///< angle Z
+ Float_t fEAngleY; ///< angle Y
+ Float_t fEAmp; ///< total charge deposited in row
+ Float_t fEPrim; ///< primary charge deposited in row
+ Int_t fTrackID; ///< id of the track
+ Int_t fRow; ///< row
+ Int_t fSec; ///< sector
ClassDef(AliTPCExactPoint,1)
};
private:
// AliTPCClusterPoint fCPoint;
//Char_t fIsShared;
- AliTPCTrackerPoint fTPoint; // track point
- AliTPCclusterMI fCPoint; // cluster point
+ AliTPCTrackerPoint fTPoint; ///< track point
+ AliTPCclusterMI fCPoint; ///< cluster point
+ /// \cond CLASSIMP
ClassDef(AliTPCTrackPoint,1)
+ /// \endcond
};
class AliTPCTrackPoint2: public AliTPCTrackPoint{
fID(0),
fLab(0){}
private:
- Float_t fGX; //global poition of the point
- Float_t fGY; //global poition of the point
- Float_t fGZ; //global poition of the point
+ Float_t fGX; ///< global poition of the point
+ Float_t fGY; ///< global poition of the point
+ Float_t fGZ; ///< global poition of the point
//
- Float_t fDY; //distortion of the clusters from the global helix (3 point interpolation)
- Float_t fDZ; //distortion of the clusters from the global helix (3 point interpolation)
+ Float_t fDY; ///< distortion of the clusters from the global helix (3 point interpolation)
+ Float_t fDZ; ///< distortion of the clusters from the global helix (3 point interpolation)
//
- Float_t fDYU; //derivation in y up
- Float_t fDYD; //distortion of y down
+ Float_t fDYU; ///< derivation in y up
+ Float_t fDYD; ///< distortion of y down
//
- Float_t fDZU; //derivation in y up
- Float_t fDZD; //distortion of y down
+ Float_t fDZU; ///< derivation in y up
+ Float_t fDZD; ///< distortion of y down
//
- Float_t fDDY; //derivation in y,z up-down
- Float_t fDDZ; //derivation in y,z up-down
+ Float_t fDDY; ///< derivation in y,z up-down
+ Float_t fDDZ; ///< derivation in y,z up-down
//
- Int_t fID; //id of the corresponding track
- Int_t fLab; //MC label of the track
- ClassDef(AliTPCTrackPoint2,1)
+ Int_t fID; ///< id of the corresponding track
+ Int_t fLab; ///< MC label of the track
};
* provided "as is" without express or implied warranty. *
**************************************************************************/
-/* $Id$ */
-
-///////////////////////////////////////////////////////////////////////
-// Paramter class for AliDetector //
-// //
-// Origin: Marian Ivanov, Uni. of Bratislava, ivanov@fmph.uniba.sk //
-// //
-///////////////////////////////////////////////////////////////////////
+/// \class AliDetectorParam
+///
+/// Paramter class for AliDetector
+///
+/// \author Marian Ivanov, Uni. of Bratislava, ivanov@fmph.uniba.sk
#include <TMath.h>
#include <TObject.h>
fNPrimLoss(0.),
fNTotalLoss(0.)
{
- //
- // default constructor
- //
+ /// default constructor
+
}
Float_t * AliDetectorParam::GetAnglesAccMomentum(Float_t *x, Int_t * /*index*/, Float_t *momentum, Float_t *angle)
{
- //
- //calculates deflection angle of particle with longitudinal
- //longitudinal momentum[0] and transversal momentum momentum[1]
- //at position (x,y,z) = (x[0],x[1],x[2])
- //angle[0] - deep angle
- //angle[1] - magnetic deflection angle
+ /// calculates deflection angle of particle with longitudinal
+ /// longitudinal momentum[0] and transversal momentum momentum[1]
+ /// at position (x,y,z) = (x[0],x[1],x[2])
+ /// angle[0] - deep angle
+ /// angle[1] - magnetic deflection angle
+
if (momentum==0) {
Float_t rtotal =TMath::Sqrt(x[0]*x[0]+x[1]*x[1]);
if (rtotal==0) angle[0]=0;
- else
+ else
angle[0] = TMath::ATan(x[2]/rtotal);
angle[1]=0;
return angle;
Float_t radius2 = 1000*mtotal/(3*fBField);
if (radius1<radius2)
angle[1]= TMath::ASin(radius1/radius2);
- else
+ else
angle[1]=0;
return angle;
-}
-
-
-
-
+}
-ClassImp(AliDetectorParam)
+ClassImp(AliDetectorParam);
/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
* See cxx source for full Copyright notice */
-/* $Id$ */
-
-////////////////////////////////////////////////
-// Manager class for detector parameters //
-////////////////////////////////////////////////
+/// \class AliDetectorParam
+/// \brief Manager class for detector parameters
#include <TNamed.h>
class AliDetectorParam : public TNamed {
public:
AliDetectorParam();
virtual Int_t GetNSegmentsTotal() const {return 0;} //get total nuber of segments
- virtual Bool_t Get1DIndex(Int_t */*index*/, const Int_t * /*arrindex*/) {return kFALSE;}
+ virtual Bool_t Get1DIndex(Int_t */*index*/, const Int_t * /*arrindex*/) {return kFALSE;}
//transform multidimensional index to one dimesional
virtual Bool_t GetNDIndex(const Int_t * /*index1*/, Int_t * /*arrIndex*/) {return kFALSE;}
//trasnform one dimesional index to multidimesional
virtual Float_t GetPrimaryLoss(Float_t */*x*/, Int_t */*index*/, Float_t */*angle*/){return 0;}
virtual Float_t GetTotalLoss(Float_t */*x*/, Int_t */*index*/, Float_t */*angle*/){return 0;}
virtual void GetClusterSize(Float_t */*x*/, Int_t */*index*/, Float_t */*angle*/, Int_t /*mode*/, Float_t */*sigma*/){;}
- virtual void GetSpaceResolution(Float_t */*x*/, Int_t */*index*/, Float_t */*angle*/, Float_t /*amplitude*/, Int_t /*mode*/,
+ virtual void GetSpaceResolution(Float_t */*x*/, Int_t */*index*/, Float_t */*angle*/, Float_t /*amplitude*/, Int_t /*mode*/,
Float_t */*sigma*/){;}
- virtual Float_t * GetAnglesAccMomentum(Float_t *x, Int_t * index, Float_t* momentum, Float_t *angle);
+ virtual Float_t * GetAnglesAccMomentum(Float_t *x, Int_t * index, Float_t* momentum, Float_t *angle);
- void SetBField(Float_t b){fBField=b;} //set magnetic field intensity
+ void SetBField(Float_t b){fBField=b;} //set magnetic field intensity
void SetNPrimLoss(Float_t loss) {fNPrimLoss = loss;}
void SetNTotalLoss(Float_t loss) {fNTotalLoss = loss;}
Float_t GetBFiled() {return fBField;}
Float_t GetNPrimLoss() {return fNPrimLoss;}
Float_t GetNTotalLoss() {return fNTotalLoss;}
protected:
- Float_t fBField; //intensity of magnetic field
- Float_t fNPrimLoss; //number of produced primary electrons per cm
- Float_t fNTotalLoss; //total number of produced electrons per cm
+ Float_t fBField; ///< intensity of magnetic field
+ Float_t fNPrimLoss; ///< number of produced primary electrons per cm
+ Float_t fNTotalLoss; ///< total number of produced electrons per cm
ClassDef(AliDetectorParam,1) //parameter object for set:TPC
};
-- for Marek -I had it in my code
*/
-///////////////////////////////////////////////////////////////////////////////
-// //
-// Alice digits array object AliDigits //
-// //
-// //
-// //
-///////////////////////////////////////////////////////////////////////////////
+/// \class AliDigits
+///
+/// Alice digits array object AliDigits
#include "TClass.h"
//_____________________________________________________________________________
//_____________________________________________________________________________
//_____________________________________________________________________________
+/// \cond CLASSIMP
ClassImp(AliDigits)
+/// \endcond
AliDigits::AliDigits()
fCurrentCol(0),
fCurrentIndex(0)
{
- //
- //copy constructor
- //
+ /// copy constructor
+
fNrows = digits.fNrows;
fNcols = digits.fNcols;
fElements = new TArrayS(*(digits.fElements));
AliDigits & AliDigits::operator =(const AliDigits & digits)
{
- //assignment operator
+ /// assignment operator
+
if (this == &digits) return (*this);
fNrows = digits.fNrows;
AliDigits::~AliDigits()
{
- //
- //default destructor
+ /// default destructor
+
if (fIndex !=0 ) {
delete fIndex;
}
Bool_t AliDigits::OutOfBoundsError(const char *where, Int_t row, Int_t column)
{
- // Generate an out-of-bounds error. Always returns false.
+ /// Generate an out-of-bounds error. Always returns false.
+
::Error(where, "row %d col %d out of bounds (size: %d x %d, this: 0x%08lx)",
row, column, fNrows, fNcols, (ULong_t) this);
return kFALSE;
void AliDigits::Invalidate()
{
- //
- //set default (invalid parameters)
+ /// set default (invalid parameters)
+
if (fIndex != 0) delete fIndex;
fIndex = new TArrayI;
void AliDigits::Allocate(Int_t rows, Int_t columns)
{
- //
- //construct empty buffer fDigits with size rows x columns
+ /// construct empty buffer fDigits with size rows x columns
+
Invalidate();
if (rows <= 0) {
Error("Allocate", "no of rows has to be positive");
Int_t AliDigits::GetSize()
{
- //
- //return size of object as represented in the memory
- //
- // Int_t size = sizeof(this);
+ /// return size of object as represented in the memory
+ ///
+ /// Int_t size = sizeof(this);
+
Int_t size = 0; // COVERITY consider the previous statment as bug
//
if (fIndex!=0) size+= sizeof(fIndex)+fIndex->GetSize()*sizeof(Int_t);
Int_t AliDigits::GetDigitSize() //return total size of pure digit
{
- //
- //return size of PURE DIGITS
- //
+ /// return size of PURE DIGITS
+
if (fElements==0) return 0;
else return sizeof(fElements)+fElements->GetSize()*sizeof(Short_t);
}
Int_t AliDigits::GetOverTh(Float_t threshold,Float_t x1, Float_t x2, Float_t y1, Float_t y2)
{
- //
- //return number of digits over threshold
- //
+ /// return number of digits over threshold
+
if ( (fElements==0) || (fElements->GetSize()<=0)) return 0;
if (x1<=x2) {
Short_t AliDigits::GetDigit(Int_t row, Int_t column)
{
- //
- // return digit for given row and collumn
+ /// return digit for given row and collumn
+
if (fBufType ==0) return GetDigitFast(row,column);
if (fBufType ==1) return GetDigit1(row,column);
void AliDigits::ExpandBuffer()
{
- //
- //expand buffer to two dimensional array
+ /// expand buffer to two dimensional array
+
if (fBufType<0) {
Error("ExpandBuffer", "buffer doesn't exist");
return;
void AliDigits::CompresBuffer(Int_t bufferType,Int_t threshold)
{
- //
- //compres buffer according buffertype algorithm
+ /// compres buffer according buffertype algorithm
+
if (fBufType<0) {
Error("CompressBuffer", "buffer doesn't exist");
return;
Bool_t AliDigits::First()
{
- //adjust first valid current digit
+ /// adjust first valid current digit
+
if (fBufType ==0) return First0();
if (fBufType ==1) return First1();
return kFALSE;
Bool_t AliDigits::Next()
{
- //addjust next valid current digit
+ /// addjust next valid current digit
+
if (fBufType ==0) return Next0();
if (fBufType ==1) return Next1();
return kFALSE;
void AliDigits::AcceptHisto(AliH2F * his)
{
- //
- //make digits buffer with value according histograms values
- //for testing purpose
+ /// make digits buffer with value according histograms values
+ /// for testing purpose
+
Int_t idim =his->GetNbinsX();
Int_t jdim =his->GetNbinsY();
if ( (idim<1)|| (jdim<1)) {
AliH2F * AliDigits::GenerHisto()
{
- //
- //make digits histo
+ /// make digits histo
+
char ch[30];
snprintf(ch,30, "Segment_%d ",GetID());
if ( (fNrows<1)|| (fNcols<1)) {
AliH2F *AliDigits::DrawDigits(const char *option,Float_t x1, Float_t x2, Float_t y1, Float_t y2)
{
- //
- //draw digits in given array
- //
+ /// draw digits in given array
+
AliH2F *h2f = GenerHisto();
if (x1>=0) {
AliH2F *h2fsub = h2f->GetSubrange2d(x1,x2,y1,y2);
void AliDigits::ExpandBuffer1()
{
- //
- //expand buffer of type to twodimensional array
+ /// expand buffer of type to twodimensional array
+
Int_t i,k;
fNelems = fNrows*fNcols;
Short_t * buf = new Short_t[fNelems];
void AliDigits::CompresBuffer1()
{
- //
- //compres buffer according algorithm 1
- //
+ /// compres buffer according algorithm 1
+
TArrayS buf; //lets have the nearly the "worst case"
buf.Set(fNelems);
TArrayI index;
Bool_t AliDigits::First0()
{
- //
- //first for the buffer type 0
+ /// first for the buffer type 0
+
fCurrentRow = -1;
fCurrentCol = -1;
fCurrentIndex = -1;
Bool_t AliDigits::Next0()
{
- //
- //next for the buffer type 0
- //
+ /// next for the buffer type 0
+
if (fCurrentIndex<0) return kFALSE; // if we didn't adjust first
Int_t i;
for (i=fCurrentIndex+1; ( (i<fNelems) && (fElements->At(i)<=fThreshold) ) ;i++) {}
Bool_t AliDigits::First1()
{
- //
- //first for the buffer type 1
+ /// first for the buffer type 1
+
fCurrentRow = -1;
fCurrentCol = 0;
fCurrentIndex = -1;
Bool_t AliDigits::Next1()
{
- //
- //next for the buffer type 1
+ /// next for the buffer type 1
+
if (fCurrentIndex<0) return kFALSE; // if we didn't adjust first
Int_t i;
for (i=fCurrentIndex+1; i<fNelems;i++){
Short_t AliDigits::GetDigit1(Int_t row, Int_t column)
{
- //
- //return digit for given row and column the buffer type 1
- //no control performed
-
+ /// return digit for given row and column the buffer type 1
+ /// no control performed
+
Int_t i,n2;
if ( (column+1)>=fNcols) n2 = fNelems;
else
/* $Id$ */
-////////////////////////////////////////////////
-// Manager class generaol Alice segment digits
-// segment is for example one pad row in TPC //
-////////////////////////////////////////////////
+/// \class AliDigits
+///
+/// Manager class generaol Alice segment digits
+/// segment is for example one pad row in TPC
#include <TArrayI.h>
#include <TArrayS.h>
Bool_t Next1();//next for the buffer type 1
Short_t GetDigit1(Int_t row, Int_t column); //return digit for given row and column
- Int_t fNrows; //number of rows in Segment
- Int_t fNcols; //number of collumns in Segment
+ Int_t fNrows; ///< number of rows in Segment
+ Int_t fNcols; ///< number of collumns in Segment
private:
- TArrayS *fElements; //buffer of 2 bytes integers for digits
- TArrayI *fIndex; //index position of column
- Int_t fBufType; //type of the buffer - define compression algorithm
- Int_t fThreshold; //treshold for zero suppresion
- Int_t fNelems; //total number of elements
- Int_t fCurrentRow; //!current row iteration
- Int_t fCurrentCol; //!current column iteration
- Int_t fCurrentIndex; //!current index in field
+ TArrayS *fElements; ///< buffer of 2 bytes integers for digits
+ TArrayI *fIndex; ///< index position of column
+ Int_t fBufType; ///< type of the buffer - define compression algorithm
+ Int_t fThreshold; ///< treshold for zero suppresion
+ Int_t fNelems; ///< total number of elements
+ Int_t fCurrentRow; //!< current row iteration
+ Int_t fCurrentCol; //!< current column iteration
+ Int_t fCurrentIndex; //!< current index in field
+ /// \cond CLASSIMP
ClassDef(AliDigits,2)
+ /// \endcond
};
inline Bool_t AliDigits::BoundsOK(const char *where, Int_t row, Int_t col)
{
- //Check If Bound Ok
+ /// Check If Bound Ok
+
if ( (col>=fNcols) || (col<0) ) return OutOfBoundsError(where,row,col);
Int_t index =(*fIndex).At(col)+row;
if ( (index<0) || (index>fNelems)) return OutOfBoundsError(where,row,col);
inline Short_t AliDigits::GetDigitFast(Int_t row, Int_t column)
{
- //
- //return digit from fDigits array
- //if out of range return dummy value ( value at row = 0, collumn = 0)
- //
+ /// return digit from fDigits array
+ /// if out of range return dummy value ( value at row = 0, collumn = 0)
+
return fElements->At(fIndex->At(column)+row);
}
inline Short_t AliDigits::GetDigitUnchecked(Int_t row, Int_t column)
{
- //
- //return digit from fDigits array
- //if out of range return dummy value ( value at row = 0, collumn = 0)
- //
+ /// return digit from fDigits array
+ /// if out of range return dummy value ( value at row = 0, collumn = 0)
+
return fElements->fArray[fIndex->fArray[column]+row];
}
inline Short_t * AliDigits::GetDigitsColumn(Int_t column){
- //
- //return row pointer to the array digits
- //
+ /// return row pointer to the array digits
+
return &(fElements->fArray[fIndex->fArray[column]]);
}
inline void AliDigits::SetDigitFast(Short_t value, Int_t row, Int_t column)
{
- //
- //set digit
- //
+ /// set digit
+
if ( (row<0) || (row>=fNrows) || (column<0) || (column>=fNcols) )
Error("AliDigits::SetDigitFast", "row %d col %d out of bounds (size: %d x %d, this: 0x%08lx)",
row, column, fNrows, fNcols, (ULong_t)this);
* provided "as is" without express or implied warranty. *
**************************************************************************/
-/* $Id$ */
-
-///////////////////////////////////////////////////////////////////////////////
-// //
-// AliDigitsArray object //
-//
-// Origin: Marian Ivanov , GSI Darmstadt
-// //
-// //
-///////////////////////////////////////////////////////////////////////////////
+/// \class AliDigitsArray
+/// \author Marian Ivanov , GSI Darmstadt
#include "TObject.h"
#include "AliSegmentID.h"
+/// \cond CLASSIMP
ClassImp(AliDigitsArray)
-//
+/// \endcond
AliDigitsArray::AliDigitsArray()
:AliSegmentArray(),
fParam(0)
{
- //
- // default constructor
- //
+ /// default constructor
}
AliDigitsArray::AliDigitsArray(const AliDigitsArray ¶m)
:AliSegmentArray(),
fParam(0)
{
- //
- // dummy
- //
+ /// dummy
+
fParam = param.fParam;
}
//
AliDigitsArray & AliDigitsArray::operator =(const AliDigitsArray & param)
{
- //
- // dummy
- //
+ /// dummy
+
if (this == ¶m) return (*this);
fParam = param.fParam;
return (*this);
//
AliDigitsArray::~AliDigitsArray()
{
- // if (fParam != 0) delete fParam;
+ /// if (fParam != 0) delete fParam;
+
}
Bool_t AliDigitsArray::Setup(AliDetectorParam *param)
{
- //
- //setup array according parameters
+ /// setup array according parameters
+
SetParam(param);
return kTRUE;
}
/* $Id$ */
-////////////////////////////////////////////////
-// Manager class for AliDigitsArray //
-////////////////////////////////////////////////
+/// \class AliDigitsArray
+///
+/// Manager class for AliDigitsArray
#include "AliSegmentArray.h"
class AliDetectorParam;
const AliDetectorParam * GetParam() {return fParam;}
virtual Bool_t SetParam(AliDetectorParam * param);
protected:
- AliDetectorParam * fParam; //pointer to detector parameters
+ AliDetectorParam * fParam; ///< pointer to detector parameters
ClassDef(AliDigitsArray,1) // Digits manager
};
/* $Id$ */
-//----------------------------------------------------------------------------
-// Author: Marian Ivanov
-//
-// Implementation of class AliH2F
-//
-//-----------------------------------------------------------------------------
+/// \class AliH2F
+///
+/// Implementation of class AliH2F
+///
+/// \author Marian Ivanov
#include <TClonesArray.h>
#include <TMath.h>
#include "AliH2F.h"
+/// \cond CLASSIMP
ClassImp(AliH2F)
+/// \endcond
//***********************************************************************
//***********************************************************************
//***********************************************************************
TH2F(name,title,nbinsx,xlow,xup
,nbinsy,ylow,yup)
{
- //
-
+ ///
+
}
AliH2F::~AliH2F()
{
- //
+ ///
+
}
AliH2F::AliH2F(const AliH2F &his) :
TH2F(his)
{
- //
-
+ ///
+
}
AliH2F & AliH2F::operator = (const AliH2F & /*his*/)
{
- //
+ ///
+
return *this;
}
void AliH2F::ClearSpectrum()
{
- //clera histogram
+ /// clera histogram
+
Int_t dimx = fXaxis.GetNbins();
Int_t dimy = fYaxis.GetNbins();
for (Int_t i = 0 ;i<dimx;i++)
void AliH2F::AddNoise(Float_t sn)
{
- // add gauss noise with sigma sn
+ /// add gauss noise with sigma sn
+
Int_t dimx = fXaxis.GetNbins();
Int_t dimy = fYaxis.GetNbins();
for (Int_t i = 0 ;i<dimx;i++)
void AliH2F::AddGauss(Float_t x, Float_t y,
Float_t sx, Float_t sy, Float_t max)
{
- //transform to histogram coordinata
+ /// transform to histogram coordinata
+
Int_t dimx = fXaxis.GetNbins();
Int_t dimy = fYaxis.GetNbins();
Float_t dx =(GetXaxis()->GetXmax()-GetXaxis()->GetXmin())/Float_t(dimx);
void AliH2F::ClearUnderTh(Int_t threshold)
{
- //clear histogram for bin under threshold
+ /// clear histogram for bin under threshold
+
Int_t dimx = fXaxis.GetNbins();
Int_t dimy = fYaxis.GetNbins();
for (Int_t i = 0 ;i<=dimx;i++)
void AliH2F::Round()
{
- //round float to integer
+ /// round float to integer
+
Int_t dimx = fXaxis.GetNbins();
Int_t dimy = fYaxis.GetNbins();
for (Int_t i = 0 ;i<=dimx;i++)
AliH2F *AliH2F::GetSubrange2d(Float_t xmin, Float_t xmax,
Float_t ymin, Float_t ymax)
{
- //this function return pointer to the new created
- //histogram which is subhistogram of the
- //calculate number
- //subhistogram range must be inside histogram
+ /// this function return pointer to the new created
+ /// histogram which is subhistogram of the
+ /// calculate number
+ /// subhistogram range must be inside histogram
if (xmax<=xmin) {
xmin=fXaxis.GetXmin();
TH1F *AliH2F::GetAmplitudes(Float_t zmin, Float_t zmax, Float_t th, Float_t xmin, Float_t xmax,
Float_t ymin, Float_t ymax)
{
- //this function return pointer to the new created
- //histogram which is subhistogram of the
- //calculate number
- //subhistogram range must be inside histogram
-
+ /// this function return pointer to the new created
+ /// histogram which is subhistogram of the
+ /// calculate number
+ /// subhistogram range must be inside histogram
+
if (xmax<=xmin) {
xmin=fXaxis.GetXmin();
xmax=fXaxis.GetXmax();
Float_t AliH2F::GetOccupancy(Float_t th , Float_t xmin, Float_t xmax,
Float_t ymin, Float_t ymax)
{
- //this function return pointer to the new created
- //histogram which is subhistogram of the
- //calculate number
- //subhistogram range must be inside histogram
-
+ /// this function return pointer to the new created
+ /// histogram which is subhistogram of the
+ /// calculate number
+ /// subhistogram range must be inside histogram
+
if (xmax<=xmin) {
xmin=fXaxis.GetXmin();
xmax=fXaxis.GetXmax();
/* $Id$ */
-// include files and class forward declarations
+/// \class AliH2F
+/// include files and class forward declarations
#include "TH2.h"
private:
+ /// \cond CLASSIMP
ClassDef(AliH2F,1)
+ /// \endcond
};
#endif /*TH2FSMOOTH_H */
/* $Id$ */
-///////////////////////////////////////////////////////////////////////////////
-// //
-// Alice segment manager object //
-// //
-///////////////////////////////////////////////////////////////////////////////
+/// \class AliSegmentArray
+///
+/// Alice segment manager object
+
#include <Riostream.h>
#include <TTree.h>
using std::endl;
using std::cout;
//_____________________________________________________________________________
+/// \cond CLASSIMP
ClassImp(AliSegmentArray)
+/// \endcond
AliSegmentArray::AliSegmentArray()
:TNamed(),
fBranch(0),
fClass(0)
{
- //
- //constructor which
- //
- // Create an array of objects of classname. The class must inherit from
- // AliSegmentID . The second argument adjust number of entries in
- // the array.
-
+ /// constructor which
+ ///
+ /// Create an array of objects of classname. The class must inherit from
+ /// AliSegmentID . The second argument adjust number of entries in
+ /// the array.
+
SetClass(classname);
if (MakeArray(n)==kFALSE){
fClass(0)
{
- //
- //copy constructor
- // to be later implemented
+ /// copy constructor
+ /// to be later implemented
+
}
AliSegmentArray &AliSegmentArray::operator = (const AliSegmentArray & /*segment*/)
{
- //assignment operator
- //to be later implemented
+ /// assignment operator
+ /// to be later implemented
+
return (*this);
}
AliSegmentArray::~AliSegmentArray()
{
- //
- // default destructor
+ /// default destructor
+
if (fNSegment>0){
fSegment->Delete();
delete fSegment;
Bool_t AliSegmentArray::SetClass(const char *classname)
{
- //
- //set class of stored object
+ /// set class of stored object
+
if ( fClass !=0 ) {
//delete fClass; not ower of fClass
fClass = 0;
AliSegmentID * AliSegmentArray::NewSegment()
{
- //
- //create object according class information
+ /// create object according class information
+
if (fClass==0) return 0;
AliSegmentID * segment = (AliSegmentID * )fClass->New();
if (segment == 0) return 0;
Bool_t AliSegmentArray::AddSegment(AliSegmentID *segment)
{
- //
- // add segment to array
- //
+ /// add segment to array
+
if (segment==0) return kFALSE;
if (fSegment==0) return kFALSE;
if (fClass==0) return kFALSE;
AliSegmentID * AliSegmentArray::AddSegment(Int_t index)
{
- //
- // add segment to array
- //
+ /// add segment to array
+
if (fSegment==0) return 0;
if (fClass==0) return 0;
AliSegmentID * segment = NewSegment();
void AliSegmentArray::ClearSegment(Int_t index)
{
- //
- //remove segment from active memory
- //
- //PH if ((*fSegment)[index]){
+ /// remove segment from active memory
+ ///
+ /// PH if ((*fSegment)[index]){
+
if (fSegment->At(index)){
// (*fSegment)[index]->Delete(); //not working for TClonesArray
//PH delete (*fSegment)[index]; //because problem with deleting TClonesArray
Bool_t AliSegmentArray::MakeArray(Int_t n)
{
- //
- //make array of pointers to Segments
- //
+ /// make array of pointers to Segments
+
if (fSegment) {
fSegment->Delete();
delete fSegment;
}
void AliSegmentArray::MakeTree(TTree* tree)
{
- //Make tree with the name
+ /// Make tree with the name
+
AliSegmentID * psegment = NewSegment();
fTree = tree;
//PH fBranch = fTree->Branch("Segment",psegment->IsA()->GetName(),&psegment,64000);
void AliSegmentArray::MakeTree(char *file)
{
- // AliSegmentID segment;
+ /// AliSegmentID segment;
+
AliSegmentID * psegment = NewSegment();
if (fTree) {
if (fTreeOwner)
Bool_t AliSegmentArray::MakeDictionary(Int_t size)
{
- //
- //create index table for tree
- //
+ /// create index table for tree
+
if (size<1) return kFALSE;
if (fTreeIndex) delete fTreeIndex;
fTreeIndex = new TArrayI();
Bool_t AliSegmentArray::ConnectTree(const char * treeName)
{
- //connect tree from current directory
+ /// connect tree from current directory
+
if (fTree){
if (fTreeOwner)
{
AliSegmentID *AliSegmentArray::LoadSegment(Int_t index)
{
- //
- //load segment with index to the memory
- //
- //
+ /// load segment with index to the memory
+
if (fTreeIndex ==0 ) MakeDictionary(3000);
//firstly try to load dictionary
if (fTreeIndex ==0 ) return 0;
}
AliSegmentID *AliSegmentArray::LoadEntry(Int_t index)
{
- //
- //load segment at position inex in tree to the memory
- //
- //
+ /// load segment at position inex in tree to the memory
+
if (fBranch==0) return 0;
if (index>fTree->GetEntries()) return 0;
AliSegmentID * s = NewSegment();
void AliSegmentArray::StoreSegment(Int_t index)
{
- //
- //make segment persistent
- //
+ /// make segment persistent
+
const AliSegmentID * ksegment = (*this)[index];
if (ksegment == 0 ) return;
if (fTree==0) MakeTree();
/* $Id$ */
-////////////////////////////////////////////////
-// Manager class general Alice segment
-// segment is for example one pad row in TPC //
-////////////////////////////////////////////////
+/// \class AliSegmentArray
+///
+/// Manager class general Alice segment
+/// segment is for example one pad row in TPC
#include "TNamed.h"
#include "TError.h"
protected:
AliSegmentArray(const AliSegmentArray &segment); //copy constructor
AliSegmentArray &operator = (const AliSegmentArray & segment); //assignment operator
- TObjArray * fSegment; //!pointer to array of pointers to segment
- TArrayI * fTreeIndex; //!pointers(index) table in tree
- Int_t fNSegment; //number of alocated segments
- TTree * fTree; //!tree with segment objects
- Bool_t fTreeOwner;// flag determing the ownership of the fTree
- TBranch * fBranch; //!total branch
+ TObjArray * fSegment; //!< pointer to array of pointers to segment
+ TArrayI * fTreeIndex; //!< pointers(index) table in tree
+ Int_t fNSegment; ///< number of alocated segments
+ TTree * fTree; //!< tree with segment objects
+ Bool_t fTreeOwner;///< flag determing the ownership of the fTree
+ TBranch * fBranch; //!< total branch
private:
- TClass * fClass; //!class type of included objects
- ClassDef(AliSegmentArray,3)
+ TClass * fClass; //!< class type of included objects
+
+ /// \cond CLASSIMP
+ ClassDef(AliSegmentArray,3)
+ /// \endcond
+
};
inline const AliSegmentID* AliSegmentArray::operator[](Int_t i)
{
- //
- //return segment with given index
- //
+ /// return segment with given index
+
if ( (i<0) || (i>=fNSegment)) return 0;
return (AliSegmentID *)(fSegment->At(i));
inline const AliSegmentID* AliSegmentArray::At(Int_t i)
{
- //
- //return segment with given index
- //
+ /// return segment with given index
+
if ( (i<0) || (i>=fNSegment)) return 0;
return (AliSegmentID *)(fSegment->At(i));
}
/* $Id$ */
-///////////////////////////////////////////////////////////////////////////////
-// //
-// Alice AliSementID object //
-//
-// //
-// //
-///////////////////////////////////////////////////////////////////////////////
+/// \class AliSegmentID
+///
+/// Alice AliSementID object
#include "AliSegmentID.h"
/* $Id$ */
-////////////////////////////////////////////////
-// Manager class generaol Alice segment
-// segment is for example one pad row in TPC //
-////////////////////////////////////////////////
+/// \class AliSegmentID
+///
+/// Manager class generaol Alice segment
+/// segment is for example one pad row in TPC
#include "TObject.h"
Int_t GetID() {return fSegmentID;}
void SetID(Int_t index){fSegmentID = index;}
protected:
- Int_t fSegmentID; //identification number of Segment
- ClassDef(AliSegmentID,1)
+ Int_t fSegmentID; ///< identification number of Segment
+ /// \cond CLASSIMP
+ /// \endcond
};
#endif //ALISEGMENTID_H
* provided "as is" without express or implied warranty. *
**************************************************************************/
-/* $Id$ */
-
-///////////////////////////////////////////////////////////////////////////////
-// //
-// Alice segment manager object //
-// AliSimDigits object (derived from AliDigits) //
-// provide additional track information to digit //
-// Origin: Marian Ivanov GSI Darmstadt //
-// //
-// //
-///////////////////////////////////////////////////////////////////////////////
+
+/// \class AliSimDigits
+///
+/// Alice segment manager object
+/// AliSimDigits object (derived from AliDigits)
+/// provide additional track information to digit
+/// \author Marian Ivanov GSI Darmstadt
#include "TClass.h"
#include <Riostream.h>
//_____________________________________________________________________________
//_____________________________________________________________________________
//_____________________________________________________________________________
+/// \cond CLASSIMP
ClassImp(AliSimDigits)
+/// \endcond
AliSimDigits::AliSimDigits()
:AliDigits(),
fNlevel(0),
fTrBufType(0)
{
- //
- // dummy
- //
+ /// dummy
+
fTrIndex = param.fTrIndex;
}
//
}
AliSimDigits & AliSimDigits::operator =(const AliSimDigits & param)
{
- //
- // assignment operator - dummy
- //
+ /// assignment operator - dummy
+
if(this!=¶m){
fTrIndex=param.fTrIndex;
}
//__________________________________________________________________
void AliSimDigits::InvalidateTrack()
{
- //
- //set default (invalid parameters)
+ /// set default (invalid parameters)
+
if ( fTracks != 0) delete fTracks;
fTracks = new TArrayI;
if ( fTrIndex != 0) delete fTrIndex;
void AliSimDigits::AllocateTrack(Int_t length)
{
- //
- //construct empty buffer fElements and fTracks with size fNrows x fNcols x
- //length
+ /// construct empty buffer fElements and fTracks with size fNrows x fNcols x
+ /// length
+
InvalidateTrack();
fNlevel = length;
fTracks->Set(fNcols*fNrows*fNlevel);
Int_t AliSimDigits::GetTrackID(Int_t row, Int_t column, Int_t level)
{
- //
- //Get track ID
+ /// Get track ID
+
if (fTrBufType == 0) return GetTrackIDFast(row, column,level);
if (fTrBufType == 1) return GetTrackID1(row, column,level);
if (fTrBufType == 2) return GetTrackID2(row, column,level);
void AliSimDigits::ExpandTrackBuffer()
{
- //
- //expand buffer to two dimensional array
+ /// expand buffer to two dimensional array
+
if (fTrBufType<0) {
Error("ExpandBuffer", "buffer doesn't exist");
return;
void AliSimDigits::CompresTrackBuffer(Int_t bufType)
{
- //
- //compres buffer according buffertype algorithm
- //
+ /// compres buffer according buffertype algorithm
+
if (fTrBufType<0) {
Error("CompressBuffer", "buffer doesn't exist");
return;
Int_t AliSimDigits::GetTrackID1(Int_t row, Int_t column, Int_t level)
{
- //return track ID of digits - for buffer compresion 2
+ /// return track ID of digits - for buffer compresion 2
+
Int_t i,n1,n2;
i = level*fNcols+column;
if ( (i+1)>=fTrIndex->fN) n2 = fTracks->fN;
void AliSimDigits::ExpandTrackBuffer1()
{
- //
- //expand track compressed according algorithm 1 (track id comression independent to the digit compression)
- // !!in expanded tracks we don't use fTrIndex array
- //
+ /// expand track compressed according algorithm 1 (track id comression independent to the digit compression)
+ /// !!in expanded tracks we don't use fTrIndex array
+
fTrBufType = 0;
Int_t i,j;
Int_t all = fNrows*fNcols; //total number of digits
void AliSimDigits::CompresTrackBuffer1()
{
- //
- //comress track according algorithm 1 (track id comression independent to the digit compression)
- //
+ /// comress track according algorithm 1 (track id comression independent to the digit compression)
+
fTrBufType = 1;
TArrayI * buf = new TArrayI; //create new buffer
void AliSimDigits::ExpandTrackBuffer2()
{
- //
- //comress track according algorithm 2 (track id comression according digit compression)
+ /// comress track according algorithm 2 (track id comression according digit compression)
+
fTrBufType = 0;
}
void AliSimDigits::CompresTrackBuffer2()
{
- //
- //comress track according algorithm 2 (track id comression according digit compression)
+ /// comress track according algorithm 2 (track id comression according digit compression)
+
fTrBufType = 2;
}
Int_t AliSimDigits::GetTrackID2(Int_t /*row*/, Int_t /*column*/, Int_t /*level*/)
{
- //returnb track id of digits - for buffer compresion 2
+ /// returnb track id of digits - for buffer compresion 2
+
return -2;
}
AliH2F * AliSimDigits::DrawTracks( const char *option,Int_t level,
Float_t x1, Float_t x2, Float_t y1, Float_t y2)
{
- //
- //draw digits in given array
- //
- //make digits histo
+ /// draw digits in given array
+ ///
+ /// make digits histo
+
char ch[30];
//sprintf(ch,"Track Segment_%d level %d ",GetID(),level );
snprintf(ch,30,"Track Segment_%d level %d ",GetID(),level );
}
void AliSimDigits::GlitchFilter(){
- //
- // glitch filter, optionally
- //
-
+ /// glitch filter, optionally
+
for (Int_t i=0;i<fNcols;i++){ //pads
for(Int_t j=1;j<fNrows-1;j++){ //time bins
// first and last time bins are checked separately
/* $Id$ */
-////////////////////////////////////////////////
-// Manager class generaol Alice segment digits
-// segment is for example one pad row in TPC //
-////////////////////////////////////////////////
+/// \class AliSimDigits
+///
+/// Manager class generaol Alice segment digits
+/// segment is for example one pad row in TPC
+
#include <TError.h>
#include <TArrayI.h>
#include <TClonesArray.h>
void ExpandTrackBuffer2(); //comress track according algorithm 2 (track ID comression according digit compression)
void CompresTrackBuffer2(); //comress track according algorithm 2 (track ID comression according digit compression)
- TArrayI * fTracks; //buffer of track index
- TArrayI * fTrIndex; //index position of column
- Int_t fNlevel; //number of tracks etries for one digit
- Int_t fTrBufType; //buffer type of the tracks
+ TArrayI * fTracks; ///< buffer of track index
+ TArrayI * fTrIndex; ///< index position of column
+ Int_t fNlevel; ///< number of tracks etries for one digit
+ Int_t fTrBufType; ///< buffer type of the tracks
// Bool_t ClassError( ); //signalize class error
+ /// \cond CLASSIMP
ClassDef(AliSimDigits,3)
+ /// \endcond
};
inline Int_t AliSimDigits::GetTrackIDFast(Int_t row, Int_t column,Int_t level)
{
- //
- //return track ID at given row and column
- // return fTracks[level].At(fTrIndex[level][column]+row);
+ /// return track ID at given row and column
+ /// return fTracks[level].At(fTrIndex[level][column]+row);
+
return fTracks->At(level*fNrows*fNcols+fNrows*column+row);
}
inline void AliSimDigits::SetTrackIDFast(Int_t value,Int_t row, Int_t column,Int_t level)
{
- //
+ ///
+
value+=2;
//set ID track at given row and collumn
// fTracks[level][fTrIndex[level][column]+row]=value;
* provided "as is" without express or implied warranty. *
**************************************************************************/
-// This class handles the mapping of the Altro channels in the TPC
-// The mapping is read from an external mapping files
-// Author: C.Cheshkov
+/// \class AliTPCAltroMapping
+/// This class handles the mapping of the Altro channels in the TPC
+/// The mapping is read from an external mapping files
+///
+/// \author C.Cheshkov
#include "AliTPCAltroMapping.h"
#include "AliLog.h"
//#include <stdlib.h>
+/// \cond CLASSIMP
ClassImp(AliTPCAltroMapping)
+/// \endcond
//_____________________________________________________________________________
AliTPCAltroMapping::AliTPCAltroMapping():
fMaxPad(0),
fInvMapping(NULL)
{
- // Constructor
+ /// Constructor
+
ReadMapping();
CloseMappingFile();
}
//_____________________________________________________________________________
AliTPCAltroMapping::~AliTPCAltroMapping()
{
- // destructor
+ /// destructor
+
if (fInvMapping) delete [] fInvMapping;
}
//_____________________________________________________________________________
Bool_t AliTPCAltroMapping::ReadMapping()
{
- // Initalizes the ALTRO mapping from a file
- // Look at the TPC module for the format of
- // the mapping file
+ /// Initalizes the ALTRO mapping from a file
+ /// Look at the TPC module for the format of
+ /// the mapping file
+
if (!fIn) {
AliFatal("Mapping file has not been opened !");
return kFALSE;
//_____________________________________________________________________________
Bool_t AliTPCAltroMapping::CreateInvMapping()
{
- // Create the inverse mapping
- // needed for the simulation of
- // raw data
+ /// Create the inverse mapping
+ /// needed for the simulation of
+ /// raw data
+
if (fInvMapping) return kTRUE;
if (!fMapping) {
//_____________________________________________________________________________
Int_t AliTPCAltroMapping::GetHWAddress(Int_t padrow, Int_t pad, Int_t /* sector */)
{
- // Get the content of the mapping array
- // return -1 in case there is no hardware
- // adress defined for these pad-row and pad
+ /// Get the content of the mapping array
+ /// return -1 in case there is no hardware
+ /// adress defined for these pad-row and pad
+
if (!fInvMapping) {
if (!CreateInvMapping()) return -1;
}
/* Copyright(c) 1998-2003, ALICE Experiment at CERN, All rights reserved. *
* See cxx source for full Copyright notice */
-//////////////////////////////////////////////////////////
-// Class used to setup the mapping of hardware adresses //
-// in ALTRO to pad-rows and pad indeces. //
-// The mapping is defined in an external mapping files //
-// separately. The class derives from the base altro //
-// mapping class defined in the RAW package. //
-//////////////////////////////////////////////////////////
+/// \class AliTPCAltroMapping
+///
+/// Class used to setup the mapping of hardware adresses
+/// in ALTRO to pad-rows and pad indeces.
+/// The mapping is defined in an external mapping files
+/// separately. The class derives from the base altro
+/// mapping class defined in the RAW package.
#include "AliAltroMapping.h"
virtual Bool_t ReadMapping();
virtual Bool_t CreateInvMapping();
- Int_t fMinPadRow; // Minimum Index of pad-row
- Int_t fMaxPadRow; // Maximum Index of pad-row
- Int_t fMaxPad; // Maximum Index of pad inside row
- Short_t *fInvMapping; //! Inverse of fMapping
+ Int_t fMinPadRow; ///< Minimum Index of pad-row
+ Int_t fMaxPadRow; ///< Maximum Index of pad-row
+ Int_t fMaxPad; ///< Maximum Index of pad inside row
+ Short_t *fInvMapping; //!< Inverse of fMapping
private:
* provided "as is" without express or implied warranty. *
**************************************************************************/
-// _________________________________________________________________
-//
-// Begin_Html
-// <h2> AliTPCBoundaryVoltError class </h2>
-// This class calculates the space point distortions due to residual voltage errors on
-// the main boundaries of the TPC. For example, the inner vessel of the TPC is shifted
-// by a certain amount, whereas the ROCs on the A side and the C side follow this mechanical
-// shift (at the inner vessel) in z direction. This example can be named "conical deformation"
-// of the TPC field cage (see example below).
-// <p>
-// The boundary conditions can be set via two arrays (A and C side) which contain the
-// residual voltage setting modeling a possible shift or an inhomogeneity on the TPC field
-// cage. In order to avoid that the user splits the Central Electrode (CE), the settings for
-// the C side is taken from the array on the A side (points: A.6 and A.7). The region betweem
-// the points is interpolated linearly onto the boundaries.
-// <p>
-// The class uses the PoissonRelaxation2D (see AliTPCCorrection) to calculate the resulting
-// electrical field inhomogeneities in the (r,z)-plane. Then, the Langevin-integral formalism
-// is used to calculate the space point distortions. <br>
-// Note: This class assumes a homogeneous magnetic field.
-// <p>
-// One has two possibilities when calculating the $dz$ distortions. The resulting distortions
-// are purely due to the change of the drift velocity (along with the change of the drift field)
-// when the SetROCDisplacement is FALSE. This emulates for example a Gating-Grid Voltage offset
-// without moving the ROCs. When the flag is set to TRUE, the ROCs are assumed to be misaligned
-// and the corresponding offset in z is added.
-// End_Html
-//
-// Begin_Macro(source)
-// {
-// gROOT->SetStyle("Plain"); gStyle->SetPalette(1);
-// TCanvas *c2 = new TCanvas("cAliTPCBoundaryVoltError","cAliTPCBoundaryVoltError",500,300);
-// AliTPCBoundaryVoltError bve;
-// Float_t val = 40;// [Volt]; 40V corresponds to 1mm
-// /* IFC shift, CE follows, ROC follows by factor half */
-// Float_t boundA[8] = { val, val, val,0,0,0,0,val}; // voltages A-side
-// Float_t boundC[6] = {-val,-val,-val,0,0,0}; // voltages C-side
-// bve.SetBoundariesA(boundA);
-// bve.SetBoundariesC(boundC);
-// bve.SetOmegaTauT1T2(-0.32,1,1);
-// bve.SetROCDisplacement(kTRUE); // include the chamber offset in z when calculating the dz distortions
-// bve.CreateHistoDRinZR(0)->Draw("surf2");
-// return c2;
-// }
-// End_Macro
-//
-// Begin_Html
-// <p>
-// Date: 01/06/2010 <br>
-// Authors: Jim Thomas, Stefan Rossegger
-// End_Html
-// _________________________________________________________________
+/// \class AliTPCBoundaryVoltError
+///
+/// <h2> AliTPCBoundaryVoltError class </h2>
+/// This class calculates the space point distortions due to residual voltage errors on
+/// the main boundaries of the TPC. For example, the inner vessel of the TPC is shifted
+/// by a certain amount, whereas the ROCs on the A side and the C side follow this mechanical
+/// shift (at the inner vessel) in z direction. This example can be named "conical deformation"
+/// of the TPC field cage (see example below).
+///
+/// The boundary conditions can be set via two arrays (A and C side) which contain the
+/// residual voltage setting modeling a possible shift or an inhomogeneity on the TPC field
+/// cage. In order to avoid that the user splits the Central Electrode (CE), the settings for
+/// the C side is taken from the array on the A side (points: A.6 and A.7). The region betweem
+/// the points is interpolated linearly onto the boundaries.
+///
+/// The class uses the PoissonRelaxation2D (see AliTPCCorrection) to calculate the resulting
+/// electrical field inhomogeneities in the (r,z)-plane. Then, the Langevin-integral formalism
+/// is used to calculate the space point distortions.
+/// Note: This class assumes a homogeneous magnetic field.
+///
+/// One has two possibilities when calculating the $dz$ distortions. The resulting distortions
+/// are purely due to the change of the drift velocity (along with the change of the drift field)
+/// when the SetROCDisplacement is FALSE. This emulates for example a Gating-Grid Voltage offset
+/// without moving the ROCs. When the flag is set to TRUE, the ROCs are assumed to be misaligned
+/// and the corresponding offset in z is added.
+/// 
+///
+/// \author Jim Thomas, Stefan Rossegger
+/// \date 01/06/2010
#include "AliMagF.h"
#include "AliTPCROC.h"
#include "AliTPCBoundaryVoltError.h"
+/// \cond CLASSIMP
ClassImp(AliTPCBoundaryVoltError)
+/// \endcond
AliTPCBoundaryVoltError::AliTPCBoundaryVoltError()
: AliTPCCorrection("BoundaryVoltError","Boundary Voltage Error"),
}
AliTPCBoundaryVoltError::~AliTPCBoundaryVoltError() {
- //
- // default destructor
- //
+ /// default destructor
+
}
Bool_t AliTPCBoundaryVoltError::AddCorrectionCompact(AliTPCCorrection* corr, Double_t weight){
- //
- // Add correction and make them compact
- // Assumptions:
- // - origin of distortion/correction are additive
- // - only correction ot the same type supported ()
+ /// Add correction and make them compact
+ /// Assumptions:
+ /// - origin of distortion/correction are additive
+ /// - only correction ot the same type supported ()
+
if (corr==NULL) {
AliError("Zerro pointer - correction");
return kFALSE;
void AliTPCBoundaryVoltError::Init() {
- //
- // Initialization funtion
- //
-
+ /// Initialization funtion
+
AliMagF* magF= (AliMagF*)TGeoGlobalMagField::Instance()->GetField();
if (!magF) AliError("Magneticd field - not initialized");
Double_t bzField = magF->SolenoidField()/10.; //field in T
}
void AliTPCBoundaryVoltError::Update(const TTimeStamp &/*timeStamp*/) {
- //
- // Update function
- //
+ /// Update function
+
AliMagF* magF= (AliMagF*)TGeoGlobalMagField::Instance()->GetField();
if (!magF) AliError("Magneticd field - not initialized");
Double_t bzField = magF->SolenoidField()/10.; //field in T
void AliTPCBoundaryVoltError::GetCorrection(const Float_t x[],const Short_t roc,Float_t dx[]) {
- //
- // Calculates the correction due e.g. residual voltage errors on the TPC boundaries
- //
+ /// Calculates the correction due e.g. residual voltage errors on the TPC boundaries
if (!fInitLookUp) {
AliInfo("Lookup table was not initialized! Perform the inizialisation now ...");
}
void AliTPCBoundaryVoltError::InitBoundaryVoltErrorDistortion() {
- //
- // Initialization of the Lookup table which contains the solutions of the
- // Dirichlet boundary problem
- //
+ /// Initialization of the Lookup table which contains the solutions of the
+ /// Dirichlet boundary problem
const Float_t gridSizeR = (fgkOFCRadius-fgkIFCRadius) / (kRows-1) ;
const Float_t gridSizeZ = fgkTPCZ0 / (kColumns-1) ;
}
void AliTPCBoundaryVoltError::Print(const Option_t* option) const {
- //
- // Print function to check the settings of the boundary vectors
- // option=="a" prints the C0 and C1 coefficents for calibration purposes
- //
+ /// Print function to check the settings of the boundary vectors
+ /// option=="a" prints the C0 and C1 coefficents for calibration purposes
TString opt = option; opt.ToLower();
printf("%s\n",GetTitle());
void AliTPCBoundaryVoltError::SetBoundariesA(Float_t boundariesA[8]){
- //
- // set voltage errors on the TPC boundaries - A side
- //
- // Start at IFC at the Central electrode and work anti-clockwise (clockwise for C side) through
- // IFC, ROC, OFC, and CE. The boundary conditions are currently defined to be a linear
- // interpolation between pairs of numbers in the Boundary (e.g. fBoundariesA) vector.
- // The first pair of numbers represent the beginning and end of the Inner Field cage, etc.
- // The unit of the error potential vector is [Volt], whereas 1mm shift of the IFC would
- // correspond to ~ 40 V
- //
- // Note: The setting for the CE will be passed to the C side!
-
+ /// set voltage errors on the TPC boundaries - A side
+ ///
+ /// Start at IFC at the Central electrode and work anti-clockwise (clockwise for C side) through
+ /// IFC, ROC, OFC, and CE. The boundary conditions are currently defined to be a linear
+ /// interpolation between pairs of numbers in the Boundary (e.g. fBoundariesA) vector.
+ /// The first pair of numbers represent the beginning and end of the Inner Field cage, etc.
+ /// The unit of the error potential vector is [Volt], whereas 1mm shift of the IFC would
+ /// correspond to ~ 40 V
+ ///
+ /// Note: The setting for the CE will be passed to the C side!
+
for (Int_t i=0; i<8; i++) {
fBoundariesA[i]= boundariesA[i];
if (i>5) fBoundariesC[i]= -boundariesA[i]; // setting for the CE is passed to C side
fInitLookUp=kFALSE;
}
void AliTPCBoundaryVoltError::SetBoundariesC(Float_t boundariesC[6]){
- //
- // set voltage errors on the TPC boundaries - C side
- //
- // Start at IFC at the Central electrode and work clockwise (for C side) through
- // IFC, ROC and OFC. The boundary conditions are currently defined to be a linear
- // interpolation between pairs of numbers in the Boundary (e.g. fBoundariesC) vector.
- // The first pair of numbers represent the beginning and end of the Inner Field cage, etc.
- // The unit of the error potential vector is [Volt], whereas 1mm shift of the IFC would
- // correspond to ~ 40 V
- //
- // Note: The setting for the CE will be taken from the A side (pos 6 and 7)!
+ /// set voltage errors on the TPC boundaries - C side
+ ///
+ /// Start at IFC at the Central electrode and work clockwise (for C side) through
+ /// IFC, ROC and OFC. The boundary conditions are currently defined to be a linear
+ /// interpolation between pairs of numbers in the Boundary (e.g. fBoundariesC) vector.
+ /// The first pair of numbers represent the beginning and end of the Inner Field cage, etc.
+ /// The unit of the error potential vector is [Volt], whereas 1mm shift of the IFC would
+ /// correspond to ~ 40 V
+ ///
+ /// Note: The setting for the CE will be taken from the A side (pos 6 and 7)!
for (Int_t i=0; i<6; i++) {
fBoundariesC[i]= boundariesC[i];
/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
* See cxx source for full Copyright notice */
-////////////////////////////////////////////////////////////////////////////
-// AliTPCBoundaryVoltError class //
-// date: 01/06/2010 //
-// Authors: Jim Thomas, Stefan Rossegger //
-////////////////////////////////////////////////////////////////////////////
+/// \class AliTPCBoundaryVoltError
+///
+/// AliTPCBoundaryVoltError class
+///
+/// \author Jim Thomas, Stefan Rossegger
+/// \date 01/06/2010
#include "AliTPCCorrection.h"
virtual void GetCorrection(const Float_t x[],const Short_t roc,Float_t dx[]);
private:
- Float_t fC0; // coefficient C0 (compare Jim Thomas's notes for definitions)
- Float_t fC1; // coefficient C1 (compare Jim Thomas's notes for definitions)
- Float_t fBoundariesA[8]; // Boundary values on the A side (see Setter function)
- Float_t fBoundariesC[8]; // Boundary values on the C side (see Setter function)
+ Float_t fC0; ///< coefficient C0 (compare Jim Thomas's notes for definitions)
+ Float_t fC1; ///< coefficient C1 (compare Jim Thomas's notes for definitions)
+ Float_t fBoundariesA[8]; ///< Boundary values on the A side (see Setter function)
+ Float_t fBoundariesC[8]; ///< Boundary values on the C side (see Setter function)
- Bool_t fROCdisplacement; // flag for ROC displacement (important for z distortions)
- Bool_t fInitLookUp; // flag to check it the Look Up table was created
+ Bool_t fROCdisplacement; ///< flag for ROC displacement (important for z distortions)
+ Bool_t fInitLookUp; ///< flag to check it the Look Up table was created
- Double_t fLookUpErOverEz[kNZ][kNR]; // Array to store electric field integral (int Er/Ez)
- Double_t fLookUpDeltaEz[kNZ][kNR]; // Array to store electric field integral (int Delta Ez)
+ Double_t fLookUpErOverEz[kNZ][kNR]; ///< Array to store electric field integral (int Er/Ez)
+ Double_t fLookUpDeltaEz[kNZ][kNR]; ///< Array to store electric field integral (int Delta Ez)
// basic numbers for the poisson relaxation //can be set individually in each class
enum {kRows =257}; // grid size in r direction used in the poisson relaxation // ( 2**n + 1 ) eg. 65, 129, 257 etc.
enum {kColumns=257}; // grid size in r direction used in the poisson relaxation // ( 2**m + 1 ) eg. 65, 129, 257 etc.
enum {kIterations=100}; // Number of iterations within the poisson relaxation
+ /// \cond CLASSIMP
ClassDef(AliTPCBoundaryVoltError,1);
+ /// \endcond
};
#endif
/* $Id$ */
-///////////////////////////////////////////////////////////////////////////////
-// //
-// TPC calibration class for parameters which are saved per pad //
-// Each AliTPCCalPad consists of 72 AliTPCCalROC-objects //
-// //
-///////////////////////////////////////////////////////////////////////////////
+/// \class AliTPCCalPad
+///
+/// TPC calibration class for parameters which are saved per pad
+/// Each AliTPCCalPad consists of 72 AliTPCCalROC-objects
#include "AliTPCCalPad.h"
#include "AliTPCCalROC.h"
#include <TVirtualPad.h>
#include "AliTPCPreprocessorOnline.h"
#include "AliTPCCalibViewer.h"
+/// \cond CLASSIMP
ClassImp(AliTPCCalPad)
+/// \endcond
//_____________________________________________________________________________
AliTPCCalPad::AliTPCCalPad():TNamed()
AliTPCCalPad::AliTPCCalPad(const Text_t *name, const Text_t *title)
:TNamed(name,title)
{
- //
- // AliTPCCalPad constructor
- //
+ /// AliTPCCalPad constructor
+
for (Int_t isec = 0; isec < kNsec; isec++) {
fROC[isec] = new AliTPCCalROC(isec);
}
//_____________________________________________________________________________
AliTPCCalPad::AliTPCCalPad(const AliTPCCalPad &c):TNamed(c)
{
- //
- // AliTPCCalPad copy constructor
- //
+ /// AliTPCCalPad copy constructor
for (Int_t isec = 0; isec < kNsec; isec++) {
fROC[isec] = 0;
//_____________________________________________________________________________
AliTPCCalPad::AliTPCCalPad(TObjArray * array):TNamed(array->GetName(),array->GetName())
{
- //
- // AliTPCCalPad default constructor
- //
+ /// AliTPCCalPad default constructor
for (Int_t isec = 0; isec < kNsec; isec++) {
fROC[isec] = (AliTPCCalROC *)array->At(isec);
///_____________________________________________________________________________
AliTPCCalPad::~AliTPCCalPad()
{
- //
- // AliTPCCalPad destructor
- //
+ /// AliTPCCalPad destructor
for (Int_t isec = 0; isec < kNsec; isec++) {
if (fROC[isec]) {
//_____________________________________________________________________________
AliTPCCalPad &AliTPCCalPad::operator=(const AliTPCCalPad &c)
{
- //
- // Assignment operator
- //
+ /// Assignment operator
if (this != &c) ((AliTPCCalPad &) c).Copy(*this);
return *this;
//_____________________________________________________________________________
void AliTPCCalPad::Copy(TObject &c) const
{
- //
- // Copy function
- //
+ /// Copy function
for (Int_t isec = 0; isec < kNsec; isec++) {
if (fROC[isec]) {
void AliTPCCalPad::SetCalROC(AliTPCCalROC* roc, Int_t sector){
- //
- // Set AliTPCCalROC copies values from 'roc'
- // if sector == -1 the sector specified in 'roc' is used
- // else sector specified in 'roc' is ignored and specified sector is filled
- //
+ /// Set AliTPCCalROC copies values from 'roc'
+ /// if sector == -1 the sector specified in 'roc' is used
+ /// else sector specified in 'roc' is ignored and specified sector is filled
+
if (sector == -1) sector = roc->GetSector();
if (!fROC[sector]) fROC[sector] = new AliTPCCalROC(sector);
for (UInt_t ichannel = 0; ichannel < roc->GetNchannels(); ichannel++)
}
Bool_t AliTPCCalPad::MedianFilter(Int_t deltaRow, Int_t deltaPad, AliTPCCalPad*outlierPad, Bool_t doEdge){
- //
- // replace constent with median in the neigborhood
- //
+ /// replace constent with median in the neigborhood
+
Bool_t isOK=kTRUE;
for (Int_t isec = 0; isec < kNsec; isec++) {
AliTPCCalROC *outlierROC=(outlierPad==NULL)?NULL:outlierPad->GetCalROC(isec);
}
Bool_t AliTPCCalPad::LTMFilter(Int_t deltaRow, Int_t deltaPad, Float_t fraction, Int_t type, AliTPCCalPad*outlierPad, Bool_t doEdge){
- //
- // replace constent with LTM statistic in neigborhood
- //
+ /// replace constent with LTM statistic in neigborhood
+
Bool_t isOK=kTRUE;
for (Int_t isec = 0; isec < kNsec; isec++) {
AliTPCCalROC *outlierROC=(outlierPad==NULL)?NULL:outlierPad->GetCalROC(isec);
}
Bool_t AliTPCCalPad::Convolute(Double_t sigmaPad, Double_t sigmaRow, AliTPCCalPad*outlierPad, TF1 *fpad, TF1 *frow){
- //
- // replace constent with median in the neigborhood
- //
+ /// replace constent with median in the neigborhood
+
Bool_t isOK=kTRUE;
for (Int_t isec = 0; isec < kNsec; isec++) {
AliTPCCalROC *outlierROC=(outlierPad==NULL)?NULL:outlierPad->GetCalROC(isec);
//_____________________________________________________________________________
void AliTPCCalPad::Add(Float_t c1)
{
- //
- // add constant c1 to all channels of all ROCs
- //
+ /// add constant c1 to all channels of all ROCs
for (Int_t isec = 0; isec < kNsec; isec++) {
if (fROC[isec]){
//_____________________________________________________________________________
void AliTPCCalPad::Multiply(Float_t c1)
{
- //
- // multiply each channel of all ROCs with c1
- //
+ /// multiply each channel of all ROCs with c1
+
for (Int_t isec = 0; isec < kNsec; isec++) {
if (fROC[isec]){
fROC[isec]->Multiply(c1);
//_____________________________________________________________________________
void AliTPCCalPad::Add(const AliTPCCalPad * pad, Double_t c1)
{
- //
- // multiply AliTPCCalPad 'pad' by c1 and add each channel to the coresponing channel in all ROCs
- // - pad by pad -
- //
+ /// multiply AliTPCCalPad 'pad' by c1 and add each channel to the coresponing channel in all ROCs
+ /// - pad by pad -
+
for (Int_t isec = 0; isec < kNsec; isec++) {
if (fROC[isec] && pad->GetCalROC(isec)){
fROC[isec]->Add(pad->GetCalROC(isec),c1);
//_____________________________________________________________________________
void AliTPCCalPad::Multiply(const AliTPCCalPad * pad)
{
- //
- // multiply each channel of all ROCs with the coresponding channel of 'pad'
- // - pad by pad -
- //
+ /// multiply each channel of all ROCs with the coresponding channel of 'pad'
+ /// - pad by pad -
+
for (Int_t isec = 0; isec < kNsec; isec++) {
if (fROC[isec]){
fROC[isec]->Multiply(pad->GetCalROC(isec));
//_____________________________________________________________________________
void AliTPCCalPad::Divide(const AliTPCCalPad * pad)
{
- //
- // divide each channel of all ROCs by the coresponding channel of 'pad'
- // - pad by pad -
- //
+ /// divide each channel of all ROCs by the coresponding channel of 'pad'
+ /// - pad by pad -
+
for (Int_t isec = 0; isec < kNsec; isec++) {
if (fROC[isec]){
fROC[isec]->Divide(pad->GetCalROC(isec));
//_____________________________________________________________________________
void AliTPCCalPad::Reset()
{
- //
- // Reset all cal Rocs
- //
+ /// Reset all cal Rocs
+
for (Int_t isec = 0; isec < kNsec; isec++) {
if (fROC[isec]){
fROC[isec]->Reset();
//_____________________________________________________________________________
TGraph * AliTPCCalPad::MakeGraph(Int_t type, Float_t ratio){
- //
- // type=1 - mean
- // 2 - median
- // 3 - LTM
- //
+ /// type=1 - mean
+ /// 2 - median
+ /// 3 - LTM
+
Int_t npoints = 0;
for (Int_t i=0;i<72;i++) if (fROC[i]) npoints++;
TGraph * graph = new TGraph(npoints);
//_____________________________________________________________________________
Double_t AliTPCCalPad::GetMeanRMS(Double_t &rms)
{
- //
- // Calculates mean and RMS of all ROCs
- //
+ /// Calculates mean and RMS of all ROCs
+
Double_t sum = 0, sum2 = 0, n=0, val=0;
for (Int_t isec = 0; isec < kNsec; isec++) {
AliTPCCalROC *calRoc = fROC[isec];
//_____________________________________________________________________________
Double_t AliTPCCalPad::GetMean(AliTPCCalPad* outlierPad)
{
- //
- // return mean of the mean of all ROCs
- //
+ /// return mean of the mean of all ROCs
+
Double_t arr[kNsec];
Int_t n=0;
for (Int_t isec = 0; isec < kNsec; isec++) {
//_____________________________________________________________________________
Double_t AliTPCCalPad::GetRMS(AliTPCCalPad* outlierPad)
{
- //
- // return mean of the RMS of all ROCs
- //
+ /// return mean of the RMS of all ROCs
+
Double_t arr[kNsec];
Int_t n=0;
for (Int_t isec = 0; isec < kNsec; isec++) {
//_____________________________________________________________________________
Double_t AliTPCCalPad::GetMedian(AliTPCCalPad* outlierPad)
{
- //
- // return mean of the median of all ROCs
- //
+ /// return mean of the median of all ROCs
+
Double_t arr[kNsec];
Int_t n=0;
for (Int_t isec = 0; isec < kNsec; isec++) {
//_____________________________________________________________________________
Double_t AliTPCCalPad::GetLTM(Double_t *sigma, Double_t fraction, AliTPCCalPad* outlierPad)
{
- //
- // return mean of the LTM and sigma of all ROCs
- //
+ /// return mean of the LTM and sigma of all ROCs
+
Double_t arrm[kNsec];
Double_t arrs[kNsec];
Double_t *sTemp=0x0;
//_____________________________________________________________________________
TH1F * AliTPCCalPad::MakeHisto1D(Float_t min, Float_t max,Int_t type, Int_t side){
- //
- // make 1D histo
- // type -1 = user defined range
- // 0 = nsigma cut nsigma=min
- //
+ /// make 1D histo
+ /// type -1 = user defined range
+ /// 0 = nsigma cut nsigma=min
+
if (type>=0){
if (type==0){
// nsigma range
//_____________________________________________________________________________
TH2F *AliTPCCalPad::MakeHisto2D(Int_t side){
- //
- // Make 2D graph
- // side - specify the side A = 0 C = 1
- // type - used types of determination of boundaries in z
- //
+ /// Make 2D graph
+ /// side - specify the side A = 0 C = 1
+ /// type - used types of determination of boundaries in z
+
Float_t kEpsilon = 0.000000000001;
TH2F * his = new TH2F(GetName(), GetName(), 250,-250,250,250,-250,250);
AliTPCROC * roc = AliTPCROC::Instance();
AliTPCCalPad* AliTPCCalPad::LocalFit(const char* padName, Int_t rowRadius, Int_t padRadius, AliTPCCalPad* PadOutliers, Bool_t robust, Double_t chi2Threshold, Double_t robustFraction, Bool_t printCurrentSector) const {
- //
- // Loops over all AliTPCCalROCs and performs a localFit in each ROC
- // AliTPCCalPad with fit-data is returned
- // rowRadius and padRadius specifies a window around a given pad in one sector.
- // The data of this window are fitted with a parabolic function.
- // This function is evaluated at the pad's position.
- // At the edges the window is shifted, so that the specified pad is not anymore in the center of the window.
- // rowRadius - radius - rows to be used for smoothing
- // padradius - radius - pads to be used for smoothing
- // ROCoutlier - map of outliers - pads not to be used for local smoothing
- // robust - robust method of fitting - (much slower)
- // chi2Threshold: Threshold for chi2 when EvalRobust is called
- // robustFraction: Fraction of data that will be used in EvalRobust
- //
- //
+ /// Loops over all AliTPCCalROCs and performs a localFit in each ROC
+ /// AliTPCCalPad with fit-data is returned
+ /// rowRadius and padRadius specifies a window around a given pad in one sector.
+ /// The data of this window are fitted with a parabolic function.
+ /// This function is evaluated at the pad's position.
+ /// At the edges the window is shifted, so that the specified pad is not anymore in the center of the window.
+ /// rowRadius - radius - rows to be used for smoothing
+ /// padradius - radius - pads to be used for smoothing
+ /// ROCoutlier - map of outliers - pads not to be used for local smoothing
+ /// robust - robust method of fitting - (much slower)
+ /// chi2Threshold: Threshold for chi2 when EvalRobust is called
+ /// robustFraction: Fraction of data that will be used in EvalRobust
+
AliTPCCalPad* pad = new AliTPCCalPad(padName, padName);
for (Int_t isec = 0; isec < 72; isec++){
if (printCurrentSector) std::cout << "LocalFit in sector " << isec << "\r" << std::flush;
AliTPCCalPad* AliTPCCalPad::GlobalFit(const char* padName, AliTPCCalPad* PadOutliers, Bool_t robust, Int_t fitType, Double_t chi2Threshold, Double_t robustFraction, Double_t err, TObjArray *fitParArr, TObjArray *fitCovArr){
- //
- // Loops over all AliTPCCalROCs and performs a globalFit in each ROC
- // AliTPCCalPad with fit-data is returned
- // chi2Threshold: Threshold for chi2 when EvalRobust is called
- // robustFraction: Fraction of data that will be used in EvalRobust
- // chi2Threshold: Threshold for chi2 when EvalRobust is called
- // robustFraction: Fraction of data that will be used in EvalRobust
- // err: error of the data points
- // if fitParArr and/or fitCovArr is given, write fitParameters and/or covariance Matrices into the array
- //
+ /// Loops over all AliTPCCalROCs and performs a globalFit in each ROC
+ /// AliTPCCalPad with fit-data is returned
+ /// chi2Threshold: Threshold for chi2 when EvalRobust is called
+ /// robustFraction: Fraction of data that will be used in EvalRobust
+ /// chi2Threshold: Threshold for chi2 when EvalRobust is called
+ /// robustFraction: Fraction of data that will be used in EvalRobust
+ /// err: error of the data points
+ /// if fitParArr and/or fitCovArr is given, write fitParameters and/or covariance Matrices into the array
+
AliTPCCalPad* pad = new AliTPCCalPad(padName, padName);
TVectorD fitParam(0);
TMatrixD covMatrix(0,0);
//_____________________________________________________________________________
TObjArray* AliTPCCalPad::CreateFormulaArray(const char *fitFormula)
{
- //
- // create an array of TFormulas for the each parameter of the fit function
- //
+ /// create an array of TFormulas for the each parameter of the fit function
// split fit string in single parameters
// find dimension of the fit:
void AliTPCCalPad::EvalFormulaArray(const TObjArray &arrFitFormulas, TVectorD &results,
const Int_t sec, const Int_t row, const Int_t pad)
{
- //
- // evaluate the fit formulas
- //
+ /// evaluate the fit formulas
+
Int_t ndim=arrFitFormulas.GetEntries();
results.ResizeTo(ndim);
}
//_____________________________________________________________________________
void AliTPCCalPad::GlobalSidesFit(const AliTPCCalPad* PadOutliers, const char* fitFormula, TVectorD &fitParamSideA, TVectorD &fitParamSideC,TMatrixD &covMatrixSideA, TMatrixD &covMatrixSideC, Float_t & chi2SideA, Float_t & chi2SideC, AliTPCCalPad *pointError, Bool_t robust, Double_t robustFraction){
- //
- // Performs a fit on both sides.
- // Valid information for the fitFormula are the variables
- // - gx, gy, lx ,ly: meaning global x, global y, local x, local y value of the padName
- // - sector: the sector number.
- // eg. a formula might look 'gy' or '(sector<36) ++ gy' or 'gx ++ gy' or 'gx ++ gy ++ lx ++ lx^2' and so on
- //
- // PadOutliers - pads with value !=0 are not used in fitting procedure
- // chi2Threshold: Threshold for chi2 when EvalRobust is called
- // robustFraction: Fraction of data that will be used in EvalRobust
- //
+ /// Performs a fit on both sides.
+ /// Valid information for the fitFormula are the variables
+ /// - gx, gy, lx ,ly: meaning global x, global y, local x, local y value of the padName
+ /// - sector: the sector number.
+ /// eg. a formula might look 'gy' or '(sector<36) ++ gy' or 'gx ++ gy' or 'gx ++ gy ++ lx ++ lx^2' and so on
+ ///
+ /// PadOutliers - pads with value !=0 are not used in fitting procedure
+ /// chi2Threshold: Threshold for chi2 when EvalRobust is called
+ /// robustFraction: Fraction of data that will be used in EvalRobust
TObjArray* arrFitFormulas=CreateFormulaArray(fitFormula);
Int_t ndim = arrFitFormulas->GetEntries();
//
AliTPCCalPad *AliTPCCalPad::CreateCalPadFit(const char* fitFormula, const TVectorD &fitParamSideA, const TVectorD &fitParamSideC)
{
- //
- //
- //
+ ///
+
TObjArray *arrFitFormulas=CreateFormulaArray(fitFormula);
Int_t ndim = arrFitFormulas->GetEntries();
//check if dimension of fit formula and fit parameters agree
TCanvas * AliTPCCalPad::MakeReportPadSector(TTree *chain, const char* varName, const char*varTitle, const char *axisTitle, Float_t min, Float_t max, const char *cutUser){
- //
- // Make a report - cal pads per sector
- // mean valeus per sector and local X
- //
+ /// Make a report - cal pads per sector
+ /// mean valeus per sector and local X
+
TH1* his=0;
TLegend *legend = 0;
TCanvas *canvas = new TCanvas(Form("Sector: %s",varTitle),Form("Sector: %s",varTitle),1500,1100);
TCanvas * AliTPCCalPad::MakeReportPadSector2D(TTree *chain, const char* varName, const char*varTitle, const char *axisTitle, Float_t min, Float_t max, const char *cutUser){
- //
- // Make a report - cal pads per sector
- // 2D view
- // Input tree should be created using AliPreprocesorOnline before
- //
+ /// Make a report - cal pads per sector
+ /// 2D view
+ /// Input tree should be created using AliPreprocesorOnline before
+
TH1* his=0;
TCanvas *canvas = new TCanvas(Form("%s2D",varTitle),Form("%s2D",varTitle),1500,1100);
canvas->Divide(2);
}
void AliTPCCalPad::Draw(Option_t* option){
- //
- // Draw function - standard 2D view
- //
+ /// Draw function - standard 2D view
+
TH1* his=0;
TCanvas *canvas = new TCanvas(Form("%s2D",GetTitle()),Form("%s2D",GetTitle()),900,900);
canvas->Divide(2,2);
AliTPCCalPad * AliTPCCalPad::MakeCalPadFromHistoRPHI(TH2 * hisA, TH2* hisC){
- //
- // Make cal pad from r-phi histograms
- //
+ /// Make cal pad from r-phi histograms
+
AliTPCROC *proc= AliTPCROC::Instance();
AliTPCCalPad *calPad = new AliTPCCalPad("his","his");
Float_t globalPos[3];
}
AliTPCCalPad *AliTPCCalPad::MakePadFromTree(TTree * treePad, const char *query, const char* name, Bool_t doFast){
- //
- // make cal pad from the tree
- //
+ /// make cal pad from the tree
+
if (!treePad){
::Error("AliTPCCalPad::MakePadFromTree(TTree * treePad, const char *query, const char* name)","Input tree is missing");
return 0;
}
void AliTPCCalPad::AddFriend(TTree * treePad, const char *friendName, const char *fname){
- //
- //
- //
+ ///
+
TObjArray *fArray = new TObjArray(1);
fArray->AddLast(this);
this->SetName(friendName);
/* $Id$ */
-///////////////////////////////////////////////////////////////////////////////
-// //
-// TPC calibration class for parameters which are saved per pad //
-// //
-///////////////////////////////////////////////////////////////////////////////
+/// \class AliTPCCalPad
+///
+/// TPC calibration class for parameters which are saved per pad
#include "TNamed.h"
//#include <TMath.h>
static TCanvas * MakeReportPadSector2D(TTree *chain, const char* varName, const char*varTitle, const char *axisTitle, Float_t min, Float_t max, const char *cutUser="");
static AliTPCCalPad *MakeCalPadFromHistoRPHI(TH2 * hisA, TH2* hisC);
protected:
- AliTPCCalROC *fROC[kNsec]; // Array of ROC objects which contain the values per pad
+ AliTPCCalROC *fROC[kNsec]; ///< Array of ROC objects which contain the values per pad
+ /// \cond CLASSIMP
ClassDef(AliTPCCalPad,1) // TPC calibration class for parameters which are saved per pad
+ /// \endcond
};
#endif
**************************************************************************/
-///////////////////////////////////////////////////////////////////////////////
-// //
-// Calibration base class for a single ROC //
-// Contains one float value per pad //
-// mapping of the pads taken form AliTPCROC //
-// //
-///////////////////////////////////////////////////////////////////////////////
-
-//
-// ROOT includes
-//
+/// \class AliTPCCalROC
+///
+/// Calibration base class for a single ROC
+/// Contains one float value per pad
+/// mapping of the pads taken form AliTPCROC
+///
+
+// ROOT includes
#include "TMath.h"
#include "TClass.h"
#include "TFile.h"
#include "TRandom3.h" // only needed by the AliTPCCalROCTest() method
+/// \cond CLASSIMP
ClassImp(AliTPCCalROC)
+/// \endcond
//_____________________________________________________________________________
fkIndexes(0),
fData(0)
{
- //
- // Constructor that initializes a given sector
- //
+ /// Constructor that initializes a given sector
+
fSector = sector;
fNChannels = AliTPCROC::Instance()->GetNChannels(fSector);
fNRows = AliTPCROC::Instance()->GetNRows(fSector);
fkIndexes(0),
fData(0)
{
- //
- // AliTPCCalROC copy constructor
- //
+ /// AliTPCCalROC copy constructor
+
fSector = c.fSector;
fNChannels = AliTPCROC::Instance()->GetNChannels(fSector);
fNRows = AliTPCROC::Instance()->GetNRows(fSector);
//____________________________________________________________________________
AliTPCCalROC & AliTPCCalROC::operator =(const AliTPCCalROC & param)
{
- //
- // assignment operator - dummy
- //
+ /// assignment operator - dummy
+
if (this == ¶m) return (*this);
fSector = param.fSector;
fNChannels = AliTPCROC::Instance()->GetNChannels(fSector);
//_____________________________________________________________________________
AliTPCCalROC::~AliTPCCalROC()
{
- //
- // AliTPCCalROC destructor
- //
+ /// AliTPCCalROC destructor
+
if (fData) {
delete [] fData;
fData = 0;
void AliTPCCalROC::Streamer(TBuffer &R__b)
{
- //
- // Stream an object of class AliTPCCalROC.
- //
+ /// Stream an object of class AliTPCCalROC.
+
if (R__b.IsReading()) {
AliTPCCalROC::Class()->ReadBuffer(R__b, this);
fkIndexes = AliTPCROC::Instance()->GetRowIndexes(fSector);
//
Bool_t AliTPCCalROC::MedianFilter(Int_t deltaRow, Int_t deltaPad, AliTPCCalROC* outlierROC, Bool_t doEdge){
- //){
- //
- // Modify content of the object - raplace value by median in neighorhood
- //
+ /// Modify content of the object - raplace value by median in neighorhood
+
Float_t *newBuffer=new Float_t[fNChannels] ;
Double_t *cacheBuffer=new Double_t[fNChannels];
//
Bool_t AliTPCCalROC::LTMFilter(Int_t deltaRow, Int_t deltaPad, Float_t fraction, Int_t type, AliTPCCalROC* outlierROC, Bool_t doEdge){
- //){
- //
- //
- // //
- // Modify content of the class
- // write LTM mean or median
+ /// Modify content of the class
+ /// write LTM mean or median
+
if (fraction<0 || fraction>1) return kFALSE;
Float_t *newBuffer=new Float_t[fNChannels] ;
Double_t *cacheBuffer=new Double_t[fNChannels];
}
Bool_t AliTPCCalROC::Convolute(Double_t sigmaPad, Double_t sigmaRow, AliTPCCalROC*outlierROC, TF1 */*fpad*/, TF1 */*frow*/){
- //
- // convolute the calibration with function fpad,frow
- // in range +-4 sigma
+ /// convolute the calibration with function fpad,frow
+ /// in range +-4 sigma
Float_t *newBuffer=new Float_t[fNChannels] ;
//
// algebra fuctions:
void AliTPCCalROC::Add(Float_t c1){
- //
- // add c1 to each channel of the ROC
- //
+ /// add c1 to each channel of the ROC
+
for (UInt_t idata = 0; idata< fNChannels; idata++) fData[idata]+=c1;
}
void AliTPCCalROC::Multiply(Float_t c1){
- //
- // multiply each channel of the ROC with c1
- //
+ /// multiply each channel of the ROC with c1
+
for (UInt_t idata = 0; idata< fNChannels; idata++) fData[idata]*=c1;
}
void AliTPCCalROC::Add(const AliTPCCalROC * roc, Double_t c1){
- //
- // multiply AliTPCCalROC roc by c1 and add each channel to the coresponing channel in the ROC
- // - pad by pad
- //
+ /// multiply AliTPCCalROC roc by c1 and add each channel to the coresponing channel in the ROC
+ /// - pad by pad
+
if (!roc) return;
for (UInt_t idata = 0; idata< fNChannels; idata++){
fData[idata]+=roc->fData[idata]*c1;
void AliTPCCalROC::Multiply(const AliTPCCalROC* roc) {
- //
- // multiply each channel of the ROC with the coresponding channel of 'roc'
- // - pad by pad -
- //
+ /// multiply each channel of the ROC with the coresponding channel of 'roc'
+ /// - pad by pad -
+
if (!roc) return;
for (UInt_t idata = 0; idata< fNChannels; idata++){
fData[idata]*=roc->fData[idata];
void AliTPCCalROC::Divide(const AliTPCCalROC* roc) {
- //
- // divide each channel of the ROC by the coresponding channel of 'roc'
- // - pad by pad -
- //
+ /// divide each channel of the ROC by the coresponding channel of 'roc'
+ /// - pad by pad -
+
if (!roc) return;
Float_t kEpsilon=0.00000000000000001;
for (UInt_t idata = 0; idata< fNChannels; idata++){
void AliTPCCalROC::Reset()
{
- //
- // reset to ZERO
- //
+ /// reset to ZERO
+
memset(fData,0,sizeof(Float_t)*fNChannels); // set all values to 0
}
Double_t AliTPCCalROC::GetMean(AliTPCCalROC *const outlierROC) const {
- //
- // returns the mean value of the ROC
- // pads with value != 0 in outlierROC are not used for the calculation
- // return 0 if no data is accepted by the outlier cuts
- //
+ /// returns the mean value of the ROC
+ /// pads with value != 0 in outlierROC are not used for the calculation
+ /// return 0 if no data is accepted by the outlier cuts
+
if (!outlierROC) return TMath::Mean(fNChannels, fData);
Double_t *ddata = new Double_t[fNChannels];
Int_t nPoints = 0;
}
Double_t AliTPCCalROC::GetMedian(AliTPCCalROC *const outlierROC) const {
- //
- // returns the median value of the ROC
- // pads with value != 0 in outlierROC are not used for the calculation
- // return 0 if no data is accepted by the outlier cuts
- //
+ /// returns the median value of the ROC
+ /// pads with value != 0 in outlierROC are not used for the calculation
+ /// return 0 if no data is accepted by the outlier cuts
+
if (!outlierROC) return TMath::Median(fNChannels, fData);
Double_t *ddata = new Double_t[fNChannels];
Int_t nPoints = 0;
}
Double_t AliTPCCalROC::GetRMS(AliTPCCalROC *const outlierROC) const {
- //
- // returns the RMS value of the ROC
- // pads with value != 0 in outlierROC are not used for the calculation
- // return 0 if no data is accepted by the outlier cuts
- //
+ /// returns the RMS value of the ROC
+ /// pads with value != 0 in outlierROC are not used for the calculation
+ /// return 0 if no data is accepted by the outlier cuts
+
if (!outlierROC) return TMath::RMS(fNChannels, fData);
Double_t *ddata = new Double_t[fNChannels];
Int_t nPoints = 0;
}
Double_t AliTPCCalROC::GetLTM(Double_t *const sigma, Double_t fraction, AliTPCCalROC *const outlierROC){
- //
- // returns the LTM and sigma
- // pads with value != 0 in outlierROC are not used for the calculation
- // return 0 if no data is accepted by the outlier cuts
- //
+ /// returns the LTM and sigma
+ /// pads with value != 0 in outlierROC are not used for the calculation
+ /// return 0 if no data is accepted by the outlier cuts
+
Double_t *ddata = new Double_t[fNChannels];
UInt_t nPoints = 0;
for (UInt_t i=0;i<fNChannels;i++) {
}
TH1F * AliTPCCalROC::MakeHisto1D(Float_t min, Float_t max,Int_t type){
- //
- // make 1D histo
- // type -1 = user defined range
- // 0 = nsigma cut nsigma=min
- // 1 = delta cut around median delta=min
- //
+ /// make 1D histo
+ /// type -1 = user defined range
+ /// 0 = nsigma cut nsigma=min
+ /// 1 = delta cut around median delta=min
+
if (type>=0){
if (type==0){
// nsigma range
TH2F * AliTPCCalROC::MakeHisto2D(Float_t min, Float_t max,Int_t type){
- //
- // make 2D histo
- // type -1 = user defined range
- // 0 = nsigma cut nsigma=min
- // 1 = delta cut around median delta=min
- //
+ /// make 2D histo
+ /// type -1 = user defined range
+ /// 0 = nsigma cut nsigma=min
+ /// 1 = delta cut around median delta=min
+
if (type>=0){
if (type==0){
// nsigma range
}
TH2F * AliTPCCalROC::MakeHistoOutliers(Float_t delta, Float_t fraction, Int_t type){
- //
- // Make Histogram with outliers
- // mode = 0 - sigma cut used
- // mode = 1 - absolute cut used
- // fraction - fraction of values used to define sigma
- // delta - in mode 0 - nsigma cut
- // mode 1 - delta cut
- //
+ /// Make Histogram with outliers
+ /// mode = 0 - sigma cut used
+ /// mode = 1 - absolute cut used
+ /// fraction - fraction of values used to define sigma
+ /// delta - in mode 0 - nsigma cut
+ /// mode 1 - delta cut
+
Double_t sigma;
Float_t mean = GetLTM(&sigma,fraction);
if (type==0) delta*=sigma;
void AliTPCCalROC::Draw(Option_t* opt){
- //
- // create histogram with values and draw it
- //
+ /// create histogram with values and draw it
+
TH1 * his=0;
TString option=opt;
option.ToUpper();
void AliTPCCalROC::Test() {
- //
- // example function to show functionality and test AliTPCCalROC
- //
+ /// example function to show functionality and test AliTPCCalROC
Float_t kEpsilon=0.00001;
AliTPCCalROC * AliTPCCalROC::LocalFit(Int_t rowRadius, Int_t padRadius, AliTPCCalROC* ROCoutliers, Bool_t robust, Double_t chi2Threshold, Double_t robustFraction) {
- //
- // MakeLocalFit - smoothing
- // returns a AliTPCCalROC with smoothed data
- // rowRadius and padRadius specifies a window around a given pad.
- // The data of this window are fitted with a parabolic function.
- // This function is evaluated at the pad's position.
- // At the edges the window is shifted, so that the specified pad is not anymore in the center of the window.
- // rowRadius - radius - rows to be used for smoothing
- // padradius - radius - pads to be used for smoothing
- // ROCoutlier - map of outliers - pads not to be used for local smoothing
- // robust - robust method of fitting - (much slower)
- // chi2Threshold: Threshold for chi2 when EvalRobust is called
- // robustFraction: Fraction of data that will be used in EvalRobust
- //
+ /// MakeLocalFit - smoothing
+ /// returns a AliTPCCalROC with smoothed data
+ /// rowRadius and padRadius specifies a window around a given pad.
+ /// The data of this window are fitted with a parabolic function.
+ /// This function is evaluated at the pad's position.
+ /// At the edges the window is shifted, so that the specified pad is not anymore in the center of the window.
+ /// rowRadius - radius - rows to be used for smoothing
+ /// padradius - radius - pads to be used for smoothing
+ /// ROCoutlier - map of outliers - pads not to be used for local smoothing
+ /// robust - robust method of fitting - (much slower)
+ /// chi2Threshold: Threshold for chi2 when EvalRobust is called
+ /// robustFraction: Fraction of data that will be used in EvalRobust
+
AliTPCCalROC * xROCfitted = new AliTPCCalROC(fSector);
TLinearFitter fitterQ(6,"hyp5");
// TLinearFitter fitterQ(6,"x0++x1++x2++x3++x4++x5");
Double_t AliTPCCalROC::GetNeighbourhoodValue(TLinearFitter* fitterQ, Int_t row, Int_t pad, Int_t rRadius, Int_t pRadius, AliTPCCalROC *const ROCoutliers, Bool_t robust, Double_t chi2Threshold, Double_t robustFraction) {
- //
- // AliTPCCalROC::GetNeighbourhoodValue - smoothing - PRIVATE
- // in this function the fit for LocalFit is done
- //
+ /// AliTPCCalROC::GetNeighbourhoodValue - smoothing - PRIVATE
+ /// in this function the fit for LocalFit is done
fitterQ->ClearPoints();
TVectorD fitParam(6);
void AliTPCCalROC::GetNeighbourhood(TArrayI* &rowArray, TArrayI* &padArray, Int_t row, Int_t pad, Int_t rRadius, Int_t pRadius) {
- //
- // AliTPCCalROC::GetNeighbourhood - PRIVATE
- // in this function the window for LocalFit is determined
- //
+ /// AliTPCCalROC::GetNeighbourhood - PRIVATE
+ /// in this function the window for LocalFit is determined
+
rowArray = new TArrayI((2*rRadius+1)*(2*pRadius+1));
padArray = new TArrayI((2*rRadius+1)*(2*pRadius+1));
void AliTPCCalROC::GlobalFit(const AliTPCCalROC* ROCoutliers, Bool_t robust, TVectorD &fitParam, TMatrixD &covMatrix, Float_t & chi2, Int_t fitType, Double_t chi2Threshold, Double_t robustFraction, Double_t err){
- //
- // Makes a GlobalFit for the given secotr and return fit-parameters, covariance and chi2
- // The origin of the fit function is the center of the ROC!
- // fitType == 0: fit plane function
- // fitType == 1: fit parabolic function
- // ROCoutliers - pads with value !=0 are not used in fitting procedure
- // chi2Threshold: Threshold for chi2 when EvalRobust is called
- // robustFraction: Fraction of data that will be used in EvalRobust
- // err: error of the data points
- //
+ /// Makes a GlobalFit for the given secotr and return fit-parameters, covariance and chi2
+ /// The origin of the fit function is the center of the ROC!
+ /// fitType == 0: fit plane function
+ /// fitType == 1: fit parabolic function
+ /// ROCoutliers - pads with value !=0 are not used in fitting procedure
+ /// chi2Threshold: Threshold for chi2 when EvalRobust is called
+ /// robustFraction: Fraction of data that will be used in EvalRobust
+ /// err: error of the data points
+
TLinearFitter* fitterG = 0;
Double_t xx[6];
AliTPCCalROC* AliTPCCalROC::CreateGlobalFitCalROC(TVectorD &fitParam, Int_t sector){
- //
- // Create ROC with global fit parameters
- // The origin of the fit function is the center of the ROC!
- // loop over all channels, write fit values into new ROC and return it
- //
+ /// Create ROC with global fit parameters
+ /// The origin of the fit function is the center of the ROC!
+ /// loop over all channels, write fit values into new ROC and return it
+
Float_t dlx, dly;
Float_t centerPad[3] = {0};
Float_t localXY[3] = {0};
/* $Id: AliTPCCalROC.h -1 */
-//////////////////////////////////////////////////
-// //
-// TPC calibration base class for one ROC //
-// //
-//////////////////////////////////////////////////
+/// \class AliTPCCalROC
+///
+/// TPC calibration base class for one ROC
+
#include <TObject.h>
#include <TMath.h>
#include <AliTPCROC.h>
Double_t GetNeighbourhoodValue(TLinearFitter* fitterQ, Int_t row, Int_t pad, Int_t rRadius, Int_t pRadius, AliTPCCalROC *const ROCoutliers, Bool_t robust, Double_t chi2Threshold, Double_t robustFraction);
void GetNeighbourhood(TArrayI* &rowArray, TArrayI* &padArray, Int_t row, Int_t pad, Int_t rRadius, Int_t pRadius);
- UInt_t fSector; // sector number
- UInt_t fNChannels; // number of channels
- UInt_t fNRows; // number of rows
- const UInt_t* fkIndexes; //!indexes
- Float_t *fData; //[fNChannels] Data
+ UInt_t fSector; ///< sector number
+ UInt_t fNChannels; ///< number of channels
+ UInt_t fNRows; ///< number of rows
+ const UInt_t* fkIndexes; //!< indexes
+ Float_t *fData; ///< [fNChannels] Data
+ /// \cond CLASSIMP
ClassDef(AliTPCCalROC,2) // TPC ROC calibration class
+ /// \endcond
};
* provided "as is" without express or implied warranty. *
**************************************************************************/
-/* $Id$ */
-
-////////////////////////////////////////////////////////////////////////////////////////
-// //
-// Implementation of the TPC Central Electrode calibration //
-// //
-// Origin: Jens Wiechula, Marian Ivanov J.Wiechula@gsi.de, Marian.Ivanov@cern.ch //
-// //
-////////////////////////////////////////////////////////////////////////////////////////
-//
-//
-// *************************************************************************************
-// * Class Description *
-// *************************************************************************************
-//
-/* BEGIN_HTML
- <h4>The AliTPCCalibCE class is used to get calibration data from the Central Electrode
- using laser runs.</h4>
-
- The information retrieved is
- <ul style="list-style-type: square;">
- <li>Time arrival from the CE</li>
- <li>Signal width</li>
- <li>Signal sum</li>
- </ul>
-
-<h4>Overview:</h4>
- <ol style="list-style-type: upper-roman;">
- <li><a href="#working">Working principle</a></li>
- <li><a href="#user">User interface for filling data</a></li>
- <li><a href="#info">Stored information</a></li>
- </ol>
-
- <h3><a name="working">I. Working principle</a></h3>
-
- <h4>Raw laser data is processed by calling one of the ProcessEvent(...) functions
- (see below). These in the end call the Update(...) function.</h4>
-
- <ul style="list-style-type: square;">
- <li>the Update(...) function:<br />
- In this function the array fPadSignal is filled with the adc signals between the specified range
- fFirstTimeBin and fLastTimeBin for the current pad.
- before going to the next pad the ProcessPad() function is called, which analyses the data for one pad
- stored in fPadSignal.
- </li>
- <ul style="list-style-type: square;">
- <li>the ProcessPad() function:</li>
- <ol style="list-style-type: decimal;">
- <li>Find Pedestal and Noise information</li>
- <ul style="list-style-type: square;">
- <li>use database information which has to be set by calling<br />
- SetPedestalDatabase(AliTPCCalPad *pedestalTPC, AliTPCCalPad *padNoiseTPC)</li>
- <li>if no information from the pedestal data base
- is available the informaion is calculated on the fly
- ( see FindPedestal() function )</li>
- </ul>
- <li>Find local maxima of the pad signal</li>
- <ul style="list-style-type: square;">
- <li>maxima arise from the laser tracks, the CE and also periodic postpeaks after the CE signal have
- have been observed ( see FindLocalMaxima(...) )</li>
- </ul>
- <li>Find the CE signal information</li>
- <ul style="list-style-type: square;">
- <li>to find the position of the CE signal the Tmean information from the previos event is used
- as the CE signal the local maximum closest to this Tmean is identified</li>
- <li>calculate mean = T0, RMS = signal width and Q sum in a range of -4+7 timebins around Q max position
- the Q sum is scaled by pad area (see FindPulserSignal(...) function)</li>
- </ul>
- <li>Fill a temprary array for the T0 information (GetPadTimesEvent(fCurrentSector,kTRUE)) (why see below)</li>
- <li>Fill the Q sum and RMS values in the histograms (GetHisto[RMS,Q](ROC,kTRUE))</li>
- </ol>
- </ul>
- </ul>
-
- <h4>At the end of each event the EndEvent() function is called</h4>
-
- <ul style="list-style-type: square;">
- <li>the EndEvent() function:</li>
- <ul style="list-style-type: square;">
- <li>calculate the mean T0 for side A and side C. Fill T0 histogram with Time0-<Time0 for side[A,C]>
- This is done to overcome syncronisation problems between the trigger and the fec clock.</li>
- <li>calculate Mean T for each ROC using the COG aroud the median of the LocalMaxima distribution in one sector</li>
- <li>calculate Mean Q</li>
- <li>calculate Global fit parameters for Pol1 and Pol2 fits</li>
- </ul>
- </ul>
-
- <h4>After accumulating the desired statistics the Analyse() function has to be called.</h4>
- <ul style="list-style-type: square;">
- <li>the Analyse() function:</li>
- <ul style="list-style-type: square;">
- <li>calculate the mean values of T0, RMS, Q for each pad, using
- the AliMathBase::GetCOG(...) function</li>
- <li>fill the calibration storage classes (AliTPCCalROC) for each ROC</li>
- (The calibration information is stored in the TObjArrays fCalRocArrayT0, fCalRocArrayRMS and fCalRocArrayQ</li>
- </ul>
- </ul>
-
- <h3><a name="user">II. User interface for filling data</a></h3>
-
- <h4>To Fill information one of the following functions can be used:</h4>
-
- <ul style="list-style-type: none;">
- <li> Bool_t ProcessEvent(eventHeaderStruct *event);</li>
- <ul style="list-style-type: square;">
- <li>process Date event</li>
- <li>use AliTPCRawReaderDate and call ProcessEvent(AliRawReader *rawReader)</li>
- </ul>
- <br />
-
- <li> Bool_t ProcessEvent(AliRawReader *rawReader);</li>
- <ul style="list-style-type: square;">
- <li>process AliRawReader event</li>
- <li>use AliTPCRawStream to loop over data and call ProcessEvent(AliTPCRawStream *rawStream)</li>
- </ul>
- <br />
-
- <li> Bool_t ProcessEvent(AliTPCRawStream *rawStream);</li>
- <ul style="list-style-type: square;">
- <li>process event from AliTPCRawStream</li>
- <li>call Update function for signal filling</li>
- </ul>
- <br />
-
- <li> Int_t Update(const Int_t isector, const Int_t iRow, const Int_t
- iPad, const Int_t iTimeBin, const Float_t signal);</li>
- <ul style="list-style-type: square;">
- <li>directly fill signal information (sector, row, pad, time bin, pad)
- to the reference histograms</li>
- </ul>
- </ul>
-
- <h4>It is also possible to merge two independently taken calibrations using the function</h4>
-
- <ul style="list-style-type: none;">
- <li> void Merge(AliTPCCalibSignal *sig)</li>
- <ul style="list-style-type: square;">
- <li>copy histograms in 'sig' if they do not exist in this instance</li>
- <li>Add histograms in 'sig' to the histograms in this instance if the allready exist</li>
- <li>After merging call Analyse again!</li>
- </ul>
- </ul>
-
-
- <h4>example: filling data using root raw data:</h4>
- <pre>
- void fillCE(Char_t *filename)
- {
- rawReader = new AliRawReaderRoot(fileName);
- if ( !rawReader ) return;
- AliTPCCalibCE *calib = new AliTPCCalibCE;
- while (rawReader->NextEvent()){
- calib->ProcessEvent(rawReader);
- }
- calib->Analyse();
- calib->DumpToFile("CEData.root");
- delete rawReader;
- delete calib;
- }
- </pre>
-
- <h3><a name="info">III. What kind of information is stored and how to retrieve it</a></h4>
-
- <h4><a name="info:stored">III.1 Stored information</a></h4>
- <ul style="list-style-type: none;">
- <li>Histograms:</li>
- <ul style="list-style-type: none;">
- <li>For each ROC three TH2S histos 'Reference Histograms' (ROC channel vs. [Time0, signal width, Q sum])
- is created when it is filled for the first time (GetHisto[T0,RMS,Q](ROC,kTRUE)). The histos are
- stored in the TObjArrays fHistoT0Array, fHistoRMSArray and fHistoQArray.</li>
- </ul>
- <br />
-
- <li>Calibration Data:</li>
- <ul style="list-style-type: none;">
- <li>For each ROC three types of calibration data (AliTPCCalROC) is stored: for the mean arrival Time,
- the signal width and the signal Sum. The AliTPCCalROC objects are stored in the TObjArrays
- fCalRocArrayT0, fCalRocArrayRMS , fCalRocArrayQ. The object for each roc is created the first time it
- is accessed (GetCalRoc[T0,RMS,Q](ROC,kTRUE));</li>
- </ul>
- <br />
-
- <li>For each event the following information is stored:</li>
-
- <ul style="list-style-type: square;">
- <li>event time ( TVectorD fVEventTime )</li>
- <li>event id ( TVectorD fVEventNumber )</li>
- <br />
- <li>mean arrival time for each ROC ( TObjArray fTMeanArrayEvent )</li>
- <li>mean Q for each ROC ( TObjArray fQMeanArrayEvent )</li>
- <li>parameters of a plane fit for each ROC ( TObjArray fParamArrayEventPol1 )</li>
- <li>parameters of a 2D parabola fit for each ROC ( TObjArray fParamArrayEventPol2 )</li>
- </ul>
- </ul>
-
- <h4><a name="info:retrieve">III.2 Retrieving information</a></h4>
- <ul style="list-style-type: none;">
- <li>Accessing the 'Reference Histograms' (Time0, signal width and Q sum information pad by pad):</li>
- <ul style="list-style-type: square;">
- <li>TH2F *GetHistoT0(Int_t sector);</li>
- <li>TH2F *GetHistoRMS(Int_t sector);</li>
- <li>TH2F *GetHistoQ(Int_t sector);</li>
- </ul>
- <br />
-
- <li>Accessing the calibration storage objects:</li>
- <ul style="list-style-type: square;">
- <li>AliTPCCalROC *GetCalRocT0(Int_t sector); // for the Time0 values</li>
- <li>AliTPCCalROC *GetCalRocRMS(Int_t sector); // for the signal width values</li>
- <li>AliTPCCalROC *GetCalRocQ(Int_t sector); // for the Q sum values</li>
- </ul>
- <br />
-
- <li>Accessin the event by event information:</li>
- <ul style="list-style-type: square;">
- <li>The event by event information can be displayed using the</li>
- <li>MakeGraphTimeCE(Int_t sector, Int_t xVariable, Int_t fitType, Int_t fitParameter)</li>
- <li>which creates a graph from the specified variables</li>
- </ul>
- </ul>
-
- <h4>example for visualisation:</h4>
- <pre>
- //if the file "CEData.root" was created using the above example one could do the following:
- TFile fileCE("CEData.root")
- AliTPCCalibCE *ce = (AliTPCCalibCE*)fileCE->Get("AliTPCCalibCE");
- ce->GetCalRocT0(0)->Draw("colz");
- ce->GetCalRocRMS(0)->Draw("colz");
-
- //or use the AliTPCCalPad functionality:
- AliTPCCalPad padT0(ped->GetCalPadT0());
- AliTPCCalPad padSigWidth(ped->GetCalPadRMS());
- padT0->MakeHisto2D()->Draw("colz"); //Draw A-Side Time0 Information
- padSigWidth->MakeHisto2D()->Draw("colz"); //Draw A-Side signal width Information
-
- //display event by event information:
- //Draw mean arrival time as a function of the event time for oroc sector A00
- ce->MakeGraphTimeCE(36, 0, 2)->Draw("alp");
- //Draw first derivative in local x from a plane fit as a function of the event time for oroc sector A00
- ce->MakeGraphTimeCE(36, 0, 0, 1)->Draw("alp");
- </pre>
-END_HTML */
-//////////////////////////////////////////////////////////////////////////////////////
-
+/// \class AliTPCCalibCE
+/// \brief Implementation of the TPC Central Electrode calibration
+///
+/// \author Jens Wiechula, Marian Ivanov J.Wiechula@gsi.de, Marian.Ivanov@cern.ch
+///
+/// Class Description
+/// The AliTPCCalibCE class is used to get calibration data from the Central Electrode
+/// using laser runs.
+///
+/// The information retrieved is
+/// <ul style="list-style-type: square;">
+/// <li>Time arrival from the CE</li>
+/// <li>Signal width</li>
+/// <li>Signal sum</li>
+/// </ul>
+///
+/// <h4>Overview:</h4>
+/// <ol style="list-style-type: upper-roman;">
+/// <li><a href="#working">Working principle</a></li>
+/// <li><a href="#user">User interface for filling data</a></li>
+/// <li><a href="#info">Stored information</a></li>
+/// </ol>
+///
+/// <h3><a name="working">I. Working principle</a></h3>
+///
+/// <h4>Raw laser data is processed by calling one of the ProcessEvent(...) functions
+/// (see below). These in the end call the Update(...) function.</h4>
+///
+/// <ul style="list-style-type: square;">
+/// <li>the Update(...) function:<br />
+/// In this function the array fPadSignal is filled with the adc signals between the specified range
+/// fFirstTimeBin and fLastTimeBin for the current pad.
+/// before going to the next pad the ProcessPad() function is called, which analyses the data for one pad
+/// stored in fPadSignal.
+/// </li>
+/// <ul style="list-style-type: square;">
+/// <li>the ProcessPad() function:</li>
+/// <ol style="list-style-type: decimal;">
+/// <li>Find Pedestal and Noise information</li>
+/// <ul style="list-style-type: square;">
+/// <li>use database information which has to be set by calling<br />
+/// SetPedestalDatabase(AliTPCCalPad *pedestalTPC, AliTPCCalPad *padNoiseTPC)</li>
+/// <li>if no information from the pedestal data base
+/// is available the informaion is calculated on the fly
+/// ( see FindPedestal() function )</li>
+/// </ul>
+/// <li>Find local maxima of the pad signal</li>
+/// <ul style="list-style-type: square;">
+/// <li>maxima arise from the laser tracks, the CE and also periodic postpeaks after the CE signal have
+/// have been observed ( see FindLocalMaxima(...) )</li>
+/// </ul>
+/// <li>Find the CE signal information</li>
+/// <ul style="list-style-type: square;">
+/// <li>to find the position of the CE signal the Tmean information from the previos event is used
+/// as the CE signal the local maximum closest to this Tmean is identified</li>
+/// <li>calculate mean = T0, RMS = signal width and Q sum in a range of -4+7 timebins around Q max position
+/// the Q sum is scaled by pad area (see FindPulserSignal(...) function)</li>
+/// </ul>
+/// <li>Fill a temprary array for the T0 information (GetPadTimesEvent(fCurrentSector,kTRUE)) (why see below)</li>
+/// <li>Fill the Q sum and RMS values in the histograms (GetHisto[RMS,Q](ROC,kTRUE))</li>
+/// </ol>
+/// </ul>
+/// </ul>
+///
+/// <h4>At the end of each event the EndEvent() function is called</h4>
+///
+/// <ul style="list-style-type: square;">
+/// <li>the EndEvent() function:</li>
+/// <ul style="list-style-type: square;">
+/// <li>calculate the mean T0 for side A and side C. Fill T0 histogram with Time0-<Time0 for side[A,C]>
+/// This is done to overcome syncronisation problems between the trigger and the fec clock.</li>
+/// <li>calculate Mean T for each ROC using the COG aroud the median of the LocalMaxima distribution in one sector</li>
+/// <li>calculate Mean Q</li>
+/// <li>calculate Global fit parameters for Pol1 and Pol2 fits</li>
+/// </ul>
+/// </ul>
+///
+/// <h4>After accumulating the desired statistics the Analyse() function has to be called.</h4>
+/// <ul style="list-style-type: square;">
+/// <li>the Analyse() function:</li>
+/// <ul style="list-style-type: square;">
+/// <li>calculate the mean values of T0, RMS, Q for each pad, using
+/// the AliMathBase::GetCOG(...) function</li>
+/// <li>fill the calibration storage classes (AliTPCCalROC) for each ROC</li>
+/// (The calibration information is stored in the TObjArrays fCalRocArrayT0, fCalRocArrayRMS and fCalRocArrayQ</li>
+/// </ul>
+/// </ul>
+///
+/// <h3><a name="user">II. User interface for filling data</a></h3>
+///
+/// <h4>To Fill information one of the following functions can be used:</h4>
+///
+/// <ul style="list-style-type: none;">
+/// <li> Bool_t ProcessEvent(eventHeaderStruct *event);</li>
+/// <ul style="list-style-type: square;">
+/// <li>process Date event</li>
+/// <li>use AliTPCRawReaderDate and call ProcessEvent(AliRawReader *rawReader)</li>
+/// </ul>
+/// <br />
+///
+/// <li> Bool_t ProcessEvent(AliRawReader *rawReader);</li>
+/// <ul style="list-style-type: square;">
+/// <li>process AliRawReader event</li>
+/// <li>use AliTPCRawStream to loop over data and call ProcessEvent(AliTPCRawStream *rawStream)</li>
+/// </ul>
+/// <br />
+///
+/// <li> Bool_t ProcessEvent(AliTPCRawStream *rawStream);</li>
+/// <ul style="list-style-type: square;">
+/// <li>process event from AliTPCRawStream</li>
+/// <li>call Update function for signal filling</li>
+/// </ul>
+/// <br />
+///
+/// <li> Int_t Update(const Int_t isector, const Int_t iRow, const Int_t
+/// iPad, const Int_t iTimeBin, const Float_t signal);</li>
+/// <ul style="list-style-type: square;">
+/// <li>directly fill signal information (sector, row, pad, time bin, pad)
+/// to the reference histograms</li>
+/// </ul>
+/// </ul>
+///
+/// <h4>It is also possible to merge two independently taken calibrations using the function</h4>
+///
+/// <ul style="list-style-type: none;">
+/// <li> void Merge(AliTPCCalibSignal *sig)</li>
+/// <ul style="list-style-type: square;">
+/// <li>copy histograms in 'sig' if they do not exist in this instance</li>
+/// <li>Add histograms in 'sig' to the histograms in this instance if the allready exist</li>
+/// <li>After merging call Analyse again!</li>
+/// </ul>
+/// </ul>
+///
+///
+/// <h4>example: filling data using root raw data:</h4>
+/// <pre>
+/// void fillCE(Char_t *filename)
+/// {
+/// rawReader = new AliRawReaderRoot(fileName);
+/// if ( !rawReader ) return;
+/// AliTPCCalibCE *calib = new AliTPCCalibCE;
+/// while (rawReader->NextEvent()){
+/// calib->ProcessEvent(rawReader);
+/// }
+/// calib->Analyse();
+/// calib->DumpToFile("CEData.root");
+/// delete rawReader;
+/// delete calib;
+/// }
+/// </pre>
+///
+/// <h3><a name="info">III. What kind of information is stored and how to retrieve it</a></h4>
+///
+/// <h4><a name="info:stored">III.1 Stored information</a></h4>
+/// <ul style="list-style-type: none;">
+/// <li>Histograms:</li>
+/// <ul style="list-style-type: none;">
+/// <li>For each ROC three TH2S histos 'Reference Histograms' (ROC channel vs. [Time0, signal width, Q sum])
+/// is created when it is filled for the first time (GetHisto[T0,RMS,Q](ROC,kTRUE)). The histos are
+/// stored in the TObjArrays fHistoT0Array, fHistoRMSArray and fHistoQArray.</li>
+/// </ul>
+/// <br />
+///
+/// <li>Calibration Data:</li>
+/// <ul style="list-style-type: none;">
+/// <li>For each ROC three types of calibration data (AliTPCCalROC) is stored: for the mean arrival Time,
+/// the signal width and the signal Sum. The AliTPCCalROC objects are stored in the TObjArrays
+/// fCalRocArrayT0, fCalRocArrayRMS , fCalRocArrayQ. The object for each roc is created the first time it
+/// is accessed (GetCalRoc[T0,RMS,Q](ROC,kTRUE));</li>
+/// </ul>
+/// <br />
+///
+/// <li>For each event the following information is stored:</li>
+///
+/// <ul style="list-style-type: square;">
+/// <li>event time ( TVectorD fVEventTime )</li>
+/// <li>event id ( TVectorD fVEventNumber )</li>
+/// <br />
+/// <li>mean arrival time for each ROC ( TObjArray fTMeanArrayEvent )</li>
+/// <li>mean Q for each ROC ( TObjArray fQMeanArrayEvent )</li>
+/// <li>parameters of a plane fit for each ROC ( TObjArray fParamArrayEventPol1 )</li>
+/// <li>parameters of a 2D parabola fit for each ROC ( TObjArray fParamArrayEventPol2 )</li>
+/// </ul>
+/// </ul>
+///
+/// <h4><a name="info:retrieve">III.2 Retrieving information</a></h4>
+/// <ul style="list-style-type: none;">
+/// <li>Accessing the 'Reference Histograms' (Time0, signal width and Q sum information pad by pad):</li>
+/// <ul style="list-style-type: square;">
+/// <li>TH2F *GetHistoT0(Int_t sector);</li>
+/// <li>TH2F *GetHistoRMS(Int_t sector);</li>
+/// <li>TH2F *GetHistoQ(Int_t sector);</li>
+/// </ul>
+/// <br />
+///
+/// <li>Accessing the calibration storage objects:</li>
+/// <ul style="list-style-type: square;">
+/// <li>AliTPCCalROC *GetCalRocT0(Int_t sector); // for the Time0 values</li>
+/// <li>AliTPCCalROC *GetCalRocRMS(Int_t sector); // for the signal width values</li>
+/// <li>AliTPCCalROC *GetCalRocQ(Int_t sector); // for the Q sum values</li>
+/// </ul>
+/// <br />
+///
+/// <li>Accessin the event by event information:</li>
+/// <ul style="list-style-type: square;">
+/// <li>The event by event information can be displayed using the</li>
+/// <li>MakeGraphTimeCE(Int_t sector, Int_t xVariable, Int_t fitType, Int_t fitParameter)</li>
+/// <li>which creates a graph from the specified variables</li>
+/// </ul>
+/// </ul>
+///
+/// <h4>example for visualisation:</h4>
+/// <pre>
+/// //if the file "CEData.root" was created using the above example one could do the following:
+/// TFile fileCE("CEData.root")
+/// AliTPCCalibCE *ce = (AliTPCCalibCE*)fileCE->Get("AliTPCCalibCE");
+/// ce->GetCalRocT0(0)->Draw("colz");
+/// ce->GetCalRocRMS(0)->Draw("colz");
+///
+/// //or use the AliTPCCalPad functionality:
+/// AliTPCCalPad padT0(ped->GetCalPadT0());
+/// AliTPCCalPad padSigWidth(ped->GetCalPadRMS());
+/// padT0->MakeHisto2D()->Draw("colz"); //Draw A-Side Time0 Information
+/// padSigWidth->MakeHisto2D()->Draw("colz"); //Draw A-Side signal width Information
+///
+/// //display event by event information:
+/// //Draw mean arrival time as a function of the event time for oroc sector A00
+/// ce->MakeGraphTimeCE(36, 0, 2)->Draw("alp");
+/// //Draw first derivative in local x from a plane fit as a function of the event time for oroc sector A00
+/// ce->MakeGraphTimeCE(36, 0, 0, 1)->Draw("alp");
+/// </pre>
//Root includes
#include <TObjArray.h>
#include "AliCDBEntry.h"
//date
#include "event.h"
+/// \cond CLASSIMP
ClassImp(AliTPCCalibCE)
+/// \endcond
AliTPCCalibCE::AliTPCCalibCE() :
fArrFitGraphs(0x0),
fEventInBunch(0)
{
- //
- // AliTPCSignal copy constructor
- //
+ /// AliTPCSignal copy constructor
+
for (Int_t i=0;i<1024;++i) fPadSignal[i]=0;
-
+
for (Int_t iSec = 0; iSec < 72; ++iSec){
const AliTPCCalROC *calQ = (AliTPCCalROC*)sig.fCalRocArrayQ.UncheckedAt(iSec);
const AliTPCCalROC *calT0 = (AliTPCCalROC*)sig.fCalRocArrayT0.UncheckedAt(iSec);
for (Int_t i=0;i<sig.fTimeBursts.GetNrows();++i){
fTimeBursts[i]=sig.fTimeBursts[i];
}
-
+
for (Int_t i=0;i<14;++i){
fPeaks[i]=sig.fPeaks[i];
fPeakWidths[i]=sig.fPeakWidths[i];
}
for (Int_t i=0; i<100; ++i) fBinsLastAna[i]=sig.fBinsLastAna[i];
-
+
}
//_____________________________________________________________________
AliTPCCalibCE::AliTPCCalibCE(const TMap *config) :
fArrFitGraphs(0x0),
fEventInBunch(0)
{
- //
- // constructor which uses a tmap as input to set some specific parameters
- //
+ /// constructor which uses a tmap as input to set some specific parameters
+
SetNameTitle("AliTPCCalibCE","AliTPCCalibCE");
fFirstTimeBin=650;
fLastTimeBin=1030;
if (config->GetValue("ProcessOld")) fProcessOld = (Bool_t)((TObjString*)config->GetValue("ProcessOld"))->GetString().Atoi();
if (config->GetValue("ProcessNew")) fProcessNew = (Bool_t)((TObjString*)config->GetValue("ProcessNew"))->GetString().Atoi();
if (config->GetValue("AnalyseNew")) fAnalyseNew = (Bool_t)((TObjString*)config->GetValue("AnalyseNew"))->GetString().Atoi();
-
+
for (Int_t i=0;i<1024;++i) fPadSignal[i]=0;
for (Int_t i=0;i<14;++i){
fPeaks[i]=0;
fPeakWidths[i]=0;
}
-
+
fParam->Update();
for (Int_t i=0; i<100; ++i) fBinsLastAna[i]=0;
}
//_____________________________________________________________________
AliTPCCalibCE& AliTPCCalibCE::operator = (const AliTPCCalibCE &source)
{
- //
- // assignment operator
- //
+ /// assignment operator
+
if (&source == this) return *this;
new (this) AliTPCCalibCE(source);
//_____________________________________________________________________
AliTPCCalibCE::~AliTPCCalibCE()
{
- //
- // destructor
- //
-
+ /// destructor
+
fCalRocArrayT0.Delete();
fCalRocArrayT0Err.Delete();
fCalRocArrayQ.Delete();
fCalRocArrayRMS.Delete();
fCalRocArrayOutliers.Delete();
-
+
fHistoQArray.Delete();
fHistoT0Array.Delete();
fHistoRMSArray.Delete();
-
+
fHistoTmean.Delete();
-
+
fParamArrayEventPol1.Delete();
fParamArrayEventPol2.Delete();
fTMeanArrayEvent.Delete();
fQMeanArrayEvent.Delete();
-
+
fPadTimesArrayEvent.Delete();
fPadQArrayEvent.Delete();
fPadRMSArrayEvent.Delete();
fPadPedestalArrayEvent.Delete();
-
+
fArrHnDrift.SetOwner();
fArrHnDrift.Delete();
-
+
if (fArrFitGraphs){
fArrFitGraphs->SetOwner();
delete fArrFitGraphs;
const Int_t icTimeBin,
const Float_t csignal)
{
- //
- // Signal filling methode on the fly pedestal and Time offset correction if necessary.
- // no extra analysis necessary. Assumes knowledge of the signal shape!
- // assumes that it is looped over consecutive time bins of one pad
- //
+ /// Signal filling methode on the fly pedestal and Time offset correction if necessary.
+ /// no extra analysis necessary. Assumes knowledge of the signal shape!
+ /// assumes that it is looped over consecutive time bins of one pad
if (!fProcessOld) return 0;
//temp
void AliTPCCalibCE::ProcessBunch(const Int_t sector, const Int_t row, const Int_t pad,
const Int_t length, const UInt_t startTimeBin, const UShort_t* signal)
{
- //
- // new filling method to fill the THnSparse histogram
- //
+ /// new filling method to fill the THnSparse histogram
//only in new processing mode
if (!fProcessNew) return;
//don't use the IROCs and inner part of OROCs
if (sector<36) return;
- if (row<40) return;
+ if (row<40) return;
//only bunches with reasonable length
if (length<3||length>10) return;
-
+
UShort_t timeBin = (UShort_t)startTimeBin;
//skip first laser layer
if (timeBin<280) return;
Double_t timeBurst=SetBurstHnDrift();
-
+
Int_t cePeak=((sector/18)%2)*7+6;
//after 1 event setup peak ranges
if (fEventInBunch==1 && fPeaks[cePeak]==0) {
fHnDrift->GetAxis(4)->SetRangeUser(fHnDrift->GetAxis(4)->GetXmin(),fHnDrift->GetAxis(4)->GetXmax());
fHnDrift->Reset();
}
-
+
// After the first event only fill every 5th bin in a row with the CE information
Int_t padFill=pad;
if (fEventInBunch==0||(fPeaks[cePeak]>100&&TMath::Abs((Short_t)fPeaks[cePeak]-(Short_t)timeBin)<(Short_t)fPeakWidths[cePeak])){
//noise removal
if (!IsPeakInRange(timeBin+length/2,sector)) return;
-
+
Double_t x[kHnBinsDV]={(Double_t)sector,(Double_t)row,
(Double_t)padFill,(Double_t)timeBin,timeBurst};
-
+
for (Int_t iTimeBin = 0; iTimeBin<length; iTimeBin++){
Float_t sig=(Float_t)signal[iTimeBin];
// if (fPeaks[6]>900&&timeBin>(fPeaks[6]-20)&&sig<20) continue;
//_____________________________________________________________________
void AliTPCCalibCE::FindLaserLayers()
{
- //
- // Find the laser layer positoins
- //
+ /// Find the laser layer positoins
//A-side + C-side
for (Int_t iside=0;iside<2;++iside){
Int_t maxbin=hproj->GetMaximumBin();
Double_t binc=hproj->GetBinCenter(maxbin);
hproj->GetXaxis()->SetRangeUser(binc-5,binc+5);
-
+
fPeaks[add+6]=(UShort_t)TMath::Nint(binc);
// fPeakWidths[4]=(UShort_t)TMath::Nint(4*hproj->GetRMS()+.5);
fPeakWidths[add+6]=7;
-
+
hproj->GetXaxis()->SetRangeUser(0,maxbin-10);
TSpectrum s(6);
s.Search(hproj,2,"goff");
fPeaks[i+add]=(UShort_t)TMath::Nint(s.GetPositionX()[index[i]]);
fPeakWidths[i+add]=5;
}
-
+
//other peaks
-
+
// Int_t timepos=fPeaks[4]-2*fPeakWidths[4];
// Int_t width=100;
-
+
// for (Int_t i=3; i>=0; --i){
// hproj->GetXaxis()->SetRangeUser(timepos-width,timepos);
-// fPeaks[i]=hproj->GetMaximumBin();
+// fPeaks[i]=hproj->GetMaximumBin();
// fPeakWidths[i]=(UShort_t)TMath::Nint(10.);
// width=250;
// timepos=fPeaks[i]-width/2;
// }
-
+
// for (Int_t i=add; i<add+7; ++i){
// printf("Peak: %u +- %u\n",fPeaks[i],fPeakWidths[i]);
// }
//_____________________________________________________________________
void AliTPCCalibCE::FindPedestal(Float_t part)
{
- //
- // find pedestal and noise for the current pad. Use either database or
- // truncated mean with part*100%
- //
+ /// find pedestal and noise for the current pad. Use either database or
+ /// truncated mean with part*100%
+
Bool_t noPedestal = kTRUE;
//use pedestal database if set
//_____________________________________________________________________
void AliTPCCalibCE::UpdateCETimeRef()
{
- // Find the time reference of the last valid CE signal in sector
- // for irocs of the A-Side the reference of the corresponging OROC is returned
- // the reason are the non reflective bands on the A-Side, which make the reference very uncertain
+ /// Find the time reference of the last valid CE signal in sector
+ /// for irocs of the A-Side the reference of the corresponging OROC is returned
+ /// the reason are the non reflective bands on the A-Side, which make the reference very uncertain
+
if ( fLastSector == fCurrentSector ) return;
- Int_t sector=fCurrentSector;
+ Int_t sector=fCurrentSector;
if ( sector < 18 ) sector+=36;
fCurrentCETimeRef=0;
TVectorF *vtRef = GetTMeanEvents(sector);
- if ( !vtRef ) return;
+ if ( !vtRef ) return;
Int_t vtRefSize= vtRef->GetNrows();
if ( vtRefSize < fNevents+1 ) vtRef->ResizeTo(vtRefSize+100);
- else vtRefSize=fNevents;
+ else vtRefSize=fNevents;
while ( (*vtRef)[vtRefSize]==0 && vtRefSize>=0 ) --vtRefSize;
fCurrentCETimeRef=(*vtRef)[vtRefSize];
- AliDebug(3,Form("Sector: %02d - T0 ref: %.2f",fCurrentSector,fCurrentCETimeRef));
-}
+ AliDebug(3,Form("Sector: %02d - T0 ref: %.2f",fCurrentSector,fCurrentCETimeRef));
+}
//_____________________________________________________________________
void AliTPCCalibCE::FindCESignal(TVectorD ¶m, Float_t &qSum, const TVectorF maxima)
{
- //
- // Find position, signal width and height of the CE signal (last signal)
- // param[0] = Qmax, param[1] = mean time, param[2] = rms;
- // maxima: array of local maxima of the pad signal use the one closest to the mean CE position
- //
+ /// Find position, signal width and height of the CE signal (last signal)
+ /// param[0] = Qmax, param[1] = mean time, param[2] = rms;
+ /// maxima: array of local maxima of the pad signal use the one closest to the mean CE position
Float_t ceQmax =0, ceQsum=0, ceTime=0, ceRMS=0;
Int_t cemaxpos = 0;
// the pick-up signal should scale with the pad area. In addition
// the signal should decrease with the wire distance (4mm in IROC, 6mm in OROC),
// ratio 2/3. The pad area we express in cm2. We normalise the signal
- // to the OROC signal (factor 2/3 for the IROCs).
+ // to the OROC signal (factor 2/3 for the IROCs).
Float_t norm = fParam->GetPadPitchWidth(fCurrentSector)*fParam->GetPadPitchLength(fCurrentSector,fCurrentRow);
if ( fCurrentSector<fParam->GetNInnerSector() ) norm*=3./2.;
ceQsum=0;
}
param[0] = ceQmax;
- param[1] = ceTime;
+ param[1] = ceTime;
param[2] = ceRMS;
qSum = ceQsum;
}
//_____________________________________________________________________
Bool_t AliTPCCalibCE::IsPeak(Int_t pos, Int_t tminus, Int_t tplus) const
{
- //
- // Check if 'pos' is a Maximum. Consider 'tminus' timebins before
- // and 'tplus' timebins after 'pos'
- //
+ /// Check if 'pos' is a Maximum. Consider 'tminus' timebins before
+ /// and 'tplus' timebins after 'pos'
+
if ( (pos-tminus)<fFirstTimeBin || (pos+tplus)>fLastTimeBin ) return kFALSE;
for (Int_t iTime = pos; iTime>pos-tminus; --iTime)
if ( fPadSignal[iTime-1] >= fPadSignal[iTime] ) return kFALSE;
//_____________________________________________________________________
void AliTPCCalibCE::FindLocalMaxima(TVectorF &maxima)
{
- //
- // Find local maxima on the pad signal and Histogram them
- //
+ /// Find local maxima on the pad signal and Histogram them
+
Float_t ceThreshold = fNoiseThresholdMax*TMath::Max(fPadNoise,Float_t(1.)); // threshold for the signal
Int_t count = 0;
-
+
for (Int_t i=fLastTimeBin-fPeakDetPlus+1; i>=fFirstTimeBin+fPeakDetMinus; --i){
if ( (fPadSignal[i]-fPadPedestal)<ceThreshold ) continue;
if (IsPeak(i,fPeakDetMinus,fPeakDetPlus) ){
//_____________________________________________________________________
void AliTPCCalibCE::ProcessPad()
{
- //
- // Process data of current pad
- //
+ /// Process data of current pad
+
FindPedestal();
-
+
TVectorF maxima(15); // the expected maximum number of maxima in the complete TPC should be 8 laser beam layers
// + central electrode and possibly post peaks from the CE signal
// however if we are on a high noise pad a lot more peaks due to the noise might occur
FindLocalMaxima(maxima);
if ( (fNevents == 0) || (fOldRunNumber!=fRunNumber) ) return; // return because we don't have Time0 info for the CE yet
-
+
UpdateCETimeRef(); // update the time refenrence for the current sector
if ( fCurrentCETimeRef<1e-30 ) return; //return if we don't have time 0 info, eg if only one side has laser
TVectorD param(3);
Float_t qSum;
FindCESignal(param, qSum, maxima);
-
+
Double_t meanT = param[1];
Double_t sigmaT = param[2];
-
+
//Fill Event T0 counter
(*GetPadTimesEvent(fCurrentSector,kTRUE)).GetMatrixArray()[fCurrentChannel] = meanT;
-
+
//Fill Q histogram
GetHistoQ(fCurrentSector,kTRUE)->Fill( TMath::Sqrt(qSum), fCurrentChannel );
-
+
//Fill RMS histogram
GetHistoRMS(fCurrentSector,kTRUE)->Fill( sigmaT, fCurrentChannel );
-
-
+
+
//Fill debugging info
if ( GetStreamLevel()>0 ){
(*GetPadPedestalEvent(fCurrentSector,kTRUE)).GetMatrixArray()[fCurrentChannel]=fPadPedestal;
(*GetPadRMSEvent(fCurrentSector,kTRUE)).GetMatrixArray()[fCurrentChannel]=sigmaT;
(*GetPadQEvent(fCurrentSector,kTRUE)).GetMatrixArray()[fCurrentChannel]=qSum;
}
-
+
ResetPad();
}
//_____________________________________________________________________
void AliTPCCalibCE::EndEvent()
{
- // Process data of current pad
- // The Functions 'SetTimeStamp' and 'SetRunNumber' should be called
- // before the EndEvent function to set the event timestamp and number!!!
- // This is automatically done if the ProcessEvent(AliRawReader *rawReader)
- // function was called
+ /// Process data of current pad
+ /// The Functions 'SetTimeStamp' and 'SetRunNumber' should be called
+ /// before the EndEvent function to set the event timestamp and number!!!
+ /// This is automatically done if the ProcessEvent(AliRawReader *rawReader)
+ /// function was called
+
if (!fProcessOld) {
if (fProcessNew){
++fNevents;
}
return;
}
-
+
//check if last pad has allready been processed, if not do so
if ( fMaxTimeBin>-1 ) ProcessPad();
AliDebug(3,Form("Skipping sec. '%02d': Not enough statistics\n",iSec));
continue;
}
-
+
Double_t entries = hMeanT->GetEffectiveEntries();
Double_t sum = 0;
Short_t *arr = hMeanT->GetArray()+1;
if ( firstBin<fFirstTimeBin ) firstBin=fFirstTimeBin;
if ( lastBin>fLastTimeBin ) lastBin =fLastTimeBin;
Float_t median =AliMathBase::GetCOG(arr+ibin-delta,2*delta,firstBin,lastBin);
-
+
// check boundaries for ebye info of mean time
TVectorF *vMeanTime=GetTMeanEvents(iSec,kTRUE);
Int_t vSize=vMeanTime->GetNrows();
}
fVTime0SideA.GetMatrixArray()[fNevents]=time0Side[0];
fVTime0SideC.GetMatrixArray()[fNevents]=time0Side[1];
-
+
vMeanTime->GetMatrixArray()[fNevents]=median;
nSecMeanT++;
// end find median
-
+
TVectorF *vTimes = GetPadTimesEvent(iSec);
if ( !vTimes ) continue; //continue if no time information for this sector is available
-
+
AliTPCCalROC calIrocOutliers(0);
AliTPCCalROC calOrocOutliers(36);
-
+
// calculate mean Q of the sector
TVectorF *vMeanQ=GetQMeanEvents(iSec,kTRUE);
vSize=vMeanQ->GetNrows();
if ( vSize < fNevents+1 ){
vMeanQ->ResizeTo(vSize+100);
- }
+ }
Float_t meanQ = 0;
if ( fVMeanQCounter.GetMatrixArray()[iSec]>0 ) meanQ=fVMeanQ.GetMatrixArray()[iSec]/fVMeanQCounter.GetMatrixArray()[iSec];
vMeanQ->GetMatrixArray()[fNevents]=meanQ;
-
+
for ( UInt_t iChannel=0; iChannel<fROC->GetNChannels(iSec); ++iChannel ){
Float_t time = (*vTimes).GetMatrixArray()[iChannel];
}
if ( (fNevents>0) && (fOldRunNumber==fRunNumber) )
- // test that we really found the CE signal reliably
+ // test that we really found the CE signal reliably
if ( TMath::Abs(fVTime0SideA.GetMatrixArray()[fNevents-1]-time0Side[0])<.05)
GetHistoT0(iSec,kTRUE)->Fill( time-time0Side[(iSec/18)%2],iChannel );
Int_t row=0;
Int_t pad=0;
Int_t padc=0;
-
+
Float_t q = (*GetPadQEvent(iSec))[iChannel];
Float_t rms = (*GetPadRMSEvent(iSec))[iChannel];
-
+
UInt_t channel=iChannel;
Int_t sector=iSec;
-
+
while ( channel > (fROC->GetRowIndexes(sector)[row]+fROC->GetNPads(sector,row)-1) ) row++;
pad = channel-fROC->GetRowIndexes(sector)[row];
padc = pad-(fROC->GetNPads(sector,row)/2);
-
+
// TH1F *h1 = new TH1F(Form("hSignalD%d.%d.%d",sector,row,pad),
// Form("hSignalD%d.%d.%d",sector,row,pad),
// fLastTimeBin-fFirstTimeBin,
//
// for (Int_t i=fFirstTimeBin; i<fLastTimeBin+1; ++i)
// h1->Fill(i,fPadSignal(i));
-
+
Double_t t0Sec = 0;
if (fVTime0OffsetCounter.GetMatrixArray()[iSec]>0)
t0Sec = fVTime0Offset.GetMatrixArray()[iSec]/fVTime0OffsetCounter.GetMatrixArray()[iSec];
"MeanQ=" << meanQ <<
// "hist.=" << h1 <<
"\n";
-
+
// delete h1;
}
}
TMatrixD matPol2(6,6);
Float_t chi2Pol1=0;
Float_t chi2Pol2=0;
-
+
if ( (fNevents>0) && (fOldRunNumber==fRunNumber) ){
if ( iSec < 36 ){
calIroc->GlobalFit(&calIrocOutliers,0,paramPol1,matPol1,chi2Pol1,0);
calOroc->GlobalFit(&calOrocOutliers,0,paramPol1,matPol1,chi2Pol1,0);
calOroc->GlobalFit(&calOrocOutliers,0,paramPol2,matPol2,chi2Pol2,1);
}
-
+
GetParamArrayPol1(iSec,kTRUE)->AddAtAndExpand(new TVectorD(paramPol1), fNevents);
GetParamArrayPol2(iSec,kTRUE)->AddAtAndExpand(new TVectorD(paramPol2), fNevents);
}
-
+
//------------------------------- Debug start ------------------------------
if ( GetStreamLevel()>0 ){
TTreeSRedirector *streamer=GetDebugStreamer();
}// end sector loop
//return if no sector has a valid mean time
if ( nSecMeanT == 0 ) return;
-
-
+
+
// fTMeanArrayEvent.AddAtAndExpand(new TVectorF(vMeanTime),fNevents);
// fQMeanArrayEvent.AddAtAndExpand(new TVectorF(vMeanQ),fNevents);
if ( fVEventTime.GetNrows() < fNevents+1 ) {
Int_t nbinsY, Float_t ymin, Float_t ymax,
const Char_t *type, Bool_t force)
{
- //
- // return pointer to TH2S histogram of 'type'
- // if force is true create a new histogram if it doesn't exist allready
- //
+ /// return pointer to TH2S histogram of 'type'
+ /// if force is true create a new histogram if it doesn't exist allready
+
if ( !force || arr->UncheckedAt(sector) )
return (TH2S*)arr->UncheckedAt(sector);
//_____________________________________________________________________
TH2S* AliTPCCalibCE::GetHistoT0(Int_t sector, Bool_t force)
{
- //
- // return pointer to T0 histogram
- // if force is true create a new histogram if it doesn't exist allready
- //
+ /// return pointer to T0 histogram
+ /// if force is true create a new histogram if it doesn't exist allready
+
TObjArray *arr = &fHistoT0Array;
return GetHisto(sector, arr, fNbinsT0, fXminT0, fXmaxT0, "T0", force);
}
//_____________________________________________________________________
TH2S* AliTPCCalibCE::GetHistoQ(Int_t sector, Bool_t force)
{
- //
- // return pointer to Q histogram
- // if force is true create a new histogram if it doesn't exist allready
- //
+ /// return pointer to Q histogram
+ /// if force is true create a new histogram if it doesn't exist allready
+
TObjArray *arr = &fHistoQArray;
return GetHisto(sector, arr, fNbinsQ, fXminQ, fXmaxQ, "Q", force);
}
//_____________________________________________________________________
TH2S* AliTPCCalibCE::GetHistoRMS(Int_t sector, Bool_t force)
{
- //
- // return pointer to Q histogram
- // if force is true create a new histogram if it doesn't exist allready
- //
+ /// return pointer to Q histogram
+ /// if force is true create a new histogram if it doesn't exist allready
+
TObjArray *arr = &fHistoRMSArray;
return GetHisto(sector, arr, fNbinsRMS, fXminRMS, fXmaxRMS, "RMS", force);
}
TH1S* AliTPCCalibCE::GetHisto(Int_t sector, TObjArray *arr,
const Char_t *type, Bool_t force)
{
- //
- // return pointer to TH1S histogram
- // if force is true create a new histogram if it doesn't exist allready
- //
+ /// return pointer to TH1S histogram
+ /// if force is true create a new histogram if it doesn't exist allready
+
if ( !force || arr->UncheckedAt(sector) )
return (TH1S*)arr->UncheckedAt(sector);
//_____________________________________________________________________
TH1S* AliTPCCalibCE::GetHistoTmean(Int_t sector, Bool_t force)
{
- //
- // return pointer to Q histogram
- // if force is true create a new histogram if it doesn't exist allready
- //
+ /// return pointer to Q histogram
+ /// if force is true create a new histogram if it doesn't exist allready
+
TObjArray *arr = &fHistoTmean;
return GetHisto(sector, arr, "LastTmean", force);
}
//_____________________________________________________________________
TVectorF* AliTPCCalibCE::GetVectSector(Int_t sector, TObjArray *arr, UInt_t size, Bool_t force) const
{
- //
- // return pointer to Pad Info from 'arr' for the current event and sector
- // if force is true create it if it doesn't exist allready
- //
+ /// return pointer to Pad Info from 'arr' for the current event and sector
+ /// if force is true create it if it doesn't exist allready
+
if ( !force || arr->UncheckedAt(sector) )
return (TVectorF*)arr->UncheckedAt(sector);
//_____________________________________________________________________
TVectorF* AliTPCCalibCE::GetPadTimesEvent(Int_t sector, Bool_t force)
{
- //
- // return pointer to Pad Times Array for the current event and sector
- // if force is true create it if it doesn't exist allready
- //
+ /// return pointer to Pad Times Array for the current event and sector
+ /// if force is true create it if it doesn't exist allready
+
TObjArray *arr = &fPadTimesArrayEvent;
return GetVectSector(sector,arr,fROC->GetNChannels(sector),force);
}
//_____________________________________________________________________
TVectorF* AliTPCCalibCE::GetPadQEvent(Int_t sector, Bool_t force)
{
- //
- // return pointer to Pad Q Array for the current event and sector
- // if force is true create it if it doesn't exist allready
- // for debugging purposes only
- //
+ /// return pointer to Pad Q Array for the current event and sector
+ /// if force is true create it if it doesn't exist allready
+ /// for debugging purposes only
TObjArray *arr = &fPadQArrayEvent;
return GetVectSector(sector,arr,fROC->GetNChannels(sector),force);
//_____________________________________________________________________
TVectorF* AliTPCCalibCE::GetPadRMSEvent(Int_t sector, Bool_t force)
{
- //
- // return pointer to Pad RMS Array for the current event and sector
- // if force is true create it if it doesn't exist allready
- // for debugging purposes only
- //
+ /// return pointer to Pad RMS Array for the current event and sector
+ /// if force is true create it if it doesn't exist allready
+ /// for debugging purposes only
+
TObjArray *arr = &fPadRMSArrayEvent;
return GetVectSector(sector,arr,fROC->GetNChannels(sector),force);
}
//_____________________________________________________________________
TVectorF* AliTPCCalibCE::GetPadPedestalEvent(Int_t sector, Bool_t force)
{
- //
- // return pointer to Pad RMS Array for the current event and sector
- // if force is true create it if it doesn't exist allready
- // for debugging purposes only
- //
+ /// return pointer to Pad RMS Array for the current event and sector
+ /// if force is true create it if it doesn't exist allready
+ /// for debugging purposes only
+
TObjArray *arr = &fPadPedestalArrayEvent;
return GetVectSector(sector,arr,fROC->GetNChannels(sector),force);
}
//_____________________________________________________________________
TVectorF* AliTPCCalibCE::GetTMeanEvents(Int_t sector, Bool_t force)
{
- //
- // return pointer to the EbyE info of the mean arrival time for 'sector'
- // if force is true create it if it doesn't exist allready
- //
+ /// return pointer to the EbyE info of the mean arrival time for 'sector'
+ /// if force is true create it if it doesn't exist allready
+
TObjArray *arr = &fTMeanArrayEvent;
return GetVectSector(sector,arr,100,force);
}
//_____________________________________________________________________
TVectorF* AliTPCCalibCE::GetQMeanEvents(Int_t sector, Bool_t force)
{
- //
- // return pointer to the EbyE info of the mean arrival time for 'sector'
- // if force is true create it if it doesn't exist allready
- //
+ /// return pointer to the EbyE info of the mean arrival time for 'sector'
+ /// if force is true create it if it doesn't exist allready
+
TObjArray *arr = &fQMeanArrayEvent;
return GetVectSector(sector,arr,100,force);
}
//_____________________________________________________________________
AliTPCCalROC* AliTPCCalibCE::GetCalRoc(Int_t sector, TObjArray* arr, Bool_t force) const
{
- //
- // return pointer to ROC Calibration
- // if force is true create a new histogram if it doesn't exist allready
- //
+ /// return pointer to ROC Calibration
+ /// if force is true create a new histogram if it doesn't exist allready
+
if ( !force || arr->UncheckedAt(sector) )
return (AliTPCCalROC*)arr->UncheckedAt(sector);
//_____________________________________________________________________
AliTPCCalROC* AliTPCCalibCE::GetCalRocT0(Int_t sector, Bool_t force)
{
- //
- // return pointer to Time 0 ROC Calibration
- // if force is true create a new histogram if it doesn't exist allready
- //
+ /// return pointer to Time 0 ROC Calibration
+ /// if force is true create a new histogram if it doesn't exist allready
+
TObjArray *arr = &fCalRocArrayT0;
return GetCalRoc(sector, arr, force);
}
//_____________________________________________________________________
AliTPCCalROC* AliTPCCalibCE::GetCalRocT0Err(Int_t sector, Bool_t force)
{
- //
- // return pointer to the error of Time 0 ROC Calibration
- // if force is true create a new histogram if it doesn't exist allready
- //
+ /// return pointer to the error of Time 0 ROC Calibration
+ /// if force is true create a new histogram if it doesn't exist allready
+
TObjArray *arr = &fCalRocArrayT0Err;
return GetCalRoc(sector, arr, force);
}
//_____________________________________________________________________
AliTPCCalROC* AliTPCCalibCE::GetCalRocQ(Int_t sector, Bool_t force)
{
- //
- // return pointer to T0 ROC Calibration
- // if force is true create a new histogram if it doesn't exist allready
- //
+ /// return pointer to T0 ROC Calibration
+ /// if force is true create a new histogram if it doesn't exist allready
+
TObjArray *arr = &fCalRocArrayQ;
return GetCalRoc(sector, arr, force);
}
//_____________________________________________________________________
AliTPCCalROC* AliTPCCalibCE::GetCalRocRMS(Int_t sector, Bool_t force)
{
- //
- // return pointer to signal width ROC Calibration
- // if force is true create a new histogram if it doesn't exist allready
- //
+ /// return pointer to signal width ROC Calibration
+ /// if force is true create a new histogram if it doesn't exist allready
+
TObjArray *arr = &fCalRocArrayRMS;
return GetCalRoc(sector, arr, force);
}
//_____________________________________________________________________
AliTPCCalROC* AliTPCCalibCE::GetCalRocOutliers(Int_t sector, Bool_t force)
{
- //
- // return pointer to Outliers
- // if force is true create a new histogram if it doesn't exist allready
- //
+ /// return pointer to Outliers
+ /// if force is true create a new histogram if it doesn't exist allready
+
TObjArray *arr = &fCalRocArrayOutliers;
return GetCalRoc(sector, arr, force);
}
//_____________________________________________________________________
TObjArray* AliTPCCalibCE::GetParamArray(Int_t sector, TObjArray* arr, Bool_t force) const
{
- //
- // return pointer to TObjArray of fit parameters
- // if force is true create a new histogram if it doesn't exist allready
- //
+ /// return pointer to TObjArray of fit parameters
+ /// if force is true create a new histogram if it doesn't exist allready
+
if ( !force || arr->UncheckedAt(sector) )
return (TObjArray*)arr->UncheckedAt(sector);
//_____________________________________________________________________
TObjArray* AliTPCCalibCE::GetParamArrayPol1(Int_t sector, Bool_t force)
{
- //
- // return pointer to TObjArray of fit parameters from plane fit
- // if force is true create a new histogram if it doesn't exist allready
- //
+ /// return pointer to TObjArray of fit parameters from plane fit
+ /// if force is true create a new histogram if it doesn't exist allready
+
TObjArray *arr = &fParamArrayEventPol1;
return GetParamArray(sector, arr, force);
}
//_____________________________________________________________________
TObjArray* AliTPCCalibCE::GetParamArrayPol2(Int_t sector, Bool_t force)
{
- //
- // return pointer to TObjArray of fit parameters from parabola fit
- // if force is true create a new histogram if it doesn't exist allready
- //
+ /// return pointer to TObjArray of fit parameters from parabola fit
+ /// if force is true create a new histogram if it doesn't exist allready
+
TObjArray *arr = &fParamArrayEventPol2;
return GetParamArray(sector, arr, force);
}
//_____________________________________________________________________
void AliTPCCalibCE::CreateDVhist()
{
- //
- // Setup the THnSparse for the drift velocity determination
- //
+ /// Setup the THnSparse for the drift velocity determination
//HnSparse bins
//roc, row, pad, timebin, timestamp
TTimeStamp begin(2010,01,01,0,0,0);
TTimeStamp end(2035,01,01,0,0,0);
Int_t nbinsTime=(end.GetSec()-begin.GetSec())/60; //Minutes resolution
-
+
Int_t bins[kHnBinsDV] = { 72, 96, 140, 1030, nbinsTime};
Double_t xmin[kHnBinsDV] = { 0., 0., 0., 0., (Double_t)begin.GetSec()};
Double_t xmax[kHnBinsDV] = {72., 96., 140., 1030., (Double_t)end.GetSec()};
-
+
fHnDrift=new THnSparseI("fHnDrift","Laser digits",kHnBinsDV, bins, xmin, xmax);
fHnDrift->GetAxis(0)->SetNameTitle("ROC","Read-out chamber number");
fHnDrift->GetAxis(1)->SetNameTitle("Row","Row number");
//_____________________________________________________________________
void AliTPCCalibCE::ResetEvent()
{
- //
- // Reset global counters -- Should be called before each event is processed
- //
+ /// Reset global counters -- Should be called before each event is processed
+
fLastSector=-1;
fCurrentSector=-1;
fCurrentRow=-1;
//_____________________________________________________________________
void AliTPCCalibCE::ResetPad()
{
- //
- // Reset pad infos -- Should be called after a pad has been processed
- //
+ /// Reset pad infos -- Should be called after a pad has been processed
+
for (Int_t i=fFirstTimeBin; i<fLastTimeBin+1; ++i)
fPadSignal[i] = 0;
fMaxTimeBin = -1;
//_____________________________________________________________________
void AliTPCCalibCE::Merge(AliTPCCalibCE * const ce)
{
- //
- // Merge ce to the current AliTPCCalibCE
- //
+ /// Merge ce to the current AliTPCCalibCE
+
MergeBase(ce);
Int_t nCEevents = ce->GetNeventsProcessed();
-
+
if (fProcessOld&&ce->fProcessOld){
//merge histograms
for (Int_t iSec=0; iSec<72; ++iSec){
TH2S *hRefQmerge = ce->GetHistoQ(iSec);
TH2S *hRefT0merge = ce->GetHistoT0(iSec);
TH2S *hRefRMSmerge = ce->GetHistoRMS(iSec);
-
-
+
+
if ( hRefQmerge ){
TDirectory *dir = hRefQmerge->GetDirectory(); hRefQmerge->SetDirectory(0);
TH2S *hRefQ = GetHistoQ(iSec);
}
hRefRMSmerge->SetDirectory(dir);
}
-
+
}
-
+
// merge time information
-
-
+
+
for (Int_t iSec=0; iSec<72; ++iSec){
TObjArray *arrPol1CE = ce->GetParamArrayPol1(iSec);
TObjArray *arrPol2CE = ce->GetParamArrayPol2(iSec);
TVectorF *vMeanTimeCE = ce->GetTMeanEvents(iSec);
TVectorF *vMeanQCE = ce->GetQMeanEvents(iSec);
-
+
TObjArray *arrPol1 = 0x0;
TObjArray *arrPol2 = 0x0;
TVectorF *vMeanTime = 0x0;
TVectorF *vMeanQ = 0x0;
-
+
//resize arrays
if ( arrPol1CE && arrPol2CE ){
arrPol1 = GetParamArrayPol1(iSec,kTRUE);
vMeanTime->ResizeTo(fNevents+nCEevents);
vMeanQ->ResizeTo(fNevents+nCEevents);
}
-
+
for (Int_t iEvent=0; iEvent<nCEevents; ++iEvent){
if ( arrPol1CE && arrPol2CE ){
TVectorD *paramPol1 = (TVectorD*)(arrPol1CE->UncheckedAt(iEvent));
}
}
}
-
-
-
+
+
+
const TVectorD& eventTimes = ce->fVEventTime;
const TVectorD& eventIds = ce->fVEventNumber;
const TVectorF& time0SideA = ce->fVTime0SideA;
Double_t evId = eventIds.GetMatrixArray()[iEvent];
Float_t t0SideA = time0SideA.GetMatrixArray()[iEvent];
Float_t t0SideC = time0SideC.GetMatrixArray()[iEvent];
-
+
fVEventTime.GetMatrixArray()[fNevents+iEvent] = evTime;
fVEventNumber.GetMatrixArray()[fNevents+iEvent] = evId;
fVTime0SideA.GetMatrixArray()[fNevents+iEvent] = t0SideA;
//TODO: What to do with fTimeBursts???
}
}
-
+
fNevents+=nCEevents; //increase event counter
}
//_____________________________________________________________________
Long64_t AliTPCCalibCE::Merge(TCollection * const list)
{
- //
- // Merge all objects of this type in list
- //
+ /// Merge all objects of this type in list
Long64_t nmerged=1;
//_____________________________________________________________________
TGraph *AliTPCCalibCE::MakeGraphTimeCE(Int_t sector, Int_t xVariable, Int_t fitType, Int_t fitParameter)
{
- //
- // Make graph from fit parameters of pol1 fit, pol2 fit, mean arrival time or mean Q for ROC 'sector'
- // or side (-1: A-Side, -2: C-Side)
- // xVariable: 0-event time, 1-event id, 2-internal event counter
- // fitType: 0-pol1 fit, 1-pol2 fit, 2-mean time, 3-mean Q
- // fitParameter: fit parameter ( 0-2 for pol1 ([0]+[1]*x+[2]*y),
- // 0-5 for pol2 ([0]+[1]*x+[2]*y+[3]*x*x+[4]*y*y+[5]*x*y),
- // not used for mean time and mean Q )
- // for an example see class description at the beginning
- //
+ /// Make graph from fit parameters of pol1 fit, pol2 fit, mean arrival time or mean Q for ROC 'sector'
+ /// or side (-1: A-Side, -2: C-Side)
+ /// xVariable: 0-event time, 1-event id, 2-internal event counter
+ /// fitType: 0-pol1 fit, 1-pol2 fit, 2-mean time, 3-mean Q
+ /// fitParameter: fit parameter ( 0-2 for pol1 ([0]+[1]*x+[2]*y),
+ /// 0-5 for pol2 ([0]+[1]*x+[2]*y+[3]*x*x+[4]*y*y+[5]*x*y),
+ /// not used for mean time and mean Q )
+ /// for an example see class description at the beginning
TVectorD *xVar = 0x0;
TObjArray *aType = 0x0;
xVar = new TVectorD(fNevents);
for ( Int_t i=0;i<fNevents; ++i) (*xVar)[i]=i;
}
-
+
Double_t *x = new Double_t[fNevents];
Double_t *y = new Double_t[fNevents];
-
+
for (Int_t ievent =0; ievent<fNevents; ++ievent){
if ( fitType<2 ){
TObjArray *events = (TObjArray*)(aType->At(sector));
//_____________________________________________________________________
void AliTPCCalibCE::Analyse()
{
- //
- // Calculate calibration constants
- //
+ /// Calculate calibration constants
if (fProcessOld){
TVectorD paramQ(3);
TVectorD paramT0(3);
TVectorD paramRMS(3);
TMatrixD dummy(3,3);
-
+
Float_t channelCounter=0;
fMeanT0rms=0;
fMeanQrms=0;
fMeanRMSrms=0;
-
+
for (Int_t iSec=0; iSec<72; ++iSec){
TH2S *hT0 = GetHistoT0(iSec);
if (!hT0 ) continue;
-
+
AliTPCCalROC *rocQ = GetCalRocQ (iSec,kTRUE);
AliTPCCalROC *rocT0 = GetCalRocT0 (iSec,kTRUE);
AliTPCCalROC *rocT0Err = GetCalRocT0Err (iSec,kTRUE);
AliTPCCalROC *rocRMS = GetCalRocRMS(iSec,kTRUE);
AliTPCCalROC *rocOut = GetCalRocOutliers(iSec,kTRUE);
-
+
TH2S *hQ = GetHistoQ(iSec);
TH2S *hRMS = GetHistoRMS(iSec);
-
+
Short_t *arrayhQ = hQ->GetArray();
Short_t *arrayhT0 = hT0->GetArray();
Short_t *arrayhRMS = hRMS->GetArray();
-
+
UInt_t nChannels = fROC->GetNChannels(iSec);
-
+
//debug
Int_t row=0;
Int_t pad=0;
Int_t padc=0;
//! debug
-
+
for (UInt_t iChannel=0; iChannel<nChannels; ++iChannel){
-
-
+
+
Float_t cogTime0 = -1000;
Float_t cogQ = -1000;
Float_t cogRMS = -1000;
Float_t cogOut = 0;
Float_t rms = 0;
Float_t rmsT0 = 0;
-
-
+
+
Int_t offsetQ = (fNbinsQ+2)*(iChannel+1)+1;
Int_t offsetT0 = (fNbinsT0+2)*(iChannel+1)+1;
Int_t offsetRMS = (fNbinsRMS+2)*(iChannel+1)+1;
-
+
cogQ = AliMathBase::GetCOG(arrayhQ+offsetQ,fNbinsQ,fXminQ,fXmaxQ,&rms);
fMeanQrms+=rms;
cogTime0 = AliMathBase::GetCOG(arrayhT0+offsetT0,fNbinsT0,fXminT0,fXmaxT0,&rmsT0);
cogRMS = AliMathBase::GetCOG(arrayhRMS+offsetRMS,fNbinsRMS,fXminRMS,fXmaxRMS,&rms);
fMeanRMSrms+=rms;
channelCounter++;
-
+
/*
//outlier specifications
if ( (cogQ < ??) && (cogTime0 > ??) && (cogTime0<??) && ( cogRMS>??) ){
rocT0Err->SetValue(iChannel, rmsT0);
rocRMS->SetValue(iChannel, cogRMS);
rocOut->SetValue(iChannel, cogOut);
-
-
+
+
//debug
if ( GetStreamLevel() > 0 ){
TTreeSRedirector *streamer=GetDebugStreamer();
if ( streamer ) {
-
+
while ( iChannel > (fROC->GetRowIndexes(iSec)[row]+fROC->GetNPads(iSec,row)-1) ) row++;
pad = iChannel-fROC->GetRowIndexes(iSec)[row];
padc = pad-(fROC->GetNPads(iSec,row)/2);
-
+
(*streamer) << "DataEnd" <<
"Sector=" << iSec <<
"Pad=" << pad <<
}
}
//! debug
-
+
}
-
+
}
if ( channelCounter>0 ){
fMeanT0rms/=channelCounter;
//_____________________________________________________________________
void AliTPCCalibCE::FindLocalMaxima(TObjArray * const arrObj, Double_t timestamp, Int_t burst)
{
- //
- //Find the local maximums for the projections to each axis
- //
-
+ /// Find the local maximums for the projections to each axis
+
//find laser layer positoins
fHnDrift->GetAxis(4)->SetRangeUser(timestamp-2*60,timestamp+2*60);
FindLaserLayers();
THnSparse *hProj=fHnDrift;
Double_t posCE[4]={0.,0.,0.,0.};
Double_t widthCE[4]={0.,0.,0.,0.};
-
+
// if(fPeaks[4]!=0){
// find central electrode position once more, separately for IROC, OROC, A-, C-Side
-
+
for (Int_t i=0; i<4; ++i){
Int_t ce=(i/2>0)*7+6;
hProj->GetAxis(0)->SetRangeUser(i*18,(i+1)*18-1);
//Current drift velocity
Float_t vdrift=2.61301900000000000e+06;//fParam->GetDriftV();
// cout<<"vdrift="<<vdrift<<endl;
-
+
AliDebug(5,Form("Timestamp %f - default drift velocity %f",timestamp,vdrift));
//loop over all entries in the histogram
Int_t coord[5];
for(Long64_t ichunk=0;ichunk<hProj->GetNbins();ichunk++){
//get entry position and content
Double_t adc=hProj->GetBinContent(ichunk,coord);
-
-
+
+
Int_t sector = coord[0]-1;
Int_t row = coord[1]-1;
Int_t pad = coord[2]-1;
// return;
// fPeaks[4]=(UInt_t)posCE[sector/18];
// fPeakWidths[4]=(UInt_t)widthCE[sector/18];
-
+
//cuts
if (time<timestamp-120||time>timestamp+120) continue; //window of +- 2min
if (adc < 5 ) continue;
// if (!IsPeakInRange(timeBin)) continue;
// if (isCE&&((row%2)||(row%2)||(sector%2))) continue;
// if (isCE&&(sector!=0)) continue;
-
+
Int_t padmin=-2, padmax=2;
Int_t timemin=-2, timemax=2;
Int_t minsumperpad=2;
timemin=-3;
timemax=7;
}
-
+
//
// Find local maximum and cogs
//
Float_t totalmass=0, tbcm=0, padcm=0, rmstb=0, rmspad=0;
Double_t cogY=0, rmsY=0;
Int_t npart=0;
-
+
// for position calculation use
for(Int_t ipad=padmin;ipad<=padmax;++ipad){
Float_t lxyz[3];
fROC->GetPositionLocal(sector,row,pad+ipad,lxyz);
-
+
for(Int_t itime=timemin;itime<=timemax;++itime){
-
+
Int_t a[5]={coord[0],coord[1],coord[2]+ipad,coord[3]+itime,coord[4]};
Double_t val=hProj->GetBinContent(a);
totalmass+=val;
-
+
tbcm +=(timeBin+itime)*val;
padcm+=(pad+ipad)*val;
cogY +=lxyz[1]*val;
-
+
rmstb +=(timeBin+itime)*(timeBin+itime)*val;
rmspad+=(pad+ipad)*(pad+ipad)*val;
rmsY +=lxyz[1]*lxyz[1]*val;
-
+
if (val>0) ++npart;
if (val>adc) {
isMaximum=kFALSE;
}
if (!isMaximum) break;
}
-
+
if (!isMaximum||!npart) continue;
if (totalmass<npart*minsumperpad) continue;
if (!isCE&&rmspad<.1) continue; //most probably noise, since signal only in one pad,
//for CE we want only one pad by construction
-
+
tbcm/=totalmass;
padcm/=totalmass;
cogY/=totalmass;
-
+
rmstb/=totalmass;
rmspad/=totalmass;
rmsY/=totalmass;
-
+
rmstb=TMath::Sqrt(TMath::Abs(tbcm*tbcm-rmstb));
rmspad=TMath::Sqrt(TMath::Abs(padcm*padcm-rmspad));
rmsY=TMath::Sqrt(TMath::Abs(cogY*cogY-rmsY));
-
+
Int_t cog=TMath::Nint(padcm);
-
+
// timebin --> z position
Float_t zlength=fParam->GetZLength(side);
// Float_t timePos=tbcm+(1000-fPeaks[4])
// drift velocity is in m/s we would like to have cm/100ns, so 100cm/(10^7*100ns)
Double_t gz=(zlength-(tbcm*vdrift*1.e-7))*TMath::Power(-1,side);
-
+
// local to global transformation--> x and y positions
Float_t padlxyz[3];
fROC->GetPositionLocal(sector,row,pad,padlxyz);
-
+
Double_t gxyz[3]={padlxyz[0],cogY,gz};
Double_t lxyz[3]={padlxyz[0],cogY,gz};
Double_t igxyz[3]={0,0,0};
AliTPCTransform t1;
t1.RotatedGlobal2Global(sector,gxyz);
-
+
Double_t mindist=0;
Int_t trackID=-1;
Int_t trackID2=-1;
-
+
//find track id and index of the position in the track (row)
Int_t index=0;
if (!isCE){
// mindist=TMath::Abs(fPeaks[4]-tbcm);
mindist=1.;
}
-
+
// fill track vectors
if (trackID>0){
AliTPCLaserTrack *ltr=(AliTPCLaserTrack*)arrObj->UncheckedAt(trackID);
Double_t oldMinDist=ltr->fVecPhi->GetMatrixArray()[index];
-
-
+
+
// travel time effect of light includes
-
+
Double_t raylength=ltr->GetRayLength();
Double_t globmir[3]={ltr->Xv(),ltr->Yv(),ltr->Zv()};
ltr->GetXYZ(globmir);
+(gxyz[2]-globmir[2])*(gxyz[2]-globmir[2])+raylength))*vdrift*TMath::Power(10.,-6.)/30000;
}
}
-
+
if (TMath::Abs(oldMinDist)<1.e-20||oldMinDist>mindist){
ltr->fVecSec->GetMatrixArray()[index]=sector;
ltr->fVecP2->GetMatrixArray()[index]=0;
igxyz[1]=ltr->fVecGY->GetMatrixArray()[row];
igxyz[2]=ltr->fVecGZ->GetMatrixArray()[row];
}
-
-
+
+
if (fStreamLevel>4){
(*GetDebugStreamer()) << "clusters" <<
"run=" << fRunNumber <<
"cogCE=" << posCE[sector/18] <<
"withCE=" << widthCE[sector/18] <<
"index=" << index <<
-
+
"padcm=" << padcm <<
"rmspad=" << rmspad <<
-
+
"cogtb=" << tbcm <<
"rmstb=" << rmstb <<
-
+
"npad=" << npart <<
-
+
"lx=" << padlxyz[0]<<
"ly=" << cogY <<
"lypad=" << padlxyz[1]<<
"rmsY=" << rmsY <<
-
+
"gx=" << gxyz[0] <<
"gy=" << gxyz[1] <<
"gz=" << gxyz[2] <<
-
+
"igx=" << igxyz[0] <<
"igy=" << igxyz[1] <<
"igz=" << igxyz[2] <<
-
+
"mind=" << mindist <<
"max=" << adc <<
"trackid=" << trackID <<
"npart=" << npart <<
"\n";
} // end stream levelmgz.fElements
-
+
}
-
+
}
//_____________________________________________________________________
void AliTPCCalibCE::AnalyseTrack()
{
- //
- // Analyse the tracks
- //
-
-
+ /// Analyse the tracks
+
+
AliTPCLaserTrack::LoadTracks();
// AliTPCParam *param=0x0;
// //cdb run number
// } else {
// AliError("Could not get updated AliTPCParam from OCDB!!!");
// }
-
+
//Measured and ideal laser tracks
TObjArray* arrMeasured = SetupMeasured();
TObjArray* arrIdeal = AliTPCLaserTrack::GetTracks();
AddCEtoIdeal(arrIdeal);
-
+
//find bursts and loop over them
for (Int_t iburst=0; iburst<fArrHnDrift.GetEntries();++iburst){
Double_t timestamp=fTimeBursts[iburst];
UInt_t entries=(UInt_t)fHnDrift->GetEntries();
if (fBinsLastAna[iburst]>=entries) continue; //already analysed!!!
fBinsLastAna[iburst]=entries;
-
+
for (Int_t iDim=0; iDim<fHnDrift->GetNdimensions(); ++iDim) fHnDrift->GetAxis(iDim)->SetRange(0,0);
// if (iburst==0) FindLaserLayers();
-
+
//reset laser tracks
ResetMeasured(arrMeasured);
-
+
//find clusters and associate to the tracks
FindLocalMaxima(arrMeasured, timestamp, iburst);
-
+
//calculate drift velocity
CalculateDV(arrIdeal,arrMeasured,iburst);
-
+
//Dump information to file if requested
if (fStreamLevel>2){
//printf("make tree\n");
//laser track information
-
+
for (Int_t itrack=0; itrack<338; ++itrack){
TObject *iltr=arrIdeal->UncheckedAt(itrack);
TObject *mltr=arrMeasured->UncheckedAt(itrack);
Int_t AliTPCCalibCE::FindLaserTrackID(Int_t sector,Int_t row, const Double_t *peakpos,Double_t &mindist,
const Double_t *peakposloc, Int_t &itrackMin2)
{
- //
- // Find the tracks, which are closest to the ideal tracks, from clusters closest to the ideal tracks
- //
-
-
+ /// Find the tracks, which are closest to the ideal tracks, from clusters closest to the ideal tracks
+
+
TObjArray *arr=AliTPCLaserTrack::GetTracks();
TVector3 vP(peakpos[0],peakpos[1],peakpos[2]);
TVector3 vDir;
TVector3 vSt;
-
+
Int_t firstbeam=0;
Int_t lastbeam=336/2;
if ( (sector/18)%2 ) {
firstbeam=336/2;
lastbeam=336;
}
-
+
mindist=1000000;
Int_t itrackMin=-1;
for (Int_t itrack=firstbeam; itrack<lastbeam; ++itrack){
vDir.SetMagThetaPhi(1,ltr->Theta(),TMath::ASin(ltr->GetSnp()));
vSt.RotateZ(ltr->GetAlpha());
vDir.RotateZ(ltr->GetAlpha());
-
+
Double_t dist=(vDir.Cross(vSt-vP)).Mag()/vDir.Mag();
-
+
if (dist<mindist){
mindist=dist;
itrackMin=itrack;
}
-
+
}
itrackMin2=-1;
Float_t mindist2=10;
for (Int_t itrack=firstbeam; itrack<lastbeam; ++itrack){
AliTPCLaserTrack *ltr=(AliTPCLaserTrack*)arr->At(itrack); //get the track
if ((ltr->fVecSec->GetMatrixArray())[row]!=sector) continue;
-
+
Double_t deltaZ=ltr->GetZ()-peakpos[2];
if (TMath::Abs(deltaZ)>40) continue;
-
+
Double_t dist=TMath::Abs((ltr->fVecLY->GetMatrixArray())[row]-peakposloc[1]);
if (dist>1) continue;
-
+
if (dist<mindist2){
mindist2=dist;
itrackMin2=itrack;
}
mindist=mindist2;
return itrackMin2;
-
+
}
//_____________________________________________________________________
Bool_t AliTPCCalibCE::IsEdgePad(Int_t sector, Int_t row, Int_t pad) const
{
- //
- // return true if pad is on the edge of a row
- //
+ /// return true if pad is on the edge of a row
+
Int_t edge1 = 0;
if ( pad == edge1 ) return kTRUE;
Int_t edge2 = fROC->GetNPads(sector,row)-1;
if ( pad == edge2 ) return kTRUE;
-
+
return kFALSE;
}
//_____________________________________________________________________
TObjArray* AliTPCCalibCE::SetupMeasured()
{
- //
- // setup array of measured laser tracks and CE
- //
-
+ /// setup array of measured laser tracks and CE
+
TObjArray *arrIdeal = AliTPCLaserTrack::GetTracks();
TObjArray *arrMeasured = new TObjArray(338);
arrMeasured->SetOwner();
for(Int_t itrack=0;itrack<336;itrack++){
arrMeasured->AddAt(new AliTPCLaserTrack(*((AliTPCLaserTrack*)arrIdeal->At(itrack))),itrack);
}
-
+
//"tracks" for CE
AliTPCLaserTrack *ltrce=new AliTPCLaserTrack;
ltrce->SetId(336);
ltrce->fVecLX=new TVectorD(557568/2);
ltrce->fVecLY=new TVectorD(557568/2);
ltrce->fVecLZ=new TVectorD(557568/2);
-
+
arrMeasured->AddAt(ltrce,336); //CE A-Side
-
+
ltrce=new AliTPCLaserTrack;
ltrce->SetId(337);
ltrce->SetSide(1);
ltrce->fVecLY=new TVectorD(557568/2);
ltrce->fVecLZ=new TVectorD(557568/2);
arrMeasured->AddAt(ltrce,337); //CE C-Side
-
+
return arrMeasured;
}
//_____________________________________________________________________
void AliTPCCalibCE::ResetMeasured(TObjArray * const arr)
{
- //
- // reset array of measured laser tracks and CE
- //
+ /// reset array of measured laser tracks and CE
+
for(Int_t itrack=0;itrack<338;itrack++){
AliTPCLaserTrack *ltr=(AliTPCLaserTrack*)arr->UncheckedAt(itrack);
ltr->fVecSec->Zero();
//_____________________________________________________________________
void AliTPCCalibCE::AddCEtoIdeal(TObjArray *arr)
{
- //
- // Add ideal CE positions to the ideal track data
- //
-
+ /// Add ideal CE positions to the ideal track data
+
arr->Expand(338);
//"tracks" for CE
AliTPCLaserTrack *ltrceA=new AliTPCLaserTrack;
ltrceA->fVecLY=new TVectorD(557568/2);
ltrceA->fVecLZ=new TVectorD(557568/2);
arr->AddAt(ltrceA,336); //CE A-Side
-
+
AliTPCLaserTrack *ltrceC=new AliTPCLaserTrack;
ltrceC->SetId(337);
ltrceC->SetSide(1);
ltrceC->fVecLY=new TVectorD(557568/2);
ltrceC->fVecLZ=new TVectorD(557568/2);
arr->AddAt(ltrceC,337); //CE C-Side
-
+
//Calculate ideal positoins
Float_t gxyz[3];
Float_t lxyz[3];
Int_t channelSideC=0;
Int_t channelSide=0;
AliTPCLaserTrack *ltrce=0x0;
-
+
for (Int_t isector=0; isector<72; ++isector){
Int_t side=((isector/18)%2);
for (UInt_t irow=0;irow<fROC->GetNRows(isector);++irow){
ltrce=ltrceC;
channelSide=channelSideC;
}
-
+
ltrce->fVecSec->GetMatrixArray()[channelSide]=isector;
ltrce->fVecP2->GetMatrixArray()[channelSide]=0;
ltrce->fVecPhi->GetMatrixArray()[channelSide]=0;
ltrce->fVecLX->GetMatrixArray()[channelSide]=lxyz[0];
ltrce->fVecLY->GetMatrixArray()[channelSide]=lxyz[1];
// ltrce->fVecLZ->GetMatrixArray()[channelSide]=-1;
-
+
if (side==0){
ltrce->fVecGZ->GetMatrixArray()[channelSide]=-0.335;
ltrce->fVecLZ->GetMatrixArray()[channelSide]=-0.335;
}
}
}
-
-
+
+
}
//_____________________________________________________________________
void AliTPCCalibCE::CalculateDV(TObjArray * const arrIdeal, TObjArray * const arrMeasured, Int_t burst)
{
- //
- // calculate the drift velocity from the reconstructed clusters associated
- // to the ideal laser tracks
- // use two different fit scenarios: Separate fit for A- and C-Side
- // Common fit for A- and C-Side
- //
-
+ /// calculate the drift velocity from the reconstructed clusters associated
+ /// to the ideal laser tracks
+ /// use two different fit scenarios: Separate fit for A- and C-Side
+ /// Common fit for A- and C-Side
+
if (!fArrFitGraphs){
fArrFitGraphs=new TObjArray;
}
-
+
// static TLinearFitter fdriftA(5,"hyp4");
// static TLinearFitter fdriftC(5,"hyp4");
// static TLinearFitter fdriftAC(6,"hyp5");
Double_t timestamp=fTimeBursts[burst];
-
+
static TLinearFitter fdriftA(4,"hyp3");
static TLinearFitter fdriftC(4,"hyp3");
static TLinearFitter fdriftAC(5,"hyp4");
TVectorD fitA(7),fitC(7),fitAC(8); //fit values+chi2+npoints
-
+
Float_t chi2A = 10;
Float_t chi2C = 10;
Float_t chi2AC = 10;
Int_t npointsA=0;
Int_t npointsC=0;
Int_t npointsAC=0;
-
+
Double_t minres[3]={20.,1,0.8};
//----
for(Int_t i=0;i<3;i++){
-
+
fdriftA.ClearPoints();
fdriftC.ClearPoints();
fdriftAC.ClearPoints();
-
+
chi2A = 10;
chi2C = 10;
chi2AC = 10;
npointsA=0;
npointsC=0;
npointsAC=0;
-
+
for (Int_t itrack=0; itrack<338; ++itrack){
AliTPCLaserTrack *iltr=(AliTPCLaserTrack*)arrIdeal->UncheckedAt(itrack);
AliTPCLaserTrack *mltr=(AliTPCLaserTrack*)arrMeasured->UncheckedAt(itrack);
if ((itrack%7==0||itrack%7==6)&&itrack<336) continue;
Int_t clustercounter=0;
Int_t indexMax=159;
-
+
//-- exclude the low intensity tracks
-
+
for (Int_t index=0; index<indexMax; ++index){
-
+
Double_t mGx=mltr->fVecGX->GetMatrixArray()[index];
Double_t mGy=mltr->fVecGY->GetMatrixArray()[index];
Double_t mGz=mltr->fVecGZ->GetMatrixArray()[index];
-
+
if (TMath::Abs(mGz)<1e-20 && TMath::Abs(mGy)<1e-20 && TMath::Abs(mGx)<1e-20) clustercounter++;
}
if (clustercounter>130&&itrack<336) continue; // don't accept tracks with <= 159-130=29 clusters
clustercounter=0;
-
+
//-- drift length
Double_t zlength = (iltr->GetSide()==0)? fParam->GetZLength(36): fParam->GetZLength(71);
-
+
if (itrack>335) indexMax=557568/2;
for (Int_t index=0; index<indexMax; ++index){
Double_t iGx=iltr->fVecGX->GetMatrixArray()[index];
Double_t iGy=iltr->fVecGY->GetMatrixArray()[index];
Double_t iGz=iltr->fVecGZ->GetMatrixArray()[index];
Double_t iR=TMath::Sqrt(iGx*iGx+iGy*iGy);
-
+
Double_t mGx=mltr->fVecGX->GetMatrixArray()[index];
Double_t mGy=mltr->fVecGY->GetMatrixArray()[index];
Double_t mGz=mltr->fVecGZ->GetMatrixArray()[index];
Double_t mR=TMath::Sqrt(mGx*mGx+mGy*mGy);
-
+
//cut if no track info available
if (iltr->GetBundle()==0) continue;
if (iR<133||mR<133) continue;
if(TMath::Abs(mltr->fVecP2->GetMatrixArray()[index])>minres[i]) continue;
-
+
Double_t ldrift = (iltr->GetSide()==0)?zlength-iGz:iGz+zlength;
Double_t mdrift = (iltr->GetSide()==0)?zlength-mGz:mGz+zlength;
-
+
//Double_t xxx[4] = {ldrift,iGy*ldrift/(zlength*250.), 250.-mR, iltr->fVecSec->GetMatrixArray()[index]>35};
Double_t xxx[3] = {ldrift,iGy*ldrift/(zlength*250.), 250.-mR};
-
+
if (iltr->GetSide()==0){
fdriftA.AddPoint(xxx,mdrift,1);
}else{
// Double_t xxx2[4] = { ldrift,iGy*ldrift/(zlength*250.), 250.-mR, iltr->fVecSec->GetMatrixArray()[index]>35, iltr->GetSide()};
Double_t xxx2[4] = { ldrift,iGy*ldrift/(zlength*250.), 250.-mR, static_cast<Double_t>(iltr->GetSide())};
fdriftAC.AddPoint(xxx2,mdrift,1);
-
+
}//end index loop
}//end laser track loop
-
+
//perform fit
fdriftA.Eval();
fdriftC.Eval();
fdriftAC.Eval();
-
-
-
+
+
+
//get fit values
fdriftA.GetParameters(fitA);
fdriftC.GetParameters(fitC);
fdriftAC.GetParameters(fitAC);
-
+
//Parameters: 0 linear offset
// 1 mean drift velocity correction factor
// 2 relative global y gradient
// 3 radial deformation
// 4 IROC/OROC offset
-
+
// FindResiduals(arrMeasured,arrIdeal,fitA,fitC);
-
+
for (Int_t itrack=0; itrack<338; ++itrack){
AliTPCLaserTrack *iltr=(AliTPCLaserTrack*)arrIdeal->UncheckedAt(itrack);
AliTPCLaserTrack *mltr=(AliTPCLaserTrack*)arrMeasured->UncheckedAt(itrack);
Double_t iGy=iltr->fVecGY->GetMatrixArray()[index];
Double_t iGz=iltr->fVecGZ->GetMatrixArray()[index];
Double_t iR=TMath::Sqrt(iGx*iGx+iGy*iGy);
-
+
Double_t mGx=mltr->fVecGX->GetMatrixArray()[index];
Double_t mGy=mltr->fVecGY->GetMatrixArray()[index];
Double_t mGz=mltr->fVecGZ->GetMatrixArray()[index];
Double_t mR=TMath::Sqrt(mGx*mGx+mGy*mGy);
-
+
//cut if no track info available
if (iR<60||mR<60) continue;
-
+
Double_t ldrift = (iltr->GetSide()==0)?zlength-iGz:iGz+zlength;
Double_t mdrift = (iltr->GetSide()==0)?zlength-mGz:mGz+zlength;
-
+
TVectorD *v=&fitA;
if (iltr->GetSide()==1) v=&fitC;
// Double_t iCorr=(*v)[0]+(*v)[1]*ldrift+(*v)[2]*iGy*ldrift/(zlength*250.)+(*v)[3]*(250.-mR)+(*v)[4]*( iltr->fVecSec->GetMatrixArray()[index]>35);
Double_t iCorr=(*v)[0]+(*v)[1]*ldrift+(*v)[2]*iGy*ldrift/(zlength*250.)+(*v)[3]*(250.-mR);
-
+
mltr->fVecP2->GetMatrixArray()[index]=mdrift-iCorr;
-
+
}
}
-
+
fitA.ResizeTo(7);
fitC.ResizeTo(7);
fitAC.ResizeTo(8);
-
+
//set statistics values
npointsA= fdriftA.GetNpoints();
if (npointsA>0) chi2A = fdriftA.GetChisquare()/fdriftA.GetNpoints();
fitA[5]=npointsA;
fitA[6]=chi2A;
-
+
npointsC= fdriftC.GetNpoints();
if (npointsC>0) chi2C = fdriftC.GetChisquare()/fdriftC.GetNpoints();
fitC[5]=npointsC;
fitC[6]=chi2C;
-
+
npointsAC= fdriftAC.GetNpoints();
if (npointsAC>0) chi2AC = fdriftAC.GetChisquare()/fdriftAC.GetNpoints();
fitAC[5]=npointsAC;
fitAC[6]=chi2AC;
-
+
if (fStreamLevel>2){
//laser track information
(*GetDebugStreamer()) << "DriftV" <<
"fitC.=" << &fitC <<
"fitAC.=" << &fitAC <<
"\n";
-
-
+
+
}
-
+
}
//-----
-
-
+
+
//Parameters: 0 linear offset (global)
// 1 mean drift velocity correction factor
// 2 relative global y gradient
// 3 radial deformation
// 4 IROC/OROC offset
// 5 linear offset relative A-C
-
+
//get graphs
TGraphErrors *grA[7];
TGraphErrors *grC[7];
TGraphErrors *grAC[8];
TString names("GRAPH_MEAN_DELAY_LASER_ALL_;GRAPH_MEAN_DRIFT_LASER_ALL_;GRAPH_MEAN_GLOBALYGRADIENT_LASER_ALL_;GRAPH_MEAN_RGRADIENT_LASER_ALL_;GRAPH_MEAN_IROCOROCOFFSET_LASER_ALL_;GRAPH_MEAN_NPOINTS_LASER_ALL_;GRAPH_MEAN_CHI2_LASER_ALL_");
TString namesAC("GRAPH_MEAN_DELAY_LASER_ALL_;GRAPH_MEAN_DRIFT_LASER_ALL_;GRAPH_MEAN_GLOBALYGRADIENT_LASER_ALL_;GRAPH_MEAN_RGRADIENT_LASER_ALL_;GRAPH_MEAN_IROCOROCOFFSET_LASER_ALL_;GRAPH_MEAN_NPOINTS_LASER_ALL_;GRAPH_MEAN_CHI2_LASER_ALL_;GRAPH_MEAN_DELAYC_LASER_ALL_");
-
+
TObjArray *arrNames=names.Tokenize(";");
TObjArray *arrNamesAC=namesAC.Tokenize(";");
-
+
//A-Side graphs
for (Int_t i=0; i<7; ++i){
TString grName=arrNames->UncheckedAt(i)->GetName();
grA[i]->SetPointError(ipoint,60,.0001);
if (i<4) grA[i]->SetPointError(ipoint,60,fdriftA.GetCovarianceMatrixElement(i,i));
}
-
+
//C-Side graphs
for (Int_t i=0; i<7; ++i){
TString grName=arrNames->UncheckedAt(i)->GetName();
grC[i]->SetPointError(ipoint,60,.0001);
if (i<4) grC[i]->SetPointError(ipoint,60,fdriftC.GetCovarianceMatrixElement(i,i));
}
-
+
//AC-Side graphs
for (Int_t i=0; i<8; ++i){
TString grName=arrNamesAC->UncheckedAt(i)->GetName();
grAC[i]->SetPointError(ipoint,60,.0001);
if (i<5) grAC[i]->SetPointError(ipoint,60,fdriftAC.GetCovarianceMatrixElement(i,i));
}
-
+
if (fDebugLevel>10){
printf("A side fit parameters:\n");
fitA.Print();
//_____________________________________________________________________
Double_t AliTPCCalibCE::SetBurstHnDrift()
{
- //
- // Create a new THnSparse for the current burst
- // return the time of the current burst
- //
+ /// Create a new THnSparse for the current burst
+ /// return the time of the current burst
+
Int_t i=0;
for(i=0; i<fTimeBursts.GetNrows(); ++i){
if(fTimeBursts.GetMatrixArray()[i]<1.e-20) break;
return fTimeBursts(i);
}
}
-
+
CreateDVhist();
fArrHnDrift.AddAt(fHnDrift,i);
fTimeBursts.GetMatrixArray()[i]=fTimeStamp;
//_____________________________________________________________________
void AliTPCCalibCE::DumpToFile(const Char_t *filename, const Char_t *dir, Bool_t /*append*/)
{
- //
- // Write class to file
- // option can be specified in the dir option:
- // options:
- // name=<objname>: the name of the calibration object in file will be <objname>
- // type=<type>: the saving type:
- // 0 - write the complte object
- // 1 - Store the histogram arrays separately to make the streamed object smaller, Analyse to be called
- // 2 - like 2, but in addition delete objects that will most probably not be used for calibration
- // 3 - store only calibration output, don't store the reference histograms
- // and THnSparse (requires Analyse called before)
- //
- // NOTE: to read the object back, the ReadFromFile function should be used
- //
-
+ /// Write class to file
+ /// option can be specified in the dir option:
+ /// options:
+ /// name=<objname>: the name of the calibration object in file will be <objname>
+ /// type=<type>: the saving type:
+ /// 0 - write the complte object
+ /// 1 - Store the histogram arrays separately to make the streamed object smaller, Analyse to be called
+ /// 2 - like 2, but in addition delete objects that will most probably not be used for calibration
+ /// 3 - store only calibration output, don't store the reference histograms
+ /// and THnSparse (requires Analyse called before)
+ ///
+ /// NOTE: to read the object back, the ReadFromFile function should be used
+
TString sDir(dir);
TString objName=GetName();
Int_t type=0;
-
+
//get options
TObjArray *arr=sDir.Tokenize(",");
TIter next(arr);
fParamArrayEventPol1.Delete();
fParamArrayEventPol2.Delete();
}
-
+
TObjArray histoQArray(72);
TObjArray histoT0Array(72);
TObjArray histoRMSArray(72);
fHistoQArray.Clear();
fHistoT0Array.Clear();
fHistoRMSArray.Clear();
-
+
for (Int_t i=0;i<fArrHnDrift.GetEntries();++i){
arrHnDrift.AddAt(fArrHnDrift.UncheckedAt(i),i);
}
fArrHnDrift.SetOwner(kFALSE);
fArrHnDrift.Clear();
}
-
-
+
+
TDirectory *backup = gDirectory;
-
+
TFile f(filename,"recreate");
Write(objName.Data());
if (type==1||type==2) {
}
fArrHnDrift.SetOwner(kTRUE);
}
-
+
if ( backup ) backup->cd();
}
//_____________________________________________________________________
AliTPCCalibCE* AliTPCCalibCE::ReadFromFile(const Char_t *filename)
{
- //
- // Read object from file
- // Handle properly if the histogram arrays were stored separately
- // call Analyse to make sure to have the calibration relevant information in the object
- //
-
+ /// Read object from file
+ /// Handle properly if the histogram arrays were stored separately
+ /// call Analyse to make sure to have the calibration relevant information in the object
+
TFile f(filename);
if (!f.IsOpen() || f.IsZombie() ) return 0x0;
TList *l=f.GetListOfKeys();
TObjArray *histoT0Array=0x0;
TObjArray *histoRMSArray=0x0;
TObjArray *arrHnDrift=0x0;
-
+
while ( (key=(TKey*)next()) ){
o=key->ReadObj();
if ( o->IsA()==AliTPCCalibCE::Class() ){
}
ce->fHistoQArray.SetOwner(kTRUE);
}
-
+
if (histoT0Array) {
for (Int_t i=0; i<72; ++i){
hist=(TH1*)histoT0Array->UncheckedAt(i);
}
ce->fHistoT0Array.SetOwner(kTRUE);
}
-
+
if (histoRMSArray){
for (Int_t i=0; i<72; ++i){
hist=(TH1*)histoRMSArray->UncheckedAt(i);
}
ce->fHistoRMSArray.SetOwner(kTRUE);
}
-
+
if (arrHnDrift){
for (Int_t i=0; i<arrHnDrift->GetEntries(); ++i){
THnSparseI *hSparse=(THnSparseI*)arrHnDrift->UncheckedAt(i);
ce->fArrHnDrift.AddAt(hSparse,i);
}
}
-
+
ce->Analyse();
}
f.Close();
-
+
return ce;
}
/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
* See cxx source for full Copyright notice */
-////////////////////////////////////////////////////////////////////////////////////////
-// //
-// Implementation of the TPC Central Electrode calibration //
-// //
-////////////////////////////////////////////////////////////////////////////////////////
+/// \class AliTPCCalibCE
+/// \brief Implementation of the TPC Central Electrode calibration
#include <TVectorT.h>
#include <THnSparse.h>
struct eventHeaderStruct;
class AliTPCCalibCE : public AliTPCCalibRawBase {
-
+
public:
AliTPCCalibCE();
AliTPCCalibCE(const AliTPCCalibCE &sig);
AliTPCCalibCE(const TMap *config);
virtual ~AliTPCCalibCE();
-
+
AliTPCCalibCE& operator = (const AliTPCCalibCE &source);
-
+
virtual Int_t Update(const Int_t isector, const Int_t iRow, const Int_t iPad,
const Int_t iTimeBin, const Float_t signal);
virtual void ProcessBunch(const Int_t sector, const Int_t row, const Int_t pad,
const Int_t length, const UInt_t startTimeBin, const UShort_t* signal);
-
+
virtual void Analyse();
void AnalyseTrack();
-
+
//
AliTPCCalROC* GetCalRocT0 (Int_t sector, Bool_t force=kFALSE); // get calibration object - sector
AliTPCCalROC* GetCalRocT0Err(Int_t sector, Bool_t force=kFALSE); // get calibration object - sector
AliTPCCalROC* GetCalRocQ (Int_t sector, Bool_t force=kFALSE); // get calibration object - sector
AliTPCCalROC* GetCalRocRMS(Int_t sector, Bool_t force=kFALSE); // get calibration object - sector
AliTPCCalROC* GetCalRocOutliers(Int_t sector, Bool_t force=kFALSE); // get calibration object - sector
-
+
const TObjArray* GetCalPadT0() const { return &fCalRocArrayT0; } // get calibration object
const TObjArray* GetCalPadT0Err() const { return &fCalRocArrayT0Err; } // get calibration object
const TObjArray* GetCalPadQ() const { return &fCalRocArrayQ; } // get calibration object
const TObjArray* GetCalPadRMS() const { return &fCalRocArrayRMS;} // get calibration object
const TObjArray* GetCalPadOutliers() const { return &fCalRocArrayOutliers;} // get calibration object
-
+
TH2S* GetHistoQ (Int_t sector, Bool_t force=kFALSE); // get refernce histogram
TH2S* GetHistoT0 (Int_t sector, Bool_t force=kFALSE); // get refernce histogram
TH2S* GetHistoRMS(Int_t sector, Bool_t force=kFALSE); // get refernce histogram
Float_t GetMeanT0rms() const {return fMeanT0rms;}
Float_t GetMeanQrms() const {return fMeanQrms;}
Float_t GetMeanRMSrms() const {return fMeanRMSrms;}
-
+
Int_t GetPeakDetectionMinus() const {return fPeakDetMinus;}
Int_t GetPeakDetectionPlus() const {return fPeakDetPlus;}
Int_t GetPeakIntRangeMinus() const {return fPeakIntMinus;}
Int_t GetPeakIntRangePlus() const {return fPeakIntPlus;}
Float_t GetNnoiseThresholdMax() const {return fNoiseThresholdMax;}
Float_t GetNnoiseThresholdSum() const {return fNoiseThresholdSum;}
-
+
TH1S* GetHistoTmean(Int_t sector, Bool_t force=kFALSE); // get refernce histogram
-
+
//needed here to merge ClibCE objects
TObjArray* GetParamArrayPol1(Int_t sector, Bool_t force=kFALSE);
TObjArray* GetParamArrayPol2(Int_t sector, Bool_t force=kFALSE);
-
+
// TObjArray* GetTMeanArrayEvent(){ return &fTMeanArrayEvent; }
// TObjArray* GetQMeanArrayEvent(){ return &fQMeanArrayEvent; }
TVectorF* GetTMeanEvents(Int_t sector, Bool_t force=kFALSE);
TVectorF* GetQMeanEvents(Int_t sector, Bool_t force=kFALSE);
-
+
const TVectorD* GetEventTimes() const { return &fVEventTime; }
const TVectorD* GetEventIds() const { return &fVEventNumber; }
-
+
//
void SetRangeRefQ (Int_t nBins, Float_t xMin, Float_t xMax){ fNbinsQ = nBins; fXminQ = xMin; fXmaxQ = xMax; } //Set range for Q reference histograms
void SetRangeRefT0 (Int_t nBins, Float_t xMin, Float_t xMax){ fNbinsT0 = nBins; fXminT0 = xMin; fXmaxT0 = xMax; } //Set range for T0 reference histograms
void SetProcessNew(Bool_t process=kTRUE) {fProcessNew=process; if (process&&!fHnDrift) CreateDVhist(); }
//Getters
Int_t GetNeventsProcessed() const { return fNevents; }
-
+
Bool_t GetIsZeroSuppressed() const { return fIsZeroSuppressed; }
-
+
Float_t GetSecRejectRatio() const { return fSecRejectRatio; }
const TVectorF *GetTime0Side(Int_t side=0) const {return (side==0)?&fVTime0SideA:&fVTime0SideC;}
Float_t GetPeakIntegralMinus() const {return fPeakIntMinus;}
Float_t GetPeakIntegralPlus() const {return fPeakIntPlus;}
-
-
+
+
void Merge(AliTPCCalibCE * const ce);
virtual Long64_t Merge(TCollection * const list);
-
+
TGraph *MakeGraphTimeCE(Int_t sector, Int_t xVariable=0, Int_t fitType=0, Int_t fitParameter=0);
//
// New functions using also the laser tracks
//
Bool_t IsEdgePad(Int_t sector, Int_t row, Int_t pad) const;
-
+
void FindLocalMaxima(TObjArray * const arrObj, Double_t timestamp, Int_t burst);
Int_t FindLaserTrackID(Int_t sector,Int_t row, const Double_t *peakpos,Double_t &mindist, const Double_t *peakposloc, Int_t &itrackMin2);
-
+
const THnSparseI *GetHnDrift() const {return fHnDrift;}
const TObjArray& GetArrHnDrift() const {return fArrHnDrift;}
const TVectorD& GetTimeBursts() const {return fTimeBursts;}
const TObjArray *GetArrFitGraphs() const {return fArrFitGraphs;}
virtual void DumpToFile(const Char_t *filename, const Char_t *dir="", Bool_t append=kFALSE);
-
+
static AliTPCCalibCE *ReadFromFile(const Char_t *filename);
-
+
protected:
virtual void EndEvent();
virtual void ResetEvent();
-
+
private:
// reference histogram ranges
- Int_t fNbinsT0; // Number of bins for T0 reference histogram
- Float_t fXminT0; // xmin of T0 reference histogram
- Float_t fXmaxT0; // xmax of T0 reference histogram
- Int_t fNbinsQ; // Number of bins for T0 reference histogram
- Float_t fXminQ; // xmin of T0 reference histogram
- Float_t fXmaxQ; // xmax of T0 reference histogram
- Int_t fNbinsRMS; // Number of bins for T0 reference histogram
- Float_t fXminRMS; // xmin of T0 reference histogram
- Float_t fXmaxRMS; // xmax of T0 reference histogram
- Int_t fPeakDetMinus; // Consecutive timebins on rising edge to be regarded as a signal
- Int_t fPeakDetPlus; // Consecutive timebins on falling edge to be regarded as a signal
- Int_t fPeakIntMinus; // Peak integral range for COG determination. Bins used before max bin
- Int_t fPeakIntPlus; // Peak integral range for COG determination. Bins used after max bin
- Float_t fNoiseThresholdMax; // Analysis Treshold for signal finding: Max>fNoiseThresholdMax*PadNoise
- Float_t fNoiseThresholdSum; // Analysis Treshold for signal finding: Sum>fNoiseThresholdSum*PadNoise
-
- Bool_t fIsZeroSuppressed; // If data is Zero Suppressed -> Don't subtrakt pedestals!
-
- Int_t fLastSector; //! Last sector processed
-
- Float_t fSecRejectRatio; //! Needed percentage of signals in one chamber. Below it will be rejected
+ Int_t fNbinsT0; ///< Number of bins for T0 reference histogram
+ Float_t fXminT0; ///< xmin of T0 reference histogram
+ Float_t fXmaxT0; ///< xmax of T0 reference histogram
+ Int_t fNbinsQ; ///< Number of bins for T0 reference histogram
+ Float_t fXminQ; ///< xmin of T0 reference histogram
+ Float_t fXmaxQ; ///< xmax of T0 reference histogram
+ Int_t fNbinsRMS; ///< Number of bins for T0 reference histogram
+ Float_t fXminRMS; ///< xmin of T0 reference histogram
+ Float_t fXmaxRMS; ///< xmax of T0 reference histogram
+ Int_t fPeakDetMinus; ///< Consecutive timebins on rising edge to be regarded as a signal
+ Int_t fPeakDetPlus; ///< Consecutive timebins on falling edge to be regarded as a signal
+ Int_t fPeakIntMinus; ///< Peak integral range for COG determination. Bins used before max bin
+ Int_t fPeakIntPlus; ///< Peak integral range for COG determination. Bins used after max bin
+ Float_t fNoiseThresholdMax; ///< Analysis Treshold for signal finding: Max>fNoiseThresholdMax*PadNoise
+ Float_t fNoiseThresholdSum; ///< Analysis Treshold for signal finding: Sum>fNoiseThresholdSum*PadNoise
+
+ Bool_t fIsZeroSuppressed; ///< If data is Zero Suppressed -> Don't subtrakt pedestals!
+
+ Int_t fLastSector; //!< Last sector processed
+
+ Float_t fSecRejectRatio; //!< Needed percentage of signals in one chamber. Below it will be rejected
// This is neede if we do not process a laser event
-
- AliTPCParam *fParam; //! TPC information
-
- AliTPCCalPad *fPedestalTPC; //! Pedestal Information whole TPC
- AliTPCCalPad *fPadNoiseTPC; //! Pad noise Information whole TPC
- AliTPCCalROC *fPedestalROC; //! Pedestal Information for current ROC
- AliTPCCalROC *fPadNoiseROC; //! Pad noise Information for current ROC
-
- TObjArray fCalRocArrayT0; // Array of AliTPCCalROC class for Time0 calibration
- TObjArray fCalRocArrayT0Err; // Array of AliTPCCalROC class for the error (rms) of Time0 calibration
- TObjArray fCalRocArrayQ; // Array of AliTPCCalROC class for Charge calibration
- TObjArray fCalRocArrayRMS; // Array of AliTPCCalROC class for signal width calibration
- TObjArray fCalRocArrayOutliers; // Array of AliTPCCalROC class for signal outliers
-
- TObjArray fHistoQArray; // Calibration histograms for Charge distribution
- TObjArray fHistoT0Array; // Calibration histograms for Time0 distribution
- TObjArray fHistoRMSArray; // Calibration histograms for signal width distribution
-
- Float_t fMeanT0rms; // mean of the rms of all pad T0 fits, used as error estimation of T0 results
- Float_t fMeanQrms; // mean of the rms of all pad Q fits, used as error estimation of Q results
- Float_t fMeanRMSrms; // mean of the rms of all pad TMS fits, used as error estimation of RMS results
-
- TObjArray fHistoTmean; //! Calibration histograms of the mean CE position for all sectors
-
- TObjArray fParamArrayEventPol1; // Store mean arrival time parameters for each sector event by event from global plane fit
- TObjArray fParamArrayEventPol2; // Store mean arrival time parameters for each sector event by event from global parabola fit
- TObjArray fTMeanArrayEvent; // Store mean arrival time for each sector event by event
- TObjArray fQMeanArrayEvent; // Store mean arrival Charge for each sector event by event
- TVectorD fVEventTime; // Timestamps of the events
- TVectorD fVEventNumber; // Eventnumbers of the events
- TVectorF fVTime0SideA; // Mean Time0 for side A for all events
- TVectorF fVTime0SideC; // Mean Time0 for side C for all events
- Double_t fEventId; //! Event Id of the current event
- UInt_t fOldRunNumber; //! Old Run Number
-
- TObjArray fPadTimesArrayEvent; //! Pad Times for the event, before mean Time0 corrections
- TObjArray fPadQArrayEvent; //! Charge for the event, only needed for debugging streamer
- TObjArray fPadRMSArrayEvent; //! Signal width for the event, only needed for debugging streamer
- TObjArray fPadPedestalArrayEvent; //! Signal width for the event, only needed for debugging streamer
-
- Int_t fCurrentChannel; //! current channel processed
- Int_t fCurrentSector; //! current sector processed
- Int_t fCurrentRow; //! current row processed
- Float_t fMaxPadSignal; //! maximum bin of current pad
- Int_t fMaxTimeBin; //! time bin with maximum value
- Float_t fPadSignal[1024]; //! signal of current Pad
- Float_t fPadPedestal; //! Pedestal Value of current pad
- Float_t fPadNoise; //! Noise Value of current pad
-
- TVectorD fVTime0Offset; //! Time0 Offset for each sector;
- TVectorD fVTime0OffsetCounter; //! Time0 Offset counter for each sector;
- TVectorD fVMeanQ; //! Mean Q for each sector;
- TVectorD fVMeanQCounter; //! Mean Q counter for each sector;
-
- Float_t fCurrentCETimeRef; //! Time refernce of the current sector
-
+
+ AliTPCParam *fParam; //!< TPC information
+
+ AliTPCCalPad *fPedestalTPC; //!< Pedestal Information whole TPC
+ AliTPCCalPad *fPadNoiseTPC; //!< Pad noise Information whole TPC
+ AliTPCCalROC *fPedestalROC; //!< Pedestal Information for current ROC
+ AliTPCCalROC *fPadNoiseROC; //!< Pad noise Information for current ROC
+
+ TObjArray fCalRocArrayT0; ///< Array of AliTPCCalROC class for Time0 calibration
+ TObjArray fCalRocArrayT0Err; ///< Array of AliTPCCalROC class for the error (rms) of Time0 calibration
+ TObjArray fCalRocArrayQ; ///< Array of AliTPCCalROC class for Charge calibration
+ TObjArray fCalRocArrayRMS; ///< Array of AliTPCCalROC class for signal width calibration
+ TObjArray fCalRocArrayOutliers; ///< Array of AliTPCCalROC class for signal outliers
+
+ TObjArray fHistoQArray; ///< Calibration histograms for Charge distribution
+ TObjArray fHistoT0Array; ///< Calibration histograms for Time0 distribution
+ TObjArray fHistoRMSArray; ///< Calibration histograms for signal width distribution
+
+ Float_t fMeanT0rms; ///< mean of the rms of all pad T0 fits, used as error estimation of T0 results
+ Float_t fMeanQrms; ///< mean of the rms of all pad Q fits, used as error estimation of Q results
+ Float_t fMeanRMSrms; ///< mean of the rms of all pad TMS fits, used as error estimation of RMS results
+
+ TObjArray fHistoTmean; //!< Calibration histograms of the mean CE position for all sectors
+
+ TObjArray fParamArrayEventPol1; ///< Store mean arrival time parameters for each sector event by event from global plane fit
+ TObjArray fParamArrayEventPol2; ///< Store mean arrival time parameters for each sector event by event from global parabola fit
+ TObjArray fTMeanArrayEvent; ///< Store mean arrival time for each sector event by event
+ TObjArray fQMeanArrayEvent; ///< Store mean arrival Charge for each sector event by event
+ TVectorD fVEventTime; ///< Timestamps of the events
+ TVectorD fVEventNumber; ///< Eventnumbers of the events
+ TVectorF fVTime0SideA; ///< Mean Time0 for side A for all events
+ TVectorF fVTime0SideC; ///< Mean Time0 for side C for all events
+ Double_t fEventId; //!< Event Id of the current event
+ UInt_t fOldRunNumber; //!< Old Run Number
+
+ TObjArray fPadTimesArrayEvent; //!< Pad Times for the event, before mean Time0 corrections
+ TObjArray fPadQArrayEvent; //!< Charge for the event, only needed for debugging streamer
+ TObjArray fPadRMSArrayEvent; //!< Signal width for the event, only needed for debugging streamer
+ TObjArray fPadPedestalArrayEvent; //!< Signal width for the event, only needed for debugging streamer
+
+ Int_t fCurrentChannel; //!< current channel processed
+ Int_t fCurrentSector; //!< current sector processed
+ Int_t fCurrentRow; //!< current row processed
+ Float_t fMaxPadSignal; //!< maximum bin of current pad
+ Int_t fMaxTimeBin; //!< time bin with maximum value
+ Float_t fPadSignal[1024]; //!< signal of current Pad
+ Float_t fPadPedestal; //!< Pedestal Value of current pad
+ Float_t fPadNoise; //!< Noise Value of current pad
+
+ TVectorD fVTime0Offset; //!< Time0 Offset for each sector;
+ TVectorD fVTime0OffsetCounter; //!< Time0 Offset counter for each sector;
+ TVectorD fVMeanQ; //!< Mean Q for each sector;
+ TVectorD fVMeanQCounter; //!< Mean Q counter for each sector;
+
+ Float_t fCurrentCETimeRef; //!< Time refernce of the current sector
+
// new part of the algorithm
- Bool_t fProcessOld; // Whether to use the old algorithm
- Bool_t fProcessNew; // Whether to use the new algorithm
- Bool_t fAnalyseNew; //! Whether to analyse the new part of the algorithm.
+ Bool_t fProcessOld; ///< Whether to use the old algorithm
+ Bool_t fProcessNew; ///< Whether to use the new algorithm
+ Bool_t fAnalyseNew; //!< Whether to analyse the new part of the algorithm.
//In the DA this needs to be switched off, in the Preprocessor on...
enum {kHnBinsDV=5};
- THnSparseI *fHnDrift; //! Histogram digits for each pad and timebin for several timestamps
- TObjArray fArrHnDrift; // array of sparse histograms for each burst
- TVectorD fTimeBursts; // time stamps of bursts
- UInt_t fBinsLastAna[100]; // number of bin in the THnSparse during the last analysis
- UShort_t fPeaks[14]; //! Peak position: 4 laser layers and CE
- UShort_t fPeakWidths[14]; //! Peak window widths
- TObjArray *fArrFitGraphs; // Fit resut graphs for each parameter
- UInt_t fEventInBunch; //! event in current bunch
-
-
+ THnSparseI *fHnDrift; //!< Histogram digits for each pad and timebin for several timestamps
+ TObjArray fArrHnDrift; ///< array of sparse histograms for each burst
+ TVectorD fTimeBursts; ///< time stamps of bursts
+ UInt_t fBinsLastAna[100]; ///< number of bin in the THnSparse during the last analysis
+ UShort_t fPeaks[14]; //!< Peak position: 4 laser layers and CE
+ UShort_t fPeakWidths[14]; //!< Peak window widths
+ TObjArray *fArrFitGraphs; ///< Fit resut graphs for each parameter
+ UInt_t fEventInBunch; //!< event in current bunch
+
+
//
void FindPedestal(Float_t part=.6);
void UpdateCETimeRef(); //Get the time reference of the last valid measurement in sector
void FindCESignal(TVectorD ¶m, Float_t &qSum, const TVectorF maxima);
void FindLocalMaxima(TVectorF &maxima);
Bool_t IsPeak(Int_t pos, Int_t tminus, Int_t tplus) const;
-
+
TH2S* GetHisto(Int_t sector, TObjArray *arr,
Int_t nbinsY, Float_t ymin, Float_t ymax,
const Char_t *type, Bool_t force);
TH1S* GetHisto(Int_t sector, TObjArray *arr,
const Char_t *type, Bool_t force);
-
+
AliTPCCalROC* GetCalRoc(Int_t sector, TObjArray* arr, Bool_t force) const;
-
+
TVectorF* GetVectSector(Int_t sector, TObjArray *arr, UInt_t size, Bool_t force=kFALSE) const;
TVectorF* GetPadTimesEvent(Int_t sector, Bool_t force=kFALSE);
-
+
TObjArray* GetParamArray(Int_t sector, TObjArray *arr, Bool_t force=kFALSE) const;
-
+
void ResetPad();
void ProcessPad();
// new part of the algorithm
void CreateDVhist();
-
+
void FindLaserLayers();
Bool_t IsPeakInRange(UShort_t timebin, Int_t roc) const;
TObjArray *SetupMeasured();
void ResetMeasured(TObjArray * const arr);
-
+
void AddCEtoIdeal(TObjArray *arr);
void CalculateDV(TObjArray * const arrIdeal, TObjArray * const arrMeasured, Int_t burst);
TVectorF* GetPadQEvent(Int_t sector, Bool_t force=kFALSE);
TVectorF* GetPadRMSEvent(Int_t sector, Bool_t force=kFALSE);
TVectorF* GetPadPedestalEvent(Int_t sector, Bool_t force=kFALSE);
-
+
+ /// \cond CLASSIMP
ClassDef(AliTPCCalibCE,10) //Implementation of the TPC Central Electrode calibration
+ /// \endcond
};
//Inline functions
//_____________________________________________________________________
inline Bool_t AliTPCCalibCE::IsPeakInRange(UShort_t timebin, Int_t roc) const
{
- //
- // Check whether timebin is in the range of a laser layer
- //
+ /// Check whether timebin is in the range of a laser layer
+
Int_t side=(roc/18)%2;
Int_t add=7*side;
// return kTRUE;
**************************************************************************/
-////////////////////////////////////////////////////////////////////////////
-// //
-// AliTPCCalibGlobalMisalignment class //
-// The class calculates the space point distortions due to simple //
-// misalignments like shifts in caresian coordinates or a rotation //
-// of the TPC read out planes (A and C side) //
-// Optionaly possible to use it for visualization of the alignemnt form the Alignment OCDB //
-// fUseGeoManager has to be set to kTRUE to enable this option
-// //
-// date: 06/05/2010 //
-// Authors: Stefan Rossegger, Jim Thomas, Magnus Mager //
-////////////////////////////////////////////////////////////////////////////
+/// \class AliTPCCalibGlobalMisalignment
+///
+/// AliTPCCalibGlobalMisalignment class
+/// The class calculates the space point distortions due to simple
+/// misalignments like shifts in caresian coordinates or a rotation
+/// of the TPC read out planes (A and C side)
+/// Optionaly possible to use it for visualization of the alignemnt form the Alignment OCDB
+/// fUseGeoManager has to be set to kTRUE to enable this option
+///
+/// \author Stefan Rossegger, Jim Thomas, Magnus Mager
+/// \date 06/05/2010
#include "AliTPCCalibGlobalMisalignment.h"
#include "TMath.h"
fMatrixGlobalDelta(0), // global Alignment Delta A side-c side
fArraySector(0) // fArraySector
{
- //
- // default constructor
- //
+ /// default constructor
+
}
AliTPCCalibGlobalMisalignment::~AliTPCCalibGlobalMisalignment() {
- //
- // destructor
- //
+ /// destructor
+
delete fQuadrantQ0; //OROC medium pads -delta ly+ - ly - shift
delete fQuadrantRQ0; //OROC medium pads -delta ly+ - ly - rotation
delete fQuadrantQ1; //OROC long pads -delta ly+ - ly - shift
Bool_t AliTPCCalibGlobalMisalignment::AddCorrectionCompact(AliTPCCorrection* corr, Double_t weight){
- //
- // Add correction and make them compact
- // Assumptions:
- // - origin of distortion/correction are additive
- // - only correction ot the same type supported ()
+ /// Add correction and make them compact
+ /// Assumptions:
+ /// - origin of distortion/correction are additive
+ /// - only correction ot the same type supported ()
+
if (corr==NULL) {
//AliError("Zerro pointer - correction");
return kFALSE;
void AliTPCCalibGlobalMisalignment::SetQuadranAlign(const TVectorD *quadrantQ0, const TVectorD *quadrantRQ0, const TVectorD *quadrantQ1,const TVectorD *quadrantRQ1, const TVectorD *quadrantQ2, const TVectorD *quadrantRQ2){
- //
- // Set quadrant alignment
- // 6 vectors for 36 (super) sectors
- //
+ /// Set quadrant alignment
+ /// 6 vectors for 36 (super) sectors
+
if (quadrantQ0) fQuadrantQ0 = new TVectorD(*quadrantQ0);
if (quadrantRQ0) fQuadrantRQ0 = new TVectorD(*quadrantRQ0);
//
void AliTPCCalibGlobalMisalignment::SetAlignGlobal(const TGeoMatrix * matrixGlobal){
- //
- // Set global misalignment
- // Object is OWNER
- //
+ /// Set global misalignment
+ /// Object is OWNER
+
if (fMatrixGlobal) delete fMatrixGlobal;
fMatrixGlobal=0;
if (matrixGlobal) fMatrixGlobal = new TGeoHMatrix(*matrixGlobal);
}
void AliTPCCalibGlobalMisalignment::SetAlignGlobalDelta(const TGeoMatrix * matrixGlobalDelta){
- //
- // Set global misalignment
- // Object is OWNER
- //
+ /// Set global misalignment
+ /// Object is OWNER
+
if (fMatrixGlobalDelta) delete fMatrixGlobalDelta;
fMatrixGlobalDelta=0;
if (matrixGlobalDelta) fMatrixGlobalDelta = new TGeoHMatrix(*matrixGlobalDelta);
}
void AliTPCCalibGlobalMisalignment::SetAlignSectors(const TObjArray *arraySector){
- //
- // Set misalignment TObjArray of TGeoMatrices - for each sector
- // Object is OWNER
- //
+ /// Set misalignment TObjArray of TGeoMatrices - for each sector
+ /// Object is OWNER
+
if (fArraySector) delete fArraySector;
fArraySector=0;
if (arraySector) fArraySector = (TObjArray*)arraySector->Clone();
void AliTPCCalibGlobalMisalignment::GetCorrection(const Float_t x[],const Short_t roc,Float_t dx[]) {
- //
- // Calculates the simple correction due to a shift (in x,y,z) or an rotation of the TPC (around z)
- //
+ /// Calculates the simple correction due to a shift (in x,y,z) or an rotation of the TPC (around z)
+
static AliTPCROC *tpcRoc =AliTPCROC::Instance();
Double_t xref = ( tpcRoc->GetPadRowRadii(0,0)+tpcRoc->GetPadRowRadii(36,tpcRoc->GetNRows(36)-1))*0.5;
Double_t xquadrant = tpcRoc->GetPadRowRadii(36,53); // row 53 from uli
}
void AliTPCCalibGlobalMisalignment::Print(Option_t* option ) const{
- //
- // Print function to check the settings
- //
+ /// Print function to check the settings
+
printf("%s",GetTitle());
printf(" - Trivial Misalignments for calibration purposes: \n");
printf(" - X-Shift: %1.3f cm, Y-Shift: %1.3f cm, Z-Shift: %1.3f cm \n",fXShift,fYShift,fZShift);
}
void AliTPCCalibGlobalMisalignment::AddAlign(const AliTPCCalibGlobalMisalignment & add){
- //
- // Add the alignmnet to current object
- //
+ /// Add the alignmnet to current object
+
fXShift+=add.fXShift; // Shift in global X [cm]
fYShift+=add.fYShift; // Shift in global Y [cm]
fZShift+=add.fZShift; // Shift in global Z [cm]
AliTPCCalibGlobalMisalignment * AliTPCCalibGlobalMisalignment::CreateOCDBAlign(){
- //
- // Create AliTPCCalibGlobalMisalignment from OCDB Alignment entry
- // OCDB has to be initialized before in user code
- // All storages (defualt and specific) and run number
- //
+ /// Create AliTPCCalibGlobalMisalignment from OCDB Alignment entry
+ /// OCDB has to be initialized before in user code
+ /// All storages (defualt and specific) and run number
+
AliCDBEntry * entry = AliCDBManager::Instance()->Get("TPC/Align/Data");
if (!entry){
printf("Missing alignmnet entry. OCDB not initialized?\n");
AliTPCCalibGlobalMisalignment * AliTPCCalibGlobalMisalignment::CreateMeanAlign(const AliTPCCalibGlobalMisalignment *alignIn){
- //
- // Create new object, disantangle common mean alignmnet and sector alignment
- //
- // 1. Try to get mean alignment
- // 2. Remove mean alignment from sector alignment
- // 3. Create new object
- //
+ /// Create new object, disantangle common mean alignmnet and sector alignment
+ ///
+ /// 1. Try to get mean alignment
+ /// 2. Remove mean alignment from sector alignment
+ /// 3. Create new object
+
TObjArray * array = alignIn->GetAlignSectors();
TObjArray * arrayNew = new TObjArray(72);
//
void AliTPCCalibGlobalMisalignment::DumpAlignment( AliTPCCalibGlobalMisalignment* align, TTreeSRedirector *pcstream, const char *name){
- //
- // Dump alignment per sector into tree
- //
+ /// Dump alignment per sector into tree
+
TObjArray * array = align->GetAlignSectors();
if (!array) return;
//
/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
* See cxx source for full Copyright notice */
-////////////////////////////////////////////////////////////////////////////
-// //
-// AliTPCCalibGlobalMisalignment class //
-// The class calculates the space point distortions due to simple //
-// misalignments like shifts in caresian coordinates or a rotation //
-// of the TPC read out planes (A and C side) //
-// //
-// date: 06/05/2010 //
-// Authors: Stefan Rossegger, Jim Thomas, Magnus Mager //
-////////////////////////////////////////////////////////////////////////////
+/// \class AliTPCCalibGlobalMisalignment
+///
+/// AliTPCCalibGlobalMisalignment class
+/// The class calculates the space point distortions due to simple
+/// misalignments like shifts in caresian coordinates or a rotation
+/// of the TPC read out planes (A and C side)
+///
+/// \author Stefan Rossegger, Jim Thomas, Magnus Mager
+/// \date 06/05/2010
#include "AliTPCCorrection.h"
#include "TVectorD.h"
virtual void GetCorrection(const Float_t x[],const Short_t roc,Float_t dx[]);
private:
- Float_t fXShift; // Shift in global X [cm]
- Float_t fYShift; // Shift in global Y [cm]
- Float_t fZShift; // Shift in global Z [cm]
+ Float_t fXShift; ///< Shift in global X [cm]
+ Float_t fYShift; ///< Shift in global Y [cm]
+ Float_t fZShift; ///< Shift in global Z [cm]
- Float_t fRotPhiA; // simple rotation of A side read-out plane around the Z axis [rad]
- Float_t fRotPhiC; // simple rotation of C side read-out plane around the Z axis [rad]
- Float_t fdRPhiOffsetA; // add a constant offset of dRPhi (or local Y) in [cm]: purely for calibration purposes!
- Float_t fdRPhiOffsetC; // add a constant offset of dRPhi (or local Y) in [cm]: purely for calibration purposes!
+ Float_t fRotPhiA; ///< simple rotation of A side read-out plane around the Z axis [rad]
+ Float_t fRotPhiC; ///< simple rotation of C side read-out plane around the Z axis [rad]
+ Float_t fdRPhiOffsetA; ///< add a constant offset of dRPhi (or local Y) in [cm]: purely for calibration purposes!
+ Float_t fdRPhiOffsetC; ///< add a constant offset of dRPhi (or local Y) in [cm]: purely for calibration purposes!
//
// Quadrant alignment
//
- TVectorD *fQuadrantQ0; //OROC medium pads -delta ly+ - ly - shift (cm)
- TVectorD *fQuadrantRQ0; //OROC medium pads -delta ly+ - ly - rotation (rad)
- TVectorD *fQuadrantQ1; //OROC long pads -delta ly+ - ly - shift
- TVectorD *fQuadrantQ2; //OROC long pads -shift
- TVectorD *fQuadrantRQ1; //OROC long pads -delta ly+ - ly - rotation
- TVectorD *fQuadrantRQ2; //OROC long pads -rotation
+ TVectorD *fQuadrantQ0; ///< OROC medium pads -delta ly+ - ly - shift (cm)
+ TVectorD *fQuadrantRQ0; ///< OROC medium pads -delta ly+ - ly - rotation (rad)
+ TVectorD *fQuadrantQ1; ///< OROC long pads -delta ly+ - ly - shift
+ TVectorD *fQuadrantQ2; ///< OROC long pads -shift
+ TVectorD *fQuadrantRQ1; ///< OROC long pads -delta ly+ - ly - rotation
+ TVectorD *fQuadrantRQ2; ///< OROC long pads -rotation
//
//
// Global alignment - use native ROOT representation
//
- TGeoMatrix * fMatrixGlobal; // global Alignment common
- TGeoMatrix * fMatrixGlobalDelta; // global Alignment common A side-C side
- TObjArray * fArraySector; // local Alignmnet Sector
+ TGeoMatrix * fMatrixGlobal; ///< global Alignment common
+ TGeoMatrix * fMatrixGlobalDelta; ///< global Alignment common A side-C side
+ TObjArray * fArraySector; ///< local Alignmnet Sector
//
AliTPCCalibGlobalMisalignment& operator=(const AliTPCCalibGlobalMisalignment&);
AliTPCCalibGlobalMisalignment(const AliTPCCalibGlobalMisalignment&);
+ /// \cond CLASSIMP
ClassDef(AliTPCCalibGlobalMisalignment,3);
+ /// \endcond
};
#endif
* provided "as is" without express or implied warranty. *
**************************************************************************/
+/// \class AliTPCCalibPedestal
-/* $Id$ */
-
-
-//Root includes
+// Root includes
#include <TH1F.h>
#include <TH2F.h>
#include <TString.h>
//
+/// \cond CLASSIMP
ClassImp(AliTPCCalibPedestal)
+/// \endcond
AliTPCCalibPedestal::AliTPCCalibPedestal() :
AliTPCCalibRawBase(),
fCalRocArrayMean(72),
fCalRocArrayRMS(72)
{
- //
- // copy constructor
- //
+ /// copy constructor
+
for (Int_t iSec = 0; iSec < 72; ++iSec){
const AliTPCCalROC *calPed = (AliTPCCalROC*)ped.fCalRocArrayPedestal.UncheckedAt(iSec);
const AliTPCCalROC *calRMS = (AliTPCCalROC*)ped.fCalRocArrayRMS.UncheckedAt(iSec);
fCalRocArrayMean(72),
fCalRocArrayRMS(72)
{
- //
- // This constructor uses a TMap for setting some parametes
- //
+ /// This constructor uses a TMap for setting some parametes
+
SetNameTitle("AliTPCCalibPedestal","AliTPCCalibPedestal");
fFirstTimeBin=60;
fLastTimeBin=1000;
//_____________________________________________________________________
AliTPCCalibPedestal& AliTPCCalibPedestal::operator = (const AliTPCCalibPedestal &source)
{
- //
- // assignment operator
- //
+ /// assignment operator
+
if (&source == this) return *this;
new (this) AliTPCCalibPedestal(source);
//_____________________________________________________________________
AliTPCCalibPedestal::~AliTPCCalibPedestal()
{
- //
- // destructor
- //
+ /// destructor
fCalRocArrayPedestal.Delete();
fCalRocArrayRMS.Delete();
//_____________________________________________________________________
void AliTPCCalibPedestal::SetTimeAnalysis(Bool_t time)
{
- //
- // Use time dependent analysis: Pedestals are analysed as a function
- // of the drift time. There is one mean value generated for each time
- // bin and each channel. It can be used as reference data and for
- // configuration of the ALTRO pattern memory for baseline subtraction.
- //
- // ATTENTION: Use only on LDC in TPCPEDESTALda! On a LDC we get data
- // only from one sector. For the full TPC we would need a lot of
- // memory (36*159*140*1024*4bytes = 3.3GB)!
- //
+ /// Use time dependent analysis: Pedestals are analysed as a function
+ /// of the drift time. There is one mean value generated for each time
+ /// bin and each channel. It can be used as reference data and for
+ /// configuration of the ALTRO pattern memory for baseline subtraction.
+ ///
+ /// ATTENTION: Use only on LDC in TPCPEDESTALda! On a LDC we get data
+ /// only from one sector. For the full TPC we would need a lot of
+ /// memory (36*159*140*1024*4bytes = 3.3GB)!
fTimeAnalysis = time;
const Int_t icTimeBin,
const Float_t csignal)
{
- //
- // Signal filling method
- //
+ /// Signal filling method
+
if (icRow<0) return 0;
if (icPad<0) return 0;
if (icTimeBin<0) return 0;
//_____________________________________________________________________
Bool_t AliTPCCalibPedestal::TestEvent()
{
- //
- // Test event loop
- // fill one oroc and one iroc with random gaus
- //
+ /// Test event loop
+ /// fill one oroc and one iroc with random gaus
gRandom->SetSeed(0);
Int_t nbinsY, Float_t ymin, Float_t ymax,
const Char_t *type, Bool_t force)
{
- //
- // return pointer to Q histogram
- // if force is true create a new histogram if it doesn't exist allready
- //
+ /// return pointer to Q histogram
+ /// if force is true create a new histogram if it doesn't exist allready
+
if ( !force || arr->UncheckedAt(sector) )
return (TH2F*)arr->UncheckedAt(sector);
//_____________________________________________________________________
TH2F* AliTPCCalibPedestal::GetHistoPedestal(Int_t sector, Bool_t force)
{
- //
- // return pointer to T0 histogram
- // if force is true create a new histogram if it doesn't exist allready
- //
+ /// return pointer to T0 histogram
+ /// if force is true create a new histogram if it doesn't exist allready
+
TObjArray *arr = &fHistoPedestalArray;
return GetHisto(sector, arr, fAdcMax-fAdcMin, fAdcMin, fAdcMax, "Pedestal", force);
}
//_____________________________________________________________________
AliTPCCalROC* AliTPCCalibPedestal::GetCalRoc(Int_t sector, TObjArray* arr, Bool_t force)
{
- //
- // return pointer to ROC Calibration
- // if force is true create a new histogram if it doesn't exist allready
- //
+ /// return pointer to ROC Calibration
+ /// if force is true create a new histogram if it doesn't exist allready
+
if ( !force || arr->UncheckedAt(sector) )
return (AliTPCCalROC*)arr->UncheckedAt(sector);
//_____________________________________________________________________
AliTPCCalROC* AliTPCCalibPedestal::GetCalRocPedestal(Int_t sector, Bool_t force)
{
- //
- // return pointer to ROC with Pedestal data
- // if force is true create a new histogram if it doesn't exist allready
- //
+ /// return pointer to ROC with Pedestal data
+ /// if force is true create a new histogram if it doesn't exist allready
+
TObjArray *arr = &fCalRocArrayPedestal;
return GetCalRoc(sector, arr, force);
}
//_____________________________________________________________________
AliTPCCalROC* AliTPCCalibPedestal::GetCalRocSigma(Int_t sector, Bool_t force)
{
- //
- // return pointer to ROC with signal witdth in sigma
- // if force is true create a new histogram if it doesn't exist allready
- //
+ /// return pointer to ROC with signal witdth in sigma
+ /// if force is true create a new histogram if it doesn't exist allready
+
TObjArray *arr = &fCalRocArraySigma;
return GetCalRoc(sector, arr, force);
}
//_____________________________________________________________________
AliTPCCalROC* AliTPCCalibPedestal::GetCalRocMean(Int_t sector, Bool_t force)
{
- //
- // return pointer to ROC with signal mean information
- // if force is true create a new histogram if it doesn't exist allready
- //
+ /// return pointer to ROC with signal mean information
+ /// if force is true create a new histogram if it doesn't exist allready
+
TObjArray *arr = &fCalRocArrayMean;
return GetCalRoc(sector, arr, force);
}
//_____________________________________________________________________
AliTPCCalROC* AliTPCCalibPedestal::GetCalRocRMS(Int_t sector, Bool_t force)
{
- //
- // return pointer to signal width ROC Calibration
- // if force is true create a new histogram if it doesn't exist allready
- //
+ /// return pointer to signal width ROC Calibration
+ /// if force is true create a new histogram if it doesn't exist allready
+
TObjArray *arr = &fCalRocArrayRMS;
return GetCalRoc(sector, arr, force);
}
//_____________________________________________________________________
void AliTPCCalibPedestal::Merge(AliTPCCalibPedestal * const ped)
{
- //
- // Merge reference histograms of sig to the current AliTPCCalibPedestal
- //
+ /// Merge reference histograms of sig to the current AliTPCCalibPedestal
+
MergeBase(ped);
// merge histograms
for (Int_t iSec=0; iSec<72; ++iSec){
//_____________________________________________________________________
Long64_t AliTPCCalibPedestal::Merge(TCollection * const list)
{
- //
- // Merge all objects of this type in list
- //
-
+ /// Merge all objects of this type in list
+
Long64_t nmerged=1;
TIter next(list);
//_____________________________________________________________________
void AliTPCCalibPedestal::Analyse()
{
- //
- // Calculate calibration constants
- //
+ /// Calculate calibration constants
Int_t nbinsAdc = fAdcMax-fAdcMin;
//_____________________________________________________________________
void AliTPCCalibPedestal::AnalyseTime(Int_t nevents)
{
- //
- // Calculate for each channel and time bin the mean pedestal. This
- // is used on LDC by TPCPEDESTALda to generate data used for configuration
- // of the pattern memory for baseline subtraction in the ALTROs.
- //
+ /// Calculate for each channel and time bin the mean pedestal. This
+ /// is used on LDC by TPCPEDESTALda to generate data used for configuration
+ /// of the pattern memory for baseline subtraction in the ALTROs.
if ( nevents <= 0 ) return;
if ( fTimeAnalysis ) {
/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
* See cxx source for full Copyright notice */
-/////////////////////////////////////////////////////////////////////////////////////////
-// //
-// Implementation of the TPC pedestal calibration //
-// //
-/////////////////////////////////////////////////////////////////////////////////////////
+/// \class AliTPCCalibPedestal
+/// \brief Implementation of the TPC pedestal calibration
#include <TObjArray.h>
#include "AliTPCCalibRawBase.h"
AliTPCCalROC* GetCalRocRMS(Int_t sector, Bool_t force=kFALSE); // get calibration object - sector
const TObjArray* GetCalPadMean() const {return &fCalRocArrayMean;} // get calibration object
const TObjArray* GetCalPadRMS() const {return &fCalRocArrayRMS;} // get calibration object
-
+
TH2F* GetHistoPedestal (Int_t sector, Bool_t force=kFALSE); // get refernce histogram
//
void SetTimeAnalysis(Bool_t time = kTRUE); // Use ONLY in TPCPEDESTALda on LDC for one sector!
Int_t GetAdcMax() const { return fAdcMax; }
Float_t GetAnaMeanDown() const { return fAnaMeanDown; }
Float_t GetAnaMeanUp() const { return fAnaMeanUp; }
-
+
void SetRangeAdc (Int_t aMin, Int_t aMax){ fAdcMin=aMin; fAdcMax=aMax; } // Set adc range for the pedestal calibration
void SetAnalysisTruncationRange(Float_t down, Float_t up) {fAnaMeanDown=down; fAnaMeanUp=up;} //Set range for truncated mean analysis of the channel information
void Merge(AliTPCCalibPedestal * const ped);
virtual Long64_t Merge(TCollection * const list);
-
+
Bool_t TestEvent(); // Test the fast approach to fill histogram - used for test purposes
private:
- Int_t fAdcMin; // min adc channel of pedestal value
- Int_t fAdcMax; // max adc channel of pedestal value
+ Int_t fAdcMin; ///< min adc channel of pedestal value
+ Int_t fAdcMax; ///< max adc channel of pedestal value
+
+ Float_t fAnaMeanDown; ///< Truncated mean channel analysis - lower cut
+ Float_t fAnaMeanUp; ///< Truncated mean channel analysis - upper cut
+
+ Bool_t fTimeAnalysis; //!< Should we use the time dependent analysis? ONLY ON LDC!
- Float_t fAnaMeanDown; // Truncated mean channel analysis - lower cut
- Float_t fAnaMeanUp; // Truncated mean channel analysis - upper cut
-
- Bool_t fTimeAnalysis; //! Should we use the time dependent analysis? ONLY ON LDC!
+ TObjArray fCalRocArrayPedestal; ///< Array of AliTPCCalROC class for pedestal values from gaus fit
+ TObjArray fCalRocArraySigma; ///< Array of AliTPCCalROC class for noise values from gaus fit
- TObjArray fCalRocArrayPedestal; // Array of AliTPCCalROC class for pedestal values from gaus fit
- TObjArray fCalRocArraySigma; // Array of AliTPCCalROC class for noise values from gaus fit
+ TObjArray fHistoPedestalArray; ///< Calibration histograms for Pedestal distribution
- TObjArray fHistoPedestalArray; // Calibration histograms for Pedestal distribution
+ TArrayF **fTimeSignal; //!< Arrays which hold time dependent signals
- TArrayF **fTimeSignal; //! Arrays which hold time dependent signals
-
- TObjArray fCalRocArrayMean; // Array of AliTPCCalROC class for pedestal values, simple mean
- TObjArray fCalRocArrayRMS; // Array of AliTPCCalROC class for noise values, simple rms
+ TObjArray fCalRocArrayMean; ///< Array of AliTPCCalROC class for pedestal values, simple mean
+ TObjArray fCalRocArrayRMS; ///< Array of AliTPCCalROC class for noise values, simple rms
TH2F* GetHisto(Int_t sector, TObjArray *arr,
Int_t nbinsY, Float_t ymin, Float_t ymax,
* provided "as is" without express or implied warranty. *
**************************************************************************/
-/* $Id$ */
-
-/////////////////////////////////////////////////////////////////////////////////////////
-// //
-// Implementation of the TPC pulser calibration //
-// //
-// Origin: Jens Wiechula, Marian Ivanov J.Wiechula@gsi.de, Marian.Ivanov@cern.ch //
-// //
-/////////////////////////////////////////////////////////////////////////////////////////
-/***************************************************************************
- * Class Description *
- ***************************************************************************
-
- The AliTPCCalibPulser class is used to get calibration data concerning the FEE using
- runs performed with the calibration pulser.
-
- The information retrieved is
- - Time0 differences
- - Signal width differences
- - Amplification variations
-
- the seen differences arise from the manufacturing tolerances of the PASAs and are very small within
- one chip and somewhat large between different chips.
-
- Histograms:
- For each ROC three TH2S histos 'Reference Histograms' (ROC channel vs. [Time0, signal width, Q sum]) is created when
- it is filled for the first time (GetHisto[T0,RMS,Q](ROC,kTRUE)). The histos are stored in the
- TObjArrays fHistoT0Array, fHistoRMSArray and fHistoQArray.
-
-
- Working principle:
- ------------------
- Raw calibration pulser data is processed by calling one of the ProcessEvent(...) functions
- (see below). These in the end call the Update(...) function.
-
- - the Update(...) function:
- In this function the array fPadSignal is filled with the adc signals between the specified range
- fFirstTimeBin and fLastTimeBin for the current pad.
- before going to the next pad the ProcessPad() function is called, which analyses the data for one pad
- stored in fPadSignal.
-
- - the ProcessPad() function:
- Find Pedestal and Noise information
- - use database information which has to be set by calling
- SetPedestalDatabase(AliTPCCalPad *pedestalTPC, AliTPCCalPad *padNoiseTPC)
- - if no information from the pedestal data base
- is available the informaion is calculated on the fly ( see FindPedestal() function )
-
- Find the Pulser signal information
- - calculate mean = T0, RMS = signal width and Q sum in a range of -2+7 timebins around Q max
- the Q sum is scaled by pad area
- (see FindPulserSignal(...) function)
-
- Fill a temprary array for the T0 information (GetPadTimesEvent(fCurrentSector,kTRUE)) (why see below)
- Fill the Q sum and RMS values in the histograms (GetHisto[RMS,Q](ROC,kTRUE)),
-
- At the end of each event the EndEvent() function is called
-
- - the EndEvent() function:
- calculate the mean T0 for each ROC and fill the Time0 histogram with Time0-<Time0 for ROC>
- This is done to overcome syncronisation problems between the trigger and the fec clock.
-
- After accumulating the desired statistics the Analyse() function has to be called.
- - the Analyse() function
- Whithin this function the mean values of T0, RMS, Q are calculated for each pad, using
- the AliMathBase::GetCOG(...) function, and the calibration
- storage classes (AliTPCCalROC) are filled for each ROC.
- The calibration information is stored in the TObjArrays fCalRocArrayT0, fCalRocArrayRMS and
- fCalRocArrayQ;
-
-
-
- User interface for filling data:
- --------------------------------
-
- To Fill information one of the following functions can be used:
-
- Bool_t ProcessEvent(eventHeaderStruct *event);
- - process Date event
- - use AliTPCRawReaderDate and call ProcessEvent(AliRawReader *rawReader)
-
- Bool_t ProcessEvent(AliRawReader *rawReader);
- - process AliRawReader event
- - use AliTPCRawStreamV3 to loop over data and call ProcessEvent(AliTPCRawStreamV3 *rawStream)
-
- Bool_t ProcessEvent(AliTPCRawStreamV3 *rawStream);
- - process event from AliTPCRawStreamV3
- - call Update function for signal filling
-
- Int_t Update(const Int_t isector, const Int_t iRow, const Int_t
- iPad, const Int_t iTimeBin, const Float_t signal);
- - directly fill signal information (sector, row, pad, time bin, pad)
- to the reference histograms
-
- It is also possible to merge two independently taken calibrations using the function
-
- void Merge(AliTPCCalibPulser *sig)
- - copy histograms in 'sig' if the do not exist in this instance
- - Add histograms in 'sig' to the histograms in this instance if the allready exist
- - After merging call Analyse again!
-
-
-
- -- example: filling data using root raw data:
- void fillSignal(Char_t *filename)
- {
- rawReader = new AliRawReaderRoot(fileName);
- if ( !rawReader ) return;
- AliTPCCalibPulser *calib = new AliTPCCalibPulser;
- while (rawReader->NextEvent()){
- calib->ProcessEvent(rawReader);
- }
- calib->Analyse();
- calib->DumpToFile("SignalData.root");
- delete rawReader;
- delete calib;
- }
-
-
- What kind of information is stored and how to retrieve them:
- ------------------------------------------------------------
-
- - Accessing the 'Reference Histograms' (Time0, signal width and Q sum information pad by pad):
-
- TH2F *GetHistoT0(Int_t sector);
- TH2F *GetHistoRMS(Int_t sector);
- TH2F *GetHistoQ(Int_t sector);
-
- - Accessing the calibration storage objects:
-
- AliTPCCalROC *GetCalRocT0(Int_t sector); // for the Time0 values
- AliTPCCalROC *GetCalRocRMS(Int_t sector); // for the signal width values
- AliTPCCalROC *GetCalRocQ(Int_t sector); // for the Q sum values
-
- example for visualisation:
- if the file "SignalData.root" was created using the above example one could do the following:
-
- TFile fileSignal("SignalData.root")
- AliTPCCalibPulser *sig = (AliTPCCalibPulser*)fileSignal->Get("AliTPCCalibPulser");
- sig->GetCalRocT0(0)->Draw("colz");
- sig->GetCalRocRMS(0)->Draw("colz");
-
- or use the AliTPCCalPad functionality:
- AliTPCCalPad padT0(ped->GetCalPadT0());
- AliTPCCalPad padSigWidth(ped->GetCalPadRMS());
- padT0->MakeHisto2D()->Draw("colz"); //Draw A-Side Time0 Information
- padSigWidth->MakeHisto2D()->Draw("colz"); //Draw A-Side signal width Information
-*/
-
+/// \class AliTPCCalibPulser
+/// \brief Implementation of the TPC pulser calibration
+///
+/// \author Jens Wiechula, Marian Ivanov J.Wiechula@gsi.de, Marian.Ivanov@cern.ch
+///
+/// Class Description
+/// -----------------
+///
+/// The AliTPCCalibPulser class is used to get calibration data concerning the FEE using
+/// runs performed with the calibration pulser.
+///
+/// The information retrieved is
+/// - Time0 differences
+/// - Signal width differences
+/// - Amplification variations
+///
+/// the seen differences arise from the manufacturing tolerances of the PASAs and are very small within
+/// one chip and somewhat large between different chips.
+///
+/// Histograms:
+/// For each ROC three TH2S histos 'Reference Histograms' (ROC channel vs. [Time0, signal width, Q sum]) is created when
+/// it is filled for the first time (GetHisto[T0,RMS,Q](ROC,kTRUE)). The histos are stored in the
+/// TObjArrays fHistoT0Array, fHistoRMSArray and fHistoQArray.
+///
+///
+/// Working principle:
+/// ------------------
+/// Raw calibration pulser data is processed by calling one of the ProcessEvent(...) functions
+/// (see below). These in the end call the Update(...) function.
+///
+/// - the Update(...) function:
+/// In this function the array fPadSignal is filled with the adc signals between the specified range
+/// fFirstTimeBin and fLastTimeBin for the current pad.
+/// before going to the next pad the ProcessPad() function is called, which analyses the data for one pad
+/// stored in fPadSignal.
+///
+/// - the ProcessPad() function:
+/// Find Pedestal and Noise information
+/// - use database information which has to be set by calling
+/// SetPedestalDatabase(AliTPCCalPad *pedestalTPC, AliTPCCalPad *padNoiseTPC)
+/// - if no information from the pedestal data base
+/// is available the informaion is calculated on the fly ( see FindPedestal() function )
+///
+/// Find the Pulser signal information
+/// - calculate mean = T0, RMS = signal width and Q sum in a range of -2+7 timebins around Q max
+/// the Q sum is scaled by pad area
+/// (see FindPulserSignal(...) function)
+///
+/// Fill a temprary array for the T0 information (GetPadTimesEvent(fCurrentSector,kTRUE)) (why see below)
+/// Fill the Q sum and RMS values in the histograms (GetHisto[RMS,Q](ROC,kTRUE)),
+///
+/// At the end of each event the EndEvent() function is called
+///
+/// - the EndEvent() function:
+/// calculate the mean T0 for each ROC and fill the Time0 histogram with Time0-<Time0 for ROC>
+/// This is done to overcome syncronisation problems between the trigger and the fec clock.
+///
+/// After accumulating the desired statistics the Analyse() function has to be called.
+/// - the Analyse() function
+/// Whithin this function the mean values of T0, RMS, Q are calculated for each pad, using
+/// the AliMathBase::GetCOG(...) function, and the calibration
+/// storage classes (AliTPCCalROC) are filled for each ROC.
+/// The calibration information is stored in the TObjArrays fCalRocArrayT0, fCalRocArrayRMS and
+/// fCalRocArrayQ;
+///
+///
+///
+/// User interface for filling data:
+/// --------------------------------
+///
+/// To Fill information one of the following functions can be used:
+///
+/// Bool_t ProcessEvent(eventHeaderStruct *event);
+/// - process Date event
+/// - use AliTPCRawReaderDate and call ProcessEvent(AliRawReader *rawReader)
+///
+/// Bool_t ProcessEvent(AliRawReader *rawReader);
+/// - process AliRawReader event
+/// - use AliTPCRawStreamV3 to loop over data and call ProcessEvent(AliTPCRawStreamV3 *rawStream)
+///
+/// Bool_t ProcessEvent(AliTPCRawStreamV3 *rawStream);
+/// - process event from AliTPCRawStreamV3
+/// - call Update function for signal filling
+///
+/// Int_t Update(const Int_t isector, const Int_t iRow, const Int_t
+/// iPad, const Int_t iTimeBin, const Float_t signal);
+/// - directly fill signal information (sector, row, pad, time bin, pad)
+/// to the reference histograms
+///
+/// It is also possible to merge two independently taken calibrations using the function
+///
+/// void Merge(AliTPCCalibPulser *sig)
+/// - copy histograms in 'sig' if the do not exist in this instance
+/// - Add histograms in 'sig' to the histograms in this instance if the allready exist
+/// - After merging call Analyse again!
+///
+///
+///
+/// -- example: filling data using root raw data:
+/// ~~~{.cpp}
+/// void fillSignal(Char_t *filename)
+/// {
+/// rawReader = new AliRawReaderRoot(fileName);
+/// if ( !rawReader ) return;
+/// AliTPCCalibPulser *calib = new AliTPCCalibPulser;
+/// while (rawReader->NextEvent()){
+/// calib->ProcessEvent(rawReader);
+/// }
+/// calib->Analyse();
+/// calib->DumpToFile("SignalData.root");
+/// delete rawReader;
+/// delete calib;
+/// }
+/// ~~~
+///
+/// What kind of information is stored and how to retrieve them:
+/// ------------------------------------------------------------
+///
+/// - Accessing the 'Reference Histograms' (Time0, signal width and Q sum information pad by pad):
+///
+/// TH2F *GetHistoT0(Int_t sector);
+/// TH2F *GetHistoRMS(Int_t sector);
+/// TH2F *GetHistoQ(Int_t sector);
+///
+/// - Accessing the calibration storage objects:
+///
+/// AliTPCCalROC *GetCalRocT0(Int_t sector); // for the Time0 values
+/// AliTPCCalROC *GetCalRocRMS(Int_t sector); // for the signal width values
+/// AliTPCCalROC *GetCalRocQ(Int_t sector); // for the Q sum values
+///
+/// example for visualisation:
+/// if the file "SignalData.root" was created using the above example one could do the following:
+///
+/// ~~~{.cpp}
+/// TFile fileSignal("SignalData.root")
+/// AliTPCCalibPulser *sig = (AliTPCCalibPulser*)fileSignal->Get("AliTPCCalibPulser");
+/// sig->GetCalRocT0(0)->Draw("colz");
+/// sig->GetCalRocRMS(0)->Draw("colz");
+/// ~~~
+///
+/// or use the AliTPCCalPad functionality:
+///
+/// ~~~{.cpp}
+/// AliTPCCalPad padT0(ped->GetCalPadT0());
+/// AliTPCCalPad padSigWidth(ped->GetCalPadRMS());
+/// padT0->MakeHisto2D()->Draw("colz"); //Draw A-Side Time0 Information
+/// padSigWidth->MakeHisto2D()->Draw("colz"); //Draw A-Side signal width Information
+/// ~~~
//Root includes
#include <TObjArray.h>
+/// \cond CLASSIMP
ClassImp(AliTPCCalibPulser)
+/// \endcond
AliTPCCalibPulser::AliTPCCalibPulser() :
AliTPCCalibRawBase(),
fVTime0Offset(72),
fVTime0OffsetCounter(72)
{
- //
- // AliTPCSignal default constructor
- //
-
+ /// AliTPCSignal default constructor
+
for (Int_t iSec = 0; iSec < 72; ++iSec){
const AliTPCCalROC *calQ = (AliTPCCalROC*)sig.fCalRocArrayQ.UncheckedAt(iSec);
const AliTPCCalROC *calT0 = (AliTPCCalROC*)sig.fCalRocArrayT0.UncheckedAt(iSec);
const AliTPCCalROC *calRMS = (AliTPCCalROC*)sig.fCalRocArrayRMS.UncheckedAt(iSec);
const AliTPCCalROC *calOut = (AliTPCCalROC*)sig.fCalRocArrayOutliers.UncheckedAt(iSec);
-
+
const TH2S *hQ = (TH2S*)sig.fHistoQArray.UncheckedAt(iSec);
const TH2S *hT0 = (TH2S*)sig.fHistoT0Array.UncheckedAt(iSec);
const TH2S *hRMS = (TH2S*)sig.fHistoRMSArray.UncheckedAt(iSec);
-
+
if ( calQ != 0x0 ) fCalRocArrayQ.AddAt(new AliTPCCalROC(*calQ), iSec);
if ( calT0 != 0x0 ) fCalRocArrayT0.AddAt(new AliTPCCalROC(*calT0), iSec);
if ( calRMS != 0x0 ) fCalRocArrayRMS.AddAt(new AliTPCCalROC(*calRMS), iSec);
if ( calOut != 0x0 ) fCalRocArrayOutliers.AddAt(new AliTPCCalROC(*calOut), iSec);
-
+
if ( hQ != 0x0 ){
TH2S *hNew = new TH2S(*hQ);
hNew->SetDirectory(0);
}
fVMeanTimeSector[iSec]=sig.fVMeanTimeSector[iSec];
}
-
+
if ( sig.fHMeanTimeSector ) fHMeanTimeSector=(TH2F*)sig.fHMeanTimeSector->Clone();
fParam->Update();
}
fVTime0Offset(72),
fVTime0OffsetCounter(72)
{
- //
- // This constructor uses a TMap for setting some parametes
- //
+ /// This constructor uses a TMap for setting some parametes
+
SetNameTitle("AliTPCCalibPulser","AliTPCCalibPulser");
fFirstTimeBin=60;
fLastTimeBin=900;
if (config->GetValue("PeakIntMinus")) fPeakIntMinus = (Int_t)((TObjString*)config->GetValue("PeakIntMinus"))->GetString().Atof();
if (config->GetValue("PeakIntPlus")) fPeakIntPlus = (Int_t)((TObjString*)config->GetValue("PeakIntPlus"))->GetString().Atof();
if (config->GetValue("IsZeroSuppressed")) fIsZeroSuppressed = (Bool_t)((TObjString*)config->GetValue("IsZeroSuppressed"))->GetString().Atoi();
-
+
fParam->Update();
}
//_____________________________________________________________________
AliTPCCalibPulser& AliTPCCalibPulser::operator = (const AliTPCCalibPulser &source)
{
- //
- // assignment operator
- //
+ /// assignment operator
+
if (&source == this) return *this;
new (this) AliTPCCalibPulser(source);
-
+
return *this;
}
//_____________________________________________________________________
AliTPCCalibPulser::~AliTPCCalibPulser()
{
- //
- // destructor
- //
-
+ /// destructor
+
Reset();
delete fParam;
}
void AliTPCCalibPulser::Reset()
{
- //
- // Delete all information: Arrays, Histograms, CalRoc objects
- //
+ /// Delete all information: Arrays, Histograms, CalRoc objects
+
fCalRocArrayT0.Delete();
fCalRocArrayQ.Delete();
fCalRocArrayRMS.Delete();
fCalRocArrayOutliers.Delete();
-
+
fHistoQArray.Delete();
fHistoT0Array.Delete();
fHistoRMSArray.Delete();
-
+
fPadTimesArrayEvent.Delete();
fPadQArrayEvent.Delete();
fPadRMSArrayEvent.Delete();
fPadPedestalArrayEvent.Delete();
-
+
if (fHMeanTimeSector) delete fHMeanTimeSector;
}
//_____________________________________________________________________
const Int_t icTimeBin,
const Float_t csignal)
{
- //
- // Signal filling methode on the fly pedestal and time offset correction if necessary.
- // no extra analysis necessary. Assumes knowledge of the signal shape!
- // assumes that it is looped over consecutive time bins of one pad
- //
-
+ /// Signal filling methode on the fly pedestal and time offset correction if necessary.
+ /// no extra analysis necessary. Assumes knowledge of the signal shape!
+ /// assumes that it is looped over consecutive time bins of one pad
+
if (icRow<0) return 0;
if (icPad<0) return 0;
if (icTimeBin<0) return 0;
if ( (icTimeBin>fLastTimeBin) || (icTimeBin<fFirstTimeBin) ) return 0;
-
+
if ( icRow<0 || icPad<0 ){
AliWarning("Wrong Pad or Row number, skipping!");
return 0;
}
-
+
Int_t iChannel = fROC->GetRowIndexes(icsector)[icRow]+icPad; // global pad position in sector
-
+
//init first pad and sector in this event
if ( fCurrentChannel == -1 ) {
fCurrentChannel = iChannel;
fCurrentRow = icRow;
fCurrentPad = icPad;
}
-
+
//process last pad if we change to a new one
if ( iChannel != fCurrentChannel ){
ProcessPad();
fCurrentRow = icRow;
fCurrentPad = icPad;
}
-
+
//fill signals for current pad
fPadSignal[icTimeBin]=csignal;
if ( csignal > fMaxPadSignal ){
//_____________________________________________________________________
void AliTPCCalibPulser::FindPedestal(Float_t part)
{
- //
- // find pedestal and noise for the current pad. Use either database or
- // truncated mean with part*100%
- //
+ /// find pedestal and noise for the current pad. Use either database or
+ /// truncated mean with part*100%
+
Bool_t noPedestal = kTRUE;;
if (fPedestalTPC&&fPadNoiseTPC){
//use pedestal database
fPedestalROC = fPedestalTPC->GetCalROC(fCurrentSector);
fPadNoiseROC = fPadNoiseTPC->GetCalROC(fCurrentSector);
}
-
+
if ( fPedestalROC&&fPadNoiseROC ){
fPadPedestal = fPedestalROC->GetValue(fCurrentChannel);
fPadNoise = fPadNoiseROC->GetValue(fCurrentChannel);
noPedestal = kFALSE;
}
-
+
}
-
+
//if we are not running with pedestal database, or for the current sector there is no information
//available, calculate the pedestal and noise on the fly
if ( noPedestal ) {
//
UShort_t histo[kPedMax];
memset(histo,0,kPedMax*sizeof(UShort_t));
-
+
for (Int_t i=fFirstTimeBin; i<=fLastTimeBin; ++i){
padSignal = fPadSignal.GetMatrixArray()[i];
if (padSignal<=0) continue;
//_____________________________________________________________________
void AliTPCCalibPulser::FindPulserSignal(TVectorD ¶m, Float_t &qSum)
{
-//
- // Find position, signal width and height of the CE signal (last signal)
- // param[0] = Qmax, param[1] = mean time, param[2] = rms;
- // maxima: array of local maxima of the pad signal use the one closest to the mean CE position
- //
-
+/// Find position, signal width and height of the CE signal (last signal)
+/// param[0] = Qmax, param[1] = mean time, param[2] = rms;
+/// maxima: array of local maxima of the pad signal use the one closest to the mean CE position
+
Float_t ceQmax =0, ceQsum=0, ceTime=0, ceRMS=0;
Int_t cemaxpos = fMaxTimeBin;
Float_t ceSumThreshold = 10.*TMath::Max(fPadNoise,Float_t(1.)); // threshold for the signal sum
param[1] = ceTime;
param[2] = ceRMS;
qSum = ceQsum;
-
+
if (cemaxpos>0){
ceQmax = fPadSignal.GetMatrixArray()[cemaxpos]-fPadPedestal;
if ( ceQmax<ceMaxThreshold ) return;
fVTime0OffsetCounter.GetMatrixArray()[fCurrentSector]++;
}
}
-
+
//Normalise Q to the 'cell-size': The wire density is the same in the IROC and OROC, therefore the
// the pick-up signal should scale with the pad area. In addition
// the signal should decrease with the wire distance (4mm in IROC, 6mm in OROC),
// to the OROC signal (factor 2/3 for the IROCs).
Float_t norm = fParam->GetPadPitchWidth(fCurrentSector)*fParam->GetPadPitchLength(fCurrentSector,fCurrentRow)*100;
if ( fCurrentSector<fParam->GetNInnerSector() ) norm*=3./2.;
-
+
ceQsum/=norm;
} else {
ceQmax=0;
//_____________________________________________________________________
void AliTPCCalibPulser::ProcessPad()
{
- //
- // Process data of current pad
- //
-
+ /// Process data of current pad
+
FindPedestal();
TVectorD param(3);
Float_t qSum;
FindPulserSignal(param, qSum);
-
+
Double_t meanT = param[1];
Double_t sigmaT = param[2];
-
-
+
+
//Fill Event T0 counter
(*GetPadTimesEvent(fCurrentSector,kTRUE)).GetMatrixArray()[fCurrentChannel] = meanT;
-
+
//Fill Q histogram
// GetHistoQ(fCurrentSector,kTRUE)->Fill( TMath::Sqrt(qSum), fCurrentChannel ); //use linear scale, needs also a change in the Analyse funciton.
GetHistoQ(fCurrentSector,kTRUE)->Fill( qSum, fCurrentChannel );
-
+
//Fill RMS histogram
GetHistoRMS(fCurrentSector,kTRUE)->Fill( sigmaT, fCurrentChannel );
-
-
+
+
//Fill debugging info
if ( GetStreamLevel()>0 ){
TTreeSRedirector *streamer=GetDebugStreamer();
//_____________________________________________________________________
void AliTPCCalibPulser::EndEvent()
{
- //
- // Process data of current event
- //
-
+ /// Process data of current event
+
//check if last pad has allready been processed, if not do so
if ( fMaxTimeBin>-1 ) ProcessPad();
-
+
//loop over all ROCs, fill Time0 histogram corrected for the mean Time0 of each ROC
for ( Int_t iSec = 0; iSec<72; ++iSec ){
TVectorF *vTimes = GetPadTimesEvent(iSec);
Float_t time0 = fVTime0Offset[iSec]/fVTime0OffsetCounter[iSec];
for ( UInt_t iChannel=0; iChannel<fROC->GetNChannels(iSec); ++iChannel ){
Float_t time = (*vTimes).GetMatrixArray()[iChannel];
-
+
GetHistoT0(iSec,kTRUE)->Fill( time-time0,iChannel );
//GetHistoT0(iSec,kTRUE)->Fill( time,iChannel );
-
-
+
+
//Debug start
if ( GetStreamLevel()>1 ){
TTreeSRedirector *streamer=GetDebugStreamer();
Int_t row=0;
Int_t pad=0;
Int_t padc=0;
-
+
Float_t q = (*GetPadQEvent(iSec)).GetMatrixArray()[iChannel];
Float_t rms = (*GetPadRMSEvent(iSec)).GetMatrixArray()[iChannel];
-
+
UInt_t channel=iChannel;
Int_t sector=iSec;
-
+
while ( channel > (fROC->GetRowIndexes(sector)[row]+fROC->GetNPads(sector,row)-1) ) row++;
pad = channel-fROC->GetRowIndexes(sector)[row];
padc = pad-(fROC->GetNPads(sector,row)/2);
-
+
(*streamer) << "DataPad" <<
"Event=" << fNevents <<
"Sector="<< sector <<
Int_t nbinsY, Float_t ymin, Float_t ymax,
const Char_t *type, Bool_t force)
{
- //
- // return pointer to Q histogram
- // if force is true create a new histogram if it doesn't exist allready
- //
+ /// return pointer to Q histogram
+ /// if force is true create a new histogram if it doesn't exist allready
+
if ( !force || arr->UncheckedAt(sector) )
return (TH2S*)arr->UncheckedAt(sector);
-
+
// if we are forced and histogram doesn't yes exist create it
// new histogram with Q calib information. One value for each pad!
TH2S* hist = new TH2S(Form("hCalib%s%.2d",type,sector),Form("%s calibration histogram sector %.2d",type,sector),
//_____________________________________________________________________
TH2S* AliTPCCalibPulser::GetHistoT0(Int_t sector, Bool_t force)
{
- //
- // return pointer to T0 histogram
- // if force is true create a new histogram if it doesn't exist allready
- //
+ /// return pointer to T0 histogram
+ /// if force is true create a new histogram if it doesn't exist allready
+
TObjArray *arr = &fHistoT0Array;
return GetHisto(sector, arr, fNbinsT0, fXminT0, fXmaxT0, "T0", force);
}
//_____________________________________________________________________
TH2S* AliTPCCalibPulser::GetHistoQ(Int_t sector, Bool_t force)
{
- //
- // return pointer to Q histogram
- // if force is true create a new histogram if it doesn't exist allready
- //
+ /// return pointer to Q histogram
+ /// if force is true create a new histogram if it doesn't exist allready
+
TObjArray *arr = &fHistoQArray;
return GetHisto(sector, arr, fNbinsQ, fXminQ, fXmaxQ, "Q", force);
}
//_____________________________________________________________________
TH2S* AliTPCCalibPulser::GetHistoRMS(Int_t sector, Bool_t force)
{
- //
- // return pointer to Q histogram
- // if force is true create a new histogram if it doesn't exist allready
- //
+ /// return pointer to Q histogram
+ /// if force is true create a new histogram if it doesn't exist allready
+
TObjArray *arr = &fHistoRMSArray;
return GetHisto(sector, arr, fNbinsRMS, fXminRMS, fXmaxRMS, "RMS", force);
}
//_____________________________________________________________________
TH2F* AliTPCCalibPulser::GetHistoTSec()
{
- //
- // return the pointer to the abs time distribution per sector
- // create it if it does not exist
- //
+ /// return the pointer to the abs time distribution per sector
+ /// create it if it does not exist
+
if ( !fHMeanTimeSector ) //!!!if you change the binning here, you should also change it in the Analyse Function!!
fHMeanTimeSector = new TH2F("fHMeanTimeSector","Abs mean time per sector",
20*(fLastTimeBin-fFirstTimeBin), fFirstTimeBin, fLastTimeBin,
//_____________________________________________________________________
TVectorF* AliTPCCalibPulser::GetPadInfoEvent(Int_t sector, TObjArray *arr, Bool_t force)
{
- //
- // return pointer to Pad Info from 'arr' for the current event and sector
- // if force is true create it if it doesn't exist allready
- //
+ /// return pointer to Pad Info from 'arr' for the current event and sector
+ /// if force is true create it if it doesn't exist allready
+
if ( !force || arr->UncheckedAt(sector) )
return (TVectorF*)arr->UncheckedAt(sector);
-
+
TVectorF *vect = new TVectorF(fROC->GetNChannels(sector));
arr->AddAt(vect,sector);
return vect;
//_____________________________________________________________________
TVectorF* AliTPCCalibPulser::GetPadTimesEvent(Int_t sector, Bool_t force)
{
- //
- // return pointer to Pad Times Array for the current event and sector
- // if force is true create it if it doesn't exist allready
- //
+ /// return pointer to Pad Times Array for the current event and sector
+ /// if force is true create it if it doesn't exist allready
+
TObjArray *arr = &fPadTimesArrayEvent;
return GetPadInfoEvent(sector,arr,force);
}
//_____________________________________________________________________
TVectorF* AliTPCCalibPulser::GetPadQEvent(Int_t sector, Bool_t force)
{
- //
- // return pointer to Pad Q Array for the current event and sector
- // if force is true create it if it doesn't exist allready
- // for debugging purposes only
- //
-
+ /// return pointer to Pad Q Array for the current event and sector
+ /// if force is true create it if it doesn't exist allready
+ /// for debugging purposes only
+
TObjArray *arr = &fPadQArrayEvent;
return GetPadInfoEvent(sector,arr,force);
}
//_____________________________________________________________________
TVectorF* AliTPCCalibPulser::GetPadRMSEvent(Int_t sector, Bool_t force)
{
- //
- // return pointer to Pad RMS Array for the current event and sector
- // if force is true create it if it doesn't exist allready
- // for debugging purposes only
- //
+ /// return pointer to Pad RMS Array for the current event and sector
+ /// if force is true create it if it doesn't exist allready
+ /// for debugging purposes only
+
TObjArray *arr = &fPadRMSArrayEvent;
return GetPadInfoEvent(sector,arr,force);
}
//_____________________________________________________________________
TVectorF* AliTPCCalibPulser::GetPadPedestalEvent(Int_t sector, Bool_t force)
{
- //
- // return pointer to Pad RMS Array for the current event and sector
- // if force is true create it if it doesn't exist allready
- // for debugging purposes only
- //
+ /// return pointer to Pad RMS Array for the current event and sector
+ /// if force is true create it if it doesn't exist allready
+ /// for debugging purposes only
+
TObjArray *arr = &fPadPedestalArrayEvent;
return GetPadInfoEvent(sector,arr,force);
}
//_____________________________________________________________________
AliTPCCalROC* AliTPCCalibPulser::GetCalRoc(Int_t sector, TObjArray* arr, Bool_t force) const
{
- //
- // return pointer to ROC Calibration
- // if force is true create a new histogram if it doesn't exist allready
- //
+ /// return pointer to ROC Calibration
+ /// if force is true create a new histogram if it doesn't exist allready
+
if ( !force || arr->UncheckedAt(sector) )
return (AliTPCCalROC*)arr->UncheckedAt(sector);
-
+
// if we are forced and histogram doesn't yes exist create it
-
+
// new AliTPCCalROC for T0 information. One value for each pad!
AliTPCCalROC *croc = new AliTPCCalROC(sector);
arr->AddAt(croc,sector);
//_____________________________________________________________________
AliTPCCalROC* AliTPCCalibPulser::GetCalRocT0(Int_t sector, Bool_t force)
{
- //
- // return pointer to Carge ROC Calibration
- // if force is true create a new histogram if it doesn't exist allready
- //
+ /// return pointer to Carge ROC Calibration
+ /// if force is true create a new histogram if it doesn't exist allready
+
TObjArray *arr = &fCalRocArrayT0;
return GetCalRoc(sector, arr, force);
}
//_____________________________________________________________________
AliTPCCalROC* AliTPCCalibPulser::GetCalRocQ(Int_t sector, Bool_t force)
{
- //
- // return pointer to T0 ROC Calibration
- // if force is true create a new histogram if it doesn't exist allready
- //
+ /// return pointer to T0 ROC Calibration
+ /// if force is true create a new histogram if it doesn't exist allready
+
TObjArray *arr = &fCalRocArrayQ;
return GetCalRoc(sector, arr, force);
}
//_____________________________________________________________________
AliTPCCalROC* AliTPCCalibPulser::GetCalRocRMS(Int_t sector, Bool_t force)
{
- //
- // return pointer to signal width ROC Calibration
- // if force is true create a new histogram if it doesn't exist allready
- //
+ /// return pointer to signal width ROC Calibration
+ /// if force is true create a new histogram if it doesn't exist allready
+
TObjArray *arr = &fCalRocArrayRMS;
return GetCalRoc(sector, arr, force);
}
//_____________________________________________________________________
AliTPCCalROC* AliTPCCalibPulser::GetCalRocOutliers(Int_t sector, Bool_t force)
{
- //
- // return pointer to Outliers
- // if force is true create a new histogram if it doesn't exist allready
- //
+ /// return pointer to Outliers
+ /// if force is true create a new histogram if it doesn't exist allready
+
TObjArray *arr = &fCalRocArrayOutliers;
return GetCalRoc(sector, arr, force);
}
//_____________________________________________________________________
void AliTPCCalibPulser::ResetEvent()
{
- //
- // Reset global counters -- Should be called before each event is processed
- //
+ /// Reset global counters -- Should be called before each event is processed
+
fLastSector=-1;
fCurrentSector=-1;
fCurrentRow=-1;
fCurrentPad=-1;
fCurrentChannel=-1;
-
+
ResetPad();
-
+
fPadTimesArrayEvent.Delete();
-
+
fPadQArrayEvent.Delete();
fPadRMSArrayEvent.Delete();
fPadPedestalArrayEvent.Delete();
-
+
for ( Int_t i=0; i<72; ++i ){
fVTime0Offset[i]=0;
fVTime0OffsetCounter[i]=0;
//_____________________________________________________________________
void AliTPCCalibPulser::ResetPad()
{
- //
- // Reset pad infos -- Should be called after a pad has been processed
- //
+ /// Reset pad infos -- Should be called after a pad has been processed
+
for (Int_t i=fFirstTimeBin; i<fLastTimeBin+1; ++i)
fPadSignal[i] = 0;
fMaxTimeBin = -1;
//_____________________________________________________________________
Bool_t AliTPCCalibPulser::IsEdgePad(Int_t sector, Int_t row, Int_t pad)
{
- //
- // return true if pad is on the edge of a row
- //
+ /// return true if pad is on the edge of a row
+
Int_t edge1 = 0;
Int_t edge2 = fROC->GetNPads(sector,row)-1;
if ( pad == edge1 || pad == edge2 ) return kTRUE;
-
+
return kFALSE;
}
//_____________________________________________________________________
void AliTPCCalibPulser::Merge(AliTPCCalibPulser * const sig)
{
- //
- // Merge reference histograms of sig to the current AliTPCCalibPulser
- //
+ /// Merge reference histograms of sig to the current AliTPCCalibPulser
MergeBase(sig);
//merge histograms
TH2S *hRefQmerge = sig->GetHistoQ(iSec);
TH2S *hRefT0merge = sig->GetHistoT0(iSec);
TH2S *hRefRMSmerge = sig->GetHistoRMS(iSec);
-
-
+
+
if ( hRefQmerge ){
TDirectory *dir = hRefQmerge->GetDirectory(); hRefQmerge->SetDirectory(0);
TH2S *hRefQ = GetHistoQ(iSec);
}
hRefRMSmerge->SetDirectory(dir);
}
-
+
}
if ( sig->fHMeanTimeSector ){
TDirectory *dir = sig->fHMeanTimeSector->GetDirectory(); sig->fHMeanTimeSector->SetDirectory(0);
//_____________________________________________________________________
Long64_t AliTPCCalibPulser::Merge(TCollection * const list)
{
- //
- // Merge all objects of this type in list
- //
-
+ /// Merge all objects of this type in list
+
Long64_t nmerged=1;
-
+
TIter next(list);
AliTPCCalibPulser *ce=0;
TObject *o=0;
-
+
while ( (o=next()) ){
ce=dynamic_cast<AliTPCCalibPulser*>(o);
if (ce){
++nmerged;
}
}
-
+
return nmerged;
}
//_____________________________________________________________________
void AliTPCCalibPulser::Analyse()
{
- //
- // Calculate calibration constants
- //
-
+ /// Calculate calibration constants
+
TVectorD paramQ(3);
TVectorD paramT0(3);
TVectorD paramRMS(3);
//calculate mean time for each sector and mean time for each side
TH1F hMeanTsec("hMeanTsec","hMeanTsec",20*(fLastTimeBin-fFirstTimeBin),fFirstTimeBin,fLastTimeBin);
fVMeanTimeSector.Zero();
-
+
for (Int_t iSec=0; iSec<72; ++iSec){
TH2S *hT0 = GetHistoT0(iSec);
if (!hT0 ) continue;
if ( entries>0 ) AliMathBase::TruncatedMean(&hMeanTsec,¶mT0,0.05,.95);
fVMeanTimeSector[iSec]=paramT0[1];
}
-
+
AliTPCCalROC *rocQ = GetCalRocQ (iSec,kTRUE);
AliTPCCalROC *rocT0 = GetCalRocT0 (iSec,kTRUE);
AliTPCCalROC *rocRMS = GetCalRocRMS(iSec,kTRUE);
AliTPCCalROC *rocOut = GetCalRocOutliers(iSec,kTRUE);
-
+
TH2S *hQ = GetHistoQ(iSec);
TH2S *hRMS = GetHistoRMS(iSec);
-
+
Short_t *arrayhQ = hQ->GetArray();
Short_t *arrayhT0 = hT0->GetArray();
Short_t *arrayhRMS = hRMS->GetArray();
-
+
UInt_t nChannels = fROC->GetNChannels(iSec);
Float_t meanTsec = fVMeanTimeSector[iSec];
-
+
//debug
Int_t row=0;
Int_t pad=0;
Int_t padc=0;
//! debug
-
+
for (UInt_t iChannel=0; iChannel<nChannels; ++iChannel){
-
+
Float_t cogTime0 = -1000;
Float_t cogQ = -1000;
Float_t cogRMS = -1000;
Float_t cogOut = 0;
-
+
Int_t offsetQ = (fNbinsQ+2)*(iChannel+1)+1;
Int_t offsetT0 = (fNbinsT0+2)*(iChannel+1)+1;
Int_t offsetRMS = (fNbinsRMS+2)*(iChannel+1)+1;
cogQ = AliMathBase::GetCOG(arrayhQ+offsetQ,fNbinsQ,fXminQ,fXmaxQ);
cogTime0 = AliMathBase::GetCOG(arrayhT0+offsetT0,fNbinsT0,fXminT0,fXmaxT0);
cogRMS = AliMathBase::GetCOG(arrayhRMS+offsetRMS,fNbinsRMS,fXminRMS,fXmaxRMS);
-
+
/*
if ( (cogQ < ??) && (cogTime0 > ??) && (cogTime0<??) && ( cogRMS>??) ){
cogOut = 1;
rocT0->SetValue(iChannel, 0); //offset by mean time of the sector
rocRMS->SetValue(iChannel, 0);
}
-
+
//debug
if ( GetStreamLevel() > 2 ){
TTreeSRedirector *streamer=GetDebugStreamer();
while ( iChannel > (fROC->GetRowIndexes(iSec)[row]+fROC->GetNPads(iSec,row)-1) ) row++;
pad = iChannel-fROC->GetRowIndexes(iSec)[row];
padc = pad-(fROC->GetNPads(iSec,row)/2);
-
+
(*streamer) << "DataEnd" <<
"Sector=" << iSec <<
"Pad=" << pad <<
}
//! debug
}
-
-
+
+
}
}
//_____________________________________________________________________
//_____________________________________________________________________
TObjArray* AliTPCCalibPulser::TestBinning()
{
- //
- // Function to test the binning of the reference histograms
- // type: T0, Q or RMS
- // mode: 0 - number of filled bins per channel
- // 1 - number of empty bins between filled bins in one ROC
- // returns TObjArray with the test histograms type*2+mode:
- // position 0 = T0,0 ; 1 = T0,1 ; 2 = Q,0 ...
-
-
+ /// Function to test the binning of the reference histograms
+ /// type: T0, Q or RMS
+ /// mode: 0 - number of filled bins per channel
+ /// 1 - number of empty bins between filled bins in one ROC
+ /// returns TObjArray with the test histograms type*2+mode:
+ /// position 0 = T0,0 ; 1 = T0,1 ; 2 = Q,0 ...
+
+
TObjArray *histArray = new TObjArray(6);
const Char_t *type[] = {"T0","Q","RMS"};
Int_t fNbins[3] = {fNbinsT0,fNbinsQ,fNbinsRMS};
-
+
for (Int_t itype = 0; itype<3; ++itype){
for (Int_t imode=0; imode<2; ++imode){
Int_t icount = itype*2+imode;
icount);
}
}
-
-
+
+
TH2S *hRef=0x0;
Short_t *array=0x0;
for (Int_t itype = 0; itype<3; ++itype){
if ( hRef == 0x0 ) continue;
array = (hRef->GetArray());
UInt_t nChannels = fROC->GetNChannels(iSec);
-
+
Int_t nempty=0;
for (UInt_t iChannel=0; iChannel<nChannels; ++iChannel){
Int_t nfilled=0;
else c1 = 1;
}
else if ( c1 ) c2 = 1;
-
+
}
((TH1F*)histArray->At(itype*2))->Fill(nfilled);
}
/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
* See cxx source for full Copyright notice */
-/////////////////////////////////////////////////////////////////////////////////////////
-// //
-// Implementation of the TPC pulser calibration //
-// //
-/////////////////////////////////////////////////////////////////////////////////////////
+/// \class AliTPCCalibPulser
+/// \brief Iplementation of the TPC pulser calibration
#include <TVectorT.h>
#include "AliTPCCalibRawBase.h"
AliTPCCalibPulser(const AliTPCCalibPulser &sig);
AliTPCCalibPulser(const TMap *config);
virtual ~AliTPCCalibPulser();
-
+
void Reset();
-
+
AliTPCCalibPulser& operator = (const AliTPCCalibPulser &source);
-
-
+
+
virtual Int_t Update(const Int_t isector, const Int_t iRow, const Int_t iPad,
const Int_t iTimeBin, const Float_t signal);
virtual void Analyse();
AliTPCCalROC* GetCalRocQ (Int_t sector, Bool_t force=kFALSE); // get calibration object - sector
AliTPCCalROC* GetCalRocRMS(Int_t sector, Bool_t force=kFALSE); // get calibration object - sector
AliTPCCalROC* GetCalRocOutliers(Int_t sector, Bool_t force=kFALSE); // get calibration object - sector
-
+
const TObjArray* GetCalPadT0() const { return &fCalRocArrayT0; } // get calibration object
const TObjArray* GetCalPadQ() const { return &fCalRocArrayQ; } // get calibration object
const TObjArray* GetCalPadRMS() const{ return &fCalRocArrayRMS;} // get calibration object
const TObjArray* GetCalPadOutliers() const { return &fCalRocArrayOutliers;} // get calibration object
-
+
TH2S* GetHistoQ (Int_t sector, Bool_t force=kFALSE); // get refernce histogram
TH2S* GetHistoT0 (Int_t sector, Bool_t force=kFALSE); // get refernce histogram
TH2S* GetHistoRMS(Int_t sector, Bool_t force=kFALSE); // get refernce histogram
-
+
TH2F* GetHistoTSec(); // mean abs time distribution histogram
-
+
Float_t GetMeanTimeSector(Int_t sector) const {return fVMeanTimeSector[sector];}
const TVectorF* GetMeanTimeSectorArray() const {return &fVMeanTimeSector;}
-
+
Short_t GetDebugLevel() const { return fDebugLevel; }
//
void SetRangeTime (Int_t firstTimeBin, Int_t lastTimeBin) { fFirstTimeBin=firstTimeBin; fLastTimeBin=lastTimeBin; } //Set range in which the pulser signal is expected
void SetRangeRefT0 (Int_t nBins, Float_t xMin, Float_t xMax){ fNbinsT0 = nBins; fXminT0 = xMin; fXmaxT0 = xMax; } //Set range for T0 reference histograms
void SetRangeRefRMS(Int_t nBins, Float_t xMin, Float_t xMax){ fNbinsRMS = nBins; fXminRMS = xMin; fXmaxRMS = xMax; } //Set range for T0 reference histograms
void SetRangePeakIntegral(Int_t minus, Int_t plus) { fPeakIntMinus=minus; fPeakIntPlus=plus;}
-
+
void SetDebugLevel(Short_t debug=1){ fDebugLevel = debug;}
-
+
void SetIsZeroSuppressed(Bool_t zs=kTRUE){ fIsZeroSuppressed=zs;}
-
+
void SetPedestalDatabase(AliTPCCalPad * const pedestalTPC, AliTPCCalPad * const padNoiseTPC) {fPedestalTPC = pedestalTPC; fPadNoiseTPC = padNoiseTPC;}
void SetOutliers(AliTPCCalPad * const outliers) {fOutliers = outliers;}
-
+
Bool_t GetIsZeroSupperssed() const { return fIsZeroSuppressed; }
Float_t GetPeakIntegralMinus() const {return fPeakIntMinus;}
Float_t GetPeakIntegralPlus() const {return fPeakIntPlus;}
-
+
void Merge(AliTPCCalibPulser * const sig);
virtual Long64_t Merge(TCollection * const list);
-
+
//
// Test functions
TObjArray* TestBinning();
-
+
protected:
virtual void ResetEvent();
virtual void EndEvent();
-
+
private:
// reference histogram ranges
- Int_t fNbinsT0; // Number of bins for T0 reference histogram
- Float_t fXminT0; // xmin of T0 reference histogram
- Float_t fXmaxT0; // xmax of T0 reference histogram
- Int_t fNbinsQ; // Number of bins for T0 reference histogram
- Float_t fXminQ; // xmin of T0 reference histogram
- Float_t fXmaxQ; // xmax of T0 reference histogram
- Int_t fNbinsRMS; // Number of bins for T0 reference histogram
- Float_t fXminRMS; // xmin of T0 reference histogram
- Float_t fXmaxRMS; // xmax of T0 reference histogram
- Int_t fPeakIntMinus; // Peak integral range for COG determination. Bins used before max bin
- Int_t fPeakIntPlus; // Peak integral range for COG determination. Bins used after max bin
-
- Bool_t fIsZeroSuppressed; // if data is zero suppressed
-
- Int_t fLastSector; //! Last sector processed
-
- AliTPCParam *fParam; //! TPC information
-
- AliTPCCalPad *fPedestalTPC; //! Pedestal Information
- AliTPCCalPad *fPadNoiseTPC; //! Pad noise Information whole TPC
- AliTPCCalPad *fOutliers; //! Outlier information. Those will not be used for calculating the T0
- AliTPCCalROC *fPedestalROC; //! Pedestal Information for current ROC
- AliTPCCalROC *fPadNoiseROC; //! Pad noise Information for current ROC
-
- TObjArray fCalRocArrayT0; // Array of AliTPCCalROC class for Time0 calibration
- TObjArray fCalRocArrayQ; // Array of AliTPCCalROC class for Charge calibration
- TObjArray fCalRocArrayRMS; // Array of AliTPCCalROC class for signal width calibration
- TObjArray fCalRocArrayOutliers; // Array of AliTPCCalROC class for signal outliers
-
- TObjArray fHistoQArray; // Calibration histograms for Charge distribution
- TObjArray fHistoT0Array; // Calibration histograms for Time0 distribution
- TObjArray fHistoRMSArray; // Calibration histograms for signal width distribution
-
- TH2F *fHMeanTimeSector; // Timing distribution per sector
- TVectorF fVMeanTimeSector; // Mean time per sector from analysis of fHMeanTimeSector
-
- TObjArray fPadTimesArrayEvent; //! Pad Times for the event, before mean Time0 corrections
- TObjArray fPadQArrayEvent; //! Charge for the event, only needed for debugging streamer
- TObjArray fPadRMSArrayEvent; //! Signal width for the event, only needed for debugging streamer
- TObjArray fPadPedestalArrayEvent; //! Signal width for the event, only needed for debugging streamer
-
- Int_t fCurrentChannel; //! current channel processed
- Int_t fCurrentSector; //! current sector processed
- Int_t fCurrentRow; //! current row processed
- Int_t fCurrentPad; //! current pad processed
- Float_t fMaxPadSignal; //! maximum bin of current pad
- Int_t fMaxTimeBin; //! time bin with maximum value
- TVectorF fPadSignal; //! signal of current Pad
- Float_t fPadPedestal; //! Pedestal Value of current pad
- Float_t fPadNoise; //! Noise Value of current pad
-
- TVectorF fVTime0Offset; //! Time0 Offset from preprocessing for each sector;
- TVectorF fVTime0OffsetCounter; //! Time0 Offset from preprocessing for each sector;
-
-
+ Int_t fNbinsT0; ///< Number of bins for T0 reference histogram
+ Float_t fXminT0; ///< xmin of T0 reference histogram
+ Float_t fXmaxT0; ///< xmax of T0 reference histogram
+ Int_t fNbinsQ; ///< Number of bins for T0 reference histogram
+ Float_t fXminQ; ///< xmin of T0 reference histogram
+ Float_t fXmaxQ; ///< xmax of T0 reference histogram
+ Int_t fNbinsRMS; ///< Number of bins for T0 reference histogram
+ Float_t fXminRMS; ///< xmin of T0 reference histogram
+ Float_t fXmaxRMS; ///< xmax of T0 reference histogram
+ Int_t fPeakIntMinus; ///< Peak integral range for COG determination. Bins used before max bin
+ Int_t fPeakIntPlus; ///< Peak integral range for COG determination. Bins used after max bin
+
+ Bool_t fIsZeroSuppressed; ///< if data is zero suppressed
+
+ Int_t fLastSector; //!< Last sector processed
+
+ AliTPCParam *fParam; //!< TPC information
+
+ AliTPCCalPad *fPedestalTPC; //!< Pedestal Information
+ AliTPCCalPad *fPadNoiseTPC; //!< Pad noise Information whole TPC
+ AliTPCCalPad *fOutliers; //!< Outlier information. Those will not be used for calculating the T0
+ AliTPCCalROC *fPedestalROC; //!< Pedestal Information for current ROC
+ AliTPCCalROC *fPadNoiseROC; //!< Pad noise Information for current ROC
+
+ TObjArray fCalRocArrayT0; ///< Array of AliTPCCalROC class for Time0 calibration
+ TObjArray fCalRocArrayQ; ///< Array of AliTPCCalROC class for Charge calibration
+ TObjArray fCalRocArrayRMS; ///< Array of AliTPCCalROC class for signal width calibration
+ TObjArray fCalRocArrayOutliers; ///< Array of AliTPCCalROC class for signal outliers
+
+ TObjArray fHistoQArray; ///< Calibration histograms for Charge distribution
+ TObjArray fHistoT0Array; ///< Calibration histograms for Time0 distribution
+ TObjArray fHistoRMSArray; ///< Calibration histograms for signal width distribution
+
+ TH2F *fHMeanTimeSector; ///< Timing distribution per sector
+ TVectorF fVMeanTimeSector; ///< Mean time per sector from analysis of fHMeanTimeSector
+
+ TObjArray fPadTimesArrayEvent; //!< Pad Times for the event, before mean Time0 corrections
+ TObjArray fPadQArrayEvent; //!< Charge for the event, only needed for debugging streamer
+ TObjArray fPadRMSArrayEvent; //!< Signal width for the event, only needed for debugging streamer
+ TObjArray fPadPedestalArrayEvent; //!< Signal width for the event, only needed for debugging streamer
+
+ Int_t fCurrentChannel; //!< current channel processed
+ Int_t fCurrentSector; //!< current sector processed
+ Int_t fCurrentRow; //!< current row processed
+ Int_t fCurrentPad; //!< current pad processed
+ Float_t fMaxPadSignal; //!< maximum bin of current pad
+ Int_t fMaxTimeBin; //!< time bin with maximum value
+ TVectorF fPadSignal; //!< signal of current Pad
+ Float_t fPadPedestal; //!< Pedestal Value of current pad
+ Float_t fPadNoise; //!< Noise Value of current pad
+
+ TVectorF fVTime0Offset; //!< Time0 Offset from preprocessing for each sector;
+ TVectorF fVTime0OffsetCounter; //!< Time0 Offset from preprocessing for each sector;
+
+
void FindPedestal(Float_t part=.6);
void FindPulserSignal(TVectorD ¶m, Float_t &qSum);
-
+
TH2S* GetHisto(Int_t sector, TObjArray *arr,
Int_t nbinsY, Float_t ymin, Float_t ymax,
const Char_t *type, Bool_t force);
-
-
+
+
AliTPCCalROC* GetCalRoc(Int_t sector, TObjArray* arr, Bool_t force) const;
-
+
TVectorF* GetPadTimesEvent(Int_t sector, Bool_t force=kFALSE);
-
+
Bool_t IsEdgePad(Int_t sector, Int_t row, Int_t pad);
-
+
void ResetPad();
void ProcessPad();
-
-
+
+
//debug
TVectorF* GetPadInfoEvent(Int_t sector, TObjArray *arr, Bool_t force=kFALSE);
TVectorF* GetPadQEvent(Int_t sector, Bool_t force=kFALSE);
TVectorF* GetPadRMSEvent(Int_t sector, Bool_t force=kFALSE);
TVectorF* GetPadPedestalEvent(Int_t sector, Bool_t force=kFALSE);
-
+
+ /// \cond CLASSIMP
ClassDef(AliTPCCalibPulser,5) //Implementation of the TPC pulser calibration
+ /// \endcond
};
/* $Id: $ */
-////////////////////////////////////////////////////////////////////////////////////////
-// //
-// Implementation of the TPC Raw drift velocity and Altro L1 Phase calibration //
-// //
-// Origin: Jens Wiechula, J.Wiechula@gsi.de //
-// //
-////////////////////////////////////////////////////////////////////////////////////////
-//
-//
-// *************************************************************************************
-// * Class Description *
-// *************************************************************************************
-/*
-
-----example---
-TFile f("CalibAltro.root");
-AliTPCCalibRaw *al=(AliTPCCalibRaw*)f.Get(f.GetListOfKeys()->At(0)->GetName())
-{
-TCanvas *c1=(TCanvas*)gROOT->FindObject("c1");
-if (!c1) c1=new TCanvas("c1","c1");
-c1->Clear();
-
-TH2F h2f("h2","h2;RCU;fail",216,0,216,al->GetNevents(),0,al->GetNevents());
-Bool_t first=kTRUE;
-Int_t i,iev;
-for (i=0;i<216;++i) {
- TVectorF *v=al->GetALTROL1PhaseFailEventsRCU(i);
- if (!v) continue;
- for (iev=0;iev<al->GetNevents();++iev) {
- h2f->SetBinContent(i+1,iev+1,(*v)(iev));
- }
-// TH1F h(*v);
-// h.SetLineColor(i/216.*50+50);
-// ((TH1F*)h.Clone(Form("h%d",i)))->Draw(first?"":"same");
-// c1->Modified();
-// c1->Update();
- first=kFALSE;
-}
-h2f->Draw("col");
-}
-
-*/
-
-
+/// \class AliTPCCalibRaw
+/// \brief Implementation of the TPC Raw drift velocity and Altro L1 Phase calibration
+///
+/// \author Jens Wiechula, J.Wiechula@gsi.de
+///
+/// Class Description
+/// -----------------
+///
+/// ~~~{.cpp}
+/// TFile f("CalibAltro.root");
+/// AliTPCCalibRaw *al=(AliTPCCalibRaw*)f.Get(f.GetListOfKeys()->At(0)->GetName())
+/// {
+/// TCanvas *c1=(TCanvas*)gROOT->FindObject("c1");
+/// if (!c1) c1=new TCanvas("c1","c1");
+/// c1->Clear();
+///
+/// TH2F h2f("h2","h2;RCU;fail",216,0,216,al->GetNevents(),0,al->GetNevents());
+/// Bool_t first=kTRUE;
+/// Int_t i,iev;
+/// for (i=0;i<216;++i) {
+/// TVectorF *v=al->GetALTROL1PhaseFailEventsRCU(i);
+/// if (!v) continue;
+/// for (iev=0;iev<al->GetNevents();++iev) {
+/// h2f->SetBinContent(i+1,iev+1,(*v)(iev));
+/// }
+/// // TH1F h(*v);
+/// // h.SetLineColor(i/216.*50+50);
+/// // ((TH1F*)h.Clone(Form("h%d",i)))->Draw(first?"":"same");
+/// // c1->Modified();
+/// // c1->Update();
+/// first=kFALSE;
+/// }
+/// h2f->Draw("col");
+/// }
+/// ~~~
//Root includes
#include <TROOT.h>
//class header
#include "AliTPCCalibRaw.h"
+/// \cond CLASSIMP
ClassImp(AliTPCCalibRaw)
+/// \endcond
AliTPCCalibRaw::AliTPCCalibRaw() :
AliTPCCalibRawBase(),
fVNfiredPadsSenEvent(100000),
fVTimeStampEvent(100000)
{
- //
- // Default ctor
- //
+ /// Default ctor
+
SetNameTitle("AliTPCCalibRaw","AliTPCCalibRaw");
CreateDVhist();
for (Int_t ircu=0;ircu<kNRCU;++ircu) fArrCurrentPhase.GetMatrixArray()[ircu]=-1;
//_____________________________________________________________________
AliTPCCalibRaw::~AliTPCCalibRaw()
{
- //
- // dtor
- //
- delete fHnDrift;
+ /// dtor
+
+ delete fHnDrift;
}
//_____________________________________________________________________
// AliTPCCalibRaw& AliTPCCalibRaw::operator = (const AliTPCCalibRaw &source)
// //
// if (&source == this) return *this;
// new (this) AliTPCCalibRaw(source);
-//
+//
// return *this;
// }
Int_t AliTPCCalibRaw::Update(const Int_t isector, const Int_t iRow, const Int_t iPad,
const Int_t iTimeBin, const Float_t signal)
{
- //
- // Data filling method
- //
+ /// Data filling method
+
if (iRow<0) return 0;
if (iPad<0) return 0;
if (iTimeBin<0) return 0;
}
// Double_t x2[kHnBinsDV]={2,isector,0};
// fHnDrift->Fill(x2);
-
+
if (signal>fLastSignal) ++fNOkPlus;
else if(signal<fLastSignal && fNOkPlus>=fPeakDetPlus){
if ( fNOkMinus>=fPeakDetMinus ) {
Double_t x[kHnBinsDV]={static_cast<Double_t>(fPeakTimeBin),static_cast<Double_t>(isector),static_cast<Double_t>((fTimeStamp-fFirstTimeStamp)/fNSecTime)};
fHnDrift->Fill(x);
- }
+ }
} else {
fNOkPlus=0;
fNOkMinus=0;
}
//_____________________________________________________________________
void AliTPCCalibRaw::UpdateDDL(){
- //
- // fill ALTRO L1 information
- //
-
+ /// fill ALTRO L1 information
+
//set nanoseconds
if (!fNanoSec) {
TTimeStamp s;
fArrCurrentPhase.GetMatrixArray()[fCurrDDLNum]=phase;
//increase phase counter
++((fArrCurrentPhaseDist.GetMatrixArray())[phase]);
-
+
}
//_____________________________________________________________________
void AliTPCCalibRaw::ResetEvent()
{
- //
- // Reset event counters
- //
+ /// Reset event counters
fCurrentChannel=-1;
fCurrentRow=-1;
//_____________________________________________________________________
void AliTPCCalibRaw::EndEvent()
{
- //
- // End event analysis
- //
+ /// End event analysis
+
-
//find phase of the current event
Int_t phaseMaxEntries=-1;
Int_t maxEntries=0;
if (fArrALTROL1Phase.GetNrows()-1<=GetNevents())
fArrALTROL1Phase.ResizeTo(GetNevents()+10000);
(fArrALTROL1Phase.GetMatrixArray())[GetNevents()]=phaseMaxEntries;
-
+
//loop over RCUs and test failures
UInt_t fail=0;
for (Int_t ircu=0;ircu<kNRCU;++ircu){
//_____________________________________________________________________
TH2C *AliTPCCalibRaw::MakeHistL1RCUEvents(Int_t type)
{
- // Create a 2D histo RCU:Events indicating the there was a deviation
- // from the mean L1 phase of the event
- //
- //type: 0=Failures, 1=Phases
+ /// Create a 2D histo RCU:Events indicating the there was a deviation
+ /// from the mean L1 phase of the event
+ ///
+ /// type: 0=Failures, 1=Phases
//number of relavant events, depending on version
Int_t nevents=GetNevents();
//_____________________________________________________________________
TH1F *AliTPCCalibRaw::MakeHistL1PhaseDist()
{
- //
- // L1 phase distribution. Should be flat in ideal case
- //
+ /// L1 phase distribution. Should be flat in ideal case
+
TH1F *h=new TH1F("L1phaseDist","Normalized L1 phase distribution;phase;fraction of events",4,0,4);
h->Sumw2();
for (Int_t iev=0;iev<GetNevents();++iev) h->Fill(fArrALTROL1Phase.GetMatrixArray()[iev]);
//_____________________________________________________________________
TVectorF *AliTPCCalibRaw::MakeVectL1PhaseDist()
{
- //
- // L1 phase distribution. Should be flat in ideal case
- //
+ /// L1 phase distribution. Should be flat in ideal case
+
TVectorF *v=new TVectorF(4);
for (Int_t iev=0;iev<GetNevents();++iev) {
Int_t phase=(Int_t)fArrALTROL1Phase.GetMatrixArray()[iev];
//_____________________________________________________________________
TH2C *AliTPCCalibRaw::MakeHistL1RCUEventsIROC(Int_t type)
{
- //
- // Create a 2D histo RCU:Events indicating the there was a deviation
- // from the mean L1 phase of the event
- //
+ /// Create a 2D histo RCU:Events indicating the there was a deviation
+ /// from the mean L1 phase of the event
+
TH2C *h2 = new TH2C("hL1FailRCUEventsIROC","L1 Failures IROCs;RCU;Event",72,0,36,GetNevents(),0,GetNevents());
for (Int_t ircu=0;ircu<72;++ircu) {
const TVectorF *v=0;
//_____________________________________________________________________
TH2C *AliTPCCalibRaw::MakeHistL1RCUEventsOROC(Int_t type)
{
- //
- // Create a 2D histo RCU:Events indicating the there was a deviation
- // from the mean L1 phase of the event
- //
+ /// Create a 2D histo RCU:Events indicating the there was a deviation
+ /// from the mean L1 phase of the event
+
TH2C *h2 = new TH2C("hL1FailRCUEventsOROC","L1 Failures OROCs;RCU;Event",144,0,36,GetNevents(),0,GetNevents());
for (Int_t ircu=72;ircu<kNRCU;++ircu) {
const TVectorF *v=0;
//_____________________________________________________________________
void AliTPCCalibRaw::CreateDVhist()
{
- //
- // Setup the HnSparse for the drift velocity determination
- //
+ /// Setup the HnSparse for the drift velocity determination
+
if (fHnDrift) return;
//HnSparse bins
//time bin, roc, time
Double_t xmin[kHnBinsDV] = {static_cast<Double_t>(fFirstTimeBin),0,0};
Double_t xmax[kHnBinsDV] = {static_cast<Double_t>(fLastTimeBin),72,static_cast<Double_t>(fNBinsTime)};
fHnDrift=new THnSparseI("fHnDrift",Form("Drift velocity using last time bin;time bin[#times 100ns];ROC;Time bin [#times %us]",fNSecTime),kHnBinsDV, bins, xmin, xmax);
-
+
}
//_____________________________________________________________________
void AliTPCCalibRaw::Analyse()
{
- //
- // Analyse Data
- //
+ /// Analyse Data
//resize arrays
fArrALTROL1Phase.ResizeTo(GetNevents());
fVTimeStampEvent.ResizeTo(0);
}
//Analyse drift velocity TODO
-
+
}
//_____________________________________________________________________
TGraph* AliTPCCalibRaw::MakeGraphOccupancy(const Int_t type, const Int_t xType)
{
- //
- // create occupancy graph (of samples abouve threshold)
- // type=0: number of samples
- // type=1: mean data volume (ADC counts/sample)
- // type=2: data volume (ADC counts)
- // type=3: samples per ADC count
- // type=4: sample occupancy
- //
- // type=5: number of sample sensitive / number of samples
- //
- // same in sensitive regions:
- // type=10: number of samples
- // type=11: mean data volume (ADC counts/sample)
- // type=12: data volume (ADC counts)
- // type=13: samples per ADC count
- // type=14: sample occupancy
- //
- // type=16: number of samples sensitive / number of pads sensitive
- // type=17: pad occupancy in sensitive regions
- // xType=0: vs. time stamp
- // xType=1: vs. event counter
- //
+ /// create occupancy graph (of samples abouve threshold)
+ /// type=0: number of samples
+ /// type=1: mean data volume (ADC counts/sample)
+ /// type=2: data volume (ADC counts)
+ /// type=3: samples per ADC count
+ /// type=4: sample occupancy
+ ///
+ /// type=5: number of sample sensitive / number of samples
+ ///
+ /// same in sensitive regions:
+ /// type=10: number of samples
+ /// type=11: mean data volume (ADC counts/sample)
+ /// type=12: data volume (ADC counts)
+ /// type=13: samples per ADC count
+ /// type=14: sample occupancy
+ ///
+ /// type=16: number of samples sensitive / number of pads sensitive
+ /// type=17: pad occupancy in sensitive regions
+ /// xType=0: vs. time stamp
+ /// xType=1: vs. event counter
TString title("Event occupancy");
TString xTitle("Time");
}
for (Int_t i=0;i<GetNevents(); ++i){
Double_t nAboveThreshold=vOcc->GetMatrixArray()[i];
-
+
Double_t nSumADC =1;
Double_t timestamp =1;
Double_t nPads =1;
//
// Not implemented for the moment
//
-// return 0;
+// return 0;
// }
//_____________________________________________________________________
TCanvas* AliTPCCalibRaw::MakeCanvasOccupancy(const Int_t xType, Bool_t sen)
{
- //
- // Create a canvas with occupancy information of all 'type's (see MakeGraphOccupancy)
- // xType=0: vs. timestamp
- // xType=1: vs. event number
- //
- // sen=kTRUE: for sensitive regions
- //
+ /// Create a canvas with occupancy information of all 'type's (see MakeGraphOccupancy)
+ /// xType=0: vs. timestamp
+ /// xType=1: vs. event number
+ ///
+ /// sen=kTRUE: for sensitive regions
TString name("RawOccupancy_");
TString title("Raw Occupancy vs. ");
//_____________________________________________________________________
void AliTPCCalibRaw::Merge(AliTPCCalibRaw * const sig)
{
- //
- // Merge sig with this instance
- //
+ /// Merge sig with this instance
if (!sig) return;
MergeBase(sig);
fHnDrift->Add(sig->fHnDrift);
//Add occupancy data
-
+
}
//_____________________________________________________________________
Long64_t AliTPCCalibRaw::Merge(TCollection * const list)
{
- //
- // Merge all objects of this type in list
- //
-
+ /// Merge all objects of this type in list
+
Long64_t nmerged=1;
-
+
TIter next(list);
AliTPCCalibRaw *ce=0;
TObject *o=0;
-
+
while ( (o=next()) ){
ce=dynamic_cast<AliTPCCalibRaw*>(o);
if (ce){
++nmerged;
}
}
-
+
return nmerged;
}
/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
* See cxx source for full Copyright notice */
-////////////////////////////////////////////////////////////////////////////////////////
-// //
-// TPC ALTRO Header analysis //
-// //
-////////////////////////////////////////////////////////////////////////////////////////
+/// \class AliTPCCalibRaw
+/// \brief TPC ALTRO Header analysis
#include <TVectorF.h>
#include <TObjArray.h>
virtual Long64_t Merge(TCollection * const list);
private:
- Int_t fPeakDetMinus; // Consecutive timebins on rising edge to be regarded as a signal
- Int_t fPeakDetPlus; // Consecutive timebins on falling edge to be regarded as a signal
- UInt_t fNFailL1Phase; //Number of failures in L1 phase
- UInt_t fNFailL1PhaseEvent; //Number of events with L1 phase failures
+ Int_t fPeakDetMinus; ///< Consecutive timebins on rising edge to be regarded as a signal
+ Int_t fPeakDetPlus; ///< Consecutive timebins on falling edge to be regarded as a signal
+ UInt_t fNFailL1Phase; ///< Number of failures in L1 phase
+ UInt_t fNFailL1PhaseEvent; ///< Number of events with L1 phase failures
//binning dv hist
- UInt_t fNSecTime; //Number of seconds per bin in time
- UInt_t fNBinsTime; //Number of bin in time
+ UInt_t fNSecTime; ///< Number of seconds per bin in time
+ UInt_t fNBinsTime; ///< Number of bin in time
//processing information
- Bool_t fPadProcessed; //! if last pead has already been filled for the current pad
- Int_t fCurrentChannel; //! current channel processed
- Int_t fCurrentSector; //! current sector processed
- Int_t fLastSector; //! current sector processed
- Int_t fCurrentRow; //! current row processed
- Int_t fCurrentPad; //! current pad processed
- Int_t fLastTimeBinProc; //! last time bin processed
- Int_t fPeakTimeBin; //! time bin with local maximum
- Int_t fLastSignal; //! last signal processed
- Int_t fNOkPlus; //! number of processed time bins fullfilling peak criteria
- Int_t fNOkMinus; //! number of processed time bins fullfilling peak criteria
- Int_t fNanoSec; //! current nano seconds stamp
+ Bool_t fPadProcessed; //!< if last pead has already been filled for the current pad
+ Int_t fCurrentChannel; //!< current channel processed
+ Int_t fCurrentSector; //!< current sector processed
+ Int_t fLastSector; //!< current sector processed
+ Int_t fCurrentRow; //!< current row processed
+ Int_t fCurrentPad; //!< current pad processed
+ Int_t fLastTimeBinProc; //!< last time bin processed
+ Int_t fPeakTimeBin; //!< time bin with local maximum
+ Int_t fLastSignal; //!< last signal processed
+ Int_t fNOkPlus; //!< number of processed time bins fullfilling peak criteria
+ Int_t fNOkMinus; //!< number of processed time bins fullfilling peak criteria
+ Int_t fNanoSec; //!< current nano seconds stamp
//
//L1 phase stuff
- TVectorF fArrCurrentPhaseDist; //!Phase distribution of the current event
- TVectorF fArrCurrentPhase; //!Current phase of all RCUs
- TVectorF fArrFailEventNumber; //event numbers of failed events;
- TVectorF fArrALTROL1Phase; //Array of L1 phases on an event bases;
- TObjArray fArrALTROL1PhaseEvent; //L1 phase for each RCU and event
- TObjArray fArrALTROL1PhaseFailEvent; //L1 failure for each RCU and event
+ TVectorF fArrCurrentPhaseDist; //!< Phase distribution of the current event
+ TVectorF fArrCurrentPhase; //!< Current phase of all RCUs
+ TVectorF fArrFailEventNumber; ///< event numbers of failed events;
+ TVectorF fArrALTROL1Phase; ///< Array of L1 phases on an event bases;
+ TObjArray fArrALTROL1PhaseEvent; ///< L1 phase for each RCU and event
+ TObjArray fArrALTROL1PhaseFailEvent; ///< L1 failure for each RCU and event
//drift velocity stuff
enum {kHnBinsDV=3};
- THnSparseI *fHnDrift; //Histogram last time bin vs. ROC, Time
+ THnSparseI *fHnDrift; ///< Histogram last time bin vs. ROC, Time
//occupancy
- TVectorF fVOccupancyEvent; //occupancy per event (number of samples above threshold)
- TVectorF fVSignalSumEvent; //occupancy per event (sum of all adc values)
- TVectorF fVOccupancySenEvent; //occupancy per event (number of samples abouve threshold) in sensitive regions
- TVectorF fVSignalSumSenEvent; //occupancy per event (sum of all adc values) in sensitive regions
- TVectorF fVNfiredPadsSenEvent; //number of pads with a signal above threshold in sensitive regions
- TVectorF fVTimeStampEvent; //timestamp for all events
+ TVectorF fVOccupancyEvent; ///< occupancy per event (number of samples above threshold)
+ TVectorF fVSignalSumEvent; ///< occupancy per event (sum of all adc values)
+ TVectorF fVOccupancySenEvent; ///< occupancy per event (number of samples abouve threshold) in sensitive regions
+ TVectorF fVSignalSumSenEvent; ///< occupancy per event (sum of all adc values) in sensitive regions
+ TVectorF fVNfiredPadsSenEvent; ///< number of pads with a signal above threshold in sensitive regions
+ TVectorF fVTimeStampEvent; ///< timestamp for all events
TVectorF *MakeArrL1PhaseRCU(Int_t rcu, Bool_t force=kFALSE);
TVectorF *MakeArrL1PhaseFailRCU(Int_t rcu, Bool_t force=kFALSE);
AliTPCCalibRaw(const AliTPCCalibRaw &calib);
AliTPCCalibRaw& operator = (const AliTPCCalibRaw &source);
+ /// \cond CLASSIMP
ClassDef(AliTPCCalibRaw,4) // Analysis of the Altro header information
+ /// \endcond
};
//----------------------
//_____________________________________________________________________
inline Bool_t AliTPCCalibRaw::IsEdgePad(Int_t sector, Int_t row, Int_t pad) const
{
- //
- // return true if pad is on the edge of a row
- //
+ /// return true if pad is on the edge of a row
+
Int_t edge1 = 0;
if ( pad == edge1 ) return kTRUE;
Int_t edge2 = fROC->GetNPads(sector,row)-1;
* provided "as is" without express or implied warranty. *
**************************************************************************/
-/* $Id: AliTPCCalibRawBase.cxx */
-
-/////////////////////////////////////////////////////////////////////////////////////////
-// //
-// Base class for the calibration algorithms using raw data as input //
-// //
-// Origin: Jens Wiechula J.Wiechula@gsi.de //
-// //
-/////////////////////////////////////////////////////////////////////////////////////////
+/// \class AliTPCCalibRawBase
+/// \brief Base class for the calibration algorithms using raw data as input
+///
+/// \author Jens Wiechula J.Wiechula@gsi.de
//Root includes
#include <TDirectory.h>
#include "AliTPCCalibRawBase.h"
+/// \cond CLASSIMP
ClassImp(AliTPCCalibRawBase)
+/// \endcond
AliTPCCalibRawBase::AliTPCCalibRawBase() :
TNamed(),
fMapping(0x0),
fROC(AliTPCROC::Instance())
{
- //
- // copy ctor
- //
-
+ /// copy ctor
+
}
//_____________________________________________________________________
AliTPCCalibRawBase::~AliTPCCalibRawBase()
{
- //
- // dtor
- //
+ /// dtor
+
if (fDebugStreamer) delete fDebugStreamer;
}
//_____________________________________________________________________
AliTPCCalibRawBase& AliTPCCalibRawBase::operator = (const AliTPCCalibRawBase &source)
{
- //
- // assignment operator
- //
+ /// assignment operator
+
if (&source == this) return *this;
new (this) AliTPCCalibRawBase(source);
//_____________________________________________________________________
Bool_t AliTPCCalibRawBase::ProcessEvent(AliTPCRawStreamV3 * const rawStreamV3)
{
- //
- // Event Processing loop - AliTPCRawStreamV3
- //
+ /// Event Processing loop - AliTPCRawStreamV3
+
ResetEvent();
Bool_t withInput = kFALSE;
fAltroL1Phase=0;
//_____________________________________________________________________
Bool_t AliTPCCalibRawBase::ProcessEvent(AliRawReader * const rawReader)
{
- //
- // Event processing loop - AliRawReader
- //
+ /// Event processing loop - AliRawReader
+
AliRawEventHeaderBase* eventHeader = (AliRawEventHeaderBase*)rawReader->GetEventHeader();
if (eventHeader){
fTimeStamp = eventHeader->Get("Timestamp");
//_____________________________________________________________________
Bool_t AliTPCCalibRawBase::ProcessEvent(eventHeaderStruct * const event)
{
- //
- // Event processing loop - date event
- //
+ /// Event processing loop - date event
fRunNumber=event->eventRunNb;
fTimeStamp=event->eventTimestamp;
//_____________________________________________________________________
void AliTPCCalibRawBase::DumpToFile(const Char_t *filename, const Char_t *dir, Bool_t append)
{
- //
- // Write class to file
- //
-
+ /// Write class to file
+
TString sDir(dir);
TString option;
}
//_____________________________________________________________________
TTreeSRedirector *AliTPCCalibRawBase::GetDebugStreamer(){
- //
- // Get Debug streamer
- // In case debug streamer not yet initialized and StreamLevel>0 create new one
- //
+ /// Get Debug streamer
+ /// In case debug streamer not yet initialized and StreamLevel>0 create new one
+
if (fStreamLevel==0) return 0;
if (fDebugStreamer) return fDebugStreamer;
TString dsName;
//_____________________________________________________________________
void AliTPCCalibRawBase::MergeBase(const AliTPCCalibRawBase *calib)
{
- //
- // merge this with base
- //
+ /// merge this with base
+
if (calib->fFirstTimeStamp<fFirstTimeStamp) fFirstTimeStamp=calib->fFirstTimeStamp;
if (calib->fLastTimeStamp>fLastTimeStamp) fLastTimeStamp =calib->fLastTimeStamp;
}
/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
* See cxx source for full Copyright notice */
-/////////////////////////////////////////////////////////////////////////////////////////
-// //
-// Raw data processing base class //
-// //
-/////////////////////////////////////////////////////////////////////////////////////////
+/// \class AliTPCCalibRawBase
+/// \brief Raw data processing base class
#include <TNamed.h>
AliTPCCalibRawBase& operator = (const AliTPCCalibRawBase &source);
virtual ~AliTPCCalibRawBase();
-
+
//uses the new decoder which is compatible with the new altro format
Bool_t ProcessEvent(AliTPCRawStreamV3 * const rawStreamV3);
Bool_t ProcessEvent(AliRawReader * const rawReader);
virtual void ProcessBunch(const Int_t /*sector*/, const Int_t /*row*/, const Int_t /*pad*/,
const Int_t /*length*/, const UInt_t /*startTimeBin*/, const UShort_t* /*signal*/) {return; }
virtual void Analyse(){ return; }
-
+
virtual Long64_t Merge(TCollection * /*list*/) {return 0;}
void MergeBase(const AliTPCCalibRawBase *calib);
-
+
//Setters
void SetRangeTime (Int_t firstTimeBin, Int_t lastTimeBin) { fFirstTimeBin=firstTimeBin; fLastTimeBin=lastTimeBin; } //Set range in which the signal is expected
void SetAltroMapping(AliTPCAltroMapping **mapp) { fMapping = mapp; }
Int_t GetDebugLevel() const {return fDebugLevel;}
protected:
- Int_t fFirstTimeBin; // First Time bin used for analysis
- Int_t fLastTimeBin; // Last Time bin used for analysis
-
- Int_t fNevents; // Number of processed events
-
- Int_t fDebugLevel; //! debug level
- Int_t fStreamLevel; //! level of streamer output
+ Int_t fFirstTimeBin; ///< First Time bin used for analysis
+ Int_t fLastTimeBin; ///< Last Time bin used for analysis
+
+ Int_t fNevents; ///< Number of processed events
+
+ Int_t fDebugLevel; //!< debug level
+ Int_t fStreamLevel; //!< level of streamer output
//
- UInt_t fRunNumber; // current run number from event header
- UInt_t fFirstTimeStamp; // First event time stamp
- UInt_t fLastTimeStamp; // Last event time stamp
- UInt_t fTimeStamp; //! time stamp from event header
- UInt_t fEventType; //! current event Type from event header
+ UInt_t fRunNumber; ///< current run number from event header
+ UInt_t fFirstTimeStamp; ///< First event time stamp
+ UInt_t fLastTimeStamp; ///< Last event time stamp
+ UInt_t fTimeStamp; //!< time stamp from event header
+ UInt_t fEventType; //!< current event Type from event header
//
- Double_t fAltroL1Phase; //! L1 Phase
- Float_t fAltroL1PhaseTB; //! L1 Phase in time bins
- Int_t fCurrRCUId; //! Current RCU Id
- Int_t fPrevRCUId; //! Previous RCU Id
- Int_t fCurrDDLNum; //! Current DDL number
- Int_t fPrevDDLNum; //! Current DDL number
- Bool_t fUseL1Phase; // use L1 Phase information?
+ Double_t fAltroL1Phase; //!< L1 Phase
+ Float_t fAltroL1PhaseTB; //!< L1 Phase in time bins
+ Int_t fCurrRCUId; //!< Current RCU Id
+ Int_t fPrevRCUId; //!< Previous RCU Id
+ Int_t fCurrDDLNum; //!< Current DDL number
+ Int_t fPrevDDLNum; //!< Current DDL number
+ Bool_t fUseL1Phase; ///< use L1 Phase information?
//
- TTreeSRedirector *fDebugStreamer; //! debug streamer
+ TTreeSRedirector *fDebugStreamer; //!< debug streamer
//
- AliAltroRawStream *fAltroRawStream; //! pointer to the altro object
- AliTPCAltroMapping **fMapping; //! Altro Mapping object
+ AliAltroRawStream *fAltroRawStream; //!< pointer to the altro object
+ AliTPCAltroMapping **fMapping; //!< Altro Mapping object
+
+ AliTPCROC *fROC; //!< ROC information
- AliTPCROC *fROC; //! ROC information
-
virtual void EndEvent() {++fNevents; return; } //fNevents should be updated in the derived classes in a proper place
virtual void ResetEvent(){ return; } //Reset Event counters
-
-
+
+ /// \cond CLASSIMP
ClassDef(AliTPCCalibRawBase,3) // Calibration base class for raw data processing
-
+ /// \endcond
};
**************************************************************************/
-///////////////////////////////////////////////////////////////////////////////
-// //
-// Class describing the Vdrift dependencies on E,T,P and GasComposition //
-// Authors: Stefan Rossegger, Haavard Helstrup //
-// //
-///////////////////////////////////////////////////////////////////////////////
+/// \class AliTPCCalibVdrift
+///
+/// Class describing the Vdrift dependencies on E,T,P and GasComposition
+///
+/// \author Stefan Rossegger, Haavard Helstrup
#include "TSystem.h"
#include "TObject.h"
#include "AliTPCCalibVdrift.h"
+/// \cond CLASSIMP
ClassImp(AliTPCCalibVdrift)
+/// \endcond
namespace paramDefinitions {
fNominalTemp(0), // nominal temperature in Kelvin
fNominalPress(0) // nominal pressure in mbar
{
- //
- // default constructor
- //
+ /// default constructor
+
}
AliTPCCalibVdrift::AliTPCCalibVdrift(AliTPCSensorTempArray *SensTemp, AliDCSSensor *SensPres, TObject *SensGasComp):
fNominalTemp(0), // nominal temperature in Kelvin
fNominalPress(0) // nominal pressure in mbar
{
- //
- // Standard constructor
- //
+ /// Standard constructor
fSensTemp = SensTemp;
fSensPres = SensPres;
fNominalPress(source.fNominalPress) // nominal pressure in mbar
{
- //
- // Copy constructor
- //
+ /// Copy constructor
+
}
//_____________________________________________________________________________
AliTPCCalibVdrift& AliTPCCalibVdrift::operator=(const AliTPCCalibVdrift& source){
- //
- // assignment operator
- //
+ /// assignment operator
+
if (&source == this) return *this;
new (this) AliTPCCalibVdrift(source);
//_____________________________________________________________________________
AliTPCCalibVdrift::~AliTPCCalibVdrift()
{
- //
- // AliTPCCalibVdrift destructor
- //
+ /// AliTPCCalibVdrift destructor
}
//_____________________________________________________________________________
Double_t AliTPCCalibVdrift::GetPTRelative(UInt_t absTimeSec, Int_t side){
- //
- // Get Relative difference of p/T for given time stamp
- // absTimeSec - absolute time in secounds
- // side: 0 - A side | 1 - C side
- //
+ /// Get Relative difference of p/T for given time stamp
+ /// absTimeSec - absolute time in secounds
+ /// side: 0 - A side | 1 - C side
TTimeStamp tstamp(absTimeSec);
//_____________________________________________________________________________
Double_t AliTPCCalibVdrift::VdriftLinearHyperplaneApprox(Double_t dE, Double_t dT, Double_t dP, Double_t dCco2, Double_t dCn2)
{
- //
- // Returns approximated value for the driftvelocity change (in percent)
- // based on a Hyperplane approximation (~ Taylorapproximation of 2nd order)
- //
+ /// Returns approximated value for the driftvelocity change (in percent)
+ /// based on a Hyperplane approximation (~ Taylorapproximation of 2nd order)
Double_t termE = dE*kdvdE + TMath::Power(dE,2)*kdvdE2nd;
Double_t termT = dT*kdvdT + TMath::Power(dT,2)*kdvdT2nd;
Double_t AliTPCCalibVdrift::GetVdriftNominal()
{
- // returns nominal Driftvelocity at StandardConditions
+ /// returns nominal Driftvelocity at StandardConditions
+
return kstdVdrift;
}
Double_t AliTPCCalibVdrift::GetVdriftChange(Double_t x, Double_t y, Double_t z, UInt_t absTimeSec)
{
- //
- // Calculates Vdrift change in percent of Vdrift_nominal
- // (under nominal conditions) at x,y,z at absolute time (in sec)
- //
+ /// Calculates Vdrift change in percent of Vdrift_nominal
+ /// (under nominal conditions) at x,y,z at absolute time (in sec)
TTimeStamp tstamp(absTimeSec);
Double_t AliTPCCalibVdrift::GetMeanZVdriftChange(Double_t x, Double_t y, UInt_t absTimeSec)
{
- //
- // Calculates Meanvalue in z direction of Vdrift change in percent
- // of Vdrift_nominal (under standard conditions) at position x,y,absTimeSec
- // with help of 'nPopints' base points
- //
-
+ /// Calculates Meanvalue in z direction of Vdrift change in percent
+ /// of Vdrift_nominal (under standard conditions) at position x,y,absTimeSec
+ /// with help of 'nPopints' base points
+
Int_t nPoints = 5;
Double_t vdriftSum = 0;
TGraph *AliTPCCalibVdrift::MakeGraphMeanZVdriftChange(Double_t x, Double_t y, Int_t nPoints)
{
- //
- // Make graph from start time to end time of Mean Drift Velocity in
- // Z direction at given x and y position
- //
+ /// Make graph from start time to end time of Mean Drift Velocity in
+ /// Z direction at given x and y position
UInt_t startTime = fSensTemp->GetStartTime();
UInt_t endTime = fSensTemp->GetEndTime();
/* Copyright(c) 2006-07, ALICE Experiment at CERN, All rights reserved. *
* See cxx source for full Copyright notice */
-////////////////////////////////////////////////////////////////////////
-// Class AliTPCCalibVdrift
-////////////////////////////////////////////////////////////////////////
+/// \class AliTPCCalibVdrift
class TObject;
protected:
//
- AliTPCSensorTempArray *fSensTemp; // Temperature sensors
- AliDCSSensor *fSensPres; // pressure sensor (cavernpress in GRP)
- AliTPCTempMap *fTempMap; // Temperature Map
- TObject *fSensGasComp; // placeholder for GasConzentration infos
+ AliTPCSensorTempArray *fSensTemp; ///< Temperature sensors
+ AliDCSSensor *fSensPres; ///< pressure sensor (cavernpress in GRP)
+ AliTPCTempMap *fTempMap; ///< Temperature Map
+ TObject *fSensGasComp; ///< placeholder for GasConzentration infos
//
// Nominal values
//
- Float_t fNominalTemp; // nominal temperature in Kelvin
- Float_t fNominalPress; // nominal pressure in mbar
+ Float_t fNominalTemp; ///< nominal temperature in Kelvin
+ Float_t fNominalPress; ///< nominal pressure in mbar
+ /// \cond CLASSIMP
ClassDef(AliTPCCalibVdrift,1);
+ /// \endcond
};
#endif
**************************************************************************/
-///////////////////////////////////////////////////////////////////////////////
-// //
-// Class for viewing/visualizing TPC calibration data //
-// base on TTree functionality for visualization //
-// //
-// Create a list of AliTPCCalPads, arrange them in an TObjArray. //
-// Pass this TObjArray to MakeTree and create the calibration Tree //
-// While craating this tree some statistical information are calculated //
-// Open the viewer with this Tree: AliTPCCalibViewer v("CalibTree.root") //
-// Have fun! //
-// EasyDraw("CETmean~-CETmean_mean", "A", "(CETmean~-CETmean_mean)>0") //
-// //
-// If you like to click, we recommand you the //
-// AliTPCCalibViewerGUI //
-// //
-// THE DOCUMENTATION IS STILL NOT COMPLETED !!!! //
-// //
-///////////////////////////////////////////////////////////////////////////////
-
-//
-// ROOT includes
-//
+/// \class AliTPCCalibViewer
+///
+/// Class for viewing/visualizing TPC calibration data
+/// base on TTree functionality for visualization
+///
+/// Create a list of AliTPCCalPads, arrange them in an TObjArray.
+/// Pass this TObjArray to MakeTree and create the calibration Tree
+/// While craating this tree some statistical information are calculated
+/// Open the viewer with this Tree: AliTPCCalibViewer v("CalibTree.root")
+/// Have fun!
+/// EasyDraw("CETmean~-CETmean_mean", "A", "(CETmean~-CETmean_mean)>0")
+///
+/// If you like to click, we recommand you the
+/// AliTPCCalibViewerGUI
+///
+/// THE DOCUMENTATION IS STILL NOT COMPLETED !!!!
+///
+/// ROOT includes
#include <fstream>
#include <iostream>
#include <TKey.h>
#include <TPad.h>
//#include <TCanvas.h>
-#include <TH1.h>
+#include <TH1.h>
#include <TH1F.h>
#include <TLegend.h>
#include <TLine.h>
#include "AliTPCCalibViewer.h"
using std::ifstream;
+/// \cond CLASSIMP
ClassImp(AliTPCCalibViewer)
+/// \endcond
AliTPCCalibViewer::AliTPCCalibViewer()
fTree(0),
fFile(0),
fListOfObjectsToBeDeleted(0),
- fTreeMustBeDeleted(0),
- fAbbreviation(0),
+ fTreeMustBeDeleted(0),
+ fAbbreviation(0),
fAppendString(0)
{
//
fFile(0),
fListOfObjectsToBeDeleted(0),
fTreeMustBeDeleted(0),
- fAbbreviation(0),
+ fAbbreviation(0),
fAppendString(0)
{
- //
- // dummy AliTPCCalibViewer copy constructor
- // not yet working!!!
- //
+ /// dummy AliTPCCalibViewer copy constructor
+ /// not yet working!!!
+
fTree = c.fTree;
fTreeMustBeDeleted = c.fTreeMustBeDeleted;
//fFile = new TFile(*(c.fFile));
fFile(0),
fListOfObjectsToBeDeleted(0),
fTreeMustBeDeleted(0),
- fAbbreviation(0),
+ fAbbreviation(0),
fAppendString(0)
{
- //
- // Constructor that initializes the calibration viewer
- //
+ /// Constructor that initializes the calibration viewer
+
fTree = tree;
fTreeMustBeDeleted = kFALSE;
fListOfObjectsToBeDeleted = new TObjArray();
fFile(0),
fListOfObjectsToBeDeleted(0),
fTreeMustBeDeleted(0),
- fAbbreviation(0),
+ fAbbreviation(0),
fAppendString(0)
-
+
{
- //
- // Constructor to initialize the calibration viewer
- // the file 'fileName' contains the tree 'treeName'
- //
+ /// Constructor to initialize the calibration viewer
+ /// the file 'fileName' contains the tree 'treeName'
+
fFile = new TFile(fileName, "read");
fTree = (TTree*) fFile->Get(treeName);
fTreeMustBeDeleted = kTRUE;
fAbbreviation = "~";
fAppendString = ".fElements";
}
-
+
//____________________________________________________________________________
AliTPCCalibViewer & AliTPCCalibViewer::operator =(const AliTPCCalibViewer & param)
{
- //
- // assignment operator - dummy
- // not yet working!!!
- //
+ /// assignment operator - dummy
+ /// not yet working!!!
+
if (this == ¶m) return (*this);
fTree = param.fTree;
//_____________________________________________________________________________
AliTPCCalibViewer::~AliTPCCalibViewer()
{
- //
- // AliTPCCalibViewer destructor
- // all objects will be deleted, the file will be closed, the pictures will disappear
- //
+ /// AliTPCCalibViewer destructor
+ /// all objects will be deleted, the file will be closed, the pictures will disappear
+
if (fTree && fTreeMustBeDeleted) {
fTree->SetCacheSize(0);
fTree->Delete();
//_____________________________________________________________________________
void AliTPCCalibViewer::Delete(Option_t* /*option*/) {
- //
- // Should be called from AliTPCCalibViewerGUI class only.
- // If you use Delete() do not call the destructor.
- // All objects (except those contained in fListOfObjectsToBeDeleted) will be deleted, the file will be closed.
- //
-
+ /// Should be called from AliTPCCalibViewerGUI class only.
+ /// If you use Delete() do not call the destructor.
+ /// All objects (except those contained in fListOfObjectsToBeDeleted) will be deleted, the file will be closed.
+
if (fTree && fTreeMustBeDeleted) {
fTree->SetCacheSize(0);
fTree->Delete();
}
-const char* AliTPCCalibViewer::AddAbbreviations(const Char_t *c, Bool_t printDrawCommand){
- // Replace all "<variable>" with "<variable><fAbbreviation>" (Adds forgotten "~")
- // but take care on the statistical information, like "CEQmean_Mean"
- // and also take care on correct given variables, like "CEQmean~"
- //
- // For each variable out of "listOfVariables":
- // - 'Save' correct items:
- // - form <replaceString>, take <variable>'s first char, add <removeString>, add rest of <variable>, e.g. "C!#EQmean" (<removeString> = "!#")
- // - For each statistical information in "listOfNormalizationVariables":
- // - ReplaceAll <variable><statistical_Information> with <replaceString><statistical_Information>
- // - ReplaceAll <variable><abbreviation> with <replaceString><abbreviation>, e.g. "CEQmean~" -> "C!#EQmean~"
- // - ReplaceAll <variable><appendStr> with <replaceString><appendStr>, e.g. "CEQmean.fElements" -> "C!#EQmean.fElements"
- //
- // - Do actual replacing:
- // - ReplaceAll <variable> with <variable><fAbbreviation>, e.g. "CEQmean" -> "CEQmean~"
- //
- // - Undo saving:
- // - For each statistical information in "listOfNormalizationVariables":
- // - ReplaceAll <replaceString><statistical_Information> with <variable><statistical_Information>
- // - ReplaceAll <replaceString><abbreviation> with <variable><abbreviation>, e.g. "C!#EQmean~" -> "CEQmean~"
- // - ReplaceAll <replaceString><appendStr> with <variable><appendStr>, e.g. "C!#EQmean.fElements" -> "CEQmean.fElements"
- //
- // Now all the missing "~" should be added.
-
+const char* AliTPCCalibViewer::AddAbbreviations(const Char_t *c, Bool_t printDrawCommand){
+ /// Replace all "<variable>" with "<variable><fAbbreviation>" (Adds forgotten "~")
+ /// but take care on the statistical information, like "CEQmean_Mean"
+ /// and also take care on correct given variables, like "CEQmean~"
+ ///
+ /// For each variable out of "listOfVariables":
+ /// - 'Save' correct items:
+ /// - form <replaceString>, take <variable>'s first char, add <removeString>, add rest of <variable>, e.g. "C!#EQmean" (<removeString> = "!#")
+ /// - For each statistical information in "listOfNormalizationVariables":
+ /// - ReplaceAll <variable><statistical_Information> with <replaceString><statistical_Information>
+ //
/ - ReplaceAll <variable><abbreviation> with <replaceString><abbreviation>, e.g. "CEQmean~" -> "C!#EQmean~"
+ //
/ - ReplaceAll <variable><appendStr> with <replaceString><appendStr>, e.g. "CEQmean.fElements" -> "C!#EQmean.fElements"
+ ///
+ /// - Do actual replacing:
+ /// - ReplaceAll <variable> with <variable><fAbbreviation>, e.g. "CEQmean" -> "CEQmean~"
+ ///
+ /// - Undo saving:
+ /// - For each statistical information in "listOfNormalizationVariables":
+ /// - ReplaceAll <replaceString><statistical_Information> with <variable><statistical_Information>
+ //
/ - ReplaceAll <replaceString><abbreviation> with <variable><abbreviation>, e.g. "C!#EQmean~" -> "CEQmean~"
+ //
/ - ReplaceAll <replaceString><appendStr> with <variable><appendStr>, e.g. "C!#EQmean.fElements" -> "CEQmean.fElements"
+ ///
+ /// Now all the missing "~" should be added.
+
TString str(c);
TString removeString = "!#"; // very unpropable combination of chars
TString replaceString = "";
TObjArray *listOfNormalizationVariables = GetListOfNormalizationVariables();
Int_t nVariables = listOfVariables->GetEntriesFast();
Int_t nNorm = listOfNormalizationVariables->GetEntriesFast();
-
+
Int_t *varLengths = new Int_t[nVariables];
for (Int_t i = 0; i < nVariables; i++) {
varLengths[i] = ((TObjString*)listOfVariables->At(i))->String().Length();
TMath::Sort(nNorm, normLengths, normSort, kTRUE);
// for (Int_t i = 0; i<nNorm; i++) printf("normLengths: %i\n", normLengths[normSort[i]]);
// for (Int_t i = 0; i<nVariables; i++) printf("varLengths: %i\n", varLengths[varSort[i]]);
-
+
for (Int_t ivar = 0; ivar < nVariables; ivar++) {
// ***** save correct tokens *****
// first get the next variable:
// like: str.ReplaceAll("CEQmean~", "C!EQmean~");
str.ReplaceAll(searchString + fAppendString, replaceString + fAppendString);
// like: str.ReplaceAll("CEQmean.fElements", "C!EQmean.fElements");
-
+
// ***** add missing extensions *****
str.ReplaceAll(searchString, replaceString + fAbbreviation);
// like: str.ReplaceAll("CEQmean", "C!EQmean~");
}
-
+
// ***** undo saving *****
str.ReplaceAll(removeString, "");
-
+
if (printDrawCommand) std::cout << "The string looks now like: " << str.Data() << std::endl;
delete [] varLengths;
delete [] normLengths;
//_____________________________________________________________________________
Int_t AliTPCCalibViewer::EasyDraw(const char* drawCommand, const char* sector, const char* cuts, const char* drawOptions, Bool_t writeDrawCommand) const {
- //
- // easy drawing of data, use '~' for abbreviation of '.fElements'
- // example: EasyDraw("CETmean~-CETmean_mean", "A", "(CETmean~-CETmean_mean)>0")
- // sector: sector-number - only the specified sector will be drwawn
- // 'A'/'C' or 'a'/'c' - side A/C will be drawn
- // 'ALL' - whole TPC will be drawn, projected on one side
- // cuts: specifies cuts
- // drawOptions: draw options like 'same'
- // writeDrawCommand: write the command, that is passed to TTree::Draw
- //
+ /// easy drawing of data, use '~' for abbreviation of '.fElements'
+ /// example: EasyDraw("CETmean~-CETmean_mean", "A", "(CETmean~-CETmean_mean)>0")
+ /// sector: sector-number - only the specified sector will be drwawn
+ /// 'A'/'C' or 'a'/'c' - side A/C will be drawn
+ /// 'ALL' - whole TPC will be drawn, projected on one side
+ /// cuts: specifies cuts
+ /// drawOptions: draw options like 'same'
+ /// writeDrawCommand: write the command, that is passed to TTree::Draw
TString drawStr(drawCommand);
TString sectorStr(sector);
Int_t AliTPCCalibViewer::EasyDraw(const char* drawCommand, Int_t sector, const char* cuts, const char* drawOptions, Bool_t writeDrawCommand) const {
- //
- // easy drawing of data, use '~' for abbreviation of '.fElements'
- // example: EasyDraw("CETmean~-CETmean_mean", 34, "(CETmean~-CETmean_mean)>0")
- // sector: sector-number - only the specified sector will be drwawn
- // cuts: specifies cuts
- // drawOptions: draw options like 'same'
- // writeDrawCommand: write the command, that is passed to TTree::Draw
- //
+ /// easy drawing of data, use '~' for abbreviation of '.fElements'
+ /// example: EasyDraw("CETmean~-CETmean_mean", 34, "(CETmean~-CETmean_mean)>0")
+ /// sector: sector-number - only the specified sector will be drwawn
+ /// cuts: specifies cuts
+ /// drawOptions: draw options like 'same'
+ /// writeDrawCommand: write the command, that is passed to TTree::Draw
+
if (sector >= 0 && sector < 72) {
return EasyDraw(drawCommand, Form("%i", sector), cuts, drawOptions, writeDrawCommand);
}
//_____________________________________________________________________________
Int_t AliTPCCalibViewer::EasyDraw1D(const char* drawCommand, const char* sector, const char* cuts, const char* drawOptions, Bool_t writeDrawCommand) const {
- //
- // easy drawing of data, use '~' for abbreviation of '.fElements'
- // example: EasyDraw("CETmean~-CETmean_mean", "A", "(CETmean~-CETmean_mean)>0")
- // sector: sector-number - the specified sector will be drwawn
- // 'A'/'C' or 'a'/'c' - side A/C will be drawn
- // 'ALL' - whole TPC will be drawn, projected on one side
- // cuts: specifies cuts
- // drawOptions: draw options like 'same'
- // writeDrawCommand: write the command, that is passed to TTree::Draw
- //
+ /// easy drawing of data, use '~' for abbreviation of '.fElements'
+ /// example: EasyDraw("CETmean~-CETmean_mean", "A", "(CETmean~-CETmean_mean)>0")
+ /// sector: sector-number - the specified sector will be drwawn
+ /// 'A'/'C' or 'a'/'c' - side A/C will be drawn
+ /// 'ALL' - whole TPC will be drawn, projected on one side
+ /// cuts: specifies cuts
+ /// drawOptions: draw options like 'same'
+ /// writeDrawCommand: write the command, that is passed to TTree::Draw
TString drawStr(drawCommand);
TString sectorStr(sector);
if (writeDrawCommand) std::cout << "fTree->Draw(\"" << drawStr << "\", \"" << cutStr << "\", \"" << drawOptionsStr << "\");" << std::endl;
Int_t returnValue = fTree->Draw(drawStr.Data(), cutStr.Data(), drawOptionsStr.Data());
if (returnValue == -1) return -1;
-
- TObject *obj = (gPad) ? gPad->GetPrimitive("htemp") : 0;
+
+ TObject *obj = (gPad) ? gPad->GetPrimitive("htemp") : 0;
if (!obj) obj = (TH1F*)gDirectory->Get("htemp");
if (!obj) obj = gPad->GetPrimitive("tempHist");
if (!obj) obj = (TH1F*)gDirectory->Get("tempHist");
Int_t AliTPCCalibViewer::EasyDraw1D(const char* drawCommand, Int_t sector, const char* cuts, const char* drawOptions, Bool_t writeDrawCommand) const {
- //
- // easy drawing of data, use '~' for abbreviation of '.fElements'
- // example: EasyDraw("CETmean~-CETmean_mean", 34, "(CETmean~-CETmean_mean)>0")
- // sector: sector-number - the specified sector will be drwawn
- // cuts: specifies cuts
- // drawOptions: draw options like 'same'
- // writeDrawCommand: write the command, that is passed to TTree::Draw
- //
+ /// easy drawing of data, use '~' for abbreviation of '.fElements'
+ /// example: EasyDraw("CETmean~-CETmean_mean", 34, "(CETmean~-CETmean_mean)>0")
+ /// sector: sector-number - the specified sector will be drwawn
+ /// cuts: specifies cuts
+ /// drawOptions: draw options like 'same'
+ /// writeDrawCommand: write the command, that is passed to TTree::Draw
if (sector >= 0 && sector < 72) {
return EasyDraw1D(drawCommand, Form("%i",sector), cuts, drawOptions, writeDrawCommand);
void AliTPCCalibViewer::FormatHistoLabels(TH1 *histo) const {
- //
- // formats title and axis labels of histo
- // removes '.fElements'
- //
+ /// formats title and axis labels of histo
+ /// removes '.fElements'
+
if (!histo) return;
TString replaceString(fAppendString.Data());
TString *str = new TString(histo->GetTitle());
Int_t AliTPCCalibViewer::DrawHisto1D(const char* drawCommand, Int_t sector, const char* cuts, const char *sigmas, Bool_t plotMean, Bool_t plotMedian, Bool_t plotLTM) const {
- //
- // Easy drawing of data, in principle the same as EasyDraw1D
- // Difference: A line for the mean / median / LTM is drawn
- // in 'sigmas' you can specify in which distance to the mean/median/LTM you want to see a line in sigma-units, separated by ';'
- // example: sigmas = "2; 4; 6;" at Begin_Latex 2 #sigma End_Latex, Begin_Latex 4 #sigma End_Latex and Begin_Latex 6 #sigma End_Latex a line is drawn.
- // "plotMean", "plotMedian" and "plotLTM": what kind of lines do you want to see?
- //
+ /// Easy drawing of data, in principle the same as EasyDraw1D
+ /// Difference: A line for the mean / median / LTM is drawn
+ /// in 'sigmas' you can specify in which distance to the mean/median/LTM you want to see a line in sigma-units, separated by ';'
+ /// example: sigmas = "2; 4; 6;" at \f$2 \sigma\f$, \f$4 \sigma\f$ and \f$6 \sigma\f$ a line is drawn.
+ /// "plotMean", "plotMedian" and "plotLTM": what kind of lines do you want to see?
+
if (sector >= 0 && sector < 72) {
return DrawHisto1D(drawCommand, Form("%i", sector), cuts, sigmas, plotMean, plotMedian, plotLTM);
}
Error("DrawHisto1D","The TPC contains only sectors between 0 and 71.");
return -1;
-}
+}
Int_t AliTPCCalibViewer::DrawHisto1D(const char* drawCommand, const char* sector, const char* cuts, const char *sigmas, Bool_t plotMean, Bool_t plotMedian, Bool_t plotLTM) const {
- //
- // Easy drawing of data, in principle the same as EasyDraw1D
- // Difference: A line for the mean / median / LTM is drawn
- // in 'sigmas' you can specify in which distance to the mean/median/LTM you want to see a line in sigma-units, separated by ';'
- // example: sigmas = "2; 4; 6;" at Begin_Latex 2 #sigma End_Latex, Begin_Latex 4 #sigma End_Latex and Begin_Latex 6 #sigma End_Latex a line is drawn.
- // "plotMean", "plotMedian" and "plotLTM": what kind of lines do you want to see?
- //
+ /// Easy drawing of data, in principle the same as EasyDraw1D
+ /// Difference: A line for the mean / median / LTM is drawn
+ /// in 'sigmas' you can specify in which distance to the mean/median/LTM you want to see a line in sigma-units, separated by ';'
+ /// example: sigmas = "2; 4; 6;" at \f$2 \sigma\f$, \f$4 \sigma\f$ and \f$6 \sigma\f$ a line is drawn.
+ /// "plotMean", "plotMedian" and "plotLTM": what kind of lines do you want to see?
+
Int_t oldOptStat = gStyle->GetOptStat();
gStyle->SetOptStat(0000000);
Double_t ltmFraction = 0.8;
-
- TObjArray *sigmasTokens = TString(sigmas).Tokenize(";");
+
+ TObjArray *sigmasTokens = TString(sigmas).Tokenize(";");
TVectorF nsigma(sigmasTokens->GetEntriesFast());
for (Int_t i = 0; i < sigmasTokens->GetEntriesFast(); i++) {
TString str(((TObjString*)sigmasTokens->At(i))->GetString());
TH1F *htemp = (TH1F*)gDirectory->Get("tempHist");
// FIXME is this histogram deleted automatically?
Double_t *values = fTree->GetV1(); // value is the array containing 'entries' numbers
-
+
Double_t mean = TMath::Mean(entries, values);
Double_t median = TMath::Median(entries, values);
Double_t sigma = TMath::RMS(entries, values);
Double_t maxY = htemp->GetMaximum();
-
+
TLegend * legend = new TLegend(.7,.7, .99, .99, "Statistical information");
//fListOfObjectsToBeDeleted->Add(legend);
linePlusSigma->SetLineColor(kGreen+2);
linePlusSigma->SetLineStyle(2+i);
linePlusSigma->Draw();
-
+
TLine* lineMinusSigma = new TLine(ltm - nsigma[i] * ltmRms, 0, ltm - nsigma[i] * ltmRms, maxY);
//fListOfObjectsToBeDeleted->Add(lineMinusSigma);
lineMinusSigma->SetLineColor(kGreen+2);
Int_t AliTPCCalibViewer::SigmaCut(const char* drawCommand, Int_t sector, const char* cuts, Float_t sigmaMax, Bool_t plotMean, Bool_t plotMedian, Bool_t plotLTM, Bool_t pm, const char *sigmas, Float_t sigmaStep) const {
- //
- // Creates a histogram Begin_Latex S(t, #mu, #sigma) End_Latex, where you can see, how much of the data are inside sigma-intervals around the mean value
- // The data of the distribution Begin_Latex f(x, #mu, #sigma) End_Latex are given in 'array', 'n' specifies the length of the array
- // 'mean' and 'sigma' are Begin_Latex #mu End_Latex and Begin_Latex #sigma End_Latex of the distribution in 'array', to be specified by the user
- // 'nbins': number of bins, 'binLow': first bin, 'binUp': last bin
- // sigmaMax: up to which sigma around the mean/median/LTM the histogram is generated (in units of sigma, Begin_Latex t #sigma End_Latex)
- // sigmaStep: the binsize of the generated histogram
- // Begin_Latex
- // f(x, #mu, #sigma) #Rightarrow S(t, #mu, #sigma) = (#int_{#mu}^{#mu + t #sigma} f(x, #mu, #sigma) dx + #int_{#mu}^{#mu - t #sigma} f(x, #mu, #sigma) dx) / (#int_{-#infty}^{+#infty} f(x, #mu, #sigma) dx)
- // End_Latex
- //
- //
- // Creates a histogram, where you can see, how much of the data are inside sigma-intervals
- // around the mean/median/LTM
- // with drawCommand, sector and cuts you specify your input data, see EasyDraw
- // sigmaMax: up to which sigma around the mean/median/LTM the histogram is generated (in units of sigma)
- // sigmaStep: the binsize of the generated histogram
- // plotMean/plotMedian/plotLTM: specifies where to put the center
- //
+ /// Creates a histogram \f$S(t, \mu, \sigma)\f$, where you can see, how much of the data are inside sigma-intervals around the mean value
+ /// The data of the distribution \f$f(x, \mu, \sigma)\f$ are given in 'array', 'n' specifies the length of the array
+ /// 'mean' and 'sigma' are \f$\mu\f$ and \f$\sigma\f$ of the distribution in 'array', to be specified by the user
+ /// 'nbins': number of bins, 'binLow': first bin, 'binUp': last bin
+ /// sigmaMax: up to which sigma around the mean/median/LTM the histogram is generated (in units of sigma, \f$t \sigma\f$)
+ /// sigmaStep: the binsize of the generated histogram
+ /// \f[
+ /// f(x, \mu, \sigma) \Rightarrow S(t, \mu, \sigma) = (\int_{\mu}^{\mu + t \sigma} f(x, \mu, \sigma) dx + \int_{\mu}^{\mu - t \sigma} f(x, \mu, \sigma) dx) / (\int_{-\infty}^{+\infty} f(x, \mu, \sigma) dx)
+ /// \f]
+ ///
+ /// Creates a histogram, where you can see, how much of the data are inside sigma-intervals
+ /// around the mean/median/LTM
+ /// with drawCommand, sector and cuts you specify your input data, see EasyDraw
+ /// sigmaMax: up to which sigma around the mean/median/LTM the histogram is generated (in units of sigma)
+ /// sigmaStep: the binsize of the generated histogram
+ /// plotMean/plotMedian/plotLTM: specifies where to put the center
+
if (sector >= 0 && sector < 72) {
return SigmaCut(drawCommand, Form("%i", sector), cuts, sigmaMax, plotMean, plotMedian, plotLTM, pm, sigmas, sigmaStep);
}
Int_t AliTPCCalibViewer::SigmaCut(const char* drawCommand, const char* sector, const char* cuts, Float_t sigmaMax, Bool_t plotMean, Bool_t plotMedian, Bool_t plotLTM, Bool_t pm, const char *sigmas, Float_t sigmaStep) const {
- //
- // Creates a histogram, where you can see, how much of the data are inside sigma-intervals
- // around the mean/median/LTM
- // with drawCommand, sector and cuts you specify your input data, see EasyDraw
- // sigmaMax: up to which sigma around the mean/median/LTM the histogram is generated (in units of sigma)
- // sigmaStep: the binsize of the generated histogram
- // plotMean/plotMedian/plotLTM: specifies where to put the center
- //
-
+ /// Creates a histogram, where you can see, how much of the data are inside sigma-intervals
+ /// around the mean/median/LTM
+ /// with drawCommand, sector and cuts you specify your input data, see EasyDraw
+ /// sigmaMax: up to which sigma around the mean/median/LTM the histogram is generated (in units of sigma)
+ /// sigmaStep: the binsize of the generated histogram
+ /// plotMean/plotMedian/plotLTM: specifies where to put the center
+
Double_t ltmFraction = 0.8;
-
+
TString drawStr(drawCommand);
Bool_t dangerousToDraw = drawStr.Contains(":") || drawStr.Contains(">>");
if (dangerousToDraw) {
return -1;
}
drawStr += " >> tempHist";
-
+
Int_t entries = EasyDraw1D(drawStr.Data(), sector, cuts, "goff");
TH1F *htemp = (TH1F*)gDirectory->Get("tempHist");
// FIXME is this histogram deleted automatically?
Double_t *values = fTree->GetV1(); // value is the array containing 'entries' numbers
-
+
Double_t mean = TMath::Mean(entries, values);
Double_t median = TMath::Median(entries, values);
Double_t sigma = TMath::RMS(entries, values);
-
+
TLegend * legend = new TLegend(.7,.7, .99, .99, "Cumulative");
//fListOfObjectsToBeDeleted->Add(legend);
TH1F *cutHistoMean = 0;
TH1F *cutHistoMedian = 0;
TH1F *cutHistoLTM = 0;
-
- TObjArray *sigmasTokens = TString(sigmas).Tokenize(";");
+
+ TObjArray *sigmasTokens = TString(sigmas).Tokenize(";");
TVectorF nsigma(sigmasTokens->GetEntriesFast());
for (Int_t i = 0; i < sigmasTokens->GetEntriesFast(); i++) {
TString str(((TObjString*)sigmasTokens->At(i))->GetString());
cutHistoMean->Draw();
DrawLines(cutHistoMean, nsigma, legend, kRed, pm);
} // if (cutHistoMean)
-
+
}
if (plotMedian) {
cutHistoMedian = AliTPCCalibViewer::SigmaCut(htemp, median, sigma, sigmaMax, sigmaStep, pm);
Int_t AliTPCCalibViewer::SigmaCutNew(const char* drawCommand, const char* sector, const char* cuts, Float_t /*sigmaMax*/, Bool_t plotMean, Bool_t plotMedian, Bool_t plotLTM, Bool_t /*pm*/, const char *sigmas, Float_t /*sigmaStep*/) const {
- //
- // Creates a histogram, where you can see, how much of the data are inside sigma-intervals
- // around the mean/median/LTM
- // with drawCommand, sector and cuts you specify your input data, see EasyDraw
- // sigmaMax: up to which sigma around the mean/median/LTM the histogram is generated (in units of sigma)
- // sigmaStep: the binsize of the generated histogram
- // plotMean/plotMedian/plotLTM: specifies where to put the center
- //
-
+ /// Creates a histogram, where you can see, how much of the data are inside sigma-intervals
+ /// around the mean/median/LTM
+ /// with drawCommand, sector and cuts you specify your input data, see EasyDraw
+ /// sigmaMax: up to which sigma around the mean/median/LTM the histogram is generated (in units of sigma)
+ /// sigmaStep: the binsize of the generated histogram
+ /// plotMean/plotMedian/plotLTM: specifies where to put the center
+
// Double_t ltmFraction = 0.8; //unused
-
+
TString drawStr(drawCommand);
drawStr += " >> tempHist";
-
+
Int_t entries = EasyDraw1D(drawStr.Data(), sector, cuts, "goff");
TH1F *htemp = (TH1F*)gDirectory->Get("tempHist");
TGraph *cutGraphMean = 0;
Float_t *xarray = new Float_t[entries];
Float_t *yarray = new Float_t[entries];
TMath::Sort(entries, values, index, kFALSE);
-
+
Double_t mean = TMath::Mean(entries, values);
// Double_t median = TMath::Median(entries, values);
Double_t sigma = TMath::RMS(entries, values);
-
+
TLegend * legend = new TLegend(.7,.7, .99, .99, "Cumulative");
//fListOfObjectsToBeDeleted->Add(legend);
-
+
// parse sigmas string
- TObjArray *sigmasTokens = TString(sigmas).Tokenize(";");
+ TObjArray *sigmasTokens = TString(sigmas).Tokenize(";");
TVectorF nsigma(sigmasTokens->GetEntriesFast());
for (Int_t i = 0; i < sigmasTokens->GetEntriesFast(); i++) {
TString str(((TObjString*)sigmasTokens->At(i))->GetString());
nsigma[i] = sig;
}
delete sigmasTokens;
-
+
if (plotMean) {
for (Int_t i = 0; i < entries; i++) {
- xarray[i] = TMath::Abs(values[index[i]] - mean) / sigma;
+ xarray[i] = TMath::Abs(values[index[i]] - mean) / sigma;
yarray[i] = float(i) / float(entries);
}
cutGraphMean = new TGraph(entries, xarray, yarray);
Int_t AliTPCCalibViewer::Integrate(const char* drawCommand, Int_t sector, const char* cuts, Float_t sigmaMax, Bool_t plotMean, Bool_t plotMedian, Bool_t plotLTM, const char *sigmas, Float_t sigmaStep) const {
- //
- // Creates an integrated histogram Begin_Latex S(t, #mu, #sigma) End_Latex, out of the input distribution distribution Begin_Latex f(x, #mu, #sigma) End_Latex, given in "histogram"
- // "mean" and "sigma" are Begin_Latex #mu End_Latex and Begin_Latex #sigma End_Latex of the distribution in "histogram", to be specified by the user
- // sigmaMax: up to which sigma around the mean/median/LTM you want to integrate
- // if "igma == 0" and "sigmaMax == 0" the whole histogram is integrated
- // "sigmaStep": the binsize of the generated histogram, -1 means, that the maximal reasonable stepsize is used
- // The actual work is done on the array.
- /* Begin_Latex
+ /// Creates an integrated histogram \f$S(t, \mu, \sigma)\f$, out of the input distribution distribution \f$f(x, \mu, \sigma)\f$, given in "histogram"
+ /// "mean" and "sigma" are \f$\mu\f$ and \f$\sigma\f$ of the distribution in "histogram", to be specified by the user
+ /// sigmaMax: up to which sigma around the mean/median/LTM you want to integrate
+ /// if "igma == 0" and "sigmaMax == 0" the whole histogram is integrated
+ /// "sigmaStep": the binsize of the generated histogram, -1 means, that the maximal reasonable stepsize is used
+ /// The actual work is done on the array.
+
+ /* Begin_Latex
f(x, #mu, #sigma) #Rightarrow S(t, #mu, #sigma) = #int_{-#infty}^{#mu + t #sigma} f(x, #mu, #sigma) dx / #int_{-#infty}^{+#infty} f(x, #mu, #sigma) dx
- End_Latex
+ End_Latex
*/
if (sector >= 0 && sector < 72) {
return Integrate(drawCommand, Form("%i", sector), cuts, sigmaMax, plotMean, plotMedian, plotLTM, sigmas, sigmaStep);
}
Error("Integrate","The TPC contains only sectors between 0 and 71.");
return -1;
-
+
}
Int_t AliTPCCalibViewer::IntegrateOld(const char* drawCommand, const char* sector, const char* cuts, Float_t sigmaMax, Bool_t plotMean, Bool_t plotMedian, Bool_t plotLTM, const char *sigmas, Float_t sigmaStep) const {
- //
- // Creates an integrated histogram Begin_Latex S(t, #mu, #sigma) End_Latex, out of the input distribution distribution Begin_Latex f(x, #mu, #sigma) End_Latex, given in "histogram"
- // "mean" and "sigma" are Begin_Latex #mu End_Latex and Begin_Latex #sigma End_Latex of the distribution in "histogram", to be specified by the user
- // sigmaMax: up to which sigma around the mean/median/LTM you want to integrate
- // if "igma == 0" and "sigmaMax == 0" the whole histogram is integrated
- // "sigmaStep": the binsize of the generated histogram, -1 means, that the maximal reasonable stepsize is used
- // The actual work is done on the array.
- /* Begin_Latex
+ /// Creates an integrated histogram \f$S(t, \mu, \sigma)\f$, out of the input distribution distribution \f$f(x, \mu, \sigma)\f$, given in "histogram"
+ /// "mean" and "sigma" are \f$\mu\f$ and \f$\sigma\f$ of the distribution in "histogram", to be specified by the user
+ /// sigmaMax: up to which sigma around the mean/median/LTM you want to integrate
+ /// if "igma == 0" and "sigmaMax == 0" the whole histogram is integrated
+ /// "sigmaStep": the binsize of the generated histogram, -1 means, that the maximal reasonable stepsize is used
+ /// The actual work is done on the array.
+
+ /* Begin_Latex
f(x, #mu, #sigma) #Rightarrow S(t, #mu, #sigma) = #int_{-#infty}^{#mu + t #sigma} f(x, #mu, #sigma) dx / #int_{-#infty}^{+#infty} f(x, #mu, #sigma) dx
- End_Latex
+ End_Latex
*/
-
+
Double_t ltmFraction = 0.8;
-
+
TString drawStr(drawCommand);
drawStr += " >> tempHist";
-
+
Int_t entries = EasyDraw1D(drawStr.Data(), sector, cuts, "goff");
TH1F *htemp = (TH1F*)gDirectory->Get("tempHist");
// FIXME is this histogram deleted automatically?
Double_t *values = fTree->GetV1(); // value is the array containing 'entries' numbers
-
+
Double_t mean = TMath::Mean(entries, values);
Double_t median = TMath::Median(entries, values);
Double_t sigma = TMath::RMS(entries, values);
-
- TObjArray *sigmasTokens = TString(sigmas).Tokenize(";");
+
+ TObjArray *sigmasTokens = TString(sigmas).Tokenize(";");
TVectorF nsigma(sigmasTokens->GetEntriesFast());
for (Int_t i = 0; i < sigmasTokens->GetEntriesFast(); i++) {
TString str(((TObjString*)sigmasTokens->At(i))->GetString());
TH1F *integralHistoMean = 0;
TH1F *integralHistoMedian = 0;
TH1F *integralHistoLTM = 0;
-
+
if (plotMean) {
integralHistoMean = AliTPCCalibViewer::Integrate(htemp, mean, sigma, sigmaMax, sigmaStep);
if (integralHistoMean) {
Int_t AliTPCCalibViewer::Integrate(const char* drawCommand, const char* sector, const char* cuts, Float_t /*sigmaMax*/, Bool_t plotMean, Bool_t plotMedian, Bool_t plotLTM, const char *sigmas, Float_t /*sigmaStep*/) const {
- //
- // Creates an integrated histogram Begin_Latex S(t, #mu, #sigma) End_Latex, out of the input distribution distribution Begin_Latex f(x, #mu, #sigma) End_Latex, given in "histogram"
- // "mean" and "sigma" are Begin_Latex #mu End_Latex and Begin_Latex #sigma End_Latex of the distribution in "histogram", to be specified by the user
- // sigmaMax: up to which sigma around the mean/median/LTM you want to integrate
- // if "igma == 0" and "sigmaMax == 0" the whole histogram is integrated
- // "sigmaStep": the binsize of the generated histogram, -1 means, that the maximal reasonable stepsize is used
- // The actual work is done on the array.
- /* Begin_Latex
+ /// Creates an integrated histogram \f$S(t, \mu, \sigma)\f$, out of the input distribution distribution \f$f(x, \mu, \sigma)\f$, given in "histogram"
+ /// "mean" and "sigma" are \f$\mu\f$ and \f$\sigma\f$ of the distribution in "histogram", to be specified by the user
+ /// sigmaMax: up to which sigma around the mean/median/LTM you want to integrate
+ /// if "igma == 0" and "sigmaMax == 0" the whole histogram is integrated
+ /// "sigmaStep": the binsize of the generated histogram, -1 means, that the maximal reasonable stepsize is used
+ /// The actual work is done on the array.
+
+ /* Begin_Latex
f(x, #mu, #sigma) #Rightarrow S(t, #mu, #sigma) = #int_{-#infty}^{#mu + t #sigma} f(x, #mu, #sigma) dx / #int_{-#infty}^{+#infty} f(x, #mu, #sigma) dx
- End_Latex
+ End_Latex
*/
-
+
Double_t ltmFraction = 0.8;
-
+
TString drawStr(drawCommand);
Bool_t dangerousToDraw = drawStr.Contains(":") || drawStr.Contains(">>");
if (dangerousToDraw) {
return -1;
}
drawStr += " >> tempHist";
-
+
Int_t entries = EasyDraw1D(drawStr.Data(), sector, cuts, "goff");
TH1F *htemp = (TH1F*)gDirectory->Get("tempHist");
TGraph *integralGraphMean = 0;
Float_t *xarray = new Float_t[entries];
Float_t *yarray = new Float_t[entries];
TMath::Sort(entries, values, index, kFALSE);
-
+
Double_t mean = TMath::Mean(entries, values);
Double_t median = TMath::Median(entries, values);
Double_t sigma = TMath::RMS(entries, values);
-
+
// parse sigmas string
- TObjArray *sigmasTokens = TString(sigmas).Tokenize(";");
+ TObjArray *sigmasTokens = TString(sigmas).Tokenize(";");
TVectorF nsigma(sigmasTokens->GetEntriesFast());
for (Int_t i = 0; i < sigmasTokens->GetEntriesFast(); i++) {
TString str(((TObjString*)sigmasTokens->At(i))->GetString());
TLegend * legend = new TLegend(.7,.7, .99, .99, "Integrated histogram");
//fListOfObjectsToBeDeleted->Add(legend);
-
+
if (plotMean) {
for (Int_t i = 0; i < entries; i++) {
- xarray[i] = (values[index[i]] - mean) / sigma;
+ xarray[i] = (values[index[i]] - mean) / sigma;
yarray[i] = float(i) / float(entries);
}
integralGraphMean = new TGraph(entries, xarray, yarray);
}
if (plotMedian) {
for (Int_t i = 0; i < entries; i++) {
- xarray[i] = (values[index[i]] - median) / sigma;
+ xarray[i] = (values[index[i]] - median) / sigma;
yarray[i] = float(i) / float(entries);
}
integralGraphMedian = new TGraph(entries, xarray, yarray);
Double_t ltmRms = 0;
Double_t ltm = GetLTM(entries, values, <mRms, ltmFraction);
for (Int_t i = 0; i < entries; i++) {
- xarray[i] = (values[index[i]] - ltm) / ltmRms;
+ xarray[i] = (values[index[i]] - ltm) / ltmRms;
yarray[i] = float(i) / float(entries);
}
integralGraphLTM = new TGraph(entries, xarray, yarray);
delete [] index;
delete [] xarray;
delete [] yarray;
-
+
if (!plotMean && !plotMedian && !plotLTM) return -1;
legend->Draw();
return entries;
void AliTPCCalibViewer::DrawLines(TH1F *histogram, TVectorF nsigma, TLegend *legend, Int_t color, Bool_t pm) const {
- //
- // Private function for SigmaCut(...) and Integrate(...)
- // Draws lines into the given histogram, specified by "nsigma", the lines are addeed to the legend
- //
-
+ /// Private function for SigmaCut(...) and Integrate(...)
+ /// Draws lines into the given histogram, specified by "nsigma", the lines are addeed to the legend
+
// start to draw the lines, loop over requested sigmas
for (Int_t i = 0; i < nsigma.GetNoElements(); i++) {
- if (!pm) {
+ if (!pm) {
Int_t bin = histogram->GetXaxis()->FindBin(nsigma[i]);
TLine* lineUp = new TLine(nsigma[i], 0, nsigma[i], histogram->GetBinContent(bin));
//fListOfObjectsToBeDeleted->Add(lineUp);
lineLeft2->Draw();
legend->AddEntry(lineLeft2, Form("Fraction(-%f #sigma) = %f",nsigma[i], histogram->GetBinContent(bin)), "l");
}
- } // for (Int_t i = 0; i < nsigma.GetNoElements(); i++)
+ } // for (Int_t i = 0; i < nsigma.GetNoElements(); i++)
}
void AliTPCCalibViewer::DrawLines(TGraph *graph, TVectorF nsigma, TLegend *legend, Int_t color, Bool_t pm) const {
- //
- // Private function for SigmaCut(...) and Integrate(...)
- // Draws lines into the given histogram, specified by "nsigma", the lines are addeed to the legend
- //
-
+ /// Private function for SigmaCut(...) and Integrate(...)
+ /// Draws lines into the given histogram, specified by "nsigma", the lines are addeed to the legend
+
// start to draw the lines, loop over requested sigmas
for (Int_t i = 0; i < nsigma.GetNoElements(); i++) {
- if (!pm) {
+ if (!pm) {
TLine* lineUp = new TLine(nsigma[i], 0, nsigma[i], graph->Eval(nsigma[i]));
//fListOfObjectsToBeDeleted->Add(lineUp);
lineUp->SetLineColor(color);
lineLeft2->Draw();
legend->AddEntry(lineLeft2, Form("Fraction(-%f #sigma) = %f",nsigma[i], graph->Eval(-nsigma[i])), "l");
}
- } // for (Int_t i = 0; i < nsigma.GetNoElements(); i++)
+ } // for (Int_t i = 0; i < nsigma.GetNoElements(); i++)
}
Int_t AliTPCCalibViewer::GetBin(Float_t value, Int_t nbins, Double_t binLow, Double_t binUp){
- // Returns the 'bin' for 'value'
- // The interval between 'binLow' and 'binUp' is divided into 'nbins' equidistant bins
- // avoid index out of bounds error: 'if (bin < binLow) bin = binLow' and vice versa
+ /// Returns the 'bin' for 'value'
+ /// The interval between 'binLow' and 'binUp' is divided into 'nbins' equidistant bins
+ /// avoid index out of bounds error: 'if (bin < binLow) bin = binLow' and vice versa
+
/* Begin_Latex
GetBin(value) = #frac{nbins - 1}{binUp - binLow} #upoint (value - binLow) +1
End_Latex
*/
-
+
Int_t bin = TMath::Nint( (Float_t)(value - binLow) / (Float_t)(binUp - binLow) * (nbins-1) ) + 1;
- // avoid index out of bounds:
+ // avoid index out of bounds:
if (value < binLow) bin = 0;
if (value > binUp) bin = nbins + 1;
return bin;
-
-}
+
+}
Double_t AliTPCCalibViewer::GetLTM(Int_t n, const Double_t *const array, Double_t *const sigma, Double_t fraction){
- //
- // returns the LTM and sigma
- //
+ /// returns the LTM and sigma
+
Double_t *ddata = new Double_t[n];
Double_t mean = 0, lsigma = 0;
UInt_t nPoints = 0;
TH1F* AliTPCCalibViewer::SigmaCut(TH1F *const histogram, Float_t mean, Float_t sigma, Float_t sigmaMax, Float_t sigmaStep, Bool_t pm) {
- //
- // Creates a cumulative histogram Begin_Latex S(t, #mu, #sigma) End_Latex, where you can see, how much of the data are inside sigma-intervals around the mean value
- // The data of the distribution Begin_Latex f(x, #mu, #sigma) End_Latex are given in 'histogram'
- // 'mean' and 'sigma' are Begin_Latex #mu End_Latex and Begin_Latex #sigma End_Latex of the distribution in 'histogram', to be specified by the user
- // sigmaMax: up to which sigma around the mean/median/LTM the histogram is generated (in units of sigma, Begin_Latex t #sigma End_Latex)
- // sigmaStep: the binsize of the generated histogram, -1 means, that the maximal reasonable stepsize is used
- // pm: Decide weather Begin_Latex t > 0 End_Latex (first case) or Begin_Latex t End_Latex arbitrary (secound case)
- // The actual work is done on the array.
- /* Begin_Latex
- f(x, #mu, #sigma) #Rightarrow S(t, #mu, #sigma) = (#int_{#mu}^{#mu + t #sigma} f(x, #mu, #sigma) dx + #int_{#mu}^{#mu - t #sigma} f(x, #mu, #sigma) dx) / (#int_{-#infty}^{+#infty} f(x, #mu, #sigma) dx), for t > 0
- or
+ /// Creates a cumulative histogram \f$S(t, \mu, \sigma)\f$, where you can see, how much of the data are inside sigma-intervals around the mean value
+ /// The data of the distribution \f$f(x, \mu, \sigma)\f$ are given in 'histogram'
+ /// 'mean' and 'sigma' are \f$\mu\f$ and \f$\sigma\f$ of the distribution in 'histogram', to be specified by the user
+ /// sigmaMax: up to which sigma around the mean/median/LTM the histogram is generated (in units of sigma, \f$t \sigma\f$)
+ /// sigmaStep: the binsize of the generated histogram, -1 means, that the maximal reasonable stepsize is used
+ /// pm: Decide weather \f$t > 0\f$ (first case) or \f$t\f$ arbitrary (secound case)
+ /// The actual work is done on the array.
+
+ /* Begin_Latex
+ f(x, #mu, #sigma) #Rightarrow S(t, #mu, #sigma) = (#int_{#mu}^{#mu + t #sigma} f(x, #mu, #sigma) dx + #int_{#mu}^{#mu - t #sigma} f(x, #mu, #sigma) dx) / (#int_{-#infty}^{+#infty} f(x, #mu, #sigma) dx), for t > 0
+ or
f(x, #mu, #sigma) #Rightarrow S(t, #mu, #sigma) = #int_{#mu}^{#mu + t #sigma} f(x, #mu, #sigma) dx / #int_{-#infty}^{+#infty} f(x, #mu, #sigma) dx
- End_Latex
+ End_Latex
Begin_Macro(source)
{
Float_t mean = 0;
TRandom rand(23);
for (Int_t i = 0; i <50000;i++) distribution->Fill(rand.Gaus(mean, sigma));
Float_t *ar = distribution->GetArray();
-
+
TCanvas* macro_example_canvas = new TCanvas("cAliTPCCalibViewer1", "", 350, 350);
macro_example_canvas->Divide(0,3);
TVirtualPad *pad1 = macro_example_canvas->cd(1);
TVirtualPad *pad2 = macro_example_canvas->cd(2);
pad2->SetGridy();
pad2->SetGridx();
-
+
TH1F *shist = AliTPCCalibViewer::SigmaCut(distribution, mean, sigma, sigmaMax);
shist->SetNameTitle("Cumulative","Cumulative S(t, #mu, #sigma)");
- shist->Draw();
+ shist->Draw();
TVirtualPad *pad3 = macro_example_canvas->cd(3);
pad3->SetGridy();
pad3->SetGridx();
TH1F *shistPM = AliTPCCalibViewer::SigmaCut(distribution, mean, sigma, sigmaMax, -1, kTRUE);
- shistPM->Draw();
+ shistPM->Draw();
return macro_example_canvas;
- }
+ }
End_Macro
- */
-
+ */
+
Float_t *array = histogram->GetArray();
Int_t nbins = histogram->GetXaxis()->GetNbins();
Float_t binLow = histogram->GetXaxis()->GetXmin();
Float_t binUp = histogram->GetXaxis()->GetXmax();
return AliTPCCalibViewer::SigmaCut(nbins, array, mean, sigma, nbins, binLow, binUp, sigmaMax, sigmaStep, pm);
-}
-
+}
+
TH1F* AliTPCCalibViewer::SigmaCut(Int_t n, const Float_t *array, Float_t mean, Float_t sigma, Int_t nbins, Float_t binLow, Float_t binUp, Float_t sigmaMax, Float_t sigmaStep, Bool_t pm){
- //
- // Creates a histogram Begin_Latex S(t, #mu, #sigma) End_Latex, where you can see, how much of the data are inside sigma-intervals around the mean value
- // The data of the distribution Begin_Latex f(x, #mu, #sigma) End_Latex are given in 'array', 'n' specifies the length of the array
- // 'mean' and 'sigma' are Begin_Latex #mu End_Latex and Begin_Latex #sigma End_Latex of the distribution in 'array', to be specified by the user
- // 'nbins': number of bins, 'binLow': first bin, 'binUp': last bin
- // sigmaMax: up to which sigma around the mean/median/LTM the histogram is generated (in units of sigma, Begin_Latex t #sigma End_Latex)
- // sigmaStep: the binsize of the generated histogram
- // Here the actual work is done.
-
+ /// Creates a histogram \f$S(t, \mu, \sigma)\f$, where you can see, how much of the data are inside sigma-intervals around the mean value
+ /// The data of the distribution \f$f(x, \mu, \sigma)\f$ are given in 'array', 'n' specifies the length of the array
+ /// 'mean' and 'sigma' are \f$\mu\f$ and \f$\sigma\f$ of the distribution in 'array', to be specified by the user
+ /// 'nbins': number of bins, 'binLow': first bin, 'binUp': last bin
+ /// sigmaMax: up to which sigma around the mean/median/LTM the histogram is generated (in units of sigma, \f$t \sigma\f$)
+ /// sigmaStep: the binsize of the generated histogram
+ /// Here the actual work is done.
+
if (sigma == 0) return 0;
Float_t binWidth = (binUp-binLow)/(nbins - 1);
if (sigmaStep <= 0) sigmaStep = binWidth;
if (pm) kbins = 2 * (Int_t)(sigmaMax * sigma / sigmaStep) + 1;
Float_t kbinLow = !pm ? 0 : -sigmaMax;
Float_t kbinUp = sigmaMax;
- TH1F *hist = new TH1F("sigmaCutHisto","Cumulative; Multiples of #sigma; Fraction of included data", kbins, kbinLow, kbinUp);
+ TH1F *hist = new TH1F("sigmaCutHisto","Cumulative; Multiples of #sigma; Fraction of included data", kbins, kbinLow, kbinUp);
hist->SetDirectory(0);
hist->Reset();
-
+
// calculate normalization
Double_t normalization = 0;
for (Int_t i = 0; i <= n; i++) {
normalization += array[i];
}
-
+
// given units: units from given histogram
// sigma units: in units of sigma
// iDelta: integrate in interval (mean +- iDelta), given units
// x: ofset from mean for integration, given units
- // hist: needs
-
+ // hist: needs
+
// printf("nbins: %i, binLow: %f, binUp: %f \n", nbins, binLow, binUp);
// fill histogram
for (Float_t iDelta = 0; iDelta <= sigmaMax * sigma; iDelta += sigmaStep) {
// printf("++ adding bins: ");
for (Float_t x = binWidth; x <= iDelta; x += binWidth) {
valueP += (mean + x <= binUp) ? array[GetBin(mean + x, nbins, binLow, binUp)] : 0;
- valueM += (mean-binWidth - x >= binLow) ? array[GetBin(mean-binWidth - x, nbins, binLow, binUp)] : 0;
-// printf("%i, ", GetBin(mean + x, nbins, binLow, binUp));
+ valueM += (mean-binWidth - x >= binLow) ? array[GetBin(mean-binWidth - x, nbins, binLow, binUp)] : 0;
+// printf("%i, ", GetBin(mean + x, nbins, binLow, binUp));
}
// printf("\n");
if (valueP / normalization > 100) printf("+++ Error, value to big: %f, normalization with %f will fail +++ \n", valueP, normalization);
TH1F* AliTPCCalibViewer::SigmaCut(Int_t /*n*/, const Double_t */*array*/, Double_t /*mean*/, Double_t /*sigma*/, Int_t /*nbins*/, const Double_t */*xbins*/, Double_t /*sigmaMax*/){
- //
- // SigmaCut for variable binsize
- // NOT YET IMPLEMENTED !!!
- //
+ /// SigmaCut for variable binsize
+ /// NOT YET IMPLEMENTED !!!
+
printf("SigmaCut with variable binsize, Not yet implemented\n");
-
+
return 0;
-}
+}
TH1F* AliTPCCalibViewer::Integrate(TH1F *const histogram, Float_t mean, Float_t sigma, Float_t sigmaMax, Float_t sigmaStep){
- //
- // Creates an integrated histogram Begin_Latex S(t, #mu, #sigma) End_Latex, out of the input distribution distribution Begin_Latex f(x, #mu, #sigma) End_Latex, given in "histogram"
- // "mean" and "sigma" are Begin_Latex #mu End_Latex and Begin_Latex #sigma End_Latex of the distribution in "histogram", to be specified by the user
- // sigmaMax: up to which sigma around the mean/median/LTM you want to integrate
- // if "igma == 0" and "sigmaMax == 0" the whole histogram is integrated
- // "sigmaStep": the binsize of the generated histogram, -1 means, that the maximal reasonable stepsize is used
- // The actual work is done on the array.
- /* Begin_Latex
+ /// Creates an integrated histogram \f$S(t, \mu, \sigma)\f$, out of the input distribution distribution \f$f(x, \mu, \sigma)\f$, given in "histogram"
+ /// "mean" and "sigma" are \f$\mu\f$ and \f$\sigma\f$ of the distribution in "histogram", to be specified by the user
+ /// sigmaMax: up to which sigma around the mean/median/LTM you want to integrate
+ /// if "igma == 0" and "sigmaMax == 0" the whole histogram is integrated
+ /// "sigmaStep": the binsize of the generated histogram, -1 means, that the maximal reasonable stepsize is used
+ /// The actual work is done on the array.
+
+ /* Begin_Latex
f(x, #mu, #sigma) #Rightarrow S(t, #mu, #sigma) = #int_{-#infty}^{#mu + t #sigma} f(x, #mu, #sigma) dx / #int_{-#infty}^{+#infty} f(x, #mu, #sigma) dx
- End_Latex
+ End_Latex
Begin_Macro(source)
{
Float_t mean = 0;
TRandom rand(23);
for (Int_t i = 0; i <50000;i++) distribution->Fill(rand.Gaus(mean, sigma));
Float_t *ar = distribution->GetArray();
-
+
TCanvas* macro_example_canvas = new TCanvas("cAliTPCCalibViewer2", "", 350, 350);
macro_example_canvas->Divide(0,2);
TVirtualPad *pad1 = macro_example_canvas->cd(1);
pad2->SetGridx();
TH1F *shist = AliTPCCalibViewer::Integrate(distribution, mean, sigma, sigmaMax);
shist->SetNameTitle("Cumulative","Cumulative S(t, #mu, #sigma)");
- shist->Draw();
-
- }
+ shist->Draw();
+
+ }
End_Macro
- */
+ */
+
-
Float_t *array = histogram->GetArray();
Int_t nbins = histogram->GetXaxis()->GetNbins();
Float_t binLow = histogram->GetXaxis()->GetXmin();
Float_t binUp = histogram->GetXaxis()->GetXmax();
return AliTPCCalibViewer::Integrate(nbins, array, nbins, binLow, binUp, mean, sigma, sigmaMax, sigmaStep);
-}
+}
TH1F* AliTPCCalibViewer::Integrate(Int_t n, const Float_t *const array, Int_t nbins, Float_t binLow, Float_t binUp, Float_t mean, Float_t sigma, Float_t sigmaMax, Float_t sigmaStep){
- // Creates an integrated histogram Begin_Latex S(t, #mu, #sigma) End_Latex, out of the input distribution distribution Begin_Latex f(x, #mu, #sigma) End_Latex, given in "histogram"
- // "mean" and "sigma" are Begin_Latex #mu End_Latex and Begin_Latex #sigma End_Latex of the distribution in "histogram", to be specified by the user
- // sigmaMax: up to which sigma around the mean/median/LTM you want to integrate
- // if "igma == 0" and "sigmaMax == 0" the whole histogram is integrated
- // "sigmaStep": the binsize of the generated histogram, -1 means, that the maximal reasonable stepsize is used
- // Here the actual work is done.
-
+ /// Creates an integrated histogram \f$S(t, \mu, \sigma)\f$, out of the input distribution distribution \f$f(x, \mu, \sigma)\f$, given in "histogram"
+ /// "mean" and "sigma" are \f$\mu\f$ and \f$\sigma\f$ of the distribution in "histogram", to be specified by the user
+ /// sigmaMax: up to which sigma around the mean/median/LTM you want to integrate
+ /// if "igma == 0" and "sigmaMax == 0" the whole histogram is integrated
+ /// "sigmaStep": the binsize of the generated histogram, -1 means, that the maximal reasonable stepsize is used
+ /// Here the actual work is done.
+
Bool_t givenUnits = kTRUE;
if (sigma != 0 && sigmaMax != 0) givenUnits = kFALSE;
if (givenUnits) {
sigma = 1;
sigmaMax = (binUp - binLow) / 2.;
}
-
+
Float_t binWidth = (binUp-binLow)/(nbins - 1);
if (sigmaStep <= 0) sigmaStep = binWidth;
Int_t kbins = (Int_t)(sigmaMax * sigma / sigmaStep) + 1; // + 1 due to overflow bin in histograms
Float_t kbinLow = givenUnits ? binLow : -sigmaMax;
Float_t kbinUp = givenUnits ? binUp : sigmaMax;
- TH1F *hist = 0;
- if (givenUnits) hist = new TH1F("integratedHisto","Integrated Histogram; Given x; Fraction of included data", kbins, kbinLow, kbinUp);
- if (!givenUnits) hist = new TH1F("integratedHisto","Integrated Histogram; Multiples of #sigma; Fraction of included data", kbins, kbinLow, kbinUp);
+ TH1F *hist = 0;
+ if (givenUnits) hist = new TH1F("integratedHisto","Integrated Histogram; Given x; Fraction of included data", kbins, kbinLow, kbinUp);
+ if (!givenUnits) hist = new TH1F("integratedHisto","Integrated Histogram; Multiples of #sigma; Fraction of included data", kbins, kbinLow, kbinUp);
hist->SetDirectory(0);
hist->Reset();
-
+
// calculate normalization
// printf("calculating normalization, integrating from bin 1 to %i \n", n);
Double_t normalization = 0;
normalization += array[i];
}
// printf("normalization: %f \n", normalization);
-
+
// given units: units from given histogram
// sigma units: in units of sigma
// iDelta: integrate in interval (mean +- iDelta), given units
// x: ofset from mean for integration, given units
- // hist: needs
-
+ // hist: needs
+
// fill histogram
for (Float_t iDelta = mean - sigmaMax * sigma; iDelta <= mean + sigmaMax * sigma; iDelta += sigmaStep) {
// integrate array
//_____________________________________________________________________________
AliTPCCalPad* AliTPCCalibViewer::GetCalPadOld(const char* desiredData, const char* cuts, const char* calPadName) const {
- //
- // creates a AliTPCCalPad out of the 'desiredData'
- // the functionality of EasyDraw1D is used
- // calPadName specifies the name of the created AliTPCCalPad
- // - this takes a while -
- //
+ /// creates a AliTPCCalPad out of the 'desiredData'
+ /// the functionality of EasyDraw1D is used
+ /// calPadName specifies the name of the created AliTPCCalPad
+ /// - this takes a while -
+
TString drawStr(desiredData);
drawStr.Append(":channel");
drawStr.Append(fAbbreviation);
if (entries == -1) return 0;
const Double_t *pchannel = fTree->GetV2();
const Double_t *pvalue = fTree->GetV1();
- for (Int_t i = 0; i < entries; i++)
+ for (Int_t i = 0; i < entries; i++)
roc->SetValue((UInt_t)(pchannel[i]), (Float_t)(pvalue[i]));
}
- return createdCalPad;
+ return createdCalPad;
}
//_____________________________________________________________________________
AliTPCCalPad* AliTPCCalibViewer::GetCalPad(const char* desiredData, const char* cuts, const char* calPadName) const {
- //
- // creates a AliTPCCalPad out of the 'desiredData'
- // the functionality of EasyDraw1D is used
- // calPadName specifies the name of the created AliTPCCalPad
- // - this takes a while -
- //
+ /// creates a AliTPCCalPad out of the 'desiredData'
+ /// the functionality of EasyDraw1D is used
+ /// calPadName specifies the name of the created AliTPCCalPad
+ /// - this takes a while -
+
TString drawStr(desiredData);
drawStr.Append(":channel.fElements:sector");
AliTPCCalPad * createdCalPad = new AliTPCCalPad(calPadName, calPadName);
// AliTPCCalROC * roc = createdCalPad->GetCalROC(sec);
// entries = EasyDraw1D(drawStr.Data(), (Int_t)sec, cuts, "goff");
// if (entries == -1) return 0;
-// for (Int_t i = 0; i < entries; i++)
+// for (Int_t i = 0; i < entries; i++)
// roc->SetValue((UInt_t)(pchannel[i]), (Float_t)(pvalue[i]));
// }
- return createdCalPad;
+ return createdCalPad;
}
//_____________________________________________________________________________
AliTPCCalROC* AliTPCCalibViewer::GetCalROC(const char* desiredData, UInt_t sector, const char* cuts) const {
- //
- // creates a AliTPCCalROC out of the desiredData
- // the functionality of EasyDraw1D is used
- // sector specifies the sector of the created AliTPCCalROC
- //
+ /// creates a AliTPCCalROC out of the desiredData
+ /// the functionality of EasyDraw1D is used
+ /// sector specifies the sector of the created AliTPCCalROC
+
TString drawStr(desiredData);
drawStr.Append(":channel");
drawStr.Append(fAbbreviation);
Int_t entries = EasyDraw1D(drawStr.Data(), (Int_t)sector, cuts, "goff");
if (entries == -1) return 0;
AliTPCCalROC * createdROC = new AliTPCCalROC(sector);
- for (Int_t i = 0; i < entries; i++)
+ for (Int_t i = 0; i < entries; i++)
createdROC->SetValue((UInt_t)(fTree->GetV2()[i]), fTree->GetV1()[i]);
return createdROC;
}
TObjArray* AliTPCCalibViewer::GetListOfVariables(Bool_t printList) {
- //
- // scan the tree - produces a list of available variables in the tree
- // printList: print the list to the screen, after the scan is done
- //
+ /// scan the tree - produces a list of available variables in the tree
+ /// printList: print the list to the screen, after the scan is done
+
TObjArray* arr = new TObjArray();
TObjString* str = 0;
if (!fTree) return 0;
str->String().ReplaceAll("_LTM", "");
str->String().ReplaceAll("_OutlierCutted", "");
str->String().ReplaceAll(".", "");
- if (!arr->FindObject(str) &&
- !(str->String() == "channel" || str->String() == "gx" || str->String() == "gy" ||
- str->String() == "lx" || str->String() == "ly" || str->String() == "pad" ||
+ if (!arr->FindObject(str) &&
+ !(str->String() == "channel" || str->String() == "gx" || str->String() == "gy" ||
+ str->String() == "lx" || str->String() == "ly" || str->String() == "pad" ||
str->String() == "row" || str->String() == "rpad" || str->String() == "sector" ))
arr->Add(str);
}
-
+
// loop over all friends (if there are some) and add them to the list
if (fTree->GetListOfFriends()) {
for (Int_t ifriend = 0; ifriend < fTree->GetListOfFriends()->GetEntries(); ifriend++){
str->String().ReplaceAll("_LTM", "");
str->String().ReplaceAll("_OutlierCutted", "");
str->String().ReplaceAll(".", "");
- if (!(str->String() == "channel" || str->String() == "gx" || str->String() == "gy" ||
- str->String() == "lx" || str->String() == "ly" || str->String() == "pad" ||
+ if (!(str->String() == "channel" || str->String() == "gx" || str->String() == "gy" ||
+ str->String() == "lx" || str->String() == "ly" || str->String() == "pad" ||
str->String() == "row" || str->String() == "rpad" || str->String() == "sector" )){
// insert "<friendName>." at the beginning: (<friendName> is per default "R")
str->String().Insert(0, ".");
}
}
} // if (fTree->GetListOfFriends())
-
+
arr->Sort();
// ((TFriendElement*)gui->GetViewer()->GetTree()->GetListOfFriends()->At(0))->GetTree()->GetListOfBranches()->At(0)->GetName()
// ((TFriendElement*)gui->GetViewer()->GetTree()->GetListOfFriends()->At(0))->GetTree()->GetListOfBranches()
TObjArray* AliTPCCalibViewer::GetListOfNormalizationVariables(Bool_t printList) const{
- //
- // produces a list of available variables for normalization in the tree
- // printList: print the list to the screen, after the scan is done
- //
+ /// produces a list of available variables for normalization in the tree
+ /// printList: print the list to the screen, after the scan is done
+
TObjArray* arr = new TObjArray();
arr->Add(new TObjString("_Mean"));
arr->Add(new TObjString("_Mean_OutlierCutted"));
TFriendElement* AliTPCCalibViewer::AddReferenceTree(const char* filename, const char* treename, const char* refname){
- //
- // add a reference tree to the current tree
- // by default the treename is 'calPads' and the reference treename is 'R'
- //
+ /// add a reference tree to the current tree
+ /// by default the treename is 'calPads' and the reference treename is 'R'
+
TFile *file = new TFile(filename);
fListOfObjectsToBeDeleted->Add(file);
TTree * tree = (TTree*)file->Get(treename);
TObjArray* AliTPCCalibViewer::GetArrayOfCalPads(){
- //
- // Returns a TObjArray with all AliTPCCalPads that are stored in the tree
- // - this takes a while -
- //
+ /// Returns a TObjArray with all AliTPCCalPads that are stored in the tree
+ /// - this takes a while -
+
TObjArray *listOfCalPads = GetListOfVariables();
TObjArray *calPadsArray = new TObjArray();
Int_t numberOfCalPads = listOfCalPads->GetEntries();
char* calPadName = (char*)((TObjString*)(listOfCalPads->At(i)))->GetString().Data();
TString drawCommand = ((TObjString*)(listOfCalPads->At(i)))->GetString();
drawCommand.Append(fAbbreviation.Data());
- AliTPCCalPad* calPad = GetCalPad(drawCommand.Data(), "", calPadName);
- calPadsArray->Add(calPad);
+ AliTPCCalPad* calPad = GetCalPad(drawCommand.Data(), "", calPadName);
+ calPadsArray->Add(calPad);
}
std::cout << std::endl;
listOfCalPads->Delete();
TString* AliTPCCalibViewer::Fit(const char* drawCommand, const char* formula, const char* cuts, Double_t & chi2, TVectorD &fitParam, TMatrixD &covMatrix){
- //
- // fit an arbitrary function, specified by formula into the data, specified by drawCommand and cuts
- // returns chi2, fitParam and covMatrix
- // returns TString with fitted formula
- //
-
- TString formulaStr(formula);
+ /// fit an arbitrary function, specified by formula into the data, specified by drawCommand and cuts
+ /// returns chi2, fitParam and covMatrix
+ /// returns TString with fitted formula
+
+ TString formulaStr(formula);
TString drawStr(drawCommand);
TString cutStr(cuts);
-
+
// abbreviations:
drawStr.ReplaceAll(fAbbreviation, fAppendString);
cutStr.ReplaceAll(fAbbreviation, fAppendString);
formulaStr.ReplaceAll(fAbbreviation, fAppendString);
-
+
formulaStr.ReplaceAll("++", fAbbreviation);
- TObjArray* formulaTokens = formulaStr.Tokenize(fAbbreviation.Data());
+ TObjArray* formulaTokens = formulaStr.Tokenize(fAbbreviation.Data());
Int_t dim = formulaTokens->GetEntriesFast();
-
+
fitParam.ResizeTo(dim);
covMatrix.ResizeTo(dim,dim);
-
+
TLinearFitter* fitter = new TLinearFitter(dim+1, Form("hyp%d",dim));
- fitter->StoreData(kTRUE);
+ fitter->StoreData(kTRUE);
fitter->ClearPoints();
-
+
Int_t entries = Draw(drawStr.Data(), cutStr.Data(), "goff");
if (entries == -1) {
delete formulaTokens;
return new TString("An ERROR has occured during fitting!");
}
- Double_t **values = new Double_t*[dim+1] ;
-
+ Double_t **values = new Double_t*[dim+1] ;
+
for (Int_t i = 0; i < dim + 1; i++){
Int_t centries = 0;
if (i < dim) centries = fTree->Draw(((TObjString*)formulaTokens->At(i))->GetName(), cutStr.Data(), "goff");
else centries = fTree->Draw(drawStr.Data(), cutStr.Data(), "goff");
-
+
if (entries != centries) {
delete [] values;
delete formulaTokens;
return new TString("An ERROR has occured during fitting!");
}
values[i] = new Double_t[entries];
- memcpy(values[i], fTree->GetV1(), entries*sizeof(Double_t));
+ memcpy(values[i], fTree->GetV1(), entries*sizeof(Double_t));
}
-
+
// add points to the fitter
for (Int_t i = 0; i < entries; i++){
Double_t x[1000];
fitter->GetCovarianceMatrix(covMatrix);
chi2 = fitter->GetChisquare();
// chi2 = chi2;
-
+
TString *preturnFormula = new TString(Form("( %e+",fitParam[0])), &returnFormula = *preturnFormula;
-
+
for (Int_t iparam = 0; iparam < dim; iparam++) {
returnFormula.Append(Form("%s*(%e)",((TObjString*)formulaTokens->At(iparam))->GetName(),fitParam[iparam+1]));
if (iparam < dim-1) returnFormula.Append("+");
void AliTPCCalibViewer::MakeTreeWithObjects(const char *fileName, const TObjArray *const array, const char * mapFileName) {
- //
- // Write tree with all available information
- // im mapFileName is speciefied, the Map information are also written to the tree
- // AliTPCCalPad-Objects are written directly to the tree, so that they can be accessd later on
- // (does not work!!!)
- //
+ /// Write tree with all available information
+ /// im mapFileName is speciefied, the Map information are also written to the tree
+ /// AliTPCCalPad-Objects are written directly to the tree, so that they can be accessd later on
+ /// (does not work!!!)
+
AliTPCROC* tpcROCinstance = AliTPCROC::Instance();
TObjArray* mapIROCs = 0;
TVectorF *mapOROCArray = 0;
Int_t mapEntries = 0;
TString* mapNames = 0;
-
+
if (mapFileName) {
TFile mapFile(mapFileName, "read");
-
+
TList* listOfROCs = mapFile.GetListOfKeys();
mapEntries = listOfROCs->GetEntries()/2;
mapIROCs = new TObjArray(mapEntries*2);
mapOROCs = new TObjArray(mapEntries*2);
mapIROCArray = new TVectorF[mapEntries];
mapOROCArray = new TVectorF[mapEntries];
-
+
mapNames = new TString[mapEntries];
for (Int_t ivalue = 0; ivalue < mapEntries; ivalue++) {
TString rocName(((TKey*)(listOfROCs->At(ivalue*2)))->GetName());
mapOROCs->AddAt((AliTPCCalROC*)mapFile.Get((rocName + "OROC").Data()), ivalue);
mapNames[ivalue].Append(rocName);
}
-
+
for (Int_t ivalue = 0; ivalue < mapEntries; ivalue++) {
mapIROCArray[ivalue].ResizeTo(tpcROCinstance->GetNChannels(0));
mapOROCArray[ivalue].ResizeTo(tpcROCinstance->GetNChannels(36));
-
+
for (UInt_t ichannel = 0; ichannel < tpcROCinstance->GetNChannels(0); ichannel++)
(mapIROCArray[ivalue])[ichannel] = ((AliTPCCalROC*)(mapIROCs->At(ivalue)))->GetValue(ichannel);
for (UInt_t ichannel = 0; ichannel < tpcROCinstance->GetNChannels(36); ichannel++)
}
} // if (mapFileName)
-
+
TTreeSRedirector cstream(fileName);
Int_t arrayEntries = array->GetEntries();
-
+
// Read names of AliTPCCalPads and save them in names[]
TString* names = new TString[arrayEntries];
for (Int_t ivalue = 0; ivalue < arrayEntries; ivalue++)
names[ivalue].Append(((AliTPCCalPad*)array->At(ivalue))->GetName());
for (UInt_t isector = 0; isector < tpcROCinstance->GetNSectors(); isector++) {
-
+
TVectorF *vectorArray = new TVectorF[arrayEntries];
for (Int_t ivalue = 0; ivalue < arrayEntries; ivalue++)
vectorArray[ivalue].ResizeTo(tpcROCinstance->GetNChannels(isector));
-
-
+
+
//
// fill vectors of variable per pad
//
posArray[5][ichannel] = posG[1];
posArray[6][ichannel] = (Int_t)(ipad - (Double_t)(tpcROCinstance->GetNPads(isector, irow))/2);
posArray[7][ichannel] = ichannel;
-
+
// loop over array containing AliTPCCalPads
for (Int_t ivalue = 0; ivalue < arrayEntries; ivalue++) {
AliTPCCalPad* calPad = (AliTPCCalPad*) array->At(ivalue);
if (!roc) roc = &dummyROC;
cstream << "calPads" <<
(Char_t*)((names[ivalue] + ".=").Data()) << &vectorArray[ivalue];
- cstream << "calPads" <<
+ cstream << "calPads" <<
(Char_t*)((names[ivalue] + "Pad.=").Data()) << roc;
}
(Char_t*)((mapNames[ivalue] + ".=").Data()) << &mapOROCArray[ivalue];
}
}
-
+
cstream << "calPads" <<
"sector=" << isector;
void AliTPCCalibViewer::MakeTree(const char * fileName, TObjArray * array, const char * mapFileName, AliTPCCalPad *const outlierPad, Float_t ltmFraction) {
- //
- // Write a tree with all available information
- // if mapFileName is speciefied, the Map information are also written to the tree
- // pads specified in outlierPad are not used for calculating statistics
- // The following statistical information on the basis of a ROC are calculated:
- // "_Median", "_Mean", "_LTM", "_RMS_LTM"
- // "_Median_OutlierCutted", "_Mean_OutlierCutted", "_RMS_OutlierCutted", "_LTM_OutlierCutted", "_RMS_LTM_OutlierCutted"
- // The following position variables are available:
- // "row", "pad", "lx", "ly", "gx", "gy", "rpad", "channel"
- //
- // The tree out of this function is the basis for the AliTPCCalibViewer and the AliTPCCalibViewerGUI.
-
+ /// Write a tree with all available information
+ /// if mapFileName is speciefied, the Map information are also written to the tree
+ /// pads specified in outlierPad are not used for calculating statistics
+ /// The following statistical information on the basis of a ROC are calculated:
+ /// "_Median", "_Mean", "_LTM", "_RMS_LTM"
+ /// "_Median_OutlierCutted", "_Mean_OutlierCutted", "_RMS_OutlierCutted", "_LTM_OutlierCutted", "_RMS_LTM_OutlierCutted"
+ /// The following position variables are available:
+ /// "row", "pad", "lx", "ly", "gx", "gy", "rpad", "channel"
+ ///
+ /// The tree out of this function is the basis for the AliTPCCalibViewer and the AliTPCCalibViewerGUI.
+
AliTPCROC* tpcROCinstance = AliTPCROC::Instance();
TObjArray* mapIROCs = 0;
TVectorF *mapOROCArray = 0;
Int_t mapEntries = 0;
TString* mapNames = 0;
-
+
if (mapFileName) {
TFile mapFile(mapFileName, "read");
-
+
TList* listOfROCs = mapFile.GetListOfKeys();
mapEntries = listOfROCs->GetEntries()/2;
mapIROCs = new TObjArray(mapEntries*2);
mapOROCs = new TObjArray(mapEntries*2);
mapIROCArray = new TVectorF[mapEntries];
mapOROCArray = new TVectorF[mapEntries];
-
+
mapNames = new TString[mapEntries];
for (Int_t ivalue = 0; ivalue < mapEntries; ivalue++) {
TString rocName(((TKey*)(listOfROCs->At(ivalue*2)))->GetName());
mapOROCs->AddAt((AliTPCCalROC*)mapFile.Get((rocName + "OROC").Data()), ivalue);
mapNames[ivalue].Append(rocName);
}
-
+
for (Int_t ivalue = 0; ivalue < mapEntries; ivalue++) {
mapIROCArray[ivalue].ResizeTo(tpcROCinstance->GetNChannels(0));
mapOROCArray[ivalue].ResizeTo(tpcROCinstance->GetNChannels(36));
-
+
for (UInt_t ichannel = 0; ichannel < tpcROCinstance->GetNChannels(0); ichannel++)
(mapIROCArray[ivalue])[ichannel] = ((AliTPCCalROC*)(mapIROCs->At(ivalue)))->GetValue(ichannel);
for (UInt_t ichannel = 0; ichannel < tpcROCinstance->GetNChannels(36); ichannel++)
(mapOROCArray[ivalue])[ichannel] = ((AliTPCCalROC*)(mapOROCs->At(ivalue)))->GetValue(ichannel);
}
-
+
} // if (mapFileName)
-
+
TTreeSRedirector cstream(fileName,"recreate");
Int_t arrayEntries = 0;
if (array) arrayEntries = array->GetEntries();
-
+
TString* names = new TString[arrayEntries];
for (Int_t ivalue = 0; ivalue < arrayEntries; ivalue++)
names[ivalue].Append(((AliTPCCalPad*)array->At(ivalue))->GetName());
-
+
for (UInt_t isector = 0; isector < tpcROCinstance->GetNSectors(); isector++) {
//
// get statistic for given sector
TVectorF rmsWithOut(arrayEntries);
TVectorF ltmWithOut(arrayEntries);
TVectorF ltmrmsWithOut(arrayEntries);
-
+
TVectorF *vectorArray = new TVectorF[arrayEntries];
for (Int_t ivalue = 0; ivalue < arrayEntries; ivalue++){
vectorArray[ivalue].ResizeTo(tpcROCinstance->GetNChannels(isector));
vectorArray[ivalue].SetUniqueID(array->UncheckedAt(ivalue)->GetUniqueID());
// printf("UniqueID: %d\n",vectorArray[ivalue].GetUniqueID());
}
-
+
for (Int_t ivalue = 0; ivalue < arrayEntries; ivalue++) {
AliTPCCalPad* calPad = (AliTPCCalPad*) array->At(ivalue);
AliTPCCalROC* calROC = calPad->GetCalROC(isector);
ltmrmsWithOut[ivalue] = 0.;
}
}
-
+
//
// fill vectors of variable per pad
//
TVectorF *posArray = new TVectorF[8];
for (Int_t ivalue = 0; ivalue < 8; ivalue++)
posArray[ivalue].ResizeTo(tpcROCinstance->GetNChannels(isector));
-
+
Float_t posG[3] = {0};
Float_t posL[3] = {0};
Int_t ichannel = 0;
posArray[5][ichannel] = posG[1];
posArray[6][ichannel] = (Int_t)(ipad - (Double_t)(tpcROCinstance->GetNPads(isector, irow))/2);
posArray[7][ichannel] = ichannel;
-
+
// loop over array containing AliTPCCalPads
for (Int_t ivalue = 0; ivalue < arrayEntries; ivalue++) {
AliTPCCalPad* calPad = (AliTPCCalPad*) array->At(ivalue);
ichannel++;
}
}
-
+
cstream << "calPads" <<
"sector=" << isector;
-
+
for (Int_t ivalue = 0; ivalue < arrayEntries; ivalue++) {
if (outlierPad==0) {
cstream << "calPads" <<
}
}
delete arrtitle;*/
-
+
}
-
+
for (Int_t ivalue = 0; ivalue < arrayEntries; ivalue++) {
cstream << "calPads" <<
(Char_t*)((names[ivalue] + ".=").Data()) << &vectorArray[ivalue];
}
-
+
if (mapFileName) {
for (Int_t ivalue = 0; ivalue < mapEntries; ivalue++) {
if (isector < 36)
"gy.=" << &posArray[5] <<
"rpad.=" << &posArray[6] <<
"channel.=" << &posArray[7];
-
+
cstream << "calPads" <<
"\n";
-
+
delete[] posArray;
delete[] vectorArray;
}
}
}
void AliTPCCalibViewer::MakeCalPadAliases(TTree * tree){
- //
- // make standard aliases for standard calibration trees
- //
+ /// make standard aliases for standard calibration trees
+
tree->SetAlias("Pad0","MapPadLength.fElements==7.5"); // pad types
tree->SetAlias("Pad1","MapPadLength.fElements==10.0");
tree->SetAlias("Pad2","MapPadLength.fElements==15.0");
tree->SetAlias("ly","(ly.fElements+((sector<36)*(2*((sector%36)<18)-1)*0.2)+((sector>=36)*(2*((sector%36)<18)-1)*0.3))"); // correction for bug in tpcROCinstance->GetPositionLocal(isector, irow, ipad, posL);
tree->SetAlias("dRowNorm0","(row.fElements/32-1)"); // normalized distance to the center of the chamber in lx (-1,1)
- tree->SetAlias("dRowNorm1","(row.fElements/32-1)"); //
+ tree->SetAlias("dRowNorm1","(row.fElements/32-1)"); //
tree->SetAlias("dRowNorm2","((row.fElements-63)/16-1)"); //
tree->SetAlias("dRowNorm","(row.fElements<63)*(row.fElements/32-1)+(row.fElements>63)*((row.fElements-63)/16-1)");
tree->SetAlias("dPhiNorm","(ly/lx.fElements)/(pi/18)"); // normalized distance to the center of the chamber in phi (-1,1)
}
void AliTPCCalibViewer::MakeTree(const char *outPutFileName, const Char_t *inputFileName, AliTPCCalPad *outlierPad, Float_t ltmFraction, const char *mapFileName ){
- //
- // Function to create a calibration Tree with all available information.
- // See also documentation to MakeTree
- // the file "inputFileName" must be in the following format (see also CreateObjectList):
- // (each colum separated by tabs, "dependingOnType" can have 2 or 3 colums)
- //
- // type path dependingOnType
- //
- // type == "CE":
- // dependingOnType = CETmean CEQmean CETrms
- //
- // type == "Pulser":
- // dependingOnType = PulserTmean PulsterQmean PulserTrms
- //
- // type == "Pedestals":
- // dependingOnType = Pedestals Noise
- //
- // type == "CalPad":
- // dependingOnType = NameInFile NameToWriteToFile
- //
- //
+ /// Function to create a calibration Tree with all available information.
+ /// See also documentation to MakeTree
+ /// the file "inputFileName" must be in the following format (see also CreateObjectList):
+ /// (each colum separated by tabs, "dependingOnType" can have 2 or 3 colums)
+ ///
+ /// type path dependingOnType
+ ///
+ /// type == "CE":
+ /// dependingOnType = CETmean CEQmean CETrms
+ ///
+ /// type == "Pulser":
+ /// dependingOnType = PulserTmean PulsterQmean PulserTrms
+ ///
+ /// type == "Pedestals":
+ /// dependingOnType = Pedestals Noise
+ ///
+ /// type == "CalPad":
+ /// dependingOnType = NameInFile NameToWriteToFile
+
TObjArray objArray;
CreateObjectList(inputFileName, &objArray);
- MakeTree(outPutFileName, &objArray, mapFileName, outlierPad, ltmFraction);
+ MakeTree(outPutFileName, &objArray, mapFileName, outlierPad, ltmFraction);
}
void AliTPCCalibViewer::CreateObjectList(const Char_t *filename, TObjArray *calibObjects){
- //
- // Function to create a TObjArray out of a given file
- // the file must be in the following format:
- // (each colum separated by tabs, "dependingOnType" can have 2 or 3 colums)
- //
- //
- // type path dependingOnType
- //
- // type == "CE":
- // dependingOnType = CETmean CEQmean CETrms
- //
- // type == "Pulser":
- // dependingOnType = PulserTmean PulsterQmean PulserTrms
- //
- // type == "Pedestals":
- // dependingOnType = Pedestals Noise
- //
- // type == "CalPad":
- // dependingOnType = NameInFile NameToWriteToFile
- //
- //
- //
+ /// Function to create a TObjArray out of a given file
+ /// the file must be in the following format:
+ /// (each colum separated by tabs, "dependingOnType" can have 2 or 3 colums)
+ ///
+ /// type path dependingOnType
+ ///
+ /// type == "CE":
+ /// dependingOnType = CETmean CEQmean CETrms
+ ///
+ /// type == "Pulser":
+ /// dependingOnType = PulserTmean PulsterQmean PulserTrms
+ ///
+ /// type == "Pedestals":
+ /// dependingOnType = Pedestals Noise
+ ///
+ /// type == "CalPad":
+ /// dependingOnType = NameInFile NameToWriteToFile
+
if ( calibObjects == 0x0 ) return;
ifstream in;
in.open(filename);
fprintf(stderr,"Error: cannot open list file '%s'", filename);
return;
}
-
+
AliTPCCalPad *calPad=0x0;
-
+
TString sFile;
sFile.ReadFile(in);
in.close();
-
+
TObjArray *arrFileLine = sFile.Tokenize("\n");
TIter nextLine(arrFileLine);
-
+
TObjString *sObjLine = 0x0;
while ( (sObjLine = (TObjString*)nextLine()) ){
TString sLine(sObjLine->GetString());
-
+
TObjArray *arrCol = sLine.Tokenize("\t");
Int_t nCols = arrCol->GetEntriesFast();
-
+
TObjString *sObjType = (TObjString*)(arrCol->At(0));
TObjString *sObjFileName = (TObjString*)(arrCol->At(1));
TObjString *sObjName = 0x0;
-
+
if ( !sObjType || !sObjFileName ) continue;
TString sType(sObjType->GetString());
TString sFileName(sObjFileName->GetString());
fprintf(stderr,"File not found: '%s'", sFileName.Data());
continue;
}
-
+
if ( sType == "CE" ){ // next three colums are the names for CETmean, CEQmean and CETrms
AliTPCCalibCE *ce = (AliTPCCalibCE*)fIn->Get("AliTPCCalibCE");
- calPad = new AliTPCCalPad((TObjArray*)ce->GetCalPadT0());
+ calPad = new AliTPCCalPad((TObjArray*)ce->GetCalPadT0());
if (nCols > 2) { // check, if the name is provided
sObjName = (TObjString*)(arrCol->At(2));
calPad->SetNameTitle(sObjName->GetString().Data(), sObjName->GetString().Data());
}
else calPad->SetNameTitle("CETmean","CETmean");
calibObjects->Add(calPad);
-
- calPad = new AliTPCCalPad((TObjArray*)ce->GetCalPadQ());
+
+ calPad = new AliTPCCalPad((TObjArray*)ce->GetCalPadQ());
if (nCols > 3) { // check, if the name is provided
sObjName = (TObjString*)(arrCol->At(3));
calPad->SetNameTitle(sObjName->GetString().Data(), sObjName->GetString().Data());
}
else calPad->SetNameTitle("CEQmean","CEQmean");
- calibObjects->Add(calPad);
-
+ calibObjects->Add(calPad);
+
calPad = new AliTPCCalPad((TObjArray*)ce->GetCalPadRMS());
if (nCols > 4) { // check, if the name is provided
sObjName = (TObjString*)(arrCol->At(4));
calPad->SetNameTitle(sObjName->GetString().Data(), sObjName->GetString().Data());
}
else calPad->SetNameTitle("CETrms","CETrms");
- calibObjects->Add(calPad);
-
+ calibObjects->Add(calPad);
+
} else if ( sType == "Pulser") {
AliTPCCalibPulser *sig = (AliTPCCalibPulser*)fIn->Get("AliTPCCalibPulser");
-
- calPad = new AliTPCCalPad((TObjArray*)sig->GetCalPadT0());
+
+ calPad = new AliTPCCalPad((TObjArray*)sig->GetCalPadT0());
if (nCols > 2) {
sObjName = (TObjString*)(arrCol->At(2));
calPad->SetNameTitle(sObjName->GetString().Data(), sObjName->GetString().Data());
}
else calPad->SetNameTitle("PulserTmean","PulserTmean");
calibObjects->Add(calPad);
-
- calPad = new AliTPCCalPad((TObjArray*)sig->GetCalPadQ());
+
+ calPad = new AliTPCCalPad((TObjArray*)sig->GetCalPadQ());
if (nCols > 3) {
sObjName = (TObjString*)(arrCol->At(3));
calPad->SetNameTitle(sObjName->GetString().Data(), sObjName->GetString().Data());
}
else calPad->SetNameTitle("PulserQmean","PulserQmean");
- calibObjects->Add(calPad);
-
+ calibObjects->Add(calPad);
+
calPad = new AliTPCCalPad((TObjArray*)sig->GetCalPadRMS());
if (nCols > 4) {
sObjName = (TObjString*)(arrCol->At(4));
calPad->SetNameTitle(sObjName->GetString().Data(), sObjName->GetString().Data());
}
else calPad->SetNameTitle("PulserTrms","PulserTrms");
- calibObjects->Add(calPad);
-
+ calibObjects->Add(calPad);
+
} else if ( sType == "Pedestals") {
AliTPCCalibPedestal *ped = (AliTPCCalibPedestal*)fIn->Get("AliTPCCalibPedestal");
-
- calPad = new AliTPCCalPad((TObjArray*)ped->GetCalPadPedestal());
+
+ calPad = new AliTPCCalPad((TObjArray*)ped->GetCalPadPedestal());
if (nCols > 2) {
sObjName = (TObjString*)(arrCol->At(2));
calPad->SetNameTitle(sObjName->GetString().Data(), sObjName->GetString().Data());
}
else calPad->SetNameTitle("Pedestals","Pedestals");
calibObjects->Add(calPad);
-
- calPad = new AliTPCCalPad((TObjArray*)ped->GetCalPadRMS());
+
+ calPad = new AliTPCCalPad((TObjArray*)ped->GetCalPadRMS());
if (nCols > 3) {
sObjName = (TObjString*)(arrCol->At(3));
calPad->SetNameTitle(sObjName->GetString().Data(), sObjName->GetString().Data());
}
else calPad->SetNameTitle("Noise","Noise");
- calibObjects->Add(calPad);
-
+ calibObjects->Add(calPad);
+
} else if ( sType == "CalPad") {
if (nCols > 2) sObjName = (TObjString*)(arrCol->At(2));
else continue;
/* $Id: AliTPCCalibViewer.h,v */
-///////////////////////////////////////////////////
-// //
-// TPC calibration viewer/visualization class //
-// use Tree for visualization //
-///////////////////////////////////////////////////
+/// \class AliTPCCalibViewer
+///
+/// \brief TPC calibration viewer/visualization class
+/// use Tree for visualization
class TFile;
class TLegend;
protected:
- TTree* fTree; // tree containing visualization data (e.g. written by AliTPCCalPad::MakeTree(...)
- TFile* fFile; // file that contains a calPads tree (e.g. written by AliTPCCalPad::MakeTree(...)
- TObjArray* fListOfObjectsToBeDeleted; //Objects, that will be deleted when the destructor ist called
- Bool_t fTreeMustBeDeleted; // decides weather the tree must be deleted in destructor or not
- TString fAbbreviation; // the abreviation for '.fElements'
- TString fAppendString; // '.fElements', stored in a TStrig
+ TTree* fTree; ///< tree containing visualization data (e.g. written by AliTPCCalPad::MakeTree(...)
+ TFile* fFile; ///< file that contains a calPads tree (e.g. written by AliTPCCalPad::MakeTree(...)
+ TObjArray* fListOfObjectsToBeDeleted; ///< Objects, that will be deleted when the destructor ist called
+ Bool_t fTreeMustBeDeleted; ///< decides weather the tree must be deleted in destructor or not
+ TString fAbbreviation; ///< the abreviation for '.fElements'
+ TString fAppendString; ///< '.fElements', stored in a TStrig
void DrawLines(TH1F *cutHistoMean, TVectorF nsigma, TLegend *legend, Int_t color, Bool_t pm) const;
void DrawLines(TGraph *graph, TVectorF nsigma, TLegend *legend, Int_t color, Bool_t pm) const;
+ /// \cond CLASSIMP
ClassDef(AliTPCCalibViewer,1) // TPC calibration viewer class
+ /// \endcond
};
#endif
**************************************************************************/
-///////////////////////////////////////////////////////////////////////////////
-// //
-// GUI for the AliTPCCalibViewer //
-// used for the calibration monitor //
-// All functionalities of the AliTPCCalibViewer are here available
-//
-// Example usage: //
-/*
- aliroot
- AliTPCCalibViewerGUI::ShowGUI("CalibTree.root")
-
-*/
-// //
-// //
-///////////////////////////////////////////////////////////////////////////////
-
+/// \class AliTPCCalibViewerGUI
+/// \brief GUI for the AliTPCCalibViewer
+/// used for the calibration monitor
+/// All functionalities of the AliTPCCalibViewer are here available
+///
+/// Example usage:
+/// ~~~
+/// aliroot
+/// AliTPCCalibViewerGUI::ShowGUI("CalibTree.root")
+/// ~~~
#include "AliTPCCalibViewerGUI.h"
#include "AliTPCCalPad.h"
+/// \cond CLASSIMP
ClassImp(AliTPCCalibViewerGUI)
+/// \endcond
AliTPCCalibViewerGUI::AliTPCCalibViewerGUI(const TGWindow *p, UInt_t w, UInt_t h, char* fileName)
: TGCompositeFrame(p, w, h),
void AliTPCCalibViewerGUI::DrawGUI(const TGWindow */*p*/, UInt_t w, UInt_t h) {
- //
- // draw the GUI
- //
- // ======================================================================
+ /// draw the GUI
+
// ************************* Display everything *************************
- // ======================================================================
-
+
SetCleanup(kDeepCleanup);
// *****************************************************************************
void AliTPCCalibViewerGUI::SetInitialValues() {
- //
- // Set the default button states
- //
+ /// Set the default button states
+
fChkAuto->SetState(kButtonUp);
fRadioPredefined->SetState(kButtonDown);
fRadioRaw->SetState(kButtonDown);
fTxtRefName(0),
fInitialized(0)
{
- //
- // dummy AliTPCCalibViewerGUI copy constructor
- //
+ /// dummy AliTPCCalibViewerGUI copy constructor
+
}
AliTPCCalibViewerGUI & AliTPCCalibViewerGUI::operator =(const AliTPCCalibViewerGUI & /*param*/) {
- //
- // dummy assignment operator
- //
+ /// dummy assignment operator
+
return (*this);
}
AliTPCCalibViewerGUI::~AliTPCCalibViewerGUI() {
- //
- // Destructor
- //
+ /// Destructor
+
if (fCanvMain && fCanvMain->GetCanvas()) {
for (Int_t i = 0; i < fCanvMain->GetCanvas()->GetListOfPrimitives()->GetEntries(); i++) {
if (strcmp(fCanvMain->GetCanvas()->GetListOfPrimitives()->At(i)->ClassName(), "TFrame") != 0)
void AliTPCCalibViewerGUI::Initialize(const char* fileName, const char* treeName) {
- //
- // initialize the GUI with a calibrationTree from fileName
- //
-
+ /// initialize the GUI with a calibrationTree from fileName
+
// create AliTPCCalibViewer object, which will be used for generating all drawings
if (fViewer) delete fViewer;
fViewer = new AliTPCCalibViewer(fileName, treeName);
void AliTPCCalibViewerGUI::Initialize(AliTPCCalibViewer *viewer) {
- //
- // initializes the GUI with default settings and opens tree for drawing
- //
-
+ /// initializes the GUI with default settings and opens tree for drawing
+
fViewer = viewer;
TString selectedVariable("");
TString selectedNormalization("");
}
void AliTPCCalibViewerGUI::Reset(){
- //
- // reset variables, delete calib viewer
- //
+ /// reset variables, delete calib viewer
+
if (fViewer) delete fViewer;
fListVariables->RemoveAll();
fListNormalization->RemoveAll();
}
void AliTPCCalibViewerGUI::HandleButtonsGeneral(Int_t id) {
- //
- // handles mutual radio button exclusions
- // for general Tab
- //
+ /// handles mutual radio button exclusions
+ /// for general Tab
+
if (id == -1) {
TGButton *btn = (TGButton *) gTQSender;
id = btn->WidgetId();
void AliTPCCalibViewerGUI::HandleButtons1D(Int_t id) {
- //
- // handles mutual radio button exclusions
- // 1D-Tab buttons
- //
-
+ /// handles mutual radio button exclusions
+ /// 1D-Tab buttons
+
if (id == -1) {
TGButton *btn = (TGButton *) gTQSender;
id = btn->WidgetId();
void AliTPCCalibViewerGUI::HandleButtonsStat(Int_t id) {
- //
- // handles statistic check boxes
- // checks each checkbox if checked
- // if the checkbox is checked, appends 'n' for name, 'e' for entries, ...
- // to a TString, passes this TString to gStyle->SetOptStat(...)
- //
+ /// handles statistic check boxes
+ /// checks each checkbox if checked
+ /// if the checkbox is checked, appends 'n' for name, 'e' for entries, ...
+ /// to a TString, passes this TString to gStyle->SetOptStat(...)
+
if (id == -1) {
TGButton *btn = (TGButton *) gTQSender;
id = btn->WidgetId();
void AliTPCCalibViewerGUI::HandleButtonsCuts(Int_t id) {
- //
- // handles mutual radio button exclusions
- // right side buttons
- //
+ /// handles mutual radio button exclusions
+ /// right side buttons
+
if (id == -1) {
TGButton *btn = (TGButton *) gTQSender;
id = btn->WidgetId();
void AliTPCCalibViewerGUI::HandleButtonsNoRedraw(Int_t id) {
- //
- // handles label & scaling checkboxes
- // without redrawing (not necessary, faster like this)
- //
+ /// handles label & scaling checkboxes
+ /// without redrawing (not necessary, faster like this)
+
if (id == -1) {
TGButton *btn = (TGButton *) gTQSender;
id = btn->WidgetId();
void AliTPCCalibViewerGUI::ReplacePlaceHolders(TString &str)
{
- //
- // replace the defined placeholders in the custom draw string and cut string
- //
+ /// replace the defined placeholders in the custom draw string and cut string
+
TString drawPlaceHolder("#draw#");
TString normPlaceHolder("#norm#");
}
void AliTPCCalibViewerGUI::DoNewSelection() {
- //
- // decides whether to redraw if user makes another selection
- //
+ /// decides whether to redraw if user makes another selection
+
if (fChkAuto->GetState() == kButtonDown) DoDraw();
}
TString* AliTPCCalibViewerGUI::GetDrawString() {
- //
- // create the draw string out of selection
- //
-
+ /// create the draw string out of selection
+
// specify data to plot
TString desiredData("");
if (!fListVariables->GetSelectedEntry()) return 0;
TString* AliTPCCalibViewerGUI::GetSectorString() {
- //
- // create the sector string out of selection
- //
+ /// create the sector string out of selection
TString sectorStr("");
if (fRadioTPC->GetState() == kButtonDown)
TString* AliTPCCalibViewerGUI::GetCutString() {
- //
- // create the cut string out of selection
- //
-
+ /// create the cut string out of selection
+
TString cutsStr("");
if (fChkCutZero->GetState() == kButtonDown) {
TString cutZerosStr(GetDrawString()->Data());
void AliTPCCalibViewerGUI::DoDraw() {
- //
- // main method for drawing according to user selection
- //
-
+ /// main method for drawing according to user selection
+
// specify data to plot:
if (!GetDrawString()) return;
TString desiredData(GetDrawString()->Data());
void AliTPCCalibViewerGUI::DoFit() {
- //
- // main method for fitting
- //
-
+ /// main method for fitting
+
Double_t chi2 = 0;
TVectorD fitParam(0);
TMatrixD covMatrix(0,0);
void AliTPCCalibViewerGUI::DoExport() {
- //
- // function to export a CalPad to Cint
- //
+ /// function to export a CalPad to Cint
+
if ( fRadio2D->GetState() != kButtonDown){
Error("ExportCalPad", "Export of AliTPCCalPad to CINT works only in 2D mode.");
return;
void AliTPCCalibViewerGUI::DoExportNorm() {
- //
- // function to export a CalPad to Cint
- //
-
+ /// function to export a CalPad to Cint
+
if ( fRadio2D->GetState() != kButtonDown){
Error("ExportCalPad", "Adding an AliTPCCalPad to the normalization works only in 2D mode.");
return;
void AliTPCCalibViewerGUI::GetMinMax() {
- //
- // Read current Min & Max from the plot and set it to fTxtSetMin & fTxtSetMax
- //
+ /// Read current Min & Max from the plot and set it to fTxtSetMin & fTxtSetMax
+
if (fChkGetMinMaxAuto->GetState() == kButtonUp) return;
TList* listOfPrimitives = fCanvMain->GetCanvas()->GetListOfPrimitives();
TObject* ptr = 0;
void AliTPCCalibViewerGUI::SetMinMaxLabel() {
- //
- // Set Minimum, Maximum and labels without redrawing the plot
- // (faster)
- //
-
+ /// Set Minimum, Maximum and labels without redrawing the plot
+ /// (faster)
+
// search for histogram
TList* listOfPrimitives = fCanvMain->GetCanvas()->GetListOfPrimitives();
TObject* ptr = 0;
void AliTPCCalibViewerGUI::ChangeSector(){
- //
- // function that is called, when the number of the sector is changed
- // to change the sector label
- //
+ /// function that is called, when the number of the sector is changed
+ /// to change the sector label
+
if ( fRadioROC->GetState()!=kButtonDown && fRadioSector->GetState()!=kButtonDown ){
fLblSector->SetText("not used");
return;
void AliTPCCalibViewerGUI::AddFitFunction() const {
- //
- // adds the last fit function to the normalization list
- //
+ /// adds the last fit function to the normalization list
+
std::cout << "Not yet implemented." << std::endl;
}
void AliTPCCalibViewerGUI::UnchekAllStat() {
- //
- // Disable all statistical legend entries, no statistical legend.
- //
+ /// Disable all statistical legend entries, no statistical legend.
+
fChkStatName->SetState(kButtonUp);
fChkStatEntries->SetState(kButtonUp);
fChkStatMean->SetState(kButtonUp);
void AliTPCCalibViewerGUI::MouseMove(Int_t event, Int_t x, Int_t y, TObject *selectedObject) {
- //
- // mouse move
- // zoom to sector works ONLY in 2D mode, if one side is specified
- //
+ /// mouse move
+ /// zoom to sector works ONLY in 2D mode, if one side is specified
+
Double_t pi = TMath::Pi();
if (event != kButton1Double )
return;
void AliTPCCalibViewerGUI::SavePicture() {
- //
- // saves the current picture
- //
- // use the following combination of file type and save options:
- // (see also TCanvas::Print)
- //
- // "ps" - Postscript file is produced (see special cases below)
- // "Portrait" - Postscript file is produced (Portrait)
- // "Landscape" - Postscript file is produced (Landscape)
- // "eps" - an Encapsulated Postscript file is produced
- // "Preview" - an Encapsulated Postscript file with preview is produced.
- // "pdf" - a PDF file is produced
- // "svg" - a SVG file is produced
- // "gif" - a GIF file is produced
- // "gif+NN" - an animated GIF file is produced, where NN is delay in 10ms units
- // "xpm" - a XPM file is produced
- // "png" - a PNG file is produced
- // "jpg" - a JPEG file is produced
- // "tiff" - a TIFF file is produced
- // "cxx" - a C++ macro file is produced
- // "xml" - a XML file
- // "root" - a ROOT binary file
-
+ /// saves the current picture
+ ///
+ /// use the following combination of file type and save options:
+ /// (see also TCanvas::Print)
+ ///
+ /// "ps" - Postscript file is produced (see special cases below)
+ /// "Portrait" - Postscript file is produced (Portrait)
+ /// "Landscape" - Postscript file is produced (Landscape)
+ /// "eps" - an Encapsulated Postscript file is produced
+ /// "Preview" - an Encapsulated Postscript file with preview is produced.
+ /// "pdf" - a PDF file is produced
+ /// "svg" - a SVG file is produced
+ /// "gif" - a GIF file is produced
+ /// "gif+NN" - an animated GIF file is produced, where NN is delay in 10ms units
+ /// "xpm" - a XPM file is produced
+ /// "png" - a PNG file is produced
+ /// "jpg" - a JPEG file is produced
+ /// "tiff" - a TIFF file is produced
+ /// "cxx" - a C++ macro file is produced
+ /// "xml" - a XML file
+ /// "root" - a ROOT binary file
+
const char *kSaveAsTypes[] = {
"Postscript", "*.ps",
"Encapsulated Postscript", "*.eps",
void AliTPCCalibViewerGUI::DoDumpToFile() {
- //
- // This function is called, when the "Dump to File" button is pressed.
- // All the exported CalPads will be written into an new CalibTree,
- // a Save File dialog will appear to specify the filename
- //
+ /// This function is called, when the "Dump to File" button is pressed.
+ /// All the exported CalPads will be written into an new CalibTree,
+ /// a Save File dialog will appear to specify the filename
+
const char *kSaveAsTypes[] = {
"ROOT file", "*.root",
0, 0
void AliTPCCalibViewerGUI::DoLoadTree() {
- // function to load a new calib tree
- //
- //
+ /// function to load a new calib tree
+
const char *kFileTypes[] = {
"ROOT file", "*.root",
0, 0
/* $Id: AliTPCCalibViewerGUI.h,v */
-///////////////////////////////////////////////////////////////////////////////
-// //
-// GUI for the AliTPCCalibViewer //
-// used for the calibration monitor //
-// //
-///////////////////////////////////////////////////////////////////////////////
+/// \class AliTPCCalibViewerGUI
+///
+/// GUI for the AliTPCCalibViewer
+/// used for the calibration monitor
#ifndef ROOT_TGButton
#include "TGWidget.h"
void UnchekAllStat(); // Disable all statistical legend entries, no statistical legend.
protected:
- AliTPCCalibViewer *fViewer; // CalibViewer object used for drawing
- AliTPCPreprocessorOnline *fPreprocessor; // PreprocessorOnline object, used to collect the exported CalPads and to save them into a new calibTree
+ AliTPCCalibViewer *fViewer; ///< CalibViewer object used for drawing
+ AliTPCPreprocessorOnline *fPreprocessor; ///< PreprocessorOnline object, used to collect the exported CalPads and to save them into a new calibTree
- TGCompositeFrame *fContTopBottom; // container for all GUI elements, vertical divided
- TGCompositeFrame *fContLCR; // container for all GUI elements, horizontal divided
- TGCompositeFrame *fContLeft; // container for GUI elements on left side
- TGTab *ftabLeft; // Tabs on the left side for plot options
- TGCompositeFrame *ftabLeft0; // Tab 0 on the left side for general plot options
- TGCompositeFrame *ftabLeft1; // Tab 1 on the left side for 1D plot options
- TGTab *ftabRight; // Tabs on the right side
- TGCompositeFrame *fTabRight0; // Tab 0 on the right side for basic
- TGCompositeFrame *fTabRight1; // Tab 1 on the right side for advanced
- TGCompositeFrame *fContRight; // container for GUI elements on right side
- TGCompositeFrame *fContCenter; // container for GUI elements at the center
- TGCompositeFrame *fContPlotOpt; // container for plot options GUI elements
- TGCompositeFrame *fContDrawOpt; // container for draw options GUI elements
- TGCompositeFrame *fContDrawOptSub1D2D; // container for 1D and 2D radio-button
- TGCompositeFrame *fContNormalized; // container for normalization options GUI elements
- TGCompositeFrame *fContCustom; // container for custom draw command GUI elements
- TGCompositeFrame *fContCuts; // container for cut options GUI elements
- TGCompositeFrame *fContSector; // container for sector GUI elements
- TGCompositeFrame *fContAddCuts; // container for additional cut command GUI elements
- TGCompositeFrame *fContFit; // container for fit GUI elements
- TGCompositeFrame *fContAddFit; // container for additional fit GUI elements
- TGCompositeFrame *fContScaling; // container for scaling GUI elements
- TGCompositeFrame *fContSetMax; // container for SetMaximum elements
- TGCompositeFrame *fContSetMin; // container for SetMinimum elements
- TGCompositeFrame *fContAddDrawOpt; // additional draw options container
- TGListBox *fListVariables; // listbox with possible variables
- TGTextButton *fBtnDraw; // draw button
- TGTextButton *fBtnFit; // fit button
- TGTextButton *fBtnAddFitFunction; // button to add fit function to normalization
- TGTextButton *fBtnGetMinMax; // GetMinMax-button
- TRootEmbeddedCanvas *fCanvMain; // main drawing canvas
- TGRadioButton *fRadioRaw; // raw radio button
- TGRadioButton *fRadioNormalized; // normalized radio button
- TGRadioButton *fRadioPredefined; // predefined plot radio button
- TGRadioButton *fRadioCustom; // custom radio button
- TGRadioButton *fRadio1D; // 1D radio button
- TGRadioButton *fRadio2D; // 2D radio button
- TGRadioButton *fRadioTPC; // TPC radio button
- TGRadioButton *fRadioSideA; // side A radio button
- TGRadioButton *fRadioSideC; // side C radio button
- TGRadioButton *fRadioROC; // ROC radio button
- TGRadioButton *fRadioSector; // sector radio button
- TGComboBox *fComboAddDrawOpt; // additional draw options combo box
- TGCheckButton *fChkAuto; // automatic redraw checkbox
- TGCheckButton *fChkAutoAppend; // automatic appendign of "~" checkbox
- TGComboBox *fComboMethod; // normalization methods dropdown box
- TGListBox *fListNormalization; // listbox with possible normalization variables
- TGComboBox *fComboCustom; // combo box for custom draw commands
- TGLabel *fLblCustomDraw; // custom draw labal
- TGCheckButton *fChkAddDrawOpt; // additional draw options check box
- TGNumberEntry *fNmbSector; // number entry box for specifying the sector
- TGLabel *fLblSector; // label that shows the active sector
- TGCheckButton *fChkCutZero; // cut zeros check box
- TGCheckButton *fChkAddCuts; // additional cuts check box
- TGLabel *fLblAddCuts; // additional cuts label
- TGComboBox *fComboAddCuts; // additional cuts combo box
- TGComboBox *fComboCustomFit; // custom fit combo box
- TGCheckButton *fChkSetMax; // Set maximum check box
- TGCheckButton *fChkSetMin; // Set maximum check box
- TGCheckButton *fChkGetMinMaxAuto; // Get Min & Max automatically from plot
- TGTextEntry *fTxtSetMax; // custom maximum text box
- TGTextEntry *fTxtSetMin; // custom minimum text box
- TGGroupFrame *fContDrawOpt1D; // container in tabLeft1
- TGCompositeFrame *fcontDrawOpt1DSubLR; // container in tabLeft1 to divide L/R
- TGCompositeFrame *fContDrawOpt1DSubNSC; // container in tabLeft1 for following radio buttons
- TGRadioButton *fRadioNorm; // radio button for normal 1D drawing
- TGRadioButton *fRadioSigma; // radio button for sigma 1D drawing
- TGTextEntry *fTxtSigmas; // text box to specify sigmas
- TGCompositeFrame *fContCumuLR; // container in tabLeft1 for two colums for cumulative and integrative
- TGCompositeFrame *fContCumLeft; // container in tabLeft1 for cumulative, left
- TGCompositeFrame *fContCumRight; // container in tabLeft1 for cumulative, right
- TGLabel *fLblSigmaMax; // label to indicate sigmaMax
- TGTextEntry *fTxtSigmaMax; // text box to specify sigmaMax
- TGRadioButton *fRadioCumulative; // radio button for cumulative 1D drawing
- TGCheckButton *fCheckCumulativePM; // checkbox for plus/minus cumulative 1D drawing
- TGRadioButton *fRadioIntegrate; // radio button for integral 1D drawing
- TGCompositeFrame *fContDrawOpt1DSubMML; // container in tabLeft1 for following check boxes
- TGCheckButton *fChkMean; // checkbox to plot mean
- TGCheckButton *fChkMedian; // checkbox to plot median
- TGCheckButton *fChkLTM; // checkbox to plot LTM
- TGGroupFrame *fContStatOpt; // container for statistic options in tabLeft1
- TGCheckButton *fChkStatName; // checkbox to display histogram name in statistic legend
- TGCheckButton *fChkStatEntries; // checkbox to display entries in statistic legend
- TGCompositeFrame *fContStatMean; // container for mean and its error in stat opt
- TGCheckButton *fChkStatMean; // checkbox to display mean in statistic legend
- TGCheckButton *fChkStatMeanPM; // checkbox to display mean error in statistic legend
- TGCompositeFrame *fContStatRMS; // container for RMS and its error in stat opt
- TGCheckButton *fChkStatRMS; // checkbox to display RMS in statistic legend
- TGCheckButton *fChkStatRMSPM; // checkbox to display RMS error in statistic legend
- TGCheckButton *fChkStatUnderflow; // checkbox to display underflow error in statistic legend
- TGCheckButton *fChkStatOverflow; // checkbox to display overflow error in statistic legend
- TGCheckButton *fChkStatIntegral; // checkbox to display integral in statistic legend
- TGCompositeFrame *fContStatSkew; // container for skewness and its error in stat opt
- TGCheckButton *fChkStatSkewness; // checkbox to display skewness in statistic legend
- TGCheckButton *fChkStatSkewnessPM; // checkbox to display skewness error in statistic legend
- TGCompositeFrame *fContStatKurt; // container for kurtosis and its error in stat opt
- TGCheckButton *fChkStatKurtosis; // checkbox to display kurtosis in statistic legend
- TGCheckButton *fChkStatKurtosisPM; // checkbox to display kurtosis error in statistic legend
- TGButton *fBtnUnchekAll; // Button to uncheck all statistic entries
- TGGroupFrame *fContLabeling; // groupframe container for labeling
- TGCheckButton *fChkLabelTitle; // checkbox to display specified title
- TGTextEntry *fTxtLabelTitle; // text box to specify title
- TGCheckButton *fChkLabelXaxis; // checkbox to display specified xaxis label
- TGTextEntry *fTxtLabelXaxis; // text box to specify xaxis label
- TGCheckButton *fChkLabelYaxis; // checkbox to display specified yaxis label
- TGTextEntry *fTxtLabelYaxis; // text box to specify yaxis label
- TGCheckButton *fChkLabelGetAuto; // checkbox to get labels atuomatically from plot
- TGGroupFrame *fContSave; // container for save-button
- TGButton *fBtnSave; // Save button
- TGCompositeFrame *fContAddSaveOpt; // container for additional save options
- TGCheckButton *fChkAddSaveOpt; // checkbox for additional save options
- TGComboBox *fComboAddSaveOpt; // combobox for additional save options
- TGGroupFrame *fContExport; // container for cint-export
- TGCompositeFrame *fContAddExport; // container for dropdown list to enter export name
- TGComboBox *fComboExportName; // dropdownbox to enter a name for the exported CalPad
- TGTextButton *fBtnExport; // button to export a CalPad
- TGTextButton *fBtnAddNorm; // button to add a CalPad to the normalization
- TGCompositeFrame *fContTree; // container for tree functions
- TGTextButton *fBtnDumpToFile; // button to dump a new CalibTree to file
- TGTextButton *fBtnLoadTree; // button to load a new tree
- TGCheckButton *fChkAddAsReference; // checkbox to add a new tree as referenceTree
- TGTextEntry *fTxtRefName; // text box to specify the referenceTree's name
+ TGCompositeFrame *fContTopBottom; ///< container for all GUI elements, vertical divided
+ TGCompositeFrame *fContLCR; ///< container for all GUI elements, horizontal divided
+ TGCompositeFrame *fContLeft; ///< container for GUI elements on left side
+ TGTab *ftabLeft; ///< Tabs on the left side for plot options
+ TGCompositeFrame *ftabLeft0; ///< Tab 0 on the left side for general plot options
+ TGCompositeFrame *ftabLeft1; ///< Tab 1 on the left side for 1D plot options
+ TGTab *ftabRight; ///< Tabs on the right side
+ TGCompositeFrame *fTabRight0; ///< Tab 0 on the right side for basic
+ TGCompositeFrame *fTabRight1; ///< Tab 1 on the right side for advanced
+ TGCompositeFrame *fContRight; ///< container for GUI elements on right side
+ TGCompositeFrame *fContCenter; ///< container for GUI elements at the center
+ TGCompositeFrame *fContPlotOpt; ///< container for plot options GUI elements
+ TGCompositeFrame *fContDrawOpt; ///< container for draw options GUI elements
+ TGCompositeFrame *fContDrawOptSub1D2D; ///< container for 1D and 2D radio-button
+ TGCompositeFrame *fContNormalized; ///< container for normalization options GUI elements
+ TGCompositeFrame *fContCustom; ///< container for custom draw command GUI elements
+ TGCompositeFrame *fContCuts; ///< container for cut options GUI elements
+ TGCompositeFrame *fContSector; ///< container for sector GUI elements
+ TGCompositeFrame *fContAddCuts; ///< container for additional cut command GUI elements
+ TGCompositeFrame *fContFit; ///< container for fit GUI elements
+ TGCompositeFrame *fContAddFit; ///< container for additional fit GUI elements
+ TGCompositeFrame *fContScaling; ///< container for scaling GUI elements
+ TGCompositeFrame *fContSetMax; ///< container for SetMaximum elements
+ TGCompositeFrame *fContSetMin; ///< container for SetMinimum elements
+ TGCompositeFrame *fContAddDrawOpt; ///< additional draw options container
+ TGListBox *fListVariables; ///< listbox with possible variables
+ TGTextButton *fBtnDraw; ///< draw button
+ TGTextButton *fBtnFit; ///< fit button
+ TGTextButton *fBtnAddFitFunction; ///< button to add fit function to normalization
+ TGTextButton *fBtnGetMinMax; ///< GetMinMax-button
+ TRootEmbeddedCanvas *fCanvMain; ///< main drawing canvas
+ TGRadioButton *fRadioRaw; ///< raw radio button
+ TGRadioButton *fRadioNormalized; ///< normalized radio button
+ TGRadioButton *fRadioPredefined; ///< predefined plot radio button
+ TGRadioButton *fRadioCustom; ///< custom radio button
+ TGRadioButton *fRadio1D; ///< 1D radio button
+ TGRadioButton *fRadio2D; ///< 2D radio button
+ TGRadioButton *fRadioTPC; ///< TPC radio button
+ TGRadioButton *fRadioSideA; ///< side A radio button
+ TGRadioButton *fRadioSideC; ///< side C radio button
+ TGRadioButton *fRadioROC; ///< ROC radio button
+ TGRadioButton *fRadioSector; ///< sector radio button
+ TGComboBox *fComboAddDrawOpt; ///< additional draw options combo box
+ TGCheckButton *fChkAuto; ///< automatic redraw checkbox
+ TGCheckButton *fChkAutoAppend; ///< automatic appendign of "~" checkbox
+ TGComboBox *fComboMethod; ///< normalization methods dropdown box
+ TGListBox *fListNormalization; ///< listbox with possible normalization variables
+ TGComboBox *fComboCustom; ///< combo box for custom draw commands
+ TGLabel *fLblCustomDraw; ///< custom draw labal
+ TGCheckButton *fChkAddDrawOpt; ///< additional draw options check box
+ TGNumberEntry *fNmbSector; ///< number entry box for specifying the sector
+ TGLabel *fLblSector; ///< label that shows the active sector
+ TGCheckButton *fChkCutZero; ///< cut zeros check box
+ TGCheckButton *fChkAddCuts; ///< additional cuts check box
+ TGLabel *fLblAddCuts; ///< additional cuts label
+ TGComboBox *fComboAddCuts; ///< additional cuts combo box
+ TGComboBox *fComboCustomFit; ///< custom fit combo box
+ TGCheckButton *fChkSetMax; ///< Set maximum check box
+ TGCheckButton *fChkSetMin; ///< Set maximum check box
+ TGCheckButton *fChkGetMinMaxAuto; ///< Get Min & Max automatically from plot
+ TGTextEntry *fTxtSetMax; ///< custom maximum text box
+ TGTextEntry *fTxtSetMin; ///< custom minimum text box
+ TGGroupFrame *fContDrawOpt1D; ///< container in tabLeft1
+ TGCompositeFrame *fcontDrawOpt1DSubLR; ///< container in tabLeft1 to divide L/R
+ TGCompositeFrame *fContDrawOpt1DSubNSC; ///< container in tabLeft1 for following radio buttons
+ TGRadioButton *fRadioNorm; ///< radio button for normal 1D drawing
+ TGRadioButton *fRadioSigma; ///< radio button for sigma 1D drawing
+ TGTextEntry *fTxtSigmas; ///< text box to specify sigmas
+ TGCompositeFrame *fContCumuLR; ///< container in tabLeft1 for two colums for cumulative and integrative
+ TGCompositeFrame *fContCumLeft; ///< container in tabLeft1 for cumulative, left
+ TGCompositeFrame *fContCumRight; ///< container in tabLeft1 for cumulative, right
+ TGLabel *fLblSigmaMax; ///< label to indicate sigmaMax
+ TGTextEntry *fTxtSigmaMax; ///< text box to specify sigmaMax
+ TGRadioButton *fRadioCumulative; ///< radio button for cumulative 1D drawing
+ TGCheckButton *fCheckCumulativePM; ///< checkbox for plus/minus cumulative 1D drawing
+ TGRadioButton *fRadioIntegrate; ///< radio button for integral 1D drawing
+ TGCompositeFrame *fContDrawOpt1DSubMML; ///< container in tabLeft1 for following check boxes
+ TGCheckButton *fChkMean; ///< checkbox to plot mean
+ TGCheckButton *fChkMedian; ///< checkbox to plot median
+ TGCheckButton *fChkLTM; ///< checkbox to plot LTM
+ TGGroupFrame *fContStatOpt; ///< container for statistic options in tabLeft1
+ TGCheckButton *fChkStatName; ///< checkbox to display histogram name in statistic legend
+ TGCheckButton *fChkStatEntries; ///< checkbox to display entries in statistic legend
+ TGCompositeFrame *fContStatMean; ///< container for mean and its error in stat opt
+ TGCheckButton *fChkStatMean; ///< checkbox to display mean in statistic legend
+ TGCheckButton *fChkStatMeanPM; ///< checkbox to display mean error in statistic legend
+ TGCompositeFrame *fContStatRMS; ///< container for RMS and its error in stat opt
+ TGCheckButton *fChkStatRMS; ///< checkbox to display RMS in statistic legend
+ TGCheckButton *fChkStatRMSPM; ///< checkbox to display RMS error in statistic legend
+ TGCheckButton *fChkStatUnderflow; ///< checkbox to display underflow error in statistic legend
+ TGCheckButton *fChkStatOverflow; ///< checkbox to display overflow error in statistic legend
+ TGCheckButton *fChkStatIntegral; ///< checkbox to display integral in statistic legend
+ TGCompositeFrame *fContStatSkew; ///< container for skewness and its error in stat opt
+ TGCheckButton *fChkStatSkewness; ///< checkbox to display skewness in statistic legend
+ TGCheckButton *fChkStatSkewnessPM; ///< checkbox to display skewness error in statistic legend
+ TGCompositeFrame *fContStatKurt; ///< container for kurtosis and its error in stat opt
+ TGCheckButton *fChkStatKurtosis; ///< checkbox to display kurtosis in statistic legend
+ TGCheckButton *fChkStatKurtosisPM; ///< checkbox to display kurtosis error in statistic legend
+ TGButton *fBtnUnchekAll; ///< Button to uncheck all statistic entries
+ TGGroupFrame *fContLabeling; ///< groupframe container for labeling
+ TGCheckButton *fChkLabelTitle; ///< checkbox to display specified title
+ TGTextEntry *fTxtLabelTitle; ///< text box to specify title
+ TGCheckButton *fChkLabelXaxis; ///< checkbox to display specified xaxis label
+ TGTextEntry *fTxtLabelXaxis; ///< text box to specify xaxis label
+ TGCheckButton *fChkLabelYaxis; ///< checkbox to display specified yaxis label
+ TGTextEntry *fTxtLabelYaxis; ///< text box to specify yaxis label
+ TGCheckButton *fChkLabelGetAuto; ///< checkbox to get labels atuomatically from plot
+ TGGroupFrame *fContSave; ///< container for save-button
+ TGButton *fBtnSave; ///< Save button
+ TGCompositeFrame *fContAddSaveOpt; ///< container for additional save options
+ TGCheckButton *fChkAddSaveOpt; ///< checkbox for additional save options
+ TGComboBox *fComboAddSaveOpt; ///< combobox for additional save options
+ TGGroupFrame *fContExport; ///< container for cint-export
+ TGCompositeFrame *fContAddExport; ///< container for dropdown list to enter export name
+ TGComboBox *fComboExportName; ///< dropdownbox to enter a name for the exported CalPad
+ TGTextButton *fBtnExport; ///< button to export a CalPad
+ TGTextButton *fBtnAddNorm; ///< button to add a CalPad to the normalization
+ TGCompositeFrame *fContTree; ///< container for tree functions
+ TGTextButton *fBtnDumpToFile; ///< button to dump a new CalibTree to file
+ TGTextButton *fBtnLoadTree; ///< button to load a new tree
+ TGCheckButton *fChkAddAsReference; ///< checkbox to add a new tree as referenceTree
+ TGTextEntry *fTxtRefName; ///< text box to specify the referenceTree's name
private:
- Bool_t fInitialized; // has the GUI already been initialized?
+ Bool_t fInitialized; ///< has the GUI already been initialized?
+ /// \cond CLASSIMP
ClassDef(AliTPCCalibViewerGUI, 0)
+ /// \endcond
};
#endif
**************************************************************************/
-///////////////////////////////////////////////////////////////////////////////
-// //
-// //
-///////////////////////////////////////////////////////////////////////////////
+/// \class AliTPCCalibViewerGUItime
#include <iostream>
}
//______________________________________________________________________________
AliTPCCalibViewerGUItime::~AliTPCCalibViewerGUItime(){
- //
- // dtor
- //
+ /// dtor
+
delete fConfigParser;
delete fTrashBox;
delete fMapRefTrees;
}
//______________________________________________________________________________
void AliTPCCalibViewerGUItime::DrawGUI(const TGWindow */*p*/, UInt_t w, UInt_t h) {
- //
- // draw the GUI
- //
- // ======================================================================
- // ************************* Display everything *************************
- // ======================================================================
-
+ /// draw the GUI
+ ///
+ /// ************************* Display everything *************************
+
SetCleanup(kDeepCleanup);
// *****************************************************************************
}
//______________________________________________________________________________
void AliTPCCalibViewerGUItime::SetInitialValues(){
- //
- // Set inital selections of the gui
- //
+ /// Set inital selections of the gui
+
fRadioXrun->SetState(kButtonDown);
fRadioXtime->SetState(kButtonUp);
}
//______________________________________________________________________________
void AliTPCCalibViewerGUItime::UseFile(const char* fileName, const char* treeName) {
- //
- // retrieve tree from file
- //
+ /// retrieve tree from file
+
TObjArray *arr=0x0;
TString file(fileName);
if (file.Contains("://")) {
//______________________________________________________________________________
void AliTPCCalibViewerGUItime::UseChain(TChain *const chain = 0)
{
- //
- //
- //
+ ///
+
fTree=chain;
if (!CheckChain()) return;
//set configuration file
//______________________________________________________________________________
Bool_t AliTPCCalibViewerGUItime::CheckChain()
{
- //
- // check whether cahin has entries
- // decide whether to draw graphs in 2D
- //
+ /// check whether cahin has entries
+ /// decide whether to draw graphs in 2D
+
if (!fTree) return kFALSE;
fTree->Lookup();
Long64_t entries=fTree->GetEntries();
//______________________________________________________________________________
void AliTPCCalibViewerGUItime::UseConfigFile(const char* file)
{
- //
- // Use 'file' as configuration file
- //
+ /// Use 'file' as configuration file
+
fConfigFile=file;
fConfigParser->ParseConfigFileTxt(fConfigFile.Data());
FillCalibTypes();
//______________________________________________________________________________
void AliTPCCalibViewerGUItime::FillRunTypes()
{
- //
- //Loop over the tree entries and fill the run types
- //
+ /// Loop over the tree entries and fill the run types
+
if (!fTree) return;
Int_t id=0;
fComboRunType->RemoveAll();
//______________________________________________________________________________
void AliTPCCalibViewerGUItime::FillCalibTypes()
{
- //
- // loop over configuration and fill calibration types
- //
+ /// loop over configuration and fill calibration types
+
Int_t id=0;
fListCalibType->RemoveAll();
TObject *o=0x0;
//______________________________________________________________________________
void AliTPCCalibViewerGUItime::CheckDrawGraph()
{
- //
- // Check whether to draw graphs in 2D mode based on the number of entries in the chain
- // GetEstimate() returns the maximum size of the arrays stored in GetV1()...
- //
+ /// Check whether to draw graphs in 2D mode based on the number of entries in the chain
+ /// GetEstimate() returns the maximum size of the arrays stored in GetV1()...
+
if (!fTree) return;
fNoGraph=kTRUE;
if (fTree->GetEntries()<fTree->GetEstimate()) fNoGraph=kFALSE;
//______________________________________________________________________________
void AliTPCCalibViewerGUItime::Reload(Int_t first)
{
- //
- // reload the gui contents, this is needed after the input tree has changed
- //
+ /// reload the gui contents, this is needed after the input tree has changed
if ( !fTree ) return;
//in case of the first call create run type and calibration type entries
//______________________________________________________________________________
void AliTPCCalibViewerGUItime::AddReferenceTree(const char* treeFileName, const char* refName)
{
- //
- // map of reference trees that should always be attached to the CalibViewerGUI
- //
+ /// map of reference trees that should always be attached to the CalibViewerGUI
+
fMapRefTrees->Add(new TObjString(refName), new TObjString(treeFileName));
}
//______________________________________________________________________________
const TString AliTPCCalibViewerGUItime::GetDrawString(){
- //
- // create draw string for ttree by combining the user requestsa
- //
-
+ /// create draw string for ttree by combining the user requestsa
+
TString selectedVariable="";
Int_t id=-1;
if (!fListVariables->GetSelectedEntry()) return "";
}
//______________________________________________________________________________
const TString AliTPCCalibViewerGUItime::GetDrawOptionString(){
- //
- // get user selected draw options
- //
+ /// get user selected draw options
+
TString drawOpt;
if (fComboAddDrawOpt->GetSelectedEntry()) drawOpt=fComboAddDrawOpt->GetSelectedEntry()->GetTitle();
if (fChkDrawOptSame->GetState()==kButtonDown && !drawOpt.Contains("same",TString::kIgnoreCase))
}
//______________________________________________________________________________
void AliTPCCalibViewerGUItime::GetCutString(TString &cutStr){
- //
- // create cut string
- //
+ /// create cut string
+
TCut cuts(fComboCustomCuts->GetTextEntry()->GetText());
TString runType="";
if (fComboRunType->GetSelectedEntry()) runType=fComboRunType->GetSelectedEntry()->GetTitle();
//______________________________________________________________________________
void AliTPCCalibViewerGUItime::UpdateValueArrays(Bool_t withGraph, const Double_t *xArr)
{
- //
- //
- //
+ ///
+
if (!withGraph){
fValuesX.ResizeTo(1);
fValuesY.ResizeTo(1);
//______________________________________________________________________________
void AliTPCCalibViewerGUItime::GetHistogramTitle(TString &title)
{
- //
- // Create string for histogram title
- //
+ /// Create string for histogram title
title=fDrawString;
Int_t pos=title.First(">>");
//______________________________________________________________________________
void AliTPCCalibViewerGUItime::AdjustYRange()
{
- //
- //
- //
+ ///
+
TIter nextGraphicObject(fTrashBox);
TObject *o=0x0;
Float_t min=1,max=0;
}
//______________________________________________________________________________
void AliTPCCalibViewerGUItime::DoDraw() {
- //
- // Draw graphics
- //
+ /// Draw graphics
+
TString drawString=fDrawString;
TString cutString;
GetCutString(cutString);
//______________________________________________________________________________
void AliTPCCalibViewerGUItime::DoDumpRuns()
{
- //
- // Dump the current run numbers to stdout
- //
+ /// Dump the current run numbers to stdout
+
Int_t npoints=fRunNumbers.GetNrows();
Int_t *sortIndex = new Int_t[npoints];
TMath::Sort(npoints,fRunNumbers.GetMatrixArray(),sortIndex,kFALSE);
//______________________________________________________________________________
void AliTPCCalibViewerGUItime::DoParLimitChange()
{
- //
- //
- //
+ ///
+
UpdateParName();
DoDraw();
}
//______________________________________________________________________________
void AliTPCCalibViewerGUItime::DoNewSelection() {
- //
- // decides whether to redraw if user makes another selection
- //
+ /// decides whether to redraw if user makes another selection
+
UpdateParLimits();
fDrawString=GetDrawString();
fIsCustomDraw=kFALSE;
//______________________________________________________________________________
void AliTPCCalibViewerGUItime::DoCustomDraw()
{
- //
- //
- //
+ ///
+
fDrawString=fComboCustomDraw->GetTextEntry()->GetText();
// if (fDrawString.Contains(">>")){
// Warning("DoCustomDraw","Currently no user defined histograms allowed!");
//______________________________________________________________________________
void AliTPCCalibViewerGUItime::DoCustomCutsDraw()
{
- //
- //
- //
+ ///
+
if (fIsCustomDraw) DoCustomDraw();
else {
fDrawString=GetDrawString();
//______________________________________________________________________________
void AliTPCCalibViewerGUItime::HandleButtonsDrawSel(Int_t id)
{
- //
- // Draw selection button handling (x-variable)
- //
+ /// Draw selection button handling (x-variable)
if (id == -1) {
TGButton *btn = (TGButton *) gTQSender;
//______________________________________________________________________________
void AliTPCCalibViewerGUItime::UpdateParName()
{
- //
- // change parameter name
- //
-
+ /// change parameter name
+
Int_t par = (Int_t)(fNmbPar->GetNumber());
TString parName="";
Int_t id=fListVariables->GetSelectedEntry()->EntryId();
//______________________________________________________________________________
void AliTPCCalibViewerGUItime::UpdateParLimits()
{
- //
- // Adjust limits for TVectorT based variables
- //
+ /// Adjust limits for TVectorT based variables
+
if (!fTree) return;
TString selectedVariableTitle="";
Int_t id=-1;
//______________________________________________________________________________
void AliTPCCalibViewerGUItime::MouseMove(Int_t event, Int_t x, Int_t y, TObject */*selected*/)
{
- //
- // handle mouse events in the draw canvas
- //
+ /// handle mouse events in the draw canvas
+
UInt_t dd=0,mm=0,yy=0,HH=0,MM=0,SS=0,run=0;
Double_t valx=0.,valy=0.;
if (!fCurrentGraph) {
//______________________________________________________________________________
void AliTPCCalibViewerGUItime::SetGuiTree(Int_t run)
{
- //
- // create the AliTPCCalibViewerGUI tree for run
- // cache tree in directory fOutputCacheDir
- // retrieve file from this directory if it already exists
- //
+ /// create the AliTPCCalibViewerGUI tree for run
+ /// cache tree in directory fOutputCacheDir
+ /// retrieve file from this directory if it already exists
//
//Create and set GUI tree
//______________________________________________________________________________
void AliTPCCalibViewerGUItime::SubstituteUnderscores(TString &s)
{
- //
- //
- //
+ ///
+
s.ReplaceAll("_{","|{");
s.ReplaceAll("_"," ");
s.ReplaceAll("|{","_{");
//______________________________________________________________________________
void AliTPCCalibViewerGUItime::DoNewSelectionAliases()
{
- //
- //
- //
+ ///
+
if (!fTree) return;
TList *l=fTree->GetListOfAliases();
if (!l) return;
//______________________________________________________________________________
void AliTPCCalibViewerGUItime::DoAddAlias()
{
- //
- //
- //
+ ///
+
new AliTPCCalibViewerGUItimeAddAliasFrame(gClient->GetRoot(), fContTopBottom, 400, 200, kVerticalFrame, this);
}
//______________________________________________________________________________
void AliTPCCalibViewerGUItime::DoDelAlias()
{
- //
- //
- //
+ ///
+
if (!fTree) return;
TList *l=fTree->GetListOfAliases();
if (!l) return;
//______________________________________________________________________________
void AliTPCCalibViewerGUItime::UpdateAliasList()
{
- //
- //
- //
+ ///
+
printf("UpdateAliasList\n");
if (!fTree) return;
TList *l=fTree->GetListOfAliases();
}
//______________________________________________________________________________
TObjArray* AliTPCCalibViewerGUItime::ShowGUI(const char* fileName, const char* treeName) {
- //
- // Initialize and show GUI for presentation for demonstration purposes
- // or for fast standalone use
- //
+ /// Initialize and show GUI for presentation for demonstration purposes
+ /// or for fast standalone use
+
TGMainFrame* frmMain = new TGMainFrame(gClient->GetRoot(), 1000, 600);
frmMain->SetWindowName("AliTPCCalibViewer GUItime");
frmMain->SetCleanup(kDeepCleanup);
//______________________________________________________________________________
TObjArray* AliTPCCalibViewerGUItime::ShowGUI(TChain *chain) {
- //
- // Initialize and show GUI for presentation for demonstration purposes
- // or for fast standalone use
- //
+ /// Initialize and show GUI for presentation for demonstration purposes
+ /// or for fast standalone use
+
TGMainFrame* frmMain = new TGMainFrame(gClient->GetRoot(), 1000, 600);
frmMain->SetWindowName("AliTPCCalibViewer GUItime");
frmMain->SetCleanup(kDeepCleanup);
////////////////////////////////////////////////////////////////////////
+/// \cond CLASSIMP
ClassImp(AliTPCCalibViewerGUItimeAddAliasFrame)
+/// \endcond
AliTPCCalibViewerGUItimeAddAliasFrame::AliTPCCalibViewerGUItimeAddAliasFrame(const TGWindow *p, const TGWindow *main,
UInt_t w, UInt_t h, UInt_t options,
//______________________________________________________________________________
AliTPCCalibViewerGUItimeAddAliasFrame::~AliTPCCalibViewerGUItimeAddAliasFrame()
{
- //
- //
- //
+ ///
+
fMain->DeleteWindow(); // deletes fMain
}
//______________________________________________________________________________
void AliTPCCalibViewerGUItimeAddAliasFrame::DoOK()
{
- //
- //
- //
+ ///
+
TString aliasName=fTxt1->GetText();
TString alias=fTxt2->GetText();
if (!aliasName.IsNull()&&!alias.IsNull()){
//______________________________________________________________________________
void AliTPCCalibViewerGUItimeAddAliasFrame::DoCancel()
{
- //
- //
- //
+ ///
+
delete this;
}
/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
* See cxx source for full Copyright notice */
-/* $Id: AliTPCCalibViewerGUI.h,v */
-
-///////////////////////////////////////////////////////////////////////////////
-// //
-// GUI for displaying calibration entires over time //
-// Calibration Trees are created using the macro TPC/CalibMacros/CalibEnv.C //
-// used for the calibration monitor //
-// //
-///////////////////////////////////////////////////////////////////////////////
+/// \class AliTPCCalibViewerGUItime
+///
+/// \brief GUI for displaying calibration entires over time
+/// Calibration Trees are created using the macro TPC/CalibMacros/CalibEnv.C
+/// used for the calibration monitor
#ifndef ROOT_TGButton
void UpdateAliasList();
TCanvas * GetCanvas(){ return fCanvMain->GetCanvas();}
private:
- TFile* fFile; //file that keeps the tree
- TChain* fTree; //internal tree
- AliTPCCalibViewerGUI *fCalibViewerGUI; //calib viewer gui used to display verbose information for one run
- TGTabElement *fCalibViewerGUItab; //tab the calib view gui redies in
- TH1* fCurrentHist; //histogram currently drawn in main canvas
- TGraph* fCurrentGraph; //current graph
- Int_t fCurrentRunDetails; //run number for wich details are currently shown
- TString fOutputCacheDir; //output cache diretory for AliTPCCalibViewerGUI trees, created on the fly
- TString fDrawString; //current draw string
- TString fConfigFile; //configuration file keeping active branches and branch descriptions
- AliTPCConfigParser *fConfigParser; //configuration parser
- Bool_t fIsCustomDraw; //if custom draw string is selected
- TVectorD fRunNumbers; //run numbers of current selection
- TVectorD fTimeStamps; //timr stamps of current selection
- TVectorD fValuesX; //values of current selection
- TVectorD fValuesY; //values of current selection
+ TFile* fFile; ///< file that keeps the tree
+ TChain* fTree; ///< internal tree
+ AliTPCCalibViewerGUI *fCalibViewerGUI; ///< calib viewer gui used to display verbose information for one run
+ TGTabElement *fCalibViewerGUItab; ///< tab the calib view gui redies in
+ TH1* fCurrentHist; ///< histogram currently drawn in main canvas
+ TGraph* fCurrentGraph; ///< current graph
+ Int_t fCurrentRunDetails; ///< run number for wich details are currently shown
+ TString fOutputCacheDir; ///< output cache diretory for AliTPCCalibViewerGUI trees, created on the fly
+ TString fDrawString; ///< current draw string
+ TString fConfigFile; ///< configuration file keeping active branches and branch descriptions
+ AliTPCConfigParser *fConfigParser; ///< configuration parser
+ Bool_t fIsCustomDraw; ///< if custom draw string is selected
+ TVectorD fRunNumbers; ///< run numbers of current selection
+ TVectorD fTimeStamps; ///< timr stamps of current selection
+ TVectorD fValuesX; ///< values of current selection
+ TVectorD fValuesY; ///< values of current selection
//
- Bool_t fNoGraph; //Whether to create a graph
- Long64_t fGraphLimitEntries; //limit in number of entries in the chain for producing a graph
+ Bool_t fNoGraph; ///< Whether to create a graph
+ Long64_t fGraphLimitEntries; ///< limit in number of entries in the chain for producing a graph
//
- TMap *fMapRefTrees; //map of reference trees for the CalibViewer
+ TMap *fMapRefTrees; ///< map of reference trees for the CalibViewer
//GUI elements
//main canvas Top part, bottom part
- TGCompositeFrame *fContTopBottom; // container for all GUI elements, vertical divided
+ TGCompositeFrame *fContTopBottom; ///< container for all GUI elements, vertical divided
//top left, centre, right
- TGCompositeFrame *fContLCR; // container for all GUI elements, horizontal divided
+ TGCompositeFrame *fContLCR; ///< container for all GUI elements, horizontal divided
//content left
- TGCompositeFrame *fContLeft; // container for GUI elements on left side
- TGGroupFrame *fContDrawOpt; // Subgroup for draw selection
- TGCheckButton *fChkDrawOptSame; // draw option 'same'
- TGCheckButton *fChkDrawOptSparse; // draw option 'sparse'
- TGComboBox *fComboAddDrawOpt; // additional draw options combo box
- TGGroupFrame *fContDrawSel; // Subgroup for draw selection
- TGCompositeFrame *fContDrawSelSubRunTime; //Radio button subframe
- TGRadioButton *fRadioXhist; // Radio button x-variable: show only 1D distribution
- TGRadioButton *fRadioXrun; // Radio button x-variable: run
- TGRadioButton *fRadioXtime; // Radio button x-variable: time
- TGListBox *fListVariables; // listbox with possible variables
- TGComboBox *fComboRunType; // run type selection box
- TGLabel *fLblRunType; // run type label
- TGNumberEntry *fNmbPar; // parameter number
- TGLabel *fLblPar; // parameter name
- TGListBox *fListCalibType; // calibration type selection box
- TGGroupFrame *fContCalibType; // calibration type label
+ TGCompositeFrame *fContLeft; ///< container for GUI elements on left side
+ TGGroupFrame *fContDrawOpt; ///< Subgroup for draw selection
+ TGCheckButton *fChkDrawOptSame; ///< draw option 'same'
+ TGCheckButton *fChkDrawOptSparse; ///< draw option 'sparse'
+ TGComboBox *fComboAddDrawOpt; ///< additional draw options combo box
+ TGGroupFrame *fContDrawSel; ///< Subgroup for draw selection
+ TGCompositeFrame *fContDrawSelSubRunTime; ///< Radio button subframe
+ TGRadioButton *fRadioXhist; ///< Radio button x-variable: show only 1D distribution
+ TGRadioButton *fRadioXrun; ///< Radio button x-variable: run
+ TGRadioButton *fRadioXtime; ///< Radio button x-variable: time
+ TGListBox *fListVariables; ///< listbox with possible variables
+ TGComboBox *fComboRunType; ///< run type selection box
+ TGLabel *fLblRunType; ///< run type label
+ TGNumberEntry *fNmbPar; ///< parameter number
+ TGLabel *fLblPar; ///< parameter name
+ TGListBox *fListCalibType; ///< calibration type selection box
+ TGGroupFrame *fContCalibType; ///< calibration type label
//content centre
- TGCompositeFrame *fContCenter; // container for GUI elements at the center
- TRootEmbeddedCanvas *fCanvMain; // main drawing canvas
+ TGCompositeFrame *fContCenter; ///< container for GUI elements at the center
+ TRootEmbeddedCanvas *fCanvMain; ///< main drawing canvas
//content right
- TGCompositeFrame *fContRight; // container for GUI elements on right side
- TGGroupFrame *fContValues; // container to keep data point information
- TGLabel *fLblRunNumber; // run number label
- TGLabel *fLblRunTime; // time stamp label
- TGLabel *fLblValueX; // value label
- TGLabel *fLblValueY; // value label
- TGLabel *fLblRunNumberVal; // run number of the data point hoovered
- TGLabel *fLblRunTimeVal; // time stamp of the data point hoovered
- TGLabel *fLblValueXVal; // value of the data point hoovered
- TGLabel *fLblValueYVal; // value of the data point hoovered
- TGTextButton *fBtnDumpRuns; // draw button
- TGGroupFrame *fContAliases; // container to keep data point information
- TGListBox *fListAliases; // list of aliases
+ TGCompositeFrame *fContRight; ///< container for GUI elements on right side
+ TGGroupFrame *fContValues; ///< container to keep data point information
+ TGLabel *fLblRunNumber; ///< run number label
+ TGLabel *fLblRunTime; ///< time stamp label
+ TGLabel *fLblValueX; ///< value label
+ TGLabel *fLblValueY; ///< value label
+ TGLabel *fLblRunNumberVal; ///< run number of the data point hoovered
+ TGLabel *fLblRunTimeVal; ///< time stamp of the data point hoovered
+ TGLabel *fLblValueXVal; ///< value of the data point hoovered
+ TGLabel *fLblValueYVal; ///< value of the data point hoovered
+ TGTextButton *fBtnDumpRuns; ///< draw button
+ TGGroupFrame *fContAliases; ///< container to keep data point information
+ TGListBox *fListAliases; ///< list of aliases
//content bottom
- TGCompositeFrame *fContCustom; // container for custom draw command GUI elements
- TGCompositeFrame *fContCustomCuts; // container for custom cut options GUI elements
- TGLabel *fLblCustomDraw; // label for custom draw string
- TGLabel *fLblCustomCuts; // label for custom cuts string
- TGComboBox *fComboCustomDraw; // combo box custom draw string
- TGComboBox *fComboCustomCuts; // combo box custom cuts string
+ TGCompositeFrame *fContCustom; ///< container for custom draw command GUI elements
+ TGCompositeFrame *fContCustomCuts; ///< container for custom cut options GUI elements
+ TGLabel *fLblCustomDraw; ///< label for custom draw string
+ TGLabel *fLblCustomCuts; ///< label for custom cuts string
+ TGComboBox *fComboCustomDraw; ///< combo box custom draw string
+ TGComboBox *fComboCustomCuts; ///< combo box custom cuts string
//
- TObjArray *fTrashBox; //graphics objects to be deleted (histograms, graphs,...)
+ TObjArray *fTrashBox; ///< graphics objects to be deleted (histograms, graphs,...)
enum { kRadioXhist=10, kRadioXrun=11, kRadioXtime=12 };
enum { kBranchOnOff=0, kBranchTitle=1, kCalibType=2, kParamNames=3 };
private:
- TGTransientFrame *fMain; //Main frame
- TGTextEntry *fTxt1, *fTxt2; //text input
+ TGTransientFrame *fMain; ///< Main frame
+ TGTextEntry *fTxt1, *fTxt2; ///< text input
- AliTPCCalibViewerGUItime *fGUI; //pointer to mother process
+ AliTPCCalibViewerGUItime *fGUI; ///< pointer to mother process
AliTPCCalibViewerGUItimeAddAliasFrame(const AliTPCCalibViewerGUItimeAddAliasFrame &r);
AliTPCCalibViewerGUItimeAddAliasFrame &operator = (const AliTPCCalibViewerGUItimeAddAliasFrame &r);
+ /// \cond CLASSIMP
ClassDef(AliTPCCalibViewerGUItimeAddAliasFrame,0)
+ /// \endcond
};
#endif
**************************************************************************/
-///////////////////////////////////////////////////////////////////////////////
-// //
-// TPC cluster error, shape and charge parameterization as function
-// of drift length, and inclination angle //
-//
-// Following notation is used in following
-// Int_t dim 0 - y direction
-// 1 - z direction
-//
-// Int_t type 0 - short pads
-// 1 - medium pads
-// 2 - long pads
-// Float_t z - drift length
-//
-// Float_t angle - tangent of inclination angle at given dimension
-//
-// Implemented parameterization
-//
-//
-// 1. Resolution as function of drift length and inclination angle
-// 1.a) GetError0(Int_t dim, Int_t type, Float_t z, Float_t angle)
-// Simple error parameterization as derived from analytical formula
-// only linear term in drift length and angle^2
-// The formula is valid only with precission +-5%
-// Separate parameterization for differnt pad geometry
-// 1.b) GetError0Par
-// Parabolic term correction - better precision
-//
-// 1.c) GetError1 - JUST FOR Study
-// Similar to GetError1
-// The angular and diffusion effect is scaling with pad length
-// common parameterization for different pad length
-//
-// 2. Error parameterization using charge
-// 2.a) GetErrorQ
-// GetError0+
-// adding 1/Q component to diffusion and angluar part
-// 2.b) GetErrorQPar
-// GetError0Par+
-// adding 1/Q component to diffusion and angluar part
-// 2.c) GetErrorQParScaled - Just for study
-// One parameterization for all pad shapes
-// Smaller precission as previous one
-//
-//
-// Example how to retrieve the paramterization:
-/*
- AliCDBManager::Instance()->SetDefaultStorage("local://$ALICE_ROOT/OCDB");
- AliCDBManager::Instance()->SetRun(0)
- AliTPCClusterParam * param = AliTPCcalibDB::Instance()->GetClusterParam();
+/// \class AliTPCClusterParam
+/// \brief TPC cluster error, shape and charge parameterization as function of drift length and inclination angle
+///
+/// Following notation is used in following
+/// Int_t dim 0 - y direction
+/// 1 - z direction
+///
+/// Int_t type 0 - short pads
+/// 1 - medium pads
+/// 2 - long pads
+/// Float_t z - drift length
+///
+/// Float_t angle - tangent of inclination angle at given dimension
+///
+/// Implemented parameterization
+///
+/// 1. Resolution as function of drift length and inclination angle
+/// 1.a) GetError0(Int_t dim, Int_t type, Float_t z, Float_t angle)
+/// Simple error parameterization as derived from analytical formula
+/// only linear term in drift length and angle^2
+/// The formula is valid only with precission +-5%
+/// Separate parameterization for differnt pad geometry
+/// 1.b) GetError0Par
+/// Parabolic term correction - better precision
+///
+/// 1.c) GetError1 - JUST FOR Study
+/// Similar to GetError1
+/// The angular and diffusion effect is scaling with pad length
+/// common parameterization for different pad length
+///
+/// 2. Error parameterization using charge
+/// 2.a) GetErrorQ
+/// GetError0+
+/// adding 1/Q component to diffusion and angluar part
+/// 2.b) GetErrorQPar
+/// GetError0Par+
+/// adding 1/Q component to diffusion and angluar part
+/// 2.c) GetErrorQParScaled - Just for study
+/// One parameterization for all pad shapes
+/// Smaller precission as previous one
+///
+/// Example how to retrieve the paramterization:
+///
+/// ~~~{.cpp}
+/// AliCDBManager::Instance()->SetDefaultStorage("local://$ALICE_ROOT/OCDB");
+/// AliCDBManager::Instance()->SetRun(0)
+/// AliTPCClusterParam * param = AliTPCcalibDB::Instance()->GetClusterParam();
+///
+/// AliTPCClusterParam::SetInstance(param);
+/// TF1 f1("f1","AliTPCClusterParam::SGetError0Par(1,0,x,0)",0,250);
+/// ~~~
+///
+/// Example how to create parameterization:
+/// Note resol is the resolution tree created by AliTPCcalibTracks
+///
+/// ~~~{.cpp}
+/// AliTPCClusterParam *param = new AliTPCClusterParam;
+/// param->FitData(Resol);
+/// AliTPCClusterParam::SetInstance(param);
+/// ~~~
- //
- //
- AliTPCClusterParam::SetInstance(param);
- TF1 f1("f1","AliTPCClusterParam::SGetError0Par(1,0,x,0)",0,250);
-*/
-
-// EXAMPLE hot to create parameterization
-/*
-// Note resol is the resolution tree created by AliTPCcalibTracks
-//
-AliTPCClusterParam *param = new AliTPCClusterParam;
-param->FitData(Resol);
-AliTPCClusterParam::SetInstance(param);
-
-*/
-
-//
-// //
-///////////////////////////////////////////////////////////////////////////////
#include "AliTPCClusterParam.h"
#include "TMath.h"
#include "TFile.h"
#include "AliMathBase.h"
+/// \cond CLASSIMP
ClassImp(AliTPCClusterParam)
+/// \endcond
AliTPCClusterParam* AliTPCClusterParam::fgInstance = 0;
/*
Example usage fitting parameterization:
- TFile fres("resol.root"); //tree with resolution and shape
+ TFile fres("resol.root"); //tree with resolution and shape
TTree * treeRes =(TTree*)fres.Get("Resol");
-
+
AliTPCClusterParam param;
param.SetInstance(¶m);
param.FitResol(treeRes);
//
//
TFile fparam("TPCClusterParam.root");
- AliTPCClusterParam *param2 = (AliTPCClusterParam *) fparam.Get("Param");
+ AliTPCClusterParam *param2 = (AliTPCClusterParam *) fparam.Get("Param");
param2->SetInstance(param2);
param2->Test(treeRes);
-
+
treeRes->Draw("(Resol-AliTPCClusterParam::SGetError0(Dim,Pad,Zm,AngleM))/Resol","Dim==0&&QMean<0")
//_ singleton implementation __________________________________________________
AliTPCClusterParam* AliTPCClusterParam::Instance()
{
- //
- // Singleton implementation
- // Returns an instance of this class, it is created if neccessary
- //
+ /// Singleton implementation
+ /// Returns an instance of this class, it is created if neccessary
+
if (fgInstance == 0){
fgInstance = new AliTPCClusterParam();
}
fResolutionYMap(0)
//
{
+ /// Default constructor
+
+ fPosQTnorm[0] = 0; fPosQTnorm[1] = 0; fPosQTnorm[2] = 0;
+ fPosQMnorm[0] = 0; fPosQMnorm[1] = 0; fPosQMnorm[2] = 0;
//
- // Default constructor
- //
- fPosQTnorm[0] = 0; fPosQTnorm[1] = 0; fPosQTnorm[2] = 0;
- fPosQMnorm[0] = 0; fPosQMnorm[1] = 0; fPosQMnorm[2] = 0;
- //
- fPosYcor[0] = 0; fPosYcor[1] = 0; fPosYcor[2] = 0;
- fPosZcor[0] = 0; fPosZcor[1] = 0; fPosZcor[2] = 0;
- fErrorRMSSys[0]=0; fErrorRMSSys[1]=0;
+ fPosYcor[0] = 0; fPosYcor[1] = 0; fPosYcor[2] = 0;
+ fPosZcor[0] = 0; fPosZcor[1] = 0; fPosZcor[2] = 0;
+ fErrorRMSSys[0]=0; fErrorRMSSys[1]=0;
}
AliTPCClusterParam::AliTPCClusterParam(const AliTPCClusterParam& param):
fWaveCorrectionMirroredAngle( kFALSE ),
fResolutionYMap(0)
{
- //
- // copy constructor
- //
+ /// copy constructor
+
if (param.fQNorm) fQNorm = (TObjArray*) param.fQNorm->Clone();
if (param.fQNormHis) fQNormHis = (TObjArray*) param.fQNormHis->Clone();
//
AliTPCClusterParam & AliTPCClusterParam::operator=(const AliTPCClusterParam& param){
- //
- // Assignment operator
- //
+ /// Assignment operator
+
if (this != ¶m) {
if (param.fQNorm) fQNorm = (TObjArray*) param.fQNorm->Clone();
if (param.fQNormHis) fQNormHis = (TObjArray*) param.fQNormHis->Clone();
fPosZcor[1] = new TVectorD(*(param.fPosZcor[1]));
fPosZcor[2] = new TVectorD(*(param.fPosZcor[2]));
}
-
+
for (Int_t ii = 0; ii < 2; ++ii) {
for (Int_t jj = 0; jj < 3; ++jj) {
for (Int_t kk = 0; kk < 4; ++kk) {
fRMSSigmaRatio[ii][jj] = param.fRMSSigmaRatio[ii][jj];
}
}
-
+
SetWaveCorrectionMap( param.fWaveCorrectionMap );
SetResolutionYMap( param.fResolutionYMap );
}
AliTPCClusterParam::~AliTPCClusterParam(){
- //
- // destructor
- //
+ /// destructor
+
if (fQNorm) fQNorm->Delete();
if (fQNormCorr) delete fQNormCorr;
if (fQNormHis) fQNormHis->Delete();
void AliTPCClusterParam::FitResol0(TTree * tree, Int_t dim, Int_t type, Float_t *param0, Float_t *error){
- //
- // Fit z - angular dependence of resolution
- //
- // Int_t dim=0, type=0;
+ /// Fit z - angular dependence of resolution
+ ///
+ /// Int_t dim=0, type=0;
+
TString varVal;
varVal="Resol:AngleM:Zm";
TString varErr;
Float_t px[10000], py[10000], pz[10000];
Float_t ex[10000], ey[10000], ez[10000];
//
- tree->Draw(varErr.Data(),varCut);
+ tree->Draw(varErr.Data(),varCut);
for (Int_t ipoint=0; ipoint<entries; ipoint++){
ex[ipoint]= tree->GetV3()[ipoint];
ey[ipoint]= tree->GetV2()[ipoint];
ez[ipoint]= tree->GetV1()[ipoint];
- }
+ }
tree->Draw(varVal.Data(),varCut);
for (Int_t ipoint=0; ipoint<entries; ipoint++){
px[ipoint]= tree->GetV3()[ipoint];
py[ipoint]= tree->GetV2()[ipoint];
pz[ipoint]= tree->GetV1()[ipoint];
}
-
- //
+
+ //
TLinearFitter fitter(3,"hyp2");
for (Int_t ipoint=0; ipoint<entries; ipoint++){
Float_t val = pz[ipoint]*pz[ipoint];
void AliTPCClusterParam::FitResol0Par(TTree * tree, Int_t dim, Int_t type, Float_t *param0, Float_t *error){
- //
- // Fit z - angular dependence of resolution
- //
- // Int_t dim=0, type=0;
+ /// Fit z - angular dependence of resolution
+ ///
+ /// Int_t dim=0, type=0;
+
TString varVal;
varVal="Resol:AngleM:Zm";
TString varErr;
Float_t px[10000], py[10000], pz[10000];
Float_t ex[10000], ey[10000], ez[10000];
//
- tree->Draw(varErr.Data(),varCut);
+ tree->Draw(varErr.Data(),varCut);
for (Int_t ipoint=0; ipoint<entries; ipoint++){
ex[ipoint]= tree->GetV3()[ipoint];
ey[ipoint]= tree->GetV2()[ipoint];
ez[ipoint]= tree->GetV1()[ipoint];
- }
+ }
tree->Draw(varVal.Data(),varCut);
for (Int_t ipoint=0; ipoint<entries; ipoint++){
px[ipoint]= tree->GetV3()[ipoint];
py[ipoint]= tree->GetV2()[ipoint];
pz[ipoint]= tree->GetV1()[ipoint];
}
-
- //
+
+ //
TLinearFitter fitter(6,"hyp5");
for (Int_t ipoint=0; ipoint<entries; ipoint++){
Float_t val = pz[ipoint]*pz[ipoint];
void AliTPCClusterParam::FitResol1(TTree * tree, Int_t dim, Float_t *param0, Float_t *error){
- //
- // Fit z - angular dependence of resolution - pad length scaling
- //
- // Int_t dim=0, type=0;
+ /// Fit z - angular dependence of resolution - pad length scaling
+ ///
+ /// Int_t dim=0, type=0;
+
TString varVal;
varVal="Resol:AngleM*sqrt(Length):Zm/Length";
TString varErr;
Float_t px[10000], py[10000], pz[10000];
Float_t ex[10000], ey[10000], ez[10000];
//
- tree->Draw(varErr.Data(),varCut);
+ tree->Draw(varErr.Data(),varCut);
for (Int_t ipoint=0; ipoint<entries; ipoint++){
ex[ipoint]= tree->GetV3()[ipoint];
ey[ipoint]= tree->GetV2()[ipoint];
ez[ipoint]= tree->GetV1()[ipoint];
- }
+ }
tree->Draw(varVal.Data(),varCut);
for (Int_t ipoint=0; ipoint<entries; ipoint++){
px[ipoint]= tree->GetV3()[ipoint];
py[ipoint]= tree->GetV2()[ipoint];
pz[ipoint]= tree->GetV1()[ipoint];
}
-
- //
+
+ //
TLinearFitter fitter(3,"hyp2");
for (Int_t ipoint=0; ipoint<entries; ipoint++){
Float_t val = pz[ipoint]*pz[ipoint];
}
void AliTPCClusterParam::FitResolQ(TTree * tree, Int_t dim, Int_t type, Float_t *param0, Float_t *error){
- //
- // Fit z - angular dependence of resolution - Q scaling
- //
- // Int_t dim=0, type=0;
+ /// Fit z - angular dependence of resolution - Q scaling
+ ///
+ /// Int_t dim=0, type=0;
+
TString varVal;
varVal="Resol:AngleM/sqrt(QMean):Zm/QMean";
char varVal0[100];
Float_t px[20000], py[20000], pz[20000], pu[20000], pt[20000];
Float_t ex[20000], ey[20000], ez[20000];
//
- tree->Draw(varErr.Data(),varCut);
+ tree->Draw(varErr.Data(),varCut);
for (Int_t ipoint=0; ipoint<entries; ipoint++){
ex[ipoint]= tree->GetV3()[ipoint];
ey[ipoint]= tree->GetV2()[ipoint];
ez[ipoint]= tree->GetV1()[ipoint];
- }
+ }
tree->Draw(varVal.Data(),varCut);
for (Int_t ipoint=0; ipoint<entries; ipoint++){
px[ipoint]= tree->GetV3()[ipoint];
pu[ipoint]= tree->GetV3()[ipoint];
pt[ipoint]= tree->GetV2()[ipoint];
}
-
- //
+
+ //
TLinearFitter fitter(5,"hyp4");
for (Int_t ipoint=0; ipoint<entries; ipoint++){
Float_t val = pz[ipoint]*pz[ipoint];
}
void AliTPCClusterParam::FitResolQPar(TTree * tree, Int_t dim, Int_t type, Float_t *param0, Float_t *error){
- //
- // Fit z - angular dependence of resolution - Q scaling - parabolic correction
- //
- // Int_t dim=0, type=0;
+ /// Fit z - angular dependence of resolution - Q scaling - parabolic correction
+ ///
+ /// Int_t dim=0, type=0;
+
TString varVal;
varVal="Resol:AngleM/sqrt(QMean):Zm/QMean";
char varVal0[100];
Float_t px[20000], py[20000], pz[20000], pu[20000], pt[20000];
Float_t ex[20000], ey[20000], ez[20000];
//
- tree->Draw(varErr.Data(),varCut);
+ tree->Draw(varErr.Data(),varCut);
for (Int_t ipoint=0; ipoint<entries; ipoint++){
ex[ipoint]= tree->GetV3()[ipoint];
ey[ipoint]= tree->GetV2()[ipoint];
ez[ipoint]= tree->GetV1()[ipoint];
- }
+ }
tree->Draw(varVal.Data(),varCut);
for (Int_t ipoint=0; ipoint<entries; ipoint++){
px[ipoint]= tree->GetV3()[ipoint];
pu[ipoint]= tree->GetV3()[ipoint];
pt[ipoint]= tree->GetV2()[ipoint];
}
-
- //
+
+ //
TLinearFitter fitter(8,"hyp7");
for (Int_t ipoint=0; ipoint<entries; ipoint++){
Float_t val = pz[ipoint]*pz[ipoint];
void AliTPCClusterParam::FitRMS0(TTree * tree, Int_t dim, Int_t type, Float_t *param0, Float_t *error){
- //
- // Fit z - angular dependence of resolution
- //
- // Int_t dim=0, type=0;
+ /// Fit z - angular dependence of resolution
+ ///
+ /// Int_t dim=0, type=0;
+
TString varVal;
varVal="RMSm:AngleM:Zm";
TString varErr;
Float_t px[10000], py[10000], pz[10000];
Float_t ex[10000], ey[10000], ez[10000];
//
- tree->Draw(varErr.Data(),varCut);
+ tree->Draw(varErr.Data(),varCut);
for (Int_t ipoint=0; ipoint<entries; ipoint++){
ex[ipoint]= tree->GetV3()[ipoint];
ey[ipoint]= tree->GetV2()[ipoint];
ez[ipoint]= tree->GetV1()[ipoint];
- }
+ }
tree->Draw(varVal.Data(),varCut);
for (Int_t ipoint=0; ipoint<entries; ipoint++){
px[ipoint]= tree->GetV3()[ipoint];
py[ipoint]= tree->GetV2()[ipoint];
pz[ipoint]= tree->GetV1()[ipoint];
}
-
- //
+
+ //
TLinearFitter fitter(3,"hyp2");
for (Int_t ipoint=0; ipoint<entries; ipoint++){
Float_t val = pz[ipoint]*pz[ipoint];
}
void AliTPCClusterParam::FitRMS1(TTree * tree, Int_t dim, Float_t *param0, Float_t *error){
- //
- // Fit z - angular dependence of resolution - pad length scaling
- //
- // Int_t dim=0, type=0;
+ /// Fit z - angular dependence of resolution - pad length scaling
+ ///
+ /// Int_t dim=0, type=0;
+
TString varVal;
varVal="RMSm:AngleM*Length:Zm";
TString varErr;
Float_t px[10000], py[10000], pz[10000];
Float_t type[10000], ey[10000], ez[10000];
//
- tree->Draw(varErr.Data(),varCut);
+ tree->Draw(varErr.Data(),varCut);
for (Int_t ipoint=0; ipoint<entries; ipoint++){
type[ipoint] = tree->GetV3()[ipoint];
ey[ipoint] = tree->GetV2()[ipoint];
ez[ipoint] = tree->GetV1()[ipoint];
- }
+ }
tree->Draw(varVal.Data(),varCut);
for (Int_t ipoint=0; ipoint<entries; ipoint++){
px[ipoint]= tree->GetV3()[ipoint];
py[ipoint]= tree->GetV2()[ipoint];
pz[ipoint]= tree->GetV1()[ipoint];
}
-
- //
+
+ //
TLinearFitter fitter(4,"hyp3");
for (Int_t ipoint=0; ipoint<entries; ipoint++){
Float_t val = pz[ipoint]*pz[ipoint];
}
void AliTPCClusterParam::FitRMSQ(TTree * tree, Int_t dim, Int_t type, Float_t *param0, Float_t *error){
- //
- // Fit z - angular dependence of resolution - Q scaling
- //
- // Int_t dim=0, type=0;
+ /// Fit z - angular dependence of resolution - Q scaling
+ ///
+ /// Int_t dim=0, type=0;
+
TString varVal;
varVal="RMSm:AngleM/sqrt(QMean):Zm/QMean";
char varVal0[100];
Float_t px[20000], py[20000], pz[20000], pu[20000], pt[20000];
Float_t ex[20000], ey[20000], ez[20000];
//
- tree->Draw(varErr.Data(),varCut);
+ tree->Draw(varErr.Data(),varCut);
for (Int_t ipoint=0; ipoint<entries; ipoint++){
ex[ipoint]= tree->GetV3()[ipoint];
ey[ipoint]= tree->GetV2()[ipoint];
ez[ipoint]= tree->GetV1()[ipoint];
- }
+ }
tree->Draw(varVal.Data(),varCut);
for (Int_t ipoint=0; ipoint<entries; ipoint++){
px[ipoint]= tree->GetV3()[ipoint];
pu[ipoint]= tree->GetV3()[ipoint];
pt[ipoint]= tree->GetV2()[ipoint];
}
-
- //
+
+ //
TLinearFitter fitter(5,"hyp4");
for (Int_t ipoint=0; ipoint<entries; ipoint++){
Float_t val = pz[ipoint]*pz[ipoint];
void AliTPCClusterParam::FitRMSSigma(TTree * tree, Int_t dim, Int_t type, Float_t *param0, Float_t */*error*/){
- //
- // Fit z - angular dependence of resolution - Q scaling
- //
- // Int_t dim=0, type=0;
+ /// Fit z - angular dependence of resolution - Q scaling
+ ///
+ /// Int_t dim=0, type=0;
+
TString varVal;
varVal="RMSs:RMSm";
//
Float_t AliTPCClusterParam::GetError0(Int_t dim, Int_t type, Float_t z, Float_t angle) const {
- //
- //
- //
+ ///
+
Float_t value=0;
value += fParamS0[dim][type][0];
value += fParamS0[dim][type][1]*z;
value += fParamS0[dim][type][2]*angle*angle;
- value = TMath::Sqrt(TMath::Abs(value));
+ value = TMath::Sqrt(TMath::Abs(value));
return value;
}
Float_t AliTPCClusterParam::GetError0Par(Int_t dim, Int_t type, Float_t z, Float_t angle) const {
- //
- //
- //
+ ///
+
Float_t value=0;
value += fParamS0Par[dim][type][0];
value += fParamS0Par[dim][type][1]*z;
value += fParamS0Par[dim][type][3]*z*z;
value += fParamS0Par[dim][type][4]*angle*angle*angle*angle;
value += fParamS0Par[dim][type][5]*z*angle*angle;
- value = TMath::Sqrt(TMath::Abs(value));
+ value = TMath::Sqrt(TMath::Abs(value));
return value;
}
Float_t AliTPCClusterParam::GetError1(Int_t dim, Int_t type, Float_t z, Float_t angle) const {
- //
- //
- //
+ ///
+
Float_t value=0;
Float_t length=0.75;
if (type==1) length=1;
value += fParamS1[dim][0];
value += fParamS1[dim][1]*z/length;
value += fParamS1[dim][2]*angle*angle*length;
- value = TMath::Sqrt(TMath::Abs(value));
+ value = TMath::Sqrt(TMath::Abs(value));
return value;
}
Float_t AliTPCClusterParam::GetErrorQ(Int_t dim, Int_t type, Float_t z, Float_t angle, Float_t Qmean) const {
- //
- //
- //
+ ///
+
Float_t value=0;
value += fParamSQ[dim][type][0];
value += fParamSQ[dim][type][1]*z;
value += fParamSQ[dim][type][2]*angle*angle;
value += fParamSQ[dim][type][3]*z/Qmean;
value += fParamSQ[dim][type][4]*angle*angle/Qmean;
- value = TMath::Sqrt(TMath::Abs(value));
+ value = TMath::Sqrt(TMath::Abs(value));
return value;
}
Float_t AliTPCClusterParam::GetErrorQPar(Int_t dim, Int_t type, Float_t z, Float_t angle, Float_t Qmean) const {
- //
- //
- //
+ ///
+
Float_t value=0;
value += fParamSQPar[dim][type][0];
value += fParamSQPar[dim][type][1]*z;
value += fParamSQPar[dim][type][5]*z*angle*angle;
value += fParamSQPar[dim][type][6]*z/Qmean;
value += fParamSQPar[dim][type][7]*angle*angle/Qmean;
- value = TMath::Sqrt(TMath::Abs(value));
+ value = TMath::Sqrt(TMath::Abs(value));
return value;
}
Float_t AliTPCClusterParam::GetErrorQParScaled(Int_t dim, Int_t type, Float_t z, Float_t angle, Float_t Qmean) const {
- //
- //
- //
+ ///
+
Float_t value=0;
value += fParamSQPar[dim][type][0];
value += fParamSQPar[dim][type][1]*z;
value += fParamSQPar[dim][type][6]*z/Qmean;
value += fParamSQPar[dim][type][7]*angle*angle/Qmean;
Float_t valueMean = GetError0Par(dim,type,z,angle);
- value -= 0.35*0.35*valueMean*valueMean;
- value = TMath::Sqrt(TMath::Abs(value));
+ value -= 0.35*0.35*valueMean*valueMean;
+ value = TMath::Sqrt(TMath::Abs(value));
return value;
}
Float_t AliTPCClusterParam::GetRMS0(Int_t dim, Int_t type, Float_t z, Float_t angle) const {
- //
- // calculate mean RMS of cluster - z,angle - parameters for each pad and dimension separatelly
- //
+ /// calculate mean RMS of cluster - z,angle - parameters for each pad and dimension separatelly
+
Float_t value=0;
value += fParamRMS0[dim][type][0];
value += fParamRMS0[dim][type][1]*z;
value += fParamRMS0[dim][type][2]*angle*angle;
- value = TMath::Sqrt(TMath::Abs(value));
+ value = TMath::Sqrt(TMath::Abs(value));
return value;
}
Float_t AliTPCClusterParam::GetRMS1(Int_t dim, Int_t type, Float_t z, Float_t angle) const {
- //
- // calculate mean RMS of cluster - z,angle - pad length scalling
- //
+ /// calculate mean RMS of cluster - z,angle - pad length scalling
+
Float_t value=0;
Float_t length=0.75;
if (type==1) length=1;
}
value += fParamRMS1[dim][2]*z;
value += fParamRMS1[dim][3]*angle*angle*length*length;
- value = TMath::Sqrt(TMath::Abs(value));
+ value = TMath::Sqrt(TMath::Abs(value));
return value;
}
Float_t AliTPCClusterParam::GetRMSQ(Int_t dim, Int_t type, Float_t z, Float_t angle, Float_t Qmean) const {
- //
- // calculate mean RMS of cluster - z,angle, Q dependence
- //
+ /// calculate mean RMS of cluster - z,angle, Q dependence
+
Float_t value=0;
value += fParamRMSQ[dim][type][0];
value += fParamRMSQ[dim][type][1]*z;
value += fParamRMSQ[dim][type][2]*angle*angle;
value += fParamRMSQ[dim][type][3]*z/Qmean;
value += fParamRMSQ[dim][type][4]*angle*angle/Qmean;
- value = TMath::Sqrt(TMath::Abs(value));
+ value = TMath::Sqrt(TMath::Abs(value));
return value;
}
Float_t AliTPCClusterParam::GetRMSSigma(Int_t dim, Int_t type, Float_t z, Float_t angle, Float_t Qmean) const {
- //
- // calculates RMS of signal shape fluctuation
- //
+ /// calculates RMS of signal shape fluctuation
+
Float_t mean = GetRMSQ(dim,type,z,angle,Qmean);
Float_t value = fRMSSigmaFit[dim][type][0];
value+= fRMSSigmaFit[dim][type][1]*mean;
}
Float_t AliTPCClusterParam::GetShapeFactor(Int_t dim, Int_t type, Float_t z, Float_t angle, Float_t Qmean, Float_t rmsL, Float_t rmsM) const {
- //
- // calculates vallue - sigma distortion contribution
- //
+ /// calculates vallue - sigma distortion contribution
+
Double_t value =0;
//
Float_t rmsMeanQ = GetRMSQ(dim,type,z,angle,Qmean);
void AliTPCClusterParam::FitData(TTree * tree){
- //
- // make fits for error param and shape param
- //
+ /// make fits for error param and shape param
+
FitResol(tree);
FitRMS(tree);
}
void AliTPCClusterParam::FitResol(TTree * tree){
- //
+ ///
+
SetInstance(this);
- for (Int_t idir=0;idir<2; idir++){
+ for (Int_t idir=0;idir<2; idir++){
for (Int_t itype=0; itype<3; itype++){
Float_t param0[10];
Float_t error0[10];
printf("%f\t%f\t%f\n", param0[0],param0[1],param0[2]);
printf("%f\t%f\t%f\n", error0[0],error0[1],error0[2]);
for (Int_t ipar=0;ipar<4; ipar++){
- fParamS0[idir][itype][ipar] = param0[ipar];
- fErrorS0[idir][itype][ipar] = param0[ipar];
- }
+ fParamS0[idir][itype][ipar] = param0[ipar];
+ fErrorS0[idir][itype][ipar] = param0[ipar];
+ }
// error param with parabolic correction
FitResol0Par(tree, idir, itype,param0,error0);
printf("\nResolPar\t%d\t%d\tchi2=%f\n",idir,itype,param0[6]);
printf("%f\t%f\t%f\t%f\t%f\t%f\n", param0[0],param0[1],param0[2],param0[3],param0[4],param0[5]);
printf("%f\t%f\t%f\t%f\t%f\t%f\n", error0[0],error0[1],error0[2],error0[3],error0[4],error0[5]);
for (Int_t ipar=0;ipar<7; ipar++){
- fParamS0Par[idir][itype][ipar] = param0[ipar];
- fErrorS0Par[idir][itype][ipar] = param0[ipar];
+ fParamS0Par[idir][itype][ipar] = param0[ipar];
+ fErrorS0Par[idir][itype][ipar] = param0[ipar];
}
//
FitResolQ(tree, idir, itype,param0,error0);
printf("%f\t%f\t%f\t%f\t%f\n", param0[0],param0[1],param0[2],param0[3],param0[4]);
printf("%f\t%f\t%f\t%f\t%f\n", error0[0],error0[1],error0[2],error0[3],error0[4]);
for (Int_t ipar=0;ipar<6; ipar++){
- fParamSQ[idir][itype][ipar] = param0[ipar];
- fErrorSQ[idir][itype][ipar] = param0[ipar];
+ fParamSQ[idir][itype][ipar] = param0[ipar];
+ fErrorSQ[idir][itype][ipar] = param0[ipar];
}
//
FitResolQPar(tree, idir, itype,param0,error0);
printf("%f\t%f\t%f\t%f\t%f\t%f\t%f\t%f\n", param0[0],param0[1],param0[2],param0[3],param0[4],param0[5],param0[6],param0[7]);
printf("%f\t%f\t%f\t%f\t%f\t%f\t%f\t%f\n", error0[0],error0[1],error0[2],error0[3],error0[4],error0[5],error0[6],error0[7]);
for (Int_t ipar=0;ipar<9; ipar++){
- fParamSQPar[idir][itype][ipar] = param0[ipar];
- fErrorSQPar[idir][itype][ipar] = param0[ipar];
+ fParamSQPar[idir][itype][ipar] = param0[ipar];
+ fErrorSQPar[idir][itype][ipar] = param0[ipar];
}
}
}
//
printf("Resol z-scaled\n");
- for (Int_t idir=0;idir<2; idir++){
+ for (Int_t idir=0;idir<2; idir++){
Float_t param0[4];
Float_t error0[4];
FitResol1(tree, idir,param0,error0);
printf("%f\t%f\t%f\n", param0[0],param0[1],param0[2]);
printf("%f\t%f\t%f\n", error0[0],error0[1],error0[2]);
for (Int_t ipar=0;ipar<4; ipar++){
- fParamS1[idir][ipar] = param0[ipar];
- fErrorS1[idir][ipar] = param0[ipar];
+ fParamS1[idir][ipar] = param0[ipar];
+ fErrorS1[idir][ipar] = param0[ipar];
}
}
if (itype==2) length=1.5;
printf("%d\t%f\t%f\t%f\n", itype,fParamS0[idir][itype][0],fParamS0[idir][itype][1]*TMath::Sqrt(length),fParamS0[idir][itype][2]/TMath::Sqrt(length));
}
- }
+ }
}
void AliTPCClusterParam::FitRMS(TTree * tree){
- //
+ ///
+
SetInstance(this);
- for (Int_t idir=0;idir<2; idir++){
+ for (Int_t idir=0;idir<2; idir++){
for (Int_t itype=0; itype<3; itype++){
Float_t param0[6];
Float_t error0[6];
printf("%f\t%f\t%f\n", param0[0],param0[1],param0[2]);
printf("%f\t%f\t%f\n", error0[0],error0[1],error0[2]);
for (Int_t ipar=0;ipar<4; ipar++){
- fParamRMS0[idir][itype][ipar] = param0[ipar];
- fErrorRMS0[idir][itype][ipar] = param0[ipar];
+ fParamRMS0[idir][itype][ipar] = param0[ipar];
+ fErrorRMS0[idir][itype][ipar] = param0[ipar];
}
FitRMSQ(tree, idir, itype,param0,error0);
printf("\nRMSQ\t%d\t%d\tchi2=%f\n",idir,itype,param0[5]);
printf("%f\t%f\t%f\t%f\t%f\n", param0[0],param0[1],param0[2],param0[3],param0[4]);
printf("%f\t%f\t%f\t%f\t%f\n", error0[0],error0[1],error0[2],error0[3],error0[4]);
for (Int_t ipar=0;ipar<6; ipar++){
- fParamRMSQ[idir][itype][ipar] = param0[ipar];
- fErrorRMSQ[idir][itype][ipar] = param0[ipar];
+ fParamRMSQ[idir][itype][ipar] = param0[ipar];
+ fErrorRMSQ[idir][itype][ipar] = param0[ipar];
}
}
}
//
printf("RMS z-scaled\n");
- for (Int_t idir=0;idir<2; idir++){
+ for (Int_t idir=0;idir<2; idir++){
Float_t param0[5];
Float_t error0[5];
FitRMS1(tree, idir,param0,error0);
printf("%f\t%f\t%f\t%f\n", param0[0],param0[1],param0[2], param0[3]);
printf("%f\t%f\t%f\t%f\n", error0[0],error0[1],error0[2], error0[3]);
for (Int_t ipar=0;ipar<5; ipar++){
- fParamRMS1[idir][ipar] = param0[ipar];
- fErrorRMS1[idir][ipar] = param0[ipar];
+ fParamRMS1[idir][ipar] = param0[ipar];
+ fErrorRMS1[idir][ipar] = param0[ipar];
}
}
if (itype==0) printf("%d\t%f\t\t\t%f\t%f\n", itype,fParamRMS0[idir][itype][0],fParamRMS0[idir][itype][1],fParamRMS0[idir][itype][2]/length);
if (itype>0) printf("%d\t\t\t%f\t%f\t%f\n", itype,fParamRMS0[idir][itype][0],fParamRMS0[idir][itype][1],fParamRMS0[idir][itype][2]/length);
}
- }
+ }
//
// Fit RMS sigma
//
printf("RMS fluctuation parameterization \n");
- for (Int_t idir=0;idir<2; idir++){
- for (Int_t itype=0; itype<3; itype++){
+ for (Int_t idir=0;idir<2; idir++){
+ for (Int_t itype=0; itype<3; itype++){
Float_t param0[5];
Float_t error0[5];
- FitRMSSigma(tree, idir,itype,param0,error0);
+ FitRMSSigma(tree, idir,itype,param0,error0);
printf("\t%d\t%d\t%f\t%f\n", idir, itype, param0[0],param0[1]);
for (Int_t ipar=0;ipar<2; ipar++){
- fRMSSigmaFit[idir][itype][ipar] = param0[ipar];
+ fRMSSigmaFit[idir][itype][ipar] = param0[ipar];
}
}
- }
+ }
//
// store systematic error end RMS fluctuation parameterization
//
}
void AliTPCClusterParam::Test(TTree * tree, const char *output){
- //
- // Draw standard quality histograms to output file
- //
+ /// Draw standard quality histograms to output file
+
SetInstance(this);
TFile f(output,"recreate");
f.cd();
void AliTPCClusterParam::Print(Option_t* /*option*/) const{
- //
- // Print param Information
- //
+ /// Print param Information
//
// Error parameterization
for (Int_t ipad=0; ipad<3; ipad++){
Float_t length=0.75;
if (ipad==1) length=1;
- if (ipad==2) length=1.5;
- printf("\t%d\t%f\t%f\t%f\t%f\n", ipad,
+ if (ipad==2) length=1.5;
+ printf("\t%d\t%f\t%f\t%f\t%f\n", ipad,
TMath::Sqrt(TMath::Abs(fParamS0[0][ipad][0])),
TMath::Sqrt(TMath::Abs(fParamS0[0][ipad][1]*length)),
TMath::Sqrt(TMath::Abs(fParamS0[0][ipad][2]/length)),
Float_t length=0.75;
if (ipad==1) length=1;
if (ipad==2) length=1.5;
- printf("\t%dPar\t%f\t%f\t%f\t%f\n", ipad,
+ printf("\t%dPar\t%f\t%f\t%f\t%f\n", ipad,
TMath::Sqrt(TMath::Abs(fParamS0Par[0][ipad][0])),
TMath::Sqrt(TMath::Abs(fParamS0Par[0][ipad][1]*length)),
TMath::Sqrt(TMath::Abs(fParamS0Par[0][ipad][2]/length)),
}
printf("Z\tall\t%f\t%f\t%f\t%f\n", TMath::Sqrt(TMath::Abs(fParamS1[1][0])),TMath::Sqrt(fParamS1[1][1]),
TMath::Sqrt(fParamS1[1][2]), TMath::Sqrt(fParamS1[1][3]));
-
+
for (Int_t ipad=0; ipad<3; ipad++){
Float_t length=0.75;
if (ipad==1) length=1;
- if (ipad==2) length=1.5;
- printf("\t%d\t%f\t%f\t%f\t%f\n", ipad,
+ if (ipad==2) length=1.5;
+ printf("\t%d\t%f\t%f\t%f\t%f\n", ipad,
TMath::Sqrt(TMath::Abs(fParamS0[1][ipad][0])),
TMath::Sqrt(TMath::Abs(fParamS0[1][ipad][1]*length)),
TMath::Sqrt(TMath::Abs(fParamS0[1][ipad][2]/length)),
for (Int_t ipad=0; ipad<3; ipad++){
Float_t length=0.75;
if (ipad==1) length=1;
- if (ipad==2) length=1.5;
- printf("\t%dPar\t%f\t%f\t%f\t%f\n", ipad,
+ if (ipad==2) length=1.5;
+ printf("\t%dPar\t%f\t%f\t%f\t%f\n", ipad,
TMath::Sqrt(TMath::Abs(TMath::Abs(fParamS0Par[1][ipad][0]))),
TMath::Sqrt(TMath::Abs(fParamS0Par[1][ipad][1]*length)),
TMath::Sqrt(TMath::Abs(fParamS0Par[1][ipad][2]/length)),
TMath::Sqrt(TMath::Abs(fParamS0Par[1][ipad][6])));
}
-
+
//
// RMS scaling
//
printf("\n");
printf("\nRMS Scaled factors\n");
printf("Dir\tPad\tP00\t\tP01\t\tP1\t\tP2\t\tchi2\n");
- printf("Y\tall\t%f\t%f\t%f\t%f\t%f\n",
+ printf("Y\tall\t%f\t%f\t%f\t%f\t%f\n",
TMath::Sqrt(TMath::Abs(fParamRMS1[0][0])),
TMath::Sqrt(TMath::Abs(fParamRMS1[0][1])),
TMath::Sqrt(TMath::Abs(fParamRMS1[0][2])),
for (Int_t ipad=0; ipad<3; ipad++){
Float_t length=0.75;
if (ipad==1) length=1;
- if (ipad==2) length=1.5;
+ if (ipad==2) length=1.5;
if (ipad==0){
- printf("\t%d\t%f\t%f\t%f\t%f\t%f\n", ipad,
+ printf("\t%d\t%f\t%f\t%f\t%f\t%f\n", ipad,
TMath::Sqrt(TMath::Abs(fParamRMS0[0][ipad][0])),
0.,
TMath::Sqrt(TMath::Abs(fParamRMS0[0][ipad][1])),
TMath::Sqrt(TMath::Abs(fParamRMS0[0][ipad][2]/(length*length))),
TMath::Sqrt(TMath::Abs(fParamRMS0[0][ipad][3])));
}else{
- printf("\t%d\t%f\t%f\t%f\t%f\t%f\n", ipad,
+ printf("\t%d\t%f\t%f\t%f\t%f\t%f\n", ipad,
0.,
TMath::Sqrt(TMath::Abs(fParamRMS0[0][ipad][0])),
TMath::Sqrt(TMath::Abs(fParamRMS0[0][ipad][1])),
TMath::Sqrt(TMath::Abs(fParamRMS0[0][ipad][2]/(length*length))),
- TMath::Sqrt(TMath::Abs(fParamRMS0[0][ipad][3])));
+ TMath::Sqrt(TMath::Abs(fParamRMS0[0][ipad][3])));
}
}
printf("\n");
- printf("Z\tall\t%f\t%f\t%f\t%f\t%f\n",
+ printf("Z\tall\t%f\t%f\t%f\t%f\t%f\n",
TMath::Sqrt(TMath::Abs(fParamRMS1[1][0])),
TMath::Sqrt(TMath::Abs(fParamRMS1[1][1])),
TMath::Sqrt(TMath::Abs(fParamRMS1[1][2])),
for (Int_t ipad=0; ipad<3; ipad++){
Float_t length=0.75;
if (ipad==1) length=1;
- if (ipad==2) length=1.5;
+ if (ipad==2) length=1.5;
if (ipad==0){
- printf("\t%d\t%f\t%f\t%f\t%f\t%f\n", ipad,
+ printf("\t%d\t%f\t%f\t%f\t%f\t%f\n", ipad,
TMath::Sqrt(TMath::Abs(fParamRMS0[1][ipad][0])),
0.,
TMath::Sqrt(TMath::Abs(fParamRMS0[1][ipad][1])),
TMath::Sqrt(TMath::Abs(fParamRMS0[1][ipad][2]/(length*length))),
TMath::Sqrt(TMath::Abs(fParamRMS0[1][ipad][3])));
}else{
- printf("\t%d\t%f\t%f\t%f\t%f\t%f\n", ipad,
+ printf("\t%d\t%f\t%f\t%f\t%f\t%f\n", ipad,
0.,
TMath::Sqrt(TMath::Abs(fParamRMS0[1][ipad][0])),
TMath::Sqrt(TMath::Abs(fParamRMS0[1][ipad][1])),
TMath::Sqrt(TMath::Abs(fParamRMS0[1][ipad][2]/(length*length))),
- TMath::Sqrt(TMath::Abs(fParamRMS0[1][ipad][3])));
+ TMath::Sqrt(TMath::Abs(fParamRMS0[1][ipad][3])));
}
}
printf("\ndEdx correction matrix used in GetQnormCorr\n");
Float_t AliTPCClusterParam::Qnorm(Int_t ipad, Int_t itype, Float_t dr, Float_t ty, Float_t tz){
- // get Q normalization
- // type - 0 Qtot 1 Qmax
- // ipad - 0 (0.75 cm) ,1 (1 cm), 2 (1.5 cm)
- //
- //expession formula - TString *strq0 = toolkit.FitPlane(chain,"dedxQ.fElements[2]","dr++ty++tz++dr*ty++dr*tz++++dr*dr++ty*tz++ty^2++tz^2","IPad==0",chi2,npoints,param,covar,0,100000);
+ /// get Q normalization
+ /// type - 0 Qtot 1 Qmax
+ /// ipad - 0 (0.75 cm) ,1 (1 cm), 2 (1.5 cm)
+ ///
+ /// expession formula - TString *strq0 = toolkit.FitPlane(chain,"dedxQ.fElements[2]","dr++ty++tz++dr*ty++dr*tz++++dr*dr++ty*tz++ty^2++tz^2","IPad==0",chi2,npoints,param,covar,0,100000);
if (fQNorm==0) return 0;
TVectorD * norm = (TVectorD*)fQNorm->At(3*itype+ipad);
if (!norm) return 0;
TVectorD &no = *norm;
- Float_t res =
+ Float_t res =
no[0]+
no[1]*dr+
no[2]*ty+
Float_t AliTPCClusterParam::QnormHis(Int_t ipad, Int_t itype, Float_t dr, Float_t p2, Float_t p3){
- // get Q normalization
- // type - 0 Qtot 1 Qmax
- // ipad - 0 (0.75 cm) ,1 (1 cm), 2 (1.5 cm)
- //
+ /// get Q normalization
+ /// type - 0 Qtot 1 Qmax
+ /// ipad - 0 (0.75 cm) ,1 (1 cm), 2 (1.5 cm)
if (fQNormHis==0) return 0;
TH3F * norm = (TH3F*)fQNormHis->At(4*itype+ipad);
p3=TMath::Max(p3,Float_t(norm->GetZaxis()->GetXmin()+norm->GetZaxis()->GetBinWidth(0)));
//
Double_t res = norm->GetBinContent(norm->FindBin(dr,p2,p3));
- if (res==0) res = norm->GetBinContent(norm->FindBin(0.5,0.5,0.5)); // This is just hack - to be fixed entries without
+ if (res==0) res = norm->GetBinContent(norm->FindBin(0.5,0.5,0.5)); // This is just hack - to be fixed entries without
return res;
}
void AliTPCClusterParam::SetQnorm(Int_t ipad, Int_t itype, const TVectorD *const norm){
- //
- // set normalization
- //
- // type - 0 Qtot 1 Qmax
- // ipad - 0 (0.75 cm) ,1 (1 cm), 2 (1.5 cm)
- //
+ /// set normalization
+ ///
+ /// type - 0 Qtot 1 Qmax
+ /// ipad - 0 (0.75 cm) ,1 (1 cm), 2 (1.5 cm)
if (fQNorm==0) fQNorm = new TObjArray(6);
fQNorm->AddAt(new TVectorD(*norm), itype*3+ipad);
}
void AliTPCClusterParam::ResetQnormCorr(){
- //
- //
- //
+ ///
+
if (!fQNormCorr) fQNormCorr= new TMatrixD(12,6);
for (Int_t irow=0;irow<12; irow++)
for (Int_t icol=0;icol<6; icol++){
(*fQNormCorr)(irow,icol)=1.; // default - no correction
if (irow>5) (*fQNormCorr)(irow,icol)=0.; // default - no correction
- }
+ }
}
void AliTPCClusterParam::SetQnormCorr(Int_t ipad, Int_t itype, Int_t corrType, Float_t val, Int_t mode){
- //
- // ipad - pad type
- // itype - 0- qtot 1-qmax
- // corrType - 0 - s0y corr - eff. PRF corr
- // - 1 - s0z corr - eff. TRF corr
- // - 2 - d0y - eff. diffusion correction y
- // - 3 - d0z - eff. diffusion correction
- // - 4 - eff length - eff.length - wire pitch + x diffsion
- // - 5 - pad type normalization
+ /// ipad - pad type
+ /// itype - 0- qtot 1-qmax
+ /// corrType - 0 - s0y corr - eff. PRF corr
+ /// - 1 - s0z corr - eff. TRF corr
+ /// - 2 - d0y - eff. diffusion correction y
+ /// - 3 - d0z - eff. diffusion correction
+ /// - 4 - eff length - eff.length - wire pitch + x diffsion
+ /// - 5 - pad type normalization
+
if (!fQNormCorr) {
ResetQnormCorr();
}
//
// rows
// itype*3+ipad - itype=0 qtot itype=1 qmax ipad=0
- //
- if (mode==1) {
+ //
+ if (mode==1) {
// mode introduced in 20.07.2014 - git describe ~ vAN-20140703-48-g3449a97 - to keep back compatibility with o
(*fQNormCorr)(itype*3+ipad, corrType) = val; // set value
return;
}
if (itype<2) (*fQNormCorr)(itype*3+ipad, corrType) *= val; // multiplicative correction
- if (itype>=2) (*fQNormCorr)(itype*3+ipad, corrType)+= val; // additive correction
+ if (itype>=2) (*fQNormCorr)(itype*3+ipad, corrType)+= val; // additive correction
}
Double_t AliTPCClusterParam::GetQnormCorr(Int_t ipad, Int_t itype, Int_t corrType) const{
- //
- // see AliTPCClusterParam::SetQnormCorr
- //
+ /// see AliTPCClusterParam::SetQnormCorr
+
if (!fQNormCorr) return 0;
return (*fQNormCorr)(itype*3+ipad, corrType);
}
Float_t AliTPCClusterParam::QnormPos(Int_t ipad,Bool_t isMax, Float_t pad, Float_t time, Float_t z, Float_t sy2, Float_t sz2, Float_t qm, Float_t qt){
- //
- // Make Q normalization as function of following parameters
- // Fit parameters to be used in corresponding correction function extracted in the AliTPCclaibTracksGain - Taylor expansion
- // 1 - dp - relative pad position
- // 2 - dt - relative time position
- // 3 - di - drift length (norm to 1);
- // 4 - dq0 - Tot/Max charge
- // 5 - dq1 - Max/Tot charge
- // 6 - sy - sigma y - shape
- // 7 - sz - sigma z - shape
- //
-
- //The results can be visualized using the debug streamer information of the AliTPCcalibTracksGain -
- // Following variable used - correspondance to the our variable conventions
+ /// Make Q normalization as function of following parameters
+ /// Fit parameters to be used in corresponding correction function extracted in the AliTPCclaibTracksGain - Taylor expansion
+ /// 1 - dp - relative pad position
+ /// 2 - dt - relative time position
+ /// 3 - di - drift length (norm to 1);
+ /// 4 - dq0 - Tot/Max charge
+ /// 5 - dq1 - Max/Tot charge
+ /// 6 - sy - sigma y - shape
+ /// 7 - sz - sigma z - shape
+
+ //The results can be visualized using the debug streamer information of the AliTPCcalibTracksGain -
+ // Following variable used - correspondance to the our variable conventions
//chain0->SetAlias("dp","((Cl.fPad-int(Cl.fPad)-0.5)/0.5)");
Double_t dp = ((pad-int(pad)-0.5)*2.);
//chain0->SetAlias("dt","((Cl.fTimeBin-int(Cl.fTimeBin)-0.5)/0.5)");
if (isMax){
pvec = fPosQMnorm[ipad];
}else{
- pvec = fPosQTnorm[ipad];
+ pvec = fPosQTnorm[ipad];
}
TVectorD ¶m = *pvec;
//
// Eval part - in correspondance with fit part from debug streamer
- //
+ //
Double_t result=param[0];
Int_t index =1;
//
if (result>1.25) result=1.25;
return result;
-
+
}
Float_t AliTPCClusterParam::PosCorrection(Int_t type, Int_t ipad, Float_t pad, Float_t time, Float_t z, Float_t /*sy2*/, Float_t /*sz2*/, Float_t /*qm*/){
- //
- // Make postion correction
- // type - 0 - y correction
- // 1 - z correction
- // ipad - 0, 1, 2 - short, medium long pads
- // pad - float pad number
- // time - float time bin number
- // z - z of the cluster
-
+ /// Make postion correction
+ /// type - 0 - y correction
+ /// 1 - z correction
+ /// ipad - 0, 1, 2 - short, medium long pads
+ /// pad - float pad number
+ /// time - float time bin number
+ /// z - z of the cluster
+
//
//chainres->SetAlias("dp","(-1+(Cl.fZ>0)*2)*((Cl.fPad-int(Cl.fPad))-0.5)");
//chainres->SetAlias("dt","(-1+(Cl.fZ>0)*2)*((Cl.fTimeBin-0.66-int(Cl.fTimeBin-0.66))-0.5)");
if (type==0){
pvec = fPosYcor[ipad];
}else{
- pvec = fPosZcor[ipad];
+ pvec = fPosZcor[ipad];
}
TVectorD ¶m = *pvec;
//
Double_t AliTPCClusterParam::GaussConvolution(Double_t x0, Double_t x1, Double_t k0, Double_t k1, Double_t s0, Double_t s1){
- //
- // 2 D gaus convoluted with angular effect
- // See in mathematica:
- //Simplify[Integrate[Exp[-(x0-k0*xd)*(x0-k0*xd)/(2*s0*s0)-(x1-k1*xd)*(x1-k1*xd)/(2*s1*s1)]/(s0*s1),{xd,-1/2,1/2}]]
- //
- //TF1 f1("f1","AliTPCClusterParam::GaussConvolution(x,0,1,0,0.1,0.1)",-2,2)
- //TF2 f2("f2","AliTPCClusterParam::GaussConvolution(x,y,1,1,0.1,0.1)",-2,2,-2,2)
- //
+ /// 2 D gaus convoluted with angular effect
+ /// See in mathematica:
+ /// Simplify[Integrate[Exp[-(x0-k0*xd)*(x0-k0*xd)/(2*s0*s0)-(x1-k1*xd)*(x1-k1*xd)/(2*s1*s1)]/(s0*s1),{xd,-1/2,1/2}]]
+ ///
+ /// TF1 f1("f1","AliTPCClusterParam::GaussConvolution(x,0,1,0,0.1,0.1)",-2,2)
+ /// TF2 f2("f2","AliTPCClusterParam::GaussConvolution(x,y,1,1,0.1,0.1)",-2,2,-2,2)
+
const Double_t kEpsilon = 0.0001;
const Double_t twoPi = TMath::TwoPi();
const Double_t hnorm = 0.5/TMath::Sqrt(twoPi);
Double_t AliTPCClusterParam::GaussConvolutionTail(Double_t x0, Double_t x1, Double_t k0, Double_t k1, Double_t s0, Double_t s1, Double_t tau){
- //
- // 2 D gaus convoluted with angular effect and exponential tail in z-direction
- // tail integrated numerically
- // Integral normalized to one
- // Mean at 0
- //
- // TF1 f1t("f1t","AliTPCClusterParam::GaussConvolutionTail(0,x,0,0,0.5,0.5,0.9)",-5,5)
+ /// 2 D gaus convoluted with angular effect and exponential tail in z-direction
+ /// tail integrated numerically
+ /// Integral normalized to one
+ /// Mean at 0
+ ///
+ /// TF1 f1t("f1t","AliTPCClusterParam::GaussConvolutionTail(0,x,0,0,0.5,0.5,0.9)",-5,5)
+
Double_t sum =1, mean=0;
// the COG of exponent
for (Float_t iexp=0;iexp<5;iexp+=0.2){
}
Double_t AliTPCClusterParam::GaussConvolutionGamma4(Double_t x0, Double_t x1, Double_t k0, Double_t k1, Double_t s0, Double_t s1, Double_t tau){
- //
- // 2 D gaus convoluted with angular effect and exponential tail in z-direction
- // tail integrated numerically
- // Integral normalized to one
- // Mean at 0
- //
- // TF1 f1g4("f1g4","AliTPCClusterParam::GaussConvolutionGamma4(0,x,0,0,0.5,0.2,1.6)",-5,5)
- // TF2 f2g4("f2g4","AliTPCClusterParam::GaussConvolutionGamma4(y,x,0,0,0.5,0.2,1.6)",-5,5,-5,5)
+ /// 2 D gaus convoluted with angular effect and exponential tail in z-direction
+ /// tail integrated numerically
+ /// Integral normalized to one
+ /// Mean at 0
+ ///
+ /// TF1 f1g4("f1g4","AliTPCClusterParam::GaussConvolutionGamma4(0,x,0,0,0.5,0.2,1.6)",-5,5)
+ /// TF2 f2g4("f2g4","AliTPCClusterParam::GaussConvolutionGamma4(y,x,0,0,0.5,0.2,1.6)",-5,5,-5,5)
+
Double_t sum =0, mean=0;
// the COG of G4
for (Float_t iexp=0;iexp<5;iexp+=0.2){
//
sum = 0;
Double_t val = 0;
- for (Float_t iexp=0;iexp<5;iexp+=0.2){
+ for (Float_t iexp=0;iexp<5;iexp+=0.2){
Double_t g4 = TMath::Exp(-4.*iexp/tau)*TMath::Power(iexp/tau,4.);
val+=GaussConvolution(x0,x1+mean-iexp, k0, k1 , s0,s1)*g4;
sum+=g4;
}
Double_t AliTPCClusterParam::QmaxCorrection(Int_t sector, Int_t row, Float_t cpad, Float_t ctime, Float_t ky, Float_t kz, Float_t rmsy0, Float_t rmsz0, Float_t effPad, Float_t effDiff){
- //
- //
- // cpad - pad (y) coordinate
- // ctime - time(z) coordinate
- // ky - dy/dx
- // kz - dz/dx
- // rmsy0 - RF width in pad units
- // rmsz0 - RF width in time bin units
- // effLength - contibution of PRF and diffusion
- // effDiff - overwrite diffusion
+ /// cpad - pad (y) coordinate
+ /// ctime - time(z) coordinate
+ /// ky - dy/dx
+ /// kz - dz/dx
+ /// rmsy0 - RF width in pad units
+ /// rmsz0 - RF width in time bin units
+ /// effLength - contibution of PRF and diffusion
+ /// effDiff - overwrite diffusion
// Response function aproximated by convolution of gaussian with angular effect (integral=1)
- //
- // Gaus width sy and sz is determined by RF width and diffusion
+ //
+ // Gaus width sy and sz is determined by RF width and diffusion
// Integral of Q is equal 1
// Q max is calculated at position cpad, ctime
- // Example function:
- // TF1 f1("f1", "AliTPCClusterParam::QmaxCorrection(0,0.5,x,0,0,0.5,0.6)",0,1000)
+ // Example function:
+ // TF1 f1("f1", "AliTPCClusterParam::QmaxCorrection(0,0.5,x,0,0,0.5,0.6)",0,1000)
//
- AliTPCParam * param = AliTPCcalibDB::Instance()->GetParameters();
+ AliTPCParam * param = AliTPCcalibDB::Instance()->GetParameters();
Double_t padLength= param->GetPadPitchLength(sector,row);
Double_t padWidth = param->GetPadPitchWidth(sector);
Double_t zwidth = param->GetZWidth();
//
//
Double_t sy = TMath::Sqrt(rmsy0*rmsy0+diffT*diffT);
- Double_t sz = TMath::Sqrt(rmsz0*rmsz0+diffL*diffL);
+ Double_t sz = TMath::Sqrt(rmsz0*rmsz0+diffL*diffL);
//return GaussConvolutionGamma4(py,pz, pky,pkz,sy,sz,tau);
Double_t length = padLength*TMath::Sqrt(1+ky*ky+kz*kz);
return GaussConvolution(py,pz, pky,pkz,sy,sz)*length;
}
Double_t AliTPCClusterParam::QtotCorrection(Int_t sector, Int_t row, Float_t cpad, Float_t ctime, Float_t ky, Float_t kz, Float_t rmsy0, Float_t rmsz0, Float_t qtot, Float_t thr, Float_t effPad, Float_t effDiff){
- //
- //
- // cpad - pad (y) coordinate
- // ctime - time(z) coordinate
- // ky - dy/dx
- // kz - dz/dx
- // rmsy0 - RF width in pad units
- // rmsz0 - RF width in time bin units
- // qtot - the sum of signal in cluster - without thr correction
- // thr - threshold
- // effLength - contibution of PRF and diffusion
- // effDiff - overwrite diffusion
+ /// cpad - pad (y) coordinate
+ /// ctime - time(z) coordinate
+ /// ky - dy/dx
+ /// kz - dz/dx
+ /// rmsy0 - RF width in pad units
+ /// rmsz0 - RF width in time bin units
+ /// qtot - the sum of signal in cluster - without thr correction
+ /// thr - threshold
+ /// effLength - contibution of PRF and diffusion
+ /// effDiff - overwrite diffusion
// Response function aproximated by convolution of gaussian with angular effect (integral=1)
- //
- // Gaus width sy and sz is determined by RF width and diffusion
+ //
+ // Gaus width sy and sz is determined by RF width and diffusion
// Integral of Q is equal 1
// Q max is calculated at position cpad, ctime
- //
- //
//
- AliTPCParam * param = AliTPCcalibDB::Instance()->GetParameters();
+ //
+ //
+ AliTPCParam * param = AliTPCcalibDB::Instance()->GetParameters();
Double_t padLength= param->GetPadPitchLength(sector,row);
Double_t padWidth = param->GetPadPitchWidth(sector);
Double_t zwidth = param->GetZWidth();
diffT*=effDiff; //
diffL*=effDiff; //
//
- // transform angular effect to pad units
+ // transform angular effect to pad units
Double_t pky = ky*effLength/padWidth;
Double_t pkz = kz*effLength/zwidth;
// position in pad unit
- //
+ //
Double_t py = (cpad+0.5)-TMath::Nint(cpad+0.5);
Double_t pz = (ctime+0.5)-TMath::Nint(ctime+0.5);
//
Double_t sy = TMath::Sqrt(rmsy0*rmsy0+diffT*diffT);
- Double_t sz = TMath::Sqrt(rmsz0*rmsz0+diffL*diffL);
+ Double_t sz = TMath::Sqrt(rmsz0*rmsz0+diffL*diffL);
//
//
//
Double_t qnorm=qtot;
for (Float_t iy=-3;iy<=3;iy+=1.)
for (Float_t iz=-4;iz<=4;iz+=1.){
- // Double_t val = GaussConvolutionGamma4(py-iy,pz-iz, pky,pkz, sy,sz,tau);
- Double_t val = GaussConvolution(py-iy,pz-iz, pky,pkz, sy,sz);
+ // Double_t val = GaussConvolutionGamma4(py-iy,pz-iz, pky,pkz, sy,sz,tau);
+ Double_t val = GaussConvolution(py-iy,pz-iz, pky,pkz, sy,sz);
Double_t qlocal =qnorm*val;
if (TMath::Abs(iy)<1.5&&TMath::Abs(iz)<1.5){
sumThr+=qlocal; // Virtual charge used in cluster finder
void AliTPCClusterParam::SetWaveCorrectionMap( THnBase *Map)
{
- //
- // Set Correction Map for Y
- //
+ /// Set Correction Map for Y
+
delete fWaveCorrectionMap;
fWaveCorrectionMap = 0;
fWaveCorrectionMirroredPad = kFALSE;
void AliTPCClusterParam::SetResolutionYMap( THnBase *Map)
{
- //
- // Set Resolution Map for Y
- //
+ /// Set Resolution Map for Y
+
delete fResolutionYMap;
fResolutionYMap = 0;
if( Map ){
Float_t AliTPCClusterParam::GetWaveCorrection(Int_t Type, Float_t Z, Int_t QMax, Float_t Pad, Float_t angleY ) const
{
- //
- // Correct Y cluster coordinate using a map
- //
+ /// Correct Y cluster coordinate using a map
if( !fWaveCorrectionMap ) return 0;
Bool_t swapY = kFALSE;
Pad = Pad-(Int_t)Pad;
if( TMath::Abs(Pad-0.5)<1.e-8 ){// one pad clusters a stored in underflow bins
- Pad = -1.;
+ Pad = -1.;
} else {
if( fWaveCorrectionMirroredPad && (Pad<0.5) ){ // cog axis is mirrored at 0.5
swapY = !swapY;
swapY = !swapY;
Z = -Z;
}
-
+
if( fWaveCorrectionMirroredAngle && (angleY<0) ){ // Angle axis is mirrored at 0
angleY = -angleY;
- }
+ }
double var[5] = { static_cast<double>(Type), Z, static_cast<double>(QMax), Pad, angleY };
Long64_t bin = fWaveCorrectionMap->GetBin(var, kFALSE );
if( bin<0 ) return 0;
/* $Id: AliTPCClusterParam.h,v */
-////////////////////////////////////////////////////
-// //
-// TPC cluster error and shape parameterization //
-// //
-////////////////////////////////////////////////////
+/// \class AliTPCClusterParam
+/// \brief TPC cluster error and shape parameterization
#include <TObject.h>
void FitData(TTree * tree);
void FitResol(TTree * tree);
void FitRMS(TTree * tree);
- void SetQnorm(Int_t ipad, Int_t itype, const TVectorD *const norm);
- void SetQnormCorr(Int_t ipad, Int_t itype, Int_t corrType, Float_t val, Int_t mode=1);
+ void SetQnorm(Int_t ipad, Int_t itype, const TVectorD *const norm);
+ void SetQnormCorr(Int_t ipad, Int_t itype, Int_t corrType, Float_t val, Int_t mode=1);
Double_t GetQnormCorr(Int_t ipad, Int_t itype, Int_t corrType) const;
TMatrixD *GetQnormCorrMatrix(){return fQNormCorr;};
- void ResetQnormCorr();
+ void ResetQnormCorr();
void SetWaveCorrectionMap( THnBase *WaveCorrectionMap);
void SetResolutionYMap( THnBase *ResolutionYMap);
//
// Charge parameterization
//
- Float_t Qnorm(Int_t ipad, Int_t itype, Float_t dr, Float_t ty, Float_t tz);
+ Float_t Qnorm(Int_t ipad, Int_t itype, Float_t dr, Float_t ty, Float_t tz);
Float_t QnormHis(Int_t ipad, Int_t itype, Float_t dr, Float_t ty, Float_t tz);
Float_t QnormPos(Int_t ipad, Bool_t isMax, Float_t pad, Float_t time, Float_t z, Float_t sy2, Float_t sz2, Float_t qm, Float_t qt);
static Float_t SQnormPos(Int_t ipad, Bool_t isMax, Float_t pad, Float_t time, Float_t z, Float_t sy2, Float_t sz2, Float_t qm, Float_t qt){ return fgInstance->QnormPos(ipad,isMax,pad,time,z,sy2,sz2,qm,qt);;}
-
+
Float_t PosCorrection(Int_t type, Int_t ipad, Float_t pad, Float_t time, Float_t z, Float_t sy2, Float_t sz2, Float_t qm);
static Float_t SPosCorrection(Int_t type, Int_t ipad, Float_t pad, Float_t time, Float_t z, Float_t sy2, Float_t sz2, Float_t qm){ return fgInstance->PosCorrection(type,ipad,pad,time,z,sy2,sz2,qm);}
//
Float_t GetRMSQ(Int_t dim, Int_t type, Float_t z, Float_t angle, Float_t Qmean) const;
Float_t GetRMSSigma(Int_t dim, Int_t type, Float_t z, Float_t angle, Float_t Qmean) const;
Float_t GetShapeFactor(Int_t dim, Int_t type, Float_t z, Float_t angle, Float_t Qmean, Float_t rmsL, Float_t rmsM) const;
- //
+ //
// Correction and resolution maps
//
const THnBase *GetWaveCorrectionMap() const { return fWaveCorrectionMap; }
//
void Test(TTree * tree, const char *output="TestClusterParam.root");
//
- // static methods equivalents - use instance of param object - useful for tree draw and TF2 visualization
+ // static methods equivalents - use instance of param object - useful for tree draw and TF2 visualization
static Float_t SGetError0(Int_t dim, Int_t type, Float_t z, Float_t angle){
return fgInstance->GetError0(dim,type,z,angle);
}
void FitResolQPar(TTree * tree, Int_t dim, Int_t type, Float_t *param0, Float_t *error);
void FitRMS0(TTree * tree, Int_t dim, Int_t type, Float_t *param0, Float_t *error);
void FitRMS1(TTree * tree, Int_t dim, Float_t *param0, Float_t *error);
- void FitRMSQ(TTree * tree, Int_t dim, Int_t type, Float_t *param0, Float_t *error);
- void FitRMSSigma(TTree * tree, Int_t dim, Int_t type, Float_t *param0, Float_t *error);
+ void FitRMSQ(TTree * tree, Int_t dim, Int_t type, Float_t *param0, Float_t *error);
+ void FitRMSSigma(TTree * tree, Int_t dim, Int_t type, Float_t *param0, Float_t *error);
//
TVectorD*& PosYcor(Int_t ind) {return fPosYcor[ind];}
TVectorD*& PosZcor(Int_t ind) {return fPosZcor[ind];}
TVectorD* QpadMnorm() const {return fQpadMnorm;}
protected:
- Float_t fRatio; //ratio of values constibution to error
- Float_t fParamS0[2][3][4]; //error parameterization coeficients
- Float_t fErrorS0[2][3][4]; //error parameterization coeficients
- Float_t fParamS0Par[2][3][7]; //error parameterization coeficients
- Float_t fErrorS0Par[2][3][7]; //error parameterization coeficients
- Float_t fParamSQ[2][3][6]; //error parameterization coeficients
- Float_t fErrorSQ[2][3][6]; //error parameterization coeficients
- Float_t fParamSQPar[2][3][9]; //error parameterization coeficients
- Float_t fErrorSQPar[2][3][9]; //error parameterization coeficients
- Float_t fParamS1[2][4]; //error parameterization coeficients
- Float_t fErrorS1[2][4]; //error parameterization coeficients
- //
- Float_t fParamRMS0[2][3][4]; //shape parameterization coeficients
- Float_t fErrorRMS0[2][3][4]; //shape parameterization coeficients
- Float_t fParamRMSQ[2][3][6]; //shape parameterization coeficients
- Float_t fErrorRMSQ[2][3][6]; //shape parameterization coeficients
- Float_t fParamRMS1[2][5]; //shape parameterization coeficients
- Float_t fErrorRMS1[2][5]; //shape parameterization coeficients
- Float_t fErrorRMSSys[2]; // systematic relative error of the parametererization
- Float_t fRMSSigmaRatio[2][2]; // mean value of the varation of RMS to RMS
- Float_t fRMSSigmaFit[2][3][2]; // mean value of the varation of RMS to RMS
+ Float_t fRatio; ///< ratio of values constibution to error
+ Float_t fParamS0[2][3][4]; ///< error parameterization coeficients
+ Float_t fErrorS0[2][3][4]; ///< error parameterization coeficients
+ Float_t fParamS0Par[2][3][7]; ///< error parameterization coeficients
+ Float_t fErrorS0Par[2][3][7]; ///< error parameterization coeficients
+ Float_t fParamSQ[2][3][6]; ///< error parameterization coeficients
+ Float_t fErrorSQ[2][3][6]; ///< error parameterization coeficients
+ Float_t fParamSQPar[2][3][9]; ///< error parameterization coeficients
+ Float_t fErrorSQPar[2][3][9]; ///< error parameterization coeficients
+ Float_t fParamS1[2][4]; ///< error parameterization coeficients
+ Float_t fErrorS1[2][4]; ///< error parameterization coeficients
+ //
+ Float_t fParamRMS0[2][3][4]; ///< shape parameterization coeficients
+ Float_t fErrorRMS0[2][3][4]; ///< shape parameterization coeficients
+ Float_t fParamRMSQ[2][3][6]; ///< shape parameterization coeficients
+ Float_t fErrorRMSQ[2][3][6]; ///< shape parameterization coeficients
+ Float_t fParamRMS1[2][5]; ///< shape parameterization coeficients
+ Float_t fErrorRMS1[2][5]; ///< shape parameterization coeficients
+ Float_t fErrorRMSSys[2]; ///< systematic relative error of the parametererization
+ Float_t fRMSSigmaRatio[2][2]; ///< mean value of the varation of RMS to RMS
+ Float_t fRMSSigmaFit[2][3][2]; ///< mean value of the varation of RMS to RMS
//
// charge normalization parametrization
//
- TObjArray *fQNorm; // q norm paramters
- TMatrixD *fQNormCorr; // q norm correction for analytica correction
- TObjArray *fQNormHis; // q norm correction for analytical correction
+ TObjArray *fQNorm; ///< q norm paramters
+ TMatrixD *fQNormCorr; ///< q norm correction for analytica correction
+ TObjArray *fQNormHis; ///< q norm correction for analytical correction
//
- TVectorD *fPosQTnorm[3]; // q position normalization
- TVectorD *fPosQMnorm[3]; // q position normalization
- TVectorD *fQpadTnorm; // q pad normalization - Total charge
- TVectorD *fQpadMnorm; // q pad normalization - Max charge
+ TVectorD *fPosQTnorm[3]; ///< q position normalization
+ TVectorD *fPosQMnorm[3]; ///< q position normalization
+ TVectorD *fQpadTnorm; ///< q pad normalization - Total charge
+ TVectorD *fQpadMnorm; ///< q pad normalization - Max charge
//
// Position corrections
- //
- TVectorD *fPosYcor[3]; // position correction parameterization
- TVectorD *fPosZcor[3]; // position correction parameterization
//
- // Wave Correction Map
+ TVectorD *fPosYcor[3]; ///< position correction parameterization
+ TVectorD *fPosZcor[3]; ///< position correction parameterization
+ //
+ // Wave Correction Map
//
- THnBase* fWaveCorrectionMap; //dY with respect to the distance to the center of the pad
- Bool_t fWaveCorrectionMirroredPad; // flag is the cog axis mirrored at 0.5
- Bool_t fWaveCorrectionMirroredZ; // flag is the Z axis mirrored at 0
- Bool_t fWaveCorrectionMirroredAngle; // flag is the Angle axis mirrored at 0
+ THnBase* fWaveCorrectionMap; ///< dY with respect to the distance to the center of the pad
+ Bool_t fWaveCorrectionMirroredPad; ///< flag is the cog axis mirrored at 0.5
+ Bool_t fWaveCorrectionMirroredZ; ///< flag is the Z axis mirrored at 0
+ Bool_t fWaveCorrectionMirroredAngle; ///< flag is the Angle axis mirrored at 0
//
// Resolution Map
//
- THnBase* fResolutionYMap; // Map of resolution in Y
+ THnBase* fResolutionYMap; ///< Map of resolution in Y
//
- static AliTPCClusterParam* fgInstance; //! Instance of this class (singleton implementation)
+ static AliTPCClusterParam* fgInstance; //!< Instance of this class (singleton implementation)
+ /// \cond CLASSIMP
ClassDef(AliTPCClusterParam,7) // TPC Cluster parameter class
+ /// \endcond
};
#endif
* about the suitability of this software for any purpose. It is *
* provided "as is" without express or implied warranty. *
**************************************************************************/
-
+
/* $Id$ */
-///////////////////////////////////////////////////////////////////////////////
-// //
-// Time Projection Chamber AliTPCClusterRow objects
-// - clusters for given segment of TPC //
-//
-// Origin: Marian Ivanov , GSI Darmstadt
-// //
-// //
-///////////////////////////////////////////////////////////////////////////////
+/// \class AliTPCClustersRow
+/// \brief Time Projection Chamber AliTPCClusterRow objects
+///
+/// - clusters for given segment of TPC
+///
+/// \author Marian Ivanov , GSI Darmstadt
+
#include <TClass.h>
#include "AliClusters.h"
#include "AliTPCclusterMI.h"
#include <TClonesArray.h>
-const Int_t kDefSize = 1; //defalut size
+const Int_t kDefSize = 1; ///< defalut size
-ClassImp(AliTPCClustersRow)
+/// \cond CLASSIMP
+ClassImp(AliTPCClustersRow)
+/// \endcond
//*****************************************************************************
//
//_____________________________________________________________________________
-AliTPCClustersRow::AliTPCClustersRow()
-{
+AliTPCClustersRow::AliTPCClustersRow()
+{
//
//default constructor
fNclusters=0;
//____________________________________________________________________________
AliTPCClustersRow::AliTPCClustersRow(const char *classname) : AliClusters(classname)
{
- // special constructor
+ /// special constructor
+
fNclusters=0;
}
//_____________________________________________________________________________
-TObject *AliTPCClustersRow::InsertCluster(const TObject *c)
-{
- //
- // Add a simulated cluster copy to the list
- //
+TObject *AliTPCClustersRow::InsertCluster(const TObject *c)
+{
+ /// Add a simulated cluster copy to the list
+
if (fClass==0) {
Error("AliClusters", "class type not specified");
return 0;
TObject *AliTPCClustersRow::Append(){
- //create new object return pointer to this object
+ /// create new object return pointer to this object
+
return fClusters->operator[](fClusters->GetEntriesFast());
}
/* $Id$ */
-////////////////////////////////////////////////
-// Manager class for TPC clusters //
-////////////////////////////////////////////////
+/// \class AliTPCClustersRow
+/// \brief Manager class for TPC clusters
#include "AliClusters.h"
virtual TObject *Append(); //create new object return pointer to this object
public:
-
- ClassDef(AliTPCClustersRow,1) // Cluster manager
-};
+
+ /// \cond CLASSIMP
+ ClassDef(AliTPCClustersRow,1) // Cluster manager
+ /// \endcond
+};
#endif //ALITPCCLUSTERROW_H
* provided "as is" without express or implied warranty. *
**************************************************************************/
-////////////////////////////////////////////////////////////////////////////////
-// //
-// AliTPCComposedCorrection class //
-// //
-// This class is creating a correction that is composed out of smaller //
-// corrections. //
-// There are two ways the sub-corrections can be combined into this one: //
-// 1. kParallel: All corrections are applied at the given position x and //
-// the dx terms are summed up (this commutes). //
-// 2. kQueue: The corrections are called in order. The first one at the //
-// given position x resulting in dx1, the second one is called at //
-// the corrected position (x+dx1) resulting in dx2, the third one //
-// is then called at position (x+dx1+dx2) and so forth. dx=dx1+dx2+... //
-// is returned. //
-// 3. kQueueResidual: like kQueue with the exception that in case of //
-// a positive weight the 'Distortion' is called and in case of a negative //
-// weight the 'Correction' is called, where the absolute of the weight //
-// will be applied to the correction
-// For the inverse of the correction this is taken into account by reversing //
-// the order the corrections are applied in the kQueue case (no issue for //
-// kParallel). //
-// //
-// date: 27/04/2010 //
-// Authors: Magnus Mager, Stefan Rossegger, Jim Thomas //
-// //
-// Example usage: //
-// //
-// AliMagF mag("mag","mag"); //
-// AliTPCExBBShape exb; // B field shape distortions //
-// exb.SetBField(&mag); //
-// //
-// AliTPCExBTwist twist; // ExB Twist distortions //
-// twist.SetXTwist(0.001); //
-// //
-// TObjArray cs; cs.Add(&exb); cs.Add(&twist); //
-// //
-// AliTPCComposedCorrection cc; //
-// cc.SetCorrections(&cs); //
-// cc.SetOmegaTauT1T2(wt,T1,T2); //
-// cc.Print("DA"); //
-// cc.CreateHistoDRPhiinZR(0,100,100)->Draw("surf2"); //
-////////////////////////////////////////////////////////////////////////////////
+/// \class AliTPCComposedCorrection
+/// \brief AliTPCComposedCorrection class
+///
+/// This class is creating a correction that is composed out of smaller
+/// corrections.
+/// There are two ways the sub-corrections can be combined into this one:
+/// 1. kParallel: All corrections are applied at the given position x and
+/// the dx terms are summed up (this commutes).
+/// 2. kQueue: The corrections are called in order. The first one at the
+/// given position x resulting in dx1, the second one is called at
+/// the corrected position (x+dx1) resulting in dx2, the third one
+/// is then called at position (x+dx1+dx2) and so forth. dx=dx1+dx2+...
+/// is returned.
+/// 3. kQueueResidual: like kQueue with the exception that in case of
+/// a positive weight the 'Distortion' is called and in case of a negative
+/// weight the 'Correction' is called, where the absolute of the weight
+/// will be applied to the correction
+/// For the inverse of the correction this is taken into account by reversing
+/// the order the corrections are applied in the kQueue case (no issue for
+/// kParallel).
+///
+/// Example usage:
+///
+/// ~~~{.cpp}
+/// AliMagF mag("mag","mag");
+/// AliTPCExBBShape exb; // B field shape distortions
+/// exb.SetBField(&mag);
+///
+/// AliTPCExBTwist twist; // ExB Twist distortions
+/// twist.SetXTwist(0.001);
+///
+/// TObjArray cs; cs.Add(&exb); cs.Add(&twist);
+///
+/// AliTPCComposedCorrection cc;
+/// cc.SetCorrections(&cs);
+/// cc.SetOmegaTauT1T2(wt,T1,T2);
+/// cc.Print("DA");
+/// cc.CreateHistoDRPhiinZR(0,100,100)->Draw("surf2");
+/// ~~~
+///
+/// \author Magnus Mager, Stefan Rossegger, Jim Thomas
+/// \date 27/04/2010
#include <TCollection.h>
#include "AliTPCComposedCorrection.h"
-AliTPCComposedCorrection::AliTPCComposedCorrection()
+AliTPCComposedCorrection::AliTPCComposedCorrection()
: AliTPCCorrection("composed_correction",
"composition of corrections"),
fCorrections(0),
fMode(kParallel),
fWeights(0) // weights of corrections
{
- //
- // default constructor
- //
+ /// default constructor
+
}
AliTPCComposedCorrection::AliTPCComposedCorrection(TCollection *corrections,
fMode(mode),
fWeights(0) //weights of correction
{
- //
- // Constructor that defines the set of corrections, this one is composed of.
- //
+ /// Constructor that defines the set of corrections, this one is composed of.
+
}
AliTPCComposedCorrection::~AliTPCComposedCorrection() {
- //
- // destructor
- //
+ /// destructor
+
if (!fCorrections) {
AliInfo("No Correction-models were set: can not delete them");
} else {
Bool_t AliTPCComposedCorrection::AddCorrectionCompact(AliTPCCorrection* corr, Double_t weight){
- //
- // Add correction - better name needed (left/right) - for the moment I assumme they commute
- // Why not to just use array of corrections - CPU consideration
- // Assumptions:
- // - origin of distortion/correction are additive
- // - corrections/distortion are small and they commute
- // - only correction ot the same type supported
+ /// Add correction - better name needed (left/right) - for the moment I assumme they commute
+ /// Why not to just use array of corrections - CPU consideration
+ /// Assumptions:
+ /// - origin of distortion/correction are additive
+ /// - corrections/distortion are small and they commute
+ /// - only correction ot the same type supported
+
const Int_t knCorr=100;
if (corr==NULL) {
AliError("Zerro pointer - correction");
if (GetSubCorrection(icorr)==NULL) continue;
if (GetSubCorrection(icorr)->IsA()==corr->IsA()) toAdd=GetSubCorrection(icorr);
}
- // 3.) create of givent type if does not exist
+ // 3.) create of givent type if does not exist
if (toAdd==NULL){
toAdd= (AliTPCCorrection*)((corr->IsA())->New());
fCorrections->Add(toAdd);
}
- // 4.) add to object of given type
+ // 4.) add to object of given type
return toAdd->AddCorrectionCompact(corr, weight);
}
AliTPCCorrection * AliTPCComposedCorrection::GetSubCorrection(Int_t ipos){
- //
- //
- //
+ ///
+
TObjArray *arr = (TObjArray*)fCorrections;
return (AliTPCCorrection *)arr->At(ipos);
}
AliTPCCorrection * AliTPCComposedCorrection::GetSubCorrection(const char *cname){
- //
- //
- //
+ ///
+
TCollection *arr = fCorrections;
return (AliTPCCorrection *)arr->FindObject(cname);
}
void AliTPCComposedCorrection::GetCorrection(const Float_t x[],const Short_t roc,Float_t dx[]) {
- //
- // This applies all correction and the specified manner (see general
- // class description for details).
- //
+ /// This applies all correction and the specified manner (see general
+ /// class description for details).
if (!fCorrections) {
AliInfo("No Corrections-models were set: can not calculate distortions");
}
void AliTPCComposedCorrection::GetDistortion(const Float_t x[],const Short_t roc,Float_t dx[]) {
- //
- // This applies all distortions and the specified manner (see general
- // class descxiption for details).
- //
+ /// This applies all distortions and the specified manner (see general
+ /// class descxiption for details).
if (!fCorrections) {
AliInfo("No Corrections-models were set: can not calculate distortions");
return;
}
-
+
if (fMode==kQueueResidual && !fWeights) {
AliInfo("kQueueResidual mode was selected but no weights were given. Switching to kQueue instead.");
fMode=kQueue;
}
-
+
TIterator *i=fCorrections->MakeReverseIterator();
AliTPCCorrection *c;
Int_t weightIndex=0;
void AliTPCComposedCorrection::Print(Option_t* option) const {
- //
- // Print function to check which correction classes are used
- // option=="d" prints details regarding the setted magnitude
- // option=="a" prints the C0 and C1 coefficents for calibration purposes
- //
+ /// Print function to check which correction classes are used
+ /// option=="d" prints details regarding the setted magnitude
+ /// option=="a" prints the C0 and C1 coefficents for calibration purposes
printf("Composed TPC spacepoint correction \"%s\" -- composed of:\n",GetTitle());
TString opt = option; opt.ToLower();
void AliTPCComposedCorrection::Init() {
- //
- // Initialization funtion (not used at the moment)
- //
+ /// Initialization funtion (not used at the moment)
+
if (!fCorrections) {
AliInfo("No Correction-models were set");
return;
}
TIterator *i=fCorrections->MakeIterator();
AliTPCCorrection *c;
- while (0!=(c=dynamic_cast<AliTPCCorrection*>(i->Next())))
+ while (0!=(c=dynamic_cast<AliTPCCorrection*>(i->Next())))
c->Init();
delete i;
-
+
}
void AliTPCComposedCorrection::Update(const TTimeStamp &timeStamp) {
- //
- // Update function
- //
+ /// Update function
+
if (!fCorrections) {
AliInfo("No Correction-models were set");
return;
TIterator *i=fCorrections->MakeIterator();
AliTPCCorrection *c;
- while (0!=(c=dynamic_cast<AliTPCCorrection*>(i->Next())))
+ while (0!=(c=dynamic_cast<AliTPCCorrection*>(i->Next())))
c->Update(timeStamp);
delete i;
-
+
}
void AliTPCComposedCorrection::SetOmegaTauT1T2(Float_t omegaTau,Float_t t1,Float_t t2) {
- //
- // Gives the possibility to set the OmegaTau plus Tensor corrections T1 and T2 (effective omega Tau)
- // to each subcorrection (since they might become event specific due to changing drift velocity)
- //
- // The omegaTau comes idealy from the Database, since it is a function of drift velocity, B and E field
- // e.g. omegaTau = -10.0 * Bz * vdrift / Ez ; // with Bz in kG and Ez in V/cm
- // omegaTau = -0.325 for Bz=5kG, Ez=400V/cm and vdrift = 2.6cm/muSec
- // The T1 and T2 tensors were measured in a dedicated calibration run
- //
- // Note: overwrites previously set values!
- //
+ /// Gives the possibility to set the OmegaTau plus Tensor corrections T1 and T2 (effective omega Tau)
+ /// to each subcorrection (since they might become event specific due to changing drift velocity)
+ ///
+ /// The omegaTau comes idealy from the Database, since it is a function of drift velocity, B and E field
+ /// e.g. omegaTau = -10.0 * Bz * vdrift / Ez ; // with Bz in kG and Ez in V/cm
+ /// omegaTau = -0.325 for Bz=5kG, Ez=400V/cm and vdrift = 2.6cm/muSec
+ /// The T1 and T2 tensors were measured in a dedicated calibration run
+ ///
+ /// Note: overwrites previously set values!
if (!fCorrections) {
AliInfo("No Correction-models were set");
delete i;
}
+/// \cond CLASSIMP
ClassImp(AliTPCComposedCorrection)
+/// \endcond
/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
* See cxx source for full Copyright notice */
-////////////////////////////////////////////////////////////////////////////////
-// //
-// AliTPCComposedCorrection class //
-// //
-// This class is creating a correction that is composed out of smaller //
-// corrections. //
-// There are two ways the sub-corrections can be combined into this one: //
-// 1. kParallel: All corrections are applied at the given position x and //
-// the dx terms are summed up (this commutes). //
-// 2. kQueue: The corrections are called in order. The first one at the //
-// given position x resulting in dx1, the second one is called at //
-// the corrected position (x+dx1) resulting in dx2, the third one //
-// is then called at position (x+dx1+dx2) and so forth. dx=dx1+dx2+... //
-// is returned. //
-// For the inverse of the correction this is taken into account by reversing //
-// the order the corrections are applied in the kQueue case (no issue for //
-// kParallel). //
-// //
-// date: 27/04/2010 //
-// Authors: Magnus Mager, Stefan Rossegger, Jim Thomas //
-////////////////////////////////////////////////////////////////////////////////
+/// \class AliTPCComposedCorrection
+/// \brief AliTPCComposedCorrection class
+///
+/// This class is creating a correction that is composed out of smaller
+/// corrections.
+/// There are two ways the sub-corrections can be combined into this one:
+/// 1. kParallel: All corrections are applied at the given position x and
+/// the dx terms are summed up (this commutes).
+/// 2. kQueue: The corrections are called in order. The first one at the
+/// given position x resulting in dx1, the second one is called at
+/// the corrected position (x+dx1) resulting in dx2, the third one
+/// is then called at position (x+dx1+dx2) and so forth. dx=dx1+dx2+...
+/// is returned.
+/// For the inverse of the correction this is taken into account by reversing
+/// the order the corrections are applied in the kQueue case (no issue for
+/// kParallel).
+///
+/// \author Magnus Mager, Stefan Rossegger, Jim Thomas
+/// \date 27/04/2010
#include "AliTPCCorrection.h"
#include "TVectorD.h"
void SetCorrections(const TCollection *corrections) {fCorrections=(TCollection*)corrections;}
CompositionType GetMode() const {return fMode;}
void SetMode(CompositionType mode) {fMode=mode;}
-
+
virtual void GetCorrection(const Float_t x[],const Short_t roc,Float_t dx[]);
virtual void GetDistortion(const Float_t x[],const Short_t roc,Float_t dx[]);
virtual AliTPCCorrection * GetSubCorrection(Int_t ipos);
const TVectorD * GetWeights() const {return fWeights;}
private:
- TCollection *fCorrections; // The corrections this one is composed of.
- CompositionType fMode; // The way to apply the corrections (see general class documentation)
- TVectorD *fWeights; // optional vector with weights - used for fit benchmarking
+ TCollection *fCorrections; ///< The corrections this one is composed of.
+ CompositionType fMode; ///< The way to apply the corrections (see general class documentation)
+ TVectorD *fWeights; ///< optional vector with weights - used for fit benchmarking
AliTPCComposedCorrection & operator = (const AliTPCComposedCorrection &); // dummy assignment operator
AliTPCComposedCorrection(const AliTPCComposedCorrection&); //dummy copy contructor
+ /// \cond CLASSIMP
ClassDef(AliTPCComposedCorrection,2);
+ /// \endcond
};
* provided "as is" without express or implied warranty. *
**************************************************************************/
-///////////////////////////////////////////////////////////////////////////////
-// //
-// Class for Parsing simple text configuration files //
-// It produces a TMap for the Key=>Value pairs found in the //
-// Configutation file. //
-// //
-// The configuration file has a simple structure: //
-// * Lines starting with a # or empty lines are ignored //
-// * Key and Value are separated either by a <tab> or <space>es //
-// //
-// Currently the class is used in the TPC DAs to allow an adjustment of //
-// the most relevant parameters without recompiling the DAs //
-///////////////////////////////////////////////////////////////////////////////
+/// \class AliTPCConfigDA
+/// \brief Class for Parsing simple text configuration files
+///
+/// It produces a TMap for the Key=>Value pairs found in the
+/// Configutation file.
+///
+/// The configuration file has a simple structure:
+/// * Lines starting with a # or empty lines are ignored
+/// * Key and Value are separated either by a <tab> or <space>es
+///
+/// Currently the class is used in the TPC DAs to allow an adjustment of
+/// the most relevant parameters without recompiling the DAs
#include <fstream>
TObject(),
fConfigMap(new TMap)
{
- //
- // default constructor
- //
+ /// default constructor
+
fConfigMap->SetOwnerKeyValue();
-}
+}
//_____________________________________________________________________
AliTPCConfigDA::AliTPCConfigDA(const AliTPCConfigDA &cfg) :
TObject(),
fConfigMap((TMap*)cfg.fConfigMap->Clone())
{
- //
- // copy constructor
- //
+ /// copy constructor
+
fConfigMap->SetOwnerKeyValue();
}
TObject(),
fConfigMap(new TMap)
{
- //
- // default constructor using the config file name as input parameter
- //
+ /// default constructor using the config file name as input parameter
+
fConfigMap->SetOwnerKeyValue();
if ( !cfgfile ) return;
ParseConfigFileTxt(cfgfile);
//_____________________________________________________________________
AliTPCConfigDA& AliTPCConfigDA::operator = (const AliTPCConfigDA &source)
{
- //
- // assignment operator
- //
+ /// assignment operator
+
if (&source == this) return *this;
new (this) AliTPCConfigDA(source);
//_____________________________________________________________________
AliTPCConfigDA::~AliTPCConfigDA()
{
- //
- // dtor
- //
+ /// dtor
+
delete fConfigMap;
}
//_____________________________________________________________________
Int_t AliTPCConfigDA::ParseConfigFileTxt(const char* cfgfile)
{
- //
- // Function to parse a configuration file
- //
+ /// Function to parse a configuration file
ifstream file(cfgfile);
if ( !file.is_open() ){
Error("ParseConfigFileTxt","File %s could not be opened!", cfgfile);
return 1;
- }
+ }
TString strFile;
strFile.ReadFile(file);
TObjArray *arr=strFile.Tokenize("\n");
if ( !arr ) {
- file.close();
+ file.close();
return 2;
}
TIter nextLine(arr);
while (TObject *l=nextLine()){
TString line(((TObjString*)l)->GetString());
- //remove whitespcaces
+ //remove whitespcaces
line.Remove(TString::kBoth,' ');
line.Remove(TString::kBoth,'\t');
if ( line.BeginsWith("#") || line=="" ) continue;
continue;
}
fConfigMap->Add(arrValues->At(0)->Clone(),arrValues->At(1)->Clone());
- delete arrValues;
- }
+ delete arrValues;
+ }
delete arr;
return 0;
//_____________________________________________________________________
Float_t AliTPCConfigDA::GetValue(const char *key) const
{
- //
- //Get value for the speciefied key
- //
+ /// Get value for the speciefied key
+
TObject *val=fConfigMap->GetValue(key);
if ( !val ) return -999.;
TString sval(((TObjString*)val)->GetString());
- return sval.Atof();
+ return sval.Atof();
}
//_____________________________________________________________________
void AliTPCConfigDA::ResetMap()
{
- //
- // Reset the map with the configuration values
- //
+ /// Reset the map with the configuration values
+
fConfigMap->DeleteAll();
}
/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
* See cxx source for full Copyright notice */
#include <TObject.h>
-////////////////////////////////////////////////////////////////////////////
-//
-// Simple configuration file parser
-//
-////////////////////////////////////////////////////////////////////////////
+/// \class AliTPCConfigDA
+/// \brief Simple configuration file parser
class TMap;
class AliTPCConfigDA : public TObject{
-
+
public:
AliTPCConfigDA();
AliTPCConfigDA(const char* cfgfile);
AliTPCConfigDA(const AliTPCConfigDA &cfg);
AliTPCConfigDA& operator = (const AliTPCConfigDA &cfg);
-
+
virtual ~AliTPCConfigDA();
-
+
Int_t ParseConfigFileTxt(const char* cfgfile);
- Float_t GetValue(const char* name) const;
+ Float_t GetValue(const char* name) const;
const TMap* GetConfigurationMap() const {return fConfigMap;}
void ResetMap();
private:
- TMap *fConfigMap; // Configuration map
-
+ TMap *fConfigMap; ///< Configuration map
+
+ /// \cond CLASSIMP
ClassDef(AliTPCConfigDA, 1) // TPC DA configuration file parser
+ /// \endcond
};
#endif
* provided "as is" without express or implied warranty. *
**************************************************************************/
-///////////////////////////////////////////////////////////////////////////////
-// //
-// Class for Parsing simple text configuration files //
-// It produces a TList for the TObjArrays with the name of the Key
-// the TObjArray contain the Values, split from kommas, as found in the //
-// Configutation file. //
-// //
-// The configuration file has a simple structure: //
-// * Lines starting with a # or empty lines are ignored //
-// * Key and Value are separated either by a <tab> or <space>es //
-// //
-// Currently the class is used in the TPC DAs to allow an adjustment of //
-// the most relevant parameters without recompiling the DAs //
-///////////////////////////////////////////////////////////////////////////////
+/// \class AliTPCConfigParser
+/// \brief Class for Parsing simple text configuration files
+///
+/// It produces a TList for the TObjArrays with the name of the Key
+/// the TObjArray contain the Values, split from kommas, as found in the
+/// Configutation file.
+///
+/// The configuration file has a simple structure:
+/// * Lines starting with a # or empty lines are ignored
+/// * Key and Value are separated either by a <tab> or <space>es
+///
+/// Currently the class is used in the TPC DAs to allow an adjustment of
+/// the most relevant parameters without recompiling the DAs
#include <fstream>
fKeyIter(0),
fValIter(0)
{
- //
- // default constructor
- //
+ /// default constructor
+
fConfigMap->SetOwner();
-}
+}
//_____________________________________________________________________
AliTPCConfigParser::AliTPCConfigParser(const AliTPCConfigParser &cfg) :
TObject(),
fKeyIter(0),
fValIter(0)
{
- //
- // copy constructor
- //
+ /// copy constructor
+
fConfigMap->SetOwner();
}
fKeyIter(0),
fValIter(0)
{
- //
- // default constructor using the config file name as input parameter
- //
+ /// default constructor using the config file name as input parameter
+
fConfigMap->SetOwner();
if ( !cfgfile ) return;
ParseConfigFileTxt(cfgfile);
//_____________________________________________________________________
AliTPCConfigParser& AliTPCConfigParser::operator = (const AliTPCConfigParser &source)
{
- //
- // assignment operator
- //
+ /// assignment operator
+
if (&source == this) return *this;
new (this) AliTPCConfigParser(source);
-
+
return *this;
}
//_____________________________________________________________________
AliTPCConfigParser::~AliTPCConfigParser()
{
- //
- // dtor
- //
+ /// dtor
+
delete fConfigMap;
delete fKeyIter;
delete fValIter;
//_____________________________________________________________________
Int_t AliTPCConfigParser::ParseConfigFileTxt(const char* cfgfile)
{
- //
- // Function to parse a configuration file
- //
+ /// Function to parse a configuration file
+
ResetMap();
ifstream file(gSystem->ExpandPathName(cfgfile));
if ( !file.is_open() ){
fConfigMap->AddLast(objArr);
delete arrValues;
}
-
+
delete arr;
return 0;
}
//_____________________________________________________________________
Float_t AliTPCConfigParser::GetValue(const char *key, UInt_t position)
{
- //
- //Get value for the speciefied key
- //
+ /// Get value for the speciefied key
+
TObject *val=((TObjArray*)fConfigMap->FindObject(key))->At(position);
if ( !val ) return -999.;
TString sval(((TObjString*)val)->GetString());
//_____________________________________________________________________
const char* AliTPCConfigParser::GetData(const char *key, UInt_t position)
{
- //
- //Get value for the speciefied key
- //
+ /// Get value for the speciefied key
+
TObjArray *arr=((TObjArray*)fConfigMap->FindObject(key));
if (position>=(UInt_t)(arr->GetEntries())) return "";
TObject *val=arr->At(position);
//_____________________________________________________________________
Float_t AliTPCConfigParser::GetValue(const TObject *key, UInt_t position)
{
- //
- //Get value for the speciefied key
- //
+ /// Get value for the speciefied key
+
TObject *val=((TObjArray*)fConfigMap->FindObject(key))->At(position);
if ( !val ) return -999.;
TString sval(((TObjString*)val)->GetString());
//_____________________________________________________________________
const char* AliTPCConfigParser::GetData(const TObject *key, UInt_t position)
{
- //
- //Get value for the speciefied key
- //
+ /// Get value for the speciefied key
+
TObjArray *arr=((TObjArray*)fConfigMap->FindObject(key));
if (position>=((UInt_t)arr->GetEntries())) return "";
TObject *val=arr->At(position);
//_____________________________________________________________________
Int_t AliTPCConfigParser::GetNumberOfValues(const char* key) const
{
- //
- // return the number of values for key
- //
+ /// return the number of values for key
+
return ((TObjArray*)fConfigMap->FindObject(key))->GetEntries();
}
//_____________________________________________________________________
Int_t AliTPCConfigParser::GetNumberOfValues(TObject* key) const
{
- //
- // return the number of values for key
- //
+ /// return the number of values for key
+
return ((TObjArray*)fConfigMap->FindObject(key))->GetEntries();
}
//_____________________________________________________________________
//_____________________________________________________________________
void AliTPCConfigParser::ResetMap()
{
- //
- // Reset the map with the configuration values
- //
+ /// Reset the map with the configuration values
+
fConfigMap->Delete();
}
+/// \class AliTPCConfigParser
+
#ifndef AliTPCConfigParser_H
#define AliTPCConfigParser_H
/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
class TList;
class AliTPCConfigParser : public TObject{
-
+
public:
AliTPCConfigParser();
AliTPCConfigParser(const char* cfgfile);
AliTPCConfigParser(const AliTPCConfigParser &cfg);
AliTPCConfigParser& operator = (const AliTPCConfigParser &cfg);
-
+
virtual ~AliTPCConfigParser();
-
+
Int_t ParseConfigFileTxt(const char* cfgfile);
Float_t GetValue(const char* key, UInt_t position=0);
Float_t GetValue(const TObject *key, UInt_t position=0);
const char* GetData(const char* key, UInt_t position=0);
const char* GetData(const TObject* key, UInt_t position=0);
-
+
Int_t GetNumberOfValues(const char* key) const;
Int_t GetNumberOfValues(TObject* key) const;
-
+
const TList* GetConfigurationMap() const {return fConfigMap;}
void ResetMap();
const TObject* operator()(TObject* key) const {return fConfigMap->FindObject(key);}
void ResetIter() {delete fKeyIter; fKeyIter=0; delete fValIter; fValIter=0;}
-
+
TObject* NextKey();
TObject* NextValue(const char *key);
TObject* NextValue(TObject *key);
TIterator *fValIter;
TObject *NextValueIter(TObjArray *obj);
-
+
+ /// \cond CLASSIMP
ClassDef(AliTPCConfigParser, 1) // TPC DA configuration file parser
+ /// \endcond
};
#endif
* provided "as is" without express or implied warranty. *
**************************************************************************/
-// _________________________________________________________________
-//
-// Begin_Html
-// <h2> AliTPCCorrection class </h2>
-//
-// The AliTPCCorrection class provides a general framework to deal with space point distortions.
-// An correction class which inherits from here is for example AliTPCExBBShape or AliTPCExBTwist. <br>
-// General virtual functions are (for example) CorrectPoint(x,roc) where x is the vector of initial
-// positions in cartesian coordinates and roc represents the read-out chamber number according to
-// the offline numbering convention. The vector x is overwritten with the corrected coordinates. <br>
-// An alternative usage would be CorrectPoint(x,roc,dx), which leaves the vector x untouched, but
-// returns the distortions via the vector dx. <br>
-// This class is normally used via the general class AliTPCComposedCorrection.
-// <p>
-// Furthermore, the class contains basic geometrical descriptions like field cage radii
-// (fgkIFCRadius, fgkOFCRadius) and length (fgkTPCZ0) plus the voltages. Also, the definitions
-// of size and widths of the fulcrums building the grid of the final look-up table, which is
-// then interpolated, is defined in kNX and fgkXList).
-// <p>
-// All physics-model classes below are derived from this class in order to not duplicate code
-// and to allow a uniform treatment of all physics models.
-// <p>
-// <h3> Poisson solver </h3>
-// A numerical solver of the Poisson equation (relaxation technique) is implemented for 2-dimensional
-// geometries (r,z) as well as for 3-dimensional problems (r,$\phi$,z). The corresponding function
-// names are PoissonRelaxation?D. The relevant function arguments are the arrays of the boundary and
-// initial conditions (ArrayofArrayV, ArrayofChargeDensities) as well as the grid granularity which
-// is used during the calculation. These inputs can be chosen according to the needs of the physical
-// effect which is supposed to be simulated. In the 3D version, different symmetry conditions can be set
-// in order to reduce the calculation time (used in AliTPCFCVoltError3D).
-// <p>
-// <h3> Unified plotting functionality </h3>
-// Generic plot functions were implemented. They return a histogram pointer in the chosen plane of
-// the TPC drift volume with a selectable grid granularity and the magnitude of the correction vector.
-// For example, the function CreateHistoDZinXY(z,nx,ny) returns a 2-dimensional histogram which contains
-// the longitudinal corrections $dz$ in the (x,y)-plane at the given z position with the granularity of
-// nx and ny. The magnitude of the corrections is defined by the class from which this function is called.
-// In the same manner, standard plots for the (r,$\phi$)-plane and for the other corrections like $dr$ and $rd\phi$ are available
-// <p>
-// Note: This class is normally used via the class AliTPCComposedCorrection
-// End_Html
-//
-// Begin_Macro(source)
-// {
-// gROOT->SetStyle("Plain"); gStyle->SetPalette(1);
-// TCanvas *c2 = new TCanvas("cAliTPCCorrection","cAliTPCCorrection",700,1050); c2->Divide(2,3);
-// AliTPCROCVoltError3D roc; // EXAMPLE PLOTS - SEE BELOW
-// roc.SetROCDataFileName("$ALICE_ROOT/TPC/Calib/maps/TPCROCdzSurvey.root");
-// roc.SetOmegaTauT1T2(0,1,1); // B=0
-// Float_t z0 = 1; // at +1 cm -> A side
-// c2->cd(1); roc.CreateHistoDRinXY(1.,300,300)->Draw("cont4z");
-// c2->cd(3);roc.CreateHistoDRPhiinXY(1.,300,300)->Draw("cont4z");
-// c2->cd(5);roc.CreateHistoDZinXY(1.,300,300)->Draw("cont4z");
-// Float_t phi0=0.5;
-// c2->cd(2);roc.CreateHistoDRinZR(phi0)->Draw("surf2");
-// c2->cd(4);roc.CreateHistoDRPhiinZR(phi0)->Draw("surf2");
-// c2->cd(6);roc.CreateHistoDZinZR(phi0)->Draw("surf2");
-// return c2;
-// }
-// End_Macro
-//
-// Begin_Html
-// <p>
-// Date: 27/04/2010 <br>
-// Authors: Magnus Mager, Stefan Rossegger, Jim Thomas
-// End_Html
-// _________________________________________________________________
+/// \class AliTPCCorrection
+/// \brief <h2> AliTPCCorrection class </h2>
+///
+/// The AliTPCCorrection class provides a general framework to deal with space point distortions.
+/// An correction class which inherits from here is for example AliTPCExBBShape or AliTPCExBTwist.
+/// General virtual functions are (for example) CorrectPoint(x,roc) where x is the vector of initial
+/// positions in cartesian coordinates and roc represents the read-out chamber number according to
+/// the offline numbering convention. The vector x is overwritten with the corrected coordinates.
+/// An alternative usage would be CorrectPoint(x,roc,dx), which leaves the vector x untouched, but
+/// returns the distortions via the vector dx.
+/// This class is normally used via the general class AliTPCComposedCorrection.
+///
+/// Furthermore, the class contains basic geometrical descriptions like field cage radii
+/// (fgkIFCRadius, fgkOFCRadius) and length (fgkTPCZ0) plus the voltages. Also, the definitions
+/// of size and widths of the fulcrums building the grid of the final look-up table, which is
+/// then interpolated, is defined in kNX and fgkXList).
+///
+/// All physics-model classes below are derived from this class in order to not duplicate code
+/// and to allow a uniform treatment of all physics models.
+///
+/// <h3> Poisson solver </h3>
+/// A numerical solver of the Poisson equation (relaxation technique) is implemented for 2-dimensional
+/// geometries (r,z) as well as for 3-dimensional problems (r,$\phi$,z). The corresponding function
+/// names are PoissonRelaxation?D. The relevant function arguments are the arrays of the boundary and
+/// initial conditions (ArrayofArrayV, ArrayofChargeDensities) as well as the grid granularity which
+/// is used during the calculation. These inputs can be chosen according to the needs of the physical
+/// effect which is supposed to be simulated. In the 3D version, different symmetry conditions can be set
+/// in order to reduce the calculation time (used in AliTPCFCVoltError3D).
+///
+/// <h3> Unified plotting functionality </h3>
+/// Generic plot functions were implemented. They return a histogram pointer in the chosen plane of
+/// the TPC drift volume with a selectable grid granularity and the magnitude of the correction vector.
+/// For example, the function CreateHistoDZinXY(z,nx,ny) returns a 2-dimensional histogram which contains
+/// the longitudinal corrections $dz$ in the (x,y)-plane at the given z position with the granularity of
+/// nx and ny. The magnitude of the corrections is defined by the class from which this function is called.
+/// In the same manner, standard plots for the (r,$\phi$)-plane and for the other corrections like $dr$ and $rd\phi$ are available
+///
+/// Note: This class is normally used via the class AliTPCComposedCorrection
+/// 
+///
+/// \author Magnus Mager, Stefan Rossegger, Jim Thomas
+/// \date 27/04/2010
#include "Riostream.h"
#include "TLinearFitter.h"
#include <AliSysInfo.h>
+/// \cond CLASSIMP
ClassImp(AliTPCCorrection)
+/// \endcond
+
-
TObjArray *AliTPCCorrection::fgVisualCorrection=0;
// instance of correction for visualization
// FIXME: the following values should come from the database
-const Double_t AliTPCCorrection::fgkTPCZ0 = 249.7; // nominal gating grid position
-const Double_t AliTPCCorrection::fgkIFCRadius= 83.5; // radius which renders the "18 rod manifold" best -> compare calc. of Jim Thomas
+const Double_t AliTPCCorrection::fgkTPCZ0 = 249.7; ///< nominal gating grid position
+const Double_t AliTPCCorrection::fgkIFCRadius= 83.5; ///< radius which renders the "18 rod manifold" best -> compare calc. of Jim Thomas
// compare gkIFCRadius= 83.05: Mean Radius of the Inner Field Cage ( 82.43 min, 83.70 max) (cm)
-const Double_t AliTPCCorrection::fgkOFCRadius= 254.5; // Mean Radius of the Outer Field Cage (252.55 min, 256.45 max) (cm)
-const Double_t AliTPCCorrection::fgkZOffSet = 0.2; // Offset from CE: calculate all distortions closer to CE as if at this point
-const Double_t AliTPCCorrection::fgkCathodeV = -100000.0; // Cathode Voltage (volts)
-const Double_t AliTPCCorrection::fgkGG = -70.0; // Gating Grid voltage (volts)
+const Double_t AliTPCCorrection::fgkOFCRadius= 254.5; ///< Mean Radius of the Outer Field Cage (252.55 min, 256.45 max) (cm)
+const Double_t AliTPCCorrection::fgkZOffSet = 0.2; ///< Offset from CE: calculate all distortions closer to CE as if at this point
+const Double_t AliTPCCorrection::fgkCathodeV = -100000.0; ///< Cathode Voltage (volts)
+const Double_t AliTPCCorrection::fgkGG = -70.0; ///< Gating Grid voltage (volts)
+
+const Double_t AliTPCCorrection::fgkdvdE = 0.0024; ///< [cm/V] drift velocity dependency on the E field (from Magboltz for NeCO2N2 at standard environment)
-const Double_t AliTPCCorrection::fgkdvdE = 0.0024; // [cm/V] drift velocity dependency on the E field (from Magboltz for NeCO2N2 at standard environment)
+const Double_t AliTPCCorrection::fgkEM = -1.602176487e-19/9.10938215e-31; ///< charge/mass in [C/kg]
+const Double_t AliTPCCorrection::fgke0 = 8.854187817e-12; ///< vacuum permittivity [A·s/(V·m)]
-const Double_t AliTPCCorrection::fgkEM = -1.602176487e-19/9.10938215e-31; // charge/mass in [C/kg]
-const Double_t AliTPCCorrection::fgke0 = 8.854187817e-12; // vacuum permittivity [A·s/(V·m)]
-
-AliTPCCorrection::AliTPCCorrection()
+AliTPCCorrection::AliTPCCorrection()
: TNamed("correction_unity","unity"),fILow(0),fJLow(0),fKLow(0), fT1(1), fT2(1), fIsLocal(kFALSE)
{
- //
- // default constructor
- //
+ /// default constructor
+
if (!fgVisualCorrection) fgVisualCorrection= new TObjArray;
InitLookUpfulcrums();
AliTPCCorrection::AliTPCCorrection(const char *name,const char *title)
: TNamed(name,title),fILow(0),fJLow(0),fKLow(0), fT1(1), fT2(1), fIsLocal(kFALSE)
{
- //
- // default constructor, that set the name and title
- //
+ /// default constructor, that set the name and title
+
if (!fgVisualCorrection) fgVisualCorrection= new TObjArray;
InitLookUpfulcrums();
}
AliTPCCorrection::~AliTPCCorrection() {
- //
- // virtual destructor
- //
+ /// virtual destructor
+
}
Bool_t AliTPCCorrection::AddCorrectionCompact(AliTPCCorrection* corr, Double_t weight){
- //
- // Add correction and make them compact
- // Assumptions:
- // - origin of distortion/correction are additive
- // - only correction ot the same type supported ()
+ /// Add correction and make them compact
+ /// Assumptions:
+ /// - origin of distortion/correction are additive
+ /// - only correction ot the same type supported ()
+
if (corr==NULL) {
AliError("Zerro pointer - correction");
return kFALSE;
- }
+ }
AliError(TString::Format("Correction %s not implementend",IsA()->GetName()).Data());
return kFALSE;
}
void AliTPCCorrection::CorrectPoint(Float_t x[], Short_t roc) {
- //
- // Corrects the initial coordinates x (cartesian coordinates)
- // according to the given effect (inherited classes)
- // roc represents the TPC read out chamber (offline numbering convention)
- //
+ /// Corrects the initial coordinates x (cartesian coordinates)
+ /// according to the given effect (inherited classes)
+ /// roc represents the TPC read out chamber (offline numbering convention)
+
Float_t dx[3];
GetCorrection(x,roc,dx);
for (Int_t j=0;j<3;++j) x[j]+=dx[j];
}
void AliTPCCorrection::CorrectPoint(const Float_t x[], Short_t roc,Float_t xp[]) {
- //
- // Corrects the initial coordinates x (cartesian coordinates) and stores the new
- // (distorted) coordinates in xp. The distortion is set according to the given effect (inherited classes)
- // roc represents the TPC read out chamber (offline numbering convention)
- //
+ /// Corrects the initial coordinates x (cartesian coordinates) and stores the new
+ /// (distorted) coordinates in xp. The distortion is set according to the given effect (inherited classes)
+ /// roc represents the TPC read out chamber (offline numbering convention)
+
Float_t dx[3];
GetCorrection(x,roc,dx);
for (Int_t j=0;j<3;++j) xp[j]=x[j]+dx[j];
}
void AliTPCCorrection::DistortPoint(Float_t x[], Short_t roc) {
- //
- // Distorts the initial coordinates x (cartesian coordinates)
- // according to the given effect (inherited classes)
- // roc represents the TPC read out chamber (offline numbering convention)
- //
+ /// Distorts the initial coordinates x (cartesian coordinates)
+ /// according to the given effect (inherited classes)
+ /// roc represents the TPC read out chamber (offline numbering convention)
+
Float_t dx[3];
GetDistortion(x,roc,dx);
for (Int_t j=0;j<3;++j) x[j]+=dx[j];
}
void AliTPCCorrection::DistortPointLocal(Float_t x[], Short_t roc) {
- //
- // Distorts the initial coordinates x (cartesian coordinates)
- // according to the given effect (inherited classes)
- // roc represents the TPC read out chamber (offline numbering convention)
- //
+ /// Distorts the initial coordinates x (cartesian coordinates)
+ /// according to the given effect (inherited classes)
+ /// roc represents the TPC read out chamber (offline numbering convention)
+
Float_t gxyz[3]={0,0,0};
Double_t alpha = TMath::TwoPi()*(roc%18+0.5)/18;
Double_t ca=TMath::Cos(alpha), sa= TMath::Sin(alpha);
x[2]= gxyz[2];
}
void AliTPCCorrection::CorrectPointLocal(Float_t x[], Short_t roc) {
- //
- // Distorts the initial coordinates x (cartesian coordinates)
- // according to the given effect (inherited classes)
- // roc represents the TPC read out chamber (offline numbering convention)
- //
+ /// Distorts the initial coordinates x (cartesian coordinates)
+ /// according to the given effect (inherited classes)
+ /// roc represents the TPC read out chamber (offline numbering convention)
+
Float_t gxyz[3]={0,0,0};
Double_t alpha = TMath::TwoPi()*(roc%18+0.5)/18;
Double_t ca=TMath::Cos(alpha), sa= TMath::Sin(alpha);
}
void AliTPCCorrection::DistortPoint(const Float_t x[], Short_t roc,Float_t xp[]) {
- //
- // Distorts the initial coordinates x (cartesian coordinates) and stores the new
- // (distorted) coordinates in xp. The distortion is set according to the given effect (inherited classes)
- // roc represents the TPC read out chamber (offline numbering convention)
- //
+ /// Distorts the initial coordinates x (cartesian coordinates) and stores the new
+ /// (distorted) coordinates in xp. The distortion is set according to the given effect (inherited classes)
+ /// roc represents the TPC read out chamber (offline numbering convention)
+
Float_t dx[3];
GetDistortion(x,roc,dx);
for (Int_t j=0;j<3;++j) xp[j]=x[j]+dx[j];
}
void AliTPCCorrection::GetCorrection(const Float_t /*x*/[], Short_t /*roc*/,Float_t dx[]) {
- //
- // This function delivers the correction values dx in respect to the inital coordinates x
- // roc represents the TPC read out chamber (offline numbering convention)
- // Note: The dx is overwritten by the inherited effectice class ...
- //
+ /// This function delivers the correction values dx in respect to the inital coordinates x
+ /// roc represents the TPC read out chamber (offline numbering convention)
+ /// Note: The dx is overwritten by the inherited effectice class ...
+
for (Int_t j=0;j<3;++j) { dx[j]=0.; }
}
void AliTPCCorrection::GetDistortion(const Float_t x[], Short_t roc,Float_t dx[]) {
- //
- // This function delivers the distortion values dx in respect to the inital coordinates x
- // roc represents the TPC read out chamber (offline numbering convention)
- //
+ /// This function delivers the distortion values dx in respect to the inital coordinates x
+ /// roc represents the TPC read out chamber (offline numbering convention)
+
GetCorrection(x,roc,dx);
for (Int_t j=0;j<3;++j) dx[j]=-dx[j];
}
void AliTPCCorrection::GetCorrectionDz(const Float_t x[], Short_t roc,Float_t dx[], Float_t delta) {
- // author: marian.ivanov@cern.ch
- //
- // In this (virtual)function calculates the dx'/dz, dy'/dz and dz'/dz at given point (x,y,z)
- // Generic implementation. Better precision can be acchieved knowing the internal structure
- // of underlying trasnformation. Derived classes can reimplement it.
- // To calculate correction is fitted in small neighberhood:
- // (x+-delta,y+-delta,z+-delta) where delta is an argument
- //
- // Input parameters:
- // x[] - space point corrdinate
- // roc - readout chamber identifier (important e.g to do not miss the side of detector)
- // delta - define the size of neighberhood
- // Output parameter:
- // dx[] - array {dx'/dz, dy'/dz , dz'/dz }
+ /// author: marian.ivanov@cern.ch
+ ///
+ /// In this (virtual)function calculates the dx'/dz, dy'/dz and dz'/dz at given point (x,y,z)
+ /// Generic implementation. Better precision can be acchieved knowing the internal structure
+ /// of underlying trasnformation. Derived classes can reimplement it.
+ /// To calculate correction is fitted in small neighberhood:
+ /// (x+-delta,y+-delta,z+-delta) where delta is an argument
+ ///
+ /// Input parameters:
+ /// x[] - space point corrdinate
+ /// roc - readout chamber identifier (important e.g to do not miss the side of detector)
+ /// delta - define the size of neighberhood
+ /// Output parameter:
+ /// dx[] - array {dx'/dz, dy'/dz , dz'/dz }
// if (fIsLocal){ //standard implemenation provides the correction/distortion integrated over full drift length
- //
//
- // GetCorrection(xyz,roc,dxyz);
+ //
+ // GetCorrection(xyz,roc,dxyz);
// }
- static TLinearFitter fitx(2,"pol1");
+ static TLinearFitter fitx(2,"pol1");
static TLinearFitter fity(2,"pol1");
static TLinearFitter fitz(2,"pol1");
fitx.ClearPoints();
}
void AliTPCCorrection::GetDistortionDz(const Float_t x[], Short_t roc,Float_t dx[], Float_t delta) {
- // author: marian.ivanov@cern.ch
- //
- // In this (virtual)function calculates the dx'/dz, dy'/dz and dz'/dz at given point (x,y,z)
- // Generic implementation. Better precision can be acchieved knowing the internal structure
- // of underlying trasnformation. Derived classes can reimplement it.
- // To calculate distortion is fitted in small neighberhood:
- // (x+-delta,y+-delta,z+-delta) where delta is an argument
- //
- // Input parameters:
- // x[] - space point corrdinate
- // roc - readout chamber identifier (important e.g to do not miss the side of detector)
- // delta - define the size of neighberhood
- // Output parameter:
- // dx[] - array {dx'/dz, dy'/dz , dz'/dz }
-
+ /// author: marian.ivanov@cern.ch
+ ///
+ /// In this (virtual)function calculates the dx'/dz, dy'/dz and dz'/dz at given point (x,y,z)
+ /// Generic implementation. Better precision can be acchieved knowing the internal structure
+ /// of underlying trasnformation. Derived classes can reimplement it.
+ /// To calculate distortion is fitted in small neighberhood:
+ /// (x+-delta,y+-delta,z+-delta) where delta is an argument
+ ///
+ /// Input parameters:
+ /// x[] - space point corrdinate
+ /// roc - readout chamber identifier (important e.g to do not miss the side of detector)
+ /// delta - define the size of neighberhood
+ /// Output parameter:
+ /// dx[] - array {dx'/dz, dy'/dz , dz'/dz }
+
static TLinearFitter fitx(2,"pol1");
static TLinearFitter fity(2,"pol1");
static TLinearFitter fitz(2,"pol1");
zmax=0;
}
}
-
+
//TODO: in principle one shuld check that x[2]+zdelta*delta does not get 'out of' bounds,
// so close to the CE it doesn't change the sign, since then the corrections will be wrong ...
for (Int_t xdelta=-1; xdelta<=1; xdelta++)
}
void AliTPCCorrection::GetCorrectionIntegralDz(const Float_t x[], Short_t roc,Float_t dx[], Float_t delta){
- //
- // Integrate 3D distortion along drift lines starting from the roc plane
- // to the expected z position of the point, this assumes that dz is small
- // and the error propagating to z' instead of the correct z is negligible
- // To define the drift lines virtual function AliTPCCorrection::GetCorrectionDz is used
- //
- // Input parameters:
- // x[] - space point corrdinate
- // roc - readout chamber identifier (important e.g to do not miss the side of detector)
- // delta - define the size of neighberhood
- // Output parameter:
- // dx[] - array { integral(dx'/dz), integral(dy'/dz) , integral(dz'/dz) }
+ /// Integrate 3D distortion along drift lines starting from the roc plane
+ /// to the expected z position of the point, this assumes that dz is small
+ /// and the error propagating to z' instead of the correct z is negligible
+ /// To define the drift lines virtual function AliTPCCorrection::GetCorrectionDz is used
+ ///
+ /// Input parameters:
+ /// x[] - space point corrdinate
+ /// roc - readout chamber identifier (important e.g to do not miss the side of detector)
+ /// delta - define the size of neighberhood
+ /// Output parameter:
+ /// dx[] - array { integral(dx'/dz), integral(dy'/dz) , integral(dz'/dz) }
Float_t zroc= ((roc%36)<18) ? fgkTPCZ0:-fgkTPCZ0;
Double_t zdrift = TMath::Abs(x[2]-zroc);
// since at larger drift (smaller z) the corrections are larger (absolute, but negative)
// the slopes will be positive.
// but since we chose deltaZ opposite sign the singn of the corretion should be fine
-
+
Float_t xyz2[3]={xyz[0],xyz[1],static_cast<Float_t>(xyz[2]+deltaZ/2.)};
GetCorrectionDz(xyz2,roc,dxyz,delta/2.);
xyz[0]+=deltaZ*dxyz[0];
}
void AliTPCCorrection::GetDistortionIntegralDz(const Float_t x[], Short_t roc,Float_t dx[], Float_t delta){
- //
- // Integrate 3D distortion along drift lines
- // To define the drift lines virtual function AliTPCCorrection::GetCorrectionDz is used
- //
- // Input parameters:
- // x[] - space point corrdinate
- // roc - readout chamber identifier (important e.g to do not miss the side of detector)
- // delta - define the size of neighberhood
- // Output parameter:
- // dx[] - array { integral(dx'/dz), integral(dy'/dz) , integral(dz'/dz) }
-
+ /// Integrate 3D distortion along drift lines
+ /// To define the drift lines virtual function AliTPCCorrection::GetCorrectionDz is used
+ ///
+ /// Input parameters:
+ /// x[] - space point corrdinate
+ /// roc - readout chamber identifier (important e.g to do not miss the side of detector)
+ /// delta - define the size of neighberhood
+ /// Output parameter:
+ /// dx[] - array { integral(dx'/dz), integral(dy'/dz) , integral(dz'/dz) }
+
Float_t zroc= ((roc%36)<18) ? fgkTPCZ0:-fgkTPCZ0;
Double_t zdrift = TMath::Abs(x[2]-zroc);
Int_t nsteps = Int_t(zdrift/delta)+1;
dx[0]=xyz[0]-x[0];
dx[1]=xyz[1]-x[1];
dx[2]= sumdz; //TODO: is sumdz correct?
-
+
}
void AliTPCCorrection::Init() {
- //
- // Initialization funtion (not used at the moment)
- //
+ /// Initialization funtion (not used at the moment)
+
}
void AliTPCCorrection::Update(const TTimeStamp &/*timeStamp*/) {
- //
- // Update function
- //
+ /// Update function
+
}
void AliTPCCorrection::Print(Option_t* /*option*/) const {
- //
- // Print function to check which correction classes are used
- // option=="d" prints details regarding the setted magnitude
- // option=="a" prints the C0 and C1 coefficents for calibration purposes
- //
+ /// Print function to check which correction classes are used
+ /// option=="d" prints details regarding the setted magnitude
+ /// option=="a" prints the C0 and C1 coefficents for calibration purposes
+
printf("TPC spacepoint correction: \"%s\"\n",GetTitle());
}
void AliTPCCorrection:: SetOmegaTauT1T2(Float_t /*omegaTau*/,Float_t t1,Float_t t2) {
- //
- // Virtual funtion to pass the wt values (might become event dependent) to the inherited classes
- // t1 and t2 represent the "effective omegaTau" corrections and were measured in a dedicated
- // calibration run
- //
+ /// Virtual funtion to pass the wt values (might become event dependent) to the inherited classes
+ /// t1 and t2 represent the "effective omegaTau" corrections and were measured in a dedicated
+ /// calibration run
+
fT1=t1;
fT2=t2;
//SetOmegaTauT1T2(omegaTau, t1, t2);
}
TH2F* AliTPCCorrection::CreateHistoDRinXY(Float_t z,Int_t nx,Int_t ny) {
- //
- // Simple plot functionality.
- // Returns a 2d hisogram which represents the corrections in radial direction (dr)
- // in respect to position z within the XY plane.
- // The histogramm has nx times ny entries.
- //
+ /// Simple plot functionality.
+ /// Returns a 2d hisogram which represents the corrections in radial direction (dr)
+ /// in respect to position z within the XY plane.
+ /// The histogramm has nx times ny entries.
+
AliTPCParam* tpcparam = new AliTPCParamSR;
TH2F *h=CreateTH2F("dr_xy", TString::Format("%s: DRinXY Z=%2.0f", GetTitle(),z).Data(),"x [cm]","y [cm]","dr [cm]",
}
TH2F* AliTPCCorrection::CreateHistoDRPhiinXY(Float_t z,Int_t nx,Int_t ny) {
- //
- // Simple plot functionality.
- // Returns a 2d hisogram which represents the corrections in rphi direction (drphi)
- // in respect to position z within the XY plane.
- // The histogramm has nx times ny entries.
- //
+ /// Simple plot functionality.
+ /// Returns a 2d hisogram which represents the corrections in rphi direction (drphi)
+ /// in respect to position z within the XY plane.
+ /// The histogramm has nx times ny entries.
AliTPCParam* tpcparam = new AliTPCParamSR;
Float_t dphi=phi1-phi0;
if (dphi<TMath::Pi()) dphi+=TMath::TwoPi();
if (dphi>TMath::Pi()) dphi-=TMath::TwoPi();
-
+
h->SetBinContent(ix,iy,r0*dphi);
}
else
}
TH2F* AliTPCCorrection::CreateHistoDZinXY(Float_t z,Int_t nx,Int_t ny) {
- //
- // Simple plot functionality.
- // Returns a 2d hisogram which represents the corrections in longitudinal direction (dz)
- // in respect to position z within the XY plane.
- // The histogramm has nx times ny entries.
- //
+ /// Simple plot functionality.
+ /// Returns a 2d hisogram which represents the corrections in longitudinal direction (dz)
+ /// in respect to position z within the XY plane.
+ /// The histogramm has nx times ny entries.
AliTPCParam* tpcparam = new AliTPCParamSR;
-
+
TH2F *h=CreateTH2F("dz_xy",TString::Format("%s: DZinXY Z=%2.0f", GetTitle(),z).Data(),"x [cm]","y [cm]","dz [cm]",
nx,-250.,250.,ny,-250.,250.);
Float_t x[3],dx[3];
}
TH2F* AliTPCCorrection::CreateHistoDRinZR(Float_t phi,Int_t nz,Int_t nr) {
- //
- // Simple plot functionality.
- // Returns a 2d hisogram which represents the corrections in r direction (dr)
- // in respect to angle phi within the ZR plane.
- // The histogramm has nx times ny entries.
- //
+ /// Simple plot functionality.
+ /// Returns a 2d hisogram which represents the corrections in r direction (dr)
+ /// in respect to angle phi within the ZR plane.
+ /// The histogramm has nx times ny entries.
+
TH2F *h=CreateTH2F("dr_zr",TString::Format("%s: DRinZR Phi=%2.2f", GetTitle(),phi).Data(),"z [cm]","r [cm]","dr [cm]",
nz,-250.,250.,nr,85.,250.);
Float_t x[3],dx[3];
}
TH2F* AliTPCCorrection::CreateHistoDRPhiinZR(Float_t phi,Int_t nz,Int_t nr) {
- //
- // Simple plot functionality.
- // Returns a 2d hisogram which represents the corrections in rphi direction (drphi)
- // in respect to angle phi within the ZR plane.
- // The histogramm has nx times ny entries.
- //
+ /// Simple plot functionality.
+ /// Returns a 2d hisogram which represents the corrections in rphi direction (drphi)
+ /// in respect to angle phi within the ZR plane.
+ /// The histogramm has nx times ny entries.
+
TH2F *h=CreateTH2F("drphi_zr", TString::Format("%s: DRPhiinZR R=%2.2f", GetTitle(),phi).Data(),"z [cm]","r [cm]","drphi [cm]",
nz,-250.,250.,nr,85.,250.);
Float_t x[3],dx[3];
Float_t r0=TMath::Sqrt((x[0] )*(x[0] )+(x[1] )*(x[1] ));
Float_t phi0=TMath::ATan2(x[1] ,x[0] );
Float_t phi1=TMath::ATan2(x[1]+dx[1],x[0]+dx[0]);
-
+
Float_t dphi=phi1-phi0;
if (dphi<TMath::Pi()) dphi+=TMath::TwoPi();
if (dphi>TMath::Pi()) dphi-=TMath::TwoPi();
-
+
h->SetBinContent(iz,ir,r0*dphi);
}
}
}
TH2F* AliTPCCorrection::CreateHistoDZinZR(Float_t phi,Int_t nz,Int_t nr) {
- //
- // Simple plot functionality.
- // Returns a 2d hisogram which represents the corrections in longitudinal direction (dz)
- // in respect to angle phi within the ZR plane.
- // The histogramm has nx times ny entries.
- //
+ /// Simple plot functionality.
+ /// Returns a 2d hisogram which represents the corrections in longitudinal direction (dz)
+ /// in respect to angle phi within the ZR plane.
+ /// The histogramm has nx times ny entries.
+
TH2F *h=CreateTH2F("dz_zr",TString::Format("%s: DZinZR Z=%2.0f", GetTitle(),phi).Data(),"z [cm]","r [cm]","dz [cm]",
nz,-250.,250.,nr,85.,250.);
Float_t x[3],dx[3];
const char *xlabel,const char *ylabel,const char *zlabel,
Int_t nbinsx,Double_t xlow,Double_t xup,
Int_t nbinsy,Double_t ylow,Double_t yup) {
- //
- // Helper function to create a 2d histogramm of given size
- //
-
+ /// Helper function to create a 2d histogramm of given size
+
TString hname=name;
Int_t i=0;
if (gDirectory) {
// Simple Interpolation functions: e.g. with bi(tri)cubic interpolations (not yet in TH2 and TH3)
-void AliTPCCorrection::Interpolate2DEdistortion( Int_t order, Double_t r, Double_t z,
+void AliTPCCorrection::Interpolate2DEdistortion( Int_t order, Double_t r, Double_t z,
const Double_t er[kNZ][kNR], Double_t &erValue ) {
- //
- // Interpolate table - 2D interpolation
- //
+ /// Interpolate table - 2D interpolation
+
Double_t saveEr[5] = {0,0,0,0,0};
Search( kNZ, fgkZList, z, fJLow ) ;
}
-void AliTPCCorrection::Interpolate3DEdistortion( Int_t order, Double_t r, Float_t phi, Double_t z,
+void AliTPCCorrection::Interpolate3DEdistortion( Int_t order, Double_t r, Float_t phi, Double_t z,
const Double_t er[kNZ][kNPhi][kNR], const Double_t ephi[kNZ][kNPhi][kNR], const Double_t ez[kNZ][kNPhi][kNR],
Double_t &erValue, Double_t &ephiValue, Double_t &ezValue) {
- //
- // Interpolate table - 3D interpolation
- //
-
+ /// Interpolate table - 3D interpolation
+
Double_t saveEr[5]= {0,0,0,0,0};
Double_t savedEr[5]= {0,0,0,0,0} ;
saveEphi[j-fJLow] = Interpolate( &fgkRList[fKLow], &ephi[i][j][fKLow], order, r ) ;
saveEz[j-fJLow] = Interpolate( &fgkRList[fKLow], &ez[i][j][fKLow], order, r ) ;
}
- savedEr[i-fILow] = Interpolate( &fgkPhiList[fJLow], saveEr, order, phi ) ;
- savedEphi[i-fILow] = Interpolate( &fgkPhiList[fJLow], saveEphi, order, phi ) ;
- savedEz[i-fILow] = Interpolate( &fgkPhiList[fJLow], saveEz, order, phi ) ;
+ savedEr[i-fILow] = Interpolate( &fgkPhiList[fJLow], saveEr, order, phi ) ;
+ savedEphi[i-fILow] = Interpolate( &fgkPhiList[fJLow], saveEphi, order, phi ) ;
+ savedEz[i-fILow] = Interpolate( &fgkPhiList[fJLow], saveEz, order, phi ) ;
}
erValue = Interpolate( &fgkZList[fILow], savedEr, order, z ) ;
ephiValue = Interpolate( &fgkZList[fILow], savedEphi, order, z ) ;
}
-Double_t AliTPCCorrection::Interpolate2DTable( Int_t order, Double_t x, Double_t y,
- Int_t nx, Int_t ny, const Double_t xv[], const Double_t yv[],
+Double_t AliTPCCorrection::Interpolate2DTable( Int_t order, Double_t x, Double_t y,
+ Int_t nx, Int_t ny, const Double_t xv[], const Double_t yv[],
const TMatrixD &array ) {
- //
- // Interpolate table (TMatrix format) - 2D interpolation
- //
+ /// Interpolate table (TMatrix format) - 2D interpolation
static Int_t jlow = 0, klow = 0 ;
Double_t saveArray[5] = {0,0,0,0,0} ;
Int_t nx, Int_t ny, Int_t nz,
const Double_t xv[], const Double_t yv[], const Double_t zv[],
TMatrixD **arrayofArrays ) {
- //
- // Interpolate table (TMatrix format) - 3D interpolation
- //
+ /// Interpolate table (TMatrix format) - 3D interpolation
static Int_t ilow = 0, jlow = 0, klow = 0 ;
Double_t saveArray[5]= {0,0,0,0,0};
Search( nx, xv, x, ilow ) ;
Search( ny, yv, y, jlow ) ;
- Search( nz, zv, z, klow ) ;
+ Search( nz, zv, z, klow ) ;
if ( ilow < 0 ) ilow = 0 ; // check if out of range
if ( jlow < 0 ) jlow = 0 ;
{
saveArray[i-ilow] = Interpolate( &yv[jlow], &table(i,jlow), order, y ) ;
}
- savedArray[k-klow] = Interpolate( &xv[ilow], saveArray, order, x ) ;
+ savedArray[k-klow] = Interpolate( &xv[ilow], saveArray, order, x ) ;
}
return( Interpolate( &zv[klow], savedArray, order, z ) ) ;
}
-Double_t AliTPCCorrection::Interpolate( const Double_t xArray[], const Double_t yArray[],
+Double_t AliTPCCorrection::Interpolate( const Double_t xArray[], const Double_t yArray[],
Int_t order, Double_t x ) {
- //
- // Interpolate function Y(x) using linear (order=1) or quadratic (order=2) interpolation.
- //
+ /// Interpolate function Y(x) using linear (order=1) or quadratic (order=2) interpolation.
Double_t y ;
- if ( order == 2 ) { // Quadratic Interpolation = 2
- y = (x-xArray[1]) * (x-xArray[2]) * yArray[0] / ( (xArray[0]-xArray[1]) * (xArray[0]-xArray[2]) ) ;
- y += (x-xArray[2]) * (x-xArray[0]) * yArray[1] / ( (xArray[1]-xArray[2]) * (xArray[1]-xArray[0]) ) ;
- y += (x-xArray[0]) * (x-xArray[1]) * yArray[2] / ( (xArray[2]-xArray[0]) * (xArray[2]-xArray[1]) ) ;
+ if ( order == 2 ) { // Quadratic Interpolation = 2
+ y = (x-xArray[1]) * (x-xArray[2]) * yArray[0] / ( (xArray[0]-xArray[1]) * (xArray[0]-xArray[2]) ) ;
+ y += (x-xArray[2]) * (x-xArray[0]) * yArray[1] / ( (xArray[1]-xArray[2]) * (xArray[1]-xArray[0]) ) ;
+ y += (x-xArray[0]) * (x-xArray[1]) * yArray[2] / ( (xArray[2]-xArray[0]) * (xArray[2]-xArray[1]) ) ;
} else { // Linear Interpolation = 1
y = yArray[0] + ( yArray[1]-yArray[0] ) * ( x-xArray[0] ) / ( xArray[1] - xArray[0] ) ;
}
}
-Float_t AliTPCCorrection::Interpolate2DTable( Int_t order, Double_t x, Double_t y,
- Int_t nx, Int_t ny, const Double_t xv[], const Double_t yv[],
+Float_t AliTPCCorrection::Interpolate2DTable( Int_t order, Double_t x, Double_t y,
+ Int_t nx, Int_t ny, const Double_t xv[], const Double_t yv[],
const TMatrixF &array ) {
- //
- // Interpolate table (TMatrix format) - 2D interpolation
- // Float version (in order to decrease the OCDB size)
- //
+ /// Interpolate table (TMatrix format) - 2D interpolation
+ /// Float version (in order to decrease the OCDB size)
static Int_t jlow = 0, klow = 0 ;
Float_t saveArray[5] = {0.,0.,0.,0.,0.} ;
Int_t nx, Int_t ny, Int_t nz,
const Double_t xv[], const Double_t yv[], const Double_t zv[],
TMatrixF **arrayofArrays ) {
- //
- // Interpolate table (TMatrix format) - 3D interpolation
- // Float version (in order to decrease the OCDB size)
- //
+ /// Interpolate table (TMatrix format) - 3D interpolation
+ /// Float version (in order to decrease the OCDB size)
static Int_t ilow = 0, jlow = 0, klow = 0 ;
Float_t saveArray[5]= {0.,0.,0.,0.,0.};
Search( nx, xv, x, ilow ) ;
Search( ny, yv, y, jlow ) ;
- Search( nz, zv, z, klow ) ;
+ Search( nz, zv, z, klow ) ;
if ( ilow < 0 ) ilow = 0 ; // check if out of range
if ( jlow < 0 ) jlow = 0 ;
{
saveArray[i-ilow] = Interpolate( &yv[jlow], &table(i,jlow), order, y ) ;
}
- savedArray[k-klow] = Interpolate( &xv[ilow], saveArray, order, x ) ;
+ savedArray[k-klow] = Interpolate( &xv[ilow], saveArray, order, x ) ;
}
return( Interpolate( &zv[klow], savedArray, order, z ) ) ;
}
-Float_t AliTPCCorrection::Interpolate( const Double_t xArray[], const Float_t yArray[],
+Float_t AliTPCCorrection::Interpolate( const Double_t xArray[], const Float_t yArray[],
Int_t order, Double_t x ) {
- //
- // Interpolate function Y(x) using linear (order=1) or quadratic (order=2) interpolation.
- // Float version (in order to decrease the OCDB size)
- //
+ /// Interpolate function Y(x) using linear (order=1) or quadratic (order=2) interpolation.
+ /// Float version (in order to decrease the OCDB size)
Float_t y ;
- if ( order == 2 ) { // Quadratic Interpolation = 2
- y = (x-xArray[1]) * (x-xArray[2]) * yArray[0] / ( (xArray[0]-xArray[1]) * (xArray[0]-xArray[2]) ) ;
- y += (x-xArray[2]) * (x-xArray[0]) * yArray[1] / ( (xArray[1]-xArray[2]) * (xArray[1]-xArray[0]) ) ;
- y += (x-xArray[0]) * (x-xArray[1]) * yArray[2] / ( (xArray[2]-xArray[0]) * (xArray[2]-xArray[1]) ) ;
+ if ( order == 2 ) { // Quadratic Interpolation = 2
+ y = (x-xArray[1]) * (x-xArray[2]) * yArray[0] / ( (xArray[0]-xArray[1]) * (xArray[0]-xArray[2]) ) ;
+ y += (x-xArray[2]) * (x-xArray[0]) * yArray[1] / ( (xArray[1]-xArray[2]) * (xArray[1]-xArray[0]) ) ;
+ y += (x-xArray[0]) * (x-xArray[1]) * yArray[2] / ( (xArray[2]-xArray[0]) * (xArray[2]-xArray[1]) ) ;
} else { // Linear Interpolation = 1
y = yArray[0] + ( yArray[1]-yArray[0] ) * ( x-xArray[0] ) / ( xArray[1] - xArray[0] ) ;
}
void AliTPCCorrection::Search( Int_t n, const Double_t xArray[], Double_t x, Int_t &low ) {
- //
- // Search an ordered table by starting at the most recently used point
- //
+ /// Search an ordered table by starting at the most recently used point
Long_t middle, high ;
Int_t ascend = 0, increment = 1 ;
if ( xArray[n-1] >= xArray[0] ) ascend = 1 ; // Ascending ordered table if true
-
- if ( low < 0 || low > n-1 ) {
- low = -1 ; high = n ;
+
+ if ( low < 0 || low > n-1 ) {
+ low = -1 ; high = n ;
} else { // Ordered Search phase
if ( (Int_t)( x >= xArray[low] ) == ascend ) {
- if ( low == n-1 ) return ;
+ if ( low == n-1 ) return ;
high = low + 1 ;
while ( (Int_t)( x >= xArray[high] ) == ascend ) {
low = high ;
}
}
}
-
+
while ( (high-low) != 1 ) { // Binary Search Phase
middle = ( high + low ) / 2 ;
if ( (Int_t)( x >= xArray[middle] ) == ascend )
else
high = middle ;
}
-
+
if ( x == xArray[n-1] ) low = n-2 ;
if ( x == xArray[0] ) low = 0 ;
-
+
}
void AliTPCCorrection::InitLookUpfulcrums() {
- //
- // Initialization of interpolation points - for main look up table
- // (course grid in the middle, fine grid on the borders)
- //
+ /// Initialization of interpolation points - for main look up table
+ /// (course grid in the middle, fine grid on the borders)
AliTPCROC * roc = AliTPCROC::Instance();
- const Double_t rLow = TMath::Floor(roc->GetPadRowRadii(0,0))-1; // first padRow plus some margin
+ const Double_t rLow = TMath::Floor(roc->GetPadRowRadii(0,0))-1; // first padRow plus some margin
// fulcrums in R
fgkRList[0] = rLow;
for (Int_t i = 1; i<kNR; i++) {
- fgkRList[i] = fgkRList[i-1] + 3.5; // 3.5 cm spacing
- if (fgkRList[i]<90 ||fgkRList[i]>245)
+ fgkRList[i] = fgkRList[i-1] + 3.5; // 3.5 cm spacing
+ if (fgkRList[i]<90 ||fgkRList[i]>245)
fgkRList[i] = fgkRList[i-1] + 0.5; // 0.5 cm spacing
- else if (fgkRList[i]<100 || fgkRList[i]>235)
+ else if (fgkRList[i]<100 || fgkRList[i]>235)
fgkRList[i] = fgkRList[i-1] + 1.5; // 1.5 cm spacing
- else if (fgkRList[i]<120 || fgkRList[i]>225)
+ else if (fgkRList[i]<120 || fgkRList[i]>225)
fgkRList[i] = fgkRList[i-1] + 2.5; // 2.5 cm spacing
}
fgkZList[j] = fgkZList[j-1] + 0.09; // 0.09 cm spacing
else if(TMath::Abs(fgkZList[j])< 0.6)
fgkZList[j] = fgkZList[j-1] + 0.4; // 0.4 cm spacing
- else if (TMath::Abs(fgkZList[j])< 2.5 || TMath::Abs(fgkZList[j])>248)
+ else if (TMath::Abs(fgkZList[j])< 2.5 || TMath::Abs(fgkZList[j])>248)
fgkZList[j] = fgkZList[j-1] + 0.5; // 0.5 cm spacing
- else if (TMath::Abs(fgkZList[j])<10 || TMath::Abs(fgkZList[j])>235)
+ else if (TMath::Abs(fgkZList[j])<10 || TMath::Abs(fgkZList[j])>235)
fgkZList[j] = fgkZList[j-1] + 1.5; // 1.5 cm spacing
- else if (TMath::Abs(fgkZList[j])<25 || TMath::Abs(fgkZList[j])>225)
+ else if (TMath::Abs(fgkZList[j])<25 || TMath::Abs(fgkZList[j])>225)
fgkZList[j] = fgkZList[j-1] + 2.5; // 2.5 cm spacing
- else
+ else
fgkZList[j] = fgkZList[j-1] + 4; // 4 cm spacing
fgkZList[kNZ-j-1] = -fgkZList[j];
}
-
+
// fulcrums in phi
- for (Int_t k = 0; k<kNPhi; k++)
- fgkPhiList[k] = TMath::TwoPi()*k/(kNPhi-1);
-
-
+ for (Int_t k = 0; k<kNPhi; k++)
+ fgkPhiList[k] = TMath::TwoPi()*k/(kNPhi-1);
+
+
}
-void AliTPCCorrection::PoissonRelaxation2D(TMatrixD &arrayV, TMatrixD &chargeDensity,
- TMatrixD &arrayErOverEz, TMatrixD &arrayDeltaEz,
+void AliTPCCorrection::PoissonRelaxation2D(TMatrixD &arrayV, TMatrixD &chargeDensity,
+ TMatrixD &arrayErOverEz, TMatrixD &arrayDeltaEz,
Int_t rows, Int_t columns, Int_t iterations,
Bool_t rocDisplacement ) {
- //
- // Solve Poisson's Equation by Relaxation Technique in 2D (assuming cylindrical symmetry)
- //
- // Solve Poissons equation in a cylindrical coordinate system. The arrayV matrix must be filled with the
- // boundary conditions on the first and last rows, and the first and last columns. The remainder of the
- // array can be blank or contain a preliminary guess at the solution. The Charge density matrix contains
- // the enclosed spacecharge density at each point. The charge density matrix can be full of zero's if
- // you wish to solve Laplaces equation however it should not contain random numbers or you will get
- // random numbers back as a solution.
- // Poisson's equation is solved by iteratively relaxing the matrix to the final solution. In order to
- // speed up the convergence to the best solution, this algorithm does a binary expansion of the solution
- // space. First it solves the problem on a very sparse grid by skipping rows and columns in the original
- // matrix. Then it doubles the number of points and solves the problem again. Then it doubles the
- // number of points and solves the problem again. This happens several times until the maximum number
- // of points has been included in the array.
- //
- // NOTE: In order for this algorithmto work, the number of rows and columns must be a power of 2 plus one.
- // So rows == 2**M + 1 and columns == 2**N + 1. The number of rows and columns can be different.
- //
- // NOTE: rocDisplacement is used to include (or ignore) the ROC misalignment in the dz calculation
- //
- // Original code by Jim Thomas (STAR TPC Collaboration)
- //
-
- Double_t ezField = (fgkCathodeV-fgkGG)/fgkTPCZ0; // = ALICE Electric Field (V/cm) Magnitude ~ -400 V/cm;
+ /// Solve Poisson's Equation by Relaxation Technique in 2D (assuming cylindrical symmetry)
+ ///
+ /// Solve Poissons equation in a cylindrical coordinate system. The arrayV matrix must be filled with the
+ /// boundary conditions on the first and last rows, and the first and last columns. The remainder of the
+ /// array can be blank or contain a preliminary guess at the solution. The Charge density matrix contains
+ /// the enclosed spacecharge density at each point. The charge density matrix can be full of zero's if
+ /// you wish to solve Laplaces equation however it should not contain random numbers or you will get
+ /// random numbers back as a solution.
+ /// Poisson's equation is solved by iteratively relaxing the matrix to the final solution. In order to
+ /// speed up the convergence to the best solution, this algorithm does a binary expansion of the solution
+ /// space. First it solves the problem on a very sparse grid by skipping rows and columns in the original
+ /// matrix. Then it doubles the number of points and solves the problem again. Then it doubles the
+ /// number of points and solves the problem again. This happens several times until the maximum number
+ /// of points has been included in the array.
+ ///
+ /// NOTE: In order for this algorithmto work, the number of rows and columns must be a power of 2 plus one.
+ /// So rows == 2**M + 1 and columns == 2**N + 1. The number of rows and columns can be different.
+ ///
+ /// NOTE: rocDisplacement is used to include (or ignore) the ROC misalignment in the dz calculation
+ ///
+ /// Original code by Jim Thomas (STAR TPC Collaboration)
+
+ Double_t ezField = (fgkCathodeV-fgkGG)/fgkTPCZ0; // = ALICE Electric Field (V/cm) Magnitude ~ -400 V/cm;
const Float_t gridSizeR = (fgkOFCRadius-fgkIFCRadius) / (rows-1) ;
const Float_t gridSizeZ = fgkTPCZ0 / (columns-1) ;
TMatrixD arrayEz(rows,columns) ;
//Check that number of rows and columns is suitable for a binary expansion
-
+
if ( !IsPowerOfTwo(rows-1) ) {
AliError("PoissonRelaxation - Error in the number of rows. Must be 2**M - 1");
return;
AliError("PoissonRelaxation - Error in the number of columns. Must be 2**N - 1");
return;
}
-
+
// Solve Poisson's equation in cylindrical coordinates by relaxation technique
// Allow for different size grid spacing in R and Z directions
// Use a binary expansion of the size of the matrix to speed up the solution of the problem
-
+
Int_t iOne = (rows-1)/4 ;
Int_t jOne = (columns-1)/4 ;
// Solve for N in 2**N, add one.
- Int_t loops = 1 + (int) ( 0.5 + TMath::Log2( (double) TMath::Max(iOne,jOne) ) ) ;
+ Int_t loops = 1 + (int) ( 0.5 + TMath::Log2( (double) TMath::Max(iOne,jOne) ) ) ;
- for ( Int_t count = 0 ; count < loops ; count++ ) {
+ for ( Int_t count = 0 ; count < loops ; count++ ) {
// Loop while the matrix expands & the resolution increases.
Float_t tempGridSizeR = gridSizeR * iOne ;
Float_t tempRatio = ratio * iOne * iOne / ( jOne * jOne ) ;
Float_t tempFourth = 1.0 / (2.0 + 2.0*tempRatio) ;
-
+
// Do this the standard C++ way to avoid gcc extensions for Float_t coef1[rows]
- std::vector<float> coef1(rows) ;
- std::vector<float> coef2(rows) ;
+ std::vector<float> coef1(rows) ;
+ std::vector<float> coef2(rows) ;
for ( Int_t i = iOne ; i < rows-1 ; i+=iOne ) {
Float_t radius = fgkIFCRadius + i*gridSizeR ;
coef1[i] = 1.0 + tempGridSizeR/(2*radius);
coef2[i] = 1.0 - tempGridSizeR/(2*radius);
}
-
+
TMatrixD sumChargeDensity(rows,columns) ;
for ( Int_t i = iOne ; i < rows-1 ; i += iOne ) {
Float_t radius = fgkIFCRadius + iOne*gridSizeR ;
for ( Int_t j = jOne ; j < columns-1 ; j += jOne ) {
if ( iOne == 1 && jOne == 1 ) sumChargeDensity(i,j) = chargeDensity(i,j) ;
- else {
+ else {
// Add up all enclosed charge density contributions within 1/2 unit in all directions
Float_t weight = 0.0 ;
Float_t sum = 0.0 ;
else
weight = 1.0 ;
// Note that this is cylindrical geometry
- sumChargeDensity(i,j) += chargeDensity(ii,jj)*weight*radius ;
+ sumChargeDensity(i,j) += chargeDensity(ii,jj)*weight*radius ;
sum += weight*radius ;
}
}
}
}
- for ( Int_t k = 1 ; k <= iterations; k++ ) {
+ for ( Int_t k = 1 ; k <= iterations; k++ ) {
// Solve Poisson's Equation
- // Over-relaxation index, must be >= 1 but < 2. Arrange for it to evolve from 2 => 1
+ // Over-relaxation index, must be >= 1 but < 2. Arrange for it to evolve from 2 => 1
// as interations increase.
- Float_t overRelax = 1.0 + TMath::Sqrt( TMath::Cos( (k*TMath::PiOver2())/iterations ) ) ;
+ Float_t overRelax = 1.0 + TMath::Sqrt( TMath::Cos( (k*TMath::PiOver2())/iterations ) ) ;
Float_t overRelaxM1 = overRelax - 1.0 ;
Float_t overRelaxtempFourth, overRelaxcoef5 ;
overRelaxtempFourth = overRelax * tempFourth ;
- overRelaxcoef5 = overRelaxM1 / overRelaxtempFourth ;
+ overRelaxcoef5 = overRelaxM1 / overRelaxtempFourth ;
for ( Int_t i = iOne ; i < rows-1 ; i += iOne ) {
for ( Int_t j = jOne ; j < columns-1 ; j += jOne ) {
arrayV(i,j) = ( coef2[i] * arrayV(i-iOne,j)
+ tempRatio * ( arrayV(i,j-jOne) + arrayV(i,j+jOne) )
- - overRelaxcoef5 * arrayV(i,j)
- + coef1[i] * arrayV(i+iOne,j)
- + sumChargeDensity(i,j)
+ - overRelaxcoef5 * arrayV(i,j)
+ + coef1[i] * arrayV(i+iOne,j)
+ + sumChargeDensity(i,j)
) * overRelaxtempFourth;
}
}
- if ( k == iterations ) {
+ if ( k == iterations ) {
// After full solution is achieved, copy low resolution solution into higher res array
for ( Int_t i = iOne ; i < rows-1 ; i += iOne ) {
for ( Int_t j = jOne ; j < columns-1 ; j += jOne ) {
- if ( iOne > 1 ) {
+ if ( iOne > 1 ) {
arrayV(i+iOne/2,j) = ( arrayV(i+iOne,j) + arrayV(i,j) ) / 2 ;
if ( i == iOne ) arrayV(i-iOne/2,j) = ( arrayV(0,j) + arrayV(iOne,j) ) / 2 ;
}
arrayV(i+iOne/2,j+jOne/2) = ( arrayV(i+iOne,j+jOne) + arrayV(i,j) ) / 2 ;
if ( i == iOne ) arrayV(i-iOne/2,j-jOne/2) = ( arrayV(0,j-jOne) + arrayV(iOne,j) ) / 2 ;
if ( j == jOne ) arrayV(i-iOne/2,j-jOne/2) = ( arrayV(i-iOne,0) + arrayV(i,jOne) ) / 2 ;
- // Note that this leaves a point at the upper left and lower right corners uninitialized.
+ // Note that this leaves a point at the upper left and lower right corners uninitialized.
// -> Not a big deal.
}
jOne = jOne / 2 ; if ( jOne < 1 ) jOne = 1 ;
sumChargeDensity.Clear();
- }
+ }
// Differentiate V(r) and solve for E(r) using special equations for the first and last rows
- for ( Int_t j = 0 ; j < columns ; j++ ) {
+ for ( Int_t j = 0 ; j < columns ; j++ ) {
for ( Int_t i = 1 ; i < rows-1 ; i++ ) arrayEr(i,j) = -1 * ( arrayV(i+1,j) - arrayV(i-1,j) ) / (2*gridSizeR) ;
- arrayEr(0,j) = -1 * ( -0.5*arrayV(2,j) + 2.0*arrayV(1,j) - 1.5*arrayV(0,j) ) / gridSizeR ;
- arrayEr(rows-1,j) = -1 * ( 1.5*arrayV(rows-1,j) - 2.0*arrayV(rows-2,j) + 0.5*arrayV(rows-3,j) ) / gridSizeR ;
+ arrayEr(0,j) = -1 * ( -0.5*arrayV(2,j) + 2.0*arrayV(1,j) - 1.5*arrayV(0,j) ) / gridSizeR ;
+ arrayEr(rows-1,j) = -1 * ( 1.5*arrayV(rows-1,j) - 2.0*arrayV(rows-2,j) + 0.5*arrayV(rows-3,j) ) / gridSizeR ;
}
// Differentiate V(z) and solve for E(z) using special equations for the first and last columns
for ( Int_t i = 0 ; i < rows ; i++) {
for ( Int_t j = 1 ; j < columns-1 ; j++ ) arrayEz(i,j) = -1 * ( arrayV(i,j+1) - arrayV(i,j-1) ) / (2*gridSizeZ) ;
- arrayEz(i,0) = -1 * ( -0.5*arrayV(i,2) + 2.0*arrayV(i,1) - 1.5*arrayV(i,0) ) / gridSizeZ ;
- arrayEz(i,columns-1) = -1 * ( 1.5*arrayV(i,columns-1) - 2.0*arrayV(i,columns-2) + 0.5*arrayV(i,columns-3) ) / gridSizeZ ;
+ arrayEz(i,0) = -1 * ( -0.5*arrayV(i,2) + 2.0*arrayV(i,1) - 1.5*arrayV(i,0) ) / gridSizeZ ;
+ arrayEz(i,columns-1) = -1 * ( 1.5*arrayV(i,columns-1) - 2.0*arrayV(i,columns-2) + 0.5*arrayV(i,columns-3) ) / gridSizeZ ;
}
-
+
for ( Int_t i = 0 ; i < rows ; i++) {
// Note: go back and compare to old version of this code. See notes below.
// JT Test ... attempt to divide by real Ez not Ez to first order
for ( Int_t j = 0 ; j < columns ; j++ ) {
arrayEz(i,j) += ezField;
// This adds back the overall Z gradient of the field (main E field component)
- }
+ }
// Warning: (-=) assumes you are using an error potetial without the overall Field included
- }
-
+ }
+
// Integrate Er/Ez from Z to zero
- for ( Int_t j = 0 ; j < columns ; j++ ) {
+ for ( Int_t j = 0 ; j < columns ; j++ ) {
for ( Int_t i = 0 ; i < rows ; i++ ) {
-
- Int_t index = 1 ; // Simpsons rule if N=odd. If N!=odd then add extra point by trapezoidal rule.
+
+ Int_t index = 1 ; // Simpsons rule if N=odd. If N!=odd then add extra point by trapezoidal rule.
arrayErOverEz(i,j) = 0.0 ;
arrayDeltaEz(i,j) = 0.0 ;
-
+
for ( Int_t k = j ; k < columns ; k++ ) {
arrayErOverEz(i,j) += index*(gridSizeZ/3.0)*arrayEr(i,k)/arrayEz(i,k) ;
arrayDeltaEz(i,j) += index*(gridSizeZ/3.0)*(arrayEz(i,k)-ezField) ;
arrayDeltaEz(i,j) -= (gridSizeZ/3.0)*(arrayEz(i,columns-1)-ezField) ;
}
if ( index == 2 ) {
- arrayErOverEz(i,j) += (gridSizeZ/3.0) * ( 0.5*arrayEr(i,columns-2)/arrayEz(i,columns-2)
+ arrayErOverEz(i,j) += (gridSizeZ/3.0) * ( 0.5*arrayEr(i,columns-2)/arrayEz(i,columns-2)
-2.5*arrayEr(i,columns-1)/arrayEz(i,columns-1));
- arrayDeltaEz(i,j) += (gridSizeZ/3.0) * ( 0.5*(arrayEz(i,columns-2)-ezField)
+ arrayDeltaEz(i,j) += (gridSizeZ/3.0) * ( 0.5*(arrayEz(i,columns-2)-ezField)
-2.5*(arrayEz(i,columns-1)-ezField));
}
if ( j == columns-2 ) {
}
}
}
-
+
// calculate z distortion from the integrated Delta Ez residuals
// and include the aquivalence (Volt to cm) of the ROC shift !!
- for ( Int_t j = 0 ; j < columns ; j++ ) {
+ for ( Int_t j = 0 ; j < columns ; j++ ) {
for ( Int_t i = 0 ; i < rows ; i++ ) {
// Scale the Ez distortions with the drift velocity pertubation -> delivers cm
arrayDeltaEz(i,j) = arrayDeltaEz(i,j)*fgkdvdE;
// ROC Potential in cm aquivalent
- Double_t dzROCShift = arrayV(i, columns -1)/ezField;
+ Double_t dzROCShift = arrayV(i, columns -1)/ezField;
if ( rocDisplacement ) arrayDeltaEz(i,j) = arrayDeltaEz(i,j) + dzROCShift; // add the ROC misaligment
}
}
-
+
arrayEr.Clear();
arrayEz.Clear();
}
-void AliTPCCorrection::PoissonRelaxation3D( TMatrixD**arrayofArrayV, TMatrixD**arrayofChargeDensities,
+void AliTPCCorrection::PoissonRelaxation3D( TMatrixD**arrayofArrayV, TMatrixD**arrayofChargeDensities,
TMatrixD**arrayofEroverEz, TMatrixD**arrayofEPhioverEz, TMatrixD**arrayofDeltaEz,
- Int_t rows, Int_t columns, Int_t phislices,
+ Int_t rows, Int_t columns, Int_t phislices,
Float_t deltaphi, Int_t iterations, Int_t symmetry,
Bool_t rocDisplacement ) {
- //
- // 3D - Solve Poisson's Equation in 3D by Relaxation Technique
- //
- // NOTE: In order for this algorith to work, the number of rows and columns must be a power of 2 plus one.
- // The number of rows and COLUMNS can be different.
- //
- // ROWS == 2**M + 1
- // COLUMNS == 2**N + 1
- // PHISLICES == Arbitrary but greater than 3
- //
- // DeltaPhi in Radians
- //
- // SYMMETRY = 0 if no phi symmetries, and no phi boundary conditions
- // = 1 if we have reflection symmetry at the boundaries (eg. sector symmetry or half sector symmetries).
- //
- // NOTE: rocDisplacement is used to include (or ignore) the ROC misalignment in the dz calculation
-
- const Double_t ezField = (fgkCathodeV-fgkGG)/fgkTPCZ0; // = ALICE Electric Field (V/cm) Magnitude ~ -400 V/cm;
+ /// 3D - Solve Poisson's Equation in 3D by Relaxation Technique
+ ///
+ /// NOTE: In order for this algorith to work, the number of rows and columns must be a power of 2 plus one.
+ /// The number of rows and COLUMNS can be different.
+ ///
+ /// ROWS == 2**M + 1
+ /// COLUMNS == 2**N + 1
+ /// PHISLICES == Arbitrary but greater than 3
+ ///
+ /// DeltaPhi in Radians
+ ///
+ /// SYMMETRY = 0 if no phi symmetries, and no phi boundary conditions
+ /// = 1 if we have reflection symmetry at the boundaries (eg. sector symmetry or half sector symmetries).
+ ///
+ /// NOTE: rocDisplacement is used to include (or ignore) the ROC misalignment in the dz calculation
+
+ const Double_t ezField = (fgkCathodeV-fgkGG)/fgkTPCZ0; // = ALICE Electric Field (V/cm) Magnitude ~ -400 V/cm;
const Float_t gridSizeR = (fgkOFCRadius-fgkIFCRadius) / (rows-1) ;
const Float_t gridSizePhi = deltaphi ;
TMatrixD arrayE(rows,columns) ;
// Check that the number of rows and columns is suitable for a binary expansion
- if ( !IsPowerOfTwo((rows-1)) ) {
- AliError("Poisson3DRelaxation - Error in the number of rows. Must be 2**M - 1");
+ if ( !IsPowerOfTwo((rows-1)) ) {
+ AliError("Poisson3DRelaxation - Error in the number of rows. Must be 2**M - 1");
return; }
- if ( !IsPowerOfTwo((columns-1)) ) {
+ if ( !IsPowerOfTwo((columns-1)) ) {
AliError("Poisson3DRelaxation - Error in the number of columns. Must be 2**N - 1");
return; }
- if ( phislices <= 3 ) {
+ if ( phislices <= 3 ) {
AliError("Poisson3DRelaxation - Error in the number of phislices. Must be larger than 3");
return; }
- if ( phislices > 1000 ) {
- AliError("Poisson3D phislices > 1000 is not allowed (nor wise) ");
- return; }
-
+ if ( phislices > 1000 ) {
+ AliError("Poisson3D phislices > 1000 is not allowed (nor wise) ");
+ return; }
+
// Solve Poisson's equation in cylindrical coordinates by relaxation technique
// Allow for different size grid spacing in R and Z directions
// Use a binary expansion of the matrix to speed up the solution of the problem
for ( Int_t count = 0 ; count < loops ; count++ ) { // START the master loop and do the binary expansion
AliSysInfo::AddStamp("3Diter", 20,count,0);
-
+
Float_t tempgridSizeR = gridSizeR * ione ;
Float_t tempratioPhi = ratioPhi * ione * ione ; // Used tobe divided by ( m_one * m_one ) when m_one was != 1
Float_t tempratioZ = ratioZ * ione * ione / ( jone * jone ) ;
for ( Int_t jj = j-jone/2 ; jj <= j+jone/2 ; jj++ ) {
if ( ii == i-ione/2 || ii == i+ione/2 || jj == j-jone/2 || jj == j+jone/2 ) weight = 0.5 ;
else
- weight = 1.0 ;
- sumChargeDensity(i,j) += chargeDensity(ii,jj)*weight*radius ;
+ weight = 1.0 ;
+ sumChargeDensity(i,j) += chargeDensity(ii,jj)*weight*radius ;
sum += weight*radius ;
}
}
for ( Int_t k = 1 ; k <= iterations; k++ ) {
// over-relaxation index, >= 1 but < 2
- Float_t overRelax = 1.0 + TMath::Sqrt( TMath::Cos( (k*TMath::PiOver2())/iterations ) ) ;
+ Float_t overRelax = 1.0 + TMath::Sqrt( TMath::Cos( (k*TMath::PiOver2())/iterations ) ) ;
Float_t overRelaxM1 = overRelax - 1.0 ;
std::vector<float> overRelaxcoef4(rows) ; // Do this the standard C++ way to avoid gcc extensions
std::vector<float> overRelaxcoef5(rows) ; // Do this the standard C++ way to avoid gcc extensions
- for ( Int_t i = ione ; i < rows-1 ; i+=ione ) {
+ for ( Int_t i = ione ; i < rows-1 ; i+=ione ) {
overRelaxcoef4[i] = overRelax * coef4[i] ;
- overRelaxcoef5[i] = overRelaxM1 / overRelaxcoef4[i] ;
+ overRelaxcoef5[i] = overRelaxM1 / overRelaxcoef4[i] ;
}
for ( Int_t m = 0 ; m < phislices ; m++ ) {
- mplus = m + 1; signplus = 1 ;
+ mplus = m + 1; signplus = 1 ;
mminus = m - 1 ; signminus = 1 ;
if (symmetry==1) { // Reflection symmetry in phi (e.g. symmetry at sector boundaries, or half sectors, etc.)
if ( mplus > phislices-1 ) mplus = phislices - 2 ;
}
else if (symmetry==-1) { // Anti-symmetry in phi
if ( mplus > phislices-1 ) { mplus = phislices - 2 ; signplus = -1 ; }
- if ( mminus < 0 ) { mminus = 1 ; signminus = -1 ; }
+ if ( mminus < 0 ) { mminus = 1 ; signminus = -1 ; }
}
else { // No Symmetries in phi, no boundaries, the calculation is continuous across all phi
if ( mplus > phislices-1 ) mplus = m + 1 - phislices ;
// slow implementation
for ( Int_t i = ione ; i < rows-1 ; i+=ione ) {
for ( Int_t j = jone ; j < columns-1 ; j+=jone ) {
-
+
arrayV(i,j) = ( coef2[i] * arrayV(i-ione,j)
+ tempratioZ * ( arrayV(i,j-jone) + arrayV(i,j+jone) )
- - overRelaxcoef5[i] * arrayV(i,j)
- + coef1[i] * arrayV(i+ione,j)
+ - overRelaxcoef5[i] * arrayV(i,j)
+ + coef1[i] * arrayV(i+ione,j)
+ coef3[i] * ( signplus*arrayVP(i,j) + signminus*arrayVM(i,j) )
- + sumChargeDensity(i,j)
- ) * overRelaxcoef4[i] ;
- // Note: over-relax the solution at each step. This speeds up the convergance.
+ + sumChargeDensity(i,j)
+ ) * overRelaxcoef4[i] ;
+ // Note: over-relax the solution at each step. This speeds up the convergance.
}
}
}else{
Double_t /*resSlow*/resFast;
// resSlow = ( coef2[i] * arrayV(i-ione,j)
// + tempratioZ * ( arrayV(i,j-jone) + arrayV(i,j+jone) )
-// - overRelaxcoef5[i] * arrayV(i,j)
-// + coef1[i] * arrayV(i+ione,j)
+// - overRelaxcoef5[i] * arrayV(i,j)
+// + coef1[i] * arrayV(i+ione,j)
// + coef3[i] * ( signplus*arrayVP(i,j) + signminus*arrayVM(i,j) )
-// + sumChargeDensity(i,j)
-// ) * overRelaxcoef4[i] ;
+// + sumChargeDensity(i,j)
+// ) * overRelaxcoef4[i] ;
resFast = ( coef2[i] * arrayVfastI[j-columns*ione]
+ tempratioZ * ( arrayVfastI[j-jone] + arrayVfastI[j+jone] )
- - overRelaxcoef5[i] * arrayVfastI[j]
- + coef1[i] * arrayVfastI[j+columns*ione]
+ - overRelaxcoef5[i] * arrayVfastI[j]
+ + coef1[i] * arrayVfastI[j+columns*ione]
+ coef3[i] * ( signplus* arrayVPfastI[j] + signminus*arrayVMfastI[j])
- + sumChargeDensityFastI[j]
- ) * overRelaxcoef4[i] ;
+ + sumChargeDensityFastI[j]
+ ) * overRelaxcoef4[i] ;
// if (resSlow!=resFast){
// printf("problem\t%d\t%d\t%f\t%f\t%f\n",i,j,resFast,resSlow,resFast-resSlow);
// }
arrayVfastI[j]=resFast;
- // Note: over-relax the solution at each step. This speeds up the convergance.
+ // Note: over-relax the solution at each step. This speeds up the convergance.
}
}
}
if ( k == iterations ) { // After full solution is achieved, copy low resolution solution into higher res array
for ( Int_t i = ione ; i < rows-1 ; i+=ione ) {
for ( Int_t j = jone ; j < columns-1 ; j+=jone ) {
-
- if ( ione > 1 ) {
+
+ if ( ione > 1 ) {
arrayV(i+ione/2,j) = ( arrayV(i+ione,j) + arrayV(i,j) ) / 2 ;
if ( i == ione ) arrayV(i-ione/2,j) = ( arrayV(0,j) + arrayV(ione,j) ) / 2 ;
}
if ( j == jone ) arrayV(i-ione/2,j-jone/2) = ( arrayV(i-ione,0) + arrayV(i,jone) ) / 2 ;
// Note that this leaves a point at the upper left and lower right corners uninitialized. Not a big deal.
}
- }
+ }
}
}
}
- }
+ }
ione = ione / 2 ; if ( ione < 1 ) ione = 1 ;
jone = jone / 2 ; if ( jone < 1 ) jone = 1 ;
}
-
+
//Differentiate V(r) and solve for E(r) using special equations for the first and last row
//Integrate E(r)/E(z) from point of origin to pad plane
AliSysInfo::AddStamp("CalcField", 100,0,0);
for ( Int_t m = 0 ; m < phislices ; m++ ) {
TMatrixD& arrayV = *arrayofArrayV[m] ;
TMatrixD& eroverEz = *arrayofEroverEz[m] ;
-
+
for ( Int_t j = columns-1 ; j >= 0 ; j-- ) { // Count backwards to facilitate integration over Z
-
+
// Differentiate in R
for ( Int_t i = 1 ; i < rows-1 ; i++ ) arrayE(i,j) = -1 * ( arrayV(i+1,j) - arrayV(i-1,j) ) / (2*gridSizeR) ;
- arrayE(0,j) = -1 * ( -0.5*arrayV(2,j) + 2.0*arrayV(1,j) - 1.5*arrayV(0,j) ) / gridSizeR ;
- arrayE(rows-1,j) = -1 * ( 1.5*arrayV(rows-1,j) - 2.0*arrayV(rows-2,j) + 0.5*arrayV(rows-3,j) ) / gridSizeR ;
+ arrayE(0,j) = -1 * ( -0.5*arrayV(2,j) + 2.0*arrayV(1,j) - 1.5*arrayV(0,j) ) / gridSizeR ;
+ arrayE(rows-1,j) = -1 * ( 1.5*arrayV(rows-1,j) - 2.0*arrayV(rows-2,j) + 0.5*arrayV(rows-3,j) ) / gridSizeR ;
// Integrate over Z
for ( Int_t i = 0 ; i < rows ; i++ ) {
- Int_t index = 1 ; // Simpsons rule if N=odd. If N!=odd then add extra point by trapezoidal rule.
+ Int_t index = 1 ; // Simpsons rule if N=odd. If N!=odd then add extra point by trapezoidal rule.
eroverEz(i,j) = 0.0 ;
for ( Int_t k = j ; k < columns ; k++ ) {
-
+
eroverEz(i,j) += index*(gridSizeZ/3.0)*arrayE(i,k)/(-1*ezField) ;
if ( index != 4 ) index = 4; else index = 2 ;
}
if ( index == 4 ) eroverEz(i,j) -= (gridSizeZ/3.0)*arrayE(i,columns-1)/ (-1*ezField) ;
- if ( index == 2 ) eroverEz(i,j) +=
+ if ( index == 2 ) eroverEz(i,j) +=
(gridSizeZ/3.0)*(0.5*arrayE(i,columns-2)-2.5*arrayE(i,columns-1))/(-1*ezField) ;
- if ( j == columns-2 ) eroverEz(i,j) =
+ if ( j == columns-2 ) eroverEz(i,j) =
(gridSizeZ/3.0)*(1.5*arrayE(i,columns-2)+1.5*arrayE(i,columns-1))/(-1*ezField) ;
if ( j == columns-1 ) eroverEz(i,j) = 0.0 ;
}
// eroverEz.Draw("surf") ; } // JT test
}
AliSysInfo::AddStamp("IntegrateEr", 120,0,0);
-
- //Differentiate V(r) and solve for E(phi)
+
+ //Differentiate V(r) and solve for E(phi)
//Integrate E(phi)/E(z) from point of origin to pad plane
for ( Int_t m = 0 ; m < phislices ; m++ ) {
-
- mplus = m + 1; signplus = 1 ;
- mminus = m - 1 ; signminus = 1 ;
+
+ mplus = m + 1; signplus = 1 ;
+ mminus = m - 1 ; signminus = 1 ;
if (symmetry==1) { // Reflection symmetry in phi (e.g. symmetry at sector boundaries, or half sectors, etc.)
if ( mplus > phislices-1 ) mplus = phislices - 2 ;
if ( mminus < 0 ) mminus = 1 ;
}
else if (symmetry==-1) { // Anti-symmetry in phi
if ( mplus > phislices-1 ) { mplus = phislices - 2 ; signplus = -1 ; }
- if ( mminus < 0 ) { mminus = 1 ; signminus = -1 ; }
+ if ( mminus < 0 ) { mminus = 1 ; signminus = -1 ; }
}
else { // No Symmetries in phi, no boundaries, the calculations is continuous across all phi
if ( mplus > phislices-1 ) mplus = m + 1 - phislices ;
}
// Integrate over Z
for ( Int_t i = 0 ; i < rows ; i++ ) {
- Int_t index = 1 ; // Simpsons rule if N=odd. If N!=odd then add extra point by trapezoidal rule.
+ Int_t index = 1 ; // Simpsons rule if N=odd. If N!=odd then add extra point by trapezoidal rule.
ePhioverEz(i,j) = 0.0 ;
for ( Int_t k = j ; k < columns ; k++ ) {
-
+
ePhioverEz(i,j) += index*(gridSizeZ/3.0)*arrayE(i,k)/(-1*ezField) ;
if ( index != 4 ) index = 4; else index = 2 ;
}
if ( index == 4 ) ePhioverEz(i,j) -= (gridSizeZ/3.0)*arrayE(i,columns-1)/ (-1*ezField) ;
- if ( index == 2 ) ePhioverEz(i,j) +=
+ if ( index == 2 ) ePhioverEz(i,j) +=
(gridSizeZ/3.0)*(0.5*arrayE(i,columns-2)-2.5*arrayE(i,columns-1))/(-1*ezField) ;
- if ( j == columns-2 ) ePhioverEz(i,j) =
+ if ( j == columns-2 ) ePhioverEz(i,j) =
(gridSizeZ/3.0)*(1.5*arrayE(i,columns-2)+1.5*arrayE(i,columns-1))/(-1*ezField) ;
if ( j == columns-1 ) ePhioverEz(i,j) = 0.0 ;
}
// arrayE.Draw("surf") ; } // JT test
}
AliSysInfo::AddStamp("IntegrateEphi", 130,0,0);
-
+
// Differentiate V(r) and solve for E(z) using special equations for the first and last row
// Integrate (E(z)-Ezstd) from point of origin to pad plane
-
+
for ( Int_t m = 0 ; m < phislices ; m++ ) {
TMatrixD& arrayV = *arrayofArrayV[m] ;
TMatrixD& deltaEz = *arrayofDeltaEz[m] ;
-
+
// Differentiate V(z) and solve for E(z) using special equations for the first and last columns
for ( Int_t i = 0 ; i < rows ; i++) {
for ( Int_t j = 1 ; j < columns-1 ; j++ ) arrayE(i,j) = -1 * ( arrayV(i,j+1) - arrayV(i,j-1) ) / (2*gridSizeZ) ;
- arrayE(i,0) = -1 * ( -0.5*arrayV(i,2) + 2.0*arrayV(i,1) - 1.5*arrayV(i,0) ) / gridSizeZ ;
- arrayE(i,columns-1) = -1 * ( 1.5*arrayV(i,columns-1) - 2.0*arrayV(i,columns-2) + 0.5*arrayV(i,columns-3) ) / gridSizeZ ;
+ arrayE(i,0) = -1 * ( -0.5*arrayV(i,2) + 2.0*arrayV(i,1) - 1.5*arrayV(i,0) ) / gridSizeZ ;
+ arrayE(i,columns-1) = -1 * ( 1.5*arrayV(i,columns-1) - 2.0*arrayV(i,columns-2) + 0.5*arrayV(i,columns-3) ) / gridSizeZ ;
}
-
+
for ( Int_t j = columns-1 ; j >= 0 ; j-- ) { // Count backwards to facilitate integration over Z
// Integrate over Z
for ( Int_t i = 0 ; i < rows ; i++ ) {
- Int_t index = 1 ; // Simpsons rule if N=odd. If N!=odd then add extra point by trapezoidal rule.
+ Int_t index = 1 ; // Simpsons rule if N=odd. If N!=odd then add extra point by trapezoidal rule.
deltaEz(i,j) = 0.0 ;
for ( Int_t k = j ; k < columns ; k++ ) {
deltaEz(i,j) += index*(gridSizeZ/3.0)*arrayE(i,k) ;
if ( index != 4 ) index = 4; else index = 2 ;
}
if ( index == 4 ) deltaEz(i,j) -= (gridSizeZ/3.0)*arrayE(i,columns-1) ;
- if ( index == 2 ) deltaEz(i,j) +=
+ if ( index == 2 ) deltaEz(i,j) +=
(gridSizeZ/3.0)*(0.5*arrayE(i,columns-2)-2.5*arrayE(i,columns-1)) ;
- if ( j == columns-2 ) deltaEz(i,j) =
+ if ( j == columns-2 ) deltaEz(i,j) =
(gridSizeZ/3.0)*(1.5*arrayE(i,columns-2)+1.5*arrayE(i,columns-1)) ;
if ( j == columns-1 ) deltaEz(i,j) = 0.0 ;
}
// if ( m == 0 ) { TCanvas* c1 = new TCanvas("erOverEz","erOverEz",50,50,840,600) ; c1 -> cd() ;
// eroverEz.Draw("surf") ; } // JT test
-
+
// calculate z distortion from the integrated Delta Ez residuals
// and include the aquivalence (Volt to cm) of the ROC shift !!
-
- for ( Int_t j = 0 ; j < columns ; j++ ) {
+
+ for ( Int_t j = 0 ; j < columns ; j++ ) {
for ( Int_t i = 0 ; i < rows ; i++ ) {
-
+
// Scale the Ez distortions with the drift velocity pertubation -> delivers cm
deltaEz(i,j) = deltaEz(i,j)*fgkdvdE;
-
+
// ROC Potential in cm aquivalent
- Double_t dzROCShift = arrayV(i, columns -1)/ezField;
+ Double_t dzROCShift = arrayV(i, columns -1)/ezField;
if ( rocDisplacement ) deltaEz(i,j) = deltaEz(i,j) + dzROCShift; // add the ROC misaligment
-
+
}
}
- } // end loop over phi
+ } // end loop over phi
AliSysInfo::AddStamp("IntegrateEz", 140,0,0);
-
+
for ( Int_t k = 0 ; k < phislices ; k++ )
{
arrayofSumChargeDensities[k]->Delete() ;
}
-
+
arrayE.Clear();
Int_t AliTPCCorrection::IsPowerOfTwo(Int_t i) const {
- //
- // Helperfunction: Check if integer is a power of 2
- //
+ /// Helperfunction: Check if integer is a power of 2
+
Int_t j = 0;
while( i > 0 ) { j += (i&1) ; i = (i>>1) ; }
if ( j == 1 ) return(1) ; // True
AliExternalTrackParam * AliTPCCorrection::FitDistortedTrack(AliExternalTrackParam & trackIn, Double_t refX, Int_t dir, TTreeSRedirector * const pcstream){
- //
- // Fit the track parameters - without and with distortion
- // 1. Space points in the TPC are simulated along the trajectory
- // 2. Space points distorted
- // 3. Fits the non distorted and distroted track to the reference plane at refX
- // 4. For visualization and debugging purposes the space points and tracks can be stored in the tree - using the TTreeSRedirector functionality
- //
- // trackIn - input track parameters
- // refX - reference X to fit the track
- // dir - direction - out=1 or in=-1
- // pcstream - debug streamer to check the results
- //
- // see AliExternalTrackParam.h documentation:
- // track1.fP[0] - local y (rphi)
- // track1.fP[1] - z
- // track1.fP[2] - sinus of local inclination angle
- // track1.fP[3] - tangent of deep angle
- // track1.fP[4] - 1/pt
+ /// Fit the track parameters - without and with distortion
+ /// 1. Space points in the TPC are simulated along the trajectory
+ /// 2. Space points distorted
+ /// 3. Fits the non distorted and distroted track to the reference plane at refX
+ /// 4. For visualization and debugging purposes the space points and tracks can be stored in the tree - using the TTreeSRedirector functionality
+ ///
+ /// trackIn - input track parameters
+ /// refX - reference X to fit the track
+ /// dir - direction - out=1 or in=-1
+ /// pcstream - debug streamer to check the results
+ ///
+ /// see AliExternalTrackParam.h documentation:
+ /// track1.fP[0] - local y (rphi)
+ /// track1.fP[1] - z
+ /// track1.fP[2] - sinus of local inclination angle
+ /// track1.fP[3] - tangent of deep angle
+ /// track1.fP[4] - 1/pt
AliTPCROC * roc = AliTPCROC::Instance();
const Int_t npoints0=roc->GetNRows(0)+roc->GetNRows(36);
const Double_t kRTPC0 =roc->GetPadRowRadii(0,0);
const Double_t kRTPC1 =roc->GetPadRowRadii(36,roc->GetNRows(36)-1);
- const Double_t kMaxSnp = 0.85;
+ const Double_t kMaxSnp = 0.85;
const Double_t kSigmaY=0.1;
const Double_t kSigmaZ=0.1;
const Double_t kMaxR=500;
const Double_t kMaxZ=500;
-
+
const Double_t kMaxZ0=220;
const Double_t kZcut=3;
const Double_t kMass = TDatabasePDG::Instance()->GetParticle("pi+")->Mass();
Int_t npoints1=0;
Int_t npoints2=0;
- AliExternalTrackParam track(trackIn); //
+ AliExternalTrackParam track(trackIn); //
// generate points
AliTrackPointArray pointArray0(npoints0);
AliTrackPointArray pointArray1(npoints0);
if (TMath::Abs(track.GetZ())>kMaxZ0) continue;
if (TMath::Abs(track.GetX())<kRTPC0) continue;
if (TMath::Abs(track.GetX())>kRTPC1) continue;
- AliTrackPoint pIn0; // space point
+ AliTrackPoint pIn0; // space point
AliTrackPoint pIn1;
Int_t sector= (xyz[2]>0)? 0:18;
pointArray0.GetPoint(pIn0,npoints);
prot1.SetXYZ(prot1.GetX(),prot1.GetY(), prot1.GetZ(),covPoint);
pIn0=prot0.Rotate(-alpha); // rotate back to global frame
pIn1=prot1.Rotate(-alpha); // rotate back to global frame
- pointArray0.AddPoint(npoints, &pIn0);
+ pointArray0.AddPoint(npoints, &pIn0);
pointArray1.AddPoint(npoints, &pIn1);
npoints++;
if (npoints>=npoints0) break;
pointArray0.GetPoint(point1,npoints-21);
pointArray0.GetPoint(point2,npoints-11);
pointArray0.GetPoint(point3,npoints-1);
- }
+ }
if ((TMath::Abs(point1.GetX()-point3.GetX())+TMath::Abs(point1.GetY()-point3.GetY()))<10){
printf("fit points not properly initialized\n");
return 0;
track0->ResetCovariance(10);
track1->ResetCovariance(10);
if (TMath::Abs(AliTrackerBase::GetBz())<0.01){
- ((Double_t*)track0->GetParameter())[4]= trackIn.GetParameter()[4];
+ ((Double_t*)track0->GetParameter())[4]= trackIn.GetParameter()[4];
((Double_t*)track1->GetParameter())[4]= trackIn.GetParameter()[4];
}
for (Int_t jpoint=0; jpoint<npoints; jpoint++){
pointCov[2]=prot0.GetCov()[5];//sigmaz^2
if (!track0->Update(pointPos,pointCov)) break;
//
- Double_t deltaX=prot1.GetX()-prot0.GetX(); // delta X
+ Double_t deltaX=prot1.GetX()-prot0.GetX(); // delta X
Double_t deltaYX=deltaX*TMath::Tan(TMath::ASin(track1->GetSnp())); // deltaY due delta X
Double_t deltaZX=deltaX*track1->GetTgl(); // deltaZ due delta X
TTree* AliTPCCorrection::CreateDistortionTree(Double_t step){
- //
- // create the distortion tree on a mesh with granularity given by step
- // return the tree with distortions at given position
- // Map is created on the mesh with given step size
- //
+ /// create the distortion tree on a mesh with granularity given by step
+ /// return the tree with distortions at given position
+ /// Map is created on the mesh with given step size
+
TTreeSRedirector *pcstream = new TTreeSRedirector(Form("correction%s.root",GetName()));
Float_t xyz[3];
for (Double_t x= -250; x<250; x+=step){
for (Double_t y= -250; y<250; y+=step){
Double_t r = TMath::Sqrt(x*x+y*y);
if (r<80) continue;
- if (r>250) continue;
+ if (r>250) continue;
for (Double_t z= -250; z<250; z+=step){
Int_t roc=(z>0)?0:18;
xyz[0]=x;
Double_t dr=r1-r;
Double_t drphi=(phi1-phi)*r;
(*pcstream)<<"distortion"<<
- "x="<<x<< // original position
+ "x="<<x<< // original position
"y="<<y<<
"z="<<z<<
"r="<<r<<
- "phi="<<phi<<
+ "phi="<<phi<<
"x1="<<xyz[0]<< // distorted position
"y1="<<xyz[1]<<
"z1="<<xyz[2]<<
"drphi="<<drphi<<
"\n";
}
- }
+ }
}
delete pcstream;
TFile f(Form("correction%s.root",GetName()));
void AliTPCCorrection::MakeTrackDistortionTree(TTree *tinput, Int_t dtype, Int_t ptype, const TObjArray * corrArray, Int_t step, Int_t offset, Bool_t debug ){
- //
- // Make a fit tree:
- // For each partial correction (specified in array) and given track topology (phi, theta, snp, refX)
- // calculates partial distortions
- // Partial distortion is stored in the resulting tree
- // Output is storred in the file distortion_<dettype>_<partype>.root
- // Partial distortion is stored with the name given by correction name
- //
- //
- // Parameters of function:
- // input - input tree
- // dtype - distortion type 0 - ITSTPC, 1 -TPCTRD, 2 - TPCvertex , 3 - TPC-TOF, 4 - TPCTPC track crossing
- // ppype - parameter type
- // corrArray - array with partial corrections
- // step - skipe entries - if 1 all entries processed - it is slow
- // debug 0 if debug on also space points dumped - it is slow
-
- const Double_t kMaxSnp = 0.85;
+ /// Make a fit tree:
+ /// For each partial correction (specified in array) and given track topology (phi, theta, snp, refX)
+ /// calculates partial distortions
+ /// Partial distortion is stored in the resulting tree
+ /// Output is storred in the file distortion_<dettype>_<partype>.root
+ /// Partial distortion is stored with the name given by correction name
+ ///
+ /// Parameters of function:
+ /// input - input tree
+ /// dtype - distortion type 0 - ITSTPC, 1 -TPCTRD, 2 - TPCvertex , 3 - TPC-TOF, 4 - TPCTPC track crossing
+ /// ppype - parameter type
+ /// corrArray - array with partial corrections
+ /// step - skipe entries - if 1 all entries processed - it is slow
+ /// debug 0 if debug on also space points dumped - it is slow
+
+ const Double_t kMaxSnp = 0.85;
const Double_t kcutSnp=0.25;
const Double_t kcutTheta=1.;
const Double_t kRadiusTPC=85;
- // AliTPCROC *tpcRoc =AliTPCROC::Instance();
+ // AliTPCROC *tpcRoc =AliTPCROC::Instance();
//
const Double_t kMass = TDatabasePDG::Instance()->GetParticle("pi+")->Mass();
// const Double_t kB2C=-0.299792458e-3;
- const Int_t kMinEntries=20;
+ const Int_t kMinEntries=20;
Double_t phi,theta, snp, mean,rms, entries,sector,dsec;
- Float_t refX;
+ Float_t refX;
Int_t run;
tinput->SetBranchAddress("run",&run);
tinput->SetBranchAddress("theta",&theta);
Double_t bz=AliTrackerBase::GetBz();
if (dtype !=4) { //exclude TPC - for TPC mainly non primary tracks
if (dtype!=2 && TMath::Abs(bz)>0.1 ) tPar[4]=snp/(refX*bz*kB2C*2);
-
+
if (dtype==2 && TMath::Abs(bz)>0.1 ) {
tPar[4]=snp/(kRadiusTPC*bz*kB2C*2);//
// snp at the TPC inner radius in case the vertex match used
"dtype="<<dtype<< // detector match type
"ptype="<<ptype<< // parameter type
"theta="<<theta<< // theta
- "phi="<<phi<< // phi
+ "phi="<<phi<< // phi
"snp="<<snp<< // snp
"mean="<<mean<< // mean dist value
"rms="<<rms<< // rms
"refX="<<refXD<< // referece X as double
"gx="<<xyz[0]<< // global position at reference
"gy="<<xyz[1]<< // global position at reference
- "gz="<<xyz[2]<< // global position at reference
+ "gz="<<xyz[2]<< // global position at reference
"dRrec="<<dRrec<< // delta Radius in reconstruction
"pt="<<pt<< // pt
"id="<<id<< // track id
if (!trackOut->Rotate(trackIn.GetAlpha())) isOK=kFALSE;
if (!AliTrackerBase::PropagateTrackTo(trackOut,trackIn.GetX(),kMass,5,kFALSE,kMaxSnp)) isOK=kFALSE;
// trackOut->PropagateTo(trackIn.GetX(),AliTrackerBase::GetBz());
- //
+ //
corrections[icorr]= trackOut->GetParameter()[ptype]-trackIn.GetParameter()[ptype];
- delete trackOut;
+ delete trackOut;
}else{
corrections[icorr]=0;
isOK=kFALSE;
}
//if (ptype==4 &&bz<0) corrections[icorr]*=-1; // interpret as curvature - commented out
- }
+ }
(*pcstream)<<"fit"<<
Form("%s=",corr->GetName())<<corrections[icorr]; // dump correction value
}
-
+
if (dtype==4) for (Int_t icorr=0; icorr<ncorr; icorr++) {
//
// special case of the TPC tracks crossing the CE
corrections[icorr]=0;
if (entries>kMinEntries){
AliExternalTrackParam trackIn0(refX,phi,tPar,cov); //Outer - direction to vertex
- AliExternalTrackParam trackIn1(refX,phi,tPar,cov); //Inner - direction magnet
+ AliExternalTrackParam trackIn1(refX,phi,tPar,cov); //Inner - direction magnet
AliExternalTrackParam *trackOut0 = 0;
AliExternalTrackParam *trackOut1 = 0;
//
if (!AliTrackerBase::PropagateTrackTo(&trackIn1,refX,kMass,5,kTRUE,kMaxSnp)) isOK=kFALSE;
if (!trackIn1.Rotate(trackIn0.GetAlpha())) isOK=kFALSE;
if (!AliTrackerBase::PropagateTrackTo(&trackIn1,trackIn0.GetX(),kMass,1,kFALSE,kMaxSnp)) isOK=kFALSE;
- if (!trackOut1->Rotate(trackIn1.GetAlpha())) isOK=kFALSE;
+ if (!trackOut1->Rotate(trackIn1.GetAlpha())) isOK=kFALSE;
if (!AliTrackerBase::PropagateTrackTo(trackOut1,trackIn1.GetX(),kMass,5,kFALSE,kMaxSnp)) isOK=kFALSE;
//
corrections[icorr] = (trackOut0->GetParameter()[ptype]-trackIn0.GetParameter()[ptype]);
(TMath::Abs(trackIn0.GetSnp()-trackIn1.GetSnp())>0.0001)
){
isOK=kFALSE;
- }
- delete trackOut0;
- delete trackOut1;
+ }
+ delete trackOut0;
+ delete trackOut1;
}else{
corrections[icorr]=0;
isOK=kFALSE;
}
//
//if (ptype==4 &&bz<0) corrections[icorr]*=-1; // interpret as curvature - commented out no in lookup
- }
+ }
(*pcstream)<<"fit"<<
Form("%s=",corr->GetName())<<corrections[icorr]; // dump correction value
}
void AliTPCCorrection::MakeSectorDistortionTree(TTree *tinput, Int_t dtype, Int_t ptype, const TObjArray * corrArray, Int_t step, Int_t offset, Bool_t debug ){
- //
- // Make a fit tree:
- // For each partial correction (specified in array) and given track topology (phi, theta, snp, refX)
- // calculates partial distortions
- // Partial distortion is stored in the resulting tree
- // Output is storred in the file distortion_<dettype>_<partype>.root
- // Partial distortion is stored with the name given by correction name
- //
- //
- // Parameters of function:
- // input - input tree
- // dtype - distortion type 10 - IROC-OROC
- // ppype - parameter type
- // corrArray - array with partial corrections
- // step - skipe entries - if 1 all entries processed - it is slow
- // debug 0 if debug on also space points dumped - it is slow
-
- const Double_t kMaxSnp = 0.8;
- const Int_t kMinEntries=200;
- // AliTPCROC *tpcRoc =AliTPCROC::Instance();
+ /// Make a fit tree:
+ /// For each partial correction (specified in array) and given track topology (phi, theta, snp, refX)
+ /// calculates partial distortions
+ /// Partial distortion is stored in the resulting tree
+ /// Output is storred in the file distortion_<dettype>_<partype>.root
+ /// Partial distortion is stored with the name given by correction name
+ ///
+ /// Parameters of function:
+ /// input - input tree
+ /// dtype - distortion type 10 - IROC-OROC
+ /// ppype - parameter type
+ /// corrArray - array with partial corrections
+ /// step - skipe entries - if 1 all entries processed - it is slow
+ /// debug 0 if debug on also space points dumped - it is slow
+
+ const Double_t kMaxSnp = 0.8;
+ const Int_t kMinEntries=200;
+ // AliTPCROC *tpcRoc =AliTPCROC::Instance();
//
const Double_t kMass = TDatabasePDG::Instance()->GetParticle("pi+")->Mass();
// const Double_t kB2C=-0.299792458e-3;
//
printf("%f\t%f\t%f\t%f\t%f\t%f\n",entries, sector,theta,snp, mean,rms);
Double_t bz=AliTrackerBase::GetBz();
- AliExternalTrackParam track(refX,phi,tPar,cov);
+ AliExternalTrackParam track(refX,phi,tPar,cov);
Double_t xyz[3],xyzIn[3],xyzOut[3];
track.GetXYZ(xyz);
- track.GetXYZAt(85,bz,xyzIn);
- track.GetXYZAt(245,bz,xyzOut);
+ track.GetXYZAt(85,bz,xyzIn);
+ track.GetXYZAt(245,bz,xyzOut);
Double_t phiIn = TMath::ATan2(xyzIn[1],xyzIn[0]);
Double_t phiOut = TMath::ATan2(xyzOut[1],xyzOut[0]);
Double_t phiRef = TMath::ATan2(xyz[1],xyz[0]);
Int_t sectorIn = TMath::Nint(9.*phiIn/TMath::Pi()-0.5);
Int_t sectorOut = TMath::Nint(9.*phiOut/TMath::Pi()-0.5);
//
- Bool_t isOK=kTRUE;
+ Bool_t isOK=kTRUE;
if (sectorIn!=sectorOut) isOK=kFALSE; // requironment - cluster in the same sector
if (sectorIn!=sectorRef) isOK=kFALSE; // requironment - cluster in the same sector
if (entries<kMinEntries/(1+TMath::Abs(globalZ/100.))) isOK=kFALSE; // requironment - minimal amount of tracks in bin
"dtype="<<dtype<< // detector match type
"ptype="<<ptype<< // parameter type
"theta="<<theta<< // theta
- "phi="<<phi<< // phi
+ "phi="<<phi<< // phi
"snp="<<snp<< // snp
"mean="<<mean<< // mean dist value
"rms="<<rms<< // rms
"refX="<<refXD<< // referece X
"gx="<<xyz[0]<< // global position at reference
"gy="<<xyz[1]<< // global position at reference
- "gz="<<xyz[2]<< // global position at reference
+ "gz="<<xyz[2]<< // global position at reference
"dRrec="<<dRrec<< // delta Radius in reconstruction
"pt="<<pt<< //pt
"id="<<id<< // track id
// rotate all tracks to the same frame
if (!trackOut0->Rotate(trackIn0.GetAlpha())) isOK=kFALSE;
if (!trackIn1.Rotate(trackIn0.GetAlpha())) isOK=kFALSE;
- if (!trackOut1->Rotate(trackIn0.GetAlpha())) isOK=kFALSE;
+ if (!trackOut1->Rotate(trackIn0.GetAlpha())) isOK=kFALSE;
//
if (!AliTrackerBase::PropagateTrackTo(trackOut0,refX,kMass,1,kFALSE,kMaxSnp)) isOK=kFALSE;
if (!AliTrackerBase::PropagateTrackTo(&trackIn1,refX,kMass,1,kFALSE,kMaxSnp)) isOK=kFALSE;
"pOut1.="<<trackOut1<<
"refX="<<refXD<<
"\n";
- delete trackOut0;
- delete trackOut1;
+ delete trackOut0;
+ delete trackOut1;
}else{
corrections[icorr]=0;
isOK=kFALSE;
}
- }
+ }
(*pcstream)<<"fit"<<
Form("%s=",corr->GetName())<<corrections[icorr]; // dump correction value
}
void AliTPCCorrection::MakeLaserDistortionTreeOld(TTree* tree, TObjArray *corrArray, Int_t itype){
- //
- // Make a laser fit tree for global minimization
- //
+ /// Make a laser fit tree for global minimization
+
const Double_t cutErrY=0.1;
const Double_t cutErrZ=0.1;
const Double_t kEpsilon=0.00000001;
Int_t entries= tree->GetEntries();
TTreeSRedirector *pcstream= new TTreeSRedirector("distortionLaser_0.root");
Double_t bz=AliTrackerBase::GetBz();
- //
+ //
for (Int_t ientry=0; ientry<entries; ientry++){
tree->GetEntry(ientry);
array[counter]=(*delta)[jrow];
counter++;
}
- }
+ }
Double_t rms3 = 0;
Double_t mean3 = 0;
if (counter>2){
gz = (*ltr->GetVecGZ())[irow];
//
// get delta R used in reconstruction
- AliTPCcalibDB* calib=AliTPCcalibDB::Instance();
+ AliTPCcalibDB* calib=AliTPCcalibDB::Instance();
AliTPCCorrection * correction = calib->GetTPCComposedCorrection(AliTrackerBase::GetBz());
// const AliTPCRecoParam * recoParam = calib->GetTransform()->GetCurrentRecoParam();
//Double_t xyz0[3]={gx,gy,gz};
Double_t oldR=TMath::Sqrt(gx*gx+gy*gy);
- Double_t fphi = TMath::ATan2(gy,gx);
+ Double_t fphi = TMath::ATan2(gy,gx);
Double_t fsector = 9.*fphi/TMath::Pi();
if (fsector<0) fsector+=18;
Double_t dsec = fsector-Int_t(fsector)-0.5;
correction->CorrectPoint(xyz1, sector);
refX=TMath::Sqrt(xyz1[0]*xyz1[0]+xyz1[1]*xyz1[1]);
dRrec=oldR-refX;
- }
+ }
if (TMath::Abs(rms3)>kMaxRMS) isOK=kFALSE;
if (TMath::Abs(mean-mean3)>kMaxRMS) isOK=kFALSE;
- if (counter<4) isOK=kFALSE;
- if (npoints<90) isOK=kFALSE;
+ if (counter<4) isOK=kFALSE;
+ if (npoints<90) isOK=kFALSE;
if (isOK){
fitter.AddPoint(&refX,mean);
}
"dtype="<<dtype<< // detector match type
"ptype="<<itype<< // parameter type
"theta="<<theta<< // theta
- "phi="<<phi<< // phi
+ "phi="<<phi<< // phi
"snp="<<snp<< // snp
"mean="<<mean3<< // mean dist value
"rms="<<rms3<< // rms
"gy="<<gy<< // global position
"gz="<<gz<< // global position
"dRrec="<<dRrec<< // delta Radius in reconstruction
- "id="<<id<< //bundle
+ "id="<<id<< //bundle
"entries="<<nentries<<// number of entries in bin
"\n";
}
"dtype="<<dtype<< // detector match type
"ptype="<<itype<< // parameter type
"theta="<<theta<< // theta
- "phi="<<phi<< // phi
+ "phi="<<phi<< // phi
"snp="<<snp<< // snp
"mean="<<mean3<< // mean dist value
"rms="<<rms3<< // rms
"gz="<<gz<< // global position
"dRrec="<<dRrec<< // delta Radius in reconstruction
"pt="<<pt<< //pt
- "id="<<id<< //bundle
+ "id="<<id<< //bundle
"entries="<<nentries;// number of entries in bin
//
- //
+ //
Double_t ky = TMath::Tan(TMath::ASin(snp));
Int_t ncorr = corrArray->GetEntries();
Double_t r0 = TMath::Sqrt(gx*gx+gy*gy);
if (iter==1){
for (Int_t icorr=0; icorr<ncorr; icorr++) {
AliTPCCorrection *corr = (AliTPCCorrection*)corrArray->At(icorr);
- Float_t distPoint[3]={static_cast<Float_t>(gx),static_cast<Float_t>(gy),static_cast<Float_t>(gz)};
+ Float_t distPoint[3]={static_cast<Float_t>(gx),static_cast<Float_t>(gy),static_cast<Float_t>(gz)};
Int_t sector= (gz>0)? 0:18;
if (r0>80){
corr->DistortPoint(distPoint, sector);
void AliTPCCorrection::MakeDistortionMap(THnSparse * his0, TTreeSRedirector * const pcstream, const char* hname, Int_t run, Float_t refX, Int_t type, Int_t integ){
- //
- // make a distortion map out ou fthe residual histogram
- // Results are written to the debug streamer - pcstream
- // Parameters:
- // his0 - input (4D) residual histogram
- // pcstream - file to write the tree
- // run - run number
- // refX - track matching reference X
- // type - 0- y 1-z,2 -snp, 3-theta, 4=1/pt
- // THnSparse axes:
- // OBJ: TAxis #Delta #Delta
- // OBJ: TAxis tanTheta tan(#Theta)
- // OBJ: TAxis phi #phi
- // OBJ: TAxis snp snp
+ /// make a distortion map out ou fthe residual histogram
+ /// Results are written to the debug streamer - pcstream
+ /// Parameters:
+ /// his0 - input (4D) residual histogram
+ /// pcstream - file to write the tree
+ /// run - run number
+ /// refX - track matching reference X
+ /// type - 0- y 1-z,2 -snp, 3-theta, 4=1/pt
+ /// THnSparse axes:
+ /// OBJ: TAxis #Delta #Delta
+ /// OBJ: TAxis tanTheta tan(#Theta)
+ /// OBJ: TAxis phi #phi
+ /// OBJ: TAxis snp snp
// marian.ivanov@cern.ch
const Int_t kMinEntries=10;
Double_t entries = hisDelta->GetEntries();
Double_t mean=0, rms=0;
if (entries>kMinEntries){
- mean = hisDelta->GetMean();
- rms = hisDelta->GetRMS();
+ mean = hisDelta->GetMean();
+ rms = hisDelta->GetRMS();
}
Double_t sector = 9.*x2/TMath::Pi();
if (sector<0) sector+=18;
void AliTPCCorrection::MakeDistortionMapCosmic(THnSparse * hisInput, TTreeSRedirector * const pcstream, const char* hname, Int_t run, Float_t refX, Int_t type){
- //
- // make a distortion map out ou fthe residual histogram
- // Results are written to the debug streamer - pcstream
- // Parameters:
- // his0 - input (4D) residual histogram
- // pcstream - file to write the tree
- // run - run number
- // refX - track matching reference X
- // type - 0- y 1-z,2 -snp, 3-theta, 4=1/pt
- // marian.ivanov@cern.ch
- //
- // Histo axeses
- // Collection name='TObjArray', class='TObjArray', size=16
- // 0. OBJ: TAxis #Delta #Delta
- // 1. OBJ: TAxis N_{cl} N_{cl}
- // 2. OBJ: TAxis dca_{r} (cm) dca_{r} (cm)
- // 3. OBJ: TAxis z (cm) z (cm)
- // 4. OBJ: TAxis sin(#phi) sin(#phi)
- // 5. OBJ: TAxis tan(#theta) tan(#theta)
- // 6. OBJ: TAxis 1/pt (1/GeV) 1/pt (1/GeV)
- // 7. OBJ: TAxis pt (GeV) pt (GeV)
- // 8. OBJ: TAxis alpha alpha
+ /// make a distortion map out ou fthe residual histogram
+ /// Results are written to the debug streamer - pcstream
+ /// Parameters:
+ /// his0 - input (4D) residual histogram
+ /// pcstream - file to write the tree
+ /// run - run number
+ /// refX - track matching reference X
+ /// type - 0- y 1-z,2 -snp, 3-theta, 4=1/pt
+ /// marian.ivanov@cern.ch
+ ///
+ /// Histo axeses
+ /// Collection name='TObjArray', class='TObjArray', size=16
+ /// 0. OBJ: TAxis #Delta #Delta
+ /// 1. OBJ: TAxis N_{cl} N_{cl}
+ /// 2. OBJ: TAxis dca_{r} (cm) dca_{r} (cm)
+ /// 3. OBJ: TAxis z (cm) z (cm)
+ /// 4. OBJ: TAxis sin(#phi) sin(#phi)
+ /// 5. OBJ: TAxis tan(#theta) tan(#theta)
+ /// 6. OBJ: TAxis 1/pt (1/GeV) 1/pt (1/GeV)
+ /// 7. OBJ: TAxis pt (GeV) pt (GeV)
+ /// 8. OBJ: TAxis alpha alpha
+
const Int_t kMinEntries=10;
//
// 1. make default selections
//
for (Int_t ibin1=first1; ibin1<=last1; ibin1++){ //axis 1 - theta
//
- Double_t x1= his0->GetAxis(1)->GetBinCenter(ibin1);
+ Double_t x1= his0->GetAxis(1)->GetBinCenter(ibin1);
his0->GetAxis(1)->SetRange(TMath::Max(ibin1-1,1),TMath::Min(ibin1+1,nbins1));
//
THnSparse * his1 = his0->Projection(4,idim); // projected histogram according range1
Double_t entries = hisDelta->GetEntries();
Double_t mean=0, rms=0;
if (entries>kMinEntries){
- mean = hisDelta->GetMean();
- rms = hisDelta->GetRMS();
+ mean = hisDelta->GetMean();
+ rms = hisDelta->GetRMS();
}
Double_t sector = 9.*x2/TMath::Pi();
if (sector<0) sector+=18;
void AliTPCCorrection::MakeDistortionMapSector(THnSparse * hisInput, TTreeSRedirector * const pcstream, const char* hname, Int_t run, Int_t type){
- //
- // make a distortion map out of the residual histogram
- // Results are written to the debug streamer - pcstream
- // Parameters:
- // his0 - input (4D) residual histogram
- // pcstream - file to write the tree
- // run - run number
- // type - 0- y 1-z,2 -snp, 3-theta
- // marian.ivanov@cern.ch
+ /// make a distortion map out of the residual histogram
+ /// Results are written to the debug streamer - pcstream
+ /// Parameters:
+ /// his0 - input (4D) residual histogram
+ /// pcstream - file to write the tree
+ /// run - run number
+ /// type - 0- y 1-z,2 -snp, 3-theta
+ /// marian.ivanov@cern.ch
//Collection name='TObjArray', class='TObjArray', size=16
//0 OBJ: TAxis delta delta
// z - 7 ==> 3
// snp - 3 ==> 2
// theta- 4 ==> 1
- // 0 ==> 0;
+ // 0 ==> 0;
for (Int_t isec0=0; isec0<72; isec0++){
Int_t index0[9]={0, 4, 3, 7, 1, 2, 5, 6,8}; //regroup indeces
//
hisSector0=hisInput->Projection(7,index0);
//
//
- for (Int_t isec1=isec0+1; isec1<72; isec1++){
+ for (Int_t isec1=isec0+1; isec1<72; isec1++){
//if (isec1!=isec0+36) continue;
if ( TMath::Abs((isec0%18)-(isec1%18))>1.5 && TMath::Abs((isec0%18)-(isec1%18))<16.5) continue;
printf("Sectors %d\t%d\n",isec1,isec0);
- hisSector0->GetAxis(6)->SetRangeUser(isec1-0.1,isec1+0.1);
+ hisSector0->GetAxis(6)->SetRangeUser(isec1-0.1,isec1+0.1);
TH1 * hisX=hisSector0->Projection(5);
Double_t refX= hisX->GetMean();
delete hisX;
//
// Phi loop
//
- Double_t xPhi= hisSector1->GetAxis(4)->GetBinCenter(ibinPhi);
+ Double_t xPhi= hisSector1->GetAxis(4)->GetBinCenter(ibinPhi);
Double_t psec = (9*xPhi/TMath::Pi());
if (psec<0) psec+=18;
Bool_t isOK0=kFALSE;
//
hisPhi->GetAxis(3)->SetRange(TMath::Max(ibinZ,firstZ),TMath::Min(ibinZ,lastZ));
if (isec1!=isec0+36) {
- hisPhi->GetAxis(3)->SetRange(TMath::Max(ibinZ-1,firstZ),TMath::Min(ibinZ-1,lastZ));
+ hisPhi->GetAxis(3)->SetRange(TMath::Max(ibinZ-1,firstZ),TMath::Min(ibinZ-1,lastZ));
}
htemp = hisPhi->Projection(3);
Double_t xZ= htemp->GetMean();
delete htemp;
- THnSparse * hisZ= hisPhi->Projection(3,idim);
+ THnSparse * hisZ= hisPhi->Projection(3,idim);
//projected histogram according selection 3 -z
//
//
htemp = hisZ->Projection(2);
Double_t xSnp= htemp->GetMean();
delete htemp;
- THnSparse * hisSnp= hisZ->Projection(2,idim);
+ THnSparse * hisSnp= hisZ->Projection(2,idim);
//projected histogram according selection 2 - snp
-
+
//Int_t nbinsTheta = hisSnp->GetAxis(1)->GetNbins();
Int_t firstTheta = hisSnp->GetAxis(1)->GetFirst();
Int_t lastTheta = hisSnp->GetAxis(1)->GetLast();
//
for (Int_t ibinTheta=firstTheta; ibinTheta<=lastTheta; ibinTheta+=2){ // axis1 theta
-
-
+
+
hisSnp->GetAxis(1)->SetRange(TMath::Max(ibinTheta-2,firstTheta),TMath::Min(ibinTheta+2,lastTheta));
if (isec1!=isec0+36) {
- hisSnp->GetAxis(1)->SetRange(TMath::Max(ibinTheta-3,firstTheta),TMath::Min(ibinTheta+3,lastTheta));
+ hisSnp->GetAxis(1)->SetRange(TMath::Max(ibinTheta-3,firstTheta),TMath::Min(ibinTheta+3,lastTheta));
}
- htemp = hisSnp->Projection(1);
+ htemp = hisSnp->Projection(1);
Double_t xTheta=htemp->GetMean();
delete htemp;
hisDelta = hisSnp->Projection(0);
Double_t entries = hisDelta->GetEntries();
Double_t mean=0, rms=0;
if (entries>kMinEntries){
- mean = hisDelta->GetMean();
- rms = hisDelta->GetRMS();
+ mean = hisDelta->GetMean();
+ rms = hisDelta->GetRMS();
}
Double_t sector = 9.*xPhi/TMath::Pi();
if (sector<0) sector+=18;
"bz="<<bz<< // magnetic field
"ptype="<<type<< // parameter type
"dtype="<<dtype<< // parameter type
- "isec0="<<isec0<< // sector 0
- "isec1="<<isec1<< // sector 1
+ "isec0="<<isec0<< // sector 0
+ "isec1="<<isec1<< // sector 1
"sector="<<sector<< // sector as float
"dsec="<<dsec<< // delta sector
//
"theta="<<xTheta<< // theta
- "phi="<<xPhi<< // phi (alpha)
+ "phi="<<xPhi<< // phi (alpha)
"z="<<xZ<< // z
"snp="<<xSnp<< // snp
//
"entries="<<entries<< // entries in bin
"mean="<<mean<< // mean
- "rms="<<rms<< // rms
+ "rms="<<rms<< // rms
"refX="<<refX<< // track matching reference plane
"\n";
delete hisDelta;
}//ibinZ
delete hisPhi;
}//ibinPhi
- delete hisSector1;
+ delete hisSector1;
}//isec1
delete hisSector0;
}//isec0
void AliTPCCorrection::StoreInOCDB(Int_t startRun, Int_t endRun, const char *comment){
- //
- // Store object in the OCDB
- // By default the object is stored in the current directory
- // default comment consit of user name and the date
- //
+ /// Store object in the OCDB
+ /// By default the object is stored in the current directory
+ /// default comment consit of user name and the date
+
TString ocdbStorage="";
ocdbStorage+="local://"+gSystem->GetFromPipe("pwd")+"/OCDB";
AliCDBMetaData *metaData= new AliCDBMetaData();
void AliTPCCorrection::FastSimDistortedVertex(Double_t orgVertex[3], Int_t nTracks, AliESDVertex &aV, AliESDVertex &avOrg, AliESDVertex &cV, AliESDVertex &cvOrg, TTreeSRedirector * const pcstream, Double_t etaCuts){
- //
- // Fast method to simulate the influence of the given distortion on the vertex reconstruction
- //
+ /// Fast method to simulate the influence of the given distortion on the vertex reconstruction
AliMagF* magF= (AliMagF*)TGeoGlobalMagField::Instance()->GetField();
if (!magF) AliError("Magneticd field - not initialized");
TObjArray aTrk; // Original Track array of Aside
TObjArray daTrk; // Distorted Track array of A side
UShort_t *aId = new UShort_t[nTracks]; // A side Track ID
- TObjArray cTrk;
+ TObjArray cTrk;
TObjArray dcTrk;
UShort_t *cId = new UShort_t [nTracks];
- Int_t id=0;
+ Int_t id=0;
Double_t mass = TDatabasePDG::Instance()->GetParticle("pi+")->Mass();
TF1 fpt("fpt",Form("x*(1+(sqrt(x*x+%f^2)-%f)/([0]*[1]))^(-[0])",mass,mass),0.4,10);
fpt.SetParameters(7.24,0.120);
cId[nn]=id;
}
}
- id++;
+ id++;
}// end of track loop
vertexer->SetTPCMode();
vertexer->SetConstraintOff();
- aV = *((AliESDVertex*)vertexer->FindPrimaryVertex(&daTrk,aId));
+ aV = *((AliESDVertex*)vertexer->FindPrimaryVertex(&daTrk,aId));
avOrg = *((AliESDVertex*)vertexer->FindPrimaryVertex(&aTrk,aId));
- cV = *((AliESDVertex*)vertexer->FindPrimaryVertex(&dcTrk,cId));
+ cV = *((AliESDVertex*)vertexer->FindPrimaryVertex(&dcTrk,cId));
cvOrg = *((AliESDVertex*)vertexer->FindPrimaryVertex(&cTrk,cId));
if (pcstream) (*pcstream)<<"vertex"<<
"x="<<orgVertex[0]<<
}
void AliTPCCorrection::AddVisualCorrection(AliTPCCorrection* corr, Int_t position){
- //
- // make correction available for visualization using
- // TFormula, TFX and TTree::Draw
- // important in order to check corrections and also compute dervied variables
- // e.g correction partial derivatives
- //
- // NOTE - class is not owner of correction
- //
+ /// make correction available for visualization using
+ /// TFormula, TFX and TTree::Draw
+ /// important in order to check corrections and also compute dervied variables
+ /// e.g correction partial derivatives
+ ///
+ /// NOTE - class is not owner of correction
+
if (!fgVisualCorrection) fgVisualCorrection=new TObjArray(10000);
if (position>=fgVisualCorrection->GetEntriesFast())
fgVisualCorrection->Expand((position+10)*2);
fgVisualCorrection->AddAt(corr, position);
}
-AliTPCCorrection* AliTPCCorrection::GetVisualCorrection(Int_t position) {
- //
- // Get visula correction registered at index=position
- //
+AliTPCCorrection* AliTPCCorrection::GetVisualCorrection(Int_t position) {
+ /// Get visula correction registered at index=position
+
return fgVisualCorrection? (AliTPCCorrection*)fgVisualCorrection->At(position):0;
}
Double_t AliTPCCorrection::GetCorrSector(Double_t sector, Double_t r, Double_t kZ, Int_t axisType, Int_t corrType){
- //
- // calculate the correction at given position - check the geffCorr
- //
- // corrType return values
- // 0 - delta R
- // 1 - delta RPhi
- // 2 - delta Z
- // 3 - delta RPHI
- //
+ /// calculate the correction at given position - check the geffCorr
+ ///
+ /// corrType return values
+ /// 0 - delta R
+ /// 1 - delta RPhi
+ /// 2 - delta Z
+ /// 3 - delta RPHI
+
if (!fgVisualCorrection) return 0;
AliTPCCorrection *corr = (AliTPCCorrection*)fgVisualCorrection->At(corrType);
if (!corr) return 0;
Double_t gx = r*TMath::Cos(phi);
Double_t gy = r*TMath::Sin(phi);
Double_t gz = r*kZ;
- Int_t nsector=(gz>=0) ? 0:18;
+ Int_t nsector=(gz>=0) ? 0:18;
//
//
//
}
Double_t AliTPCCorrection::GetCorrXYZ(Double_t gx, Double_t gy, Double_t gz, Int_t axisType, Int_t corrType){
- //
- // return correction at given x,y,z
- //
+ /// return correction at given x,y,z
+
if (!fgVisualCorrection) return 0;
AliTPCCorrection *corr = (AliTPCCorrection*)fgVisualCorrection->At(corrType);
if (!corr) return 0;
Double_t phi0= TMath::ATan2(gy,gx);
- Int_t nsector=(gz>=0) ? 0:18;
+ Int_t nsector=(gz>=0) ? 0:18;
Float_t distPoint[3]={static_cast<Float_t>(gx),static_cast<Float_t>(gy),static_cast<Float_t>(gz)};
corr->CorrectPoint(distPoint, nsector);
Double_t r0=TMath::Sqrt(gx*gx+gy*gy);
}
Double_t AliTPCCorrection::GetCorrXYZDz(Double_t gx, Double_t gy, Double_t gz, Int_t axisType, Int_t corrType,Double_t delta){
- //
- // return correction at given x,y,z
- //
+ /// return correction at given x,y,z
+
if (!fgVisualCorrection) return 0;
AliTPCCorrection *corr = (AliTPCCorrection*)fgVisualCorrection->At(corrType);
if (!corr) return 0;
Double_t phi0= TMath::ATan2(gy,gx);
- Int_t nsector=(gz>=0) ? 0:18;
+ Int_t nsector=(gz>=0) ? 0:18;
Float_t distPoint[3]={static_cast<Float_t>(gx),static_cast<Float_t>(gy),static_cast<Float_t>(gz)};
Float_t dxyz[3]={static_cast<Float_t>(gx),static_cast<Float_t>(gy),static_cast<Float_t>(gz)};
//
}
Double_t AliTPCCorrection::GetCorrXYZIntegrateZ(Double_t gx, Double_t gy, Double_t gz, Int_t axisType, Int_t corrType,Double_t delta){
- //
- // return correction at given x,y,z
- //
+ /// return correction at given x,y,z
+
if (!fgVisualCorrection) return 0;
AliTPCCorrection *corr = (AliTPCCorrection*)fgVisualCorrection->At(corrType);
if (!corr) return 0;
Double_t phi0= TMath::ATan2(gy,gx);
- Int_t nsector=(gz>=0) ? 0:18;
+ Int_t nsector=(gz>=0) ? 0:18;
Float_t distPoint[3]={static_cast<Float_t>(gx),static_cast<Float_t>(gy),static_cast<Float_t>(gz)};
Float_t dxyz[3]={static_cast<Float_t>(gx),static_cast<Float_t>(gy),static_cast<Float_t>(gz)};
//
Double_t AliTPCCorrection::GetDistXYZ(Double_t gx, Double_t gy, Double_t gz, Int_t axisType, Int_t corrType){
- //
- // return correction at given x,y,z
- //
+ /// return correction at given x,y,z
+
if (!fgVisualCorrection) return 0;
AliTPCCorrection *corr = (AliTPCCorrection*)fgVisualCorrection->At(corrType);
if (!corr) return 0;
}
Double_t AliTPCCorrection::GetDistXYZDz(Double_t gx, Double_t gy, Double_t gz, Int_t axisType, Int_t corrType,Double_t delta){
- //
- // return correction at given x,y,z
- //
+ /// return correction at given x,y,z
+
if (!fgVisualCorrection) return 0;
AliTPCCorrection *corr = (AliTPCCorrection*)fgVisualCorrection->At(corrType);
if (!corr) return 0;
}
Double_t AliTPCCorrection::GetDistXYZIntegrateZ(Double_t gx, Double_t gy, Double_t gz, Int_t axisType, Int_t corrType,Double_t delta){
- //
- // return correction at given x,y,z
- //
+ /// return correction at given x,y,z
+
if (!fgVisualCorrection) return 0;
AliTPCCorrection *corr = (AliTPCCorrection*)fgVisualCorrection->At(corrType);
if (!corr) return 0;
void AliTPCCorrection::MakeLaserDistortionTree(TTree* tree, TObjArray */*corrArray*/, Int_t /*itype*/){
- //
- // Make a laser fit tree for global minimization
- //
- AliTPCcalibDB* calib=AliTPCcalibDB::Instance();
- AliTPCCorrection * correction = calib->GetTPCComposedCorrection();
- if (!correction) correction = calib->GetTPCComposedCorrection(AliTrackerBase::GetBz());
+ /// Make a laser fit tree for global minimization
+
+ AliTPCcalibDB* calib=AliTPCcalibDB::Instance();
+ AliTPCCorrection * correction = calib->GetTPCComposedCorrection();
+ if (!correction) correction = calib->GetTPCComposedCorrection(AliTrackerBase::GetBz());
correction->AddVisualCorrection(correction,0); //register correction
// AliTPCTransform *transform = AliTPCcalibDB::Instance()->GetTransform() ;
Int_t entries= tree->GetEntries();
TTreeSRedirector *pcstream= new TTreeSRedirector("distortionLaser_0.root");
Double_t bz=AliTrackerBase::GetBz();
- //
+ //
// Double_t globalXYZ[3];
//Double_t globalXYZCorr[3];
for (Int_t ientry=0; ientry<entries; ientry++){
TVectorD fit5(5);
printf("Entry\t%d\n",ientry);
for (Int_t irow0=0; irow0<158; irow0+=1){
- //
+ //
TLinearFitter fitter10(4,"hyp3");
TLinearFitter fitter5(2,"hyp1");
Int_t sector= (Int_t)(*ltr->GetVecSec())[irow0];
Double_t mean10 =0;// fitter10.GetParameter(0);
Double_t slope10 =0;// fitter10.GetParameter(0);
Double_t cosPart10 = 0;// fitter10.GetParameter(2);
- Double_t sinPart10 =0;// fitter10.GetParameter(3);
+ Double_t sinPart10 =0;// fitter10.GetParameter(3);
if (fitter10.GetNpoints()>10){
fitter10.Eval();
mean10 = fitter10.GetParameter(0);
slope10 = fitter10.GetParameter(1);
cosPart10 = fitter10.GetParameter(2);
- sinPart10 = fitter10.GetParameter(3);
+ sinPart10 = fitter10.GetParameter(3);
//
// make short range fit
//
Double_t gz= (*ltr->GetVecGZ())[irow1];
Double_t measY=(*vecdY)[irow1]+idealY;
Double_t deltaR = GetCorrXYZ(gx, gy, gz, 0,0);
- // deltaR = R distorted -R ideal
+ // deltaR = R distorted -R ideal
Double_t expY= mean10+slope10*(idealX+deltaR-refX);
if (TMath::Abs(measY-expY)>kSigmaCut*rms10) continue;
//
Double_t corr=cosPart10*TMath::Cos(idealY/padWidth)+sinPart10*TMath::Sin(idealY/padWidth);
Double_t xxx[4]={idealX+deltaR-refX,TMath::Cos(idealY/padWidth), TMath::Sin(idealY/padWidth)};
fitter5.AddPoint(xxx,measY-corr,1);
- }
+ }
}else{
isOK=kFALSE;
}
Double_t rms5=0;//TMath::Sqrt(fitter5.GetChisquare()/(fitter5.GetNpoints()-4));
Double_t offset5 =0;// fitter5.GetParameter(0);
- Double_t slope5 =0;// fitter5.GetParameter(0);
+ Double_t slope5 =0;// fitter5.GetParameter(0);
if (isOK){
fitter5.Eval();
rms5=TMath::Sqrt(fitter5.GetChisquare()/(fitter5.GetNpoints()-4));
offset5 = fitter5.GetParameter(0);
- slope5 = fitter5.GetParameter(0);
+ slope5 = fitter5.GetParameter(0);
}
//
Double_t dtype=5;
gz = (*ltr->GetVecGZ())[irow0];
Double_t dRrec = GetCorrXYZ(gx, gy, gz, 0,0);
fitter10.GetParameters(fit10);
- fitter5.GetParameters(fit5);
+ fitter5.GetParameters(fit5);
Double_t idealY= (*ltr->GetVecLY())[irow0];
Double_t measY=(*vecdY)[irow0]+idealY;
Double_t corr=cosPart10*TMath::Cos(idealY/padWidth)+sinPart10*TMath::Sin(idealY/padWidth);
"dtype="<<dtype<< // detector match type
"ptype="<<ptype<< // parameter type
"theta="<<theta<< // theta
- "phi="<<phi<< // phi
+ "phi="<<phi<< // phi
"snp="<<snp<< // snp
"sector="<<sector<<
"bundle="<<bundle<<
* See cxx source for full Copyright notice */
-////////////////////////////////////////////////////////////////////////////////
-// AliTPCCorrection class //
-////////////////////////////////////////////////////////////////////////////////
+/// \class AliTPCCorrection
+/// \brief AliTPCCorrection class
#include <TNamed.h>
virtual void GetCorrectionDz(const Float_t x[], Short_t roc,Float_t dx[], Float_t delta);
virtual void GetCorrectionIntegralDz(const Float_t x[], Short_t roc,Float_t dx[], Float_t delta);
-
+
// functions to distort a space point
void DistortPoint ( Float_t x[], Short_t roc);
void DistortPointLocal(Float_t x[], Short_t roc);
virtual void GetDistortionDz(const Float_t x[], Short_t roc,Float_t dx[], Float_t delta);
virtual void GetDistortionIntegralDz(const Float_t x[], Short_t roc,Float_t dx[], Float_t delta);
-
+
// initialization and update functions
virtual void Init();
virtual void Update(const TTimeStamp &timeStamp);
// map scaling
virtual void SetCorrScaleFactor(Float_t /*val*/) { ; }
virtual Float_t GetCorrScaleFactor() const { return 1.; }
-
+
// convenience functions
virtual void Print(Option_t* option="") const;
-
+
TH2F* CreateHistoDRinXY (Float_t z=10.,Int_t nx=100,Int_t ny=100);
TH2F* CreateHistoDRPhiinXY(Float_t z=10.,Int_t nx=100,Int_t nphi=100);
TH2F* CreateHistoDZinXY (Float_t z=10.,Int_t nx=100,Int_t ny=100);
static AliTPCCorrection* GetVisualCorrection(Int_t position);
static AliTPCCorrection* GetVisualCorrection(const char *corName){return (fgVisualCorrection==NULL) ? 0: ( AliTPCCorrection*) fgVisualCorrection->FindObject(corName);}
static TObjArray* GetVisualCorrections() { return fgVisualCorrection;}
-
+
static Double_t GetCorrSector(Double_t sector, Double_t r, Double_t kZ, Int_t axisType, Int_t corrType=0);
static Double_t GetCorrXYZ(Double_t gx, Double_t gy, Double_t gz, Int_t axisType, Int_t corrType=0);
//
//
static Double_t GetDistXYZDz(Double_t gx, Double_t gy, Double_t gz, Int_t axisType, Int_t corrType=0,Double_t delta=5);
static Double_t GetDistXYZIntegrateZ(Double_t gx, Double_t gy, Double_t gz, Int_t axisType, Int_t corrType=0, Double_t delta=5);
-
+
protected:
TH2F* CreateTH2F(const char *name,const char *title,
const char *xlabel,const char *ylabel,const char *zlabel,
Int_t nbinsx,Double_t xlow,Double_t xup,
Int_t nbinsy,Double_t ylow,Double_t yup);
-
- static const Double_t fgkTPCZ0; // nominal gating grid position
- static const Double_t fgkIFCRadius; // Mean Radius of the Inner Field Cage ( 82.43 min, 83.70 max) (cm)
- static const Double_t fgkOFCRadius; // Mean Radius of the Outer Field Cage (252.55 min, 256.45 max) (cm)
- static const Double_t fgkZOffSet; // Offset from CE: calculate all distortions closer to CE as if at this point
- static const Double_t fgkCathodeV; // Cathode Voltage (volts)
- static const Double_t fgkGG; // Gating Grid voltage (volts)
- static const Double_t fgkdvdE; // [cm/V] drift velocity dependency on the E field (from Magboltz for NeCO2N2 at standard environment)
- static const Double_t fgkEM; // charge/mass in [C/kg]
- static const Double_t fgke0; // vacuum permittivity [A·s/(V·m)]
+
+ static const Double_t fgkTPCZ0; ///< nominal gating grid position
+ static const Double_t fgkIFCRadius; ///< Mean Radius of the Inner Field Cage ( 82.43 min, 83.70 max) (cm)
+ static const Double_t fgkOFCRadius; ///< Mean Radius of the Outer Field Cage (252.55 min, 256.45 max) (cm)
+ static const Double_t fgkZOffSet; ///< Offset from CE: calculate all distortions closer to CE as if at this point
+ static const Double_t fgkCathodeV; ///< Cathode Voltage (volts)
+ static const Double_t fgkGG; ///< Gating Grid voltage (volts)
+ static const Double_t fgkdvdE; ///< [cm/V] drift velocity dependency on the E field (from Magboltz for NeCO2N2 at standard environment)
+ static const Double_t fgkEM; ///< charge/mass in [C/kg]
+ static const Double_t fgke0; ///< vacuum permittivity [A·s/(V·m)]
enum {kNR= 72 }; // Number of R points in the table for interpolating distortion data
- enum {kNPhi= 18*10+1}; // Number of Phi points in the table for interpolating distortion data ( plus one extra for 360 == 0 )
+ enum {kNPhi= 18*10+1}; // Number of Phi points in the table for interpolating distortion data ( plus one extra for 360 == 0 )
enum {kNZ= 166}; // Number of Z points in the table for interpolating distortion data
- Double_t fgkRList[kNR]; // points in the radial direction (for the lookup table)
- Double_t fgkPhiList[kNPhi]; // points in the phi direction (for the lookup table)
- Double_t fgkZList[kNZ]; // points in the z direction (for the lookup table)
+ Double_t fgkRList[kNR]; ///< points in the radial direction (for the lookup table)
+ Double_t fgkPhiList[kNPhi]; ///< points in the phi direction (for the lookup table)
+ Double_t fgkZList[kNZ]; ///< points in the z direction (for the lookup table)
// Simple Interpolation functions: e.g. with tricubic interpolation (not yet in TH3)
- Int_t fILow, fJLow, fKLow; // variable to help in the interpolation
+ Int_t fILow, fJLow, fKLow; ///< variable to help in the interpolation
// Double_t versions
- void Interpolate2DEdistortion( Int_t order, Double_t r, Double_t z,
+ void Interpolate2DEdistortion( Int_t order, Double_t r, Double_t z,
const Double_t er[kNZ][kNR], Double_t &erValue );
- void Interpolate3DEdistortion( Int_t order, Double_t r, Float_t phi, Double_t z,
- const Double_t er[kNZ][kNPhi][kNR], const Double_t ephi[kNZ][kNPhi][kNR],
+ void Interpolate3DEdistortion( Int_t order, Double_t r, Float_t phi, Double_t z,
+ const Double_t er[kNZ][kNPhi][kNR], const Double_t ephi[kNZ][kNPhi][kNR],
const Double_t ez[kNZ][kNPhi][kNR],
Double_t &erValue, Double_t &ephiValue, Double_t &ezValue);
// TMatrixD versions (for e.g. Poisson relaxation)
- Double_t Interpolate2DTable( Int_t order, Double_t x, Double_t y,
- Int_t nx, Int_t ny, const Double_t xv[], const Double_t yv[],
+ Double_t Interpolate2DTable( Int_t order, Double_t x, Double_t y,
+ Int_t nx, Int_t ny, const Double_t xv[], const Double_t yv[],
const TMatrixD &array );
Double_t Interpolate3DTable( Int_t order, Double_t x, Double_t y, Double_t z,
Int_t nx, Int_t ny, Int_t nz,
const Double_t xv[], const Double_t yv[], const Double_t zv[],
TMatrixD **arrayofArrays );
- Double_t Interpolate( const Double_t xArray[], const Double_t yArray[],
+ Double_t Interpolate( const Double_t xArray[], const Double_t yArray[],
Int_t order, Double_t x );
void Search( Int_t n, const Double_t xArray[], Double_t x, Int_t &low );
-
+
// TMatrixF versions (smaller size, e.g. for final look up table)
- Float_t Interpolate2DTable( Int_t order, Double_t x, Double_t y,
- Int_t nx, Int_t ny, const Double_t xv[], const Double_t yv[],
+ Float_t Interpolate2DTable( Int_t order, Double_t x, Double_t y,
+ Int_t nx, Int_t ny, const Double_t xv[], const Double_t yv[],
const TMatrixF &array );
Float_t Interpolate3DTable( Int_t order, Double_t x, Double_t y, Double_t z,
Int_t nx, Int_t ny, Int_t nz,
const Double_t xv[], const Double_t yv[], const Double_t zv[],
- TMatrixF **arrayofArrays );
- Float_t Interpolate( const Double_t xArray[], const Float_t yArray[],
+ TMatrixF **arrayofArrays );
+ Float_t Interpolate( const Double_t xArray[], const Float_t yArray[],
Int_t order, Double_t x );
virtual Int_t IsPowerOfTwo ( Int_t i ) const ;
-
-
- // Algorithms to solve the laplace or poisson equation
- void PoissonRelaxation2D(TMatrixD &arrayV, TMatrixD &chargeDensity,
+
+
+ // Algorithms to solve the laplace or poisson equation
+ void PoissonRelaxation2D(TMatrixD &arrayV, TMatrixD &chargeDensity,
TMatrixD &arrayErOverEz, TMatrixD &arrayDeltaEz,
Int_t rows, Int_t columns, Int_t iterations,
Bool_t rocDisplacement = kTRUE);
- void PoissonRelaxation3D( TMatrixD **arrayofArrayV, TMatrixD **arrayofChargeDensities,
+ void PoissonRelaxation3D( TMatrixD **arrayofArrayV, TMatrixD **arrayofChargeDensities,
TMatrixD **arrayofEroverEz, TMatrixD **arrayofEPhioverEz, TMatrixD **arrayofEz,
- Int_t rows, Int_t columns, Int_t phislices,
+ Int_t rows, Int_t columns, Int_t phislices,
Float_t deltaphi, Int_t iterations, Int_t summetry,
- Bool_t rocDisplacement = kTRUE);
+ Bool_t rocDisplacement = kTRUE);
void SetIsLocal(Bool_t isLocal){fIsLocal=isLocal;}
Bool_t IsLocal() const { return fIsLocal;}
protected:
- Double_t fT1; // tensor term of wt - T1
- Double_t fT2; // tensor term of wt - T2
- Bool_t fIsLocal; // switch to indicate that the distortion is a local vector drphi/dz, dr/dz
- static TObjArray *fgVisualCorrection; // array of orrection for visualization
+ Double_t fT1; ///< tensor term of wt - T1
+ Double_t fT2; ///< tensor term of wt - T2
+ Bool_t fIsLocal; ///< switch to indicate that the distortion is a local vector drphi/dz, dr/dz
+ static TObjArray *fgVisualCorrection; ///< array of orrection for visualization
private:
AliTPCCorrection(const AliTPCCorrection &); // not implemented
AliTPCCorrection &operator=(const AliTPCCorrection &); // not implemented
void InitLookUpfulcrums(); // to initialize the grid of the look up table
+ /// \cond CLASSIMP
ClassDef(AliTPCCorrection,5);
+ /// \endcond
};
#endif
* provided "as is" without express or implied warranty. *
**************************************************************************/
-////////////////////////////////////////////////////////////////////////////
-// //
-// AliTPCCorrectionDrift class
-// linear drift corrections //
-//
-////////////////////////////////////////////////////////////////////////////
+/// \class AliTPCCorrectionDrift
+/// \brief Linear drift corrections
+
#include "AliMagF.h"
#include "TGeoGlobalMagField.h"
#include "AliTPCcalibDB.h"
#include "TMath.h"
#include "AliTPCROC.h"
#include "AliTPCCorrectionDrift.h"
+/// \cond CLASSIMP
ClassImp(AliTPCCorrectionDrift)
+/// \endcond
AliTPCCorrectionDrift::AliTPCCorrectionDrift()
: AliTPCCorrection("CorrectionDrift","CorrectionDrift") ,
}
AliTPCCorrectionDrift::~AliTPCCorrectionDrift() {
- //
- // default destructor
- //
+ /// default destructor
+
}
void AliTPCCorrectionDrift::Init() {
- //
- // Initialization funtion
- //
-
+ /// Initialization funtion
+
}
void AliTPCCorrectionDrift::Update(const TTimeStamp &/*timeStamp*/) {
- //
- // Update function
- //
+ /// Update function
}
void AliTPCCorrectionDrift::GetCorrection(const Float_t x[],const Short_t roc,Float_t dx[]) {
- //
- // Calculates the correction due conical shape
- //
+ /// Calculates the correction due conical shape
+
AliTPCROC * calROC = AliTPCROC::Instance();
//const Double_t kRTPC0 =calROC->GetPadRowRadii(0,0);
const Double_t kRTPC1 =calROC->GetPadRowRadii(36,calROC->GetNRows(36)-1);
void AliTPCCorrectionDrift::Print(const Option_t* option) const {
- //
- // Print function to check the settings (e.g. the twist in the X direction)
- //
- //
+ /// Print function to check the settings (e.g. the twist in the X direction)
TString opt = option; opt.ToLower();
printf("%s\t%s\n",GetName(),GetTitle());
-
+
if (opt.Contains("a")) { // Print all details
printf(" - T0A: %1.4f, T0C: %1.4f (cm)\n",fZ0Aside,fZ0Cside);
printf(" - Scale0: %1.4f, ScaleR: %1.4f \n",fVScale0,fVScaleR);
printf(" - ScaleX: %1.4f, ScaleY: %1.4f \n",fVScaleX,fVScaleY);
- }
-
-
+ }
+
+
}
/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
* See cxx source for full Copyright notice */
-////////////////////////////////////////////////////////////////////////////
-// //
-// AliTPCCorrectionDrift class //
-// date: 02/05/2010 //
-// Authors: Maarian Ivanov, Jim Thomas, Magnus Mager, Stefan Rossegger //
-////////////////////////////////////////////////////////////////////////////
+/// \class AliTPCCorrectionDrift
+/// \brief AliTPCCorrectionDrift class
+///
+/// \author Maarian Ivanov, Jim Thomas, Magnus Mager, Stefan Rossegger
+/// \date 02/05/2010
#include "AliTPCCorrection.h"
public:
virtual void GetCorrection(const Float_t x[],const Short_t roc,Float_t dx[]);
- Double_t fZ0Aside; // z- t0*vdrift shift A side
- Double_t fZ0Cside; // z- t0*vdrift shift C side
- Double_t fVScale0; // drift velocity scaling - constant
- Double_t fVScaleR; // drift velocity scaling - radial
- Double_t fVScaleX; // drift velocity scaling - global x
- Double_t fVScaleY; // drift velocity scaling - global y
+ Double_t fZ0Aside; ///< z- t0*vdrift shift A side
+ Double_t fZ0Cside; ///< z- t0*vdrift shift C side
+ Double_t fVScale0; ///< drift velocity scaling - constant
+ Double_t fVScaleR; ///< drift velocity scaling - radial
+ Double_t fVScaleX; ///< drift velocity scaling - global x
+ Double_t fVScaleY; ///< drift velocity scaling - global y
//
- Double_t fIROCZ0; // IROC to OROC shift due unknown reason (clusterer shift Ampl. dependents?)
- Double_t fOROCDZ; // IROC to OROC slope shift due unknown reason (clusterer shift amplitude dependent?)
+ Double_t fIROCZ0; ///< IROC to OROC shift due unknown reason (clusterer shift Ampl. dependents?)
+ Double_t fOROCDZ; ///< IROC to OROC slope shift due unknown reason (clusterer shift amplitude dependent?)
private:
AliTPCCorrectionDrift(const AliTPCCorrectionDrift&);
AliTPCCorrectionDrift &operator=(const AliTPCCorrectionDrift&);
+ /// \cond CLASSIMP
ClassDef(AliTPCCorrectionDrift,1);
+ /// \endcond
};
#endif
+/// \class AliTPCCorrectionLookupTable
+
/**************************************************************************
* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
* *
#include "AliTPCCorrectionLookupTable.h"
+/// \cond CLASSIMP
ClassImp(AliTPCCorrectionLookupTable)
+/// \endcond
//_________________________________________________________________________________________
AliTPCCorrectionLookupTable::AliTPCCorrectionLookupTable()
//_________________________________________________________________________________________
AliTPCCorrectionLookupTable::~AliTPCCorrectionLookupTable()
{
- //
- // dtor
- //
+ /// dtor
ResetTables();
}
//_________________________________________________________________________________________
void AliTPCCorrectionLookupTable::GetDistortion(const Float_t x[],const Short_t roc,Float_t dx[]) {
- //
- // Get interpolated Distortion
- //
+ /// Get interpolated Distortion
GetInterpolation(x,roc,dx,fLookUpDxDist,fLookUpDyDist,fLookUpDzDist);
}
//_________________________________________________________________________________________
void AliTPCCorrectionLookupTable::GetCorrection(const Float_t x[],const Short_t roc,Float_t dx[]) {
- //
- // Get interplolated correction
- //
+ /// Get interplolated correction
+
GetInterpolation(x,roc,dx,fLookUpDxCorr,fLookUpDyCorr,fLookUpDzCorr);
if (fCorrScaleFactor>0) {
void AliTPCCorrectionLookupTable::GetInterpolation(const Float_t x[],const Short_t roc,Float_t dx[],
TMatrixF **mDx, TMatrixF **mDy, TMatrixF **mDz)
{
- //
- // Calculates the correction/distotring from a lookup table
- // type: 0 = correction
- // 1 = distortion
- //
+ /// Calculates the correction/distotring from a lookup table
+ /// type: 0 = correction
+ /// 1 = distortion
// Float_t typeSign=-1;
// if (type==1) typeSign=1;
-
+
Int_t order = 1 ; // FIXME: hardcoded? Linear interpolation = 1, Quadratic = 2
-
+
Double_t r, phi, z ;
Int_t sign;
-
+
r = TMath::Sqrt( x[0]*x[0] + x[1]*x[1] ) ;
phi = TMath::ATan2(x[1],x[0]) ;
if ( phi < 0 ) phi += TMath::TwoPi() ; // Table uses phi from 0 to 2*Pi
z = x[2] ; // Create temporary copy of x[2]
-
+
if ( (roc%36) < 18 ) {
sign = 1; // (TPC A side)
} else {
sign = -1; // (TPC C side)
}
-
+
if ( sign==1 && z < fgkZOffSet ) z = fgkZOffSet; // Protect against discontinuity at CE
if ( sign==-1 && z > -fgkZOffSet ) z = -fgkZOffSet; // Protect against discontinuity at CE
if ( (sign==1 && z<0) || (sign==-1 && z>0) ) // just a consistency check
AliError("ROC number does not correspond to z coordinate! Calculation of distortions is most likely wrong!");
-
+
// Get the Er and Ephi field integrals plus the integral over Z
dx[0] = Interpolate3DTable(order, r, z, phi,
fNR, fNZ, fNPhi,
//_________________________________________________________________________________________
void AliTPCCorrectionLookupTable::CreateLookupTable(AliTPCCorrection &tpcCorr, Float_t stepSize/*=5.*/)
{
- //
- // create lookup table for all phi,r,z bins
- //
+ /// create lookup table for all phi,r,z bins
if (fNR==0) {
AliError("Limits are not set yet. Please use one of the Set..Limits functions first");
}
TStopwatch s;
-
+
ResetTables();
InitTables();
-
+
for (Int_t iPhi=0; iPhi<fNPhi; ++iPhi){
CreateLookupTablePhiBin(tpcCorr,iPhi,stepSize);
}
//_________________________________________________________________________________________
void AliTPCCorrectionLookupTable::CreateLookupTableSinglePhi(AliTPCCorrection &tpcCorr, Int_t iPhi, Float_t stepSize)
{
- //
- // Lookup table for only one phi bin. Can be used for parallel processing
- //
-
+ /// Lookup table for only one phi bin. Can be used for parallel processing
+
if (fNR==0) {
AliError("Limits are not set yet. Please use one of the Set..Limits functions first");
return;
}
TStopwatch s;
-
+
ResetTables();
InitTableArrays();
InitTablesPhiBin(iPhi);
//_________________________________________________________________________________________
void AliTPCCorrectionLookupTable::CreateLookupTablePhiBin(AliTPCCorrection &tpcCorr, Int_t iPhi, Float_t stepSize)
{
- //
- //
- //
+ ///
if (iPhi<0||iPhi>=fNPhi) return;
-
+
const Float_t delta=stepSize; // 5cm
Float_t x[3]={0.,0.,0.};
Float_t dx[3]={0.,0.,0.};
TMatrixF &mDxCorr = *fLookUpDxCorr[iPhi];
TMatrixF &mDyCorr = *fLookUpDyCorr[iPhi];
TMatrixF &mDzCorr = *fLookUpDzCorr[iPhi];
-
+
for (Int_t ir=0; ir<fNR; ++ir){
Double_t r=fLimitsR(ir);
x[0]=r * TMath::Cos(phi);
x[1]=r * TMath::Sin(phi);
-
+
for (Int_t iz=0; iz<fNZ; ++iz){
Double_t z=fLimitsZ(iz);
x[2]=z;
Int_t roc=TMath::Nint(phi*TMath::RadToDeg()/20.)%18;
if (r>133.) roc+=36;
if (z<0) roc+=18;
-
+
if (delta>0)
tpcCorr.GetDistortionIntegralDz(x,roc,dx,delta);
else
}
}
}
-
+
}
//_________________________________________________________________________________________
void AliTPCCorrectionLookupTable::InitTables()
{
- //
- // Init all tables
- //
+ /// Init all tables
InitTableArrays();
for (Int_t iPhi=0; iPhi<fNPhi; ++iPhi){
//_________________________________________________________________________________________
void AliTPCCorrectionLookupTable::CreateLookupTableFromResidualDistortion(THn &resDist)
{
- //
- // create lookup table from residual distortions stored in a 3d histogram
- // assume dimensions are r, phi, z
- //
+ /// create lookup table from residual distortions stored in a 3d histogram
+ /// assume dimensions are r, phi, z
+
if (fNR==0) {
AliError("Limits are not set yet. Please use one of the Set..Limits functions first");
return;
}
-
+
ResetTables();
InitTables();
Double_t x[3]={0.,0.,0.};
-
+
for (Int_t iPhi=0; iPhi<fNPhi; ++iPhi){
const Double_t phi=fLimitsPhi(iPhi);
x[1]=phi;
TMatrixF &mDxCorr = *fLookUpDxCorr[iPhi];
TMatrixF &mDyCorr = *fLookUpDyCorr[iPhi];
TMatrixF &mDzCorr = *fLookUpDzCorr[iPhi];
-
+
for (Int_t ir=0; ir<fNR; ++ir){
const Double_t r=fLimitsR(ir);
x[0]=r;
-
+
for (Int_t iz=0; iz<fNZ; ++iz){
const Double_t z=fLimitsZ(iz);
x[2]=z;
const Double_t drphi = resDist.GetBinContent(resDist.GetBin(x));
Double_t dx[3]={0.,drphi,0.};
-
+
// transform rphi distortions (local y, so dy') to a global distortion
// assume no radial distortion (dx' = 0)
// assume no residual distortion in z for the moment
//_________________________________________________________________________________________
void AliTPCCorrectionLookupTable::CreateResidual(AliTPCCorrection *distortion, AliTPCCorrection* correction)
{
- //
- // create lookup table from residual distortions calculated from distorted - correction
- //
-
+ /// create lookup table from residual distortions calculated from distorted - correction
+
ResetTables();
InitTables();
-
+
Float_t x[3]={0.,0.,0.};
-
+
for (Int_t iPhi=0; iPhi<fNPhi; ++iPhi){
const Double_t phi=fLimitsPhi(iPhi);
//
TMatrixF &mDxCorr = *fLookUpDxCorr[iPhi];
TMatrixF &mDyCorr = *fLookUpDyCorr[iPhi];
TMatrixF &mDzCorr = *fLookUpDzCorr[iPhi];
-
+
for (Int_t ir=0; ir<fNR; ++ir){
const Double_t r=fLimitsR(ir);
x[0]=r * TMath::Cos(phi);
x[1]=r * TMath::Sin(phi);
-
+
for (Int_t iz=0; iz<fNZ; ++iz){
const Double_t z=fLimitsZ(iz);
x[2]=z;
//original point
Float_t xdc[3]={x[0], x[1], x[2]};
-
+
Int_t roc=TMath::Nint(phi*TMath::RadToDeg()/20.)%18;
if (r>133.) roc+=36;
if (z<0) roc+=18;
distortion->DistortPoint(xdc, roc);
correction->CorrectPoint(xdc, roc);
Float_t dx[3]={xdc[0]-x[0], xdc[1]-x[1], xdc[2]-x[2]};
-
+
mDxDist(ir,iz)=dx[0];
mDyDist(ir,iz)=dx[1];
mDzDist(ir,iz)=dx[2];
-
+
mDxCorr(ir,iz)=-dx[0];
mDyCorr(ir,iz)=-dx[1];
mDzCorr(ir,iz)=-dx[2];
//_________________________________________________________________________________________
void AliTPCCorrectionLookupTable::InitTablesPhiBin(Int_t iPhi)
{
- //
- //
- //
+ ///
// check if already initialised
if (iPhi<0||iPhi>=fNPhi) return;
if (fLookUpDxCorr[iPhi]) return;
-
+
fLookUpDxCorr[iPhi] = new TMatrixF(fNR,fNZ);
fLookUpDyCorr[iPhi] = new TMatrixF(fNR,fNZ);
fLookUpDzCorr[iPhi] = new TMatrixF(fNR,fNZ);
-
+
fLookUpDxDist[iPhi] = new TMatrixF(fNR,fNZ);
fLookUpDyDist[iPhi] = new TMatrixF(fNR,fNZ);
fLookUpDzDist[iPhi] = new TMatrixF(fNR,fNZ);
-
+
}
//_________________________________________________________________________________________
void AliTPCCorrectionLookupTable::InitTableArrays()
{
- //
- //
- //
+ ///
// needs to be before the table creation to set the limits
SetupDefaultLimits();
-
+
fLookUpDxCorr = new TMatrixF*[fNPhi];
fLookUpDyCorr = new TMatrixF*[fNPhi];
fLookUpDzCorr = new TMatrixF*[fNPhi];
-
+
fLookUpDxDist = new TMatrixF*[fNPhi];
fLookUpDyDist = new TMatrixF*[fNPhi];
fLookUpDzDist = new TMatrixF*[fNPhi];
fLookUpDxCorr[iPhi] = 0x0;
fLookUpDyCorr[iPhi] = 0x0;
fLookUpDzCorr[iPhi] = 0x0;
-
+
fLookUpDxDist[iPhi] = 0x0;
fLookUpDyDist[iPhi] = 0x0;
fLookUpDzDist[iPhi] = 0x0;
//_________________________________________________________________________________________
void AliTPCCorrectionLookupTable::ResetTables()
{
- //
- // Reset the lookup tables
- //
+ /// Reset the lookup tables
if (!fLookUpDxCorr) return;
-
+
for (Int_t iPhi=0; iPhi<fNPhi; ++iPhi){
delete fLookUpDxCorr[iPhi];
delete fLookUpDyCorr[iPhi];
delete [] fLookUpDxCorr;
delete [] fLookUpDyCorr;
delete [] fLookUpDzCorr;
-
+
delete [] fLookUpDxDist;
delete [] fLookUpDyDist;
delete [] fLookUpDzDist;
-
+
fLookUpDxCorr = 0x0;
fLookUpDyCorr = 0x0;
fLookUpDzCorr = 0x0;
-
+
fLookUpDxDist = 0x0;
fLookUpDyDist = 0x0;
fLookUpDzDist = 0x0;
//_________________________________________________________________________________________
void AliTPCCorrectionLookupTable::SetupDefaultLimits()
{
- //
- // Set default limits for tables
- //
+ /// Set default limits for tables
fNR = kNR;
fNPhi = kNPhi;
//_________________________________________________________________________________________
void AliTPCCorrectionLookupTable::MergePhiTables(const char* files)
{
- //
- // merge all lookup tables stored in 'files' with this one
- // assume that each lookup table in each file has only one phi bin
- //
+ /// merge all lookup tables stored in 'files' with this one
+ /// assume that each lookup table in each file has only one phi bin
ResetTables();
ResetLimits(); // use limits from the first file assuming they are all the same
-
+
TString sfiles=gSystem->GetFromPipe(Form("ls %s",files));
TObjArray *arrFiles=sfiles.Tokenize("\n");
AliFatal(Form("Phi bin '%d' not initialised from files!",iPhi));
}
}
-
+
delete arrFiles;
}
//_________________________________________________________________________________________
void AliTPCCorrectionLookupTable::BuildExactInverse()
{
- //
- // this method build the exact inverse of the standard distortion map
- // for the the distortion man first needs to be calculated
- // then the correction map will be overwritten
- //
+ /// this method build the exact inverse of the standard distortion map
+ /// for the the distortion man first needs to be calculated
+ /// then the correction map will be overwritten
Float_t x[3] = {0.,0.,0.};
Float_t x2[3] = {0.,0.,0.};
TMatrixF &mDxCorr = *fLookUpDxCorr[iPhi];
TMatrixF &mDyCorr = *fLookUpDyCorr[iPhi];
TMatrixF &mDzCorr = *fLookUpDzCorr[iPhi];
-
+
for (Int_t ir=0; ir<fNR; ++ir){
for (Int_t iz=0; iz<fNZ; ++iz){
mDxCorr(ir,iz) = -1000.;
}
}
}
-
+
// get interplolated corrections on standard grid
for (Int_t iPhi=0; iPhi<fNPhi; ++iPhi){
Double_t phi=fLimitsPhi(iPhi);
TMatrixF &mDxDist = *fLookUpDxDist[iPhi];
TMatrixF &mDyDist = *fLookUpDyDist[iPhi];
TMatrixF &mDzDist = *fLookUpDzDist[iPhi];
-
+
for (Int_t ir=0; ir<fNR; ++ir){
Double_t r=fLimitsR(ir);
x[0]=r * TMath::Cos(phi);
for (Int_t iz=0; iz<fNZ; ++iz){
Double_t z=fLimitsZ(iz);
x[2]=z;
-
+
//TODO: change hardcoded value for r>133.?
Int_t roc=TMath::Nint(phi*TMath::RadToDeg()/20.)%18;
if (r>133.) roc+=36;
const Double_t zd = xd[2];
Int_t ilow = 0, jlow = 0, klow = 0 ;
-
+
Search( fLimitsR.GetNrows(), fLimitsR.GetMatrixArray(), rd, ilow ) ;
Search( fLimitsZ.GetNrows(), fLimitsZ.GetMatrixArray(), zd, jlow ) ;
Search( fLimitsPhi.GetNrows(), fLimitsPhi.GetMatrixArray(), phid, klow ) ;
-
+
if ( ilow < 0 ) ilow = 0 ; // check if out of range
if ( jlow < 0 ) jlow = 0 ;
if ( klow < 0 ) klow = 0 ;
const Double_t phiRef = fLimitsPhi[klow];
const Double_t rRef = fLimitsR[ilow];
const Double_t zRef = fLimitsZ[jlow];
-
+
TMatrixF &mDxCorr = *fLookUpDxCorr[klow];
if ( mDxCorr(ilow, jlow) > -1000. ) continue;
TMatrixF &mDyCorr = *fLookUpDyCorr[klow];
TMatrixF &mDzCorr = *fLookUpDzCorr[klow];
-
+
xref[0]= rRef * TMath::Cos(phiRef);
xref[1]= rRef * TMath::Sin(phiRef);
xref[2]= zRef;
-
+
FindClosestPosition(ir,iz,iPhi, xref, x2);
GetDistortion(x2,roc,dx);
TMatrixF &mDxCorr = *fLookUpDxCorr[0];
TMatrixF &mDyCorr = *fLookUpDyCorr[0];
TMatrixF &mDzCorr = *fLookUpDzCorr[0];
-
+
TMatrixF &mDxCorr2 = *fLookUpDxCorr[fNPhi-1];
TMatrixF &mDyCorr2 = *fLookUpDyCorr[fNPhi-1];
TMatrixF &mDzCorr2 = *fLookUpDzCorr[fNPhi-1];
-
+
for (Int_t ir=0; ir<fNR; ++ir){
for (Int_t iz=0; iz<fNZ; ++iz){
mDxCorr2(ir,iz) = mDxCorr(ir,iz);
TMatrixF &mDxCorr = *fLookUpDxCorr[iPhi];
TMatrixF &mDyCorr = *fLookUpDyCorr[iPhi];
TMatrixF &mDzCorr = *fLookUpDzCorr[iPhi];
-
+
Double_t phi=fLimitsPhi(iPhi);
for (Int_t ir=0; ir<fNR; ++ir){
Double_t r=fLimitsR(ir);
Double_t z=fLimitsZ(iz);
x[2]=z;
-
+
//TODO: change hardcoded value for r>133.?
Int_t roc=TMath::Nint(phi*TMath::RadToDeg()/20.)%18;
if (r>133.) roc+=36;
if (z<0) roc+=18;
-
+
// get last point
dx[0] = mDxCorr(ir,iz-1);
dx[1] = mDyCorr(ir,iz-1);
dx[2] = mDzCorr(ir,iz-1);
-
+
xd[0] = x[0]+dx[0];
xd[1] = x[1]+dx[1];
xd[2] = x[2]+dx[2];
const Double_t phid = TVector2::Phi_0_2pi(TMath::ATan2(xd[1],xd[0]));
const Double_t rd = TMath::Sqrt(xd[0]*xd[0] + xd[1]*xd[1]);
const Double_t zd = xd[2];
-
+
Int_t ilow = 0, jlow = 0, klow = 0 ;
-
+
Search( fLimitsR.GetNrows(), fLimitsR.GetMatrixArray(), rd, ilow ) ;
Search( fLimitsZ.GetNrows(), fLimitsZ.GetMatrixArray(), zd, jlow ) ;
Search( fLimitsPhi.GetNrows(), fLimitsPhi.GetMatrixArray(), phid, klow ) ;
-
+
if ( ilow < 0 ) ilow = 0 ; // check if out of range
if ( jlow < 0 ) jlow = 0 ;
if ( klow < 0 ) klow = 0 ;
if ( ilow >= fLimitsR.GetNrows()) ilow = fLimitsR.GetNrows() - 1;
if ( jlow >= fLimitsZ.GetNrows()) jlow = fLimitsZ.GetNrows() - 1;
if ( klow >= fLimitsPhi.GetNrows()) klow = fLimitsPhi.GetNrows() - 1;
-
+
FindClosestPosition(ilow,jlow,klow, x, x2);
-
+
GetDistortion(x2,roc,dx);
-
+
mDxCorr(ir, iz) = -dx[0];
mDyCorr(ir, iz) = -dx[1];
mDzCorr(ir, iz) = -dx[2];
}
}
}
-
+
}
//_________________________________________________________________________________________
void AliTPCCorrectionLookupTable::FindClosestPosition(const Int_t binR, const Int_t binZ, const Int_t binPhi,
const Float_t xref[3], Float_t xret[3])
{
- //
- //
- //
+ ///
// static TLinearFitter fitx(2,"pol2");
// static TLinearFitter fity(2,"pol2");
while (rMax>=fNR) {--rMin; --rMax;}
while (zMax>=fNZ) {--zMin; --zMax;}
while (phiMax>=fNPhi) {--phiMin; --phiMax;}
-
+
Float_t x[3] = {0.,0.,0.};
Double_t xd[3] = {0.,0.,0.};
Float_t dx[3] = {0.,0.,0.};
-
+
for (Int_t iPhi=phiMin; iPhi<phiMax; ++iPhi) {
TMatrixF &mDxDist = *fLookUpDxDist[iPhi];
TMatrixF &mDyDist = *fLookUpDyDist[iPhi];
TMatrixF &mDzDist = *fLookUpDzDist[iPhi];
-
+
Double_t phi=fLimitsPhi(iPhi);
for (Int_t ir=rMin; ir<rMax; ++ir){
Double_t r=fLimitsR(ir);
x[0]=r * TMath::Cos(phi);
x[1]=r * TMath::Sin(phi);
-
+
for (Int_t iz=zMin; iz<zMax; ++iz){
Double_t z=fLimitsZ(iz);
x[2]=z;
-
+
dx[0] = mDxDist(ir,iz);
dx[1] = mDyDist(ir,iz);
dx[2] = mDzDist(ir,iz);
-
+
xd[0] = x[0]+dx[0];
xd[1] = x[1]+dx[1];
xd[2] = x[2]+dx[2];
/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
* See cxx source for full Copyright notice */
-////////////////////////////////////////////////////////////////////////////
-// AliTPCCorrectionLookupTable class //
-// Authors: Jens Wiechula //
-////////////////////////////////////////////////////////////////////////////
+/// \class AliTPCCorrectionLookupTable
+/// \brief AliTPCCorrectionLookupTable class
+///
+/// \author Jens Wiechula
#include "AliTPCCorrection.h"
#include <TVectorD.h>
void CreateLookupTableFromResidualDistortion(THn &resDist);
void CreateResidual(AliTPCCorrection *distortion, AliTPCCorrection* correction);
-
+
void MergePhiTables(const char* files);
void SetFillCorrection(Bool_t fill) { fFillCorrection=fill; }
const TVectorD& GetLimitsR() const { return fLimitsR; }
const TVectorD& GetLimitsPhi() const { return fLimitsPhi; }
const TVectorD& GetLimitsZ() const { return fLimitsZ; }
-
+
void SetCorrScaleFactor(Float_t val) { fCorrScaleFactor = val; }
Float_t GetCorrScaleFactor() const { return fCorrScaleFactor; }
-
+
private:
// sizes of lookup tables
// TODO: Remove, since it will be stored in the TVectorD anyhow?
- Int_t fNR; // number of rows (r) used for lookup table
- Int_t fNPhi; // number of phi slices used for lookup table
- Int_t fNZ; // number of columns (z) used for lookup table
+ Int_t fNR; ///< number of rows (r) used for lookup table
+ Int_t fNPhi; ///< number of phi slices used for lookup table
+ Int_t fNZ; ///< number of columns (z) used for lookup table
+
+ Float_t fCorrScaleFactor; ///< overall scaling factor for the correction
- Float_t fCorrScaleFactor; // overall scaling factor for the correction
-
- Bool_t fFillCorrection; // whether to also fill the correction tables
+ Bool_t fFillCorrection; ///< whether to also fill the correction tables
//
- TVectorD fLimitsR; // bin limits in row direction
- TVectorD fLimitsPhi; // bin limits in phi direction
- TVectorD fLimitsZ; // bin limits in z direction
+ TVectorD fLimitsR; ///< bin limits in row direction
+ TVectorD fLimitsPhi; ///< bin limits in phi direction
+ TVectorD fLimitsZ; ///< bin limits in z direction
// for distortion
- TMatrixF **fLookUpDxDist; //[fNPhi] Array to store electric field integral (int Er/Ez)
- TMatrixF **fLookUpDyDist; //[fNPhi] Array to store electric field integral (int Er/Ez)
- TMatrixF **fLookUpDzDist; //[fNPhi] Array to store electric field integral (int Er/Ez)
+ /// Array to store electric field integral (int Er/Ez)
+ TMatrixF **fLookUpDxDist; //[fNPhi]
+ /// Array to store electric field integral (int Er/Ez)
+ TMatrixF **fLookUpDyDist; //[fNPhi]
+ /// Array to store electric field integral (int Er/Ez)
+ TMatrixF **fLookUpDzDist; //[fNPhi]
// for correction
- TMatrixF **fLookUpDxCorr; //[fNPhi] Array to store electric field integral (int Er/Ez)
- TMatrixF **fLookUpDyCorr; //[fNPhi] Array to store electric field integral (int Er/Ez)
- TMatrixF **fLookUpDzCorr; //[fNPhi] Array to store electric field integral (int Er/Ez)
+ /// Array to store electric field integral (int Er/Ez)
+ TMatrixF **fLookUpDxCorr; //[fNPhi]
+ /// Array to store electric field integral (int Er/Ez)
+ TMatrixF **fLookUpDyCorr; //[fNPhi]
+ /// Array to store electric field integral (int Er/Ez)
+ TMatrixF **fLookUpDzCorr; //[fNPhi]
void InitTables();
void InitTableArrays();
void InitTablesPhiBin(Int_t iPhi);
-
+
void ResetTables();
void ResetLimits();
-
+
void GetInterpolation(const Float_t x[],const Short_t roc,Float_t dx[],
TMatrixF **mR, TMatrixF **mPhi, TMatrixF **mZ);
const Float_t xref[3], Float_t xret[3]);
AliTPCCorrectionLookupTable(const AliTPCCorrectionLookupTable &corr);
AliTPCCorrectionLookupTable& operator= (const AliTPCCorrectionLookupTable &corr);
-
+
+ /// \cond CLASSIMP
ClassDef(AliTPCCorrectionLookupTable,3); // TPC corrections dumped into a lookup table
+ /// \endcond
};
/* $Id$ */
-///////////////////////////////////////////////////////////////////////////////
-// //
-// Time Projection Chamber clusters objects //
-//
-// Origin: Marian Ivanov , GSI Darmstadt
-// //
-// //
-// //
-///////////////////////////////////////////////////////////////////////////////
-#include "AliTPCParam.h"
+/// \class AliTPCDigitsArray
+/// \brief Time Projection Chamber clusters objects
+///
+/// \author Marian Ivanov , GSI Darmstadt
+
+#include "AliTPCParam.h"
#include "AliTPCPRF2D.h"
#include "TObjArray.h"
-#include "AliSegmentID.h"
-#include "AliSegmentArray.h"
+#include "AliSegmentID.h"
+#include "AliSegmentArray.h"
#include "AliDigits.h"
#include "AliSimDigits.h"
-#include "AliDigitsArray.h"
+#include "AliDigitsArray.h"
#include "AliTPCDigitsArray.h"
#include <TDirectory.h>
//_____________________________________________________________________________
-ClassImp(AliTPCDigitsArray)
+/// \cond CLASSIMP
+ClassImp(AliTPCDigitsArray)
+/// \endcond
AliTPCDigitsArray::AliTPCDigitsArray(Bool_t sim)
:AliDigitsArray(),
SetClass("AliDigits");
fParam = 0;
// fPRF = 0;
- //fRF = 0;
+ //fRF = 0;
fCompression = 1;
fTrackLevel = 3;
}
AliTPCDigitsArray::~AliTPCDigitsArray()
{
- //
-
+ ///
+
//
}
AliDigits * AliTPCDigitsArray::CreateRow(Int_t sector, Int_t row)
{
- //
- //create digits row
- //
- //if row just exist - delete it
+ /// create digits row
+ ///
+ /// if row just exist - delete it
+
AliTPCParam * param = (AliTPCParam*)fParam;
- Int_t index = param->GetIndex(sector,row);
+ Int_t index = param->GetIndex(sector,row);
AliDigits * dig = (AliDigits *)(*this)[index];
if (dig !=0) delete dig;
dig = (AliDigits *) AddSegment(index);
if (dig == 0) return 0;
- dig->Allocate(param->GetMaxTBin(),param->GetNPads(sector,row));
+ dig->Allocate(param->GetMaxTBin(),param->GetNPads(sector,row));
if (fBSim == kTRUE) ((AliSimDigits*) dig)->AllocateTrack(fTrackLevel);
return dig;
}
AliDigits * AliTPCDigitsArray::GetRow(Int_t sector,Int_t row)
{
- //
- //return clusters ((AliTPCDigitsRow *) per given sector and padrow
- //
+ /// return clusters ((AliTPCDigitsRow *) per given sector and padrow
+
if (fParam==0) return 0;
- Int_t index = ((AliTPCParam*)fParam)->GetIndex(sector,row);
+ Int_t index = ((AliTPCParam*)fParam)->GetIndex(sector,row);
return (AliDigits *)(*this)[index];
}
AliDigits * AliTPCDigitsArray::LoadRow(Int_t sector,Int_t row)
{
- //
- //return clusters ((AliTPCDigitsRow *) per given sector and padrow
- //
+ /// return clusters ((AliTPCDigitsRow *) per given sector and padrow
+
if (fParam==0) return 0;
- Int_t index = ((AliTPCParam*)fParam)->GetIndex(sector,row);
+ Int_t index = ((AliTPCParam*)fParam)->GetIndex(sector,row);
return (AliDigits *)LoadSegment(index);
}
Bool_t AliTPCDigitsArray::StoreRow(Int_t sector,Int_t row)
{
- //
- //return clusters ((AliTPCDigitsRow *) per given sector and padrow
- //
+ /// return clusters ((AliTPCDigitsRow *) per given sector and padrow
+
AliTPCParam * param = (AliTPCParam*)fParam;
if (fParam==0) return 0;
- Int_t index = param->GetIndex(sector,row);
+ Int_t index = param->GetIndex(sector,row);
( (AliDigits *)At(index))->CompresBuffer(fCompression,param->GetZeroSup());
if (fBSim == kTRUE) ( (AliSimDigits *)At(index))->CompresTrackBuffer(1);
StoreSegment(index);
Bool_t AliTPCDigitsArray::ClearRow(Int_t sector,Int_t row)
{
- //
- //return clusters ((AliTPCDigitsRow *) per given sector and padrow
- //
+ /// return clusters ((AliTPCDigitsRow *) per given sector and padrow
+
if (fParam==0) return 0;
- Int_t index = ((AliTPCParam*)fParam)->GetIndex(sector,row);
+ Int_t index = ((AliTPCParam*)fParam)->GetIndex(sector,row);
ClearSegment(index);
return kTRUE;
}
Bool_t AliTPCDigitsArray::Setup(AliDetectorParam *param)
{
- //
- //setup function to adjust array parameters
- //
+ /// setup function to adjust array parameters
+
if (param==0) return kFALSE;
if (fParam !=0) delete fParam;
// fParam = new AliTPCParam((AliTPCParam&)(*param));
Bool_t AliTPCDigitsArray::Update()
{
- //
- //setup function to adjust array parameters
- //
+ /// setup function to adjust array parameters
+
if (fParam ==0 ) return kFALSE;
if (fTree!=0) return MakeDictionary( ((AliTPCParam*)fParam)->GetNRowsTotal()) ;
((AliTPCParam*)fParam)->Update();
/* $Id$ */
-////////////////////////////////////////////////
-// Manager class for TPC digits //
-////////////////////////////////////////////////
+/// \class AliTPCDigitsArray
+/// \brief Manager class for TPC digits
-#include "AliDigits.h"
+#include "AliDigits.h"
#include "AliDigitsArray.h"
-#include "AliTPCParam.h"
+#include "AliTPCParam.h"
class AliDigits;
class AliDetectorParam;
AliDigits * LoadRow(Int_t sector,Int_t row);
Bool_t StoreRow(Int_t sector,Int_t row);
Bool_t ClearRow(Int_t sector,Int_t row);
- Bool_t Setup(AliDetectorParam *param);
-
+ Bool_t Setup(AliDetectorParam *param);
+
Bool_t IsSimulated(){return fBSim;}
- Bool_t Update();
-private:
- Bool_t fBSim; //signalize if we have digits with track ID
- Int_t fCompression; //default compression for AliDigits - used in storing
- Int_t fTrackLevel; //default level for track ID storing
+ Bool_t Update();
+private:
+ Bool_t fBSim; ///< signalize if we have digits with track ID
+ Int_t fCompression; ///< default compression for AliDigits - used in storing
+ Int_t fTrackLevel; ///< default level for track ID storing
+ /// \cond CLASSIMP
ClassDef(AliTPCDigitsArray,1) // TPC digits manager
+ /// \endcond
};
-
+
#endif //ALITPCCLUSTERSARRAY_H
#include "AliTPCcalibDB.h"
-//
-// Abstract class for ExB effect parameterization
-//
-//
-//
-// The ExB correction map is stored in the calib DB
-// The lookup can be dumped to the tree:
-/*
-
- //
- char *storage = "local://OCDBres"
- Int_t RunNumber=0;
- AliCDBManager::Instance()->SetDefaultStorage(storage);
- AliCDBManager::Instance()->SetRun(RunNumber)
- AliTPCExBFirst * exb = AliTPCcalibDB::Instance()->GetExB();
- //
- // See example macro $ALICE_ROOT/TPC/macros/AliTPCExBdraw.C
- //
- .L $ALICE_ROOT/TPC/macros/AliTPCExBdraw.C
- Draw(0)
-
-
-
-
-*/
+/// \class AliTPCExB
+/// \brief Abstract class for ExB effect parameterization
+///
+/// The ExB correction map is stored in the calib DB
+/// The lookup can be dumped to the tree:
+///
+/// ~~~{.cxx}
+/// char *storage = "local://OCDBres"
+/// Int_t RunNumber=0;
+/// AliCDBManager::Instance()->SetDefaultStorage(storage);
+/// AliCDBManager::Instance()->SetRun(RunNumber)
+/// AliTPCExBFirst * exb = AliTPCcalibDB::Instance()->GetExB();
+///
+/// // See example macro $ALICE_ROOT/TPC/macros/AliTPCExBdraw.C
+///
+/// .L $ALICE_ROOT/TPC/macros/AliTPCExBdraw.C
+/// Draw(0)
+/// ~~~
AliTPCExB* AliTPCExB::fgInstance = 0;
+/// \cond CLASSIMP
ClassImp(AliTPCExB)
+/// \endcond
AliTPCExB::AliTPCExB():
TObject(),
fMatBrBz(0), //param matrix Br/Bz
fMatBrfiBz(0), //param matrix Br/Bz
- fMatBrBzI0(0), //param matrix Br/Bz integral z>0
- fMatBrBzI1(0), //param matrix Br/Bz integral z<0
- fMatBrfiBzI0(0), //param matrix Br/Bz integral z>0
+ fMatBrBzI0(0), //param matrix Br/Bz integral z>0
+ fMatBrBzI1(0), //param matrix Br/Bz integral z<0
+ fMatBrfiBzI0(0), //param matrix Br/Bz integral z>0
fMatBrfiBzI1(0) //param matrix Br/Bz integral z<0
{
//
TObject(exb),
fMatBrBz(new TVectorD(*(exb.fMatBrBz))), //param matrix Br/Bz
fMatBrfiBz(new TVectorD(*(exb.fMatBrfiBz))), //param matrix Br/Bz
- fMatBrBzI0(new TVectorD(*(exb.fMatBrBzI0))), //param matrix Br/Bz integral z>0
- fMatBrBzI1(new TVectorD(*(exb.fMatBrBzI1))), //param matrix Br/Bz integral z<0
- fMatBrfiBzI0(new TVectorD(*(exb.fMatBrfiBzI0))), //param matrix Br/Bz integral z>0
+ fMatBrBzI0(new TVectorD(*(exb.fMatBrBzI0))), //param matrix Br/Bz integral z>0
+ fMatBrBzI1(new TVectorD(*(exb.fMatBrBzI1))), //param matrix Br/Bz integral z<0
+ fMatBrfiBzI0(new TVectorD(*(exb.fMatBrfiBzI0))), //param matrix Br/Bz integral z>0
fMatBrfiBzI1(new TVectorD(*(exb.fMatBrfiBzI1))) //param matrix Br/Bz integral z<0
{
- //
- // copy constructor
- //
+ /// copy constructor
+
}
AliTPCExB& AliTPCExB::operator=(const AliTPCExB &/*exb*/)
{
- //
- // Dummy assignment
- //
+ /// Dummy assignment
+
return *this;
}
void AliTPCExB::TestExB(const char* fileName) {
- //
- // Test ExB -
- // Dump the filed and corrections to the tree in file fileName
- //
- //
+ /// Test ExB -
+ /// Dump the filed and corrections to the tree in file fileName
+
TTreeSRedirector ts(fileName);
Double_t x[3];
for (x[0]=-250.;x[0]<=250.;x[0]+=10.)
Double_t AliTPCExB::GetDr(Double_t r, Double_t phi, Double_t z, Double_t bz){
- //
- // Static function
- // Posibble to us it for visualization
- //
- //
+ /// Static function
+ /// Posibble to us it for visualization
+
AliTPCExB *exb = Instance();
if (!exb) exb = AliTPCcalibDB::GetExB(bz,kFALSE);
if (!exb) return 0;
Double_t dx=pos1[0]-pos0[0];
Double_t dy=pos1[1]-pos0[1];
// Double_t dz=pos1[2]-pos0[2];
- // return TMath::Sqrt(dx*dx+dy*dy);
+ // return TMath::Sqrt(dx*dx+dy*dy);
Float_t dr = (dx*pos0[0]+dy*pos0[1])/r;
return dr;
}
Double_t AliTPCExB::GetDrphi(Double_t r, Double_t phi, Double_t z, Double_t bz){
- //
- //
- //
+ ///
+
AliTPCExB *exb = Instance();
if (!exb) exb = AliTPCcalibDB::GetExB(bz,kFALSE);
if (!exb) return 0;
Double_t dphi=TMath::ATan2(pos1[1],pos1[0])-TMath::ATan2(pos0[1],pos0[0]);
if (dphi>TMath::Pi()) dphi-=TMath::TwoPi();
if (dphi<-TMath::Pi()) dphi+=TMath::TwoPi();
- return r*dphi;
+ return r*dphi;
}
Double_t AliTPCExB::GetDphi(Double_t r, Double_t phi, Double_t z, Double_t bz){
- //
- //
- //
+ ///
+
AliTPCExB *exb = Instance();
if (!exb) exb = AliTPCcalibDB::GetExB(bz,kFALSE);
if (!exb) return 0;
Double_t pos1[3];
exb->Correct(pos0,pos1);
Double_t dphi=TMath::ATan2(pos1[1],pos1[0])-TMath::ATan2(pos0[1],pos0[0]);
- return dphi;
+ return dphi;
}
Double_t AliTPCExB::GetDz(Double_t r, Double_t phi, Double_t z, Double_t bz){
- //
- //
- //
+ ///
+
AliTPCExB *exb = Instance();
if (!exb) exb = AliTPCcalibDB::GetExB(bz,kFALSE);
if (!exb) return 0;
Double_t pos1[3];
exb->Correct(pos0,pos1);
Double_t dz=pos1[2]-pos0[2];
- return dz;
+ return dz;
}
//
void AliTPCExB::RegisterField(Int_t index, AliMagF * magf){
- //
- // add the filed to the list
- //
+ /// add the filed to the list
+
fgArray.AddAt(magf,index);
}
Double_t AliTPCExB::GetBx(Double_t r, Double_t phi, Double_t z,Int_t index){
- //
- //
- //
+ ///
+
AliMagF *mag = (AliMagF*)fgArray.At(index);
if (!mag) return 0;
Double_t xyz[3]={r*TMath::Cos(phi),r*TMath::Sin(phi),z};
Double_t bxyz[3];
mag->Field(xyz,bxyz);
return bxyz[0];
-}
+}
Double_t AliTPCExB::GetBy(Double_t r, Double_t phi, Double_t z,Int_t index){
- //
- //
- //
+ ///
+
AliMagF *mag = (AliMagF*)fgArray.At(index);
if (!mag) return 0;
Double_t xyz[3]={r*TMath::Cos(phi),r*TMath::Sin(phi),z};
Double_t bxyz[3];
mag->Field(xyz,bxyz);
return bxyz[1];
-}
+}
Double_t AliTPCExB::GetBz(Double_t r, Double_t phi, Double_t z,Int_t index){
- //
- //
- //
+ ///
+
AliMagF *mag = (AliMagF*)fgArray.At(index);
if (!mag) return 0;
Double_t xyz[3]={r*TMath::Cos(phi),r*TMath::Sin(phi),z};
Double_t bxyz[3];
mag->Field(xyz,bxyz);
return bxyz[2];
-}
+}
Double_t AliTPCExB::GetBr(Double_t r, Double_t phi, Double_t z,Int_t index){
- //
- //
- //
+ ///
+
AliMagF *mag = (AliMagF*)fgArray.At(index);
if (!mag) return 0;
Double_t xyz[3]={r*TMath::Cos(phi),r*TMath::Sin(phi),z};
if (r==0) return 0;
Double_t br = (bxyz[0]*xyz[0]+bxyz[1]*xyz[1])/r;
return br;
-}
+}
Double_t AliTPCExB::GetBrfi(Double_t r, Double_t phi, Double_t z,Int_t index){
- //
- //
- //
+ ///
+
AliMagF *mag = (AliMagF*)fgArray.At(index);
if (!mag) return 0;
Double_t xyz[3]={r*TMath::Cos(phi),r*TMath::Sin(phi),z};
if (r==0) return 0;
Double_t br = (-bxyz[0]*xyz[1]+bxyz[1]*xyz[0])/r;
return br;
-}
+}
Double_t AliTPCExB::Eval(Int_t type, Double_t r, Double_t phi, Double_t z){
- //
- // Evaluate parameterization
- //
- // br integral param
+ /// Evaluate parameterization
+ ///
+ /// br integral param
+
if (type==0) {
if (z>0 && fMatBrBzI0) return EvalMat(*fMatBrBzI0,r,phi,z);
if (z<0 && fMatBrBzI1) return EvalMat(*fMatBrBzI1,r,phi,z);
}
- // brfi integral param
+ // brfi integral param
if (type==1) {
if (z>0 && fMatBrfiBzI0) return EvalMat(*fMatBrfiBzI0,r,phi,z);
if (z<0 && fMatBrfiBzI1) return EvalMat(*fMatBrfiBzI1,r,phi,z);
Double_t AliTPCExB::EvalMat(const TVectorD &vec, Double_t r, Double_t phi, Double_t z){
- //
- // Evaluate taylor expansion in r,phi,z
- //
- // Variables
- //tree->SetAlias("sa","sin(phi+0.0)");
- //tree->SetAlias("ca","cos(phi+0.0)");
- //tree->SetAlias("sa2","sin(phi*2+0.0)");
- //tree->SetAlias("ca2","cos(phi*2+0.0)");
- //tree->SetAlias("zn","(x2/250.)");
- //tree->SetAlias("rn","(r/250.)")
- // TString fstringSym="";
- // //
- // fstringSym+="zn++";
- // fstringSym+="rn++";
- // fstringSym+="zn*rn++";
- // fstringSym+="zn*zn++";
- // fstringSym+="zn*zn*rn++";
- // fstringSym+="zn*rn*rn++";
- // //
- // fstringSym+="sa++";
- // fstringSym+="ca++";
- // fstringSym+="ca2++";
- // fstringSym+="sa2++";
- // fstringSym+="ca*zn++";
- // fstringSym+="sa*zn++";
- // fstringSym+="ca2*zn++";
- // fstringSym+="sa2*zn++";
- // fstringSym+="ca*zn*zn++";
- // fstringSym+="sa*zn*zn++";
- // fstringSym+="ca*zn*rn++";
- // fstringSym+="sa*zn*rn++";
-
+ /// Evaluate taylor expansion in r,phi,z
+ ///
+ /// Variables:
+ /// ~~~
+ /// tree->SetAlias("sa","sin(phi+0.0)");
+ /// tree->SetAlias("ca","cos(phi+0.0)");
+ /// tree->SetAlias("sa2","sin(phi*2+0.0)");
+ /// tree->SetAlias("ca2","cos(phi*2+0.0)");
+ /// tree->SetAlias("zn","(x2/250.)");
+ /// tree->SetAlias("rn","(r/250.)")
+ /// TString fstringSym="";
+ ///
+ /// fstringSym+="zn++";
+ /// fstringSym+="rn++";
+ /// fstringSym+="zn*rn++";
+ /// fstringSym+="zn*zn++";
+ /// fstringSym+="zn*zn*rn++";
+ /// fstringSym+="zn*rn*rn++";
+ ///
+ /// fstringSym+="sa++";
+ /// fstringSym+="ca++";
+ /// fstringSym+="ca2++";
+ /// fstringSym+="sa2++";
+ /// fstringSym+="ca*zn++";
+ /// fstringSym+="sa*zn++";
+ /// fstringSym+="ca2*zn++";
+ /// fstringSym+="sa2*zn++";
+ /// fstringSym+="ca*zn*zn++";
+ /// fstringSym+="sa*zn*zn++";
+ /// fstringSym+="ca*zn*rn++";
+ /// fstringSym+="sa*zn*rn++";
+ /// ~~~
Double_t sa = TMath::Sin(phi);
Double_t ca = TMath::Cos(phi);
res+=vec[ipoint++]*zn*rn*rn;
//
res+=vec[ipoint++]*sa;
- res+=vec[ipoint++]*ca;
+ res+=vec[ipoint++]*ca;
res+=vec[ipoint++]*ca2;
res+=vec[ipoint++]*sa2;
res+=vec[ipoint++]*ca*zn;
/*
-
+
AliTPCExB draw;
draw.RegisterField(0,new AliMagWrapCheb("Maps","Maps", 2, 1., 10., AliMagWrapCheb::k5kG));
draw.RegisterField(1,new AliMagFMaps("Maps","Maps", 2, 1., 10., 2));
TF2 fbz_rz_0pi("fbz_rz_0pi","AliTPCExB::GetBz(x,0*pi,y)",0,250,-250,250);
fbz_rz_0pi->Draw("surf2");
-
+
TF1 fbz_z_90_00pi("fbz_z_90_00pi","AliTPCExB::GetBz(90,0*pi,x)",-250,250);
TF1 fbz_z_90_05pi("fbz_z_90_05pi","AliTPCExB::GetBz(90,0.5*pi,x)",-250,250);
TF1 fbz_z_90_10pi("fbz_z_90_10pi","AliTPCExB::GetBz(90,1.0*pi,x)",-250,250);
fbz_z_90_05pi->Draw("same")
fbz_z_90_15pi->Draw("same")
fbz_z_90_10pi->Draw("same")
-
+
TF1 fbr_z_90_00pi("fbz_z_90_00pi","AliTPCExB::GetBr(90,0*pi,x)",-250,250);
TF1 fbr_z_90_05pi("fbz_z_90_05pi","AliTPCExB::GetBr(90,0.5*pi,x)",-250,250);
+/// \class AliTPCExB
+
#ifndef ALITPCEXB_H
#define ALITPCEXB_H
Double_t Eval(Int_t type, Double_t r, Double_t phi, Double_t z);
Double_t SEval(Int_t type, Double_t r, Double_t phi, Double_t z){return Instance()->Eval(type,r,phi,z);}
static Double_t EvalMat(const TVectorD &vec, Double_t r, Double_t phi, Double_t z); // evalute parameterization
-
+
private:
- TVectorD * fMatBrBz; //param matrix Br/Bz
- TVectorD * fMatBrfiBz; //param matrix Br/Bz
- TVectorD * fMatBrBzI0; //param matrix Br/Bz integral z>0
- TVectorD * fMatBrBzI1; //param matrix Br/Bz integral z<0
- TVectorD * fMatBrfiBzI0; //param matrix Br/Bz integral z>0
- TVectorD * fMatBrfiBzI1; //param matrix Br/Bz integral z<0
-
- static AliTPCExB* fgInstance; //! Instance of this class (singleton implementation)
- static TObjArray fgArray; //! array of magnetic fields
+ TVectorD * fMatBrBz; ///< param matrix Br/Bz
+ TVectorD * fMatBrfiBz; ///< param matrix Br/Bz
+ TVectorD * fMatBrBzI0; ///< param matrix Br/Bz integral z>0
+ TVectorD * fMatBrBzI1; ///< param matrix Br/Bz integral z<0
+ TVectorD * fMatBrfiBzI0; ///< param matrix Br/Bz integral z>0
+ TVectorD * fMatBrfiBzI1; ///< param matrix Br/Bz integral z<0
+
+ static AliTPCExB* fgInstance; //!< Instance of this class (singleton implementation)
+ static TObjArray fgArray; //!< array of magnetic fields
//
+ /// \cond CLASSIMP
ClassDef(AliTPCExB,2)
+ /// \endcond
};
#endif
* provided "as is" without express or implied warranty. *
**************************************************************************/
-////////////////////////////////////////////////////////////////////////////
-// AliTPCExBBShape class //
-////////////////////////////////////////////////////////////////////////////
+/// \class AliTPCExBBShape
+/// \brief AliTPCExBBShape class
#include <AliMagF.h>
#include "TGeoGlobalMagField.h"
fScaling(1.),
fBField(0)
{
- //
- // default constructor
- //
+ /// default constructor
+
}
AliTPCExBBShape::~AliTPCExBBShape() {
- //
- // virtual destructor
- //
+ /// virtual destructor
+
}
Bool_t AliTPCExBBShape::AddCorrectionCompact(AliTPCCorrection* corr, Double_t weight){
- //
- // Add correction and make them compact
- // Assumptions:
- // - origin of distortion/correction are additive
- // - only correction ot the same type supported ()
+ /// Add correction and make them compact
+ /// Assumptions:
+ /// - origin of distortion/correction are additive
+ /// - only correction ot the same type supported ()
+
if (corr==NULL) {
- AliError("Zerro pointer - correction");
+ AliError("Zerro pointer - correction");
return kFALSE;
- }
+ }
AliTPCExBBShape* corrC = dynamic_cast<AliTPCExBBShape *>(corr);
if (corrC == NULL) {
AliError(TString::Format("Inconsistent class types: %s\%s",IsA()->GetName(),corr->IsA()->GetName()).Data());
void AliTPCExBBShape::Init() {
- //
- // Initialization funtion
- //
-
+ /// Initialization funtion
+
AliMagF* magF= (AliMagF*)TGeoGlobalMagField::Instance()->GetField();
if (!magF) AliError("Magneticd field - not initialized");
Double_t bzField = magF->SolenoidField()/10.; //field in T
if (!param) AliError("Parameters - not initialized");
Double_t vdrift = param->GetDriftV()/1000000.; // [cm/us] // From dataBase: to be updated: per second (ideally)
Double_t ezField = 400; // [V/cm] // to be updated: never (hopefully)
- Double_t wt = -10.0 * (bzField*10) * vdrift / ezField ;
+ Double_t wt = -10.0 * (bzField*10) * vdrift / ezField ;
// Correction Terms for effective omegaTau; obtained by a laser calibration run
SetOmegaTauT1T2(wt,fT1,fT2);
}
void AliTPCExBBShape::Update(const TTimeStamp &/*timeStamp*/) {
- //
- // Update function
- //
+ /// Update function
+
AliMagF* magF= (AliMagF*)TGeoGlobalMagField::Instance()->GetField();
if (!magF) AliError("Magneticd field - not initialized");
Double_t bzField = magF->SolenoidField()/10.; //field in T
if (!param) AliError("Parameters - not initialized");
Double_t vdrift = param->GetDriftV()/1000000.; // [cm/us] // From dataBase: to be updated: per second (ideally)
Double_t ezField = 400; // [V/cm] // to be updated: never (hopefully)
- Double_t wt = -10.0 * (bzField*10) * vdrift / ezField ;
+ Double_t wt = -10.0 * (bzField*10) * vdrift / ezField ;
// Correction Terms for effective omegaTau; obtained by a laser calibration run
SetOmegaTauT1T2(wt,fT1,fT2);
void AliTPCExBBShape::GetCorrection(const Float_t x[],const Short_t roc,Float_t dx[]) {
- //
- // Calculates the space point corrections of the B field inperfections (B field shape)
- //
+ /// Calculates the space point corrections of the B field inperfections (B field shape)
if (!fBField) {
for (Int_t j=0;j<3;++j) dx[j]=0.;
const Float_t intBxOverBz=fScaling*(intBEnd[0]-intBStart[0]);
const Float_t intByOverBz=fScaling*(intBEnd[1]-intBStart[1]);
-
+
dx[0]=fC2*intBxOverBz-fC1*intByOverBz;
dx[1]=fC1*intBxOverBz+fC2*intByOverBz;
dx[2]=0.;
}
void AliTPCExBBShape::GetBxAndByOverBz(const Float_t x[],const Short_t roc,Float_t BxByOverBz[]) {
- //
- // This function is purely for calibration purposes
- // Returns the via AliMagF obtaind B field integrals
- //
+ /// This function is purely for calibration purposes
+ /// Returns the via AliMagF obtaind B field integrals
if (!fBField) {
for (Int_t j=0;j<3;++j) BxByOverBz[j]=0.;
const Float_t intBxOverBz=fScaling*(intBEnd[0]-intBStart[0]);
const Float_t intByOverBz=fScaling*(intBEnd[1]-intBStart[1]);
-
+
BxByOverBz[0]=intBxOverBz;
BxByOverBz[1]=intByOverBz;
}
void AliTPCExBBShape::Print(Option_t* option) const {
- //
- // Print function to check the settings (e.g. voltage offsets)
- // option=="a" prints details of the B field settings and the
- // C0 and C1 coefficents (for calibration purposes)
- //
+ /// Print function to check the settings (e.g. voltage offsets)
+ /// option=="a" prints details of the B field settings and the
+ /// C0 and C1 coefficents (for calibration purposes)
+
TString opt = option; opt.ToLower();
printf("%s\t%s\n - B field settings:\n",GetTitle(),GetName());
fBField->Print(option);
// printf(" - B field: X-Twist: %1.5lf rad, Y-Twist: %1.5lf rad \n",fBField->Print(option));
- if (opt.Contains("a")) { // Print all details
+ if (opt.Contains("a")) { // Print all details
printf(" - T1: %1.4f, T2: %1.4f \n",fT1,fT2);
printf(" - C1: %1.4f, C2: %1.4f \n",fC1,fC2);
- }
+ }
}
Double_t AliTPCExBBShape::GetBFieldXYZ(Double_t gx, Double_t gy, Double_t gz, Int_t axisType){
- //
- // return B field at given x,y,z
- //
+ /// return B field at given x,y,z
+
AliMagF* field = (AliMagF*)TGeoGlobalMagField::Instance()->GetField();
if (!field) return 0;
Double_t xyz[3]={gx,gy,gz};
/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
* See cxx source for full Copyright notice */
-// _________________________________________________________________
-//
-// Begin_Html
-// <h2>AliExBBShape class </h2>
-// The class calculates the space point distortions due to the B field
-// shape imperfections using a second order technique based on integrals
-// over Bz (e.g. int By/Bz) obtained via the AliMagF class. The essential
-// input for this class is the magnetic field maps which can be set via the function SetBField.
-// <p>
-// The class allows "effective Omega Tau" corrections.
-// End_Html
-// Begin_Macro(source)
-// {
-// gROOT->SetStyle("Plain"); gStyle->SetPalette(1);
-// TCanvas *c2 = new TCanvas("cAliTPCExBBShape","cAliTPCExBBShape",500,300);
-// AliTPCExBBShape exb;
-// AliMagF mag("mag","mag"); // 0.5 Tesla (solenoid)
-// exb.SetBField(&mag); // use Bfield from AliMagF
-// exb.SetOmegaTauT1T2(-0.32,1.,1.); // values ideally from OCDB
-// exb.CreateHistoDRPhiinZR(0,100,100)->Draw("surf2");
-// return c2;
-// }
-// End_Macro
-// Begin_Html
-// <p>
-// Date: 27/04/2010 <br>
-// Authors: Magnus Mager, Jim Thomas, Stefan Rossegger
-// End_Html
-// _________________________________________________________________
+/// \class AliTPCExBBShape
+/// \brief AliExBBShape class
+///
+/// The class calculates the space point distortions due to the B field
+/// shape imperfections using a second order technique based on integrals
+/// over Bz (e.g. int By/Bz) obtained via the AliMagF class. The essential
+/// input for this class is the magnetic field maps which can be set via the function SetBField.
+///
+/// The class allows "effective Omega Tau" corrections.
+/// 
+///
+/// \author Magnus Mager, Jim Thomas, Stefan Rossegger
+/// \date 27/04/2010
#include "AliTPCCorrection.h"
class AliTPCExBBShape : public AliTPCCorrection {
public:
AliTPCExBBShape();
- virtual ~AliTPCExBBShape();
+ virtual ~AliTPCExBBShape();
virtual Bool_t AddCorrectionCompact(AliTPCCorrection* corr, Double_t weight);
// initialization and update functions
static Double_t GetBFieldXYZ(Double_t gx, Double_t gy, Double_t gz, Int_t axisType);
Double_t GetScaling() const {return fScaling;}
private:
- Float_t fC1; // coefficient C1 (compare Jim Thomas's notes for definitions)
- Float_t fC2; // coefficient C2 (compare Jim Thomas's notes for definitions)
- Float_t fScaling; // scaling factor to rescale distortion - for tests purposes only
- AliMagF *fBField; // pointer to magnetic field
+ Float_t fC1; ///< coefficient C1 (compare Jim Thomas's notes for definitions)
+ Float_t fC2; ///< coefficient C2 (compare Jim Thomas's notes for definitions)
+ Float_t fScaling; ///< scaling factor to rescale distortion - for tests purposes only
+ AliMagF *fBField; ///< pointer to magnetic field
AliTPCExBBShape & operator =(const AliTPCExBBShape &); // dummy assignment operator
AliTPCExBBShape(const AliTPCExBBShape&); //dummy copy contructor
+ /// \cond CLASSIMP
ClassDef(AliTPCExBBShape,2);
+ /// \endcond
};
#endif
* provided "as is" without express or implied warranty. *
**************************************************************************/
-////////////////////////////////////////////////////////////////////////////
-// //
-// AliTPCExBEffective class //
-// Correct for the rest of ExB effect which are not covered by physical models
-//
-// Motivation:
-// ExB correction:
-// dr = c0* integral(Er/Ez) + c1* integral(Erphi/Ez)
-// drphi = -c1* integral(Er/Ez) + c0* integral(Erphi/Ez)
-// Where:
-// wt = Bz*(k*vdrift/E) ~ 0.3 at B=0.5 T
-// c0 = 1/(1+T2*T2*wt*wt)
-// c1 = T1*wt/(1+T1*T1*wt*wt)
-//
-// Residual integral(Er/Ez,Erphi/Ez) obtained comparing the B field 0 and B field +-0.5 T setting
-// minimizing track matching residuals
-// delta(Er/Ez) ~ sum[ poln(r) * polm(z) * cos(n,phi)]
-//
-////////////////////////////////////////////////////////////////////////////
+/// \class AliTPCExBEffective
+/// \brief Correct for the rest of ExB effect which are not covered by physical models
+///
+/// Motivation:
+/// ExB correction:
+/// dr = c0* integral(Er/Ez) + c1* integral(Erphi/Ez)
+/// drphi = -c1* integral(Er/Ez) + c0* integral(Erphi/Ez)
+/// Where:
+/// wt = Bz*(k*vdrift/E) ~ 0.3 at B=0.5 T
+/// c0 = 1/(1+T2*T2*wt*wt)
+/// c1 = T1*wt/(1+T1*T1*wt*wt)
+///
+/// Residual integral(Er/Ez,Erphi/Ez) obtained comparing the B field 0 and B field +-0.5 T setting
+/// minimizing track matching residuals
+/// delta(Er/Ez) ~ sum[ poln(r) * polm(z) * cos(n,phi)]
+
#include "AliMagF.h"
#include "TGeoGlobalMagField.h"
#include "AliTPCcalibDB.h"
#include "TMath.h"
#include "AliTPCROC.h"
#include "AliTPCExBEffective.h"
+/// \cond CLASSIMP
ClassImp(AliTPCExBEffective)
+/// \endcond
AliTPCExBEffective::AliTPCExBEffective()
: AliTPCCorrection("ExB_effective","ExB effective"),
- fC0(1.),fC1(0.),
+ fC0(1.),fC1(0.),
fPolynomA(0),
fPolynomC(0),
fPolynomValA(0),
}
AliTPCExBEffective::~AliTPCExBEffective() {
- //
- // default destructor
- //
+ /// default destructor
+
}
void AliTPCExBEffective::Init() {
- //
- // Initialization funtion
- //
-
+ /// Initialization funtion
+
AliMagF* magF= (AliMagF*)TGeoGlobalMagField::Instance()->GetField();
if (!magF) AliError("Magneticd field - not initialized");
Double_t bzField = magF->SolenoidField()/10.; //field in T
if (!param) AliError("Parameters - not initialized");
Double_t vdrift = param->GetDriftV()/1000000.; // [cm/us] // From dataBase: to be updated: per second (ideally)
Double_t ezField = 400; // [V/cm] // to be updated: never (hopefully)
- Double_t wt = -10.0 * (bzField*10) * vdrift / ezField ;
+ Double_t wt = -10.0 * (bzField*10) * vdrift / ezField ;
// Correction Terms for effective omegaTau; obtained by a laser calibration run
SetOmegaTauT1T2(wt,fT1,fT2);
}
void AliTPCExBEffective::Update(const TTimeStamp &/*timeStamp*/) {
- //
- // Update function
- //
+ /// Update function
+
AliMagF* magF= (AliMagF*)TGeoGlobalMagField::Instance()->GetField();
if (!magF) AliError("Magneticd field - not initialized");
Double_t bzField = magF->SolenoidField()/10.; //field in T
if (!param) AliError("Parameters - not initialized");
Double_t vdrift = param->GetDriftV()/1000000.; // [cm/us] // From dataBase: to be updated: per second (ideally)
Double_t ezField = 400; // [V/cm] // to be updated: never (hopefully)
- Double_t wt = -10.0 * (bzField*10) * vdrift / ezField ;
+ Double_t wt = -10.0 * (bzField*10) * vdrift / ezField ;
// Correction Terms for effective omegaTau; obtained by a laser calibration run
SetOmegaTauT1T2(wt,fT1,fT2);
void AliTPCExBEffective::GetCorrection(const Float_t x[],const Short_t roc,Float_t dx[]) {
- //
- // Calculates the correction due conical shape
- //
+ /// Calculates the correction due conical shape
+
if (!fPolynomA) return;
AliTPCROC * calROC = AliTPCROC::Instance();
const Double_t kRTPC0 =calROC->GetPadRowRadii(0,0);
Double_t dr = fC0 * erez + fC1 * erphiez;
Double_t drphi = -fC1 * erez + fC0 * erphiez;
-
+
// Calculate distorted position
if ( r > 0.0 ) {
r = r + dr;
Double_t AliTPCExBEffective::GetSum(const TMatrixD& mpol, const TMatrixD&mcoef, Double_t r, Double_t drift, Double_t phi, Int_t coord) const {
- //
- // Summation of the polynomials
- //
+ /// Summation of the polynomials
+
Int_t npols=mpol.GetNrows();
Double_t sum=0;
for (Int_t ipol=0;ipol<npols; ipol++){
}
return sum;
}
-
+
void AliTPCExBEffective::SetPolynoms(const TMatrixD *polA,const TMatrixD *polC){
- //
- // Set correction polynom - coefficients
- //
+ /// Set correction polynom - coefficients
+
fPolynomA = new TMatrixD(*polA);
fPolynomC = new TMatrixD(*polC);
}
void AliTPCExBEffective::SetCoeficients(const TMatrixD *valA,const TMatrixD *valC){
- //
- // Set correction polynom - coefficients
- //
+ /// Set correction polynom - coefficients
+
fPolynomValA = new TMatrixD(*valA);
fPolynomValC = new TMatrixD(*valC);
}
void AliTPCExBEffective::Print(const Option_t* option) const {
- //
- // Print function to check the settings (e.g. the twist in the X direction)
- // option=="a" prints the C0 and C1 coefficents for calibration purposes
- //
+ /// Print function to check the settings (e.g. the twist in the X direction)
+ /// option=="a" prints the C0 and C1 coefficents for calibration purposes
TString opt = option; opt.ToLower();
printf("%s\t%s\n",GetName(),GetTitle());
-
+
if (opt.Contains("a")) { // Print all details
printf(" - T1: %1.4f, T2: %1.4f \n",fT1,fT2);
printf(" - C0: %1.4f, C1: %1.4f \n",fC0,fC1);
fPolynomValA->Print();
fPolynomValC->Print();
- }
-
-
+ }
+
+
}
/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
* See cxx source for full Copyright notice */
-////////////////////////////////////////////////////////////////////////////
-// //
-// AliTPCExBEffective class //
-// date: 02/05/2010 //
-// Authors: Maarian Ivanov, Jim Thomas, Magnus Mager, Stefan Rossegger //
-////////////////////////////////////////////////////////////////////////////
+/// \class AliTPCExBEffective
+///
+/// \author Maarian Ivanov, Jim Thomas, Magnus Mager, Stefan Rossegger
+/// \date 02/05/2010
#include "AliTPCCorrection.h"
virtual void GetCorrection(const Float_t x[],const Short_t roc,Float_t dx[]);
private:
- Double_t fC0; // coefficient C0 (compare Jim Thomas's notes for definitions)
- Double_t fC1; // coefficient C1 (compare Jim Thomas's notes for definitions)
- TMatrixD *fPolynomA; // correction polynoms A
- TMatrixD *fPolynomC; // correction polynoms C
- TMatrixD *fPolynomValA; // correction polynoms coefficient A
- TMatrixD *fPolynomValC; // correction polynoms coefficient C
+ Double_t fC0; ///< coefficient C0 (compare Jim Thomas's notes for definitions)
+ Double_t fC1; ///< coefficient C1 (compare Jim Thomas's notes for definitions)
+ TMatrixD *fPolynomA; ///< correction polynoms A
+ TMatrixD *fPolynomC; ///< correction polynoms C
+ TMatrixD *fPolynomValA; ///< correction polynoms coefficient A
+ TMatrixD *fPolynomValC; ///< correction polynoms coefficient C
AliTPCExBEffective(const AliTPCExBEffective&);
AliTPCExBEffective &operator=(const AliTPCExBEffective&);
+ /// \cond CLASSIMP
ClassDef(AliTPCExBEffective,1);
+ /// \endcond
};
#endif
* provided "as is" without express or implied warranty. *
**************************************************************************/
-////////////////////////////////////////////////////////////////////////////
-// //
-// AliTPCExBEffectiveSector class //
-// Correct for the rest of ExB effect which are not covered yet by physical models
-//
-// Motivation:
-// ExB correction:
-// dr = c0* integral(Er/Ez) + c1* integral(Erphi/Ez)
-// drphi = -c1* integral(Er/Ez) + c0* integral(Erphi/Ez)
-// Where:
-// wt = Bz*(k*vdrift/E) ~ 0.3 at B=0.5 T
-// c0 = 1/(1+T2*T2*wt*wt)
-// c1 = T1*wt/(1+T1*T1*wt*wt)
-//
-//
-// 3 correction maps 0 implemented as histogram used
-// R-Phi correction map obtained minimizing residuals betwee the track
-// and space points (AliTPCcalibAlign class). Track is defined using
-// the points from the refernce plain at the middle of the TPC
-// and vertex
-// Corrected primar tracks straight pointing to the primary vertex
-//
-// R distortion - obtained using the cluster residuals in the setup with
-// plus and minus field
-// Only high momenta tracks used for this calibration (1 GeV threshold)
-// drphi_plus-drphi_minus=-2*c1 integral(Er/Ez)
-// - Erphi/Ez cancels
-////////////////////////////////////////////////////////////////////////////
+/// \class AliTPCExBEffectiveSector
+/// \brief Correct for the rest of ExB effect which are not covered yet by physical models
+///
+/// Motivation:
+/// ExB correction:
+/// dr = c0* integral(Er/Ez) + c1* integral(Erphi/Ez)
+/// drphi = -c1* integral(Er/Ez) + c0* integral(Erphi/Ez)
+/// Where:
+/// wt = Bz*(k*vdrift/E) ~ 0.3 at B=0.5 T
+/// c0 = 1/(1+T2*T2*wt*wt)
+/// c1 = T1*wt/(1+T1*T1*wt*wt)
+///
+/// 3 correction maps 0 implemented as histogram used
+/// R-Phi correction map obtained minimizing residuals betwee the track
+/// and space points (AliTPCcalibAlign class). Track is defined using
+/// the points from the refernce plain at the middle of the TPC
+/// and vertex
+/// Corrected primar tracks straight pointing to the primary vertex
+///
+/// R distortion - obtained using the cluster residuals in the setup with
+/// plus and minus field
+/// Only high momenta tracks used for this calibration (1 GeV threshold)
+/// drphi_plus-drphi_minus=-2*c1 integral(Er/Ez)
+/// - Erphi/Ez cancels
+
#include "AliMagF.h"
#include "TGeoGlobalMagField.h"
#include "AliTPCcalibDB.h"
#include "TH3F.h"
#include "TROOT.h"
#include "AliTPCExBEffectiveSector.h"
+/// \cond CLASSIMP
ClassImp(AliTPCExBEffectiveSector)
+/// \endcond
AliTPCExBEffectiveSector::AliTPCExBEffectiveSector()
: AliTPCCorrection("ExB_effectiveSector","ExB effective sector"),
- fC0(1.),fC1(0.),
+ fC0(1.),fC1(0.),
fCorrectionR(0), // radial correction
fCorrectionRPhi(0), // r-phi correction
fCorrectionZ(0) // z correction
}
AliTPCExBEffectiveSector::~AliTPCExBEffectiveSector() {
- //
- // default destructor
- //
+ /// default destructor
+
delete fCorrectionR; // radial correction
delete fCorrectionRPhi; // r-phi correction
delete fCorrectionZ; // z correction
void AliTPCExBEffectiveSector::Init() {
- //
- // Initialization funtion
- //
-
+ /// Initialization funtion
+
AliMagF* magF= (AliMagF*)TGeoGlobalMagField::Instance()->GetField();
if (!magF) AliError("Magneticd field - not initialized");
Double_t bzField = magF->SolenoidField()/10.; //field in T
if (!param) AliError("Parameters - not initialized");
Double_t vdrift = param->GetDriftV()/1000000.; // [cm/us] // From dataBase: to be updated: per second (ideally)
Double_t ezField = 400; // [V/cm] // to be updated: never (hopefully)
- Double_t wt = -10.0 * (bzField*10) * vdrift / ezField ;
+ Double_t wt = -10.0 * (bzField*10) * vdrift / ezField ;
// Correction Terms for effective omegaTau; obtained by a laser calibration run
SetOmegaTauT1T2(wt,fT1,fT2);
}
void AliTPCExBEffectiveSector::Update(const TTimeStamp &/*timeStamp*/) {
- //
- // Update function
- //
+ /// Update function
+
AliMagF* magF= (AliMagF*)TGeoGlobalMagField::Instance()->GetField();
if (!magF) AliError("Magneticd field - not initialized");
Double_t bzField = magF->SolenoidField()/10.; //field in T
if (!param) AliError("Parameters - not initialized");
Double_t vdrift = param->GetDriftV()/1000000.; // [cm/us] // From dataBase: to be updated: per second (ideally)
Double_t ezField = 400; // [V/cm] // to be updated: never (hopefully)
- Double_t wt = -10.0 * (bzField*10) * vdrift / ezField ;
+ Double_t wt = -10.0 * (bzField*10) * vdrift / ezField ;
// Correction Terms for effective omegaTau; obtained by a laser calibration run
SetOmegaTauT1T2(wt,fT1,fT2);
}
void AliTPCExBEffectiveSector::GetCorrection(const Float_t x[],const Short_t roc,Float_t dx[]) {
- //
- // Calculates the correction using the lookup table (histogram) of distortion
- // The histogram is created as poscl - postrack
- //
+ /// Calculates the correction using the lookup table (histogram) of distortion
+ /// The histogram is created as poscl - postrack
+
dx[0]=0;
dx[1]=0;
dx[2]=0;
if (roc%36>=18) kZ=-TMath::Abs(kZ);
if (TMath::Abs(kZ)<0.15){
kZ = (roc%36<18) ? 0.15:-0.15;
- }
+ }
//
Double_t dlR=0;
Double_t dlRPhi=0;
Double_t kZZ=TMath::Max(kZ,fCorrectionRPhi->GetZaxis()->GetXmin()+0.001);
kZZ=TMath::Min(kZZ,fCorrectionRPhi->GetZaxis()->GetXmax()-0.001);
- if (fCorrectionRPhi) {
+ if (fCorrectionRPhi) {
// dlRPhi= -fCorrectionRPhi->Interpolate(sector,rr,kZZ);
dlRPhi= -fCorrectionRPhi->GetBinContent(fCorrectionRPhi->FindBin(sector,rr,kZZ));
}
// Calculate correction in cartesian coordinates
dx[0] = r * TMath::Cos(phi) - x[0];
dx[1] = r * TMath::Sin(phi) - x[1];
- dx[2] = dlZ;
+ dx[2] = dlZ;
}
void AliTPCExBEffectiveSector::Print(const Option_t* option) const {
- //
- // Print function to check the settings (e.g. the twist in the X direction)
- // option=="a" prints the C0 and C1 coefficents for calibration purposes
- //
+ /// Print function to check the settings (e.g. the twist in the X direction)
+ /// option=="a" prints the C0 and C1 coefficents for calibration purposes
TString opt = option; opt.ToLower();
- printf("%s\t%s\n",GetName(),GetTitle());
+ printf("%s\t%s\n",GetName(),GetTitle());
if (opt.Contains("a")) { // Print all details
printf(" - T1: %1.4f, T2: %1.4f \n",fT1,fT2);
printf(" - C0: %1.4f, C1: %1.4f \n",fC0,fC1);
- }
+ }
}
/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
* See cxx source for full Copyright notice */
-////////////////////////////////////////////////////////////////////////////
-// //
-// AliTPCExBEffectiveSector class //
-// date: 02/05/2010 //
-// Authors: Maarian Ivanov, Jim Thomas, Magnus Mager, Stefan Rossegger //
-////////////////////////////////////////////////////////////////////////////
+/// \class AliTPCExBEffectiveSector
+///
+/// \author Maarian Ivanov, Jim Thomas, Magnus Mager, Stefan Rossegger
+/// \date 02/05/2010
#include "AliTPCCorrection.h"
class TH3F;
public:
virtual void GetCorrection(const Float_t x[],const Short_t roc,Float_t dx[]);
public:
- Double_t fC0; // coefficient C0 (compare Jim Thomas's notes for definitions)
- Double_t fC1; // coefficient C1 (compare Jim Thomas's notes for definitions)
- TH3F *fCorrectionR; // radial correction
- TH3F *fCorrectionRPhi; // r-phi correction
- TH3F *fCorrectionZ; // z correction
+ Double_t fC0; ///< coefficient C0 (compare Jim Thomas's notes for definitions)
+ Double_t fC1; ///< coefficient C1 (compare Jim Thomas's notes for definitions)
+ TH3F *fCorrectionR; ///< radial correction
+ TH3F *fCorrectionRPhi; ///< r-phi correction
+ TH3F *fCorrectionZ; ///< z correction
private:
AliTPCExBEffectiveSector(const AliTPCExBEffectiveSector&);
AliTPCExBEffectiveSector &operator=(const AliTPCExBEffectiveSector&);
+ /// \cond CLASSIMP
ClassDef(AliTPCExBEffectiveSector,2);
+ /// \endcond
};
#endif
* provided "as is" without express or implied warranty. *
**************************************************************************/
-////
-// This implementation AliTPCExB is using an "exact" calculation of the ExB
-// effect. That is, it uses the drift ODE to calculate the distortion
-// without any further assumption.
-// Due to the numerical integration of the ODE, there are some numerical
-// uncertencies involed.
-////
+/// \class AliTPCExBExact
+/// \brief This implementation AliTPCExB is using an "exact" calculation of the ExB effect.
+///
+/// That is, it uses the drift ODE to calculate the distortion
+/// without any further assumption.
+/// Due to the numerical integration of the ODE, there are some numerical
+/// uncertencies involed.
#include "TMath.h"
#include "TTreeStream.h"
#include "AliMagF.h"
#include "AliTPCExBExact.h"
+/// \cond CLASSIMP
ClassImp(AliTPCExBExact)
+/// \endcond
const Double_t AliTPCExBExact::fgkEM=1.602176487e-19/9.10938215e-31;
const Double_t AliTPCExBExact::fgkDriftField=-40.e3;
fkXMin(-250.),fkXMax(250.),fkYMin(-250.),fkYMax(250.),
fkZMin(-250.),fkZMax(250.),
fkNLook(0),fkLook(0) {
- //
- // purely for I/O
- //
+ /// purely for I/O
+
}
AliTPCExBExact::AliTPCExBExact(const AliMagF *bField,
fkXMin(-250.),fkXMax(250.),fkYMin(-250.),fkYMax(250.),
fkZMin(-250.),fkZMax(250.),
fkNLook(0),fkLook(0) {
- //
- // The constructor. One has to supply a magnetic field and an (initial)
- // drift velocity. Since some kind of lookuptable is created the
- // number of its meshpoints can be supplied.
- // n sets the number of integration steps to be used when integrating
- // over the full drift length.
- //
+ /// The constructor. One has to supply a magnetic field and an (initial)
+ /// drift velocity. Since some kind of lookuptable is created the
+ /// number of its meshpoints can be supplied.
+ /// n sets the number of integration steps to be used when integrating
+ /// over the full drift length.
+
CreateLookupTable();
}
/*
AliTPCExBExact::AliTPCExBExact(const AliFieldMap *bFieldMap,
- Double_t driftVelocity,Int_t n)
+ Double_t driftVelocity,Int_t n)
: fDriftVelocity(driftVelocity),
- fkMap(bFieldMap),fkField(0),fkN(n),
+ fkMap(bFieldMap),fkField(0),fkN(n),
fkNX(0),fkNY(0),fkNZ(0),
fkXMin(-250.),fkXMax(250.),fkYMin(-250.),fkYMax(250.),
fkZMin(-250.),fkZMax(250.),
*/
AliTPCExBExact::~AliTPCExBExact() {
- //
- // destruct the poor object.
- //
+ /// destruct the poor object.
+
delete[] fkLook;
}
void AliTPCExBExact::Correct(const Double_t *position, Double_t *corrected) {
- //
- // correct for the distortion
- //
+ /// correct for the distortion
+
Double_t x=(position[0]-fkXMin)/(fkXMax-fkXMin)*(fkNX-1);
Int_t xi1=static_cast<Int_t>(x);
xi1=TMath::Max(TMath::Min(xi1,fkNX-2),0);
Int_t xi2=xi1+1;
Double_t dx=(x-xi1);
Double_t dx1=(xi2-x);
-
+
Double_t y=(position[1]-fkYMin)/(fkYMax-fkYMin)*(fkNY-1);
Int_t yi1=static_cast<Int_t>(y);
yi1=TMath::Max(TMath::Min(yi1,fkNY-2),0);
Int_t yi2=yi1+1;
Double_t dy=(y-yi1);
Double_t dy1=(yi2-y);
-
+
Double_t z=position[2]/fkZMax*(fkNZ-1);
Int_t side;
if (z>0) {
Int_t zi2=zi1+1;
Double_t dz=(z-zi1);
Double_t dz1=(zi2-z);
-
+
for (int i=0;i<3;++i)
corrected[i]
=fkLook[(((xi1*fkNY+yi1)*fkNZ+zi1)*2+side)*3+i]*dx1*dy1*dz1
void AliTPCExBExact::TestThisBeautifulObject(const AliMagF *bField,
const char* fileName) {
- //
- // Have a look at the common part "TestThisBeautifulObjectGeneric".
- //
+ /// Have a look at the common part "TestThisBeautifulObjectGeneric".
+
fkField=bField;
//fkMap=0;
TestThisBeautifulObjectGeneric(fileName);
}
void AliTPCExBExact::TestThisBeautifulObjectGeneric(const char* fileName) {
- //
- // Well, as the name sais... it tests the object.
- //
+ /// Well, as the name sais... it tests the object.
+
TTreeSRedirector ts(fileName);
Double_t x[3];
for (x[0]=-250.;x[0]<=250.;x[0]+=10.)
}
void AliTPCExBExact::CreateLookupTable() {
- //
- // Helper function to fill the lookup table.
- //
+ /// Helper function to fill the lookup table.
+
fkNLook=fkNX*fkNY*fkNZ*2*3;
fkLook=new Double_t[fkNLook];
Double_t x[3];
}
void AliTPCExBExact::GetE(Double_t *e,const Double_t *x) const {
- //
- // Helper function returning the E field in SI units (V/m).
- //
+ /// Helper function returning the E field in SI units (V/m).
+
e[0]=0.;
e[1]=0.;
e[2]=(x[2]<0.?-1.:1.)*fgkDriftField; // in V/m
}
void AliTPCExBExact::GetB(Double_t *b,const Double_t *x) const {
- //
- // Helper function returning the B field in SI units (T).
- //
+ /// Helper function returning the B field in SI units (T).
+
Double_t xm[3];
- // the beautiful m to cm (and the ugly "const_cast") and Double_t
+ // the beautiful m to cm (and the ugly "const_cast") and Double_t
// to Float_t read the NRs introduction!:
for (int i=0;i<3;++i) xm[i]=x[i]*100.;
Double_t bf[3];
void AliTPCExBExact::Motion(const Double_t *x,Double_t,
Double_t *dxdt) const {
- //
- // The differential equation of motion of the electrons.
- //
+ /// The differential equation of motion of the electrons.
+
Double_t tau=fDriftVelocity/fgkDriftField/fgkEM;
Double_t tau2=tau*tau;
Double_t e[3];
void AliTPCExBExact::CalculateDistortion(const Double_t *x0,
Double_t *dist) const {
- //
- // Helper function that calculates one distortion by integration
- // (only used to fill the lookup table).
- //
+ /// Helper function that calculates one distortion by integration
+ /// (only used to fill the lookup table).
+
Double_t h=0.01*250./fDriftVelocity/fkN;
Double_t t=0.;
Double_t xt[3];
}
void AliTPCExBExact::DGLStep(Double_t *x,Double_t t,Double_t h) const {
- //
- // An elementary integration step.
- // (simple Euler Method)
- //
+ /// An elementary integration step.
+ /// (simple Euler Method)
+
Double_t dxdt[3];
Motion(x,t,dxdt);
for (int i=0;i<3;++i)
/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
* See cxx source for full Copyright notice */
-////
-// An exact implementation of the ExB effect.
-////
+/// \class AliTPCExBExact
+/// \brief An exact implementation of the ExB effect.
#ifndef ALITPCEXBEXACT_H
#define ALITPCEXBEXACT_H
//void TestThisBeautifulObject(const AliFieldMap *bFieldMap,const char* fileName);
void TestThisBeautifulObject(const AliMagF *bField,const char* fileName);
protected:
- Double_t fDriftVelocity; // The electron drift velocity.
+ Double_t fDriftVelocity; ///< The electron drift velocity.
private:
AliTPCExBExact& operator=(const AliTPCExBExact&); // don't assign me
AliTPCExBExact(const AliTPCExBExact&); // don't copy me
void CalculateDistortion(const Double_t *x,Double_t *dist) const;
void DGLStep(Double_t *x,Double_t t,Double_t h) const;
//const AliFieldMap *fkMap; //! the magnetic field map as supplied by the user
- const AliMagF *fkField; //! the magnetic field as supplied by the user
- Int_t fkN; // max number of integration steps
- Int_t fkNX; // field mesh points in x direction
- Int_t fkNY; // field mesh points in y direction
- Int_t fkNZ; // field mesh points in z direction
- Double_t fkXMin; // the first grid point in x direction
- Double_t fkXMax; // the last grid point in x direction
- Double_t fkYMin; // the first grid point in y direction
- Double_t fkYMax; // the last grid point in y direction
- Double_t fkZMin; // the first grid point in z direction
- Double_t fkZMax; // the last grid point in z direction
- Int_t fkNLook; // size of the lookup table
- Double_t *fkLook; //[fkNLook] the great lookup table
- static const Double_t fgkEM; //! elementary charge over electron mass (C/kg)
- static const Double_t fgkDriftField; //! the TPC drift field (V/m) (modulus)
+ const AliMagF *fkField; //!< the magnetic field as supplied by the user
+ Int_t fkN; ///< max number of integration steps
+ Int_t fkNX; ///< field mesh points in x direction
+ Int_t fkNY; ///< field mesh points in y direction
+ Int_t fkNZ; ///< field mesh points in z direction
+ Double_t fkXMin; ///< the first grid point in x direction
+ Double_t fkXMax; ///< the last grid point in x direction
+ Double_t fkYMin; ///< the first grid point in y direction
+ Double_t fkYMax; ///< the last grid point in y direction
+ Double_t fkZMin; ///< the first grid point in z direction
+ Double_t fkZMax; ///< the last grid point in z direction
+ Int_t fkNLook; ///< size of the lookup table
+ /// the great lookup table
+ Double_t *fkLook; //[fkNLook]
+ static const Double_t fgkEM; //!< elementary charge over electron mass (C/kg)
+ static const Double_t fgkDriftField; //!< the TPC drift field (V/m) (modulus)
+ /// \cond CLASSIMP
ClassDef(AliTPCExBExact,1)
+ /// \endcond
};
#endif
* provided "as is" without express or implied warranty. *
**************************************************************************/
-//
-// This implementation AliTPCExB is using an aproximate calculation of the ExB
-// effect. Therefore the drift ODE is Taylor expanded and only the first
-// order part is taken.
-//
-//
-// The ExB correction map is stored in the calib DB
-// To test current version:
-/*
- char *storage = "local://OCDBres"
- Int_t RunNumber=0;
- AliCDBManager::Instance()->SetDefaultStorage(storage);
- AliCDBManager::Instance()->SetRun(RunNumber)
- AliTPCExBFirst * exb = AliTPCcalibDB::Instance()->GetExB();
-
- // exb->TestExB("exb.root");
- // TFile f("exb.root");
- //positions->Draw("drphi");
-*/
+/// \class AliTPCExBFirst
+/// \brief This implementation AliTPCExB is using an aproximate calculation of the ExB effect
+///
+/// Therefore the drift ODE is Taylor expanded and only the first
+/// order part is taken.
+///
+/// The ExB correction map is stored in the calib DB
+/// To test current version:
+///
+/// ~~~
+/// char *storage = "local://OCDBres"
+/// Int_t RunNumber=0;
+/// AliCDBManager::Instance()->SetDefaultStorage(storage);
+/// AliCDBManager::Instance()->SetRun(RunNumber)
+/// AliTPCExBFirst * exb = AliTPCcalibDB::Instance()->GetExB();
+///
+/// // exb->TestExB("exb.root");
+/// // TFile f("exb.root");
+/// //positions->Draw("drphi");
+/// ~~~
#include "TTreeStream.h"
#include "AliTPCExBFirst.h"
+/// \cond CLASSIMP
ClassImp(AliTPCExBFirst)
+/// \endcond
const Double_t AliTPCExBFirst::fgkEM=1.602176487e-19/9.10938215e-31;
const Double_t AliTPCExBFirst::fgkDriftField=-40.e3;
fkZMin(-250.),fkZMax(250.),
fkNMean(0),
fkMeanBx(0),fkMeanBy(0),fkMeanBz(0.) {
- //
- // purely for I/O
- //
+ /// purely for I/O
+
SetInstance(this);
}
fkZMin(-250.),fkZMax(250.),
fkNMean(0),
fkMeanBx(0),fkMeanBy(0),fkMeanBz(0.) {
- //
- // The constructor. One has to supply a magnetic field and an (initial)
- // drift velocity. Since some kind of lookuptable is created the
- // number of its meshpoints can be supplied.
- //
- // ConstructCommon(0,bField);
+ /// The constructor. One has to supply a magnetic field and an (initial)
+ /// drift velocity. Since some kind of lookuptable is created the
+ /// number of its meshpoints can be supplied.
+ ///
+ /// ConstructCommon(0,bField);
+
ConstructCommon(bField);
SetInstance(this);
}
/*
AliTPCExBFirst::AliTPCExBFirst(const AliFieldMap *bFieldMap,
- Double_t driftVelocity)
+ Double_t driftVelocity)
: fDriftVelocity(driftVelocity),
fkNX(0),fkNY(0),fkNZ(0),
fkXMin(-250.),fkXMax(250.),fkYMin(-250.),fkYMax(250.),
}
*/
-AliTPCExBFirst::~AliTPCExBFirst() {
- //
- // destruct the poor object.
- //
+AliTPCExBFirst::~AliTPCExBFirst() {
+ /// destruct the poor object.
+
delete[] fkMeanBx;
delete[] fkMeanBy;
}
void AliTPCExBFirst::Correct(const Double_t *position,Double_t *corrected) {
- //
- // correct for the distortion
- //
+ /// correct for the distortion
+
Double_t bx,by;
GetMeanFields(position[0],position[1],position[2],&bx,&by);
if (position[2]>0.) {
by=bye;
}
}
-
+
Double_t mu=fDriftVelocity/fgkDriftField;
Double_t wt=mu*fkMeanBz;
-
+
corrected[0]=mu*(wt*bx-by)/(1.+wt*wt);
corrected[1]=mu*(wt*by+bx)/(1.+wt*wt);
-
+
if (position[2]>0.) {
corrected[0]*=(250.-position[2]);
corrected[1]*=(250.-position[2]);
}
void AliTPCExBFirst::TestThisBeautifulObject(const char* fileName) {
- //
- // well, as the name sais...
- //
+ /// well, as the name sais...
+
TTreeSRedirector ts(fileName);
Double_t x[3];
for (x[0]=-250.;x[0]<=250.;x[0]+=10.)
void AliTPCExBFirst::ConstructCommon(//const AliFieldMap *bFieldMap,
const AliMagF *bField) {
- //
- // THIS IS PRIVATE! (a helper for the constructor)
- //
+ /// THIS IS PRIVATE! (a helper for the constructor)
+
fkNMean=fkNX*fkNY*fkNZ;
fkMeanBx=new Double_t[fkNMean];
fkMeanBy=new Double_t[fkNMean];
// that happens due to the lack of a sophisticated class design:
// if (bFieldMap!=0)
// bFieldMap->Field(xt,b);
- // else
+ // else
((AliMagF*)bField)->Field(xt,b);
bx+=b[0]/10.;
by+=b[1]/10.;
void AliTPCExBFirst::GetMeanFields(Double_t rx,Double_t ry,Double_t rz,
Double_t *Bx,Double_t *By) const {
- //
- // THIS IS PRIVATE! (calculates the mean field utilising a lookup table)
- //
+ /// THIS IS PRIVATE! (calculates the mean field utilising a lookup table)
+
Double_t x=(fkNX-1)*(rx-fkXMin)/(fkXMax-fkXMin);
Int_t xi1=static_cast<Int_t>(x);
xi1=TMath::Max(TMath::Min(xi1,fkNX-2),0);
Int_t yi2=yi1+1;
Double_t dy=(y-yi1);
Double_t dy1=(yi2-y);
-
+
Double_t z=(fkNZ-1)*(rz-fkZMin)/(fkZMax-fkZMin);
Int_t zi1=static_cast<Int_t>(z);
zi1=TMath::Max(TMath::Min(zi1,fkNZ-2),0);
/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
* See cxx source for full Copyright notice */
-////
-// An approximate (first order) implementation of the ExB effect.
-////
+/// \class AliTPCExBFirst
+/// \brief An approximate (first order) implementation of the ExB effect.
#ifndef ALITPCEXBFIRST_H
#define ALITPCEXBFIRST_H
fDriftVelocity=driftVelocity;
};
protected:
- Double_t fDriftVelocity; // The electron drift velocity.
+ Double_t fDriftVelocity; ///< The electron drift velocity.
private:
AliTPCExBFirst& operator=(const AliTPCExBFirst&); // don't assign me
AliTPCExBFirst(const AliTPCExBFirst&); // don't copy me
void ConstructCommon(const AliMagF *bField);
void GetMeanFields(Double_t rx,Double_t ry,Double_t rz,
Double_t *Bx,Double_t *By) const;
- Int_t fkNX; // field mesh points in x direction
- Int_t fkNY; // field mesh points in y direction
- Int_t fkNZ; // field mesh points in z direction
- Double_t fkXMin; // the first grid point in x direction
- Double_t fkXMax; // the last grid point in x direction
- Double_t fkYMin; // the first grid point in y direction
- Double_t fkYMax; // the last grid point in y direction
- Double_t fkZMin; // the first grid point in z direction
- Double_t fkZMax; // the last grid point in z direction
- Int_t fkNMean; // size of the tablE the mean fields
- Double_t *fkMeanBx; //[fkNMean] the mean field in x direction upto a certain z value
- Double_t *fkMeanBy; //[fkNMean] the mean field in y direction upto a certain z value
- Double_t fkMeanBz; // the mean field in z direction inside the TPC volume
- static const Double_t fgkEM; //! elementary charge over electron mass (C/kg)
- static const Double_t fgkDriftField; //! the TPC drift field (V/m) (modulus)
+ Int_t fkNX; ///< field mesh points in x direction
+ Int_t fkNY; ///< field mesh points in y direction
+ Int_t fkNZ; ///< field mesh points in z direction
+ Double_t fkXMin; ///< the first grid point in x direction
+ Double_t fkXMax; ///< the last grid point in x direction
+ Double_t fkYMin; ///< the first grid point in y direction
+ Double_t fkYMax; ///< the last grid point in y direction
+ Double_t fkZMin; ///< the first grid point in z direction
+ Double_t fkZMax; ///< the last grid point in z direction
+ Int_t fkNMean; ///< size of the tablE the mean fields
+ /// the mean field in x direction upto a certain z value
+ Double_t *fkMeanBx; //[fkNMean]
+ /// the mean field in y direction upto a certain z value
+ Double_t *fkMeanBy; //[fkNMean]
+ Double_t fkMeanBz; ///< the mean field in z direction inside the TPC volume
+ static const Double_t fgkEM; //!< elementary charge over electron mass (C/kg)
+ static const Double_t fgkDriftField; //!< the TPC drift field (V/m) (modulus)
+ /// \cond CLASSIMP
ClassDef(AliTPCExBFirst,2)
+ /// \endcond
};
#endif
* provided "as is" without express or implied warranty. *
**************************************************************************/
-////////////////////////////////////////////////////////////////////////////
-// AliTPCExBTwist class //
-////////////////////////////////////////////////////////////////////////////
+/// \class AliTPCExBTwist
+/// \brief AliTPCExBTwist class
#include "AliMagF.h"
fC1(0.),fC2(0.),
fXTwist(0.),fYTwist(0.)
{
- //
- // default constructor
- //
+ /// default constructor
+
}
AliTPCExBTwist::~AliTPCExBTwist() {
- //
- // default destructor
- //
+ /// default destructor
+
}
Bool_t AliTPCExBTwist::AddCorrectionCompact(AliTPCCorrection* corr, Double_t weight){
- //
- // Add correction and make them compact
- // Assumptions:
- // - origin of distortion/correction are additive
- // - only correction ot the same type supported ()
+ /// Add correction and make them compact
+ /// Assumptions:
+ /// - origin of distortion/correction are additive
+ /// - only correction ot the same type supported ()
+
if (corr==NULL) {
AliError("Zerro pointer - correction");
return kFALSE;
- }
+ }
AliTPCExBTwist * corrC = dynamic_cast< AliTPCExBTwist*>(corr);
if (corrC == NULL) return kFALSE;
fXTwist+=weight*corrC->fXTwist; // Twist of E to B field in X-Z [rad]
void AliTPCExBTwist::Init() {
- //
- // Initialization funtion
- //
-
+ /// Initialization funtion
+
AliMagF* magF= (AliMagF*)TGeoGlobalMagField::Instance()->GetField();
if (!magF) AliError("Magneticd field - not initialized");
Double_t bzField = magF->SolenoidField()/10.; //field in T
if (!param) AliError("Parameters - not initialized");
Double_t vdrift = param->GetDriftV()/1000000.; // [cm/us] // From dataBase: to be updated: per second (ideally)
Double_t ezField = 400; // [V/cm] // to be updated: never (hopefully)
- Double_t wt = -10.0 * (bzField*10) * vdrift / ezField ;
+ Double_t wt = -10.0 * (bzField*10) * vdrift / ezField ;
// Correction Terms for effective omegaTau; obtained by a laser calibration run
SetOmegaTauT1T2(wt,fT1,fT2);
}
void AliTPCExBTwist::Update(const TTimeStamp &/*timeStamp*/) {
- //
- // Update function
- //
+ /// Update function
+
AliMagF* magF= (AliMagF*)TGeoGlobalMagField::Instance()->GetField();
if (!magF) AliError("Magneticd field - not initialized");
Double_t bzField = magF->SolenoidField()/10.; //field in T
if (!param) AliError("Parameters - not initialized");
Double_t vdrift = param->GetDriftV()/1000000.; // [cm/us] // From dataBase: to be updated: per second (ideally)
Double_t ezField = 400; // [V/cm] // to be updated: never (hopefully)
- Double_t wt = -10.0 * (bzField*10) * vdrift / ezField ;
+ Double_t wt = -10.0 * (bzField*10) * vdrift / ezField ;
// Correction Terms for effective omegaTau; obtained by a laser calibration run
SetOmegaTauT1T2(wt,fT1,fT2);
void AliTPCExBTwist::GetCorrection(const Float_t x[],const Short_t roc,Float_t dx[]) {
- //
- // Calculates the correction of a mismatch between the E and B field axis
- //
-
+ /// Calculates the correction of a mismatch between the E and B field axis
+
const Float_t zstart=x[2];
const Float_t zend =(roc%36<18?fgkTPCZ0:-fgkTPCZ0);
const Float_t zdrift=zstart-zend;
-
+
dx[0]=(fC2*fXTwist-fC1*fYTwist)*zdrift;
dx[1]=(fC1*fXTwist+fC2*fYTwist)*zdrift;
dx[2]=0.;
}
void AliTPCExBTwist::Print(const Option_t* option) const {
- //
- // Print function to check the settings (e.g. the twist in the X direction)
- // option=="a" prints the C0 and C1 coefficents for calibration purposes
- //
+ /// Print function to check the settings (e.g. the twist in the X direction)
+ /// option=="a" prints the C0 and C1 coefficents for calibration purposes
TString opt = option; opt.ToLower();
printf("%s\n",GetTitle());
-
+
printf(" - Twist settings: X-Twist: %1.5f rad, Y-Twist: %1.5f rad \n",fXTwist,fYTwist);
if (opt.Contains("a")) { // Print all details
printf(" - T1: %1.4f, T2: %1.4f \n",fT1,fT2);
printf(" - C1: %1.4f, C2: %1.4f \n",fC1,fC2);
- }
-
-
+ }
+
+
}
/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
* See cxx source for full Copyright notice */
-// _________________________________________________________________
-//
-// Begin_Html
-// <h2> AliTPCExBTwist class </h2>
-// The class calculates the space point distortions due to a mismatch
-// of the E and B field axis (original code from STAR)
-// <p>
-// It assumes a homogeneous magnetic and electric field. The calculations performed
-// within this class can be written in a compact form as well (compare notes of Jim Thomas)
-// <p>
-// The inputs to this class are the twist angles in the x and y plane ($\theta_x,\theta_y$)
-// in cartesian coordinates. They can be set via the member functions SetXTwist and SetYTwist.
-// End_Html
-//
-// Begin_Macro(source)
-// {
-// gROOT->SetStyle("Plain"); gStyle->SetPalette(1);
-// TCanvas *c2 = new TCanvas("cAliTPCExBTwist","cAliTPCExBTwist",500,300);
-// AliTPCExBTwist twist;
-// twist.SetXTwist(0.001); // x angle in [rad]
-// twist.SetXTwist(0.0005); // y angle in [rad]
-// twist.SetOmegaTauT1T2(0.32,1,1);
-// twist.CreateHistoDRPhiinXY(1.)->Draw("surf2"); // A side
-// return c2;
-// }
-// End_Macro
-//
-// Begin_Html
-// <p>
-// Date: 27/04/2010 <br>
-// Authors: Jim Thomas, Magnus Mager, Stefan Rossegger
-// Support since 2010: mrain.ivanov@cern.ch
-// End_Html
-// _________________________________________________________________
+/// \class AliTPCExBTwist
+/// \brief AliTPCExBTwist class
+///
+/// The class calculates the space point distortions due to a mismatch
+/// of the E and B field axis (original code from STAR)
+///
+/// It assumes a homogeneous magnetic and electric field. The calculations performed
+/// within this class can be written in a compact form as well (compare notes of Jim Thomas)
+///
+/// The inputs to this class are the twist angles in the x and y plane ($\theta_x,\theta_y$)
+/// in cartesian coordinates. They can be set via the member functions SetXTwist and SetYTwist.
+///
+/// 
+///
+/// Support since 2010: mrain.ivanov@cern.ch
+///
+/// \author Jim Thomas, Magnus Mager, Stefan Rossegger
+/// \date 27/04/2010
#include "AliTPCCorrection.h"
// common setters and getters for ExB
virtual void SetOmegaTauT1T2(Float_t omegaTau,Float_t t1,Float_t t2) {
- fT1=t1; fT2=t2;
+ fT1=t1; fT2=t2;
const Float_t wt1=t1*omegaTau; fC1=wt1/(1.+wt1*wt1);
const Float_t wt2=t2*omegaTau; fC2=wt2*wt2/(1.+wt2*wt2);
};
virtual void GetCorrection(const Float_t x[],const Short_t roc,Float_t dx[]);
private:
- Float_t fC1; // coefficient C1 (compare Jim Thomas's notes for definitions)
- Float_t fC2; // coefficient C2 (compare Jim Thomas's notes for definitions)
+ Float_t fC1; ///< coefficient C1 (compare Jim Thomas's notes for definitions)
+ Float_t fC2; ///< coefficient C2 (compare Jim Thomas's notes for definitions)
- Float_t fXTwist; // Twist of E to B field in X-Z [rad]
- Float_t fYTwist; // Twist of E to B field in Y-Z [rad]
+ Float_t fXTwist; ///< Twist of E to B field in X-Z [rad]
+ Float_t fYTwist; ///< Twist of E to B field in Y-Z [rad]
+ /// \cond CLASSIMP
ClassDef(AliTPCExBTwist,1);
+ /// \endcond
};
#endif
* provided "as is" without express or implied warranty. *
**************************************************************************/
-// _________________________________________________________________
-//
-// Begin_Html
-// <h2>AliTPCFCVoltError3D class </h2>
-// The class calculates the space point distortions due to residual voltage errors
-// on the Field Cage (FC) boundaries (rods and strips) of the TPC in 3D. It uses
-// the Poisson relaxation technique in three dimension as implemented in the parent class.
-// <p>
-// Although the calculation is performed in 3D, the calculation time was significantly
-// reduced by using certain symmetry conditions within the calculation.
-// <p>
-// The input parameters can be set via the functions (e.g.) SetRodVoltShift(rod,dV) where
-// rod is the number of the rod on which the voltage offset dV is set. The corresponding
-// shift in z direction would be $dz=dV/40$ with an opposite sign for the C side. The
-// rods are numbered in anti-clock-wise direction starting at $\phi=0$. Rods in the IFC
-// are from 0 to 17, rods on the OFC go from 18 to 35. <br>
-// This convention is following the offline numbering scheme of the ROCs.
-// <p>
-// Different misalignment scenarios can be modeled:
-// <ul>
-// <li> A rotated clip scenario is only possible at two positions (Rod 11 at IFC, rod 3(+18) at OFC)
-// and can be set via SetRotatedClipVolt. The key feature is that at the mentioned positions,
-// the strip-ends were combined. At these positions, a systematic offset of one strip-end in
-// respect to the other is possible.
-// <li> A normal rod offset, where the strips follow the movement of the rod, can be set via
-// SetRodVoltShift. It has a anti-mirrored signature in terms of distortions when compared
-// to the rotated clip. This misalignment is possible at each single rod of the FC.
-// <li> A simple rod offset, where the strips do not follow the shift, results in an even more
-// localized distortion close to the rod. The difference to a rod shift, where the strips follow,
-// is more dominant on the OFC. This effect can be set via the function SetCopperRodShift.
-// </ul>
-// End_Html
-//
-// Begin_Macro(source)
-// {
-// gROOT->SetStyle("Plain"); gStyle->SetPalette(1);
-// TCanvas *c2 = new TCanvas("cAliTPCVoltError3D","cAliTPCVoltError3D",500,450);
-// AliTPCFCVoltError3D fc;
-// fc.SetOmegaTauT1T2(0,1,1);
-// fc.SetRotatedClipVoltA(0,40);
-// fc.SetRodVoltShiftA(3,40);
-// fc.SetCopperRodShiftA(7+18,40);
-// fc.SetRodVoltShiftA(15+18,40);
-// fc.CreateHistoDRPhiinXY(10)->Draw("cont4z");
-// return c2;
-// }
-// End_Macro
-//
-// Begin_Html
-// <p>
-// Date: 08/08/2010 <br>
-// Authors: Jim Thomas, Stefan Rossegger
-// End_Html
-// _________________________________________________________________
+/// \class AliTPCFCVoltError3D
+/// \brief AliTPCFCVoltError3D class
+///
+/// The class calculates the space point distortions due to residual voltage errors
+/// on the Field Cage (FC) boundaries (rods and strips) of the TPC in 3D. It uses
+/// the Poisson relaxation technique in three dimension as implemented in the parent class.
+///
+/// Although the calculation is performed in 3D, the calculation time was significantly
+/// reduced by using certain symmetry conditions within the calculation.
+///
+/// The input parameters can be set via the functions (e.g.) SetRodVoltShift(rod,dV) where
+/// rod is the number of the rod on which the voltage offset dV is set. The corresponding
+/// shift in z direction would be $dz=dV/40$ with an opposite sign for the C side. The
+/// rods are numbered in anti-clock-wise direction starting at $\phi=0$. Rods in the IFC
+/// are from 0 to 17, rods on the OFC go from 18 to 35.
+/// This convention is following the offline numbering scheme of the ROCs.
+///
+/// Different misalignment scenarios can be modeled:
+/// <ul>
+/// <li> A rotated clip scenario is only possible at two positions (Rod 11 at IFC, rod 3(+18) at OFC)
+/// and can be set via SetRotatedClipVolt. The key feature is that at the mentioned positions,
+/// the strip-ends were combined. At these positions, a systematic offset of one strip-end in
+/// respect to the other is possible.
+/// <li> A normal rod offset, where the strips follow the movement of the rod, can be set via
+/// SetRodVoltShift. It has a anti-mirrored signature in terms of distortions when compared
+/// to the rotated clip. This misalignment is possible at each single rod of the FC.
+/// <li> A simple rod offset, where the strips do not follow the shift, results in an even more
+/// localized distortion close to the rod. The difference to a rod shift, where the strips follow,
+/// is more dominant on the OFC. This effect can be set via the function SetCopperRodShift.
+/// </ul>
+/// 
+///
+/// \author Jim Thomas, Stefan Rossegger
+/// \date 08/08/2010
#include "AliMagF.h"
#include "AliTPCROC.h"
#include "AliTPCFCVoltError3D.h"
+/// \cond CLASSIMP
ClassImp(AliTPCFCVoltError3D)
+/// \endcond
AliTPCFCVoltError3D::AliTPCFCVoltError3D()
: AliTPCCorrection("FieldCageVoltErrors","FieldCage (Rods) Voltage Errors"),
// flags for filled 'basic lookup tables'
for (Int_t i=0; i<6; i++){
- fInitLookUpBasic[i]= kFALSE;
+ fInitLookUpBasic[i]= kFALSE;
}
- // Boundary settings
+ // Boundary settings
for (Int_t i=0; i<36; i++){
- fRodVoltShiftA[i] = 0;
- fRodVoltShiftC[i] = 0;
+ fRodVoltShiftA[i] = 0;
+ fRodVoltShiftC[i] = 0;
}
for (Int_t i=0; i<2; i++){
- fRotatedClipVoltA[i] = 0;
- fRotatedClipVoltC[i] = 0;
+ fRotatedClipVoltA[i] = 0;
+ fRotatedClipVoltC[i] = 0;
}
- //
+ //
for (Int_t i=0; i<36; i++){
- fCopperRodShiftA[i] = 0;
- fCopperRodShiftC[i] = 0;
+ fCopperRodShiftA[i] = 0;
+ fCopperRodShiftC[i] = 0;
}
// Array which will contain the solution according to the setted boundary conditions
// it represents a sum up of the 4 basic look up tables (created individually)
// see InitFCVoltError3D() function
for ( Int_t k = 0 ; k < kNPhi ; k++ ) {
- fLookUpErOverEz[k] = new TMatrixF(kNR,kNZ);
+ fLookUpErOverEz[k] = new TMatrixF(kNR,kNZ);
fLookUpEphiOverEz[k] = new TMatrixF(kNR,kNZ);
- fLookUpDeltaEz[k] = new TMatrixF(kNR,kNZ);
+ fLookUpDeltaEz[k] = new TMatrixF(kNR,kNZ);
}
-
+
for ( Int_t k = 0 ; k < kPhiSlices ; k++ ) {
fLookUpBasic1ErOverEz[k] = 0;
- fLookUpBasic1EphiOverEz[k] = 0;
+ fLookUpBasic1EphiOverEz[k] = 0;
fLookUpBasic1DeltaEz[k] = 0;
fLookUpBasic2ErOverEz[k] = 0;
- fLookUpBasic2EphiOverEz[k] = 0;
+ fLookUpBasic2EphiOverEz[k] = 0;
fLookUpBasic2DeltaEz[k] = 0;
fLookUpBasic3ErOverEz[k] = 0;
- fLookUpBasic3EphiOverEz[k] = 0;
+ fLookUpBasic3EphiOverEz[k] = 0;
fLookUpBasic3DeltaEz[k] = 0;
fLookUpBasic4ErOverEz[k] = 0;
- fLookUpBasic4EphiOverEz[k] = 0;
+ fLookUpBasic4EphiOverEz[k] = 0;
fLookUpBasic4DeltaEz[k] = 0;
-
+
fLookUpBasic5ErOverEz[k] = 0;
- fLookUpBasic5EphiOverEz[k] = 0;
+ fLookUpBasic5EphiOverEz[k] = 0;
fLookUpBasic5DeltaEz[k] = 0;
fLookUpBasic6ErOverEz[k] = 0;
- fLookUpBasic6EphiOverEz[k] = 0;
+ fLookUpBasic6EphiOverEz[k] = 0;
fLookUpBasic6DeltaEz[k] = 0;
}
}
AliTPCFCVoltError3D::~AliTPCFCVoltError3D() {
- //
- // destructor
- //
-
+ /// destructor
+
for ( Int_t k = 0 ; k < kNPhi ; k++ ) {
delete fLookUpErOverEz[k];
delete fLookUpEphiOverEz[k];
for ( Int_t k = 0 ; k < kPhiSlices ; k++ ) {
delete fLookUpBasic1ErOverEz[k]; // does nothing if pointer is zero!
- delete fLookUpBasic1EphiOverEz[k];
- delete fLookUpBasic1DeltaEz[k];
+ delete fLookUpBasic1EphiOverEz[k];
+ delete fLookUpBasic1DeltaEz[k];
delete fLookUpBasic2ErOverEz[k]; // does nothing if pointer is zero!
- delete fLookUpBasic2EphiOverEz[k];
- delete fLookUpBasic2DeltaEz[k];
-
+ delete fLookUpBasic2EphiOverEz[k];
+ delete fLookUpBasic2DeltaEz[k];
+
delete fLookUpBasic3ErOverEz[k]; // does nothing if pointer is zero!
- delete fLookUpBasic3EphiOverEz[k];
- delete fLookUpBasic3DeltaEz[k];
+ delete fLookUpBasic3EphiOverEz[k];
+ delete fLookUpBasic3DeltaEz[k];
delete fLookUpBasic4ErOverEz[k]; // does nothing if pointer is zero!
- delete fLookUpBasic4EphiOverEz[k];
- delete fLookUpBasic4DeltaEz[k];
+ delete fLookUpBasic4EphiOverEz[k];
+ delete fLookUpBasic4DeltaEz[k];
delete fLookUpBasic5ErOverEz[k]; // does nothing if pointer is zero!
- delete fLookUpBasic5EphiOverEz[k];
- delete fLookUpBasic5DeltaEz[k];
+ delete fLookUpBasic5EphiOverEz[k];
+ delete fLookUpBasic5DeltaEz[k];
delete fLookUpBasic6ErOverEz[k]; // does nothing if pointer is zero!
- delete fLookUpBasic6EphiOverEz[k];
- delete fLookUpBasic6DeltaEz[k];
+ delete fLookUpBasic6EphiOverEz[k];
+ delete fLookUpBasic6DeltaEz[k];
}
}
Bool_t AliTPCFCVoltError3D::AddCorrectionCompact(AliTPCCorrection* corr, Double_t weight){
- //
- // Add correction and make them compact
- // Assumptions:
- // - origin of distortion/correction are additive
- // - only correction ot the same type supported ()
+ /// Add correction and make them compact
+ /// Assumptions:
+ /// - origin of distortion/correction are additive
+ /// - only correction ot the same type supported ()
+
if (corr==NULL) {
AliError("Zerro pointer - correction");
return kFALSE;
- }
+ }
AliTPCFCVoltError3D * corrC = dynamic_cast<AliTPCFCVoltError3D *>(corr);
if (corrC == NULL) {
AliError(TString::Format("Inconsistent class types: %s\%s",IsA()->GetName(),corr->IsA()->GetName()).Data());
}
//
for (Int_t isec=0; isec<36; isec++){
- fRodVoltShiftA[isec]+= weight*corrC->fRodVoltShiftA[isec]; // Rod (&strips) shift in Volt (40V~1mm)
- fRodVoltShiftC[isec]+=weight*corrC->fRodVoltShiftC[isec]; // Rod (&strips) shift in Volt (40V~1mm)
- fCopperRodShiftA[isec]+=weight*corrC->fCopperRodShiftA[isec]; // only Rod shift
- fCopperRodShiftC[isec]+=weight*corrC->fCopperRodShiftC[isec]; // only Rod shift
+ fRodVoltShiftA[isec]+= weight*corrC->fRodVoltShiftA[isec]; // Rod (&strips) shift in Volt (40V~1mm)
+ fRodVoltShiftC[isec]+=weight*corrC->fRodVoltShiftC[isec]; // Rod (&strips) shift in Volt (40V~1mm)
+ fCopperRodShiftA[isec]+=weight*corrC->fCopperRodShiftA[isec]; // only Rod shift
+ fCopperRodShiftC[isec]+=weight*corrC->fCopperRodShiftC[isec]; // only Rod shift
}
- for (Int_t isec=0; isec<2; isec++){
+ for (Int_t isec=0; isec<2; isec++){
fRotatedClipVoltA[isec]+= weight*corrC->fRotatedClipVoltA[isec]; // rotated clips at HV rod
fRotatedClipVoltC[isec]+= weight*corrC-> fRotatedClipVoltC[isec]; // rotated clips at HV rod
}
void AliTPCFCVoltError3D::Init() {
- //
- // Initialization funtion
- //
-
+ /// Initialization funtion
+
AliMagF* magF= (AliMagF*)TGeoGlobalMagField::Instance()->GetField();
if (!magF) AliError("Magneticd field - not initialized");
Double_t bzField = magF->SolenoidField()/10.; //field in T
if (!param) AliError("Parameters - not initialized");
Double_t vdrift = param->GetDriftV()/1000000.; // [cm/us] // From dataBase: to be updated: per second (ideally)
Double_t ezField = 400; // [V/cm] // to be updated: never (hopefully)
- Double_t wt = -10.0 * (bzField*10) * vdrift / ezField ;
+ Double_t wt = -10.0 * (bzField*10) * vdrift / ezField ;
// Correction Terms for effective omegaTau; obtained by a laser calibration run
SetOmegaTauT1T2(wt,fT1,fT2);
}
void AliTPCFCVoltError3D::Update(const TTimeStamp &/*timeStamp*/) {
- //
- // Update function
- //
+ /// Update function
+
AliMagF* magF= (AliMagF*)TGeoGlobalMagField::Instance()->GetField();
if (!magF) AliError("Magneticd field - not initialized");
Double_t bzField = magF->SolenoidField()/10.; //field in T
if (!param) AliError("Parameters - not initialized");
Double_t vdrift = param->GetDriftV()/1000000.; // [cm/us] // From dataBase: to be updated: per second (ideally)
Double_t ezField = 400; // [V/cm] // to be updated: never (hopefully)
- Double_t wt = -10.0 * (bzField*10) * vdrift / ezField ;
+ Double_t wt = -10.0 * (bzField*10) * vdrift / ezField ;
// Correction Terms for effective omegaTau; obtained by a laser calibration run
SetOmegaTauT1T2(wt,fT1,fT2);
void AliTPCFCVoltError3D::GetCorrection(const Float_t x[],const Short_t roc,Float_t dx[]) {
- //
- // Calculates the correction due e.g. residual voltage errors on the TPC boundaries
- //
+ /// Calculates the correction due e.g. residual voltage errors on the TPC boundaries
+
const Double_t kEpsilon=Double_t(FLT_MIN);
if (!fInitLookUp) {
}
- Int_t order = 1 ; // FIXME: hardcoded? Linear interpolation = 1, Quadratic = 2
+ Int_t order = 1 ; // FIXME: hardcoded? Linear interpolation = 1, Quadratic = 2
// note that the poisson solution was linearly mirroed on this grid!
Float_t intEr, intEphi, intDeltaEz;
Float_t r, phi, z ;
} else {
sign = -1; // (TPC C side)
}
-
+
if ( sign==1 && z < fgkZOffSet ) z = fgkZOffSet; // Protect against discontinuity at CE
if ( sign==-1 && z > -fgkZOffSet ) z = -fgkZOffSet; // Protect against discontinuity at CE
-
+
if ( (sign==1 && z<0) || (sign==-1 && z>0) ) // just a consistency check
AliError("ROC number does not correspond to z coordinate! Calculation of distortions is most likely wrong!");
- // Get the Er and Ephi field integrals plus the integral over DeltaEz
- intEr = Interpolate3DTable(order, r, z, phi, kNR, kNZ, kNPhi,
+ // Get the Er and Ephi field integrals plus the integral over DeltaEz
+ intEr = Interpolate3DTable(order, r, z, phi, kNR, kNZ, kNPhi,
fgkRList, fgkZList, fgkPhiList, fLookUpErOverEz );
- intEphi = Interpolate3DTable(order, r, z, phi, kNR, kNZ, kNPhi,
+ intEphi = Interpolate3DTable(order, r, z, phi, kNR, kNZ, kNPhi,
fgkRList, fgkZList, fgkPhiList, fLookUpEphiOverEz );
- intDeltaEz = Interpolate3DTable(order, r, z, phi, kNR, kNZ, kNPhi,
+ intDeltaEz = Interpolate3DTable(order, r, z, phi, kNR, kNZ, kNPhi,
fgkRList, fgkZList, fgkPhiList, fLookUpDeltaEz );
// printf("%lf %lf %lf\n",intEr,intEphi,intDeltaEz);
// Calculate distorted position
if ( r > 0.0 ) {
- phi = phi + ( fC0*intEphi - fC1*intEr ) / r;
- r = r + ( fC0*intEr + fC1*intEphi );
+ phi = phi + ( fC0*intEphi - fC1*intEr ) / r;
+ r = r + ( fC0*intEr + fC1*intEphi );
}
-
+
// Calculate correction in cartesian coordinates
dx[0] = r * TMath::Cos(phi) - x[0];
- dx[1] = r * TMath::Sin(phi) - x[1];
- dx[2] = intDeltaEz; // z distortion - (internally scaled with driftvelocity dependency
+ dx[1] = r * TMath::Sin(phi) - x[1];
+ dx[2] = intDeltaEz; // z distortion - (internally scaled with driftvelocity dependency
// on the Ez field plus the actual ROC misalignment (if set TRUE)
}
void AliTPCFCVoltError3D::InitFCVoltError3D() {
- //
- // Initialization of the Lookup table which contains the solutions of the
- // Dirichlet boundary problem
- // Calculation of the single 3D-Poisson solver is done just if needed
- // (see basic lookup tables in header file)
- //
+ /// Initialization of the Lookup table which contains the solutions of the
+ /// Dirichlet boundary problem
+ /// Calculation of the single 3D-Poisson solver is done just if needed
+ /// (see basic lookup tables in header file)
- const Int_t order = 1 ; // Linear interpolation = 1, Quadratic = 2
+ const Int_t order = 1 ; // Linear interpolation = 1, Quadratic = 2
const Float_t gridSizeR = (fgkOFCRadius-fgkIFCRadius) / (kRows-1) ;
const Float_t gridSizeZ = fgkTPCZ0 / (kColumns-1) ;
const Float_t gridSizePhi = TMath::TwoPi() / ( 18.0 * kPhiSlicesPerSector);
// temporary arrays to create the boundary conditions
- TMatrixD *arrayofArrayV[kPhiSlices], *arrayofCharge[kPhiSlices] ;
+ TMatrixD *arrayofArrayV[kPhiSlices], *arrayofCharge[kPhiSlices] ;
for ( Int_t k = 0 ; k < kPhiSlices ; k++ ) {
arrayofArrayV[k] = new TMatrixD(kRows,kColumns) ;
arrayofCharge[k] = new TMatrixD(kRows,kColumns) ;
}
Double_t innerList[kPhiSlices], outerList[kPhiSlices] ;
-
+
// list of point as used in the poisson relation and the interpolation (during sum up)
Double_t rlist[kRows], zedlist[kColumns] , philist[kPhiSlices];
for ( Int_t k = 0 ; k < kPhiSlices ; k++ ) {
// ==========================================================================
// Solve Poisson's equation in 3D cylindrical coordinates by relaxation technique
// Allow for different size grid spacing in R and Z directions
-
+
const Int_t symmetry[6] = {1,1,-1,-1,1,1}; // shifted rod (2x), rotated clip (2x), only rod shift on OFC (1x)
// check which lookup tables are needed ---------------------------------
// Rotated clips
if (fRotatedClipVoltA[0]!=0 || fRotatedClipVoltC[0]!=0) needTable[2]=kTRUE;
if (fRotatedClipVoltA[1]!=0 || fRotatedClipVoltC[1]!=0) needTable[3]=kTRUE;
-
- // shifted Copper rods
+
+ // shifted Copper rods
for ( Int_t rod = 0 ; rod < 18 ; rod++ ) {
if (fCopperRodShiftA[rod]!=0) needTable[4]=kTRUE;
if (fCopperRodShiftC[rod]!=0) needTable[4]=kTRUE;
}
- // shifted Copper rods
+ // shifted Copper rods
for ( Int_t rod = 18; rod < 36 ; rod++ ) {
if (fCopperRodShiftA[rod]!=0) needTable[5]=kTRUE;
if (fCopperRodShiftC[rod]!=0) needTable[5]=kTRUE;
// will be deleted in destructor
}
}
-
+
// Set bondaries and solve Poisson's equation --------------------------
-
+
for (Int_t look=0; look<6; look++) {
-
- Float_t inner18[18] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } ;
- Float_t outer18[18] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } ;
-
+
+ Float_t inner18[18] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } ;
+ Float_t outer18[18] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } ;
+
if (needTable[look] && !fInitLookUpBasic[look]) {
// Specify which rod is the reference; other distortions calculated by summing over multiple rotations of refrence
// Note: the interpolation later on depends on it!! Do not change if not really needed!
if (look==0) {
AliInfo(Form("IFC - ROD&Strip shift : Filling table (~ %d sec)",3*(int)(kPhiSlices/5)));
- inner18[0] = 1;
+ inner18[0] = 1;
} else if (look==1) {
AliInfo(Form("OFC - ROD&Strip shift : Filling table (~ %d sec)",3*(int)(kPhiSlices/5)));
- outer18[0] = 1;
+ outer18[0] = 1;
} else if (look==2) {
AliInfo(Form("IFC - Clip rot. : Filling table (~ %d sec)",3*(int)(kPhiSlices/5)));
- inner18[0] = 1;
+ inner18[0] = 1;
} else if (look==3) {
AliInfo(Form("OFC - Clip rot. : Filling table (~ %d sec)",3*(int)(kPhiSlices/5)));
- outer18[0] = 1;
+ outer18[0] = 1;
} else if (look==4) {
AliInfo(Form("IFC - CopperRod shift : Filling table (~ %d sec)",3*(int)(kPhiSlices/5)));
- inner18[0] = 1;
+ inner18[0] = 1;
} else if (look==5) {
AliInfo(Form("OFC - CopperRod shift : Filling table (~ %d sec)",3*(int)(kPhiSlices/5)));
- outer18[0] = 1;
+ outer18[0] = 1;
}
// Build potentials on boundary stripes for a rotated clip (SYMMETRY==-1) or a shifted rod (SYMMETRY==1)
if (look<4) {
// in these cases, the strips follow the actual rod shift (linear interpolation between the rods)
for ( Int_t k = 0 ; k < kPhiSlices ; k++ ) {
Int_t slices = kPhiSlicesPerSector ;
- Int_t ipoint = k/slices ;
+ Int_t ipoint = k/slices ;
innerList[k] = (((ipoint+1)*slices-k)*inner18[ipoint]-(k-ipoint*slices)*inner18[ipoint+1])/slices ;
outerList[k] = (((ipoint+1)*slices-k)*outer18[ipoint]-(k-ipoint*slices)*outer18[ipoint+1])/slices ;
- if ( (k%slices) == 0 && symmetry[look] == -1 ) { innerList[k] = 0.0 ; outerList[k] = 0.0 ; }
+ if ( (k%slices) == 0 && symmetry[look] == -1 ) { innerList[k] = 0.0 ; outerList[k] = 0.0 ; }
// above, force Zero if Anti-Sym
- }
+ }
} else if (look==4){
// in this case, we assume that the strips stay at the correct position, but the rods move
// the distortion is then much more localized around the rod (indicated by real data)
TMatrixD &charge = *arrayofCharge[k] ;
for ( Int_t i = 0 ; i < kRows ; i++ ) {
for ( Int_t j = 0 ; j < kColumns ; j++ ) { // Fill Vmatrix with Boundary Conditions
- arrayV(i,j) = 0.0 ;
+ arrayV(i,j) = 0.0 ;
charge(i,j) = 0.0 ;
- if ( i == 0 ) arrayV(i,j) = innerList[k] ;
- if ( i == kRows-1 ) arrayV(i,j) = outerList[k] ;
+ if ( i == 0 ) arrayV(i,j) = innerList[k] ;
+ if ( i == kRows-1 ) arrayV(i,j) = outerList[k] ;
}
- }
+ }
// no charge in the volume
- for ( Int_t i = 1 ; i < kRows-1 ; i++ ) {
+ for ( Int_t i = 1 ; i < kRows-1 ; i++ ) {
for ( Int_t j = 1 ; j < kColumns-1 ; j++ ) {
charge(i,j) = 0.0 ;
}
}
- }
-
+ }
+
// Solve Poisson's equation in 3D cylindrical coordinates by relaxation technique
// Allow for different size grid spacing in R and Z directions
if (look==0) {
- PoissonRelaxation3D( arrayofArrayV, arrayofCharge,
+ PoissonRelaxation3D( arrayofArrayV, arrayofCharge,
fLookUpBasic1ErOverEz, fLookUpBasic1EphiOverEz, fLookUpBasic1DeltaEz,
kRows, kColumns, kPhiSlices, gridSizePhi, kIterations, symmetry[0]) ;
AliInfo("IFC - ROD&Strip shift : done ");
} else if (look==1) {
- PoissonRelaxation3D( arrayofArrayV, arrayofCharge,
+ PoissonRelaxation3D( arrayofArrayV, arrayofCharge,
fLookUpBasic2ErOverEz, fLookUpBasic2EphiOverEz, fLookUpBasic2DeltaEz,
kRows, kColumns, kPhiSlices, gridSizePhi, kIterations, symmetry[1]) ;
-
+
AliInfo("OFC - ROD&Strip shift : done ");
} else if (look==2) {
- PoissonRelaxation3D( arrayofArrayV, arrayofCharge,
+ PoissonRelaxation3D( arrayofArrayV, arrayofCharge,
fLookUpBasic3ErOverEz, fLookUpBasic3EphiOverEz, fLookUpBasic3DeltaEz,
kRows, kColumns, kPhiSlices, gridSizePhi, kIterations, symmetry[2]) ;
AliInfo("IFC - Clip rot. : done ");
} else if (look==3) {
- PoissonRelaxation3D( arrayofArrayV, arrayofCharge,
+ PoissonRelaxation3D( arrayofArrayV, arrayofCharge,
fLookUpBasic4ErOverEz, fLookUpBasic4EphiOverEz, fLookUpBasic4DeltaEz,
kRows, kColumns, kPhiSlices, gridSizePhi, kIterations, symmetry[3]) ;
AliInfo("OFC - Clip rot. : done ");
} else if (look==4) {
- PoissonRelaxation3D( arrayofArrayV, arrayofCharge,
+ PoissonRelaxation3D( arrayofArrayV, arrayofCharge,
fLookUpBasic5ErOverEz, fLookUpBasic5EphiOverEz, fLookUpBasic5DeltaEz,
kRows, kColumns, kPhiSlices, gridSizePhi, kIterations, symmetry[4]) ;
AliInfo("IFC - CopperRod shift : done ");
} else if (look==5) {
- PoissonRelaxation3D( arrayofArrayV, arrayofCharge,
+ PoissonRelaxation3D( arrayofArrayV, arrayofCharge,
fLookUpBasic6ErOverEz, fLookUpBasic6EphiOverEz, fLookUpBasic6DeltaEz,
kRows, kColumns, kPhiSlices, gridSizePhi, kIterations, symmetry[5]) ;
AliInfo("OFC - CopperRod shift : done ");
}
-
+
fInitLookUpBasic[look] = kTRUE;
}
}
-
+
// =============================================================================
// Create the final lookup table with corresponding ROD shifts or clip rotations
for ( Int_t i = 0 ; i < kNZ ; i++ ) {
z = TMath::Abs(fgkZList[i]) ; // Symmetric solution in Z that depends only on ABS(Z)
- for ( Int_t j = 0 ; j < kNR ; j++ ) {
+ for ( Int_t j = 0 ; j < kNR ; j++ ) {
r = fgkRList[j] ;
// Interpolate basicLookup tables; once for each rod, then sum the results
-
+
erIntegralSum = 0.0 ;
ephiIntegralSum = 0.0 ;
ezIntegralSum = 0.0 ;
-
+
// SHIFTED RODS =========================================================
// IFC ROD SHIFTS +++++++++++++++++++++++++++++
for ( Int_t rod = 0 ; rod < 18 ; rod++ ) {
-
+
erIntegral = ephiIntegral = ezIntegral = 0.0 ;
-
+
if ( fRodVoltShiftA[rod] == 0 && fgkZList[i] > 0) continue ;
if ( fRodVoltShiftC[rod] == 0 && fgkZList[i] < 0) continue ;
// Rotate to a position where we have maps and prepare to sum
- phiPrime = phi - rod*kPhiSlicesPerSector*gridSizePhi ;
+ phiPrime = phi - rod*kPhiSlicesPerSector*gridSizePhi ;
- if ( phiPrime < 0 ) phiPrime += TMath::TwoPi() ; // Stay in range from 0 to TwoPi
+ if ( phiPrime < 0 ) phiPrime += TMath::TwoPi() ; // Stay in range from 0 to TwoPi
if ( (phiPrime >= 0) && (phiPrime <= kPhiSlices*gridSizePhi) ) {
-
- erIntegral = Interpolate3DTable(order, r, z, phiPrime, kRows, kColumns, kPhiSlices,
+
+ erIntegral = Interpolate3DTable(order, r, z, phiPrime, kRows, kColumns, kPhiSlices,
rlist, zedlist, philist, fLookUpBasic1ErOverEz );
ephiIntegral = Interpolate3DTable(order, r, z, phiPrime, kRows, kColumns, kPhiSlices,
rlist, zedlist, philist, fLookUpBasic1EphiOverEz);
ezIntegral = Interpolate3DTable(order, r, z, phiPrime, kRows, kColumns, kPhiSlices,
rlist, zedlist, philist, fLookUpBasic1DeltaEz );
-
+
} else if ( (phiPrime <= TMath::TwoPi()) && (phiPrime >= (TMath::TwoPi()-kPhiSlices*gridSizePhi)) ){
-
+
phiPrime = TMath::TwoPi() - phiPrime ;
-
- erIntegral = Interpolate3DTable(order, r, z, phiPrime, kRows, kColumns, kPhiSlices,
+
+ erIntegral = Interpolate3DTable(order, r, z, phiPrime, kRows, kColumns, kPhiSlices,
rlist, zedlist, philist, fLookUpBasic1ErOverEz );
ephiIntegral = Interpolate3DTable(order, r, z, phiPrime, kRows, kColumns, kPhiSlices,
rlist, zedlist, philist, fLookUpBasic1EphiOverEz);
ezIntegral = Interpolate3DTable(order, r, z, phiPrime, kRows, kColumns, kPhiSlices,
rlist, zedlist, philist, fLookUpBasic1DeltaEz );
-
+
// Flip symmetry of phi integral for symmetric boundary conditions
- if ( symmetry[0] == 1 ) ephiIntegral *= -1 ;
- // Flip symmetry of r integral if anti-symmetric boundary conditions
- if ( symmetry[0] == -1 ) erIntegral *= -1 ;
+ if ( symmetry[0] == 1 ) ephiIntegral *= -1 ;
+ // Flip symmetry of r integral if anti-symmetric boundary conditions
+ if ( symmetry[0] == -1 ) erIntegral *= -1 ;
}
for ( Int_t rod = 18 ; rod < 36 ; rod++ ) {
erIntegral = ephiIntegral = ezIntegral = 0.0 ;
-
+
if ( fRodVoltShiftA[rod] == 0 && fgkZList[i] > 0) continue ;
if ( fRodVoltShiftC[rod] == 0 && fgkZList[i] < 0) continue ;
// Rotate to a position where we have maps and prepare to sum
- phiPrime = phi - (rod-18)*kPhiSlicesPerSector*gridSizePhi ;
-
- if ( phiPrime < 0 ) phiPrime += TMath::TwoPi() ; // Stay in range from 0 to TwoPi
+ phiPrime = phi - (rod-18)*kPhiSlicesPerSector*gridSizePhi ;
+
+ if ( phiPrime < 0 ) phiPrime += TMath::TwoPi() ; // Stay in range from 0 to TwoPi
if ( (phiPrime >= 0) && (phiPrime <= kPhiSlices*gridSizePhi) ) {
-
- erIntegral = Interpolate3DTable(order, r, z, phiPrime, kRows, kColumns, kPhiSlices,
+
+ erIntegral = Interpolate3DTable(order, r, z, phiPrime, kRows, kColumns, kPhiSlices,
rlist, zedlist, philist, fLookUpBasic2ErOverEz );
ephiIntegral = Interpolate3DTable(order, r, z, phiPrime, kRows, kColumns, kPhiSlices,
rlist, zedlist, philist, fLookUpBasic2EphiOverEz);
ezIntegral = Interpolate3DTable(order, r, z, phiPrime, kRows, kColumns, kPhiSlices,
rlist, zedlist, philist, fLookUpBasic2DeltaEz );
-
+
} else if ( (phiPrime <= TMath::TwoPi()) && (phiPrime >= (TMath::TwoPi()-kPhiSlices*gridSizePhi)) ){
-
+
phiPrime = TMath::TwoPi() - phiPrime ;
-
- erIntegral = Interpolate3DTable(order, r, z, phiPrime, kRows, kColumns, kPhiSlices,
+
+ erIntegral = Interpolate3DTable(order, r, z, phiPrime, kRows, kColumns, kPhiSlices,
rlist, zedlist, philist, fLookUpBasic2ErOverEz );
ephiIntegral = Interpolate3DTable(order, r, z, phiPrime, kRows, kColumns, kPhiSlices,
rlist, zedlist, philist, fLookUpBasic2EphiOverEz);
ezIntegral = Interpolate3DTable(order, r, z, phiPrime, kRows, kColumns, kPhiSlices,
rlist, zedlist, philist, fLookUpBasic2DeltaEz );
-
+
// Flip symmetry of phi integral for symmetric boundary conditions
- if ( symmetry[1] == 1 ) ephiIntegral *= -1 ;
- // Flip symmetry of r integral if anti-symmetric boundary conditions
- if ( symmetry[1] == -1 ) erIntegral *= -1 ;
+ if ( symmetry[1] == 1 ) ephiIntegral *= -1 ;
+ // Flip symmetry of r integral if anti-symmetric boundary conditions
+ if ( symmetry[1] == -1 ) erIntegral *= -1 ;
}
if ( fRotatedClipVoltC[0] == 0 && fgkZList[i] < 0) continue ;
// Rotate to a position where we have maps and prepare to sum
- phiPrime = phi - rod*kPhiSlicesPerSector*gridSizePhi ;
-
- if ( phiPrime < 0 ) phiPrime += TMath::TwoPi() ; // Stay in range from 0 to TwoPi
-
+ phiPrime = phi - rod*kPhiSlicesPerSector*gridSizePhi ;
+
+ if ( phiPrime < 0 ) phiPrime += TMath::TwoPi() ; // Stay in range from 0 to TwoPi
+
if ( (phiPrime >= 0) && (phiPrime <= kPhiSlices*gridSizePhi) ) {
-
- erIntegral = Interpolate3DTable(order, r, z, phiPrime, kRows, kColumns, kPhiSlices,
+
+ erIntegral = Interpolate3DTable(order, r, z, phiPrime, kRows, kColumns, kPhiSlices,
rlist, zedlist, philist, fLookUpBasic3ErOverEz );
ephiIntegral = Interpolate3DTable(order, r, z, phiPrime, kRows, kColumns, kPhiSlices,
rlist, zedlist, philist, fLookUpBasic3EphiOverEz);
ezIntegral = Interpolate3DTable(order, r, z, phiPrime, kRows, kColumns, kPhiSlices,
rlist, zedlist, philist, fLookUpBasic3DeltaEz );
-
+
} else if ( (phiPrime <= TMath::TwoPi()) && (phiPrime >= (TMath::TwoPi()-kPhiSlices*gridSizePhi)) ){
-
+
phiPrime = TMath::TwoPi() - phiPrime ;
-
- erIntegral = Interpolate3DTable(order, r, z, phiPrime, kRows, kColumns, kPhiSlices,
+
+ erIntegral = Interpolate3DTable(order, r, z, phiPrime, kRows, kColumns, kPhiSlices,
rlist, zedlist, philist, fLookUpBasic3ErOverEz );
ephiIntegral = Interpolate3DTable(order, r, z, phiPrime, kRows, kColumns, kPhiSlices,
rlist, zedlist, philist, fLookUpBasic3EphiOverEz);
ezIntegral = Interpolate3DTable(order, r, z, phiPrime, kRows, kColumns, kPhiSlices,
rlist, zedlist, philist, fLookUpBasic3DeltaEz );
-
+
// Flip symmetry of phi integral for symmetric boundary conditions
- if ( symmetry[2] == 1 ) ephiIntegral *= -1 ;
- // Flip symmetry of r integral if anti-symmetric boundary conditions
- if ( symmetry[2] == -1 ) erIntegral *= -1 ;
-
+ if ( symmetry[2] == 1 ) ephiIntegral *= -1 ;
+ // Flip symmetry of r integral if anti-symmetric boundary conditions
+ if ( symmetry[2] == -1 ) erIntegral *= -1 ;
+
}
-
+
if ( fgkZList[i] > 0 ) {
erIntegralSum += fRotatedClipVoltA[0]*erIntegral ;
ephiIntegralSum += fRotatedClipVoltA[0]*ephiIntegral ;
// OFC: ROTATED CLIP +++++++++++++++++++++++++++++
for ( Int_t rod = rodOFC ; rod < rodOFC+1 ; rod++ ) { // loop over 1 to keep the "ignore"-functionality
-
+
erIntegral = ephiIntegral = ezIntegral = 0.0 ;
-
+
if ( fRotatedClipVoltA[1] == 0 && fgkZList[i] > 0) continue ;
if ( fRotatedClipVoltC[1] == 0 && fgkZList[i] < 0) continue ;
// Rotate to a position where we have maps and prepare to sum
- phiPrime = phi - rod*kPhiSlicesPerSector*gridSizePhi ;
-
-
- if ( phiPrime < 0 ) phiPrime += TMath::TwoPi() ; // Stay in range from 0 to TwoPi
-
+ phiPrime = phi - rod*kPhiSlicesPerSector*gridSizePhi ;
+
+
+ if ( phiPrime < 0 ) phiPrime += TMath::TwoPi() ; // Stay in range from 0 to TwoPi
+
if ( (phiPrime >= 0) && (phiPrime <= kPhiSlices*gridSizePhi) ) {
-
- erIntegral = Interpolate3DTable(order, r, z, phiPrime, kRows, kColumns, kPhiSlices,
+
+ erIntegral = Interpolate3DTable(order, r, z, phiPrime, kRows, kColumns, kPhiSlices,
rlist, zedlist, philist, fLookUpBasic4ErOverEz );
ephiIntegral = Interpolate3DTable(order, r, z, phiPrime, kRows, kColumns, kPhiSlices,
rlist, zedlist, philist, fLookUpBasic4EphiOverEz);
ezIntegral = Interpolate3DTable(order, r, z, phiPrime, kRows, kColumns, kPhiSlices,
rlist, zedlist, philist, fLookUpBasic4DeltaEz );
-
+
} else if ( (phiPrime <= TMath::TwoPi()) && (phiPrime >= (TMath::TwoPi()-kPhiSlices*gridSizePhi)) ){
-
+
phiPrime = TMath::TwoPi() - phiPrime ;
-
- erIntegral = Interpolate3DTable(order, r, z, phiPrime, kRows, kColumns, kPhiSlices,
+
+ erIntegral = Interpolate3DTable(order, r, z, phiPrime, kRows, kColumns, kPhiSlices,
rlist, zedlist, philist, fLookUpBasic4ErOverEz );
ephiIntegral = Interpolate3DTable(order, r, z, phiPrime, kRows, kColumns, kPhiSlices,
rlist, zedlist, philist, fLookUpBasic4EphiOverEz);
ezIntegral = Interpolate3DTable(order, r, z, phiPrime, kRows, kColumns, kPhiSlices,
rlist, zedlist, philist, fLookUpBasic4DeltaEz );
-
+
// Flip symmetry of phi integral for symmetric boundary conditions
- if ( symmetry[3] == 1 ) ephiIntegral *= -1 ;
- // Flip symmetry of r integral if anti-symmetric boundary conditions
- if ( symmetry[3] == -1 ) erIntegral *= -1 ;
-
+ if ( symmetry[3] == 1 ) ephiIntegral *= -1 ;
+ // Flip symmetry of r integral if anti-symmetric boundary conditions
+ if ( symmetry[3] == -1 ) erIntegral *= -1 ;
+
}
-
+
if ( fgkZList[i] > 0 ) {
erIntegralSum += fRotatedClipVoltA[1]*erIntegral ;
ephiIntegralSum += fRotatedClipVoltA[1]*ephiIntegral ;
// IFC Cooper rod shift +++++++++++++++++++++++++++++
for ( Int_t rod = 0 ; rod < 18 ; rod++ ) {
-
+
erIntegral = ephiIntegral = ezIntegral = 0.0 ;
-
+
if ( fCopperRodShiftA[rod] == 0 && fgkZList[i] > 0) continue ;
if ( fCopperRodShiftC[rod] == 0 && fgkZList[i] < 0) continue ;
// Rotate to a position where we have maps and prepare to sum
- phiPrime = phi - rod*kPhiSlicesPerSector*gridSizePhi ;
+ phiPrime = phi - rod*kPhiSlicesPerSector*gridSizePhi ;
- if ( phiPrime < 0 ) phiPrime += TMath::TwoPi() ; // Stay in range from 0 to TwoPi
+ if ( phiPrime < 0 ) phiPrime += TMath::TwoPi() ; // Stay in range from 0 to TwoPi
if ( (phiPrime >= 0) && (phiPrime <= kPhiSlices*gridSizePhi) ) {
-
- erIntegral = Interpolate3DTable(order, r, z, phiPrime, kRows, kColumns, kPhiSlices,
+
+ erIntegral = Interpolate3DTable(order, r, z, phiPrime, kRows, kColumns, kPhiSlices,
rlist, zedlist, philist, fLookUpBasic5ErOverEz );
ephiIntegral = Interpolate3DTable(order, r, z, phiPrime, kRows, kColumns, kPhiSlices,
rlist, zedlist, philist, fLookUpBasic5EphiOverEz);
ezIntegral = Interpolate3DTable(order, r, z, phiPrime, kRows, kColumns, kPhiSlices,
rlist, zedlist, philist, fLookUpBasic5DeltaEz );
-
+
} else if ( (phiPrime <= TMath::TwoPi()) && (phiPrime >= (TMath::TwoPi()-kPhiSlices*gridSizePhi)) ){
-
+
phiPrime = TMath::TwoPi() - phiPrime ;
-
- erIntegral = Interpolate3DTable(order, r, z, phiPrime, kRows, kColumns, kPhiSlices,
+
+ erIntegral = Interpolate3DTable(order, r, z, phiPrime, kRows, kColumns, kPhiSlices,
rlist, zedlist, philist, fLookUpBasic5ErOverEz );
ephiIntegral = Interpolate3DTable(order, r, z, phiPrime, kRows, kColumns, kPhiSlices,
rlist, zedlist, philist, fLookUpBasic5EphiOverEz);
ezIntegral = Interpolate3DTable(order, r, z, phiPrime, kRows, kColumns, kPhiSlices,
rlist, zedlist, philist, fLookUpBasic5DeltaEz );
-
+
// Flip symmetry of phi integral for symmetric boundary conditions
- if ( symmetry[4] == 1 ) ephiIntegral *= -1 ;
- // Flip symmetry of r integral if anti-symmetric boundary conditions
- if ( symmetry[4] == -1 ) erIntegral *= -1 ;
+ if ( symmetry[4] == 1 ) ephiIntegral *= -1 ;
+ // Flip symmetry of r integral if anti-symmetric boundary conditions
+ if ( symmetry[4] == -1 ) erIntegral *= -1 ;
}
// OFC Cooper rod shift +++++++++++++++++++++++++++++
for ( Int_t rod = 18 ; rod < 36 ; rod++ ) {
-
+
erIntegral = ephiIntegral = ezIntegral = 0.0 ;
-
+
if ( fCopperRodShiftA[rod] == 0 && fgkZList[i] > 0) continue ;
if ( fCopperRodShiftC[rod] == 0 && fgkZList[i] < 0) continue ;
// Rotate to a position where we have maps and prepare to sum
- phiPrime = phi - (rod-18)*kPhiSlicesPerSector*gridSizePhi ;
+ phiPrime = phi - (rod-18)*kPhiSlicesPerSector*gridSizePhi ;
- if ( phiPrime < 0 ) phiPrime += TMath::TwoPi() ; // Stay in range from 0 to TwoPi
+ if ( phiPrime < 0 ) phiPrime += TMath::TwoPi() ; // Stay in range from 0 to TwoPi
if ( (phiPrime >= 0) && (phiPrime <= kPhiSlices*gridSizePhi) ) {
-
- erIntegral = Interpolate3DTable(order, r, z, phiPrime, kRows, kColumns, kPhiSlices,
+
+ erIntegral = Interpolate3DTable(order, r, z, phiPrime, kRows, kColumns, kPhiSlices,
rlist, zedlist, philist, fLookUpBasic6ErOverEz );
ephiIntegral = Interpolate3DTable(order, r, z, phiPrime, kRows, kColumns, kPhiSlices,
rlist, zedlist, philist, fLookUpBasic6EphiOverEz);
ezIntegral = Interpolate3DTable(order, r, z, phiPrime, kRows, kColumns, kPhiSlices,
rlist, zedlist, philist, fLookUpBasic6DeltaEz );
-
+
} else if ( (phiPrime <= TMath::TwoPi()) && (phiPrime >= (TMath::TwoPi()-kPhiSlices*gridSizePhi)) ){
-
+
phiPrime = TMath::TwoPi() - phiPrime ;
-
- erIntegral = Interpolate3DTable(order, r, z, phiPrime, kRows, kColumns, kPhiSlices,
+
+ erIntegral = Interpolate3DTable(order, r, z, phiPrime, kRows, kColumns, kPhiSlices,
rlist, zedlist, philist, fLookUpBasic6ErOverEz );
ephiIntegral = Interpolate3DTable(order, r, z, phiPrime, kRows, kColumns, kPhiSlices,
rlist, zedlist, philist, fLookUpBasic6EphiOverEz);
ezIntegral = Interpolate3DTable(order, r, z, phiPrime, kRows, kColumns, kPhiSlices,
rlist, zedlist, philist, fLookUpBasic6DeltaEz );
-
+
// Flip symmetry of phi integral for symmetric boundary conditions
- if ( symmetry[5] == 1 ) ephiIntegral *= -1 ;
- // Flip symmetry of r integral if anti-symmetric boundary conditions
- if ( symmetry[5] == -1 ) erIntegral *= -1 ;
+ if ( symmetry[5] == 1 ) ephiIntegral *= -1 ;
+ // Flip symmetry of r integral if anti-symmetric boundary conditions
+ if ( symmetry[5] == -1 ) erIntegral *= -1 ;
}
erOverEz(j,i) = erIntegralSum;
ephiOverEz(j,i) = ephiIntegralSum;
deltaEz(j,i) = ezIntegralSum;
-
+
// if (j==1) printf("%lf %lf %lf: %lf %lf %lf\n",r, phi, z, erIntegralSum,ephiIntegralSum,ezIntegralSum);
-
+
} // endo r loop
} // end of z loop
} // end of phi loop
delete arrayofArrayV[k];
delete arrayofCharge[k];
}
-
+
AliInfo(" done");
fInitLookUp = kTRUE;
}
void AliTPCFCVoltError3D::Print(const Option_t* option) const {
- //
- // Print function to check the settings of the Rod shifts and the rotated clips
- // option=="a" prints the C0 and C1 coefficents for calibration purposes
- //
+ /// Print function to check the settings of the Rod shifts and the rotated clips
+ /// option=="a" prints the C0 and C1 coefficents for calibration purposes
TString opt = option; opt.ToLower();
printf("%s\n",GetTitle());
printf(" - ROD shifts (residual voltage settings): 40V correspond to 1mm of shift\n");
Int_t count = 0;
- printf(" : A-side - (Rod & Strips) \n ");
+ printf(" : A-side - (Rod & Strips) \n ");
for (Int_t i=0; i<36;i++) {
if (fRodVoltShiftA[i]!=0) {
printf("Rod%2d:%3.1fV ",i,fRodVoltShiftA[i]);
count++;
}
- if (count==0&&i==35)
+ if (count==0&&i==35)
printf("-> all at 0 V\n");
else if (i==35){
printf("\n");
count=0;
}
- }
- printf(" : C-side - (Rod & Strips) \n ");
+ }
+ printf(" : C-side - (Rod & Strips) \n ");
for (Int_t i=0; i<36;i++) {
if (fRodVoltShiftC[i]!=0) {
printf("Rod%2d:%3.1fV ",i,fRodVoltShiftC[i]);
count++;
}
- if (count==0&&i==35)
+ if (count==0&&i==35)
printf("-> all at 0 V\n");
else if (i==35){
printf("\n");
count=0;
}
- }
-
+ }
+
printf(" - Rotated clips (residual voltage settings): 40V correspond to 1mm of 'offset'\n");
if (fRotatedClipVoltA[0]!=0) { printf(" A side (IFC): HV Rod: %3.1f V \n",fRotatedClipVoltA[0]); count++; }
if (fRotatedClipVoltA[1]!=0) { printf(" A side (OFC): HV Rod: %3.1f V \n",fRotatedClipVoltA[1]); count++; }
if (fRotatedClipVoltC[0]!=0) { printf(" C side (IFC): HV Rod: %3.1f V \n",fRotatedClipVoltC[0]); count++; }
if (fRotatedClipVoltC[1]!=0) { printf(" C side (OFC): HV Rod: %3.1f V \n",fRotatedClipVoltC[1]); count++; }
- if (count==0)
+ if (count==0)
printf(" -> no rotated clips \n");
count=0;
printf(" - Copper ROD shifts (without strips):\n");
- printf(" : A-side - (Copper Rod shift) \n ");
+ printf(" : A-side - (Copper Rod shift) \n ");
for (Int_t i=0; i<36;i++) {
if (fCopperRodShiftA[i]!=0) {
printf("Rod%2d:%3.1fV ",i,fCopperRodShiftA[i]);
count++;
}
- if (count==0&&i==35)
+ if (count==0&&i==35)
printf("-> all at 0 V\n");
else if (i==35){
printf("\n");
count=0;
}
- }
- printf(" : C-side - (Copper Rod shift) \n ");
+ }
+ printf(" : C-side - (Copper Rod shift) \n ");
for (Int_t i=0; i<36;i++) {
if (fCopperRodShiftC[i]!=0) {
printf("Rod%2d:%3.1fV ",i,fCopperRodShiftC[i]);
count++;
}
- if (count==0&&i==35)
+ if (count==0&&i==35)
printf("-> all at 0 V\n");
else if (i==35){
printf("\n");
count=0;
}
- }
+ }
if (opt.Contains("a")) { // Print all details
printf(" - T1: %1.4f, T2: %1.4f \n",fT1,fT2);
/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
* See cxx source for full Copyright notice */
-////////////////////////////////////////////////////////////////////////////
-// AliTPCFCVoltError3D class //
-// Authors: Jim Thomas, Stefan Rossegger //
-////////////////////////////////////////////////////////////////////////////
+/// \class AliTPCFCVoltError3D
+/// \brief AliTPCFCVoltError3D class
+///
+/// \author Jim Thomas, Stefan Rossegger
#include "AliTPCCorrection.h"
Float_t GetC0() const {return fC0;}
Float_t GetC1() const {return fC1;}
- // setters and getters
+ // setters and getters
// Set rod shift in Voltage equivalents (40V ~ 1mm)
// rod numbers: 0-17 (IFC), 18-35 (OFC)
AliTPCFCVoltError3D(const AliTPCFCVoltError3D &); // not implemented
AliTPCFCVoltError3D &operator=(const AliTPCFCVoltError3D &); // not implemented
- Float_t fC0; // coefficient C0 (compare Jim Thomas's notes for definitions)
- Float_t fC1; // coefficient C1 (compare Jim Thomas's notes for definitions)
- Float_t fRodVoltShiftA[36]; // Rod (&strips) shift in Volt (40V~1mm)
- Float_t fRodVoltShiftC[36]; // Rod (&strips) shift in Volt (40V~1mm)
- Float_t fRotatedClipVoltA[2]; // rotated clips at HV rod
- Float_t fRotatedClipVoltC[2]; // rotated clips at HV rod
- Float_t fCopperRodShiftA[36]; // only Rod shift
- Float_t fCopperRodShiftC[36]; // only Rod shift
+ Float_t fC0; ///< coefficient C0 (compare Jim Thomas's notes for definitions)
+ Float_t fC1; ///< coefficient C1 (compare Jim Thomas's notes for definitions)
+ Float_t fRodVoltShiftA[36]; ///< Rod (&strips) shift in Volt (40V~1mm)
+ Float_t fRodVoltShiftC[36]; ///< Rod (&strips) shift in Volt (40V~1mm)
+ Float_t fRotatedClipVoltA[2]; ///< rotated clips at HV rod
+ Float_t fRotatedClipVoltC[2]; ///< rotated clips at HV rod
+ Float_t fCopperRodShiftA[36]; ///< only Rod shift
+ Float_t fCopperRodShiftC[36]; ///< only Rod shift
- Bool_t fInitLookUp; // flag to check if the Look Up table was created (SUM)
- Bool_t fInitLookUpBasic[6]; // ! flag if the basic lookup was created (shifted Rod (IFC,OFC) or rotated clip (IFC,OFC))
+ Bool_t fInitLookUp; ///< flag to check if the Look Up table was created (SUM)
+ Bool_t fInitLookUpBasic[6]; //!< flag if the basic lookup was created (shifted Rod (IFC,OFC) or rotated clip (IFC,OFC))
- TMatrixF *fLookUpErOverEz[kNPhi]; // Array to store electric field integral (int Er/Ez)
- TMatrixF *fLookUpEphiOverEz[kNPhi]; // Array to store electric field integral (int Er/Ez)
- TMatrixF *fLookUpDeltaEz[kNPhi]; // Array to store electric field integral (int Er/Ez)
+ TMatrixF *fLookUpErOverEz[kNPhi]; ///< Array to store electric field integral (int Er/Ez)
+ TMatrixF *fLookUpEphiOverEz[kNPhi]; ///< Array to store electric field integral (int Er/Ez)
+ TMatrixF *fLookUpDeltaEz[kNPhi]; ///< Array to store electric field integral (int Er/Ez)
// basic numbers for the poisson relaxation //can be set individually in each class
enum {kRows =257}; // grid size in r direction used in the poisson relaxation // ( 2**n + 1 ) eg. 65, 129, 257 etc.
enum {kColumns=129}; // grid size in z direction used in the poisson relaxation // ( 2**m + 1 ) eg. 65, 129, 257 etc.
enum {kPhiSlicesPerSector = 10 }; // number of points in phi slices
enum {kPhiSlices = 1+kPhiSlicesPerSector*3 }; // number of points in phi for the basic lookup tables
- enum {kIterations=100}; // Number of iterations within the poisson relaxation
+ enum {kIterations=100}; // Number of iterations within the poisson relaxation
// ugly way to store "partial" look up tables
// needed for the faster calculation of the final distortion table
// for Rod and Strip shift
- TMatrixD *fLookUpBasic1ErOverEz[kPhiSlices]; // ! Array to store electric field integral (int Er/Ez)
- TMatrixD *fLookUpBasic1EphiOverEz[kPhiSlices]; // ! Array to store electric field integral (int Ephi/Ez)
- TMatrixD *fLookUpBasic1DeltaEz[kPhiSlices]; // ! Array to store electric field integral (int Ez)
+ TMatrixD *fLookUpBasic1ErOverEz[kPhiSlices]; //!< Array to store electric field integral (int Er/Ez)
+ TMatrixD *fLookUpBasic1EphiOverEz[kPhiSlices]; //!< Array to store electric field integral (int Ephi/Ez)
+ TMatrixD *fLookUpBasic1DeltaEz[kPhiSlices]; //!< Array to store electric field integral (int Ez)
- TMatrixD *fLookUpBasic2ErOverEz[kPhiSlices]; // ! Array to store electric field integral
- TMatrixD *fLookUpBasic2EphiOverEz[kPhiSlices]; // ! Array to store electric field integral
- TMatrixD *fLookUpBasic2DeltaEz[kPhiSlices]; // ! Array to store electric field integral
+ TMatrixD *fLookUpBasic2ErOverEz[kPhiSlices]; //!< Array to store electric field integral
+ TMatrixD *fLookUpBasic2EphiOverEz[kPhiSlices]; //!< Array to store electric field integral
+ TMatrixD *fLookUpBasic2DeltaEz[kPhiSlices]; //!< Array to store electric field integral
// for rotated clips
- TMatrixD *fLookUpBasic3ErOverEz[kPhiSlices]; // ! Array to store electric field integral
- TMatrixD *fLookUpBasic3EphiOverEz[kPhiSlices]; // ! Array to store electric field integral
- TMatrixD *fLookUpBasic3DeltaEz[kPhiSlices]; // ! Array to store electric field integral
+ TMatrixD *fLookUpBasic3ErOverEz[kPhiSlices]; //!< Array to store electric field integral
+ TMatrixD *fLookUpBasic3EphiOverEz[kPhiSlices]; //!< Array to store electric field integral
+ TMatrixD *fLookUpBasic3DeltaEz[kPhiSlices]; //!< Array to store electric field integral
- TMatrixD *fLookUpBasic4ErOverEz[kPhiSlices]; // ! Array to store electric field integral
- TMatrixD *fLookUpBasic4EphiOverEz[kPhiSlices]; // ! Array to store electric field integral
- TMatrixD *fLookUpBasic4DeltaEz[kPhiSlices]; // ! Array to store electric field integral
+ TMatrixD *fLookUpBasic4ErOverEz[kPhiSlices]; //!< Array to store electric field integral
+ TMatrixD *fLookUpBasic4EphiOverEz[kPhiSlices]; //!< Array to store electric field integral
+ TMatrixD *fLookUpBasic4DeltaEz[kPhiSlices]; //!< Array to store electric field integral
// for (only rod) shift (copper rods)
- TMatrixD *fLookUpBasic5ErOverEz[kPhiSlices]; // ! Array to store electric field integral
- TMatrixD *fLookUpBasic5EphiOverEz[kPhiSlices]; // ! Array to store electric field integral
- TMatrixD *fLookUpBasic5DeltaEz[kPhiSlices]; // ! Array to store electric field integral
+ TMatrixD *fLookUpBasic5ErOverEz[kPhiSlices]; //!< Array to store electric field integral
+ TMatrixD *fLookUpBasic5EphiOverEz[kPhiSlices]; //!< Array to store electric field integral
+ TMatrixD *fLookUpBasic5DeltaEz[kPhiSlices]; //!< Array to store electric field integral
- TMatrixD *fLookUpBasic6ErOverEz[kPhiSlices]; // ! Array to store electric field integral
- TMatrixD *fLookUpBasic6EphiOverEz[kPhiSlices]; // ! Array to store electric field integral
- TMatrixD *fLookUpBasic6DeltaEz[kPhiSlices]; // ! Array to store electric field integral
+ TMatrixD *fLookUpBasic6ErOverEz[kPhiSlices]; //!< Array to store electric field integral
+ TMatrixD *fLookUpBasic6EphiOverEz[kPhiSlices]; //!< Array to store electric field integral
+ TMatrixD *fLookUpBasic6DeltaEz[kPhiSlices]; //!< Array to store electric field integral
+ /// \cond CLASSIMP
ClassDef(AliTPCFCVoltError3D,3); //
+ /// \endcond
};
#endif
* provided "as is" without express or implied warranty. *
**************************************************************************/
-////////////////////////////////////////////////////////////////////////////
-// AliTPCGGVoltError class //
-////////////////////////////////////////////////////////////////////////////
+/// \class AliTPCGGVoltError
+/// \brief AliTPCGGVoltError class
#include "AliMagF.h"
fDeltaVGGA(0.),fDeltaVGGC(0.),
fInitLookUp(kFALSE)
{
- //
- // default constructor
- //
+ /// default constructor
+
}
AliTPCGGVoltError::~AliTPCGGVoltError() {
- //
- // default destructor
- //
+ /// default destructor
+
}
void AliTPCGGVoltError::Init() {
- //
- // Init function
- //
+ /// Init function
+
AliMagF* magF= (AliMagF*)TGeoGlobalMagField::Instance()->GetField();
if (!magF) AliError("Magneticd field - not initialized");
Double_t bzField = magF->SolenoidField()/10.; //field in T
if (!param) AliError("Parameters - not initialized");
Double_t vdrift = param->GetDriftV()/1000000.; // [cm/us] // From dataBase: to be updated: per second (ideally)
Double_t ezField = 400; // [V/cm] // to be updated: never (hopefully)
- Double_t wt = -10.0 * (bzField*10) * vdrift / ezField ;
+ Double_t wt = -10.0 * (bzField*10) * vdrift / ezField ;
//
SetOmegaTauT1T2(wt,fT1,fT2);
InitGGVoltErrorDistortion();
}
void AliTPCGGVoltError::Update(const TTimeStamp &/*timeStamp*/) {
- //
- // Update function
- //
+ /// Update function
+
AliMagF* magF= (AliMagF*)TGeoGlobalMagField::Instance()->GetField();
if (!magF) AliError("Magneticd field - not initialized");
Double_t bzField = magF->SolenoidField()/10.; //field in T
if (!param) AliError("Parameters - not initialized");
Double_t vdrift = param->GetDriftV()/1000000.; // [cm/us] // From dataBase: to be updated: per second (ideally)
Double_t ezField = 400; // [V/cm] // to be updated: never (hopefully)
- Double_t wt = -10.0 * (bzField*10) * vdrift / ezField ;
+ Double_t wt = -10.0 * (bzField*10) * vdrift / ezField ;
SetOmegaTauT1T2(wt,fT1,fT2);
// InitGGVoltErrorDistortion(); // not necessary in here since the Voltage should not change!
void AliTPCGGVoltError::GetCorrection(const Float_t x[],const Short_t roc,Float_t dx[]) {
- //
- // Gated Grid Voltage Error
- //
- // Calculates the effect of having an incorrect voltage on the A or C end plate Gated Grids.
- //
- // Electrostatic Equations from StarNote SN0253 by Howard Wieman.
- //
-
+ /// Gated Grid Voltage Error
+ ///
+ /// Calculates the effect of having an incorrect voltage on the A or C end plate Gated Grids.
+ ///
+ /// Electrostatic Equations from StarNote SN0253 by Howard Wieman.
+
if (!fInitLookUp) AliError("Lookup table was not initialized! You should do InitGGVoltErrorDistortion() ...");
-
- Int_t order = 1 ; // FIXME: hardcoded? Linear interpolation = 1, Quadratic = 2
-
+
+ Int_t order = 1 ; // FIXME: hardcoded? Linear interpolation = 1, Quadratic = 2
+
Double_t intEr, intEphi ;
Double_t r, phi, z ;
Int_t sign ;
Double_t deltaVGG;
-
+
r = TMath::Sqrt( x[0]*x[0] + x[1]*x[1] );
phi = TMath::ATan2(x[1],x[0]);
if ( phi < 0 ) phi += TMath::TwoPi(); // Table uses phi from 0 to 2*Pi
z = x[2] ;
if ( (roc%36) < 18 ) {
- sign = 1;
+ sign = 1;
deltaVGG = fDeltaVGGA; // (TPC End A)
} else {
sign = -1; // (TPC End C)
- deltaVGG = fDeltaVGGC;
+ deltaVGG = fDeltaVGGC;
}
if ( sign==1 && z < fgkZOffSet ) z = fgkZOffSet; // Protect against discontinuity at CE
// Calculate distorted position
if ( r > 0.0 ) {
- phi = phi + deltaVGG*( fC0*intEphi - fC1*intEr ) / r;
- r = r + deltaVGG*( fC0*intEr + fC1*intEphi );
+ phi = phi + deltaVGG*( fC0*intEphi - fC1*intEr ) / r;
+ r = r + deltaVGG*( fC0*intEr + fC1*intEphi );
}
-
+
// Calculate correction in cartesian coordinates
dx[0] = r * TMath::Cos(phi) - x[0];
- dx[1] = r * TMath::Sin(phi) - x[1];
+ dx[1] = r * TMath::Sin(phi) - x[1];
dx[2] = 0.; // z distortion not implemented (1st order distortions) - see e.g. AliTPCBoundaryVoltError-class
Float_t AliTPCGGVoltError::GetIntErOverEz(const Float_t x[],const Short_t roc) {
- //
- // This function is purely for calibration purposes
- // Calculates the integral (int Er/Ez dz) for the setted GG voltage offset
- //
+ /// This function is purely for calibration purposes
+ /// Calculates the integral (int Er/Ez dz) for the setted GG voltage offset
if (!fInitLookUp) AliError("Lookup table was not initialized! You should do InitGGVoltErrorDistortion() ...");
- Int_t order = 1 ; // FIXME: so far hardcoded? Linear interpolation = 1, Quadratic = 2
-
+ Int_t order = 1 ; // FIXME: so far hardcoded? Linear interpolation = 1, Quadratic = 2
+
Double_t intEr;
Double_t r, phi, z ;
Int_t sign ;
-
+
Double_t deltaVGG;
-
+
r = TMath::Sqrt( x[0]*x[0] + x[1]*x[1] );
phi = TMath::ATan2(x[1],x[0]);
if ( phi < 0 ) phi += TMath::TwoPi(); // Table uses phi from 0 to 2*Pi
z = x[2] ;
if ( (roc%36) < 18 ) {
- sign = 1;
+ sign = 1;
deltaVGG = fDeltaVGGA; // (TPC End A)
} else {
sign = -1; // (TPC End C)
- deltaVGG = fDeltaVGGC;
+ deltaVGG = fDeltaVGGC;
}
if ( sign==1 && z < fgkZOffSet ) z = fgkZOffSet; // Protect against discontinuity at CE
}
void AliTPCGGVoltError::InitGGVoltErrorDistortion() {
- //
- // Initialization of the Lookup table which contains the solutions of the GG Error problem
- //
+ /// Initialization of the Lookup table which contains the solutions of the GG Error problem
Double_t r,z;
Int_t nterms = 100 ;
z = fgkZList[i] ;
for ( Int_t j = 0 ; j < kNR ; ++j ) {
r = fgkRList[j] ;
- fGGVoltErrorER[i][j] = 0.0 ;
+ fGGVoltErrorER[i][j] = 0.0 ;
Double_t intz = 0.0 ;
for ( Int_t n = 1 ; n < nterms ; ++n ) {
Double_t k = n * TMath::Pi() / fgkTPCZ0 ;
Double_t ein = 0 ; // Error potential on the IFC
Double_t eout = 0 ; // Error potential on the OFC
if ( z < 0 ) {
- ein = -2.0 / ( k * (fgkCathodeV - fgkGG) ) ;
- eout = -2.0 / ( k * (fgkCathodeV - fgkGG) ) ;
+ ein = -2.0 / ( k * (fgkCathodeV - fgkGG) ) ;
+ eout = -2.0 / ( k * (fgkCathodeV - fgkGG) ) ;
}
if ( z == 0 ) continue ;
if ( z > 0 ) {
- ein = -2.0 / ( k * (fgkCathodeV - fgkGG) ) ;
- eout = -2.0 / ( k * (fgkCathodeV - fgkGG) ) ;
+ ein = -2.0 / ( k * (fgkCathodeV - fgkGG) ) ;
+ eout = -2.0 / ( k * (fgkCathodeV - fgkGG) ) ;
}
Double_t an = ein * TMath::BesselK0( k*fgkOFCRadius ) - eout * TMath::BesselK0( k*fgkIFCRadius ) ;
Double_t bn = eout * TMath::BesselI0( k*fgkIFCRadius ) - ein * TMath::BesselI0( k*fgkOFCRadius ) ;
Double_t zterm = TMath::Cos( k*(fgkTPCZ0-TMath::Abs(z)) ) - 1 ;
intz += zterm * numerator / denominator ;
// Assume series converges, break if small terms
- if ( n>10 && TMath::Abs(intz)*1.e-10 > TMath::Abs(numerator/denominator) ) break;
+ if ( n>10 && TMath::Abs(intz)*1.e-10 > TMath::Abs(numerator/denominator) ) break;
}
fGGVoltErrorER[i][j] = (Double_t) intz ;
}
}
-
+
fInitLookUp = kTRUE;
}
void AliTPCGGVoltError::Print(const Option_t* option) const {
- //
- // Print function to check the settings (e.g. voltage offsets)
- // option=="a" prints the C0 and C1 coefficents for calibration purposes
- //
+ /// Print function to check the settings (e.g. voltage offsets)
+ /// option=="a" prints the C0 and C1 coefficents for calibration purposes
TString opt = option; opt.ToLower();
printf("%s\n",GetTitle());
- printf(" - GG Voltage offset: A-side: %3.1f V, C-side: %3.1f V \n",fDeltaVGGA,fDeltaVGGC);
+ printf(" - GG Voltage offset: A-side: %3.1f V, C-side: %3.1f V \n",fDeltaVGGA,fDeltaVGGC);
if (opt.Contains("a")) { // Print all details
printf(" - T1: %1.4f, T2: %1.4f \n",fT1,fT2);
printf(" - C1: %1.4f, C0: %1.4f \n",fC1,fC0);
- }
+ }
if (!fInitLookUp) AliError("Lookup table was not initialized! You should do InitGGVoltErrorDistortion() ...");
-
+
}
/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
* See cxx source for full Copyright notice */
-// _________________________________________________________________
-//
-// Begin_Html
-// <h2> AliTPCGGVoltError class </h2>
-// The class calculates the electric field and the resulting space point distortions
-// due a Gating Grid (GG) voltage error. It uses the analytical solution for such a problem.
-// <p>
-// The input is the effective GG voltage residual in respect to the ideal setting. The effective
-// residual voltage can be set via the functions SetDeltaVGGx. Note that this effective
-// voltage-residuals are approx. a factor 0.9 lower than the actual difference in the setting
-// of the GG due to the fact that the voltage on the GG is partially screened by the wire
-// structure. The calculation has to be performed with the observable effective voltage difference.
-// <p>
-// Unfortunately, the class is not capable of calculation the $dz$ offset due to possible changes
-// of the drift velocity in dependence of the electric field. The special case of the numerical
-// approximation (AliTPCBoundaryVoltError), which is capable of calculating the same effect, should
-// be used for this purpose.
-// End_Html
-//
-// Begin_Macro(source)
-// {
-// gROOT->SetStyle("Plain"); gStyle->SetPalette(1);
-// TCanvas *c2 = new TCanvas("cAliTPCGGVoltError","cAliTPCGGVoltError",500,300);
-// AliTPCGGVoltError gg;
-// gg.SetDeltaVGGA(-40); gg.SetDeltaVGGC(-40); // 40 Volt offset
-// gg.InitGGVoltErrorDistortion();
-// gg.SetOmegaTauT1T2(0,1,1); // B=0
-// gg.CreateHistoDRinZR(0)->Draw("surf2");
-// return c2;
-// }
-// End_Macro
-//
-// Begin_Html
-// <p>
-// Date: 27/04/2010 <br>
-// Authors: Jim Thomas, Stefan Rossegger, Magnus Mager
-// End_Html
-// _________________________________________________________________
+/// \class AliTPCGGVoltError
+/// \brief AliTPCGGVoltError class
+///
+/// The class calculates the electric field and the resulting space point distortions
+/// due a Gating Grid (GG) voltage error. It uses the analytical solution for such a problem.
+///
+/// The input is the effective GG voltage residual in respect to the ideal setting. The effective
+/// residual voltage can be set via the functions SetDeltaVGGx. Note that this effective
+/// voltage-residuals are approx. a factor 0.9 lower than the actual difference in the setting
+/// of the GG due to the fact that the voltage on the GG is partially screened by the wire
+/// structure. The calculation has to be performed with the observable effective voltage difference.
+///
+/// Unfortunately, the class is not capable of calculation the $dz$ offset due to possible changes
+/// of the drift velocity in dependence of the electric field. The special case of the numerical
+/// approximation (AliTPCBoundaryVoltError), which is capable of calculating the same effect, should
+/// be used for this purpose.
+/// 
+///
+/// \author Jim Thomas, Stefan Rossegger, Magnus Mager
+/// \date 27/04/2010
#include "AliTPCCorrection.h"
virtual void GetCorrection(const Float_t x[],const Short_t roc, Float_t dx[]);
private:
- Float_t fC0; // coefficient C0 (compare Jim Thomas's notes for definitions)
- Float_t fC1; // coefficient C1 (compare Jim Thomas's notes for definitions)
+ Float_t fC0; ///< coefficient C0 (compare Jim Thomas's notes for definitions)
+ Float_t fC1; ///< coefficient C1 (compare Jim Thomas's notes for definitions)
- Double_t fDeltaVGGA; // Missmatch of gating grid voltage on A-side [V]
- Double_t fDeltaVGGC; // Missmatch of gating grid voltage on C-side [V]
- Double_t fGGVoltErrorER[kNZ][kNR]; // Array to store electric field for GGVoltError calculation
+ Double_t fDeltaVGGA; ///< Missmatch of gating grid voltage on A-side [V]
+ Double_t fDeltaVGGC; ///< Missmatch of gating grid voltage on C-side [V]
+ Double_t fGGVoltErrorER[kNZ][kNR]; ///< Array to store electric field for GGVoltError calculation
- Bool_t fInitLookUp; // flag to check it the Look Up table was created
+ Bool_t fInitLookUp; ///< flag to check it the Look Up table was created
+ /// \cond CLASSIMP
ClassDef(AliTPCGGVoltError,1);
+ /// \endcond
};
#endif
* provided "as is" without express or implied warranty. *
**************************************************************************/
-////////////////////////////////////////////////////////////////////////////////
-// //
-// AliTPCInverseCorrection class //
-// //
-// This is a wrapper that inverts an AliTPCCorrection. This is done by //
-// swapping the CalculateCorrection and CalculateInverseCorrection functions. //
-// The wrapped correction is supplied as a pointer and the class relies //
-// on the fact, that this pointer keeps pointing to the right object. //
-// However, the ownership is not changed, i.e. the wrapped correction //
-// will not be deleted when this correction is destructed. //
-// //
-// date: 27/04/2010 //
-// Authors: Magnus Mager, Stefan Rossegger, Jim Thomas //
-////////////////////////////////////////////////////////////////////////////////
+/// \class AliTPCInverseCorrection
+/// \brief AliTPCInverseCorrection class
+///
+/// This is a wrapper that inverts an AliTPCCorrection. This is done by
+/// swapping the CalculateCorrection and CalculateInverseCorrection functions.
+/// The wrapped correction is supplied as a pointer and the class relies
+/// on the fact, that this pointer keeps pointing to the right object.
+/// However, the ownership is not changed, i.e. the wrapped correction
+/// will not be deleted when this correction is destructed.
+///
+/// \author Magnus Mager, Stefan Rossegger, Jim Thomas
+/// \date 27/04/2010
#include <TString.h>
#include "AliTPCInverseCorrection.h"
AliTPCInverseCorrection::AliTPCInverseCorrection()
: fCorrection(0) {
- //
- // default constructor
- // (only meant for ROOT I/O)
- //
+ /// default constructor
+ /// (only meant for ROOT I/O)
+
}
-AliTPCInverseCorrection::AliTPCInverseCorrection(AliTPCCorrection *correction)
+AliTPCInverseCorrection::AliTPCInverseCorrection(AliTPCCorrection *correction)
: fCorrection(correction) {
- //
- // Constructor that is creating the inverse of the supplied correction.
- // It automatically sets the name ("inv_[correction name]") and tile
- // ("Inverse of [correction title]").
- //
+ /// Constructor that is creating the inverse of the supplied correction.
+ /// It automatically sets the name ("inv_[correction name]") and tile
+ /// ("Inverse of [correction title]").
+
TString name,title;
name ="inv_";
name +=correction->GetName();
}
AliTPCInverseCorrection::~AliTPCInverseCorrection() {
- //
- // virtual destructor
- //
+ /// virtual destructor
+
if (fCorrection) delete fCorrection;
}
void AliTPCInverseCorrection::Init() {
- //
- // Initialization funtion (not used at the moment)
- //
+ /// Initialization funtion (not used at the moment)
+
if (fCorrection) fCorrection->Init();
}
void AliTPCInverseCorrection::Update(const TTimeStamp &timeStamp) {
- //
- // Update function
- //
+ /// Update function
+
if (fCorrection) fCorrection->Update(timeStamp);
}
void AliTPCInverseCorrection::Print(Option_t* option) const {
- //
- // Print function to check which correction classes are used
- // option=="d" prints details regarding the setted magnitude
- // option=="a" prints the C0 and C1 coefficents for calibration purposes
- //
+ /// Print function to check which correction classes are used
+ /// option=="d" prints details regarding the setted magnitude
+ /// option=="a" prints the C0 and C1 coefficents for calibration purposes
printf("Inverse of ");
if (fCorrection) fCorrection->Print(option);
}
void AliTPCInverseCorrection::GetCorrection(const Float_t x[],const Short_t roc,Float_t dx[]) {
- //
- // This is just calling the CalculateInverseCorrection of the wrapped
- // correction -- or puts dr=0 if the latter is 0.
- //
+ /// This is just calling the CalculateInverseCorrection of the wrapped
+ /// correction -- or puts dr=0 if the latter is 0.
+
if (fCorrection)
fCorrection->GetDistortion(x,roc,dx);
else
}
void AliTPCInverseCorrection:: SetOmegaTauT1T2(Float_t omegaTau,Float_t t1,Float_t t2) {
- //
- // Virtual funtion to pass the wt values (might become event dependent) to the inherited classes
- // t1 and t2 represent the "effective omegaTau" corrections and were measured in a dedicated
- // calibration run
- //
+ /// Virtual funtion to pass the wt values (might become event dependent) to the inherited classes
+ /// t1 and t2 represent the "effective omegaTau" corrections and were measured in a dedicated
+ /// calibration run
+
if (fCorrection) fCorrection->SetOmegaTauT1T2(omegaTau, t1, t2);
}
void AliTPCInverseCorrection::GetDistortion(const Float_t x[],const Short_t roc,Float_t dx[]) {
- //
- // This is just calling the CalculateCorrection of the wrapped
- // correction -- or puts dr=0 if the latter is 0.
- //
+ /// This is just calling the CalculateCorrection of the wrapped
+ /// correction -- or puts dr=0 if the latter is 0.
+
if (fCorrection)
fCorrection->GetCorrection(x,roc,dx);
else
for (Int_t j=0;j<3;++j) dx[j]=0.;
}
+/// \cond CLASSIMP
ClassImp(AliTPCInverseCorrection)
+/// \endcond
/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
* See cxx source for full Copyright notice */
-////////////////////////////////////////////////////////////////////////////////
-// //
-// AliTPCInverseCorrection class //
-// //
-// This is a wrapper that inverts an AliTPCCorrection. This is done by //
-// swapping the CalculateCorrection and CalculateInverseCorrection functions. //
-// The wrapped correction is supplied as a pointer and the class relies //
-// on the fact, that this pointer keeps pointing to the right object. //
-// However, the ownership is not changed, i.e. the wrapped correction //
-// will not be deleted when this correction is destructed. //
-// //
-// date: 27/04/2010 //
-// Authors: Magnus Mager, Stefan Rossegger, Jim Thomas //
-////////////////////////////////////////////////////////////////////////////////
+/// \class AliTPCInverseCorrection
+/// \brief AliTPCInverseCorrection class
+///
+/// This is a wrapper that inverts an AliTPCCorrection. This is done by
+/// swapping the CalculateCorrection and CalculateInverseCorrection functions.
+/// The wrapped correction is supplied as a pointer and the class relies
+/// on the fact, that this pointer keeps pointing to the right object.
+/// However, the ownership is not changed, i.e. the wrapped correction
+/// will not be deleted when this correction is destructed.
+///
+/// \author Magnus Mager, Stefan Rossegger, Jim Thomas
+/// \date 27/04/2010
#include "AliTPCCorrection.h"
virtual void Update(const TTimeStamp &timeStamp);
virtual void SetOmegaTauT1T2(Float_t omegaTau,Float_t t1,Float_t t2);
-
+
// convenience functions
virtual void Print(Option_t* option="") const;
-
+
private:
- AliTPCCorrection *fCorrection; // The correction to be inverted.
+ AliTPCCorrection *fCorrection; ///< The correction to be inverted.
AliTPCInverseCorrection & operator = (const AliTPCInverseCorrection &); // dummy assignment operator
AliTPCInverseCorrection(const AliTPCInverseCorrection&); //dummy copy contructor
+ /// \cond CLASSIMP
ClassDef(AliTPCInverseCorrection,1);
+ /// \endcond
};
#endif
* provided "as is" without express or implied warranty. *
**************************************************************************/
-////////////////////////////////////////////////////////////////////////////
-// //
-// Surveyed Laser Track positions //
-// the position and direction information are stored in //
-// the AliExternalTrackParam base class //
-// This class extends this information by identification parameters //
-/*
-
-//Dump positions to a tree:
-AliTPCLaserTrack::LoadTracks();
-TObjArray *arr=AliTPCLaserTrack::GetTracks();
-TTreeSRedirector *s=new TTreeSRedirector("LaserTracks.root");
-TIter next(arr);
-TObject *o=0x0;
-while ( (o=next()) ) (*s) << "tracks" << "l.=" << o << "\n";
-delete s;
-
-//draw something
-TFile f("LaserTracks.root");
-TTree *tracks=(TTree*)f.Get("tracks");
-tracks->Draw("fVecGY.fElements:fVecGX.fElements");
-
- tracks->Draw("fVecGY.fElements:fVecGX.fElements>>h(500,-250,250,500,-250,250)","fId<7")
-*/
-// //
-////////////////////////////////////////////////////////////////////////////
+/// \class AliTPCLaserTrack
+/// \brief Surveyed Laser Track positions
+///
+/// the position and direction information are stored in
+/// the AliExternalTrackParam base class
+/// This class extends this information by identification parameters
+///
+/// Dump positions to a tree:
+/// ~~~
+/// AliTPCLaserTrack::LoadTracks();
+/// TObjArray *arr=AliTPCLaserTrack::GetTracks();
+/// TTreeSRedirector *s=new TTreeSRedirector("LaserTracks.root");
+/// TIter next(arr);
+/// TObject *o=0x0;
+/// while ( (o=next()) ) (*s) << "tracks" << "l.=" << o << "\n";
+/// delete s;
+/// ~~~
+/// draw something
+/// TFile f("LaserTracks.root");
+/// TTree *tracks=(TTree*)f.Get("tracks");
+/// tracks->Draw("fVecGY.fElements:fVecGX.fElements");
+///
+/// tracks->Draw("fVecGY.fElements:fVecGX.fElements>>h(500,-250,250,500,-250,250)","fId<7")
#include <TObjArray.h>
#include "AliTPCLaserTrack.h"
#include "AliTPCROC.h"
+/// \cond CLASSIMP
ClassImp(AliTPCLaserTrack)
+/// \endcond
TObjArray *AliTPCLaserTrack::fgArrLaserTracks=0x0;
fVecLY(0), // points vectors - localY
fVecLZ(0) // points vectors - localZ
{
- //
-// // Default constructor
- //
-
+ /// Default constructor
}
AliTPCLaserTrack::AliTPCLaserTrack(const AliTPCLaserTrack <r) :
fVecLY(0), // points vectors - localY
fVecLZ(0) // points vectors - localZ
{
- //
- // Default constructor
- //
+ /// Default constructor
+
fVecSec=new TVectorD(*ltr.fVecSec); // points vectors - sector
fVecP2 =new TVectorD(*ltr.fVecP2); // points vectors - snp
fVecPhi=new TVectorD(*ltr.fVecPhi); // points vectors - global phi
fVecLZ(new TVectorD(159)) // points vectors - localZ
{
- //
- // create laser track from arguments
- //
-
+ /// create laser track from arguments
+
}
//_____________________________________________________________________
AliTPCLaserTrack& AliTPCLaserTrack::operator = (const AliTPCLaserTrack &source)
{
- //
- // assignment operator
- //
+ /// assignment operator
+
if (&source == this) return *this;
new (this) AliTPCLaserTrack(source);
-
+
return *this;
}
AliTPCLaserTrack::~AliTPCLaserTrack(){
- //
- // destructor
- //
- delete fVecSec; // - sector numbers
- delete fVecP2; // - P2
+ /// destructor
+
+ delete fVecSec; // - sector numbers
+ delete fVecP2; // - P2
delete fVecPhi; // points vectors - global phi
delete fVecGX; // points vectors - globalX
delete fVecGY; // points vectors - globalY
void AliTPCLaserTrack::LoadTracks()
{
- //
- // Load all design positions from file into the static array fgArrLaserTracks
- //
-
+ /// Load all design positions from file into the static array fgArrLaserTracks
+
if ( fgArrLaserTracks ) return;
TObjArray *arrLaserTracks = 0x0;
-
+
AliCDBManager *man=AliCDBManager::Instance();
if (!man->GetDefaultStorage() && gSystem->Getenv("ALICE_ROOT")) man->SetDefaultStorage("local://$ALICE_ROOT/OCDB");
if (man->GetDefaultStorage()){
// AliWarning(Form("Could not get laser position data from file: '%s'",fgkDataFileName));
return;
}
-
+
arrLaserTracks->SetOwner();
-
+
fgArrLaserTracks = new TObjArray(fgkNLaserTracks);
fgArrLaserTracks->SetOwner();
for (Int_t itrack=0; itrack<fgkNLaserTracks; itrack++){
void AliTPCLaserTrack::UpdatePoints(){
- //
- // update track points
- //
+ /// update track points
+
const Double_t kMaxSnp=0.97;
AliTPCROC* roc = AliTPCROC::Instance();
//
//
if (!fVecSec){
fVecSec=new TVectorD(159);
- fVecP2 =new TVectorD(159); // - P2
+ fVecP2 =new TVectorD(159); // - P2
fVecPhi=new TVectorD(159); // - Phi
fVecGX=new TVectorD(159); // points vectors - globalX
fVecGY=new TVectorD(159); // points vectors - globalY
for (Int_t irow=158; irow>=0; irow--){
UInt_t srow = irow;
Int_t sector=0;
-
+
if (srow >=roc->GetNRows(0)) {
srow-=roc->GetNRows(0);
sector=36 ;
if (alpha<0) alpha+=2*TMath::Pi();
sector +=TMath::Nint(-0.5+9*alpha/TMath::Pi());
if (gxyz[2]<0) sector+=18;
- Double_t salpha = TMath::Pi()*(sector+0.5)/9.;
+ Double_t salpha = TMath::Pi()*(sector+0.5)/9.;
if (!ltrp->Rotate(salpha)) break;
if (!ltrp->PropagateTo(lxyz[0],5)) break;
if (TMath::Abs(ltrp->GetSnp())>kMaxSnp) break;
Int_t AliTPCLaserTrack::IdentifyTrack(AliExternalTrackParam *track, Int_t side)
{
- //
- // Find the laser track which is corresponding closest to 'track'
- // return its id
- //
- //
+ /// Find the laser track which is corresponding closest to 'track'
+ /// return its id
+
const Float_t kMaxdphi=0.2;
const Float_t kMaxdphiP=0.05;
const Float_t kMaxdz=40;
//
Float_t mindist=10; // maxima minimal distance
Int_t id = -1;
- for (Int_t itrack=0; itrack<fgkNLaserTracks; itrack++){
+ for (Int_t itrack=0; itrack<fgkNLaserTracks; itrack++){
AliTPCLaserTrack *ltr = (AliTPCLaserTrack*)arrTracks->UncheckedAt(itrack);
if (side>=0) if (ltr->GetSide()!=side) continue;
Double_t * kokot = (Double_t*)ltr->GetParameter();
dist+=TMath::Abs(lxyz1[1]-lxyz0[1]);
// dist+=TMath::Abs(lxyz1[2]-lxyz0[2]); //z is not used for distance calculation
dist+=distdir;
- //
+ //
if (id<0) {
- id =itrack;
- mindist=dist;
+ id =itrack;
+ mindist=dist;
continue;
}
if (dist>mindist) continue;
#define ALITPCLASERTRACK_H
/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
* See cxx source for full Copyright notice */
-////////////////////////////////////////////////////////////////////////////
-//
-// Surveyed Laser Track positions
-//
-////////////////////////////////////////////////////////////////////////////
+/// \class AliTPCLaserTrack
+/// \brief Surveyed Laser Track positions
#include <TString.h>
Double_t x, Double_t alpha,
const Double_t param[5],
const Double_t covar[15], const Float_t rayLength=0);
-
+
AliTPCLaserTrack& operator = (const AliTPCLaserTrack &source);
void UpdatePoints(); // update track points
static void LoadTracks();
static TObjArray* GetTracks() {return fgArrLaserTracks;}
-
+
static Int_t IdentifyTrack(AliExternalTrackParam *track, Int_t side=-1);
-
+
Int_t GetId() const {return fId; }
Int_t GetSide() const {return fSide; }
Int_t GetRod() const {return fRod; }
Int_t GetBeam() const {return fBeam; }
Float_t GetRayLength() const {return fRayLength;}
-
-
-
+
+
+
static Int_t GetNLaserTracks() { return fgkNLaserTracks; }
static Int_t GetNLaserRodsPerSide() { return fgkNRodsPerSide; }
static Int_t GetNMirrorBundlesPerRod() { return fgkNBundlePerRod; }
static Int_t GetNLaserRaysPerMirrorBundle() { return fgkNBeamsPerBundle; }
-
-
+
+
void SetId (Int_t id) {fId = id; }
void SetSide (Int_t side) {fSide = side; }
void SetRod (Int_t rod) {fRod = rod; }
void SetBundle(Int_t bundle){fBundle = bundle;}
void SetBeam (Int_t beam) {fBeam = beam; }
void SetRayLength (Float_t len) {fRayLength = len;}
-
+
const TVectorD* GetVecSec() const { return fVecSec; }
const TVectorD* GetVecP2() const { return fVecP2; }
const TVectorD* GetVecPhi() const { return fVecPhi; }
const TVectorD* GetVecLX() const { return fVecLX; }
const TVectorD* GetVecLY() const { return fVecLY; }
const TVectorD* GetVecLZ() const { return fVecLZ; }
-
+
private:
- Int_t fId; //Laser beam id (0-335)
- Int_t fSide; //TPC side; 0:Shaft Side (A) -- 1:Muon Side (C)
- Int_t fRod; //Laser Rod (0-5)
- Int_t fBundle; //Mirror bundle in the Rod (0-3)
- Int_t fBeam; //Laser Beam in the bundle (0-6)
-
- Float_t fRayLength; //distance from the last common point of the laser Rays
+ Int_t fId; ///< Laser beam id (0-335)
+ Int_t fSide; ///< TPC side; 0:Shaft Side (A) -- 1:Muon Side (C)
+ Int_t fRod; ///< Laser Rod (0-5)
+ Int_t fBundle; ///< Mirror bundle in the Rod (0-3)
+ Int_t fBeam; ///< Laser Beam in the bundle (0-6)
+
+ Float_t fRayLength; ///< distance from the last common point of the laser Rays
//(Splitter box on the A-Side at the bottom of the TPC)
//to each mirror [cm](needed for an exact drift velocity estimation)
public:
- TVectorD *fVecSec; // - sector numbers
- TVectorD *fVecP2; // - P2
- TVectorD *fVecPhi; // - global phi
- TVectorD *fVecGX; // points vectors - globalX
- TVectorD *fVecGY; // points vectors - globalY
- TVectorD *fVecGZ; // points vectors - globalZ
- TVectorD *fVecLX; // points vectors - localX
- TVectorD *fVecLY; // points vectors - localY
- TVectorD *fVecLZ; // points vectors - localZ
-private:
- static TObjArray* fgArrLaserTracks; //! Array of all Laser Tracks,
+ TVectorD *fVecSec; ///< - sector numbers
+ TVectorD *fVecP2; ///< - P2
+ TVectorD *fVecPhi; ///< - global phi
+ TVectorD *fVecGX; ///< points vectors - globalX
+ TVectorD *fVecGY; ///< points vectors - globalY
+ TVectorD *fVecGZ; ///< points vectors - globalZ
+ TVectorD *fVecLX; ///< points vectors - localX
+ TVectorD *fVecLY; ///< points vectors - localY
+ TVectorD *fVecLZ; ///< points vectors - localZ
+private:
+ static TObjArray* fgArrLaserTracks; //!< Array of all Laser Tracks,
// keeps instances of this class;
-
- static const Int_t fgkNLaserTracks = 336; //Number of laser tracks
- static const Int_t fgkNRodsPerSide = 6; //Number of laser rods on each readout side
- static const Int_t fgkNBundlePerRod = 4; //Number of mirror bundles per rod
- static const Int_t fgkNBeamsPerBundle = 7; //Number of laser rays per bundle
-
+
+ static const Int_t fgkNLaserTracks = 336; ///< Number of laser tracks
+ static const Int_t fgkNRodsPerSide = 6; ///< Number of laser rods on each readout side
+ static const Int_t fgkNBundlePerRod = 4; ///< Number of mirror bundles per rod
+ static const Int_t fgkNBeamsPerBundle = 7; ///< Number of laser rays per bundle
+
// static const char* fgkDataFileName = "$ALIC_ROOT/TPC/Calib/LaserTracks.root"; //Path to the Data File
-
+
+ /// \cond CLASSIMP
ClassDef(AliTPCLaserTrack,3) // Laser Track positions and track identification
+ /// \endcond
};
#endif
+/// \class AliTPCLoader
+
/**************************************************************************
* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
* *
* provided "as is" without express or implied warranty. *
**************************************************************************/
-/* $Id$ */
#include "AliTPCLoader.h"
#include "AliLog.h"
const TString AliTPCLoader::fgkDefaultTracksFileName = "TPC.Tracks.root";
+/// \cond CLASSIMP
ClassImp(AliTPCLoader)
+/// \endcond
AliTPCLoader::AliTPCLoader()
{
}
-/*****************************************************************************/
+/*****************************************************************************/
AliTPCLoader::AliTPCLoader(const Char_t *name,const Char_t *topfoldername)
:AliLoader(name,topfoldername)
{
AliDebug(1,Form("Name = %s; topfolder = %s",name,topfoldername));
}
-/*****************************************************************************/
+/*****************************************************************************/
AliTPCLoader::AliTPCLoader(const Char_t *name,TFolder *topfolder)
:AliLoader(name,topfolder)
#ifndef ALITPCGETTER_H
#define ALITPCGETTER_H
-//base class for loaders
-//loader is common for reading data for all detectors
-//Each detector has a loader data member
-//loader is accessible via folder structure as well
+/// \class AliTPCLoader
+/// \brief base class for loaders
+///
+/// loader is common for reading data for all detectors
+/// Each detector has a loader data member
+/// loader is accessible via folder structure as well
#include <AliLoader.h>
AliTPCLoader();
AliTPCLoader(const Char_t *name,const Char_t *topfoldername);
AliTPCLoader(const Char_t *name,TFolder *topfolder);
-
+
virtual ~AliTPCLoader(){};//-----------------
protected:
static const TString fgkDefaultDigitsFileName;
static const TString fgkDefaultRecPointsFileName;
static const TString fgkDefaultTracksFileName;
-
+
public:
+ /// \cond CLASSIMP
ClassDef(AliTPCLoader,1)
+ /// \endcond
};
-
+
#endif
* provided "as is" without express or implied warranty. *
**************************************************************************/
-/* $Id$ */
-
-///////////////////////////////////////////////////////////////////////////////
-// AliTPCPRF2D - //
-// Pad response function object in two dimesions //
-// This class contains the basic functions for the //
-// calculation of PRF according generic charge distribution //
-// In Update function object calculate table of response function //
-// in discrete x and y position //
-// This table is used for interpolation od response function in any position //
-// (function GetPRF) //
-// //
-// Origin: Marian Ivanov, Uni. of Bratislava, ivanov@fmph.uniba.sk //
-// //
-///////////////////////////////////////////////////////////////////////////////
+
+/// \class AliTPCPRF2D
+/// \brief Pad response function object in two dimesions
+///
+/// This class contains the basic functions for the
+/// calculation of PRF according generic charge distribution
+/// In Update function object calculate table of response function
+/// in discrete x and y position
+/// This table is used for interpolation od response function in any position
+/// (function GetPRF)
+///
+/// \author Marian Ivanov, Uni. of Bratislava, ivanov@fmph.uniba.sk
#include <Riostream.h>
#include <TCanvas.h>
#include <TClass.h>
#include <TF2.h>
-#include <TH1.h>
+#include <TH1.h>
#include <TMath.h>
#include <TPad.h>
#include <TPaveText.h>
static Double_t FunGauss2D(const Double_t *const x, const Double_t *const par)
-{
-//Gauss function -needde by the generic function object
+{
+/// Gauss function -needde by the generic function object
+
return ( TMath::Exp(-(x[0]*x[0])/(2*par[0]*par[0]))*
TMath::Exp(-(x[1]*x[1])/(2*par[1]*par[1])));
static Double_t FunCosh2D(const Double_t *const x, const Double_t *const par)
{
- //Cosh function -needde by the generic function object
+ /// Cosh function -needde by the generic function object
+
return ( 1/(TMath::CosH(3.14159*x[0]/(2*par[0]))*
TMath::CosH(3.14159*x[1]/(2*par[1]))));
-}
+}
static Double_t FunGati2D(const Double_t *const x, const Double_t *const par)
{
- //Gati function -needde by the generic function object
+ /// Gati function -needde by the generic function object
+
Float_t k3=par[1];
Float_t k3R=TMath::Sqrt(k3);
Float_t k2=(TMath::Pi()/2)*(1-k3R/2.);
k2=(TMath::Pi()/2)*(1-k3R/2.);
k1=k2*k3R/(4*TMath::ATan(k3R));
l=x[1]/par[0];
- tan2=TMath::TanH(k2*l);
+ tan2=TMath::TanH(k2*l);
tan2*=tan2;
- res = res*k1*(1-tan2)/(1+k3*tan2);
- return res;
-}
+ res = res*k1*(1-tan2)/(1+k3*tan2);
+ return res;
+}
///////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////
+/// \cond CLASSIMP
ClassImp(AliTPCPRF2D)
+/// \endcond
AliTPCPRF2D::AliTPCPRF2D()
:TObject(),
fInterY(0),
fCurrentY(0.),
fDYtoWire(0.),
- fDStepM1(0.)
+ fDStepM1(0.)
{
//default constructor for response function object
funParam[i]=0.;
fType[i]=0;
}
-
- //chewron default values
+
+ //chewron default values
SetPad(0.8,0.8);
SetChevron(0.2,0.0,1.0);
SetY(-0.2,0.2,2);
AliTPCPRF2D::~AliTPCPRF2D()
{
if (fChargeArray!=0) delete [] fChargeArray;
- if (fGRF !=0 ) fGRF->Delete();
+ if (fGRF !=0 ) fGRF->Delete();
}
void AliTPCPRF2D::SetY(Float_t y1, Float_t y2, Int_t nYdiv)
{
- //
- //set virtual line position
- //first and last line and number of lines
+ /// set virtual line position
+ /// first and last line and number of lines
+
fNYdiv = nYdiv;
fY1=y1;
fY2=y2;
void AliTPCPRF2D::SetPad(Float_t width, Float_t height)
{
- //set base chevron parameters
+ /// set base chevron parameters
+
fHeightFull=height;
fWidth=width;
}
-void AliTPCPRF2D::SetChevron(Float_t hstep,
- Float_t shifty,
+void AliTPCPRF2D::SetChevron(Float_t hstep,
+ Float_t shifty,
Float_t fac)
{
- //set shaping of chewron parameters
+ /// set shaping of chewron parameters
+
fHeightS=hstep;
fShiftY=shifty;
fK=fac;
Float_t AliTPCPRF2D::GetPRF(Float_t xin, Float_t yin)
{
- //function which return pad response
- //for the charge in distance xin
- //return cubic aproximation of PRF or PRF at nearest virtual wire
+ /// function which return pad response
+ /// for the charge in distance xin
+ /// return cubic aproximation of PRF or PRF at nearest virtual wire
+
if (fChargeArray==0) return 0;
//transform position to "wire position"
Float_t y=fDYtoWire*(yin-fY1);
if (fNYdiv == 1) y=fY1;
//normaly it find nearest line charge
- if (fInterY ==0){
+ if (fInterY ==0){
Int_t i=Int_t(0.5+y);
if (y<0) i=Int_t(-0.5+y);
if ((i<0) || (i>=fNYdiv) ) return 0;
d=l-2*k;
c=k-d;
Float_t dy=y-Float_t(i);
-
- res = a+b*dy+c*dy*dy+d*dy*dy*dy;
- return res;
-}
+
+ res = a+b*dy+c*dy*dy+d*dy*dy*dy;
+ return res;
+}
Float_t AliTPCPRF2D::GetPRFActiv(Float_t xin)
{
- //GEt response function on given charege line
- //return spline aproximaton
+ /// GEt response function on given charege line
+ /// return spline aproximaton
+
Float_t x = (xin*fDStepM1)+fNPRF/2;
Int_t i = Int_t(x);
-
+
if ( (i>1) && ((i+2)<fNPRF)) {
Float_t a,b,c,d,k,l;
a = fcharge[i];
- b = (fcharge[i+1]-fcharge[i-1])*0.5;
+ b = (fcharge[i+1]-fcharge[i-1])*0.5;
k = fcharge[i+1]-a-b;
l = (fcharge[i+2]-fcharge[i])*0.5-b;
d=l-2.*k;
c=k-d;
Float_t dx=x-Float_t(i);
- Float_t res = a+b*dx+c*dx*dx+d*dx*dx*dx;
+ Float_t res = a+b*dx+c*dx*dx+d*dx*dx*dx;
return res;
}
else return 0;
Float_t AliTPCPRF2D::GetGRF(Float_t xin, Float_t yin)
-{
- //function which returnoriginal charge distribution
- //this function is just normalised for fKnorm
- if (GetGRF() != 0 )
+{
+ /// function which returnoriginal charge distribution
+ /// this function is just normalised for fKnorm
+
+ if (GetGRF() != 0 )
return fKNorm*GetGRF()->Eval(xin,yin)/fInteg;
else
return 0.;
}
-
-void AliTPCPRF2D::SetParam( TF2 *const GRF, Float_t kNorm,
+
+void AliTPCPRF2D::SetParam( TF2 *const GRF, Float_t kNorm,
Float_t sigmaX, Float_t sigmaY)
{
- //adjust parameters of the original charge distribution
- //and pad size parameters
+ /// adjust parameters of the original charge distribution
+ /// and pad size parameters
+
if (fGRF !=0 ) fGRF->Delete();
fGRF = GRF;
fKNorm = kNorm;
snprintf(fType,5,"User");
if (sigmaX ==0) sigmaX=(fWidth*(1+TMath::Abs(fK)))/fgkSQRT12;
if (sigmaY ==0) sigmaY=(fWidth*(1+TMath::Abs(fK)))/fgkSQRT12;
- fOrigSigmaX=sigmaX;
- fOrigSigmaY=sigmaY;
- Double_t estimsigma =
+ fOrigSigmaX=sigmaX;
+ fOrigSigmaY=sigmaY;
+ Double_t estimsigma =
TMath::Sqrt(sigmaX*sigmaX+(fWidth*fWidth*(1+TMath::Abs(fK))/12)+
- TMath::Tan(fPadAngle*fgkDegtoRad)*TMath::Tan(fPadAngle*fgkDegtoRad)*fHeightFull*fHeightFull/12);
+ TMath::Tan(fPadAngle*fgkDegtoRad)*TMath::Tan(fPadAngle*fgkDegtoRad)*fHeightFull*fHeightFull/12);
if (estimsigma < 5*sigmaX) {
fDStep = estimsigma/10.;
- fNPRF = Int_t(estimsigma*8./fDStep);
+ fNPRF = Int_t(estimsigma*8./fDStep);
}
else{
- fDStep = sigmaX;
+ fDStep = sigmaX;
Double_t width = fWidth*(1+TMath::Abs(fK))+TMath::Abs(TMath::Tan(fPadAngle*fgkDegtoRad))*fHeightFull;
fNPRF = Int_t((width+8.*sigmaX)/fDStep);
};
}
-
+
void AliTPCPRF2D::SetGauss(Float_t sigmaX, Float_t sigmaY,
Float_t kNorm)
{
- //
- // set parameters for Gauss generic charge distribution
- //
+ /// set parameters for Gauss generic charge distribution
+
fKNorm = kNorm;
fOrigSigmaX=sigmaX;
fOrigSigmaY=sigmaY;
snprintf(fType,5,"Gauss");
if (fGRF !=0 ) fGRF->Delete();
fGRF = new TF2("FunGauss2D",FunGauss2D,-5.,5.,-5.,5.,4);
-
+
funParam[0]=sigmaX;
- funParam[1]=sigmaY;
+ funParam[1]=sigmaY;
funParam[2]=fK;
- funParam[3]=fHeightS;
-
- fGRF->SetParameters(funParam);
- Double_t estimsigma =
+ funParam[3]=fHeightS;
+
+ fGRF->SetParameters(funParam);
+ Double_t estimsigma =
TMath::Sqrt(sigmaX*sigmaX+(fWidth*fWidth*(1+TMath::Abs(fK))/12)+
- TMath::Tan(fPadAngle)*TMath::Tan(fPadAngle*fgkDegtoRad)*fHeightFull*fHeightFull/12);
+ TMath::Tan(fPadAngle)*TMath::Tan(fPadAngle*fgkDegtoRad)*fHeightFull*fHeightFull/12);
if (estimsigma < 5*sigmaX) {
fDStep = estimsigma/10.;
- fNPRF = Int_t(estimsigma*8./fDStep);
+ fNPRF = Int_t(estimsigma*8./fDStep);
}
else{
- fDStep = sigmaX;
+ fDStep = sigmaX;
Double_t width = fWidth*(1+TMath::Abs(fK))+TMath::Abs(TMath::Tan(fPadAngle*fgkDegtoRad))*fHeightFull;
fNPRF = Int_t((width+8.*sigmaX)/fDStep);
};
-
-
+
+
}
void AliTPCPRF2D::SetCosh(Float_t sigmaX, Float_t sigmaY,
Float_t kNorm)
-{
- // set parameters for Cosh generic charge distribution
- //
+{
+ /// set parameters for Cosh generic charge distribution
+
fKNorm = kNorm;
fOrigSigmaX=sigmaX;
- fOrigSigmaY=sigmaY;
+ fOrigSigmaY=sigmaY;
// sprintf(fType,"Cosh");
snprintf(fType,5,"Cosh");
if (fGRF !=0 ) fGRF->Delete();
- fGRF = new TF2("FunCosh2D", FunCosh2D,-5.,5.,-5.,5.,4);
+ fGRF = new TF2("FunCosh2D", FunCosh2D,-5.,5.,-5.,5.,4);
funParam[0]=sigmaX;
funParam[1]=sigmaY;
- funParam[2]=fK;
+ funParam[2]=fK;
funParam[3]=fHeightS;
fGRF->SetParameters(funParam);
- Double_t estimsigma = TMath::Sqrt(sigmaX*sigmaX+fWidth*fWidth*(1+TMath::Abs(fK))/12);
+ Double_t estimsigma = TMath::Sqrt(sigmaX*sigmaX+fWidth*fWidth*(1+TMath::Abs(fK))/12);
if (estimsigma < 5*sigmaX) {
fDStep = estimsigma/10.;
- fNPRF = Int_t(estimsigma*8./fDStep);
+ fNPRF = Int_t(estimsigma*8./fDStep);
}
else{
- fDStep = sigmaX;
+ fDStep = sigmaX;
fNPRF = Int_t((1.2*fWidth*(1+TMath::Abs(fK))+8.*sigmaX)/fDStep);
- };
-
+ };
+
}
void AliTPCPRF2D::SetGati(Float_t K3X, Float_t K3Y,
Float_t padDistance,
Float_t kNorm)
{
- // set parameters for Gati generic charge distribution
- //
+ /// set parameters for Gati generic charge distribution
+
fKNorm = kNorm;
fK3X=K3X;
fK3Y=K3Y;
- fPadDistance=padDistance;
+ fPadDistance=padDistance;
//sprintf(fType,"Gati");
snprintf(fType,5,"Gati");
if (fGRF !=0 ) fGRF->Delete();
- fGRF = new TF2("FunGati2D", FunGati2D,-5.,5.,-5.,5.,5);
-
+ fGRF = new TF2("FunGati2D", FunGati2D,-5.,5.,-5.,5.,5);
+
funParam[0]=padDistance;
funParam[1]=K3X;
- funParam[2]=fK;
+ funParam[2]=fK;
funParam[3]=fHeightS;
funParam[4]=K3Y;
fGRF->SetParameters(funParam);
fOrigSigmaX=padDistance;
fOrigSigmaY=padDistance;
Float_t sigmaX = fOrigSigmaX;
- Double_t estimsigma = TMath::Sqrt(sigmaX*sigmaX+fWidth*fWidth*(1+TMath::Abs(fK))/12);
+ Double_t estimsigma = TMath::Sqrt(sigmaX*sigmaX+fWidth*fWidth*(1+TMath::Abs(fK))/12);
if (estimsigma < 5*sigmaX) {
fDStep = estimsigma/10.;
- fNPRF = Int_t(estimsigma*8./fDStep);
+ fNPRF = Int_t(estimsigma*8./fDStep);
}
else{
- fDStep = sigmaX;
+ fDStep = sigmaX;
fNPRF = Int_t((1.2*fWidth*(1+TMath::Abs(fK))+8.*sigmaX)/fDStep);
};
}
void AliTPCPRF2D::Update()
{
- //
- //update fields with interpolated values for
- //PRF calculation
+ /// update fields with interpolated values for
+ /// PRF calculation
- if ( fGRF == 0 ) return;
+ if ( fGRF == 0 ) return;
//initialize interpolated values to 0
Int_t i;
if (fChargeArray!=0) delete [] fChargeArray;
Float_t x2= 4*fOrigSigmaX;
Float_t y2= 4*fOrigSigmaY;
Float_t dx = fOrigSigmaX/Float_t(fNdiv*6);
- Float_t dy = fOrigSigmaY/Float_t(fNdiv*6);
+ Float_t dy = fOrigSigmaY/Float_t(fNdiv*6);
Int_t nx = Int_t(0.5+x2/dx);
Int_t ny = Int_t(0.5+y2/dy);
Int_t ix,iy;
fInteg = 0;
Double_t dInteg =0;
for (ix=-nx;ix<=nx;ix++)
- for ( iy=-ny;iy<=ny;iy++)
- dInteg+=fGRF->Eval(Float_t(ix)*dx,Float_t(iy)*dy)*dx*dy;
+ for ( iy=-ny;iy<=ny;iy++)
+ dInteg+=fGRF->Eval(Float_t(ix)*dx,Float_t(iy)*dy)*dx*dy;
/////////////////////////////////////////////////////
fInteg =dInteg;
- if ( fInteg == 0 ) fInteg = 1;
+ if ( fInteg == 0 ) fInteg = 1;
for (i=0; i<fNYdiv; i++){
if (fNYdiv == 1) fCurrentY = fY1;
void AliTPCPRF2D::Update1()
{
- //
- //update fields with interpolated values for
- //PRF calculation for given charge line
+ /// update fields with interpolated values for
+ /// PRF calculation for given charge line
+
Int_t i;
Double_t cos = TMath::Cos(fChargeAngle);
Double_t sin = TMath::Sin(fChargeAngle);
const Double_t kprec =0.00000001;
//integrate charge over pad for different distance of pad
- for (i =0; i<fNPRF;i++){
+ for (i =0; i<fNPRF;i++){
//x in cm fWidth in cm
- //calculate integral
+ //calculate integral
Double_t xch = fDStep * (Double_t)(i-fNPRF/2);
fcharge[i]=0;
- Double_t k=1;
-
-
- for (Double_t ym=-fHeightFull/2.-fShiftY; ym<fHeightFull/2.-kprec;ym+=fHeightS){
+ Double_t k=1;
+
+
+ for (Double_t ym=-fHeightFull/2.-fShiftY; ym<fHeightFull/2.-kprec;ym+=fHeightS){
Double_t y2chev=TMath::Min((ym+fHeightS),Double_t(fHeightFull/2.)); // end of chevron step
Double_t y1chev= ym; //beginning of chevron step
Double_t y2 = TMath::Min(y2chev,fCurrentY+3.5*fOrigSigmaY);
y1 = TMath::Max(y1chev,fCurrentY-3.5*fOrigSigmaY);
Double_t x0 = fWidth*(-1.-(Double_t(k)*fK))*0.5+ym*TMath::Tan(fPadAngle*fgkDegtoRad);
- Double_t kx = Double_t(k)*(fK*fWidth)/fHeightS;
- kx = TMath::Tan(TMath::ATan(kx))+TMath::Tan(fPadAngle*fgkDegtoRad);
+ Double_t kx = Double_t(k)*(fK*fWidth)/fHeightS;
+ kx = TMath::Tan(TMath::ATan(kx))+TMath::Tan(fPadAngle*fgkDegtoRad);
Int_t ny = TMath::Max(Int_t(fNdiv*TMath::Exp(-(y1-fCurrentY)*(y1-fCurrentY)/(2*fOrigSigmaY*fOrigSigmaY))),4);
Double_t dy = TMath::Min(fOrigSigmaY/Double_t(ny),y2-y1);
Double_t ndy = dy;
-
+
//loop over different y strips with variable step size dy
- if (y2>(y1+kprec)) for (Double_t y = y1; y<y2+kprec;){
- //new step SIZE
-
+ if (y2>(y1+kprec)) for (Double_t y = y1; y<y2+kprec;){
+ //new step SIZE
+
ny = TMath::Max(Int_t(fNdiv*TMath::Exp(-(y-fCurrentY)*(y-fCurrentY)/(2*fOrigSigmaY*fOrigSigmaY))),5);
- ndy = fOrigSigmaY/Double_t(ny);
+ ndy = fOrigSigmaY/Double_t(ny);
if (ndy>(y2-y-dy)) {
ndy =y2-y-dy;
if (ndy<kprec) ndy=2*kprec; //calculate new delta y
}
- //
+ //
Double_t sumch=0;
//calculation of x borders and initial step
- Double_t deltay = (y-y1chev);
+ Double_t deltay = (y-y1chev);
Double_t xp1 = x0+deltay*kx;
//x begining of pad at position y
Double_t xp2 =xp1+fWidth; //x end of pad at position y
Double_t xp3 =xp1+kx*dy; //...at position y+dy
- Double_t xp4 =xp2+kx*dy; //..
-
+ Double_t xp4 =xp2+kx*dy; //..
+
Double_t x1 = TMath::Min(xp1,xp3);
x1 = TMath::Max(xp1,xch-3.5*fOrigSigmaX); //beging of integration
Double_t x2 = TMath::Max(xp2,xp4);
TMath::Exp(-(y1-fCurrentY)*(y1-fCurrentY)/(2*fOrigSigmaY*fOrigSigmaY))),2);
Double_t dx = TMath::Min(fOrigSigmaX/Double_t(nx),x2-x1)/5.; //on the border more iteration
Double_t ndx=dx;
-
+
if (x2>(x1+kprec)) {
for (Double_t x = x1; x<x2+kprec ;){
- //new step SIZE
- nx = TMath::Max(Int_t(fNdiv*TMath::Exp(-(x-xch)*(x-xch)/(2*fOrigSigmaX*fOrigSigmaX))),3);
+ //new step SIZE
+ nx = TMath::Max(Int_t(fNdiv*TMath::Exp(-(x-xch)*(x-xch)/(2*fOrigSigmaX*fOrigSigmaX))),3);
ndx = fOrigSigmaX/Double_t(nx);
if (ndx>(x2-x-dx)) {
- ndx =x2-x-dx;
+ ndx =x2-x-dx;
}
if ( ( (x+dx+ndx)<TMath::Max(xp3,xp1)) || ( (x+dx+ndx)>TMath::Min(xp4,xp2))) {
ndx/=5.;
- }
+ }
if (ndx<kprec) ndx=2*kprec;
//INTEGRAL APROXIMATION
Double_t ddx,ddy,dddx,dddy;
dddx = cos*ddx-sin*ddy;
dddy = sin*ddx+cos*ddy;
Double_t z0=fGRF->Eval(dddx,dddy); //middle point
-
+
ddx = xch-(x+dx/2.);
ddy = fCurrentY-(y);
dddx = cos*ddx-sin*ddy;
dddy = sin*ddx+cos*ddy;
Double_t z1=fGRF->Eval(dddx,dddy); //point down
-
+
ddx = xch-(x+dx/2.);
ddy = fCurrentY-(y+dy);
dddx = cos*ddx-sin*ddy;
dddy = sin*ddx+cos*ddy;
Double_t z3=fGRF->Eval(dddx,dddy); //point up
-
+
ddx = xch-(x);
ddy = fCurrentY-(y+dy/2.);
dddx = cos*ddx-sin*ddy;
dddy = sin*ddx+cos*ddy;
- Double_t z2=fGRF->Eval(dddx,dddy); //point left
-
+ Double_t z2=fGRF->Eval(dddx,dddy); //point left
+
ddx = xch-(x+dx);
ddy = fCurrentY-(y+dy/2.);
dddx = cos*ddx-sin*ddy;
dddy = sin*ddx+cos*ddy;
Double_t z4=fGRF->Eval(dddx,dddy); //point right
-
-
+
+
if (z0<0) {z0=0;z1=0;z2=0;z3=0;z4=0;}
-
+
Double_t f2x= (z3+z1-2*z0)*4.;//second derivation in y
Double_t f2y= (z2+z4-2*z0)*4.;//second derivation in x
Double_t f1y= (z3-z1);
- Double_t z ;
- z = (z0+f2x/6.+f2y/6.);//second order aproxiation of integral
+ Double_t z ;
+ z = (z0+f2x/6.+f2y/6.);//second order aproxiation of integral
if (kx>kprec){ //positive derivation
- if (x<(xp1+dy*kx)){ //calculate volume at left border
+ if (x<(xp1+dy*kx)){ //calculate volume at left border
Double_t xx1 = x;
Double_t xx2 = TMath::Min(x+dx,xp1+dy*kx);
Double_t yy1 = y+(xx1-xp1)/kx;
- Double_t yy2 = TMath::Min(y+(xx2-xp1)/kx,y+dy);
+ Double_t yy2 = TMath::Min(y+(xx2-xp1)/kx,y+dy);
z=z0;
- if (yy2<y+dy) {
+ if (yy2<y+dy) {
z-= z0*(y+dy-yy2)/dy; //constant part rectangle
z-= f1y*(xx2-xx1)*(y+dy-yy2)*(y+dy-yy2)/(2.*dx*dy);
}
z-=z0*(xx2-xx1)*(yy2-yy1)/(2*dx*dy); //constant part rectangle
-
+
}
- if (x>xp2){ //calculate volume at right border
+ if (x>xp2){ //calculate volume at right border
Double_t xx1 = x;
Double_t xx2 = x+dx;
Double_t yy1 = y+(xx1-xp2)/kx;
- Double_t yy2 = y+(xx2-xp2)/kx;
+ Double_t yy2 = y+(xx2-xp2)/kx;
z=z0;
//rectangle part
z-=z0*(yy1-y)/dy; //constant part
z-=f1y*(xx2-xx1)*(yy1-y)*(yy1-y)/(2*dx*dy);
- //triangle part
- z-=z0*(xx2-xx1)*(yy2-yy1)/(2*dx*dy); //constant part
+ //triangle part
+ z-=z0*(xx2-xx1)*(yy2-yy1)/(2*dx*dy); //constant part
}
- }
- if (kx<-kprec){ //negative derivation
- if (x<(xp1+dy*kx)){ //calculate volume at left border
+ }
+ if (kx<-kprec){ //negative derivation
+ if (x<(xp1+dy*kx)){ //calculate volume at left border
Double_t xx1 = x;
Double_t xx2 = TMath::Min(x+dx,xp3-dy/kx);
Double_t yy1 = y+(xx1-xp1)/kx;
- Double_t yy2 = TMath::Max(y,yy1+(xx2-xx1)/kx); //yy2<yy1
+ Double_t yy2 = TMath::Max(y,yy1+(xx2-xx1)/kx); //yy2<yy1
z = z0;
- z-= z0*(yy2-y)/dy; // constant part rectangle
- z-= f1y*(xx2-xx1)*(yy2-y)*(yy2-y)/(2.*dx*dy);
+ z-= z0*(yy2-y)/dy; // constant part rectangle
+ z-= f1y*(xx2-xx1)*(yy2-y)*(yy2-y)/(2.*dx*dy);
z-=z0*(xx2-xx1)*(yy1-yy2)/(2*dx*dy); //constant part triangle
}
- if (x>xp2){ //calculate volume at right border
+ if (x>xp2){ //calculate volume at right border
Double_t xx1 = TMath::Max(x,xp2+dy*kx);
Double_t xx2 = x+dx;
Double_t yy1 = TMath::Min(y+dy,y-(xp2-xx1)/kx);
Double_t yy2 = y-(xp2-xx2)/kx;
z=z0;
z-=z0*(yy2-y)/dy; //constant part rextangle
- z-= f1y*(xx2-xx1)*(yy2-y)*(yy2-y)/(2.*dx*dy);
+ z-= f1y*(xx2-xx1)*(yy2-y)*(yy2-y)/(2.*dx*dy);
z-=z0*(xx2-xx1)*(yy1-yy2)/(2*dx*dy); //constant part triangle
- }
- }
-
+ }
+ }
+
if (z>0.) sumch+=fKNorm*z*dx*dy/fInteg;
-
+
x+=dx;
dx = ndx;
- }; //loop over x
+ }; //loop over x
fcharge[i]+=sumch;
}//if x2>x1
y+=dy;
dy =ndy;
}//step over different y
k*=-1.;
- }//step over chevron
-
+ }//step over chevron
+
}//step over different points on line NPRF
}
void AliTPCPRF2D::UpdateSigma()
{
- //
- //calulate effective sigma X and sigma y of PRF
+ /// calulate effective sigma X and sigma y of PRF
+
fMeanX = 0;
fMeanY = 0;
fSigmaX = 0;
fSigmaY = 0;
-
+
Float_t sum =0;
Int_t i;
Float_t x,y;
else
y = fY1+Float_t(i)*(fY2-fY1)/Float_t(fNYdiv-1);
for (x =-fNPRF*fDStep; x<fNPRF*fDStep;x+=fDStep)
- {
+ {
//x in cm fWidth in cm
Float_t weight = GetPRF(x,y);
- fSigmaX+=x*x*weight;
+ fSigmaX+=x*x*weight;
fSigmaY+=y*y*weight;
fMeanX+=x*weight;
fMeanY+=y*weight;
sum+=weight;
- };
+ };
}
if (sum>0){
fMeanX/=sum;
- fMeanY/=sum;
+ fMeanY/=sum;
fSigmaX = TMath::Sqrt(fSigmaX/sum-fMeanX*fMeanX);
- fSigmaY = TMath::Sqrt(fSigmaY/sum-fMeanY*fMeanY);
+ fSigmaY = TMath::Sqrt(fSigmaY/sum-fMeanY*fMeanY);
}
- else fSigmaX=0;
+ else fSigmaX=0;
}
void AliTPCPRF2D::Streamer(TBuffer &xRuub)
{
- // Stream an object of class AliTPCPRF2D
+ /// Stream an object of class AliTPCPRF2D
if (xRuub.IsReading()) {
UInt_t xRuus, xRuuc;
AliTPCPRF2D::Class()->ReadBuffer(xRuub, this, xRuuv, xRuus, xRuuc);
//read functions
if (strncmp(fType,"User",3)!=0){
- delete fGRF;
- if (strncmp(fType,"Gauss",3)==0)
+ delete fGRF;
+ if (strncmp(fType,"Gauss",3)==0)
fGRF = new TF2("FunGauss2D",FunGauss2D,-5.,5.,-5.,5.,4);
- if (strncmp(fType,"Cosh",3)==0)
+ if (strncmp(fType,"Cosh",3)==0)
fGRF = new TF2("FunCosh2D",FunCosh2D,-5.,5.,-5.,5.,4);
- if (strncmp(fType,"Gati",3)==0)
- fGRF = new TF2("FunGati2D",FunGati2D,-5.,5.,-5.,5.,5);
+ if (strncmp(fType,"Gati",3)==0)
+ fGRF = new TF2("FunGati2D",FunGati2D,-5.,5.,-5.,5.,5);
if (fGRF!=0) fGRF->SetParameters(funParam);
}
//calculate conversion coefitient to convert position to virtual wire
TH1F * AliTPCPRF2D::GenerDrawXHisto(Float_t x1, Float_t x2,Float_t y)
{
- //gener one dimensional hist of pad response function
- // at position y
- char s[100];
+ /// gener one dimensional hist of pad response function
+ /// at position y
+
+ char s[100];
const Int_t kn=200;
- //sprintf(s,"Pad Response Function");
- snprintf(s,100,"Pad Response Function");
+ //sprintf(s,"Pad Response Function");
+ snprintf(s,100,"Pad Response Function");
TH1F * hPRFc = new TH1F("hPRFc",s,kn+1,x1,x2);
Float_t x=x1;
Float_t y1;
};
hPRFc->SetXTitle("pad (cm)");
return hPRFc;
-}
+}
AliH2F * AliTPCPRF2D::GenerDrawHisto(Float_t x1, Float_t x2, Float_t y1, Float_t y2, Int_t Nx, Int_t Ny)
{
- //
- //gener two dimensional histogram with PRF
- //
+ /// gener two dimensional histogram with PRF
+
char s[100];
- //sprintf(s,"Pad Response Function");
- snprintf(s,100,"Pad Response Function");
+ //sprintf(s,"Pad Response Function");
+ snprintf(s,100,"Pad Response Function");
AliH2F * hPRFc = new AliH2F("hPRFc",s,Nx,x1,x2,Ny,y1,y2);
Float_t dx=(x2-x1)/Float_t(Nx);
Float_t dy=(y2-y1)/Float_t(Ny) ;
- Float_t x,y,z;
+ Float_t x,y,z;
x = x1;
y = y1;
for ( Int_t i = 0;i<=Nx;i++,x+=dx){
z = GetPRF(x,y);
hPRFc->SetBinContent(hPRFc->GetBin(i,j),z);
};
- };
+ };
hPRFc->SetXTitle("pad direction (cm)");
hPRFc->SetYTitle("pad row direction (cm)");
hPRFc->SetTitleOffset(1.5,"X");
AliH2F * AliTPCPRF2D::GenerDrawDistHisto(Float_t x1, Float_t x2, Float_t y1, Float_t y2, Int_t Nx, Int_t Ny, Float_t thr)
{
- //return histogram with distortion
+ /// return histogram with distortion
+
const Float_t kminth=0.00001;
if (thr<kminth) thr=kminth;
- char s[100];
- //sprintf(s,"COG distortion of PRF (threshold=%2.2f)",thr);
- snprintf(s,100,"COG distortion of PRF (threshold=%2.2f)",thr);
+ char s[100];
+ //sprintf(s,"COG distortion of PRF (threshold=%2.2f)",thr);
+ snprintf(s,100,"COG distortion of PRF (threshold=%2.2f)",thr);
AliH2F * hPRFDist = new AliH2F("hDistortion",s,Nx,x1,x2,Ny,y1,y2);
Float_t dx=(x2-x1)/Float_t(Nx);
Float_t dy=(y2-y1)/Float_t(Ny) ;
x=x1;
for ( Int_t i = 0;i<=Nx;i++,x+=dx){
y=y1;
- for(Int_t j = 0;j<=Ny;j++,y+=dy)
+ for(Int_t j = 0;j<=Ny;j++,y+=dy)
{
Float_t sumx=0;
Float_t sum=0;
for (Int_t k=-3;k<=3;k++)
- {
+ {
Float_t padx=Float_t(k)*fWidth;
- z = GetPRF(x-padx,y);
+ z = GetPRF(x-padx,y);
if (z>thr){
sum+=z;
sumx+=z*padx;
- }
- };
- if (sum>kminth)
+ }
+ };
+ if (sum>kminth)
{
ddx = (x-(sumx/sum));
}
hPRFDist->SetTitleOffset(1.5,"X");
hPRFDist->SetTitleOffset(1.5,"Y");
return hPRFDist;
-}
-
+}
+
void AliTPCPRF2D::DrawX(Float_t x1 ,Float_t x2,Float_t y1,Float_t y2, Int_t N)
-{
- //
- //draw pad response function at interval <x1,x2> at given y position
- //
+{
+ /// draw pad response function at interval <x1,x2> at given y position
+
if (N<0) return;
TCanvas * c1 = new TCanvas("PRFX","Pad response function",700,900);
- c1->cd();
-
+ c1->cd();
+
TPaveText * comment = new TPaveText(0.05,0.02,0.95,0.20,"NDC");
comment->SetTextAlign(12);
comment->SetFillColor(42);
- DrawComment(comment);
+ DrawComment(comment);
comment->Draw();
- c1->cd();
+ c1->cd();
TPad * pad2 = new TPad("pPRF","",0.05,0.22,0.95,0.95);
pad2->Divide(2,(N+1)/2);
pad2->Draw();
gStyle->SetOptFit(1);
- gStyle->SetOptStat(1);
+ gStyle->SetOptStat(1);
for (Int_t i=0;i<N;i++){
char ch[200];
Float_t y;
TH1F * hPRFc =GenerDrawXHisto(x1, x2,y);
//sprintf(ch,"PRF at wire position: %2.3f",y);
snprintf(ch,40,"PRF at wire position: %2.3f",y);
- hPRFc->SetTitle(ch);
+ hPRFc->SetTitle(ch);
//sprintf(ch,"PRF %d",i);
snprintf(ch,15,"PRF %d",i);
- hPRFc->SetName(ch);
+ hPRFc->SetName(ch);
hPRFc->Fit("gaus");
}
-
+
}
void AliTPCPRF2D::DrawPRF(Float_t x1 ,Float_t x2,Float_t y1, Float_t y2, Int_t Nx, Int_t Ny)
-{
- //
- //
+{
+ ///
+
TCanvas * c1 = new TCanvas("canPRF","Pad response function",700,900);
c1->cd();
TPad * pad2 = new TPad("pad2PRF","",0.05,0.22,0.95,0.95);
- pad2->Draw();
+ pad2->Draw();
gStyle->SetOptFit(1);
- gStyle->SetOptStat(1);
- TH2F * hPRFc = GenerDrawHisto(x1, x2, y1, y2, Nx,Ny);
+ gStyle->SetOptStat(1);
+ TH2F * hPRFc = GenerDrawHisto(x1, x2, y1, y2, Nx,Ny);
pad2->cd();
hPRFc->Draw("surf");
- c1->cd();
+ c1->cd();
TPaveText * comment = new TPaveText(0.05,0.02,0.95,0.20,"NDC");
comment->SetTextAlign(12);
comment->SetFillColor(42);
- DrawComment(comment);
+ DrawComment(comment);
comment->Draw();
}
void AliTPCPRF2D::DrawDist(Float_t x1 ,Float_t x2,Float_t y1, Float_t y2, Int_t Nx, Int_t Ny, Float_t thr)
-{
- //
- //draw distortion of the COG method - for different threshold parameter
+{
+ /// draw distortion of the COG method - for different threshold parameter
+
TCanvas * c1 = new TCanvas("padDistortion","COG distortion",700,900);
c1->cd();
TPad * pad1 = new TPad("dist","",0.05,0.55,0.95,0.95,21);
TPad * pad2 = new TPad("dist","",0.05,0.22,0.95,0.53,21);
pad2->Draw();
gStyle->SetOptFit(1);
- gStyle->SetOptStat(0);
-
- AliH2F * hPRFDist = GenerDrawDistHisto(x1, x2, y1, y2, Nx,Ny,thr);
-
+ gStyle->SetOptStat(0);
+
+ AliH2F * hPRFDist = GenerDrawDistHisto(x1, x2, y1, y2, Nx,Ny,thr);
+
pad1->cd();
hPRFDist->Draw("surf");
Float_t distmax =hPRFDist->GetMaximum();
Float_t distmin =hPRFDist->GetMinimum();
- gStyle->SetOptStat(1);
-
+ gStyle->SetOptStat(1);
+
TH1F * dist = hPRFDist->GetAmplitudes(distmin,distmax,distmin-1);
pad2->cd();
dist->Draw();
- c1->cd();
+ c1->cd();
TPaveText * comment = new TPaveText(0.05,0.02,0.95,0.20,"NDC");
comment->SetTextAlign(12);
comment->SetFillColor(42);
- DrawComment(comment);
+ DrawComment(comment);
comment->Draw();
}
void AliTPCPRF2D::DrawComment(TPaveText *comment)
{
- //
- //function to write comment to picture
-
+ /// function to write comment to picture
+
char s[100];
//draw comments to picture
TText * title = comment->AddText("Pad Response Function parameters:");
//sprintf(s,"Pad Angle: %2.2f ",fPadAngle);
snprintf(s,100,"Pad Angle: %2.2f ",fPadAngle);
comment->AddText(s);
-
+
if (TMath::Abs(fK)>0.0001){
//sprintf(s,"Height of one chevron unit h: %2.2f cm",2*fHeightS);
snprintf(s,100,"Height of one chevron unit h: %2.2f cm",2*fHeightS);
comment->AddText(s);
//sprintf(s,"Overlap factor: %2.2f",fK);
snprintf(s,100,"Overlap factor: %2.2f",fK);
- comment->AddText(s);
+ comment->AddText(s);
}
if (strncmp(fType,"User",3)==0){
//sprintf(s,"Charge distribution - user defined function %s ",fGRF->GetTitle());
snprintf(s,100,"Charge distribution - user defined function %s ",fGRF->GetTitle());
- comment->AddText(s);
+ comment->AddText(s);
//sprintf(s,"Sigma x of charge distribution: %2.2f ",fOrigSigmaX);
- snprintf(s,100,"Sigma x of charge distribution: %2.2f ",fOrigSigmaX);
- comment->AddText(s);
+ snprintf(s,100,"Sigma x of charge distribution: %2.2f ",fOrigSigmaX);
+ comment->AddText(s);
//sprintf(s,"Sigma y of charge distribution: %2.2f ",fOrigSigmaY);
snprintf(s,100,"Sigma y of charge distribution: %2.2f ",fOrigSigmaY);
- comment->AddText(s);
+ comment->AddText(s);
}
if (strncmp(fType,"Gauss",3)==0){
//sprintf(s,"Gauss charge distribution");
snprintf(s,100,"Gauss charge distribution");
- comment->AddText(s);
+ comment->AddText(s);
//sprintf(s,"Sigma x of charge distribution: %2.2f ",fOrigSigmaX);
snprintf(s,100,"Sigma x of charge distribution: %2.2f ",fOrigSigmaX);
- comment->AddText(s);
+ comment->AddText(s);
//sprintf(s,"Sigma y of charge distribution: %2.2f ",fOrigSigmaY);
snprintf(s,100,"Sigma y of charge distribution: %2.2f ",fOrigSigmaY);
- comment->AddText(s);
+ comment->AddText(s);
}
if (strncmp(fType,"Gati",3)==0){
//sprintf(s,"Gati charge distribution");
snprintf(s,100,"Gati charge distribution");
- comment->AddText(s);
+ comment->AddText(s);
//sprintf(s,"K3X of Gati : %2.2f ",fK3X);
snprintf(s,100,"K3X of Gati : %2.2f ",fK3X);
- comment->AddText(s);
+ comment->AddText(s);
//sprintf(s,"K3Y of Gati: %2.2f ",fK3Y);
snprintf(s,100,"K3Y of Gati: %2.2f ",fK3Y);
- comment->AddText(s);
+ comment->AddText(s);
//sprintf(s,"Wire to Pad Distance: %2.2f ",fPadDistance);
snprintf(s,100,"Wire to Pad Distance: %2.2f ",fPadDistance);
- comment->AddText(s);
+ comment->AddText(s);
}
if (strncmp(fType,"Cosh",3)==0){
//sprintf(s,"Cosh charge distribution");
snprintf(s,100,"Cosh charge distribution");
- comment->AddText(s);
+ comment->AddText(s);
//sprintf(s,"Sigma x of charge distribution: %2.2f ",fOrigSigmaX);
snprintf(s,100,"Sigma x of charge distribution: %2.2f ",fOrigSigmaX);
- comment->AddText(s);
+ comment->AddText(s);
//sprintf(s,"Sigma y of charge distribution: %2.2f ",fOrigSigmaY);
snprintf(s,100,"Sigma y of charge distribution: %2.2f ",fOrigSigmaY);
- comment->AddText(s);
+ comment->AddText(s);
}
//sprintf(s,"Normalisation: %2.2f ",fKNorm);
snprintf(s,100,"Normalisation: %2.2f ",fKNorm);
- comment->AddText(s);
+ comment->AddText(s);
}
/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
* See cxx source for full Copyright notice */
-/* $Id$ */
-//////////////////////////////////////////////////////////////////
-// Manager class for AliTPCPRF2D //
-// This is to generate the 2-dimensional pad-response function //
-//////////////////////////////////////////////////////////////////
+/// \class AliTPCPRF2D
+/// \brief Manager class for AliTPCPRF2D
+///
+/// This is to generate the 2-dimensional pad-response function
+
#include "TObject.h"
class TF2;
class TPaveText;
class AliTPCPRF2D : public TObject {
-public :
+public :
AliTPCPRF2D();
- virtual ~AliTPCPRF2D();
+ virtual ~AliTPCPRF2D();
virtual void Update(); //recalculate tables for charge calculation
- Float_t GetGRF(Float_t xin, Float_t yin);
+ Float_t GetGRF(Float_t xin, Float_t yin);
//return generic response function in xin
virtual TF2 * GetGRF(){return fGRF;}
- virtual Float_t GetPRF(Float_t xin, Float_t yin);
+ virtual Float_t GetPRF(Float_t xin, Float_t yin);
//return PRF in point xin,yin
virtual void DrawX(Float_t x1 ,Float_t x2,Float_t y1,Float_t y2=0, Int_t N=1);
virtual void DrawPRF(Float_t x1, Float_t x2, Float_t y1, Float_t y2, Int_t Nx=20, Int_t Ny=20);
//draw two dimensional PRF
- virtual void DrawDist(Float_t x1, Float_t x2, Float_t y1, Float_t y2, Int_t Nx=20, Int_t Ny=20,
+ virtual void DrawDist(Float_t x1, Float_t x2, Float_t y1, Float_t y2, Int_t Nx=20, Int_t Ny=20,
Float_t thr=0);
//draw distortion of COG method
//we suppose threshold equal to thr
- TH1F * GenerDrawXHisto(Float_t x1, Float_t x2,Float_t y);
+ TH1F * GenerDrawXHisto(Float_t x1, Float_t x2,Float_t y);
AliH2F * GenerDrawHisto(Float_t x1, Float_t x2, Float_t y1, Float_t y2, Int_t Nx=20, Int_t Ny=20);
- AliH2F * GenerDrawDistHisto(Float_t x1, Float_t x2, Float_t y1, Float_t y2, Int_t Nx=20, Int_t Ny=20,
- Float_t thr=0);
-
+ AliH2F * GenerDrawDistHisto(Float_t x1, Float_t x2, Float_t y1, Float_t y2, Int_t Nx=20, Int_t Ny=20,
+ Float_t thr=0);
+
virtual void SetPad(Float_t width, Float_t height);
//set base chevron parameters
virtual void SetChevron(Float_t hstep, Float_t shifty, Float_t fac);
- //set chevron parameters
+ //set chevron parameters
virtual void SetChParam(Float_t width, Float_t height,
Float_t hstep, Float_t shifty, Float_t fac);
- //set all geometrical parameters
+ //set all geometrical parameters
virtual void SetY(Float_t y1, Float_t y2, Int_t nYdiv) ;
virtual void SetChargeAngle(Float_t angle){fChargeAngle = angle;} //set angle of pad and charge distribution
//axes
virtual void SetPadAngle(Float_t angle){fPadAngle = angle;} //set pad angle
void SetInterpolationType(Int_t interx, Int_t intery) {fInterX=interx; fInterY =intery;}
virtual void SetGauss(Float_t sigmaX,Float_t sigmaY , Float_t kNorm=1);
- //adjust PRF with GAUSIAN as generic GRF
+ //adjust PRF with GAUSIAN as generic GRF
//if direct = kTRUE then it does't convolute distribution
virtual void SetCosh(Float_t sigmaX,Float_t sigmaY , Float_t kNorm=1);
//adjust PRF with 1/Cosh as generic GRF
virtual void SetGati(Float_t K3X, Float_t K3Y,
Float_t padDistance,
Float_t kNorm=1);
- void SetParam(TF2 *const GRF,Float_t kNorm,
+ void SetParam(TF2 *const GRF,Float_t kNorm,
Float_t sigmaX=0, Float_t sigmaY=0);
void SetNdiv(Int_t Ndiv){fNdiv=Ndiv;}
virtual Float_t GetSigmaX() const {return fSigmaX;}
virtual Float_t GetSigmaY() const {return fSigmaY;}
-
-
+
+
protected:
- void Update1();
+ void Update1();
virtual void UpdateSigma(); //recalculate sigma of PRF
Float_t GetPRFActiv(Float_t xin); //return PRF in point xin and actual y
- Float_t * fcharge; //!field with PRF
- Float_t fY1; //position of first "virtual" vire
- Float_t fY2; //position of last virtual vire
- Int_t fNYdiv; //number of wires
- Int_t fNChargeArray; //number of charge interpolation points
- Float_t * fChargeArray; //[fNChargeArray]pointer to array of arrays
-
+ Float_t * fcharge; //!< field with PRF
+ Float_t fY1; ///< position of first "virtual" vire
+ Float_t fY2; ///< position of last virtual vire
+ Int_t fNYdiv; ///< number of wires
+ Int_t fNChargeArray; ///< number of charge interpolation points
+ /// pointer to array of arrays
+ Float_t * fChargeArray; //[fNChargeArray]
+
void DrawComment(TPaveText * comment); //draw comments to picture
//chevron parameters
- Float_t fHeightFull; //height of the full pad
- Float_t fHeightS; //height of the one step
- Float_t fShiftY; //shift of the step
- Float_t fWidth; //width of the pad
- Float_t fK; //k factor of the chewron
-
- Double_t funParam[5];//parameters of used charge function
- Int_t fNPRF; //number of interpolations point
- Int_t fNdiv; //number of division to calculate integral
- Float_t fDStep; //element step for point
- Float_t fKNorm; //normalisation factor of the charge integral
- Float_t fInteg; //integral of GRF on +- infinity
- TF2 * fGRF; //charge distribution function
-
- Float_t fK3X; //KX parameter (only for Gati parametrization)
- Float_t fK3Y; //KY parameter (only for Gati parametrisation)
- Float_t fPadDistance; //pad anode distnce (only for Gati parametrisation)
-
- Float_t fOrigSigmaX; //sigma of original distribution;
- Float_t fOrigSigmaY; //sigma of original distribution;
-
- Float_t fChargeAngle;//'angle' of charge distribution refernce system to pad reference system
- Float_t fPadAngle; //'angle' of the pad assymetry
-
- Float_t fSigmaX; //sigma X of PAD response function
- Float_t fSigmaY; //sigma Y of PAD response function
- Float_t fMeanX; //mean X value
- Float_t fMeanY; //mean Y value
- Int_t fInterX; //interpolation in X
- Int_t fInterY; //interpolation in Y
+ Float_t fHeightFull; ///< height of the full pad
+ Float_t fHeightS; ///< height of the one step
+ Float_t fShiftY; ///< shift of the step
+ Float_t fWidth; ///< width of the pad
+ Float_t fK; ///< k factor of the chewron
+
+ Double_t funParam[5];///< parameters of used charge function
+ Int_t fNPRF; ///< number of interpolations point
+ Int_t fNdiv; ///< number of division to calculate integral
+ Float_t fDStep; ///< element step for point
+ Float_t fKNorm; ///< normalisation factor of the charge integral
+ Float_t fInteg; ///< integral of GRF on +- infinity
+ TF2 * fGRF; ///< charge distribution function
+
+ Float_t fK3X; ///< KX parameter (only for Gati parametrization)
+ Float_t fK3Y; ///< KY parameter (only for Gati parametrisation)
+ Float_t fPadDistance; ///< pad anode distnce (only for Gati parametrisation)
+
+ Float_t fOrigSigmaX; ///< sigma of original distribution;
+ Float_t fOrigSigmaY; ///< sigma of original distribution;
+
+ Float_t fChargeAngle;///< 'angle' of charge distribution refernce system to pad reference system
+ Float_t fPadAngle; ///< 'angle' of the pad assymetry
+
+ Float_t fSigmaX; ///< sigma X of PAD response function
+ Float_t fSigmaY; ///< sigma Y of PAD response function
+ Float_t fMeanX; ///< mean X value
+ Float_t fMeanY; ///< mean Y value
+ Int_t fInterX; ///< interpolation in X
+ Int_t fInterY; ///< interpolation in Y
//calculated during update
- char fType[5]; //charge type
- Float_t fCurrentY; //in reality we calculate PRF only for one fixed y
- Float_t fDYtoWire; //! used to make PRF calculation faster in GetPRF
- Float_t fDStepM1; //! used in GetPRFActiv to make calculation faster
+ char fType[5]; ///< charge type
+ Float_t fCurrentY; ///< in reality we calculate PRF only for one fixed y
+ Float_t fDYtoWire; //!< used to make PRF calculation faster in GetPRF
+ Float_t fDStepM1; //!< used in GetPRFActiv to make calculation faster
//
- static const Double_t fgkDegtoRad; //numeric constant
- static const Double_t fgkSQRT12; //numeric constant
- static const Int_t fgkNPRF; //default number of division
+ static const Double_t fgkDegtoRad; ///< numeric constant
+ static const Double_t fgkSQRT12; ///< numeric constant
+ static const Int_t fgkNPRF; ///< default number of division
-private:
+private:
AliTPCPRF2D(const AliTPCPRF2D &prf);
AliTPCPRF2D &operator = (const AliTPCPRF2D &/*prf*/) {return *this;}
-
- ClassDef(AliTPCPRF2D,1)
-};
+
+ /// \cond CLASSIMP
+ ClassDef(AliTPCPRF2D,1)
+ /// \endcond
+};
#endif /* ALITPCPRF2D_H */
* provided "as is" without express or implied warranty. *
**************************************************************************/
-/* $Id$ */
-
-///////////////////////////////////////////////////////////////////////
-// Manager and of geomety classes for set: TPC //
-// //
-// !sectors are numbered from 0 //
-// !pad rows are numbered from 0 //
-//
-// 12.6. changed z relative
-// Origin: Marian Ivanov, Uni. of Bratislava, ivanov@fmph.uniba.sk //
-// //
-///////////////////////////////////////////////////////////////////////
+
+/// \class AliTPCParam
+/// \brief Manager and of geomety classes for set: TPC
+///
+/// !sectors are numbered from 0
+/// !pad rows are numbered from 0
+///
+/// 12.6. changed z relative
+///
+/// \author Marian Ivanov, Uni. of Bratislava, ivanov@fmph.uniba.sk
//
TObjArray *AliTPCParam::fBBParam = 0;
+/// \cond CLASSIMP
ClassImp(AliTPCParam)
+/// \endcond
//___________________________________________
fRotAngle(),
fGeometryType(0),
fTrackingMatrix(0),
- fClusterMatrix(0),
+ fClusterMatrix(0),
fGlobalMatrix(0),
fNInnerWiresPerPad(0),
fInnerWWPitch(0),
fGateDelay(0.),
fL1Delay(0.),
fNTBinsBeforeL1(0),
- fNTBinsL1(0.)
-{
+ fNTBinsL1(0.)
+{
//
//constructor sets the default parameters
//
SetTitle("75x40_100x60_150x60");
- SetDefault();
+ SetDefault();
if (!fBBParam) fBBParam= new TObjArray(1000);
}
AliTPCParam::~AliTPCParam()
{
- //
- //destructor deletes some dynamicaly alocated variables
- //
+ /// destructor deletes some dynamicaly alocated variables
if (fResponseBin!=0) delete [] fResponseBin;
if (fResponseWeight!=0) delete [] fResponseWeight;
Int_t AliTPCParam::Transform0to1(Float_t *xyz, Int_t * index) const
{
- //
- // calculates sector number (index[1], undefined on input)
- // xyz intact
- //
+ /// calculates sector number (index[1], undefined on input)
+ /// xyz intact
Float_t angle,x1;
Int_t sector;
if ( (xyz[0]>0) && (xyz[1]<0) ) angle=2*TMath::Pi()+angle;
}
- sector=Int_t(TMath::Nint((angle-fInnerAngleShift)/fInnerAngle));
-
+ sector=Int_t(TMath::Nint((angle-fInnerAngleShift)/fInnerAngle));
+
Float_t cos,sin;
AdjustCosSin(sector,cos,sin);
x1=xyz[0]*cos + xyz[1]*sin;
if (x1>fOuterRadiusLow)
{
- sector=Int_t(TMath::Nint((angle-fOuterAngleShift)/fOuterAngle))+fNInnerSector;
- if (xyz[2]<0) sector+=(fNOuterSector>>1);
+ sector=Int_t(TMath::Nint((angle-fOuterAngleShift)/fOuterAngle))+fNInnerSector;
+ if (xyz[2]<0) sector+=(fNOuterSector>>1);
}
- else
- if (xyz[2]<0) sector+=(fNInnerSector>>1);
+ else
+ if (xyz[2]<0) sector+=(fNInnerSector>>1);
if (sector<0 || sector>=fNSector) AliError(Form("Wrong sector %d",sector));
index[1]=sector; // calculated sector number
index[0]=1; // indicates system after transformation
Bool_t AliTPCParam::Transform(Float_t */*xyz*/, Int_t *index, Int_t* /*oindex*/)
{
- //transformation from input coodination system to output coordination system
+ /// transformation from input coodination system to output coordination system
+
switch (index[0]){
case 0:
break;
}
-Int_t AliTPCParam::GetPadRow(Float_t *xyz, Int_t *index) const
+Int_t AliTPCParam::GetPadRow(Float_t *xyz, Int_t *index) const
{
- //
- //calculates pad row of point xyz - transformation to system 8 (digit system)
- //
+ /// calculates pad row of point xyz - transformation to system 8 (digit system)
+
Int_t system = index[0];
if (0==system) {
- Transform0to1(xyz,index);
+ Transform0to1(xyz,index);
system=1;
}
if (1==system) {
- Transform1to2(xyz,index);
+ Transform1to2(xyz,index);
system=2;
}
-
- if (fGeometryType==0){ //straight row
+
+ if (fGeometryType==0){ //straight row
if (2==system) {
- Transform2to3(xyz,index);
+ Transform2to3(xyz,index);
system=3;
- }
+ }
if (3==system) {
Transform3to4(xyz,index);
- system=4;
+ system=4;
}
if (4==system) {
Transform4to8(xyz,index);
- system=8;
+ system=8;
}
if (8==system) {
index[0]=8;
return index[2];
- }
+ }
}
- if (fGeometryType==1){ //cylindrical geometry
+ if (fGeometryType==1){ //cylindrical geometry
if (2==system) {
- Transform2to5(xyz,index);
+ Transform2to5(xyz,index);
system=5;
- }
+ }
if (5==system) {
Transform2to3(xyz,index);
system=6;
}
if (6==system) {
- Transform3to4(xyz,index);
+ Transform3to4(xyz,index);
system=7;
}
if (8==system) {
index[0]=8;
return index[2];
}
- }
+ }
index[0]=system;
- return -1; //if no reasonable system
+ return -1; //if no reasonable system
}
void AliTPCParam::SetSectorAngles(Float_t innerangle, Float_t innershift, Float_t outerangle,
Float_t outershift)
{
- //
- // set opening angles
+ /// set opening angles
+
static const Float_t kDegtoRad = 0.01745329251994;
fInnerAngle = innerangle; //opening angle of Inner sector
fInnerAngleShift = innershift; //shift of first inner sector center to the 0
fOuterAngle = outerangle; //opening angle of outer sector
- fOuterAngleShift = outershift; //shift of first sector center to the 0
+ fOuterAngleShift = outershift; //shift of first sector center to the 0
fInnerAngle *=kDegtoRad;
fInnerAngleShift *=kDegtoRad;
fOuterAngle *=kDegtoRad;
Float_t AliTPCParam::GetInnerAngle() const
{
- //return angle
+ /// return angle
+
return fInnerAngle;
}
Float_t AliTPCParam::GetInnerAngleShift() const
-{
- //return angle
- return fInnerAngleShift;
+{
+ /// return angle
+
+ return fInnerAngleShift;
}
Float_t AliTPCParam::GetOuterAngle() const
-{
- //return angle
+{
+ /// return angle
+
return fOuterAngle;
-}
+}
Float_t AliTPCParam::GetOuterAngleShift() const
-{
- //return angle
+{
+ /// return angle
return fOuterAngleShift;
-}
+}
Int_t AliTPCParam::GetIndex(Int_t sector, Int_t row) const
{
- //
- //give index of the given sector and pad row
- //no control if the sectors and rows are reasonable !!!
- //
+ /// give index of the given sector and pad row
+ /// no control if the sectors and rows are reasonable !!!
+
if (sector<fNInnerSector) return sector*fNRowLow+row;
- return (fNInnerSector*fNRowLow)+(sector-fNInnerSector)*fNRowUp+row;
+ return (fNInnerSector*fNRowLow)+(sector-fNInnerSector)*fNRowUp+row;
}
Bool_t AliTPCParam::AdjustSectorRow(Int_t index, Int_t & sector, Int_t &row) const
{
- //
- //return sector and padrow for given index
- //if index is reasonable returns true else return false
- //
+ /// return sector and padrow for given index
+ /// if index is reasonable returns true else return false
+
if ( (index<0) || (index>fNtRows)) return kFALSE;
Int_t outindex = fNInnerSector*fNRowLow;
if (index<outindex) {
sector = index/fNRowUp;
row = index - sector*fNRowUp;
sector += fNInnerSector;
- return kTRUE;
-}
+ return kTRUE;
+}
void AliTPCParam::SetDefault()
{
- //
- //set default parameters
- //
- //const static Int_t kMaxRows=600;
- //
- //sector default parameters
- //
+ /// set default parameters
+ ///
+ /// const static Int_t kMaxRows=600;
+ ///
+ /// sector default parameters
+
static const Float_t kInnerRadiusLow = 83.65;
static const Float_t kInnerRadiusUp = 133.3;
static const Float_t kOuterRadiusLow = 133.5;
static const Float_t kInnerWireMount = 1.2;
static const Float_t kOuterWireMount = 1.4;
static const Float_t kZLength =250.;
- static const Int_t kGeometryType = 0; //straight rows
+ static const Int_t kGeometryType = 0; //straight rows
static const Int_t kNRowLow = 63;
static const Int_t kNRowUp1 = 64;
static const Int_t kNRowUp2 = 32;
static const Float_t kInnerOffWire = 0.5;
static const Int_t kNOuter1WiresPerPad = 4;
static const Int_t kNOuter2WiresPerPad = 6;
- static const Float_t kOuterWWPitch = 0.25;
+ static const Float_t kOuterWWPitch = 0.25;
static const Float_t kROuterFirstWire = 134.225;
static const Float_t kROuterLastWire = 246.975;
static const Int_t kOuterDummyWire = 2;
static const Float_t kOuterOffWire = 0.5;
//
//pad default parameters
- //
+ //
static const Float_t kInnerPadPitchLength = 0.75;
static const Float_t kInnerPadPitchWidth = 0.40;
static const Float_t kInnerPadLength = 0.75;
static const Float_t kOuter2PadPitchLength = 1.5;
static const Float_t kOuter2PadLength = 1.5;
- static const Bool_t kBMWPCReadout = kTRUE; //MWPC readout - another possibility GEM
+ static const Bool_t kBMWPCReadout = kTRUE; //MWPC readout - another possibility GEM
static const Int_t kNCrossRows = 1; //number of rows to cross-talk
-
+
//
//gas default parameters
//
- static const Float_t kDiffT = 2.2e-2;
+ static const Float_t kDiffT = 2.2e-2;
static const Float_t kDiffL = 2.2e-2;
static const Float_t kGasGain = 2.e4;
static const Float_t kDriftV =2.83e6;
static const Float_t kNtot=42.66;
static const Float_t kWmean = 35.97e-9;
static const Float_t kExp = 2.2;
- static const Float_t kEend = 10.e-6;
+ static const Float_t kEend = 10.e-6;
//
//electronic default parameters
//
static const Float_t kPadCoupling=0.5;
static const Int_t kZeroSup=2;
- static const Float_t kNoise = 1000;
+ static const Float_t kNoise = 1000;
static const Float_t kChipGain = 12;
static const Float_t kChipNorm = 0.4;
- static const Float_t kTSample = 2.e-7;
+ static const Float_t kTSample = 2.e-7;
static const Float_t kTFWHM = 1.9e-7; //fwhm of charge distribution
- static const Int_t kMaxTBin =445;
- static const Int_t kADCSat =1024;
- static const Float_t kADCDynRange =2000.;
- //
+ static const Int_t kMaxTBin =445;
+ static const Int_t kADCSat =1024;
+ static const Float_t kADCDynRange =2000.;
+ //
//response constants
//
static const Int_t kNResponseMax=100;
- static const Float_t kResponseThreshold=0.01;
+ static const Float_t kResponseThreshold=0.01;
//L1 constants
// static const Float_t kGateDelay=6.1e-6; //In s
static const Float_t kGateDelay=0.; //For the moment no gating
SetRInnerLastWire(kRInnerLastWire);
SetOuterWWPitch(kOuterWWPitch);
SetROuterFirstWire(kROuterFirstWire);
- SetROuterLastWire(kROuterLastWire);
+ SetROuterLastWire(kROuterLastWire);
//
//set pad parameter
//
SetInnerPadPitchWidth(kInnerPadPitchWidth);
SetInnerPadLength(kInnerPadLength);
SetInnerPadWidth(kInnerPadWidth);
- SetOuter1PadPitchLength(kOuter1PadPitchLength);
+ SetOuter1PadPitchLength(kOuter1PadPitchLength);
SetOuter2PadPitchLength(kOuter2PadPitchLength);
SetOuterPadPitchWidth(kOuterPadPitchWidth);
SetOuter1PadLength(kOuter1PadLength);
SetOuter2PadLength(kOuter2PadLength);
- SetOuterPadWidth(kOuterPadWidth);
+ SetOuterPadWidth(kOuterPadWidth);
SetMWPCReadout(kBMWPCReadout);
SetNCrossRows(kNCrossRows);
//
SetBetheBloch(GetBetheBlochParamAlice());
SetBetheBlochMC(GetBetheBlochParamAliceMC());
//
- //set electronivc parameters
+ //set electronivc parameters
//
SetPadCoupling(kPadCoupling);
SetZeroSup(kZeroSup);
SetNoise(kNoise);
SetChipGain(kChipGain);
- SetChipNorm(kChipNorm);
+ SetChipNorm(kChipNorm);
SetTSample(kTSample);
SetTFWHM(kTFWHM);
SetMaxTBin(kMaxTBin);
// SetNPrimLoss(kNPrimLoss);
// SetNTotalLoss(kNTotalLoss);
//
- //set response parameters
+ //set response parameters
//
- SetNResponseMax(kNResponseMax);
+ SetNResponseMax(kNResponseMax);
SetResponseThreshold(static_cast<int>(kResponseThreshold));
//L1 data
SetGateDelay(kGateDelay);
SetNominalGainSlopes();
}
-
+
Bool_t AliTPCParam::Update()
{
- //
- // update some calculated parameter which must be updated after changing "base"
- // parameters
- // for example we can change size of pads and according this recalculate number
- // of pad rows, number of of pads in given row ....
- //
+ /// update some calculated parameter which must be updated after changing "base"
+ /// parameters
+ /// for example we can change size of pads and according this recalculate number
+ /// of pad rows, number of of pads in given row ....
+
const Float_t kQel = 1.602e-19; // elementary charge
fbStatus = kFALSE;
- Int_t i,j; //loop variables because HP
+ Int_t i,j; //loop variables because HP
//-----------------Sector section------------------------------------------
//calclulate number of sectors
- fNInnerSector = Int_t(4*TMath::Pi()/fInnerAngle+0.2);
+ fNInnerSector = Int_t(4*TMath::Pi()/fInnerAngle+0.2);
// number of inner sectors - factor 0.2 to don't be influnced by inprecision
if (fNInnerSector%2) return kFALSE;
- fNOuterSector = Int_t(4*TMath::Pi()/fOuterAngle+0.2);
+ fNOuterSector = Int_t(4*TMath::Pi()/fOuterAngle+0.2);
if (fNOuterSector%2) return kFALSE;
fNSector = fNInnerSector+fNOuterSector;
if (fRotAngle!=0) delete [] fRotAngle;
fRotAngle = new Float_t[4*fNSector];
- //calculate sin and cosine of rotations angle
+ //calculate sin and cosine of rotations angle
//sectors angles numbering from 0
j=fNInnerSector*2;
- Float_t angle = fInnerAngleShift;
+ Float_t angle = fInnerAngleShift;
for (i=0; j<fNInnerSector*4; i+=4, j+=4 , angle +=fInnerAngle){
fRotAngle[i]=TMath::Cos(angle);
fRotAngle[i+1]=TMath::Sin(angle);
fRotAngle[i+3] =angle;
fRotAngle[j+3] =angle;
}
- angle = fOuterAngleShift;
+ angle = fOuterAngleShift;
j=(fNInnerSector+fNOuterSector/2)*4;
for (i=fNInnerSector*4; j<fNSector*4; i+=4,j+=4, angle +=fOuterAngle){
fRotAngle[i]=TMath::Cos(angle);
fRotAngle[j+3] =angle;
}
- fZWidth = fTSample*fDriftV;
+ fZWidth = fTSample*fDriftV;
fTotalNormFac = fPadCoupling*fChipNorm*kQel*1.e15*fChipGain*fADCSat/fADCDynRange;
fNoiseNormFac = kQel*1.e15*fChipGain*fADCSat/fADCDynRange;
- //wire section
+ //wire section
/* Int_t nwire;
Float_t wspace; //available space for wire
Float_t dummyspace; //dummyspace for wire
-
+
wspace =fInnerRadiusUp-fInnerRadiusLow-2*fInnerOffWire;
nwire = Int_t(wspace/fInnerWWPitch);
wspace = Float_t(nwire)*fInnerWWPitch;
- dummyspace =(fInnerRadiusUp-fInnerRadiusLow-wspace)/2.;
+ dummyspace =(fInnerRadiusUp-fInnerRadiusLow-wspace)/2.;
wspace =fOuterRadiusUp-fOuterRadiusLow-2*fOuterOffWire;
nwire = Int_t(wspace/fOuterWWPitch);
wspace = Float_t(nwire)*fOuterWWPitch;
- dummyspace =(fOuterRadiusUp-fOuterRadiusLow-wspace)/2.;
+ dummyspace =(fOuterRadiusUp-fOuterRadiusLow-wspace)/2.;
fROuterFirstWire = fOuterRadiusLow+dummyspace;
fROuterLastWire = fROuterFirstWire+fOuterWWPitch*(Float_t)(nwire);
*/
-
+
//
//response data
//
}
void AliTPCParam::CleanGeoMatrices(){
- //
- // clean geo matrices
- //
+ /// clean geo matrices
if (fTrackingMatrix) {
for(Int_t i = 0; i < fNSector; i++)
delete fTrackingMatrix[i];
delete [] fTrackingMatrix;
}
-
+
if (fClusterMatrix) {
for(Int_t i = 0; i < fNSector; i++)
delete fClusterMatrix[i];
delete [] fClusterMatrix;
}
-
+
if (fGlobalMatrix) {
for(Int_t i = 0; i < fNSector; i++)
delete fGlobalMatrix[i];
delete [] fGlobalMatrix;
}
-
+
return;
}
Bool_t AliTPCParam::ReadGeoMatrices(){
- //
- // read geo matrixes
- //
+ /// read geo matrixes
+
if (!gGeoManager){
AliFatal("Geo manager not initialized\n");
}
fGlobalMatrix[isec] = 0;
fClusterMatrix[isec]= 0;
fTrackingMatrix[isec]=0;
- }
+ }
//
for (Int_t isec=0; isec<fNSector; isec++) {
fGlobalMatrix[isec] = 0;
fClusterMatrix[isec]= 0;
- fTrackingMatrix[isec]=0;
+ fTrackingMatrix[isec]=0;
AliGeomManager::ELayerID iLayer;
Int_t iModule;
TGeoHMatrix *m = gGeoManager->GetCurrentMatrix();
// Since GEANT4 does not allow reflections, in this case the reflection
// component if the matrix is embedded by TGeo inside TGeoScaledShape
- if (gGeoManager->GetCurrentVolume()->GetShape()->IsReflected())
+ if (gGeoManager->GetCurrentVolume()->GetShape()->IsReflected())
m->ReflectZ(kFALSE, kTRUE);
//
- TGeoRotation mchange;
+ TGeoRotation mchange;
mchange.RotateY(90); mchange.RotateX(90);
- Float_t ROCcenter[3];
+ Float_t ROCcenter[3];
GetChamberCenter(isec,ROCcenter);
//
// Convert to global coordinate system
rotMatrix.RotateZ(sectorAngle);
if (GetGlobalMatrix(isec)->GetTranslation()[2]>0){
//
- // mirrored system
+ // mirrored system
//
TGeoRotation mirrorZ;
mirrorZ.SetAngles(90,0,90,90,180,0);
}
TGeoTranslation trans(0,0,GetZLength(isec));
fClusterMatrix[isec]->MultiplyLeft(&trans);
- fClusterMatrix[isec]->MultiplyLeft((GetGlobalMatrix(isec)));
+ fClusterMatrix[isec]->MultiplyLeft((GetGlobalMatrix(isec)));
fClusterMatrix[isec]->MultiplyLeft(&(rotMatrix.Inverse()));
}
return kTRUE;
}
TGeoHMatrix * AliTPCParam::Tracking2LocalMatrix(const TGeoHMatrix * geoMatrix, Int_t sector) const{
- //
- // make local to tracking matrix
- //
+ /// make local to tracking matrix
+
Double_t sectorAngle = 20.*(sector%18)+10;
TGeoHMatrix *newMatrix = new TGeoHMatrix();
newMatrix->RotateZ(sectorAngle);
Bool_t AliTPCParam::GetStatus() const
{
- //get information about object consistency
+ /// get information about object consistency
+
return fbStatus;
}
Int_t AliTPCParam::GetNRowLow() const
{
- //get the number of pad rows in low sector
+ /// get the number of pad rows in low sector
+
return fNRowLow;
}
Int_t AliTPCParam::GetNRowUp() const
{
- //get the number of pad rows in up sector
+ /// get the number of pad rows in up sector
+
return fNRowUp;
}
Int_t AliTPCParam::GetNRowUp1() const
{
- //get the number of pad rows in up1 sector
+ /// get the number of pad rows in up1 sector
+
return fNRowUp1;
}
Int_t AliTPCParam::GetNRowUp2() const
{
- //get the number of pad rows in up2 sector
+ /// get the number of pad rows in up2 sector
+
return fNRowUp2;
}
Float_t AliTPCParam::GetPadRowRadiiLow(Int_t irow) const
{
- //get the pad row (irow) radii
- if ( !(irow<0) && (irow<fNRowLow) )
+ /// get the pad row (irow) radii
+
+ if ( !(irow<0) && (irow<fNRowLow) )
return fPadRowLow[irow];
else
return 0;
Float_t AliTPCParam::GetPadRowRadiiUp(Int_t irow) const
{
- //get the pad row (irow) radii
- if ( !(irow<0) && (irow<fNRowUp) )
+ /// get the pad row (irow) radii
+
+ if ( !(irow<0) && (irow<fNRowUp) )
return fPadRowUp[irow];
else
return 0;
Int_t AliTPCParam::GetNPadsLow(Int_t irow) const
{
- //get the number of pads in row irow
- if ( !(irow<0) && (irow<fNRowLow) )
+ /// get the number of pads in row irow
+
+ if ( !(irow<0) && (irow<fNRowLow) )
return fNPadsLow[irow];
else
return 0;
Int_t AliTPCParam::GetNPadsUp(Int_t irow) const
{
- //get the number of pads in row irow
- if ( !(irow<0) && (irow<fNRowUp) )
+ /// get the number of pads in row irow
+
+ if ( !(irow<0) && (irow<fNRowUp) )
return fNPadsUp[irow];
else
return 0;
Int_t AliTPCParam::GetWireSegment(Int_t sector, Int_t row) const
{
- //
- // Get Anode wire segment index IROC --> 4 segments in [0,3], 7 segments OROC[4,10]
- //
- // To be speed-up using caching lookup table
- //
- Int_t wireIndex = -1;
+ /// Get Anode wire segment index IROC --> 4 segments in [0,3], 7 segments OROC[4,10]
+ ///
+ /// To be speed-up using caching lookup table
+
+ Int_t wireIndex = -1;
// check if the given set of sector and row is OK
if ( (sector<0 || sector>=72) || (row<0 || row>95) || (sector<36 && row>64) ){
AliError("No matching anode wire segment for this set of sector-row \n");
return wireIndex;
- }
+ }
// find the wire index for given sector-row
- if ( sector<36 ){ // IROC anode wire segments
+ if ( sector<36 ){ // IROC anode wire segments
if (row<16) wireIndex=0;
else if (row>=16 && row<32) wireIndex=1;
else if (row>=32 && row<48) wireIndex=2;
- else wireIndex=3;
- } else { // OROC anode wire segments
+ else wireIndex=3;
+ } else { // OROC anode wire segments
if (row<16) wireIndex=4;
else if ( row>=16 && row<32) wireIndex=5;
else if ( row>=32 && row<48) wireIndex=6;
else if ( row>=64 && row<75) wireIndex=8;
else if ( row>=75 && row<85) wireIndex=9;
else wireIndex=10;
- }
- return wireIndex;
+ }
+ return wireIndex;
}
Int_t AliTPCParam::GetNPadsPerSegment(Int_t wireSegmentID) const
{
- //
- // Get the number of pads in a given anode wire segment
- //
- // check if the given segment index is OK
- // To be done (if needed) - cache the lookup table
- //
+ /// Get the number of pads in a given anode wire segment
+ ///
+ /// check if the given segment index is OK
+ /// To be done (if needed) - cache the lookup table
+
if ( wireSegmentID<0 || wireSegmentID>10 ){
AliError("Wrong anode wire segment index. it should be [0,10] \n");
return -1;
}
// get sector type from wireSegmentID
- Int_t sector = (wireSegmentID<4) ? 0 : 36; // ROC [0,35] --> IROC, ROC [36,71] --> OROC
+ Int_t sector = (wireSegmentID<4) ? 0 : 36; // ROC [0,35] --> IROC, ROC [36,71] --> OROC
// get the upper and lower row number for the given wireSegmentID
Int_t segRowDown = 0;
Int_t segRowUp = 0;
-
+
if ( wireSegmentID == 0 || wireSegmentID == 4 ) {
segRowDown = 0;
segRowUp = 16;
} else {
segRowDown = 85;
segRowUp = 95;
- }
+ }
// count the number of pads on the given segment
AliTPCROC *r=AliTPCROC::Instance();
Int_t nPads=0;
Int_t AliTPCParam::GetSectorIndex(Float_t angle, Int_t row, Float_t z) const
{
- // returns the sector index
- // takes as input the angle, index of the pad row and z position
+ /// returns the sector index
+ /// takes as input the angle, index of the pad row and z position
+
if(row<0) return -1;
if (angle > 2.*TMath::Pi()) angle -= 2.*TMath::Pi();
if (angle < 0. ) angle += 2.*TMath::Pi();
-
+
Int_t sector;
if(row<fNRowLow) {
sector=Int_t(TMath::Nint((angle-fInnerAngleShift)/fInnerAngle));
if (z<0) sector += (fNInnerSector>>1);
}
else {
- sector=Int_t(TMath::Nint((angle-fOuterAngleShift)/fOuterAngle))+fNInnerSector;
+ sector=Int_t(TMath::Nint((angle-fOuterAngleShift)/fOuterAngle))+fNInnerSector;
if (z<0) sector += (fNOuterSector>>1);
- }
-
+ }
+
return sector;
}
Float_t AliTPCParam::GetChamberCenter(Int_t isec, Float_t * center) const
{
- // returns the default radial position
- // of the readout chambers
+ /// returns the default radial position
+ /// of the readout chambers
const Float_t kROCcenterIn = 110.2;
const Float_t kROCcenterOut = 188.45;
if (isec<fNInnerSector){
if (center){
center[0] = kROCcenterIn;
- center[1] = 0;
- center[2] = -5.51-0.08;
+ center[1] = 0;
+ center[2] = -5.51-0.08;
}
return kROCcenterIn;
}
else{
if (center){
center[0] = kROCcenterOut;
- center[1] = 0;
- center[2] = -5.61-0.08;
+ center[1] = 0;
+ center[2] = -5.61-0.08;
}
return kROCcenterOut;
}
}
void AliTPCParam::SetNominalGainSlopes(){
- //
- // Setting the nominal TPC gain slopes
- // Nominal values were obtained as a mena values foe 2010,2011, and 2012 data
- // Differntial values can be provided per year
- //
+ /// Setting the nominal TPC gain slopes
+ /// Nominal values were obtained as a mena values foe 2010,2011, and 2012 data
+ /// Differntial values can be provided per year
+
Float_t sector[72]={0};
Float_t gainHV[72]={0};
Float_t gainPT[72]={0};
TVectorD * AliTPCParam::GetBetheBlochParamNa49(){
- //
- // Parameters of the BB for the Aleph parametrization AliMathBase::BetheBlochAleph
- // Na49 parameters were used as first set of parameters for ALICE simulation
- // (see TPC TDR for details)
+ /// Parameters of the BB for the Aleph parametrization AliMathBase::BetheBlochAleph
+ /// Na49 parameters were used as first set of parameters for ALICE simulation
+ /// (see TPC TDR for details)
+
TVectorD v(5);
v(0)=0.76176e-1;
v(1)=10.632;
}
TVectorD * AliTPCParam::GetBetheBlochParamAlice(){
- //
- //
- // Parameters of the BB for the Aleph parametrization AliMathBase::BetheBlochAleph
- // Na49 parameters were used as first set of parameters for ALICE simulation
- // Second set was obtained from ALICE 2009-2013 data taking
- // (see TPC TDR for details)
- //
+ /// Parameters of the BB for the Aleph parametrization AliMathBase::BetheBlochAleph
+ /// Na49 parameters were used as first set of parameters for ALICE simulation
+ /// Second set was obtained from ALICE 2009-2013 data taking
+ /// (see TPC TDR for details)
+
TVectorD v(5);
v[0] = 0.0851148;
v[1] = 9.25771;
}
TVectorD * AliTPCParam::GetBetheBlochParamAliceMC(){
- //
- //
- // Parameters of the BB for the Aleph parametrization AliMathBase::BetheBlochAleph
- // dNdx parameterization
+ /// Parameters of the BB for the Aleph parametrization AliMathBase::BetheBlochAleph
+ /// dNdx parameterization
+
TVectorD v(5);
v[0] =0.0820172 ;
v[1] =9.94795 ;
- v[2] =8.97292e-05;
+ v[2] =8.97292e-05;
v[3] =2.05873 ;
v[4] =1.65272 ;
Double_t AliTPCParam::BetheBlochAleph(Double_t bg, Int_t type){
- //
- // GetBetheBloch retur values for the parametrs regieter at poition type
- // Used for visualization and comparison purposes
+ /// GetBetheBloch retur values for the parametrs regieter at poition type
+ /// Used for visualization and comparison purposes
+
TVectorD * paramBB =0;
if (type==0) {
AliTPCParam* param = AliTPCcalibDB::Instance()->GetParameters();
if (param) paramBB=param->GetBetheBlochParameters();
- }
+ }
if (type==1){
paramBB = (TVectorD*)fBBParam->At(type);
}
if (!paramBB) return 0;
//
- return AliMathBase::BetheBlochAleph(bg,(*paramBB)(0),(*paramBB)(1),(*paramBB)(2),(*paramBB)(3),(*paramBB)(4));
+ return AliMathBase::BetheBlochAleph(bg,(*paramBB)(0),(*paramBB)(1),(*paramBB)(2),(*paramBB)(3),(*paramBB)(4));
}
void AliTPCParam::RegisterBBParam(TVectorD* param, Int_t position){
- //
- //
- //
+ ///
+
fBBParam->AddAt(param,position);
}
/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
* See cxx source for full Copyright notice */
-/* $Id$ */
-////////////////////////////////////////////////
-// Manager class for TPC parameters //
-////////////////////////////////////////////////
+/// \class AliTPCParam
+/// \brief Manager class for TPC parameters
#include "AliDetectorParam.h"
#include "TMath.h"
class AliTPCParam : public AliDetectorParam {
//////////////////////////////////////////////////////
//////////////////////////////////////////////////////
- //ALITPCParam object to be possible change
- //geometry and some other parameters of TPC
- //used by AliTPC and AliTPCSector
-
+ //ALITPCParam object to be possible change
+ //geometry and some other parameters of TPC
+ //used by AliTPC and AliTPCSector
+
public:
- AliTPCParam();
+ AliTPCParam();
virtual ~AliTPCParam();
- TGeoHMatrix * Tracking2LocalMatrix(const TGeoHMatrix * geoMatrix, Int_t sector) const;
+ TGeoHMatrix * Tracking2LocalMatrix(const TGeoHMatrix * geoMatrix, Int_t sector) const;
virtual Bool_t Transform(Float_t *xyz, Int_t *index, Int_t* oindex);
- //transformation from input coodination system to output coordination system
+ //transformation from input coodination system to output coordination system
Int_t Transform0to1(Float_t *xyz, Int_t *index) const;
- //trasforamtion from global to global - adjust index[0] sector
+ //trasforamtion from global to global - adjust index[0] sector
//return value is equal to sector corresponding to global position
void Transform1to2Ideal(Float_t *xyz, Int_t *index) const;
- //transformation to rotated coordinata - ideal frame
+ //transformation to rotated coordinata - ideal frame
void Transform1to2(Float_t *xyz, Int_t *index) const;
- //transformation to rotated coordinata
+ //transformation to rotated coordinata
void Transform2to1(Float_t *xyz, Int_t *index) const;
//transformation from rotated coordinata to global coordinata
void Transform2to2(Float_t *xyz, Int_t *index, Int_t *oindex) const;
//round x position to nearest wire
Int_t Transform2to3(Float_t *xyz, Int_t *index) const;
//calulate coresponding index[2] -pad row for straight rows
- //does not change xyz[]
- //return pad - row
+ //does not change xyz[]
+ //return pad - row
void Transform3to4(Float_t *xyz, Int_t *index) const;
//valid only for straight rows straight rows
//calculate xyz[0] position relative to given index
- //return pad - row
+ //return pad - row
void Transform4to3(Float_t *xyz, Int_t *index) const;
//valid only for straight rows straight rows
//transform xyz[0] position relative to given index
void Transform2to5( Float_t *xyz, Int_t *index) const;
//transform [x,y,z] to [r,rphi,z]
void Transform5to2(Float_t *xyz, Int_t *index) const;
- //transform [r,rphi,z] coordinata to [x,y,z]
+ //transform [r,rphi,z] coordinata to [x,y,z]
void Transform4to8(Float_t *xyz, Int_t *index) const;
//transform xyz coordinata to 'digit' coordinata
void Transform8to4(Float_t *xyz, Int_t *index) const;
- //transform 'digit' coordinata to xyz coordinata
+ //transform 'digit' coordinata to xyz coordinata
void Transform6to8(Float_t *xyz, Int_t *index) const;
//transform dr,f coordinata to 'digit' coordinata
void Transform8to6(Float_t *xyz, Int_t *index) const;
- //transform 'digit' coordinata to dr,f coordinata
+ //transform 'digit' coordinata to dr,f coordinata
virtual Int_t Transform2toPadRow(Float_t */*xyz*/, Int_t */*index*/) const{return 0;}
//transform rotated to
virtual Int_t GetPadRow(Float_t *xyz, Int_t *index) const ;
//return pad row of point xyz - xyz is given in coordinate system -(given by index)
//output system is 3 for straight row and 7 for cylindrical row
- virtual void XYZtoCRXYZ(Float_t */*xyz*/,
+ virtual void XYZtoCRXYZ(Float_t */*xyz*/,
Int_t &/*sector*/, Int_t &/*padrow*/, Int_t /*option*/) const {;}
//transform global position to the position relative to the sector padrow
//if option=0 X calculate absolute calculate sector
//if option=3 X relative use input sector
virtual void CRXYZtoXYZ(Float_t */*xyz*/,
- const Int_t &/*sector*/, const Int_t & /*padrow*/, Int_t /*option*/) const {;}
+ const Int_t &/*sector*/, const Int_t & /*padrow*/, Int_t /*option*/) const {;}
//transform relative position to the gloabal position
- virtual void CRTimePadtoYZ(Float_t &/*y*/, Float_t &/*z*/,
+ virtual void CRTimePadtoYZ(Float_t &/*y*/, Float_t &/*z*/,
const Float_t &/*time*/, const Float_t &/*pad*/,
Int_t /*sector*/, Int_t /*padrow*/ ){;}
- //transform position in digit units (time slices and pads) to "normal"
- //units (cm)
- virtual void CRYZtoTimePad(const Float_t &/*y*/, const Float_t &/*z*/,
+ //transform position in digit units (time slices and pads) to "normal"
+ //units (cm)
+ virtual void CRYZtoTimePad(const Float_t &/*y*/, const Float_t &/*z*/,
Float_t &/*time*/, Float_t &/*pad*/,
Int_t /*sector*/, Int_t /*padrow*/){;}
- //transform position in cm to position in digit unit
+ //transform position in cm to position in digit unit
virtual Int_t CalcResponse(Float_t* /*x*/, Int_t * /*index*/, Int_t /*row*/){return 0;}
- //calculate bin response as function of the input position -x and the weight
- //if row -pad row is equal -1 calculate response for each pad row
+ //calculate bin response as function of the input position -x and the weight
+ //if row -pad row is equal -1 calculate response for each pad row
//otherwise it calculate only in given pad row
//return number of valid response bin
- virtual void SetDefault(); //set defaut TPCparam
- virtual Bool_t Update(); //recalculate and check geometric parameters
- virtual Bool_t ReadGeoMatrices(); //read geo matrixes
- Bool_t GetStatus() const; //get information about object consistency
- Int_t GetIndex(Int_t sector, Int_t row) const; //give index of the given sector and pad row
- Int_t GetNSegmentsTotal() const {return fNtRows;}
+ virtual void SetDefault(); //set defaut TPCparam
+ virtual Bool_t Update(); //recalculate and check geometric parameters
+ virtual Bool_t ReadGeoMatrices(); //read geo matrixes
+ Bool_t GetStatus() const; //get information about object consistency
+ Int_t GetIndex(Int_t sector, Int_t row) const; //give index of the given sector and pad row
+ Int_t GetNSegmentsTotal() const {return fNtRows;}
Double_t GetLowMaxY(Int_t irow) const {return irow*0.;}
Double_t GetUpMaxY(Int_t irow) const {return irow*0;}
//additional geometrical function - for Belikov
-
+
Bool_t AdjustSectorRow(Int_t index, Int_t & sector, Int_t &row) const; //return sector and padrow
//for given index
void AdjustCosSin(Int_t isec, Float_t &cos, Float_t &sin) const;
- //set cosinus and sinus of rotation angles for sector isec
+ //set cosinus and sinus of rotation angles for sector isec
Float_t GetAngle(Int_t isec) const;
// void GetChamberPos(Int_t isec, Float_t* xyz) const;
// void GetChamberRot(Int_t isec, Float_t* angles) const;
//set sector parameters
//
void SetInnerRadiusLow(Float_t InnerRadiusLow ) { fInnerRadiusLow=InnerRadiusLow;}
- void SetOuterRadiusLow(Float_t OuterRadiusLow ) { fOuterRadiusLow=OuterRadiusLow;}
- void SetInnerRadiusUp(Float_t InnerRadiusUp) { fInnerRadiusUp= InnerRadiusUp;}
- void SetOuterRadiusUp(Float_t OuterRadiusUp) { fOuterRadiusUp= OuterRadiusUp;}
+ void SetOuterRadiusLow(Float_t OuterRadiusLow ) { fOuterRadiusLow=OuterRadiusLow;}
+ void SetInnerRadiusUp(Float_t InnerRadiusUp) { fInnerRadiusUp= InnerRadiusUp;}
+ void SetOuterRadiusUp(Float_t OuterRadiusUp) { fOuterRadiusUp= OuterRadiusUp;}
void SetSectorAngles(Float_t innerangle, Float_t innershift, Float_t outerangle,
Float_t outershift);
void SetInnerFrameSpace(Float_t frspace) {fInnerFrameSpace = frspace;}
void SetOuterFrameSpace(Float_t frspace) {fOuterFrameSpace = frspace;}
void SetInnerWireMount(Float_t fmount) {fInnerWireMount = fmount;}
void SetOuterWireMount(Float_t fmount) {fOuterWireMount = fmount;}
- void SetZLength(Float_t zlength) {fZLength = zlength;}
+ void SetZLength(Float_t zlength) {fZLength = zlength;}
void SetGeometryType(Int_t type) {fGeometryType = type;}
//
// pad rows geometry
//
void SetRowNLow( Int_t NRowLow){fNRowLow = NRowLow;}
- void SetRowNUp1 (Int_t NRowUp1){fNRowUp1 = NRowUp1 ;} //upper sec short pads
+ void SetRowNUp1 (Int_t NRowUp1){fNRowUp1 = NRowUp1 ;} //upper sec short pads
void SetRowNUp2 (Int_t NRowUp2){fNRowUp2 = NRowUp2 ;} //upper sec long pads
- void SetRowNUp (Int_t NRowUp){fNRowUp = NRowUp ;}
+ void SetRowNUp (Int_t NRowUp){fNRowUp = NRowUp ;}
//
//set wire parameters
//
void SetInnerNWires(Int_t nWires){ fNInnerWiresPerPad=nWires;}
void SetInnerDummyWire(Int_t dummy) {fInnerDummyWire = dummy;}
- void SetInnerOffWire(Float_t offset) {fInnerOffWire =offset;}
+ void SetInnerOffWire(Float_t offset) {fInnerOffWire =offset;}
void SetOuter1NWires(Int_t nWires){ fNOuter1WiresPerPad=nWires;}
void SetOuter2NWire(Int_t nWires){ fNOuter2WiresPerPad=nWires;}
void SetOuterDummyWire(Int_t dummy) {fOuterDummyWire = dummy;}
- void SetOuterOffWire(Float_t offset) {fOuterOffWire =offset;}
+ void SetOuterOffWire(Float_t offset) {fOuterOffWire =offset;}
void SetInnerWWPitch( Float_t wwPitch) {fInnerWWPitch = wwPitch;}
void SetRInnerFirstWire(Float_t firstWire){fRInnerFirstWire = firstWire;}
void SetRInnerLastWire(Float_t lastWire){fRInnerLastWire = lastWire;}
void SetOuterWWPitch(Float_t wwPitch){fOuterWWPitch = wwPitch;}
- void SetLastWireUp1(Float_t wireUp1){fLastWireUp1 = wireUp1;}
+ void SetLastWireUp1(Float_t wireUp1){fLastWireUp1 = wireUp1;}
void SetROuterFirstWire(Float_t firstWire){fROuterFirstWire = firstWire;}
- void SetROuterLastWire(Float_t lastWire){fROuterLastWire = lastWire;}
+ void SetROuterLastWire(Float_t lastWire){fROuterLastWire = lastWire;}
//
//set pad parameter
//
void SetInnerPadPitchLength(Float_t PadPitchLength){ fInnerPadPitchLength=PadPitchLength;}
void SetInnerPadPitchWidth(Float_t PadPitchWidth){ fInnerPadPitchWidth = PadPitchWidth;}
void SetInnerPadLength(Float_t PadLength){ fInnerPadLength=PadLength;}
- void SetInnerPadWidth(Float_t PadWidth) { fInnerPadWidth=PadWidth;}
+ void SetInnerPadWidth(Float_t PadWidth) { fInnerPadWidth=PadWidth;}
void SetOuter1PadPitchLength(Float_t PadPitchLength){ fOuter1PadPitchLength=PadPitchLength;}
void SetOuter2PadPitchLength(Float_t PadPitchLength){ fOuter2PadPitchLength=PadPitchLength;}
void SetOuterPadPitchWidth(Float_t PadPitchWidth){ fOuterPadPitchWidth = PadPitchWidth;}
static TVectorD * GetBetheBlochParamAliceMC();
static void RegisterBBParam(TVectorD* param, Int_t position);
//
- //set electronivc parameters
+ //set electronivc parameters
//
void SetPadCoupling(Float_t PadCoupling){ fPadCoupling=PadCoupling;}
void SetZeroSup(Int_t ZeroSup) { fZeroSup=ZeroSup;}
void SetMaxFractionHVbad(Float_t frac ) { fMaxHVfractionBad=frac; }
void SetVoltageDipScanPeriod(Float_t period) { fVoltageDipScanPeriod=period; }
//
- //set response parameters
+ //set response parameters
//
- void SetNResponseMax(Int_t max) { fNResponseMax = max;}
+ void SetNResponseMax(Int_t max) { fNResponseMax = max;}
void SetResponseThreshold(Int_t threshold) {fResponseThreshold = threshold;}
//set L1 parameters
void SetGateDelay(Float_t delay) {fGateDelay = delay;}
//get sector parameters
//
Float_t GetInnerRadiusLow() const {return fInnerRadiusLow;}
- Float_t GetInnerRadiusUp() const {return fInnerRadiusUp;}
- Float_t GetOuterRadiusLow() const {return fOuterRadiusLow;}
- Float_t GetOuterRadiusUp() const {return fOuterRadiusUp;}
+ Float_t GetInnerRadiusUp() const {return fInnerRadiusUp;}
+ Float_t GetOuterRadiusLow() const {return fOuterRadiusLow;}
+ Float_t GetOuterRadiusUp() const {return fOuterRadiusUp;}
Float_t GetInnerFrameSpace() const {return fInnerFrameSpace;}
Float_t GetOuterFrameSpace() const {return fOuterFrameSpace;}
Float_t GetInnerWireMount() const {return fInnerWireMount;}
Float_t GetInnerAngle() const ;
Float_t GetInnerAngleShift() const ;
Float_t GetOuterAngle() const ;
- Float_t GetOuterAngleShift() const ;
+ Float_t GetOuterAngleShift() const ;
Int_t GetNInnerSector() const {return fNInnerSector;}
Int_t GetNOuterSector() const {return fNOuterSector;}
Int_t GetNSector() const {return fNSector;}
//get wires parameter
//
Int_t GetInnerNWires() const {return fNInnerWiresPerPad;}
- Float_t GetInnerWWPitch() const {return fInnerWWPitch;}
+ Float_t GetInnerWWPitch() const {return fInnerWWPitch;}
Int_t GetInnerDummyWire() const {return fInnerDummyWire;}
Float_t GetInnerOffWire() const {return fInnerOffWire;}
Float_t GetRInnerFirstWire() const {return fRInnerFirstWire;}
Float_t GetRInnerLastWire() const {return fRInnerLastWire;}
Int_t GetOuter1NWires() const {return fNOuter1WiresPerPad;}
Int_t GetOuter2NWires() const {return fNOuter2WiresPerPad;}
- Float_t GetOuterWWPitch() const {return fOuterWWPitch;}
+ Float_t GetOuterWWPitch() const {return fOuterWWPitch;}
Int_t GetOuterDummyWire() const {return fOuterDummyWire;}
Float_t GetOuterOffWire() const {return fOuterOffWire;}
Float_t GetLastWireUp1() const {return fLastWireUp1;}
Float_t GetROuterFirstWire() const {return fROuterFirstWire;}
- Float_t GetROuterLastWire() const {return fROuterLastWire;}
+ Float_t GetROuterLastWire() const {return fROuterLastWire;}
Float_t GetWWPitch(Int_t isector = 0) const {
- return ( (isector < fNInnerSector) ? fInnerWWPitch :fOuterWWPitch);}
+ return ( (isector < fNInnerSector) ? fInnerWWPitch :fOuterWWPitch);}
//
//get pad parameters
//
Float_t GetInnerPadLength() const {return fInnerPadLength;}
Float_t GetInnerPadWidth() const {return fInnerPadWidth;}
Float_t GetOuter1PadPitchLength() const {return fOuter1PadPitchLength;}
- Float_t GetOuter2PadPitchLength() const {return fOuter2PadPitchLength;}
+ Float_t GetOuter2PadPitchLength() const {return fOuter2PadPitchLength;}
Float_t GetOuterPadPitchWidth() const {return fOuterPadPitchWidth;}
Float_t GetOuter1PadLength() const {return fOuter1PadLength;}
Float_t GetOuter2PadLength() const {return fOuter2PadLength;}
- Float_t GetOuterPadWidth() const {return fOuterPadWidth;}
+ Float_t GetOuterPadWidth() const {return fOuterPadWidth;}
Bool_t GetMWPCReadout() const {return fBMWPCReadout;}
Int_t GetNCrossRows() const {return fNCrossRows;}
Float_t GetPadPitchWidth(Int_t isector = 0) const {
return ( (isector < fNInnerSector) ? fInnerPadPitchWidth :fOuterPadPitchWidth);}
Float_t GetPadPitchLength(Int_t isector = 0, Int_t padrow=0) const
- { if (isector < fNInnerSector) return fInnerPadPitchLength;
+ { if (isector < fNInnerSector) return fInnerPadPitchLength;
else return ((padrow<fNRowUp1) ? fOuter1PadPitchLength:fOuter2PadPitchLength);}
Int_t GetNRowLow() const; //get the number of pad rows in low sector
Int_t GetNRowUp() const; //get the number of pad rows in up sector
- Int_t GetNRowUp1() const; // number of short rows in up sector
+ Int_t GetNRowUp1() const; // number of short rows in up sector
Int_t GetNRowUp2() const; // number of long rows in up sector
Int_t GetNRow(Int_t isec) const {return ((isec<fNInnerSector) ? fNRowLow:fNRowUp);}
Int_t GetNRowsTotal() const {return fNtRows;} //get total nuber of rows
Float_t GetPadRowRadii(Int_t isec,Int_t irow) const {
return ( (isec < fNInnerSector) ?GetPadRowRadiiLow(irow):GetPadRowRadiiUp(irow));}
//retrun radii of the pad row irow in sector i
- Int_t GetNPadsLow(Int_t irow) const; //get the number of pads in row irow
+ Int_t GetNPadsLow(Int_t irow) const; //get the number of pads in row irow
Int_t GetNPadsUp(Int_t irow) const; //get the number of pads in row irow
Int_t GetNPads(Int_t isector,Int_t irow) const{
- return ( (isector < fNInnerSector) ?GetNPadsLow(irow) : GetNPadsUp(irow));}
+ return ( (isector < fNInnerSector) ?GetNPadsLow(irow) : GetNPadsUp(irow));}
Int_t GetWireSegment(Int_t sector, Int_t row) const ; // get Anode wire segment index IROC --> [0,4], OROC[0,7]
Int_t GetNPadsPerSegment(Int_t segmentID) const; // get number of pads for a given Anode wire segment
Float_t GetYInner(Int_t irow) const; // wire length in low sec row
- Float_t GetYOuter(Int_t irow) const; // wire length in up sec row
+ Float_t GetYOuter(Int_t irow) const; // wire length in up sec row
Int_t GetSectorIndex(Float_t angle, Int_t row, Float_t z) const; // get sector index
Float_t GetChamberCenter(Int_t isec, Float_t * center = 0) const; // get readout chamber positions
TGeoHMatrix *GetTrackingMatrix(Int_t isec) const {
return fGlobalMatrix[isec];}
Bool_t IsGeoRead(){ return fGlobalMatrix!=0;}
//
- //get GAS parameters
+ //get GAS parameters
//
Float_t GetDiffT() const {return fDiffT;}
Float_t GetDiffL() const {return fDiffL;}
Float_t GetDriftV() const {return fDriftV;}
Float_t GetOmegaTau() const {return fOmegaTau;}
Float_t GetAttCoef() const {return fAttCoef;}
- Float_t GetOxyCont() const {return fOxyCont;}
+ Float_t GetOxyCont() const {return fOxyCont;}
TGraphErrors * GetGainSlopesHV() const { return fGainSlopesHV;}
TGraphErrors * GetGainSlopesPT() const { return fGainSlopesPT;}
Float_t* GetComposition() {return fComposition;}
Float_t GetWmean()const {return fWmean;}
Float_t GetExp()const {return fExp;}
Float_t GetEend()const {return fEend;}
- TVectorD* GetBetheBlochParameters(){return fBetheBloch;}
- TVectorD* GetBetheBlochParametersMC(){return fBetheBlochMC;}
+ TVectorD* GetBetheBlochParameters(){return fBetheBloch;}
+ TVectorD* GetBetheBlochParametersMC(){return fBetheBlochMC;}
static Double_t BetheBlochAleph(Double_t bb, Int_t type=0);
//
//get Electronic parameters
Float_t GetTSample() const {return fTSample;}
Float_t GetZWidth() const {return fZWidth;}
Float_t GetTFWHM() const {return fTSigma*2.35;}
- Float_t GetZSigma() const {return fTSigma*fDriftV;}
+ Float_t GetZSigma() const {return fTSigma*fDriftV;}
virtual Float_t GetZOffset() const {return 3*fTSigma*fDriftV;}
Int_t GetMaxTBin() const {return fMaxTBin;}
Int_t GetADCSat() const {return fADCSat;}
Float_t GetMaxDipVoltage() const { return fMaxDipVoltage; }
Float_t GetMaxFractionHVbad() const { return fMaxHVfractionBad; }
Float_t GetVoltageDipScanPeriod() const { return fVoltageDipScanPeriod; }
-
+
//
// get response data
- //
- Int_t * GetResBin(Int_t i);
- //return response bin i - bin given by padrow [0] pad[1] timebin[2]
+ //
+ Int_t * GetResBin(Int_t i);
+ //return response bin i - bin given by padrow [0] pad[1] timebin[2]
Float_t & GetResWeight(Int_t i);
//return weight of response bin i
Float_t GetNTBinsL1() const {return fNTBinsL1;}
protected :
- Bool_t fbStatus; //indicates consistency of the data
+ Bool_t fbStatus; ///< indicates consistency of the data
//---------------------------------------------------------------------
// ALICE TPC sector geometry
- //--------------------------------------------------------------------
- Float_t fInnerRadiusLow; // lower radius of inner sector-IP
- Float_t fInnerRadiusUp; // upper radius of inner sector-IP
- Float_t fOuterRadiusUp; // upper radius of outer sector-IP
- Float_t fOuterRadiusLow; // lower radius of outer sector-IP
- Float_t fInnerAngle; //opening angle of Inner sector
- Float_t fInnerAngleShift; //shift of first inner sector center to the 0
- Float_t fOuterAngle; //opening angle of outer sector
- Float_t fOuterAngleShift; //shift of first sector center to the 0
- Float_t fInnerFrameSpace; //space for inner frame in the phi direction
- Float_t fOuterFrameSpace; //space for outer frame in the phi direction
- Float_t fInnerWireMount; //space for wire mount, inner sector
- Float_t fOuterWireMount; //space for wire mount, outer sector
- Int_t fNInnerSector; //number of inner sectors -calculated
- Int_t fNOuterSector; //number of outer sectors -calculated
- Int_t fNSector; // total number of sectors -calculated
- Float_t fZLength; //length of the drift region of the TPC
- Float_t *fRotAngle; //[fNSector] sin and cos of rotation angles for
- // diferent sectors -calculated
- Int_t fGeometryType; //type of geometry -0 straight rows
- // Float_t *fChamberPos; //[fNSector] displacements of the readout chambers
+ //--------------------------------------------------------------------
+ Float_t fInnerRadiusLow; ///< lower radius of inner sector-IP
+ Float_t fInnerRadiusUp; ///< upper radius of inner sector-IP
+ Float_t fOuterRadiusUp; ///< upper radius of outer sector-IP
+ Float_t fOuterRadiusLow; ///< lower radius of outer sector-IP
+ Float_t fInnerAngle; ///< opening angle of Inner sector
+ Float_t fInnerAngleShift; ///< shift of first inner sector center to the 0
+ Float_t fOuterAngle; ///< opening angle of outer sector
+ Float_t fOuterAngleShift; ///< shift of first sector center to the 0
+ Float_t fInnerFrameSpace; ///< space for inner frame in the phi direction
+ Float_t fOuterFrameSpace; ///< space for outer frame in the phi direction
+ Float_t fInnerWireMount; ///< space for wire mount, inner sector
+ Float_t fOuterWireMount; ///< space for wire mount, outer sector
+ Int_t fNInnerSector; ///< number of inner sectors -calculated
+ Int_t fNOuterSector; ///< number of outer sectors -calculated
+ Int_t fNSector; ///< total number of sectors -calculated
+ Float_t fZLength; ///< length of the drift region of the TPC
+ /// sin and cos of rotation angles for different sectors - calculated
+ Float_t *fRotAngle; //[fNSector]
+ Int_t fGeometryType; ///< type of geometry -0 straight rows
+ // Float_t *fChamberPos; //[fNSector] displacements of the readout chambers
//with respect to the 'idead' geometry
//in local corrdinate system
- // Float_t *fChamberRot; //[fNSector] rotation angles of the readout chambers
+ // Float_t *fChamberRot; //[fNSector] rotation angles of the readout chambers
//with respect to the 'idead' geometry
//in local corrdinate system
- TGeoHMatrix **fTrackingMatrix; //![fNSector] transformation matrices of the tracking
- //coordinate system
- TGeoHMatrix **fClusterMatrix; //![fNSector] transformation matrices of the cluster
- //coordinate system
- TGeoHMatrix **fGlobalMatrix; //![fNSector] fTrackingMatrix * fClusterMatrix
+ /// transformation matrices of the tracking coordinate system
+ TGeoHMatrix **fTrackingMatrix; //![fNSector]
+ /// transformation matrices of the cluster coordinate system
+ TGeoHMatrix **fClusterMatrix; //![fNSector]
+ /// fTrackingMatrix * fClusterMatrix
+ TGeoHMatrix **fGlobalMatrix; //![fNSector]
//1-cylindrical
//---------------------------------------------------------------------
- // ALICE TPC wires geometry - for GEM we can consider that it is gating
+ // ALICE TPC wires geometry - for GEM we can consider that it is gating
//--------------------------------------------------------------------
- Int_t fNInnerWiresPerPad; //Number of wires per pad
- Float_t fInnerWWPitch; //pitch between wires in inner sector - calculated
- Int_t fInnerDummyWire; //number of wires without pad readout
- Float_t fInnerOffWire; //oofset of first wire to the begining of the sector
- Float_t fRInnerFirstWire; //position of the first wire -calculated
- Float_t fRInnerLastWire; //position of the last wire -calculated
- Float_t fLastWireUp1; //position of the last wire in outer1 sector
- Int_t fNOuter1WiresPerPad; //Number of wires per pad
- Int_t fNOuter2WiresPerPad; // Number of wires per pad
- Float_t fOuterWWPitch; //pitch between wires in outer sector -calculated
- Int_t fOuterDummyWire; //number of wires without pad readout
- Float_t fOuterOffWire; //oofset of first wire to the begining of the sector
- Float_t fROuterFirstWire; //position of the first wire -calulated
- Float_t fROuterLastWire; //position of the last wire -calculated
+ Int_t fNInnerWiresPerPad; ///< Number of wires per pad
+ Float_t fInnerWWPitch; ///< pitch between wires in inner sector - calculated
+ Int_t fInnerDummyWire; ///< number of wires without pad readout
+ Float_t fInnerOffWire; ///< oofset of first wire to the begining of the sector
+ Float_t fRInnerFirstWire; ///< position of the first wire -calculated
+ Float_t fRInnerLastWire; ///< position of the last wire -calculated
+ Float_t fLastWireUp1; ///< position of the last wire in outer1 sector
+ Int_t fNOuter1WiresPerPad; ///< Number of wires per pad
+ Int_t fNOuter2WiresPerPad; ///< Number of wires per pad
+ Float_t fOuterWWPitch; ///< pitch between wires in outer sector -calculated
+ Int_t fOuterDummyWire; ///< number of wires without pad readout
+ Float_t fOuterOffWire; ///< oofset of first wire to the begining of the sector
+ Float_t fROuterFirstWire; ///< position of the first wire -calulated
+ Float_t fROuterLastWire; ///< position of the last wire -calculated
//---------------------------------------------------------------------
// ALICE TPC pad parameters
//--------------------------------------------------------------------
- Float_t fInnerPadPitchLength; //Inner pad pitch length
- Float_t fInnerPadPitchWidth; //Inner pad pitch width
- Float_t fInnerPadLength; //Inner pad length
- Float_t fInnerPadWidth; //Inner pad width
- Float_t fOuter1PadPitchLength; //Outer pad pitch length
- Float_t fOuter2PadPitchLength; //Outer pad pitch length
- Float_t fOuterPadPitchWidth; //Outer pad pitch width
- Float_t fOuter1PadLength; //Outer pad length
- Float_t fOuter2PadLength; //Outer pad length
- Float_t fOuterPadWidth; //Outer pad width
- Bool_t fBMWPCReadout; //indicate wire readout - kTRUE or GEM readout -kFALSE
- Int_t fNCrossRows; //number of rows to crostalk calculation
-
- Int_t fNRowLow; //number of pad rows per low sector -set
- Int_t fNRowUp1; //number of short pad rows per sector up -set
- Int_t fNRowUp2; //number of long pad rows per sector up -set
- Int_t fNRowUp; //number of pad rows per sector up -calculated
- Int_t fNtRows; //total number of rows in TPC -calculated
- Float_t fPadRowLow[600]; //Lower sector, pad row radii -calculated
- Float_t fPadRowUp[600]; //Upper sector, pad row radii -calculated
- Int_t fNPadsLow[600]; //Lower sector, number of pads per row -calculated
- Int_t fNPadsUp[600]; //Upper sector, number of pads per row -calculated
- Float_t fYInner[600]; //Inner sector, wire-length
- Float_t fYOuter[600]; //Outer sector, wire-length
+ Float_t fInnerPadPitchLength; ///< Inner pad pitch length
+ Float_t fInnerPadPitchWidth; ///< Inner pad pitch width
+ Float_t fInnerPadLength; ///< Inner pad length
+ Float_t fInnerPadWidth; ///< Inner pad width
+ Float_t fOuter1PadPitchLength; ///< Outer pad pitch length
+ Float_t fOuter2PadPitchLength; ///< Outer pad pitch length
+ Float_t fOuterPadPitchWidth; ///< Outer pad pitch width
+ Float_t fOuter1PadLength; ///< Outer pad length
+ Float_t fOuter2PadLength; ///< Outer pad length
+ Float_t fOuterPadWidth; ///< Outer pad width
+ Bool_t fBMWPCReadout; ///< indicate wire readout - kTRUE or GEM readout -kFALSE
+ Int_t fNCrossRows; ///< number of rows to crostalk calculation
+
+ Int_t fNRowLow; ///< number of pad rows per low sector -set
+ Int_t fNRowUp1; ///< number of short pad rows per sector up -set
+ Int_t fNRowUp2; ///< number of long pad rows per sector up -set
+ Int_t fNRowUp; ///< number of pad rows per sector up -calculated
+ Int_t fNtRows; ///< total number of rows in TPC -calculated
+ Float_t fPadRowLow[600]; ///< Lower sector, pad row radii -calculated
+ Float_t fPadRowUp[600]; ///< Upper sector, pad row radii -calculated
+ Int_t fNPadsLow[600]; ///< Lower sector, number of pads per row -calculated
+ Int_t fNPadsUp[600]; ///< Upper sector, number of pads per row -calculated
+ Float_t fYInner[600]; ///< Inner sector, wire-length
+ Float_t fYOuter[600]; ///< Outer sector, wire-length
//---------------------------------------------------------------------
// ALICE TPC Gas Parameters
//--------------------------------------------------------------------
- Float_t fDiffT; //tangencial diffusion constant
- Float_t fDiffL; //longutudinal diffusion constant
- Float_t fGasGain; //gas gain constant
- Float_t fDriftV; //drift velocity constant
- Float_t fOmegaTau; //omega tau ExB coeficient
- Float_t fAttCoef; //attachment coefitients
- Float_t fOxyCont; //oxygen content
- Float_t fFpot; // first ionisation potential
- Float_t fNprim; // number of primary electrons/cm
- Float_t fNtot; //total number of electrons/c (MIP)
- Float_t fWmean; // mean energy for electron/ion pair
- Float_t fExp; // de = f(E) - energy loss parametrization
- Float_t fEend; // upper cutoff for de generation
- TVectorD* fBetheBloch; // Bethe-Bloch parametrization
- TVectorD* fBetheBlochMC; // Bethe-Bloch parametrization
+ Float_t fDiffT; ///< tangencial diffusion constant
+ Float_t fDiffL; ///< longutudinal diffusion constant
+ Float_t fGasGain; ///< gas gain constant
+ Float_t fDriftV; ///< drift velocity constant
+ Float_t fOmegaTau; ///< omega tau ExB coeficient
+ Float_t fAttCoef; ///< attachment coefitients
+ Float_t fOxyCont; ///< oxygen content
+ Float_t fFpot; ///< first ionisation potential
+ Float_t fNprim; ///< number of primary electrons/cm
+ Float_t fNtot; ///< total number of electrons/c (MIP)
+ Float_t fWmean; ///< mean energy for electron/ion pair
+ Float_t fExp; ///< de = f(E) - energy loss parametrization
+ Float_t fEend; ///< upper cutoff for de generation
+ TVectorD* fBetheBloch; ///< Bethe-Bloch parametrization
+ TVectorD* fBetheBlochMC; ///< Bethe-Bloch parametrization
// gas mixture composition
- Float_t fComposition[6];
- TGraphErrors * fGainSlopesHV; // graph with the gain slope as function of HV - per chamber
- TGraphErrors * fGainSlopesPT; // graph with the gain slope as function of P/T - per chamber
+ Float_t fComposition[6];
+ TGraphErrors * fGainSlopesHV; ///< graph with the gain slope as function of HV - per chamber
+ TGraphErrors * fGainSlopesPT; ///< graph with the gain slope as function of P/T - per chamber
//---------------------------------------------------------------------
// ALICE TPC Electronics Parameters
//--------------------------------------------------------------------
- Float_t fPadCoupling; //coupling factor ration of anode signal
- //and total pads signal
- Int_t fZeroSup; //zero suppresion constant
- Float_t fNoise; //noise sigma constant
- Float_t fChipGain; //preamp shaper constant
- Float_t fChipNorm; //preamp shaper normalisation
- Float_t fTSample; //sampling time
- Float_t fZWidth; //derived value calculated using TSample and driftw -computed
- Float_t fTSigma; //width of the Preamp/Shaper function
- Int_t fMaxTBin; //maximum time bin number
- Int_t fADCSat; //saturation value of ADC (10 bits)
- Float_t fADCDynRange; //input dynamic range (mV)
- Float_t fTotalNormFac; //full normalisation factor - calculated
- Float_t fNoiseNormFac; //normalisation factor to transform noise in electron to ADC channel
+ Float_t fPadCoupling; ///< coupling factor ration of anode signal
+ //and total pads signal
+ Int_t fZeroSup; ///< zero suppresion constant
+ Float_t fNoise; ///< noise sigma constant
+ Float_t fChipGain; ///< preamp shaper constant
+ Float_t fChipNorm; ///< preamp shaper normalisation
+ Float_t fTSample; ///< sampling time
+ Float_t fZWidth; ///< derived value calculated using TSample and driftw -computed
+ Float_t fTSigma; ///< width of the Preamp/Shaper function
+ Int_t fMaxTBin; ///< maximum time bin number
+ Int_t fADCSat; ///< saturation value of ADC (10 bits)
+ Float_t fADCDynRange; ///< input dynamic range (mV)
+ Float_t fTotalNormFac; ///< full normalisation factor - calculated
+ Float_t fNoiseNormFac; ///< normalisation factor to transform noise in electron to ADC channel
//---------------------------------------------------------------------
// High voltage parameters
//---------------------------------------------------------------------
- Float_t fNominalVoltage[72]; //nominal voltage in [V] per chamber
- Float_t fMaxVoltageDeviation; // maximum voltage deviation from nominal voltage before a chamber is masked
- Float_t fMaxDipVoltage; // maximum voltage deviation from median before a dip event is marked
- Float_t fMaxHVfractionBad; // maximum fraction of bad HV entries (deviation from Median) before a chamber is marked bad
- Float_t fVoltageDipScanPeriod; // scanning period to detect a high volrage dip: event time stamp +- fVoltageDipScanPeriod [sec]
-
+ Float_t fNominalVoltage[72]; ///< nominal voltage in [V] per chamber
+ Float_t fMaxVoltageDeviation; ///< maximum voltage deviation from nominal voltage before a chamber is masked
+ Float_t fMaxDipVoltage; ///< maximum voltage deviation from median before a dip event is marked
+ Float_t fMaxHVfractionBad; ///< maximum fraction of bad HV entries (deviation from Median) before a chamber is marked bad
+ Float_t fVoltageDipScanPeriod; ///< scanning period to detect a high volrage dip: event time stamp +- fVoltageDipScanPeriod [sec]
+
//---------------------------------------------------------------------
- // ALICE TPC response data
+ // ALICE TPC response data
//---------------------------------------------------------------------
- Int_t fNResponseMax; //maximal dimension of response
- Float_t fResponseThreshold; //threshold for accepted response
- Int_t fCurrentMax; //!current maximal dimension -calulated
- Int_t *fResponseBin; //!array with bins -calulated
- Float_t *fResponseWeight; //!array with response -calulated
+ Int_t fNResponseMax; ///< maximal dimension of response
+ Float_t fResponseThreshold; ///< threshold for accepted response
+ Int_t fCurrentMax; //!< current maximal dimension -calulated
+ Int_t *fResponseBin; //!< array with bins -calulated
+ Float_t *fResponseWeight; //!< array with response -calulated
//---------------------------------------------------------------------
// ALICE TPC L1 Parameters
//--------------------------------------------------------------------
- Float_t fGateDelay; //Delay of L1 arrival for the TPC gate signal
- Float_t fL1Delay; //Delay of L1 arrival for the TPC readout
- UShort_t fNTBinsBeforeL1; //Number of time bins before L1 arrival which are being read out
- Float_t fNTBinsL1; //Overall L1 delay in time bins
+ Float_t fGateDelay; ///< Delay of L1 arrival for the TPC gate signal
+ Float_t fL1Delay; ///< Delay of L1 arrival for the TPC readout
+ UShort_t fNTBinsBeforeL1; ///< Number of time bins before L1 arrival which are being read out
+ Float_t fNTBinsL1; ///< Overall L1 delay in time bins
protected:
- static TObjArray *fBBParam; // array of the Bethe-Bloch parameters.
+ static TObjArray *fBBParam; ///< array of the Bethe-Bloch parameters.
private:
AliTPCParam(const AliTPCParam &);
AliTPCParam & operator=(const AliTPCParam &);
void CleanGeoMatrices();
+ /// \cond CLASSIMP
ClassDef(AliTPCParam,10) //parameter object for set:TPC
+ /// \endcond
};
-
+
inline Int_t * AliTPCParam::GetResBin(Int_t i)
{
- //return response bin i - bin given by padrow [0] pad[1] timebin[2]
+ /// return response bin i - bin given by padrow [0] pad[1] timebin[2]
+
if (i<fCurrentMax) return &fResponseBin[i*3];
else return 0;
}
-
+
inline Float_t &AliTPCParam::GetResWeight(Int_t i)
{
- //return weight of response bin i
+ /// return weight of response bin i
+
if (i<fCurrentMax) return fResponseWeight[i];
else return fResponseWeight[i];
}
inline void AliTPCParam::AdjustCosSin(Int_t isec, Float_t &cos, Float_t &sin) const
{
- //
- //set cosinus and sinus of rotation angles for sector isec
- //
+ /// set cosinus and sinus of rotation angles for sector isec
+
cos=fRotAngle[isec*4];
sin=fRotAngle[isec*4+1];
}
inline Float_t AliTPCParam::GetAngle(Int_t isec) const
{
- //
- //return rotation angle of given sector
- //
+ /// return rotation angle of given sector
+
return fRotAngle[isec*4+2];
}
inline void AliTPCParam::Transform1to2Ideal(Float_t *xyz, Int_t *index) const
{
- //transformation to rotated coordinates
- //we must have information about sector!
- //rotate to given sector
- // ideal frame
+ /// transformation to rotated coordinates
+ /// we must have information about sector!
+ /// rotate to given sector
+ /// ideal frame
Float_t cos,sin;
AdjustCosSin(index[1],cos,sin);
inline void AliTPCParam::Transform1to2(Float_t *xyz, Int_t *index) const
{
- //transformation to rotated coordinates
- //we must have information about sector!
- //rotate to given sector
+ /// transformation to rotated coordinates
+ /// we must have information about sector!
+ /// rotate to given sector
+
Double_t xyzmaster[3] = {xyz[0],xyz[1],xyz[2]};
Double_t xyzlocal[3]={0,0,0};
- if (index[1]>=0 && index[1]<fNSector)
+ if (index[1]>=0 && index[1]<fNSector)
fGlobalMatrix[index[1]]->MasterToLocal(xyzmaster,xyzlocal);
xyz[0] = xyzlocal[0];
xyz[1] = xyzlocal[1];
inline void AliTPCParam::Transform2to1(Float_t *xyz, Int_t *index) const
{
- //
- //transformation from rotated coordinates to global coordinates
- //
+ /// transformation from rotated coordinates to global coordinates
+
Float_t cos,sin;
- AdjustCosSin(index[1],cos,sin);
+ AdjustCosSin(index[1],cos,sin);
Float_t x1=xyz[0]*cos - xyz[1]*sin;
- Float_t y1=xyz[0]*sin + xyz[1]*cos;
+ Float_t y1=xyz[0]*sin + xyz[1]*cos;
xyz[0]=x1;
xyz[1]=y1;
- xyz[2]=fZLength-xyz[2];
+ xyz[2]=fZLength-xyz[2];
if (index[1]<fNInnerSector)
{if ( index[1]>=(fNInnerSector>>1)) xyz[2]*=-1.;}
- else
+ else
{if ( (index[1]-fNInnerSector) >= (fNOuterSector>>1) ) xyz[2]*=-1;}
index[0]=1;
}
inline void AliTPCParam::Transform2to2(Float_t *xyz, Int_t *index, Int_t *oindex) const
{
- //transform rotated coordinats of one sector to rotated
- //coordinates relative to another sector
+ /// transform rotated coordinats of one sector to rotated
+ /// coordinates relative to another sector
+
Transform2to1(xyz,index);
Transform1to2(xyz,oindex);
index[0]=2;
- index[1]=oindex[1];
+ index[1]=oindex[1];
}
inline Float_t AliTPCParam::Transform2to2NearestWire(Float_t *xyz, Int_t *index) const
{
- //
- // asigns the x-position of the closest wire to xyz[0], return the
- // electron to closest wire distance
- //
+ /// asigns the x-position of the closest wire to xyz[0], return the
+ /// electron to closest wire distance
+
Float_t xnew,dx;
if (index[1]<fNInnerSector) {
xnew = fRInnerFirstWire+TMath::Nint((xyz[0]-fRInnerFirstWire)/fInnerWWPitch)*fInnerWWPitch;
inline Int_t AliTPCParam::Transform2to3(Float_t *xyz, Int_t *index) const
{
- //
- //calulates coresponding pad row number, sets index[2] for straight rows
- //does not change xyz[] information
- //valid only for straight row
- //
- if (index[1]<fNInnerSector)
+ /// calulates coresponding pad row number, sets index[2] for straight rows
+ /// does not change xyz[] information
+ /// valid only for straight row
+
+ if (index[1]<fNInnerSector)
index[2] =TMath::Nint((xyz[0]-fPadRowLow[0])/fInnerPadPitchLength);
else
if (xyz[0] < fLastWireUp1 )
index[2] = TMath::Nint((xyz[0]-fPadRowUp[0])/fOuter1PadPitchLength);
- else
+ else
index[2] = TMath::Nint(fNRowUp1+(xyz[0]-fPadRowUp[64])/fOuter2PadPitchLength);
index[0]=3;
return index[2];
inline void AliTPCParam::Transform3to4(Float_t *xyz, Int_t *index) const
{
- //
- //valid only for straight rows straight rows
- //calculate xyz[0] position relative to given index
- //
- if (index[1]<fNInnerSector)
+ /// valid only for straight rows straight rows
+ /// calculate xyz[0] position relative to given index
+
+ if (index[1]<fNInnerSector)
xyz[0] -=index[2]*fInnerPadPitchLength+fPadRowLow[0];
else
if (index[2]<fNRowUp1)
xyz[0] -=index[2]*fOuter1PadPitchLength+fPadRowUp[0];
- else
+ else
xyz[0] -=(index[2]-fNRowUp1)*fOuter2PadPitchLength+fPadRowUp[64];
index[0] =4;
}
inline void AliTPCParam::Transform4to3(Float_t *xyz, Int_t *index) const
{
- //
- //valid only for straight rows
- //transforms relative xyz[0] to the global one within given sector
- //
- if (index[1]<fNInnerSector)
+ /// valid only for straight rows
+ /// transforms relative xyz[0] to the global one within given sector
+
+ if (index[1]<fNInnerSector)
xyz[0] +=index[2]*fInnerPadPitchLength+fPadRowLow[0];
else
if(index[2]<fNRowUp1)
xyz[0] +=index[2]*fOuter1PadPitchLength+fPadRowUp[0];
- else
+ else
xyz[0] +=index[2]*fOuter2PadPitchLength+fPadRowUp[64];
index[0] =3;
}
inline void AliTPCParam::Transform2to5( Float_t *xyz, Int_t *index) const
{
- //
- //transform [x,y,z] to [r,phi,z]
- //
+ /// transform [x,y,z] to [r,phi,z]
+
Float_t angle;
Float_t r = TMath::Sqrt(xyz[0]*xyz[0]+xyz[1]*xyz[1]);
if ((xyz[0]==0)&&(xyz[1]==0)) angle = 0;
inline void AliTPCParam::Transform5to2( Float_t *xyz, Int_t *index) const
{
- //
- //transform [r,rphi,z] to [x,y,z]
- //
+ /// transform [r,rphi,z] to [x,y,z]
+
Float_t r = xyz[0];
Float_t angle= xyz[1];
xyz[0]=r*TMath::Cos(angle);
inline void AliTPCParam::Transform4to8(Float_t *xyz, Int_t *index) const
{
- //
- //transform xyz coordinates to 'digit' coordinates
- //
+ /// transform xyz coordinates to 'digit' coordinates
if (index[1]<fNInnerSector) {
if ( index[1]>=(fNInnerSector>>1)) xyz[1]*=-1.;
}
else {
- if ( (index[1]-fNInnerSector) >= (fNOuterSector>>1) ) xyz[1]*=-1;
+ if ( (index[1]-fNInnerSector) >= (fNOuterSector>>1) ) xyz[1]*=-1;
}
- xyz[2]/=fZWidth;
- if (index[1]<fNInnerSector) {
+ xyz[2]/=fZWidth;
+ if (index[1]<fNInnerSector) {
xyz[0]/=fInnerPadPitchLength;
xyz[1]/=fInnerPadPitchWidth;
}
- else{
- xyz[1]/=fOuterPadPitchWidth;
- if (index[2]<fNRowUp1 ) xyz[0]/=fOuter1PadPitchLength;
- else xyz[0]/=fOuter2PadPitchLength;
+ else{
+ xyz[1]/=fOuterPadPitchWidth;
+ if (index[2]<fNRowUp1 ) xyz[0]/=fOuter1PadPitchLength;
+ else xyz[0]/=fOuter2PadPitchLength;
}
xyz[1]-=0.5;
index[0]=8;
inline void AliTPCParam::Transform8to4(Float_t *xyz, Int_t *index) const
{
- //
- //transforms 'digit' coordinates to xyz coordinates
- //
+ /// transforms 'digit' coordinates to xyz coordinates
+
if (index[1]<fNInnerSector) {
if ( index[1]>=(fNInnerSector>>1)) xyz[1]*=-1.;
}
else {
- if ( (index[1]-fNInnerSector) >= (fNOuterSector>>1) ) xyz[1]*=-1;
+ if ( (index[1]-fNInnerSector) >= (fNOuterSector>>1) ) xyz[1]*=-1;
}
xyz[2]*=fZWidth;
- if (index[1]<fNInnerSector) {
+ if (index[1]<fNInnerSector) {
xyz[0]*=fInnerPadPitchLength;
- xyz[1]*=fInnerPadPitchWidth;
+ xyz[1]*=fInnerPadPitchWidth;
}
- else{
- xyz[1]*=fOuterPadPitchWidth;
+ else{
+ xyz[1]*=fOuterPadPitchWidth;
if (index[2] < fNRowUp1 ) xyz[0]*=fOuter1PadPitchLength;
- else xyz[0]*=fOuter2PadPitchLength;
- }
+ else xyz[0]*=fOuter2PadPitchLength;
+ }
index[0]=4;
}
inline void AliTPCParam::Transform6to8(Float_t *xyz, Int_t *index) const
{
- //
- //transforms cylindrical xyz coordinates to 'digit' coordinates
- //
+ /// transforms cylindrical xyz coordinates to 'digit' coordinates
+
xyz[2]/=fZWidth;
- if (index[1]<fNInnerSector) {
+ if (index[1]<fNInnerSector) {
xyz[0]/=fInnerPadPitchLength;
xyz[1]*=xyz[0]/fInnerPadPitchWidth;
}
- else{
+ else{
xyz[1]*=xyz[0]/fOuterPadPitchWidth;
if (index[2] < fNRowUp1 ) xyz[0]/=fOuter1PadPitchLength;
- else xyz[0]/=fOuter2PadPitchLength;
+ else xyz[0]/=fOuter2PadPitchLength;
}
index[0]=8;
}
inline void AliTPCParam::Transform8to6(Float_t *xyz, Int_t *index) const
{
- //
- //transforms 'digit' coordinates to cylindrical xyz coordinates
- //
+ /// transforms 'digit' coordinates to cylindrical xyz coordinates
+
xyz[2]*=fZWidth;
- if (index[1]<fNInnerSector) {
+ if (index[1]<fNInnerSector) {
xyz[0]*=fInnerPadPitchLength;
xyz[1]/=xyz[0]/fInnerPadPitchWidth;
}
- else{
- xyz[1]/=xyz[0]/fOuterPadPitchWidth;
+ else{
+ xyz[1]/=xyz[0]/fOuterPadPitchWidth;
if (index[2] < fNRowUp1 ) xyz[0]*=fOuter1PadPitchLength;
- else xyz[0]*=fOuter2PadPitchLength;
- }
+ else xyz[0]*=fOuter2PadPitchLength;
+ }
index[0]=6;
}
inline Float_t AliTPCParam::GetZLength(Int_t sector) const
{ if(sector <18 || (sector>35&§or<54)) return fZLength-0.275;
else return fZLength-0.302;
}
-#endif
+#endif
* provided "as is" without express or implied warranty. *
**************************************************************************/
-/* $Id$ */
-
-///////////////////////////////////////////////////////////////////////
-// Manager and of geomety classes for set: TPC //
-// //
-// !sectors are numbered from 0 //
-// !pad rows are numbered from 0 //
-//
-// 27.7. - AliTPCPaaramSr object for TPC
-// TPC with straight pad rows
-// Origin: Marian Ivanov, Uni. of Bratislava, ivanov@fmph.uniba.sk //
-// //
-///////////////////////////////////////////////////////////////////////
+
+/// \class AliTPCParamSR
+/// \brief Manager and of geomety classes for set: TPC
+///
+/// !sectors are numbered from 0
+/// !pad rows are numbered from 0
+///
+/// 27.7. - AliTPCPaaramSr object for TPC
+/// TPC with straight pad rows
+///
+/// \author Marian Ivanov, Uni. of Bratislava, ivanov@fmph.uniba.sk
//#include <Riostream.h>
#include <TMath.h>
#include "AliTPCROC.h"
#include "TGeoManager.h"
+/// \cond CLASSIMP
ClassImp(AliTPCParamSR)
+/// \endcond
static const Int_t kMaxRows=600;
static const Float_t kEdgeSectorSpace = 2.5;
static const Float_t kFacSigmaPadRow=3.;
fFacSigmaPadRow(0),
fFacSigmaPad(0),
fFacSigmaTime(0)
-{
- //
- //constructor set the default parameters
- //
+{
+ /// constructor set the default parameters
fFacSigmaPadRow = Float_t(kFacSigmaPadRow);
fFacSigmaPad = Float_t(kFacSigmaPad);
AliTPCParamSR::~AliTPCParamSR()
{
- //
- //destructor destroy some dynmicaly alocated variables
+ /// destructor destroy some dynmicaly alocated variables
+
if (fInnerPRF != 0) delete fInnerPRF;
if (fOuter1PRF != 0) delete fOuter1PRF;
if (fOuter2PRF != 0) delete fOuter2PRF;
void AliTPCParamSR::SetDefault()
{
- //set default TPC param
+ /// set default TPC param
+
fbStatus = kFALSE;
- AliTPCParam::SetDefault();
-}
+ AliTPCParam::SetDefault();
+}
Int_t AliTPCParamSR::CalcResponse(Float_t* xyz, Int_t * index, Int_t row)
{
- //
- //calculate bin response as function of the input position -x
- //return number of valid response bin
- //
- //we suppose that coordinate is expressed in float digits
- // it's mean coordinate system 8
- //xyz[0] - float padrow xyz[1] is float pad (center pad is number 0) and xyz[2] is float time bin
- //xyz[3] - electron time in float time bin format
- if ( (fInnerPRF==0)||(fOuter1PRF==0)||(fOuter2PRF==0) ||(fTimeRF==0) ){
+ /// calculate bin response as function of the input position -x
+ /// return number of valid response bin
+ ///
+ /// we suppose that coordinate is expressed in float digits
+ /// it's mean coordinate system 8
+ /// xyz[0] - float padrow xyz[1] is float pad (center pad is number 0) and xyz[2] is float time bin
+ /// xyz[3] - electron time in float time bin format
+
+ if ( (fInnerPRF==0)||(fOuter1PRF==0)||(fOuter2PRF==0) ||(fTimeRF==0) ){
Error("AliTPCParamSR", "response function was not adjusted");
return -1;
}
-
+
Float_t sfpadrow; // sigma of response function
- Float_t sfpad; // sigma of
+ Float_t sfpad; // sigma of
Float_t sftime= fFacSigmaTime*fTimeRF->GetSigma()/fZWidth; //3 sigma of time response
if (index[1]<fNInnerSector){
sfpadrow =fFacSigmaPadRow*fInnerPRF->GetSigmaY()/fInnerPadPitchLength;
else{
sfpadrow =fFacSigmaPadRow*fOuter2PRF->GetSigmaY()/fOuter2PadPitchLength;
sfpad =fFacSigmaPad*fOuter2PRF->GetSigmaX()/fOuterPadPitchWidth;
- }
+ }
}
Int_t fpadrow = TMath::Max(TMath::Nint(index[2]+xyz[0]-sfpadrow),0); //"first" padrow
lpadrow = TMath::Min(GetNRow(index[1])-1,lpadrow);
Int_t lpad = TMath::Min(TMath::Nint(xyz[1]+sfpad),fpad+19); //last pad
Int_t ltime = TMath::Min(TMath::Nint(xyz[2]+xyz[3]+GetZOffset()/GetZWidth()+sftime),ftime+19); // last time
- ltime = TMath::Min(ltime,GetMaxTBin()-1);
- //
+ ltime = TMath::Min(ltime,GetMaxTBin()-1);
+ //
Int_t npads = GetNPads(index[1],row);
- if (fpad<-npads/2)
+ if (fpad<-npads/2)
fpad = -npads/2;
- if (lpad>npads/2)
+ if (lpad>npads/2)
lpad= npads/2;
if (ftime<0) ftime=0;
- //
+ //
if (row>=0) { //if we are interesting about given pad row
if (fpadrow<=row) fpadrow =row;
- else
+ else
return 0;
if (lpadrow>=row) lpadrow = row;
- else
+ else
return 0;
}
-
+
Float_t padres[20][20]; //I don't expect bigger number of bins
- Float_t timeres[20];
+ Float_t timeres[20];
Int_t cindex3=0;
Int_t cindex=0;
Float_t cweight = 0;
if (fpadrow>=0) {
- //calculate padresponse function
+ //calculate padresponse function
Int_t padrow, pad;
for (padrow = fpadrow;padrow<=lpadrow;padrow++)
for (pad = fpad;pad<=lpad;pad++){
padres[padrow-fpadrow][pad-fpad]=fOuter2PRF->GetPRF(dx*fOuterPadPitchWidth,dy*fOuter2PadPitchLength);}}}
//calculate time response function
Int_t time;
- for (time = ftime;time<=ltime;time++)
- timeres[time-ftime]= fTimeRF->GetRF((-xyz[2]-xyz[3]+Float_t(time))*fZWidth);
+ for (time = ftime;time<=ltime;time++)
+ timeres[time-ftime]= fTimeRF->GetRF((-xyz[2]-xyz[3]+Float_t(time))*fZWidth);
//write over threshold values to stack
for (padrow = fpadrow;padrow<=lpadrow;padrow++)
for (pad = fpad;pad<=lpad;pad++)
fResponseBin[cindex3]=padrow;
fResponseBin[cindex3+1]=pad;
fResponseBin[cindex3+2]=time;
- cindex3+=3;
+ cindex3+=3;
fResponseWeight[cindex]=cweight;
cindex++;
}
}
}
- fCurrentMax=cindex;
+ fCurrentMax=cindex;
return fCurrentMax;
}
void AliTPCParamSR::TransformTo8(Float_t *xyz, Int_t *index) const
{
- //
- // transformate point to digit coordinate
- //
+ /// transformate point to digit coordinate
+
if (index[0]==0) Transform0to1(xyz,index);
if (index[0]==1) Transform1to2(xyz,index);
if (index[0]==2) Transform2to3(xyz,index);
void AliTPCParamSR::TransformTo2(Float_t *xyz, Int_t *index) const
{
- //
- //transformate point to rotated coordinate
- //
- //we suppose that
+ /// transformate point to rotated coordinate
+ ///
+ /// we suppose that
+
if (index[0]==0) Transform0to1(xyz,index);
if (index[0]==1) Transform1to2(xyz,index);
if (index[0]==4) Transform4to3(xyz,index);
if (index[0]==8) { //if we are in digit coordinate system transform to global
Transform8to4(xyz,index);
- Transform4to3(xyz,index);
+ Transform4to3(xyz,index);
}
}
void AliTPCParamSR::CRXYZtoXYZ(Float_t *xyz,
- const Int_t §or, const Int_t & padrow, Int_t option) const
-{
- //transform relative coordinates to absolute
+ const Int_t §or, const Int_t & padrow, Int_t option) const
+{
+ /// transform relative coordinates to absolute
+
Bool_t rel = ( (option&2)!=0);
Int_t index[3]={sector,padrow,0};
- if (rel==kTRUE) Transform4to3(xyz,index);//if the position is relative to pad row
+ if (rel==kTRUE) Transform4to3(xyz,index);//if the position is relative to pad row
Transform2to1(xyz,index);
}
void AliTPCParamSR::XYZtoCRXYZ(Float_t *xyz,
Int_t §or, Int_t & padrow, Int_t option) const
{
- //transform global position to the position relative to the sector padrow
- //if option=0 X calculate absolute calculate sector
- //if option=1 X absolute use input sector
- //if option=2 X relative to pad row calculate sector
- //if option=3 X relative use input sector
- //!!!!!!!!! WE start to calculate rows from row = 0
+ /// transform global position to the position relative to the sector padrow
+ /// if option=0 X calculate absolute calculate sector
+ /// if option=1 X absolute use input sector
+ /// if option=2 X relative to pad row calculate sector
+ /// if option=3 X relative use input sector
+ /// !!!!!!!!! WE start to calculate rows from row = 0
+
Int_t index[3];
- Bool_t rel = ( (option&2)!=0);
+ Bool_t rel = ( (option&2)!=0);
//option 0 and 2 means that we don't have information about sector
- if ((option&1)==0) Transform0to1(xyz,index); //we calculate sector number
+ if ((option&1)==0) Transform0to1(xyz,index); //we calculate sector number
else
index[0]=sector;
Transform1to2(xyz,index);
Float_t AliTPCParamSR::GetPrimaryLoss(Float_t */*x*/, Int_t *index, Float_t *angle)
{
- //
- //
+ ///
+
Float_t padlength=GetPadPitchLength(index[1]);
Float_t a1=TMath::Sin(angle[0]);
a1*=a1;
Float_t AliTPCParamSR::GetTotalLoss(Float_t */*x*/, Int_t *index, Float_t *angle)
{
- //
- //
+ ///
+
Float_t padlength=GetPadPitchLength(index[1]);
Float_t a1=TMath::Sin(angle[0]);
a1*=a1;
a2*=a2;
Float_t length =padlength*TMath::Sqrt(1+a1+a2);
return length*fNTotalLoss;
-
+
}
void AliTPCParamSR::GetClusterSize(Float_t *x, Int_t *index, Float_t */*angle*/, Int_t /*mode*/, Float_t *sigma)
{
- //
- //return cluster sigma2 (x,y) for particle at position x
- // in this case x coordinata is in drift direction
- //and y in pad row direction
- //we suppose that input coordinate system is digit system
-
+ /// return cluster sigma2 (x,y) for particle at position x
+ /// in this case x coordinata is in drift direction
+ /// and y in pad row direction
+ /// we suppose that input coordinate system is digit system
+
Float_t xx;
Float_t lx[3] = {x[0],x[1],x[2]};
Int_t li[3] = {index[0],index[1],index[2]};
// Float_t sigmadiff;
sigma[0]=0;
sigma[1]=0;
-
+
xx = lx[2]; //calculate drift length in cm
if (xx>0) {
sigma[0]+= xx*GetDiffL()*GetDiffL();
- sigma[1]+= xx*GetDiffT()*GetDiffT();
+ sigma[1]+= xx*GetDiffT()*GetDiffT();
}
//sigma[0]=sigma[1]=0;
if (GetTimeRF()!=0) sigma[0]+=GetTimeRF()->GetSigma()*GetTimeRF()->GetSigma();
- if ( (index[1]<fNInnerSector) &&(GetInnerPRF()!=0))
+ if ( (index[1]<fNInnerSector) &&(GetInnerPRF()!=0))
sigma[1]+=GetInnerPRF()->GetSigmaX()*GetInnerPRF()->GetSigmaX();
if ( (index[1]>=fNInnerSector) &&(index[2]<fNRowUp1) && (GetOuter1PRF()!=0))
sigma[1]+=GetOuter1PRF()->GetSigmaX()*GetOuter1PRF()->GetSigmaX();
-void AliTPCParamSR::GetSpaceResolution(Float_t */*x*/, Int_t */*index*/, Float_t */*angle*/,
+void AliTPCParamSR::GetSpaceResolution(Float_t */*x*/, Int_t */*index*/, Float_t */*angle*/,
Float_t /*amplitude*/, Int_t /*mode*/, Float_t */*sigma*/)
{
- //
- //
- //
-
+ ///
+
}
Float_t AliTPCParamSR::GetAmp(Float_t */*x*/, Int_t */*index*/, Float_t */*angle*/)
{
- //
- //
- //
+ ///
+
return 0;
}
Float_t * AliTPCParamSR::GetAnglesAccMomentum(Float_t *x, Int_t * index, Float_t* momentum, Float_t *angle)
{
- //
- //calculate angle of track to padrow at given position
- // for given magnetic field and momentum of the particle
- //
+ /// calculate angle of track to padrow at given position
+ /// for given magnetic field and momentum of the particle
TransformTo2(x,index);
- AliDetectorParam::GetAnglesAccMomentum(x,index,momentum,angle);
+ AliDetectorParam::GetAnglesAccMomentum(x,index,momentum,angle);
Float_t addangle = TMath::ASin(x[1]/GetPadRowRadii(index[1],index[2]));
angle[1] +=addangle;
- return angle;
+ return angle;
}
-
+
Bool_t AliTPCParamSR::Update()
{
Int_t i;
if (AliTPCParam::Update()==kFALSE) return kFALSE;
fbStatus = kFALSE;
- Float_t firstrow = fInnerRadiusLow + 1.575;
+ Float_t firstrow = fInnerRadiusLow + 1.575;
for( i= 0;i<fNRowLow;i++)
{
- Float_t x = firstrow + fInnerPadPitchLength*(Float_t)i;
+ Float_t x = firstrow + fInnerPadPitchLength*(Float_t)i;
fPadRowLow[i]=x;
// number of pads per row
// Float_t y = (x-0.5*fInnerPadPitchLength)*tan(fInnerAngle/2.)-fInnerWireMount-
// 0 and fNRowLow+1 reserved for cross talk rows
fYInner[i+1] = x*tan(fInnerAngle/2.)-fInnerWireMount;
//fNPadsLow[i] = 1+2*(Int_t)(y/fInnerPadPitchWidth) ;
- fNPadsLow[i] = AliTPCROC::Instance()->GetNPads(0,i) ; // ROC implement
+ fNPadsLow[i] = AliTPCROC::Instance()->GetNPads(0,i) ; // ROC implement
}
// cross talk rows
fYInner[0]=(fPadRowLow[0]-fInnerPadPitchLength)*tan(fInnerAngle/2.)-fInnerWireMount;
- fYInner[fNRowLow+1]=(fPadRowLow[fNRowLow-1]+fInnerPadPitchLength)*tan(fInnerAngle/2.)-fInnerWireMount;
+ fYInner[fNRowLow+1]=(fPadRowLow[fNRowLow-1]+fInnerPadPitchLength)*tan(fInnerAngle/2.)-fInnerWireMount;
firstrow = fOuterRadiusLow + 1.6;
for(i=0;i<fNRowUp;i++)
{
if(i<fNRowUp1){
- Float_t x = firstrow + fOuter1PadPitchLength*(Float_t)i;
+ Float_t x = firstrow + fOuter1PadPitchLength*(Float_t)i;
fPadRowUp[i]=x;
// Float_t y =(x-0.5*fOuter1PadPitchLength)*tan(fOuterAngle/2.)-fOuterWireMount-
// fOuterPadPitchWidth/2.;
fYOuter[i+1]= x*tan(fOuterAngle/2.)-fOuterWireMount;
//fNPadsUp[i] = 1+2*(Int_t)(y/fOuterPadPitchWidth) ;
- fNPadsUp[i] = AliTPCROC::Instance()->GetNPads(36,i) ; // ROC implement
+ fNPadsUp[i] = AliTPCROC::Instance()->GetNPads(36,i) ; // ROC implement
if(i==fNRowUp1-1) {
fLastWireUp1=fPadRowUp[i] +0.625;
firstrow = fPadRowUp[i] + 0.5*(fOuter1PadPitchLength+fOuter2PadPitchLength);
fPadRowUp[i]=x;
//Float_t y =(x-0.5*fOuter2PadPitchLength)*tan(fOuterAngle/2.)-fOuterWireMount-
// fOuterPadPitchWidth/2.;
- //fNPadsUp[i] = 1+2*(Int_t)(y/fOuterPadPitchWidth) ;
+ //fNPadsUp[i] = 1+2*(Int_t)(y/fOuterPadPitchWidth) ;
fNPadsUp[i] = AliTPCROC::Instance()->GetNPads(36,i) ; // ROC implement
}
fYOuter[i+1] = fPadRowUp[i]*tan(fOuterAngle/2.)-fOuterWireMount;
void AliTPCParamSR::Streamer(TBuffer &R__b)
{
- // Stream an object of class AliTPC.
+ /// Stream an object of class AliTPC.
if (R__b.IsReading()) {
Version_t R__v = R__b.ReadVersion(); if (R__v) { }
if (gGeoManager) ReadGeoMatrices();
} else {
R__b.WriteVersion(AliTPCParamSR::IsA());
- //TObject::Streamer(R__b);
- AliTPCParam::Streamer(R__b);
+ //TObject::Streamer(R__b);
+ AliTPCParam::Streamer(R__b);
}
}
Int_t AliTPCParamSR::CalcResponseFast(Float_t* xyz, Int_t * index, Int_t row, Float_t phase)
{
- //
- //calculate bin response as function of the input position -x
- //return number of valid response bin
- //
- //we suppose that coordinate is expressed in float digits
- // it's mean coordinate system 8
- //xyz[0] - electron position w.r.t. pad center, normalized to pad length,
- //xyz[1] is float pad (center pad is number 0) and xyz[2] is float time bin
- //xyz[3] - electron time in float time bin format
- if ( (fInnerPRF==0)||(fOuter1PRF==0)||(fOuter2PRF==0) ||(fTimeRF==0) ){
+ /// calculate bin response as function of the input position -x
+ /// return number of valid response bin
+ ///
+ /// we suppose that coordinate is expressed in float digits
+ /// it's mean coordinate system 8
+ /// xyz[0] - electron position w.r.t. pad center, normalized to pad length,
+ /// xyz[1] is float pad (center pad is number 0) and xyz[2] is float time bin
+ /// xyz[3] - electron time in float time bin format
+
+ if ( (fInnerPRF==0)||(fOuter1PRF==0)||(fOuter2PRF==0) ||(fTimeRF==0) ){
Error("AliTPCParamSR", "response function was not adjusted");
return -1;
}
-
+
const Int_t kpadn = 500;
const Float_t kfpadn = 500.;
const Int_t ktimen = 500;
const Int_t kpadrn = 500;
const Float_t kfpadrn = 500.;
-
+
static Float_t prfinner[2*kpadrn][5*kpadn]; //pad divided by 50
static Float_t prfouter1[2*kpadrn][5*kpadn]; //prfouter division
static Float_t prfouter2[2*kpadrn][5*kpadn];
- static Float_t kTanMax =0;
+ static Float_t kTanMax =0;
static Float_t rftime[5*ktimen]; //time division
static Int_t blabla=0;
static TH1F * hdiff=0;
static TH1F * hdiff1=0;
static TH1F * hdiff2=0;
-
+
if (blabla==0) { //calculate Response function - only at the begginning
kTanMax = TMath::ATan(10.*TMath::DegToRad());
hdiff =new TH1F("prf_diff","prf_diff",10000,-1,1);
hdiff1 =new TH1F("no_repsonse1","no_response1",10000,-1,1);
hdiff2 =new TH1F("no_response2","no_response2",10000,-1,1);
-
+
blabla=1;
zoffset = GetZOffset();
zwidth = fZWidth;
for (Int_t i=0;i<5*ktimen;i++){
rftime[i] = fTimeRF->GetRF(((i-2.5*kftimen)/kftimen)*zwidth+zoffset);
}
- for (Int_t i=0;i<5*kpadn;i++){
+ for (Int_t i=0;i<5*kpadn;i++){
for (Int_t j=0;j<2*kpadrn;j++){
prfinner[j][i] =
fInnerPRF->GetPRF((i-2.5*kfpadn)/kfpadn
fOuter2PRF->GetPRF((i-2.5*kfpadn)/kfpadn
*fOuterPadPitchWidth,(j-kfpadrn)/kfpadrn*fOuter2PadPitchLength);
}
- }
+ }
} // the above is calculated only once
// calculate central padrow, pad, time
dpadrow *= fOuter2PadPitchLength;
dpadrow += fOuterWWPitch;
dpadrow /= fOuter1PadPitchLength;
- }
+ }
// cross talk from short pad to long one
- if(row==fNRowUp1+1 && fpadrow==1){
+ if(row==fNRowUp1+1 && fpadrow==1){
dpadrow *= fOuter1PadPitchLength;
if(dpadrow < 0.) dpadrow = -1.; //protection against 3rd wire
dpadrow += fOuterWWPitch;
dpadrow /= fOuter2PadPitchLength;
-
+
}
// "normal"
Int_t apadrow = TMath::Nint((dpadrow-fpadrow)*kfpadrn+kfpadrn);
for (Int_t ipadrow = fpadrow; ipadrow<=lpadrow;ipadrow++){
- if ( (apadrow<0) || (apadrow>=2*kpadrn))
+ if ( (apadrow<0) || (apadrow>=2*kpadrn))
continue;
// pad angular correction
Float_t angle = 0.;
}
// if (cweight<fResponseThreshold) continue;
Int_t atime = TMath::Nint((dtime-ftime)*kftimen+2.5*kftimen);
- for (Int_t itime = ftime;itime<=ltime;itime++){
+ for (Int_t itime = ftime;itime<=ltime;itime++){
Float_t cweight2 = cweight*rftime[atime];
if (cweight2>fResponseThreshold) {
fResponseBin[cindex3++]=cpadrow+ipadrow;
fResponseBin[cindex3++]=cpad+ipad;
fResponseBin[cindex3++]=ctime+itime;
- fResponseWeight[cindex++]=cweight2;
+ fResponseWeight[cindex++]=cweight2;
}
atime-=ktimen;
}
- apad-= kpadn;
+ apad-= kpadn;
}
apadrow-=kpadrn;
}
- fCurrentMax=cindex;
- return fCurrentMax;
-
+ fCurrentMax=cindex;
+ return fCurrentMax;
+
}
/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
* See cxx source for full Copyright notice */
-/* $Id$ */
-////////////////////////////////////////////////
-// Manager class for TPC parameters //
-////////////////////////////////////////////////
+/// \class AliTPCParamSR
+/// \brief Manager class for TPC parameters
+
#include "AliTPCParam.h"
class AliTPCRF1D;
Int_t CalcResponse(Float_t* x, Int_t * index, Int_t row);
Int_t CalcResponseFast(Float_t* x, Int_t * index, Int_t row,Float_t phase);
- //calculate bin response as function of the input position -x
+ //calculate bin response as function of the input position -x
//return number of valid response bin
-
- void XYZtoCRXYZ(Float_t *xyz,
+
+ void XYZtoCRXYZ(Float_t *xyz,
Int_t §or, Int_t &padrow, Int_t option=3) const;
//transform global position to the position relative to the sector padrow
//if option=0 X calculate absolute calculate sector
//if option=3 X relative use input sector
void CRXYZtoXYZ(Float_t *xyz,
- const Int_t §or, const Int_t & padrow, Int_t option=3) const;
+ const Int_t §or, const Int_t & padrow, Int_t option=3) const;
//transform relative position to the gloabal position
void TransformTo8(Float_t *xyz, Int_t *index) const;
void TransformTo2(Float_t *xyz, Int_t *index) const;
- Bool_t Update(); //recalculate and check geometric parameters
+ Bool_t Update(); //recalculate and check geometric parameters
void SetDefault(); //set default parameters
void SetInnerPRF(AliTPCPRF2D * prf) {fInnerPRF = prf;}
void SetOuter1PRF(AliTPCPRF2D * prf) {fOuter1PRF = prf;} //e.k
virtual void GetClusterSize(Float_t *x, Int_t *index, Float_t *angle, Int_t mode, Float_t *sigma);
virtual void GetSpaceResolution(Float_t *x, Int_t *index, Float_t *angle, Float_t amplitude, Int_t mode,Float_t *sigma);
virtual Float_t GetAmp(Float_t *x, Int_t *index, Float_t *angle);
- virtual Float_t * GetAnglesAccMomentum(Float_t *x, Int_t * index, Float_t* momentum, Float_t *angle);
-
+ virtual Float_t * GetAnglesAccMomentum(Float_t *x, Int_t * index, Float_t* momentum, Float_t *angle);
+
protected:
- AliTPCPRF2D * fInnerPRF; //pad response function for inner sector
- AliTPCPRF2D * fOuter1PRF; //pad response function for outer sector
- AliTPCPRF2D * fOuter2PRF;
- AliTPCRF1D * fTimeRF; //time response function object
- Float_t fFacSigmaPadRow; //factor-how many sigma of response I accept
- Float_t fFacSigmaPad; //factor-how many sigma of response I accept
- Float_t fFacSigmaTime; //factor-how many sigma of response I accept
+ AliTPCPRF2D * fInnerPRF; ///< pad response function for inner sector
+ AliTPCPRF2D * fOuter1PRF; ///< pad response function for outer sector
+ AliTPCPRF2D * fOuter2PRF;
+ AliTPCRF1D * fTimeRF; ///< time response function object
+ Float_t fFacSigmaPadRow; ///< factor-how many sigma of response I accept
+ Float_t fFacSigmaPad; ///< factor-how many sigma of response I accept
+ Float_t fFacSigmaTime; ///< factor-how many sigma of response I accept
private:
AliTPCParamSR(const AliTPCParamSR ¶m); // copy constructor
AliTPCParamSR &operator = (const AliTPCParamSR & param); //assignment operator
+ /// \cond CLASSIMP
ClassDef(AliTPCParamSR,2) //parameter object for set:TPC
+ /// \endcond
};
-#endif
+#endif
+/// \class AliTPCPointCorrection
+
/**************************************************************************
* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
* *
* provided "as is" without express or implied warranty. *
**************************************************************************/
-/*
-
+/*
+
Unlinearities fitting:
Model for Outer field cage:
Unlinearities at the edge aproximated using two exponential decays.
-
- dz = dz0(r,z) +dr(r,z)*tan(theta)
+
+ dz = dz0(r,z) +dr(r,z)*tan(theta)
dy = +dr(r,z)*tan(phi)
-
-
-
+
+
+
*/
#include "AliTPCcalibDB.h"
AliTPCPointCorrection* AliTPCPointCorrection::fgInstance = 0;
+/// \cond CLASSIMP
ClassImp(AliTPCPointCorrection)
+/// \endcond
AliTPCPointCorrection::AliTPCPointCorrection():
TNamed(),
fXmiddle(0),
fXquadrant(0),
fArraySectorIntParam(36), // array of sector alignment parameters
- fArraySectorIntCovar(36), // array of sector alignment covariances
+ fArraySectorIntCovar(36), // array of sector alignment covariances
//
// Kalman filter for global alignment
//
- fSectorParam(0), // Kalman parameter
- fSectorCovar(0) // Kalman covariance
+ fSectorParam(0), // Kalman parameter
+ fSectorCovar(0) // Kalman covariance
{
//
fErrorsOutZ(38),
fParamOutZVersion(0),
//
- //
+ //
//
fXIO(0),
fXmiddle(0),
fXquadrant(0),
fArraySectorIntParam(36), // array of sector alignment parameters
- fArraySectorIntCovar(36), // array of sector alignment covariances
+ fArraySectorIntCovar(36), // array of sector alignment covariances
//
// Kalman filter for global alignment
//
fSectorParam(0), // Kalman parameter for A side
- fSectorCovar(0) // Kalman covariance for A side
-
+ fSectorCovar(0) // Kalman covariance for A side
+
{
- //
- // Non default constructor
- //
+ /// Non default constructor
+
AliTPCROC * roc = AliTPCROC::Instance();
fXquadrant = roc->GetPadRowRadii(36,53);
fXmiddle = ( roc->GetPadRowRadii(0,0)+roc->GetPadRowRadii(36,roc->GetNRows(36)-1))*0.5;
}
AliTPCPointCorrection::~AliTPCPointCorrection(){
- //
- //
- //
+ ///
+
}
AliTPCPointCorrection* AliTPCPointCorrection::Instance()
{
- //
- // Singleton implementation
- // Returns an instance of this class, it is created if neccessary
- //
+ /// Singleton implementation
+ /// Returns an instance of this class, it is created if neccessary
+
if (fgInstance == 0){
fgInstance = new AliTPCPointCorrection();
}
Double_t AliTPCPointCorrection::GetDrOut(Bool_t isGlobal, Bool_t type, Double_t cx, Double_t cy, Double_t cz, Int_t sector){
- //
- // return radial correction
- //
+ /// return radial correction
+
if (fParamOutRVersion==0) return CorrectionOutR0(isGlobal, type,cx,cy,cz,sector);
return 0;
}
Double_t AliTPCPointCorrection::SGetDrOut(Bool_t isGlobal, Bool_t type, Double_t cx, Double_t cy, Double_t cz, Int_t sector){
- //
- // return radial correction - static function
- //
+ /// return radial correction - static function
+
return fgInstance->GetDrOut(isGlobal, type,cx,cy,cz,sector);
}
Double_t AliTPCPointCorrection::GetDzOut(Bool_t isGlobal, Bool_t type, Double_t cx, Double_t cy, Double_t cz, Int_t sector){
- //
- //
- //
+ ///
+
if (fParamOutZVersion==0) return CorrectionOutZ0(isGlobal, type,cx,cy,cz,sector);
return 0;
}
Double_t AliTPCPointCorrection::SGetDzOut(Bool_t isGlobal, Bool_t type, Double_t cx, Double_t cy, Double_t cz, Int_t sector){
- //
- //
- //
+ ///
+
return fgInstance->GetDzOut(isGlobal, type,cx,cy,cz,sector);
}
Double_t AliTPCPointCorrection::CorrectionOutR0(Bool_t isGlobal, Bool_t type, Double_t cx, Double_t cy, Double_t cz, Int_t sector){
- //
- // return dR correction - for correction version 0
- // Parameters:
- // isGlobal - is the x in global frame
- // type - kTRUE - use sectors - kFALSE - only Side param
- // cx, cy,cz - cluster position
- // sector - sector number
+ /// return dR correction - for correction version 0
+ /// Parameters:
+ /// isGlobal - is the x in global frame
+ /// type - kTRUE - use sectors - kFALSE - only Side param
+ /// cx, cy,cz - cluster position
+ /// sector - sector number
+
if (isGlobal){
// recalculate sector if in global frame
Double_t alpha = TMath::ATan2(cy,cx);
if (type==kFALSE) sector=36+(sector%36>=18); // side level parameters
// dout
- Double_t radius = TMath::Sqrt(cx*cx+cy*cy);
+ Double_t radius = TMath::Sqrt(cx*cx+cy*cy);
AliTPCROC * roc = AliTPCROC::Instance();
Double_t xout = roc->GetPadRowRadiiUp(roc->GetNRows(37)-1);
- Double_t dout = xout-radius;
+ Double_t dout = xout-radius;
if (dout<0) return 0;
//drift
Double_t dr = 0.5 - TMath::Abs(cz/250.);
TVectorD * vec = GetParamOutR(sector);
if (!vec) return 0;
Double_t eout10 = TMath::Exp(-dout/10.);
- Double_t eout5 = TMath::Exp(-dout/5.);
+ Double_t eout5 = TMath::Exp(-dout/5.);
Double_t eoutp = (eout10+eout5)*0.5;
Double_t eoutm = (eout10-eout5)*0.5;
//
}
Double_t AliTPCPointCorrection::RPhiCOGCorrection(Int_t sector, Int_t padrow, Float_t pad, Float_t cy, Float_t y, Float_t z, Float_t ky,Float_t qMax, Float_t threshold){
- //
- // Calculates COG corection in RPHI direction
- // cluster and track position y is supposed to be corrected before for other effects
- // (e.g ExB and alignemnt)
- // Rphi distortion dependeds on the distance to the edge-pad, distance to the wire edge and
- // relative distance to the center of the pad. Therefore the y position is trnsfromed to the
- // pad coordiante frame (correction offset (ExB alignemnt) substracted).
- //
- // Input parameters:
- //
- // sector - sector number - 0-71 - cl.GetDetector()
- // padrow - padrow number -0-63 -IROC 0-95 OROC - cl->GetRow()
- // pad - mean pad number - cl->GetPad()
- // cy - cluster y - cl->GetY()
- // y - track -or cluster y
- // qMax - cluster max charge - cl-.GetMax()
- // threshold - clusterer threshold
- //
+ /// Calculates COG corection in RPHI direction
+ /// cluster and track position y is supposed to be corrected before for other effects
+ /// (e.g ExB and alignemnt)
+ /// Rphi distortion dependeds on the distance to the edge-pad, distance to the wire edge and
+ /// relative distance to the center of the pad. Therefore the y position is trnsfromed to the
+ /// pad coordiante frame (correction offset (ExB alignemnt) substracted).
+ ///
+ /// Input parameters:
+ ///
+ /// sector - sector number - 0-71 - cl.GetDetector()
+ /// padrow - padrow number -0-63 -IROC 0-95 OROC - cl->GetRow()
+ /// pad - mean pad number - cl->GetPad()
+ /// cy - cluster y - cl->GetY()
+ /// y - track -or cluster y
+ /// qMax - cluster max charge - cl-.GetMax()
+ /// threshold - clusterer threshold
+
AliTPCClusterParam * clparam = AliTPCcalibDB::Instance()->GetClusterParam();
if (!clparam) {
- AliFatal("TPC OCDB not initialized");
+ AliFatal("TPC OCDB not initialized");
return 0;
}
Int_t padtype=0;
Int_t npads = AliTPCROC::Instance()->GetNPads(sector,padrow);
Float_t yshift = TMath::Abs(cy)-TMath::Abs((-npads*0.5+pad)*padwidth); // the clusters can be corrected before
// shift to undo correction
-
+
y -= yshift*((y>0)?1.:-1.); // y in the sector coordinate
Double_t y0 = npads*0.5*padwidth;
- Double_t dy = (TMath::Abs(y0)-TMath::Abs(y))/padwidth-0.5; // distance to the center of pad0
+ Double_t dy = (TMath::Abs(y0)-TMath::Abs(y))/padwidth-0.5; // distance to the center of pad0
//
Double_t padcenter = TMath::Nint(dy);
Double_t sumw=0;
if (ip<0 &&weight> threshold) weight = threshold; // this is done in cl finder
if (weight<0) continue;
sumw+=weight;
- sumwi+=weight*(ip);
+ sumwi+=weight*(ip);
}
Double_t result =0;
if (sumw>0) result = sumwi/sumw;
Double_t AliTPCPointCorrection::CorrectionOutZ0(Bool_t isGlobal, Bool_t type, Double_t cx, Double_t cy, Double_t cz, Int_t sector){
- //
- // return dR correction - for correction version 0
- // Parameters:
- // isGlobal - is the x in global frame
- // type - kTRUE - use sectors - kFALSE - only Side param
- // cx, cy,cz - cluster position
- // sector - sector number
+ /// return dR correction - for correction version 0
+ /// Parameters:
+ /// isGlobal - is the x in global frame
+ /// type - kTRUE - use sectors - kFALSE - only Side param
+ /// cx, cy,cz - cluster position
+ /// sector - sector number
+
if (isGlobal){
// recalculate sector if in global frame
Double_t alpha = TMath::ATan2(cy,cx);
if (type==kFALSE) sector=36+(sector%36>=18); // side level parameters
// dout
- Double_t radius = TMath::Sqrt(cx*cx+cy*cy);
+ Double_t radius = TMath::Sqrt(cx*cx+cy*cy);
AliTPCROC * roc = AliTPCROC::Instance();
Double_t xout = roc->GetPadRowRadiiUp(roc->GetNRows(37)-1);
Double_t dout = xout-radius;
TVectorD * vec = GetParamOutR(sector);
if (!vec) return 0;
Double_t eout10 = TMath::Exp(-dout/10.);
- Double_t eout5 = TMath::Exp(-dout/5.);
+ Double_t eout5 = TMath::Exp(-dout/5.);
Double_t eoutp = (eout10+eout5)*0.5;
Double_t eoutm = (eout10-eout5)*0.5;
//
}
Double_t AliTPCPointCorrection::GetEdgeQ0(Int_t sector, Int_t padrow, Float_t y){
- //
+ ///
+
/* TF1 fexp("fexp","1-exp(-[0]*(x-[1]))",0,20)
| param [0] | param [1]
IROC | 4.71413 | 1.39558
OROC1| 2.11437 | 1.52643
- OROC2| 2.15082 | 1.53537
+ OROC2| 2.15082 | 1.53537
*/
Double_t params[2]={100,0};
}
Double_t AliTPCPointCorrection::SGetEdgeQ0(Int_t sector, Int_t padrow, Float_t y){
- //
- //
+ ///
+
return fgInstance->GetEdgeQ0(sector, padrow, y);
}
void AliTPCPointCorrection::AddCorrectionSector(TObjArray & sideAPar, TObjArray &sideCPar, TObjArray & sideACov, TObjArray &sideCCov, Bool_t reset){
- //
- //
- //
+ ///
+
for (Int_t isec=0;isec<36;isec++){
TMatrixD * mat1 = (TMatrixD*)(sideAPar.At(isec));
TMatrixD * mat1Covar = (TMatrixD*)(sideACov.At(isec));
TMatrixD * mat0 = (TMatrixD*)(fArraySectorIntParam.At(isec));
TMatrixD * mat0Covar = (TMatrixD*)(fArraySectorIntCovar.At(isec));
if (!mat0) {
- fArraySectorIntParam.AddAt(mat1->Clone(),isec);
- fArraySectorIntCovar.AddAt(mat1Covar->Clone(),isec);
+ fArraySectorIntParam.AddAt(mat1->Clone(),isec);
+ fArraySectorIntCovar.AddAt(mat1Covar->Clone(),isec);
continue;
}
- (*mat0Covar)=(*mat1Covar);
+ (*mat0Covar)=(*mat1Covar);
if (reset) (*mat0)=(*mat1);
if (!reset) (*mat0)+=(*mat1);
}
TMatrixD * mat0 = (TMatrixD*)(fArraySectorIntParam.At(isec));
TMatrixD * mat0Covar = (TMatrixD*)(fArraySectorIntCovar.At(isec));
if (!mat0) {
- fArraySectorIntParam.AddAt(mat1->Clone(),isec);
- fArraySectorIntCovar.AddAt(mat1Covar->Clone(),isec);
+ fArraySectorIntParam.AddAt(mat1->Clone(),isec);
+ fArraySectorIntCovar.AddAt(mat1Covar->Clone(),isec);
continue;
}
- (*mat0Covar)=(*mat1Covar);
+ (*mat0Covar)=(*mat1Covar);
if (reset) (*mat0)=(*mat1);
if (!reset) (*mat0)+=(*mat1);
}
Double_t AliTPCPointCorrection::GetCorrectionSector(Int_t coord, Int_t sector, Double_t lx, Double_t ly, Double_t /*lz*/, Int_t quadrant){
- //
- // Get position correction for given sector
- //
+ /// Get position correction for given sector
TMatrixD * param = (TMatrixD*)fArraySectorIntParam.At(sector%36);
if (!param) return 0;
if (ly<0) quadrant=3;
if (ly>0) quadrant=4;
}
- }
+ }
}
Double_t a10 = (*param)(quadrant*6+0,0);
Double_t a20 = (*param)(quadrant*6+1,0);
}
Double_t AliTPCPointCorrection::SGetCorrectionSector(Int_t coord, Int_t sector, Double_t lx, Double_t ly, Double_t lz, Int_t quadrant){
- //
- //
- //
+ ///
+
if (!Instance()) return 0;
return Instance()->GetCorrectionSector(coord,sector,lx,ly,lz, quadrant);
}
Double_t AliTPCPointCorrection::GetCorrection(Int_t coord, Int_t sector, Double_t lx, Double_t ly, Double_t /*lz*/){
- //
- // Get position correction for given sector
- //
+ /// Get position correction for given sector
+
if (!fSectorParam) return 0;
-
+
Double_t a10 = (*fSectorParam)(sector*6+0,0);
Double_t a20 = (*fSectorParam)(sector*6+1,0);
Double_t a21 = (*fSectorParam)(sector*6+2,0);
}
Double_t AliTPCPointCorrection::SGetCorrection(Int_t coord, Int_t sector, Double_t lx, Double_t ly, Double_t lz){
- //
- //
- //
+ ///
+
if (!Instance()) return 0;
return Instance()->GetCorrection(coord,sector,lx,ly,lz);
}
+/// \class AliTPCPointCorrection
+
#ifndef ALITPCPOINTCORRECTION_H
#define ALITPCPOINTCORRECTION_H
#include "TObjArray.h"
#include "TVectorD.h"
-
+
class AliTPCPointCorrection:public TNamed {
public:
- AliTPCPointCorrection();
+ AliTPCPointCorrection();
AliTPCPointCorrection(const Text_t *name, const Text_t *title);
virtual ~AliTPCPointCorrection();
- //
+ //
TVectorD * GetParamOutR(Int_t sector) {return (TVectorD*)fParamsOutR.At(sector);}
TVectorD * GetParamOutZ(Int_t sector) {return (TVectorD*)fParamsOutZ.At(sector);}
//
static Double_t SGetDrOut(Bool_t isGlobal, Bool_t type, Double_t cx, Double_t cy, Double_t cz, Int_t sector);
static Double_t SGetDzOut(Bool_t isGlobal, Bool_t type, Double_t cx, Double_t cy, Double_t cz, Int_t sector);
-
+
static AliTPCPointCorrection* Instance();
void SetInstance(AliTPCPointCorrection*param){fgInstance = param;}
//
Double_t CorrectionOutR0(Bool_t isGlobal, Bool_t type, Double_t cx, Double_t cy, Double_t cz, Int_t sector);
Double_t CorrectionOutZ0(Bool_t isGlobal, Bool_t type, Double_t cx, Double_t cy, Double_t cz, Int_t sector);
-
+
Double_t RPhiCOGCorrection(Int_t sector, Int_t padrow, Float_t pad, Float_t cy, Float_t y, Float_t z, Float_t ky, Float_t qMax, Float_t threhsold);
Double_t SRPhiCOGCorrection(Int_t sector, Int_t padrow, Float_t pad, Float_t cy, Float_t y, Float_t z, Float_t ky, Float_t qMax, Float_t threhsold);
//
// IROC -OROC+Quadrant alignment
//
void AddCorrectionSector(TObjArray & sideAPar, TObjArray &sideCPar, TObjArray & sideACov, TObjArray &sideCCov, Bool_t reset);
- Double_t GetCorrectionSector(Int_t coord, Int_t sector, Double_t lx, Double_t ly, Double_t lz, Int_t quadrant =-1);
- static Double_t SGetCorrectionSector(Int_t coord, Int_t sector, Double_t lx, Double_t ly, Double_t lz, Int_t quadrant=-1);
+ Double_t GetCorrectionSector(Int_t coord, Int_t sector, Double_t lx, Double_t ly, Double_t lz, Int_t quadrant =-1);
+ static Double_t SGetCorrectionSector(Int_t coord, Int_t sector, Double_t lx, Double_t ly, Double_t lz, Int_t quadrant=-1);
//
// Global alignment
//
Double_t GetCorrection(Int_t coord, Int_t sector, Double_t lx, Double_t ly, Double_t lz);
static Double_t SGetCorrection(Int_t coord, Int_t sector, Double_t lx, Double_t ly, Double_t lz);
-public:
+public:
//
// Correction out
//
- TObjArray fParamsOutR; // Parameters for radial distortion - outer field cage
- TObjArray fParamsOutZ; // Parameters for z distortion - outer field cage
- Int_t fParamOutRVersion; // version of the parameterization
- TObjArray fErrorsOutR; // Parameters for radial distortion - outer field cage
- TObjArray fErrorsOutZ; // Parameters for z distortion - outer field cage
- Int_t fParamOutZVersion; // version of the parameterization
+ TObjArray fParamsOutR; ///< Parameters for radial distortion - outer field cage
+ TObjArray fParamsOutZ; ///< Parameters for z distortion - outer field cage
+ Int_t fParamOutRVersion; ///< version of the parameterization
+ TObjArray fErrorsOutR; ///< Parameters for radial distortion - outer field cage
+ TObjArray fErrorsOutZ; ///< Parameters for z distortion - outer field cage
+ Int_t fParamOutZVersion; ///< version of the parameterization
//
// Edge rfi
- //
+ //
//
// Alignment part
//
- Double_t fXIO; // OROC-IROC boundary
- Double_t fXmiddle; // center of the TPC sector local X
- Double_t fXquadrant; // x quadrant
+ Double_t fXIO; ///< OROC-IROC boundary
+ Double_t fXmiddle; ///< center of the TPC sector local X
+ Double_t fXquadrant; ///< x quadrant
//
// IROC OROC alignment
//
- TObjArray fArraySectorIntParam; // array of sector alignment parameters
- TObjArray fArraySectorIntCovar; // array of sector alignment covariances
+ TObjArray fArraySectorIntParam; ///< array of sector alignment parameters
+ TObjArray fArraySectorIntCovar; ///< array of sector alignment covariances
//
// Kalman filter for global alignment
//
- TMatrixD *fSectorParam; // Kalman parameter
- TMatrixD *fSectorCovar; // Kalman covariance
+ TMatrixD *fSectorParam; ///< Kalman parameter
+ TMatrixD *fSectorCovar; ///< Kalman covariance
//
//
//
private:
- AliTPCPointCorrection(const AliTPCPointCorrection&);
- AliTPCPointCorrection& operator=(const AliTPCPointCorrection&);
- static AliTPCPointCorrection* fgInstance; //! Instance of this class (singleton implementation)
- ClassDef(AliTPCPointCorrection, 3);
+ AliTPCPointCorrection(const AliTPCPointCorrection&);
+ AliTPCPointCorrection& operator=(const AliTPCPointCorrection&);
+ static AliTPCPointCorrection* fgInstance; //!< Instance of this class (singleton implementation)
+ /// \cond CLASSIMP
+ ClassDef(AliTPCPointCorrection, 3);
+ /// \endcond
};
#endif
+/// \class AliTPCPreprocessor
+
/**************************************************************************
* Copyright(c) 2007, ALICE Experiment at CERN, All rights reserved. *
* *
#include "ARVersion.h"
#include "TFile.h"
#include "TTree.h"
-#include "TGraph.h"
+#include "TGraph.h"
#include "TEnv.h"
#include "TParameter.h"
#include <TTimeStamp.h>
-const Int_t kValCutTemp = 100; // discard temperatures > 100 degrees
-const Int_t kDiffCutTemp = 5; // discard temperature differences > 5 degrees
-const Double_t kHighVoltageDifference = 1e-4; // don't record High Voltage points
+const Int_t kValCutTemp = 100; ///< discard temperatures > 100 degrees
+const Int_t kDiffCutTemp = 5; ///< discard temperature differences > 5 degrees
+const Double_t kHighVoltageDifference = 1e-4; ///< don't record High Voltage points
// differing by less than 1e-4 from
// previous point.
-const Double_t kGasCompositionDifference = 1e-3; // don't record Gas Composition points
+const Double_t kGasCompositionDifference = 1e-3; ///< don't record Gas Composition points
// differing by less than 1e-3 from
// previous point
-const TString kPedestalRunType = "PEDESTAL"; // pedestal run identifier
-const TString kPulserRunType = "PULSER"; // pulser run identifier
-const TString kPhysicsRunType = "PHYSICS"; // physics run identifier
-const TString kCosmicRunType = "COSMIC"; // cosmic run identifier
-const TString kLaserRunType = "LASER"; // laser run identifier
-const TString kDaqRunType = "DAQ"; // DAQ run identifier
-const TString kStandaloneRunType = "STANDALONE"; // STANDALONE run identifier
-const TString kAmandaTemp = "TPC_PT_%d_TEMPERATURE"; // Amanda string for temperature entries
-const TString kAmandaDDL = "DDL%d"; // Amanda string for list of active DDLs
-const Int_t kNumDDL = 216; // number of TPC DDLs
-const Int_t kFirstDDL = 768; // identifier of first DDL
-//const Double_t kFitFraction = 0.7; // Fraction of DCS sensor fits required
-const Double_t kFitFraction = -1.0; // Don't require minimum number of fits in commissioning run
-const Int_t kNumPressureSensors = 3; // number of pressure sensors
+const TString kPedestalRunType = "PEDESTAL"; ///< pedestal run identifier
+const TString kPulserRunType = "PULSER"; ///< pulser run identifier
+const TString kPhysicsRunType = "PHYSICS"; ///< physics run identifier
+const TString kCosmicRunType = "COSMIC"; ///< cosmic run identifier
+const TString kLaserRunType = "LASER"; ///< laser run identifier
+const TString kDaqRunType = "DAQ"; ///< DAQ run identifier
+const TString kStandaloneRunType = "STANDALONE"; ///< STANDALONE run identifier
+const TString kAmandaTemp = "TPC_PT_%d_TEMPERATURE"; ///< Amanda string for temperature entries
+const TString kAmandaDDL = "DDL%d"; ///< Amanda string for list of active DDLs
+const Int_t kNumDDL = 216; ///< number of TPC DDLs
+const Int_t kFirstDDL = 768; ///< identifier of first DDL
+//const Double_t kFitFraction = 0.7; // Fraction of DCS sensor fits required
+const Double_t kFitFraction = -1.0; ///< Don't require minimum number of fits in commissioning run
+const Int_t kNumPressureSensors = 3; ///< number of pressure sensors
const char* kPressureSensorNames[kNumPressureSensors] = {
"CavernAtmosPressure",
"CavernAtmosPressure2",
"SurfaceAtmosPressure" };
-const Int_t kMinCESectors = 32; // minimum number of sectors (per side)
+const Int_t kMinCESectors = 32; ///< minimum number of sectors (per side)
// to accept CE calibration
-
+
//
// This class is the SHUTTLE preprocessor for the TPC detector.
//
+/// \cond CLASSIMP
ClassImp(AliTPCPreprocessor)
+/// \endcond
//______________________________________________________________________________________________
AliTPCPreprocessor::AliTPCPreprocessor(AliShuttleInterface* shuttle) :
fROC = AliTPCROC::Instance();
// define run types to be processed
-
+
AddRunType(kPedestalRunType);
AddRunType(kPulserRunType);
AddRunType(kPhysicsRunType);
AddRunType(kLaserRunType);
AddRunType(kDaqRunType);
AddRunType(kStandaloneRunType);
-
}
//______________________________________________________________________________________________
AliTPCPreprocessor::AliTPCPreprocessor(const AliTPCPreprocessor& ) :
//______________________________________________________________________________________________
AliTPCPreprocessor::~AliTPCPreprocessor()
{
- // destructor
+ /// destructor
delete fTemp;
delete fHighVoltage;
TString hvConf = fConfEnv->GetValue("HighVoltage","ON");
hvConf.ToUpper();
- if (hvConf != "OFF" ) {
+ if (hvConf != "OFF" ) {
confTree=0;
entry=0;
entry = GetFromOCDB("Config", "HighVoltage");
}
time_t timeStart = (time_t)(((TString)GetRunParameter("DAQ_time_start")).Atoi());
time_t timeEnd = (time_t)(((TString)GetRunParameter("DAQ_time_end")).Atoi());
- fHighVoltage = new AliDCSSensorArray (UInt_t(timeStart),
+ fHighVoltage = new AliDCSSensorArray (UInt_t(timeStart),
UInt_t(timeEnd), confTree);
}
// High voltage status values
-
+
TString hvStatConf = fConfEnv->GetValue("HighVoltageStat","ON");
hvStatConf.ToUpper();
- if (hvStatConf != "OFF" ) {
+ if (hvStatConf != "OFF" ) {
confTree=0;
entry=0;
entry = GetFromOCDB("Config", "HighVoltageStat");
}
// Goofie values
-
+
TString goofieConf = fConfEnv->GetValue("Goofie","ON");
goofieConf.ToUpper();
- if (goofieConf != "OFF" ) {
+ if (goofieConf != "OFF" ) {
confTree=0;
entry=0;
entry = GetFromOCDB("Config", "Goofie");
TString gasConf = fConfEnv->GetValue("GasComposition","OFF");
gasConf.ToUpper();
- if (gasConf != "OFF" ) {
+ if (gasConf != "OFF" ) {
confTree=0;
entry=0;
entry = GetFromOCDB("Config", "GasComposition");
}
time_t timeStart = (time_t)(((TString)GetRunParameter("DAQ_time_start")).Atoi());
time_t timeEnd = (time_t)(((TString)GetRunParameter("DAQ_time_end")).Atoi());
- fGasComposition = new AliDCSSensorArray (UInt_t(timeStart),
+ fGasComposition = new AliDCSSensorArray (UInt_t(timeStart),
UInt_t(timeEnd), confTree);
}
// Pressure values
-
+
TString runType = GetRunType();
- if( runType == kPhysicsRunType ||
- runType == kLaserRunType ) {
+ if( runType == kPhysicsRunType ||
+ runType == kLaserRunType ) {
TString pressureConf = fConfEnv->GetValue("Pressure","ON");
pressureConf.ToUpper();
- if (pressureConf != "OFF" ) {
- TClonesArray * array = new TClonesArray("AliDCSSensor",kNumPressureSensors);
+ if (pressureConf != "OFF" ) {
+ TClonesArray * array = new TClonesArray("AliDCSSensor",kNumPressureSensors);
for(Int_t j = 0; j < kNumPressureSensors; j++) {
AliDCSSensor * sens = new ((*array)[j])AliDCSSensor;
sens->SetStringID(kPressureSensorNames[j]);
//______________________________________________________________________________________________
UInt_t AliTPCPreprocessor::Process(TMap* dcsAliasMap)
{
- // Fills data into TPC calibrations objects
+ /// Fills data into TPC calibrations objects
// Amanda servers provide information directly through dcsAliasMap
-
+
if (!fConfigOK) return 9;
UInt_t result = 0;
TObjArray *resultArray = new TObjArray();
TObject * status;
UInt_t dcsResult=0;
- if (!dcsAliasMap) {
+ if (!dcsAliasMap) {
dcsResult=1;
} else {
if (dcsAliasMap->GetEntries() == 0 ) dcsResult=1;
- }
+ }
status = new TParameter<int>("dcsResult",dcsResult);
resultArray->Add(status);
TString hvConf = fConfEnv->GetValue("HighVoltage","ON");
hvConf.ToUpper();
- if (hvConf != "OFF" ) {
+ if (hvConf != "OFF" ) {
UInt_t hvResult = MapHighVoltage(dcsAliasMap);
if (hvConf != "TRY") result+=hvResult;
status = new TParameter<int>("hvResult",hvResult);
TString goofieConf = fConfEnv->GetValue("Goofie","ON");
goofieConf.ToUpper();
- if (goofieConf != "OFF" ) {
+ if (goofieConf != "OFF" ) {
UInt_t goofieResult = MapGoofie(dcsAliasMap);
if (goofieConf != "TRY") result+=goofieResult;
status = new TParameter<int>("goofieResult",goofieResult);
TString gasConf = fConfEnv->GetValue("GasComposition","OFF");
gasConf.ToUpper();
- if (gasConf != "OFF" ) {
+ if (gasConf != "OFF" ) {
UInt_t gasResult = MapGasComposition(dcsAliasMap);
if (gasConf != "TRY") result+=gasResult;
status = new TParameter<int>("gasResult",gasResult);
TString pressureConf = fConfEnv->GetValue("Pressure","ON");
pressureConf.ToUpper();
- if (pressureConf != "OFF" ) {
+ if (pressureConf != "OFF" ) {
UInt_t pressureResult = MapPressure(dcsAliasMap);
status = new TParameter<int>("pressureResult",pressureResult);
resultArray->Add(status);
Int_t pedestalSource[2] = {AliShuttleInterface::kDAQ,AliShuttleInterface::kHLT} ;
TString source = fConfEnv->GetValue("Pedestal","DAQ");
source.ToUpper();
- if (source != "OFF" ) {
+ if (source != "OFF" ) {
if ( source == "HLT") pedestalSource[0] = AliShuttleInterface::kHLT;
if (!GetHLTStatus()) pedestalSource[0] = AliShuttleInterface::kDAQ;
if (source == "HLTDAQ" ) {
}
if (source == "DAQHLT" ) numSources=2;
UInt_t pedestalResult=0;
- for (Int_t i=0; i<numSources; i++ ) {
+ for (Int_t i=0; i<numSources; i++ ) {
pedestalResult = ExtractPedestals(pedestalSource[i]);
if ( pedestalResult == 0 ) break;
}
Int_t pulserSource[2] = {AliShuttleInterface::kDAQ,AliShuttleInterface::kHLT} ;
TString source = fConfEnv->GetValue("Pulser","DAQ");
source.ToUpper();
- if ( source != "OFF") {
+ if ( source != "OFF") {
if ( source == "HLT") pulserSource[0] = AliShuttleInterface::kHLT;
if (!GetHLTStatus()) pulserSource[0] = AliShuttleInterface::kDAQ;
if (source == "HLTDAQ" ) {
if (source == "DAQHLT" ) numSources=2;
if (source == "TRY" ) numSources=1;
UInt_t pulserResult=0;
- for (Int_t i=0; i<numSources; i++ ) {
+ for (Int_t i=0; i<numSources; i++ ) {
pulserResult = ExtractPulser(pulserSource[i]);
if ( pulserResult == 0 ) break;
}
Int_t rawSource[2] = {AliShuttleInterface::kDAQ,AliShuttleInterface::kHLT} ;
TString source = fConfEnv->GetValue("Raw","DAQ");
source.ToUpper();
- if ( source != "OFF") {
+ if ( source != "OFF") {
if ( source == "HLT") rawSource[0] = AliShuttleInterface::kHLT;
if (!GetHLTStatus()) rawSource[0] = AliShuttleInterface::kDAQ;
if (source == "HLTDAQ" ) {
if (source == "DAQHLT" ) numSources=2;
if (source == "TRY" ) numSources=1;
UInt_t rawResult=0;
- for (Int_t i=0; i<numSources; i++ ) {
+ for (Int_t i=0; i<numSources; i++ ) {
rawResult = ExtractRaw(rawSource[i]);
if ( rawResult == 0 ) break;
}
TString altroConf = fConfEnv->GetValue("AltroConf","ON");
altroConf.ToUpper();
- if (altroConf != "OFF" ) {
+ if (altroConf != "OFF" ) {
UInt_t altroResult = ExtractAltro(AliShuttleInterface::kDCS,dcsAliasMap);
if (altroConf != "TRY" ) result+=altroResult;
status = new TParameter<int>("altroResult",altroResult);
// Central Electrode processing
- if( runType == kPhysicsRunType ||
- runType == kLaserRunType ) {
+ if( runType == kPhysicsRunType ||
+ runType == kLaserRunType ) {
Int_t numSources = 1;
Int_t ceSource[2] = {AliShuttleInterface::kDAQ,AliShuttleInterface::kHLT} ;
TString source = fConfEnv->GetValue("CE","DAQ");
source.ToUpper();
- if ( source != "OFF" ) {
+ if ( source != "OFF" ) {
if ( source == "HLT") ceSource[0] = AliShuttleInterface::kHLT;
if (!GetHLTStatus()) ceSource[0] = AliShuttleInterface::kDAQ;
if (source == "HLTDAQ" ) {
if (source == "DAQHLT" ) numSources=2;
if (source == "TRY" ) numSources=1;
UInt_t ceResult=0;
- for (Int_t i=0; i<numSources; i++ ) {
+ for (Int_t i=0; i<numSources; i++ ) {
ceResult = ExtractCE(ceSource[i]);
if ( ceResult == 0 ) break;
}
// only flag error if CE result is missing from LASER runs
// -- for PHYSICS run do CE processing if data available
-
+
if ( runType == kLaserRunType && source != "TRY" && ceResult<10 ) result += ceResult;
status = new TParameter<int>("ceResult",ceResult);
resultArray->Add(status);
Int_t qaSource[2] = {AliShuttleInterface::kDAQ,AliShuttleInterface::kHLT} ;
source = fConfEnv->GetValue("QA","DAQ");
source.ToUpper();
- if ( source != "OFF" ) {
+ if ( source != "OFF" ) {
if ( source == "HLT") qaSource[0] = AliShuttleInterface::kHLT;
if (!GetHLTStatus()) qaSource[0] = AliShuttleInterface::kDAQ;
if (source == "HLTDAQ" ) {
if (source == "DAQHLT" ) numSources=2;
if (source == "TRY" ) numSources=1;
UInt_t qaResult=0;
- for (Int_t i=0; i<numSources; i++ ) {
+ for (Int_t i=0; i<numSources; i++ ) {
qaResult = ExtractQA(qaSource[i]);
if ( qaResult == 0 ) break;
}
}
}
}
-
+
// Store component status to OCDB
AliCDBMetaData metaData;
metaData.SetComment("Preprocessor AliTPC status.");
Bool_t storeOK = Store("Calib", "PreprocStatus", resultArray, &metaData, 0, kFALSE);
if (!storeOK) Log ("Unable to store preprocessor status entry");
-
+
resultArray->Delete();
delete resultArray;
if (errorHandling == "OFF" ) return 0;
return result;
-
+
}
//______________________________________________________________________________________________
UInt_t AliTPCPreprocessor::MapTemperature(TMap* dcsAliasMap)
{
- // extract DCS temperature maps. Perform fits to save space
+ /// extract DCS temperature maps. Perform fits to save space
UInt_t result=0;
TMap *map = fTemp->ExtractDCS(dcsAliasMap);
if (map) {
fTemp->MakeSplineFit(map);
- Double_t fitFraction = 1.0*fTemp->NumFits()/fTemp->NumSensors();
+ Double_t fitFraction = 1.0*fTemp->NumFits()/fTemp->NumSensors();
if (fitFraction > kFitFraction ) {
AliInfo(Form("Temperature values extracted, fits performed.\n"));
- } else {
+ } else {
Log ("Too few temperature maps fitted. \n");
result = 9;
}
UInt_t AliTPCPreprocessor::MapPressure(TMap* dcsAliasMap)
{
- // extract DCS pressure maps. Perform fits to save space
+ /// extract DCS pressure maps. Perform fits to save space
UInt_t result=0;
TMap *map = fPressure->ExtractDCS(dcsAliasMap);
if (map) {
fPressure->MakeSplineFit(map);
- Double_t fitFraction = 1.0*fPressure->NumFits()/fPressure->NumSensors();
+ Double_t fitFraction = 1.0*fPressure->NumFits()/fPressure->NumSensors();
if (fitFraction > kFitFraction ) {
AliInfo(Form("Pressure values extracted, fits performed.\n"));
- } else {
+ } else {
Log ("Too few pressure maps fitted. \n");
result = 9;
}
UInt_t AliTPCPreprocessor::MapHighVoltage(TMap* dcsAliasMap)
{
- // extract DCS HV maps. Perform fits to save space
+ /// extract DCS HV maps. Perform fits to save space
UInt_t result=0;
TMap *map = fHighVoltage->ExtractDCS(dcsAliasMap);
TString hvStatConf = fConfEnv->GetValue("HighVoltageStat","ON");
hvStatConf.ToUpper();
- if (hvStatConf != "OFF" ) {
+ if (hvStatConf != "OFF" ) {
TMap *map2 = fHighVoltageStat->ExtractDCS(dcsAliasMap);
if (map2) {
fHighVoltageStat->ClearFit();
UInt_t AliTPCPreprocessor::MapGoofie(TMap* dcsAliasMap)
{
- // extract DCS Goofie maps. Do not perform fits (low update rate)
+ /// extract DCS Goofie maps. Do not perform fits (low update rate)
UInt_t result=0;
UInt_t AliTPCPreprocessor::MapGasComposition(TMap* dcsAliasMap)
{
- // extract DCS HV maps. Perform fits to save space
+ /// extract DCS HV maps. Perform fits to save space
UInt_t result=0;
TMap *map = fGasComposition->ExtractDCS(dcsAliasMap);
UInt_t AliTPCPreprocessor::ExtractPedestals(Int_t sourceFXS)
{
- //
- // Read pedestal file from file exchage server
- // Keep original entry from OCDB in case no new pedestals are available
- //
+ /// Read pedestal file from file exchage server
+ /// Keep original entry from OCDB in case no new pedestals are available
+
AliTPCCalPad *calPadPedOCDB=0;
AliCDBEntry* entry = GetFromOCDB("Calib", "Pedestals");
if (entry) calPadPedOCDB = (AliTPCCalPad*)entry->GetObject();
foundSectorsRMS=0;
TList* list = GetFileSources(sourceFXS,"pedestals");
-
+
if (list && list->GetEntries()>0) {
// loop through all files from LDCs
AliTPCCalROC* roc=calPadRMS->GetCalROC(sector);
roc->Add(rocRMS,1);
foundSectorsRMS[sector]++;
- }
+ }
}
- delete calPed;
+ delete calPed;
f->Close();
}
++index;
sector);
Log (message);
result = 2;
- }
+ }
}
}
sector);
Log (message);
result = 2;
- }
+ }
- }
+ }
}
-
+
//
// Store updated pedestal entry to OCDB
//
metaData.SetBeamPeriod(0);
metaData.SetResponsible("Haavard Helstrup");
metaData.SetAliRootVersion(ALIROOT_BRANCH);
- metaData.SetComment("Preprocessor AliTPC data base entries.");
-
+ metaData.SetComment("Preprocessor AliTPC data base entries.");
+
Bool_t storeOK = Store("Calib", "Pedestals", calPadPed, &metaData, 0, kTRUE);
if ( !storeOK ) ++result;
storeOK = Store("Calib", "PadNoise", calPadRMS, &metaData, 0, kTRUE);
UInt_t AliTPCPreprocessor::ExtractPulser(Int_t sourceFXS)
{
- //
- // Read pulser calibration file from file exchage server
- // Keep original entry from OCDB in case no new pulser calibration is available
- //
-
+ /// Read pulser calibration file from file exchage server
+ /// Keep original entry from OCDB in case no new pulser calibration is available
+
TObjArray *pulserObjects = new TObjArray;
- TObjArray *pulserObjectsOCDB=0;
-
+ TObjArray *pulserObjectsOCDB=0;
+
AliCDBEntry* entry = GetFromOCDB("Calib", "Pulser");
if (entry) pulserObjectsOCDB = (TObjArray*)entry->GetObject();
if ( pulserObjectsOCDB==NULL ) {
AliTPCCalPad *pulserTmean = new AliTPCCalPad("PulserTmean","PulserTmean");
pulserObjects->Add(pulserTmean);
-
+
AliTPCCalPad *pulserTrms = new AliTPCCalPad("PulserTrms","PulserTrms");
pulserObjects->Add(pulserTrms);
-
+
AliTPCCalPad *pulserQmean = new AliTPCCalPad("PulserQmean","PulserQmean");
pulserObjects->Add(pulserQmean);
-
+
UInt_t result=0;
TList* list = GetFileSources(sourceFXS,"pulser");
-
+
if (list && list->GetEntries()>0) {
// loop through all files from LDCs
AliTPCCalPad* pulserTmeanOCDB = (AliTPCCalPad*)pulserObjectsOCDB->FindObject("PulserTmean");
AliTPCCalPad* pulserTrmsOCDB = (AliTPCCalPad*)pulserObjectsOCDB->FindObject("PulserTrms");
AliTPCCalPad* pulserQmeanOCDB = (AliTPCCalPad*)pulserObjectsOCDB->FindObject("PulserQmean");
-
+
//
// Check if calibration is complete -- otherwise take from old OCDB entry
}
}
}
-
+
// outer sectors -- two updates needed
for (Int_t sector=0; sector<nSectors/2; sector++) {
Bool_t storeOK = Store("Calib", "Pulser", pulserObjects, &metaData, 0, kTRUE);
if ( !storeOK ) ++result;
- }
+ }
} else {
Log ("Error: no entries in pulser file list!");
result = 1;
UInt_t AliTPCPreprocessor::ExtractRaw(Int_t sourceFXS)
{
- //
- // Read Raw calibration file from file exchage server
- //
-
+ /// Read Raw calibration file from file exchage server
+
UInt_t result=0;
TObjArray* rawArray = new TObjArray;
TList* list = GetFileSources(sourceFXS,"tpcCalibRaw");
-
+
if (list && list->GetEntries()>0) {
// loop through all files
Log ("Error: no entries in raw file list!");
result = 1;
}
-
+
rawArray->Delete();
delete rawArray;
UInt_t AliTPCPreprocessor::ExtractCE(Int_t sourceFXS)
{
- //
- // Read Central Electrode file from file exchage server
- //
- //
+ /// Read Central Electrode file from file exchage server
+
AliTPCCalPad *ceTmean=0;
AliTPCCalPad *ceTrms=0;
AliTPCCalPad *ceQmean=0;
TObjArray *rocTtime=0;
TObjArray *rocQtime=0;
-
+
TObjArray *ceObjects= new TObjArray;
-
-
+
+
Int_t nSectors = fROC->GetNSectors();
-
+
ceTmean = new AliTPCCalPad("CETmean","CETmean");
ceObjects->Add(ceTmean);
-
+
ceTrms = new AliTPCCalPad("CETrms","CETrms");
ceObjects->Add(ceTrms);
-
+
ceQmean = new AliTPCCalPad("CEQmean","CEQmean");
ceObjects->Add(ceQmean);
-
+
rocTtime = new TObjArray(nSectors+2); // also make room for A and C side average
rocTtime->SetName("rocTtime");
ceObjects->Add(rocTtime);
-
+
rocQtime = new TObjArray(nSectors);
rocQtime->SetName("rocQtime");
ceObjects->Add(rocQtime);
TObjArray *arrFitGraphs=new TObjArray;
arrFitGraphs->SetName("ceFitsDrift");
ceObjects->Add(arrFitGraphs);
-
-// Temperature maps
-
+
+// Temperature maps
+
if (fTemp) {
AliTPCSensorTempArray *tempMap = new AliTPCSensorTempArray(*fTemp);
tempMap->SetNameTitle("TempMap","TempMap");
ceObjects->Add(tempMap);
}
-
+
// Pressure maps
-
+
if (fPressure) {
AliDCSSensor *sensor=0, *sensorCopy=0;
for (Int_t isensor=0; isensor<kNumPressureSensors; ++isensor ) {
}
}
}
-
+
UInt_t result=0;
-
+
TList* list = GetFileSources(sourceFXS,"CE");
-
+
if (list && list->GetEntries()>0) {
-
+
// loop through all files from LDCs
-
+
UInt_t index = 0;
while (list->At(index)!=NULL) {
TObjString* fileNameEntry = (TObjString*) list->At(index);
if (fileNameEntry!=NULL) {
TString fileName = GetFile(sourceFXS, "CE",
fileNameEntry->GetString().Data());
- AliTPCCalibCE *calCE=AliTPCCalibCE::ReadFromFile(fileName.Data());
-
+ AliTPCCalibCE *calCE=AliTPCCalibCE::ReadFromFile(fileName.Data());
+
if (!calCE) {
Log ("No valid calibCE object.");
result=2;
break;
}
// replace entries for the sectors available in the present file
-
+
for (Int_t sector=0; sector<nSectors; sector++) {
AliTPCCalROC *rocTmean=calCE->GetCalRocT0(sector);
if ( rocTmean ) ceTmean->SetCalROC(rocTmean,sector);
TGraph *grQ=calCE->MakeGraphTimeCE(sector,0,3); // Q time graph
if ( grQ ) rocQtime->AddAt(grQ,sector);
}
-
+
TGraph *grT=calCE->MakeGraphTimeCE(-1,0,2); // A side average
if ( grT ) {
rocTtime->AddAt(grT,nSectors);
} // while(list)
//
// Check number of calibrated sectors per side
-//
+//
Int_t aside=0, cside=0;
for (Int_t ind=0; ind<nSectors/4; ind++ ) {
TGraph *grT=(TGraph*)rocTtime->At(ind);
// currently its only processed if there is a valid standard CE object
//
list = GetFileSources(sourceFXS,"CEnew");
-
+
if (result==0 && list && list->GetEntries()>0) {
-
+
// loop through all files from LDCs
-
+
UInt_t index2 = 0;
while (list->At(index2)!=NULL) {
TObjString* fileNameEntry = (TObjString*) list->At(index2);
if (fileNameEntry!=NULL) {
TString fileName = GetFile(sourceFXS, "CEnew",
fileNameEntry->GetString().Data());
- AliTPCCalibCE *calCE=AliTPCCalibCE::ReadFromFile(fileName.Data());
-
+ AliTPCCalibCE *calCE=AliTPCCalibCE::ReadFromFile(fileName.Data());
+
if (!calCE) {
Log ("No valid new calibCE object.");
// result=2;
++index2;
}
}
-
+
//
// Store updated pedestal entry to OCDB
//
metaData.SetResponsible("Haavard Helstrup");
metaData.SetAliRootVersion(ALIROOT_BRANCH);
metaData.SetComment("Preprocessor AliTPC data base entries.");
-
+
if ( result == 0 ) {
Bool_t storeOK = Store("Calib", "CE", ceObjects, &metaData, 0, kTRUE);
if ( !storeOK ) ++result;
Log ("Error: no CE entries available from FXS!");
result = 1;
}
-
+
ceObjects->Delete();
delete ceObjects;
-
+
return result;
}
//______________________________________________________________________________________________
UInt_t AliTPCPreprocessor::ExtractQA(Int_t sourceFXS)
{
- //
- // Read Quality Assurance file from file exchage server
- //
-
+ /// Read Quality Assurance file from file exchage server
+
UInt_t result=0;
TList* list = GetFileSources(sourceFXS,"QA");
-
+
if (list && list->GetEntries()>0) {
// only one QA object should be available!
AliTPCdataQA *calQA;
- UInt_t nentries = list->GetEntries();
+ UInt_t nentries = list->GetEntries();
UInt_t index=0;
- if ( nentries > 1) Log ( "More than one QA entry. First one processed");
+ if ( nentries > 1) Log ( "More than one QA entry. First one processed");
TObjString* fileNameEntry = (TObjString*) list->At(index);
if (fileNameEntry!=NULL) {
TString fileName = GetFile(sourceFXS, "QA",
TFile *f = TFile::Open(fileName);
if (!f) {
Log ("Error opening QA file.");
- result =2;
+ result =2;
} else {
f->GetObject("tpcCalibQA",calQA);
- if ( calQA ) {
+ if ( calQA ) {
//
// Store updated pedestal entry to OCDB
//
UInt_t AliTPCPreprocessor::ExtractAltro(Int_t sourceFXS, TMap* dcsMap)
{
- //
- // Read Altro configuration file from file exchage server
- // Keep original entry from OCDB in case no new pulser calibration is available
- //
+ /// Read Altro configuration file from file exchage server
+ /// Keep original entry from OCDB in case no new pulser calibration is available
+
TObjArray *altroObjects=0;
AliTPCCalPad *acqStart=0;
AliTPCCalPad *zsThr=0;
if (entry) altroObjects = (TObjArray*)entry->GetObject();
if ( altroObjects==NULL ) {
Log("AliTPCPreprocsessor: No previous TPC altro calibration entry available.\n");
- altroObjects = new TObjArray;
+ altroObjects = new TObjArray;
}
acqStart = (AliTPCCalPad*)altroObjects->FindObject("AcqStart");
altroObjects->Add(acqStart);
}
zsThr = (AliTPCCalPad*)altroObjects->FindObject("ZsThr");
- if ( !zsThr ) {
+ if ( !zsThr ) {
zsThr = new AliTPCCalPad("ZsThr","ZsThr");
altroObjects->Add(zsThr);
}
FPED = (AliTPCCalPad*)altroObjects->FindObject("FPED");
- if ( !FPED ) {
+ if ( !FPED ) {
FPED = new AliTPCCalPad("FPED","FPED");
altroObjects->Add(FPED);
}
altroObjects->Add(acqStop);
}
masked = (AliTPCCalPad*)altroObjects->FindObject("Masked");
- if ( !masked ) {
+ if ( !masked ) {
masked = new AliTPCCalPad("Masked","Masked");
altroObjects->Add(masked);
}
k1 = (AliTPCCalPad*)altroObjects->FindObject("K1");
- if ( !k1 ) {
+ if ( !k1 ) {
k1 = new AliTPCCalPad("K1","K1");
altroObjects->Add(k1);
}
k2 = (AliTPCCalPad*)altroObjects->FindObject("K2");
- if ( !k2 ) {
+ if ( !k2 ) {
k2 = new AliTPCCalPad("K2","K2");
altroObjects->Add(k2);
}
k3 = (AliTPCCalPad*)altroObjects->FindObject("K3");
- if ( !k3 ) {
+ if ( !k3 ) {
k3 = new AliTPCCalPad("K3","K3");
altroObjects->Add(k3);
}
l1 = (AliTPCCalPad*)altroObjects->FindObject("L1");
- if ( !l1 ) {
+ if ( !l1 ) {
l1 = new AliTPCCalPad("L1","L1");
altroObjects->Add(l1);
}
l2 = (AliTPCCalPad*)altroObjects->FindObject("L2");
- if ( !l2 ) {
+ if ( !l2 ) {
l2 = new AliTPCCalPad("L2","L2");
altroObjects->Add(l2);
}
l3 = (AliTPCCalPad*)altroObjects->FindObject("L3");
- if ( !l3 ) {
+ if ( !l3 ) {
l3 = new AliTPCCalPad("L3","L3");
altroObjects->Add(l3);
}
// extract list of active DDLs
if (dcsMap) {
- Bool_t found;
+ Bool_t found;
TString arrDDL(kNumDDL);
arrDDL.Append('x',kNumDDL);
for ( Int_t iDDL = 0; iDDL<kNumDDL; iDDL++ ) {
found = false;
if ( pair ) {
TObjArray *valueSet=(TObjArray*)pair->Value();
- if ( valueSet) {
+ if ( valueSet) {
AliDCSValue *val = (AliDCSValue*)valueSet->At(0);
- if (val) {
+ if (val) {
found = val->GetBool();
if (found){
arrDDL[iDDL] = '1';
- } else {
+ } else {
arrDDL[iDDL] = '0';
}
- }
+ }
}
- }
+ }
}
TObjString *ddlArray = new TObjString;
ddlArray->SetString(arrDDL);
} else {
Log ("ExtractAltro: No DCS map available. Active DDL list cannot be obtained.");
result = 3;
- }
+ }
// extract Altro configuration files
for ( Int_t id=0; id<2; id++) {
TList* list = GetFileSources(sourceFXS,idFXS[id].Data());
-
+
if (list && list->GetEntries()>0) {
// loop through all files from LDCs
AliTPCCalPad *l3FXS=(AliTPCCalPad*)altroFXS->FindObject("L3");
TMap *mapRCUconfigFXS = (TMap*)altroFXS->FindObject("RCUconfig");
TIterator *mapFXSiter = mapRCUconfigFXS->MakeIterator();
-
+
changed=true;
for (Int_t sector=0; sector<nSectors; sector++) {
-
+
if (acqStartFXS) {
AliTPCCalROC *rocAcqStart=acqStartFXS->GetCalROC(sector);
if ( rocAcqStart ) acqStart->SetCalROC(rocAcqStart,sector);
Bool_t storeOK = Store("Calib", "AltroConfig", altroObjects, &metaData, 0, kFALSE);
if ( !storeOK ) ++result;
- }
+ }
altroObjects->Delete();
delete altroObjects;
-
+
return result;
}
#include "AliPreprocessor.h"
-// test preprocessor that writes data to AliTestDataDCS
+/// \class AliTPCPreprocessor
+/// \brief test preprocessor that writes data to AliTestDataDCS
class AliTestDataDCS;
class AliTPCSensorTempArray;
AliTPCPreprocessor& operator = (const AliTPCPreprocessor& rhs);
private:
- TEnv *fConfEnv; // Preprocessor configuration map
- AliTPCSensorTempArray *fTemp; // CDB class for temperature sensors
- AliDCSSensorArray *fHighVoltage; // DCS high voltage measurements
- AliDCSSensorArray *fHighVoltageStat; // DCS high voltage status
- AliDCSSensorArray *fGoofie; // Goofie values from DCS
- AliDCSSensorArray *fPressure; // Pressure values from DCS
- AliDCSSensorArray *fGasComposition; // Gas composition values from DCS
- Bool_t fConfigOK; // Identify succesful reading of OCDB Config
- AliTPCROC *fROC; // TPC Read-Out configuration
-
+ TEnv *fConfEnv; ///< Preprocessor configuration map
+ AliTPCSensorTempArray *fTemp; ///< CDB class for temperature sensors
+ AliDCSSensorArray *fHighVoltage; ///< DCS high voltage measurements
+ AliDCSSensorArray *fHighVoltageStat; ///< DCS high voltage status
+ AliDCSSensorArray *fGoofie; ///< Goofie values from DCS
+ AliDCSSensorArray *fPressure; ///< Pressure values from DCS
+ AliDCSSensorArray *fGasComposition; ///< Gas composition values from DCS
+ Bool_t fConfigOK; ///< Identify succesful reading of OCDB Config
+ AliTPCROC *fROC; ///< TPC Read-Out configuration
+
+ /// \cond CLASSIMP
ClassDef(AliTPCPreprocessor, 4)
+ /// \endcond
};
#endif
**************************************************************************/
-////////////////////////////////////////////////////////////////////////////////
-// //
-// Preprocessor class for HLT and DAQ //
-// Possible usage: preprocess TPC calibration data //
-// to form needed for online viewing/visualizing TPC calibration data //
-// //
-// On HLT or DAQ AliTPCPreprocessorOnline::AddComponent(...) is called, //
-// whereas ... is either an AliTPCCalPad, or an AliTPCCalROC. //
-// Their names have to be acording the naming convention for AliTPCCalPads //
-// Special for CalROCs: Add '_ROC<ROC_Number>' to the name. //
-// //
-// Internal the AliTPCCalPads are stored in a TMap, they are retrieved by //
-// their name. //
-// //
-// Once enough values are accumulated, call ::DumpToFile(fileName). //
-// A TObjArray is created out of the TMap, which is passed to //
-// AliTPCCalibViewer::MakeTree(...) and the calibratioTree is written //
-// is written to "filenName".
-//
-// The data flow is as follows:
-/*
-Begin_Html
- <img src="../TPC/doc/dataFlowCalibViewer.png">
-End_Html
-*/
-// //
-// //
-////////////////////////////////////////////////////////////////////////////////
-
-//
-// ROOT includes
+/// \class AliTPCPreprocessorOnline
+/// \brief Preprocessor class for HLT and DAQ
+///
+/// Possible usage: preprocess TPC calibration data
+/// to form needed for online viewing/visualizing TPC calibration data
+///
+/// On HLT or DAQ AliTPCPreprocessorOnline::AddComponent(...) is called,
+/// whereas ... is either an AliTPCCalPad, or an AliTPCCalROC.
+/// Their names have to be acording the naming convention for AliTPCCalPads
+/// Special for CalROCs: Add '_ROC<ROC_Number>' to the name.
+///
+/// Internal the AliTPCCalPads are stored in a TMap, they are retrieved by
+/// their name.
+///
+/// Once enough values are accumulated, call ::DumpToFile(fileName).
+/// A TObjArray is created out of the TMap, which is passed to
+/// AliTPCCalibViewer::MakeTree(...) and the calibratioTree is written
+/// is written to "filenName".
+
+//
+// ROOT includes
//
#include <TObject.h>
#include <iostream>
+/// \cond CLASSIMP
ClassImp(AliTPCPreprocessorOnline)
+/// \endcond
AliTPCPreprocessorOnline::AliTPCPreprocessorOnline():TObject(), fMap(0)
{
//_____________________________________________________________________________
AliTPCPreprocessorOnline::AliTPCPreprocessorOnline(const AliTPCPreprocessorOnline &c):TObject(c), fMap(0)
{
- //
- // dummy AliTPCPreprocessorOnline copy constructor
- // not yet working!!!
- //
+ /// dummy AliTPCPreprocessorOnline copy constructor
+ /// not yet working!!!
+
fMap = c.fMap;
printf("AliTPCPreprocessorOnline's copy constructor called, NOT WORKING!!!\n");
}
//_____________________________________________________________________________
AliTPCPreprocessorOnline::AliTPCPreprocessorOnline(TMap *map):TObject(), fMap(0)
{
- //
- // Constructor to "copy" the AliTPCPreprocessorOnline
- //
+ /// Constructor to "copy" the AliTPCPreprocessorOnline
+
fMap = map;
}
//____________________________________________________________________________
AliTPCPreprocessorOnline & AliTPCPreprocessorOnline::operator =(const AliTPCPreprocessorOnline & param){
- //
- // assignment operator - dummy
- // not yet working!!!
- //
+ /// assignment operator - dummy
+ /// not yet working!!!
+
if (this == ¶m) return (*this);
fMap = param.fMap;
//_____________________________________________________________________________
AliTPCPreprocessorOnline::~AliTPCPreprocessorOnline()
{
- //
- // AliTPCPreprocessorOnline destructor
- //
+ /// AliTPCPreprocessorOnline destructor
+
printf("AliTPCPreprocessorOnline's destructor called. \n");
fMap->DeleteValues();
delete fMap;
void AliTPCPreprocessorOnline::AddComponent(TObject *obj) {
- //
- // Add components form HLT or DAQ here
- // The components are either AliTPCCalPads or AliTPCCalROCs
- // other to be defined
- //
- // As from HLT they will come ROC wise, they have to be set together to one AliTPCCalPad here
- // Then they are added to the Calibration Tree
- // This calibration tree will be written by AliTPCCalibViewer::MakeTree, once you call ::DumpToFile(fileName)
- //
- // To distinguish, what kind of component is added, there is a Naming-Convention:
- // The normal, already definded naming-Convention for AliTPCCalPads <PadName>
- // <padName>_ROC<ROC_Number> for example: "CEQmean_ROC34"
- //
- //
- // Get name of obj
- // Check, if it ends with "_ROC<Int_t>" / check, if it contains "ROC"
- // If it contains "ROC", find out, to which calibration CalPad it belongs -> Parse first part of the name
- // Get the corsponding AliTPCCalPad / Make a new AliTPCCalPad
- // Set "_ROC<Int_t>" to zero /? delete it -> Set the new values, out of obj
- //
-
-
+ /// Add components form HLT or DAQ here
+ /// The components are either AliTPCCalPads or AliTPCCalROCs
+ /// other to be defined
+ ///
+ /// As from HLT they will come ROC wise, they have to be set together to one AliTPCCalPad here
+ /// Then they are added to the Calibration Tree
+ /// This calibration tree will be written by AliTPCCalibViewer::MakeTree, once you call ::DumpToFile(fileName)
+ ///
+ /// To distinguish, what kind of component is added, there is a Naming-Convention:
+ /// The normal, already definded naming-Convention for AliTPCCalPads <PadName>
+ /// <padName>_ROC<ROC_Number> for example: "CEQmean_ROC34"
+ ///
+ /// Get name of obj
+ /// Check, if it ends with "_ROC<Int_t>" / check, if it contains "ROC"
+ /// If it contains "ROC", find out, to which calibration CalPad it belongs -> Parse first part of the name
+ /// Get the corsponding AliTPCCalPad / Make a new AliTPCCalPad
+ /// Set "_ROC<Int_t>" to zero /? delete it -> Set the new values, out of obj
+
+
// printf(" ****** AliTPCPreprocessorOnline::AddComponent ****** \n");
if (!obj) return;
TString objName = obj->GetName();
-
+
// Add a whole AliTPCCalPad to the list
if (TString(obj->ClassName()) == "AliTPCCalPad") {
// printf("AliTPCCalPad found\n");
return;
}
// current data already present
- if (TString(listObj->ClassName()) != "AliTPCCalPad")
+ if (TString(listObj->ClassName()) != "AliTPCCalPad")
Error("AddComponent", "Mismatch in internal list: '%s' is no AliTPCCalPad. \n", listObj->ClassName());
AliTPCCalPad *listCalPad = (AliTPCCalPad*)listObj;
listCalPad->Add(listCalPad, -1); // reset the current CalPad
listCalPad->Add(calPad);
return;
}
-
+
if (TString(obj->ClassName()) == "AliTPCCalROC") {
// printf("AliTPCCalROC found\n");
if (! objName.Contains("_ROC"))
Warning("AddComponent", "Uncomplete object name: '%s' is missing _ROC<ROC_number>\n", objName.Data());
TObjArray *stokens = objName.Tokenize("_ROC");
- TString rocNumber("");
+ TString rocNumber("");
if (stokens->GetEntriesFast()>1) rocNumber = ((TObjString*)stokens->At(1))->GetString();
delete stokens;
Int_t iroc = -1;
if (rocNumber.IsAlnum()) iroc = rocNumber.Atoi();
-
+
// Extract CalPad Name:
TString removeString("_ROC");
removeString += rocNumber;
objName.ReplaceAll(removeString, ""); // Remove "_ROC<number>" from the end
-
+
// objName is cleaned and can now be used to extract the coresponding CalPad from the list
TObject *listObj = fMap->GetValue(objName.Data());
AliTPCCalROC *calROC = (AliTPCCalROC*)obj;
if (iroc == -1) iroc = calROC->GetSector();
- if (iroc != (Int_t)calROC->GetSector())
+ if (iroc != (Int_t)calROC->GetSector())
Warning("AddComponent","Mismatch in ROC_number: ROC has number %i, in its name %i was specified. Treating now as %i. \n", calROC->GetSector(), iroc, iroc);
calROC->SetNameTitle(objName.Data(), objName.Data());
if (listObj == 0) {
return;
}
// current data already present
- if (TString(listObj->ClassName()) != "AliTPCCalPad")
+ if (TString(listObj->ClassName()) != "AliTPCCalPad")
Error("AddComponent", "Mismatch in internal list: '%s' is no AliTPCCalPad \n", listObj->ClassName());
AliTPCCalPad *listCalPad = (AliTPCCalPad*)listObj;
listCalPad->SetCalROC(calROC, iroc);
return;
-
-
+
+
}
-
+
Warning("AddComponent", "Unknown calibration object '%s', skipped.\n", obj->ClassName());
-
+
return;
-
-
+
+
}
void AliTPCPreprocessorOnline::DumpToFile(const char* fileName){
- //
- // Function to dump the tree to file
- // A TObjArray is created out of the TMap, which is passed to
- // AliTPCCalibViewer::MakeTree(...)
- //
-
+ /// Function to dump the tree to file
+ /// A TObjArray is created out of the TMap, which is passed to
+ /// AliTPCCalibViewer::MakeTree(...)
+
printf("AliTPCPreprocessorOnline::DumpToFile\n");
TObjArray *listOfCalPads = new TObjArray();
TIterator *iterator = fMap->MakeIterator();
printf("writing the tree... \n");
// AliTPCCalibViewer::MakeTree(fileName, listOfCalPads, "$ALICE_ROOT/TPC/Calib/MapCalibrationObjects.root");
AliTPCCalibViewer::MakeTree(fileName, listOfCalPads, 0);
-
+
}
/* $Id: AliTPCPreprocessorOnline.h,v */
-////////////////////////////////////////////////////////////////////////////////
-// //
-// Preprocessor class for HLT and DAQ //
-// Possible usage: preprocess TPC calibration data //
-// //
-////////////////////////////////////////////////////////////////////////////////
+/// \class AliTPCPreprocessorOnline
+/// \brief Preprocessor class for HLT and DAQ
+///
+/// Possible usage: preprocess TPC calibration data
class AliTPCCalPad;
AliTPCPreprocessorOnline(TMap *map);
AliTPCPreprocessorOnline &operator = (const AliTPCPreprocessorOnline & param);
virtual ~AliTPCPreprocessorOnline();
-
+
void AddComponent(TObject *obj);
void DumpToFile(const char* fileName);
-
+
TMap *GetMap() {return fMap; } // for debugging
-
-
+
+
protected:
- TMap *fMap; // Map of the AliTPCCalPads
-
+ TMap *fMap; ///< Map of the AliTPCCalPads
+
+ /// \cond CLASSIMP
ClassDef(AliTPCPreprocessorOnline,1) // TPC preprocessor class
+ /// \endcond
};
#endif
* provided "as is" without express or implied warranty. *
**************************************************************************/
-/* $Id: $ */
-/*
- Checks implemented a la AliMUONQAChecker.
- Checks the quality assurance by realzed checks on histogram content.
- P. Christiansen, Lund, September 2009.
-
- Based on AliPHOSQAChecker.
- Checks the quality assurance by comparing with reference data.
- P. Christiansen, Lund, January 2008.
-*/
+/// \class AliTPCQAChecker
+/// \brief Checks implemented a la AliMUONQAChecker.
+///
+/// Checks the quality assurance by realzed checks on histogram content.
+///
+/// Based on AliPHOSQAChecker.
+/// Checks the quality assurance by comparing with reference data.
+///
+/// \author P. Christiansen, Lund
+/// \date January 2008 - September 2009.
// --- ROOT header files ---
#include <TH1.h>
#include "AliTPCQAChecker.h"
#include "AliTPCQADataMakerRec.h"
+/// \cond CLASSIMP
ClassImp(AliTPCQAChecker)
+/// \endcond
//__________________________________________________________________
AliTPCQAChecker& AliTPCQAChecker::operator = (const AliTPCQAChecker &checker)
{
- // Equal operator.
+ /// Equal operator.
+
this->~AliTPCQAChecker();
new(this) AliTPCQAChecker(checker);
- return *this;
+ return *this;
}
//__________________________________________________________________
void
-AliTPCQAChecker::Check(Double_t * rv, AliQAv1::ALITASK_t index, TObjArray ** list,
+AliTPCQAChecker::Check(Double_t * rv, AliQAv1::ALITASK_t index, TObjArray ** list,
const AliDetectorRecoParam * /*recoParam*/)
{
- /* It is important to understand the destinction between indexed tasks (AliQAv1::TASKINDEX_t) which are used in the DataMaker classes and indexed tasks (AliQAv1::ALITASK_t) whihc are used in the checker class.
-
- From the AliQAChecker::Run() methods we have:
- AliQAv1::kRAW
- - AliQAv1::kRAWS
-
- AliQAv1::kSIM
- - AliQAv1::kHITS
- - AliQAv1::kSDIGITS
- - AliQAv1::kDIGITS
-
- AliQAv1::kREC
- - AliQAv1::kDIGITSR
- - AliQAv1::kRECPOINTS
- - AliQAv1::kTRACKSEGMENTS
- - AliQAv1::kRECPARTICLES
-
- AliQAv1::kESD ;
- -AliQAv1::kESDS
-
- This means that for each group of tasks the Check will be called
- one or more times. This also mean that we cannot know what
- histograms will be or not be there in a single call... And we
- also do not know the position in the list of the histogram.
- */
-
+ /// It is important to understand the destinction between indexed tasks (AliQAv1::TASKINDEX_t) which are used in the DataMaker classes and indexed tasks (AliQAv1::ALITASK_t) whihc are used in the checker class.
+ ///
+ /// From the AliQAChecker::Run() methods we have:
+ /// AliQAv1::kRAW
+ /// - AliQAv1::kRAWS
+ ///
+ /// AliQAv1::kSIM
+ /// - AliQAv1::kHITS
+ /// - AliQAv1::kSDIGITS
+ /// - AliQAv1::kDIGITS
+ ///
+ /// AliQAv1::kREC
+ /// - AliQAv1::kDIGITSR
+ /// - AliQAv1::kRECPOINTS
+ /// - AliQAv1::kTRACKSEGMENTS
+ /// - AliQAv1::kRECPARTICLES
+ ///
+ /// AliQAv1::kESD ;
+ /// -AliQAv1::kESDS
+ ///
+ /// This means that for each group of tasks the Check will be called
+ /// one or more times. This also mean that we cannot know what
+ /// histograms will be or not be there in a single call... And we
+ /// also do not know the position in the list of the histogram.
+
/// Check objects in list
if(fDebug>0)
AliInfo("In AliTPCQAChecker::Check");
-
+
if (index!=AliQAv1::kRAW&&index!=AliQAv1::kSIM&&index!=AliQAv1::kREC&&index!=AliQAv1::kESD) {
-
+
AliWarning(Form("Checker for task %d not implement for the moment",index));
return;
}
-
- for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++)
- rv[specie] = 1.0; // All is fine
-
+
+ for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++)
+ rv[specie] = 1.0; // All is fine
+
for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) {
-
- if ( !AliQAv1::Instance()->IsEventSpecieSet(specie) )
- continue ;
-
+
+ if ( !AliQAv1::Instance()->IsEventSpecieSet(specie) )
+ continue ;
+
if (index == AliQAv1::kRAW)
rv[specie] = CheckRAW(specie, list[specie]);
if (index == AliQAv1::kSIM)
rv[specie] = CheckESD(specie, list[specie]);
if(fDebug>3)
- AliInfo(Form("Specie: %s. Task: %s. Value: %f",
+ AliInfo(Form("Specie: %s. Task: %s. Value: %f",
AliRecoParam::GetEventSpecieName(specie),
AliQAv1::GetAliTaskName(index),
rv[specie]));
Double_t AliTPCQAChecker::CheckRAW(Int_t specie, TObjArray* list)
{
/// Check ESD
+
if(fDebug>0)
AliInfo("In AliTPCQAChecker::CheckRAW");
-
+
if(fDebug>2)
list->Print();
(list->FindObject(Form("%s_hRawsOccupancyVsSector",AliRecoParam::GetEventSpecieName(specie))));
TH1* hRawsQmaxVsSector = static_cast<TH1*>
(list->FindObject(Form("%s_hRawsQmaxVsSector",AliRecoParam::GetEventSpecieName(specie))));
-
+
if (!hRawsOccupancyVsSector || !hRawsQmaxVsSector)
return -0.5; // fatal
-
+
if(hRawsOccupancyVsSector->GetEntries()==0) {
return 0.25; // error - No TPC data!
}
-
+
Int_t nBinsX = hRawsOccupancyVsSector->GetNbinsX();
for(Int_t i = 1; i <= nBinsX; i++) {
-
+
if(hRawsOccupancyVsSector->GetBinContent(i)==0)
return 0.75; // warning - no TPC data for at least one sector
}
-
+
return 1.0; // ok
}
//______________________________________________________________________________
Double_t AliTPCQAChecker::CheckSIM(Int_t specie, TObjArray* list)
{
- // This method checks the QA histograms associated with simulation
- //
- // For TPC this is:
- // Digits :
- // The digit histogram gives the ADC distribution for all sigbnals
- // above threshold. The check is just that there are digits.
- // Hits : The hit histograms are checked to see that they are not
- // empty. They contain a lot of detailed information on the
- // energyloss model (they were used to debug the AliRoot TPC use of
- // FLUKA).
- //
- // The check methods are simple:
- // We do not know if it is bad that histograms are missing because
- // this will always be the case for summable digits. So this check
- // is not possible here.
- // If digit histogram is empty (set error)
- // If one of the hit histograms are empty (set error)
+ /// This method checks the QA histograms associated with simulation
+ ///
+ /// For TPC this is:
+ /// Digits :
+ /// The digit histogram gives the ADC distribution for all sigbnals
+ /// above threshold. The check is just that there are digits.
+ /// Hits : The hit histograms are checked to see that they are not
+ /// empty. They contain a lot of detailed information on the
+ /// energyloss model (they were used to debug the AliRoot TPC use of
+ /// FLUKA).
+ ///
+ /// The check methods are simple:
+ /// We do not know if it is bad that histograms are missing because
+ /// this will always be the case for summable digits. So this check
+ /// is not possible here.
+ /// If digit histogram is empty (set error)
+ /// If one of the hit histograms are empty (set error)
+
if(fDebug>0)
AliInfo("In AliTPCQAChecker::CheckSIM");
-
+
if(fDebug>2)
list->Print();
TH1* hDigits = static_cast<TH1*>
(list->FindObject(Form("%s_hDigitsADC",AliRecoParam::GetEventSpecieName(specie))));
- TH1* hHitsNhits = static_cast<TH1*>
+ TH1* hHitsNhits = static_cast<TH1*>
(list->FindObject(Form("%s_hHitsNhits",AliRecoParam::GetEventSpecieName(specie))));
- TH1* hHitsElectrons = static_cast<TH1*>
+ TH1* hHitsElectrons = static_cast<TH1*>
(list->FindObject(Form("%s_hHitsElectrons",AliRecoParam::GetEventSpecieName(specie))));
- TH1* hHitsRadius = static_cast<TH1*>
+ TH1* hHitsRadius = static_cast<TH1*>
(list->FindObject(Form("%s_hHitsRadius",AliRecoParam::GetEventSpecieName(specie))));
- TH1* histHitsPrimPerCm = static_cast<TH1*>
+ TH1* histHitsPrimPerCm = static_cast<TH1*>
(list->FindObject(Form("%s_histHitsPrimPerCm",AliRecoParam::GetEventSpecieName(specie))));
- TH1* histHitsElectronsPerCm = static_cast<TH1*>
+ TH1* histHitsElectronsPerCm = static_cast<TH1*>
(list->FindObject(Form("%s_histHitsElectronsPerCm",AliRecoParam::GetEventSpecieName(specie))));
-
+
// if (!(hDigits) || // digit hists
// !(hHitsNhits && hHitsElectrons && hHitsRadius && histHitsPrimPerCm && histHitsElectronsPerCm)) // hit hists
// return -0.5; // fatal
-
+
if (hDigits) {
- if(hDigits->GetEntries()==0)
+ if(hDigits->GetEntries()==0)
return 0.25; // error
}
- if (hHitsNhits && hHitsElectrons && hHitsRadius &&
+ if (hHitsNhits && hHitsElectrons && hHitsRadius &&
histHitsPrimPerCm && histHitsElectronsPerCm) {
if (hHitsNhits->GetEntries()==0 || hHitsElectrons->GetEntries()==0 ||
hHitsRadius->GetEntries()==0 || histHitsPrimPerCm->GetEntries()==0 ||
- histHitsElectronsPerCm->GetEntries()==0)
+ histHitsElectronsPerCm->GetEntries()==0)
return 0.25; // error
}
//______________________________________________________________________________
Double_t AliTPCQAChecker::CheckREC(Int_t specie, TObjArray* list)
{
- // This method checks the QA histograms associated with reconstruction
- //
- // For TPC this is:
- // DigitsR :
- // The digit histogram gives the ADC distribution for all sigbnals
- // above threshold. The check is just that there are digits.
- // RecPoints :
- // The cluster histograms are meant to give an idea about the gain
- // from the cluster charge and to indicate iof there are rows with
- // noise clusters, i.e., they are very visual.
- //
- // The check methods are simple:
- // If there are no histogram at all (set fatal)
- // If digit histogram is there, but there are no digits (set error)
- // If cluster histogram is there but there are less than 1000
- // clusters (set warning)
- // If there are more than 1000 clusters but no clusters for either short,
- // medium, or long pads (set error)
+ /// This method checks the QA histograms associated with reconstruction
+ ///
+ /// For TPC this is:
+ /// DigitsR :
+ /// The digit histogram gives the ADC distribution for all sigbnals
+ /// above threshold. The check is just that there are digits.
+ /// RecPoints :
+ /// The cluster histograms are meant to give an idea about the gain
+ /// from the cluster charge and to indicate iof there are rows with
+ /// noise clusters, i.e., they are very visual.
+ ///
+ /// The check methods are simple:
+ /// If there are no histogram at all (set fatal)
+ /// If digit histogram is there, but there are no digits (set error)
+ /// If cluster histogram is there but there are less than 1000
+ /// clusters (set warning)
+ /// If there are more than 1000 clusters but no clusters for either short,
+ /// medium, or long pads (set error)
+
if(fDebug>0)
AliInfo("In AliTPCQAChecker::CheckREC");
-
+
if(fDebug>2)
list->Print();
TH1* hDigits = static_cast<TH1*>
(list->FindObject(Form("%s_hDigitsADC",AliRecoParam::GetEventSpecieName(specie))));
- TH1* hNclustersVsRow = static_cast<TH1*>
+ TH1* hNclustersVsRow = static_cast<TH1*>
(list->FindObject(Form("%s_hRecPointsRow",AliRecoParam::GetEventSpecieName(specie))));
- TH1* hQshort = static_cast<TH1*>
+ TH1* hQshort = static_cast<TH1*>
(list->FindObject(Form("%s_hRecPointsQShort",AliRecoParam::GetEventSpecieName(specie))));
- TH1* hQmedium = static_cast<TH1*>
+ TH1* hQmedium = static_cast<TH1*>
(list->FindObject(Form("%s_hRecPointsQMedium",AliRecoParam::GetEventSpecieName(specie))));
- TH1* hQlong = static_cast<TH1*>
+ TH1* hQlong = static_cast<TH1*>
(list->FindObject(Form("%s_hRecPointsQLong",AliRecoParam::GetEventSpecieName(specie))));
// The Qmax histograms are for now ignored
(!hNclustersVsRow || !hQshort || !hQmedium || !hQlong)) // 1 recpoint hist missing
return -0.5; // fatal
- if (hDigits && hDigits->GetEntries()==0)
+ if (hDigits && hDigits->GetEntries()==0)
return 0.25; // error
-
+
if (hNclustersVsRow && hNclustersVsRow->GetEntries() < 1000) {
return 0.75; // warning
- } else {
+ } else {
if (!hQshort || !hQlong || !hQlong)
return -0.5;// fatal - they should be there if the cluster vs row hist is there
if (hQshort->GetEntries()==0 || hQmedium->GetEntries()==0 ||
- hQlong->GetEntries()==0)
+ hQlong->GetEntries()==0)
return 0.25; // error
}
return 1; // ok
//______________________________________________________________________________
Double_t AliTPCQAChecker::CheckESD(Int_t specie, TObjArray* list)
{
- // This method checks the QA histograms associated with ESDs
- // (Note that there is aslo a globalQA which is running on all
- // the ESD information so for now this is just a few basic
- // histograms)
- //
- // The check methods are simple:
- // If there are no histogram at all (set fatal)
- //
+ /// This method checks the QA histograms associated with ESDs
+ /// (Note that there is aslo a globalQA which is running on all
+ /// the ESD information so for now this is just a few basic
+ /// histograms)
+ ///
+ /// The check methods are simple:
+ /// If there are no histogram at all (set fatal)
+
if(fDebug>0)
AliInfo("In AliTPCQAChecker::CheckESD");
(list->FindObject(Form("%s_hESDratio",AliRecoParam::GetEventSpecieName(specie))));
TH1* hESDpt = static_cast<TH1*>
(list->FindObject(Form("%s_hESDpt",AliRecoParam::GetEventSpecieName(specie))));
-
- if (!hESDclusters || !hESDratio || !hESDpt)
+
+ if (!hESDclusters || !hESDratio || !hESDpt)
return -0.5; // fatal
return 1.0; // ok
}
//______________________________________________________________________________
-void AliTPCQAChecker::Init(const AliQAv1::DETECTORINDEX_t det)
+void AliTPCQAChecker::Init(const AliQAv1::DETECTORINDEX_t det)
{
/// intialises QA and QA checker settings
+
if(fDebug>0)
AliInfo("In AliTPCQAChecker::Init");
- AliQAv1::Instance(det) ;
- Float_t hiValue[AliQAv1::kNBIT] ;
+ AliQAv1::Instance(det) ;
+ Float_t hiValue[AliQAv1::kNBIT] ;
Float_t lowValue[AliQAv1::kNBIT] ;
- hiValue[AliQAv1::kINFO] = 1.00;
- lowValue[AliQAv1::kINFO] = 0.99;
- hiValue[AliQAv1::kWARNING] = 0.99;
- lowValue[AliQAv1::kWARNING] = 0.50;
- hiValue[AliQAv1::kERROR] = 0.50;
- lowValue[AliQAv1::kERROR] = 0.00;
- hiValue[AliQAv1::kFATAL] = 0.00;
- lowValue[AliQAv1::kFATAL] =-1.00;
- // SetHiLo(&hiValue[0], &lowValue[0]) ;
- SetHiLo(hiValue, lowValue) ;
+ hiValue[AliQAv1::kINFO] = 1.00;
+ lowValue[AliQAv1::kINFO] = 0.99;
+ hiValue[AliQAv1::kWARNING] = 0.99;
+ lowValue[AliQAv1::kWARNING] = 0.50;
+ hiValue[AliQAv1::kERROR] = 0.50;
+ lowValue[AliQAv1::kERROR] = 0.00;
+ hiValue[AliQAv1::kFATAL] = 0.00;
+ lowValue[AliQAv1::kFATAL] =-1.00;
+ // SetHiLo(&hiValue[0], &lowValue[0]) ;
+ SetHiLo(hiValue, lowValue) ;
}
//______________________________________________________________________________
-void
+void
AliTPCQAChecker::SetQA(AliQAv1::ALITASK_t index, Double_t * value) const
{
/// sets the QA according the return value of the Check
AliInfo("In AliTPCQAChecker::SetQA");
AliQAv1 * qa = AliQAv1::Instance(index);
-
+
for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) {
if (value==NULL) { // No checker is implemented, set all QA to Fatal
-
+
if(fDebug>1)
- AliInfo(Form("Fatal QA. Task: %s. Specie: %s",
- AliQAv1::GetAliTaskName(index),
+ AliInfo(Form("Fatal QA. Task: %s. Specie: %s",
+ AliQAv1::GetAliTaskName(index),
AliRecoParam::GetEventSpecieName(specie)));
- qa->Set(AliQAv1::kFATAL, specie) ;
+ qa->Set(AliQAv1::kFATAL, specie) ;
} else {
-
- if ( value[specie] >= fLowTestValue[AliQAv1::kFATAL] &&
+
+ if ( value[specie] >= fLowTestValue[AliQAv1::kFATAL] &&
value[specie] < fUpTestValue[AliQAv1::kFATAL] ) {
-
+
if(fDebug>1)
- AliInfo(Form("QA-Fatal. Task: %s. Specie: %s",
- AliQAv1::GetAliTaskName(index),
+ AliInfo(Form("QA-Fatal. Task: %s. Specie: %s",
+ AliQAv1::GetAliTaskName(index),
AliRecoParam::GetEventSpecieName(specie)));
- qa->Set(AliQAv1::kFATAL, specie) ;
- } else if ( value[specie] > fLowTestValue[AliQAv1::kERROR] &&
+ qa->Set(AliQAv1::kFATAL, specie) ;
+ } else if ( value[specie] > fLowTestValue[AliQAv1::kERROR] &&
value[specie] <= fUpTestValue[AliQAv1::kERROR] ) {
-
+
if(fDebug>1)
- AliInfo(Form("QA-Error. Task: %s. Specie: %s",
- AliQAv1::GetAliTaskName(index),
+ AliInfo(Form("QA-Error. Task: %s. Specie: %s",
+ AliQAv1::GetAliTaskName(index),
AliRecoParam::GetEventSpecieName(specie)));
- qa->Set(AliQAv1::kERROR, specie) ;
- } else if (value[specie] > fLowTestValue[AliQAv1::kWARNING] &&
+ qa->Set(AliQAv1::kERROR, specie) ;
+ } else if (value[specie] > fLowTestValue[AliQAv1::kWARNING] &&
value[specie] <= fUpTestValue[AliQAv1::kWARNING]) {
-
+
if(fDebug>1)
- AliInfo(Form("QA-Warning. Task: %s. Specie: %s",
- AliQAv1::GetAliTaskName(index),
+ AliInfo(Form("QA-Warning. Task: %s. Specie: %s",
+ AliQAv1::GetAliTaskName(index),
AliRecoParam::GetEventSpecieName(specie)));
qa->Set(AliQAv1::kWARNING, specie) ;
- } else if (value[specie] > fLowTestValue[AliQAv1::kINFO] &&
- value[specie] <= fUpTestValue[AliQAv1::kINFO] ) {
-
+ } else if (value[specie] > fLowTestValue[AliQAv1::kINFO] &&
+ value[specie] <= fUpTestValue[AliQAv1::kINFO] ) {
+
if(fDebug>1)
- AliInfo(Form("QA-Info. Task: %s. Specie: %s",
- AliQAv1::GetAliTaskName(index),
+ AliInfo(Form("QA-Info. Task: %s. Specie: %s",
+ AliQAv1::GetAliTaskName(index),
AliRecoParam::GetEventSpecieName(specie)));
- qa->Set(AliQAv1::kINFO, specie) ;
+ qa->Set(AliQAv1::kINFO, specie) ;
}
}
}
/* Copyright(c) 1998-2007, ALICE Experiment at CERN, All rights reserved. *
* See cxx source for full Copyright notice */
-
-/* $Id: $ */
-
-/*
- Checks implemented a la AliMUONQAChecker.
- Checks the quality assurance by very simple checks on histogram content.
- P. Christiansen, Lund, September 2009.
-*/
+/// \class AliTPCQAChecker
+/// \brief Checks implemented a la AliMUONQAChecker.
+///
+/// Checks the quality assurance by very simple checks on histogram content.
+///
+/// \author P. Christiansen, Lund
+/// \date September 2009.
// --- ROOT header files ---
#include <TObjArray.h>
#include "AliDetectorRecoParam.h"
class AliTPCQAChecker: public AliQACheckerBase {
-
+
public:
AliTPCQAChecker() : AliQACheckerBase("TPC","TPC Quality Assurance Checker"), fDebug(0) {;} // ctor
- AliTPCQAChecker(const AliTPCQAChecker& qac) : AliQACheckerBase(qac.GetName(), qac.GetTitle()), fDebug(qac.GetDebugLevel()) {;} // cpy ctor
+ AliTPCQAChecker(const AliTPCQAChecker& qac) : AliQACheckerBase(qac.GetName(), qac.GetTitle()), fDebug(qac.GetDebugLevel()) {;} // cpy ctor
AliTPCQAChecker& operator = (const AliTPCQAChecker &checker); // assignment
virtual ~AliTPCQAChecker() {;} // dtor
-
- virtual void Check(Double_t * test, AliQAv1::ALITASK_t, TObjArray **, const AliDetectorRecoParam * recoParam);
- void Init(const AliQAv1::DETECTORINDEX_t det);
+
+ virtual void Check(Double_t * test, AliQAv1::ALITASK_t, TObjArray **, const AliDetectorRecoParam * recoParam);
+ void Init(const AliQAv1::DETECTORINDEX_t det);
void SetQA(AliQAv1::ALITASK_t index, Double_t * value) const;
Int_t GetDebugLevel() const {return fDebug;}
void SetDebugLevel(Int_t value) {fDebug = value;}
-
+
private:
-
+
Double_t CheckRAW(Int_t specie, TObjArray* list);
Double_t CheckSIM(Int_t specie, TObjArray* list);
Double_t CheckREC(Int_t specie, TObjArray* list);
Double_t CheckESD(Int_t specie, TObjArray* list);
Int_t fDebug;
-
+
+ /// \cond CLASSIMP
ClassDef(AliTPCQAChecker,2) // TPC Quality Assurance Checker
+ /// \endcond
};
* provided "as is" without express or implied warranty. *
**************************************************************************/
-
-/* $Id: $ */
-
-/*
- Based on AliPHOSQADataMaker
- Produces the data needed to calculate the quality assurance.
- All data must be mergeable objects.
- P. Christiansen, Lund, January 2008
-
- Updated July 2011:
- ==================
-
- Major changes to accomodate updates of general DQM/QA changes to have per
- trigger histograms (for a given event specie).
-
- 1) One instance of AliTPCdataQA only. (This also solves some old wishes by
- offline team to use less memory because event the 2d arrays for this object
- is not used). This now has a new flag for only keeping DQM info event by
- event! For this reason there is no need for a special DQM reset any more
- between runs!
-
- 2) Fill the histogram for each event. The histograms are no longer filled
- from the AliTPCdataQA but per event.
-
- 3) Use profiles for the RAW info. By adding the profiles event by event we
- get the correct event averages WITHOUT having to normalize in the end!
- Results should therefore also be directly mergable when that feature will
- come. (none of the other histograms are merged).
-
- This means that from the DQM/QA point of view the TPC DQM is now fully
- standard and should ease future developments.
-
- Updated June 2010:
- ==================
-
- The "beautification" of the online DQM histograms have been moved to
- an amore macro.
-
- The per event RAW histograms have been modified in AliTPCdataQA and
- the copies have therefore also been modified here.
-
- The AliTPCdataQA can now be configured a bit from here: time bin
- range (extended default range to 1-1000, event range at start:
- 0-100000, 1000 events per bin). (At least the parameters are not
- hardcoded:-)
-
- Implementation:
- ===============
-
- For the QA of the RAW data we use the class, AliTPCdataQA, from the
- existing TPC Calibration framework (which is more advanced than the
- standard QA framework) and extract the histograms at the end. The
- Analyse method of the AliTPCdataQA class is called in the method,
- EndOfDetectorCycle, and there also: 1d histogram(s) are projected
- and added to the QA list.
-*/
+/// \class AliTPCQADataMakerRec
+/// \brief Produces the data needed to calculate the quality assurance.
+///
+/// Based on AliPHOSQADataMaker
+/// All data must be mergeable objects.
+///
+/// Updated July 2011:
+/// ==================
+///
+/// Major changes to accomodate updates of general DQM/QA changes to have per
+/// trigger histograms (for a given event specie).
+///
+/// 1) One instance of AliTPCdataQA only. (This also solves some old wishes by
+/// offline team to use less memory because event the 2d arrays for this object
+/// is not used). This now has a new flag for only keeping DQM info event by
+/// event! For this reason there is no need for a special DQM reset any more
+/// between runs!
+///
+/// 2) Fill the histogram for each event. The histograms are no longer filled
+/// from the AliTPCdataQA but per event.
+///
+/// 3) Use profiles for the RAW info. By adding the profiles event by event we
+/// get the correct event averages WITHOUT having to normalize in the end!
+/// Results should therefore also be directly mergable when that feature will
+/// come. (none of the other histograms are merged).
+///
+/// This means that from the DQM/QA point of view the TPC DQM is now fully
+/// standard and should ease future developments.
+///
+/// Updated June 2010:
+/// ==================
+///
+/// The "beautification" of the online DQM histograms have been moved to
+/// an amore macro.
+///
+/// The per event RAW histograms have been modified in AliTPCdataQA and
+/// the copies have therefore also been modified here.
+///
+/// The AliTPCdataQA can now be configured a bit from here: time bin
+/// range (extended default range to 1-1000, event range at start:
+/// 0-100000, 1000 events per bin). (At least the parameters are not
+/// hardcoded:-)
+///
+/// Implementation:
+/// ===============
+///
+/// For the QA of the RAW data we use the class, AliTPCdataQA, from the
+/// existing TPC Calibration framework (which is more advanced than the
+/// standard QA framework) and extract the histograms at the end. The
+/// Analyse method of the AliTPCdataQA class is called in the method,
+/// EndOfDetectorCycle, and there also: 1d histogram(s) are projected
+/// and added to the QA list.
+///
+/// \author P. Christiansen, Lund
+/// \date January 2008
#include "AliTPCQADataMakerRec.h"
#include <TBox.h>
#include <TLine.h>
#include <TAxis.h>
-#include <TH1.h>
-#include <TProfile.h>
-#include <TProfile2D.h>
+#include <TH1.h>
+#include <TProfile.h>
+#include <TProfile2D.h>
// --- Standard library ---
#include <AliDetectorRecoParam.h>
+/// \cond CLASSIMP
ClassImp(AliTPCQADataMakerRec)
+/// \endcond
-//____________________________________________________________________________
-AliTPCQADataMakerRec::AliTPCQADataMakerRec() :
-AliQADataMakerRec(AliQAv1::GetDetName(AliQAv1::kTPC),
+//____________________________________________________________________________
+AliTPCQADataMakerRec::AliTPCQADataMakerRec() :
+AliQADataMakerRec(AliQAv1::GetDetName(AliQAv1::kTPC),
"TPC Rec Quality Assurance Data Maker"),
fTPCdataQA(NULL),
fRawFirstTimeBin(1),
fRawLastTimeBin(1000)
{
// ctor
-
+
for(Int_t i = 0; i < 6; i++)
fMapping[i] = 0;
}
-//____________________________________________________________________________
+//____________________________________________________________________________
AliTPCQADataMakerRec::AliTPCQADataMakerRec(const AliTPCQADataMakerRec& qadm) :
AliQADataMakerRec(),
fTPCdataQA(NULL),
fRawFirstTimeBin(qadm.GetRawFirstTimeBin()),
fRawLastTimeBin(qadm.GetRawLastTimeBin())
{
- //copy ctor
- // Does not copy the calibration object, instead InitRaws have to be
- // called again
- SetName((const char*)qadm.GetName()) ;
- SetTitle((const char*)qadm.GetTitle());
+ /// copy ctor
+ /// Does not copy the calibration object, instead InitRaws have to be
+ /// called again
+
+ SetName((const char*)qadm.GetName()) ;
+ SetTitle((const char*)qadm.GetTitle());
for(Int_t i = 0; i < 6; i++)
fMapping[i] = 0;
//__________________________________________________________________
AliTPCQADataMakerRec& AliTPCQADataMakerRec::operator = (const AliTPCQADataMakerRec& qadm )
{
- // Equal operator.
+ /// Equal operator.
+
this->~AliTPCQADataMakerRec();
new(this) AliTPCQADataMakerRec(qadm);
return *this;
//__________________________________________________________________
AliTPCQADataMakerRec::~AliTPCQADataMakerRec()
{
- // Destructor
- delete fTPCdataQA;
+ /// Destructor
- for(Int_t i = 0; i < 6; i++)
+ delete fTPCdataQA;
+
+ for(Int_t i = 0; i < 6; i++)
delete fMapping[i];
}
-
-//____________________________________________________________________________
+
+//____________________________________________________________________________
void AliTPCQADataMakerRec::EndOfDetectorCycle(AliQAv1::TASKINDEX_t task, TObjArray ** list)
{
- //Detector specific actions at end of cycle
+ /// Detector specific actions at end of cycle
+
ResetEventTrigClasses();
- AliQAChecker::Instance()->Run(AliQAv1::kTPC, task, list) ;
+ AliQAChecker::Instance()->Run(AliQAv1::kTPC, task, list) ;
}
-//____________________________________________________________________________
+//____________________________________________________________________________
void AliTPCQADataMakerRec::InitESDs()
{
- //create ESDs histograms in ESDs subdir
- const Bool_t expert = kTRUE ;
- const Bool_t image = kTRUE ;
-
- TH1F * histESDclusters =
+ /// create ESDs histograms in ESDs subdir
+
+ const Bool_t expert = kTRUE ;
+ const Bool_t image = kTRUE ;
+
+ TH1F * histESDclusters =
new TH1F("hESDclusters", "N TPC clusters per track; N clusters; Counts",
160, 0, 160);
histESDclusters->Sumw2();
Add2ESDsList(histESDclusters, kClusters, !expert, image);
- TH1F * histESDratio =
+ TH1F * histESDratio =
new TH1F("hESDratio", "Ratio: TPC clusters / findable; Ratio: cluster/findable; Counts",
100, 0, 1);
histESDratio->Sumw2();
Add2ESDsList(histESDratio, kRatio, !expert, image);
-
- TH1F * histESDpt =
+
+ TH1F * histESDpt =
new TH1F("hESDpt", "P_{T} distribution; p_{T} [GeV/c]; Counts",
50, 0, 5);
histESDpt->Sumw2();
ClonePerTrigClass(AliQAv1::kESDS); // this should be the last line
}
-//____________________________________________________________________________
+//____________________________________________________________________________
void AliTPCQADataMakerRec::InitRaws()
{
- //
- // Adding the raw
- //
+ /// Adding the raw
// Modified: 7/7 - 2008
// Laurent Aphecetche pointed out that the mapping was read from file
- // for each event, so now we read in the map here and set if for
+ // for each event, so now we read in the map here and set if for
// the raw data qa
- const Bool_t expert = kTRUE ;
- const Bool_t saveCorr = kTRUE ;
- const Bool_t image = kTRUE ;
-
+ const Bool_t expert = kTRUE ;
+ const Bool_t saveCorr = kTRUE ;
+ const Bool_t image = kTRUE ;
+
// It might happen that we will be in this method a few times
// (we create the dataQA at the first call to this method)
if(!fTPCdataQA) {
fTPCdataQA = new AliTPCdataQA();
LoadMaps(); // Load Altro maps
fTPCdataQA->SetAltroMapping(fMapping); // set Altro mapping
- fTPCdataQA->SetRangeTime(fRawFirstTimeBin, fRawLastTimeBin); // set time bin interval
+ fTPCdataQA->SetRangeTime(fRawFirstTimeBin, fRawLastTimeBin); // set time bin interval
fTPCdataQA->SetIsDQM(kTRUE);
}
- TProfile * histRawsOccupancyVsSector =
+ TProfile * histRawsOccupancyVsSector =
new TProfile("hRawsOccupancyVsSector", "Occupancy vs sector; Sector; Occupancy",
72, 0, 72);
histRawsOccupancyVsSector->SetMarkerStyle(20);
Add2RawsList(histRawsOccupancyVsSector, kRawsOccupancyVsSector, expert, image, !saveCorr);
else
Add2RawsList(histRawsOccupancyVsSector, kRawsOccupancyVsSector, !expert, image, !saveCorr);
-
- TProfile * histRawsQVsSector =
+
+ TProfile * histRawsQVsSector =
new TProfile("hRawsQVsSector", "<Q> vs sector; Sector; <Q>",
72, 0, 72);
Add2RawsList(histRawsQVsSector, kRawsQVsSector, expert, !image, !saveCorr);
- TProfile * histRawsQmaxVsSector =
+ TProfile * histRawsQmaxVsSector =
new TProfile("hRawsQmaxVsSector", "<Qmax> vs sector; Sector; <Qmax>",
72, 0, 72);
histRawsQmaxVsSector->SetMarkerStyle(20);
else
Add2RawsList(histRawsQmaxVsSector, kRawsQmaxVsSector, !expert, image, !saveCorr);
- TProfile2D * histRawsOccupancy2dVsSector =
+ TProfile2D * histRawsOccupancy2dVsSector =
new TProfile2D("hRawsOccupancy2dVsSector", "Occupancy vs sector; Sector; Patch",
72, 0, 36, 6, 0, 6);
histRawsOccupancy2dVsSector->SetOption("COLZ");
Add2RawsList(histRawsOccupancy2dVsSector, kRawsOccupancy2dVsSector, expert, image, !saveCorr);
else
Add2RawsList(histRawsOccupancy2dVsSector, kRawsOccupancy2dVsSector, !expert, image, !saveCorr);
-
+
//
ClonePerTrigClass(AliQAv1::kRAWS); // this should be the last line
}
-//____________________________________________________________________________
+//____________________________________________________________________________
void AliTPCQADataMakerRec::InitDigits()
{
- const Bool_t expert = kTRUE ;
- const Bool_t image = kTRUE ;
- TH1F * histDigitsADC =
+ const Bool_t expert = kTRUE ;
+ const Bool_t image = kTRUE ;
+ TH1F * histDigitsADC =
new TH1F("hDigitsADC", "Digit ADC distribution; ADC; Counts",
1000, 0, 1000);
histDigitsADC->Sumw2();
ClonePerTrigClass(AliQAv1::kDIGITS); // this should be the last line
}
-//____________________________________________________________________________
+//____________________________________________________________________________
void AliTPCQADataMakerRec::InitRecPoints()
{
- const Bool_t expert = kTRUE ;
- const Bool_t image = kTRUE ;
-
- TH1F * histRecPointsQmaxShort =
+ const Bool_t expert = kTRUE ;
+ const Bool_t image = kTRUE ;
+
+ TH1F * histRecPointsQmaxShort =
new TH1F("hRecPointsQmaxShort", "Qmax distrbution (short pads); Qmax; Counts",
100, 0, 300);
histRecPointsQmaxShort->Sumw2();
Add2RecPointsList(histRecPointsQmaxShort, kQmaxShort, !expert, image);
- TH1F * histRecPointsQmaxMedium =
+ TH1F * histRecPointsQmaxMedium =
new TH1F("hRecPointsQmaxMedium", "Qmax distrbution (medium pads); Qmax; Counts",
100, 0, 300);
histRecPointsQmaxMedium->Sumw2();
Add2RecPointsList(histRecPointsQmaxMedium, kQmaxMedium, !expert, image);
- TH1F * histRecPointsQmaxLong =
+ TH1F * histRecPointsQmaxLong =
new TH1F("hRecPointsQmaxLong", "Qmax distrbution (long pads); Qmax; Counts",
100, 0, 300);
histRecPointsQmaxLong->Sumw2();
Add2RecPointsList(histRecPointsQmaxLong, kQmaxLong, !expert, image);
- TH1F * histRecPointsQShort =
+ TH1F * histRecPointsQShort =
new TH1F("hRecPointsQShort", "Q distrbution (short pads); Q; Counts",
100, 0, 2000);
histRecPointsQShort->Sumw2();
Add2RecPointsList(histRecPointsQShort, kQShort, !expert, image);
- TH1F * histRecPointsQMedium =
+ TH1F * histRecPointsQMedium =
new TH1F("hRecPointsQMedium", "Q distrbution (medium pads); Q; Counts",
100, 0, 2000);
histRecPointsQMedium->Sumw2();
Add2RecPointsList(histRecPointsQMedium, kQMedium, !expert, image);
- TH1F * histRecPointsQLong =
+ TH1F * histRecPointsQLong =
new TH1F("hRecPointsQLong", "Q distrbution (long pads); Q; Counts",
100, 0, 2000);
histRecPointsQLong->Sumw2();
Add2RecPointsList(histRecPointsQLong, kQLong, !expert, image);
- TH1F * histRecPointsRow =
+ TH1F * histRecPointsRow =
new TH1F("hRecPointsRow", "Clusters per row; Row; Counts",
159, 0, 159);
histRecPointsRow->Sumw2();
//____________________________________________________________________________
void AliTPCQADataMakerRec::MakeESDs(AliESDEvent * esd)
{
- // make QA data from ESDs
-
+ /// make QA data from ESDs
+
const Int_t nESDTracks = esd->GetNumberOfTracks();
- Int_t nTPCtracks = 0;
+ Int_t nTPCtracks = 0;
for(Int_t i = 0; i < nESDTracks; i++) {
-
+
AliESDtrack * track = esd->GetTrack(i);
-
+
if ((track->GetStatus() & AliESDtrack::kTPCrefit)==0)
continue;
-
+
nTPCtracks++;
-
+
Int_t nTPCclusters = track->GetTPCNcls();
Int_t nTPCclustersFindable = track->GetTPCNclsF();
if ( nTPCclustersFindable<=0) continue;
FillESDsData(kClusters,nTPCclusters);
FillESDsData(kRatio,Float_t(nTPCclusters)/Float_t(nTPCclustersFindable));
- FillESDsData(kPt,track->Pt());
+ FillESDsData(kPt,track->Pt());
}
//
IncEvCountCycleESDs();
//____________________________________________________________________________
void AliTPCQADataMakerRec::MakeRaws(AliRawReader* rawReader)
{
- //
- // To make QA for the RAW data we use the TPC Calibration framework
- // to handle the data and then in the end extract the data
- //
-
+ /// To make QA for the RAW data we use the TPC Calibration framework
+ /// to handle the data and then in the end extract the data
+
GetRawsData(0); // dummy call to init raw data
- rawReader->Reset() ;
+ rawReader->Reset() ;
if (! fTPCdataQA ) {
- AliError("No TPC data QA (no call to InitRaws?)!!!!") ;
- } else {
+ AliError("No TPC data QA (no call to InitRaws?)!!!!") ;
+ } else {
if(fTPCdataQA->GetIsDQM() == kFALSE)
- AliError("Data QA has to be initialized as DQM!!!!") ;
+ AliError("Data QA has to be initialized as DQM!!!!") ;
// Fill profile data
fTPCdataQA->ResetProfiles();
-
- if(fTPCdataQA->ProcessEvent(rawReader)) { // means that TPC data was processed
+
+ if(fTPCdataQA->ProcessEvent(rawReader)) { // means that TPC data was processed
fTPCdataQA->FillOccupancyProfile();
-
- // Fill histograms
+
+ // Fill histograms
TObjArray *arrRW = GetMatchingRawsData(kRawsOccupancyVsSector); // all kRawsOccupancyVsSector clones matching to triggers
for (int ih=arrRW->GetEntriesFast();ih--;) {
TProfile* hRawsOccupancyVsSector = dynamic_cast<TProfile*>(arrRW->At(ih));
//____________________________________________________________________________
void AliTPCQADataMakerRec::MakeDigits(TTree* digitTree)
{
-
+
TBranch* branch = digitTree->GetBranch("Segment");
AliSimDigits* digArray = 0;
branch->SetAddress(&digArray);
-
+
Int_t nEntries = Int_t(digitTree->GetEntries());
-
+
for (Int_t n = 0; n < nEntries; n++) {
-
+
digitTree->GetEvent(n);
-
+
if (digArray->First())
do {
Float_t dig = digArray->CurrentDigit();
-
+
FillDigitsData(kDigitsADC,dig);
- } while (digArray->Next());
+ } while (digArray->Next());
}
//
IncEvCountCycleDigits();
//____________________________________________________________________________
void AliTPCQADataMakerRec::MakeRecPoints(TTree* recTree)
{
-
+
AliTPCClustersRow* clrow = 0x0;
- TBranch* branch = recTree->GetBranch("Segment");
+ TBranch* branch = recTree->GetBranch("Segment");
branch->SetAddress(&clrow);
TClonesArray * clarray = 0x0;
const Int_t nEntries = Int_t(recTree->GetEntries());
for (Int_t i = 0; i < nEntries; i++) {
-
+
branch->GetEntry(i);
clarray = clrow->GetArray();
const Int_t nClusters = clarray->GetEntriesFast();
for (Int_t icl=0; icl < nClusters; icl++){
-
- AliTPCclusterMI* cluster =
+
+ AliTPCclusterMI* cluster =
(AliTPCclusterMI*)clarray->At(icl);
-
+
Float_t Qmax = cluster->GetMax();
Float_t Q = cluster->GetQ();
Int_t row = cluster->GetRow();
FillRecPointsData(kQLong,Q);
}
}
-
+
FillRecPointsData(kRow,row);
} // end loop over clusters
} // end loop over tree
/* Copyright(c) 1998-2007, ALICE Experiment at CERN, All rights reserved. *
* See cxx source for full Copyright notice */
-
-/* $Id: $ */
-
-/*
- Based on AliPHOSQADataMaker
- Produces the data needed to calculate the quality assurance.
- All data must be mergeable objects.
- P. Christiansen, Lund, January 2008
-*/
-
+/// \class AliTPCQADataMakerRec
+/// \brief Based on AliPHOSQADataMaker: produces the data needed to calculate the quality assurance.
+///
+/// All data must be mergeable objects.
+/// \author P. Christiansen, Lund,
+/// \date January 2008
// --- ROOT system ---
class AliTPCQADataMakerRec: public AliQADataMakerRec {
public:
- enum HRawsType_t {kRawsOccupancyVsSector=0, kRawsQVsSector, kRawsQmaxVsSector, kRawsOccupancy2dVsSector} ;
- enum HDigitType_t {kDigitsADC=0} ;
- enum HRECPOINTsType_t {kClusters=0, kRatio, kPt} ;
- enum HESDsType_t {kQmaxShort=0, kQmaxMedium, kQmaxLong, kQShort, kQMedium, kQLong, kRow} ;
+ enum HRawsType_t {kRawsOccupancyVsSector=0, kRawsQVsSector, kRawsQmaxVsSector, kRawsOccupancy2dVsSector} ;
+ enum HDigitType_t {kDigitsADC=0} ;
+ enum HRECPOINTsType_t {kClusters=0, kRatio, kPt} ;
+ enum HESDsType_t {kQmaxShort=0, kQmaxMedium, kQmaxLong, kQShort, kQMedium, kQLong, kRow} ;
AliTPCQADataMakerRec() ; // ctor
- AliTPCQADataMakerRec(const AliTPCQADataMakerRec& qadm) ;
+ AliTPCQADataMakerRec(const AliTPCQADataMakerRec& qadm) ;
AliTPCQADataMakerRec& operator = (const AliTPCQADataMakerRec& qadm) ;
- virtual ~AliTPCQADataMakerRec();
-
+ virtual ~AliTPCQADataMakerRec();
+
Int_t GetRawFirstTimeBin() const { return fRawFirstTimeBin; }
Int_t GetRawLastTimeBin() const { return fRawLastTimeBin; }
-
+
void SetRawRangeTime(Int_t tMin, Int_t tMax){ fRawFirstTimeBin=tMin; fRawLastTimeBin=tMax;}
-
+
private:
- virtual void StartOfDetectorCycle() {}; // empty
+ virtual void StartOfDetectorCycle() {}; // empty
virtual void EndOfDetectorCycle(AliQAv1::TASKINDEX_t, TObjArray** list) ;
-
+
// ESD QA
- virtual void InitESDs() ;
+ virtual void InitESDs() ;
virtual void MakeESDs(AliESDEvent *esd) ;
-
+
// Raw QA
virtual void InitRaws();
virtual void MakeRaws(AliRawReader* rawReader);
-
+
// Digits QA
virtual void InitDigits();
virtual void MakeDigits() {return;}
virtual void MakeDigits(TTree *digTree);
-
+
// RecPoints QA
virtual void InitRecPoints();
virtual void MakeRecPoints(TTree *recTree);
-
+
virtual void LoadMaps();
-
- AliTPCAltroMapping *fMapping[6]; //! Pointers to ALTRO mapping
- AliTPCdataQA* fTPCdataQA;//! TPC calibration object for making raw data QA
-
- Int_t fRawFirstTimeBin; //! First Time bin needed for RAW QA
- Int_t fRawLastTimeBin; //! Last Time bin needed for RAW QA
-
- ClassDef(AliTPCQADataMakerRec,1) // TPC Rec Quality Assurance Data Maker
+
+ AliTPCAltroMapping *fMapping[6]; //!< Pointers to ALTRO mapping
+ AliTPCdataQA* fTPCdataQA;//!< TPC calibration object for making raw data QA
+
+ Int_t fRawFirstTimeBin; //!< First Time bin needed for RAW QA
+ Int_t fRawLastTimeBin; //!< Last Time bin needed for RAW QA
+
+ /// \cond CLASSIMP
+ ClassDef(AliTPCQADataMakerRec,1) // TPC Rec Quality Assurance Data Maker
+ /// \endcond
};
#endif // ALITPCQADATAMAKERREC_H
* provided "as is" without express or implied warranty. *
**************************************************************************/
-/* $Id$ */
-//-----------------------------------------------------------------------------
-//
-//
-//
-// Origin: Marian Ivanov, Uni. of Bratislava, ivanov@fmph.uniba.sk
-//
-// Declaration of class AliTPCRF1D
-//
-//-----------------------------------------------------------------------------
-
-//
+/// \class AliTPCRF1D
+/// \brief Declaration of class AliTPCRF1D
+///
+/// \author Marian Ivanov, Uni. of Bratislava, ivanov@fmph.uniba.sk
#include <RVersion.h>
#include <Riostream.h>
#include "AliTPCRF1D.h"
-extern TStyle * gStyle;
+extern TStyle * gStyle;
-Int_t AliTPCRF1D::fgNRF=100; //default number of interpolation points
-Float_t AliTPCRF1D::fgRFDSTEP=0.01; //default step in cm
+Int_t AliTPCRF1D::fgNRF=100; ///< default number of interpolation points
+Float_t AliTPCRF1D::fgRFDSTEP=0.01; ///< default step in cm
static Double_t funGauss(Double_t *x, Double_t * par)
{
- //Gauss function -needde by the generic function object
+ /// Gauss function -needde by the generic function object
+
return TMath::Exp(-(x[0]*x[0])/(2*par[0]*par[0]));
}
static Double_t funCosh(Double_t *x, Double_t * par)
{
- //Cosh function -needde by the generic function object
- return 1/TMath::CosH(3.14159*x[0]/(2*par[0]));
-}
+ /// Cosh function -needde by the generic function object
+
+ return 1/TMath::CosH(3.14159*x[0]/(2*par[0]));
+}
static Double_t funGati(Double_t *x, Double_t * par)
{
- //Gati function -needde by the generic function object
+ /// Gati function -needde by the generic function object
+
Float_t k3=par[1];
Float_t k3R=TMath::Sqrt(k3);
Float_t k2=(TMath::Pi()/2)*(1-k3R/2.);
Float_t l=x[0]/par[0];
Float_t tan2=TMath::TanH(k2*l);
tan2*=tan2;
- Float_t res = k1*(1-tan2)/(1+k3*tan2);
- return res;
-}
+ Float_t res = k1*(1-tan2)/(1+k3*tan2);
+ return res;
+}
///////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////
+/// \cond CLASSIMP
ClassImp(AliTPCRF1D)
+/// \endcond
AliTPCRF1D::AliTPCRF1D(Bool_t direct,Int_t np,Float_t step)
funParam[i]=0.;
fType[i]=0;
}
-
+
}
AliTPCRF1D::AliTPCRF1D(const AliTPCRF1D &prf)
Float_t AliTPCRF1D::GetRF(Float_t xin)
{
//function which return response
- //for the charge in distance xin
+ //for the charge in distance xin
//return linear aproximation of RF
Float_t x = (xin-fOffset)*fDSTEPM1+fNRF/2;
Int_t i1=Int_t(x);
if (x<0) i1-=1;
Float_t res=0;
if (i1+1<fNRF &&i1>0)
- res = fcharge[i1]*(Float_t(i1+1)-x)+fcharge[i1+1]*(x-Float_t(i1));
+ res = fcharge[i1]*(Float_t(i1+1)-x)+fcharge[i1+1]*(x-Float_t(i1));
return res;
}
Float_t AliTPCRF1D::GetGRF(Float_t xin)
-{
+{
//function which returnoriginal charge distribution
//this function is just normalised for fKnorm
- if (fGRF != 0 )
+ if (fGRF != 0 )
return fkNorm*fGRF->Eval(xin)/fInteg;
else
return 0.;
}
-
+
void AliTPCRF1D::SetParam( TF1 * GRF,Float_t padwidth,
Float_t kNorm, Float_t sigma)
{
fkNorm = kNorm;
if (sigma==0) sigma= fpadWidth/TMath::Sqrt(12.);
forigsigma=sigma;
- fDSTEPM1 = 10/TMath::Sqrt(sigma*sigma+fpadWidth*fpadWidth/12);
+ fDSTEPM1 = 10/TMath::Sqrt(sigma*sigma+fpadWidth*fpadWidth/12);
//sprintf(fType,"User");
snprintf(fType,5,"User");
- // Update();
+ // Update();
}
-
+
void AliTPCRF1D::SetGauss(Float_t sigma, Float_t padWidth,
Float_t kNorm)
{
- //
+ //
// set parameters for Gauss generic charge distribution
//
fpadWidth = padWidth;
funParam[0]=sigma;
forigsigma=sigma;
fGRF->SetParameters(funParam);
- fDSTEPM1 = 10./TMath::Sqrt(sigma*sigma+fpadWidth*fpadWidth/12);
- //by default I set the step as one tenth of sigma
+ fDSTEPM1 = 10./TMath::Sqrt(sigma*sigma+fpadWidth*fpadWidth/12);
+ //by default I set the step as one tenth of sigma
//sprintf(fType,"Gauss");
snprintf(fType,5,"Gauss");
}
void AliTPCRF1D::SetCosh(Float_t sigma, Float_t padWidth,
Float_t kNorm)
{
- //
+ //
// set parameters for Cosh generic charge distribution
//
fpadWidth = padWidth;
fkNorm = kNorm;
if (fGRF !=0 ) fGRF->Delete();
- fGRF = new TF1("funCosh", funCosh, -5.,5.,2);
+ fGRF = new TF1("funCosh", funCosh, -5.,5.,2);
funParam[0]=sigma;
fGRF->SetParameters(funParam);
forigsigma=sigma;
- fDSTEPM1 = 10./TMath::Sqrt(sigma*sigma+fpadWidth*fpadWidth/12);
+ fDSTEPM1 = 10./TMath::Sqrt(sigma*sigma+fpadWidth*fpadWidth/12);
//by default I set the step as one tenth of sigma
//sprintf(fType,"Cosh");
snprintf(fType,5,"Cosh");
void AliTPCRF1D::SetGati(Float_t K3, Float_t padDistance, Float_t padWidth,
Float_t kNorm)
{
- //
+ //
// set parameters for Gati generic charge distribution
//
fpadWidth = padWidth;
fkNorm = kNorm;
if (fGRF !=0 ) fGRF->Delete();
- fGRF = new TF1("funGati", funGati, -5.,5.,2);
+ fGRF = new TF1("funGati", funGati, -5.,5.,2);
funParam[0]=padDistance;
- funParam[1]=K3;
+ funParam[1]=K3;
fGRF->SetParameters(funParam);
forigsigma=padDistance;
- fDSTEPM1 = 10./TMath::Sqrt(padDistance*padDistance+fpadWidth*fpadWidth/12);
+ fDSTEPM1 = 10./TMath::Sqrt(padDistance*padDistance+fpadWidth*fpadWidth/12);
//by default I set the step as one tenth of sigma
//sprintf(fType,"Gati");
snprintf(fType,5,"Gati");
void AliTPCRF1D::DrawRF(Float_t x1,Float_t x2,Int_t N)
-{
+{
//
//Draw prf in selected region <x1,x2> with nuber of diviision = n
//
pad2->Draw();
//sprintf(s,"RF response function for %1.2f cm pad width",
- // fpadWidth);
- snprintf(s,60,"RF response function for %1.2f cm pad width",fpadWidth);
+ // fpadWidth);
+ snprintf(s,60,"RF response function for %1.2f cm pad width",fpadWidth);
pad1->cd();
TH1F * hRFo = new TH1F("hRFo","Original charge distribution",N+1,x1,x2);
pad2->cd();
gStyle->SetOptFit(1);
- gStyle->SetOptStat(0);
+ gStyle->SetOptStat(0);
TH1F * hRFc = new TH1F("hRFc",s,N+1,x1,x2);
Float_t x=x1;
Float_t y1;
y1 = GetRF(x);
hRFc->Fill(x,y1);
y2 = GetGRF(x);
- hRFo->Fill(x,y2);
+ hRFo->Fill(x,y2);
};
pad1->cd();
hRFo->Fit("gaus");
//at the begining initialize to 0
for (Int_t i =0; i<fNRF;i++) fcharge[i] = 0;
if ( fGRF == 0 ) return;
- // This form is no longer available
+ // This form is no longer available
#if ROOT_VERSION_CODE < ROOT_VERSION(5,99,0)
fInteg = fGRF->Integral(-5*forigsigma,5*forigsigma,funParam,0.00001);
#else
fGRF->SetParameters(funParam);
fInteg = fGRF->Integral(-5*forigsigma,5*forigsigma,0.00001);
#endif
- if ( fInteg == 0 ) fInteg = 1;
+ if ( fInteg == 0 ) fInteg = 1;
if (fDirect==kFALSE){
//integrate charge over pad for different distance of pad
for (Int_t i =0; i<fNRF;i++)
#else
fcharge[i] = fkNorm*fGRF->Integral(x1,x2,0.0001)/fInteg;
#endif
- };
+ };
}
else{
for (Int_t i =0; i<fNRF;i++)
{ //x in cm fpadWidth in cm
Float_t x = (Float_t)(i-fNRF/2)/fDSTEPM1;
fcharge[i] = fkNorm*fGRF->Eval(x);
- };
- }
- fSigma = 0;
+ };
+ }
+ fSigma = 0;
Float_t sum =0;
Float_t mean=0;
for (Float_t x =-fNRF/fDSTEPM1; x<fNRF/fDSTEPM1;x+=1/fDSTEPM1)
{ //x in cm fpadWidth in cm
Float_t weight = GetRF(x+fOffset);
- fSigma+=x*x*weight;
+ fSigma+=x*x*weight;
mean+=x*weight;
sum+=weight;
- };
+ };
if (sum>0){
mean/=sum;
- fSigma = TMath::Sqrt(fSigma/sum-mean*mean);
+ fSigma = TMath::Sqrt(fSigma/sum-mean*mean);
}
- else fSigma=0;
+ else fSigma=0;
#if ROOT_VERSION_CODE >= ROOT_VERSION(5,99,0)
fGRF->SetParameters(savParam.GetArray());
#endif
if (R__b.IsReading()) {
AliTPCRF1D::Class()->ReadBuffer(R__b, this);
//read functions
-
+
if (strncmp(fType,"Gauss",3)==0) {delete fGRF; fGRF = new TF1("funGauss",funGauss,-5.,5.,4);}
if (strncmp(fType,"Cosh",3)==0) {delete fGRF; fGRF = new TF1("funCosh",funCosh,-5.,5.,4);}
- if (strncmp(fType,"Gati",3)==0) {delete fGRF; fGRF = new TF1("funGati",funGati,-5.,5.,4);}
- if (fGRF) fGRF->SetParameters(funParam);
+ if (strncmp(fType,"Gati",3)==0) {delete fGRF; fGRF = new TF1("funGati",funGati,-5.,5.,4);}
+ if (fGRF) fGRF->SetParameters(funParam);
} else {
AliTPCRF1D::Class()->WriteBuffer(R__b, this);
Double_t g2 = TMath::Power(x/p1,4);
return p0*g1*g2;
}
-
+
/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
* See cxx source for full Copyright notice */
-/* $Id$ */
-////////////////////////////////////////////////
-// Manager class for AliTPCRF1D //
-////////////////////////////////////////////////
-
+/// \class AliTPCRF1D
+/// \brief Manager class for AliTPCRF1D
+
// include files and class forward declarations
class AliTPCRF1D : public TObject {
-public :
- AliTPCRF1D(Bool_t direct=kFALSE,Int_t np=0,Float_t step=0 );
+public :
+ AliTPCRF1D(Bool_t direct=kFALSE,Int_t np=0,Float_t step=0 );
AliTPCRF1D(const AliTPCRF1D &prf);
AliTPCRF1D & operator = (const AliTPCRF1D &prf);
- ~AliTPCRF1D();
+ ~AliTPCRF1D();
Float_t GetRF(Float_t xin); //return RF in point xin
Float_t GetGRF(Float_t xin); //return generic response function in xin
void SetGauss(Float_t sigma,Float_t padWidth, Float_t kNorm);
- //adjust RF with GAUSIAN as generic GRF
+ //adjust RF with GAUSIAN as generic GRF
//if direct = kTRUE then it does't convolute distribution
void SetCosh(Float_t sigma,Float_t padWidth, Float_t kNorm);
void SetGati(Float_t K3, Float_t padDistance, Float_t padWidth,
Float_t kNorm);
//adjust RF with 1/Cosh as generic GRF
- void SetParam(TF1 * GRF,Float_t padwidth,Float_t kNorm,
+ void SetParam(TF1 * GRF,Float_t padwidth,Float_t kNorm,
Float_t sigma=0);
- //adjust RF with general function
+ //adjust RF with general function
void SetOffset(Float_t xoff) {fOffset=xoff;}
- //set offset value
+ //set offset value
Float_t GetOffset(){return fOffset;}
- Float_t GetPadWidth(){ return fpadWidth;};
- //return pad width
+ Float_t GetPadWidth(){ return fpadWidth;};
+ //return pad width
Float_t GetSigma(){return fSigma;}
//return estimated sigma of RF
void DrawRF(Float_t x1=-3 ,Float_t x2 =3.,Int_t N = 200);
//draw RF it don't delete histograms after drawing
/// it's on user !!!!
- void Update();
+ void Update();
static Double_t Gamma4(Double_t x, Double_t p0, Double_t p1);
-private:
- Double_t funParam[5];//parameters of used charge function
- Int_t fNRF; //number of interpolations point
- Float_t fDSTEPM1; //element step for point
- Float_t* fcharge; //[fNPRF] field with RF
- Float_t forigsigma;//sigma of original distribution;
- Float_t fpadWidth; //width of pad
- Float_t fkNorm; //normalisation factor of the charge integral
- Float_t fInteg; //integral of GRF on +- infinity
- TF1 * fGRF; //charge distribution function
- Float_t fSigma; //sigma of PAD response function
-
- Float_t fOffset; //offset of response function (for time reponse we
+private:
+ Double_t funParam[5];///< parameters of used charge function
+ Int_t fNRF; ///< number of interpolations point
+ Float_t fDSTEPM1; ///< element step for point
+ /// field with RF
+ Float_t* fcharge; //[fNPRF]
+ Float_t forigsigma;///< sigma of original distribution;
+ Float_t fpadWidth; ///< width of pad
+ Float_t fkNorm; ///< normalisation factor of the charge integral
+ Float_t fInteg; ///< integral of GRF on +- infinity
+ TF1 * fGRF; ///< charge distribution function
+ Float_t fSigma; ///< sigma of PAD response function
+
+ Float_t fOffset; ///< offset of response function (for time reponse we
//have for expample shifted gauss)
//calculated during update
-
- Bool_t fDirect; //tell us if we use directly generalfunction
-
- Float_t fPadDistance; //pad to wire distance
- char fType[5]; //type of the parametrisation
- static Int_t fgNRF;//default number of interpolation points
- static Float_t fgRFDSTEP;//default step in cm
+
+ Bool_t fDirect; ///< tell us if we use directly generalfunction
+
+ Float_t fPadDistance; ///< pad to wire distance
+ char fType[5]; ///< type of the parametrisation
+ static Int_t fgNRF;///< default number of interpolation points
+ static Float_t fgRFDSTEP;///< default step in cm
+ /// \cond CLASSIMP
ClassDef(AliTPCRF1D,2)
-};
+ /// \endcond
+};
#endif /* ALITPCRF1D_H */
-
+
**************************************************************************/
-///////////////////////////////////////////////////////////////////////////////
-// //
-// Geometry class for a single ROC //
-// //
-// //
-///////////////////////////////////////////////////////////////////////////////
+/// \class AliTPCROC
+/// \brief Geometry class for a single ROC
+
#include "AliTPCROC.h"
#include "TMath.h"
+/// \cond CLASSIMP
ClassImp(AliTPCROC)
+/// \endcond
AliTPCROC* AliTPCROC::fgInstance = 0;
//_ singleton implementation __________________________________________________
AliTPCROC* AliTPCROC::Instance()
{
- //
- // Singleton implementation
- // Returns an instance of this class, it is created if neccessary
- //
+ /// Singleton implementation
+ /// Returns an instance of this class, it is created if neccessary
+
if (fgInstance == 0){
fgInstance = new AliTPCROC();
- fgInstance->Init();
+ fgInstance->Init();
}
return fgInstance;
}
void AliTPCROC::Init(){
- //
- // initialize static variables
- //
+ /// initialize static variables
+
if (AliTPCROC::fNSectorsAll>0) return;
fNSectorsAll =72;
fNSectors[0] =36;
//
// number of pads in padrow
fNPads[0] = new UInt_t[fNRows[0]];
- fNPads[1] = new UInt_t[fNRows[1]];
+ fNPads[1] = new UInt_t[fNRows[1]];
//
// padrow index in array
//
index =0;
Double_t k1 = 10.*TMath::Tan(10*TMath::DegToRad())/6.;
Double_t k2 = 15.*TMath::Tan(10*TMath::DegToRad())/6.;
- for (UInt_t irow=0; irow<fNRows[1];irow++){
- UInt_t npads = (irow<64) ?
+ for (UInt_t irow=0; irow<fNRows[1];irow++){
+ UInt_t npads = (irow<64) ?
2*Int_t(k1*Double_t(irow)+37.75):
2*Int_t(k2*Double_t(irow-64)+56.66);
fNPads[1][irow] = npads;
void AliTPCROC::SetGeometry()
{
- //
- //set ROC geometry parameters
- //
+ /// set ROC geometry parameters
+
const Float_t kInnerRadiusLow = 83.65;
const Float_t kInnerRadiusUp = 133.3;
const Float_t kOuterRadiusLow = 133.5;
const Float_t kOuterAngle = 20; // 20 degrees
//
// pad parameters
- //
+ //
const Float_t kInnerPadPitchLength = 0.75;
const Float_t kInnerPadPitchWidth = 0.40;
const Float_t kInnerPadLength = 0.75;
const Float_t kOuter1PadLength = 1.0;
const Float_t kOuterPadWidth = 0.6;
const Float_t kOuter2PadPitchLength = 1.5;
- const Float_t kOuter2PadLength = 1.5;
+ const Float_t kOuter2PadLength = 1.5;
//
//wires default parameters
// const Float_t kInnerOffWire = 0.5;
// const UInt_t kNOuter1WiresPerPad = 4;
// const UInt_t kNOuter2WiresPerPad = 6;
-// const Float_t kOuterWWPitch = 0.25;
+// const Float_t kOuterWWPitch = 0.25;
// const Float_t kROuterFirstWire = 134.225;
// const Float_t kROuterLastWire = 246.975;
// const UInt_t kOuterDummyWire = 2;
fInnerRadiusLow = kInnerRadiusLow;
fOuterRadiusLow = kOuterRadiusLow;
fInnerRadiusUp = kInnerRadiusUp;
- fOuterRadiusUp = kOuterRadiusUp;
+ fOuterRadiusUp = kOuterRadiusUp;
fInnerFrameSpace = kInnerFrameSpace;
fOuterFrameSpace = kOuterFrameSpace;
fInnerWireMount = kInnerWireMount;
fInnerPadPitchWidth = kInnerPadPitchWidth;
fInnerPadLength = kInnerPadLength;
fInnerPadWidth = kInnerPadWidth;
- fOuter1PadPitchLength = kOuter1PadPitchLength;
+ fOuter1PadPitchLength = kOuter1PadPitchLength;
fOuter2PadPitchLength = kOuter2PadPitchLength;
fOuterPadPitchWidth = kOuterPadPitchWidth;
fOuter1PadLength = kOuter1PadLength;
fOuter2PadLength = kOuter2PadLength;
- fOuterPadWidth = kOuterPadWidth;
+ fOuterPadWidth = kOuterPadWidth;
//
//set wire parameters
// SetRInnerLastWire(kRInnerLastWire);
// SetOuterWWPitch(kOuterWWPitch);
// SetROuterFirstWire(kROuterFirstWire);
- // SetROuterLastWire(kROuterLastWire);
+ // SetROuterLastWire(kROuterLastWire);
UInt_t i=0;
- Float_t firstrow = fInnerRadiusLow + 1.575;
+ Float_t firstrow = fInnerRadiusLow + 1.575;
for( i= 0;i<fNRowLow;i++)
{
- Float_t x = firstrow + fInnerPadPitchLength*(Float_t)i;
+ Float_t x = firstrow + fInnerPadPitchLength*(Float_t)i;
fPadRowLow[i]=x;
fYInner[i+1] = x*TMath::Tan(fInnerAngle/2.)-fInnerWireMount;
- fNPadsLow[i] = GetNPads(0,i) ; // ROC implement
+ fNPadsLow[i] = GetNPads(0,i) ; // ROC implement
}
// cross talk rows
fYInner[0]=(fPadRowLow[0]-fInnerPadPitchLength)*TMath::Tan(fInnerAngle/2.)-fInnerWireMount;
- fYInner[fNRowLow+1]=(fPadRowLow[fNRowLow-1]+fInnerPadPitchLength)*TMath::Tan(fInnerAngle/2.)-fInnerWireMount;
+ fYInner[fNRowLow+1]=(fPadRowLow[fNRowLow-1]+fInnerPadPitchLength)*TMath::Tan(fInnerAngle/2.)-fInnerWireMount;
firstrow = fOuterRadiusLow + 1.6;
for(i=0;i<fNRowUp;i++)
{
if(i<fNRowUp1){
- Float_t x = firstrow + fOuter1PadPitchLength*(Float_t)i;
+ Float_t x = firstrow + fOuter1PadPitchLength*(Float_t)i;
fPadRowUp[i]=x;
fYOuter[i+1]= x*TMath::Tan(fOuterAngle/2.)-fOuterWireMount;
- fNPadsUp[i] = GetNPads(36,i) ; // ROC implement
+ fNPadsUp[i] = GetNPads(36,i) ; // ROC implement
if(i==fNRowUp1-1) {
fLastWireUp1=fPadRowUp[i] +0.625;
firstrow = fPadRowUp[i] + 0.5*(fOuter1PadPitchLength+fOuter2PadPitchLength);
}
fYOuter[i+1] = fPadRowUp[i]*TMath::Tan(fOuterAngle/2.)-fOuterWireMount;
}
-
-}
+
+}
//_____________________________________________________________________________
AliTPCROC::AliTPCROC()
- :TObject(),
+ :TObject(),
fNSectorsAll(0),
fInnerRadiusLow(0.),
fInnerRadiusUp(0.),
fNRowUp(0),
fNtRows(0)
{
- //
- // Default constructor
+ /// Default constructor
+
for (UInt_t i=0;i<2;i++){
fNSectors[i] = 0;
fNRows[i] = 0;
fNPads[i] = 0;
fRowPosIndex[i]= 0;
}
-
+
for (UInt_t i=0;i<100;++i){
fPadRowLow[i]=0.;
fPadRowUp[i]=0.;
fNtRows(0)
{
- //
- // AliTPCROC copy constructor
- //
+ /// AliTPCROC copy constructor
+
fNSectorsAll = roc.fNSectorsAll;
fNSectors[0] = roc.fNSectors[0];
fNSectors[1] = roc.fNSectors[1];
//
// number of pads in padrow
fNPads[0] = new UInt_t[fNRows[0]];
- fNPads[1] = new UInt_t[fNRows[1]];
+ fNPads[1] = new UInt_t[fNRows[1]];
//
// padrow index in array
//
fNPads[1][irow] = roc.fNPads[1][irow];
fRowPosIndex[1][irow] = roc.fRowPosIndex[1][irow];
}
-
+
for (UInt_t i=0;i<100;++i){
fPadRowLow[i]=roc.fPadRowLow[i];
fPadRowUp[i]=roc.fPadRowUp[i];
//____________________________________________________________________________
AliTPCROC & AliTPCROC::operator =(const AliTPCROC & roc)
{
- //
- // assignment operator - dummy
- //
+ /// assignment operator - dummy
+
if (this == &roc) return (*this);
fZLength = roc.fZLength;
//_____________________________________________________________________________
AliTPCROC::~AliTPCROC()
{
- //
- // AliTPCROC destructor
- //
+ /// AliTPCROC destructor
+
delete [] fNPads[0];
delete [] fNPads[1];
delete [] fRowPosIndex[0];
delete [] fRowPosIndex[1];
fgInstance = 0x0;
-
+
}
void AliTPCROC::GetPositionLocal(UInt_t sector, UInt_t row, UInt_t pad, Float_t *pos){
- //
- // get position of center of pad - ideal frame used
- //
+ /// get position of center of pad - ideal frame used
+
pos[2]=fZLength;
if (sector<36){
pos[0] = fPadRowLow[row];
pos[1] = fInnerPadPitchWidth*(Int_t(pad)+0.5-Int_t(fNPads[0][row])/2);
}else{
pos[0] = fPadRowUp[row];
- pos[1] = fOuterPadPitchWidth*(Int_t(pad)+0.5-Int_t(fNPads[1][row])/2);
+ pos[1] = fOuterPadPitchWidth*(Int_t(pad)+0.5-Int_t(fNPads[1][row])/2);
}
if ((sector%36)>=18){
pos[2] *= -1.;
void AliTPCROC::GetPositionGlobal(UInt_t sector, UInt_t row, UInt_t pad, Float_t *pos){
- //
- // get position of center of pad - ideal frame used
- //
+ /// get position of center of pad - ideal frame used
+
GetPositionLocal(sector,row,pad,pos);
Double_t alpha = TMath::DegToRad()*(10.+20.*(sector%18));
Float_t gx = pos[0]*TMath::Cos(alpha)-pos[1]*TMath::Sin(alpha);
/* $Id: AliTPCROC.h,v */
-//////////////////////////////////////////////////
-// //
-// TPC geometry class for ROC //
-// //
-//////////////////////////////////////////////////
+/// \class AliTPCROC
+/// \brief TPC geometry class for ROC
#include <TObject.h>
AliTPCROC();
AliTPCROC(const AliTPCROC &roc);
AliTPCROC &operator = (const AliTPCROC & roc); //assignment operator
- void Init();
+ void Init();
virtual ~AliTPCROC();
void GetPositionLocal(UInt_t sector, UInt_t row, UInt_t pad, Float_t *pos);
void GetPositionGlobal(UInt_t sector, UInt_t row, UInt_t pad, Float_t *pos);
UInt_t GetNSectors() const { return fNSectorsAll;}
UInt_t GetNRows(UInt_t sector) const { return (sector<fNSectors[1]) ? fNRows[0]:fNRows[1];}
UInt_t GetNChannels(UInt_t sector) const { return (sector<fNSectors[1]) ? fNChannels[0]:fNChannels[1];}
- UInt_t GetNPads(UInt_t sector,UInt_t row) const {
+ UInt_t GetNPads(UInt_t sector,UInt_t row) const {
UInt_t irow=(row<GetNRows(sector))?row:(GetNRows(sector)-1);
return (sector<fNSectors[1]) ? fNPads[0][irow]:fNPads[1][irow];}
- const UInt_t * GetRowIndexes(UInt_t sector) const {return (sector<fNSectors[1]) ? fRowPosIndex[0]:fRowPosIndex[1];}
+ const UInt_t * GetRowIndexes(UInt_t sector) const {return (sector<fNSectors[1]) ? fRowPosIndex[0]:fRowPosIndex[1];}
//
//get sector parameters
//
Float_t GetInnerRadiusLow() const {return fInnerRadiusLow;}
- Float_t GetInnerRadiusUp() const {return fInnerRadiusUp;}
- Float_t GetOuterRadiusLow() const {return fOuterRadiusLow;}
- Float_t GetOuterRadiusUp() const {return fOuterRadiusUp;}
+ Float_t GetInnerRadiusUp() const {return fInnerRadiusUp;}
+ Float_t GetOuterRadiusLow() const {return fOuterRadiusLow;}
+ Float_t GetOuterRadiusUp() const {return fOuterRadiusUp;}
Float_t GetInnerFrameSpace() const {return fInnerFrameSpace;}
Float_t GetOuterFrameSpace() const {return fOuterFrameSpace;}
Float_t GetInnerWireMount() const {return fInnerWireMount;}
// get pad row parameters
//
Float_t GetPadRowRadiiLow(UInt_t irow) const {return ( irow<fNRowLow ) ? fPadRowLow[irow]: 0;} //get the pad row (irow) radii
- Float_t GetPadRowRadiiUp(UInt_t irow) const {return ( irow<fNRowUp ) ? fPadRowUp[irow]: 0;} //get the pad row (irow) radii
+ Float_t GetPadRowRadiiUp(UInt_t irow) const {return ( irow<fNRowUp ) ? fPadRowUp[irow]: 0;} //get the pad row (irow) radii
Float_t GetPadRowRadii(UInt_t isec, UInt_t irow) const {
return ( (isec < fNSectors[0]) ?GetPadRowRadiiLow(irow):GetPadRowRadiiUp(irow));}
//
- static UInt_t GetTPCUniqueID(UInt_t sector, UInt_t row, UInt_t pad){UInt_t uid=pad+row*140+sector*140*159; return uid; } // unique Id can be used for absolute adressing of the TPC element
+ static UInt_t GetTPCUniqueID(UInt_t sector, UInt_t row, UInt_t pad){UInt_t uid=pad+row*140+sector*140*159; return uid; } // unique Id can be used for absolute adressing of the TPC element
protected:
//
// number of pads
//
void SetGeometry(); // set geometry parameters
- UInt_t fNSectorsAll; // number of sectors
- UInt_t fNSectors[2]; // number of sectors - inner outer
- UInt_t fNRows[2]; // number of row - inner outer
- UInt_t fNChannels[2]; // total number of pads - inner sector - outer sector
- UInt_t *fNPads[2]; // number of pads in row - inner - outer
- UInt_t *fRowPosIndex[2]; // index array - inner - outer
+ UInt_t fNSectorsAll; ///< number of sectors
+ UInt_t fNSectors[2]; ///< number of sectors - inner outer
+ UInt_t fNRows[2]; ///< number of row - inner outer
+ UInt_t fNChannels[2]; ///< total number of pads - inner sector - outer sector
+ UInt_t *fNPads[2]; ///< number of pads in row - inner - outer
+ UInt_t *fRowPosIndex[2]; ///< index array - inner - outer
//
//
//---------------------------------------------------------------------
// ALICE TPC sector geometry
- //--------------------------------------------------------------------
- Float_t fInnerRadiusLow; // lower radius of inner sector-IP
- Float_t fInnerRadiusUp; // upper radius of inner sector-IP
- Float_t fOuterRadiusUp; // upper radius of outer sector-IP
- Float_t fOuterRadiusLow; // lower radius of outer sector-IP
- Float_t fInnerFrameSpace; //space for inner frame in the phi direction
- Float_t fOuterFrameSpace; //space for outer frame in the phi direction
- Float_t fInnerWireMount; //space for wire mount, inner sector
- Float_t fOuterWireMount; //space for wire mount, outer sector
- Float_t fZLength; //length of the drift region of the TPC
- Float_t fInnerAngle; //angular coverage
- Float_t fOuterAngle; //angular coverage
+ //--------------------------------------------------------------------
+ Float_t fInnerRadiusLow; ///< lower radius of inner sector-IP
+ Float_t fInnerRadiusUp; ///< upper radius of inner sector-IP
+ Float_t fOuterRadiusUp; ///< upper radius of outer sector-IP
+ Float_t fOuterRadiusLow; ///< lower radius of outer sector-IP
+ Float_t fInnerFrameSpace; ///< space for inner frame in the phi direction
+ Float_t fOuterFrameSpace; ///< space for outer frame in the phi direction
+ Float_t fInnerWireMount; ///< space for wire mount, inner sector
+ Float_t fOuterWireMount; ///< space for wire mount, outer sector
+ Float_t fZLength; ///< length of the drift region of the TPC
+ Float_t fInnerAngle; ///< angular coverage
+ Float_t fOuterAngle; ///< angular coverage
//
//---------------------------------------------------------------------
- // ALICE TPC wires geometry - for GEM we can consider that it is gating
+ // ALICE TPC wires geometry - for GEM we can consider that it is gating
//--------------------------------------------------------------------
- UInt_t fNInnerWiresPerPad; //Number of wires per pad
- Float_t fInnerWWPitch; //pitch between wires in inner sector - calculated
- UInt_t fInnerDummyWire; //number of wires without pad readout
- Float_t fInnerOffWire; //oofset of first wire to the begining of the sector
- Float_t fRInnerFirstWire; //position of the first wire -calculated
- Float_t fRInnerLastWire; //position of the last wire -calculated
- Float_t fLastWireUp1; //position of the last wire in outer1 sector
- UInt_t fNOuter1WiresPerPad; //Number of wires per pad
- UInt_t fNOuter2WiresPerPad; // Number of wires per pad
- Float_t fOuterWWPitch; //pitch between wires in outer sector -calculated
- UInt_t fOuterDummyWire; //number of wires without pad readout
- Float_t fOuterOffWire; //oofset of first wire to the begining of the sector
- Float_t fROuterFirstWire; //position of the first wire -calulated
- Float_t fROuterLastWire; //position of the last wire -calculated
+ UInt_t fNInnerWiresPerPad; ///< Number of wires per pad
+ Float_t fInnerWWPitch; ///< pitch between wires in inner sector - calculated
+ UInt_t fInnerDummyWire; ///< number of wires without pad readout
+ Float_t fInnerOffWire; ///< oofset of first wire to the begining of the sector
+ Float_t fRInnerFirstWire; ///< position of the first wire -calculated
+ Float_t fRInnerLastWire; ///< position of the last wire -calculated
+ Float_t fLastWireUp1; ///< position of the last wire in outer1 sector
+ UInt_t fNOuter1WiresPerPad; ///< Number of wires per pad
+ UInt_t fNOuter2WiresPerPad; ///< Number of wires per pad
+ Float_t fOuterWWPitch; ///< pitch between wires in outer sector -calculated
+ UInt_t fOuterDummyWire; ///< number of wires without pad readout
+ Float_t fOuterOffWire; ///< oofset of first wire to the begining of the sector
+ Float_t fROuterFirstWire; ///< position of the first wire -calulated
+ Float_t fROuterLastWire; ///< position of the last wire -calculated
//---------------------------------------------------------------------
// ALICE TPC pad parameters
//--------------------------------------------------------------------
- Float_t fInnerPadPitchLength; //Inner pad pitch length
- Float_t fInnerPadPitchWidth; //Inner pad pitch width
- Float_t fInnerPadLength; //Inner pad length
- Float_t fInnerPadWidth; //Inner pad width
- Float_t fOuter1PadPitchLength; //Outer pad pitch length
- Float_t fOuter2PadPitchLength; //Outer pad pitch length
- Float_t fOuterPadPitchWidth; //Outer pad pitch width
- Float_t fOuter1PadLength; //Outer pad length
- Float_t fOuter2PadLength; //Outer pad length
- Float_t fOuterPadWidth; //Outer pad width
- //
- UInt_t fNRowLow; //number of pad rows per low sector -set
- UInt_t fNRowUp1; //number of short pad rows per sector up -set
- UInt_t fNRowUp2; //number of long pad rows per sector up -set
- UInt_t fNRowUp; //number of pad rows per sector up -calculated
- UInt_t fNtRows; //total number of rows in TPC -calculated
- Float_t fPadRowLow[100]; //Lower sector, pad row radii -calculated
- Float_t fPadRowUp[100]; //Upper sector, pad row radii -calculated
- UInt_t fNPadsLow[100]; //Lower sector, number of pads per row -calculated
- UInt_t fNPadsUp[100]; //Upper sector, number of pads per row -calculated
- Float_t fYInner[100]; //Inner sector, wire-length
- Float_t fYOuter[100]; //Outer sector, wire-length
+ Float_t fInnerPadPitchLength; ///< Inner pad pitch length
+ Float_t fInnerPadPitchWidth; ///< Inner pad pitch width
+ Float_t fInnerPadLength; ///< Inner pad length
+ Float_t fInnerPadWidth; ///< Inner pad width
+ Float_t fOuter1PadPitchLength; ///< Outer pad pitch length
+ Float_t fOuter2PadPitchLength; ///< Outer pad pitch length
+ Float_t fOuterPadPitchWidth; ///< Outer pad pitch width
+ Float_t fOuter1PadLength; ///< Outer pad length
+ Float_t fOuter2PadLength; ///< Outer pad length
+ Float_t fOuterPadWidth; ///< Outer pad width
+ //
+ UInt_t fNRowLow; ///< number of pad rows per low sector -set
+ UInt_t fNRowUp1; ///< number of short pad rows per sector up -set
+ UInt_t fNRowUp2; ///< number of long pad rows per sector up -set
+ UInt_t fNRowUp; ///< number of pad rows per sector up -calculated
+ UInt_t fNtRows; ///< total number of rows in TPC -calculated
+ Float_t fPadRowLow[100]; ///< Lower sector, pad row radii -calculated
+ Float_t fPadRowUp[100]; ///< Upper sector, pad row radii -calculated
+ UInt_t fNPadsLow[100]; ///< Lower sector, number of pads per row -calculated
+ UInt_t fNPadsUp[100]; ///< Upper sector, number of pads per row -calculated
+ Float_t fYInner[100]; ///< Inner sector, wire-length
+ Float_t fYOuter[100]; ///< Outer sector, wire-length
protected:
- static AliTPCROC* fgInstance; //! Instance of this class (singleton implementation)
+ static AliTPCROC* fgInstance; //!< Instance of this class (singleton implementation)
+ /// \cond CLASSIMP
ClassDef(AliTPCROC,0) // TPC ROC class
+ /// \endcond
};
#endif
* provided "as is" without express or implied warranty. *
**************************************************************************/
-// _________________________________________________________________
-//
-// Begin_Html
-// <h2> AliTPCROCVoltError3D class </h2>
-// The class calculates the space point distortions due to z offsets of the
-// ROCs via the residual voltage technique (Poisson relaxation) in 3D.
-// Since the GG (part of the ROCs) represents the closure of the FC in z direction,
-// every misalignment in z produces not only dz distortions but also electrical
-// field inhomogeneities throughout the volume, which produces additional dr and rd$\phi$ distortions.
-// <p>
-// Each ROC can be misaligned (in z direction) in three ways. A general z0 offset,
-// an inclination along the x and an inclination along the y axis. The z-misalignment's
-// can be set via the function SetROCData(TMatrixD *mat) for each single chamber (ROC).
-// The array size has to be (72,3) representing the 72 chambers according to the
-// offline numbering scheme (IROC: roc$<$36; OROC: roc$\geq$36) and the three misalignment's
-// (see the source code for further details).
-// <p>
-// Internally, these z offsets (unit is cm) are recalculated into residual voltage
-// equivalents in order to make use of the relaxation technique.
-// <p>
-// One has two possibilities when calculating the $dz$ distortions. The resulting
-// distortions are purely due to the change of the drift velocity (along with the
-// change of the drift field) when the SetROCDisplacement is FALSE. <br>
-// For this class, this is a rather unphysical setting and should be avoided. <br>
-// When the flag is set to TRUE, the corresponding offset in z is added to the dz
-// calculation of the outer ROCs. <br>
-// For the Alice TPC gas, both effects are of similar magnitude. This means, if the
-// drift length is sufficiently large, a z-offset of a chamber appears to have (approx.)
-// twice the magnitude when one looks at the actual dz distortions.
-// <p>
-// In addition, this class allows a correction regarding the different arrival times
-// of the electrons due to the geometrical difference of the inner and outer chambers.
-// The impact was simulated via Garfield. If the flag is set via the
-// function SetElectronArrivalCorrection, the electron-arrival correction is added to the dz calculation.
-// End_Html
-//
-// Begin_Macro(source)
-// {
-// gROOT->SetStyle("Plain"); gStyle->SetPalette(1);
-// TCanvas *c2 = new TCanvas("cAliTPCROCVoltError3D","cAliTPCROCVoltError3D",500,400);
-// AliTPCROCVoltError3D roc;
-// roc.SetROCDataFileName("$ALICE_ROOT/TPC/Calib/maps/TPCROCdzSurvey.root");
-// roc.SetElectronArrivalCorrection(kFALSE); // Correction for electron arrival offset, IROC vs OROC
-// roc.SetROCDisplacement(kTRUE); // include the chamber offset in z when calculating the dz
-// roc.SetOmegaTauT1T2(0,1,1); // B=0
-// roc.CreateHistoDZinXY(1.,300,300)->Draw("colz");
-// return c2;
-// }
-// End_Macro
-//
-// Begin_Html
-// <p>
-// Date: 08/08/2010 <br>
-// Authors: Jim Thomas, Stefan Rossegger
-// End_Html
-// _________________________________________________________________
+/// \class AliTPCROCVoltError3D
+/// \brief The class calculates the space point distortions due to z offsets of the
+///
+/// ROCs via the residual voltage technique (Poisson relaxation) in 3D.
+/// Since the GG (part of the ROCs) represents the closure of the FC in z direction,
+/// every misalignment in z produces not only dz distortions but also electrical
+/// field inhomogeneities throughout the volume, which produces additional dr and rd$\phi$ distortions.
+///
+/// Each ROC can be misaligned (in z direction) in three ways. A general z0 offset,
+/// an inclination along the x and an inclination along the y axis. The z-misalignment's
+/// can be set via the function SetROCData(TMatrixD *mat) for each single chamber (ROC).
+/// The array size has to be (72,3) representing the 72 chambers according to the
+/// offline numbering scheme (IROC: roc$<$36; OROC: roc$\geq$36) and the three misalignment's
+/// (see the source code for further details).
+///
+/// Internally, these z offsets (unit is cm) are recalculated into residual voltage
+/// equivalents in order to make use of the relaxation technique.
+///
+/// One has two possibilities when calculating the $dz$ distortions. The resulting
+/// distortions are purely due to the change of the drift velocity (along with the
+/// change of the drift field) when the SetROCDisplacement is FALSE.
+/// For this class, this is a rather unphysical setting and should be avoided.
+/// When the flag is set to TRUE, the corresponding offset in z is added to the dz
+/// calculation of the outer ROCs.
+/// For the Alice TPC gas, both effects are of similar magnitude. This means, if the
+/// drift length is sufficiently large, a z-offset of a chamber appears to have (approx.)
+/// twice the magnitude when one looks at the actual dz distortions.
+///
+/// In addition, this class allows a correction regarding the different arrival times
+/// of the electrons due to the geometrical difference of the inner and outer chambers.
+/// The impact was simulated via Garfield. If the flag is set via the
+/// function SetElectronArrivalCorrection, the electron-arrival correction is added to the dz calculation.
+/// 
+///
+/// \author Jim Thomas, Stefan Rossegger
+/// \date 08/08/2010
#include "AliMagF.h"
#include "AliTPCROC.h"
#include "AliTPCROCVoltError3D.h"
+/// \cond CLASSIMP
ClassImp(AliTPCROCVoltError3D)
+/// \endcond
AliTPCROCVoltError3D::AliTPCROCVoltError3D()
: AliTPCCorrection("ROCVoltErrors","ROC z alignment Errors"),
fROCdisplacement(kTRUE),
fElectronArrivalCorrection(kTRUE),
fInitLookUp(kFALSE),
- fROCDataFileName(""),
+ fROCDataFileName(""),
fdzDataLinFit(0)
{
//
// main input: z alignment of the Read Out chambers
// see InitROCVoltError3D() function
for ( Int_t k = 0 ; k < kNPhi ; k++ ) {
- fLookUpErOverEz[k] = new TMatrixF(kNR,kNZ);
+ fLookUpErOverEz[k] = new TMatrixF(kNR,kNZ);
fLookUpEphiOverEz[k] = new TMatrixF(kNR,kNZ);
- fLookUpDeltaEz[k] = new TMatrixF(kNR,kNZ);
+ fLookUpDeltaEz[k] = new TMatrixF(kNR,kNZ);
}
// fROCDataFileName="$ALICE_ROOT/TPC/Calib/maps/TPCROCdzSurvey.root";
// SetROCDataFileName(fROCDataFileName.Data()); // initialization of fdzDataLinFit is included
}
AliTPCROCVoltError3D::~AliTPCROCVoltError3D() {
- //
- // destructor
- //
-
+ /// destructor
+
for ( Int_t k = 0 ; k < kNPhi ; k++ ) {
delete fLookUpErOverEz[k];
delete fLookUpEphiOverEz[k];
Bool_t AliTPCROCVoltError3D::AddCorrectionCompact(AliTPCCorrection* corr, Double_t weight){
- //
- // Add correction and make them compact
- // Assumptions:
- // - origin of distortion/correction are additive
- // - only correction ot the same type supported ()
+ /// Add correction and make them compact
+ /// Assumptions:
+ /// - origin of distortion/correction are additive
+ /// - only correction ot the same type supported ()
+
if (corr==NULL) {
AliError("Zerro pointer - correction");
return kFALSE;
- }
+ }
AliTPCROCVoltError3D * corrC = dynamic_cast<AliTPCROCVoltError3D *>(corr);
if (corrC == NULL) {
AliError(TString::Format("Inconsistent class types: %s\%s",IsA()->GetName(),corr->IsA()->GetName()).Data());
void AliTPCROCVoltError3D::SetROCData(TMatrixD * matrix){
- //
- // Set a z alignment map of the chambers not via a file, but
- // directly via a TMatrix(72,3), where dz = p0 + p1*(lx-133.4) + p2*ly (all in cm)
- //
+ /// Set a z alignment map of the chambers not via a file, but
+ /// directly via a TMatrix(72,3), where dz = p0 + p1*(lx-133.4) + p2*ly (all in cm)
+
if (!fdzDataLinFit) fdzDataLinFit=new TMatrixD(*matrix);
else *fdzDataLinFit = *matrix;
}
void AliTPCROCVoltError3D::Init() {
- //
- // Initialization funtion
- //
-
+ /// Initialization funtion
+
AliMagF* magF= (AliMagF*)TGeoGlobalMagField::Instance()->GetField();
if (!magF) AliError("Magneticd field - not initialized");
Double_t bzField = magF->SolenoidField()/10.; //field in T
if (!param) AliError("Parameters - not initialized");
Double_t vdrift = param->GetDriftV()/1000000.; // [cm/us] // From dataBase: to be updated: per second (ideally)
Double_t ezField = 400; // [V/cm] // to be updated: never (hopefully)
- Double_t wt = -10.0 * (bzField*10) * vdrift / ezField ;
+ Double_t wt = -10.0 * (bzField*10) * vdrift / ezField ;
// Correction Terms for effective omegaTau; obtained by a laser calibration run
SetOmegaTauT1T2(wt,fT1,fT2);
}
void AliTPCROCVoltError3D::Update(const TTimeStamp &/*timeStamp*/) {
- //
- // Update function
- //
+ /// Update function
+
AliMagF* magF= (AliMagF*)TGeoGlobalMagField::Instance()->GetField();
if (!magF) AliError("Magneticd field - not initialized");
Double_t bzField = magF->SolenoidField()/10.; //field in T
if (!param) AliError("Parameters - not initialized");
Double_t vdrift = param->GetDriftV()/1000000.; // [cm/us] // From dataBase: to be updated: per second (ideally)
Double_t ezField = 400; // [V/cm] // to be updated: never (hopefully)
- Double_t wt = -10.0 * (bzField*10) * vdrift / ezField ;
+ Double_t wt = -10.0 * (bzField*10) * vdrift / ezField ;
// Correction Terms for effective omegaTau; obtained by a laser calibration run
SetOmegaTauT1T2(wt,fT1,fT2);
}
void AliTPCROCVoltError3D::SetROCDataFileName(const char * fname) {
- //
- // Set / load the ROC data (linear fit of ROC misalignments)
- //
+ /// Set / load the ROC data (linear fit of ROC misalignments)
fROCDataFileName = fname;
-
+
TFile f(fROCDataFileName.Data(),"READ");
TMatrixD *m = (TMatrixD*) f.Get("dzSurveyLinFitData");
TMatrixD &mf = *m;
if (fdzDataLinFit) delete fdzDataLinFit;
fdzDataLinFit = new TMatrixD(72,3);
TMatrixD &dataIntern = *fdzDataLinFit;
-
+
for (Int_t iroc=0;iroc<72;iroc++) {
dataIntern(iroc,0) = mf(iroc,0); // z0 offset
dataIntern(iroc,1) = mf(iroc,1); // slope in x
}
void AliTPCROCVoltError3D::GetCorrection(const Float_t x[],const Short_t roc,Float_t dx[]) {
- //
- // Calculates the correction due e.g. residual voltage errors on the TPC boundaries
- //
+ /// Calculates the correction due e.g. residual voltage errors on the TPC boundaries
+
const Double_t kEpsilon=Double_t(FLT_MIN);
if (!fInitLookUp) {
AliInfo("Lookup table was not initialized! Perform the inizialisation now ...");
forceInit=kFALSE;
}
-
- Int_t order = 1 ; // FIXME: hardcoded? Linear interpolation = 1, Quadratic = 2
+
+ Int_t order = 1 ; // FIXME: hardcoded? Linear interpolation = 1, Quadratic = 2
Float_t intEr, intEphi, intDeltaEz;
Double_t r, phi, z ;
} else {
sign = -1; // (TPC C side)
}
-
+
if ( sign==1 && z < fgkZOffSet ) z = fgkZOffSet; // Protect against discontinuity at CE
if ( sign==-1 && z > -fgkZOffSet ) z = -fgkZOffSet; // Protect against discontinuity at CE
-
+
if ( (sign==1 && z<0) || (sign==-1 && z>0) ) // just a consistency check
AliError("ROC number does not correspond to z coordinate! Calculation of distortions is most likely wrong!");
- // Get the Er and Ephi field integrals plus the integral over DeltaEz
- intEr = Interpolate3DTable(order, r, z, phi, kNR, kNZ, kNPhi,
+ // Get the Er and Ephi field integrals plus the integral over DeltaEz
+ intEr = Interpolate3DTable(order, r, z, phi, kNR, kNZ, kNPhi,
fgkRList, fgkZList, fgkPhiList, fLookUpErOverEz );
- intEphi = Interpolate3DTable(order, r, z, phi, kNR, kNZ, kNPhi,
+ intEphi = Interpolate3DTable(order, r, z, phi, kNR, kNZ, kNPhi,
fgkRList, fgkZList, fgkPhiList, fLookUpEphiOverEz);
- intDeltaEz = Interpolate3DTable(order, r, z, phi, kNR, kNZ, kNPhi,
+ intDeltaEz = Interpolate3DTable(order, r, z, phi, kNR, kNZ, kNPhi,
fgkRList, fgkZList, fgkPhiList, fLookUpDeltaEz );
// printf("%lf %lf %lf\n",intEr,intEphi,intDeltaEz);
// Calculate distorted position
if ( r > 0.0 ) {
- phi = phi + ( fC0*intEphi - fC1*intEr ) / r;
- r = r + ( fC0*intEr + fC1*intEphi );
+ phi = phi + ( fC0*intEphi - fC1*intEr ) / r;
+ r = r + ( fC0*intEr + fC1*intEphi );
}
-
+
// Calculate correction in cartesian coordinates
dx[0] = r * TMath::Cos(phi) - x[0];
- dx[1] = r * TMath::Sin(phi) - x[1];
- dx[2] = intDeltaEz; // z distortion - (internally scaled with driftvelocity dependency
+ dx[1] = r * TMath::Sin(phi) - x[1];
+ dx[2] = intDeltaEz; // z distortion - (internally scaled with driftvelocity dependency
// on the Ez field plus the actual ROC misalignment (if set TRUE)
// due to different position of the anode wires) -> vd*dt -> 2.64*0.014 = 0.0369 cm
// FIXME: correction are token from Magboltz simulations
// should be loaded from a database
-
+
AliTPCROC * rocInfo = AliTPCROC::Instance();
Double_t rCrossingROC = (rocInfo->GetPadRowRadii(0,62)+rocInfo->GetPadRowRadii(36,0))/2;
-
+
if (r>rCrossingROC) {
if (sign==1)
dx[2] += 0.0369; // A side - negative correction
else
dx[2] -= 0.0369; // C side - positive correction
}
-
+
}
}
void AliTPCROCVoltError3D::InitROCVoltError3D() {
- //
- // Initialization of the Lookup table which contains the solutions of the
- // Dirichlet boundary problem
- // Calculation of the single 3D-Poisson solver is done just if needed
- // (see basic lookup tables in header file)
- //
+ /// Initialization of the Lookup table which contains the solutions of the
+ /// Dirichlet boundary problem
+ /// Calculation of the single 3D-Poisson solver is done just if needed
+ /// (see basic lookup tables in header file)
- const Int_t order = 1 ; // Linear interpolation = 1, Quadratic = 2
+ const Int_t order = 1 ; // Linear interpolation = 1, Quadratic = 2
const Float_t gridSizeR = (fgkOFCRadius-fgkIFCRadius) / (kRows-1) ;
const Float_t gridSizeZ = fgkTPCZ0 / (kColumns-1) ;
const Float_t gridSizePhi = TMath::TwoPi() / ( 18.0 * kPhiSlicesPerSector);
// temporary arrays to create the boundary conditions
- TMatrixD *arrayofArrayV[kPhiSlices], *arrayofCharge[kPhiSlices] ;
- TMatrixD *arrayofEroverEz[kPhiSlices], *arrayofEphioverEz[kPhiSlices], *arrayofDeltaEz[kPhiSlices] ;
+ TMatrixD *arrayofArrayV[kPhiSlices], *arrayofCharge[kPhiSlices] ;
+ TMatrixD *arrayofEroverEz[kPhiSlices], *arrayofEphioverEz[kPhiSlices], *arrayofDeltaEz[kPhiSlices] ;
for ( Int_t k = 0 ; k < kPhiSlices ; k++ ) {
arrayofArrayV[k] = new TMatrixD(kRows,kColumns) ;
arrayofEphioverEz[k] = new TMatrixD(kRows,kColumns) ;
arrayofDeltaEz[k] = new TMatrixD(kRows,kColumns) ;
}
-
+
// list of point as used in the poisson relation and the interpolation (during sum up)
Double_t rlist[kRows], zedlist[kColumns] , philist[kPhiSlices];
for ( Int_t k = 0 ; k < kPhiSlices ; k++ ) {
// ==========================================================================
// Solve Poisson's equation in 3D cylindrical coordinates by relaxation technique
// Allow for different size grid spacing in R and Z directions
-
+
const Int_t symmetry = 0;
-
+
// Set bondaries and solve Poisson's equation --------------------------
-
+
if ( !fInitLookUp ) {
-
+
AliInfo(Form("Solving the poisson equation (~ %d sec)",2*10*(int)(kPhiSlices/10)));
-
+
for ( Int_t side = 0 ; side < 2 ; side++ ) { // Solve Poisson3D twice; once for +Z and once for -Z
-
+
for ( Int_t k = 0 ; k < kPhiSlices ; k++ ) {
TMatrixD &arrayV = *arrayofArrayV[k] ;
TMatrixD &charge = *arrayofCharge[k] ;
-
+
//Fill arrays with initial conditions. V on the boundary and Charge in the volume.
for ( Int_t i = 0 ; i < kRows ; i++ ) {
for ( Int_t j = 0 ; j < kColumns ; j++ ) { // Fill Vmatrix with Boundary Conditions
- arrayV(i,j) = 0.0 ;
+ arrayV(i,j) = 0.0 ;
charge(i,j) = 0.0 ;
Float_t radius0 = rlist[i] ;
Float_t phi0 = gridSizePhi * k ;
-
+
// To avoid problems at sector boundaries, use an average of +- 1 degree from actual phi location
if ( j == (kColumns-1) ) {
arrayV(i,j) = 0.5* ( GetROCVoltOffset( side, radius0, phi0+0.02 ) + GetROCVoltOffset( side, radius0, phi0-0.02 ) ) ;
arrayV(i,j) = -arrayV(i,j); // minus sign on the C side to allow a consistent usage of global z when setting the boundaries
}
}
- }
-
- for ( Int_t i = 1 ; i < kRows-1 ; i++ ) {
+ }
+
+ for ( Int_t i = 1 ; i < kRows-1 ; i++ ) {
for ( Int_t j = 1 ; j < kColumns-1 ; j++ ) {
charge(i,j) = 0.0 ;
}
}
- }
-
+ }
+
// Solve Poisson's equation in 3D cylindrical coordinates by relaxation technique
// Allow for different size grid spacing in R and Z directions
-
- PoissonRelaxation3D( arrayofArrayV, arrayofCharge,
+
+ PoissonRelaxation3D( arrayofArrayV, arrayofCharge,
arrayofEroverEz, arrayofEphioverEz, arrayofDeltaEz,
- kRows, kColumns, kPhiSlices, gridSizePhi, kIterations,
+ kRows, kColumns, kPhiSlices, gridSizePhi, kIterations,
symmetry, fROCdisplacement) ;
-
-
+
+
//Interpolate results onto a custom grid which is used just for these calculations.
Double_t r, phi, z ;
for ( Int_t k = 0 ; k < kNPhi ; k++ ) {
phi = fgkPhiList[k] ;
-
+
TMatrixF &erOverEz = *fLookUpErOverEz[k] ;
TMatrixF &ephiOverEz = *fLookUpEphiOverEz[k];
TMatrixF &deltaEz = *fLookUpDeltaEz[k] ;
-
+
for ( Int_t j = 0 ; j < kNZ ; j++ ) {
z = TMath::Abs(fgkZList[j]) ; // Symmetric solution in Z that depends only on ABS(Z)
-
+
if ( side == 0 && fgkZList[j] < 0 ) continue; // Skip rest of this loop if on the wrong side
if ( side == 1 && fgkZList[j] > 0 ) continue; // Skip rest of this loop if on the wrong side
-
- for ( Int_t i = 0 ; i < kNR ; i++ ) {
+
+ for ( Int_t i = 0 ; i < kNR ; i++ ) {
r = fgkRList[i] ;
// Interpolate basicLookup tables; once for each rod, then sum the results
- erOverEz(i,j) = Interpolate3DTable(order, r, z, phi, kRows, kColumns, kPhiSlices,
+ erOverEz(i,j) = Interpolate3DTable(order, r, z, phi, kRows, kColumns, kPhiSlices,
rlist, zedlist, philist, arrayofEroverEz );
ephiOverEz(i,j) = Interpolate3DTable(order, r, z, phi, kRows, kColumns, kPhiSlices,
rlist, zedlist, philist, arrayofEphioverEz);
if ( side == 1 ) AliInfo(" C side done");
} // end side loop
}
-
+
// clear the temporary arrays lists
for ( Int_t k = 0 ; k < kPhiSlices ; k++ ) {
delete arrayofArrayV[k];
delete arrayofCharge[k];
- delete arrayofEroverEz[k];
+ delete arrayofEroverEz[k];
delete arrayofEphioverEz[k];
delete arrayofDeltaEz[k];
}
-
+
fInitLookUp = kTRUE;
Float_t AliTPCROCVoltError3D::GetROCVoltOffset(Int_t side, Float_t r0, Float_t phi0) {
- //
- // Returns the dz alignment data (in voltage equivalents) at
- // the given position
- //
+ /// Returns the dz alignment data (in voltage equivalents) at
+ /// the given position
Float_t xp = r0*TMath::Cos(phi0);
Float_t yp = r0*TMath::Sin(phi0);
-
- // phi0 should be between 0 and 2pi
+
+ // phi0 should be between 0 and 2pi
if (phi0<0) phi0+=TMath::TwoPi();
Int_t roc = (Int_t)TMath::Floor((TMath::RadToDeg()*phi0)/20);
if (side==1) roc+=18; // C side
- if (r0>132) roc+=36; // OROC
-
+ if (r0>132) roc+=36; // OROC
+
// linear-plane data: z = z0 + kx*lx + ky*ly (rotation in local coordinates)
TMatrixD &fitData = *fdzDataLinFit;
- // local coordinates
+ // local coordinates
Double_t secAlpha = TMath::DegToRad()*(10.+20.*(((Int_t)roc)%18));
Float_t lx = xp*TMath::Cos(secAlpha)+yp*TMath::Sin(secAlpha);
Float_t ly = yp*TMath::Cos(secAlpha)-xp*TMath::Sin(secAlpha);
// reference of rotation in lx is at the intersection between OROC and IROC
// necessary, since the Fitprozedure is otherwise useless
-
+
AliTPCROC * rocInfo = AliTPCROC::Instance();
Double_t lxRef = (rocInfo->GetPadRowRadii(0,62)+rocInfo->GetPadRowRadii(36,0))/2;
-
+
Float_t dz = fitData(roc,0)+fitData(roc,1)*(lx-lxRef) + fitData(roc,2)*ly; // value in cm
// aproximated Voltage-offset-aquivalent to the z misalignment
// (linearly scaled with the z position)
- Double_t ezField = (fgkCathodeV-fgkGG)/fgkTPCZ0; // = ALICE Electric Field (V/cm) Magnitude ~ -400 V/cm;
+ Double_t ezField = (fgkCathodeV-fgkGG)/fgkTPCZ0; // = ALICE Electric Field (V/cm) Magnitude ~ -400 V/cm;
Float_t voltOff = dz*ezField; // values in "Volt equivalents"
return voltOff;
}
TH2F * AliTPCROCVoltError3D::CreateHistoOfZAlignment(Int_t side, Int_t nx, Int_t ny) {
- //
- // return a simple histogramm containing the input to the poisson solver
- // (z positions of the Read-out chambers, linearly interpolated)
+ /// return a simple histogramm containing the input to the poisson solver
+ /// (z positions of the Read-out chambers, linearly interpolated)
char hname[100];
if (side==0) snprintf(hname,100,"survey_dz_Aside");
Double_t yp = h->GetYaxis()->GetBinCenter(iy);
for (Int_t ix=1;ix<=nx;++ix) {
Double_t xp = h->GetXaxis()->GetBinCenter(ix);
-
+
Float_t r0 = TMath::Sqrt(xp*xp+yp*yp);
- Float_t phi0 = TMath::ATan2(yp,xp);
-
+ Float_t phi0 = TMath::ATan2(yp,xp);
+
Float_t dz = GetROCVoltOffset(side,r0,phi0); // in [volt]
- Double_t ezField = (fgkCathodeV-fgkGG)/fgkTPCZ0; // = ALICE Electric Field (V/cm) Magnitude ~ -400 V/cm;
+ Double_t ezField = (fgkCathodeV-fgkGG)/fgkTPCZ0; // = ALICE Electric Field (V/cm) Magnitude ~ -400 V/cm;
dz = dz/ezField; // in [cm]
if (85.<=r0 && r0<=245.) {
- h->SetBinContent(ix,iy,dz);
+ h->SetBinContent(ix,iy,dz);
} else {
h->SetBinContent(ix,iy,0.);
}
}
}
-
+
h->GetXaxis()->SetTitle("x [cm]");
h->GetYaxis()->SetTitle("y [cm]");
h->GetZaxis()->SetTitle("dz [cm]");
// h->DrawCopy("colz");
return h;
-}
+}
void AliTPCROCVoltError3D::Print(const Option_t* option) const {
- //
- // Print function to check the settings of the Rod shifts and the rotated clips
- // option=="a" prints the C0 and C1 coefficents for calibration purposes
- //
+ /// Print function to check the settings of the Rod shifts and the rotated clips
+ /// option=="a" prints the C0 and C1 coefficents for calibration purposes
TString opt = option; opt.ToLower();
printf("%s\n",GetTitle());
if (opt.Contains("a")) { // Print all details
TMatrixD &fitData = *fdzDataLinFit;
printf(" A side: IROC ROCX=(z0,kx,ky): \n");
- for (Int_t roc = 0; roc<18; roc++)
+ for (Int_t roc = 0; roc<18; roc++)
printf("ROC%d:(%.2e,%.2e,%.2e) ",roc,fitData(roc,0),fitData(roc,1),fitData(roc,2));
printf("\n A side: OROC ROCX=(z0,kx,ky): \n");
- for (Int_t roc = 36; roc<54; roc++)
+ for (Int_t roc = 36; roc<54; roc++)
printf("ROC%d:(%.2e,%.2e,%.2e) ",roc,fitData(roc,0),fitData(roc,1),fitData(roc,2));
printf("\n C side: IROC ROCX=(z0,kx,ky): \n");
- for (Int_t roc = 18; roc<36; roc++)
+ for (Int_t roc = 18; roc<36; roc++)
printf("ROC%d:(%.2e,%.2e,%.2e) ",roc,fitData(roc,0),fitData(roc,1),fitData(roc,2));
printf("\n C side: OROC ROCX=(z0,kx,ky): \n");
- for (Int_t roc = 54; roc<72; roc++)
+ for (Int_t roc = 54; roc<72; roc++)
printf("ROC%d:(%.2e,%.2e,%.2e) ",roc,fitData(roc,0),fitData(roc,1),fitData(roc,2));
printf("\n\n");
printf(" - T1: %1.4f, T2: %1.4f \n",fT1,fT2);
/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
* See cxx source for full Copyright notice */
-////////////////////////////////////////////////////////////////////////////
-// AliTPCROCVoltError3D class //
-// Authors: Jim Thomas, Stefan Rossegger //
-////////////////////////////////////////////////////////////////////////////
+/// \class AliTPCROCVoltError3D
+/// \author Jim Thomas, Stefan Rossegger
#include "AliTPCCorrection.h"
#include "TH2F.h"
Float_t GetC0() const {return fC0;}
Float_t GetC1() const {return fC1;}
void SetROCData(TMatrixD * matrix);
- // setters and getters
+ // setters and getters
void SetROCDataFileName(const char * fname);
const Char_t* GetROCDataFileName() const {return fROCDataFileName.Data();}
- // flag to wheter or not include the z aligment in the dz calculation
+ // flag to wheter or not include the z aligment in the dz calculation
// if FALSE, the dz offset is purely due to the electric field change
- void SetROCDisplacement(Bool_t flag) {
+ void SetROCDisplacement(Bool_t flag) {
if (flag!=fROCdisplacement) { fROCdisplacement = flag; fInitLookUp=kFALSE; }
}
Bool_t GetROCDisplacement() const { return fROCdisplacement; }
-
+
// flag on wheter to consider the difference in the electron arrival between IROC and OROC
// due to the different position of the Anode wires
- void SetElectronArrivalCorrection(Bool_t flag) {
+ void SetElectronArrivalCorrection(Bool_t flag) {
if (flag!=fElectronArrivalCorrection) { fElectronArrivalCorrection = flag; fInitLookUp=kFALSE; }
}
Bool_t GetElectronArrivalCorrection() const { return fElectronArrivalCorrection; }
void InitROCVoltError3D(); // Fill the lookup tables
- void ForceInitROCVoltError3D() { fInitLookUp=kFALSE; InitROCVoltError3D(); };
+ void ForceInitROCVoltError3D() { fInitLookUp=kFALSE; InitROCVoltError3D(); };
Float_t GetROCVoltOffset(Int_t side, Float_t r0, Float_t phi0);
TH2F* CreateHistoOfZAlignment(Int_t side, Int_t nx=250, Int_t ny=250);
virtual void Print(const Option_t* option="") const;
- TMatrixD *GetMatrix() const {return fdzDataLinFit;} // Linear fits of dz survey points (each sector=72) (z0,slopeX,slopeY)
+ TMatrixD *GetMatrix() const {return fdzDataLinFit;} // Linear fits of dz survey points (each sector=72) (z0,slopeX,slopeY)
protected:
virtual void GetCorrection(const Float_t x[],const Short_t roc,Float_t dx[]);
AliTPCROCVoltError3D(const AliTPCROCVoltError3D &); // not implemented
AliTPCROCVoltError3D &operator=(const AliTPCROCVoltError3D &); // not implemented
- Float_t fC0; // coefficient C0 (compare Jim Thomas's notes for definitions)
- Float_t fC1; // coefficient C1 (compare Jim Thomas's notes for definitions)
+ Float_t fC0; ///< coefficient C0 (compare Jim Thomas's notes for definitions)
+ Float_t fC1; ///< coefficient C1 (compare Jim Thomas's notes for definitions)
- Bool_t fROCdisplacement; // flag on wheter to consider the ROC displacement
+ Bool_t fROCdisplacement; ///< flag on wheter to consider the ROC displacement
// when calculating the z distortions
- Bool_t fElectronArrivalCorrection; // flag on wheter to consider the difference
+ Bool_t fElectronArrivalCorrection; ///< flag on wheter to consider the difference
// in the electron arrival between IROC and OROC
// due to the different position of the Anode wires
- Bool_t fInitLookUp; // flag to check it the Look Up table was created (SUM)
+ Bool_t fInitLookUp; ///< flag to check it the Look Up table was created (SUM)
- TMatrixF *fLookUpErOverEz[kNPhi]; // Array to store electric field integral (int Er/Ez)
- TMatrixF *fLookUpEphiOverEz[kNPhi]; // Array to store electric field integral (int Er/Ez)
- TMatrixF *fLookUpDeltaEz[kNPhi]; // Array to store electric field integral (int Er/Ez)
+ TMatrixF *fLookUpErOverEz[kNPhi]; ///< Array to store electric field integral (int Er/Ez)
+ TMatrixF *fLookUpEphiOverEz[kNPhi]; ///< Array to store electric field integral (int Er/Ez)
+ TMatrixF *fLookUpDeltaEz[kNPhi]; ///< Array to store electric field integral (int Er/Ez)
- TString fROCDataFileName; // filename of the survey data containing the lin Fit values
- TMatrixD *fdzDataLinFit; // Linear fits of dz survey points (each sector=72) (z0,slopeX,slopeY)
+ TString fROCDataFileName; ///< filename of the survey data containing the lin Fit values
+ TMatrixD *fdzDataLinFit; ///< Linear fits of dz survey points (each sector=72) (z0,slopeX,slopeY)
// basic numbers for the poisson relaxation //can be set individually in each class
enum {kRows =257}; // grid size in r direction used in the poisson relaxation // ( 2**n + 1 ) eg. 65, 129, 257 etc.
enum {kColumns=129}; // grid size in z direction used in the poisson relaxation // ( 2**m + 1 ) eg. 65, 129, 257 etc.
enum {kPhiSlicesPerSector=10}; // phi slices per sector
enum {kPhiSlices = 18*kPhiSlicesPerSector }; // number of points in phi for the basic lookup tables
- enum {kIterations=100}; // Number of iterations within the poisson relaxation
+ enum {kIterations=100}; // Number of iterations within the poisson relaxation
- ClassDef(AliTPCROCVoltError3D,2);
+ /// \cond CLASSIMP
+ ClassDef(AliTPCROCVoltError3D,2);
+ /// \endcond
};
#endif
* provided "as is" without express or implied warranty. *
**************************************************************************/
-/* $Id: AliTPCRawStreamV3.cxx 22777 2007-12-05 17:37:33Z marian $ */
-///////////////////////////////////////////////////////////////////////////////
-///
-/// This class provides access to TPC digits in raw data.
+/// \class AliTPCRawStreamV3
+/// \brief This class provides access to TPC digits in raw data.
///
/// It loops over all TPC digits in the raw data given by the AliRawReader.
/// The NextChannel method loads the data for the next pad. If there is no pad left
/// it returns kFALSE.
-///
-///////////////////////////////////////////////////////////////////////////////
#include <TSystem.h>
#include "AliLog.h"
#include "AliTPCAltroMapping.h"
+/// \cond CLASSIMP
ClassImp(AliTPCRawStreamV3)
+/// \endcond
//_____________________________________________________________________________
AliTPCRawStreamV3::AliTPCRawStreamV3(AliRawReader* rawReader, AliAltroMapping **mapping) :
else
return kFALSE;
*/
-
+
fPrevRow = fRow;
fPrevPad = fPad;
fRow = -1;
fPrevSector = fSector;
fSector = -1;
if (!AliAltroRawStreamV3::NextDDL()) return kFALSE;
-
+
Int_t ddlNumber = GetDDLNumber();
if (ddlNumber < 72) {
fSector = ddlNumber / 2;
fSector = (ddlNumber - 72) / 4 + 36;
patchIndex = (ddlNumber - 72) % 4 + 2;
}
-
+
Short_t hwAddress = GetHWAddress();
fRow = fMapping[patchIndex]->GetPadRow(hwAddress);
fPad = fMapping[patchIndex]->GetPad(hwAddress);
-
+
// if ((fRow < 0) || (fPad < 0))
// AddMappingErrorLog(Form("hw=%d",hwAddress));
/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
* See cxx source for full Copyright notice */
-///////////////////////////////////////////////////////////////////////////////
-///
-/// This class provides access to TPC digits in raw data.
-///
-///////////////////////////////////////////////////////////////////////////////
+/// \class AliTPCRawStreamV3
+/// \brief This class provides access to TPC digits in raw data.
#include "AliAltroRawStreamV3.h"
virtual void Reset();
virtual Bool_t NextChannel();
virtual Bool_t NextDDL();
-
+
inline Int_t GetSector() const { return fSector; } // Provide index of current sector
inline Int_t GetPrevSector() const { return fPrevSector; } // Provide index of previous sector
inline Bool_t IsNewSector() const {return fSector != fPrevSector;};
virtual void ApplyAltroMapping();
- Int_t fSector; // index of current sector
- Int_t fPrevSector; // index of previous sector
- Int_t fRow; // index of current row
- Int_t fPrevRow; // index of previous row
- Int_t fPad; // index of current pad
- Int_t fPrevPad; // index of previous pad
- Int_t fPatchIndex; // current patch
+ Int_t fSector; ///< index of current sector
+ Int_t fPrevSector; ///< index of previous sector
+ Int_t fRow; ///< index of current row
+ Int_t fPrevRow; ///< index of previous row
+ Int_t fPad; ///< index of current pad
+ Int_t fPrevPad; ///< index of previous pad
+ Int_t fPatchIndex; ///< current patch
- AliAltroMapping *fMapping[6]; // Pointers to ALTRO mapping
- Bool_t fIsMapOwner; // does object own its mappings?
+ AliAltroMapping *fMapping[6]; ///< Pointers to ALTRO mapping
+ Bool_t fIsMapOwner; ///< does object own its mappings?
+ /// \cond CLASSIMP
ClassDef(AliTPCRawStreamV3, 0) // base class for reading TPC raw digits using the fast algorithm
+ /// \endcond
};
#endif
**************************************************************************/
-///////////////////////////////////////////////////////////////////////////////
-// //
-// Class with TPC reconstruction parameters //
-// //
-//
-/*
- The reconstruction parameters are used in the AliTPCclusterer and AliTPCtracker
-
- They are retrieved:
- 0. User speciefied it in reconstruction macro
- 1. if (not 0) from OCDB - AliTPCcalibDB::GetRecoParam(eventtype)
- 2. if (not 0 or 1) default parameter - High flux enevironment used
-
-
- // Setting for systematic errors addition
- [0] - systematic RMSY
- [1] - systematic RMSZ
- [2] - systematic RMSSNP
- [3] - systematic RMSTheta
- [4] - systematic RMSCuravture - systematic error in 1/cm not in 1/pt
- //
- // How to add it example - 3 mm systematic error y, 3 cm systematic error z (drift)
- Double_t sysError[5]={0.3,3, 0.3/150., 3./150.,0.3/(150*150.)}
- param->SetSystematicError(sysError);
-
-*/
- //
-///////////////////////////////////////////////////////////////////////////////
+/// \class AliTPCRecoParam
+/// \brief Class with TPC reconstruction parameters
+///
+/// The reconstruction parameters are used in the AliTPCclusterer and AliTPCtracker
+///
+/// They are retrieved:
+/// 0. User speciefied it in reconstruction macro
+/// 1. if (not 0) from OCDB - AliTPCcalibDB::GetRecoParam(eventtype)
+/// 2. if (not 0 or 1) default parameter - High flux enevironment used
+///
+/// Setting for systematic errors addition:
+/// [0] - systematic RMSY
+/// [1] - systematic RMSZ
+/// [2] - systematic RMSSNP
+/// [3] - systematic RMSTheta
+/// [4] - systematic RMSCuravture - systematic error in 1/cm not in 1/pt
+///
+/// How to add it example - 3 mm systematic error y, 3 cm systematic error z (drift)
+/// ~~~{.cxx}
+/// Double_t sysError[5]={0.3,3, 0.3/150., 3./150.,0.3/(150*150.)}
+/// param->SetSystematicError(sysError);
+/// ~~~
#include "AliTPCRecoParam.h"
+/// \cond CLASSIMP
ClassImp(AliTPCRecoParam)
+/// \endcond
Bool_t AliTPCRecoParam::fgUseTimeCalibration=kTRUE; // flag usage the time dependent calibration
// to be switched off for pass 0 reconstruction
- // Use static function, other option will be to use
+ // Use static function, other option will be to use
// additional specific storage ?
//_____________________________________________________________________________
fUseHLTClusters(4), // use HLTorRAW data
fUseHLTPreSeeding(0), // no pre-seeding for now
fBClusterSharing(kTRUE),
- fCtgRange(1.05),
+ fCtgRange(1.05),
fMaxSnpTracker(0.95),
fMaxSnpTrack(0.999),
fUseOuterDetectors(kFALSE),
fMinFraction(0.01), // truncated mean - lower threshold
fMaxFaction(0.7), // truncated mean - upper threshold
fNeighborRowsDedx(2), // neighbour rows for below threshold dEdx calculation
- fGainCorrectionHVandPTMode(0), // switch for the usage of GainCorrectionHVandPT (see AliTPCcalibDB::GetGainCorrectionHVandPT
+ fGainCorrectionHVandPTMode(0), // switch for the usage of GainCorrectionHVandPT (see AliTPCcalibDB::GetGainCorrectionHVandPT
fSkipTimeBins(5), // number of time bins to be skiiped (corrupted signal druing gating opening)
fUseTOFCorrection(kTRUE),
fUseSystematicCorrelation(kTRUE)
{
- //
- // constructor
- //
+ /// constructor
+
SetName("TPC");
SetTitle("TPC");
for (Int_t i=0;i<5;i++) fSystematicErrors[i]=0;
// systematic error parameterization at INNER wall of the TPC
fSystematicErrorClusterInner[0]=0.5; // 0.5 cm
- fSystematicErrorClusterInner[1]=5; // 5 cm slope
+ fSystematicErrorClusterInner[1]=5; // 5 cm slope
//
fSystematicErrorCluster[0]=0; // sy cluster error
- fSystematicErrorCluster[1]=0; // sz cluster error
+ fSystematicErrorCluster[1]=0; // sz cluster error
//
fCutSharedClusters[0]=0.5; // maximal allowed fraction of shared clusters - shorter track
fClusterMaxRange[1]=1; // z - time bin range
fKinkAngleCutChi2[0]=9; // angular cut for kink finder - to create a kink
// ~ about 5 % rate for high pt kink finder
- fKinkAngleCutChi2[1]=12; // angular cut for kink finder - to use the partial track // form kink
+ fKinkAngleCutChi2[1]=12; // angular cut for kink finder - to use the partial track // form kink
// ~ about 2 % rate for high pt kink finder
}
//_____________________________________________________________________________
-AliTPCRecoParam::~AliTPCRecoParam()
+AliTPCRecoParam::~AliTPCRecoParam()
{
- //
- // destructor
- //
+ /// destructor
+
}
void AliTPCRecoParam::Print(const Option_t* /*option*/) const{
- //
- //
- //
+ ///
+
AliTPCRecoParam::Dump();
printf("Systematic errors:\n");
const char * cherrs[5]={"sy=","sz=","ssnp=","stheta=","s1pt="};
AliTPCRecoParam *AliTPCRecoParam::GetLowFluxParam(){
- //
- // make default reconstruction parameters for low flux env.
- //
+ /// make default reconstruction parameters for low flux env.
+
AliTPCRecoParam *param = new AliTPCRecoParam;
param->fCtgRange = 10;
param->fFirstBin = 0;
}
AliTPCRecoParam *AliTPCRecoParam::GetHighFluxParam(){
- //
- // make reco parameters for high flux env.
- //
+ /// make reco parameters for high flux env.
+
AliTPCRecoParam *param = new AliTPCRecoParam;
param->fCtgRange = 1.05;
param->fFirstBin = 0;
- param->fLastBin = 1000;
+ param->fLastBin = 1000;
param->fUseTotCharge=kFALSE;
param->SetName("High Flux");
param->SetTitle("High Flux");
}
AliTPCRecoParam *AliTPCRecoParam::GetHLTParam(){
- //
- // make reco parameters for high flux env.
- //
+ /// make reco parameters for high flux env.
+
AliTPCRecoParam *param = new AliTPCRecoParam;
param->fCtgRange = 1.05;
param->fFirstBin = 80;
- param->fLastBin = 1000;
- param->fMaxSnpTracker = 0.9;
- param->fMaxC = 0.06;
+ param->fLastBin = 1000;
+ param->fMaxSnpTracker = 0.9;
+ param->fMaxC = 0.06;
//
param->SetName("Hlt Param");
- param->SetTitle("Hlt Param");
+ param->SetTitle("Hlt Param");
param->fBKinkFinder = kFALSE;
return param;
}
AliTPCRecoParam *AliTPCRecoParam::GetLaserTestParam(Bool_t bPedestal){
- //
- // special setting for laser
- //
+ /// special setting for laser
+
AliTPCRecoParam *param = new AliTPCRecoParam;
param->fDumpSignal=kTRUE;
param->fCtgRange = 10.05;
}
AliTPCRecoParam *AliTPCRecoParam::GetCosmicTestParam(Bool_t bPedestal){
- //
- // special setting for cosmic
- //
+ /// special setting for cosmic
+
AliTPCRecoParam *param = new AliTPCRecoParam;
param->fDumpSignal=kTRUE;
param->fCtgRange = 10.05; // full TPC
}
-Bool_t AliTPCRecoParam::GetUseTimeCalibration(){
- //
- // get
- //
+Bool_t AliTPCRecoParam::GetUseTimeCalibration(){
+ /// get
+
return fgUseTimeCalibration;
}
void AliTPCRecoParam::SetUseTimeCalibration(Bool_t useTimeCalibration) {
- //
- // set
- //
+ /// set
+
fgUseTimeCalibration = useTimeCalibration;
}
/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
* See cxx source for full Copyright notice */
-///////////////////////////////////////////////////////////////////////////////
-// //
-// Class with TPC reconstruction parameters //
-// //
-///////////////////////////////////////////////////////////////////////////////
+/// \class AliTPCRecoParam
+/// \brief Class with TPC reconstruction parameters
#include "AliDetectorRecoParam.h"
class AliTPCRecoParam : public AliDetectorRecoParam
{
- public:
+ public:
AliTPCRecoParam();
virtual ~AliTPCRecoParam();
virtual void Print(const Option_t* option="") const;
Bool_t GetDoUnfold() const { return fBDoUnfold;}
void SetDoUnfold(Bool_t unfold) { fBDoUnfold = unfold;}
Float_t GetDumpAmplitudeMin() const { return fDumpAmplitudeMin;}
- Float_t GetMaxNoise() const { return fMaxNoise;}
+ Float_t GetMaxNoise() const { return fMaxNoise;}
//
Int_t GetUseOnePadCluster() const { return fUseOnePadCluster;}
Bool_t GetUseHLTOnePadCluster()const { return fUseHLTOnePadCluster;}
Float_t GetMinMaxCutAbs() const { return fMinMaxCutAbs; }
Float_t GetMinLeftRightCutAbs() const { return fMinLeftRightCutAbs;} // minimal amplitude left right - PRF
- Float_t GetMinUpDownCutAbs() const { return fMinUpDownCutAbs;} // minimal amplitude up-down - TRF
+ Float_t GetMinUpDownCutAbs() const { return fMinUpDownCutAbs;} // minimal amplitude up-down - TRF
Float_t GetMinMaxCutSigma() const { return fMinMaxCutSigma; }
Float_t GetMinLeftRightCutSigma() const { return fMinLeftRightCutSigma;} // minimal amplitude left right - PRF
- Float_t GetMinUpDownCutSigma() const { return fMinUpDownCutSigma;} // minimal amplitude up-down - TRF
+ Float_t GetMinUpDownCutSigma() const { return fMinUpDownCutSigma;} // minimal amplitude up-down - TRF
//
void SetUseOnePadCluster(Int_t use) { fUseOnePadCluster = use;}
void SetUseHLTOnePadCluster(Bool_t use) { fUseHLTOnePadCluster = use;}
void SetMinMaxCutAbs(Float_t th) { fMinMaxCutAbs=th; }
void SetMinLeftRightCutAbs(Float_t th) { fMinLeftRightCutAbs=th;} // minimal amplitude left right - PRF
- void SetMinUpDownCutAbs(Float_t th) { fMinUpDownCutAbs=th;} // minimal amplitude up-down - TRF
+ void SetMinUpDownCutAbs(Float_t th) { fMinUpDownCutAbs=th;} // minimal amplitude up-down - TRF
void SetMinMaxCutSigma(Float_t th) { fMinMaxCutSigma=th; }
void SetMinLeftRightCutSigma(Float_t th) { fMinLeftRightCutSigma=th;} // minimal amplitude left right - PRF
- void SetMinUpDownCutSigma(Float_t th) { fMinUpDownCutSigma=th;} // minimal amplitude up-down - TRF
+ void SetMinUpDownCutSigma(Float_t th) { fMinUpDownCutSigma=th;} // minimal amplitude up-down - TRF
void SetUseTotCharge(Bool_t flag) {fUseTotCharge = flag;}
void SetCtgRange(Double_t ctgRange) {fCtgRange = ctgRange;}
void SetUseMultiplicityCorrectionDedx(Bool_t flag) {fUseMultiplicityCorrectionDedx = flag;}
-
+
void SetUseAlignmentTime(Bool_t flag) {fUseAlignmentTime = flag;}
void SetNeighborRowsDedx(Int_t nRows) {fNeighborRowsDedx = nRows;}
void SetCorrectionHVandPTMode(Int_t value){ fGainCorrectionHVandPTMode =value;}
void SetSkipTimeBins(Double_t value) {fSkipTimeBins=value;}
//
- Int_t GetLastSeedRowSec() const { return fLastSeedRowSec;}
- Int_t GetSeedGapPrim() const { return fSeedGapPrim;}
- Int_t GetSeedGapSec() const { return fSeedGapSec;}
+ Int_t GetLastSeedRowSec() const { return fLastSeedRowSec;}
+ Int_t GetSeedGapPrim() const { return fSeedGapPrim;}
+ Int_t GetSeedGapSec() const { return fSeedGapSec;}
void SetDoKinks(Bool_t on) { fBKinkFinder=on; }
Bool_t GetDoKinks() const { return fBKinkFinder;}
Double_t GetKinkAngleCutChi2(Int_t index) const {return fKinkAngleCutChi2[index];}
void SetKinkAngleCutChi2(Int_t index,Double_t value) {fKinkAngleCutChi2[index]=value;}
- void SetSeedGapPrim(Int_t seedGapPrim) { fSeedGapPrim = seedGapPrim;}
- void SetSeedGapSec(Int_t seedGapSec) { fSeedGapSec = seedGapSec;}
+ void SetSeedGapPrim(Int_t seedGapPrim) { fSeedGapPrim = seedGapPrim;}
+ void SetSeedGapSec(Int_t seedGapSec) { fSeedGapSec = seedGapSec;}
Float_t GetMaxC() const { return fMaxC;}
Bool_t GetSpecialSeeding() const { return fBSpecialSeeding;}
//
Bool_t GetUseTotCharge() const {return fUseTotCharge;} // switch use total or max charge
Float_t GetMinFraction() const {return fMinFraction;} // truncated mean - lower threshold
Float_t GetMaxFraction() const {return fMaxFaction;} // truncated mean - upper threshold
- Int_t GetNeighborRowsDedx() const {return fNeighborRowsDedx;}
+ Int_t GetNeighborRowsDedx() const {return fNeighborRowsDedx;}
//
void SetSystematicError(Double_t *systematic){ for (Int_t i=0; i<5;i++) fSystematicErrors[i]=systematic[i];}
Bool_t GetUseSystematicCorrelation() const { return fUseSystematicCorrelation;}
static AliTPCRecoParam *GetLowFluxParam(); // make reco parameters for low flux env.
- static AliTPCRecoParam *GetHighFluxParam(); // make reco parameters for high flux env.
- static AliTPCRecoParam *GetHLTParam(); // special setting for HLT
- static AliTPCRecoParam *GetLaserTestParam(Bool_t bPedestal); // special setting for laser
- static AliTPCRecoParam *GetCosmicTestParam(Bool_t bPedestal); // special setting for cosmic
+ static AliTPCRecoParam *GetHighFluxParam(); // make reco parameters for high flux env.
+ static AliTPCRecoParam *GetHLTParam(); // special setting for HLT
+ static AliTPCRecoParam *GetLaserTestParam(Bool_t bPedestal); // special setting for laser
+ static AliTPCRecoParam *GetCosmicTestParam(Bool_t bPedestal); // special setting for cosmic
//
protected:
- Int_t fUseHLTClusters; // allows usage of HLT clusters instead of RAW data
- Int_t fUseHLTPreSeeding; // Usage of HLT pre-seeding
- Bool_t fBClusterSharing; // allows or disable cluster sharing during tracking
- Double_t fCtgRange; // +-fCtgRange is the ctg(Theta) window used for clusterization and tracking (MI)
- Double_t fMaxSnpTracker; // max sin of local angle - for TPC tracker
- Double_t fMaxSnpTrack; // max sin of local angle - for track
- Bool_t fUseOuterDetectors; // switch - to use the outer detectors
- Double_t fMaxChi2TPCTRD; // maximal allowed chi2 between the TRD in and TPC out to be accepted for refit
- Double_t fMaxChi2TPCITS; // maximal allowed chi2 between the ITS in and TPC out to be accepted for backpropagation
+ Int_t fUseHLTClusters; ///< allows usage of HLT clusters instead of RAW data
+ Int_t fUseHLTPreSeeding; ///< Usage of HLT pre-seeding
+ Bool_t fBClusterSharing; ///< allows or disable cluster sharing during tracking
+ Double_t fCtgRange; ///< +-fCtgRange is the ctg(Theta) window used for clusterization and tracking (MI)
+ Double_t fMaxSnpTracker; ///< max sin of local angle - for TPC tracker
+ Double_t fMaxSnpTrack; ///< max sin of local angle - for track
+ Bool_t fUseOuterDetectors; ///< switch - to use the outer detectors
+ Double_t fMaxChi2TPCTRD; ///< maximal allowed chi2 between the TRD in and TPC out to be accepted for refit
+ Double_t fMaxChi2TPCITS; ///< maximal allowed chi2 between the ITS in and TPC out to be accepted for backpropagation
//
// Outlier filtering configuration
//
- Int_t fUseOulierClusterFilter; // swith to use outlier cluster filter
+ Int_t fUseOulierClusterFilter; ///< swith to use outlier cluster filter
- Double_t fCutSharedClusters[2]; // cut value - maximal amount of shared clusters
- Int_t fClusterMaxRange[2]; // neighborhood - to define local maxima for cluster
+ Double_t fCutSharedClusters[2]; ///< cut value - maximal amount of shared clusters
+ Int_t fClusterMaxRange[2]; ///< neighborhood - to define local maxima for cluster
//
// clusterer parameters
//
- Bool_t fDumpSignal; // Dump Signal information flag
- Int_t fFirstBin; // first time bin used by cluster finder
- Int_t fLastBin; // last time bin used by cluster finder
- Bool_t fBCalcPedestal; // calculate Pedestal
- Bool_t fBDoUnfold; // do unfolding of clusters
- Float_t fDumpAmplitudeMin; // minimal amplitude of signal to be dumped
- Float_t fMaxNoise; // maximal noise sigma on pad to be used in cluster finder
- Int_t fUseOnePadCluster; // flag - use one pad cluster -0 not use >0 use
- Bool_t fUseHLTOnePadCluster; // flag - use one HLT pad cluster for tracking
- Float_t fMinMaxCutAbs; // minimal amplitude at cluster maxima
- Float_t fMinLeftRightCutAbs; // minimal amplitude left right - PRF
- Float_t fMinUpDownCutAbs; // minimal amplitude up-down - TRF
- Float_t fMinMaxCutSigma; // minimal amplitude at cluster maxima
- Float_t fMinLeftRightCutSigma; // minimal amplitude left right - PRF
- Float_t fMinUpDownCutSigma; // minimal amplitude up-down - TRF
- //
- //
- Float_t fMaxC; // maximal curvature for tracking
- Bool_t fBSpecialSeeding; // special seeding with big inclination angles allowed (for Cosmic and laser)
- Bool_t fBKinkFinder; // do kink finder reconstruction
- Double_t fKinkAngleCutChi2[2]; // angular cut for kinks
- Int_t fLastSeedRowSec; // Most Inner Row to make seeding for secondaries
- Int_t fSeedGapPrim; // seeding gap for primary tracks
- Int_t fSeedGapSec; // seeding gap for secondary tracks
+ Bool_t fDumpSignal; ///< Dump Signal information flag
+ Int_t fFirstBin; ///< first time bin used by cluster finder
+ Int_t fLastBin; ///< last time bin used by cluster finder
+ Bool_t fBCalcPedestal; ///< calculate Pedestal
+ Bool_t fBDoUnfold; ///< do unfolding of clusters
+ Float_t fDumpAmplitudeMin; ///< minimal amplitude of signal to be dumped
+ Float_t fMaxNoise; ///< maximal noise sigma on pad to be used in cluster finder
+ Int_t fUseOnePadCluster; ///< flag - use one pad cluster -0 not use >0 use
+ Bool_t fUseHLTOnePadCluster; ///< flag - use one HLT pad cluster for tracking
+ Float_t fMinMaxCutAbs; ///< minimal amplitude at cluster maxima
+ Float_t fMinLeftRightCutAbs; ///< minimal amplitude left right - PRF
+ Float_t fMinUpDownCutAbs; ///< minimal amplitude up-down - TRF
+ Float_t fMinMaxCutSigma; ///< minimal amplitude at cluster maxima
+ Float_t fMinLeftRightCutSigma; ///< minimal amplitude left right - PRF
+ Float_t fMinUpDownCutSigma; ///< minimal amplitude up-down - TRF
+ //
+ //
+ Float_t fMaxC; ///< maximal curvature for tracking
+ Bool_t fBSpecialSeeding; ///< special seeding with big inclination angles allowed (for Cosmic and laser)
+ Bool_t fBKinkFinder; ///< do kink finder reconstruction
+ Double_t fKinkAngleCutChi2[2]; ///< angular cut for kinks
+ Int_t fLastSeedRowSec; ///< Most Inner Row to make seeding for secondaries
+ Int_t fSeedGapPrim; ///< seeding gap for primary tracks
+ Int_t fSeedGapSec; ///< seeding gap for secondary tracks
//
// Correction switches
//
- Int_t fUseFieldCorrection; // use field correction
- Bool_t fUseComposedCorrection; // flag to use composed correction
- Int_t fUseRPHICorrection; // use rphi correction
- Int_t fUseRadialCorrection; // use radial correction
- Int_t fUseQuadrantAlignment; // use quadrant alignment
- Int_t fUseSectorAlignment; // use sector alignment
- Int_t fUseDriftCorrectionTime; // use drift correction time
- Int_t fUseDriftCorrectionGY; // use drif correction global y
- Int_t fUseGainCorrectionTime; // use gain correction time
- Int_t fUseExBCorrection; // use ExB correction
- Bool_t fUseMultiplicityCorrectionDedx; // use Dedx multiplicity correction
- Bool_t fUseAlignmentTime; // use time dependent alignment correction
- Int_t fUseIonTailCorrection; // use ion tail correction
- Double_t fCrosstalkCorrection; // crosstalk correction factor (fro each signal substracted by (mean signal in wite patch)xfCrosstalkCorrection) - Effect important only after removing oc capacitors in 2012
- Double_t fCrosstalkCorrectionMissingCharge; // crosstalk correction factor - missing charge factor (from each signal substracted by (mean signal in wite patch)xfCrosstalkCorrection) - Effect important only after removing capacitors in 2012
+ Int_t fUseFieldCorrection; ///< use field correction
+ Bool_t fUseComposedCorrection; ///< flag to use composed correction
+ Int_t fUseRPHICorrection; ///< use rphi correction
+ Int_t fUseRadialCorrection; ///< use radial correction
+ Int_t fUseQuadrantAlignment; ///< use quadrant alignment
+ Int_t fUseSectorAlignment; ///< use sector alignment
+ Int_t fUseDriftCorrectionTime; ///< use drift correction time
+ Int_t fUseDriftCorrectionGY; ///< use drif correction global y
+ Int_t fUseGainCorrectionTime; ///< use gain correction time
+ Int_t fUseExBCorrection; ///< use ExB correction
+ Bool_t fUseMultiplicityCorrectionDedx; ///< use Dedx multiplicity correction
+ Bool_t fUseAlignmentTime; ///< use time dependent alignment correction
+ Int_t fUseIonTailCorrection; ///< use ion tail correction
+ Double_t fCrosstalkCorrection; ///< crosstalk correction factor (fro each signal substracted by (mean signal in wite patch)xfCrosstalkCorrection) - Effect important only after removing oc capacitors in 2012
+ Double_t fCrosstalkCorrectionMissingCharge; ///< crosstalk correction factor - missing charge factor (from each signal substracted by (mean signal in wite patch)xfCrosstalkCorrection) - Effect important only after removing capacitors in 2012
//
// dEdx switches
//
- Bool_t fUseTotCharge; // switch use total or max charge
- Float_t fMinFraction; // truncated mean - lower threshold
- Float_t fMaxFaction; // truncated mean - upper threshold
- Int_t fNeighborRowsDedx; // number of neighboring rows to identify cluster below thres in dEdx calculation 0 -> switch off
- Int_t fGainCorrectionHVandPTMode; // switch for the usage of GainCorrectionHVandPT (see AliTPCcalibDB::GetGainCorrectionHVandPT
- Double_t fSkipTimeBins; // number of time bins to be skiiped (corrupted signal druing gating opening)
+ Bool_t fUseTotCharge; ///< switch use total or max charge
+ Float_t fMinFraction; ///< truncated mean - lower threshold
+ Float_t fMaxFaction; ///< truncated mean - upper threshold
+ Int_t fNeighborRowsDedx; ///< number of neighboring rows to identify cluster below thres in dEdx calculation 0 -> switch off
+ Int_t fGainCorrectionHVandPTMode; ///< switch for the usage of GainCorrectionHVandPT (see AliTPCcalibDB::GetGainCorrectionHVandPT
+ Double_t fSkipTimeBins; ///< number of time bins to be skiiped (corrupted signal druing gating opening)
- Bool_t fUseTOFCorrection; // switch - kTRUE use TOF correction kFALSE - do not use
+ Bool_t fUseTOFCorrection; ///< switch - kTRUE use TOF correction kFALSE - do not use
//
- // misscalibration
+ // misscalibration
//
- Double_t fSystematicErrors[5]; //systematic errors in the track parameters - to be added to TPC covariance matrix
- Double_t fSystematicErrorClusterInner[2]; // systematic error of the cluster - used to downscale the information
- Double_t fSystematicErrorCluster[2]; // systematic error of the cluster - used e.g in OpenGG run to provide better cluster to track association efficiency
- Bool_t fUseSystematicCorrelation; // switch to use the correlation for the sys
-public:
- static Bool_t fgUseTimeCalibration; // flag usage the time dependent calibration
+ Double_t fSystematicErrors[5]; ///< systematic errors in the track parameters - to be added to TPC covariance matrix
+ Double_t fSystematicErrorClusterInner[2]; ///< systematic error of the cluster - used to downscale the information
+ Double_t fSystematicErrorCluster[2]; ///< systematic error of the cluster - used e.g in OpenGG run to provide better cluster to track association efficiency
+ Bool_t fUseSystematicCorrelation; ///< switch to use the correlation for the sys
+public:
+ static Bool_t fgUseTimeCalibration; ///< flag usage the time dependent calibration
// to be switched off for pass 0 reconstruction
- // Use static function, other option will be to use
+ // Use static function, other option will be to use
// additional specific storage ?
+ /// \cond CLASSIMP
ClassDef(AliTPCRecoParam, 21)
+ /// \endcond
};
**************************************************************************/
-////////////////////////////////////////////////////////////////////////////////
-// //
-// Class describing TPC temperature sensors (including pointers to graphs/fits//
-// Authors: Marian Ivanov, Haavard Helstrup and Martin Siska //
-// //
-////////////////////////////////////////////////////////////////////////////////
+/// \class AliTPCSensorTemp
+/// \brief Class describing TPC temperature sensors (including pointers to graphs/fits
+///
+/// \author Marian Ivanov, Haavard Helstrup and Martin Siska
// Running instructions:
/*
tree->Branch("Temp",&arr);
tree->Fill();
tree->Write();
-
+
*/
//
#include <strings.h>
#include "AliTPCSensorTemp.h"
+/// \cond CLASSIMP
ClassImp(AliTPCSensorTemp)
+/// \endcond
{ 64.99, 76.75, 104.97, 122, 139.1},
{ 87.56, 103.4, 141.42, 164.37, 187.41},
{ 99.56, 117.59, 160.82, 186.92, 213.11}};
-
+
const Float_t kASideY[18][5]={
{ 17.56, 20.73, 28.36, 32.96, 37.58},
{ 50.55, 59.7, 81.65, 94.9, 108.2},
{-95.0, -112.2, -153.45, -178.35, -203.35},
{-77.45, -91.47, -125.1, -145.4, -165.77},
{-50.55, -59.7, -81.65, -94.9, -108.2},
- {-17.56, -20.73, -28.36, -32.96, -37.58}};
-
+ {-17.56, -20.73, -28.36, -32.96, -37.58}};
+
const Float_t kCSideX[18][5]={
{ 99.56, 117.59, 160.82, 186.92, 213.11},
{ 87.56, 103.4, 141.42, 164.37, 187.41},
{-95.0, -112.2, -153.45, -178.35, -203.35},
{-77.45, -91.47, -125.1, -145.4, -165.77},
{-50.55, -59.7, -81.65, -94.9, -108.2},
- {-17.56, -20.73, -28.36, -32.96, -37.58}};
+ {-17.56, -20.73, -28.36, -32.96, -37.58}};
const Float_t kIFCrad[5] = {67.2, 64.4, 60.7, 64.4, 67.2};
-const Float_t kTSrad[4] = {67.2, 61.5, 67.2, 61.5};
-const Float_t kTSz[4] = {240.0, 90.0, 240.0, 90.0};
+const Float_t kTSrad[4] = {67.2, 61.5, 67.2, 61.5};
+const Float_t kTSz[4] = {240.0, 90.0, 240.0, 90.0};
//______________________________________________________________________________________________
fSector(0),
fNum(0)
{
- //
- // Standard constructor
- //
+ /// Standard constructor
+
}
//______________________________________________________________________________________________
//______________________________________________________________________________________________
AliTPCSensorTemp& AliTPCSensorTemp::operator=(const AliTPCSensorTemp& source){
-//
-// assignment operator
-//
+/// assignment operator
+
if (&source == this) return *this;
new (this) AliTPCSensorTemp(source);
-
- return *this;
+
+ return *this;
}
//______________________________________________________________________________________________
TClonesArray * AliTPCSensorTemp::ReadList(const char *fname,
const TString& amandaString) {
- //
- // read values from ascii file
- //
+ /// read values from ascii file
+
TTree * tree = new TTree("asci","asci");
tree->ReadFile(fname,"");
TClonesArray *arr = ReadTree(tree, amandaString);
delete tree;
return arr;
}
-
+
//______________________________________________________________________________________________
-TClonesArray * AliTPCSensorTemp::ReadTree(TTree *tree,
+TClonesArray * AliTPCSensorTemp::ReadTree(TTree *tree,
const TString& amandaString) {
-
+
Int_t nentries = tree->GetEntries();
Int_t sensor=0;
Int_t sector=0;
if (bcmp(type,"ROC",3)==0) temp->SetType(0);
if (bcmp(type,"OFC",3)==0) temp->SetType(1);
if (bcmp(type,"IFC",3)==0) temp->SetType(2);
- if (bcmp(type,"TPC",3)==0) temp->SetType(3);
+ if (bcmp(type,"TPC",3)==0) temp->SetType(3);
if (bcmp(type,"ELM",3)==0) temp->SetType(4);
if (bcmp(type,"TS",2)==0) temp->SetType(5);
if (bcmp(type,"COOL",3)==0)temp->SetType(6);
temp->SetX(kCSideX[sector][num]);
} else {
temp->SetX(kASideX[sector][num]);
- }
+ }
}
if ((temp->GetType()==1) || (temp->GetType()==4)){
temp->SetX(TMath::Cos((2*sector+1)*0.1745)*278);
} else {
temp->SetX(TMath::Cos((2*sector+1)*0.1745)*241.8);
}
- }
+ }
if (temp->GetType()==5){
temp->SetX(TMath::Cos(sector*0.524+(num+1)*0.131)*kTSrad[num]);
}
if (temp->GetType()==6){
temp->SetX(0);
}
-
+
//temp->SetY(y);
if (temp->GetType()==0){
// temp->SetY(TMath::Sin((2*sector+1)*0.1745)*(83+(num+1)*30));
temp->SetY(kCSideY[sector][num]);
} else {
temp->SetY(kASideY[sector][num]);
- }
+ }
}
if ((temp->GetType()==1) || (temp->GetType()==4)){
temp->SetY(TMath::Sin((2*sector+1)*0.1745)*278);
} else {
temp->SetY(TMath::Sin((2*sector+1)*0.1745)*241.8);
}
- }
+ }
if (temp->GetType()==5){
temp->SetY(TMath::Sin(sector*0.524+(num+1)*0.131)*kTSrad[num]);
}
//temp->SetZ(z);
- if ((temp->GetType()==0 ||
- temp->GetType()==4 || temp->GetType()==6) &&
+ if ((temp->GetType()==0 ||
+ temp->GetType()==4 || temp->GetType()==6) &&
temp->GetSide()==0) {
temp->SetZ(250);
}
* See cxx source for full Copyright notice */
-////////////////////////////////////////////////////////////////////////////
-// Container class for temperature sensor positions
-////////////////////////////////////////////////////////////////////////////
+/// \class AliTPCSensorTemp
+/// \brief Container class for temperature sensor positions
#include "TMath.h"
AliTPCSensorTemp(const AliTPCSensorTemp& source);
virtual ~AliTPCSensorTemp(){}
AliTPCSensorTemp& operator=(const AliTPCSensorTemp& source);
-
+
Int_t GetType() const {return fType; }
Int_t GetSide() const {return fSide; }
Int_t GetSector() const {return fSector; }
static TClonesArray * ReadList(const char *fname,
const TString& amandaString = kAmandaStringTPC);
- static TClonesArray * ReadTree(TTree *tree,
+ static TClonesArray * ReadTree(TTree *tree,
const TString& amandaString = kAmandaStringTPC);
protected:
- Int_t fType; // Position of sensors on fieldcage
+ Int_t fType; ///< Position of sensors on fieldcage
// (0=ROC,1=OFC,2=IFC,3=TPC,4=ELM,5=TS,6=COOL)
- Int_t fSide; // TPC side; 0:Shaft Side (A) -- 1:Muon Side (C)
- Int_t fSector; // Number of sector (0-17)
- Int_t fNum; // Position depands from type of sensor.
+ Int_t fSide; ///< TPC side; 0:Shaft Side (A) -- 1:Muon Side (C)
+ Int_t fSector; ///< Number of sector (0-17)
+ Int_t fNum; ///< Position depands from type of sensor.
// fType=0(0-4) from inside to outside
// fType=1(0-5) fom A side to C side
// fType=2(0-5) fom A side to C side
- // fType=3(0) one per sector
+ // fType=3(0) one per sector
// fType=4()
// fType=5()
// fType=6(0-1) 0:input -- 1:output
+ /// \cond CLASSIMP
ClassDef(AliTPCSensorTemp,1)
+ /// \endcond
};
#endif
**************************************************************************/
-///////////////////////////////////////////////////////////////////////////////
-// //
-// TPC calibration class for parameters which saved per pad //
-// Authors: Marian Ivanov and Haavard Helstrup //
-// //
-///////////////////////////////////////////////////////////////////////////////
+/// \class AliTPCSensorTempArray
+/// \brief TPC calibration class for parameters which saved per pad
+///
+/// \author Marian Ivanov and Haavard Helstrup
#include "AliTPCSensorTempArray.h"
#include "TLinearFitter.h"
+/// \cond CLASSIMP
ClassImp(AliTPCSensorTempArray)
+/// \endcond
//_____________________________________________________________________________
//
// AliTPCSensorTempArray default constructor
//
-
+
}
//_____________________________________________________________________________
-AliTPCSensorTempArray::AliTPCSensorTempArray(Int_t run) : AliDCSSensorArray()
+AliTPCSensorTempArray::AliTPCSensorTempArray(Int_t run) : AliDCSSensorArray()
{
- //
- // Read configuration from OCDB
- //
+ /// Read configuration from OCDB
+
-
AliCDBEntry *entry =
- AliCDBManager::Instance()->Get("TPC/Config/Temperature",run);
+ AliCDBManager::Instance()->Get("TPC/Config/Temperature",run);
if (entry) {
TTree *tree = (TTree*) entry->GetObject();
fSensors = AliTPCSensorTemp::ReadTree(tree);
TTree* confTree, const TString& amandaString)
:AliDCSSensorArray()
{
- //
- // AliTPCSensorTempArray constructor for Shuttle preprocessor
- // (confTree read from OCDB)
- //
+ /// AliTPCSensorTempArray constructor for Shuttle preprocessor
+ /// (confTree read from OCDB)
+
fSensors = AliTPCSensorTemp::ReadTree(confTree,amandaString);
fSensors->BypassStreamer(kFALSE);
fStartTime = TTimeStamp((time_t)startTime,0);
const TString& amandaString) :
AliDCSSensorArray()
{
- //
- // AliTPCSensorTempArray constructor
- //
+ /// AliTPCSensorTempArray constructor
+
fSensors = AliTPCSensorTemp::ReadList(fname,amandaString);
fSensors->BypassStreamer(kFALSE);
}
AliTPCSensorTempArray::AliTPCSensorTempArray(const AliTPCSensorTempArray &c):
AliDCSSensorArray(c)
{
- //
- // AliTPCSensorTempArray copy constructor
- //
+ /// AliTPCSensorTempArray copy constructor
}
///_____________________________________________________________________________
AliTPCSensorTempArray::~AliTPCSensorTempArray()
{
- //
- // AliTPCSensorTempArray destructor
- //
+ /// AliTPCSensorTempArray destructor
+
}
//_____________________________________________________________________________
AliTPCSensorTempArray &AliTPCSensorTempArray::operator=(const AliTPCSensorTempArray &c)
{
- //
- // Assignment operator
- //
+ /// Assignment operator
+
if (this != &c) {
fSensors->Delete();
new (this) AliTPCSensorTempArray(c);
//_____________________________________________________________________________
void AliTPCSensorTempArray::ReadSensors(const char *dbEntry)
{
- //
- // Read list of temperature sensors from text file
- //
+ /// Read list of temperature sensors from text file
+
AliCDBEntry *entry = AliCDBManager::Instance()->Get(dbEntry);
if (!entry) {
AliWarning(Form("No OCDB entry %s available\n",dbEntry));
return;
- }
+ }
TTree *tree = (TTree*) entry->GetObject();
if (tree) fSensors = AliTPCSensorTemp::ReadTree(tree);
-}
+}
//_____________________________________________________________________________
-AliTPCSensorTemp* AliTPCSensorTempArray::GetSensor(Int_t type, Int_t side, Int_t sector, Int_t num)
+AliTPCSensorTemp* AliTPCSensorTempArray::GetSensor(Int_t type, Int_t side, Int_t sector, Int_t num)
{
- //
- // Return sensor information for sensor specified by type, side, sector and num
- //
+ /// Return sensor information for sensor specified by type, side, sector and num
+
Int_t nsensors = fSensors->GetEntries();
for (Int_t isensor=0; isensor<nsensors; isensor++) {
AliTPCSensorTemp *entry = (AliTPCSensorTemp*)fSensors->At(isensor);
//_____________________________________________________________________________
Double_t AliTPCSensorTempArray::GetTempGradientY(UInt_t timeSec, Int_t side){
- //
- // Extract Linear Vertical Temperature Gradient [K/cm] within the TPC on
- // Shaft Side(A): 0
- // Muon Side(C): 1
- // Values based on TemperatureSensors within the TPC (type: 3(TPC))
- //
- // FIXME: Also return residual-distribution, covariance Matrix
- // or simply chi2 for validity check?
- //
+ /// Extract Linear Vertical Temperature Gradient [K/cm] within the TPC on
+ /// Shaft Side(A): 0
+ /// Muon Side(C): 1
+ /// Values based on TemperatureSensors within the TPC (type: 3(TPC))
+ ///
+ /// FIXME: Also return residual-distribution, covariance Matrix
+ /// or simply chi2 for validity check?
TLinearFitter fitter(3,"x0++x1++x2");
TVectorD param(3);
* See cxx source for full Copyright notice */
-///////////////////////////////////////////////////////////////////////////////
-// //
-// TPC calibration class for temperature sensors //
-// //
-///////////////////////////////////////////////////////////////////////////////
+/// \class AliTPCSensorTempArray
+/// \brief TPC calibration class for temperature sensors
#include "TSystem.h"
protected:
+ /// \cond CLASSIMP
ClassDef(AliTPCSensorTempArray,1) // TPC calibration class for parameters which are saved per pad
+ /// \endcond
};
* provided "as is" without express or implied warranty. *
**************************************************************************/
-// _________________________________________________________________
-//
-// Begin_Html
-// <h2> AliTPCSpaceCharge class </h2>
-// The class calculates the space point distortions due to a rotational
-// symmetric space charge distribution with the TPC drift volume.
-// <p>
-// The class uses the PoissonRelaxation2D to calculate the resulting
-// electrical field inhomogeneities in the (r,z)-plane. Then, the
-// Langevin-integral formalism is used to calculate the space point distortions.
-// <p>
-// The class assumes, that the distortions scales linearly with the magnitude
-// of the space charge distribution $\rho(r,z)$. The in here assumed distribution is
-// $$\rho(r,z) = \frac{(A-B\,z)}{r^2} $$ wherein the factors A and B scale with the
-// event multiplicity and the interaction rate.
-// <p>
-// The scaling factor can be set via the function SetCorrectionFactor. An example of
-// the shape of the distortions is given below.
-//
-// MI modification - 22.05.2013
-// As an optional input the Space charge histogram RZ is used in case it is provided
-// - using the SetInputSpaceCharge function
-//
-// End_Html
-//
-// Begin_Macro(source)
-// {
-// gROOT->SetStyle("Plain"); gStyle->SetPalette(1);
-// TCanvas *c2 = new TCanvas("cAliTPCSpaceCharge","cAliTPCSpaceCharge",500,300);
-// AliTPCSpaceCharge sc;
-// sc.SetOmegaTauT1T2(-0.32,1,1); // B=0.5 Tesla
-// sc.SetCorrectionFactor(0.0015);
-// sc.CreateHistoDRinZR(0.)->Draw("surf2");
-// return c2;
-// }
-// End_Macro
-//
-// Begin_Html
-// <p>
-// Date: 23/08/2010 <br>
-// Authors: Jim Thomas, Stefan Rossegger
-// End_Html
-// _________________________________________________________________
+/// \class AliTPCSpaceCharge
+/// \brief The class calculates the space point distortions due to a rotational
+///
+/// symmetric space charge distribution with the TPC drift volume.
+///
+/// The class uses the PoissonRelaxation2D to calculate the resulting
+/// electrical field inhomogeneities in the (r,z)-plane. Then, the
+/// Langevin-integral formalism is used to calculate the space point distortions.
+///
+/// The class assumes, that the distortions scales linearly with the magnitude
+/// of the space charge distribution $\rho(r,z)$. The in here assumed distribution is
+/// $$\rho(r,z) = \frac{(A-B\,z)}{r^2} $$ wherein the factors A and B scale with the
+/// event multiplicity and the interaction rate.
+///
+/// The scaling factor can be set via the function SetCorrectionFactor. An example of
+/// the shape of the distortions is given below.
+///
+/// MI modification - 22.05.2013
+/// As an optional input the Space charge histogram RZ is used in case it is provided
+/// - using the SetInputSpaceCharge function
+/// 
+///
+/// \author Jim Thomas, Stefan Rossegger
+/// \date 23/08/2010
#include "AliTPCROC.h"
#include "AliTPCSpaceCharge.h"
+/// \cond CLASSIMP
ClassImp(AliTPCSpaceCharge)
+/// \endcond
AliTPCSpaceCharge::AliTPCSpaceCharge()
: AliTPCCorrection("SpaceCharge2D","Space Charge 2D"),
//
// default constructor
//
-
+
}
AliTPCSpaceCharge::~AliTPCSpaceCharge() {
- //
- // default destructor
- //
+ /// default destructor
+
}
void AliTPCSpaceCharge::Init() {
- //
- // Initialization funtion
- //
-
+ /// Initialization funtion
+
AliMagF* magF= (AliMagF*)TGeoGlobalMagField::Instance()->GetField();
if (!magF) AliError("Magneticd field - not initialized");
Double_t bzField = magF->SolenoidField()/10.; //field in T
if (!param) AliError("Parameters - not initialized");
Double_t vdrift = param->GetDriftV()/1000000.; // [cm/us] // From dataBase: to be updated: per second (ideally)
Double_t ezField = 400; // [V/cm] // to be updated: never (hopefully)
- Double_t wt = -10.0 * (bzField*10) * vdrift / ezField ;
+ Double_t wt = -10.0 * (bzField*10) * vdrift / ezField ;
// Correction Terms for effective omegaTau; obtained by a laser calibration run
SetOmegaTauT1T2(wt,fT1,fT2);
}
void AliTPCSpaceCharge::Update(const TTimeStamp &/*timeStamp*/) {
- //
- // Update function
- //
+ /// Update function
+
AliMagF* magF= (AliMagF*)TGeoGlobalMagField::Instance()->GetField();
if (!magF) AliError("Magneticd field - not initialized");
Double_t bzField = magF->SolenoidField()/10.; //field in T
if (!param) AliError("Parameters - not initialized");
Double_t vdrift = param->GetDriftV()/1000000.; // [cm/us] // From dataBase: to be updated: per second (ideally)
Double_t ezField = 400; // [V/cm] // to be updated: never (hopefully)
- Double_t wt = -10.0 * (bzField*10) * vdrift / ezField ;
+ Double_t wt = -10.0 * (bzField*10) * vdrift / ezField ;
// Correction Terms for effective omegaTau; obtained by a laser calibration run
SetOmegaTauT1T2(wt,fT1,fT2);
void AliTPCSpaceCharge::GetCorrection(const Float_t x[],const Short_t roc,Float_t dx[]) {
- //
- // Calculates the correction due the Space Charge effect within the TPC drift volume
- //
+ /// Calculates the correction due the Space Charge effect within the TPC drift volume
if (!fInitLookUp) {
AliInfo("Lookup table was not initialized! Perform the inizialisation now ...");
InitSpaceChargeDistortion();
}
- Int_t order = 1 ; // FIXME: hardcoded? Linear interpolation = 1, Quadratic = 2
-
+ Int_t order = 1 ; // FIXME: hardcoded? Linear interpolation = 1, Quadratic = 2
+
Double_t intEr, intEphi, intdEz;
Double_t r, phi, z ;
Int_t sign;
} else {
sign = -1; // (TPC C side)
}
-
+
if ( sign==1 && z < fgkZOffSet ) z = fgkZOffSet; // Protect against discontinuity at CE
if ( sign==-1 && z > -fgkZOffSet ) z = -fgkZOffSet; // Protect against discontinuity at CE
-
+
if ( (sign==1 && z<0) || (sign==-1 && z>0) ) // just a consistency check
AliError("ROC number does not correspond to z coordinate! Calculation of distortions is most likely wrong!");
// Efield is symmetric in phi - 2D calculation
- intEphi = 0.0;
+ intEphi = 0.0;
// Get the E field integrals
Interpolate2DEdistortion( order, r, z, fLookUpErOverEz, intEr );
// Get DeltaEz field integral
Interpolate2DEdistortion( order, r, z, fLookUpDeltaEz, intdEz );
-
-
+
+
// Calculate distorted position
if ( r > 0.0 ) {
- phi = phi + fCorrectionFactor *( fC0*intEphi - fC1*intEr ) / r;
- r = r + fCorrectionFactor *( fC0*intEr + fC1*intEphi );
+ phi = phi + fCorrectionFactor *( fC0*intEphi - fC1*intEr ) / r;
+ r = r + fCorrectionFactor *( fC0*intEr + fC1*intEphi );
}
Double_t dz = intdEz*fCorrectionFactor;
-
+
// Calculate correction in cartesian coordinates
dx[0] = - (r * TMath::Cos(phi) - x[0]);
- dx[1] = - (r * TMath::Sin(phi) - x[1]);
- dx[2] = - dz; // z distortion - (internally scaled with driftvelocity dependency
- // on the Ez field
+ dx[1] = - (r * TMath::Sin(phi) - x[1]);
+ dx[2] = - dz; // z distortion - (internally scaled with driftvelocity dependency
+ // on the Ez field
}
void AliTPCSpaceCharge::InitSpaceChargeDistortion() {
- //
- // Initialization of the Lookup table which contains the solutions of the
- // poisson problem
- //
+ /// Initialization of the Lookup table which contains the solutions of the
+ /// poisson problem
const Float_t gridSizeR = (fgkOFCRadius-fgkIFCRadius) / (kRows-1) ;
const Float_t gridSizeZ = fgkTPCZ0 / (kColumns-1) ;
TMatrixD arrayDeltaEz(kRows,kColumns); // solution in Ez
Double_t rList[kRows], zedList[kColumns] ;
-
- // Fill arrays with initial conditions. V on the boundary and ChargeDensity in the volume.
+
+ // Fill arrays with initial conditions. V on the boundary and ChargeDensity in the volume.
for ( Int_t j = 0 ; j < kColumns ; j++ ) {
Double_t zed = j*gridSizeZ ;
zedList[j] = zed ;
voltArray(i,j) = 0; // Initialize voltArray to zero - not used in this class
chargeDensity(i,j) = 0; // Initialize ChargeDensity to zero
}
- }
+ }
// Fill the initial conditions
for ( Int_t j = 1 ; j < kColumns-1 ; j++ ) {
Double_t zed = j*gridSizeZ ;
- for ( Int_t i = 1 ; i < kRows-1 ; i++ ) {
+ for ( Int_t i = 1 ; i < kRows-1 ; i++ ) {
Double_t radius = fgkIFCRadius + i*gridSizeR ;
Double_t zterm = (fgkTPCZ0-zed) * (fgkOFCRadius*fgkOFCRadius - fgkIFCRadius*fgkIFCRadius) / fgkTPCZ0 ;
// for 1/R**2 charge density in the TPC; then integrated in Z due to drifting ions
- chargeDensity(i,j) = zterm / ( TMath::Log(fgkOFCRadius/fgkIFCRadius) * ( radius*radius ) ) ;
+ chargeDensity(i,j) = zterm / ( TMath::Log(fgkOFCRadius/fgkIFCRadius) * ( radius*radius ) ) ;
}
}
// Fill the initial space charge in case histogram exist
if (fSpaceChargeHistogram){
for ( Int_t j = 1 ; j < kColumns-1 ; j++ ) {
Double_t zed = j*gridSizeZ ;
- for ( Int_t i = 1 ; i < kRows-1 ; i++ ) {
+ for ( Int_t i = 1 ; i < kRows-1 ; i++ ) {
Double_t radius = fgkIFCRadius + i*gridSizeR ;
-
+
Double_t zterm = (fgkTPCZ0-zed) * (fgkOFCRadius*fgkOFCRadius - fgkIFCRadius*fgkIFCRadius) / fgkTPCZ0 ;
// for 1/R**2 charge density in the TPC; then integrated in Z due to drifting ions
chargeDensity(i,j) = fSpaceChargeHistogram->Interpolate(radius,zed);
}
- // Solve the electrosatic problem in 2D
+ // Solve the electrosatic problem in 2D
PoissonRelaxation2D( voltArray, chargeDensity, arrayErOverEz, arrayDeltaEz, kRows, kColumns, kIterations ) ;
-
+
//Interpolate results onto standard grid for Electric Fields
Int_t ilow=0, jlow=0 ;
Double_t z,r;
- Float_t saveEr[2], saveEz[2] ;
+ Float_t saveEr[2], saveEz[2] ;
for ( Int_t i = 0 ; i < kNZ ; ++i ) {
z = TMath::Abs( fgkZList[i] ) ; // assume symmetric behaviour on A and C side
for ( Int_t j = 0 ; j < kNR ; ++j ) {
Search( kRows, rList, r, ilow ) ; // Note switch - R in rows and Z in columns
Search( kColumns, zedList, z, jlow ) ;
if ( ilow < 0 ) ilow = 0 ; // check if out of range
- if ( jlow < 0 ) jlow = 0 ;
- if ( ilow + 1 >= kRows - 1 ) ilow = kRows - 2 ;
- if ( jlow + 1 >= kColumns - 1 ) jlow = kColumns - 2 ;
-
- saveEr[0] = arrayErOverEz(ilow,jlow) +
+ if ( jlow < 0 ) jlow = 0 ;
+ if ( ilow + 1 >= kRows - 1 ) ilow = kRows - 2 ;
+ if ( jlow + 1 >= kColumns - 1 ) jlow = kColumns - 2 ;
+
+ saveEr[0] = arrayErOverEz(ilow,jlow) +
(arrayErOverEz(ilow,jlow+1)-arrayErOverEz(ilow,jlow))*(z-zedList[jlow])/gridSizeZ ;
- saveEr[1] = arrayErOverEz(ilow+1,jlow) +
+ saveEr[1] = arrayErOverEz(ilow+1,jlow) +
(arrayErOverEz(ilow+1,jlow+1)-arrayErOverEz(ilow+1,jlow))*(z-zedList[jlow])/gridSizeZ ;
- saveEz[0] = arrayDeltaEz(ilow,jlow) +
+ saveEz[0] = arrayDeltaEz(ilow,jlow) +
(arrayDeltaEz(ilow,jlow+1)-arrayDeltaEz(ilow,jlow))*(z-zedList[jlow])/gridSizeZ ;
- saveEz[1] = arrayDeltaEz(ilow+1,jlow) +
+ saveEz[1] = arrayDeltaEz(ilow+1,jlow) +
(arrayDeltaEz(ilow+1,jlow+1)-arrayDeltaEz(ilow+1,jlow))*(z-zedList[jlow])/gridSizeZ ;
-
+
fLookUpErOverEz[i][j] = saveEr[0] + (saveEr[1]-saveEr[0])*(r-rList[ilow])/gridSizeR ;
fLookUpDeltaEz[i][j] = saveEz[0] + (saveEz[1]-saveEz[0])*(r-rList[ilow])/gridSizeR ;
if (fgkZList[i]<0) fLookUpDeltaEz[i][j] *= -1; // C side is negative z
}
}
-
+
fInitLookUp = kTRUE;
}
void AliTPCSpaceCharge::Print(const Option_t* option) const {
- //
- // Print function to check the settings of the boundary vectors
- // option=="a" prints the C0 and C1 coefficents for calibration purposes
- //
+ /// Print function to check the settings of the boundary vectors
+ /// option=="a" prints the C0 and C1 coefficents for calibration purposes
TString opt = option; opt.ToLower();
printf("%s\n",GetTitle());
if (opt.Contains("a")) { // Print all details
printf(" - T1: %1.4f, T2: %1.4f \n",fT1,fT2);
printf(" - C1: %1.4f, C0: %1.4f \n",fC1,fC0);
- }
-
+ }
+
if (!fInitLookUp) AliError("Lookup table was not initialized! You should do InitSpaceChargeDistortion() ...");
}
/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
* See cxx source for full Copyright notice */
-////////////////////////////////////////////////////////////////////////////
-// AliTPCSpaceCharge class //
-// Authors: Jim Thomas, Stefan Rossegger //
-////////////////////////////////////////////////////////////////////////////
+/// \class AliTPCSpaceCharge
+/// \brief \author Jim Thomas, Stefan Rossegger
#include "AliTPCCorrection.h"
-class TH2;
+class TH2;
class AliTPCSpaceCharge : public AliTPCCorrection {
public:
virtual void Init();
virtual void Update(const TTimeStamp &timeStamp);
void SetInputSpaceCharge(TH2 * hisSpaceCharge){fSpaceChargeHistogram = hisSpaceCharge;} // MI add
- const TH2 * GetInputSpaceCharge(){return fSpaceChargeHistogram;} // MI add
+ const TH2 * GetInputSpaceCharge(){return fSpaceChargeHistogram;} // MI add
// common setters and getters for tangled ExB effect
virtual void GetCorrection(const Float_t x[],const Short_t roc,Float_t dx[]);
private:
- Float_t fC0; // coefficient C0 (compare Jim Thomas's notes for definitions)
- Float_t fC1; // coefficient C1 (compare Jim Thomas's notes for definitions)
- Float_t fCorrectionFactor; // Space Charge Correction factor in comparison to initialized
+ Float_t fC0; ///< coefficient C0 (compare Jim Thomas's notes for definitions)
+ Float_t fC1; ///< coefficient C1 (compare Jim Thomas's notes for definitions)
+ Float_t fCorrectionFactor; ///< Space Charge Correction factor in comparison to initialized
// look up table which was created for M_mb = 900 and IR = 3000
// compare Internal Note Nr: ???
- TH2 * fSpaceChargeHistogram; // Histogram with the input space charge histogram - used as an optional input
- Bool_t fInitLookUp; // flag to check it the Look Up table was created
+ TH2 * fSpaceChargeHistogram; ///< Histogram with the input space charge histogram - used as an optional input
+ Bool_t fInitLookUp; ///< flag to check it the Look Up table was created
- Double_t fLookUpErOverEz[kNZ][kNR]; // Array to store electric field integral (int Er/Ez)
- Double_t fLookUpDeltaEz[kNZ][kNR]; // Array to store electric field integral (int Delta Ez)
+ Double_t fLookUpErOverEz[kNZ][kNR]; ///< Array to store electric field integral (int Er/Ez)
+ Double_t fLookUpDeltaEz[kNZ][kNR]; ///< Array to store electric field integral (int Delta Ez)
// basic numbers for the poisson relaxation //can be set individually in each class
enum {kRows =257}; // grid size in r direction used in the poisson relaxation // ( 2**n + 1 ) eg. 65, 129, 257 etc.
enum {kColumns=129}; // grid size in z direction used in the poisson relaxation // ( 2**m + 1 ) eg. 65, 129, 257 etc.
- enum {kIterations=100}; // Number of iterations within the poisson relaxation
+ enum {kIterations=100}; // Number of iterations within the poisson relaxation
- ClassDef(AliTPCSpaceCharge,0);
+ /// \cond CLASSIMP
+ ClassDef(AliTPCSpaceCharge,0);
+ /// \endcond
};
#endif
* provided "as is" without express or implied warranty. *
**************************************************************************/
-// _________________________________________________________________
-//
-// Begin_Html
-// <h2> AliTPCSpaceCharge3D class </h2>
-// The class calculates the space point distortions due to an arbitrary space
-// charge distribution in 3D.
-// <p>
-// The method of calculation is based on the analytical solution for the Poisson
-// problem in 3D (cylindrical coordinates). The solution is used in form of
-// look up tables, where the pre calculated solutions for different voxel
-// positions are stored. These voxel solutions can be summed up according
-// to the weight of the position of the applied space charge distribution.
-// Further details can be found in \cite[chap.5]{PhD-thesis_S.Rossegger}.
-// <p>
-// The class also allows a simple scaling of the resulting distortions
-// via the function SetCorrectionFactor. This speeds up the calculation
-// time under the assumption, that the distortions scales linearly with the
-// magnitude of the space charge distribution $\rho(r,z)$ and the shape stays
-// the same at higher luminosities.
-// <p>
-// In contrast to the implementation in 2D (see the class AliTPCSpaceChargeabove),
-// the input charge distribution can be of arbitrary character. An example on how
-// to produce a corresponding charge distribution can be found in the function
-// WriteChargeDistributionToFile. In there, a $\rho(r,z) = (A-B\,z)/r^2$,
-// with slightly different magnitude on the A and C side (due to the muon absorber),
-// is superpositioned with a few leaking wires at arbitrary positions.
-//
-//
-// Marian Ivanov change: 26.06.2013
-// Usage of the realy 3D space charge map as an optional input
-// SetInputSpaceCharge map.
-// In case given map is used 2 2D maps are ignored and scaling functions $\rho(r,z) = (A-B\,z)/r^2$,
-// will not work
-//
+/// \class AliTPCSpaceCharge3D
+/// \brief The class calculates the space point distortions due to an arbitrary space charge distribution in 3D.
+///
+/// The method of calculation is based on the analytical solution for the Poisson
+/// problem in 3D (cylindrical coordinates). The solution is used in form of
+/// look up tables, where the pre calculated solutions for different voxel
+/// positions are stored. These voxel solutions can be summed up according
+/// to the weight of the position of the applied space charge distribution.
+/// Further details can be found in \cite[chap.5]{PhD-thesis_S.Rossegger}.
+///
+/// The class also allows a simple scaling of the resulting distortions
+/// via the function SetCorrectionFactor. This speeds up the calculation
+/// time under the assumption, that the distortions scales linearly with the
+/// magnitude of the space charge distribution $\rho(r,z)$ and the shape stays
+/// the same at higher luminosities.
+///
+/// In contrast to the implementation in 2D (see the class AliTPCSpaceChargeabove),
+/// the input charge distribution can be of arbitrary character. An example on how
+/// to produce a corresponding charge distribution can be found in the function
+/// WriteChargeDistributionToFile. In there, a $\rho(r,z) = (A-B\,z)/r^2$,
+/// with slightly different magnitude on the A and C side (due to the muon absorber),
+/// is superpositioned with a few leaking wires at arbitrary positions.
+///
+/// Marian Ivanov change: 26.06.2013
+/// Usage of the realy 3D space charge map as an optional input
+/// SetInputSpaceCharge map.
+/// In case given map is used 2 2D maps are ignored and scaling functions $\rho(r,z) = (A-B\,z)/r^2$,
+/// will not work
// End_Html
// Begin_Macro(source)
// {
// gROOT->SetStyle("Plain"); gStyle->SetPalette(1);
-// TCanvas *c2 = new TCanvas("cAliTPCSpaceCharge3D","cAliTPCSpaceCharge3D",500,400);
+// TCanvas *c2 = new TCanvas("cAliTPCSpaceCharge3D","cAliTPCSpaceCharge3D",500,400);
// AliTPCSpaceCharge3D sc;
// sc.WriteChargeDistributionToFile("SC_zr2_GGleaks.root");
// sc.SetSCDataFileName("SC_zr2_GGleaks.root");
// sc.InitSpaceCharge3DDistortion();
// sc.CreateHistoDRinXY(15,300,300)->Draw("colz");
// return c2;
-// }
+// }
// End_Macro
//
// Begin_Html
// <p>
-// Date: 19/06/2010 <br>
-// Authors: Stefan Rossegger
-// End_Html
+// Date: 19/06/2010 <br>
+// Authors: Stefan Rossegger
+// End_Html
// _________________________________________________________________
#include "AliTPCSpaceCharge3D.h"
#include "AliSysInfo.h"
+/// \cond CLASSIMP
ClassImp(AliTPCSpaceCharge3D)
+/// \endcond
AliTPCSpaceCharge3D::AliTPCSpaceCharge3D()
: AliTPCCorrection("SpaceCharge3D","Space Charge - 3D"),
fSCLookUpPOCsFileNameRZ(""),
fSCLookUpPOCsFileNameRPhi(""),
fSCdensityInRZ(0),
- fSCdensityInRPhiA(0),
+ fSCdensityInRPhiA(0),
fSCdensityInRPhiC(0),
fSpaceChargeHistogram3D(0),
fSpaceChargeHistogramRPhi(0),
// Array which will contain the solution according to the setted charge density distribution
// see InitSpaceCharge3DDistortion() function
for ( Int_t k = 0 ; k < kNPhi ; k++ ) {
- fLookUpErOverEz[k] = new TMatrixF(kNR,kNZ);
+ fLookUpErOverEz[k] = new TMatrixF(kNR,kNZ);
fLookUpEphiOverEz[k] = new TMatrixF(kNR,kNZ);
- fLookUpDeltaEz[k] = new TMatrixF(kNR,kNZ);
+ fLookUpDeltaEz[k] = new TMatrixF(kNR,kNZ);
fSCdensityDistribution[k] = new TMatrixF(kNR,kNZ);
}
fSCdensityInRZ = new TMatrixD(kNR,kNZ);
fSCLookUpPOCsFileNameRZ="$(ALICE_ROOT)/TPC/Calib/maps/sc_radSym_35-01-51_34p-01p-50p_MN60.root";
fSCLookUpPOCsFileNameRPhi="$(ALICE_ROOT)/TPC/Calib/maps/sc_cChInZ_35-144-26_34p-18p-01p-MN30.root";
// fSCLookUpPOCsFileNameRPhi="$(ALICE_ROOT)/TPC/Calib/maps/sc_cChInZ_35-36-26_34p-18p-01p-MN40.root";
-
+
// standard location of the space charge distibution ... can be changes
}
AliTPCSpaceCharge3D::~AliTPCSpaceCharge3D() {
- //
- // default destructor
- //
-
+ /// default destructor
+
for ( Int_t k = 0 ; k < kNPhi ; k++ ) {
delete fLookUpErOverEz[k];
delete fLookUpEphiOverEz[k];
void AliTPCSpaceCharge3D::Init() {
- //
- // Initialization funtion
- //
-
+ /// Initialization funtion
+
AliMagF* magF= (AliMagF*)TGeoGlobalMagField::Instance()->GetField();
if (!magF) AliError("Magneticd field - not initialized");
Double_t bzField = magF->SolenoidField()/10.; //field in T
if (!param) AliError("Parameters - not initialized");
Double_t vdrift = param->GetDriftV()/1000000.; // [cm/us] // From dataBase: to be updated: per second (ideally)
Double_t ezField = 400; // [V/cm] // to be updated: never (hopefully)
- Double_t wt = -10.0 * (bzField*10) * vdrift / ezField ;
+ Double_t wt = -10.0 * (bzField*10) * vdrift / ezField ;
// Correction Terms for effective omegaTau; obtained by a laser calibration run
SetOmegaTauT1T2(wt,fT1,fT2);
}
void AliTPCSpaceCharge3D::Update(const TTimeStamp &/*timeStamp*/) {
- //
- // Update function
- //
+ /// Update function
+
AliMagF* magF= (AliMagF*)TGeoGlobalMagField::Instance()->GetField();
if (!magF) AliError("Magneticd field - not initialized");
Double_t bzField = magF->SolenoidField()/10.; //field in T
if (!param) AliError("Parameters - not initialized");
Double_t vdrift = param->GetDriftV()/1000000.; // [cm/us] // From dataBase: to be updated: per second (ideally)
Double_t ezField = 400; // [V/cm] // to be updated: never (hopefully)
- Double_t wt = -10.0 * (bzField*10) * vdrift / ezField ;
+ Double_t wt = -10.0 * (bzField*10) * vdrift / ezField ;
// Correction Terms for effective omegaTau; obtained by a laser calibration run
SetOmegaTauT1T2(wt,fT1,fT2);
void AliTPCSpaceCharge3D::GetCorrection(const Float_t x[],const Short_t roc,Float_t dx[]) {
- //
- // Calculates the correction due the Space Charge effect within the TPC drift volume
- //
+ /// Calculates the correction due the Space Charge effect within the TPC drift volume
if (!fInitLookUp) {
AliInfo("Lookup table was not initialized! Performing the inizialisation now ...");
InitSpaceCharge3DDistortion();
}
- Int_t order = 1 ; // FIXME: hardcoded? Linear interpolation = 1, Quadratic = 2
-
+ Int_t order = 1 ; // FIXME: hardcoded? Linear interpolation = 1, Quadratic = 2
+
Float_t intEr, intEphi, intdEz ;
Double_t r, phi, z ;
Int_t sign;
} else {
sign = -1; // (TPC C side)
}
-
+
if ( sign==1 && z < fgkZOffSet ) z = fgkZOffSet; // Protect against discontinuity at CE
if ( sign==-1 && z > -fgkZOffSet ) z = -fgkZOffSet; // Protect against discontinuity at CE
-
+
if ( (sign==1 && z<0) || (sign==-1 && z>0) ) // just a consistency check
AliError("ROC number does not correspond to z coordinate! Calculation of distortions is most likely wrong!");
- // Get the Er and Ephi field integrals plus the integral over DeltaEz
- intEr = Interpolate3DTable(order, r, z, phi, kNR, kNZ, kNPhi,
+ // Get the Er and Ephi field integrals plus the integral over DeltaEz
+ intEr = Interpolate3DTable(order, r, z, phi, kNR, kNZ, kNPhi,
fgkRList, fgkZList, fgkPhiList, fLookUpErOverEz );
- intEphi = Interpolate3DTable(order, r, z, phi, kNR, kNZ, kNPhi,
+ intEphi = Interpolate3DTable(order, r, z, phi, kNR, kNZ, kNPhi,
fgkRList, fgkZList, fgkPhiList, fLookUpEphiOverEz);
- intdEz = Interpolate3DTable(order, r, z, phi, kNR, kNZ, kNPhi,
+ intdEz = Interpolate3DTable(order, r, z, phi, kNR, kNZ, kNPhi,
fgkRList, fgkZList, fgkPhiList, fLookUpDeltaEz );
// Calculate distorted position
if ( r > 0.0 ) {
- phi = phi + fCorrectionFactor *( fC0*intEphi - fC1*intEr ) / r;
- r = r + fCorrectionFactor *( fC0*intEr + fC1*intEphi );
+ phi = phi + fCorrectionFactor *( fC0*intEphi - fC1*intEr ) / r;
+ r = r + fCorrectionFactor *( fC0*intEr + fC1*intEphi );
}
Double_t dz = intdEz * fCorrectionFactor * fgkdvdE;
-
+
// Calculate correction in cartesian coordinates
dx[0] = - (r * TMath::Cos(phi) - x[0]);
- dx[1] = - (r * TMath::Sin(phi) - x[1]);
+ dx[1] = - (r * TMath::Sin(phi) - x[1]);
dx[2] = - dz; // z distortion - (scaled with driftvelocity dependency on the Ez field and the overall scaling factor)
}
void AliTPCSpaceCharge3D::InitSpaceCharge3DDistortion() {
- //
- // Initialization of the Lookup table which contains the solutions of the
- // "space charge" (poisson) problem - Faster and more accureate
- //
- // Method: Weighted sum-up of the different fields within the look up table
- // but using two lookup tables with higher granularity in the (r,z) and the (rphi)- plane to emulate
- // more realistic space charges. (r,z) from primary ionisation. (rphi) for possible Gating leaks
+ /// Initialization of the Lookup table which contains the solutions of the
+ /// "space charge" (poisson) problem - Faster and more accureate
+ ///
+ /// Method: Weighted sum-up of the different fields within the look up table
+ /// but using two lookup tables with higher granularity in the (r,z) and the (rphi)- plane to emulate
+ /// more realistic space charges. (r,z) from primary ionisation. (rphi) for possible Gating leaks
if (fInitLookUp) {
AliInfo("Lookup table was already initialized! Doing it again anyway ...");
return;
}
-
+
// ------------------------------------------------------------------------------------------------------
// step 1: lookup table in rz, fine grid, radial symetric, to emulate primary ionization
AliInfo("Step 1: Preparation of the weighted look-up tables.");
-
+
// lookup table in rz, fine grid
TFile *fZR = new TFile(fSCLookUpPOCsFileNameRZ.Data(),"READ");
if ( !fZR ) {
AliError("Precalculated POC-looup-table in ZR could not be found");
return;
- }
+ }
// units are in [m]
- TVector *gridf1 = (TVector*) fZR->Get("constants");
+ TVector *gridf1 = (TVector*) fZR->Get("constants");
TVector &grid1 = *gridf1;
TMatrix *coordf1 = (TMatrix*) fZR->Get("coordinates");
TMatrix &coord1 = *coordf1;
TMatrix *coordPOCf1 = (TMatrix*) fZR->Get("POCcoord");
TMatrix &coordPOC1 = *coordPOCf1;
-
+
Int_t rows = (Int_t)grid1(0); // number of points in r direction - from RZ or RPhi table
Int_t phiSlices = (Int_t)grid1(1); // number of points in phi - from RPhi table
Int_t columns = (Int_t)grid1(2); // number of points in z direction - from RZ table
Float_t gridSizeZ = fgkTPCZ0/(columns-1); // unit in [cm]
// temporary matrices needed for the calculation // for rotational symmetric RZ table, phislices is 1
-
- TMatrixD *arrayofErA[kNPhiSlices], *arrayofdEzA[kNPhiSlices];
- TMatrixD *arrayofErC[kNPhiSlices], *arrayofdEzC[kNPhiSlices];
+
+ TMatrixD *arrayofErA[kNPhiSlices], *arrayofdEzA[kNPhiSlices];
+ TMatrixD *arrayofErC[kNPhiSlices], *arrayofdEzC[kNPhiSlices];
TMatrixD *arrayofEroverEzA[kNPhiSlices], *arrayofDeltaEzA[kNPhiSlices];
TMatrixD *arrayofEroverEzC[kNPhiSlices], *arrayofDeltaEzC[kNPhiSlices];
-
+
for ( Int_t k = 0 ; k < phiSlices ; k++ ) {
-
+
arrayofErA[k] = new TMatrixD(rows,columns) ;
arrayofdEzA[k] = new TMatrixD(rows,columns) ;
arrayofErC[k] = new TMatrixD(rows,columns) ;
arrayofEroverEzC[k] = new TMatrixD(rows,columns) ;
arrayofDeltaEzC[k] = new TMatrixD(rows,columns) ;
- // zero initialization not necessary, it is done in the constructor of TMatrix
+ // zero initialization not necessary, it is done in the constructor of TMatrix
}
-
+
// list of points as used during sum up
Double_t rlist1[kNRows], zedlist1[kNColumns];// , philist1[phiSlices];
for ( Int_t i = 0 ; i < rows ; i++ ) {
rlist1[i] = fgkIFCRadius + i*gridSizeR ;
- for ( Int_t j = 0 ; j < columns ; j++ ) {
+ for ( Int_t j = 0 ; j < columns ; j++ ) {
zedlist1[j] = j * gridSizeZ ;
}
}
-
+
TTree *treePOC = (TTree*)fZR->Get("POCall");
TVector *bEr = 0; //TVector *bEphi= 0;
TVector *bEz = 0;
-
+
treePOC->SetBranchAddress("Er",&bEr);
treePOC->SetBranchAddress("Ez",&bEz);
// Read the complete tree and do a weighted sum-up over the POC configurations
// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
-
+
Int_t treeNumPOC = (Int_t)treePOC->GetEntries(); // Number of POC conf. in the look-up table
Int_t ipC = 0; // POC Conf. counter (note: different to the POC number in the tree!)
for (Int_t itreepC=0; itreepC<treeNumPOC; itreepC++) { // ------------- loop over POC configurations in tree
-
+
treePOC->GetEntry(itreepC);
// center of the POC voxel in [meter]
// note: coordinates are in [cm]
Double_t weightA = GetSpaceChargeDensity(r0*100,phi0, z0*100, 1); // partial load in r,z
Double_t weightC = GetSpaceChargeDensity(r0*100,phi0,-z0*100, 1); // partial load in r,z
-
+
// Summing up the vector components according to their weight
Int_t ip = 0;
- for ( Int_t j = 0 ; j < columns ; j++ ) {
+ for ( Int_t j = 0 ; j < columns ; j++ ) {
for ( Int_t i = 0 ; i < rows ; i++ ) {
for ( Int_t k = 0 ; k < phiSlices ; k++ ) {
-
+
// check wether the coordinates were screwed
- if (TMath::Abs((coord1(0,ip)*100-rlist1[i]))>1 ||
- TMath::Abs((coord1(2,ip)*100-zedlist1[j])>1)) {
+ if (TMath::Abs((coord1(0,ip)*100-rlist1[i]))>1 ||
+ TMath::Abs((coord1(2,ip)*100-zedlist1[j])>1)) {
AliError("internal error: coordinate system was screwed during the sum-up");
printf("sum-up: (r,z)=(%f,%f)\n",rlist1[i],zedlist1[j]);
printf("lookup: (r,z)=(%f,%f)\n",coord1(0,ip)*100,coord1(2,ip)*100);
AliError("Don't trust the results of the space charge calculation!");
}
-
+
// unfortunately, the lookup tables were produced to be faster for phi symmetric charges
// This will be the most frequent usage (hopefully)
// That's why we have to do this here ...
TMatrixD &erA = *arrayofErA[k] ;
TMatrixD &dEzA = *arrayofdEzA[k] ;
-
+
TMatrixD &erC = *arrayofErC[k] ;
TMatrixD &dEzC = *arrayofdEzC[k] ;
-
+
// Sum up - Efield values in [V/m] -> transition to [V/cm]
erA(i,j) += ((*bEr)(ip)) * weightA /100;
erC(i,j) += ((*bEr)(ip)) * weightC /100;
TMatrixD &erOverEzA = *arrayofEroverEzA[k] ;
TMatrixD &deltaEzA = *arrayofDeltaEzA[k];
TMatrixD &erOverEzC = *arrayofEroverEzC[k] ;
- TMatrixD &deltaEzC = *arrayofDeltaEzC[k];
-
+ TMatrixD &deltaEzC = *arrayofDeltaEzC[k];
+
for ( Int_t i = 0 ; i < rows ; i++ ) { // r loop
- for ( Int_t j = columns-1 ; j >= 0 ; j-- ) {// z loop
+ for ( Int_t j = columns-1 ; j >= 0 ; j-- ) {// z loop
// Count backwards to facilitate integration over Z
- Int_t index = 1 ; // Simpsons rule if N=odd.If N!=odd then add extra point
- // by trapezoidal rule.
+ Int_t index = 1 ; // Simpsons rule if N=odd.If N!=odd then add extra point
+ // by trapezoidal rule.
erOverEzA(i,j) = 0; //ephiOverEzA(i,j) = 0;
deltaEzA(i,j) = 0;
- erOverEzC(i,j) = 0; //ephiOverEzC(i,j) = 0;
+ erOverEzC(i,j) = 0; //ephiOverEzC(i,j) = 0;
deltaEzC(i,j) = 0;
for ( Int_t m = j ; m < columns ; m++ ) { // integration
deltaEzC(i,j) = (gridSizeZ/3.0)*(1.5*dezC(i,columns-2)+1.5*dezC(i,columns-1))/(-1) ;
}
if ( j == columns-1 ) {
- erOverEzA(i,j) = 0;
+ erOverEzA(i,j) = 0;
erOverEzC(i,j) = 0;
- deltaEzA(i,j) = 0;
+ deltaEzA(i,j) = 0;
deltaEzC(i,j) = 0;
}
}
}
}
-
+
// AliInfo("Step 1: Interpolation to Standard grid");
// -------------------------------------------------------------------------------
// Interpolate results onto the standard grid which is used for all AliTPCCorrections classes
- const Int_t order = 1 ; // Linear interpolation = 1, Quadratic = 2
+ const Int_t order = 1 ; // Linear interpolation = 1, Quadratic = 2
Double_t r, z;//phi, z ;
for ( Int_t k = 0 ; k < kNPhi ; k++ ) {
// phi = fgkPhiList[k] ;
-
+
// final lookup table
TMatrixF &erOverEzFinal = *fLookUpErOverEz[k] ;
TMatrixF &deltaEzFinal = *fLookUpDeltaEz[k] ;
-
+
// calculated and integrated tables - just one phi slice
TMatrixD &erOverEzA = *arrayofEroverEzA[0] ;
TMatrixD &deltaEzA = *arrayofDeltaEzA[0];
TMatrixD &erOverEzC = *arrayofEroverEzC[0] ;
- TMatrixD &deltaEzC = *arrayofDeltaEzC[0];
-
-
+ TMatrixD &deltaEzC = *arrayofDeltaEzC[0];
+
+
for ( Int_t j = 0 ; j < kNZ ; j++ ) {
z = TMath::Abs(fgkZList[j]) ; // z position is symmetric
-
- for ( Int_t i = 0 ; i < kNR ; i++ ) {
+
+ for ( Int_t i = 0 ; i < kNR ; i++ ) {
r = fgkRList[i] ;
// Interpolate Lookup tables onto standard grid
} // end z loop
} // end phi loop
-
+
// clear the temporary arrays lists
for ( Int_t k = 0 ; k < phiSlices ; k++ ) {
- delete arrayofErA[k];
+ delete arrayofErA[k];
delete arrayofdEzA[k];
- delete arrayofErC[k];
+ delete arrayofErC[k];
delete arrayofdEzC[k];
- delete arrayofEroverEzA[k];
+ delete arrayofEroverEzA[k];
delete arrayofDeltaEzA[k];
- delete arrayofEroverEzC[k];
+ delete arrayofEroverEzC[k];
delete arrayofDeltaEzC[k];
}
// ------------------------------------------------------------------------------------------------------
// Step 2: Load and sum up lookup table in rphi, fine grid, to emulate for example a GG leak
-
+
// AliInfo("Step 2: Preparation of the weighted look-up table");
-
+
TFile *fRPhi = new TFile(fSCLookUpPOCsFileNameRPhi.Data(),"READ");
if ( !fRPhi ) {
AliError("Precalculated POC-looup-table in RPhi could not be found");
return;
- }
+ }
// units are in [m]
- TVector *gridf2 = (TVector*) fRPhi->Get("constants");
+ TVector *gridf2 = (TVector*) fRPhi->Get("constants");
TVector &grid2 = *gridf2;
TMatrix *coordf2 = (TMatrix*) fRPhi->Get("coordinates");
TMatrix &coord2 = *coordf2;
TMatrix *coordPOCf2 = (TMatrix*) fRPhi->Get("POCcoord");
TMatrix &coordPOC2 = *coordPOCf2;
- rows = (Int_t)grid2(0); // number of points in r direction
- phiSlices = (Int_t)grid2(1); // number of points in phi
- columns = (Int_t)grid2(2); // number of points in z direction
+ rows = (Int_t)grid2(0); // number of points in r direction
+ phiSlices = (Int_t)grid2(1); // number of points in phi
+ columns = (Int_t)grid2(2); // number of points in z direction
gridSizeR = (fgkOFCRadius-fgkIFCRadius)/(rows-1); // unit in [cm]
Float_t gridSizePhi = TMath::TwoPi()/phiSlices; // unit in [rad]
gridSizeZ = fgkTPCZ0/(columns-1); // unit in [cm]
-
+
// list of points as used during sum up
- Double_t rlist2[kNRows], philist2[kNPhiSlices], zedlist2[kNColumns];
+ Double_t rlist2[kNRows], philist2[kNPhiSlices], zedlist2[kNColumns];
for ( Int_t k = 0 ; k < phiSlices ; k++ ) {
philist2[k] = gridSizePhi * k;
for ( Int_t i = 0 ; i < rows ; i++ ) {
rlist2[i] = fgkIFCRadius + i*gridSizeR ;
- for ( Int_t j = 0 ; j < columns ; j++ ) {
+ for ( Int_t j = 0 ; j < columns ; j++ ) {
zedlist2[j] = j * gridSizeZ ;
}
}
} // only done once
-
- // temporary matrices needed for the calculation
+
+ // temporary matrices needed for the calculation
TMatrixD *arrayofErA2[kNPhiSlices], *arrayofEphiA2[kNPhiSlices], *arrayofdEzA2[kNPhiSlices];
- TMatrixD *arrayofErC2[kNPhiSlices], *arrayofEphiC2[kNPhiSlices], *arrayofdEzC2[kNPhiSlices];
+ TMatrixD *arrayofErC2[kNPhiSlices], *arrayofEphiC2[kNPhiSlices], *arrayofdEzC2[kNPhiSlices];
+
+ TMatrixD *arrayofEroverEzA2[kNPhiSlices], *arrayofEphioverEzA2[kNPhiSlices], *arrayofDeltaEzA2[kNPhiSlices];
+ TMatrixD *arrayofEroverEzC2[kNPhiSlices], *arrayofEphioverEzC2[kNPhiSlices], *arrayofDeltaEzC2[kNPhiSlices];
- TMatrixD *arrayofEroverEzA2[kNPhiSlices], *arrayofEphioverEzA2[kNPhiSlices], *arrayofDeltaEzA2[kNPhiSlices];
- TMatrixD *arrayofEroverEzC2[kNPhiSlices], *arrayofEphioverEzC2[kNPhiSlices], *arrayofDeltaEzC2[kNPhiSlices];
-
for ( Int_t k = 0 ; k < phiSlices ; k++ ) {
-
+
arrayofErA2[k] = new TMatrixD(rows,columns) ;
arrayofEphiA2[k] = new TMatrixD(rows,columns) ;
arrayofdEzA2[k] = new TMatrixD(rows,columns) ;
arrayofdEzC2[k] = new TMatrixD(rows,columns) ;
arrayofEroverEzA2[k] = new TMatrixD(rows,columns) ;
- arrayofEphioverEzA2[k] = new TMatrixD(rows,columns) ;
+ arrayofEphioverEzA2[k] = new TMatrixD(rows,columns) ;
arrayofDeltaEzA2[k] = new TMatrixD(rows,columns) ;
arrayofEroverEzC2[k] = new TMatrixD(rows,columns) ;
- arrayofEphioverEzC2[k] = new TMatrixD(rows,columns) ;
+ arrayofEphioverEzC2[k] = new TMatrixD(rows,columns) ;
arrayofDeltaEzC2[k] = new TMatrixD(rows,columns) ;
- // zero initialization not necessary, it is done in the constructor of TMatrix
+ // zero initialization not necessary, it is done in the constructor of TMatrix
}
-
-
+
+
treePOC = (TTree*)fRPhi->Get("POCall");
// TVector *bEr = 0; // done above
// Read the complete tree and do a weighted sum-up over the POC configurations
// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
-
+
treeNumPOC = (Int_t)treePOC->GetEntries(); // Number of POC conf. in the look-up table
ipC = 0; // POC Conf. counter (note: different to the POC number in the tree!)
for (Int_t itreepC=0; itreepC<treeNumPOC; itreepC++) { // ------------- loop over POC configurations in tree
-
+
treePOC->GetEntry(itreepC);
// center of the POC voxel in [meter]
// note: coordinates are in [cm]
Double_t weightA = GetSpaceChargeDensity(r0*100,phi0, 0.499, 2); // partial load in r,phi
Double_t weightC = GetSpaceChargeDensity(r0*100,phi0,-0.499, 2); // partial load in r,phi
-
+
// printf("-----\n%f %f : %e %e\n",r0,phi0,weightA,weightC);
// Summing up the vector components according to their weight
Int_t ip = 0;
- for ( Int_t j = 0 ; j < columns ; j++ ) {
+ for ( Int_t j = 0 ; j < columns ; j++ ) {
for ( Int_t i = 0 ; i < rows ; i++ ) {
for ( Int_t k = 0 ; k < phiSlices ; k++ ) {
-
+
// check wether the coordinates were screwed
- if (TMath::Abs((coord2(0,ip)*100-rlist2[i]))>1 ||
- TMath::Abs((coord2(1,ip)-philist2[k]))>1 ||
- TMath::Abs((coord2(2,ip)*100-zedlist2[j]))>1) {
+ if (TMath::Abs((coord2(0,ip)*100-rlist2[i]))>1 ||
+ TMath::Abs((coord2(1,ip)-philist2[k]))>1 ||
+ TMath::Abs((coord2(2,ip)*100-zedlist2[j]))>1) {
AliError("internal error: coordinate system was screwed during the sum-up");
printf("lookup: (r,phi,z)=(%f,%f,%f)\n",coord2(0,ip)*100,coord2(1,ip),coord2(2,ip)*100);
printf("sum-up: (r,phi,z)=(%f,%f,%f)\n",rlist2[i],philist2[k],zedlist2[j]);
AliError("Don't trust the results of the space charge calculation!");
}
-
+
// unfortunately, the lookup tables were produced to be faster for phi symmetric charges
// This will be the most frequent usage (hopefully)
// That's why we have to do this here ...
TMatrixD &erA = *arrayofErA2[k] ;
TMatrixD &ephiA = *arrayofEphiA2[k];
TMatrixD &dEzA = *arrayofdEzA2[k] ;
-
+
TMatrixD &erC = *arrayofErC2[k] ;
TMatrixD &ephiC = *arrayofEphiC2[k];
TMatrixD &dEzC = *arrayofdEzC2[k] ;
-
+
// Sum up - Efield values in [V/m] -> transition to [V/cm]
erA(i,j) += ((*bEr)(ip)) * weightA /100;
erC(i,j) += ((*bEr)(ip)) * weightC /100;
}
}
} // end coordinate loop
-
-
+
+
// Rotation and summation in the rest of the dPhiSteps
// which were not stored in the this tree due to storage & symmetry reasons
-
+
Int_t phiPoints = (Int_t) grid2(1);
Int_t phiPOC = (Int_t) grid2(4);
-
+
// printf("%d %d\n",phiPOC,flagRadSym);
-
- for (Int_t phiiC = 1; phiiC<phiPOC; phiiC++) { // just used for non-radial symetric table
-
+
+ for (Int_t phiiC = 1; phiiC<phiPOC; phiiC++) { // just used for non-radial symetric table
+
Double_t phi0R = phiiC*phi0*2 + phi0; // rotate further
// weights (charge density) at POC position on the A and C side (in C/m^3/e0)
// note: coordinates are in [cm] // ecxept z
weightA = GetSpaceChargeDensity(r0*100,phi0R, 0.499, 2); // partial load in r,phi
weightC = GetSpaceChargeDensity(r0*100,phi0R,-0.499, 2); // partial load in r,phi
-
+
// printf("%f %f : %e %e\n",r0,phi0R,weightA,weightC);
-
+
// Summing up the vector components according to their weight
ip = 0;
- for ( Int_t j = 0 ; j < columns ; j++ ) {
+ for ( Int_t j = 0 ; j < columns ; j++ ) {
for ( Int_t i = 0 ; i < rows ; i++ ) {
for ( Int_t k = 0 ; k < phiSlices ; k++ ) {
-
+
// Note: rotating the coordinated during the sum up
-
+
Int_t rotVal = (phiPoints/phiPOC)*phiiC;
Int_t ipR = -1;
-
+
if ((ip%phiPoints)>=rotVal) {
ipR = ip-rotVal;
} else {
ipR = ip+(phiPoints-rotVal);
}
-
+
// unfortunately, the lookup tables were produced to be faster for phi symmetric charges
- // This will be the most frequent usage
+ // This will be the most frequent usage
// That's why we have to do this here and not outside the loop ...
-
+
TMatrixD &erA = *arrayofErA2[k] ;
TMatrixD &ephiA = *arrayofEphiA2[k];
TMatrixD &dEzA = *arrayofdEzA2[k] ;
-
+
TMatrixD &erC = *arrayofErC2[k] ;
TMatrixD &ephiC = *arrayofEphiC2[k];
TMatrixD &dEzC = *arrayofdEzC2[k] ;
-
+
// Sum up - Efield values in [V/m] -> transition to [V/cm]
erA(i,j) += ((*bEr)(ipR)) * weightA /100;
erC(i,j) += ((*bEr)(ipR)) * weightC /100;
ipC++; // POC configuration counter
// printf("POC: (r,phi,z) = (%f %f %f) | weight(A,C): %03.1lf %03.1lf\n",r0,phi0,z0, weightA, weightC);
-
+
}
TMatrixD &deltaEzA = *arrayofDeltaEzA2[k];
TMatrixD &erOverEzC = *arrayofEroverEzC2[k] ;
TMatrixD &ephiOverEzC = *arrayofEphioverEzC2[k];
- TMatrixD &deltaEzC = *arrayofDeltaEzC2[k];
-
+ TMatrixD &deltaEzC = *arrayofDeltaEzC2[k];
+
for ( Int_t i = 0 ; i < rows ; i++ ) { // r loop
- for ( Int_t j = columns-1 ; j >= 0 ; j-- ) {// z loop
+ for ( Int_t j = columns-1 ; j >= 0 ; j-- ) {// z loop
// Count backwards to facilitate integration over Z
- Int_t index = 1 ; // Simpsons rule if N=odd.If N!=odd then add extra point by trapezoidal rule.
+ Int_t index = 1 ; // Simpsons rule if N=odd.If N!=odd then add extra point by trapezoidal rule.
- erOverEzA(i,j) = 0;
+ erOverEzA(i,j) = 0;
ephiOverEzA(i,j) = 0;
deltaEzA(i,j) = 0;
- erOverEzC(i,j) = 0;
- ephiOverEzC(i,j) = 0;
+ erOverEzC(i,j) = 0;
+ ephiOverEzC(i,j) = 0;
deltaEzC(i,j) = 0;
for ( Int_t m = j ; m < columns ; m++ ) { // integration
deltaEzC(i,j) = (gridSizeZ/3.0)*(1.5*dezC(i,columns-2)+1.5*dezC(i,columns-1))/(-1) ;
}
if ( j == columns-1 ) {
- erOverEzA(i,j) = 0;
+ erOverEzA(i,j) = 0;
erOverEzC(i,j) = 0;
- ephiOverEzA(i,j) = 0;
+ ephiOverEzA(i,j) = 0;
ephiOverEzC(i,j) = 0;
- deltaEzA(i,j) = 0;
+ deltaEzA(i,j) = 0;
deltaEzC(i,j) = 0;
}
}
}
}
-
+
AliInfo("Step 2: Interpolation to Standard grid");
// -------------------------------------------------------------------------------
for ( Int_t k = 0 ; k < kNPhi ; k++ ) {
Double_t phi = fgkPhiList[k] ;
-
+
// final lookup table
TMatrixF &erOverEzFinal = *fLookUpErOverEz[k] ;
TMatrixF &ephiOverEzFinal = *fLookUpEphiOverEz[k];
TMatrixF &deltaEzFinal = *fLookUpDeltaEz[k] ;
-
+
for ( Int_t j = 0 ; j < kNZ ; j++ ) {
z = TMath::Abs(fgkZList[j]) ; // z position is symmetric
-
- for ( Int_t i = 0 ; i < kNR ; i++ ) {
+
+ for ( Int_t i = 0 ; i < kNR ; i++ ) {
r = fgkRList[i] ;
// Interpolate Lookup tables onto standard grid
if (fgkZList[j]>0) {
- erOverEzFinal(i,j) += Interpolate3DTable(order, r, z, phi, rows, columns, phiSlices,
+ erOverEzFinal(i,j) += Interpolate3DTable(order, r, z, phi, rows, columns, phiSlices,
rlist2, zedlist2, philist2, arrayofEroverEzA2 );
ephiOverEzFinal(i,j) += Interpolate3DTable(order, r, z, phi, rows, columns, phiSlices,
rlist2, zedlist2, philist2, arrayofEphioverEzA2);
deltaEzFinal(i,j) += Interpolate3DTable(order, r, z, phi, rows, columns, phiSlices,
rlist2, zedlist2, philist2, arrayofDeltaEzA2 );
} else {
- erOverEzFinal(i,j) += Interpolate3DTable(order, r, z, phi, rows, columns, phiSlices,
+ erOverEzFinal(i,j) += Interpolate3DTable(order, r, z, phi, rows, columns, phiSlices,
rlist2, zedlist2, philist2, arrayofEroverEzC2 );
ephiOverEzFinal(i,j) += Interpolate3DTable(order, r, z, phi, rows, columns, phiSlices,
rlist2, zedlist2, philist2, arrayofEphioverEzC2);
} // end r loop
} // end z loop
} // end phi loop
-
-
+
+
// clear the temporary arrays lists
for ( Int_t k = 0 ; k < phiSlices ; k++ ) {
- delete arrayofErA2[k];
+ delete arrayofErA2[k];
delete arrayofEphiA2[k];
delete arrayofdEzA2[k];
- delete arrayofErC2[k];
+ delete arrayofErC2[k];
delete arrayofEphiC2[k];
delete arrayofdEzC2[k];
- delete arrayofEroverEzA2[k];
+ delete arrayofEroverEzA2[k];
delete arrayofEphioverEzA2[k];
delete arrayofDeltaEzA2[k];
- delete arrayofEroverEzC2[k];
+ delete arrayofEroverEzC2[k];
delete arrayofEphioverEzC2[k];
delete arrayofDeltaEzC2[k];
}
-
+
fRPhi->Close();
-
+
// FINISHED
fInitLookUp = kTRUE;
}
void AliTPCSpaceCharge3D::InitSpaceCharge3DDistortionCourse() {
- //
- // Initialization of the Lookup table which contains the solutions of the
- // "space charge" (poisson) problem
- //
- // The sum-up uses a look-up table which contains different discretized Space charge fields
- // in order to calculate the corresponding field deviations due to a given (discretized)
- // space charge distribution ....
- //
- // Method of calculation: Weighted sum-up of the different fields within the look up table
- // Note: Full 3d version: Course and slow ...
+ /// Initialization of the Lookup table which contains the solutions of the
+ /// "space charge" (poisson) problem
+ ///
+ /// The sum-up uses a look-up table which contains different discretized Space charge fields
+ /// in order to calculate the corresponding field deviations due to a given (discretized)
+ /// space charge distribution ....
+ ///
+ /// Method of calculation: Weighted sum-up of the different fields within the look up table
+ /// Note: Full 3d version: Course and slow ...
if (fInitLookUp) {
AliInfo("Lookup table was already initialized!");
}
AliInfo("Preparation of the weighted look-up table");
-
+
TFile *f = new TFile(fSCLookUpPOCsFileName3D.Data(),"READ");
if ( !f ) {
AliError("Precalculated POC-looup-table could not be found");
}
// units are in [m]
- TVector *gridf = (TVector*) f->Get("constants");
+ TVector *gridf = (TVector*) f->Get("constants");
TVector &grid = *gridf;
TMatrix *coordf = (TMatrix*) f->Get("coordinates");
TMatrix &coord = *coordf;
TMatrix *coordPOCf = (TMatrix*) f->Get("POCcoord");
TMatrix &coordPOC = *coordPOCf;
-
+
Bool_t flagRadSym = 0;
if (grid(1)==1 && grid(4)==1) {
// AliInfo("LOOK UP TABLE IS RADIAL SYMETTRIC - Field in Phi is ZERO");
flagRadSym=1;
}
- Int_t rows = (Int_t)grid(0); // number of points in r direction
- Int_t phiSlices = (Int_t)grid(1); // number of points in phi
- Int_t columns = (Int_t)grid(2); // number of points in z direction
+ Int_t rows = (Int_t)grid(0); // number of points in r direction
+ Int_t phiSlices = (Int_t)grid(1); // number of points in phi
+ Int_t columns = (Int_t)grid(2); // number of points in z direction
const Float_t gridSizeR = (fgkOFCRadius-fgkIFCRadius)/(rows-1); // unit in [cm]
const Float_t gridSizePhi = TMath::TwoPi()/phiSlices; // unit in [rad]
const Float_t gridSizeZ = fgkTPCZ0/(columns-1); // unit in [cm]
-
+
// temporary matrices needed for the calculation
TMatrixD *arrayofErA[kNPhiSlices], *arrayofEphiA[kNPhiSlices], *arrayofdEzA[kNPhiSlices];
TMatrixD *arrayofErC[kNPhiSlices], *arrayofEphiC[kNPhiSlices], *arrayofdEzC[kNPhiSlices];
TMatrixD *arrayofEroverEzA[kNPhiSlices], *arrayofEphioverEzA[kNPhiSlices], *arrayofDeltaEzA[kNPhiSlices];
TMatrixD *arrayofEroverEzC[kNPhiSlices], *arrayofEphioverEzC[kNPhiSlices], *arrayofDeltaEzC[kNPhiSlices];
-
+
for ( Int_t k = 0 ; k < phiSlices ; k++ ) {
-
+
arrayofErA[k] = new TMatrixD(rows,columns) ;
arrayofEphiA[k] = new TMatrixD(rows,columns) ; // zero if radial symmetric
arrayofdEzA[k] = new TMatrixD(rows,columns) ;
// not necessary, it is done in the constructor of TMatrix - code deleted
}
-
+
// list of points as used in the interpolation (during sum up)
Double_t rlist[kNRows], zedlist[kNColumns] , philist[kNPhiSlices];
for ( Int_t k = 0 ; k < phiSlices ; k++ ) {
philist[k] = gridSizePhi * k;
for ( Int_t i = 0 ; i < rows ; i++ ) {
rlist[i] = fgkIFCRadius + i*gridSizeR ;
- for ( Int_t j = 0 ; j < columns ; j++ ) {
+ for ( Int_t j = 0 ; j < columns ; j++ ) {
zedlist[j] = j * gridSizeZ ;
}
}
} // only done once
-
-
+
+
TTree *treePOC = (TTree*)f->Get("POCall");
TVector *bEr = 0; TVector *bEphi= 0; TVector *bEz = 0;
-
+
treePOC->SetBranchAddress("Er",&bEr);
if (!flagRadSym) treePOC->SetBranchAddress("Ephi",&bEphi);
treePOC->SetBranchAddress("Ez",&bEz);
// Read the complete tree and do a weighted sum-up over the POC configurations
// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
-
+
Int_t treeNumPOC = (Int_t)treePOC->GetEntries(); // Number of POC conf. in the look-up table
Int_t ipC = 0; // POC Conf. counter (note: different to the POC number in the tree!)
for (Int_t itreepC=0; itreepC<treeNumPOC; itreepC++) { // ------------- loop over POC configurations in tree
-
+
treePOC->GetEntry(itreepC);
// center of the POC voxel in [meter]
// note: coordinates are in [cm]
Double_t weightA = GetSpaceChargeDensity(r0*100,phi0, z0*100,0);
Double_t weightC = GetSpaceChargeDensity(r0*100,phi0,-z0*100,0);
-
+
// Summing up the vector components according to their weight
Int_t ip = 0;
- for ( Int_t j = 0 ; j < columns ; j++ ) {
+ for ( Int_t j = 0 ; j < columns ; j++ ) {
for ( Int_t i = 0 ; i < rows ; i++ ) {
for ( Int_t k = 0 ; k < phiSlices ; k++ ) {
-
+
// check wether the coordinates were screwed
- if (TMath::Abs((coord(0,ip)*100-rlist[i]))>1 ||
- TMath::Abs((coord(1,ip)-philist[k]))>1 ||
- TMath::Abs((coord(2,ip)*100-zedlist[j]))>1) {
+ if (TMath::Abs((coord(0,ip)*100-rlist[i]))>1 ||
+ TMath::Abs((coord(1,ip)-philist[k]))>1 ||
+ TMath::Abs((coord(2,ip)*100-zedlist[j]))>1) {
AliError("internal error: coordinate system was screwed during the sum-up");
printf("lookup: (r,phi,z)=(%f,%f,%f)\n",coord(0,ip)*100,coord(1,ip),coord(2,ip)*100);
printf("sum-up: (r,phi,z)=(%f,%f,%f)\n",rlist[i],philist[k],zedlist[j]);
AliError("Don't trust the results of the space charge calculation!");
}
-
+
// unfortunately, the lookup tables were produced to be faster for phi symmetric charges
// This will be the most frequent usage (hopefully)
// That's why we have to do this here ...
TMatrixD &erA = *arrayofErA[k] ;
TMatrixD &ephiA = *arrayofEphiA[k];
TMatrixD &dEzA = *arrayofdEzA[k] ;
-
+
TMatrixD &erC = *arrayofErC[k] ;
TMatrixD &ephiC = *arrayofEphiC[k];
TMatrixD &dEzC = *arrayofdEzC[k] ;
-
+
// Sum up - Efield values in [V/m] -> transition to [V/cm]
erA(i,j) += ((*bEr)(ip)) * weightA /100;
erC(i,j) += ((*bEr)(ip)) * weightC /100;
}
}
} // end coordinate loop
-
-
+
+
// Rotation and summation in the rest of the dPhiSteps
// which were not stored in the this tree due to storage & symmetry reasons
Int_t phiPoints = (Int_t) grid(1);
Int_t phiPOC = (Int_t) grid(4);
-
+
// printf("%d %d\n",phiPOC,flagRadSym);
-
- for (Int_t phiiC = 1; phiiC<phiPOC; phiiC++) { // just used for non-radial symetric table
-
+
+ for (Int_t phiiC = 1; phiiC<phiPOC; phiiC++) { // just used for non-radial symetric table
+
r0 = coordPOC(ipC,0);
phi0 = coordPOC(ipC,1);
z0 = coordPOC(ipC,2);
-
+
ipC++; // POC conf. counter
-
+
// weights (charge density) at POC position on the A and C side (in C/m^3/e0)
// note: coordinates are in [cm]
- weightA = GetSpaceChargeDensity(r0*100,phi0, z0*100,0);
+ weightA = GetSpaceChargeDensity(r0*100,phi0, z0*100,0);
weightC = GetSpaceChargeDensity(r0*100,phi0,-z0*100,0);
-
+
// printf("%f %f %f: %e %e\n",r0,phi0,z0,weightA,weightC);
-
+
// Summing up the vector components according to their weight
ip = 0;
- for ( Int_t j = 0 ; j < columns ; j++ ) {
+ for ( Int_t j = 0 ; j < columns ; j++ ) {
for ( Int_t i = 0 ; i < rows ; i++ ) {
for ( Int_t k = 0 ; k < phiSlices ; k++ ) {
-
+
// Note: rotating the coordinated during the sum up
-
+
Int_t rotVal = (phiPoints/phiPOC)*phiiC;
Int_t ipR = -1;
-
+
if ((ip%phiPoints)>=rotVal) {
ipR = ip-rotVal;
} else {
ipR = ip+(phiPoints-rotVal);
}
-
+
// unfortunately, the lookup tables were produced to be faster for phi symmetric charges
- // This will be the most frequent usage
+ // This will be the most frequent usage
// That's why we have to do this here and not outside the loop ...
-
+
TMatrixD &erA = *arrayofErA[k] ;
TMatrixD &ephiA = *arrayofEphiA[k];
TMatrixD &dEzA = *arrayofdEzA[k] ;
-
+
TMatrixD &erC = *arrayofErC[k] ;
TMatrixD &ephiC = *arrayofEphiC[k];
TMatrixD &dEzC = *arrayofdEzC[k] ;
-
+
// Sum up - Efield values in [V/m] -> transition to [V/cm]
erA(i,j) += ((*bEr)(ipR)) * weightA /100;
erC(i,j) += ((*bEr)(ipR)) * weightC /100;
} // end coordinate loop
} // end phi-POC summation (phiiC)
-
+
// printf("POC: (r,phi,z) = (%f %f %f) | weight(A,C): %03.1lf %03.1lf\n",r0,phi0,z0, weightA, weightC);
-
+
}
TMatrixD &deltaEzA = *arrayofDeltaEzA[k];
TMatrixD &erOverEzC = *arrayofEroverEzC[k] ;
TMatrixD &ephiOverEzC = *arrayofEphioverEzC[k];
- TMatrixD &deltaEzC = *arrayofDeltaEzC[k];
-
+ TMatrixD &deltaEzC = *arrayofDeltaEzC[k];
+
for ( Int_t i = 0 ; i < rows ; i++ ) { // r loop
- for ( Int_t j = columns-1 ; j >= 0 ; j-- ) {// z loop
+ for ( Int_t j = columns-1 ; j >= 0 ; j-- ) {// z loop
// Count backwards to facilitate integration over Z
- Int_t index = 1 ; // Simpsons rule if N=odd.If N!=odd then add extra point by trapezoidal rule.
+ Int_t index = 1 ; // Simpsons rule if N=odd.If N!=odd then add extra point by trapezoidal rule.
erOverEzA(i,j) = 0; ephiOverEzA(i,j) = 0; deltaEzA(i,j) = 0;
erOverEzC(i,j) = 0; ephiOverEzC(i,j) = 0; deltaEzC(i,j) = 0;
deltaEzC(i,j) = (gridSizeZ/3.0)*(1.5*dezC(i,columns-2)+1.5*dezC(i,columns-1))/(-1) ;
}
if ( j == columns-1 ) {
- erOverEzA(i,j) = 0;
+ erOverEzA(i,j) = 0;
erOverEzC(i,j) = 0;
if (!flagRadSym) {
- ephiOverEzA(i,j) = 0;
+ ephiOverEzA(i,j) = 0;
ephiOverEzC(i,j) = 0;
}
- deltaEzA(i,j) = 0;
+ deltaEzA(i,j) = 0;
deltaEzC(i,j) = 0;
}
}
}
}
-
-
+
+
AliInfo("Interpolation to Standard grid");
// -------------------------------------------------------------------------------
// Interpolate results onto the standard grid which is used for all AliTPCCorrections classes
- const Int_t order = 1 ; // Linear interpolation = 1, Quadratic = 2
+ const Int_t order = 1 ; // Linear interpolation = 1, Quadratic = 2
Double_t r, phi, z ;
for ( Int_t k = 0 ; k < kNPhi ; k++ ) {
phi = fgkPhiList[k] ;
-
+
TMatrixF &erOverEz = *fLookUpErOverEz[k] ;
TMatrixF &ephiOverEz = *fLookUpEphiOverEz[k];
TMatrixF &deltaEz = *fLookUpDeltaEz[k] ;
-
+
for ( Int_t j = 0 ; j < kNZ ; j++ ) {
z = TMath::Abs(fgkZList[j]) ; // z position is symmetric
-
- for ( Int_t i = 0 ; i < kNR ; i++ ) {
+
+ for ( Int_t i = 0 ; i < kNR ; i++ ) {
r = fgkRList[i] ;
// Interpolate Lookup tables onto standard grid
if (fgkZList[j]>0) {
- erOverEz(i,j) = Interpolate3DTable(order, r, z, phi, rows, columns, phiSlices,
+ erOverEz(i,j) = Interpolate3DTable(order, r, z, phi, rows, columns, phiSlices,
rlist, zedlist, philist, arrayofEroverEzA );
ephiOverEz(i,j) = Interpolate3DTable(order, r, z, phi, rows, columns, phiSlices,
rlist, zedlist, philist, arrayofEphioverEzA);
deltaEz(i,j) = Interpolate3DTable(order, r, z, phi, rows, columns, phiSlices,
rlist, zedlist, philist, arrayofDeltaEzA );
} else {
- erOverEz(i,j) = Interpolate3DTable(order, r, z, phi, rows, columns, phiSlices,
+ erOverEz(i,j) = Interpolate3DTable(order, r, z, phi, rows, columns, phiSlices,
rlist, zedlist, philist, arrayofEroverEzC );
ephiOverEz(i,j) = Interpolate3DTable(order, r, z, phi, rows, columns, phiSlices,
rlist, zedlist, philist, arrayofEphioverEzC);
} // end z loop
} // end phi loop
-
+
// clear the temporary arrays lists
for ( Int_t k = 0 ; k < phiSlices ; k++ ) {
- delete arrayofErA[k];
+ delete arrayofErA[k];
delete arrayofEphiA[k];
delete arrayofdEzA[k];
- delete arrayofErC[k];
+ delete arrayofErC[k];
delete arrayofEphiC[k];
delete arrayofdEzC[k];
- delete arrayofEroverEzA[k];
+ delete arrayofEroverEzA[k];
delete arrayofEphioverEzA[k];
delete arrayofDeltaEzA[k];
- delete arrayofEroverEzC[k];
+ delete arrayofEroverEzC[k];
delete arrayofEphioverEzC[k];
delete arrayofDeltaEzC[k];
void AliTPCSpaceCharge3D::SetSCDataFileName(TString fname) {
- //
- // Set & load the Space charge density distribution from a file
- // (linear interpolation onto a standard grid)
- //
+ /// Set & load the Space charge density distribution from a file
+ /// (linear interpolation onto a standard grid)
+
-
fSCDataFileName = fname;
TFile *f = new TFile(fSCDataFileName.Data(),"READ");
- if (!f) {
+ if (!f) {
AliError(Form("File %s, which should contain the space charge distribution, could not be found",
fSCDataFileName.Data()));
return;
}
-
+
TH2F *densityRZ = (TH2F*) f->Get("SpaceChargeInRZ");
- if (!densityRZ) {
+ if (!densityRZ) {
AliError(Form("The indicated file (%s) does not contain a histogram called %s",
fSCDataFileName.Data(),"SpaceChargeInRZ"));
return;
}
TH3F *densityRPhi = (TH3F*) f->Get("SpaceChargeInRPhi");
- if (!densityRPhi) {
+ if (!densityRPhi) {
AliError(Form("The indicated file (%s) does not contain a histogram called %s",
fSCDataFileName.Data(),"SpaceChargeInRPhi"));
return;
}
-
+
Double_t r, phi, z ;
phi = fgkPhiList[k] ;
TMatrixF &scDensity = *fSCdensityDistribution[k] ;
for ( Int_t j = 0 ; j < kNZ ; j++ ) {
- z = fgkZList[j] ;
- for ( Int_t i = 0 ; i < kNR ; i++ ) {
+ z = fgkZList[j] ;
+ for ( Int_t i = 0 ; i < kNR ; i++ ) {
r = fgkRList[i] ;
// partial load in (r,z)
// partial load in (r,phi)
if ( j==0 || j == kNZ/2 ) {
- if (z>0)
+ if (z>0)
scDensityInRPhiA(i,k) = densityRPhi->Interpolate(r,phi,0.499); // A side
- else
+ else
scDensityInRPhiC(i,k) = densityRPhi->Interpolate(r,phi,-0.499); // C side
}
// Full 3D configuration ...
- if (z>0)
- scDensity(i,j) = scDensityInRZ(i,j) + scDensityInRPhiA(i,k);
+ if (z>0)
+ scDensity(i,j) = scDensityInRZ(i,j) + scDensityInRPhiA(i,k);
else
- scDensity(i,j) = scDensityInRZ(i,j) + scDensityInRPhiC(i,k);
+ scDensity(i,j) = scDensityInRZ(i,j) + scDensityInRPhiC(i,k);
}
}
}
fInitLookUp = kFALSE;
-
+
}
void AliTPCSpaceCharge3D::SetInputSpaceCharge(TH3 * hisSpaceCharge3D, TH2 * hisRPhi, TH2* hisRZ, Double_t norm){
- //
- // Use 3D space charge map as an optional input
- // The layout of the input histogram is assumed to be: (phi,r,z)
- // Density histogram is expreseed is expected to bin in C/m^3
- //
- // Standard histogram interpolation is used in order to use the density at center of voxel
- //
- //
+ /// Use 3D space charge map as an optional input
+ /// The layout of the input histogram is assumed to be: (phi,r,z)
+ /// Density histogram is expreseed is expected to bin in C/m^3
+ ///
+ /// Standard histogram interpolation is used in order to use the density at center of voxel
+
fSpaceChargeHistogram3D = hisSpaceCharge3D;
fSpaceChargeHistogramRPhi = hisRPhi;
fSpaceChargeHistogramRZ = hisRZ;
phi = fgkPhiList[k] ;
TMatrixF &scDensity = *fSCdensityDistribution[k] ;
for ( Int_t j = 0 ; j < kNZ ; j++ ) {
- z = fgkZList[j] ;
- for ( Int_t i = 0 ; i < kNR ; i++ ) {
+ z = fgkZList[j] ;
+ for ( Int_t i = 0 ; i < kNR ; i++ ) {
// Full 3D configuration ...
r = fgkRList[i] ;
- if (r>rmin && r<rmax && z>zmin && z< zmax){
+ if (r>rmin && r<rmax && z>zmin && z< zmax){
// partial load in (r,z)
if (k==0) {
if (fSpaceChargeHistogramRZ) scDensityInRZ(i,j) = norm*fSpaceChargeHistogramRZ->Interpolate(r,z) ;
}
// partial load in (r,phi)
if ( (j==0 || j == kNZ/2) && fSpaceChargeHistogramRPhi) {
- if (z>0)
+ if (z>0)
scDensityInRPhiA(i,k) = norm*fSpaceChargeHistogramRPhi->Interpolate(phi,r); // A side
- else
+ else
scDensityInRPhiC(i,k) = norm*fSpaceChargeHistogramRPhi->Interpolate(phi+TMath::TwoPi(),r); // C side
}
-
- if (z>0)
- scDensity(i,j) = norm*fSpaceChargeHistogram3D->Interpolate(phi,r,z);
+
+ if (z>0)
+ scDensity(i,j) = norm*fSpaceChargeHistogram3D->Interpolate(phi,r,z);
else
scDensity(i,j) = norm*fSpaceChargeHistogram3D->Interpolate(phi,r,z);
}
}
}
}
-
+
fInitLookUp = kFALSE;
}
Float_t AliTPCSpaceCharge3D::GetSpaceChargeDensity(Float_t r, Float_t phi, Float_t z, Int_t mode) {
- //
- // returns the (input) space charge density at a given point according
- // Note: input in [cm], output in [C/m^3/e0] !!
- //
+ /// returns the (input) space charge density at a given point according
+ /// Note: input in [cm], output in [C/m^3/e0] !!
while (phi<0) phi += TMath::TwoPi();
while (phi>TMath::TwoPi()) phi -= TMath::TwoPi();
Float_t sc = 0;
if (mode == 0) { // return full load
- sc = Interpolate3DTable(order, r, z, phi, kNR, kNZ, kNPhi,
+ sc = Interpolate3DTable(order, r, z, phi, kNR, kNZ, kNPhi,
fgkRList, fgkZList, fgkPhiList, fSCdensityDistribution );
-
+
} else if (mode == 1) { // return partial load in (r,z)
TMatrixD &scDensityInRZ = *fSCdensityInRZ;
sc = Interpolate2DTable(order, r, z, kNR, kNZ, fgkRList, fgkZList, scDensityInRZ );
-
+
} else if (mode == 2) { // return partial load in (r,phi)
if (z>0) {
// should i give a warning?
sc = 0;
}
-
+
// printf("%f %f %f: %f\n",r,phi,z,sc);
-
+
return sc;
}
TH2F * AliTPCSpaceCharge3D::CreateHistoSCinXY(Float_t z, Int_t nx, Int_t ny, Int_t mode) {
- //
- // return a simple histogramm containing the space charge distribution (input for the calculation)
- //
+ /// return a simple histogramm containing the space charge distribution (input for the calculation)
TH2F *h=CreateTH2F("spaceCharge",GetTitle(),"x [cm]","y [cm]","#rho_{sc} [C/m^{3}/e_{0}]",
nx,-250.,250.,ny,-250.,250.);
Double_t yp = h->GetYaxis()->GetBinCenter(iy);
for (Int_t ix=1;ix<=nx;++ix) {
Double_t xp = h->GetXaxis()->GetBinCenter(ix);
-
+
Float_t r = TMath::Sqrt(xp*xp+yp*yp);
- Float_t phi = TMath::ATan2(yp,xp);
-
+ Float_t phi = TMath::ATan2(yp,xp);
+
if (85.<=r && r<=250.) {
Float_t sc = GetSpaceChargeDensity(r,phi,z,mode)/fgke0; // in [C/m^3/e0]
- h->SetBinContent(ix,iy,sc);
+ h->SetBinContent(ix,iy,sc);
} else {
h->SetBinContent(ix,iy,0.);
}
}
}
-
+
return h;
-}
+}
TH2F * AliTPCSpaceCharge3D::CreateHistoSCinZR(Float_t phi, Int_t nz, Int_t nr,Int_t mode ) {
- //
- // return a simple histogramm containing the space charge distribution (input for the calculation)
- //
+ /// return a simple histogramm containing the space charge distribution (input for the calculation)
TH2F *h=CreateTH2F("spaceCharge",GetTitle(),"z [cm]","r [cm]","#rho_{sc} [C/m^{3}/e_{0}]",
nz,-250.,250.,nr,85.,250.);
}
return h;
-}
+}
void AliTPCSpaceCharge3D::WriteChargeDistributionToFile(const char* fname) {
- //
- // Example on how to write a Space charge distribution into a File
- // (see below: estimate from scaling STAR measurements to Alice)
- // Charge distribution is splitted into two (RZ and RPHI) in order to speed up
- // the needed calculation time
- //
+ /// Example on how to write a Space charge distribution into a File
+ /// (see below: estimate from scaling STAR measurements to Alice)
+ /// Charge distribution is splitted into two (RZ and RPHI) in order to speed up
+ /// the needed calculation time
TFile *f = new TFile(fname,"RECREATE");
-
+
// some grid, not too course
Int_t nr = 350;
Int_t nphi = 180;
TH2F *histoZR = new TH2F("chargeZR","chargeZR",
nr,fgkIFCRadius-dr-safty,fgkOFCRadius+dr+safty,
nz,-250-dz-safty,250+dz+safty);
-
+
for (Int_t ir=1;ir<=nr;++ir) {
Double_t rp = histoZR->GetXaxis()->GetBinCenter(ir);
for (Int_t iz=1;iz<=nz;++iz) {
Double_t zp = histoZR->GetYaxis()->GetBinCenter(iz);
-
+
// recalculation to meter
Double_t lZ = 2.5; // approx. TPC drift length
Double_t rpM = rp/100.; // in [m]
Double_t zpM = TMath::Abs(zp/100.); // in [m]
-
+
// setting of mb multiplicity and Interaction rate
Double_t multiplicity = 950;
Double_t intRate = 7800;
// calculation of "scaled" parameters
Double_t a = multiplicity*intRate/79175;
Double_t b = a/lZ;
-
+
Double_t charge = (a - b*zpM)/(rpM*rpM); // charge in [C/m^3/e0]
-
+
charge = charge*fgke0; // [C/m^3]
-
+
if (zp<0) charge *= 0.9; // e.g. slightly less on C side due to front absorber
// charge = 0; // for tests
- histoZR->SetBinContent(ir,iz,charge);
+ histoZR->SetBinContent(ir,iz,charge);
}
}
-
+
histoZR->Write("SpaceChargeInRZ");
-
+
// Charge distribution in RPhi (e.g. Floating GG wire) ------------
-
+
TH3F *histoRPhi = new TH3F("chargeRPhi","chargeRPhi",
nr,fgkIFCRadius-dr-safty,fgkOFCRadius+dr+safty,
nphi,0-dphi-safty,TMath::TwoPi()+dphi+safty,
2,-1,1); // z part - to allow A and C side differences
-
+
// some 'arbitrary' GG leaks
Int_t nGGleaks = 5;
Double_t secPosA[5] = {3,6,6,11,13}; // sector
Double_t phip = histoRPhi->GetYaxis()->GetBinCenter(iphi);
for (Int_t iz=1;iz<=2;++iz) {
Double_t zp = histoRPhi->GetZaxis()->GetBinCenter(iz);
-
+
Double_t charge = 0;
-
+
for (Int_t igg = 0; igg<nGGleaks; igg++) { // loop over GG leaks
-
+
// A side
- Double_t secPos = secPosA[igg];
+ Double_t secPos = secPosA[igg];
Double_t radialPos = radialPosA[igg];
if (zp<0) { // C side
- secPos = secPosC[igg];
+ secPos = secPosC[igg];
radialPos = radialPosC[igg];
- }
+ }
// some 'arbitrary' GG leaks
if ( (phip<(TMath::Pi()/9*(secPos+1)) && phip>(TMath::Pi()/9*secPos) ) ) { // sector slice
if ( rp>(radialPos-2.5) && rp<(radialPos+2.5)) // 5 cm slice
- charge = 300;
+ charge = 300;
}
-
- }
-
+
+ }
+
charge = charge*fgke0; // [C/m^3]
- histoRPhi->SetBinContent(ir,iphi,iz,charge);
+ histoRPhi->SetBinContent(ir,iphi,iz,charge);
}
}
}
histoRPhi->Write("SpaceChargeInRPhi");
f->Close();
-
+
}
void AliTPCSpaceCharge3D::Print(const Option_t* option) const {
- //
- // Print function to check the settings of the boundary vectors
- // option=="a" prints the C0 and C1 coefficents for calibration purposes
- //
+ /// Print function to check the settings of the boundary vectors
+ /// option=="a" prints the C0 and C1 coefficents for calibration purposes
TString opt = option; opt.ToLower();
printf("%s\n",GetTitle());
if (opt.Contains("a")) { // Print all details
printf(" - T1: %1.4f, T2: %1.4f \n",fT1,fT2);
printf(" - C1: %1.4f, C0: %1.4f \n",fC1,fC0);
- }
-
+ }
+
if (!fInitLookUp) AliError("Lookup table was not initialized! You should do InitSpaceCharge3DDistortion() ...");
-}
+}
void AliTPCSpaceCharge3D::InitSpaceCharge3DPoisson(Int_t kRows, Int_t kColumns, Int_t kPhiSlices, Int_t kIterations){
+ /// MI extension - calculate E field
+ /// - inspired by AliTPCROCVoltError3D::InitROCVoltError3D()
+ /// Initialization of the Lookup table which contains the solutions of the
+ /// Dirichlet boundary problem
+ /// Calculation of the single 3D-Poisson solver is done just if needed
+ /// (see basic lookup tables in header file)
+
+ Int_t kPhiSlicesPerSector = kPhiSlices/18;
//
- // MI extension - calculate E field
- // - inspired by AliTPCROCVoltError3D::InitROCVoltError3D()
- // Initialization of the Lookup table which contains the solutions of the
- // Dirichlet boundary problem
- // Calculation of the single 3D-Poisson solver is done just if needed
- // (see basic lookup tables in header file)
- //
- Int_t kPhiSlicesPerSector = kPhiSlices/18;
- //
- const Int_t order = 1 ; // Linear interpolation = 1, Quadratic = 2
+ const Int_t order = 1 ; // Linear interpolation = 1, Quadratic = 2
const Float_t gridSizeR = (fgkOFCRadius-fgkIFCRadius) / (kRows-1) ;
const Float_t gridSizeZ = fgkTPCZ0 / (kColumns-1) ;
const Float_t gridSizePhi = TMath::TwoPi() / ( 18.0 * kPhiSlicesPerSector);
// temporary arrays to create the boundary conditions
- TMatrixD *arrayofArrayV[kPhiSlices], *arrayofCharge[kPhiSlices] ;
- TMatrixD *arrayofEroverEz[kPhiSlices], *arrayofEphioverEz[kPhiSlices], *arrayofDeltaEz[kPhiSlices] ;
+ TMatrixD *arrayofArrayV[kPhiSlices], *arrayofCharge[kPhiSlices] ;
+ TMatrixD *arrayofEroverEz[kPhiSlices], *arrayofEphioverEz[kPhiSlices], *arrayofDeltaEz[kPhiSlices] ;
for ( Int_t k = 0 ; k < kPhiSlices ; k++ ) {
arrayofArrayV[k] = new TMatrixD(kRows,kColumns) ;
arrayofEphioverEz[k] = new TMatrixD(kRows,kColumns) ;
arrayofDeltaEz[k] = new TMatrixD(kRows,kColumns) ;
}
-
+
// list of point as used in the poisson relation and the interpolation (during sum up)
Double_t rlist[kRows], zedlist[kColumns] , philist[kPhiSlices];
for ( Int_t k = 0 ; k < kPhiSlices ; k++ ) {
// ==========================================================================
// Solve Poisson's equation in 3D cylindrical coordinates by relaxation technique
// Allow for different size grid spacing in R and Z directions
-
+
const Int_t symmetry = 0;
-
+
// Set bondaries and solve Poisson's equation --------------------------
-
+
if ( !fInitLookUp ) {
-
+
AliInfo(Form("Solving the poisson equation (~ %d sec)",2*10*(int)(kPhiSlices/10)));
-
+
for ( Int_t side = 0 ; side < 2 ; side++ ) { // Solve Poisson3D twice; once for +Z and once for -Z
AliSysInfo::AddStamp("RunSide", 1,side,0);
for ( Int_t k = 0 ; k < kPhiSlices ; k++ ) {
TMatrixD &arrayV = *arrayofArrayV[k] ;
TMatrixD &charge = *arrayofCharge[k] ;
-
+
//Fill arrays with initial conditions. V on the boundary and Charge in the volume.
// for ( Int_t i = 0 ; i < kRows ; i++ ) {
// for ( Int_t j = 0 ; j < kColumns ; j++ ) { // Fill Vmatrix with Boundary Conditions
-// arrayV(i,j) = 0.0 ;
+// arrayV(i,j) = 0.0 ;
// charge(i,j) = 0.0 ;
// // Float_t radius0 = rlist[i] ;
// // Float_t phi0 = gridSizePhi * k ;
-
+
// // To avoid problems at sector boundaries, use an average of +- 1 degree from actual phi location
// // if ( j == (kColumns-1) ) {
// // arrayV(i,j) = 0.5* ( GetROCVoltOffset( side, radius0, phi0+0.02 ) + GetROCVoltOffset( side, radius0, phi0-0.02 ) ) ;
// // arrayV(i,j) = -arrayV(i,j); // minus sign on the C side to allow a consistent usage of global z when setting the boundaries
// // }
// }
-// }
-
- for ( Int_t i = 1 ; i < kRows-1 ; i++ ) {
- for ( Int_t j = 1 ; j < kColumns-1 ; j++ ) {
+// }
+
+ for ( Int_t i = 1 ; i < kRows-1 ; i++ ) {
+ for ( Int_t j = 1 ; j < kColumns-1 ; j++ ) {
Float_t radius0 = rlist[i] ;
Float_t phi0 = gridSizePhi * k ;
Double_t z0 = zedlist[j];
if (side==1) z0= -TMath::Abs(zedlist[j]);
- arrayV(i,j) = 0.0 ;
+ arrayV(i,j) = 0.0 ;
charge(i,j) = fSpaceChargeHistogram3D->Interpolate(phi0,radius0,z0);
}
}
- }
+ }
AliSysInfo::AddStamp("RunPoisson", 2,side,0);
-
+
// Solve Poisson's equation in 3D cylindrical coordinates by relaxation technique
// Allow for different size grid spacing in R and Z directions
-
- // PoissonRelaxation3D( arrayofArrayV, arrayofCharge,
+
+ // PoissonRelaxation3D( arrayofArrayV, arrayofCharge,
// arrayofEroverEz, arrayofEphioverEz, arrayofDeltaEz,
- // kRows, kColumns, kPhiSlices, gridSizePhi, kIterations,
+ // kRows, kColumns, kPhiSlices, gridSizePhi, kIterations,
// symmetry , fROCdisplacement) ;
- PoissonRelaxation3D( arrayofArrayV, arrayofCharge,
+ PoissonRelaxation3D( arrayofArrayV, arrayofCharge,
arrayofEroverEz, arrayofEphioverEz, arrayofDeltaEz,
- kRows, kColumns, kPhiSlices, gridSizePhi, kIterations,
+ kRows, kColumns, kPhiSlices, gridSizePhi, kIterations,
symmetry ) ;
-
+
//Interpolate results onto a custom grid which is used just for these calculations.
Double_t r, phi, z ;
for ( Int_t k = 0 ; k < kNPhi ; k++ ) {
phi = fgkPhiList[k] ;
-
+
TMatrixF &erOverEz = *fLookUpErOverEz[k] ;
TMatrixF &ephiOverEz = *fLookUpEphiOverEz[k];
TMatrixF &deltaEz = *fLookUpDeltaEz[k] ;
-
+
for ( Int_t j = 0 ; j < kNZ ; j++ ) {
z = TMath::Abs(fgkZList[j]) ; // Symmetric solution in Z that depends only on ABS(Z)
-
+
if ( side == 0 && fgkZList[j] < 0 ) continue; // Skip rest of this loop if on the wrong side
if ( side == 1 && fgkZList[j] > 0 ) continue; // Skip rest of this loop if on the wrong side
-
- for ( Int_t i = 0 ; i < kNR ; i++ ) {
+
+ for ( Int_t i = 0 ; i < kNR ; i++ ) {
r = fgkRList[i] ;
// Interpolate basicLookup tables; once for each rod, then sum the results
- erOverEz(i,j) = Interpolate3DTable(order, r, z, phi, kRows, kColumns, kPhiSlices,
+ erOverEz(i,j) = Interpolate3DTable(order, r, z, phi, kRows, kColumns, kPhiSlices,
rlist, zedlist, philist, arrayofEroverEz );
ephiOverEz(i,j) = Interpolate3DTable(order, r, z, phi, kRows, kColumns, kPhiSlices,
rlist, zedlist, philist, arrayofEphioverEz);
} // end r loop
}// end z loop
}// end phi loop
- AliSysInfo::AddStamp("Interpolate Poisson", 3,side,0);
+ AliSysInfo::AddStamp("Interpolate Poisson", 3,side,0);
if ( side == 0 ) AliInfo(" A side done");
if ( side == 1 ) AliInfo(" C side done");
} // end side loop
}
-
+
// clear the temporary arrays lists
for ( Int_t k = 0 ; k < kPhiSlices ; k++ ) {
delete arrayofArrayV[k];
delete arrayofCharge[k];
- delete arrayofEroverEz[k];
+ delete arrayofEroverEz[k];
delete arrayofEphioverEz[k];
delete arrayofDeltaEz[k];
}
-
+
fInitLookUp = kTRUE;
AliTPCSpaceCharge3D * AliTPCSpaceCharge3D::MakeCorrection22D(const char* fileName, Double_t multiplicity, Double_t intRate, Double_t epsIROC, Double_t epsOROC,
- Double_t gasfactor,
+ Double_t gasfactor,
Double_t radialScaling){
- //
- // Origin: Christian Lippmann, CERN, Christian.Lippmann@cern.ch based on the internal note (xxx ...)
- // adopted by Marian Ivanov (different epsilon in IROC and OROC)
- //
- // Charge distribution is splitted into two (RZ and RPHI) in order to speed up
- // the needed calculation time.
- //
- // Explanation of variables:
- // 1) multiplicity: charghed particle dn/deta for top 80% centrality (660 for 2011,
- // expect 950 for full energy)
- // 2) intRate: Total interaction rate (e.g. 50kHz for the upgrade)
- // 3) eps: Number of backdrifting ions per primary electron (0 for MWPC, e.g.10 for GEM)
- // 4) gasfactor: Use different gas. E.g. Ar/CO2 has twice the primary ionization, ion drift
- // velocity factor 2.5 slower, so gasfactor = 5.
- //
-
-
- TFile *f = new TFile(fileName, "RECREATE");
+ /// Origin: Christian Lippmann, CERN, Christian.Lippmann@cern.ch based on the internal note (xxx ...)
+ /// adopted by Marian Ivanov (different epsilon in IROC and OROC)
+ ///
+ /// Charge distribution is splitted into two (RZ and RPHI) in order to speed up
+ /// the needed calculation time.
+ ///
+ /// Explanation of variables:
+ /// 1) multiplicity: charghed particle dn/deta for top 80% centrality (660 for 2011,
+ /// expect 950 for full energy)
+ /// 2) intRate: Total interaction rate (e.g. 50kHz for the upgrade)
+ /// 3) eps: Number of backdrifting ions per primary electron (0 for MWPC, e.g.10 for GEM)
+ /// 4) gasfactor: Use different gas. E.g. Ar/CO2 has twice the primary ionization, ion drift
+ /// velocity factor 2.5 slower, so gasfactor = 5.
+
+
+ TFile *f = new TFile(fileName, "RECREATE");
// some grid, not too coarse
const Int_t nr = 350;
const Int_t nphi = 180;
const Int_t nz = 500;
- const Double_t kROROC=134; // hardwired OROC radius
+ const Double_t kROROC=134; // hardwired OROC radius
Double_t dr = (fgkOFCRadius-fgkIFCRadius)/(nr+1);
Double_t dphi = TMath::TwoPi()/(nphi+1);
Double_t radialExponent = -2.; // reference = 2
Double_t radiusInner = histoZR->GetXaxis()->GetBinCenter(1) / 100.;//in [m]
Double_t radiusOuter = histoZR->GetXaxis()->GetBinCenter(nr) / 100.;//in [m]
- Double_t integralRadialExponent2 = TMath::Power(radiusOuter,radialExponent+1) * 1./(radialExponent+1)
+ Double_t integralRadialExponent2 = TMath::Power(radiusOuter,radialExponent+1) * 1./(radialExponent+1)
- TMath::Power(radiusInner,radialExponent+1) * 1./(radialExponent+1);
-
- radialExponent = -radialScaling; // user set
+
+ radialExponent = -radialScaling; // user set
Double_t integralRadialExponentUser = 0.;
if(radialScaling > 1 + 0.000001 || radialScaling < 1 - 0.000001 ) // to avoid n = -1
- integralRadialExponentUser = TMath::Power(radiusOuter,radialExponent+1) * 1./(radialExponent+1)
+ integralRadialExponentUser = TMath::Power(radiusOuter,radialExponent+1) * 1./(radialExponent+1)
- TMath::Power(radiusInner,radialExponent+1) * 1./(radialExponent+1);
else
integralRadialExponentUser = TMath::Log(radiusOuter) - TMath::Log(radiusInner);
-
+
Double_t normRadialExponent = integralRadialExponent2 / integralRadialExponentUser;
-
+
for (Int_t ir=1;ir<=nr;++ir) {
Double_t rp = histoZR->GetXaxis()->GetBinCenter(ir);
for (Int_t iz=1;iz<=nz;++iz) {
Double_t zp = histoZR->GetYaxis()->GetBinCenter(iz);
- Double_t eps = (rp <kROROC) ? epsIROC:epsOROC;
+ Double_t eps = (rp <kROROC) ? epsIROC:epsOROC;
// recalculation to meter
Double_t lZ = 2.5; // approx. TPC drift length
Double_t rpM = rp/100.; // in [m]
Double_t zpM = TMath::Abs(zp/100.); // in [m]
-
+
// calculation of "scaled" parameters
Double_t a = multiplicity*intRate/76628;
//Double_t charge = gasfactor * ( a / (rpM*rpM) * (1 - zpM/lZ) ); // charge in [C/m^3/e0], no IBF
Double_t charge = normRadialExponent * gasfactor * ( a / (TMath::Power(rpM,radialScaling)) * (1 - zpM/lZ + eps) ); // charge in [C/m^3/e0], with IBF
-
+
charge = charge*fgke0; // [C/m^3]
if (zp<0) charge *= 0.9; // Slightly less on C side due to front absorber
- histoZR->SetBinContent(ir, iz, charge);
+ histoZR->SetBinContent(ir, iz, charge);
}
}
-
+
histoZR->Write("SpaceChargeInRZ");
//
// Charge distribution in RPhi (e.g. Floating GG wire) ------------
TH3F *histoRPhi = new TH3F("chargeRPhi", "chargeRPhi",
nr, fgkIFCRadius-dr-safty, fgkOFCRadius+dr+safty,
nphi, 0-dphi-safty, TMath::TwoPi()+dphi+safty,
- 2, -1, 1); // z part - to allow A and C side differences
+ 2, -1, 1); // z part - to allow A and C side differences
histoRPhi->Write("SpaceChargeInRPhi");
f->Close();
//
/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
* See cxx source for full Copyright notice */
-////////////////////////////////////////////////////////////////////////////
-// AliTPCSpaceCharge3D class //
-// Authors: Stefan Rossegger //
-////////////////////////////////////////////////////////////////////////////
+/// \class AliTPCSpaceCharge3D
+/// \author Stefan Rossegger
#include "AliTPCCorrection.h"
class TH3F;
void SetInputSpaceCharge(TH3 * hisSpaceCharge3D, TH2 * hisRPhi, TH2* hisRZ, Double_t norm);
void SetInputSpaceCharge3D(TH3 * hisSpaceCharge3D){fSpaceChargeHistogram3D= hisSpaceCharge3D;}
- const TH3 * GetInputSpaceCharge3D(){return fSpaceChargeHistogram3D;} // MI add
- const TH2 * GetInputSpaceChargeRPhi(){return fSpaceChargeHistogramRPhi;} // MI add
- const TH2 * GetInputSpaceChargeRZ(){return fSpaceChargeHistogramRZ;} // MI add
+ const TH3 * GetInputSpaceCharge3D(){return fSpaceChargeHistogram3D;} // MI add
+ const TH2 * GetInputSpaceChargeRPhi(){return fSpaceChargeHistogramRPhi;} // MI add
+ const TH2 * GetInputSpaceChargeRZ(){return fSpaceChargeHistogramRZ;} // MI add
virtual void GetCorrection(const Float_t x[],const Short_t roc,Float_t dx[]);
static AliTPCSpaceCharge3D *MakeCorrection22D(const char * filename = "SpaceChargeMap.root", Double_t multiplicity = 950., Double_t intRate = 5e4, Double_t epsIROC = 10., Double_t epsOROC=10,
- Double_t gasfactor = 1.,
+ Double_t gasfactor = 1.,
Double_t radialScaling = 1.5);
private:
// maximum sizes of lookup tables
- enum {kNRows= 90 }; // the maximum on row-slices so far ~ 2cm slicing
- enum {kNPhiSlices= 144 }; // the maximum of phi-slices so far = (8 per sector)
- enum {kNColumns= 130 }; // the maximum on column-slices so ~ 2cm slicing
+ enum {kNRows= 90 }; // the maximum on row-slices so far ~ 2cm slicing
+ enum {kNPhiSlices= 144 }; // the maximum of phi-slices so far = (8 per sector)
+ enum {kNColumns= 130 }; // the maximum on column-slices so ~ 2cm slicing
AliTPCSpaceCharge3D(const AliTPCSpaceCharge3D &); // not implemented
AliTPCSpaceCharge3D &operator=(const AliTPCSpaceCharge3D &); // not implemented
- Float_t fC0; // coefficient C0 (compare Jim Thomas's notes for definitions)
- Float_t fC1; // coefficient C1 (compare Jim Thomas's notes for definitions)
- Float_t fCorrectionFactor; // Space Charge Correction factor in comparison to initialized
+ Float_t fC0; ///< coefficient C0 (compare Jim Thomas's notes for definitions)
+ Float_t fC1; ///< coefficient C1 (compare Jim Thomas's notes for definitions)
+ Float_t fCorrectionFactor; ///< Space Charge Correction factor in comparison to initialized
// look up table which was created for M_mb = 900 and IR = 3000
// compare Internal Note Nr: ???
- Bool_t fInitLookUp; // flag to check if the Look Up table was created
+ Bool_t fInitLookUp; ///< flag to check if the Look Up table was created
- TMatrixF *fLookUpErOverEz[kNPhi]; // Array to store electric field integral (int Er/Ez)
- TMatrixF *fLookUpEphiOverEz[kNPhi]; // Array to store electric field integral (int Er/Ez)
- TMatrixF *fLookUpDeltaEz[kNPhi]; // Array to store electric field integral (int Er/Ez)
+ TMatrixF *fLookUpErOverEz[kNPhi]; ///< Array to store electric field integral (int Er/Ez)
+ TMatrixF *fLookUpEphiOverEz[kNPhi]; ///< Array to store electric field integral (int Er/Ez)
+ TMatrixF *fLookUpDeltaEz[kNPhi]; ///< Array to store electric field integral (int Er/Ez)
- TString fSCDataFileName; // file which contains the space charge distribution
- TString fSCLookUpPOCsFileName3D; // filename of the precalculated lookup tables (for individual voxels)
- TString fSCLookUpPOCsFileNameRZ; // filename of the precalculated lookup tables (for individual voxels)
- TString fSCLookUpPOCsFileNameRPhi; // filename of the precalculated lookup tables (for individual voxels)
+ TString fSCDataFileName; ///< file which contains the space charge distribution
+ TString fSCLookUpPOCsFileName3D; ///< filename of the precalculated lookup tables (for individual voxels)
+ TString fSCLookUpPOCsFileNameRZ; ///< filename of the precalculated lookup tables (for individual voxels)
+ TString fSCLookUpPOCsFileNameRPhi; ///< filename of the precalculated lookup tables (for individual voxels)
- TMatrixF *fSCdensityDistribution[kNPhi]; // 3D space charge distribution
- TMatrixD *fSCdensityInRZ; // (r,z) space charge distribution
- TMatrixD *fSCdensityInRPhiA; // (r,phi) space charge distribution
- TMatrixD *fSCdensityInRPhiC; // (r,phi) space charge distribution
- TH3 * fSpaceChargeHistogram3D; // Histogram with the input space charge histogram - used as an optional input
- TH2 * fSpaceChargeHistogramRPhi; // Histogram with the input space charge histogram - used as an optional input
- TH2 * fSpaceChargeHistogramRZ; // Histogram with the input space charge histogram - used as an optional input
- ClassDef(AliTPCSpaceCharge3D,2);
+ TMatrixF *fSCdensityDistribution[kNPhi]; ///< 3D space charge distribution
+ TMatrixD *fSCdensityInRZ; ///< (r,z) space charge distribution
+ TMatrixD *fSCdensityInRPhiA; ///< (r,phi) space charge distribution
+ TMatrixD *fSCdensityInRPhiC; ///< (r,phi) space charge distribution
+ TH3 * fSpaceChargeHistogram3D; ///< Histogram with the input space charge histogram - used as an optional input
+ TH2 * fSpaceChargeHistogramRPhi; ///< Histogram with the input space charge histogram - used as an optional input
+ TH2 * fSpaceChargeHistogramRZ; ///< Histogram with the input space charge histogram - used as an optional input
+ /// \cond CLASSIMP
+ ClassDef(AliTPCSpaceCharge3D,2);
+ /// \endcond
};
#endif
**************************************************************************/
-///////////////////////////////////////////////////////////////////////////////
-// //
-// TPC calibration class for temperature maps and tendencies //
-// (based on TPC Temperature Sensors and FiniteElement Simulation) //
-// //
-// Authors: Stefan Rossegger, Haavard Helstrup //
-// //
-// Note: Obvioulsy some changes by Marian, but when ??? //
-// //
-///////////////////////////////////////////////////////////////////////////////
+/// \class AliTPCTempMap
+/// \brief TPC calibration class for temperature maps and tendencies
+///
+/// (based on TPC Temperature Sensors and FiniteElement Simulation)
+///
+/// Note: Obvioulsy some changes by Marian, but when ???
+///
+/// \author Stefan Rossegger, Haavard Helstrup
#include "AliTPCSensorTempArray.h"
#include "TLinearFitter.h"
#include "AliTPCTempMap.h"
+/// \cond CLASSIMP
ClassImp(AliTPCTempMap)
-
+/// \endcond
+
const char kStringFEsimulation[] = "FEsimulation.txt";
//_____________________________________________________________________________
fTempArray(0),
fStringFEsimulation(kStringFEsimulation)
{
- //
- // AliTPCTempMap default constructor
- //
+ /// AliTPCTempMap default constructor
fTempArray = sensorDCS;
fTempArray(c.fTempArray),
fStringFEsimulation(c.fStringFEsimulation)
{
- //
- // AliTPCTempMap copy constructor
- //
+ /// AliTPCTempMap copy constructor
}
//_____________________________________________________________________________
AliTPCTempMap::~AliTPCTempMap()
{
- //
- // AliTPCTempMap destructor
- //
-
+ /// AliTPCTempMap destructor
+
}
//_____________________________________________________________________________
AliTPCTempMap &AliTPCTempMap::operator=(const AliTPCTempMap &c)
{
- //
- // Assignment operator
- //
+ /// Assignment operator
if (this != &c) ((AliTPCTempMap &) c).Copy(*this);
return *this;
//_____________________________________________________________________________
void AliTPCTempMap::Copy(TObject &c) const
{
- //
- // Copy function
- //
-
+ /// Copy function
+
TObject::Copy(c);
-
+
}
//_____________________________________________________________________________
Double_t AliTPCTempMap::GetTempGradientY(UInt_t timeSec, Int_t side){
- //
- // Extract Linear Vertical Temperature Gradient [K/cm] within the TPC on
- // Shaft Side(A): 0
- // Muon Side(C): 1
- // Values based on TemperatureSensors within the TPC ( type: 3 (TPC) )
- //
- // FIXME: Also return residual-distribution, covariance Matrix
- // or simply chi2 for validity check?
- // -> better use GetLinearFitter - function in this case!
-
+ /// Extract Linear Vertical Temperature Gradient [K/cm] within the TPC on
+ /// Shaft Side(A): 0
+ /// Muon Side(C): 1
+ /// Values based on TemperatureSensors within the TPC ( type: 3 (TPC) )
+ ///
+ /// FIXME: Also return residual-distribution, covariance Matrix
+ /// or simply chi2 for validity check?
+ /// -> better use GetLinearFitter - function in this case!
+
TLinearFitter *fitter = new TLinearFitter(3,"x0++x1++x2");
TVectorD param(3);
Int_t i = 0;
Int_t nsensors = fTempArray->NumSensors();
for (Int_t isensor=0; isensor<nsensors; isensor++) { // loop over all sensors
AliTPCSensorTemp *entry = (AliTPCSensorTemp*)fTempArray->GetSensorNum(isensor);
-
- if (entry->GetType()==3 && entry->GetSide()==side) { // take SensorType:TPC
+
+ if (entry->GetType()==3 && entry->GetSide()==side) { // take SensorType:TPC
Double_t x[3];
x[0]=1;
x[1]=entry->GetX();
- x[2]=entry->GetY();
+ x[2]=entry->GetY();
Double_t y = fTempArray->GetValue(timeSec,isensor); // get temperature value
if (IsOK(y)) fitter->AddPoint(x,y,1); // add values to LinearFitter
i++;
}
- }
+ }
fitter->Eval();
fitter->GetParameters(param);
fitter->~TLinearFitter();
return param[2]; // return vertical (Y) tempGradient in [K/cm]
-
+
}
//_____________________________________________________________________________
TLinearFitter *AliTPCTempMap::GetLinearFitter(Int_t type, Int_t side, TTimeStamp &stamp)
{
- //
- // absolute time stamp used
- // see AliTPCTempMap::GetLinearFitter(Int_t type, Int_t side, UInt_t timeSec) for details
- //
+ /// absolute time stamp used
+ /// see AliTPCTempMap::GetLinearFitter(Int_t type, Int_t side, UInt_t timeSec) for details
+
Int_t timeSec = stamp.GetSec()-fTempArray->GetStartTime().GetSec();
return GetLinearFitter(type,side,timeSec);
}
//_____________________________________________________________________________
TLinearFitter *AliTPCTempMap::GetLinearFitter(Int_t type, Int_t side, UInt_t timeSec)
{
- //
- // Creates a TlinearFitter object for the desired region of the TPC
- // (via choosen type and side of TPC temperature sensors) at a given
- // timeSec (in secounds) after start time
- // type: 0 ... ReadOutChambers (ROC)
- // 1 ... OuterContainmentVessel (OFC)
- // 2 ... InnerContainmentVessel (IFC) + ThermalScreener (TS)
- // 3 ... Within the TPC (DriftVolume) (TPC)
- // 4 ... Only InnerContainmentVessel (IFC)
- // side: Can be choosen for type 0 and 3 (otherwise it will be ignored in
- // in order to get all temperature sensors of interest)
- // 0 ... Shaft Side (A)
- // 1 ... Muon Side (C)
- //
+ /// Creates a TlinearFitter object for the desired region of the TPC
+ /// (via choosen type and side of TPC temperature sensors) at a given
+ /// timeSec (in secounds) after start time
+ /// type: 0 ... ReadOutChambers (ROC)
+ /// 1 ... OuterContainmentVessel (OFC)
+ /// 2 ... InnerContainmentVessel (IFC) + ThermalScreener (TS)
+ /// 3 ... Within the TPC (DriftVolume) (TPC)
+ /// 4 ... Only InnerContainmentVessel (IFC)
+ /// side: Can be choosen for type 0 and 3 (otherwise it will be ignored in
+ /// in order to get all temperature sensors of interest)
+ /// 0 ... Shaft Side (A)
+ /// 1 ... Muon Side (C)
TLinearFitter *fitter = new TLinearFitter(3);
Double_t x[3]={0};
Double_t y = 0;
const Float_t kMaxDelta=0.5;
-
+
if (type == 1 || type == 2 || type == 4) {
fitter->SetFormula("x0++x1++TMath::Sin(x2)"); // returns Z,Y gradient
} else {
Float_t medianTemp = TMath::Median(i, temps);
if (i<3) return 0;
Float_t rmsTemp = TMath::RMS(i, temps);
-
+
i=0;
-
+
for (Int_t isensor=0; isensor<nsensors; isensor++) { // loop over all sensors
AliTPCSensorTemp *entry = (AliTPCSensorTemp*)fTempArray->GetSensorNum(isensor);
-
+
if (type==0 || type==3) { // 'side' information used
if (entry->GetType()==type && entry->GetSide()==side) {
x[0]=1;
x[1]=entry->GetX();
- x[2]=entry->GetY();
+ x[2]=entry->GetY();
y = fTempArray->GetValue(timeSec,isensor); // get temperature value
if (TMath::Abs(y-medianTemp)>kMaxDelta+4.*rmsTemp) continue;
if (IsOK(y)) fitter->AddPoint(x,y,1); // add values to LinearFitter
if ((entry->GetType()==2) || (entry->GetType()==5)) {
x[0]=1;
x[1]=entry->GetZ();
- x[2]=entry->GetPhi();
+ x[2]=entry->GetPhi();
y = fTempArray->GetValue(timeSec,isensor);
if (TMath::Abs(y-medianTemp)>kMaxDelta+4.*rmsTemp) continue;
- if (IsOK(y)) fitter->AddPoint(x,y,1);
+ if (IsOK(y)) fitter->AddPoint(x,y,1);
i++;
}
} else if (type==1){
if (entry->GetType()==type) {
x[0]=1;
x[1]=entry->GetZ();
- x[2]=entry->GetPhi();
+ x[2]=entry->GetPhi();
y = fTempArray->GetValue(timeSec,isensor);
if (TMath::Abs(y-medianTemp)>kMaxDelta+4.*rmsTemp) continue;
if (IsOK(y)) fitter->AddPoint(x,y,1);
- i++;
+ i++;
}
} else if (type==4) { // ONLY IFC
if (entry->GetType()==2) {
x[0]=1;
x[1]=entry->GetZ();
- x[2]=entry->GetPhi();
+ x[2]=entry->GetPhi();
y = fTempArray->GetValue(timeSec,isensor);
if (TMath::Abs(y-medianTemp)>kMaxDelta+4.*rmsTemp) continue;
- if (IsOK(y)) fitter->AddPoint(x,y,1);
+ if (IsOK(y)) fitter->AddPoint(x,y,1);
i++;
}
}
- }
+ }
fitter->Eval();
//fitter->EvalRobust(0.9); // Evaluates fitter
-
- return fitter;
- // returns TLinearFitter object where Chi2, Fitparameters and residuals can
+ return fitter;
+
+ // returns TLinearFitter object where Chi2, Fitparameters and residuals can
// be extracted via usual memberfunctions
// example: fitter->GetParameters(param)
- // In case of type IFC or OFC, the parameters are the gradients in
+ // In case of type IFC or OFC, the parameters are the gradients in
// Z and Y direction (see fitformula)
- // Caution: Parameters are [K/cm] except Y at IFC,OFC ([K/radius])
+ // Caution: Parameters are [K/cm] except Y at IFC,OFC ([K/radius])
}
//_____________________________________________________________________________
TGraph2D *AliTPCTempMap::GetTempMapsViaSensors(Int_t type, Int_t side, UInt_t timeSec)
{
- //
- // Creates a TGraph2D object for the desired region of the TPC
- // (via choosen type and side of TPC temperature sensors) at a given
- // timeSec (in secounds) after start time
- // type: 0 ... ReadOutChambers (ROC)
- // 1 ... OuterContainmentVessel (OFC)
- // 2 ... InnerContainmentVessel (IFC) + ThermalScreener (TS)
- // 3 ... Within the TPC (DriftVolume) (TPC)
- // side: Can be choosen for type 0 and 3 (otherwise it will be ignored in
- // in order to get all temperature sensors of interest)
- // 0 ... A - side
- // 1 ... C - side
- //
+ /// Creates a TGraph2D object for the desired region of the TPC
+ /// (via choosen type and side of TPC temperature sensors) at a given
+ /// timeSec (in secounds) after start time
+ /// type: 0 ... ReadOutChambers (ROC)
+ /// 1 ... OuterContainmentVessel (OFC)
+ /// 2 ... InnerContainmentVessel (IFC) + ThermalScreener (TS)
+ /// 3 ... Within the TPC (DriftVolume) (TPC)
+ /// side: Can be choosen for type 0 and 3 (otherwise it will be ignored in
+ /// in order to get all temperature sensors of interest)
+ /// 0 ... A - side
+ /// 1 ... C - side
TGraph2D *graph2D = new TGraph2D();
Int_t i = 0;
-
+
Int_t nsensors = fTempArray->NumSensors();
for (Int_t isensor=0; isensor<nsensors; isensor++) { // loop over all sensors
AliTPCSensorTemp *entry = (AliTPCSensorTemp*)fTempArray->GetSensorNum(isensor);
i++;
}
}
- }
-
+ }
+
if (type==0 || type==3) {
graph2D->GetXaxis()->SetTitle("X[cm]");
graph2D->GetYaxis()->SetTitle("Y[cm]");
graph2D->GetXaxis()->SetLabelOffset(0.0);
graph2D->GetYaxis()->SetLabelOffset(0.005);
graph2D->GetZaxis()->SetLabelOffset(-0.04);
-
+
return graph2D; // returns TGgraph2D object
-
+
}
//_____________________________________________________________________________
TGraph *AliTPCTempMap::MakeGraphGradient(Int_t axis, Int_t side, Int_t nPoints)
-{
- //
- // Make graph from start time to end time of TempGradient in axis direction
- // axis: 0 ... horizontal Temperature Gradient (X)
- // 1 ... vertical Temperature Gradient (Y)
- // 2 ... longitudenal Temperature Gradient (Z) (side is ignored)
- // z gradient value based on OFC temperature sensors
- // Caution!: better z gradient values through difference between
- // param[0] A- and param[0] C-side !
- // side for X and Y gradient:
- // 0 ... Shaft Side (A)
- // 1 ... Muon Side (C)
- //
-
+{
+ /// Make graph from start time to end time of TempGradient in axis direction
+ /// axis: 0 ... horizontal Temperature Gradient (X)
+ /// 1 ... vertical Temperature Gradient (Y)
+ /// 2 ... longitudenal Temperature Gradient (Z) (side is ignored)
+ /// z gradient value based on OFC temperature sensors
+ /// Caution!: better z gradient values through difference between
+ /// param[0] A- and param[0] C-side !
+ /// side for X and Y gradient:
+ /// 0 ... Shaft Side (A)
+ /// 1 ... Muon Side (C)
+
TVectorD param(3);
TLinearFitter *fitter = new TLinearFitter(3);
UInt_t fStartTime = fTempArray->AliTPCSensorTempArray::GetStartTime();
UInt_t fEndTime = fTempArray->AliTPCSensorTempArray::GetEndTime();
-
+
UInt_t stepTime = (fEndTime-fStartTime)/nPoints;
Double_t *x = new Double_t[nPoints];
fitter = GetLinearFitter(3, side, ip*stepTime);
}
fitter->GetParameters(param);
- // multiplied by 500 since TempGradient is in [K/cm]
+ // multiplied by 500 since TempGradient is in [K/cm]
// (TPC diameter and length ~500cm)
if (axis==1) { // Y axis
y[ip] = param[2]*500;
TGraph *graph = new TGraph(nPoints,x,y);
- fitter->~TLinearFitter();
+ fitter->~TLinearFitter();
delete [] x;
delete [] y;
//_____________________________________________________________________________
Double_t AliTPCTempMap::GetTemperature(Double_t x, Double_t y, Double_t z, TTimeStamp &stamp)
{
- //
- // absolute time stamp used
- // see also Double_t AliTPCTempMap::GetTemperature(Double_t x, Double_t y, Double_t z, UInt_t timeSec) for details
- //
+ /// absolute time stamp used
+ /// see also Double_t AliTPCTempMap::GetTemperature(Double_t x, Double_t y, Double_t z, UInt_t timeSec) for details
Int_t timeSec = stamp.GetSec()-fTempArray->GetStartTime().GetSec();
return GetTemperature(x, y, z, timeSec);
//_____________________________________________________________________________
Double_t AliTPCTempMap::GetTemperature(Double_t x, Double_t y, Double_t z, UInt_t timeSec)
-{
- //
- // Returns estimated Temperature at given position (x,y,z[cm]) at given time
- // (timeSec) after starttime
- // Method: so far just a linear interpolation between Linar fits of
- // the TPC temperature sensors
- // FIXME: 'Educated Fit' through FiniteElement Simulation results!
- // FIXXME: Return 0? if x,y,z out of range
- //
-
+{
+ /// Returns estimated Temperature at given position (x,y,z[cm]) at given time
+ /// (timeSec) after starttime
+ /// Method: so far just a linear interpolation between Linar fits of
+ /// the TPC temperature sensors
+ /// FIXME: 'Educated Fit' through FiniteElement Simulation results!
+ /// FIXXME: Return 0? if x,y,z out of range
+
TVectorD paramA(3), paramC(3);
TLinearFitter *fitterA = 0;
TLinearFitter *fitterC = 0;
Bool_t AliTPCTempMap::IsOK(Float_t value){
- //
- // checks if value is within a certain range
- //
+ /// checks if value is within a certain range
+
const Float_t kMinT=15;
const Float_t kMaxT=25;
return (value>kMinT && value<kMaxT);
* See cxx source for full Copyright notice */
-///////////////////////////////////////////////////////////////////////////////
-// //
-// TPC calibration class for temperature maps and tendencies //
-// //
-///////////////////////////////////////////////////////////////////////////////
+/// \class AliTPCTempMap
+/// \brief TPC calibration class for temperature maps and tendencies
#include "TSystem.h"
class AliTPCTempMap : public TNamed {
public:
AliTPCTempMap(AliTPCSensorTempArray *SensorsDCS);
- AliTPCTempMap(const AliTPCTempMap &c);
+ AliTPCTempMap(const AliTPCTempMap &c);
virtual ~AliTPCTempMap();
AliTPCTempMap &operator=(const AliTPCTempMap &c);
virtual void Copy (TObject &c) const;
Double_t GetTemperature(Double_t x, Double_t y, Double_t z, TTimeStamp &stamp);
Bool_t IsOK(Float_t value);
protected:
-
- AliTPCSensorTempArray *fTempArray; // Array of Sensors (initialized in Constructor)
- TString fStringFEsimulation; // Placeholder for file of FiniteElement
- // Simulation under ideal conditions - not existing yet
+
+ AliTPCSensorTempArray *fTempArray; ///< Array of Sensors (initialized in Constructor)
+ TString fStringFEsimulation; ///< Placeholder for file of FiniteElement Simulation under ideal conditions - not existing yet
private:
AliTPCTempMap(const char *fname);
- ClassDef(AliTPCTempMap,2) //
+ /// \cond CLASSIMP
+ ClassDef(AliTPCTempMap,2) //
+ /// \endcond
};
* provided "as is" without express or implied warranty. *
**************************************************************************/
-//-------------------------------------------------------
-// Implementation of the TPC transformation class
-//
-// Origin: Marian Ivanov Marian.Ivanov@cern.ch
-// Magnus Mager
-//
-// Class for tranformation of the coordinate frame
-// Transformation
-// local coordinate frame (sector, padrow, pad, timebine) ==>
-// rotated global (tracking) cooridnate frame (sector, lx,ly,lz)
-//
-// Unisochronity - (substract time0 - pad by pad)
-// Drift velocity - Currently common drift velocity - functionality of AliTPCParam
-// ExB effect -
-//
-// Time of flight correction -
-// - Depends on the vertex position
-// - by default
-//
-// Usage:
-// AliTPCclusterer::AddCluster
-// AliTPCtracker::Transform
-//
-//-------------------------------------------------------
-
-/* To test it:
- cdb=AliCDBManager::Instance()
- cdb->SetDefaultStorage("local:///u/mmager/mycalib1")
- c=AliTPCcalibDB::Instance()
- c->SetRun(0)
- Double_t x[]={1.0,2.0,3.0}
- Int_t i[]={4}
- AliTPCTransform trafo
- trafo.Transform(x,i,0,1)
- */
-
-/* $Id$ */
+/// \class AliTPCTransform
+/// \brief Implementation of the TPC transformation class
+///
+/// Class for tranformation of the coordinate frame
+/// Transformation
+/// local coordinate frame (sector, padrow, pad, timebine) ==>
+/// rotated global (tracking) cooridnate frame (sector, lx,ly,lz)
+///
+/// Unisochronity - (substract time0 - pad by pad)
+/// Drift velocity - Currently common drift velocity - functionality of AliTPCParam
+/// ExB effect -
+///
+/// Time of flight correction -
+/// - Depends on the vertex position
+/// - by default
+///
+/// Usage:
+///
+/// ~~~{.cxx}
+/// AliTPCclusterer::AddCluster
+/// AliTPCtracker::Transform
+/// ~~~
+///
+/// To test it:
+///
+/// ~~~{.cxx}
+/// cdb=AliCDBManager::Instance()
+/// cdb->SetDefaultStorage("local:///u/mmager/mycalib1")
+/// c=AliTPCcalibDB::Instance()
+/// c->SetRun(0)
+/// Double_t x[]={1.0,2.0,3.0}
+/// Int_t i[]={4}
+/// AliTPCTransform trafo
+/// trafo.Transform(x,i,0,1)
+/// ~~~
+///
+/// \author Magnus Mager, Marian Ivanov
#include "AliTPCROC.h"
#include "AliTPCCalPad.h"
#include "AliTracker.h"
#include <AliCTPTimeParams.h>
+/// \cond CLASSIMP
ClassImp(AliTPCTransform)
+/// \endcond
AliTPCTransform::AliTPCTransform():
AliTransform(),
fCurrentRecoParam(0), //! current reconstruction parameters
fCurrentRun(0), //! current run
- fCurrentTimeStamp(0) //! current time stamp
+ fCurrentTimeStamp(0) //! current time stamp
{
//
// Speed it up a bit!
AliTransform(transform),
fCurrentRecoParam(transform.fCurrentRecoParam), //! current reconstruction parameters
fCurrentRun(transform.fCurrentRun), //! current run
- fCurrentTimeStamp(transform.fCurrentTimeStamp) //! current time stamp
+ fCurrentTimeStamp(transform.fCurrentTimeStamp) //! current time stamp
{
- //
- // Speed it up a bit!
- //
+ /// Speed it up a bit!
+
for (Int_t i=0;i<18;++i) {
Double_t alpha=TMath::DegToRad()*(10.+20.*(i%18));
fSins[i]=TMath::Sin(alpha);
}
AliTPCTransform::~AliTPCTransform() {
- //
- // Destructor
- //
+ /// Destructor
+
}
void AliTPCTransform::SetPrimVertex(Double_t *vtx){
- //
- //
- //
+ ///
+
fPrimVtx[0]=vtx[0];
fPrimVtx[1]=vtx[1];
fPrimVtx[2]=vtx[2];
void AliTPCTransform::Transform(Double_t *x,Int_t *i,UInt_t /*time*/,
Int_t /*coordinateType*/) {
- // input: x[0] - pad row
- // x[1] - pad
- // x[2] - time in us
- // i[0] - sector
- // output: x[0] - x (all in the rotated global coordinate frame)
- // x[1] - y
- // x[2] - z
- //
- // primvtx - position of the primary vertex
- // used for the TOF correction
- // TOF of particle calculated assuming the speed-of-light and
- // line approximation
- //
+ /// input: x[0] - pad row
+ /// x[1] - pad
+ /// x[2] - time in us
+ /// i[0] - sector
+ /// output: x[0] - x (all in the rotated global coordinate frame)
+ /// x[1] - y
+ /// x[2] - z
+ ///
+ /// primvtx - position of the primary vertex
+ /// used for the TOF correction
+ /// TOF of particle calculated assuming the speed-of-light and
+ /// line approximation
+
if (!fCurrentRecoParam) {
return;
}
Int_t row=TMath::Nint(x[0]);
Int_t pad=TMath::Nint(x[1]);
Int_t sector=i[0];
- AliTPCcalibDB* calib=AliTPCcalibDB::Instance();
+ AliTPCcalibDB* calib=AliTPCcalibDB::Instance();
//
- AliTPCCalPad * time0TPC = calib->GetPadTime0();
- AliTPCCalPad * distortionMapY = calib->GetDistortionMap(0);
- AliTPCCalPad * distortionMapZ = calib->GetDistortionMap(1);
- AliTPCCalPad * distortionMapR = calib->GetDistortionMap(2);
- AliTPCParam * param = calib->GetParameters();
+ AliTPCCalPad * time0TPC = calib->GetPadTime0();
+ AliTPCCalPad * distortionMapY = calib->GetDistortionMap(0);
+ AliTPCCalPad * distortionMapZ = calib->GetDistortionMap(1);
+ AliTPCCalPad * distortionMapR = calib->GetDistortionMap(2);
+ AliTPCParam * param = calib->GetParameters();
AliTPCCorrection * correction = calib->GetTPCComposedCorrection(); // first user defined correction // if does not exist try to get it from calibDB array
if (!correction) correction = calib->GetTPCComposedCorrection(AliTracker::GetBz());
if (!time0TPC){
AliFatal("Time unisochronity missing");
return ; // make coverity happy
}
- AliTPCCorrection * correctionDelta = calib->GetTPCComposedCorrectionDelta();
+ AliTPCCorrection * correctionDelta = calib->GetTPCComposedCorrectionDelta();
if (!param){
AliFatal("Parameters missing");
Double_t xx[3];
// Apply Time0 correction - Pad by pad fluctuation
- //
+ //
if (!calib->HasAlignmentOCDB()) x[2]-=time0TPC->GetCalROC(sector)->GetValue(row,pad);
//
// Tranform from pad - time coordinate system to the rotated global (tracking) system
// Alignment
//TODO: calib->GetParameters()->GetClusterMatrix(sector)->LocalToMaster(x,xx);
RotatedGlobal2Global(sector,x);
-
+
//
- // old ExB correction
+ // old ExB correction
//
if(fCurrentRecoParam->GetUseExBCorrection()) {
xx[1]=distPointDelta[1];
xx[2]=distPointDelta[2];
}
- }
+ }
//
// Time of flight correction
- //
+ //
if (fCurrentRecoParam->GetUseTOFCorrection()){
- const Int_t kNIS=param->GetNInnerSector(), kNOS=param->GetNOuterSector();
+ const Int_t kNIS=param->GetNInnerSector(), kNOS=param->GetNOuterSector();
Float_t sign=1;
if (sector < kNIS) {
sign = (sector < kNIS/2) ? 1 : -1;
dist = TMath::Sqrt(dist);
// drift length correction because of TOF
// the drift velocity is in cm/s therefore multiplication by 0.01
- deltaDr = (dist*(0.01*param->GetDriftV()))/TMath::C();
+ deltaDr = (dist*(0.01*param->GetDriftV()))/TMath::C();
xx[2]+=sign*deltaDr;
}
//
Global2RotatedGlobal(sector,xx);
//
- // Apply non linear distortion correction
+ // Apply non linear distortion correction
//
if (distortionMapY ){
// wt - to get it form the OCDB
Double_t wt = -10.0 * (bzField*10) * vdrift / ezField ;
Double_t c0=1./(1.+wt*wt);
Double_t c1=wt/c0;
-
+
//can be switch on for each dimension separatelly
if (fCurrentRecoParam->GetUseFieldCorrection()&0x2)
if (distortionMapY){
xx[1]-= c0*distortionMapY->GetCalROC(sector)->GetValue(row,pad);
xx[0]-= c1*distortionMapY->GetCalROC(sector)->GetValue(row,pad);
}
- if (fCurrentRecoParam->GetUseFieldCorrection()&0x4)
+ if (fCurrentRecoParam->GetUseFieldCorrection()&0x4)
if (distortionMapZ)
xx[2]-=distortionMapZ->GetCalROC(sector)->GetValue(row,pad);
- if (fCurrentRecoParam->GetUseFieldCorrection()&0x8)
+ if (fCurrentRecoParam->GetUseFieldCorrection()&0x8)
if (distortionMapR){
xx[0]-= c0*distortionMapR->GetCalROC(sector)->GetValue(row,pad);
xx[1]-=-c1*distortionMapR->GetCalROC(sector)->GetValue(row,pad)*wt;
}
-
+
}
//
}
void AliTPCTransform::Local2RotatedGlobal(Int_t sector, Double_t *x) const {
- //
- //
- // Tranform coordinate from
- // row, pad, time to x,y,z
- //
- // Drift Velocity
- // Current implementation - common drift velocity - for full chamber
- // TODO: use a map or parametrisation!
- //
- //
- //
+ /// Tranform coordinate from
+ /// row, pad, time to x,y,z
+ ///
+ /// Drift Velocity
+ /// Current implementation - common drift velocity - for full chamber
+ /// TODO: use a map or parametrisation!
+
if (!fCurrentRecoParam) return;
const Int_t kMax =60; // cache for 60 seconds
static Int_t lastStamp=-1; //cached values
static Double_t lastCorr = 1;
//
AliTPCcalibDB* calib=AliTPCcalibDB::Instance();
- AliTPCParam * param = calib->GetParameters();
+ AliTPCParam * param = calib->GetParameters();
AliTPCCalibVdrift *driftCalib = AliTPCcalibDB::Instance()->GetVdrift(fCurrentRun);
Double_t driftCorr = 1.;
if (driftCalib){
driftCorr = 1.+(driftCalib->GetPTRelative(fCurrentTimeStamp,0)+ driftCalib->GetPTRelative(fCurrentTimeStamp,1))*0.5;
lastCorr=driftCorr;
lastStamp=fCurrentTimeStamp;
-
+
}
}
//
lastStampT=fCurrentTimeStamp;
if(fCurrentRecoParam->GetUseDriftCorrectionTime()>0) {
vdcorrectionTime = (1+AliTPCcalibDB::Instance()->
- GetVDriftCorrectionTime(fCurrentTimeStamp,
+ GetVDriftCorrectionTime(fCurrentTimeStamp,
fCurrentRun,
sector%36>=18,
- fCurrentRecoParam->GetUseDriftCorrectionTime()));
+ fCurrentRecoParam->GetUseDriftCorrectionTime()));
time0corrTime= AliTPCcalibDB::Instance()->
- GetTime0CorrectionTime(fCurrentTimeStamp,
+ GetTime0CorrectionTime(fCurrentTimeStamp,
fCurrentRun,
sector%36>=18,
- fCurrentRecoParam->GetUseDriftCorrectionTime());
+ fCurrentRecoParam->GetUseDriftCorrectionTime());
//
deltaZcorrTime= AliTPCcalibDB::Instance()->
- GetVDriftCorrectionDeltaZ(fCurrentTimeStamp,
+ GetVDriftCorrectionDeltaZ(fCurrentTimeStamp,
fCurrentRun,
sector%36>=18,
- 0);
-
+ 0);
+
}
//
if(fCurrentRecoParam->GetUseDriftCorrectionGY()>0) {
-
+
Double_t corrGy= AliTPCcalibDB::Instance()->
- GetVDriftCorrectionGy(fCurrentTimeStamp,
+ GetVDriftCorrectionGy(fCurrentTimeStamp,
AliTPCcalibDB::Instance()->GetRun(),
sector%36>=18,
fCurrentRecoParam->GetUseDriftCorrectionGY());
if (sector%36>17){
x[1]*=-1;
}
-
+
//
-
+
//
// Z coordinate
//
}
void AliTPCTransform::RotatedGlobal2Global(Int_t sector,Double_t *x) const {
- //
- // transform possition rotated global to the global
- //
+ /// transform possition rotated global to the global
+
Double_t cos,sin;
GetCosAndSin(sector,cos,sin);
Double_t tmp=x[0];
}
void AliTPCTransform::Global2RotatedGlobal(Int_t sector,Double_t *x) const {
- //
- // tranform possition Global2RotatedGlobal
- //
+ /// tranform possition Global2RotatedGlobal
+
Double_t cos,sin;
GetCosAndSin(sector,cos,sin);
Double_t tmp=x[0];
void AliTPCTransform::ApplyTransformations(Double_t */*xyz*/, Int_t /*volID*/){
- //
- // Modify global position
- // xyz - global xyz position
- // volID - volID of detector (sector number)
- //
- //
-
+ /// Modify global position
+ /// xyz - global xyz position
+ /// volID - volID of detector (sector number)
+
}
/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
* See cxx source for full Copyright notice */
-/* $Id$ */
-//
-// Class for tranformation of the coordinate frame
-// Transformation
-// local coordinate frame (sector, padrow, pad, timebine) ==>
-// rotated global (tracking) cooridnate frame (sector, lx,ly,lz)
-//
+/// \class AliTPCTransform
+/// \brief Class for tranformation of the coordinate frame
+///
+/// Transformation
+/// local coordinate frame (sector, padrow, pad, timebine) ==>
+/// rotated global (tracking) cooridnate frame (sector, lx,ly,lz)
class AliTPCRecoParam;
#include "AliTransform.h"
public:
AliTPCTransform();
AliTPCTransform(const AliTPCTransform& transform);
-
+
virtual ~AliTPCTransform();
virtual void Transform(Double_t *x,Int_t *i,UInt_t time,
Int_t coordinateType);
void ApplyTransformations(Double_t *xyz, Int_t volID);
private:
AliTPCTransform& operator=(const AliTPCTransform&); // not implemented
- Double_t fCoss[18]; // cache the transformation
- Double_t fSins[18]; // cache the transformation
- Double_t fPrimVtx[3];// position of the primary vertex - needed for TOF correction
- AliTPCRecoParam * fCurrentRecoParam; //! current reconstruction parameters
- Int_t fCurrentRun; //! current run
- UInt_t fCurrentTimeStamp; //! current time stamp
+ Double_t fCoss[18]; ///< cache the transformation
+ Double_t fSins[18]; ///< cache the transformation
+ Double_t fPrimVtx[3];///< position of the primary vertex - needed for TOF correction
+ AliTPCRecoParam * fCurrentRecoParam; //!< current reconstruction parameters
+ Int_t fCurrentRun; //!< current run
+ UInt_t fCurrentTimeStamp; //!< current time stamp
+ /// \cond CLASSIMP
ClassDef(AliTPCTransform,1)
+ /// \endcond
};
#endif
* provided "as is" without express or implied warranty. *
**************************************************************************/
-
-///////////////////////////////////////////////////////////////////////////////
-// //
-// Class providing the calibration parameters by accessing the CDB //
-// //
-// Request an instance with AliTPCcalibDB::Instance() //
-// If a new event is processed set the event number with SetRun //
-// Then request the calibration data ////
-//
-//
-// Calibration data:
-// 0.) Altro mapping
-// Simulation - not yet
-// Reconstruction - AliTPCclusterer::Digits2Clusters(AliRawReader* rawReader)
-//
-// 1.) pad by pad calibration - AliTPCCalPad
-//
-// a.) fPadGainFactor
-// Simulation: AliTPCDigitizer::ExecFast - Multiply by gain
-// Reconstruction : AliTPCclusterer::Digits2Clusters - Divide by gain
-//
-// b.) fPadNoise -
-// Simulation: AliTPCDigitizer::ExecFast
-// Reconstruction: AliTPCclusterer::FindClusters(AliTPCCalROC * noiseROC)
-// Noise depending cut on clusters charge (n sigma)
-// c.) fPedestal:
-// Simulation: Not used yet - To be impleneted - Rounding to the nearest integer
-// Reconstruction: Used in AliTPCclusterer::Digits2Clusters(AliRawReader* rawReader)
-// if data taken without zero suppression
-// Currently switch in fRecoParam->GetCalcPedestal();
-//
-// d.) fPadTime0
-// Simulation: applied in the AliTPC::MakeSector - adding offset
-// Reconstruction: AliTPCTransform::Transform() - remove offset
-// AliTPCTransform::Transform() - to be called
-// in AliTPCtracker::Transform()
-//
-//
-// 2.) Space points transformation:
-//
-// a.) General coordinate tranformation - AliTPCtransform (see $ALICE_ROOT/TPC/AliTPCtransform.cxx)
-// Created on fly - use the other calibration components
-// Unisochronity - (substract time0 - pad by pad)
-// Drift velocity - Currently common drift velocity - functionality of AliTPCParam
-// ExB effect
-// Simulation - Not used directly (the effects are applied one by one (see AliTPC::MakeSector)
-// Reconstruction -
-// AliTPCclusterer::AddCluster
-// AliTPCtracker::Transform
-// b.) ExB effect calibration -
-// classes (base class AliTPCExB, implementation- AliTPCExBExact.h AliTPCExBFirst.h)
-// a.a) Simulation: applied in the AliTPC::MakeSector -
-// calib->GetExB()->CorrectInverse(dxyz0,dxyz1);
-// a.b) Reconstruction -
-//
-// in AliTPCtransform::Correct() - called calib->GetExB()->Correct(dxyz0,dxyz1)
-//
-// 3.) cluster error, shape and Q parameterization
-//
-//
-//
-///////////////////////////////////////////////////////////////////////////////
+/// \class AliTPCcalibDB
+/// \brief Class providing the calibration parameters by accessing the CDB
+///
+/// Request an instance with AliTPCcalibDB::Instance()
+/// If a new event is processed set the event number with SetRun
+/// Then request the calibration data
+///
+/// Calibration data:
+/// 0.) Altro mapping
+/// Simulation - not yet
+/// Reconstruction - AliTPCclusterer::Digits2Clusters(AliRawReader* rawReader)
+///
+/// 1.) pad by pad calibration - AliTPCCalPad
+///
+/// a.) fPadGainFactor
+/// Simulation: AliTPCDigitizer::ExecFast - Multiply by gain
+/// Reconstruction : AliTPCclusterer::Digits2Clusters - Divide by gain
+///
+/// b.) fPadNoise -
+/// Simulation: AliTPCDigitizer::ExecFast
+/// Reconstruction: AliTPCclusterer::FindClusters(AliTPCCalROC * noiseROC)
+/// Noise depending cut on clusters charge (n sigma)
+/// c.) fPedestal:
+/// Simulation: Not used yet - To be impleneted - Rounding to the nearest integer
+/// Reconstruction: Used in AliTPCclusterer::Digits2Clusters(AliRawReader* rawReader)
+/// if data taken without zero suppression
+/// Currently switch in fRecoParam->GetCalcPedestal();
+///
+/// d.) fPadTime0
+/// Simulation: applied in the AliTPC::MakeSector - adding offset
+/// Reconstruction: AliTPCTransform::Transform() - remove offset
+/// AliTPCTransform::Transform() - to be called
+/// in AliTPCtracker::Transform()
+///
+/// 2.) Space points transformation:
+///
+/// a.) General coordinate tranformation - AliTPCtransform (see $ALICE_ROOT/TPC/AliTPCtransform.cxx)
+/// Created on fly - use the other calibration components
+/// Unisochronity - (substract time0 - pad by pad)
+/// Drift velocity - Currently common drift velocity - functionality of AliTPCParam
+/// ExB effect
+/// Simulation - Not used directly (the effects are applied one by one (see AliTPC::MakeSector)
+/// Reconstruction -
+/// AliTPCclusterer::AddCluster
+/// AliTPCtracker::Transform
+/// b.) ExB effect calibration -
+/// classes (base class AliTPCExB, implementation- AliTPCExBExact.h AliTPCExBFirst.h)
+/// a.a) Simulation: applied in the AliTPC::MakeSector -
+/// calib->GetExB()->CorrectInverse(dxyz0,dxyz1);
+/// a.b) Reconstruction -
+///
+/// in AliTPCtransform::Correct() - called calib->GetExB()->Correct(dxyz0,dxyz1)
+///
+/// 3.) cluster error, shape and Q parameterization
#include <iostream>
#include <fstream>
#include "AliTriggerScalers.h"
#include "AliTriggerScalersRecord.h"
+/// \cond CLASSIMP
ClassImp(AliTPCcalibDB)
+/// \endcond
AliTPCcalibDB* AliTPCcalibDB::fgInstance = 0;
Bool_t AliTPCcalibDB::fgTerminated = kFALSE;
-TObjArray AliTPCcalibDB::fgExBArray; // array of ExB corrections
+TObjArray AliTPCcalibDB::fgExBArray; ///< array of ExB corrections
//_ singleton implementation __________________________________________________
AliTPCcalibDB* AliTPCcalibDB::Instance()
{
- //
- // Singleton implementation
- // Returns an instance of this class, it is created if necessary
- //
-
+ /// Singleton implementation
+ /// Returns an instance of this class, it is created if necessary
+
if (fgTerminated != kFALSE)
return 0;
void AliTPCcalibDB::Terminate()
{
- //
- // Singleton implementation
- // Deletes the instance of this class and sets the terminated flag, instances cannot be requested anymore
- // This function can be called several times.
- //
-
+ /// Singleton implementation
+ /// Deletes the instance of this class and sets the terminated flag, instances cannot be requested anymore
+ /// This function can be called several times.
+
fgTerminated = kTRUE;
if (fgInstance != 0)
fCTPTimeParams(0),
fMode(-1)
{
- //
- // constructor
- //
- //
+ /// constructor
+
fgInstance=this;
for (Int_t i=0;i<72;++i){
fChamberHVStatus[i]=kTRUE;
fCTPTimeParams(0),
fMode(-1)
{
- //
- // Copy constructor invalid -- singleton implementation
- //
+ /// Copy constructor invalid -- singleton implementation
+
Error("copy constructor","invalid -- singleton implementation");
for (Int_t i=0;i<72;++i){
fChamberHVStatus[i]=kTRUE;
AliTPCcalibDB& AliTPCcalibDB::operator= (const AliTPCcalibDB& )
{
-//
-// Singleton implementation - no assignment operator
-//
+/// Singleton implementation - no assignment operator
+
Error("operator =", "assignment operator not implemented");
return *this;
}
//_____________________________________________________________________________
AliTPCcalibDB::~AliTPCcalibDB()
{
- //
- // destructor
- //
- //delete fIonTailArray;
+ /// destructor
+ ///
+ /// delete fIonTailArray;
+
delete fActiveChannelMap;
delete fGrRunState;
fgInstance = 0;
}
AliTPCCalPad* AliTPCcalibDB::GetDistortionMap(Int_t i) const {
- //
- // get distortion map - due E field distortions
- //
+ /// get distortion map - due E field distortions
+
return (fDistortionMap) ? (AliTPCCalPad*)fDistortionMap->At(i):0;
}
//_____________________________________________________________________________
AliCDBEntry* AliTPCcalibDB::GetCDBEntry(const char* cdbPath)
{
- //
- // Retrieves an entry with path <cdbPath> from the CDB.
- //
+ /// Retrieves an entry with path <cdbPath> from the CDB.
+
char chinfo[1000];
AliCDBEntry* entry = AliCDBManager::Instance()->Get(cdbPath, fRun);
//_____________________________________________________________________________
void AliTPCcalibDB::SetRun(Long64_t run)
{
- //
- // Sets current run number. Calibration data is read from the corresponding file.
- //
+ /// Sets current run number. Calibration data is read from the corresponding file.
+
if (fRun == run)
return;
fRun = run;
void AliTPCcalibDB::Update(){
- //
- // cache the OCDB entries for simulation, reconstruction, calibration
- //
- //
+ /// cache the OCDB entries for simulation, reconstruction, calibration
+
AliCDBEntry * entry=0;
Bool_t cdbCache = AliCDBManager::Instance()->GetCacheFlag(); // save cache status
AliCDBManager::Instance()->SetCacheFlag(kTRUE); // activate CDB cache
}
void AliTPCcalibDB::UpdateNonRec(){
- //
- // Update/Load the parameters which are important for QA studies
- // and not used yet for the reconstruction
- //
- //RAW calibration data
+ /// Update/Load the parameters which are important for QA studies
+ /// and not used yet for the reconstruction
+ ///
+ /// RAW calibration data
+
AliCDBEntry * entry=0;
entry = GetCDBEntry("TPC/Calib/Raw");
if (entry){
Bool_t AliTPCcalibDB::GetTailcancelationGraphs(Int_t sector, TGraphErrors ** graphRes, Float_t * indexAmpGraphs){
-//
-// Read OCDB entry object of Iontail (TObjArray of TGraphErrors of TRFs)
-// Naming of the TRF objects is: "gr_<chamber_type>_<voltage>_<laser_track_angle>_<distance_to_COG>" --> "gr_iroc_1240_1_1"
-//
-
+/// Read OCDB entry object of Iontail (TObjArray of TGraphErrors of TRFs)
+/// Naming of the TRF objects is: "gr_<chamber_type>_<voltage>_<laser_track_angle>_<distance_to_COG>" --> "gr_iroc_1240_1_1"
+
//Int_t run = fTransform->GetCurrentRunNumber();
//SetRun(run);
//Float_t rocVoltage = GetChamberHighVoltage(run,sector, -1); // Get the voltage from OCDB with a getter (old function)
void AliTPCcalibDB::CreateObjectList(const Char_t *filename, TObjArray *calibObjects)
{
-//
-// Create calibration objects and read contents from OCDB
-//
+/// Create calibration objects and read contents from OCDB
+
if ( calibObjects == 0x0 ) return;
ifstream in;
in.open(filename);
}
Int_t AliTPCcalibDB::InitDeadMap() {
- // Initialize DeadChannel Map
- // Source of information:
- // - HV (see UpdateChamberHighVoltageData())
- // - Altro disabled channels. Noisy channels.
- // - DDL list
+ /// Initialize DeadChannel Map
+ /// Source of information:
+ /// - HV (see UpdateChamberHighVoltageData())
+ /// - Altro disabled channels. Noisy channels.
+ /// - DDL list
// check necessary information
const Int_t run=GetRun();
}
void AliTPCcalibDB::MakeTree(const char * fileName, TObjArray * array, const char * mapFileName, AliTPCCalPad* outlierPad, Float_t ltmFraction) {
- //
- // Write a tree with all available information
- // if mapFileName is specified, the Map information are also written to the tree
- // pads specified in outlierPad are not used for calculating statistics
- // - the same function as AliTPCCalPad::MakeTree -
- //
+ /// Write a tree with all available information
+ /// if mapFileName is specified, the Map information are also written to the tree
+ /// pads specified in outlierPad are not used for calculating statistics
+ /// - the same function as AliTPCCalPad::MakeTree -
+
AliTPCROC* tpcROCinstance = AliTPCROC::Instance();
TObjArray* mapIROCs = 0;
Int_t AliTPCcalibDB::GetRCUTriggerConfig() const
{
- //
- // return the RCU trigger configuration register
- //
+ /// return the RCU trigger configuration register
+
TMap *map=GetRCUconfig();
if (!map) return -1;
TVectorF *v=(TVectorF*)map->GetValue("TRGCONF_TRG_MODE");
Bool_t AliTPCcalibDB::IsTrgL0()
{
- //
- // return if the FEE readout was triggered on L0
- //
+ /// return if the FEE readout was triggered on L0
+
if (fMode<0) return kFALSE;
return (fMode==1);
}
Bool_t AliTPCcalibDB::IsTrgL1()
{
- //
- // return if the FEE readout was triggered on L1
- //
+ /// return if the FEE readout was triggered on L1
+
if (fMode<0) return kFALSE;
return (fMode==0);
}
void AliTPCcalibDB::RegisterExB(Int_t index, Float_t bz, Bool_t bdelete){
- //
- // Register static ExB correction map
- // index - registration index - used for visualization
- // bz - bz field in kGaus
+ /// Register static ExB correction map
+ /// index - registration index - used for visualization
+ /// bz - bz field in kGaus
// Float_t factor = bz/(-5.); // default b filed in Cheb with minus sign
Float_t factor = bz/(5.); // default b filed in Cheb with minus sign
AliTPCExB* AliTPCcalibDB::GetExB(Float_t bz, Bool_t deleteB) {
- //
- // bz filed in KGaus not in tesla
- // Get ExB correction map
- // if doesn't exist - create it
- //
+ /// bz filed in KGaus not in tesla
+ /// Get ExB correction map
+ /// if doesn't exist - create it
+
Int_t index = TMath::Nint(5+bz);
if (index>fgExBArray.GetEntries()) fgExBArray.Expand((index+1)*2+11);
if (!fgExBArray.At(index)) AliTPCcalibDB::RegisterExB(index,bz,deleteB);
void AliTPCcalibDB::SetExBField(Float_t bz){
- //
- // Set magnetic filed for ExB correction
- //
+ /// Set magnetic filed for ExB correction
+
fExB = GetExB(bz,kFALSE);
}
void AliTPCcalibDB::SetExBField(const AliMagF* bmap){
- //
- // Set magnetic field for ExB correction
- //
+ /// Set magnetic field for ExB correction
+
AliTPCExBFirst *exb = new AliTPCExBFirst(bmap,0.88*2.6400e+04,50,50,50);
AliTPCExB::SetInstance(exb);
fExB=exb;
void AliTPCcalibDB::UpdateRunInformations( Int_t run, Bool_t force){
- //
- // - > Don't use it for reconstruction - Only for Calibration studies
- //
+ /// - > Don't use it for reconstruction - Only for Calibration studies
+
if (run<=0) return;
TObjString runstr(Form("%i",run));
fRun=run;
Float_t AliTPCcalibDB::GetGain(Int_t sector, Int_t row, Int_t pad){
- //
- // Get Gain factor for given pad
- //
+ /// Get Gain factor for given pad
+
AliTPCCalPad *calPad = Instance()->fDedxGainFactor;;
if (!calPad) return 0;
return calPad->GetCalROC(sector)->GetValue(row,pad);
}
AliSplineFit* AliTPCcalibDB::GetVdriftSplineFit(const char* name, Int_t run){
- //
- // GetDrift velocity spline fit
- //
+ /// GetDrift velocity spline fit
+
TObjArray *arr=GetTimeVdriftSplineRun(run);
if (!arr) return 0;
return dynamic_cast<AliSplineFit*>(arr->FindObject(name));
}
AliSplineFit* AliTPCcalibDB::CreateVdriftSplineFit(const char* graphName, Int_t run){
- //
- // create spline fit from the drift time graph in TimeDrift
- //
+ /// create spline fit from the drift time graph in TimeDrift
+
TObjArray *arr=GetTimeVdriftSplineRun(run);
if (!arr) return 0;
TGraph *graph=dynamic_cast<TGraph*>(arr->FindObject(graphName));
}
AliGRPObject *AliTPCcalibDB::GetGRP(Int_t run){
- //
- // Get GRP object for given run
- //
+ /// Get GRP object for given run
+
AliGRPObject * grpRun = dynamic_cast<AliGRPObject *>((Instance()->fGRPArray).GetValue(Form("%i",run)));
if (!grpRun) {
Instance()->UpdateRunInformations(run);
}
TMap * AliTPCcalibDB::GetGRPMap(Int_t run){
- //
- // Get GRP map for given run
- //
+ /// Get GRP map for given run
+
TMap * grpRun = dynamic_cast<TMap *>((Instance()->fGRPMaps).GetValue(Form("%i",run)));
if (!grpRun) {
Instance()->UpdateRunInformations(run);
AliDCSSensor * AliTPCcalibDB::GetPressureSensor(Int_t run, Int_t type){
- //
- // Get Pressure sensor
- // run = run number
- // type = 0 - Cavern pressure
- // 1 - Suface pressure
- // First try to get if trom map - if existing (Old format of data storing)
- //
+ /// Get Pressure sensor
+ /// run = run number
+ /// type = 0 - Cavern pressure
+ /// 1 - Suface pressure
+ /// First try to get if trom map - if existing (Old format of data storing)
TMap *map = GetGRPMap(run);
}
AliTPCSensorTempArray * AliTPCcalibDB::GetTemperatureSensor(Int_t run){
- //
- // Get temperature sensor array
- //
+ /// Get temperature sensor array
+
AliTPCSensorTempArray * tempArray = (AliTPCSensorTempArray *)fTemperatureArray.GetValue(Form("%i",run));
if (!tempArray) {
UpdateRunInformations(run);
TObjArray * AliTPCcalibDB::GetTimeGainSplinesRun(Int_t run){
- //
- // Get temperature sensor array
- //
+ /// Get temperature sensor array
+
TObjArray * gainSplines = (TObjArray *)fTimeGainSplinesArray.GetValue(Form("%i",run));
if (!gainSplines) {
UpdateRunInformations(run);
}
TObjArray * AliTPCcalibDB::GetTimeVdriftSplineRun(Int_t run){
- //
- // Get drift spline array
- //
+ /// Get drift spline array
+
TObjArray * driftSplines = (TObjArray *)fDriftCorrectionArray.GetValue(Form("%i",run));
if (!driftSplines) {
UpdateRunInformations(run);
}
AliDCSSensorArray * AliTPCcalibDB::GetVoltageSensors(Int_t run){
- //
- // Get temperature sensor array
- //
+ /// Get temperature sensor array
+
AliDCSSensorArray * voltageArray = (AliDCSSensorArray *)fVoltageArray.GetValue(Form("%i",run));
if (!voltageArray) {
UpdateRunInformations(run);
}
AliDCSSensorArray * AliTPCcalibDB::GetGoofieSensors(Int_t run){
- //
- // Get temperature sensor array
- //
+ /// Get temperature sensor array
+
AliDCSSensorArray * goofieArray = (AliDCSSensorArray *)fGoofieArray.GetValue(Form("%i",run));
if (!goofieArray) {
UpdateRunInformations(run);
AliTPCCalibVdrift * AliTPCcalibDB::GetVdrift(Int_t run){
- //
- // Get the interface to the the vdrift
- //
+ /// Get the interface to the the vdrift
+
AliTPCCalibVdrift * vdrift = (AliTPCCalibVdrift*)fVdriftArray.GetValue(Form("%i",run));
if (!vdrift) {
UpdateRunInformations(run);
Float_t AliTPCcalibDB::GetCEdriftTime(Int_t run, Int_t sector, Double_t timeStamp, Int_t *entries)
{
- //
- // GetCE drift time information for 'sector'
- // sector 72 is the mean drift time of the A-Side
- // sector 73 is the mean drift time of the C-Side
- // it timestamp==-1 return mean value
- //
+ /// GetCE drift time information for 'sector'
+ /// sector 72 is the mean drift time of the A-Side
+ /// sector 73 is the mean drift time of the C-Side
+ /// it timestamp==-1 return mean value
+
AliTPCcalibDB::Instance()->SetRun(run);
TGraph *gr=AliTPCcalibDB::Instance()->GetCErocTgraph(sector);
if (!gr||sector<0||sector>73) {
Float_t AliTPCcalibDB::GetCEchargeTime(Int_t run, Int_t sector, Double_t timeStamp, Int_t *entries)
{
- //
- // GetCE mean charge for 'sector'
- // it timestamp==-1 return mean value
- //
+ /// GetCE mean charge for 'sector'
+ /// it timestamp==-1 return mean value
+
AliTPCcalibDB::Instance()->SetRun(run);
TGraph *gr=AliTPCcalibDB::Instance()->GetCErocQgraph(sector);
if (!gr||sector<0||sector>71) {
Float_t AliTPCcalibDB::GetDCSSensorValue(AliDCSSensorArray *arr, Int_t timeStamp, const char * sensorName, Int_t sigDigits)
{
- //
- // Get Value for a DCS sensor 'sensorName', run 'run' at time 'timeStamp'
- //
+ /// Get Value for a DCS sensor 'sensorName', run 'run' at time 'timeStamp'
+
Float_t val=0;
const TString sensorNameString(sensorName);
AliDCSSensor *sensor = arr->GetSensor(sensorNameString);
Float_t AliTPCcalibDB::GetDCSSensorMeanValue(AliDCSSensorArray *arr, const char * sensorName, Int_t sigDigits)
{
- //
- // Get mean Value for a DCS sensor 'sensorName' during run 'run'
- //
+ /// Get mean Value for a DCS sensor 'sensorName' during run 'run'
+
Float_t val=0;
const TString sensorNameString(sensorName);
AliDCSSensor *sensor = arr->GetSensor(sensorNameString);
void AliTPCcalibDB::UpdateChamberHighVoltageData()
{
- //
- // set chamber high voltage data
- // 1. Robust median (sampling the hv graphs over time)
- // 2. Current nominal voltages (nominal voltage corrected for common HV offset)
- // 3. Fraction of good HV values over time (deviation from robust median)
- // 4. HV status, based on the above
- //
+ /// set chamber high voltage data
+ /// 1. Robust median (sampling the hv graphs over time)
+ /// 2. Current nominal voltages (nominal voltage corrected for common HV offset)
+ /// 3. Fraction of good HV values over time (deviation from robust median)
+ /// 4. HV status, based on the above
// start and end time of the run
const Int_t run=GetRun();
}
Float_t AliTPCcalibDB::GetChamberHighVoltage(Int_t run, Int_t sector, Int_t timeStamp, Int_t sigDigits, Bool_t current) {
- //
- // return the chamber HV for given run and time: 0-35 IROC, 36-72 OROC
- // if timeStamp==-1 return mean value
- //
+ /// return the chamber HV for given run and time: 0-35 IROC, 36-72 OROC
+ /// if timeStamp==-1 return mean value
+
Float_t val=0;
TString sensorName="";
TTimeStamp stamp(timeStamp);
}
Float_t AliTPCcalibDB::GetSkirtVoltage(Int_t run, Int_t sector, Int_t timeStamp, Int_t sigDigits)
{
- //
- // Get the skirt voltage for 'run' at 'timeStamp' and 'sector': 0-35 IROC, 36-72 OROC
- // type corresponds to the following: 0 - IROC A-Side; 1 - IROC C-Side; 2 - OROC A-Side; 3 - OROC C-Side
- // if timeStamp==-1 return the mean value for the run
- //
+ /// Get the skirt voltage for 'run' at 'timeStamp' and 'sector': 0-35 IROC, 36-72 OROC
+ /// type corresponds to the following: 0 - IROC A-Side; 1 - IROC C-Side; 2 - OROC A-Side; 3 - OROC C-Side
+ /// if timeStamp==-1 return the mean value for the run
+
Float_t val=0;
TString sensorName="";
TTimeStamp stamp(timeStamp);
Float_t AliTPCcalibDB::GetCoverVoltage(Int_t run, Int_t sector, Int_t timeStamp, Int_t sigDigits)
{
- //
- // Get the cover voltage for run 'run' at time 'timeStamp'
- // type corresponds to the following: 0 - IROC A-Side; 1 - IROC C-Side; 2 - OROC A-Side; 3 - OROC C-Side
- // if timeStamp==-1 return the mean value for the run
- //
+ /// Get the cover voltage for run 'run' at time 'timeStamp'
+ /// type corresponds to the following: 0 - IROC A-Side; 1 - IROC C-Side; 2 - OROC A-Side; 3 - OROC C-Side
+ /// if timeStamp==-1 return the mean value for the run
+
Float_t val=0;
TString sensorName="";
TTimeStamp stamp(timeStamp);
Float_t AliTPCcalibDB::GetGGoffsetVoltage(Int_t run, Int_t sector, Int_t timeStamp, Int_t sigDigits)
{
- //
- // Get the GG offset voltage for run 'run' at time 'timeStamp'
- // type corresponds to the following: 0 - IROC A-Side; 1 - IROC C-Side; 2 - OROC A-Side; 3 - OROC C-Side
- // if timeStamp==-1 return the mean value for the run
- //
+ /// Get the GG offset voltage for run 'run' at time 'timeStamp'
+ /// type corresponds to the following: 0 - IROC A-Side; 1 - IROC C-Side; 2 - OROC A-Side; 3 - OROC C-Side
+ /// if timeStamp==-1 return the mean value for the run
+
Float_t val=0;
TString sensorName="";
TTimeStamp stamp(timeStamp);
Float_t AliTPCcalibDB::GetGGnegVoltage(Int_t run, Int_t sector, Int_t timeStamp, Int_t sigDigits)
{
- //
- // Get the GG offset voltage for run 'run' at time 'timeStamp'
- // type corresponds to the following: 0 - IROC A-Side; 1 - IROC C-Side; 2 - OROC A-Side; 3 - OROC C-Side
- // if timeStamp==-1 return the mean value for the run
- //
+ /// Get the GG offset voltage for run 'run' at time 'timeStamp'
+ /// type corresponds to the following: 0 - IROC A-Side; 1 - IROC C-Side; 2 - OROC A-Side; 3 - OROC C-Side
+ /// if timeStamp==-1 return the mean value for the run
+
Float_t val=0;
TString sensorName="";
TTimeStamp stamp(timeStamp);
Float_t AliTPCcalibDB::GetGGposVoltage(Int_t run, Int_t sector, Int_t timeStamp, Int_t sigDigits)
{
- //
- // Get the GG offset voltage for run 'run' at time 'timeStamp'
- // type corresponds to the following: 0 - IROC A-Side; 1 - IROC C-Side; 2 - OROC A-Side; 3 - OROC C-Side
- // if timeStamp==-1 return the mean value for the run
- //
+ /// Get the GG offset voltage for run 'run' at time 'timeStamp'
+ /// type corresponds to the following: 0 - IROC A-Side; 1 - IROC C-Side; 2 - OROC A-Side; 3 - OROC C-Side
+ /// if timeStamp==-1 return the mean value for the run
+
Float_t val=0;
TString sensorName="";
TTimeStamp stamp(timeStamp);
}
Float_t AliTPCcalibDB::GetPressure(Int_t timeStamp, Int_t run, Int_t type){
- //
- // GetPressure for given time stamp and runt
- //
+ /// GetPressure for given time stamp and runt
+
TTimeStamp stamp(timeStamp);
AliDCSSensor * sensor = Instance()->GetPressureSensor(run,type);
if (!sensor) return 0;
}
Float_t AliTPCcalibDB::GetL3Current(Int_t run, Int_t statType){
- //
- // return L3 current
- // stat type is: AliGRPObject::Stats: kMean = 0, kTruncMean = 1, kMedian = 2, kSDMean = 3, kSDMedian = 4
- //
+ /// return L3 current
+ /// stat type is: AliGRPObject::Stats: kMean = 0, kTruncMean = 1, kMedian = 2, kSDMean = 3, kSDMedian = 4
+
Float_t current=-1;
AliGRPObject *grp=AliTPCcalibDB::GetGRP(run);
if (grp) current=grp->GetL3Current((AliGRPObject::Stats)statType);
}
Float_t AliTPCcalibDB::GetBz(Int_t run){
- //
- // calculate BZ in T from L3 current
- //
+ /// calculate BZ in T from L3 current
+
Float_t bz=-1;
Float_t current=AliTPCcalibDB::GetL3Current(run);
if (current>-1) bz=5*current/30000.*.1;
}
Char_t AliTPCcalibDB::GetL3Polarity(Int_t run) {
- //
- // get l3 polarity from GRP
- //
+ /// get l3 polarity from GRP
+
Char_t pol=-100;
AliGRPObject *grp=AliTPCcalibDB::GetGRP(run);
if (grp) pol=grp->GetL3Polarity();
}
TString AliTPCcalibDB::GetRunType(Int_t run){
- //
- // return run type from grp
- //
+ /// return run type from grp
// TString type("UNKNOWN");
AliGRPObject *grp=AliTPCcalibDB::GetGRP(run);
}
Float_t AliTPCcalibDB::GetValueGoofie(Int_t timeStamp, Int_t run, Int_t type){
- //
- // GetPressure for given time stamp and runt
- //
+ /// GetPressure for given time stamp and runt
+
TTimeStamp stamp(timeStamp);
AliDCSSensorArray* goofieArray = AliTPCcalibDB::Instance()->GetGoofieSensors(run);
if (!goofieArray) return 0;
Bool_t AliTPCcalibDB::GetTemperatureFit(Int_t timeStamp, Int_t run, Int_t side,TVectorD& fit){
- //
- // GetTmeparature fit at parameter for given time stamp
- //
+ /// GetTmeparature fit at parameter for given time stamp
+
TTimeStamp tstamp(timeStamp);
AliTPCSensorTempArray* tempArray = Instance()->GetTemperatureSensor(run);
if (! tempArray) return kFALSE;
}
Float_t AliTPCcalibDB::GetTemperature(Int_t timeStamp, Int_t run, Int_t side){
- //
- // Get mean temperature
- //
+ /// Get mean temperature
+
TVectorD vec(5);
if (side==0) {
GetTemperatureFit(timeStamp,run,0,vec);
Double_t AliTPCcalibDB::GetPTRelative(UInt_t timeSec, Int_t run, Int_t side){
- //
- // Get relative P/T
- // time - absolute time
- // run - run number
- // side - 0 - A side 1-C side
+ /// Get relative P/T
+ /// time - absolute time
+ /// run - run number
+ /// side - 0 - A side 1-C side
+
AliTPCCalibVdrift * vdrift = Instance()->GetVdrift(run);
if (!vdrift) return 0;
return vdrift->GetPTRelative(timeSec,side);
}
AliGRPObject * AliTPCcalibDB::MakeGRPObjectFromMap(TMap *map){
- //
- // Function to covert old GRP run information from TMap to GRPObject
- //
- // TMap * map = AliTPCcalibDB::GetGRPMap(52406);
+ /// Function to covert old GRP run information from TMap to GRPObject
+ ///
+ /// TMap * map = AliTPCcalibDB::GetGRPMap(52406);
+
if (!map) return 0;
AliDCSSensor * sensor = 0;
TObject *osensor=0;
Bool_t AliTPCcalibDB::CreateGUITree(Int_t run, const char* filename)
{
- //
- // Create a gui tree for run number 'run'
- //
+ /// Create a gui tree for run number 'run'
if (!AliCDBManager::Instance()->GetDefaultStorage()){
AliLog::Message(AliLog::kError, "Default Storage not set. Cannot create Calibration Tree!",
}
Bool_t AliTPCcalibDB::CreateGUITree(const char* filename){
- //
- //
- //
+ ///
+
if (!AliCDBManager::Instance()->GetDefaultStorage()){
AliError("Default Storage not set. Cannot create calibration Tree!");
return kFALSE;
Bool_t AliTPCcalibDB::CreateRefFile(Int_t run, const char* filename)
{
- //
- // Create a gui tree for run number 'run'
- //
-
+ /// Create a gui tree for run number 'run'
+
if (!AliCDBManager::Instance()->GetDefaultStorage()){
AliLog::Message(AliLog::kError, "Default Storage not set. Cannot create Calibration Tree!",
MODULENAME(), "AliTPCcalibDB", FUNCTIONNAME(), __FILE__, __LINE__);
Double_t AliTPCcalibDB::GetVDriftCorrectionTime(Int_t timeStamp, Int_t run, Int_t /*side*/, Int_t mode){
- //
- // Get time dependent drift velocity correction
- // multiplication factor vd = vdnom *(1+vdriftcorr)
- // Arguments:
- // mode determines the algorith how to combine the Laser Track, LaserCE and physics tracks
- // timestamp - timestamp
- // run - run number
- // side - the drift velocity per side (possible for laser and CE)
- //
- // Notice - Extrapolation outside of calibration range - using constant function
- //
+ /// Get time dependent drift velocity correction
+ /// multiplication factor vd = vdnom *(1+vdriftcorr)
+ /// Arguments:
+ /// mode determines the algorith how to combine the Laser Track, LaserCE and physics tracks
+ /// timestamp - timestamp
+ /// run - run number
+ /// side - the drift velocity per side (possible for laser and CE)
+ ///
+ /// Notice - Extrapolation outside of calibration range - using constant function
+
Double_t result=0;
// mode 1 automatic mode - according to the distance to the valid calibration
// -
}
Double_t AliTPCcalibDB::GetTime0CorrectionTime(Int_t timeStamp, Int_t run, Int_t /*side*/, Int_t mode){
- //
- // Get time dependent time 0 (trigger delay in cm) correction
- // additive correction time0 = time0+ GetTime0CorrectionTime
- // Value etracted combining the vdrift correction using laser tracks and CE and the physics track matchin
- // Arguments:
- // mode determines the algorith how to combine the Laser Track and physics tracks
- // timestamp - timestamp
- // run - run number
- // side - the drift velocity per side (possible for laser and CE)
- //
- // Notice - Extrapolation outside of calibration range - using constant function
- //
+ /// Get time dependent time 0 (trigger delay in cm) correction
+ /// additive correction time0 = time0+ GetTime0CorrectionTime
+ /// Value etracted combining the vdrift correction using laser tracks and CE and the physics track matchin
+ /// Arguments:
+ /// mode determines the algorith how to combine the Laser Track and physics tracks
+ /// timestamp - timestamp
+ /// run - run number
+ /// side - the drift velocity per side (possible for laser and CE)
+ ///
+ /// Notice - Extrapolation outside of calibration range - using constant function
+
Double_t result=0;
if (mode==2) {
// TPC-TPC mode
Double_t AliTPCcalibDB::GetVDriftCorrectionGy(Int_t timeStamp, Int_t run, Int_t side, Int_t /*mode*/){
- //
- // Get global y correction drift velocity correction factor
- // additive factor vd = vdnom*(1+GetVDriftCorrectionGy *gy)
- // Value etracted combining the vdrift correction using laser tracks and CE or TPC-ITS
- // Arguments:
- // mode determines the algorith how to combine the Laser Track, LaserCE or TPC-ITS
- // timestamp - timestamp
- // run - run number
- // side - the drift velocity gy correction per side (CE and Laser tracks)
- //
- // Notice - Extrapolation outside of calibration range - using constant function
- //
+ /// Get global y correction drift velocity correction factor
+ /// additive factor vd = vdnom*(1+GetVDriftCorrectionGy *gy)
+ /// Value etracted combining the vdrift correction using laser tracks and CE or TPC-ITS
+ /// Arguments:
+ /// mode determines the algorith how to combine the Laser Track, LaserCE or TPC-ITS
+ /// timestamp - timestamp
+ /// run - run number
+ /// side - the drift velocity gy correction per side (CE and Laser tracks)
+ ///
+ /// Notice - Extrapolation outside of calibration range - using constant function
+
if (run<=0 && fTransform) run = fTransform->GetCurrentRunNumber();
UpdateRunInformations(run,kFALSE);
TObjArray *array =AliTPCcalibDB::Instance()->GetTimeVdriftSplineRun(run);
Double_t AliTPCcalibDB::GetVDriftCorrectionDeltaZ(Int_t /*timeStamp*/, Int_t run, Int_t /*side*/, Int_t /*mode*/){
- //
- // Get deltaZ run/by/run correction - as fitted together with drift velocity
- // Value extracted form the TPC-ITS, mean value is used
-
+ /// Get deltaZ run/by/run correction - as fitted together with drift velocity
+ /// Value extracted form the TPC-ITS, mean value is used
+
// Arguments:
// mode determines the algorith how to combine the Laser Track, LaserCE or TPC-ITS
// timestamp - not used
AliTPCCalPad* AliTPCcalibDB::MakeDeadMap(Double_t notInMap, const char* nameMappingFile) {
-//
-// Read list of active DDLs from OCDB entry
-// Generate and return AliTPCCalPad containing 1 for all pads in active DDLs,
-// 0 for all pads in non-active DDLs.
-// For DDLs with missing status information (no DCS input point to Shuttle),
-// the value of the AliTPCCalPad entry is determined by the parameter
-// notInMap (default value 1)
-//
+/// Read list of active DDLs from OCDB entry
+/// Generate and return AliTPCCalPad containing 1 for all pads in active DDLs,
+/// 0 for all pads in non-active DDLs.
+/// For DDLs with missing status information (no DCS input point to Shuttle),
+/// the value of the AliTPCCalPad entry is determined by the parameter
+/// notInMap (default value 1)
+
char chinfo[1000];
TFile *fileMapping = new TFile(nameMappingFile, "read");
AliTPCCorrection * AliTPCcalibDB::GetTPCComposedCorrection(Float_t field) const{
- //
- // GetComposed correction for given field setting
- // If not specific correction for field used return correction for all field
- // - Complication needed to gaurantee OCDB back compatibility
- // - Not neeeded for the new space point correction
+ /// GetComposed correction for given field setting
+ /// If not specific correction for field used return correction for all field
+ /// - Complication needed to gaurantee OCDB back compatibility
+ /// - Not neeeded for the new space point correction
+
if (!fComposedCorrectionArray) return 0;
if (field>0.1 && fComposedCorrectionArray->At(1)) {
return (AliTPCCorrection *)fComposedCorrectionArray->At(1);
AliTPCCorrection * AliTPCcalibDB::GetTPCComposedCorrectionDelta() const{
- //
- // GetComposedCorrection delta
- // Delta is time dependent - taken form the CalibTime OCDB entry
- //
+ /// GetComposedCorrection delta
+ /// Delta is time dependent - taken form the CalibTime OCDB entry
+
if (!fComposedCorrectionArray) return 0;
if (fRun<0) return 0;
if (fDriftCorrectionArray.GetValue(Form("%i",fRun))==0) return 0;
}
Double_t AliTPCcalibDB::GetGainCorrectionHVandPT(Int_t timeStamp, Int_t run, Int_t sector, Int_t deltaCache, Int_t mode){
- //
- // Correction for changes of gain caused by change of the HV and by relative change of the gas density
- // Function is slow some kind of caching needed
- // Cache implemented using the static TVectorD
- //
- // Input paremeters:
- // deltaCache - maximal time differnce above which the cache is recaclulated
- // mode - mode==0 by default return combined correction
- // actual HV and Pt correction has to be present in the run calibration otherwise it is ignored.
- // (retrun value differnt than 1 only in case calibration present in the OCDB entry CalibTimeGain
- // mode==1 return combined correction ( important for calibration pass)
- // (in case thereis no calibration in CalibTimeGain, default value from the AliTPCParam (Parameters) is used
- // this mode is used in the CPass0
- // mode==2 return HV correction
- // mode==3 return P/T correction
- // Usage in the simulation/reconstruction
- // MC: Qcorr = Qorig*GetGainCorrectionHVandPT ( in AliTPC.cxx )
- // Rec: dEdx = dEdx/GetGainCorrectionHVandPT ( in aliTPCseed.cxx )
- //
+ /// Correction for changes of gain caused by change of the HV and by relative change of the gas density
+ /// Function is slow some kind of caching needed
+ /// Cache implemented using the static TVectorD
+ ///
+ /// Input paremeters:
+ /// deltaCache - maximal time differnce above which the cache is recaclulated
+ /// mode - mode==0 by default return combined correction
+ /// actual HV and Pt correction has to be present in the run calibration otherwise it is ignored.
+ /// (retrun value differnt than 1 only in case calibration present in the OCDB entry CalibTimeGain
+ /// mode==1 return combined correction ( important for calibration pass)
+ /// (in case thereis no calibration in CalibTimeGain, default value from the AliTPCParam (Parameters) is used
+ /// this mode is used in the CPass0
+ /// mode==2 return HV correction
+ /// mode==3 return P/T correction
+ /// Usage in the simulation/reconstruction
+ /// MC: Qcorr = Qorig*GetGainCorrectionHVandPT ( in AliTPC.cxx )
+ /// Rec: dEdx = dEdx/GetGainCorrectionHVandPT ( in aliTPCseed.cxx )
+
static Float_t gGainCorrection[72];
static Float_t gGainCorrectionPT[72];
static Float_t gGainCorrectionHV[72];
/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
* See cxx source for full Copyright notice */
-///////////////////////////////////////////////////////////////////////////////
-// //
-// Class providing the calibration parameters by accessing the CDB //
-// //
-///////////////////////////////////////////////////////////////////////////////
+/// \class AliTPCcalibDB
+/// \brief Class providing the calibration parameters by accessing the CDB
class AliTPCTransform;
void UpdateChamberHighVoltageData();
Int_t InitDeadMap();
- Int_t fRun; // current run number
- AliTPCTransform *fTransform; // object responsible for spacial corrections
- AliTPCExB *fExB; // ExB correction factor
+ Int_t fRun; ///< current run number
+ AliTPCTransform *fTransform; ///< object responsible for spacial corrections
+ AliTPCExB *fExB; ///< ExB correction factor
// AliCDBStorage* fLocator; // Storage locator retrieved from AliCDBManager
//
// calibration parameters per pad
//
- AliTPCCalPad* fPadGainFactor; // Gain calibration entry
- AliTPCCalPad* fActiveChannelMap; // Map of active channels calculated on the fly
- AliTPCCalPad* fDedxGainFactor; // Gain calibration entry - for dEdx
- AliTPCCalPad* fPadTime0; // Time0 calibration entry
- TObjArray *fDistortionMap; // distortion map
- AliTPCCorrection *fComposedCorrection; // general space point corrections
- TObjArray * fComposedCorrectionArray; //space point corrections for different field setting
- AliTPCCalPad* fPadNoise; // Noise calibration entry
- AliTPCCalPad* fPedestals; // Pedestal calibration entry
- AliTPCCalibRaw *fCalibRaw; // raw data calibration entry
- AliTPCdataQA *fDataQA; // qa object
- TObjArray *fALTROConfigData; // ALTRO configuration data
- TObjArray * fIonTailArray; // array of graphs with the ion tail
- TObjArray *fPulserData; // Calibration Pulser data
- TObjArray *fCEData; // CE data
+ AliTPCCalPad* fPadGainFactor; ///< Gain calibration entry
+ AliTPCCalPad* fActiveChannelMap; ///< Map of active channels calculated on the fly
+ AliTPCCalPad* fDedxGainFactor; ///< Gain calibration entry - for dEdx
+ AliTPCCalPad* fPadTime0; ///< Time0 calibration entry
+ TObjArray *fDistortionMap; ///< distortion map
+ AliTPCCorrection *fComposedCorrection; ///< general space point corrections
+ TObjArray * fComposedCorrectionArray; ///< space point corrections for different field setting
+ AliTPCCalPad* fPadNoise; ///< Noise calibration entry
+ AliTPCCalPad* fPedestals; ///< Pedestal calibration entry
+ AliTPCCalibRaw *fCalibRaw; ///< raw data calibration entry
+ AliTPCdataQA *fDataQA; ///< qa object
+ TObjArray *fALTROConfigData; ///< ALTRO configuration data
+ TObjArray * fIonTailArray; ///< array of graphs with the ion tail
+ TObjArray *fPulserData; ///< Calibration Pulser data
+ TObjArray *fCEData; ///< CE data
//
// Chamber HV info
//
- Bool_t fChamberHVStatus[72]; // Status of the Chamber, HV wise (on/off)
- Float_t fChamberHVmedian[72]; // median chamber high voltage
- Float_t fCurrentNominalVoltage[72]; // current nominal voltages
- Float_t fChamberHVgoodFraction[72]; // fraction of time the chamber has a good HV (wrt. robust median)
- AliDCSSensor *fHVsensors[72]; // HV sensors
- TGraph *fGrRunState; // store information if run is active or paused
+ Bool_t fChamberHVStatus[72]; ///< Status of the Chamber, HV wise (on/off)
+ Float_t fChamberHVmedian[72]; ///< median chamber high voltage
+ Float_t fCurrentNominalVoltage[72]; ///< current nominal voltages
+ Float_t fChamberHVgoodFraction[72]; ///< fraction of time the chamber has a good HV (wrt. robust median)
+ AliDCSSensor *fHVsensors[72]; ///< HV sensors
+ TGraph *fGrRunState; ///< store information if run is active or paused
//
//
//
- AliTPCSensorTempArray* fTemperature; // Temperature calibration entry
- AliTPCAltroMapping **fMapping; // Altro mapping
+ AliTPCSensorTempArray* fTemperature; ///< Temperature calibration entry
+ AliTPCAltroMapping **fMapping; ///< Altro mapping
//
//
- AliTPCParam * fParam; // TPC parameters
- AliTPCClusterParam * fClusterParam; // TPC cluster error, shape and Q parameterization
- TObjArray * fRecoParamList; // List of TPC reco param objects
- TObjArray * fTimeGainSplines; // Array of AliSplineFits: at 0 MIP position in time ; at 1 Fermi Plateau from cosmics
+ AliTPCParam * fParam; ///< TPC parameters
+ AliTPCClusterParam * fClusterParam; ///< TPC cluster error, shape and Q parameterization
+ TObjArray * fRecoParamList; ///< List of TPC reco param objects
+ TObjArray * fTimeGainSplines; ///< Array of AliSplineFits: at 0 MIP position in time ; at 1 Fermi Plateau from cosmics
//
// Get the corssrun information
//
- TMap fTimeGainSplinesArray; //! array Array of AliSplineFits: at 0 MIP position in time ; at 1 Fermi Plateau from cosmics
- TMap fGRPArray; //! array of GRPs - per run
- TMap fGRPMaps; //! array of GRPs maps - per run - old data
- TMap fGoofieArray; //! array of GOOFIE values -per run
- TMap fVoltageArray; //! array of Chamber HV values -per run
- TMap fTemperatureArray; //! array of temperature sensors - per run
- TMap fVdriftArray; //! array of v drift interfaces
- TMap fDriftCorrectionArray; //! array of drift correction
+ TMap fTimeGainSplinesArray; //!< array Array of AliSplineFits: at 0 MIP position in time ; at 1 Fermi Plateau from cosmics
+ TMap fGRPArray; //!< array of GRPs - per run
+ TMap fGRPMaps; //!< array of GRPs maps - per run - old data
+ TMap fGoofieArray; //!< array of GOOFIE values -per run
+ TMap fVoltageArray; //!< array of Chamber HV values -per run
+ TMap fTemperatureArray; //!< array of temperature sensors - per run
+ TMap fVdriftArray; //!< array of v drift interfaces
+ TMap fDriftCorrectionArray; //!< array of drift correction
- TArrayI fRunList; //! run list - indicates try to get the run param
- Bool_t fBHasAlignmentOCDB; // Flag - alignment from the Transformation class
+ TArrayI fRunList; //!< run list - indicates try to get the run param
+ Bool_t fBHasAlignmentOCDB; ///< Flag - alignment from the Transformation class
//
- static AliTPCcalibDB* fgInstance; // singleton control
- static Bool_t fgTerminated; // termination control
- static TObjArray fgExBArray; // array of ExB corrections
- AliTPCcalibDButil *fDButil; // utility class
+ static AliTPCcalibDB* fgInstance; ///< singleton control
+ static Bool_t fgTerminated; ///< termination control
+ static TObjArray fgExBArray; ///< array of ExB corrections
+ AliTPCcalibDButil *fDButil; ///< utility class
//ctp info
- AliCTPTimeParams *fCTPTimeParams; //CTP timing parameters
- Int_t fMode; //RCU trigger config mode
+ AliCTPTimeParams *fCTPTimeParams; ///< CTP timing parameters
+ Int_t fMode; ///< RCU trigger config mode
private:
AliTPCcalibDB (const AliTPCcalibDB& );
AliTPCcalibDB& operator= (const AliTPCcalibDB& );
+ /// \cond CLASSIMP
ClassDef(AliTPCcalibDB, 1)
+ /// \endcond
};
#endif
**************************************************************************/
-///////////////////////////////////////////////////////////////////////////////
-// //
-// Class providing the calculation of derived quantities (mean,rms,fits,...) //
-// of calibration entries //
-/*
-
-
-*/
-////////////////////////////////////////////////////////////////////////////////
+/// \class AliTPCcalibDButil
+/// \brief Class providing the calculation of derived quantities (mean,rms,fits,...) of calibration entries
#include <TMath.h>
#include <TVectorT.h>
const Float_t kAlmost0=1.e-30;
+/// \cond CLASSIMP
ClassImp(AliTPCcalibDButil)
+/// \endcond
AliTPCcalibDButil::AliTPCcalibDButil() :
TObject(),
fCalibDB(0),
//_____________________________________________________________________________________
AliTPCcalibDButil::~AliTPCcalibDButil()
{
- //
- // dtor
- //
+ /// dtor
+
delete fPulserOutlier;
delete fRefPulserOutlier;
delete fMapper;
//_____________________________________________________________________________________
void AliTPCcalibDButil::UpdateFromCalibDB()
{
- //
- // Update pointers from calibDB
- //
+ /// Update pointers from calibDB
+
if (!fCalibDB) fCalibDB=AliTPCcalibDB::Instance();
fCalibDB->UpdateNonRec(); // load all infromation now
fPadNoise=fCalibDB->GetPadNoise();
void AliTPCcalibDButil::ProcessCEdata(const char* fitFormula, TVectorD &fitResultsA, TVectorD &fitResultsC,
Int_t &noutliersCE, Double_t & chi2A, Double_t &chi2C, AliTPCCalPad * const outCE)
{
- //
- // Process the CE data for this run
- // the return TVectorD arrays contian the results of the fit
- // noutliersCE contains the number of pads marked as outliers,
- // not including masked and edge pads
- //
-
+ /// Process the CE data for this run
+ /// the return TVectorD arrays contian the results of the fit
+ /// noutliersCE contains the number of pads marked as outliers,
+ /// not including masked and edge pads
+
//retrieve CE and ALTRO data
if (!fCETmean){
TString fitString(fitFormula);
TVectorD &vecQEntries, TVectorD &vecQMean, TVectorD &vecQRMS, TVectorD &vecQMedian,
Float_t &driftTimeA, Float_t &driftTimeC )
{
- //
- // Calculate statistical information from the CE graphs for drift time and charge
- //
-
+ /// Calculate statistical information from the CE graphs for drift time and charge
+
//reset arrays
vecTEntries.ResizeTo(72);
vecTMean.ResizeTo(72);
TVectorD &vNoiseRMS, TVectorD &vNoiseRMSSenRegions,
Int_t &nonMaskedZero, Int_t &nNaN)
{
- //
- // process noise data
- // vNoiseMean/RMS contains the Mean/RMS noise of the complete TPC [0], IROCs only [1],
- // OROCs small pads [2] and OROCs large pads [3]
- // vNoiseMean/RMSsenRegions constains the same information, but only for the sensitive regions (edge pads, corners, IROC spot)
- // nonMaskedZero contains the number of pads which show zero noise and were not masked. This might indicate an error
- //
-
+ /// process noise data
+ /// vNoiseMean/RMS contains the Mean/RMS noise of the complete TPC [0], IROCs only [1],
+ /// OROCs small pads [2] and OROCs large pads [3]
+ /// vNoiseMean/RMSsenRegions constains the same information, but only for the sensitive regions (edge pads, corners, IROC spot)
+ /// nonMaskedZero contains the number of pads which show zero noise and were not masked. This might indicate an error
+
//set proper size and reset
const UInt_t infoSize=4;
vNoiseMean.ResizeTo(infoSize);
void AliTPCcalibDButil::ProcessQAData(TVectorD &vQaOcc, TVectorD &vQaQtot,
TVectorD &vQaQmax)
{
- //
- // process QA data
- //
- // vQaOcc/Qtot/Qmax contains the Mean occupancy/Qtot/Qmax for each sector
- //
+ /// process QA data
+ ///
+ /// vQaOcc/Qtot/Qmax contains the Mean occupancy/Qtot/Qmax for each sector
const UInt_t infoSize = 72;
//_____________________________________________________________________________________
void AliTPCcalibDButil::ProcessPulser(TVectorD &vMeanTime)
{
- //
- // Process the Pulser information
- // vMeanTime: pulser mean time position in IROC-A, IROC-C, OROC-A, OROC-C
- //
+ /// Process the Pulser information
+ /// vMeanTime: pulser mean time position in IROC-A, IROC-C, OROC-A, OROC-C
const UInt_t infoSize=4;
//reset counters to error number
//_____________________________________________________________________________________
void AliTPCcalibDButil::ProcessALTROConfig(Int_t &nMasked)
{
- //
- // Get Values from ALTRO configuration data
- //
+ /// Get Values from ALTRO configuration data
+
nMasked=-1;
if (!fALTROMasked) return;
nMasked=0;
//_____________________________________________________________________________________
void AliTPCcalibDButil::ProcessGoofie(TVectorD & vecEntries, TVectorD & vecMedian, TVectorD &vecMean, TVectorD &vecRMS)
{
- //
- // Proces Goofie values, return statistical information of the currently set goofieArray
- // The meaning of the entries are given below
+ /// Proces Goofie values, return statistical information of the currently set goofieArray
+ /// The meaning of the entries are given below
+
/*
1 TPC_ANODE_I_A00_STAT
2 TPC_DVM_CO2
//_____________________________________________________________________________________
void AliTPCcalibDButil::ProcessPedestalVariations(TVectorF &pedestalDeviations)
{
- //
- // check the variations of the pedestal data to the reference pedestal data
- // thresholds are 0.5, 1.0, 1.5 and 2 timebins respectively.
- //
+ /// check the variations of the pedestal data to the reference pedestal data
+ /// thresholds are 0.5, 1.0, 1.5 and 2 timebins respectively.
+
const Int_t npar=4;
TVectorF vThres(npar); //thresholds
Int_t nActive=0; //number of active channels
//_____________________________________________________________________________________
void AliTPCcalibDButil::ProcessNoiseVariations(TVectorF &noiseDeviations)
{
- //
- // check the variations of the noise data to the reference noise data
- // thresholds are 5, 10, 15 and 20 percent respectively.
- //
+ /// check the variations of the noise data to the reference noise data
+ /// thresholds are 5, 10, 15 and 20 percent respectively.
+
const Int_t npar=4;
TVectorF vThres(npar); //thresholds
Int_t nActive=0; //number of active channels
void AliTPCcalibDButil::ProcessPulserVariations(TVectorF &pulserQdeviations, Float_t &varQMean,
Int_t &npadsOutOneTB, Int_t &npadsOffAdd)
{
- //
- // check the variations of the pulserQmean data to the reference pulserQmean data: pulserQdeviations
- // thresholds are .5, 1, 5 and 10 percent respectively.
- //
- //
+ /// check the variations of the pulserQmean data to the reference pulserQmean data: pulserQdeviations
+ /// thresholds are .5, 1, 5 and 10 percent respectively.
+
const Int_t npar=4;
TVectorF vThres(npar); //thresholds
Int_t nActive=0; //number of active channels
//_____________________________________________________________________________________
void AliTPCcalibDButil::UpdatePulserOutlierMap()
{
- //
- // Update the outlier map of the pulser data
- //
+ /// Update the outlier map of the pulser data
+
PulserOutlierMap(fPulserOutlier,fPulserTmean, fPulserQmean);
}
//_____________________________________________________________________________________
void AliTPCcalibDButil::UpdateRefPulserOutlierMap()
{
- //
- // Update the outlier map of the pulser reference data
- //
+ /// Update the outlier map of the pulser reference data
+
PulserOutlierMap(fRefPulserOutlier,fRefPulserTmean, fRefPulserQmean);
}
//_____________________________________________________________________________________
void AliTPCcalibDButil::PulserOutlierMap(AliTPCCalPad *pulOut, const AliTPCCalPad *pulT, const AliTPCCalPad *pulQ)
{
- //
- // Create a map that contains outliers from the Pulser calibration data.
- // The outliers include masked channels, edge pads and pads with
- // too large timing and charge variations.
- // fNpulserOutliers is the number of outliers in the Pulser calibration data.
- // those do not contain masked and edge pads
- //
+ /// Create a map that contains outliers from the Pulser calibration data.
+ /// The outliers include masked channels, edge pads and pads with
+ /// too large timing and charge variations.
+ /// fNpulserOutliers is the number of outliers in the Pulser calibration data.
+ /// those do not contain masked and edge pads
+
if (!pulT||!pulQ) {
//reset map
pulOut->Multiply(0.);
//_____________________________________________________________________________________
AliTPCCalPad* AliTPCcalibDButil::CreatePadTime0(Int_t model, Double_t &gyA, Double_t &gyC, Double_t &chi2A, Double_t &chi2C )
{
- //
- // Create pad time0 object from pulser and/or CE data, depending on the selected model
- // Model 0: normalise each readout chamber to its mean, outlier cutted, only Pulser
- // Model 1: normalise IROCs/OROCs of each readout side to its mean, only Pulser
- // Model 2: use CE data and a combination CE fit + pulser in the outlier regions.
- //
- // In case model 2 is invoked - gy arival time gradient is also returned
- //
+ /// Create pad time0 object from pulser and/or CE data, depending on the selected model
+ /// Model 0: normalise each readout chamber to its mean, outlier cutted, only Pulser
+ /// Model 1: normalise IROCs/OROCs of each readout side to its mean, only Pulser
+ /// Model 2: use CE data and a combination CE fit + pulser in the outlier regions.
+ ///
+ /// In case model 2 is invoked - gy arival time gradient is also returned
+
gyA=0;
gyC=0;
AliTPCCalPad *padTime0=new AliTPCCalPad("PadTime0",Form("PadTime0-Model_%d",model));
//_____________________________________________________________________________________
Float_t AliTPCcalibDButil::GetMeanAltro(const AliTPCCalROC *roc, const Int_t row, const Int_t pad, AliTPCCalROC *const rocOut)
{
- //
- // GetMeanAlto information
- //
+ /// GetMeanAlto information
+
if (roc==0) return 0.;
const Int_t sector=roc->GetSector();
AliTPCROC *tpcRoc=AliTPCROC::Instance();
//_____________________________________________________________________________________
void AliTPCcalibDButil::SetRefFile(const char* filename)
{
- //
- // load cal pad objects form the reference file
- //
+ /// load cal pad objects form the reference file
+
TDirectory *currDir=gDirectory;
TFile f(filename);
fRefPedestals=(AliTPCCalPad*)f.Get("Pedestals");
//_____________________________________________________________________________________
void AliTPCcalibDButil::UpdateRefDataFromOCDB()
{
- //
- // set reference data from OCDB Reference map
- //
+ /// set reference data from OCDB Reference map
+
if (!fRefMap) {
AliWarning("Referenc map not set!");
return;
//_____________________________________________________________________________________
AliTPCCalPad* AliTPCcalibDButil::GetRefCalPad(AliCDBEntry *entry, const char* objName)
{
- //
- // TObjArray object type case
- // find 'objName' in 'arr' cast is to a calPad and store it in 'pad'
- //
+ /// TObjArray object type case
+ /// find 'objName' in 'arr' cast is to a calPad and store it in 'pad'
+
AliTPCCalPad *pad=0x0;
TObjArray *arr=(TObjArray*)entry->GetObject();
if (!arr){
//_____________________________________________________________________________________
AliTPCCalPad* AliTPCcalibDButil::GetRefCalPad(AliCDBEntry *entry)
{
- //
- // AliTPCCalPad object type case
- // cast object to a calPad and store it in 'pad'
- //
+ /// AliTPCCalPad object type case
+ /// cast object to a calPad and store it in 'pad'
+
AliTPCCalPad *pad=(AliTPCCalPad*)entry->GetObject();
if (!pad) {
AliError(Form("Could not get object from entry '%s'\nPlease check!!!",entry->GetId().GetPath().Data()));
//_____________________________________________________________________________________
AliTPCCalPad* AliTPCcalibDButil::GetAltroMasked(const char* cdbPath, const char* name)
{
- //
- // set altro masked channel map for 'cdbPath'
- //
+ /// set altro masked channel map for 'cdbPath'
+
AliTPCCalPad* pad=0x0;
const Int_t run=GetReferenceRun(cdbPath);
if (run<0) {
}
//_____________________________________________________________________________________
void AliTPCcalibDButil::SetReferenceRun(Int_t run){
- //
- // Get Reference map
- //
+ /// Get Reference map
+
if (run<0) run=fCalibDB->GetRun();
TString cdbPath="TPC/Calib/Ref";
AliCDBEntry *entry=AliCDBManager::Instance()->Get(cdbPath.Data(), run);
//_____________________________________________________________________________________
Bool_t AliTPCcalibDButil::HasRefChanged(const char *cdbPath)
{
- //
- // check whether a reference cdb entry has changed
- //
+ /// check whether a reference cdb entry has changed
+
if (!fCurrentRefMap) return kTRUE;
if (GetReferenceRun(cdbPath)!=GetCurrentReferenceRun(cdbPath)) return kTRUE;
return kFALSE;
//_____________________________________________________________________________________
AliCDBEntry* AliTPCcalibDButil::GetRefEntry(const char* cdbPath)
{
- //
- // get the reference AliCDBEntry for 'cdbPath'
- //
+ /// get the reference AliCDBEntry for 'cdbPath'
+
const Int_t run=GetReferenceRun(cdbPath);
if (run<0) {
AliError(Form("Could not get reference run number for object '%s'\nPlease check availability!!!",cdbPath));
}
//_____________________________________________________________________________________
Int_t AliTPCcalibDButil::GetCurrentReferenceRun(const char* type) const {
- //
- // Get reference run number for the specified OCDB path
- //
+ /// Get reference run number for the specified OCDB path
+
if (!fCurrentRefMap) return -2;
TObjString *str=dynamic_cast<TObjString*>(fCurrentRefMap->GetValue(type));
if (!str) return -2;
}
//_____________________________________________________________________________________
Int_t AliTPCcalibDButil::GetReferenceRun(const char* type) const{
- //
- // Get reference run number for the specified OCDB path
- //
+ /// Get reference run number for the specified OCDB path
+
if (!fRefMap) return -1;
TObjString *str=dynamic_cast<TObjString*>(fRefMap->GetValue(type));
if (!str) return -1;
}
//_____________________________________________________________________________________
AliTPCCalPad *AliTPCcalibDButil::CreateCEOutlyerMap( Int_t & noutliersCE, AliTPCCalPad * const ceOut, Float_t minSignal, Float_t cutTrmsMin, Float_t cutTrmsMax, Float_t cutMaxDistT){
- //
- // Author: marian.ivanov@cern.ch
- //
- // Create outlier map for CE study
- // Parameters:
- // Return value - outlyer map
- // noutlyersCE - number of outlyers
- // minSignal - minimal total Q signal
- // cutRMSMin - minimal width of the signal in respect to the median
- // cutRMSMax - maximal width of the signal in respect to the median
- // cutMaxDistT - maximal deviation from time median per chamber
- //
- // Outlyers criteria:
- // 0. Exclude masked pads
- // 1. Exclude first two rows in IROC and last two rows in OROC
- // 2. Exclude edge pads
- // 3. Exclude channels with too large variations
- // 4. Exclude pads with too small signal
- // 5. Exclude signal with outlyers RMS
- // 6. Exclude channels to far from the chamber median
+ /// Author: marian.ivanov@cern.ch
+ ///
+ /// Create outlier map for CE study
+ /// Parameters:
+ /// Return value - outlyer map
+ /// noutlyersCE - number of outlyers
+ /// minSignal - minimal total Q signal
+ /// cutRMSMin - minimal width of the signal in respect to the median
+ /// cutRMSMax - maximal width of the signal in respect to the median
+ /// cutMaxDistT - maximal deviation from time median per chamber
+ ///
+ /// Outlyers criteria:
+ /// 0. Exclude masked pads
+ /// 1. Exclude first two rows in IROC and last two rows in OROC
+ /// 2. Exclude edge pads
+ /// 3. Exclude channels with too large variations
+ /// 4. Exclude pads with too small signal
+ /// 5. Exclude signal with outlyers RMS
+ /// 6. Exclude channels to far from the chamber median
+
noutliersCE=0;
//create outlier map
AliTPCCalPad *out=ceOut;
AliTPCCalPad *AliTPCcalibDButil::CreatePulserOutlyerMap(Int_t &noutliersPulser, AliTPCCalPad * const pulserOut,Float_t cutTime, Float_t cutnRMSQ, Float_t cutnRMSrms){
- //
- // Author: marian.ivanov@cern.ch
- //
- // Create outlier map for Pulser
- // Parameters:
- // Return value - outlyer map
- // noutlyersPulser - number of outlyers
- // cutTime - absolute cut - distance to the median of chamber
- // cutnRMSQ - nsigma cut from median q distribution per chamber
- // cutnRMSrms - nsigma cut from median rms distribution
- // Outlyers criteria:
- // 0. Exclude masked pads
- // 1. Exclude time outlyers (default 3 time bins)
- // 2. Exclude q outlyers (default 5 sigma)
- // 3. Exclude rms outlyers (default 5 sigma)
+ /// Author: marian.ivanov@cern.ch
+ ///
+ /// Create outlier map for Pulser
+ /// Parameters:
+ /// Return value - outlyer map
+ /// noutlyersPulser - number of outlyers
+ /// cutTime - absolute cut - distance to the median of chamber
+ /// cutnRMSQ - nsigma cut from median q distribution per chamber
+ /// cutnRMSrms - nsigma cut from median rms distribution
+ /// Outlyers criteria:
+ /// 0. Exclude masked pads
+ /// 1. Exclude time outlyers (default 3 time bins)
+ /// 2. Exclude q outlyers (default 5 sigma)
+ /// 3. Exclude rms outlyers (default 5 sigma)
+
noutliersPulser=0;
AliTPCCalPad *out=pulserOut;
if (!out) out= new AliTPCCalPad("outPulser","outPulser");
AliTPCCalPad *AliTPCcalibDButil::CreatePadTime0CE(TVectorD &fitResultsA, TVectorD&fitResultsC, Int_t &nOut, Double_t &chi2A, Double_t &chi2C, const char *dumpfile){
- //
- // Author : Marian Ivanov
- // Create pad time0 correction map using information from the CE and from pulser
- //
- //
- // Return PadTime0 to be used for time0 relative alignment
- // if dump file specified intermediat results are dumped to the fiel and can be visualized
- // using $ALICE_ROOT/TPC/script/gui application
- //
- // fitResultsA - fitParameters A side
- // fitResultsC - fitParameters C side
- // chi2A - chi2/ndf for A side (assuming error 1 time bin)
- // chi2C - chi2/ndf for C side (assuming error 1 time bin)
- //
- //
- // Algorithm:
- // 1. Find outlier map for CE
- // 2. Find outlier map for Pulser
- // 3. Replace outlier by median at given sector (median without outliers)
- // 4. Substract from the CE data pulser
- // 5. Fit the CE with formula
- // 5.1) (IROC-OROC) offset
- // 5.2) gx
- // 5.3) gy
- // 5.4) (lx-xmid)
- // 5.5) (IROC-OROC)*(lx-xmid)
- // 5.6) (ly/lx)^2
- // 6. Substract gy fit dependence from the CE data
- // 7. Add pulser back to CE data
- // 8. Replace outliers by fit value - median of diff per given chamber -GY fit
- // 9. return CE data
- //
- // Time0 <= padCE = padCEin -padCEfitGy - if not outlier
- // Time0 <= padCE = padFitAll-padCEfitGy - if outlier
+ /// Author : Marian Ivanov
+ /// Create pad time0 correction map using information from the CE and from pulser
+ ///
+ /// Return PadTime0 to be used for time0 relative alignment
+ /// if dump file specified intermediat results are dumped to the fiel and can be visualized
+ /// using $ALICE_ROOT/TPC/script/gui application
+ ///
+ /// fitResultsA - fitParameters A side
+ /// fitResultsC - fitParameters C side
+ /// chi2A - chi2/ndf for A side (assuming error 1 time bin)
+ /// chi2C - chi2/ndf for C side (assuming error 1 time bin)
+ ///
+ /// Algorithm:
+ /// 1. Find outlier map for CE
+ /// 2. Find outlier map for Pulser
+ /// 3. Replace outlier by median at given sector (median without outliers)
+ /// 4. Substract from the CE data pulser
+ /// 5. Fit the CE with formula
+ /// 5.1) (IROC-OROC) offset
+ /// 5.2) gx
+ /// 5.3) gy
+ /// 5.4) (lx-xmid)
+ /// 5.5) (IROC-OROC)*(lx-xmid)
+ /// 5.6) (ly/lx)^2
+ /// 6. Substract gy fit dependence from the CE data
+ /// 7. Add pulser back to CE data
+ /// 8. Replace outliers by fit value - median of diff per given chamber -GY fit
+ /// 9. return CE data
+ ///
+ /// Time0 <= padCE = padCEin -padCEfitGy - if not outlier
+ /// Time0 <= padCE = padFitAll-padCEfitGy - if outlier
// fit formula
const char *formulaIn="(-1.+2.*(sector<36))*0.5++gx++gy++(lx-134.)++(-1.+2.*(sector<36))*0.5*(lx-134)++((ly/lx)^2/(0.1763)^2)";
Int_t AliTPCcalibDButil::GetNearest(TGraph *graph, Double_t xref, Double_t &dx, Double_t &y){
- //
- // find the closest point to xref in x direction
- // return dx and value
+ /// find the closest point to xref in x direction
+ /// return dx and value
+
dx = 0;
y = 0;
}
Double_t AliTPCcalibDButil::GetTriggerOffsetTPC(Int_t run, Int_t timeStamp, Double_t deltaT, Double_t deltaTLaser, Int_t valType){
- //
- // Get the correction of the trigger offset
- // combining information from the laser track calibration
- // and from cosmic calibration
- //
- // run - run number
- // timeStamp - tim stamp in seconds
- // deltaT - integration period to calculate offset
- // deltaTLaser -max validity of laser data
- // valType - 0 - median, 1- mean
- //
- // Integration vaues are just recomendation - if not possible to get points
- // automatically increase the validity by factor 2
- // (recursive algorithm until one month of data taking)
- //
- //
+ /// Get the correction of the trigger offset
+ /// combining information from the laser track calibration
+ /// and from cosmic calibration
+ ///
+ /// run - run number
+ /// timeStamp - tim stamp in seconds
+ /// deltaT - integration period to calculate offset
+ /// deltaTLaser -max validity of laser data
+ /// valType - 0 - median, 1- mean
+ ///
+ /// Integration vaues are just recomendation - if not possible to get points
+ /// automatically increase the validity by factor 2
+ /// (recursive algorithm until one month of data taking)
+
const Float_t kLaserCut=0.0005;
const Int_t kMaxPeriod=3600*24*30*12; // one year max
const Int_t kMinPoints=20;
}
Double_t AliTPCcalibDButil::GetVDriftTPC(Double_t &dist, Int_t run, Int_t timeStamp, Double_t deltaT, Double_t deltaTLaser, Int_t valType){
- //
- // Get the correction of the drift velocity
- // combining information from the laser track calibration
- // and from cosmic calibration
- //
- // dist - return value - distance to closest point in graph
- // run - run number
- // timeStamp - tim stamp in seconds
- // deltaT - integration period to calculate time0 offset
- // deltaTLaser -max validity of laser data
- // valType - 0 - median, 1- mean
- //
- // Integration vaues are just recomendation - if not possible to get points
- // automatically increase the validity by factor 2
- // (recursive algorithm until one month of data taking)
- //
- //
- //
+ /// Get the correction of the drift velocity
+ /// combining information from the laser track calibration
+ /// and from cosmic calibration
+ ///
+ /// dist - return value - distance to closest point in graph
+ /// run - run number
+ /// timeStamp - tim stamp in seconds
+ /// deltaT - integration period to calculate time0 offset
+ /// deltaTLaser -max validity of laser data
+ /// valType - 0 - median, 1- mean
+ ///
+ /// Integration vaues are just recomendation - if not possible to get points
+ /// automatically increase the validity by factor 2
+ /// (recursive algorithm until one month of data taking)
+
TObjArray *array =AliTPCcalibDB::Instance()->GetTimeVdriftSplineRun(run);
if (!array) {
AliTPCcalibDB::Instance()->UpdateRunInformations(run,kFALSE);
const char* AliTPCcalibDButil::GetGUIRefTreeDefaultName()
{
- //
- // Create a default name for the gui file
- //
-
+ /// Create a default name for the gui file
+
return Form("guiRefTreeRun%s.root",GetRefValidity());
}
Bool_t AliTPCcalibDButil::CreateGUIRefTree(const char* filename)
{
- //
- // Create a gui reference tree
- // if dirname and filename are empty default values will be used
- // this is the recommended way of using this function
- // it allows to check whether a file with the given run validity alredy exists
- //
+ /// Create a gui reference tree
+ /// if dirname and filename are empty default values will be used
+ /// this is the recommended way of using this function
+ /// it allows to check whether a file with the given run validity alredy exists
+
if (!AliCDBManager::Instance()->GetDefaultStorage()){
AliError("Default Storage not set. Cannot create reference calibration Tree!");
return kFALSE;
}
Double_t AliTPCcalibDButil::GetVDriftTPCLaserTracks(Double_t &dist, Int_t run, Int_t timeStamp, Double_t deltaT, Int_t side){
- //
- // Get the correction of the drift velocity using the offline laser tracks calbration
- //
- // run - run number
- // timeStamp - tim stamp in seconds
- // deltaT - integration period to calculate time0 offset
- // side - 0 - A side, 1 - C side, 2 - mean from both sides
- // Note in case no data form both A and C side - the value from active side used
+ /// Get the correction of the drift velocity using the offline laser tracks calbration
+ ///
+ /// run - run number
+ /// timeStamp - tim stamp in seconds
+ /// deltaT - integration period to calculate time0 offset
+ /// side - 0 - A side, 1 - C side, 2 - mean from both sides
+ /// Note in case no data form both A and C side - the value from active side used
+
TObjArray *array =AliTPCcalibDB::Instance()->GetTimeVdriftSplineRun(run);
return GetVDriftTPCLaserTracksCommon(dist, timeStamp, deltaT, side, array);
}
Double_t AliTPCcalibDButil::GetVDriftTPCLaserTracksOnline(Double_t &dist, Int_t /*run*/, Int_t timeStamp, Double_t deltaT, Int_t side){
- //
- // Get the correction of the drift velocity using the online laser tracks calbration
- //
- // run - run number
- // timeStamp - tim stamp in seconds
- // deltaT - integration period to calculate time0 offset
- // side - 0 - A side, 1 - C side, 2 - mean from both sides
- // Note in case no data form both A and C side - the value from active side used
+ /// Get the correction of the drift velocity using the online laser tracks calbration
+ ///
+ /// run - run number
+ /// timeStamp - tim stamp in seconds
+ /// deltaT - integration period to calculate time0 offset
+ /// side - 0 - A side, 1 - C side, 2 - mean from both sides
+ /// Note in case no data form both A and C side - the value from active side used
+
TObjArray *array =AliTPCcalibDB::Instance()->GetCEfitsDrift();
Double_t dv = GetVDriftTPCLaserTracksCommon(dist, timeStamp, deltaT, side, array);
Double_t AliTPCcalibDButil::GetVDriftTPCLaserTracksCommon(Double_t &dist, Int_t timeStamp, Double_t deltaT,
Int_t side, TObjArray * const array){
- //
- // common drift velocity retrieval for online and offline method
- //
+ /// common drift velocity retrieval for online and offline method
+
TGraphErrors *grlaserA=0;
TGraphErrors *grlaserC=0;
Double_t vlaserA=0, vlaserC=0;
Double_t AliTPCcalibDButil::GetVDriftTPCCE(Double_t &dist,Int_t run, Int_t timeStamp, Double_t deltaT, Int_t side){
- //
- // Get the correction of the drift velocity using the CE laser data
- // combining information from the CE, laser track calibration
- // and P/T calibration
- //
- // run - run number
- // timeStamp - tim stamp in seconds
- // deltaT - integration period to calculate time0 offset
- // side - 0 - A side, 1 - C side, 2 - mean from both sides
+ /// Get the correction of the drift velocity using the CE laser data
+ /// combining information from the CE, laser track calibration
+ /// and P/T calibration
+ ///
+ /// run - run number
+ /// timeStamp - tim stamp in seconds
+ /// deltaT - integration period to calculate time0 offset
+ /// side - 0 - A side, 1 - C side, 2 - mean from both sides
+
TObjArray *arrT =AliTPCcalibDB::Instance()->GetCErocTtime();
if (!arrT) return 0;
AliTPCParam *param =AliTPCcalibDB::Instance()->GetParameters();
}
Double_t AliTPCcalibDButil::GetVDriftTPCITS(Double_t &dist, Int_t run, Int_t timeStamp){
- //
- // return drift velocity using the TPC-ITS matchin method
- // return also distance to the closest point
- //
+ /// return drift velocity using the TPC-ITS matchin method
+ /// return also distance to the closest point
+
TObjArray *array =AliTPCcalibDB::Instance()->GetTimeVdriftSplineRun(run);
TGraphErrors *graph=0;
dist=0;
}
Double_t AliTPCcalibDButil::GetTime0TPCITS(Double_t &dist, Int_t run, Int_t timeStamp){
- //
- // Get time dependent time 0 (trigger delay in cm) correction
- // Arguments:
- // timestamp - timestamp
- // run - run number
- //
- // Notice - Extrapolation outside of calibration range - using constant function
- //
+ /// Get time dependent time 0 (trigger delay in cm) correction
+ /// Arguments:
+ /// timestamp - timestamp
+ /// run - run number
+ ///
+ /// Notice - Extrapolation outside of calibration range - using constant function
+
TObjArray *array =AliTPCcalibDB::Instance()->GetTimeVdriftSplineRun(run);
TGraphErrors *graph=0;
dist=0;
Int_t AliTPCcalibDButil::MakeRunList(Int_t startRun, Int_t stopRun){
- //
- // VERY obscure method - we need something in framework
- // Find the TPC runs with temperature OCDB entry
- // cache the start and end of the run
- //
+ /// VERY obscure method - we need something in framework
+ /// Find the TPC runs with temperature OCDB entry
+ /// cache the start and end of the run
+
AliCDBStorage* storage = AliCDBManager::Instance()->GetSpecificStorage("TPC/Calib/Temperature");
if (!storage) storage = AliCDBManager::Instance()->GetDefaultStorage();
if (!storage) return 0;
Int_t AliTPCcalibDButil::FindRunTPC(Int_t itime, Bool_t debug){
- //
- // binary search - find the run for given time stamp
- //
+ /// binary search - find the run for given time stamp
+
Int_t index0 = TMath::BinarySearch(fRuns.fN, fRunsStop.fArray,itime);
Int_t index1 = TMath::BinarySearch(fRuns.fN, fRunsStart.fArray,itime);
Int_t cindex = -1;
TGraph* AliTPCcalibDButil::FilterGraphMedian(TGraph * graph, Float_t sigmaCut,Double_t &medianY){
- //
- // filter outlyer measurement
- // Only points around median +- sigmaCut filtered
+ /// filter outlyer measurement
+ /// Only points around median +- sigmaCut filtered
+
if (!graph) return 0;
Int_t kMinPoints=2;
Int_t npoints0 = graph->GetN();
TGraph* AliTPCcalibDButil::FilterGraphMedianAbs(TGraph * graph, Float_t cut,Double_t &medianY){
- //
- // filter outlyer measurement
- // Only points around median +- cut filtered
+ /// filter outlyer measurement
+ /// Only points around median +- cut filtered
+
if (!graph) return 0;
Int_t kMinPoints=2;
Int_t npoints0 = graph->GetN();
TGraphErrors* AliTPCcalibDButil::FilterGraphMedianErr(TGraphErrors * const graph, Float_t sigmaCut,Double_t &medianY){
- //
- // filter outlyer measurement
- // Only points with normalized errors median +- sigmaCut filtered
- //
+ /// filter outlyer measurement
+ /// Only points with normalized errors median +- sigmaCut filtered
+
Int_t kMinPoints=10;
Int_t npoints0 = graph->GetN();
Int_t npoints=0;
void AliTPCcalibDButil::Sort(TGraph *graph){
- //
- // sort array - neccessay for approx
- //
+ /// sort array - neccessay for approx
+
Int_t npoints = graph->GetN();
Int_t *indexes=new Int_t[npoints];
Double_t *outx=new Double_t[npoints];
delete [] outy;
}
void AliTPCcalibDButil::SmoothGraph(TGraph *graph, Double_t delta){
- //
- // smmoth graph - mean on the interval
- //
+ /// smmoth graph - mean on the interval
+
Sort(graph);
Int_t npoints = graph->GetN();
Double_t *outy=new Double_t[npoints];
}
Double_t AliTPCcalibDButil::EvalGraphConst(TGraph * const graph, Double_t xref){
- //
- // Use constant interpolation outside of range
- //
+ /// Use constant interpolation outside of range
+
if (!graph) {
AliInfoGeneral("AliTPCcalibDButil","AliTPCcalibDButil::EvalGraphConst: 0 pointer\n");
return 0;
}
Double_t AliTPCcalibDButil::EvalGraphConst(AliSplineFit *graph, Double_t xref){
- //
- // Use constant interpolation outside of range also for spline fits
- //
+ /// Use constant interpolation outside of range also for spline fits
+
if (!graph) {
AliInfoGeneral("AliTPCcalibDButil","AliTPCcalibDButil::EvalGraphConst: 0 pointer\n");
return 0;
}
Float_t AliTPCcalibDButil::FilterSensor(AliDCSSensor * sensor, Double_t ymin, Double_t ymax, Double_t maxdy, Double_t sigmaCut){
- //
- // Filter DCS sensor information
- // ymin - minimal value
- // ymax - max value
- // maxdy - maximal deirivative
- // sigmaCut - cut on values and derivative in terms of RMS distribution
- // Return value - accepted fraction
- //
- // Algorithm:
- //
- // 0. Calculate median and rms of values in specified range
- // 1. Filter out outliers - median+-sigmaCut*rms
- // values replaced by median
- //
+ /// Filter DCS sensor information
+ /// ymin - minimal value
+ /// ymax - max value
+ /// maxdy - maximal deirivative
+ /// sigmaCut - cut on values and derivative in terms of RMS distribution
+ /// Return value - accepted fraction
+ ///
+ /// Algorithm:
+ ///
+ /// 0. Calculate median and rms of values in specified range
+ /// 1. Filter out outliers - median+-sigmaCut*rms
+ /// values replaced by median
+
AliSplineFit * fit = sensor->GetFit();
if (!fit) return 0.;
Int_t nknots = fit->GetKnots();
}
Float_t AliTPCcalibDButil::FilterTemperature(AliTPCSensorTempArray *tempArray, Double_t ymin, Double_t ymax, Double_t sigmaCut){
- //
- // Filter temperature array
- // tempArray - array of temperatures -
- // ymin - minimal accepted temperature - default 15
- // ymax - maximal accepted temperature - default 22
- // sigmaCut - values filtered on interval median+-sigmaCut*rms - defaut 5
- // return value - fraction of filtered sensors
+ /// Filter temperature array
+ /// tempArray - array of temperatures -
+ /// ymin - minimal accepted temperature - default 15
+ /// ymax - maximal accepted temperature - default 22
+ /// sigmaCut - values filtered on interval median+-sigmaCut*rms - defaut 5
+ /// return value - fraction of filtered sensors
+
const Double_t kMaxDy=0.1;
Int_t nsensors=tempArray->NumSensors();
if (nsensors==0) return 0.;
void AliTPCcalibDButil::FilterCE(Double_t deltaT, Double_t cutAbs, Double_t cutSigma, TTreeSRedirector * const pcstream){
- //
- // Filter CE data
- // Input parameters:
- // deltaT - smoothing window (in seconds)
- // cutAbs - max distance of the time info to the median (in time bins)
- // cutSigma - max distance (in the RMS)
- // pcstream - optional debug streamer to store original and filtered info
- // Hardwired parameters:
- // kMinPoints =10; // minimal number of points to define the CE
- // kMinSectors=12; // minimal number of sectors to define sideCE
- // Algorithm:
- // 0. Filter almost emty graphs (kMinPoints=10)
- // 1. calculate median and RMS per side
- // 2. Filter graphs - in respect with side medians
- // - cutAbs and cutDelta used
- // 3. Cut in respect wit the graph median - cutAbs and cutRMS used
- // 4. Calculate mean for A side and C side
- //
+ /// Filter CE data
+ /// Input parameters:
+ /// deltaT - smoothing window (in seconds)
+ /// cutAbs - max distance of the time info to the median (in time bins)
+ /// cutSigma - max distance (in the RMS)
+ /// pcstream - optional debug streamer to store original and filtered info
+ /// Hardwired parameters:
+ /// kMinPoints =10; // minimal number of points to define the CE
+ /// kMinSectors=12; // minimal number of sectors to define sideCE
+ /// Algorithm:
+ /// 0. Filter almost emty graphs (kMinPoints=10)
+ /// 1. calculate median and RMS per side
+ /// 2. Filter graphs - in respect with side medians
+ /// - cutAbs and cutDelta used
+ /// 3. Cut in respect wit the graph median - cutAbs and cutRMS used
+ /// 4. Calculate mean for A side and C side
+
const Int_t kMinPoints =10; // minimal number of points to define the CE
const Int_t kMinSectors=12; // minimal number of sectors to define sideCE
const Int_t kMinTime =400; // minimal arrival time of CE
void AliTPCcalibDButil::FilterTracks(Int_t run, Double_t cutSigma, TTreeSRedirector * const pcstream){
- //
- // Filter Drift velocity measurement using the tracks
- // 0. remove outlyers - error based
- // cutSigma
- //
- //
+ /// Filter Drift velocity measurement using the tracks
+ /// 0. remove outlyers - error based
+ /// cutSigma
+
const Int_t kMinPoints=1; // minimal number of points to define value
TObjArray *arrT=AliTPCcalibDB::Instance()->GetTimeVdriftSplineRun(run);
Double_t medianY=0;
Double_t AliTPCcalibDButil::GetLaserTime0(Int_t run, Int_t timeStamp, Int_t deltaT, Int_t side){
- //
- //
- // get laser time offset
- // median around timeStamp+-deltaT
- // QA - chi2 needed for later usage - to be added
- // - currently cut on error
- //
+ /// get laser time offset
+ /// median around timeStamp+-deltaT
+ /// QA - chi2 needed for later usage - to be added
+ /// - currently cut on error
+
Int_t kMinPoints=1;
Double_t kMinDelay=0.01;
Double_t kMinDelayErr=0.0001;
void AliTPCcalibDButil::FilterGoofie(AliDCSSensorArray * goofieArray, Double_t deltaT, Double_t cutSigma, Double_t minVd, Double_t maxVd, TTreeSRedirector * const pcstream){
- //
- // Filter Goofie data
- // goofieArray - points will be filtered
- // deltaT - smmothing time window
- // cutSigma - outler sigma cut in rms
- // minVn, maxVd- range absolute cut for variable vd/pt
- // - to be tuned
- //
- // Ignore goofie if not enough points
- //
+ /// Filter Goofie data
+ /// goofieArray - points will be filtered
+ /// deltaT - smmothing time window
+ /// cutSigma - outler sigma cut in rms
+ /// minVn, maxVd- range absolute cut for variable vd/pt
+ /// - to be tuned
+ ///
+ /// Ignore goofie if not enough points
+
const Int_t kMinPoints = 3;
//
TMatrixD* AliTPCcalibDButil::MakeStatRelKalman(TObjArray * const array, Float_t minFraction, Int_t minStat, Float_t maxvd){
- //
- // Make a statistic matrix
- // Input parameters:
- // array - TObjArray of AliRelKalmanAlign
- // minFraction - minimal ration of accepted tracks
- // minStat - minimal statistic (number of accepted tracks)
- // maxvd - maximal deviation for the 1
- // Output matrix:
- // columns - Mean, Median, RMS
- // row - parameter type (rotation[3], translation[3], drift[3])
+ /// Make a statistic matrix
+ /// Input parameters:
+ /// array - TObjArray of AliRelKalmanAlign
+ /// minFraction - minimal ration of accepted tracks
+ /// minStat - minimal statistic (number of accepted tracks)
+ /// maxvd - maximal deviation for the 1
+ /// Output matrix:
+ /// columns - Mean, Median, RMS
+ /// row - parameter type (rotation[3], translation[3], drift[3])
+
if (!array) return 0;
if (array->GetEntries()<=0) return 0;
// Int_t entries = array->GetEntries();
TObjArray *AliTPCcalibDButil::SmoothRelKalman(TObjArray * const array, const TMatrixD & stat, Bool_t direction, Float_t sigmaCut){
- //
- // Smooth the array of AliRelKalmanAlign - detector alignment and drift calibration)
- // Input:
- // array - input array
- // stat - mean parameters statistic
- // direction -
- // sigmaCut - maximal allowed deviation from mean in terms of RMS
+ /// Smooth the array of AliRelKalmanAlign - detector alignment and drift calibration)
+ /// Input:
+ /// array - input array
+ /// stat - mean parameters statistic
+ /// direction -
+ /// sigmaCut - maximal allowed deviation from mean in terms of RMS
+
if (!array) return 0;
if (array->GetEntries()<=0) return 0;
if (!(&stat)) return 0;
}
TObjArray *AliTPCcalibDButil::SmoothRelKalman(TObjArray * const arrayP, TObjArray * const arrayM){
- //
- // Merge 2 RelKalman arrays
- // Input:
- // arrayP - rel kalman in direction plus
- // arrayM - rel kalman in direction minus
+ /// Merge 2 RelKalman arrays
+ /// Input:
+ /// arrayP - rel kalman in direction plus
+ /// arrayM - rel kalman in direction minus
+
if (!arrayP) return 0;
if (arrayP->GetEntries()<=0) return 0;
if (!arrayM) return 0;
//_____________________________________________________________________________________
TTree* AliTPCcalibDButil::ConnectGainTrees(TString baseDir)
{
- //
- // baseDir: Base directory with the raw Kr calibration trees
- // and the trees from the calibQA
- // it assumes to following structure below:
- // KryptonCalib/<year>/calibKr/calibKr.<year>.<id>.root
- // calibQAdEdx/<year>/calibQA.<year>.<perid>.tree.root
- // map/treeMapping.root
- //
-
+ /// baseDir: Base directory with the raw Kr calibration trees
+ /// and the trees from the calibQA
+ /// it assumes to following structure below:
+ /// KryptonCalib/<year>/calibKr/calibKr.<year>.<id>.root
+ /// calibQAdEdx/<year>/calibQA.<year>.<perid>.tree.root
+ /// map/treeMapping.root
+
// === add main tree, which will be a mapping file ================
TFile *fin = TFile::Open(Form("%s/map/treeMapping.root",baseDir.Data()));
//_____________________________________________________________________________________
TTree* AliTPCcalibDButil::ConnectPulserTrees(TString baseDir, TTree *tMain)
{
- //
- // baseDir: Base directory with Pulser information
- // TTrees are added to the base tree as a friend tree
- //
- // === add the calibPulser trees ======================================
+ /// baseDir: Base directory with Pulser information
+ /// TTrees are added to the base tree as a friend tree
+ ///
+ /// === add the calibPulser trees ======================================
+
TString inputTreesPulserCalib = gSystem->GetFromPipe(Form("ls %s/calibPulser/20*/*.tree.root",baseDir.Data()));
TObjArray *arrInputTreesPulserCalib = inputTreesPulserCalib.Tokenize("\n");
for (Int_t itree=0; itree<arrInputTreesPulserCalib->GetEntriesFast(); ++itree) {
TTree* AliTPCcalibDButil::ConnectDistortionTrees(TString baseDir, TString selection, TTree *tMain){
- //
- // baseDir: Base directory with Distortion information
- // TTrees are added to the base tree as a friend tree
- // If base tree not provide - first tree from list is used as base
- //
- // === add the calibDistortion trees ======================================
- //TString inputTreesDistortionCalib = gSystem->GetFromPipe(Form("ls %s/calibDistortion/20*/*.tree.root",baseDir.Data()));
- // TString baseDir="$NOTES/reconstruction/distortionFit/"; TTree *tMain=0;
- // AliTPCcalibDButil::ConnectDistortionTrees("$NOTES/reconstruction/distortionFit/", "calibTimeResHisto.root", 0);
+ /// baseDir: Base directory with Distortion information
+ /// TTrees are added to the base tree as a friend tree
+ /// If base tree not provide - first tree from list is used as base
+ ///
+ /// === add the calibDistortion trees ======================================
+ /// TString inputTreesDistortionCalib = gSystem->GetFromPipe(Form("ls %s/calibDistortion/20*/*.tree.root",baseDir.Data()));
+ /// TString baseDir="$NOTES/reconstruction/distortionFit/"; TTree *tMain=0;
+ /// AliTPCcalibDButil::ConnectDistortionTrees("$NOTES/reconstruction/distortionFit/", "calibTimeResHisto.root", 0);
TString inputTreesDistortionCalib = "";
if (selection.Contains(".list")){
//_____________________________________________________________________________________
TTree* AliTPCcalibDButil::ConnectCalPadTrees(TString baseDir, TString pattern, TTree *tMain, Bool_t checkAliases)
{
- //
- // baseDir: Base directory with per Pad information
- // TTrees are added to the base tree as a friend tree
- // Example usage
- // TString baseDir="/hera/alice/fsozzi/summarymaps/calib2/"; // prefix directory with calibration with slash at the end
- // TString pattern="QA/*/*root";
- // TTree * tree = AliTPCcalibDButil::ConnectCalPadTrees(baseDir,pattern,0); //create tree and attach calibration as friends
+ /// baseDir: Base directory with per Pad information
+ /// TTrees are added to the base tree as a friend tree
+ /// Example usage
+ /// TString baseDir="/hera/alice/fsozzi/summarymaps/calib2/"; // prefix directory with calibration with slash at the end
+ /// TString pattern="QA/*/*root";
+ /// TTree * tree = AliTPCcalibDButil::ConnectCalPadTrees(baseDir,pattern,0); //create tree and attach calibration as friends
//
// === add the calibPulser trees ======================================
/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
* See cxx source for full Copyright notice */
-///////////////////////////////////////////////////////////////////////////////
-// //
-// Class providing the calculation of derived quantities (mean,rms,fits,...) //
-// of calibration entries //
-// //
-///////////////////////////////////////////////////////////////////////////////
+/// \class AliTPCcalibDButil
+/// \brief Class providing the calculation of derived quantities (mean,rms,fits,...) of calibration entries
#include <TObject.h>
#include <TArrayI.h>
static TTree* ConnectCalPadTrees(TString baseDir, TString pattern, TTree *tMain, Bool_t checkAliases);
private:
- AliTPCcalibDB *fCalibDB; //pointer to calibDB object
- AliTPCCalPad *fPadNoise; //noise information
- AliTPCCalPad *fPedestals; //pedestal information
- AliTPCCalPad *fPulserTmean; //pulser mean time information
- AliTPCCalPad *fPulserTrms; //pulser rms time information
- AliTPCCalPad *fPulserQmean; //pulser mean q information
- AliTPCCalPad *fPulserOutlier; //pulser outlier map
- AliTPCCalPad *fCETmean; //central electrode mean time information
- AliTPCCalPad *fCETrms; //central electrode rms time information
- AliTPCCalPad *fCEQmean; //central electrode mean q information
- AliTPCCalPad *fALTROMasked; //ALTRO masked channels information
+ AliTPCcalibDB *fCalibDB; ///< pointer to calibDB object
+ AliTPCCalPad *fPadNoise; ///< noise information
+ AliTPCCalPad *fPedestals; ///< pedestal information
+ AliTPCCalPad *fPulserTmean; ///< pulser mean time information
+ AliTPCCalPad *fPulserTrms; ///< pulser rms time information
+ AliTPCCalPad *fPulserQmean; ///< pulser mean q information
+ AliTPCCalPad *fPulserOutlier; ///< pulser outlier map
+ AliTPCCalPad *fCETmean; ///< central electrode mean time information
+ AliTPCCalPad *fCETrms; ///< central electrode rms time information
+ AliTPCCalPad *fCEQmean; ///< central electrode mean q information
+ AliTPCCalPad *fALTROMasked; ///< ALTRO masked channels information
//
- AliTPCCalibRaw *fCalibRaw; //raw calibration object
+ AliTPCCalibRaw *fCalibRaw; ///< raw calibration object
//
- AliTPCdataQA *fDataQA; //data qa
+ AliTPCdataQA *fDataQA; ///< data qa
//reference data
- TMap *fRefMap; // latest map to reference information
- TMap *fCurrentRefMap; // reference data map of entries currently loaded
- TString fRefValidity; // validity range of reference data
+ TMap *fRefMap; ///< latest map to reference information
+ TMap *fCurrentRefMap; ///< reference data map of entries currently loaded
+ TString fRefValidity; ///< validity range of reference data
//
- AliTPCCalPad *fRefPadNoise; //Reference noise information
- AliTPCCalPad *fRefPedestals; //Reference pedestal information
- AliTPCCalPad *fRefPedestalMasked; //Reference masked channels in pedestal run
- AliTPCCalPad *fRefPulserTmean; //Reference pulser mean time information
- AliTPCCalPad *fRefPulserTrms; //Reference pulser rms time information
- AliTPCCalPad *fRefPulserQmean; //Reference pulser mean q information
- AliTPCCalPad *fRefPulserOutlier; //Reference pulser outlier map
- AliTPCCalPad *fRefPulserMasked; //Reference masked channels in pulser run
- AliTPCCalPad *fRefCETmean; //Reference central electrode mean time information
- AliTPCCalPad *fRefCETrms; //Reference central electrode rms time information
- AliTPCCalPad *fRefCEQmean; //Reference central electrode mean q information
- AliTPCCalPad *fRefCEMasked; //Reference masked channels in laser run
- AliTPCCalPad *fRefALTROFPED; //Reference fixed pedestal value
- AliTPCCalPad *fRefALTROZsThr; //Reference zero suppression threshol
- AliTPCCalPad *fRefALTROAcqStart; //Reference accquistion start time bin
- AliTPCCalPad *fRefALTROAcqStop; //Reference accquistion stop time bin
- AliTPCCalPad *fRefALTROMasked; //Reference ALTRO masked channels information
+ AliTPCCalPad *fRefPadNoise; ///< Reference noise information
+ AliTPCCalPad *fRefPedestals; ///< Reference pedestal information
+ AliTPCCalPad *fRefPedestalMasked; ///< Reference masked channels in pedestal run
+ AliTPCCalPad *fRefPulserTmean; ///< Reference pulser mean time information
+ AliTPCCalPad *fRefPulserTrms; ///< Reference pulser rms time information
+ AliTPCCalPad *fRefPulserQmean; ///< Reference pulser mean q information
+ AliTPCCalPad *fRefPulserOutlier; ///< Reference pulser outlier map
+ AliTPCCalPad *fRefPulserMasked; ///< Reference masked channels in pulser run
+ AliTPCCalPad *fRefCETmean; ///< Reference central electrode mean time information
+ AliTPCCalPad *fRefCETrms; ///< Reference central electrode rms time information
+ AliTPCCalPad *fRefCEQmean; ///< Reference central electrode mean q information
+ AliTPCCalPad *fRefCEMasked; ///< Reference masked channels in laser run
+ AliTPCCalPad *fRefALTROFPED; ///< Reference fixed pedestal value
+ AliTPCCalPad *fRefALTROZsThr; ///< Reference zero suppression threshol
+ AliTPCCalPad *fRefALTROAcqStart; ///< Reference accquistion start time bin
+ AliTPCCalPad *fRefALTROAcqStop; ///< Reference accquistion stop time bin
+ AliTPCCalPad *fRefALTROMasked; ///< Reference ALTRO masked channels information
//
- AliTPCCalibRaw *fRefCalibRaw; //Reference raw calibration object
+ AliTPCCalibRaw *fRefCalibRaw; ///< Reference raw calibration object
//
- AliTPCdataQA *fRefDataQA; //Reference data QA
+ AliTPCdataQA *fRefDataQA; ///< Reference data QA
//
- AliDCSSensorArray* fGoofieArray; //Goofie Data
+ AliDCSSensorArray* fGoofieArray; ///< Goofie Data
//
- AliTPCmapper *fMapper; //TPC mapping handler
- Int_t fNpulserOutliers; //number of outliers from Pulser calibration
+ AliTPCmapper *fMapper; ///< TPC mapping handler
+ Int_t fNpulserOutliers; ///< number of outliers from Pulser calibration
- Float_t fIrocTimeOffset; //timing offset between IROC and OROC in timebins
- Float_t fCETmaxLimitAbs; //maximum variation in CE data before pads will be treated as outliers
- Float_t fPulTmaxLimitAbs; //maximum variation of Pulser Signals (time) before pads will be treated as outliers
- Float_t fPulQmaxLimitAbs; //maximum variation of Pulser Signals (charge) before pads will be treated as outliers
- Float_t fPulQminLimit; //minimum charge value for Pulser Signals before pads will be treated as outliers
+ Float_t fIrocTimeOffset; ///< timing offset between IROC and OROC in timebins
+ Float_t fCETmaxLimitAbs; ///< maximum variation in CE data before pads will be treated as outliers
+ Float_t fPulTmaxLimitAbs; ///< maximum variation of Pulser Signals (time) before pads will be treated as outliers
+ Float_t fPulQmaxLimitAbs; ///< maximum variation of Pulser Signals (charge) before pads will be treated as outliers
+ Float_t fPulQminLimit; ///< minimum charge value for Pulser Signals before pads will be treated as outliers
//
// helpers to get the run number for given time stamps
//
// filters
- TArrayI fRuns; // run list with OCDB info
- TArrayI fRunsStart; // start time for given run
- TArrayI fRunsStop; // stop time for given run
+ TArrayI fRuns; ///< run list with OCDB info
+ TArrayI fRunsStart; ///< start time for given run
+ TArrayI fRunsStop; ///< stop time for given run
AliTPCcalibDButil (const AliTPCcalibDButil& );
AliTPCcalibDButil& operator= (const AliTPCcalibDButil& );
static Double_t GetVDriftTPCLaserTracksCommon(Double_t &dist, Int_t timeStamp, Double_t deltaT, Int_t side, TObjArray * const array);
+ /// \cond CLASSIMP
ClassDef(AliTPCcalibDButil,0)
+ /// \endcond
};
* provided "as is" without express or implied warranty. *
**************************************************************************/
-//-------------------------------------------------------
-// Implementation of the TPC cluster debug information
-//
-// Origin: Marian Ivanov Marian.Ivanov@cern.ch
-//
-// Additional cluster information to monitor clustering performance
-// and to extract a features of detector response
-// Information attached to the default cluster
-// ONLY in DEBUG MODE
-//
-//-------------------------------------------------------
-
-/* $Id$ */
+/// \class AliTPCclusterInfo
+/// \brief Implementation of the TPC cluster debug information
+///
+/// Additional cluster information to monitor clustering performance
+/// and to extract a features of detector response
+/// Information attached to the default cluster
+/// ONLY in DEBUG MODE
+///
+/// \author Marian Ivanov Marian.Ivanov@cern.ch
#include "AliTPCclusterInfo.h"
#include "AliLog.h"
+/// \cond CLASSIMP
ClassImp(AliTPCclusterInfo)
+/// \endcond
AliTPCclusterInfo::AliTPCclusterInfo():
{
//
// default constructor
- //
+ //
for (Int_t i=0; i<25;i++){
- fMatrix[i] = i;
+ fMatrix[i] = i;
}
}
fNPads(info.fNPads),
fNTimeBins(info.fNTimeBins),
fNBins(info.fNBins),
- fGraph(0)
+ fGraph(0)
{
- //
- // copy constructor
- //
- // AliInfo("Copy constructor\n");
+ /// copy constructor
+
+ // AliInfo("Copy constructor\n");
for (Int_t i=0; i<25;i++){
- fMatrix[i] = info.fMatrix[i];
+ fMatrix[i] = info.fMatrix[i];
}
if (info.fGraph) {
fGraph = new Float_t[fNBins];
fNBins(0),
fGraph(0)
{
- //
- // allocate dummy graph - neccessary for IO part to use automatic branching
- //
+ /// allocate dummy graph - neccessary for IO part to use automatic branching
+
for (Int_t i=0; i<25;i++){
- fMatrix[i] = i;
+ fMatrix[i] = i;
}
if (extend){
fNBins = 1;
fNBins(0),
fGraph(0)
{
- //
- // constructor of the info
- //
+ /// constructor of the info
+
for (Int_t i=0;i<25;i++){
fMatrix[i]=matrix[i];
}
}
AliTPCclusterInfo& AliTPCclusterInfo::operator=(const AliTPCclusterInfo& info){
- //
- // assignment operator
- //
+ /// assignment operator
+
if (this == &info) return (*this);
for (Int_t i=0; i<25;i++){
- fMatrix[i] = info.fMatrix[i];
+ fMatrix[i] = info.fMatrix[i];
}
if (info.fGraph) {
if (fGraph) delete []fGraph;
for (Int_t i=0;i<fNBins; i++){
fGraph[i] = info.fGraph[i];
}
- }
+ }
return *this;
}
-UChar_t AliTPCclusterInfo::GetNPads(Float_t threshold) const {
- //
- //
+UChar_t AliTPCclusterInfo::GetNPads(Float_t threshold) const {
+ ///
+
Int_t nPads=0;
Int_t center = 5+5+2;
for (Int_t i=-2; i<=2;i++) if (fMatrix[center+i*5]>threshold) nPads++;
return nPads;
}
-UChar_t AliTPCclusterInfo::GetNTimeBins(Float_t threshold) const {
- //
- //
- //
+UChar_t AliTPCclusterInfo::GetNTimeBins(Float_t threshold) const {
+ ///
+
Int_t nTimeBins=0;
Int_t center = 5+5+2;
for (Int_t i=-2; i<=2;i++) if (fMatrix[center+i]>threshold) nTimeBins++;
AliTPCclusterInfo::~AliTPCclusterInfo(){
- //
- // destructor
- //
+ /// destructor
+
if (fGraph) delete [] fGraph;
}
#ifndef ALITPCCLUSTERINFO_H
#define ALITPCCLUSTERINFO_H
-//-------------------------------------------------------
-// TPC Cluster Class
-// Information for debugging puposes
-// Origin: Marian Ivanov
-//-------------------------------------------------------
+/// \class AliTPCclusterInfo
+/// \brief TPC Cluster Class
+///
+/// Information for debugging puposes
+///
+/// \author Marian Ivanov
/* $Id$ */
void SetGraph(Float_t * graph, Int_t nbins){ fGraph = graph; fNBins=nbins;}
void SetNPadsTimes(UChar_t npads, UChar_t ntimes){ fNPads = npads; fNTimeBins = ntimes;}
protected:
- Float_t fMatrix[25]; // matrix of amplitude arround center pad - time
- UChar_t fNPads; // number of pads in cluster
- UChar_t fNTimeBins; // number of time bins in cluster
- Int_t fNBins; // number of bins in graph
- Float_t *fGraph; //[fNBins] signal time dependence graph
+ Float_t fMatrix[25]; ///< matrix of amplitude arround center pad - time
+ UChar_t fNPads; ///< number of pads in cluster
+ UChar_t fNTimeBins; ///< number of time bins in cluster
+ Int_t fNBins; ///< number of bins in graph
+ /// signal time dependence graph
+ Float_t *fGraph; //[fNBins]
private:
- ClassDef(AliTPCclusterInfo,1) // Time Projection Chamber clusters Inofrmation
+ /// \cond CLASSIMP
+ ClassDef(AliTPCclusterInfo,1) // Time Projection Chamber clusters Inofrmation
+ /// \endcond
};
* provided "as is" without express or implied warranty. *
**************************************************************************/
-//-------------------------------------------------------
-// Implementation of the TPC cluser
-//
-// Origin: Marian Ivanov Marian.Ivanov@cern.ch
-//
-// AliTPC parallel tracker -
-// Description of this class together with its intended usage
-// will follow shortly
-//
-//-------------------------------------------------------
+/// \class AliTPCclusterMI
+/// \brief Implementation of the TPC cluser
+///
+/// AliTPC parallel tracker -
+/// Description of this class together with its intended usage
+/// will follow shortly
+///
+/// \author Marian Ivanov Marian.Ivanov@cern.ch
/* $Id$ */
#include "AliGeomManager.h"
#include "AliLog.h"
+/// \cond CLASSIMP
ClassImp(AliTPCclusterMI)
+/// \endcond
AliTPCclusterMI::AliTPCclusterMI():
fInfo(0),
fTimeBin(0), //time bin coordinate
fPad(0), //pad coordinate
- fQ(0), //Q of cluster (in ADC counts)
+ fQ(0), //Q of cluster (in ADC counts)
fMax(0), //maximal amplitude in cluster
- fType(0), //type of the cluster 0 means golden
- fUsed(0), //counter of usage
+ fType(0), //type of the cluster 0 means golden
+ fUsed(0), //counter of usage
fDetector(0), //detector number
fRow(0) //row number number
{
fDetector(cluster.fDetector),
fRow(cluster.fRow)
{
- //
- // copy constructor
- //
- // AliInfo("Copy constructor\n");
+ /// copy constructor
+
+ // AliInfo("Copy constructor\n");
+
if (cluster.fInfo) fInfo = new AliTPCclusterInfo(*(cluster.fInfo));
}
AliTPCclusterMI & AliTPCclusterMI::operator = (const AliTPCclusterMI & cluster)
{
- //
- // assignment operator
- //
- // AliInfo("Asignment operator\n");
+ /// assignment operator
+
+ // AliInfo("Asignment operator\n");
+
if (this == &cluster) return (*this);
(AliCluster&)(*this) = (AliCluster&)cluster;
-AliTPCclusterMI::AliTPCclusterMI(Int_t *lab, Float_t *hit) :
+AliTPCclusterMI::AliTPCclusterMI(Int_t *lab, Float_t *hit) :
AliCluster(0,hit,0.,0.,lab),
fInfo(0),
fTimeBin(0), //time bin coordinate
fPad(0), //pad coordinate
- fQ(0), //Q of cluster (in ADC counts)
+ fQ(0), //Q of cluster (in ADC counts)
fMax(0), //maximal amplitude in cluster
- fType(0), //type of the cluster 0 means golden
- fUsed(0), //counter of usage
+ fType(0), //type of the cluster 0 means golden
+ fUsed(0), //counter of usage
fDetector(0), //detector number
fRow(0) //row number number
{
- //
- // constructor
- //
+ /// constructor
+
fQ = (UShort_t)hit[4];
fInfo = 0;
}
AliTPCclusterMI::~AliTPCclusterMI() {
- //
- // destructor
- //
+ /// destructor
+
if (fInfo) delete fInfo;
fInfo = 0;
}
Bool_t AliTPCclusterMI::IsSortable() const
{
- //
- //
+ ///
+
return kTRUE;
}
Int_t AliTPCclusterMI::Compare(const TObject* obj) const
{
- //
- // compare according y
+ /// compare according y
+
AliTPCclusterMI * o2 = (AliTPCclusterMI*)obj;
- return (o2->GetY()>GetY())? -1:1;
+ return (o2->GetY()>GetY())? -1:1;
}
void AliTPCclusterMI::SetDetector(Int_t detector){
- //
- // set volume ID
- //
+ /// set volume ID
+
fDetector = (UChar_t)(detector%72);
- AliGeomManager::ELayerID id = (fDetector<36) ?
+ AliGeomManager::ELayerID id = (fDetector<36) ?
AliGeomManager::kTPC1 :AliGeomManager::kTPC2 ;
Int_t modId = (fDetector<36)?fDetector: fDetector-36;
- SetVolumeId(AliGeomManager::LayerToVolUID(id,modId));
+ SetVolumeId(AliGeomManager::LayerToVolUID(id,modId));
}
void AliTPCclusterMI::SetInfo(AliTPCclusterInfo * info) {
- //
- //
- //
+ ///
+
if (fInfo) delete fInfo;
fInfo = info;
}
AliTPCclusterMI* AliTPCclusterMI::MakeCluster(AliTrackPoint* /*point*/) {
- //
- // make AliTPCclusterMI out of AliTrackPoint
- // (not yet implemented)
-
+ /// make AliTPCclusterMI out of AliTrackPoint
+ /// (not yet implemented)
+
return NULL;
}
AliTrackPoint* AliTPCclusterMI::MakePoint() {
- //
- // make AliTrackPoint out of AliTPCclusterMI
- //
+ /// make AliTrackPoint out of AliTPCclusterMI
AliTrackPoint* point = new AliTrackPoint();
Float_t xyz[3]={0.};
//______________________________________________________________________________
void AliTPCclusterMI::SetGlobalTrackPoint( const AliCluster &cl, AliTrackPoint &point )
{
- //
- // Set global AliTrackPoint
- //
-
+ /// Set global AliTrackPoint
+
Float_t xyz[3]={0.};
Float_t cov[6]={0.};
cl.GetGlobalXYZ(xyz);
#ifndef ALITPCCLUSTERMI_H
#define ALITPCCLUSTERMI_H
-//-------------------------------------------------------
-// TPC Cluster Class
-// Parallel tracking
-// Origin: Marian Ivanov
-//-------------------------------------------------------
+/// \class AliTPCclusterMI
+/// \brief TPC Cluster Class
+///
+/// Parallel tracking
+///
+/// \author Marian Ivanov
/* $Id$ */
AliTPCclusterMI(Int_t *lab, Float_t *hit);
virtual ~AliTPCclusterMI();
virtual void Clear(const Option_t*) { delete fInfo; fInfo=0;}
- virtual Bool_t IsSortable() const;
+ virtual Bool_t IsSortable() const;
virtual Int_t Compare(const TObject* obj) const;
inline void Use(Int_t inc=10);
inline void Disable(){fUsed=kDisabled;}
virtual Int_t GetDetector() const {return fDetector;}
virtual Int_t GetRow() const {return fRow;}
virtual void SetDetector(Int_t detector);
- virtual void SetRow(Int_t row){fRow = (UChar_t)(row%256);}
+ virtual void SetRow(Int_t row){fRow = (UChar_t)(row%256);}
virtual void SetTimeBin(Float_t timeBin){ fTimeBin= timeBin;}
virtual void SetPad(Float_t pad){ fPad = pad;}
//
void SetMax(UShort_t max) {fMax=max;}
Int_t IsUsed(Int_t th=10) const {return (fUsed>=th) ? 1 : 0;}
Float_t GetQ() const {return TMath::Abs(fQ);}
- Float_t GetMax() const {return fMax;}
+ Float_t GetMax() const {return fMax;}
Char_t GetType()const {return fType;}
Float_t GetTimeBin() const { return fTimeBin;}
Float_t GetPad() const { return fPad;}
AliTPCclusterMI* MakeCluster(AliTrackPoint* point);
AliTrackPoint* MakePoint();
static void SetGlobalTrackPoint(const AliCluster &cl, AliTrackPoint &point);
-
+
private:
- AliTPCclusterInfo * fInfo; // pointer to the cluster debug info
- Float_t fTimeBin; //time bin coordinate
- Float_t fPad; //pad coordinate
- Short_t fQ ; //Q of cluster (in ADC counts)
- Short_t fMax; //maximal amplitude in cluster
- Char_t fType; //type of the cluster 0 means golden
- Char_t fUsed; //counter of usage
- UChar_t fDetector; //detector number
- UChar_t fRow; //row number number
+ AliTPCclusterInfo * fInfo; ///< pointer to the cluster debug info
+ Float_t fTimeBin; ///< time bin coordinate
+ Float_t fPad; ///< pad coordinate
+ Short_t fQ ; ///< Q of cluster (in ADC counts)
+ Short_t fMax; ///< maximal amplitude in cluster
+ Char_t fType; ///< type of the cluster 0 means golden
+ Char_t fUsed; ///< counter of usage
+ UChar_t fDetector; ///< detector number
+ UChar_t fRow; ///< row number number
+ /// \cond CLASSIMP
ClassDef(AliTPCclusterMI,5) // Time Projection Chamber clusters
+ /// \endcond
};
-void AliTPCclusterMI::Use(Int_t inc)
-{
- if (inc>0) fUsed+=inc;
- else
+void AliTPCclusterMI::Use(Int_t inc)
+{
+ if (inc>0) fUsed+=inc;
+ else
fUsed=0;
}
* provided "as is" without express or implied warranty. *
**************************************************************************/
-
-/* $Id$ */
-
-/*
- July 2011:
-
- Changes to accomodate updates of general DQM/QA changes to have per trigger
- histograms (for a given event specie).
-
- AliTPCdataQA has a new flag for only keeping DQM info event by
- event!
- The expert/DA functionality has been kept exactly the same!
-
-
- June 2010
-
- This update should solve two problems mainly:
- * The vs event histograms have been limited to a fixed size for the
- DQM. The 500k seemed to be a big size but is no longer so, so we
- need to dynamically expand the range. The non-trivial point is that
- we also have to do it for the copy owned by AliTPCQADataMakerRec.
- * The amoreGui now remembers the x-range of the first visualization so
- the trick of setting the relevant event range as the histogram is
- filled no longer works.
-
- The fix is a bit crude but avoids creating a new histogram. Instead
- the range is expanded (max events and events per bin is doubled) but
- the number of bins is kept constant! In this way we can change just
- double the max of the X-axis of the hist and rebin the data. The
- same can easily be done for the copy owned by AliTPCQADataMakerRec.
-
- CAUTION:
- If we change the number of bins we could crash the whole system
- because ROOT does not create space for extra bins! (but we do not do
- this). In that way it is a crude solution.
- The rebinning in the code only works for an even number of bins.
-
- In addition to the above a bug in the reading of the config file was
- also found and corrected. fAdcMax was set instead of fEventsPerBin.
-
- Finally cout was changes to AliInfo.
-
- February 2008
-
- The code has been heavily modified so that now the RAW data is
- "expanded" for each sector and stored in a big signal array. Then a
- simple version of the code in AliTPCclusterer is used to identify
- the local maxima and these are then used for QA. This gives a better
- estimate of the charge (both max and total) and also limits the
- effect of noise.
-
- Implementation:
-
- In Update the RAW signals >= 3 ADC channels are stored in the arrays.
-
- There are 3 arrays:
- Float_t** fAllBins 2d array [row][bin(pad, time)] ADC signal
- Int_t** fAllSigBins 2d array [row][signal#] bin(with signal)
- Int_t* fAllNSigBins; 1d array [row] Nsignals
-
- This is done sector by sector.
-
- When data from a new sector is encountered, the method
- FindLocalMaxima is called on the data from the previous sector, and
- the calibration/data objects are updated with the "cluster"
- info. Finally the arrays are cleared.
-
- The requirements for a local maxima is:
- Charge in bin is >= 5 ADC channels.
- Charge in bin is larger than all the 8 neighboring bins.
- At least one of the two pad neighbors has a signal.
- At least one of the two time neighbors has a signal.
-
- Before accessing the data it is expected that the Analyse method is
- called. This normalizes some of the data objects to per event or per
- cluster.
- If more data is passed to the class after Analyse has been called
- the normalization is reversed and Analyse has to be called again.
-*/
-
+/// \class AliTPCdataQA
+///
+/// July 2011:
+///
+/// Changes to accomodate updates of general DQM/QA changes to have per trigger
+/// histograms (for a given event specie).
+///
+/// AliTPCdataQA has a new flag for only keeping DQM info event by
+/// event!
+/// The expert/DA functionality has been kept exactly the same!
+///
+///
+/// June 2010
+///
+/// This update should solve two problems mainly:
+/// * The vs event histograms have been limited to a fixed size for the
+/// DQM. The 500k seemed to be a big size but is no longer so, so we
+/// need to dynamically expand the range. The non-trivial point is that
+/// we also have to do it for the copy owned by AliTPCQADataMakerRec.
+/// * The amoreGui now remembers the x-range of the first visualization so
+/// the trick of setting the relevant event range as the histogram is
+/// filled no longer works.
+///
+/// The fix is a bit crude but avoids creating a new histogram. Instead
+/// the range is expanded (max events and events per bin is doubled) but
+/// the number of bins is kept constant! In this way we can change just
+/// double the max of the X-axis of the hist and rebin the data. The
+/// same can easily be done for the copy owned by AliTPCQADataMakerRec.
+///
+/// CAUTION:
+/// If we change the number of bins we could crash the whole system
+/// because ROOT does not create space for extra bins! (but we do not do
+/// this). In that way it is a crude solution.
+/// The rebinning in the code only works for an even number of bins.
+///
+/// In addition to the above a bug in the reading of the config file was
+/// also found and corrected. fAdcMax was set instead of fEventsPerBin.
+///
+/// Finally cout was changes to AliInfo.
+///
+/// February 2008
+///
+/// The code has been heavily modified so that now the RAW data is
+/// "expanded" for each sector and stored in a big signal array. Then a
+/// simple version of the code in AliTPCclusterer is used to identify
+/// the local maxima and these are then used for QA. This gives a better
+/// estimate of the charge (both max and total) and also limits the
+/// effect of noise.
+///
+/// Implementation:
+///
+/// In Update the RAW signals >= 3 ADC channels are stored in the arrays.
+/// There are 3 arrays:
+///
+/// ~~~{.cpp}
+/// Float_t** fAllBins 2d array [row][bin(pad, time)] ADC signal
+/// Int_t** fAllSigBins 2d array [row][signal#] bin(with signal)
+/// Int_t* fAllNSigBins; 1d array [row] Nsignals
+/// ~~~
+///
+/// This is done sector by sector.
+///
+/// When data from a new sector is encountered, the method
+/// FindLocalMaxima is called on the data from the previous sector, and
+/// the calibration/data objects are updated with the "cluster"
+/// info. Finally the arrays are cleared.
+///
+/// The requirements for a local maxima is:
+/// Charge in bin is >= 5 ADC channels.
+/// Charge in bin is larger than all the 8 neighboring bins.
+/// At least one of the two pad neighbors has a signal.
+/// At least one of the two time neighbors has a signal.
+///
+/// Before accessing the data it is expected that the Analyse method is
+/// called. This normalizes some of the data objects to per event or per
+/// cluster.
+/// If more data is passed to the class after Analyse has been called
+/// the normalization is reversed and Analyse has to be called again.
//Root includes
#include <TH1F.h>
#include "AliLog.h"
+/// \cond CLASSIMP
ClassImp(AliTPCdataQA)
+/// \endcond
-AliTPCdataQA::AliTPCdataQA() : /*FOLD00*/
+AliTPCdataQA::AliTPCdataQA() : /*FOLD00*/
fFirstTimeBin(60),
fLastTimeBin(1000),
fAdcMin(3),
fOccVecFine(0x0),
fOccMaxVecFine(0x0)
{
- //
- // copy constructor
- //
+ /// copy constructor
+
if(ped.GetNLocalMaxima())
fNLocalMaxima = new AliTPCCalPad(*ped.GetNLocalMaxima());
if(ped.GetMaxCharge())
}
//_____________________________________________________________________
-AliTPCdataQA::AliTPCdataQA(const TMap *config) : /*FOLD00*/
+AliTPCdataQA::AliTPCdataQA(const TMap *config) : /*FOLD00*/
TH1F("TPCRAW","TPCRAW",100,0,100),
fFirstTimeBin(60),
fLastTimeBin(1000),
fOccVecFine(0x0),
fOccMaxVecFine(0x0)
{
- //
- // default constructor
- //
+ /// default constructor
+
if (config->GetValue("FirstTimeBin")) fFirstTimeBin = ((TObjString*)config->GetValue("FirstTimeBin"))->GetString().Atoi();
if (config->GetValue("LastTimeBin")) fLastTimeBin = ((TObjString*)config->GetValue("LastTimeBin"))->GetString().Atoi();
if (config->GetValue("AdcMin")) fAdcMin = ((TObjString*)config->GetValue("AdcMin"))->GetString().Atoi();
//_____________________________________________________________________
AliTPCdataQA& AliTPCdataQA::operator = (const AliTPCdataQA &source)
{
- //
- // assignment operator
- //
+ /// assignment operator
+
if (&source == this) return *this;
new (this) AliTPCdataQA(source);
//_____________________________________________________________________
AliTPCdataQA::~AliTPCdataQA() /*FOLD00*/
{
- //
- // destructor
- //
+ /// destructor
// do not delete fMapping, because we do not own it.
// do not delete fMapping, because we do not own it.
delete fOccMaxVec;
delete fOccVecFine;
delete fOccMaxVecFine;
-
+
for (Int_t iRow = 0; iRow < fRowsMax; iRow++) {
delete [] fAllBins[iRow];
delete [] fAllSigBins[iRow];
- }
+ }
delete [] fAllBins;
delete [] fAllSigBins;
delete [] fAllNSigBins;
//_____________________________________________________________________
TH1F* AliTPCdataQA::GetHistOccupancyVsEvent()
{
- //
- // Create Occupancy vs event histogram
- // (we create this histogram differently then the other histograms
- // because this we want to be able to access and copy
- // from AliTPCQAMakerRec before it normally would be created)
- //
+ /// Create Occupancy vs event histogram
+ /// (we create this histogram differently then the other histograms
+ /// because this we want to be able to access and copy
+ /// from AliTPCQAMakerRec before it normally would be created)
+
if(!fHistOccupancyVsEvent) {
Int_t nBins = fMaxEvents/fEventsPerBin;
fHistOccupancyVsEvent = new TH1F("hOccupancyVsEvent", "Occupancy vs event number (~time); Event number; Occupancy", nBins, 0, nBins*fEventsPerBin);
fHistOccupancyVsEvent->SetDirectory(0);
}
-
+
return fHistOccupancyVsEvent;
}
//_____________________________________________________________________
TH1F* AliTPCdataQA::GetHistNclustersVsEvent()
{
- //
- // Create Nclusters vs event histogram
- // (we create this histogram differently then the other histograms
- // because this we want to be able to access and copy
- // from AliTPCQAMakerRec before it normally would be created)
- //
+ /// Create Nclusters vs event histogram
+ /// (we create this histogram differently then the other histograms
+ /// because this we want to be able to access and copy
+ /// from AliTPCQAMakerRec before it normally would be created)
+
if(!fHistNclustersVsEvent) {
Int_t nBins = fMaxEvents/fEventsPerBin;
fHistNclustersVsEvent = new TH1F("hNclustersVsEvent", "Nclusters vs event number (~time); Event number; Nclusters per event", nBins, 0, nBins*fEventsPerBin);
fHistNclustersVsEvent->SetDirectory(0);
}
-
+
return fHistNclustersVsEvent;
}
//_____________________________________________________________________
void AliTPCdataQA::UpdateEventHistograms()
{
- // Update histograms that display occupancy and
- // number of clusters as a function of number of
- // events
+ /// Update histograms that display occupancy and
+ /// number of clusters as a function of number of
+ /// events
+
if (!fHistOccupancyVsEvent)
GetHistOccupancyVsEvent();
if (!fHistNclustersVsEvent)
GetHistNclustersVsEvent();
-
+
if(fEventCounter > fMaxEvents) {
-
+
// we have to expand the histogram to handle the larger number of
// events. The way it is done now is to double the range and the
// number of events per bin (so the number of histogram bins stays
Int_t newBin = TMath::Nint(Float_t(bin+1)/2.0);
Float_t newContent = (fHistOccupancyVsEvent->GetBinContent(bin)+
fHistOccupancyVsEvent->GetBinContent(bin+1))/2.0;
- fHistOccupancyVsEvent->SetBinContent(newBin, newContent);
+ fHistOccupancyVsEvent->SetBinContent(newBin, newContent);
newContent = (fHistNclustersVsEvent->GetBinContent(bin)+
fHistNclustersVsEvent->GetBinContent(bin+1))/2.0;
- fHistNclustersVsEvent->SetBinContent(newBin, newContent);
+ fHistNclustersVsEvent->SetBinContent(newBin, newContent);
}
// Set the remaining bins to 0
Int_t lastHalf = nBins/2 +1;
for(Int_t bin = lastHalf; bin <= nBins; bin++) {
- fHistOccupancyVsEvent->SetBinContent(bin, 0);
- fHistNclustersVsEvent->SetBinContent(bin, 0);
+ fHistOccupancyVsEvent->SetBinContent(bin, 0);
+ fHistNclustersVsEvent->SetBinContent(bin, 0);
}
// In this case we should nut update but wait untill the new
/ 570132.0; // 570,132 is number of pads
fHistOccupancyVsEvent->SetBinContent(bin, averageOccupancy);
fSignalCounter = 0;
-
+
Float_t averageNclusters =
Float_t(fClusterCounter)/fEventsPerBin;
fHistNclustersVsEvent->SetBinContent(bin, averageNclusters);
//_____________________________________________________________________
Bool_t AliTPCdataQA::ProcessEvent(AliTPCRawStreamV3 *const rawStreamV3)
{
- //
- // Event Processing loop - AliTPCRawStreamV3
- //
+ /// Event Processing loop - AliTPCRawStreamV3
+
Bool_t withInput = kFALSE;
Int_t nSignals = 0;
Int_t lastSector = -1;
Init();
-
+
while ( rawStreamV3->NextDDL() ){
while ( rawStreamV3->NextChannel() ){
-
+
Int_t iSector = rawStreamV3->GetSector(); // current sector
Int_t iRow = rawStreamV3->GetRow(); // current row
Int_t iPad = rawStreamV3->GetPad(); // current pad
if (iRow<0 || iPad<0) continue;
// Call local maxima finder if the data is in a new sector
if(iSector != lastSector) {
-
+
if(nSignals>0)
FindLocalMaxima(lastSector);
-
+
CleanArrays();
lastSector = iSector;
nSignals = 0;
}
-
+
while ( rawStreamV3->NextBunch() ){
Int_t startTbin = (Int_t)rawStreamV3->GetStartTimeBin();
Int_t bunchlength = (Int_t)rawStreamV3->GetBunchLength();
const UShort_t *sig = rawStreamV3->GetSignals();
-
+
for (Int_t iTimeBin = 0; iTimeBin<bunchlength; iTimeBin++){
Float_t signal=(Float_t)sig[iTimeBin];
nSignals += Update(iSector,iRow,iPad,startTbin--,signal, iPatch, iBranch);
}
}
}
-
- if (lastSector>=0&&nSignals>0)
+
+ if (lastSector>=0&&nSignals>0)
FindLocalMaxima(lastSector);
CleanArrays();
-
+
return withInput;
}
//_____________________________________________________________________
Bool_t AliTPCdataQA::ProcessEvent(AliRawReader *const rawReader)
{
- //
- // Event processing loop - AliRawReader
- //
+ /// Event processing loop - AliRawReader
+
AliTPCRawStreamV3 rawStreamV3(rawReader,(AliAltroMapping**)fMapping);
Bool_t res=ProcessEvent(&rawStreamV3);
if(res) {
fEventCounter++; // only increment event counter if there is TPC data
- if(fEventCounter%fEventsPerBin==0)
+ if(fEventCounter%fEventsPerBin==0)
UpdateEventHistograms();
}
return res;
//_____________________________________________________________________
Bool_t AliTPCdataQA::ProcessEvent(eventHeaderStruct *const event)
{
- //
- // process date event
- //
+ /// process date event
AliRawReaderDate rawReader((void*)event);
Bool_t result=ProcessEvent(&rawReader);
//_____________________________________________________________________
void AliTPCdataQA::DumpToFile(const Char_t *filename, const Char_t *dir, Bool_t append) /*FOLD00*/
{
- //
- // Write class to file
- //
+ /// Write class to file
TString sDir(dir);
TString option;
const Int_t iPatch,
const Int_t iBranch)
{
- //
- // Signal filling method
- //
-
+ /// Signal filling method
+
if (!fActiveChambers[iSector]) return 0;
//
// TimeBin cut
//
if (iTimeBin<fFirstTimeBin) return 0;
if (iTimeBin>fLastTimeBin) return 0;
-
+
// if pedestal calibrations are loaded subtract pedestals
if(fPedestal) {
return 0;
signal -= ped;
}
-
+
if(fIsDQM) {
fOccVec->GetArray()[iSector] += 1.0;
// if noise calibrations are loaded require at least 3*sigmaNoise
if(fNoise) {
-
+
Float_t noise = fNoise->GetCalROC(iSector)->GetValue(iRow, iPad);
-
+
if(signal < noise*3.0)
return 0;
}
SetExpandDigit(iRow, iPad, iTimeBin, signal);
fSignalCounter++;
-
+
return 1; // signal was accepted
}
//_____________________________________________________________________
void AliTPCdataQA::FindLocalMaxima(const Int_t iSector)
{
- //
- // This method is called after the data from each sector has been
- // exapanded into an array
- // Loop over the signals and identify local maxima and fill the
- // calibration objects with the information
- //
+ /// This method is called after the data from each sector has been
+ /// exapanded into an array
+ /// Loop over the signals and identify local maxima and fill the
+ /// calibration objects with the information
if (!fActiveChambers[iSector]) return;
-
+
Int_t nLocalMaxima = 0;
- const Int_t maxTimeBin = fTimeBinsMax+4; // Used to step between neighboring pads
- // Because we have tha pad-time data in a
+ const Int_t maxTimeBin = fTimeBinsMax+4; // Used to step between neighboring pads
+ // Because we have tha pad-time data in a
// 1d array
for (Int_t iRow = 0; iRow < fRowsMax; iRow++) {
Float_t* allBins = fAllBins[iRow];
Int_t* sigBins = fAllSigBins[iRow];
const Int_t nSigBins = fAllNSigBins[iRow];
-
+
for (Int_t iSig = 0; iSig < nSigBins; iSig++) {
Int_t bin = sigBins[iSig];
Float_t qMax = b[0];
// First check that the charge is bigger than the threshold
- if (qMax<fMinQMax)
+ if (qMax<fMinQMax)
continue;
-
+
// Require at least one neighboring pad with signal
if (fRequireNeighbouringPad && (b[-maxTimeBin]+b[maxTimeBin]<=0) ) continue;
// Require at least one neighboring time bin with signal
if (b[-1]+b[1]<=0) continue;
-
+
//
// Check that this is a local maximum
// Note that the checking is done so that if 2 charges has the same
- // qMax then only 1 cluster is generated
+ // qMax then only 1 cluster is generated
// (that is why there is BOTH > and >=)
//
if (b[-maxTimeBin] >= qMax) continue;
- if (b[-1 ] >= qMax) continue;
- if (b[+maxTimeBin] > qMax) continue;
- if (b[+1 ] > qMax) continue;
+ if (b[-1 ] >= qMax) continue;
+ if (b[+maxTimeBin] > qMax) continue;
+ if (b[+1 ] > qMax) continue;
if (b[-maxTimeBin-1] >= qMax) continue;
- if (b[+maxTimeBin-1] >= qMax) continue;
- if (b[+maxTimeBin+1] > qMax) continue;
+ if (b[+maxTimeBin-1] >= qMax) continue;
+ if (b[+maxTimeBin+1] > qMax) continue;
if (b[-maxTimeBin+1] >= qMax) continue;
-
+
//
// Now we accept the local maximum and fill the calibration/data objects
//
Int_t iPad, iTimeBin;
GetPadAndTimeBin(bin, iPad, iTimeBin);
-
+
if(!fIsDQM) {
Float_t count = fNLocalMaxima->GetCalROC(iSector)->GetValue(iRow, iPad);
fNLocalMaxima->GetCalROC(iSector)->SetValue(iRow, iPad, count+1);
-
+
count = fTimePosition->GetCalROC(iSector)->GetValue(iRow, iPad);
fTimePosition->GetCalROC(iSector)->SetValue(iRow, iPad, count+iTimeBin);
-
+
Float_t charge = fMaxCharge->GetCalROC(iSector)->GetValue(iRow, iPad);
fMaxCharge->GetCalROC(iSector)->SetValue(iRow, iPad, charge + qMax);
-
+
if(qMax>=10) {
count = fOverThreshold10->GetCalROC(iSector)->GetValue(iRow, iPad);
fOverThreshold10->GetCalROC(iSector)->SetValue(iRow, iPad, count+1);
Float_t qTot = qMax;
for(Int_t i = -1; i<=1; i++) {
for(Int_t j = -1; j<=1; j++) {
-
+
if(i==0 && j==0)
continue;
-
+
Float_t charge1 = GetQ(b, i, j, maxTimeBin, minT, maxT, minP, maxP);
qTot += charge1;
if(charge1>0) {
// see if the next neighbor is also above threshold
if(i*j==0) {
- qTot += GetQ(b, 2*i, 2*j, maxTimeBin, minT, maxT, minP, maxP);
+ qTot += GetQ(b, 2*i, 2*j, maxTimeBin, minT, maxT, minP, maxP);
} else {
// we are in a diagonal corner
- qTot += GetQ(b, i, 2*j, maxTimeBin, minT, maxT, minP, maxP);
- qTot += GetQ(b, 2*i, j, maxTimeBin, minT, maxT, minP, maxP);
- qTot += GetQ(b, 2*i, 2*j, maxTimeBin, minT, maxT, minP, maxP);
+ qTot += GetQ(b, i, 2*j, maxTimeBin, minT, maxT, minP, maxP);
+ qTot += GetQ(b, 2*i, j, maxTimeBin, minT, maxT, minP, maxP);
+ qTot += GetQ(b, 2*i, 2*j, maxTimeBin, minT, maxT, minP, maxP);
}
}
}
}
-
+
if(fIsDQM) {
fHistQVsSector->Fill(iSector, qTot);
fHistQmaxVsSector->Fill(iSector, qMax);
} else {
Float_t charge = fMeanCharge->GetCalROC(iSector)->GetValue(iRow, iPad);
fMeanCharge->GetCalROC(iSector)->SetValue(iRow, iPad, charge + qTot);
-
+
Float_t count = fNTimeBins->GetCalROC(iSector)->GetValue(iRow, iPad);
fNTimeBins->GetCalROC(iSector)->SetValue(iRow, iPad, count + maxT-minT+1);
-
+
count = fNPads->GetCalROC(iSector)->GetValue(iRow, iPad);
fNPads->GetCalROC(iSector)->SetValue(iRow, iPad, count + maxP-minP+1);
-
+
if((iSector%36)<18) { // A side
fHistQVsTimeSideA->Fill(iTimeBin, qTot);
fHistQMaxVsTimeSideA->Fill(iTimeBin, qMax);
} else {
fHistQVsTimeSideC->Fill(iTimeBin, qTot);
- fHistQMaxVsTimeSideC->Fill(iTimeBin, qMax);
+ fHistQMaxVsTimeSideC->Fill(iTimeBin, qMax);
}
}
} // end loop over signals
} // end loop over rows
-
+
fClusterCounter += nLocalMaxima;
}
//_____________________________________________________________________
void AliTPCdataQA::Analyse()
{
- //
- // Calculate calibration constants
- //
-
+ /// Calculate calibration constants
+
AliInfo("Analyse called");
if(fIsDQM == kTRUE) {
-
+
AliInfo("DQM flas is set -> No 2d information to analyze");
return;
}
if(fIsAnalysed == kTRUE) {
-
+
AliInfo("No new data since Analyse was called last time");
return;
}
if(fEventCounter==0) {
-
+
AliInfo("EventCounter == 0, Cannot analyse");
return;
}
-
+
Int_t nTimeBins = fLastTimeBin - fFirstTimeBin +1;
AliInfo(Form("EventCounter: %d , TimeBins: %d", fEventCounter, nTimeBins));
Float_t normalization = 1.0 / Float_t(fEventCounter * nTimeBins);
- fNoThreshold->Multiply(normalization);
-
+ fNoThreshold->Multiply(normalization);
+
fMeanCharge->Divide(fNLocalMaxima);
fMaxCharge->Divide(fNLocalMaxima);
fNTimeBins->Divide(fNLocalMaxima);
//_____________________________________________________________________
void AliTPCdataQA::MakeTree(const char *fname) const {
- //
- // Export result to the tree -located in the file
- // This file can be analyzed using AliTPCCalibViewer
- //
+ /// Export result to the tree -located in the file
+ /// This file can be analyzed using AliTPCCalibViewer
+
AliTPCPreprocessorOnline preprocesor;
if (fNLocalMaxima) preprocesor.AddComponent(fNLocalMaxima);
- if (fMaxCharge) preprocesor.AddComponent(fMaxCharge);
- if (fMeanCharge) preprocesor.AddComponent(fMeanCharge);
+ if (fMaxCharge) preprocesor.AddComponent(fMaxCharge);
+ if (fMeanCharge) preprocesor.AddComponent(fMeanCharge);
if (fNoThreshold) preprocesor.AddComponent(fNoThreshold);
if (fNTimeBins) preprocesor.AddComponent(fNTimeBins);
if (fNPads) preprocesor.AddComponent(fNPads);
if (fOverThreshold20) preprocesor.AddComponent(fOverThreshold20);
if (fOverThreshold30) preprocesor.AddComponent(fOverThreshold30);
- preprocesor.DumpToFile(fname);
+ preprocesor.DumpToFile(fname);
}
//_____________________________________________________________________
void AliTPCdataQA::MakeArrays(){
- //
- // The arrays for expanding the raw data are defined and
- // som parameters are intialised
- //
+ /// The arrays for expanding the raw data are defined and
+ /// som parameters are intialised
+
AliTPCROC * roc = AliTPCROC::Instance();
//
- // To make the array big enough for all sectors we take
+ // To make the array big enough for all sectors we take
// the dimensions from the outer row of an OROC (the last sector)
//
fRowsMax = roc->GetNRows(roc->GetNSector()-1);
fPadsMax = roc->GetNPads(roc->GetNSector()-1,fRowsMax-1);
- fTimeBinsMax = fLastTimeBin - fFirstTimeBin +1;
+ fTimeBinsMax = fLastTimeBin - fFirstTimeBin +1;
//
- // Since we have added 2 pads (TimeBins) before and after the real pads (TimeBins)
- // to make sure that we can always query the exanded table even when the
+ // Since we have added 2 pads (TimeBins) before and after the real pads (TimeBins)
+ // to make sure that we can always query the exanded table even when the
// max is on the edge
//
-
+
fAllBins = new Float_t*[fRowsMax];
fAllSigBins = new Int_t*[fRowsMax];
fAllNSigBins = new Int_t[fRowsMax];
for (Int_t iRow = 0; iRow < fRowsMax; iRow++) {
//
- Int_t maxBin = (fTimeBinsMax+4)*(fPadsMax+4);
+ Int_t maxBin = (fTimeBinsMax+4)*(fPadsMax+4);
fAllBins[iRow] = new Float_t[maxBin];
memset(fAllBins[iRow],0,sizeof(Float_t)*maxBin); // set all values to 0
fAllSigBins[iRow] = new Int_t[maxBin];
//_____________________________________________________________________
void AliTPCdataQA::CleanArrays(){
- //
- //
- //
+ ///
for (Int_t iRow = 0; iRow < fRowsMax; iRow++) {
// memset is only called if there is more than 1000 signals for a
// row (of the order 1% occupancy)
if(fAllNSigBins[iRow]<1000) {
-
+
Float_t* allBins = fAllBins[iRow];
Int_t* sigBins = fAllSigBins[iRow];
const Int_t nSignals = fAllNSigBins[iRow];
for(Int_t i = 0; i < nSignals; i++)
- allBins[sigBins[i]]=0;
+ allBins[sigBins[i]]=0;
} else {
- Int_t maxBin = (fTimeBinsMax+4)*(fPadsMax+4);
+ Int_t maxBin = (fTimeBinsMax+4)*(fPadsMax+4);
memset(fAllBins[iRow],0,sizeof(Float_t)*maxBin);
}
//_____________________________________________________________________
void AliTPCdataQA::GetPadAndTimeBin(Int_t bin, Int_t& iPad, Int_t& iTimeBin){
- //
- // Return pad and timebin for a given bin
- //
-
+ /// Return pad and timebin for a given bin
+
// Int_t bin = iPad*(fTimeBinsMax+4)+iTimeBin;
iTimeBin = bin%(fTimeBinsMax+4);
iPad = (bin-iTimeBin)/(fTimeBinsMax+4);
}
//_____________________________________________________________________
-void AliTPCdataQA::SetExpandDigit(const Int_t iRow, Int_t iPad,
- Int_t iTimeBin, const Float_t signal)
+void AliTPCdataQA::SetExpandDigit(const Int_t iRow, Int_t iPad,
+ Int_t iTimeBin, const Float_t signal)
{
- //
- //
- //
+ ///
+
R__ASSERT(iRow>=0 && iRow<fRowsMax);
R__ASSERT(iPad>=0 && iPad<=fPadsMax);
R__ASSERT(iTimeBin>=fFirstTimeBin && iTimeBin<=fLastTimeBin);
-
+
iTimeBin -= fFirstTimeBin;
iPad += 2;
iTimeBin += 2;
-
+
Int_t bin = iPad*(fTimeBinsMax+4)+iTimeBin;
fAllBins[iRow][bin] = signal;
fAllSigBins[iRow][fAllNSigBins[iRow]] = bin;
}
//______________________________________________________________________________
-Float_t AliTPCdataQA::GetQ(const Float_t* adcArray, const Int_t time,
- const Int_t pad, const Int_t maxTimeBins,
- Int_t& timeMin, Int_t& timeMax,
+Float_t AliTPCdataQA::GetQ(const Float_t* adcArray, const Int_t time,
+ const Int_t pad, const Int_t maxTimeBins,
+ Int_t& timeMin, Int_t& timeMax,
Int_t& padMin, Int_t& padMax) const
{
- //
- // This methods return the charge in the bin time+pad*maxTimeBins
- // If the charge is above 0 it also updates the padMin, padMax, timeMin
- // and timeMax if necessary
- //
+ /// This methods return the charge in the bin time+pad*maxTimeBins
+ /// If the charge is above 0 it also updates the padMin, padMax, timeMin
+ /// and timeMax if necessary
+
Float_t charge = adcArray[time + pad*maxTimeBins];
if(charge > 0) {
timeMin = TMath::Min(time, timeMin); timeMax = TMath::Max(time, timeMax);
padMin = TMath::Min(pad, padMin); padMax = TMath::Max(pad, padMax);
}
- return charge;
+ return charge;
}
//______________________________________________________________________________
void AliTPCdataQA::Streamer(TBuffer &xRuub)
{
- // Automatic schema evolution was first used from revision 4
- // Code based on:
- // http://root.cern.ch/root/roottalk/roottalk02/3207.html
+ /// Automatic schema evolution was first used from revision 4
+ /// Code based on:
+ /// http://root.cern.ch/root/roottalk/roottalk02/3207.html
UInt_t xRuus, xRuuc;
if (xRuub.IsReading()) {
//____________________________________________________________________________________________
void AliTPCdataQA::FillOccupancyProfile()
{
- // This has to be filled at the end of the loop over data
- if(!fIsDQM)
+ /// This has to be filled at the end of the loop over data
+
+ if(!fIsDQM)
AliInfo("Method only meaningful for DQM");
-
+
for(Int_t i = 0; i < 72; i++) {
fOccVec->GetArray()[i] /= fOccMaxVec->GetArray()[i];
//____________________________________________________________________________________________
void AliTPCdataQA::ResetProfiles()
{
- if(!fIsDQM)
+ if(!fIsDQM)
AliInfo("Method only meaningful for DQM");
-
+
if(fHistQVsSector)
fHistQVsSector->Reset();
if(fHistQmaxVsSector)
//____________________________________________________________________________________________
void AliTPCdataQA::Init()
{
- //
- // Define the calibration objects the first time Update is called
- // NB! This has to be done first even if the data is rejected by the time
- // cut to make sure that the objects are available in Analyse
- //
+ /// Define the calibration objects the first time Update is called
+ /// NB! This has to be done first even if the data is rejected by the time
+ /// cut to make sure that the objects are available in Analyse
+
if(!fIsDQM) {
-
+
if (!fNLocalMaxima){
TObjArray configArr(72);
fNLocalMaxima = new AliTPCCalPad(ConfigArrRocs(&configArr,"NLocalMaxima"));
}
}
// Make the arrays for expanding the data
-
+
if (!fAllBins)
MakeArrays();
-
+
//
// If Analyse has been previously called we need now to denormalize the data
// as more data is coming
//____________________________________________________________________________________________
void AliTPCdataQA::ResetData()
{
- //
- // reset all data
- //
+ /// reset all data
+
if(!fIsDQM) {
-
+
if (fNLocalMaxima){
fNoThreshold->Reset();
fNLocalMaxima->Reset();
fOverThreshold10->Reset();
fOverThreshold20->Reset();
fOverThreshold30->Reset();
-
+
fHistQVsTimeSideA->Reset();
fHistQVsTimeSideC->Reset();
fHistQMaxVsTimeSideA->Reset();
fHistQMaxVsTimeSideC->Reset();
fIsAnalysed = kFALSE;
-
+
}
}
-
+
fEventCounter=0;
fClusterCounter=0;
}
TObjArray *AliTPCdataQA::ConfigArrRocs(TObjArray *arr, const Text_t* name)
{
- //
- // GetArray with confiured ROCs
- //
+ /// GetArray with confiured ROCs
arr->Clear();
arr->SetName(name);
if (fActiveChambers[i]) arr->AddAt(new AliTPCCalROC(i),i);
}
return arr;
-}
\ No newline at end of file
+}
+/// \class AliTPCdataQA
+
#ifndef ALITPCDATAQA_H
#define ALITPCDATAQA_H
/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
void SetMinQMax (Float_t minQmax ) { fMinQMax = minQmax; }
void SetRequireNeighbouringPad(Bool_t req=kTRUE) { fRequireNeighbouringPad = req; }
-
+
// DQM methods
void FillOccupancyProfile();
void ResetProfiles();
Float_t GetMinQMax() const { return fMinQMax; }
Bool_t GetRequireNeighbouringPad() const { return fRequireNeighbouringPad; }
-
+
// DQM getter
Bool_t GetIsDQM() const { return fIsDQM; }
void SetRangeAdc (Int_t aMin, Int_t aMax){ fAdcMin=aMin; fAdcMax=aMax; } // Set adc range for the pedestal calibration
void SetMaxEvents (Int_t value) { fMaxEvents = value; }
void SetEventsPerBin(Int_t value) { fEventsPerBin = value; }
-
+
// DQM setter
void SetIsDQM(Bool_t value) { fIsDQM = value; }
void MakeArrays(); // Create arrays for random data acces
void CleanArrays(); // Clean arrays for random data acces
- void SetExpandDigit(const Int_t iRow, Int_t iPad, Int_t iTimeBin,
+ void SetExpandDigit(const Int_t iRow, Int_t iPad, Int_t iTimeBin,
const Float_t signal); // Fill arrays with signals
void GetPadAndTimeBin(Int_t bin, Int_t& iPad, Int_t& iTimeBin); // Get pad and time bin corresponding to the 1d bin
Float_t GetQ(const Float_t* adcArray, const Int_t time,
- const Int_t pad, const Int_t maxTimeBins,
+ const Int_t pad, const Int_t maxTimeBins,
Int_t& timeMin,Int_t& timeMax,Int_t& padMin,Int_t& padMax) const;
void UpdateEventHistograms();
TObjArray *ConfigArrRocs(TObjArray *arr, const Text_t* name);
- Int_t fFirstTimeBin; // First Time bin needed for analysis
- Int_t fLastTimeBin; // Last Time bin needed for analysis
- Int_t fAdcMin; // min adc channel of pedestal value
- Int_t fAdcMax; // max adc channel of pedestal value
- Float_t fMinQMax; // Minimun charge for Maximum ADC in cluster
- Bool_t fRequireNeighbouringPad; // If clusterer should require a neighbouring pad to accept it
-
+ Int_t fFirstTimeBin; ///< First Time bin needed for analysis
+ Int_t fLastTimeBin; ///< Last Time bin needed for analysis
+ Int_t fAdcMin; ///< min adc channel of pedestal value
+ Int_t fAdcMax; ///< max adc channel of pedestal value
+ Float_t fMinQMax; ///< Minimun charge for Maximum ADC in cluster
+ Bool_t fRequireNeighbouringPad; ///< If clusterer should require a neighbouring pad to accept it
+
- AliTPCAltroMapping **fMapping; //! Altro Mapping object
+ AliTPCAltroMapping **fMapping; //!< Altro Mapping object
//
//
- AliTPCCalPad * fPedestal; //! option to set pedestal cal object
- AliTPCCalPad * fNoise; //! option to set noise cal object
- AliTPCCalPad * fNLocalMaxima; // local maximas found
- AliTPCCalPad * fMaxCharge; // max charge
- AliTPCCalPad * fMeanCharge; // mean charge
- AliTPCCalPad * fNoThreshold; // number of digits
- AliTPCCalPad * fNTimeBins; // timebins width of cluster
- AliTPCCalPad * fNPads; // pads with of cluster
- AliTPCCalPad * fTimePosition; // Time position of local maximum
- AliTPCCalPad * fOverThreshold10; //! local maxima with qMax over threshold
- AliTPCCalPad * fOverThreshold20; //! local maxima with qMax over threshold
- AliTPCCalPad * fOverThreshold30; //! local maxima with qMax over threshold
-
- TProfile* fHistQVsTimeSideA; // Q vs time (side A)
- TProfile* fHistQVsTimeSideC; // Q vs time (side C)
- TProfile* fHistQMaxVsTimeSideA; // QMax vs time (side A)
- TProfile* fHistQMaxVsTimeSideC; // QMax vs time (side C)
-
- TH1F* fHistOccupancyVsEvent; // Occupancy vs event number (~time)
- TH1F* fHistNclustersVsEvent; // Nclusters vs event number (~time)
-
- Int_t fEventCounter; // event Counter
- Bool_t fIsAnalysed; // Set to true after Analyse has been called
-
- Int_t fMaxEvents; // Max events for event histograms
- Int_t fEventsPerBin; // Events per bin for event histograms
- Int_t fSignalCounter; // Signal counter
- Int_t fClusterCounter; // Cluster counter
-
- TBits fActiveChambers; // configured ROCs
+ AliTPCCalPad * fPedestal; //!< option to set pedestal cal object
+ AliTPCCalPad * fNoise; //!< option to set noise cal object
+ AliTPCCalPad * fNLocalMaxima; ///< local maximas found
+ AliTPCCalPad * fMaxCharge; ///< max charge
+ AliTPCCalPad * fMeanCharge; ///< mean charge
+ AliTPCCalPad * fNoThreshold; ///< number of digits
+ AliTPCCalPad * fNTimeBins; ///< timebins width of cluster
+ AliTPCCalPad * fNPads; ///< pads with of cluster
+ AliTPCCalPad * fTimePosition; ///< Time position of local maximum
+ AliTPCCalPad * fOverThreshold10; //!< local maxima with qMax over threshold
+ AliTPCCalPad * fOverThreshold20; //!< local maxima with qMax over threshold
+ AliTPCCalPad * fOverThreshold30; //!< local maxima with qMax over threshold
+
+ TProfile* fHistQVsTimeSideA; ///< Q vs time (side A)
+ TProfile* fHistQVsTimeSideC; ///< Q vs time (side C)
+ TProfile* fHistQMaxVsTimeSideA; ///< QMax vs time (side A)
+ TProfile* fHistQMaxVsTimeSideC; ///< QMax vs time (side C)
+
+ TH1F* fHistOccupancyVsEvent; ///< Occupancy vs event number (~time)
+ TH1F* fHistNclustersVsEvent; ///< Nclusters vs event number (~time)
+
+ Int_t fEventCounter; ///< event Counter
+ Bool_t fIsAnalysed; ///< Set to true after Analyse has been called
+
+ Int_t fMaxEvents; ///< Max events for event histograms
+ Int_t fEventsPerBin; ///< Events per bin for event histograms
+ Int_t fSignalCounter; ///< Signal counter
+ Int_t fClusterCounter; ///< Cluster counter
+
+ TBits fActiveChambers; ///< configured ROCs
//
// Expand buffer
//
- Float_t** fAllBins; //! array for digit using random access
- Int_t** fAllSigBins; //! array of pointers to the indexes over threshold
- Int_t* fAllNSigBins; //!
- Int_t fRowsMax; //! Maximum number of time bins
- Int_t fPadsMax; //! Maximum number of time bins
- Int_t fTimeBinsMax; //! Maximum number of time bins
+ Float_t** fAllBins; //!< array for digit using random access
+ Int_t** fAllSigBins; //!< array of pointers to the indexes over threshold
+ Int_t* fAllNSigBins; //!<
+ Int_t fRowsMax; //!< Maximum number of time bins
+ Int_t fPadsMax; //!< Maximum number of time bins
+ Int_t fTimeBinsMax; //!< Maximum number of time bins
// DQM variables
- Bool_t fIsDQM; //! Is DQM -> Simple output (no 2D!)
- TProfile* fHistOccVsSector; //! Occ vs sector (for DQM only)
- TProfile2D* fHistOcc2dVsSector; //! Occ vs sector 2D (for DQM only)
- TProfile* fHistQVsSector; //! Q vs sector (for DQM only)
- TProfile* fHistQmaxVsSector; //! QMax vs sector (for DQM only)
- TArrayD* fOccVec; //! Occupancy help counter for DQM
- TArrayD* fOccMaxVec; //! Occupancy help normlization for DQM
- TArrayD* fOccVecFine; //! "2D" occupancy help counter for DQM
- TArrayD* fOccMaxVecFine; //! "2D" occupancy help normlization for DQM
-
-
+ Bool_t fIsDQM; //!< Is DQM -> Simple output (no 2D!)
+ TProfile* fHistOccVsSector; //!< Occ vs sector (for DQM only)
+ TProfile2D* fHistOcc2dVsSector; //!< Occ vs sector 2D (for DQM only)
+ TProfile* fHistQVsSector; //!< Q vs sector (for DQM only)
+ TProfile* fHistQmaxVsSector; //!< QMax vs sector (for DQM only)
+ TArrayD* fOccVec; //!< Occupancy help counter for DQM
+ TArrayD* fOccMaxVec; //!< Occupancy help normlization for DQM
+ TArrayD* fOccVecFine; //!< "2D" occupancy help counter for DQM
+ TArrayD* fOccMaxVecFine; //!< "2D" occupancy help normlization for DQM
+
+
+ /// \cond CLASSIMP
ClassDef(AliTPCdataQA, 6) // Implementation of the TPC Raw QA
+ /// \endcond
};
* provided "as is" without express or implied warranty. *
**************************************************************************/
-//-------------------------------------------------------------------------
-//
-// AliTPCmapper
-// Authors: Christian.Lippmann@cern.ch, J.Wiechula@gsi.de
-// Class to map detector coordinates (row, pad, sector, ...) to
-// hardware coordinates (RCU, Branch, FEC, Altro, channel, Equipment ID, ...)
-//
-// There are two different ways to number padrows:
-// 1) local padrow: for each ROC, 0 ... 62 for an IROC, 0 ... 95 for an OROC,
-// 2) global padrow: for each sector, from 0 ... 158.
-// If the global numbering is used, it is denoted by the variable name
-// globalpadrow in this class.
-//
-// There are two different ways to number sectors:
-// 1) Sectors contain one IROC and one OROC and are counted from 0 to 17 on
-// each of the two sides (A=0 and C=1),
-// 2) ROCs are numbered from 0 to 71 where the ROCs 0 ... 35 are IROCS and
-// ROCs 36 ... 71 are OROCs. A ROC is often named "sector" in aliroot,
-// which can be very confusing!
-//
-//-------------------------------------------------------------------------
+/// \class AliTPCmapper
+/// \brief AliTPCmapper
+///
+/// Class to map detector coordinates (row, pad, sector, ...) to
+/// hardware coordinates (RCU, Branch, FEC, Altro, channel, Equipment ID, ...)
+///
+/// There are two different ways to number padrows:
+/// 1) local padrow: for each ROC, 0 ... 62 for an IROC, 0 ... 95 for an OROC,
+/// 2) global padrow: for each sector, from 0 ... 158.
+/// If the global numbering is used, it is denoted by the variable name
+/// globalpadrow in this class.
+///
+/// There are two different ways to number sectors:
+/// 1) Sectors contain one IROC and one OROC and are counted from 0 to 17 on
+/// each of the two sides (A=0 and C=1),
+/// 2) ROCs are numbered from 0 to 71 where the ROCs 0 ... 35 are IROCS and
+/// ROCs 36 ... 71 are OROCs. A ROC is often named "sector" in aliroot,
+/// which can be very confusing!
+///
+/// \author Christian.Lippmann@cern.ch, J.Wiechula@gsi.de
#include <TMath.h>
#include <TSystem.h>
#include "AliLog.h"
#include "AliDAQ.h"
+/// \cond CLASSIMP
ClassImp(AliTPCmapper)
+/// \endcond
//______________________________________________________________
AliTPCmapper::AliTPCmapper() :
fNside(0),
fNpadrowOROC(0),
fTpcDdlOffset(0)
{
- //
- // Constructor
- //
- // dirname - specify the directory with the ascii Altro mapping files
- //
+ /// Constructor
+ ///
+ /// dirname - specify the directory with the ascii Altro mapping files
+
Init(dirname);
}
//______________________________________________________________
AliTPCmapper::~AliTPCmapper()
{
- // Destructor
+ /// Destructor
for ( Int_t i = 0; i < fNrcu; i++ ) {
delete fMapping[i];
fNpadrowOROC(mapper.fNpadrowOROC),
fTpcDdlOffset(mapper.fTpcDdlOffset)
{
- // Copy Constructor
+ /// Copy Constructor
+
for ( Int_t i = 0; i < 6; i++ ) fMapping[i]=0;
for ( Int_t i = 0; i < fNrcu; i++ ) fMapping[i] = mapper.fMapping[i];
}
//_____________________________________________________________________________
AliTPCmapper& AliTPCmapper::operator = (const AliTPCmapper& mapper)
{
- // Assignment operator
+ /// Assignment operator
if(&mapper == this) return *this;
((TObject *)this)->operator=(mapper);
//______________________________________________________________
void AliTPCmapper::Init(const char *dirname)
{
- // Initialize all
+ /// Initialize all
+
fNside = 2;
fNsector = 18;
fNrcu = 6;
//_____________________________________________________________________________
Int_t AliTPCmapper::GetHWAddress(Int_t roc, Int_t padrow, Int_t pad) const
{
- // Get the hardware address from pad coordinates for a given ROC
+ /// Get the hardware address from pad coordinates for a given ROC
+
Int_t patch = GetPatch(roc, padrow, pad);
if ( (patch >= fNrcu) || (patch < 0) ) return -1;
return fMapping[patch]->GetHWAddress(padrow, pad, roc);
//_____________________________________________________________________________
Int_t AliTPCmapper::GetHWAddressSector(Int_t globalpadrow, Int_t pad) const
{
- // Get the hardware address from pad coordinates
+ /// Get the hardware address from pad coordinates
+
Int_t patch = 0;
Int_t hwAddress=-1;
if ( globalpadrow < fNpadrowIROC ) {
//_____________________________________________________________________________
Int_t AliTPCmapper::GetRcu(Int_t roc, Int_t padrow, Int_t pad) const
{
- // Get the patch (rcu) index from the pad coordinates. The Roc index is
- // needed as well to determine if it is IROC or OROC.
+ /// Get the patch (rcu) index from the pad coordinates. The Roc index is
+ /// needed as well to determine if it is IROC or OROC.
+
return GetPatch(roc, padrow, pad);
}
//_____________________________________________________________________________
Int_t AliTPCmapper::GetPatch(Int_t roc, Int_t padrow, Int_t pad) const
{
- // Get the patch (rcu) index from the pad coordinates. The Roc index is
- // needed as well to determine if it is IROC or OROC.
+ /// Get the patch (rcu) index from the pad coordinates. The Roc index is
+ /// needed as well to determine if it is IROC or OROC.
if ( (padrow < 0) || (pad < 0) || (roc < 0) ) {
AliWarning(Form("Pad coordinates outside range (padrow %d, pad %d, roc %d) !", padrow, pad, roc));
//_____________________________________________________________________________
Int_t AliTPCmapper::GetRcuSector(Int_t globalpadrow, Int_t pad) const
{
- // Get the patch (rcu) index from the pad coordinates for a sector
+ /// Get the patch (rcu) index from the pad coordinates for a sector
+
return GetPatchSector(globalpadrow, pad);
}
//_____________________________________________________________________________
Int_t AliTPCmapper::GetPatchSector(Int_t globalpadrow, Int_t pad) const
{
- // Get the patch (rcu) index from the pad coordinates for a sector
+ /// Get the patch (rcu) index from the pad coordinates for a sector
+
if ( globalpadrow >= fNpadrow ) {
AliWarning(Form("Padrow outside range (globalpadrow %d) !", globalpadrow));
return -1;
//_____________________________________________________________________________
Int_t AliTPCmapper::GetPadRow(Int_t patch, Int_t hwAddress) const
{
- // Get Pad Row (for a ROC) from the hardware address
+ /// Get Pad Row (for a ROC) from the hardware address
+
if ( (patch >= fNrcu) || (patch < 0) ) {
AliWarning(Form("Patch index outside range (patch %d) !", patch));
return -1;
//_____________________________________________________________________________
Int_t AliTPCmapper::GetGlobalPadRow(Int_t patch, Int_t hwAddress) const
{
- // Get Pad Row (for full sector) from the hardware address
+ /// Get Pad Row (for full sector) from the hardware address
+
if ( patch < 2 ) return GetPadRow(patch, hwAddress);
else return GetPadRow(patch, hwAddress) + fNpadrowIROC;
}
//_____________________________________________________________________________
Int_t AliTPCmapper::GetPad(Int_t patch, Int_t hwAddress) const
{
- // Get Pad index from the hardware address
+ /// Get Pad index from the hardware address
+
if ( (patch >= fNrcu) || (patch < 0) ) {
AliWarning(Form("Patch index outside range (patch %d) !", patch));
return -1;
Int_t AliTPCmapper::GetPadRow(Int_t patch, Int_t branch, Int_t fec, Int_t chip,
Int_t channel) const
{
- // Get pad row (for a ROC) from hardware coordinates
+ /// Get pad row (for a ROC) from hardware coordinates
+
if ( (patch >= fNrcu) || (branch >= fNbranch) || (chip >= fNaltro) || (channel >= fNchannel)
|| (patch < 0) || (branch < 0) || (chip < 0) || (channel < 0) ) {
AliWarning(Form("Coordinates outside range (patch %d, branch %d, fec %d, chip %d, channel %d)) !",
Int_t AliTPCmapper::GetGlobalPadRow(Int_t patch, Int_t branch, Int_t fec, Int_t chip,
Int_t channel) const
{
- // Get Pad Row (for full sector) from the hardware address
+ /// Get Pad Row (for full sector) from the hardware address
+
if ( (patch >= fNrcu) || (branch >= fNbranch) || (chip >= fNaltro) || (channel >= fNchannel)
|| (patch < 0) || (branch < 0) || (chip < 0) || (channel < 0) ) {
AliWarning(Form("Coordinates outside range (patch %d, branch %d, fec %d, chip %d, channel %d)) !",
//_____________________________________________________________________________
Int_t AliTPCmapper::GetPad(Int_t patch, Int_t branch, Int_t fec, Int_t chip, Int_t channel) const
{
- // Get pad from hardware coordinates
+ /// Get pad from hardware coordinates
+
if ( (patch >= fNrcu) || (branch >= fNbranch) || (chip >= fNaltro) || (channel >= fNchannel)
|| (patch < 0) || (branch < 0) || (chip < 0) || (channel < 0) ) {
AliWarning(Form("Coordinates outside range (patch %d, branch %d, fec %d, chip %d, channel %d)) !",
//_____________________________________________________________________________
Int_t AliTPCmapper::GetBranch(Int_t roc, Int_t padrow, Int_t pad) const
{
- // Get the branch to which this pad is connected. The FECs connected to
- // one RCU are divided into two branches: A(=0) and B(=1). This information
- // can be extracted from the hardware address.
+ /// Get the branch to which this pad is connected. The FECs connected to
+ /// one RCU are divided into two branches: A(=0) and B(=1). This information
+ /// can be extracted from the hardware address.
+
return DecodedHWAddressBranch(GetHWAddress(roc, padrow, pad));
}
//_____________________________________________________________________________
Int_t AliTPCmapper::GetBranchSector(Int_t globalpadrow, Int_t pad) const
{
- // Get Branch from pad coordinates, where globalpadrow is counted
- // for a full sector (0 ... 158)
+ /// Get Branch from pad coordinates, where globalpadrow is counted
+ /// for a full sector (0 ... 158)
+
return DecodedHWAddressBranch(GetHWAddressSector(globalpadrow, pad));
}
//_____________________________________________________________________________
Int_t AliTPCmapper::GetFEChw(Int_t roc, Int_t padrow, Int_t pad) const
{
- // Get the FEC number in hardware numbering. The FECs are numbered from 0 (in the
- // center of the partition) to 8 (partition 3, 4, 5), 9 (partition 0, 2), 11
- // (partition 1, branch A) or 12 (partition 1, branch B). This information
- // can be extracted from the hardware address.
+ /// Get the FEC number in hardware numbering. The FECs are numbered from 0 (in the
+ /// center of the partition) to 8 (partition 3, 4, 5), 9 (partition 0, 2), 11
+ /// (partition 1, branch A) or 12 (partition 1, branch B). This information
+ /// can be extracted from the hardware address.
+
return DecodedHWAddressFECaddr(GetHWAddress(roc, padrow, pad));
}
//_____________________________________________________________________________
Int_t AliTPCmapper::GetFEChwSector(Int_t globalpadrow, Int_t pad) const
{
- // Get the FEC number in hardware numbering from pad coordinates, where
- // globalpadrow is counted for a full sector (0 ... 158)
+ /// Get the FEC number in hardware numbering from pad coordinates, where
+ /// globalpadrow is counted for a full sector (0 ... 158)
+
return DecodedHWAddressFECaddr(GetHWAddressSector(globalpadrow, pad));
}
//_____________________________________________________________________________
Int_t AliTPCmapper::GetFEC(Int_t roc, Int_t padrow, Int_t pad) const
{
- // Get the FEC number in offline-oriented numbering. The FECs are numbered from 0
- // 17 (partition 3, 4, 5), 19 (partition 0, 2) or 24 (partition 1).
+ /// Get the FEC number in offline-oriented numbering. The FECs are numbered from 0
+ /// 17 (partition 3, 4, 5), 19 (partition 0, 2) or 24 (partition 1).
+
Int_t patch = GetPatch(roc, padrow, pad);
Int_t fec = DecodedHWAddressFECaddr(GetHWAddress(roc, padrow, pad));
Int_t branch = DecodedHWAddressBranch(GetHWAddress(roc, padrow, pad));
//_____________________________________________________________________________
Int_t AliTPCmapper::GetFECSector(Int_t globalpadrow, Int_t pad) const
{
- // Get the FEC number in offline-oriented numbering. globalpadrow is
- // counted for a full sector (0 ... 158)
+ /// Get the FEC number in offline-oriented numbering. globalpadrow is
+ /// counted for a full sector (0 ... 158)
+
Int_t patch = GetPatchSector(globalpadrow, pad);
Int_t fec = DecodedHWAddressFECaddr(GetHWAddressSector(globalpadrow, pad));
Int_t branch = DecodedHWAddressBranch(GetHWAddressSector(globalpadrow, pad));
//_____________________________________________________________________________
Int_t AliTPCmapper::GetChip(Int_t roc, Int_t padrow, Int_t pad) const
{
- // Get Chip (ALTRO) index (0 ... 7) from pad coordinates
+ /// Get Chip (ALTRO) index (0 ... 7) from pad coordinates
+
return DecodedHWAddressChipaddr(GetHWAddress(roc, padrow, pad));
}
//_____________________________________________________________________________
Int_t AliTPCmapper::GetChipSector(Int_t globalpadrow, Int_t pad) const
{
- // Get Chip (ALTRO) index (0 ... 7) from pad coordinates, where
- // globalpadrow is counted for a full sector (0 ... 158)
+ /// Get Chip (ALTRO) index (0 ... 7) from pad coordinates, where
+ /// globalpadrow is counted for a full sector (0 ... 158)
+
return DecodedHWAddressChipaddr(GetHWAddressSector(globalpadrow, pad));
}
//_____________________________________________________________________________
Int_t AliTPCmapper::GetChannel(Int_t roc, Int_t padrow, Int_t pad) const
{
- // Get Channel index (0 ... 15) from pad coordinates
+ /// Get Channel index (0 ... 15) from pad coordinates
+
return DecodedHWAddressChanneladdr(GetHWAddress(roc, padrow, pad));
}
//_____________________________________________________________________________
Int_t AliTPCmapper::GetChannelSector(Int_t globalpadrow, Int_t pad) const
{
- // Get Channel index (0 ... 15) from pad coordinates, where
- // globalpadrow is counted for a full sector (0 ... 158)
+ /// Get Channel index (0 ... 15) from pad coordinates, where
+ /// globalpadrow is counted for a full sector (0 ... 158)
+
return DecodedHWAddressChanneladdr(GetHWAddressSector(globalpadrow, pad));
}
//_____________________________________________________________________________
Int_t AliTPCmapper::CodeHWAddress(Int_t branch, Int_t fec, Int_t chip, Int_t channel) const
{
- // Get Hardware address from channel, altro, fec and branch coordinates
+ /// Get Hardware address from channel, altro, fec and branch coordinates
+
return ((branch&1)<<11) + ((fec&0xf)<<7) + ((chip&0x7)<<4) + (channel&0xf);
}
//_____________________________________________________________________________
Int_t AliTPCmapper::DecodedHWAddressBranch(Int_t hwAddress) const
{
- // Get branch index (0, 1) from hardware address
+ /// Get branch index (0, 1) from hardware address
+
if ( hwAddress < 0 ) return -1;
return ((hwAddress>>11)&1);
}
//_____________________________________________________________________________
Int_t AliTPCmapper::DecodedHWAddressFECaddr(Int_t hwAddress) const
{
- // Get FEC index (0 ... 12) from hardware address
+ /// Get FEC index (0 ... 12) from hardware address
+
if ( hwAddress < 0 ) return -1;
return ((hwAddress>>7)&0xf);
}
//_____________________________________________________________________________
Int_t AliTPCmapper::DecodedHWAddressChipaddr(Int_t hwAddress) const
{
- // Get ALTRO index (0 ... 7) from hardware address
+ /// Get ALTRO index (0 ... 7) from hardware address
+
if ( hwAddress < 0 ) return -1;
return ((hwAddress>>4)&0x7);
}
//_____________________________________________________________________________
Int_t AliTPCmapper::DecodedHWAddressChanneladdr(Int_t hwAddress) const
{
- // Get channel index (0 ... 15) from hardware address
+ /// Get channel index (0 ... 15) from hardware address
+
if ( hwAddress < 0 ) return -1;
return ((hwAddress&0xf));
}
//______________________________________________________________
Int_t AliTPCmapper::GetNpads(Int_t roc, Int_t padrow) const{
- // Get number of pads in padrow for this ROC.
+ /// Get number of pads in padrow for this ROC.
+
AliTPCROC *fROC = AliTPCROC::Instance();
Int_t retval = fROC->GetNPads((UInt_t)roc, (UInt_t)padrow);
return retval;
//______________________________________________________________
Int_t AliTPCmapper::GetNpads(Int_t globalpadrow) const{
- // Get number of pads in padrow, where globalpadrow is counted for a full sector (0 ... 158)
+ /// Get number of pads in padrow, where globalpadrow is counted for a full sector (0 ... 158)
if ( globalpadrow >= fNpadrow ) {
AliWarning(Form("Padrow outside range (globalpadrow %d) !", globalpadrow));
//______________________________________________________________
Int_t AliTPCmapper::GetNpadrows(Int_t roc) const
{
- // Get number of padrows
+ /// Get number of padrows
+
if (roc < 36) return fNpadrowIROC;
else if (roc < 72) return fNpadrowOROC;
return -1;
//_____________________________________________________________________________
Int_t AliTPCmapper::GetNfec(Int_t patch) const
{
- // Get size of readout partition (number of FECs) for this rcu (patch) index (0 ... 5)
+ /// Get size of readout partition (number of FECs) for this rcu (patch) index (0 ... 5)
+
Int_t retval = 0;
switch(patch){
case(0):
//_____________________________________________________________________________
Int_t AliTPCmapper::GetNfec(Int_t patch, Int_t branch) const
{
- // Get size of readout partition (number of FECs) for this branch
+ /// Get size of readout partition (number of FECs) for this branch
+
Int_t retval = 0;
switch(patch){
case(0):
retval = 10;
break;
};
-
+
if( (branch == 1) && (patch == 1) ){
retval = 12;
}
//_____________________________________________________________________________
Int_t AliTPCmapper::OfflineToHwFec(Int_t patch, Int_t fec) const
{
- // Convert FEC position in offline-like numbering to hardware numbering (fec).
+ /// Convert FEC position in offline-like numbering to hardware numbering (fec).
if ( (patch < 0) || (fec < 0) ) {
AliWarning(Form("Patch (%d) or Fec number (%d) outside range !", patch, fec));
//_____________________________________________________________________________
Int_t AliTPCmapper::OfflineToHwBranch(Int_t patch, Int_t fec) const
{
- // Convert fec position in offline-like numbering to hardware numbering (branch).
+ /// Convert fec position in offline-like numbering to hardware numbering (branch).
if ( (patch < 0) || (fec < 0) ) {
AliWarning(Form("Patch (%d) or Fec number (%d) outside range !", patch, fec));
//_____________________________________________________________________________
Int_t AliTPCmapper::HwToOffline(Int_t patch, Int_t branch, Int_t fec) const
{
- // Convert hardware FEC position (branch, fec) to the offline-oriented numbering
+ /// Convert hardware FEC position (branch, fec) to the offline-oriented numbering
if ( (patch < 0) || (fec < 0) || (branch < 0) ) {
AliWarning(Form("Patch (%d), branch (%d) or Fec number (%d) outside range !", patch, branch, fec));
//_____________________________________________________________________________
Int_t AliTPCmapper::GetEquipmentID(Int_t roc, Int_t padrow, Int_t pad) const
{
- // Get EqID from pad coordinate. The Roc index is
- // needed as well to determine if it is IROC or OROC.
+ /// Get EqID from pad coordinate. The Roc index is
+ /// needed as well to determine if it is IROC or OROC.
Int_t side = GetSideFromRoc(roc);
if ( side < 0 ) return -1;
//_____________________________________________________________________________
Int_t AliTPCmapper::GetEquipmentIDsector(Int_t side, Int_t sector, Int_t globalpadrow, Int_t pad) const
{
- // Get EqID from pad coordinate, where padrow is counted for a full sector (0 ... 158)
+ /// Get EqID from pad coordinate, where padrow is counted for a full sector (0 ... 158)
+
Int_t patch = GetPatchSector(globalpadrow, pad);
if ( patch < 0 ) return -1;
Int_t roc = GetRocFromPatch(side, sector, patch);
//_____________________________________________________________________________
Int_t AliTPCmapper::GetEquipmentIDfromPatch(Int_t side, Int_t sector, Int_t patch) const
{
- // Get EqID from patch (rcu).
+ /// Get EqID from patch (rcu).
Int_t roc = GetRocFromPatch(side, sector, patch);
Int_t ddl = 0;
//_____________________________________________________________________________
Int_t AliTPCmapper::GetPatchFromEquipmentID(Int_t equipmentID) const
{
- // Get rcu (patch) index (0 ... 5) from equipment ID
+ /// Get rcu (patch) index (0 ... 5) from equipment ID
+
Int_t retval = 0;
if ( (equipmentID < fTpcDdlOffset) || (equipmentID > 983) ) {
//_____________________________________________________________________________
Int_t AliTPCmapper::GetSideFromEquipmentID(Int_t equipmentID) const
{
- // Get side from Eq ID
+ /// Get side from Eq ID
+
if ( equipmentID < fTpcDdlOffset ) {
AliWarning(Form("Equipment ID (%d) outside range !", equipmentID));
return -1;
//_____________________________________________________________________________
Int_t AliTPCmapper::GetSectorFromEquipmentID(Int_t equipmentID) const
{
- // Get sector index (0 ... 17) from equipment ID
+ /// Get sector index (0 ... 17) from equipment ID
+
Int_t retval = 0;
if ( (equipmentID < fTpcDdlOffset) || (equipmentID >= fTpcDdlOffset+216) ) {
AliWarning(Form("Equipment ID (%d) outside range !", equipmentID));
//_____________________________________________________________________________
Int_t AliTPCmapper::GetRocFromEquipmentID(Int_t equipmentID) const
{
- // Get ROC index (0 ... 71) from equipment ID
+ /// Get ROC index (0 ... 71) from equipment ID
+
Int_t side = GetSideFromEquipmentID(equipmentID);
if ( side < 0 ) return -1;
Int_t sector = GetSectorFromEquipmentID(equipmentID);
//_____________________________________________________________________________
Int_t AliTPCmapper::GetSectorFromRoc(Int_t roc) const
{
- // get the sector number (0 ... 17) from the roc number (0 ... 71)
+ /// get the sector number (0 ... 17) from the roc number (0 ... 71)
if ( roc < 0 ) {
AliWarning(Form("Roc outside range (roc %d) !", roc));
//_____________________________________________________________________________
Int_t AliTPCmapper::GetSideFromRoc(Int_t roc) const
{
- // get the side (0, 1) from the roc number (0 ... 71)
+ /// get the side (0, 1) from the roc number (0 ... 71)
if ( roc < 0 ) {
AliWarning(Form("Roc outside range (roc %d) !", roc));
return 0;
} else if ( roc < 72 ) { // outer sector, C side
return 1;
- } else {
+ } else {
AliWarning(Form("Roc outside range (roc %d) !", roc));
return -1;
- }
+ }
}
//_____________________________________________________________________________
Int_t AliTPCmapper::GetRocFromPatch(Int_t side, Int_t sector, Int_t patch) const
{
- // Get Roc (0 ... 71) from side (0, 1), sector (0 ... 17) and patch (0 ... 5)
+ /// Get Roc (0 ... 71) from side (0, 1), sector (0 ... 17) and patch (0 ... 5)
if ( (side < 0) || (side >= fNside) ) {
AliWarning(Form("Side outside range (side %d) !", side));
//_____________________________________________________________________________
Int_t AliTPCmapper::GetRoc(Int_t side, Int_t sector, Int_t globalpadrow, Int_t pad) const
{
- // Get Roc (0 ... 71) from side (0, 1), sector (0 ... 17) and pad coordinates
+ /// Get Roc (0 ... 71) from side (0, 1), sector (0 ... 17) and pad coordinates
Int_t patch = GetPatchSector(globalpadrow, pad);
if ( patch < 0 ) return -1;
//_____________________________________________________________________________
Bool_t AliTPCmapper::IsIROC(Int_t roc) const
{
- // Is this ROC an IROC?
+ /// Is this ROC an IROC?
+
if ( roc < 0 ) {
AliWarning(Form("Roc outside range (roc %d) !", roc));
return -1;
//_____________________________________________________________________________
Bool_t AliTPCmapper::IsOROC(Int_t roc) const
{
- // Is this ROC an OROC?
+ /// Is this ROC an OROC?
+
if ( roc < 0 ) {
AliWarning(Form("Roc outside range (roc %d) !", roc));
return -1;
/* Copyright(c) 1998-2006, ALICE Experiment at CERN, All rights reserved. *
* See cxx source for full Copyright notice */
-////////////////////////////////////////////////////////////////////////
-//
-// AliTPCmapper class
-// Class for all mapping functions (hardware coordinates <-> pad coordinates)
-// Author: Christian Lippmann
-//
-/////////////////////////////////////////////////////////////////////////
+/// \class AliTPCmapper
+/// \brief Class for all mapping functions (hardware coordinates <-> pad coordinates)
+///
+/// \author Christian Lippmann
#include <TObject.h>
Int_t GetNfec(Int_t patch) const;
Bool_t IsIROC(Int_t roc) const;
Bool_t IsOROC(Int_t roc) const;
-
+
Int_t GetTpcDdlOffset() const {return fTpcDdlOffset;}
Int_t GetNumDdl() const {return fNside*fNsector*fNrcu; }
private:
- Int_t fNside; // TPC has 2 sides
- Int_t fNsector; // TPC side has 18 sectors
- Int_t fNrcu; // Sector has 6 RCUs (patches)
- Int_t fNbranch; // RCU has 2 branches
- Int_t fNaltro; // FEC has 8 ALTROs
- Int_t fNchannel; // ALTRO has 16 channels
- Int_t fNpadrow; // Sector has 159 padrows
- Int_t fNpadrowIROC; // IROC has 63 padrows
- Int_t fNpadrowOROC; // OROC has 96 padrows
+ Int_t fNside; ///< TPC has 2 sides
+ Int_t fNsector; ///< TPC side has 18 sectors
+ Int_t fNrcu; ///< Sector has 6 RCUs (patches)
+ Int_t fNbranch; ///< RCU has 2 branches
+ Int_t fNaltro; ///< FEC has 8 ALTROs
+ Int_t fNchannel; ///< ALTRO has 16 channels
+ Int_t fNpadrow; ///< Sector has 159 padrows
+ Int_t fNpadrowIROC; ///< IROC has 63 padrows
+ Int_t fNpadrowOROC; ///< OROC has 96 padrows
- Int_t fTpcDdlOffset; // DDL offset for TPC
+ Int_t fTpcDdlOffset; ///< DDL offset for TPC
- AliTPCAltroMapping *fMapping[6]; // The ALTRO mapping for each patch (rcu)
+ AliTPCAltroMapping *fMapping[6]; ///< The ALTRO mapping for each patch (rcu)
+ /// \cond CLASSIMP
ClassDef(AliTPCmapper,2)
+ /// \endcond
};
-#include "AliTransform.h"
+/// \class AliTransform
+#include "AliTransform.h"
+/// \cond CLASSIMP
ClassImp(AliTransform)
+/// \endcond
+/// \class AliTransform
+
#ifndef ALI_TRANSFORM_H
#define ALI_TRANSFORM_H
virtual void Transform(Double_t *x,Int_t *i,UInt_t time,
Int_t coordinateType)=0;
+ /// \cond CLASSIMP
ClassDef(AliTransform,0)
+ /// \endcond
};
#endif
* provided "as is" without express or implied warranty. *
**************************************************************************/
-/*
- marian.ivanov@cern.ch
-
- //TOOLKIT for chain manipulation:
- //Example usage:
- //
- // 1. Check the list of files
- AliXRDPROOFtoolkit toolkit;
- AliXRDPROOFtoolkit::FilterList("pp.txt","AliESDs.root esdTree AliESDfriends.root * Kinematics.root *",0)
- AliXRDPROOFtoolkit::FilterList("pp.txt","AliESDs.root esdTree AliESDfriends.root * Kinematics.root *",1)
- //
- //2. make a chain or random chain form the list of files
- TChain * chain = toolkit.MakeChain("esd.txt","esdTree",0,10)
- TChain * chainRandom = toolkit.MakeChainrandom("esd.txt","esdTree",0,10)
- chain->Draw("fTPCnclsF");
-
+/// \class AliXRDPROOFtoolkit
+/// \brief TOOLKIT for chain manipulation:
+///
+/// Example usage:
+///
+/// 1. Check the list of files
+///
+/// ~~~{.cxx}
+/// AliXRDPROOFtoolkit toolkit;
+/// AliXRDPROOFtoolkit::FilterList("pp.txt","AliESDs.root esdTree AliESDfriends.root * Kinematics.root *",0)
+/// AliXRDPROOFtoolkit::FilterList("pp.txt","AliESDs.root esdTree AliESDfriends.root * Kinematics.root *",1)
+/// ~~~
+///
+/// ~~~{.cxx}
+/// 2. make a chain or random chain form the list of files
+/// TChain * chain = toolkit.MakeChain("esd.txt","esdTree",0,10)
+/// TChain * chainRandom = toolkit.MakeChainrandom("esd.txt","esdTree",0,10)
+/// chain->Draw("fTPCnclsF");
+/// ~~~
+///
+/// \author Marian Ivanov
-*/
#include <TTree.h>
#include <TEnv.h>
#include <TString.h>
#include <AliXRDPROOFtoolkit.h>
+/// \cond CLASSIMP
ClassImp(AliXRDPROOFtoolkit)
+/// \endcond
//______________________________________________________________________________
- AliXRDPROOFtoolkit::AliXRDPROOFtoolkit () :
+ AliXRDPROOFtoolkit::AliXRDPROOFtoolkit () :
TObject () ,
- fVerbose(kFALSE), // verbso mode - print command
+ fVerbose(kFALSE), // verbso mode - print command
fUserName(""), // user name
fUserGroup(0) // user group info
{
//
- //
+ //
//
fUserGroup = gSystem->GetUserInfo();
- fUserName = fUserGroup->fUser;
+ fUserName = fUserGroup->fUser;
fVerbose=1;
}
TChain* AliXRDPROOFtoolkit::MakeChain(const char*fileIn, const char * treeName, const char *fName, Int_t maxFiles, Int_t startFile)
{
- //
- // Create a chain of files using the file 'fileIn' as input list
- // where one line per root file is expected
- //
- // treeName : Name of the tree
- // fName : file name inside of a zip file, will add '#fName'
- // to the file name
- // maxFiles : maximum number of files in the chain
- // -1 (default) add all possible files starting from 'startFile'
- // startFile: position of the first file, starting with 0
- //
+ /// Create a chain of files using the file 'fileIn' as input list
+ /// where one line per root file is expected
+ ///
+ /// treeName : Name of the tree
+ /// fName : file name inside of a zip file, will add '#fName'
+ /// to the file name
+ /// maxFiles : maximum number of files in the chain
+ /// -1 (default) add all possible files starting from 'startFile'
+ /// startFile: position of the first file, starting with 0
+
TChain* chain = new TChain(treeName);
// Open the input stream
}
if (!currentFile.Contains("root")) continue; // protection
++counter;
- if (counter<=startFile) continue;
+ if (counter<=startFile) continue;
if ((maxFiles>0) && (counter>maxFiles+startFile)) break;
TFile * f = TFile::Open(currentFile.Data());
TChain* AliXRDPROOFtoolkit::MakeChainRandom(const char*fileIn, const char * treeName,const char *fName, Int_t maxFiles, Int_t startFile)
{
- //
- // Create a TDSet - files are in random order
- //
- // filein - input list text file
- // treename - containg tree
- // maxFiles - maximum number of files included
+ /// Create a TDSet - files are in random order
+ ///
+ /// filein - input list text file
+ /// treename - containg tree
+ /// maxFiles - maximum number of files included
TObjArray array(10000);
-
+
TChain* chain = new TChain(treeName);
// Open the input stream
Double_t *randomI = new Double_t[entries];
Int_t *indexes = new Int_t[entries];
for (Int_t i=0;i<entries; i++) randomI[i]=gRandom->Rndm();
- TMath::Sort(entries,randomI,indexes);
-
+ TMath::Sort(entries,randomI,indexes);
+
for (Int_t i=startFile; (i<startFile+maxFiles) && (i<entries); i++){
Int_t ifile = indexes[i];
- if (ifile<entries && (array.At(ifile)) && array.At(ifile)->TestBit(TObject::kCannotPick)==kFALSE){
+ if (ifile<entries && (array.At(ifile)) && array.At(ifile)->TestBit(TObject::kCannotPick)==kFALSE){
printf("%d\t%d\t%s\n",i, ifile, array.At(ifile)->GetName());
chain->Add(array.At(ifile)->GetName());
array.At(ifile)->SetBit(TObject::kCannotPick);
TDSet* AliXRDPROOFtoolkit::MakeSet(const char*fileIn, const char * treeName, const char *fName, Int_t maxFiles)
{
- //
- // Create the TDSet out of list
- // filein - input list text file
- // treename - containg tree
- // maxFiles - maximum number of files included
+ /// Create the TDSet out of list
+ /// filein - input list text file
+ /// treename - containg tree
+ /// maxFiles - maximum number of files included
TDSet* chain = new TDSet(treeName);
TDSet* AliXRDPROOFtoolkit::MakeSetRandom(const char*fileIn, const char * treeName, const char *fName, Int_t maxFiles)
{
- //
- // Create a TDSet - files are in random order
- //
- // filein - input list text file
- // treename - containg tree
- // maxFiles - maximum number of files included
+ /// Create a TDSet - files are in random order
+ ///
+ /// filein - input list text file
+ /// treename - containg tree
+ /// maxFiles - maximum number of files included
TObjArray array(10000);
-
+
TDSet* chain = new TDSet(treeName);
// Open the input stream
if (maxFiles>entries) maxFiles=entries;
for (Int_t i=0; i<maxFiles; i++){
Int_t ifile = TMath::Nint(gRandom->Rndm()*Float_t(entries));
- if (ifile<entries && (array.At(ifile)) && array.At(ifile)->TestBit(TObject::kCannotPick)==kFALSE){
+ if (ifile<entries && (array.At(ifile)) && array.At(ifile)->TestBit(TObject::kCannotPick)==kFALSE){
printf("%d\t%d\t%s\n",i, ifile, array.At(ifile)->GetName());
chain->Add(array.At(ifile)->GetName());
array.At(ifile)->SetBit(TObject::kCannotPick);
Int_t AliXRDPROOFtoolkit::CheckTreeInFile(const char*fileName,const char*treeName, Int_t debugLevel, const char *branchName){
- //
- // Check the tree in file
- // fileName - the name of the file with tree
- // treeName - the name of file
- // debugLevel - 0 check the existance of the file - 1 make loop over entries
- // branchName - if debugLevel>0 the branch is chcecked
- // if brnachName =0 the content of full tree is chcecked
- // return value = 0 - Check things OK
- // -1 - file not exist or not accesible
- // -2 - file is zombie
- // -3 - tree not present
- // -4 - branch not present
+ /// Check the tree in file
+ /// fileName - the name of the file with tree
+ /// treeName - the name of file
+ /// debugLevel - 0 check the existance of the file - 1 make loop over entries
+ /// branchName - if debugLevel>0 the branch is chcecked
+ /// if brnachName =0 the content of full tree is chcecked
+ /// return value = 0 - Check things OK
+ /// -1 - file not exist or not accesible
+ /// -2 - file is zombie
+ /// -3 - tree not present
+ /// -4 - branch not present
+
TFile * file = TFile::Open(fileName);
if (!file) { return -1;}
if (file->IsZombie()) {file->Close(); delete file; return -2;};
TString TrName(treeName);
if (TrName=="*") {
//cout <<" treename ==== *"<<endl;;
- file->Close(); delete file;
+ file->Close(); delete file;
return 0;
}
TTree * tree = (TTree*)file->Get(treeName);
if (!branch) {file->Close(); delete file; return -4;}
}
//
- if (debugLevel==1 && tree->GetEntries()==0 ) return 1; //empty
+ if (debugLevel==1 && tree->GetEntries()==0 ) return 1; //empty
tree->SetBranchStatus("*",1);
try {
Int_t entries = tree->GetEntries();
for (Int_t i=0;i<entries; i++){
if (branch) branch->GetEntry(i);
- else tree->GetEntry();
+ else tree->GetEntry();
}
}
}catch ( ... ) {
- printf("PROBLEM\n");
+ printf("PROBLEM\n");
// never catched - as there is no exception in the ROOT IO
file->Close(); delete file;
return 1 ;
Bool_t AliXRDPROOFtoolkit::FilterList(const char*inputList, const char*fileList, Int_t checkLevel){
- //
- // Filter the list
- // inputList - list of original file names
- // fileList - list of file to be checked
- // - 0 - fileName
- // - 1 - treeName (if * not checked)
- // - 2 - fileName
- // ....
- // checkLevel - 0 - check only existance of the files and tree's +
- // simple file corruption
- // > 1 - check the content of the tree -
- // (can crash as there do not exest exception handling in ROOT)
- // Output - two streams are created - file with good entries
- // "%s.Good a,d file with bad entries %s.Bad
- //EXAMPLE:
- // AliXRDPROOFtoolkit::FilterList("ppgrid2.txt","AliESDs.root esdTree AliESDfriends.root * Kinematics.root *",1)
+ /// Filter the list
+ /// inputList - list of original file names
+ /// fileList - list of file to be checked
+ /// - 0 - fileName
+ /// - 1 - treeName (if * not checked)
+ /// - 2 - fileName
+ /// ....
+ /// checkLevel - 0 - check only existance of the files and tree's +
+ /// simple file corruption
+ /// > 1 - check the content of the tree -
+ /// (can crash as there do not exest exception handling in ROOT)
+ /// Output - two streams are created - file with good entries
+ /// "%s.Good a,d file with bad entries %s.Bad
+ /// EXAMPLE:
+ /// AliXRDPROOFtoolkit::FilterList("ppgrid2.txt","AliESDs.root esdTree AliESDfriends.root * Kinematics.root *",1)
+
gEnv->SetValue("TFile.Recover", 0);
//
fstream finput;
Int_t cstatus = CheckTreeInFile(fname, array->At(i+1)->GetName(), checkLevel,0);
//printf(" CheckTreeInFile returns %d",cstatus);
if (cstatus!=0) {
- status = cstatus;
+ status = cstatus;
break;
}
}
}else{
focBad<<currentFile<<endl;
}
- counter++;
+ counter++;
}
finput.close();
delete array;
Bool_t AliXRDPROOFtoolkit::FilterListZip(const char*inputList, const char*fileList, Int_t checkLevel){
- //
- // Filter the list
- // inputList - list of original file names
- // fileList - list of file to be checked
- // - 0 - fileName
- // - 1 - treeName (if * not checked)
- // - 2 - fileName
- // ....
- // checkLevel - 0 - check only existance of the files and tree's +
- // simple file corruption
- // > 1 - check the content of the tree -
- // (can crash as there do not exest exception handling in ROOT)
- // Output - two streams are created - file with good entries
- // "%s.Good a,d file with bad entries %s.Bad
- //EXAMPLE:
- // AliXRDPROOFtoolkit::FilterList("ppgrid2.txt","AliESDs.root esdTree AliESDfriends.root * Kinematics.root *",1)
+ /// Filter the list
+ /// inputList - list of original file names
+ /// fileList - list of file to be checked
+ /// - 0 - fileName
+ /// - 1 - treeName (if * not checked)
+ /// - 2 - fileName
+ /// ....
+ /// checkLevel - 0 - check only existance of the files and tree's +
+ /// simple file corruption
+ /// > 1 - check the content of the tree -
+ /// (can crash as there do not exest exception handling in ROOT)
+ /// Output - two streams are created - file with good entries
+ /// "%s.Good a,d file with bad entries %s.Bad
+ /// EXAMPLE:
+ /// AliXRDPROOFtoolkit::FilterList("ppgrid2.txt","AliESDs.root esdTree AliESDfriends.root * Kinematics.root *",1)
fstream finput;
finput.open(inputList, ios_base::in);
Int_t cstatus = CheckTreeInFile(fname, array->At(i+1)->GetName(), checkLevel,0);
//printf(" CheckTreeInFile returns %d",cstatus);
if (cstatus!=0) {
- status = cstatus;
+ status = cstatus;
break;
}
}
}else{
focBad<<currentFile<<endl;
}
- counter++;
+ counter++;
}
finput.close();
return kTRUE;
Bool_t AliXRDPROOFtoolkit::XRDCopyDir(const char * idir, const char * files, const char *odir, Bool_t /*zip*/){
- //
- // idir - input directory
- // odir - output directory
- // files - the list of files to be coppied
- // zip - not supported yet
- //
- // Example :
- //
- // idir ="root://gsiaf.gsi.de:1094//sma/sim/v4-05-Rev-03/pp/0000";
- // odir ="root://lxgrid2.gsi.de:1094//miranov/test/pp/0000";
- // char *files="AliESDs.root AliESDfriend.root Kinematics.root";
+ /// idir - input directory
+ /// odir - output directory
+ /// files - the list of files to be coppied
+ /// zip - not supported yet
+ ///
+ /// Example :
+ ///
+ /// idir ="root://gsiaf.gsi.de:1094//sma/sim/v4-05-Rev-03/pp/0000";
+ /// odir ="root://lxgrid2.gsi.de:1094//miranov/test/pp/0000";
+ /// char *files="AliESDs.root AliESDfriend.root Kinematics.root";
+
TString str(files);
- TObjArray * array = str.Tokenize(" ");
+ TObjArray * array = str.Tokenize(" ");
Int_t nfiles = array->GetEntries();
char infile[1000];
char outfile[1000];
snprintf(infile,1000,"%s/%s", idir, array->At(ifile)->GetName());
snprintf(outfile,1000,"%s/%s", odir, array->At(ifile)->GetName());
printf("%s - %s\n",infile, outfile);
- Bool_t result = TFile::Cp(infile,outfile);
+ Bool_t result = TFile::Cp(infile,outfile);
succes &= result;
}
delete array;
void AliXRDPROOFtoolkit::JoinTreesIndex(const char * outputFile, const char * outputTree, const char *indexName, const char *inputTrees, Int_t debugLevel){
- //
- // Join together several tree according to the index
- //
- // Parameters:
- // Output:
- // outputFile : name of the output file
- // outputTree : name of the output Tree
- // indexName : name of the branch to be used as an index
- // Input:
- // inputTrees : decription of the input trees setup
- /*
- Example usage:
-
- AliXRDPROOFtoolkit::JoinTreesIndex("outAll.root","joinAll","run","1#CPass1#run#tpcQA#TPCCPass1.root+1#VPass1#run#tpcQA#TPCVPass1.root+1#Pass1#run#tpcQA#TPCPass1.root+0#DAQ#run#joinTree#fproductionJoin.root+0#C#run#dcs#OCDBscan.root+0#CE#run#Fits#CEtrend.root");
- ==>
- Combine information form the Cpass1,VPass, and Pass1QA, calibration tree, DAQ information, trigger information
- Make a File "outAll.root", with tree "joinAll", index of tree with name "run"
- //
- // Input tree configuration string:
- //
- const char *inputTrees="1#CPass1#run#tpcQA#TPCCPass1.root+1#VPass1#run#tpcQA#TPCVPass1.root+1#Pass1#run#tpcQA#TPCPass1.root+0#DAQ#run#joinTree#/home/miranov/test/dbQueries/fproductionJoin.root+0#C#run#dcs#OCDBscan.root+0#CE#run#Fits#CEtrend.root"
- Describe 6 trees to be merged (string separated be +):
- TObjArray *arrayInput = TString(inputTrees).Tokenize("+");
- TObjString = 1#CPass1#run#tpcQA#TPCCPass1.root
- TObjString = 1#VPass1#run#tpcQA#TPCVPass1.root
- TObjString = 1#Pass1#run#tpcQA#TPCPass1.root
- TObjString = 0#DAQ#run#joinTree#/home/miranov/test/dbQueries/fproductionJoin.root
- TObjString = 0#C#run#dcs#OCDBscan.root
- TObjString = 0#CE#run#Fits#CEtrend.root
- //
- Each tree is characterize by 5 parameters - separate by #
- description="1#CPass1#run#tpcQA#TPCCPass1.root"
- TString(description)->Tokenize("#").Print()
- Collection name='TObjArray', class='TObjArray', size=16
- TObjString = 1 ==> (0/1) index is used
- TObjString = CPass1 ==> name of output branch in output tree
- TObjString = run ==> name of the index
- TObjString = tpcQA ==> name of the input tree in the input file
- TObjString = TPCCPass1.root ==> name of the input file
- */
- //
- //
- //
-
+ /// Join together several tree according to the index
+ ///
+ /// Parameters:
+ ///
+ /// Output:
+ /// - outputFile : name of the output file
+ /// - outputTree : name of the output Tree
+ /// - indexName : name of the branch to be used as an index
+ ///
+ /// Input:
+ /// - inputTrees : decription of the input trees setup
+ ///
+ /// Example usage:
+ ///
+ /// ~~~{.cxx}
+ /// AliXRDPROOFtoolkit::JoinTreesIndex("outAll.root","joinAll","run","1#CPass1#run#tpcQA#TPCCPass1.root+1#VPass1#run#tpcQA#TPCVPass1.root+1#Pass1#run#tpcQA#TPCPass1.root+0#DAQ#run#joinTree#fproductionJoin.root+0#C#run#dcs#OCDBscan.root+0#CE#run#Fits#CEtrend.root");
+ /// ~~~
+ /// Combine information form the Cpass1,VPass, and Pass1QA, calibration tree, DAQ information, trigger information
+ /// Make a File "outAll.root", with tree "joinAll", index of tree with name "run"
+ ///
+ /// ~~~{.cxx}
+ /// //
+ /// // Input tree configuration string:
+ /// //
+ /// const char *inputTrees="1#CPass1#run#tpcQA#TPCCPass1.root+1#VPass1#run#tpcQA#TPCVPass1.root+1#Pass1#run#tpcQA#TPCPass1.root+0#DAQ#run#joinTree#/home/miranov/test/dbQueries/fproductionJoin.root+0#C#run#dcs#OCDBscan.root+0#CE#run#Fits#CEtrend.root"
+ /// // Describe 6 trees to be merged (string separated be +):
+ /// TObjArray *arrayInput = TString(inputTrees).Tokenize("+");
+ /// TObjString = 1#CPass1#run#tpcQA#TPCCPass1.root
+ /// TObjString = 1#VPass1#run#tpcQA#TPCVPass1.root
+ /// TObjString = 1#Pass1#run#tpcQA#TPCPass1.root
+ /// TObjString = 0#DAQ#run#joinTree#/home/miranov/test/dbQueries/fproductionJoin.root
+ /// TObjString = 0#C#run#dcs#OCDBscan.root
+ /// TObjString = 0#CE#run#Fits#CEtrend.root
+ ///
+ /// // Each tree is characterize by 5 parameters - separate by #
+ /// description="1#CPass1#run#tpcQA#TPCCPass1.root"
+ /// TString(description)->Tokenize("#").Print()
+ /// Collection name='TObjArray', class='TObjArray', size=16
+ /// TObjString = 1 ==> (0/1) index is used
+ /// TObjString = CPass1 ==> name of output branch in output tree
+ /// TObjString = run ==> name of the index
+ /// TObjString = tpcQA ==> name of the input tree in the input file
+ /// TObjString = TPCCPass1.root ==> name of the input file
+ /// ~~~
+
TFile * fout = new TFile(outputFile,"recreate");
fout->cd();
TTree *joinTree=new TTree(outputTree,outputTree);
TObjArray *arrayInput = TString(inputTrees).Tokenize("+");
Int_t nTrees = arrayInput->GetEntries();
TObjArray * arrayFile = new TObjArray(nTrees); // array of TFiles with trees
- TObjArray * arrayTrees = new TObjArray(nTrees); // array of trees
+ TObjArray * arrayTrees = new TObjArray(nTrees); // array of trees
TObjArray * arrayNames = new TObjArray(nTrees); // name of tree
TObjArray * arrayRunID = new TObjArray(nTrees); // name of tree
- TArrayI arrayEnableTree(nTrees);
+ TArrayI arrayEnableTree(nTrees);
for (Int_t i=0; i<2; i++) printf("\n");
printf("Joing query\n");
arrayInput->Print();
return;
}
tree->SetCacheSize(400000000);
- //
+ //
arrayTrees->AddAt(tree,itree);
//
arrayRunID->AddAt(new TObjString(description->At(2)->GetName()),itree);
arrayNames->AddAt(new TObjString(description->At(1)->GetName()),itree);
- arrayEnableTree[itree]=atoi(description->At(0)->GetName());
+ arrayEnableTree[itree]=atoi(description->At(0)->GetName());
}}
- //
+ //
delete arrayInput;
// 2. Make the run list
//
Int_t entries=tree->GetEntries();
char query[2000];
snprintf(query,2000,"%s:Entry$", arrayRunID->At(itree)->GetName());
- entries = tree->Draw(query,"","goff");
+ entries = tree->Draw(query,"","goff");
for (Int_t ientry=0;ientry<entries; ientry++){
Int_t irun=Int_t(tree->GetV1()[ientry]);
// Int_t entryNr=Int_t(tree->GetV2()[ientry]);
char *brName = new char[10000];
char *brTitle= new char[10000];
//
-
+
{for (Int_t itree=0; itree<nTrees; itree++){
- TTree * tree = (TTree*)arrayTrees->At(itree);
+ TTree * tree = (TTree*)arrayTrees->At(itree);
tree->GetEntry(1);
TString treeName=arrayNames->At(itree)->GetName();
if (treeName.Length()>0){
TObject **addrClass = new TObject *;
(*addrClass)=0;
printf("%s\t%s\n",br->GetName(), className.Data());
- br->SetAddress(addrClass);
- br->GetEntry(0);
- joinTree->Branch(brName,addrClass);
- }
+ br->SetAddress(addrClass);
+ br->GetEntry(0);
+ joinTree->Branch(brName,addrClass);
+ }
}
}
}
//
// 4. Fill the trees
//
- map<int, int>::iterator riter;
+ map<int, int>::iterator riter;
{for (riter=runMap.begin(); riter != runMap.end(); ++riter){
printf("%d\t%d\t", riter->first, riter->second);
jrun=riter->first;
for (Int_t itree=0; itree<nTrees; itree++){
- TTree * tree = (TTree*)arrayTrees->At(itree);
+ TTree * tree = (TTree*)arrayTrees->At(itree);
Int_t entry= runMapTree[itree][jrun];
status[itree]=(entry>0)?1:0;
if (entry>=0) tree->GetEntry(entry);
void AliXRDPROOFtoolkit::CacheFileList(const char * fileIn, const char* cachePrefix){
- //
- // cache the list of file locally, cache valeus are stored in the location
- // specified by optional argumen prefix
- // 2 new files are created
- // <fileIn>.cache - file with the location of cahe files
- // <fileIn>.cacheLog - log file +list of files which can not be cached
- //
+ /// cache the list of file locally, cache valeus are stored in the location
+ /// specified by optional argumen prefix
+ /// 2 new files are created
+ /// <fileIn>.cache - file with the location of cahe files
+ /// <fileIn>.cacheLog - log file +list of files which can not be cached
+
/*
fileIn = "TPCCPass1.list";
cachePrefix = "";
*/
ifstream fin;
- fin.open(fileIn);
+ fin.open(fileIn);
ofstream fout;
- fout.open(Form("%s.cache",fileIn));
+ fout.open(Form("%s.cache",fileIn));
ofstream foutLog;
- foutLog.open(Form("%s.cacheLog",fileIn));
+ foutLog.open(Form("%s.cacheLog",fileIn));
// Read the input list of files and add them to the chain
TString currentFile;
TString cacheFile;
void AliXRDPROOFtoolkit::MakeTreeFromList(const char *fout, const char * treeOut, const char * treeIn, const char * flist, Bool_t debug){
- //
- // join trees from the list and make a common tree - stored in the file
- //
- /*
- Example:
- const char * fout="TPCCpass1.root";
- const char *treeOut="tpcQA"
- const char *treeIn="tpcQA"
- const char * flist="TPCCPass1.list"
- */
+ /// join trees from the list and make a common tree - stored in the file
+ ///
+ /// Example:
+ ///
+ /// ~~~{.cxx}
+ /// const char * fout="TPCCpass1.root";
+ /// const char *treeOut="tpcQA"
+ /// const char *treeIn="tpcQA"
+ /// const char * flist="TPCCPass1.list"
+ /// ~~~
+
if (debug>0){
printf("MakeTreeFromList\n");
printf("fout=%s\n",fout);
printf("treeOut=%s\n",treeOut);
printf("treeIn=%s\n",treeIn);
printf("fileList=%s\n",flist);
- }
+ }
ifstream fin;
- fin.open(flist);
+ fin.open(flist);
ofstream foutLog;
- foutLog.open(Form("%s.chainLog",flist));
+ foutLog.open(Form("%s.chainLog",flist));
// Read the input list of files and add them to the chain
TString currentFile;
Int_t counter=0;
if (!tree) {
foutLog<<"Error opening tree\t"<<currentFile<<treeIn<<"\n";
cout<<"Error opening tree\t"<<currentFile<<treeIn<<"\n";
- f->ls();
+ f->ls();
continue;
}
if (tree->GetListOfBranches()==0){
if ( nbranches!=nbranchesCurrent){
foutLog<<"Error tree layout\t"<<currentFile<<" \t"<<treeIn<<" \t"<<nbranches<<" \t"<<nbranchesCurrent<<"\n";
cout<<"Error tree layout\t" <<currentFile<<" \t"<<treeIn<<" \t"<<nbranches<<" \t"<<nbranchesCurrent<<"\n";
- }
+ }
counter++;
}
}
fileOut->cd();
tree->Write(treeOut);
delete tree;
- fileOut->Close();
+ fileOut->Close();
delete fileOut;
}
+/// \class AliXRDPROOFtoolkit
+
#ifndef _AliXRDPROOFtoolkit
#define _AliXRDPROOFtoolkit
TDSet * MakeSetRandom(const char*fileIn, const char * treeName,const char *fName=0, Int_t maxFiles=-1);
static Bool_t FilterList(const char*inputList, const char*fileList, Int_t checkLevel);
static Bool_t FilterListZip(const char*inputList, const char*fileList, Int_t checkLevel);
- Bool_t XRDCopyDir(const char * idir, const char * files, const char *odir, Bool_t zip);
+ Bool_t XRDCopyDir(const char * idir, const char * files, const char *odir, Bool_t zip);
static Int_t CheckTreeInFile(const char*fileName,const char*treeName, Int_t debugLevel=0, const char *branchName=0);
static void JoinTreesIndex(const char * outputFile, const char * outputTree, const char *indexName, const char *inputTrees, Int_t debugLevel);
static void MakeTreeFromList(const char *fout, const char * treeOut, const char * treeIn, const char * flist, Bool_t debug);
- static void CacheFileList(const char * fileIn, const char* cachePrefix);
+ static void CacheFileList(const char * fileIn, const char* cachePrefix);
private:
- Int_t fVerbose; // verbso mode - print command
- TString fUserName; // user name
- UserGroup_t *fUserGroup; // user group info
+ Int_t fVerbose; ///< verbso mode - print command
+ TString fUserName; ///< user name
+ UserGroup_t *fUserGroup; ///< user group info
AliXRDPROOFtoolkit(const AliXRDPROOFtoolkit&);
AliXRDPROOFtoolkit&operator=(const AliXRDPROOFtoolkit&);
- ClassDef(AliXRDPROOFtoolkit, 0);
+ /// \cond CLASSIMP
+ ClassDef(AliXRDPROOFtoolkit, 0);
+ /// \endcond
};
#endif
--- /dev/null
+/// \file AliTPCBoundaryVoltError_cxx_1511bb7.C
+
+ {
+ gROOT->SetStyle("Plain"); gStyle->SetPalette(1);
+ TCanvas *c2 = new TCanvas("cAliTPCBoundaryVoltError","cAliTPCBoundaryVoltError",500,300);
+ AliTPCBoundaryVoltError bve;
+ Float_t val = 40;// [Volt]; 40V corresponds to 1mm
+ /* IFC shift, CE follows, ROC follows by factor half */
+ Float_t boundA[8] = { val, val, val,0,0,0,0,val}; // voltages A-side
+ Float_t boundC[6] = {-val,-val,-val,0,0,0}; // voltages C-side
+ bve.SetBoundariesA(boundA);
+ bve.SetBoundariesC(boundC);
+ bve.SetOmegaTauT1T2(-0.32,1,1);
+ bve.SetROCDisplacement(kTRUE); // include the chamber offset in z when calculating the dz distortions
+ bve.CreateHistoDRinZR(0)->Draw("surf2");
+ return c2;
+ }
--- /dev/null
+ {
+ gROOT->SetStyle("Plain"); gStyle->SetPalette(1);
+ TCanvas *c2 = new TCanvas("cAliTPCCorrection","cAliTPCCorrection",700,1050); c2->Divide(2,3);
+ AliTPCROCVoltError3D roc; // EXAMPLE PLOTS - SEE BELOW
+ roc.SetROCDataFileName("$ALICE_ROOT/TPC/Calib/maps/TPCROCdzSurvey.root");
+ roc.SetOmegaTauT1T2(0,1,1); // B=0
+ Float_t z0 = 1; // at +1 cm -> A side
+ c2->cd(1); roc.CreateHistoDRinXY(1.,300,300)->Draw("cont4z");
+ c2->cd(3);roc.CreateHistoDRPhiinXY(1.,300,300)->Draw("cont4z");
+ c2->cd(5);roc.CreateHistoDZinXY(1.,300,300)->Draw("cont4z");
+ Float_t phi0=0.5;
+ c2->cd(2);roc.CreateHistoDRinZR(phi0)->Draw("surf2");
+ c2->cd(4);roc.CreateHistoDRPhiinZR(phi0)->Draw("surf2");
+ c2->cd(6);roc.CreateHistoDZinZR(phi0)->Draw("surf2");
+ return c2;
+ }
--- /dev/null
+ {
+ gROOT->SetStyle("Plain"); gStyle->SetPalette(1);
+ TCanvas *c2 = new TCanvas("cAliTPCExBBShape","cAliTPCExBBShape",500,300);
+ AliTPCExBBShape exb;
+ AliMagF mag("mag","mag"); // 0.5 Tesla (solenoid)
+ exb.SetBField(&mag); // use Bfield from AliMagF
+ exb.SetOmegaTauT1T2(-0.32,1.,1.); // values ideally from OCDB
+ exb.CreateHistoDRPhiinZR(0,100,100)->Draw("surf2");
+ return c2;
+ }
--- /dev/null
+ {
+ gROOT->SetStyle("Plain"); gStyle->SetPalette(1);
+ TCanvas *c2 = new TCanvas("cAliTPCExBTwist","cAliTPCExBTwist",500,300);
+ AliTPCExBTwist twist;
+ twist.SetXTwist(0.001); // x angle in [rad]
+ twist.SetXTwist(0.0005); // y angle in [rad]
+ twist.SetOmegaTauT1T2(0.32,1,1);
+ twist.CreateHistoDRPhiinXY(1.)->Draw("surf2"); // A side
+ return c2;
+ }
--- /dev/null
+ {
+ gROOT->SetStyle("Plain"); gStyle->SetPalette(1);
+ TCanvas *c2 = new TCanvas("cAliTPCVoltError3D","cAliTPCVoltError3D",500,450);
+ AliTPCFCVoltError3D fc;
+ fc.SetOmegaTauT1T2(0,1,1);
+ fc.SetRotatedClipVoltA(0,40);
+ fc.SetRodVoltShiftA(3,40);
+ fc.SetCopperRodShiftA(7+18,40);
+ fc.SetRodVoltShiftA(15+18,40);
+ fc.CreateHistoDRPhiinXY(10)->Draw("cont4z");
+ return c2;
+ }
--- /dev/null
+ {
+ gROOT->SetStyle("Plain"); gStyle->SetPalette(1);
+ TCanvas *c2 = new TCanvas("cAliTPCGGVoltError","cAliTPCGGVoltError",500,300);
+ AliTPCGGVoltError gg;
+ gg.SetDeltaVGGA(-40); gg.SetDeltaVGGC(-40); // 40 Volt offset
+ gg.InitGGVoltErrorDistortion();
+ gg.SetOmegaTauT1T2(0,1,1); // B=0
+ gg.CreateHistoDRinZR(0)->Draw("surf2");
+ return c2;
+ }
--- /dev/null
+ {
+ gROOT->SetStyle("Plain"); gStyle->SetPalette(1);
+ TCanvas *c2 = new TCanvas("cAliTPCROCVoltError3D","cAliTPCROCVoltError3D",500,400);
+ AliTPCROCVoltError3D roc;
+ roc.SetROCDataFileName("$ALICE_ROOT/TPC/TPCcalib/maps/TPCROCdzSurvey.root");
+ roc.SetElectronArrivalCorrection(kFALSE); // Correction for electron arrival offset, IROC vs OROC
+ roc.SetROCDisplacement(kTRUE); // include the chamber offset in z when calculating the dz
+ roc.SetOmegaTauT1T2(0,1,1); // B=0
+ roc.CreateHistoDZinXY(1.,300,300)->Draw("colz");
+ return c2;
+ }
--- /dev/null
+ {
+ gROOT->SetStyle("Plain"); gStyle->SetPalette(1);
+ TCanvas *c2 = new TCanvas("cAliTPCSpaceCharge","cAliTPCSpaceCharge",500,300);
+ AliTPCSpaceCharge sc;
+ sc.SetOmegaTauT1T2(-0.32,1,1); // B=0.5 Tesla
+ sc.SetCorrectionFactor(0.0015);
+ sc.CreateHistoDRinZR(0.)->Draw("surf2");
+ return c2;
+ }
git://git.uio.no / u / mrichter / AliRoot.git / commitdiff
