Line data    Source code

       1             : /**************************************************************************
       2             :  * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
       3             :  *                                                                        *
       4             :  * Author: The ALICE Off-line Project.                                    *
       5             :  * Contributors are mentioned in the code where appropriate.              *
       6             :  *                                                                        *
       7             :  * Permission to use, copy, modify and distribute this software and its   *
       8             :  * documentation strictly for non-commercial purposes is hereby granted   *
       9             :  * without fee, provided that the above copyright notice appears in all   *
      10             :  * copies and that both the copyright notice and this permission notice   *
      11             :  * appear in the supporting documentation. The authors make no claims     *
      12             :  * about the suitability of this software for any purpose. It is          *
      13             :  * provided "as is" without express or implied warranty.                  *
      14             :  **************************************************************************/
      15             : 
      16             : /// \class AliComplexCluster
      17             : ///
      18             : /// Time Projection Chamber clusters objects
      19             : ///
      20             : /// \author Marian Ivanov, GSI Darmstadt
      21             : ///
      22             : /// * Revision 1.9  2006/11/06 16:07:15  kowal2
      23             : /// Eff C++
      24             : ///
      25             : /// * Revision 1.8  2004/03/30 14:09:22  kowal2
      26             : /// Changes due to the coding conventions
      27             : ///
      28             : /// * Revision 1.7  2003/11/24 09:48:28  kowal2
      29             : /// Changes to obey the coding conventions
      30             : ///
      31             : /// * Revision 1.6  2003/11/24 09:43:03  kowal2
      32             : /// Obsolete - removed
      33             : ///
      34             : /// * Revision 1.5  2003/09/29 11:27:39  kowal2
      35             : /// new classes added
      36             : ///
      37             : /// * Revision 1.3  2002/11/15 14:27:45  hristov
      38             : /// First version of the parallel TPC tracking (M.Ivanov)
      39             : ///
      40             : /// * Revision 1.2  2001/02/05 14:43:13  hristov
      41             : /// Compare() declared const
      42             : ///
      43             : /// * Revision 1.1  2000/10/05 16:17:27  kowal2
      44             : /// New class replacing AliCluster
      45             : 
      46             : #include "AliComplexCluster.h"
      47             : 
      48             : /// \cond CLASSIMP
      49          24 : ClassImp(AliComplexCluster)
      50             : /// \endcond
      51             : 
      52             :   AliComplexCluster::AliComplexCluster()
      53           0 :                     :TObject(),
      54           0 :                      fX(0.),
      55           0 :                      fY(0.),
      56           0 :                      fQ(0.),
      57           0 :                      fSigmaX2(0.),
      58           0 :                      fSigmaY2(0.),
      59           0 :                      fSigmaXY(0.),
      60           0 :                      fArea(0.),
      61           0 :                      fMax(0.)
      62           0 : {
      63             :   /// default constructor
      64           0 :    fTracks[0]=fTracks[1]=fTracks[2]=0;
      65           0 : }
      66             : //_____________________________________________________________________________
      67             : Int_t AliComplexCluster::Compare(const TObject * o) const
      68             : {
      69             :   /// compare two clusters according y coordinata
      70             : 
      71           0 :   AliComplexCluster *cl= (AliComplexCluster *)o;
      72           0 :   if (fY<cl->fY) return -1;
      73           0 :   if (fY==cl->fY) return 0;
      74           0 :   return 1;
      75           0 : }
      76             : 
      77             : Bool_t AliComplexCluster::IsSortable() const
      78             : {
      79             :   /// make AliComplexCluster sortabale
      80             : 
      81           0 :   return kTRUE;
      82             : }
      83             : 
      84          24 : ClassImp(AliTPCExactPoint)
      85          24 : ClassImp(AliTPCClusterPoint)
      86          24 : ClassImp(AliTPCTrackerPoints)
      87             : 
      88             : AliTPCTrackerPoint& AliTPCTrackerPoint::operator=(const AliTPCTrackerPoint& o){
      89           0 :   if(this!=&o){
      90           0 :     fTX = o.fTX;
      91           0 :     fTY = o.fTY;
      92           0 :     fTZ = o.fTZ;
      93           0 :     fTAngleZ = o.fTAngleZ;
      94           0 :     fTAngleY = o.fTAngleY;
      95           0 :     fSigmaZ = o.fSigmaZ;
      96           0 :     fSigmaY = o.fSigmaY;
      97           0 :     fErrZ   = o.fErrZ;
      98           0 :     fErrY   = o.fErrY;
      99           0 :     fIsShared = o.fIsShared;
     100           0 :   }
     101           0 :   return *this;
     102             : }
     103             : 
     104             : //RS: array of more compact points
     105     5043390 : AliTPCTrackerPoints::AliTPCTrackerPoints()
     106       63240 : {
     107       15810 :   memset(fShared,0,20*sizeof(UChar_t));
     108       31620 : }
     109             : 
     110       52316 : AliTPCTrackerPoints::AliTPCTrackerPoints(const AliTPCTrackerPoints& o)
     111         656 : {
     112         164 :   memcpy(fPoints,o.fPoints,159*sizeof(AliTPCTrackerPoints::Point));
     113         164 :   memcpy(fShared,o.fShared,20*sizeof(UChar_t));
     114         328 : }
     115             : 
     116             : void AliTPCTrackerPoints::SetPoint(int i, const AliTPCTrackerPoint* o)
     117             : {
     118           0 :   if (o) {
     119           0 :     fPoints[i] = *o;
     120           0 :     SetShared(o->IsShared());
     121           0 :   }
     122           0 : }
     123             : 
     124             : void AliTPCTrackerPoints::Clear()
     125             : {
     126           0 :   memset(fShared,0,20*sizeof(UChar_t));
     127           0 : }
     128             : 
     129             : AliTPCTrackerPoints& AliTPCTrackerPoints::operator=(const AliTPCTrackerPoints& o)
     130             : {
     131        8472 :   if(this!=&o){
     132        4236 :     memcpy(fPoints,o.fPoints,159*sizeof(AliTPCTrackerPoints::Point));
     133        4236 :     memcpy(fShared,o.fShared,20*sizeof(UChar_t));
     134        4236 :   }
     135        4236 :   return *this;
     136             : }
     137             : 
     138             : /// \cond CLASSIMP
     139          24 : ClassImp(AliTPCTrackPoint)
     140          24 : ClassImp(AliTPCTrackPoint2)
     141             : /// \endcond