Det and SMN converted from float to int
authorbnandi <bnandi@f7af4fe6-9843-0410-8265-dc069ae4e863>
Mon, 29 Mar 2004 15:30:59 +0000 (15:30 +0000)
committerbnandi <bnandi@f7af4fe6-9843-0410-8265-dc069ae4e863>
Mon, 29 Mar 2004 15:30:59 +0000 (15:30 +0000)
PMD/AliPMDClustering.cxx
PMD/AliPMDClustering.h
PMD/AliPMDcluster.cxx
PMD/AliPMDcluster.h
PMD/AliPMDrecpoint1.cxx
PMD/AliPMDrecpoint1.h

index 37a819e..3497e4f 100644 (file)
@@ -50,10 +50,10 @@ ClassImp(AliPMDClustering)
 
 const Double_t AliPMDClustering::fgkSqroot3by2=0.8660254;  // sqrt(3.)/2.
 
-AliPMDClustering::AliPMDClustering()
+AliPMDClustering::AliPMDClustering():
+  fDebug(0),
+  fCutoff(0.0)
 {
-  fDebug  = 0;
-  fCutoff = 0.0;
   for(int i = 0; i < kNDIMX; i++)
     {
       for(int j = 0; j < kNDIMY; j++)
@@ -63,12 +63,13 @@ AliPMDClustering::AliPMDClustering()
        }
     }
 }
+// ------------------------------------------------------------------------ //
 AliPMDClustering::~AliPMDClustering()
 {
 
 }
-
-void AliPMDClustering::DoClust(Double_t celladc[48][96], TObjArray *pmdcont)
+// ------------------------------------------------------------------------ //
+void AliPMDClustering::DoClust(Int_t idet, Int_t ismn, Double_t celladc[48][96], TObjArray *pmdcont)
 {
   // main function to call other necessary functions to do clustering
   //
@@ -80,7 +81,7 @@ void AliPMDClustering::DoClust(Double_t celladc[48][96], TObjArray *pmdcont)
   */
   int i, i1, i2, j, nmx1, incr, id, jd;
   double  cutoff, ave;
-  Float_t clusdata[5];
+  Float_t clusdata[7];
 
   const float ktwobysqrt3 = 1.1547; // 2./sqrt(3.)
 
@@ -110,6 +111,9 @@ void AliPMDClustering::DoClust(Double_t celladc[48][96], TObjArray *pmdcont)
     {
       cout << " nmx1 " << nmx1 << endl;
     }
+
+  //  if (nmx1 == 0 | nmx1 == -1) return;
+
   ave=ave/nmx1;
   if (fDebug == 1)
     {
@@ -124,7 +128,7 @@ void AliPMDClustering::DoClust(Double_t celladc[48][96], TObjArray *pmdcont)
       cout << "fClno " << fClno << endl;
     }
 
-  for(i1=0; i1<fClno; i1++)
+  for(i1=0; i1<=fClno; i1++)
     {
       Float_t cluXC    = (Float_t) fClusters[0][i1];
       Float_t cluYC    = (Float_t) fClusters[1][i1];
@@ -142,13 +146,11 @@ void AliPMDClustering::DoClust(Double_t celladc[48][96], TObjArray *pmdcont)
       clusdata[3]      = cluCELLS;
       clusdata[4]      = cluRAD;
 
-      pmdcl = new AliPMDcluster(clusdata);
+      pmdcl = new AliPMDcluster(idet, ismn, clusdata);
       pmdcont->Add(pmdcl);
     }
-  delete pmdcl;
-
 }
-
+// ------------------------------------------------------------------------ //
 void AliPMDClustering::Order()
 {
   // Sorting algorithm
@@ -202,7 +204,7 @@ void AliPMDClustering::Order()
       fIord[1][i]=i2;
     }
 }
-
+// ------------------------------------------------------------------------ //
 int AliPMDClustering::CrClust(double ave, double cutoff, int nmx1)
 {
   // Does crude clustering
@@ -317,7 +319,7 @@ int AliPMDClustering::CrClust(double ave, double cutoff, int nmx1)
   //  }
   return cellcount;
 }
-
+// ------------------------------------------------------------------------ //
 void AliPMDClustering::RefClust(int incr)
 {
   // Does the refining of clusters
@@ -530,7 +532,7 @@ void AliPMDClustering::RefClust(int incr)
     }
   }
 }
-
+// ------------------------------------------------------------------------ //
 void AliPMDClustering::GaussFit(Int_t ncell, Int_t nclust, Double_t &x, Double_t &y ,Double_t &z, Double_t &xc, Double_t &yc, Double_t &zc, Double_t &rc)
 {
   // Does gaussian fitting
@@ -641,12 +643,12 @@ void AliPMDClustering::GaussFit(Int_t ncell, Int_t nclust, Double_t &x, Double_t
     *(&rc+j)=rrc[j];
   }
 }
-
+// ------------------------------------------------------------------------ //
 double AliPMDClustering::Distance(double x1, double y1, double x2, double y2)
 {
   return sqrt((x1-x2)*(x1-x2) + (y1-y2)*(y1-y2));
 }
-
+// ------------------------------------------------------------------------ //
 double AliPMDClustering::Ranmar() const
 {
   //  Universal random number generator proposed by Marsaglia and Zaman
@@ -716,11 +718,12 @@ double AliPMDClustering::Ranmar() const
   }
   return uni;
 }
-
+// ------------------------------------------------------------------------ //
 void AliPMDClustering::SetEdepCut(Float_t decut)
 {
   fCutoff = decut;
 }
+// ------------------------------------------------------------------------ //
 void AliPMDClustering::SetDebug(Int_t idebug)
 {
   fDebug = idebug;
index 706f179..a51cbb5 100644 (file)
@@ -37,7 +37,8 @@ class AliPMDClustering
   AliPMDClustering();
   virtual ~AliPMDClustering();
 
-  void DoClust(Double_t celladc[][96], TObjArray *pmdcont);
+  void DoClust(Int_t idet, Int_t ismn, Double_t celladc[][96],
+              TObjArray *pmdcont);
   void Order();
 
   Int_t CrClust(Double_t ave, Double_t cutoff, Int_t nmx1);
index 8b009e0..fd4ea31 100644 (file)
@@ -1,3 +1,17 @@
+/***************************************************************************
+ * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ *                                                                        *
+ * Author: The ALICE Off-line Project.                                    *
+ * Contributors are mentioned in the code where appropriate.              *
+ *                                                                        *
+ * Permission to use, copy, modify and distribute this software and its   *
+ * documentation strictly for non-commercial purposes is hereby granted   *
+ * without fee, provided that the above copyright notice appears in all   *
+ * copies and that both the copyright notice and this permission notice   *
+ * appear in the supporting documentation. The authors make no claims     *
+ * about the suitability of this software for any purpose. It is          *
+ * provided "as is" without express or implied warranty.                  *
+ **************************************************************************/
 //-----------------------------------------------------//
 //                                                     //
 //  Date   : August 05 2003                            //
 
 ClassImp(AliPMDcluster)
 
-AliPMDcluster::AliPMDcluster()
+AliPMDcluster::AliPMDcluster():
+  fDet(0),
+  fSMN(0)
 {
   // Default constructor
+  //  fDet = 0;
+  //  fSMN = 0;
   for (Int_t i = 0; i < 5; i++)
     {
       fClusData[i] = 0.;
     }
 }
-AliPMDcluster::AliPMDcluster(Float_t *clusdata)
+AliPMDcluster::AliPMDcluster(Int_t idet, Int_t ismn, Float_t *clusdata)
 {
   // Constructor
+  fDet = idet;
+  fSMN = ismn;
   for (Int_t i = 0; i < 5; i++)
     {
       fClusData[i] = clusdata[i];
@@ -32,6 +52,8 @@ AliPMDcluster::AliPMDcluster(const AliPMDcluster &pmdcluster):TObject(pmdcluster
 {
   //Copy Constructor 
   if(&pmdcluster == this) return;
+  this->fDet = pmdcluster.fDet;
+  this->fSMN = pmdcluster.fSMN;
   for(Int_t i=0; i<5; i++)
     {
       this->fClusData[i] = pmdcluster.fClusData[i];
@@ -43,6 +65,8 @@ AliPMDcluster & AliPMDcluster::operator=(const AliPMDcluster &pmdcluster)
 {
   // Assignment operator 
   if(&pmdcluster == this) return *this;
+  this->fDet = pmdcluster.fDet;
+  this->fSMN = pmdcluster.fSMN;
   for(Int_t i=0; i<5; i++)
     {
       this->fClusData[i] = pmdcluster.fClusData[i];
@@ -54,6 +78,15 @@ AliPMDcluster::~AliPMDcluster()
 {
   // Destructor
 }
+
+Int_t AliPMDcluster::GetDetector() const
+{
+  return fDet;
+}
+Int_t AliPMDcluster::GetSMN() const
+{
+  return fSMN;
+}
 Float_t AliPMDcluster::GetClusX() const
 {
   return fClusData[0];
@@ -74,5 +107,3 @@ Float_t AliPMDcluster::GetClusRadius() const
 {
   return fClusData[4];
 }
-
-
index 8fb0f70..8fe9d5d 100644 (file)
@@ -1,5 +1,7 @@
 #ifndef ALIPMDCLUSTER_H
 #define ALIPMDCLUSTER_H
+/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ * See cxx source for full Copyright notice                               */
 //-----------------------------------------------------//
 //                                                     //
 //  Date   : August 05 2003                            //
@@ -16,13 +18,15 @@ class AliPMDcluster : public TObject
 {
  public:
   AliPMDcluster();
-  AliPMDcluster(Float_t * /* clusdata */);
+  AliPMDcluster(Int_t idet, Int_t ismn, Float_t *clusdata);
   AliPMDcluster(AliPMDcluster *pmdcluster) {*this = *pmdcluster;}
   AliPMDcluster (const AliPMDcluster &pmdcluster);  // copy constructor
   AliPMDcluster &operator=(const AliPMDcluster &pmdcluster); // assignment op
   
   virtual ~AliPMDcluster();
 
+  Int_t   GetDetector() const;
+  Int_t   GetSMN() const;
   Float_t GetClusX() const;
   Float_t GetClusY() const;
   Float_t GetClusADC() const;
@@ -31,14 +35,17 @@ class AliPMDcluster : public TObject
 
  protected:
 
+  Int_t   fDet;          // Detector No (0:PRE, 1:CPV)
+  Int_t   fSMN;          // Serial Module No.
   Float_t fClusData[5];  // Array containing cluster information
   /*
-    fClusData[0] : Cluster x      ,  fClusData[1] : Cluster y
-    fClusData[2] : Cluster adc    ,  fClusData[3] : Cluster Cells
+    fDet         : Det (0:PRE, 1:CPV), fSMN         : SerialModuleNo
+    fClusData[0] : Cluster x         , fClusData[1] : Cluster y
+    fClusData[2] : Cluster adc       , fClusData[3] : Cluster Cells
     fClusData[4] : Cluster radius
   */
   
-  ClassDef(AliPMDcluster,1) // Keep Cluster information
+  ClassDef(AliPMDcluster,2) // Keep Cluster information
 };
 
 #endif
index ef29ae8..b92495b 100644 (file)
 
 ClassImp(AliPMDrecpoint1)
 
-AliPMDrecpoint1::AliPMDrecpoint1()
+AliPMDrecpoint1::AliPMDrecpoint1():
+  fDet(0),
+  fSMN(0)
 {
   // Default constructor
-  for (Int_t i = 0; i < 7; i++)
+  for (Int_t i = 0; i < 5; i++)
     {
       fClusData[i] = 0.;
     }
 }
-
-AliPMDrecpoint1::AliPMDrecpoint1(Float_t *clusdata)
+// ------------------------------------------------------------------------- //
+AliPMDrecpoint1::AliPMDrecpoint1(Int_t idet, Int_t ismn, Float_t *clusdata)
 {
   // Constructor
-  for (Int_t i = 0; i < 7; i++)
+  fDet = idet;
+  fSMN = ismn;
+  for (Int_t i = 0; i < 5; i++)
     {
       fClusData[i] = clusdata[i];
     }
 }
-
+// ------------------------------------------------------------------------- //
 AliPMDrecpoint1::AliPMDrecpoint1(const AliPMDrecpoint1 &pmdrecpoint):TObject(pmdrecpoint)
 {
   //Copy Constructor 
   if(&pmdrecpoint == this) return;
-  for(Int_t i=0; i<7; i++)
+  this->fDet = pmdrecpoint.fDet;
+  this->fSMN = pmdrecpoint.fSMN;
+  for(Int_t i=0; i<5; i++)
     {
       this->fClusData[i] = pmdrecpoint.fClusData[i];
     }
   return;
 }
-
+// ------------------------------------------------------------------------- //
 AliPMDrecpoint1 & AliPMDrecpoint1::operator=(const AliPMDrecpoint1 &pmdrecpoint)
 {
   // Assignment operator 
   if(&pmdrecpoint == this) return *this;
-  for(Int_t i=0; i<7; i++)
+  this->fDet = pmdrecpoint.fDet;
+  this->fSMN = pmdrecpoint.fSMN;
+  for(Int_t i=0; i<5; i++)
     {
       this->fClusData[i] = pmdrecpoint.fClusData[i];
     }
   return *this;
 }
-
+// ------------------------------------------------------------------------- //
 AliPMDrecpoint1::~AliPMDrecpoint1()
 {
   // Default destructor
 }
-
-Float_t AliPMDrecpoint1::GetDetector() const
+// ------------------------------------------------------------------------- //
+Int_t AliPMDrecpoint1::GetDetector() const
 {
-  return fClusData[0];
+  return fDet;
 }
-Float_t AliPMDrecpoint1::GetSMNumber() const
+// ------------------------------------------------------------------------- //
+Int_t AliPMDrecpoint1::GetSMNumber() const
 {
-  return fClusData[1];
+  return fSMN;
 }
+// ------------------------------------------------------------------------- //
 Float_t AliPMDrecpoint1::GetClusX() const
 {
-  return fClusData[2];
+  return fClusData[0];
 }
-
+// ------------------------------------------------------------------------- //
 Float_t AliPMDrecpoint1::GetClusY() const
 {
-  return fClusData[3];
+  return fClusData[1];
 }
-
+// ------------------------------------------------------------------------- //
 Float_t AliPMDrecpoint1::GetClusADC() const
 {
-  return fClusData[4];
+  return fClusData[2];
 }
+// ------------------------------------------------------------------------- //
 Float_t AliPMDrecpoint1::GetClusCells() const
 {
-  return fClusData[5];
+  return fClusData[3];
 }
+// ------------------------------------------------------------------------- //
 Float_t AliPMDrecpoint1::GetClusRadius() const
 {
-  return fClusData[6];
+  return fClusData[4];
 }
+// ------------------------------------------------------------------------- //
 
 
index 61bb02a..1afc8eb 100644 (file)
@@ -20,15 +20,15 @@ class AliPMDrecpoint1 : public TObject
 
  public:
   AliPMDrecpoint1();
-  AliPMDrecpoint1(Float_t *clusdata);
+  AliPMDrecpoint1(Int_t idet, Int_t ismn, Float_t *clusdata);
   AliPMDrecpoint1(AliPMDrecpoint1 *pmdrecpoint) {*this = *pmdrecpoint;}
   AliPMDrecpoint1 (const AliPMDrecpoint1 &pmdrecpoint);  // copy constructor
   AliPMDrecpoint1 &operator=(const AliPMDrecpoint1 &pmdrecpoint); // assignment op
   
   virtual ~AliPMDrecpoint1();
 
-  Float_t GetDetector() const;
-  Float_t GetSMNumber() const;
+  Int_t   GetDetector() const;
+  Int_t   GetSMNumber() const;
   Float_t GetClusX() const;
   Float_t GetClusY() const;
   Float_t GetClusADC() const;
@@ -37,12 +37,14 @@ class AliPMDrecpoint1 : public TObject
   
  protected:
 
-  Float_t fClusData[7];  // Array containing cluster information
+  Int_t   fDet;          // Detector No (0:PRE, 1:CPV)
+  Int_t   fSMN;          // Serial Module No.
+  Float_t fClusData[5];  // Array containing cluster information
   /*
-    fClusData[0] : Detector Number,  fClusData[1] : SuperModule Number
-    fClusData[2] : Cluster x      ,  fClusData[3] : Cluster y
-    fClusData[4] : Cluster adc    ,  fClusData[5] : Cluster Cells
-    fClusData[6] : Cluster radius
+    fDet         : Detector Number,  fSMN         : Serial Module Number
+    fClusData[0] : Cluster x      ,  fClusData[1] : Cluster y
+    fClusData[2] : Cluster adc    ,  fClusData[3] : Cluster Cells
+    fClusData[4] : Cluster radius
   */
   
   ClassDef(AliPMDrecpoint1,2) // keep reconstructed points info