//*****************************************************************************
//
//_____________________________________________________________________________
-AliClusters::AliClusters()
+AliClusters::AliClusters()
+ :AliSegmentID(),
+ fClusters(0),
+ fNclusters(0),
+ fClass(0)
{
//
//default constructor
//
- fNclusters=0;
- fClusters =0;
- fClass =0;
-}
+}
+//________________________________________________________________________
+AliClusters::AliClusters(const AliClusters ¶m)
+ :AliSegmentID(),
+ fClusters(0),
+ fNclusters(0),
+ fClass(0)
+{
+ //
+ // copy constructor - dummy
+ //
+ fNclusters = param.fNclusters;
+}
+AliClusters & AliClusters::operator =(const AliClusters & param)
+{
+ //
+ // assignment operator - dummy
+ //
+ fNclusters=param.fNclusters;
+ return (*this);
+}
//________________________________________________________________________
AliClusters::~AliClusters()
{
class AliClusters : public AliSegmentID{
public:
- AliClusters();
+ AliClusters();
+ AliClusters(const AliClusters ¶m); // copy constructor
+ AliClusters &operator = (const AliClusters & param);
~AliClusters();
virtual TObject* InsertCluster(const TObject* c ); //insert copy of cluster
const TObject* operator[](Int_t i);
ClassImp(AliClustersArray)
//
-AliClustersArray::AliClustersArray()
+ AliClustersArray::AliClustersArray():AliSegmentArray(),
+ fParam(0),
+ fClFinder(0),
+ fClusterType(0)
{
//
//Default constructor
//
- fParam = 0;
- fClusterType = 0;
- fClFinder = 0;
+
}
Bool_t AliClustersArray::SetClusterType(const char * classname)
/*
$Log$
+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
ClassImp(AliComplexCluster)
+ //__________________________________________________________________
+ AliComplexCluster::AliComplexCluster()
+ :TObject(),
+ fX(0.),
+ fY(0.),
+ fQ(0.),
+ fSigmaX2(0.),
+ fSigmaY2(0.),
+ fSigmaXY(0.),
+ fArea(0.),
+ fMax(0.)
+{
+ //
+ // default constructor
+ //
+ fTracks[0]=fTracks[1]=fTracks[2]=0;
+}
//_____________________________________________________________________________
Int_t AliComplexCluster::Compare(const TObject * o) const
{
ClassImp(AliTPCTrackPoint)
ClassImp(AliTPCTrackPoint2)
ClassImp(AliTPCTrackPointRef)
-
+ //_______________________________________________________________
class AliComplexCluster : public TObject {
public:
- AliComplexCluster() {
- fTracks[0]=fTracks[1]=fTracks[2]=0;
- fX=fY=fQ=fSigmaX2=fSigmaY2=fSigmaXY=fArea=fMax=0.;
- }
+ AliComplexCluster();
virtual ~AliComplexCluster() {;}
Bool_t IsSortable() const;
Int_t Compare(const TObject *o) const;
class AliTPCClusterPoint {
public:
- AliTPCClusterPoint(){fCZ=fCY=fSigmaZ=fSigmaY=fQ=fMax=fCType=0;}
+ AliTPCClusterPoint():
+ fCZ(0),
+ fCY(0),
+ fSigmaZ(0),
+ fSigmaY(0),
+ fQ(0),
+ fMax(0),
+ fCType(0){}
virtual ~AliTPCClusterPoint(){}
Float_t GetZ() const {return (fCZ*0.01);}
Float_t GetY() const {return (fCY*0.01);}
class AliTPCExactPoint : public TObject{
public:
- AliTPCExactPoint(){fEZ=fEY=fEAngleZ=fEAngleY=fEAmp=fEPrim=fTrackID=0;}
+ AliTPCExactPoint():TObject(),
+ fEZ(0.),
+ fEY(0.),
+ fEX(0.),
+ fEAngleZ(0.),
+ fEAngleY(0.),
+ fEAmp(0.),
+ fEPrim(0.),
+ fTrackID(0),
+ fRow(0),
+ fSec(0){}
private:
Float_t fEZ; // current "exact" position according simulation
Float_t fEY; // current "exact" position according simulation
class AliTPCTrackPoint: public TObject{
public:
- AliTPCTrackPoint(){}
+ AliTPCTrackPoint():TObject(),
+ fTPoint(),
+ fCPoint(){}
+
// AliTPCClusterPoint & GetCPoint(){return fCPoint;}
AliTPCTrackerPoint & GetTPoint(){return fTPoint;}
AliTPCclusterMI & GetCPoint(){return fCPoint;}
class AliTPCTrackPoint2: public AliTPCTrackPoint{
public:
- AliTPCTrackPoint2(){}
+ AliTPCTrackPoint2():AliTPCTrackPoint(),
+ fGX(0.),
+ fGY(0.),
+ fGZ(0.),
+ fDY(0.),
+ fDZ(0.),
+ fDYU(0.),
+ fDYD(0),
+ fDZU(0.),
+ fDZD(0.),
+ fDDY(0),
+ fDDZ(0.),
+ fID(0),
+ fLab(0){}
private:
Float_t fGX; //global poition of the point
Float_t fGY; //global poition of the point
#include "AliDetectorParam.h"
-
+AliDetectorParam::AliDetectorParam()
+ :TNamed(),
+ fBField(0.),
+ fNPrimLoss(0.),
+ fNTotalLoss(0.)
+{
+ //
+ // default constructor
+ //
+}
Float_t * AliDetectorParam::GetAnglesAccMomentum(Float_t *x, Int_t * /*index*/, Float_t *momentum, Float_t *angle)
{
#include <TNamed.h>
class AliDetectorParam : public TNamed {
public:
- AliDetectorParam(){;}
+ 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;}
//transform multidimensional index to one dimesional
ClassImp(AliDigits)
-AliDigits::AliDigits()
+ AliDigits::AliDigits()
+ :AliSegmentID(),
+ fNrows(0),
+ fNcols(0),
+ fElements(0),
+ fIndex(0),
+ fBufType(0),
+ fThreshold(0),
+ fNelems(0),
+ fCurrentRow(0),
+ fCurrentCol(0),
+ fCurrentIndex(0)
{
//
//default constructor
- fIndex = 0;
- fElements = 0;
- fThreshold =0;
+ //
Invalidate();
}
-AliDigits::AliDigits(const AliDigits& digits):
- AliSegmentID(digits)
+AliDigits::AliDigits(const AliDigits& digits)
+ :AliSegmentID(digits),
+ fNrows(0),
+ fNcols(0),
+ fElements(0),
+ fIndex(0),
+ fBufType(0),
+ fThreshold(0),
+ fNelems(0),
+ fCurrentRow(0),
+ fCurrentCol(0),
+ fCurrentIndex(0)
{
//
//copy constructor
+ //
fNrows = digits.fNrows;
fNcols = digits.fNcols;
fElements = new TArrayS(*(digits.fElements));
//
AliDigitsArray::AliDigitsArray()
+ :AliSegmentArray(),
+ fParam(0)
{
- fParam = 0;
+ //
+ // default constructor
+ //
}
-
+AliDigitsArray::AliDigitsArray(const AliDigitsArray ¶m)
+ :AliSegmentArray(),
+ fParam(0)
+{
+ //
+ // dummy
+ //
+ fParam = param.fParam;
+}
+//
+AliDigitsArray & AliDigitsArray::operator =(const AliDigitsArray & param)
+{
+ //
+ // dummy
+ //
+ fParam = param.fParam;
+ return (*this);
+}
+//
AliDigitsArray::~AliDigitsArray()
{
// if (fParam != 0) delete fParam;
class AliDigitsArray : public AliSegmentArray {
public:
AliDigitsArray();
+ AliDigitsArray(const AliDigitsArray ¶m); // copy constructor
+ AliDigitsArray &operator = (const AliDigitsArray & param);
virtual ~AliDigitsArray();
virtual Bool_t Setup(AliDetectorParam *param); //setup array according parameters
const AliDetectorParam * GetParam() {return fParam;}
//_____________________________________________________________________________
ClassImp(AliSegmentArray)
-AliSegmentArray::AliSegmentArray()
+ AliSegmentArray::AliSegmentArray()
+ :TNamed(),
+ fSegment(0),
+ fTreeIndex(0),
+ fNSegment(0),
+ fTree(0),
+ fTreeOwner(kFALSE),
+ fBranch(0),
+ fClass(0)
{
//
+ // constructor
//
- //
- fNSegment=0;
- fSegment =0;
- fTreeIndex = 0;
- fTree = 0;
- fClass = 0;
- fBranch = 0;
- fTreeOwner = kFALSE;
+
}
AliSegmentArray::AliSegmentArray(const char *classname, Int_t n)
+ :TNamed("SegmentArray","SegmentArray"),
+ fSegment(0),
+ fTreeIndex(0),
+ fNSegment(0),
+ fTree(0),
+ fTreeOwner(kFALSE),
+ 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.
- fTreeOwner = kFALSE;
- fNSegment=0;
- fSegment =0;
- fTreeIndex = 0;
- fTree = 0;
- fClass = 0;
- SetName("SegmentArray");
- SetTitle("SegmentArray");
+
SetClass(classname);
if (MakeArray(n)==kFALSE){
}
}
-AliSegmentArray::AliSegmentArray(const AliSegmentArray &segment):
- TNamed(segment)
+AliSegmentArray::AliSegmentArray(const AliSegmentArray &segment)
+ :TNamed(segment),
+ fSegment(0),
+ fTreeIndex(0),
+ fNSegment(0),
+ fTree(0),
+ fTreeOwner(kFALSE),
+ fBranch(0),
+ fClass(0)
+
{
//
//copy constructor
#include "AliSegmentID.h"
-AliSegmentID::AliSegmentID()
-{
-}
+
ClassImp(AliSegmentID)
class AliSegmentID: public TObject{
public:
- AliSegmentID();
- AliSegmentID(Int_t index){fSegmentID = index;}
+ AliSegmentID() : fSegmentID(0) {}
+ AliSegmentID(Int_t index) : fSegmentID(index) {}
Int_t GetID() {return fSegmentID;}
void SetID(Int_t index){fSegmentID = index;}
protected:
ClassImp(AliSimDigits)
AliSimDigits::AliSimDigits()
+ :AliDigits(),
+ fTracks(0),
+ fTrIndex(0),
+ fNlevel(0),
+ fTrBufType(0)
{
// AliDigits::Invalite();
- fTracks = 0;
- fTrIndex = 0;
+
InvalidateTrack();
}
+//
+AliSimDigits::AliSimDigits(const AliSimDigits ¶m)
+ :AliDigits(),
+ fTracks(0),
+ fTrIndex(0),
+ fNlevel(0),
+ fTrBufType(0)
+{
+ //
+ // dummy
+ //
+ fTrIndex = param.fTrIndex;
+}
+//
AliSimDigits::~AliSimDigits()
{
}
}
+AliSimDigits & AliSimDigits::operator =(const AliSimDigits & param)
+{
+ //
+ // assignment operator - dummy
+ //
+ fTrIndex=param.fTrIndex;
+ return (*this);
+}
+//__________________________________________________________________
void AliSimDigits::InvalidateTrack()
{
//
class AliSimDigits : public AliDigits{
public:
AliSimDigits();
+ AliSimDigits(const AliSimDigits ¶m);
+ AliSimDigits &operator = (const AliSimDigits & digits);
virtual ~AliSimDigits();
void AllocateTrack(Int_t length); //construct empty buffer fTracks with size rows x column x length (number of tracks for one digit)
Int_t *GetTracks(){return fTracks->GetArray();}
ClassImp(AliTPC)
//_____________________________________________________________________________
-AliTPC::AliTPC()
+ AliTPC::AliTPC():AliDetector(),
+ fDefaults(0),
+ fSens(0),
+ fNsectors(0),
+ fDigitsArray(0),
+ fTPCParam(0),
+ fTrackHits(0),
+ fHitType(0),
+ fDigitsSwitch(0),
+ fSide(0),
+ fNoiseDepth(0),
+ fNoiseTable(0),
+ fCurrentNoise(0),
+ fActiveSectors(0)
+
{
//
// Default constructor
//
fIshunt = 0;
- fHits = 0;
- fDigits = 0;
- fNsectors = 0;
- fDigitsArray = 0;
- fDefaults = 0;
- fTrackHits = 0;
+
// fTrackHitsOld = 0;
#if ROOT_VERSION_CODE >= ROOT_VERSION(4,0,1)
fHitType = 4; // ROOT containers
#else
fHitType = 2; //default CONTAINERS - based on ROOT structure
#endif
- fTPCParam = 0;
- fNoiseTable = 0;
- fActiveSectors =0;
- fSens = 0;
+
}
//_____________________________________________________________________________
AliTPC::AliTPC(const char *name, const char *title)
- : AliDetector(name,title)
+ : AliDetector(name,title),
+ fDefaults(0),
+ fSens(0),
+ fNsectors(0),
+ fDigitsArray(0),
+ fTPCParam(0),
+ fTrackHits(0),
+ fHitType(0),
+ fDigitsSwitch(0),
+ fSide(0),
+ fNoiseDepth(0),
+ fNoiseTable(0),
+ fCurrentNoise(0),
+ fActiveSectors(0)
{
//
// Standard constructor
// Initialise arrays of hits and digits
fHits = new TClonesArray("AliTPChit", 176);
gAlice->GetMCApp()->AddHitList(fHits);
- fDigitsArray = 0;
- fDefaults = 0;
//
fTrackHits = new AliTPCTrackHitsV2;
fTrackHits->SetHitPrecision(0.002);
//fTrackHitsOld->SetStepPrecision(0.003);
//fTrackHitsOld->SetMaxDistance(100);
- fNoiseTable =0;
#if ROOT_VERSION_CODE >= ROOT_VERSION(4,0,1)
fHitType = 4; // ROOT containers
#else
fHitType = 2;
#endif
- fActiveSectors = 0;
- //
- // Initialise counters
- fNsectors = 0;
+
+
//
fIshunt = 0;
AliWarning("In Config.C you must set non-default parameters.");
fTPCParam=0;
}
- fSens = 0;
+
}
//_____________________________________________________________________________
-AliTPC::AliTPC(const AliTPC& t):AliDetector(t){
+AliTPC::AliTPC(const AliTPC& t):AliDetector(t),
+ fDefaults(0),
+ fSens(0),
+ fNsectors(0),
+ fDigitsArray(0),
+ fTPCParam(0),
+ fTrackHits(0),
+ fHitType(0),
+ fDigitsSwitch(0),
+ fSide(0),
+ fNoiseDepth(0),
+ fNoiseTable(0),
+ fCurrentNoise(0),
+ fActiveSectors(0)
+{
//
// dummy copy constructor
//
}
+//
+AliTPC & AliTPC::operator =(const AliTPC & param)
+{
+ //
+ // assignment operator - dummy
+ //
+ fDefaults=param.fDefaults;
+ return (*this);
+}
+
+//
AliTPC::~AliTPC()
{
//
}
ClassImp(AliTPChit)
-
+ //______________________________________________________________________
+ AliTPChit::AliTPChit()
+ :AliHit(),
+ fSector(0),
+ fPadRow(0),
+ fQ(0),
+ fTime(0)
+{
+ //
+ // default
+ //
+
+}
//_____________________________________________________________________________
-AliTPChit::AliTPChit(Int_t shunt, Int_t track, Int_t *vol, Float_t *hits):
-AliHit(shunt,track)
+AliTPChit::AliTPChit(Int_t shunt, Int_t track, Int_t *vol, Float_t *hits)
+ :AliHit(shunt,track),
+ fSector(0),
+ fPadRow(0),
+ fQ(0),
+ fTime(0)
{
//
// Creates a TPC hit object
AliTPC();
AliTPC(const char *name, const char *title);
AliTPC(const AliTPC& t);
+ AliTPC &operator = (const AliTPC & param);
virtual AliLoader* MakeLoader(const char* topfoldername);
Float_t fTime; //hit time
public:
- AliTPChit() {fTime = 0.;}
+ AliTPChit();
AliTPChit(Int_t shunt, Int_t track, Int_t *vol, Float_t *hits);
virtual ~AliTPChit() {}
void SetX(Float_t x){fX = x;}
ClassImp(AliTPCBuffer)
//////////////////////////////////////////////////////////////////////////////////////////////////////////////
-AliTPCBuffer::AliTPCBuffer(const char* fileName){
+//___________________________________________________________
+ AliTPCBuffer::AliTPCBuffer():TObject(),
+ fVerbose(0),
+ fNumberOfDigits(0),
+ f()
+{
+ //
+ // default
+ //
+}
+//____________________________________________________________
+ AliTPCBuffer::AliTPCBuffer(const char* fileName):TObject(),
+ fVerbose(0),
+ fNumberOfDigits(0),
+ f()
+{
// Constructor
#ifndef __DECCXX
f.open(fileName,ios::binary|ios::out);
#endif
// fout=new TFile(fileName,"recreate");
// tree=new TTree("tree","Values");
- fNumberOfDigits=0;
- fVerbose=0;
+
remove("TPCdigits.txt");
}
//delete fout;
}
//////////////////////////////////////////////////////////////////////////////////////////////////////////////
-AliTPCBuffer::AliTPCBuffer(const AliTPCBuffer &source):TObject(source){
+AliTPCBuffer::AliTPCBuffer(const AliTPCBuffer &source):TObject(source),
+ fVerbose(0),
+ fNumberOfDigits(0),
+ f()
+{
// Copy Constructor
this->fVerbose=source.fVerbose;
return;
//class TFile;
class AliTPCBuffer:public TObject{
public:
- AliTPCBuffer(){
- //default constructor
- }
+ AliTPCBuffer();
+
+ //
AliTPCBuffer(const char* fileName);//constructor
virtual ~AliTPCBuffer();//destructor
AliTPCBuffer(const AliTPCBuffer &source); // copy constructor
void SetVerbose(Int_t val){fVerbose=val;}
private:
Int_t fVerbose; //Verbosity level: 0-silent, 1:cout msg, 2: txt files for checking
- fstream f; //The IO file name
+
//TFile *fout;
//TTree *tree;
UInt_t fNumberOfDigits; //Number of TPC digits
+ fstream f; //The IO file name
ClassDef(AliTPCBuffer,1)
};
//_____________________________________________________________________________
-AliTPCCalROC::AliTPCCalROC():TObject()
+AliTPCCalROC::AliTPCCalROC()
+ :TObject(),
+ fSector(0),
+ fNChannels(0),
+ fNRows(0),
+ fIndexes(0),
+ fData(0)
{
//
// Default constructor
//
- fSector = 0;
- fNChannels = 0;
- fNRows = 0;
- fData = 0;
+
}
//_____________________________________________________________________________
-AliTPCCalROC::AliTPCCalROC(UInt_t sector):TObject()
+AliTPCCalROC::AliTPCCalROC(UInt_t sector)
+ :TObject(),
+ fSector(0),
+ fNChannels(0),
+ fNRows(0),
+ fIndexes(0),
+ fData(0)
{
//
// Constructor that initializes a given sector
}
//_____________________________________________________________________________
-AliTPCCalROC::AliTPCCalROC(const AliTPCCalROC &c):TObject(c)
+AliTPCCalROC::AliTPCCalROC(const AliTPCCalROC &c)
+ :TObject(c),
+ fSector(0),
+ fNChannels(0),
+ fNRows(0),
+ fIndexes(0),
+ fData(0)
{
//
// AliTPCCalROC copy constructor
fData = new Float_t[fNChannels];
for (UInt_t idata = 0; idata< fNChannels; idata++) fData[idata] = c.fData[idata];
}
+//____________________________________________________________________________
+AliTPCCalROC & AliTPCCalROC::operator =(const AliTPCCalROC & param)
+{
+ //
+ // assignment operator - dummy
+ //
+ fData=param.fData;
+ return (*this);
+}
+
//_____________________________________________________________________________
AliTPCCalROC::~AliTPCCalROC()
AliTPCCalROC();
AliTPCCalROC(UInt_t sector);
AliTPCCalROC(const AliTPCCalROC &c);
+ AliTPCCalROC &operator = (const AliTPCCalROC & param);
virtual ~AliTPCCalROC();
UInt_t GetNrows() const { return fNRows;};
UInt_t GetNchannels() const { return fNChannels;};
////////////////////////////////////////////////////////////////////////////////////////
AliTPCDDLRawData::AliTPCDDLRawData(const AliTPCDDLRawData &source):
- TObject(source)
+ TObject(source),
+ fVerbose(0)
{
// Copy Constructor
fVerbose=source.fVerbose;
class AliTPCDDLRawData:public TObject{
public:
- AliTPCDDLRawData(){fVerbose=0;}//default constructor
+ AliTPCDDLRawData():TObject(),
+ fVerbose(0){}//default constructor
virtual ~AliTPCDDLRawData(){;}//destructor
AliTPCDDLRawData(const AliTPCDDLRawData &source); // copy constructor
AliTPCDDLRawData& operator=(const AliTPCDDLRawData &source); // ass. op.
ClassImp(AliTPCDigitizer)
//___________________________________________
-AliTPCDigitizer::AliTPCDigitizer() :AliDigitizer()
+ AliTPCDigitizer::AliTPCDigitizer() :AliDigitizer(),fDebug(0)
{
+ //
// Default ctor - don't use it
- fDebug =0;
+//
+
}
//___________________________________________
AliTPCDigitizer::AliTPCDigitizer(AliRunDigitizer* manager)
- :AliDigitizer(manager)
+ :AliDigitizer(manager),fDebug(0)
{
+ //
// ctor which should be used
- fDebug =0;
+//
AliDebug(2,"(AliRunDigitizer* manager) was processed");
}
ClassImp(AliTPCDigitsArray)
AliTPCDigitsArray::AliTPCDigitsArray(Bool_t sim)
+ :AliDigitsArray(),
+ fBSim(kFALSE),
+ fCompression(0),
+ fTrackLevel(0)
{
//
//default constructor
#include "AliLog.h"
ClassImp(AliTPCFast)
+ //____________________________________________________________________
+AliTPCFast::AliTPCFast(const AliTPCFast ¶m)
+ :TObject(param),fParam(0)
+{
+ //
+ // copy constructor - dummy
+ //
+ fParam = param.fParam;
+}
+AliTPCFast & AliTPCFast::operator =(const AliTPCFast & param)
+{
+ //
+ // assignment operator - dummy
+ //
+ fParam=param.fParam;
+ return (*this);
+}
//_____________________________________________________________________________
void AliTPCFast::Hits2Clusters(AliRunLoader* runLoader) const
class AliTPCFast : public TObject {
public:
+ AliTPCFast():TObject(),fParam(0){}
+ AliTPCFast(const AliTPCFast ¶m); // copy constructor
+ AliTPCFast &operator = (const AliTPCFast & param); //assignment
void Hits2Clusters(AliRunLoader* runLoader) const;
void Hits2ExactClusters(AliRunLoader* runLoader) const;
void Hits2ExactClustersSector(AliRunLoader* runLoader,
ClassImp(AliTPCPRF2D)
AliTPCPRF2D::AliTPCPRF2D()
+ :TObject(),
+ fcharge(0),
+ fY1(0.),
+ fY2(0.),
+ fNYdiv(0),
+ fNChargeArray(0),
+ fChargeArray(0),
+ fHeightFull(0.),
+ fHeightS(0.),
+ fShiftY(0.),
+ fWidth(0.),
+ fK(0.),
+ fNPRF(0),
+ fNdiv(5),
+ fDStep(0.),
+ fKNorm(1.),
+ fInteg(0.),
+ fGRF(0),
+ fK3X(0.),
+ fK3Y(0.),
+ fPadDistance(0.),
+ fOrigSigmaX(0.),
+ fOrigSigmaY(0.),
+ fChargeAngle(0.),
+ fPadAngle(0.),
+ fSigmaX(0.),
+ fSigmaY(0.),
+ fMeanX(0.),
+ fMeanY(0.),
+ fInterX(0),
+ fInterY(0),
+ fCurrentY(0.),
+ fDYtoWire(0.),
+ fDStepM1(0.)
{
//default constructor for response function object
- fcharge = 0;
- fNChargeArray = 0;
- fChargeArray = 0;
+
fNPRF =fgkNPRF ;
- fSigmaX = 0;
- fSigmaY = 0;
- fGRF = 0;
- fKNorm = 1;
- fOrigSigmaY=0;
- fOrigSigmaX=0;
- fNdiv = 5;
- //set daault angels
- fChargeAngle = 0;
- fPadAngle = 0;
//chewron default values
SetPad(0.8,0.8);
SetChevron(0.2,0.0,1.0);
//___________________________________________
AliTPCParam::AliTPCParam()
+ :AliDetectorParam(),
+ fbStatus(kFALSE),
+ fInnerRadiusLow(0.),
+ fInnerRadiusUp(0.),
+ fOuterRadiusUp(0.),
+ fOuterRadiusLow(0.),
+ fInnerAngle(0.),
+ fInnerAngleShift(0.),
+ fOuterAngle(0.),
+ fOuterAngleShift(0.),
+ fInnerFrameSpace(0.),
+ fOuterFrameSpace(0.),
+ fInnerWireMount(0.),
+ fOuterWireMount(0.),
+ fNInnerSector(0),
+ fNOuterSector(0),
+ fNSector(0),
+ fZLength(0),
+ fRotAngle(),
+ fGeometryType(0),
+ fTrackingMatrix(0),
+ fClusterMatrix(0),
+ fGlobalMatrix(0),
+ fNInnerWiresPerPad(0),
+ fInnerWWPitch(0),
+ fInnerDummyWire(0),
+ fInnerOffWire(0.),
+ fRInnerFirstWire(0.),
+ fRInnerLastWire(0.),
+ fLastWireUp1(0.),
+ fNOuter1WiresPerPad(0),
+ fNOuter2WiresPerPad(0),
+ fOuterWWPitch(0.),
+ fOuterDummyWire(0),
+ fOuterOffWire(0.),
+ fROuterFirstWire(0.),
+ fROuterLastWire(0.),
+ fInnerPadPitchLength(0.),
+ fInnerPadPitchWidth(0.),
+ fInnerPadLength(0.),
+ fInnerPadWidth(0.),
+ fOuter1PadPitchLength(0.),
+ fOuter2PadPitchLength(0.),
+ fOuterPadPitchWidth(0.),
+ fOuter1PadLength(0.),
+ fOuter2PadLength(0.),
+ fOuterPadWidth(0.),
+ fBMWPCReadout(kFALSE),
+ fNCrossRows(0),
+ fNRowLow(0),
+ fNRowUp1(0),
+ fNRowUp2(0),
+ fNRowUp(0),
+ fNtRows(0),
+ fDiffT(0.),
+ fDiffL(0.),
+ fGasGain(0.),
+ fDriftV(0.),
+ fOmegaTau(0.),
+ fAttCoef(0.),
+ fOxyCont(0.),
+ fPadCoupling(0.),
+ fZeroSup(0),
+ fNoise(0.),
+ fChipGain(0.),
+ fChipNorm(0.),
+ fTSample(0.),
+ fZWidth(0.),
+ fTSigma(0.),
+ fMaxTBin(0),
+ fADCSat(0),
+ fADCDynRange(0.),
+ fTotalNormFac(0.),
+ fNoiseNormFac(0.),
+ fNResponseMax(0),
+ fResponseThreshold(0.),
+ fCurrentMax(0),
+ fResponseBin(0),
+ fResponseWeight(0),
+ fGateDelay(0.),
+ fL1Delay(0.),
+ fNTBinsBeforeL1(0),
+ fNTBinsL1(0.)
{
//
//constructor sets the default parameters
//
- fResponseBin = 0;
- fResponseWeight = 0;
- fRotAngle = 0;
- fTrackingMatrix = fClusterMatrix = fGlobalMatrix = 0;
SetTitle("75x40_100x60_150x60");
SetDefault();
}
static const Float_t kEdgeSectorSpace = 2.5;
AliTPCParamCR::AliTPCParamCR()
+ :AliTPCParam(),
+ fInnerPRF(0),
+ fOuter1PRF(0),
+ fOuter2PRF(0),
+ fTimeRF(0),
+ fFacSigma(0.)
{
//
//constructor set the default parameters
- fInnerPRF=0;
- fOuter1PRF=0;
- fOuter2PRF=0;
- fTimeRF = 0;
+
fFacSigma = Float_t(2.);
SetDefault();
Update();
}
-
+AliTPCParamCR::AliTPCParamCR(const AliTPCParamCR ¶m)
+ :AliTPCParam(),
+ fInnerPRF(0),
+ fOuter1PRF(0),
+ fOuter2PRF(0),
+ fTimeRF(0),
+ fFacSigma(0.)
+{
+ //
+ // copy constructor - dummy
+ //
+ fFacSigma= param.fFacSigma;
+}
+AliTPCParamCR & AliTPCParamCR::operator =(const AliTPCParamCR & param)
+{
+ //
+ // assignment operator - dummy
+ //
+ fFacSigma= param.fFacSigma;
+ return (*this);
+}
AliTPCParamCR::~AliTPCParamCR()
{
//
class AliTPCParamCR : public AliTPCParam {
public:
AliTPCParamCR();
+ AliTPCParamCR(const AliTPCParamCR ¶m); // copy constructor
+ AliTPCParamCR &operator = (const AliTPCParamCR & param); //assignment operator
virtual ~AliTPCParamCR();
Int_t CalcResponse(Float_t* x, Int_t * index, Int_t dummy=0);
//calculate bin response as function of the input position -x
AliTPCParamSR::AliTPCParamSR()
+ :AliTPCParam(),
+ fInnerPRF(0),
+ fOuter1PRF(0),
+ fOuter2PRF(0),
+ fTimeRF(0),
+ fFacSigmaPadRow(0),
+ fFacSigmaPad(0),
+ fFacSigmaTime(0)
{
//
//constructor set the default parameters
- fInnerPRF=0;
- fOuter1PRF=0;
- fOuter2PRF=0;
- fTimeRF = 0;
+ //
+
fFacSigmaPadRow = Float_t(kFacSigmaPadRow);
fFacSigmaPad = Float_t(kFacSigmaPad);
fFacSigmaTime = Float_t(kFacSigmaTime);
SetDefault();
Update();
}
+AliTPCParamSR::AliTPCParamSR(const AliTPCParamSR ¶m)
+ :AliTPCParam(),
+ fInnerPRF(0),
+ fOuter1PRF(0),
+ fOuter2PRF(0),
+ fTimeRF(0),
+ fFacSigmaPadRow(0),
+ fFacSigmaPad(0),
+ fFacSigmaTime(0)
+{
+ //
+ // copy constructor - dummy
+ //
+ fFacSigmaPadRow = param.fFacSigmaPadRow;
+}
+AliTPCParamSR & AliTPCParamSR::operator =(const AliTPCParamSR & param)
+{
+ //
+ // assignment operator - dummy
+ //
+ fZLength=param.fZLength;
+ return (*this);
+}
AliTPCParamSR::~AliTPCParamSR()
{
class AliTPCParamSR : public AliTPCParam {
public:
AliTPCParamSR();
+ AliTPCParamSR(const AliTPCParamSR ¶m); // copy constructor
+ AliTPCParamSR &operator = (const AliTPCParamSR & param); //assignment operator
virtual ~AliTPCParamSR();
Int_t CalcResponse(Float_t* x, Int_t * index, Int_t row);
// pid class by B. Batyunya
// stupid corrections by M.K.
//
+//_______________________________________________________
//________________________________________________________
- AliTPCPid::AliTPCPid( const AliTPCPid& r):TObject(r)
+AliTPCPid::AliTPCPid( const AliTPCPid& r):TObject(r),
+ fCutKa(0),
+ fCutPr(0),
+ fCutKaTune(0.),
+ fCutPrTune(0.),
+ fSigmin(0.),
+ fSilent(0),
+ fmxtrs(0),
+ trs(0),
+ fqtot(0.),
+ fWpi(0.),
+ fWk(0.),
+ fWp(0.),
+ fRpik(0.),
+ fRppi(0.),
+ fRpka(0.),
+ fRp(0.),
+ fPcode(0)
{
// dummy copy constructor
}
if(fcorr<=0.1)fcorr=0.1;
return fqtot/fcorr;
}
+//__________________________________________________________
+AliTPCPid & AliTPCPid::operator =(const AliTPCPid & param)
+{
+ //
+ // assignment operator - dummy
+ //
+ fSigmin=param.fSigmin;
+ return (*this);
+}
//-----------------------------------------------------------
Float_t AliTPCPid::Qtrm(Int_t track) const
{
}
}
//-----------------------------------------------------------
-AliTPCPid::AliTPCPid(Int_t ntrack)
+AliTPCPid::AliTPCPid(Int_t ntrack):TObject(),
+ fCutKa(0),
+ fCutPr(0),
+ fCutKaTune(0.),
+ fCutPrTune(0.),
+ fSigmin(0.),
+ fSilent(0),
+ fmxtrs(0),
+ trs(0),
+ fqtot(0.),
+ fWpi(0.),
+ fWk(0.),
+ fWp(0.),
+ fRpik(0.),
+ fRppi(0.),
+ fRpka(0.),
+ fRp(0.),
+ fPcode(0)
{
trs = new TClonesArray("TVector",ntrack);
TClonesArray &arr=*trs;
for(Int_t i=0;i<ntrack;i++)new(arr[i])TVector(0,11);
- fmxtrs=0;
+
//fCutKa = new TF1("fkaons","[0]/x/x+[1]",0.1,1.2);
//fCutPr = new TF1("fprotons","[0]/x/x +[1]",0.2,1.2);
public TObject {
public:
- AliTPCPid(Int_t ntrs=1000);
+ AliTPCPid(Int_t ntrs=1000);
virtual ~AliTPCPid(){}
AliTPCPid( const AliTPCPid& r);
+ AliTPCPid &operator = (const AliTPCPid & param); //assignment
void SetEdep(Int_t track,Float_t Edep);
void SetPmom(Int_t track,Float_t Pmom);
void SetPcod(Int_t track,Int_t Pcod);
AliTPCRF1D::AliTPCRF1D(Bool_t direct,Int_t np,Float_t step)
+ :TObject(),
+ fNRF(0),
+ fDSTEPM1(0.),
+ fcharge(0),
+ forigsigma(0.),
+ fpadWidth(3.5),
+ fkNorm(0.5),
+ fInteg(0.),
+ fGRF(0),
+ fSigma(0.),
+ fOffset(0.),
+ fDirect(kFALSE),
+ fPadDistance(0.)
{
//default constructor for response function object
fDirect=direct;
fcharge = new Float_t[fNRF];
if (step>0) fDSTEPM1=1./step;
else fDSTEPM1 = 1./fgRFDSTEP;
- fSigma = 0;
- fGRF = 0;
- fkNorm = 0.5;
- fpadWidth = 3.5;
- forigsigma=0.;
- fOffset = 0.;
}
-AliTPCRF1D::AliTPCRF1D(const AliTPCRF1D &prf):TObject(prf)
+AliTPCRF1D::AliTPCRF1D(const AliTPCRF1D &prf)
+ :TObject(prf),
+ fNRF(0),
+ fDSTEPM1(0.),
+ fcharge(0),
+ forigsigma(0.),
+ fpadWidth(3.5),
+ fkNorm(0.5),
+ fInteg(0.),
+ fGRF(0),
+ fSigma(0.),
+ fOffset(0.),
+ fDirect(kFALSE),
+ fPadDistance(0.)
{
//
//_____________________________________________________________________________
-AliTPCROC::AliTPCROC():TObject(), fNSectorsAll(0)
+AliTPCROC::AliTPCROC()
+ :TObject(),
+ fNSectorsAll(0),
+ fInnerRadiusLow(0.),
+ fInnerRadiusUp(0.),
+ fOuterRadiusUp(0.),
+ fOuterRadiusLow(0.),
+ fInnerFrameSpace(0.),
+ fOuterFrameSpace(0.),
+ fInnerWireMount(0.),
+ fOuterWireMount(0.),
+ fZLength(0.),
+ fInnerAngle(0.),
+ fOuterAngle(0.),
+ fNInnerWiresPerPad(0),
+ fInnerWWPitch(0.),
+ fInnerDummyWire(0),
+ fInnerOffWire(0.),
+ fRInnerFirstWire(0.),
+ fRInnerLastWire(0.),
+ fLastWireUp1(0.),
+ fNOuter1WiresPerPad(0),
+ fNOuter2WiresPerPad(0),
+ fOuterWWPitch(0.),
+ fOuterDummyWire(0),
+ fOuterOffWire(0),
+ fROuterFirstWire(0.),
+ fROuterLastWire(0),
+ fInnerPadPitchLength(0.),
+ fInnerPadPitchWidth(0.),
+ fInnerPadLength(0.),
+ fInnerPadWidth(0.),
+ fOuter1PadPitchLength(0.),
+ fOuter2PadPitchLength(0),
+ fOuterPadPitchWidth(0),
+ fOuter1PadLength(0.),
+ fOuter2PadLength(0),
+ fOuterPadWidth(0),
+ fNRowLow(0),
+ fNRowUp1(0),
+ fNRowUp2(0),
+ fNRowUp(0),
+ fNtRows(0)
{
//
// Default constructor
//_____________________________________________________________________________
-AliTPCROC::AliTPCROC(const AliTPCROC &roc):TObject(roc)
+AliTPCROC::AliTPCROC(const AliTPCROC &roc)
+ :TObject(roc),
+ fNSectorsAll(0),
+ fInnerRadiusLow(0.),
+ fInnerRadiusUp(0.),
+ fOuterRadiusUp(0.),
+ fOuterRadiusLow(0.),
+ fInnerFrameSpace(0.),
+ fOuterFrameSpace(0.),
+ fInnerWireMount(0.),
+ fOuterWireMount(0.),
+ fZLength(0.),
+ fInnerAngle(0.),
+ fOuterAngle(0.),
+ fNInnerWiresPerPad(0),
+ fInnerWWPitch(0.),
+ fInnerDummyWire(0),
+ fInnerOffWire(0.),
+ fRInnerFirstWire(0.),
+ fRInnerLastWire(0.),
+ fLastWireUp1(0.),
+ fNOuter1WiresPerPad(0),
+ fNOuter2WiresPerPad(0),
+ fOuterWWPitch(0.),
+ fOuterDummyWire(0),
+ fOuterOffWire(0),
+ fROuterFirstWire(0.),
+ fROuterLastWire(0),
+ fInnerPadPitchLength(0.),
+ fInnerPadPitchWidth(0.),
+ fInnerPadLength(0.),
+ fInnerPadWidth(0.),
+ fOuter1PadPitchLength(0.),
+ fOuter2PadPitchLength(0),
+ fOuterPadPitchWidth(0),
+ fOuter1PadLength(0.),
+ fOuter2PadLength(0),
+ fOuterPadWidth(0),
+ fNRowLow(0),
+ fNRowUp1(0),
+ fNRowUp2(0),
+ fNRowUp(0),
+ fNtRows(0)
+
{
//
// AliTPCROC copy constructor
fRowPosIndex[1][irow] = roc.fRowPosIndex[1][irow];
}
}
-
+//____________________________________________________________________________
+AliTPCROC & AliTPCROC::operator =(const AliTPCROC & roc)
+{
+ //
+ // assignment operator - dummy
+ //
+ fZLength = roc.fZLength;
+ return (*this);
+}
//_____________________________________________________________________________
AliTPCROC::~AliTPCROC()
{
static AliTPCROC* Instance();
AliTPCROC();
AliTPCROC(const AliTPCROC &roc);
+ AliTPCROC &operator = (const AliTPCROC & roc); //assignment operator
void Init();
virtual ~AliTPCROC();
AliTPCTempHitInfoV2::AliTPCTempHitInfoV2()
+ :fSumDr(0.),
+ fSumDr2(0.),
+ fSumDr3(0.),
+ fSumDr4(0.),
+ fSumDFi(0.),
+ fSumDFiDr(0.),
+ fSumDFiDr2(0.),
+ fSumDZ(0.),
+ fSumDZDr(0.),
+ fSumDZDr2(0.),
+ fOldR(0.),
+ fStackIndex(0),
+ fParamIndex(0),
+ fParam(0)
{
//
// Standard constructor
}
-AliTrackHitsParamV2::AliTrackHitsParamV2()
+AliTrackHitsParamV2::AliTrackHitsParamV2():TObject(),
+ fTrackID(0),
+ fVolumeID(0),
+ fR(0.),
+ fZ(0.),
+ fFi(0.),
+ fAn(0.),
+ fAd(0.),
+ fTheta(0.),
+ fThetaD(0.),
+ fNHits(0),
+ fHitDistance(0),
+ fCharge(0),
+ fTime(0)
{
//
// default constructor
//
fgCounter1++;
fgCounter2++;
- fHitDistance=0;
- fCharge=0;
- fTime=0;
- fNHits=0;
}
AliTrackHitsParamV2::~AliTrackHitsParamV2()
}
-AliTPCTrackHitsV2::AliTPCTrackHitsV2()
+AliTPCTrackHitsV2::AliTPCTrackHitsV2():TObject(),
+ fArray(0),
+ fSize(0),
+ fPrecision(0.),
+ fStep(0.),
+ fMaxDistance(0),
+ fNVolumes(0),
+ fVolumes(0),
+ fTempInfo(0),
+ fCurrentHit(0),
+ fHit(0)
{
//
//default constructor
fPrecision=kHitPrecision; //precision in cm
fStep = kStep; //step size
fMaxDistance = kMaxDistance; //maximum distance
- fTempInfo =0;
- fSize=0;
+
//fTrackHitsInfo = new AliObjectArray("AliTrackHitsInfo");
//fTrackHitsParam = new AliObjectArray("AliTrackHitsParamV2");
//fHitsPosAndQ = new TArrayOfArrayVStack("AliHitInfo");
fArray = new TClonesArray("AliTrackHitsParamV2");
fCurrentHit = new AliTPCCurrentHitV2;
- fVolumes =0;
- fNVolumes =0;
- fHit =0;
fgCounter1++;
fgCounter2++;
class AliTrackHitsParamV2 : public TObject {
+
public:
AliTrackHitsParamV2();
- AliTrackHitsParamV2(const AliTrackHitsParamV2 &hit): TObject(hit)
+
+ AliTrackHitsParamV2(const AliTrackHitsParamV2 &hit): TObject(hit),
+ fTrackID(0),
+ fVolumeID(0),
+ fR(0.),
+ fZ(0.),
+ fFi(0.),
+ fAn(0.),
+ fAd(0.),
+ fTheta(0.),
+ fThetaD(0.),
+ fNHits(0),
+ fHitDistance(0),
+ fCharge(0),
+ fTime(0)
{hit.Copy(*this);}
AliTrackHitsParamV2& operator = (const AliTrackHitsParamV2 &hit)
{hit.Copy(*this); return (*this);}
class AliTPCTrackHitsV2 : public TObject {
public:
- AliTPCTrackHitsV2();
+ AliTPCTrackHitsV2();
~AliTPCTrackHitsV2();
- AliTPCTrackHitsV2(const AliTPCTrackHitsV2 &hit): TObject(hit)
+ AliTPCTrackHitsV2(const AliTPCTrackHitsV2 &hit): TObject(hit),
+ fArray(0),
+ fSize(0),
+ fPrecision(0.),
+ fStep(0.),
+ fMaxDistance(0),
+ fNVolumes(0),
+ fVolumes(0),
+ fTempInfo(0),
+ fCurrentHit(0),
+ fHit(0)
{hit.Copy(*this);}
AliTPCTrackHitsV2& operator = (const AliTPCTrackHitsV2 &hit)
{hit.Copy(*this); return (*this);}
public:
static AliTPCcalibDB* Instance();
AliTPCcalibDB();
+ AliTPCcalibDB(const AliTPCcalibDB ¶m); // copy constructor
+ AliTPCcalibDB &operator = (const AliTPCcalibDB & param);
virtual ~AliTPCcalibDB();
static void Terminate();
void SetRun(Long64_t run);
#include "AliTPCcluster.h"
ClassImp(AliTPCcluster)
-
+//
+AliTPCcluster:: AliTPCcluster(Int_t *lab, Float_t *hit)
+ :AliCluster(lab,hit),
+ fQ(0.)
+{
+ //
+ // constructor
+ //
+ fQ=hit[4];
+}
+
//____________________________________________________________________________
Double_t AliTPCcluster::SigmaY2(Double_t r, Double_t tgl, Double_t pt)
{
//_____________________________________________________________________________
class AliTPCcluster : public AliCluster {
public:
- AliTPCcluster():AliCluster(){fQ=0;}
- AliTPCcluster(Int_t *lab, Float_t *hit) : AliCluster(lab,hit) {fQ = hit[4];}
+ AliTPCcluster():AliCluster(),fQ(0){}
+ AliTPCcluster(Int_t *lab, Float_t *hit);
void Use(Int_t = 0) {fQ=-fQ;}
void SetQ(Float_t q) {fQ=q;}
ClassImp(AliTPCclusterer)
-AliTPCclusterer::AliTPCclusterer(const AliTPCParam *par) {
-//-------------------------------------------------------
-// The main constructor
-//-------------------------------------------------------
- fPar=par;
-}
+//____________________________________________________
+AliTPCclusterer::AliTPCclusterer(const AliTPCclusterer ¶m)
+ :TObject(),
+ fPar(0)
+{
+ //
+ // dummy
+ //
+ fPar = param.fPar;
+}
+//-----------------------------------------------------
+AliTPCclusterer & AliTPCclusterer::operator =(const AliTPCclusterer & param)
+{
+ //
+ // assignment operator - dummy
+ //
+ fPar = param.fPar;
+ return (*this);
+}
+//____________________________________________________
void AliTPCclusterer::FindPeaks(Int_t k,Int_t max,
AliBin *b,Int_t *idx,UInt_t *msk,Int_t& n) {
//find local maxima
class AliTPCclusterer : public TObject {
public:
- AliTPCclusterer(const AliTPCParam *par);
+ AliTPCclusterer():TObject(),fPar(0){};
+ AliTPCclusterer(const AliTPCParam *par):TObject(), fPar(par){};
+ AliTPCclusterer(const AliTPCclusterer ¶m); // copy constructor
+ AliTPCclusterer &operator = (const AliTPCclusterer & param);
Int_t Digits2Clusters(TTree *dig, TTree *clu);
private:
ClassImp(AliTPCdigit)
-
+ //_____________________________________________________________________
+ AliTPCdigit::AliTPCdigit()
+ :AliDigit(),
+ fSector(0),
+ fPadRow(0),
+ fPad(0),
+ fTime(0),
+ fSignal(0)
+{
+ //
+ // default constructor
+ //
+}
//_____________________________________________________________________________
-AliTPCdigit::AliTPCdigit(Int_t *tracks, Int_t *digits):
- AliDigit(tracks)
+AliTPCdigit::AliTPCdigit(Int_t *tracks, Int_t *digits)
+ :AliDigit(tracks),
+ fSector(0),
+ fPadRow(0),
+ fPad(0),
+ fTime(0),
+ fSignal(0)
{
//
// Creates a TPC digit object
Int_t fSignal; //Signal amplitude
public:
- AliTPCdigit() {}
+ AliTPCdigit();
AliTPCdigit(Int_t *tracks, Int_t *digits);
virtual ~AliTPCdigit() {}
ClassImp(AliTPCkineGrid)
//------------------------------------------------------------------------
-AliTPCkineGrid::AliTPCkineGrid() {
+ AliTPCkineGrid::AliTPCkineGrid()
+ :TNamed(),
+ fNpt(0),
+ fNeta(0),
+ fPt(0),
+ fEta(0),
+ fParams(0)
+{
//------------------------------------------------------------------------
// Default constructor
//------------------------------------------------------------------------
- fNpt = 0;
- fNeta = 0;
- fPt = 0;
- fEta = 0;
- fParams = 0;
+
}
//------------------------------------------------------------------------
AliTPCkineGrid::AliTPCkineGrid(Int_t npt,Int_t neta,
- Double_t* pt,Double_t* eta) {
+ Double_t* pt,Double_t* eta)
+ :TNamed(),
+ fNpt(npt),
+ fNeta(neta),
+ fPt(0),
+ fEta(0),
+ fParams(0)
+{
//------------------------------------------------------------------------
// Standard constructor
//------------------------------------------------------------------------
- fNpt = npt;
- fNeta = neta;
+
fPt = new TArrayD(fNpt);
fEta = new TArrayD(fNeta);
fParams = new TMatrixD(fNpt,fNeta);
}
//-------------------------------------------------------------------------
-AliTPCkineGrid::AliTPCkineGrid(const AliTPCkineGrid& grid):TNamed(grid) {
+AliTPCkineGrid::AliTPCkineGrid(const AliTPCkineGrid& grid):TNamed(grid),
+ fNpt(0),
+ fNeta(0),
+ fPt(0),
+ fEta(0),
+ fParams(0)
+{
//-------------------------------------------------------------------------
// Copy constructor
//-------------------------------------------------------------------------
delete fEta;
delete fParams;
}
+//__________________________________________________________________________
+AliTPCkineGrid & AliTPCkineGrid::operator =(const AliTPCkineGrid & param)
+{
+ //
+ // assignment operator - dummy
+ //
+ fNpt=param.fNpt;
+ return (*this);
+}
//--------------------------------------------------------------------------
void AliTPCkineGrid::GetArrayEta(Double_t* eta) const {
//--------------------------------------------------------------------------
AliTPCkineGrid();
AliTPCkineGrid(Int_t npt,Int_t neta,Double_t* pt,Double_t* eta);
AliTPCkineGrid(const AliTPCkineGrid& grid);
+ AliTPCkineGrid &operator = (const AliTPCkineGrid & param);
virtual ~AliTPCkineGrid();
void GetArrayEta(Double_t* eta) const;
void GetArrayPt(Double_t* pt) const;
ClassImp(AliTPCpidESD)
//_________________________________________________________________________
-AliTPCpidESD::AliTPCpidESD(Double_t *param)
+ AliTPCpidESD::AliTPCpidESD(Double_t *param):
+ fMIP(0.),
+ fRes(0.),
+ fRange(0.)
{
//
// The main constructor
class AliTPCpidESD {
public:
+ AliTPCpidESD():fMIP(0.),fRes(0.),fRange(0.){}
AliTPCpidESD(Double_t *param);
virtual ~AliTPCpidESD() {}
Int_t MakePID(AliESD *event);
AliTPCpolyTrack::AliTPCpolyTrack()
+ :TObject(),
+ fA(0),
+ fB(0),
+ fC(0),
+ fD(0),
+ fE(0),
+ fF(0),
+ fMaxX(0),
+ fMinX(0),
+ fSumW(0),
+ fSumX(0),
+ fSumX2(0),
+ fSumX3(0),
+ fSumX4(0),
+ fSumY(0),
+ fSumYX(0),
+ fSumYX2(0),
+ fSumZ(0),
+ fSumZX(0),
+ fSumZX2(0),
+ fNPoints(0)
{
Reset();
}
}
}
}
-
+//_________________________________________________
+AliTPCseed & AliTPCseed::operator =(const AliTPCseed & param)
+{
+ //
+ // assignment operator - dummy
+ //
+ fRow=param.fRow;
+ return (*this);
+}
+//____________________________________________________
AliTPCTrackerPoint * AliTPCseed::GetTrackPoint(Int_t i)
{
//
AliTPCseed(const AliTPCseed &s, Bool_t clusterOwner = kFALSE);
//AliTPCseed(const AliTPCseed &t, Double_t a);
AliTPCseed(Double_t xr, Double_t alpha, const Double_t xx[5],
- const Double_t cc[15], Int_t i);
+ const Double_t cc[15], Int_t i);
+ AliTPCseed &operator = (const AliTPCseed & param);
Int_t Compare(const TObject *o) const;
void Reset(Bool_t all = kTRUE);
Int_t GetProlongation(Double_t xr, Double_t &y, Double_t & z) const;
ClassImp(AliTPCtrackPid)
AliTPCtrackPid::AliTPCtrackPid()
+ :TObject(),
+ fWpi(0.),
+ fWk(0.),
+ fWp(0.),
+ fSignal(0.),
+ fMom(0.),
+ fPhi(0.),
+ fLam(0.),
+ fPcode(0),
+ fLabel(0),
+ fGSignal(0.),
+ fGMom(0.),
+ fGpx(0.),
+ fGpy(0.),
+ fGpz(0.),
+ fGx(0.),
+ fGy(0.),
+ fGz(0.),
+ fGcode(0),
+ fGlab(0)
{
- fWpi=fWk=fWp=0.;
- fPcode=0; fMom=0.; fSignal=0;
+ //
+ // default costructor
+ //
}
//-----------------------------------------------------------------------------
AliTPCtrackerParam::AliTPCtrackerParam(Int_t kcoll, Double_t kBz,
- const char* evfoldname):
- fEvFolderName(evfoldname) {
+ const char* evfoldname):TObject(),
+ fEvFolderName(evfoldname),
+ fBz(kBz),
+ fColl(kcoll),
+ fSelAndSmear(kTRUE),
+ fDBfileName(""),
+ fTrack(),
+ fCovTree(0),
+ fDBgrid(0),
+ fDBgridPi(),
+ fDBgridKa(),
+ fDBgridPr(),
+ fDBgridEl(),
+ fDBgridMu(),
+ fEff(0),
+ fEffPi(),
+ fEffKa(),
+ fEffPr(),
+ fEffEl(),
+ fEffMu(),
+ fPulls(0),
+ fRegPar(0),
+ fRegParPi(),
+ fRegParKa(),
+ fRegParPr(),
+ fRegParEl(),
+ fRegParMu(),
+ fdEdxMean(0),
+ fdEdxMeanPi(),
+ fdEdxMeanKa(),
+ fdEdxMeanPr(),
+ fdEdxMeanEl(),
+ fdEdxMeanMu(),
+ fdEdxRMS(0),
+ fdEdxRMSPi(),
+ fdEdxRMSKa(),
+ fdEdxRMSPr(),
+ fdEdxRMSEl(),
+ fdEdxRMSMu()
+{
//-----------------------------------------------------------------------------
// This is the class conctructor
//-----------------------------------------------------------------------------
- fBz = kBz; // value of the z component of L3 field (Tesla)
- fColl = kcoll; // collision code (0: PbPb6000; 1: pp)
- fSelAndSmear = kTRUE; // by default selection and smearing are done
+ // fBz = kBz; // value of the z component of L3 field (Tesla)
+ // fColl = kcoll; // collision code (0: PbPb6000; 1: pp)
+ // fSelAndSmear = kTRUE; // by default selection and smearing are done
if(fBz!=0.4 && fBz!=0.5) {
Fatal("AliTPCtrackerParam","AliTPCtrackerParam::AliTPCtrackerParam: Invalid field!\n Available: 0.4 or 0.5");
//-----------------------------------------------------------------------------
AliTPCtrackerParam::~AliTPCtrackerParam() {}
//____________________________________________________________________________
-AliTPCtrackerParam::AliTPCtrackerParam( const AliTPCtrackerParam& p):TObject(p)
+AliTPCtrackerParam::AliTPCtrackerParam( const AliTPCtrackerParam& p)
+ :TObject(p),
+ fEvFolderName(""),
+ fBz(0.),
+ fColl(0),
+ fSelAndSmear(0),
+ fDBfileName(""),
+ fTrack(),
+ fCovTree(0),
+ fDBgrid(0),
+ fDBgridPi(),
+ fDBgridKa(),
+ fDBgridPr(),
+ fDBgridEl(),
+ fDBgridMu(),
+ fEff(0),
+ fEffPi(),
+ fEffKa(),
+ fEffPr(),
+ fEffEl(),
+ fEffMu(),
+ fPulls(0),
+ fRegPar(0),
+ fRegParPi(),
+ fRegParKa(),
+ fRegParPr(),
+ fRegParEl(),
+ fRegParMu(),
+ fdEdxMean(0),
+ fdEdxMeanPi(),
+ fdEdxMeanKa(),
+ fdEdxMeanPr(),
+ fdEdxMeanEl(),
+ fdEdxMeanMu(),
+ fdEdxRMS(0),
+ fdEdxRMSPi(),
+ fdEdxRMSKa(),
+ fdEdxRMSPr(),
+ fdEdxRMSEl(),
+ fdEdxRMSMu()
{
// dummy copy constructor
}
AliTPCtrackerParam::AliTPCseedGeant::AliTPCseedGeant(
Double_t x,Double_t y,Double_t z,
Double_t px,Double_t py,Double_t pz,
- Int_t lab) {
+ Int_t lab)
+ :TObject(),
+ fXg(x),
+ fYg(y),
+ fZg(z),
+ fPx(px),
+ fPy(py),
+ fPz(pz),
+ fAlpha(0.),
+ fLabel(lab),
+ fSector(0)
+
+{
//----------------------------------------------------------------------------
// Constructor of the geant seeds
//----------------------------------------------------------------------------
- fXg = x;
- fYg = y;
- fZg = z;
- fPx = px;
- fPy = py;
- fPz = pz;
- fLabel = lab;
+
Double_t a = TMath::ATan2(y,x)*180./TMath::Pi();
if(a<0) a += 360.;
fSector = (Int_t)(a/20.);
class AliTPCtrackerParam:
public TObject
-{
-
+{
public:
+
AliTPCtrackerParam(Int_t coll=0, Double_t Bz=0.4,
const char* evfoldname = AliConfig::GetDefaultEventFolderName());
virtual ~AliTPCtrackerParam();
//********* Internal class definition *******
class AliTPCseedGeant : public TObject {
public:
+ AliTPCseedGeant():TObject(),
+ fXg(0.),
+ fYg(0.),
+ fZg(0.),
+ fPx(0.),
+ fPy(0.),
+ fPz(0.),
+ fAlpha(0.),
+ fLabel(0),
+ fSector(0){}
+
AliTPCseedGeant(Double_t x=0.,Double_t y=0.,Double_t z=0.,
Double_t px=0.,Double_t py=0.,Double_t pz=0.,
Int_t lab=0);
//_____________________________________________________________________________
- AliTPCv1::AliTPCv1(){
+ AliTPCv1::AliTPCv1():AliTPC(),fIdSens(0)
+{
fHitType = 1;
//_____________________________________________________________________________
AliTPCv1::AliTPCv1(const char *name, const char *title)
- :AliTPC(name, title) {
+ :AliTPC(name, title),fIdSens(0)
+ {
//
// Standard constructor for Time Projection Chamber
//
- fIdSens=0;
if (fTPCParam)
ClassImp(AliTPCv3)
//_____________________________________________________________________________
- AliTPCv3::AliTPCv3(){
+ AliTPCv3::AliTPCv3():AliTPC(),fIdSens(0)
+{
fHitType = 1;
//_____________________________________________________________________________
AliTPCv3::AliTPCv3(const char *name, const char *title) :
- AliTPC(name, title)
+ AliTPC(name, title), fIdSens(0)
{
//
// Standard constructor for Time Projection Chamber version 3
//
SetBufferSize(128000);
- fIdSens=0;
-
if (fTPCParam)
fTPCParam->Write(fTPCParam->GetTitle());
git://git.uio.no / u/mrichter/AliRoot.git / commitdiff