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             : #include "Riostream.h"
      16             : #include "Rtypes.h"
      17             : #include "AliPMDcludata.h"
      18             : #include <stdio.h>
      19             : 
      20          12 : ClassImp(AliPMDcludata)
      21             : 
      22           0 : AliPMDcludata::AliPMDcludata()
      23           0 : {
      24             :   // Default constructor
      25           0 :   for (Int_t i = 0; i < 6; i++)
      26             :     {
      27           0 :       fClusData[i] = 0.;
      28             :     }
      29           0 :   for (Int_t i = 0; i < 19; i++)
      30             :     {
      31           0 :       fClXY[i] = 0;
      32             : 
      33             :     }
      34           0 : }
      35             : // --------------------------------------------------------------------- //
      36         172 : AliPMDcludata::AliPMDcludata(Float_t *clusdata, Int_t *clxy)
      37         860 : {
      38             :   // Constructor
      39        2408 :   for (Int_t i = 0; i < 6; i++)
      40             :     {
      41        1032 :       fClusData[i] = clusdata[i];
      42             :     }
      43        6880 :   for (Int_t i = 0; i < 19; i++)
      44             :     {
      45        3268 :       fClXY[i] = clxy[i];
      46             :     }
      47             :   
      48         344 : }
      49             : // --------------------------------------------------------------------- //
      50             : AliPMDcludata::AliPMDcludata(const AliPMDcludata &pmdcludata):
      51           0 :   TObject(pmdcludata)
      52           0 : {
      53             :   //Copy Constructor 
      54           0 :   for(Int_t i=0; i<6; i++)
      55             :     {
      56           0 :       this->fClusData[i] = pmdcludata.fClusData[i];
      57             :     }
      58           0 :   for(Int_t i=0; i<19; i++)
      59             :     {
      60           0 :       this->fClXY[i] = pmdcludata.fClXY[i];
      61             :     }
      62           0 : }
      63             : // --------------------------------------------------------------------- //
      64             : 
      65             : AliPMDcludata & AliPMDcludata::operator=(const AliPMDcludata &pmdcludata)
      66             : {
      67             :   // Assignment operator 
      68           0 :   if(this != &pmdcludata)
      69             :     {
      70           0 :       for(Int_t i=0; i<6; i++)
      71             :         {
      72           0 :           this->fClusData[i] = pmdcludata.fClusData[i];
      73             :         }
      74           0 :       for(Int_t i=0; i<19; i++)
      75             :         {
      76           0 :           this->fClXY[i] = pmdcludata.fClXY[i];
      77             :         }
      78           0 :     }
      79           0 :   return *this;
      80             : }
      81             : // --------------------------------------------------------------------- //
      82             : 
      83             : AliPMDcludata::~AliPMDcludata()
      84         688 : {
      85             :   // Destructor
      86         688 : }
      87             : // --------------------------------------------------------------------- //
      88             : Float_t AliPMDcludata::GetClusX() const
      89             : {
      90         344 :   return fClusData[0];
      91             : }
      92             : // --------------------------------------------------------------------- //
      93             : Float_t AliPMDcludata::GetClusY() const
      94             : {
      95         344 :   return fClusData[1];
      96             : }
      97             : // --------------------------------------------------------------------- //
      98             : Float_t AliPMDcludata::GetClusADC() const
      99             : {
     100         344 :   return fClusData[2];
     101             : }
     102             : // --------------------------------------------------------------------- //
     103             : Float_t AliPMDcludata::GetClusCells() const
     104             : {
     105         344 :   return fClusData[3];
     106             : }
     107             : // --------------------------------------------------------------------- //
     108             : Float_t AliPMDcludata::GetClusSigmaX() const
     109             : {
     110         344 :   return fClusData[4];
     111             : }
     112             : // --------------------------------------------------------------------- //
     113             : Float_t AliPMDcludata::GetClusSigmaY() const
     114             : {
     115         344 :   return fClusData[5];
     116             : }
     117             : // --------------------------------------------------------------------- //
     118             : Int_t AliPMDcludata::GetCellXY(Int_t i) const
     119             : {
     120       13072 :   return fClXY[i];
     121             : }
     122             : // --------------------------------------------------------------------- //