[u/mrichter/AliRoot.git] / PMD / AliPMDclupid.cxx

/***************************************************************************
 * 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   : March 22 2004                             //
//                                                     //
//  Store cluster information                          //
//  after discrimination                               //
//                                                     //
//-----------------------------------------------------//
#include "Riostream.h"
#include "Rtypes.h"
#include "AliPMDclupid.h"
#include <stdio.h>

ClassImp(AliPMDclupid)

AliPMDclupid::AliPMDclupid():
  fDet(0),
  fSMN(0)
{
  // Default constructor
  for (Int_t i = 0; i < 6; i++)
    {
      fClusData[i] = 0.;
    }
}
// ------------------------------------------------------------------ //
AliPMDclupid::AliPMDclupid(Int_t idet, Int_t ismn, Float_t *clusdata)
{
  // Constructor
  fDet = idet;
  fSMN = ismn;
  for (Int_t i = 0; i < 6; i++)
    {
      fClusData[i] = clusdata[i];
    }
}
// ------------------------------------------------------------------ //
AliPMDclupid::AliPMDclupid(const AliPMDclupid &pmdclupid):TObject(pmdclupid)
{
  //Copy Constructor 
  if(&pmdclupid == this) return;
  this->fDet = pmdclupid.fDet;
  this->fSMN = pmdclupid.fSMN;
  for(Int_t i=0; i<6; i++)
    {
      this->fClusData[i] = pmdclupid.fClusData[i];
    }
  return;
}
// ------------------------------------------------------------------ //
AliPMDclupid & AliPMDclupid::operator=(const AliPMDclupid &pmdclupid)
{
  // Assignment operator 
  if(&pmdclupid == this) return *this;
  this->fDet = pmdclupid.fDet;
  this->fSMN = pmdclupid.fSMN;
  for(Int_t i=0; i<6; i++)
    {
      this->fClusData[i] = pmdclupid.fClusData[i];
    }
  return *this;
}
// ------------------------------------------------------------------ //
AliPMDclupid::~AliPMDclupid()
{
  // Destructor
}
// ------------------------------------------------------------------ //
Int_t AliPMDclupid::GetDetector() const
{
  return fDet;
}
// ------------------------------------------------------------------ //
Int_t AliPMDclupid::GetSMN() const
{
  return fSMN;
}
// ------------------------------------------------------------------ //
Float_t AliPMDclupid::GetClusX() const
{
  return fClusData[0];
}
// ------------------------------------------------------------------ //
Float_t AliPMDclupid::GetClusY() const
{
  return fClusData[1];
}
// ------------------------------------------------------------------ //
Float_t AliPMDclupid::GetClusADC() const
{
  return fClusData[2];
}
// ------------------------------------------------------------------ //
Float_t AliPMDclupid::GetClusCells() const
{
  return fClusData[3];
}
// ------------------------------------------------------------------ //
Float_t AliPMDclupid::GetClusRadius() const
{
  return fClusData[4];
}
// ------------------------------------------------------------------ //
Float_t AliPMDclupid::GetClusPID() const
{
  return fClusData[5];
}
Commit	Line	Data
7dcaf913	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	// //
	17	// Date : March 22 2004 //
	18	// //
	19	// Store cluster information //
	20	// after discrimination //
	21	// //
	22	//-----------------------------------------------------//
	23	#include "Riostream.h"
	24	#include "Rtypes.h"
	25	#include "AliPMDclupid.h"
	26	#include <stdio.h>
	27
	28	ClassImp(AliPMDclupid)
	29
	30	AliPMDclupid::AliPMDclupid():
	31	fDet(0),
	32	fSMN(0)
	33	{
	34	// Default constructor
	35	for (Int_t i = 0; i < 6; i++)
	36	{
	37	fClusData[i] = 0.;
	38	}
	39	}
	40	// ------------------------------------------------------------------ //
	41	AliPMDclupid::AliPMDclupid(Int_t idet, Int_t ismn, Float_t *clusdata)
	42	{
	43	// Constructor
	44	fDet = idet;
	45	fSMN = ismn;
	46	for (Int_t i = 0; i < 6; i++)
	47	{
	48	fClusData[i] = clusdata[i];
	49	}
	50	}
	51	// ------------------------------------------------------------------ //
	52	AliPMDclupid::AliPMDclupid(const AliPMDclupid &pmdclupid):TObject(pmdclupid)
	53	{
	54	//Copy Constructor
	55	if(&pmdclupid == this) return;
	56	this->fDet = pmdclupid.fDet;
	57	this->fSMN = pmdclupid.fSMN;
	58	for(Int_t i=0; i<6; i++)
	59	{
	60	this->fClusData[i] = pmdclupid.fClusData[i];
	61	}
	62	return;
	63	}
	64	// ------------------------------------------------------------------ //
65	AliPMDclupid & AliPMDclupid::operator=(const AliPMDclupid &pmdclupid)
66	{
67	// Assignment operator
68	if(&pmdclupid == this) return *this;
69	this->fDet = pmdclupid.fDet;
70	this->fSMN = pmdclupid.fSMN;
71	for(Int_t i=0; i<6; i++)
72	{
73	this->fClusData[i] = pmdclupid.fClusData[i];
74	}
75	return *this;
76	}
77	// ------------------------------------------------------------------ //
78	AliPMDclupid::~AliPMDclupid()
79	{
80	// Destructor
81	}
82	// ------------------------------------------------------------------ //
83	Int_t AliPMDclupid::GetDetector() const
84	{
85	return fDet;
86	}
87	// ------------------------------------------------------------------ //
88	Int_t AliPMDclupid::GetSMN() const
89	{
90	return fSMN;
91	}
92	// ------------------------------------------------------------------ //
93	Float_t AliPMDclupid::GetClusX() const
94	{
95	return fClusData[0];
96	}
97	// ------------------------------------------------------------------ //
98	Float_t AliPMDclupid::GetClusY() const
99	{
100	return fClusData[1];
101	}
102	// ------------------------------------------------------------------ //
103	Float_t AliPMDclupid::GetClusADC() const
104	{
105	return fClusData[2];
106	}
107	// ------------------------------------------------------------------ //
108	Float_t AliPMDclupid::GetClusCells() const
109	{
110	return fClusData[3];
111	}
112	// ------------------------------------------------------------------ //
113	Float_t AliPMDclupid::GetClusRadius() const
114	{
115	return fClusData[4];
116	}
117	// ------------------------------------------------------------------ //
118	Float_t AliPMDclupid::GetClusPID() const
119	{
120	return fClusData[5];
121	}
122
123