Removed compiler warning.
authorkowal2 <kowal2@f7af4fe6-9843-0410-8265-dc069ae4e863>
Fri, 17 Oct 2003 12:01:17 +0000 (12:01 +0000)
committerkowal2 <kowal2@f7af4fe6-9843-0410-8265-dc069ae4e863>
Fri, 17 Oct 2003 12:01:17 +0000 (12:01 +0000)
21 files changed:
TPC/AliClustersArray.cxx
TPC/AliDetectorParam.cxx
TPC/AliDetectorParam.h
TPC/AliHelix.cxx
TPC/AliSimDigits.cxx
TPC/AliTPC.cxx
TPC/AliTPCBuffer.cxx
TPC/AliTPCClusterFinder.cxx
TPC/AliTPCPRF2D.h
TPC/AliTPCParam.cxx
TPC/AliTPCParam.h
TPC/AliTPCParamCR.cxx
TPC/AliTPCParamSR.cxx
TPC/AliTPCPid.cxx
TPC/AliTPCRF1D.cxx
TPC/AliTPCclustererMI.cxx
TPC/AliTPCkineGrid.cxx
TPC/AliTPCtrack.cxx
TPC/AliTPCtracker.cxx
TPC/AliTPCtrackerMI.cxx
TPC/AliTPCtrackerMI.h

index afd98b7..bbbe77e 100644 (file)
@@ -74,7 +74,7 @@ Bool_t  AliClustersArray::SetClusterType(Text_t * classname)
   return kTRUE;
 }
 
-Bool_t AliClustersArray::Setup(const AliDetectorParam *param)
+Bool_t AliClustersArray::Setup(const AliDetectorParam */*param*/)
 {
   //
   //make copy of param object
@@ -82,12 +82,12 @@ Bool_t AliClustersArray::Setup(const AliDetectorParam *param)
   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;
 }
index b33db2f..a4a66ff 100644 (file)
@@ -28,7 +28,7 @@
 
 
 
-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
index 9cb8c80..577888c 100644 (file)
@@ -14,15 +14,15 @@ 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;}
+  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  
index 43f4860..1d1aec5 100644 (file)
@@ -37,7 +37,7 @@ AliHelix::AliHelix()
 }
 
 //_______________________________________________________________________
-AliHelix::AliHelix(const AliHelix &t){
+AliHelix::AliHelix(const AliHelix &t):TObject(t){
   //
   //
   for (Int_t i=0;i<9;i++) 
@@ -213,7 +213,7 @@ Double_t  AliHelix::GetPhase(Double_t x, Double_t y )
   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 ()
index 8feda02..a065033 100644 (file)
@@ -327,7 +327,7 @@ void  AliSimDigits::CompresTrackBuffer2()
 }
 
 
-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;
index d8ec691..9a1e1b2 100644 (file)
@@ -832,7 +832,7 @@ void    AliTPC::SetActiveSectors(Int_t flag)
 
 
 
-void AliTPC::Digits2Clusters(Int_t eventnumber)
+void AliTPC::Digits2Clusters(Int_t /*eventnumber*/)
 {
   //-----------------------------------------------------------------
   // This is a simple cluster finder.
@@ -844,7 +844,7 @@ void AliTPC::Digits2Clusters(Int_t eventnumber)
 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
@@ -1227,7 +1227,7 @@ void AliTPC::Hits2ExactClustersSector(Int_t isec)
 
 
 //__
-void AliTPC::SDigits2Digits2(Int_t eventnumber)  
+void AliTPC::SDigits2Digits2(Int_t /*eventnumber*/)  
 {
   //create digits from summable digits
   GenerNoise(500000); //create teble with noise
@@ -2432,7 +2432,7 @@ AliHit(shunt,track)
 //________________________________________________________________________
 // 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
@@ -2862,7 +2862,7 @@ void AliTPC::LoadPoints3(Int_t)
 
 
 
-void AliTPC::FindTrackHitsIntersection(TClonesArray * arr)
+void AliTPC::FindTrackHitsIntersection(TClonesArray * /*arr*/)
 {
 
   //
index 378c186..99b4993 100644 (file)
@@ -30,7 +30,7 @@
 
 ClassImp(AliTPCBuffer)
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////
-AliTPCBuffer::AliTPCBuffer(const char* fileName){
+AliTPCBuffer::AliTPCBuffer(const char* /*fileName*/){
   // Constructor
 #ifndef __DECCXX
   f.open("AliTPCDDL.dat",ios::binary|ios::out);
@@ -52,7 +52,7 @@ AliTPCBuffer::~AliTPCBuffer(){
   //delete fout;
 }
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////
-AliTPCBuffer::AliTPCBuffer(const AliTPCBuffer &source){
+AliTPCBuffer::AliTPCBuffer(const AliTPCBuffer &source):TObject(source){
   // Copy Constructor
   this->fVerbose=source.fVerbose;
   return;
index cc726f2..a055413 100644 (file)
@@ -57,7 +57,7 @@ const Int_t kClStackSize =1000;
 
 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();
index d1f7c55..dc0f055 100644 (file)
@@ -50,7 +50,7 @@ public :
   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);
@@ -123,7 +123,7 @@ protected:
   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) 
index 5b66a57..4418efb 100644 (file)
@@ -105,7 +105,7 @@ Int_t  AliTPCParam::Transform0to1(Float_t *xyz, Int_t * index)  const
   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]){
@@ -178,7 +178,7 @@ void  AliTPCParam::SetSectorAngles(Float_t innerangle, Float_t innershift, Float
 {
   //
   // 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
@@ -253,91 +253,91 @@ void AliTPCParam::SetDefault()
   //
   //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
index 734a0a7..75eae7a 100644 (file)
@@ -63,34 +63,34 @@ public:
   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 &sector, 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 &sector, 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
index ac03e73..28b1079 100644 (file)
@@ -38,8 +38,8 @@
 
 
 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()
 {   
@@ -71,7 +71,7 @@ void AliTPCParamCR::SetDefault()
   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 
index 08beb7f..5f12c45 100644 (file)
 
 
 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()
@@ -237,7 +237,7 @@ void AliTPCParamSR::XYZtoCRXYZ(Float_t *xyz,
   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)
 {
   //
   //
@@ -250,7 +250,7 @@ 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)
 {
   //
   //
@@ -265,7 +265,7 @@ 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
@@ -305,15 +305,15 @@ void AliTPCParamSR::GetClusterSize(Float_t *x, Int_t *index, Float_t *angle, Int
 
 
 
-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*/)
 {
   //
   //
index 8e6ccea..86c5941 100644 (file)
@@ -153,7 +153,7 @@ cout<<" ppi,pk,pp="<<ppi<<"  "<<pk<<"  "<<pp<<endl;
     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;    
 }
@@ -379,7 +379,9 @@ AliTPCPid::AliTPCPid(Int_t ntrack)
 
     //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",
index cd3fd2e..ff3e1e0 100644 (file)
@@ -91,13 +91,15 @@ AliTPCRF1D::AliTPCRF1D(Bool_t direct,Int_t np,Float_t step)
   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)
index 237673d..a8cee7b 100644 (file)
@@ -98,7 +98,7 @@ Float_t  AliTPCclustererMI::GetSigmaZ2(Int_t iz){
   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
index 5f2d5fa..6ea8059 100644 (file)
@@ -65,7 +65,7 @@ AliTPCkineGrid::AliTPCkineGrid(Int_t npt,Int_t neta,
   fParams = new TMatrixD(fNpt,fNeta);
 }
 //-------------------------------------------------------------------------
-AliTPCkineGrid::AliTPCkineGrid(const AliTPCkineGrid& grid) {
+AliTPCkineGrid::AliTPCkineGrid(const AliTPCkineGrid& grid):TNamed(grid) {
 //-------------------------------------------------------------------------
 // Copy constructor
 //-------------------------------------------------------------------------
index b316507..63340ef 100644 (file)
@@ -190,7 +190,7 @@ AliTPCtrack::AliTPCtrack(const AliTPCtrack& t) : AliKalmanTrack(t) {
   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 
@@ -304,7 +304,7 @@ Double_t AliTPCtrack::GetYat(Double_t xk) const {
 }
 
 //_____________________________________________________________________________
-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.
   //-----------------------------------------------------------------
index 5e26f49..cb35114 100644 (file)
@@ -15,6 +15,9 @@
 
 /*
 $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)
 
@@ -977,7 +980,7 @@ Int_t AliTPCtracker::RefitInward(AliESD* event) {
 }
 
 //_____________________________________________________________________________
-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.
@@ -1190,7 +1193,7 @@ Int_t AliTPCtracker::PropagateBack(AliESD *event) {
 }
 
 //_____________________________________________________________________________
-Int_t AliTPCtracker::PropagateBack(TTree *in, TTree *out) {
+Int_t AliTPCtracker::PropagateBack(TTree */*in*/, TTree */*out*/) {
   //-----------------------------------------------------------------
   // This function propagates tracks back through the TPC.
   //-----------------------------------------------------------------
index b7f28b8..467a1c9 100644 (file)
@@ -15,6 +15,9 @@
 
 /*
 $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
 
@@ -967,7 +970,7 @@ void AliTPCtrackerMI::RotateToLocal(AliTPCseed *seed)
 
 
 //_____________________________________________________________________________
-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.
   //-----------------------------------------------------------------
@@ -3015,8 +3018,8 @@ void AliTPCtrackerMI::MakeSeeds5(TObjArray * arr, Int_t sec, Int_t i1, Int_t i2,
 
 
 //_____________________________________________________________________________
-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
   //-----------------------------------------------------------------
@@ -3279,7 +3282,7 @@ AliTPCseed *AliTPCtrackerMI::MakeSeed(AliTPCseed *track, Float_t r0, Float_t r1,
   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;
@@ -3287,6 +3290,9 @@ AliTPCseed *AliTPCtrackerMI::MakeSeed(AliTPCseed *track, Float_t r0, Float_t r1,
 
   // 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++){
index 80ed26b..236393c 100644 (file)
@@ -132,7 +132,7 @@ public:
    //   
    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;