return kTRUE;
}
-Bool_t AliClustersArray::Setup(const AliDetectorParam *param)
+Bool_t AliClustersArray::Setup(const AliDetectorParam */*param*/)
{
//
//make copy of param object
return kTRUE;
}
-Bool_t AliClustersArray::SetParam(AliDetectorParam * param)
+Bool_t AliClustersArray::SetParam(AliDetectorParam * /*param*/)
{
return kTRUE;
}
-Bool_t AliClustersArray::SetFinder(AliClustersFinder * finder)
+Bool_t AliClustersArray::SetFinder(AliClustersFinder * /*finder*/)
{
return kTRUE;
}
-Float_t * AliDetectorParam::GetAnglesAccMomentum(Float_t *x, Int_t * index, Float_t *momentum, Float_t *angle)
+Float_t * AliDetectorParam::GetAnglesAccMomentum(Float_t *x, Int_t * /*index*/, Float_t *momentum, Float_t *angle)
{
//
//calculates deflection angle of particle with longitudinal
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;}
+ 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,
- Float_t *sigma){;}
+ 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*/,
+ Float_t */*sigma*/){;}
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
}
//_______________________________________________________________________
-AliHelix::AliHelix(const AliHelix &t){
+AliHelix::AliHelix(const AliHelix &t):TObject(t){
//
//
for (Int_t i=0;i<9;i++)
return t;
}
-Int_t AliHelix::GetPhase(Double_t r0, Double_t t[2])
+Int_t AliHelix::GetPhase(Double_t /*r0*/, Double_t * /*t[2]*/)
{
//
//calculate helix param at given r point - return nearest point ()
}
-Int_t AliSimDigits::GetTrackID2(Int_t row, Int_t column, Int_t level)
+Int_t AliSimDigits::GetTrackID2(Int_t /*row*/, Int_t /*column*/, Int_t /*level*/)
{
//returnb track id of digits - for buffer compresion 2
return -2;
-void AliTPC::Digits2Clusters(Int_t eventnumber)
+void AliTPC::Digits2Clusters(Int_t /*eventnumber*/)
{
//-----------------------------------------------------------------
// This is a simple cluster finder.
extern Double_t SigmaY2(Double_t, Double_t, Double_t);
extern Double_t SigmaZ2(Double_t, Double_t);
//_____________________________________________________________________________
-void AliTPC::Hits2Clusters(Int_t eventn)
+void AliTPC::Hits2Clusters(Int_t /*eventn*/)
{
//--------------------------------------------------------
// TPC simple cluster generator from hits
//__
-void AliTPC::SDigits2Digits2(Int_t eventnumber)
+void AliTPC::SDigits2Digits2(Int_t /*eventnumber*/)
{
//create digits from summable digits
GenerNoise(500000); //create teble with noise
//________________________________________________________________________
// Additional code because of the AliTPCTrackHitsV2
-void AliTPC::MakeBranch2(Option_t *option,const char *file)
+void AliTPC::MakeBranch2(Option_t *option,const char */*file*/)
{
//
// Create a new branch in the current Root Tree
-void AliTPC::FindTrackHitsIntersection(TClonesArray * arr)
+void AliTPC::FindTrackHitsIntersection(TClonesArray * /*arr*/)
{
//
ClassImp(AliTPCBuffer)
//////////////////////////////////////////////////////////////////////////////////////////////////////////////
-AliTPCBuffer::AliTPCBuffer(const char* fileName){
+AliTPCBuffer::AliTPCBuffer(const char* /*fileName*/){
// Constructor
#ifndef __DECCXX
f.open("AliTPCDDL.dat",ios::binary|ios::out);
//delete fout;
}
//////////////////////////////////////////////////////////////////////////////////////////////////////////////
-AliTPCBuffer::AliTPCBuffer(const AliTPCBuffer &source){
+AliTPCBuffer::AliTPCBuffer(const AliTPCBuffer &source):TObject(source){
// Copy Constructor
this->fVerbose=source.fVerbose;
return;
static AliTPCClusterFinder * gClusterFinder; //for fitting routine
-void gauss(Int_t &npar, Double_t *gin, Double_t &f, Double_t *par, Int_t iflag)
+void gauss(Int_t &/*npar*/, Double_t */*gin*/, Double_t &f, Double_t *par, Int_t /*iflag*/)
{
AliArrayI * points = gClusterFinder->GetStack();
const Int_t nbins = gClusterFinder->GetStackIndex();
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 SetCurrentAngle(Float_t angle){return;}
+ virtual void SetCurrentAngle(Float_t /*angle*/){return;}
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);
static const Int_t fgkNPRF; //default number of division
private:
- AliTPCPRF2D(const AliTPCPRF2D &prf) {;}
+ AliTPCPRF2D(const AliTPCPRF2D &prf);
AliTPCPRF2D &operator = (const AliTPCPRF2D &prf) {return *this;}
ClassDef(AliTPCPRF2D,1)
return sector;
}
-Bool_t AliTPCParam::Transform(Float_t *xyz, Int_t *index, Int_t* oindex)
+Bool_t AliTPCParam::Transform(Float_t */*xyz*/, Int_t *index, Int_t* /*oindex*/)
{
//transformation from input coodination system to output coordination system
switch (index[0]){
{
//
// set opening angles
- const static Float_t kDegtoRad = 0.01745329251994;
+ 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
//
//sector default parameters
//
- const static Float_t kInnerRadiusLow = 82.97;
- const static Float_t kInnerRadiusUp = 133.17;
- const static Float_t kOuterRadiusLow = 133.58;
- const static Float_t kOuterRadiusUp = 247.78;
- const static Float_t kInnerAngle = 20; // 20 degrees
- const static Float_t kInnerAngleShift = 10;
- const static Float_t kOuterAngle = 20; // 20 degrees
- const static Float_t kOuterAngleShift = 10;
- const static Float_t kInnerFrameSpace = 1.5;
- const static Float_t kOuterFrameSpace = 1.5;
- const static Float_t kInnerWireMount = 1.370825926;
- const static Float_t kOuterWireMount = 1.370825926;
- const static Float_t kZLength =250.;
- const static Int_t kGeometryType = 0; //straight rows
- const static Int_t kNRowLow = 63;
- const static Int_t kNRowUp1 = 64;
- const static Int_t kNRowUp2 = 32;
- const static Int_t kNRowUp = 96;
+ static const Float_t kInnerRadiusLow = 82.97;
+ static const Float_t kInnerRadiusUp = 133.17;
+ static const Float_t kOuterRadiusLow = 133.58;
+ static const Float_t kOuterRadiusUp = 247.78;
+ static const Float_t kInnerAngle = 20; // 20 degrees
+ static const Float_t kInnerAngleShift = 10;
+ static const Float_t kOuterAngle = 20; // 20 degrees
+ static const Float_t kOuterAngleShift = 10;
+ static const Float_t kInnerFrameSpace = 1.5;
+ static const Float_t kOuterFrameSpace = 1.5;
+ static const Float_t kInnerWireMount = 1.370825926;
+ static const Float_t kOuterWireMount = 1.370825926;
+ static const Float_t kZLength =250.;
+ 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 Int_t kNRowUp = 96;
//
//wires default parameters
//
- const static Int_t kNInnerWiresPerPad = 3;
- const static Int_t kInnerDummyWire = 2;
- const static Float_t kInnerWWPitch = 0.25;
- const static Float_t kRInnerFirstWire = 84.445;
- const static Float_t kRInnerLastWire = 132.445;
- const static Float_t kInnerOffWire = 0.5;
- const static Int_t kNOuter1WiresPerPad = 4;
- const static Int_t kNOuter2WiresPerPad = 6;
- const static Float_t kOuterWWPitch = 0.25;
- const static Float_t kROuterFirstWire = 134.305;
- const static Float_t kROuterLastWire = 247.055;
- const static Int_t kOuterDummyWire = 2;
- const static Float_t kOuterOffWire = 0.5;
+ static const Int_t kNInnerWiresPerPad = 3;
+ static const Int_t kInnerDummyWire = 2;
+ static const Float_t kInnerWWPitch = 0.25;
+ static const Float_t kRInnerFirstWire = 84.445;
+ static const Float_t kRInnerLastWire = 132.445;
+ 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 kROuterFirstWire = 134.305;
+ static const Float_t kROuterLastWire = 247.055;
+ static const Int_t kOuterDummyWire = 2;
+ static const Float_t kOuterOffWire = 0.5;
//
//pad default parameters
//
- const static Float_t kInnerPadPitchLength = 0.75;
- const static Float_t kInnerPadPitchWidth = 0.40;
- const static Float_t kInnerPadLength = 0.75;
- const static Float_t kInnerPadWidth = 0.40;
- const static Float_t kOuter1PadPitchLength = 1.0;
- const static Float_t kOuterPadPitchWidth = 0.6;
- const static Float_t kOuter1PadLength = 1.0;
- const static Float_t kOuterPadWidth = 0.6;
- const static Float_t kOuter2PadPitchLength = 1.5;
- const static Float_t kOuter2PadLength = 1.5;
-
- const static Bool_t kBMWPCReadout = kTRUE; //MWPC readout - another possibility GEM
- const static Int_t kNCrossRows = 1; //number of rows to cross-talk
+ 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 kInnerPadWidth = 0.40;
+ static const Float_t kOuter1PadPitchLength = 1.0;
+ static const Float_t kOuterPadPitchWidth = 0.6;
+ static const Float_t kOuter1PadLength = 1.0;
+ static const Float_t kOuterPadWidth = 0.6;
+ 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 Int_t kNCrossRows = 1; //number of rows to cross-talk
//
//gas default parameters
//
- const static Float_t kDiffT = 2.2e-2;
- const static Float_t kDiffL = 2.2e-2;
- const static Float_t kGasGain = 2.e4;
- const static Float_t kDriftV =2.83e6;
- const static Float_t kOmegaTau = 0.145;
- const static Float_t kAttCoef = 250.;
- const static Float_t kOxyCont = 5.e-6;
+ 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 kOmegaTau = 0.145;
+ static const Float_t kAttCoef = 250.;
+ static const Float_t kOxyCont = 5.e-6;
//
//electronic default parameters
//
- const static Float_t kPadCoupling=0.5;
- const static Int_t kZeroSup=2;
- const static Float_t kNoise = 1000;
- const static Float_t kChipGain = 12;
- const static Float_t kChipNorm = 0.4;
- const static Float_t kTSample = 2.e-7;
- const static Float_t kTFWHM = 1.9e-7; //fwhm of charge distribution
- const static Int_t kMaxTBin =445;
- const static Int_t kADCSat =1024;
- const static Float_t kADCDynRange =2000.;
+ static const Float_t kPadCoupling=0.5;
+ static const Int_t kZeroSup=2;
+ 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 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.;
//
//
//
- const static Float_t kBField =0.2;
- const static Float_t kNPrimLoss =10.9;
- const static Float_t kNTotalLoss =39.9;
+ static const Float_t kBField =0.2;
+ static const Float_t kNPrimLoss =10.9;
+ static const Float_t kNTotalLoss =39.9;
//
//response constants
//
- const static Int_t kNResponseMax=100;
- const static Float_t kResponseThreshold=0.01;
+ static const Int_t kNResponseMax=100;
+ static const Float_t kResponseThreshold=0.01;
fbStatus = kFALSE;
//
//set sector parameters
void Transform8to6(Float_t *xyz, Int_t *index) const;
//transform 'digit' coordinata to dr,f coordinata
- virtual Int_t Transform2toPadRow(Float_t *xyz, Int_t *index) const{return 0;}
+ 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,
- Int_t §or, Int_t &padrow, Int_t option=3) const {;}
+ 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=1 X absolute use input sector
//if option=2 X relative to pad row calculate sector
//if option=3 X relative use input sector
- virtual void CRXYZtoXYZ(Float_t *xyz,
- const Int_t §or, const Int_t & padrow, Int_t option=3) const {;}
+ virtual void CRXYZtoXYZ(Float_t */*xyz*/,
+ 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,
- const Float_t &time, const Float_t &pad,
- Int_t sector, Int_t padrow ){;}
+ 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,
- Float_t &time, Float_t &pad,
- Int_t sector, Int_t padrow){;}
+ 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
- virtual Int_t CalcResponse(Float_t* x, Int_t * index, Int_t row){return 0;}
+ 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
//otherwise it calculate only in given pad row
ClassImp(AliTPCParamCR)
-const static Int_t kMaxRows=600;
-const static Float_t kEdgeSectorSpace = 2.5;
+static const Int_t kMaxRows=600;
+static const Float_t kEdgeSectorSpace = 2.5;
AliTPCParamCR::AliTPCParamCR()
{
AliTPCParam::SetDefault();
}
-Int_t AliTPCParamCR::CalcResponse(Float_t* xyz, Int_t * index, Int_t dummy)
+Int_t AliTPCParamCR::CalcResponse(Float_t* xyz, Int_t * index, Int_t /*dummy*/)
{
//
//calculate bin response as function of the input position -x
ClassImp(AliTPCParamSR)
-const static Int_t kMaxRows=600;
-const static Float_t kEdgeSectorSpace = 2.5;
-const static Float_t kFacSigmaPadRow=3.;
-const static Float_t kFacSigmaPad=3.;
-const static Float_t kFacSigmaTime=3.;
+static const Int_t kMaxRows=600;
+static const Float_t kEdgeSectorSpace = 2.5;
+static const Float_t kFacSigmaPadRow=3.;
+static const Float_t kFacSigmaPad=3.;
+static const Float_t kFacSigmaTime=3.;
AliTPCParamSR::AliTPCParamSR()
padrow = index[1];
}
-Float_t AliTPCParamSR::GetPrimaryLoss(Float_t *x, Int_t *index, Float_t *angle)
+Float_t AliTPCParamSR::GetPrimaryLoss(Float_t */*x*/, Int_t *index, Float_t *angle)
{
//
//
return length*fNPrimLoss;
}
-Float_t AliTPCParamSR::GetTotalLoss(Float_t *x, Int_t *index, Float_t *angle)
+Float_t AliTPCParamSR::GetTotalLoss(Float_t */*x*/, Int_t *index, Float_t *angle)
{
//
//
}
-void AliTPCParamSR::GetClusterSize(Float_t *x, Int_t *index, Float_t *angle, Int_t mode, Float_t *sigma)
+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
-void AliTPCParamSR::GetSpaceResolution(Float_t *x, Int_t *index, Float_t *angle,
- Float_t amplitude, Int_t mode, Float_t *sigma)
+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)
+Float_t AliTPCParamSR::GetAmp(Float_t */*x*/, Int_t */*index*/, Float_t */*angle*/)
{
//
//
if(pk>pp){return kaon();}else{return proton();}
}
//-----------------------------------------------------------
-Int_t AliTPCPid::GetPcode(TClonesArray* rps,Float_t pm)
+Int_t AliTPCPid::GetPcode(TClonesArray* /*rps*/,Float_t /*pm*/)
{
return 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);
- TF1 *f_rmska = new TF1("x_frmska","1.46-7.82*x+16.78*x^2-15.53*x^3+5.24*x^4 ",
+ TF1 *f_rmska=0;
+
+ f_rmska = new TF1("x_frmska","1.46-7.82*x+16.78*x^2-15.53*x^3+5.24*x^4 ",
0.1,1.2);
fCutKa = new TF1("fkaons",
"1.25+0.044/x/x+1.25+0.044*x-13.87*x^2+22.37*x^3-10.05*x^4-2.5*x_frmska",
fOffset = 0.;
}
-AliTPCRF1D::AliTPCRF1D(const AliTPCRF1D &prf)
+AliTPCRF1D::AliTPCRF1D(const AliTPCRF1D &prf):TObject(prf)
{
+
//
memcpy(this, &prf, sizeof(prf));
fcharge = new Float_t[fNRF];
memcpy(fcharge,prf.fcharge, fNRF);
fGRF = new TF1(*(prf.fGRF));
+
}
AliTPCRF1D & AliTPCRF1D::operator = (const AliTPCRF1D &prf)
return res;
}
-void AliTPCclustererMI::MakeCluster(Int_t k,Int_t max,Int_t *bins, UInt_t m,
+void AliTPCclustererMI::MakeCluster(Int_t k,Int_t max,Int_t *bins, UInt_t /*m*/,
AliTPCclusterMI &c)
{
Int_t i0=k/max; //central pad
fParams = new TMatrixD(fNpt,fNeta);
}
//-------------------------------------------------------------------------
-AliTPCkineGrid::AliTPCkineGrid(const AliTPCkineGrid& grid) {
+AliTPCkineGrid::AliTPCkineGrid(const AliTPCkineGrid& grid):TNamed(grid) {
//-------------------------------------------------------------------------
// Copy constructor
//-------------------------------------------------------------------------
fC30=t.fC30; fC31=t.fC31; fC32=t.fC32; fC33=t.fC33;
fC40=t.fC40; fC41=t.fC41; fC42=t.fC42; fC43=t.fC43; fC44=t.fC44;
- Int_t n=GetNumberOfClusters();
+ //Int_t n=GetNumberOfClusters();
for (Int_t i=0; i<kMaxRow; i++) fIndex[i]=t.fIndex[i];
//
//MI
}
//_____________________________________________________________________________
-Int_t AliTPCtrack::PropagateTo(Double_t xk,Double_t x0,Double_t rho) {
+Int_t AliTPCtrack::PropagateTo(Double_t xk,Double_t /*x0*/,Double_t rho) {
//-----------------------------------------------------------------
// This function propagates a track to a reference plane x=xk.
//-----------------------------------------------------------------
/*
$Log$
+Revision 1.37 2003/07/22 15:56:14 hristov
+Implementing ESD functionality in the NewIO (Yu.Belikov)
+
Revision 1.35.2.3 2003/07/15 09:58:03 hristov
Corrected back-propagation (Yu.Belikov)
}
//_____________________________________________________________________________
-Int_t AliTPCtracker::RefitInward(TTree *in, TTree *out) {
+Int_t AliTPCtracker::RefitInward(TTree */*in*/, TTree */*out*/) {
//
// The function propagates tracks throught TPC inward
// using already associated clusters.
}
//_____________________________________________________________________________
-Int_t AliTPCtracker::PropagateBack(TTree *in, TTree *out) {
+Int_t AliTPCtracker::PropagateBack(TTree */*in*/, TTree */*out*/) {
//-----------------------------------------------------------------
// This function propagates tracks back through the TPC.
//-----------------------------------------------------------------
/*
$Log$
+Revision 1.15 2003/09/29 11:56:58 kowal2
+bug fix2
+
Revision 1.14 2003/09/29 11:39:43 kowal2
bug fix
//_____________________________________________________________________________
-Int_t AliTPCseed::Update(const AliTPCclusterMI *c, Double_t chisq, UInt_t index) {
+Int_t AliTPCseed::Update(const AliTPCclusterMI *c, Double_t chisq, UInt_t /*index*/) {
//-----------------------------------------------------------------
// This function associates a cluster with this track.
//-----------------------------------------------------------------
//_____________________________________________________________________________
-void AliTPCtrackerMI::MakeSeeds2(TObjArray * arr, Int_t sec, Int_t i1, Int_t i2, Float_t cuts[4],
- Float_t deltay, Bool_t bconstrain) {
+void AliTPCtrackerMI::MakeSeeds2(TObjArray * arr, Int_t sec, Int_t i1, Int_t i2, Float_t */*cuts[4]*/,
+ Float_t deltay, Bool_t /*bconstrain*/) {
//-----------------------------------------------------------------
// This function creates track seeds - without vertex constraint
//-----------------------------------------------------------------
Int_t p0 = int(r0*track->GetNumberOfClusters()); // point 0
Int_t p1 = int(r1*track->GetNumberOfClusters());
Int_t p2 = int(r2*track->GetNumberOfClusters()); // last point
- Int_t pp2;
+ Int_t pp2=0;
Double_t x0[3],x1[3],x2[3];
x0[0]=-1;
x0[0]=-1;
// find track position at given ratio of the length
Int_t sec0, sec1, sec2;
+ sec0=0;
+ sec1=0;
+ sec2=0;
Int_t index=-1;
Int_t clindex;
for (Int_t i=0;i<160;i++){
//
AliCluster * GetCluster (int) const {return 0;}
AliTPCclusterMI *GetClusterMI(Int_t index) const;
- Int_t Clusters2Tracks(const TFile *in, TFile *out){return 0;}
+ Int_t Clusters2Tracks(const TFile */*in*/, TFile */*out*/){return 0;}
Int_t Clusters2Tracks();
virtual void CookLabel(AliTPCseed *t,Float_t wrong) const;