[u/mrichter/AliRoot.git] / STEER / AliMultiplicity.cxx

#include <string.h>
#include "AliMultiplicity.h"

ClassImp(AliMultiplicity)

//______________________________________________________________________
AliMultiplicity::AliMultiplicity():
  TObject(),
  fNtracks(0),
  fTh(0),
  fPhi(0),
  fDeltPhi(0),
  fLabels(0),
  fNsingle(0),
  fThsingle(0),
  fPhisingle(0)

{
  // Default Constructor
}

//______________________________________________________________________
AliMultiplicity::AliMultiplicity(Int_t ntr, Float_t *t,  Float_t *ph, Float_t *df, Int_t *labels, Int_t ns, Float_t *ts, Float_t *ps):
  TObject(),
  fNtracks(ntr),
  fTh(0),
  fPhi(0),
  fDeltPhi(0),
  fLabels(0),
  fNsingle(ns),
  fThsingle(0),
  fPhisingle(0)
{
// Standard constructor
  if(ntr>0){
    fTh = new Float_t [ntr];
    fPhi = new Float_t [ntr];
    fDeltPhi = new Float_t [ntr];
    fLabels = new Int_t[ntr];
    for(Int_t i=0;i<fNtracks;i++){
      fTh[i]=t[i];
      fPhi[i]=ph[i];
      fDeltPhi[i]=df[i];
      fLabels[i] = labels[i];
    }
  }
  if(ns>0){
    fThsingle = new Float_t [ns];
    fPhisingle = new Float_t [ns];
    for(Int_t i=0;i<fNsingle;i++){
      fThsingle[i]=ts[i];
      fPhisingle[i]=ps[i];
    }
  }
}

//______________________________________________________________________
AliMultiplicity::AliMultiplicity(const AliMultiplicity& m):
  TObject(m),
  fNtracks(m.fNtracks),
  fTh(0),
  fPhi(0),
  fDeltPhi(0),
  fLabels(0),
  fNsingle(m.fNsingle),
  fThsingle(0),
  fPhisingle(0)
{
  // copy constructor

  Duplicate(m);

}

//______________________________________________________________________
AliMultiplicity &AliMultiplicity::operator=(const AliMultiplicity& m){
  // assignment operator
  if(this == &m)return *this;
  ((TObject *)this)->operator=(m);

  if (fTh)delete [] fTh;
  if(fPhi)delete [] fPhi;
  if(fDeltPhi)delete [] fDeltPhi;
  if(fLabels)delete [] fLabels;
  if(fThsingle)delete [] fThsingle;
  if(fPhisingle)delete [] fPhisingle;
  Duplicate(m);

  return *this;
}

//______________________________________________________________________
void AliMultiplicity::Duplicate(const AliMultiplicity& m){
  // used by copy constructor and assignment operator
  fNtracks = m.fNtracks;
  if(fNtracks>0){
    fTh = new Float_t [fNtracks];
    fPhi = new Float_t [fNtracks];
    fDeltPhi = new Float_t [fNtracks];
    fLabels = new Int_t[fNtracks];
  }
  else {
    fTh = 0;
    fPhi = 0;
    fDeltPhi = 0;
    fLabels = 0;
  }
  fNsingle = m.fNsingle;
  if(fNsingle>0){
    fThsingle = new Float_t [fNsingle];
    fPhisingle = new Float_t [fNsingle];
  }
  else {
    fThsingle = 0;
    fPhisingle = 0;
  }
  memcpy(fTh,m.fTh,fNtracks*sizeof(Float_t));
  memcpy(fPhi,m.fPhi,fNtracks*sizeof(Float_t));
  memcpy(fDeltPhi,m.fDeltPhi,fNtracks*sizeof(Float_t));
  memcpy(fLabels,m.fLabels,fNtracks*sizeof(Int_t));
  memcpy(fThsingle,m.fThsingle,fNsingle*sizeof(Float_t));
  memcpy(fPhisingle,m.fPhisingle,fNsingle*sizeof(Float_t));
}

//______________________________________________________________________
AliMultiplicity::~AliMultiplicity(){
  // Destructor
  if (fTh)delete [] fTh;
  if(fPhi)delete [] fPhi;
  if(fDeltPhi)delete [] fDeltPhi;
  if(fLabels)delete [] fLabels;
  if(fThsingle)delete [] fThsingle;
  if(fPhisingle)delete [] fPhisingle;
}
Commit	Line	Data
	1	#include <string.h>
	2	#include "AliMultiplicity.h"
	3
	4	ClassImp(AliMultiplicity)
	5
	6	//______________________________________________________________________
	7	AliMultiplicity::AliMultiplicity():
	8	TObject(),
	9	fNtracks(0),
	10	fTh(0),
	11	fPhi(0),
	12	fDeltPhi(0),
	13	fLabels(0),
	14	fNsingle(0),
	15	fThsingle(0),
	16	fPhisingle(0)
	17
	18	{
	19	// Default Constructor
	20	}
	21
	22	//______________________________________________________________________
	23	AliMultiplicity::AliMultiplicity(Int_t ntr, Float_t t, Float_t ph, Float_t df, Int_t labels, Int_t ns, Float_t ts, Float_t ps):
	24	TObject(),
	25	fNtracks(ntr),
	26	fTh(0),
	27	fPhi(0),
	28	fDeltPhi(0),
	29	fLabels(0),
	30	fNsingle(ns),
	31	fThsingle(0),
	32	fPhisingle(0)
	33	{
	34	// Standard constructor
	35	if(ntr>0){
	36	fTh = new Float_t [ntr];
	37	fPhi = new Float_t [ntr];
	38	fDeltPhi = new Float_t [ntr];
	39	fLabels = new Int_t[ntr];
	40	for(Int_t i=0;i<fNtracks;i++){
	41	fTh[i]=t[i];
	42	fPhi[i]=ph[i];
	43	fDeltPhi[i]=df[i];
	44	fLabels[i] = labels[i];
	45	}
	46	}
	47	if(ns>0){
	48	fThsingle = new Float_t [ns];
	49	fPhisingle = new Float_t [ns];
	50	for(Int_t i=0;i<fNsingle;i++){
	51	fThsingle[i]=ts[i];
	52	fPhisingle[i]=ps[i];
	53	}
	54	}
	55	}
	56
	57	//______________________________________________________________________
	58	AliMultiplicity::AliMultiplicity(const AliMultiplicity& m):
	59	TObject(m),
	60	fNtracks(m.fNtracks),
	61	fTh(0),
	62	fPhi(0),
	63	fDeltPhi(0),
	64	fLabels(0),
	65	fNsingle(m.fNsingle),
	66	fThsingle(0),
	67	fPhisingle(0)
	68	{
	69	// copy constructor
	70
	71	Duplicate(m);
	72
	73	}
	74
	75	//______________________________________________________________________
	76	AliMultiplicity &AliMultiplicity::operator=(const AliMultiplicity& m){
	77	// assignment operator
	78	if(this == &m)return *this;
	79	((TObject *)this)->operator=(m);
	80
	81	if (fTh)delete [] fTh;
	82	if(fPhi)delete [] fPhi;
	83	if(fDeltPhi)delete [] fDeltPhi;
	84	if(fLabels)delete [] fLabels;
	85	if(fThsingle)delete [] fThsingle;
	86	if(fPhisingle)delete [] fPhisingle;
	87	Duplicate(m);
	88
	89	return *this;
	90	}
	91
	92	//______________________________________________________________________
	93	void AliMultiplicity::Duplicate(const AliMultiplicity& m){
	94	// used by copy constructor and assignment operator
	95	fNtracks = m.fNtracks;
	96	if(fNtracks>0){
	97	fTh = new Float_t [fNtracks];
	98	fPhi = new Float_t [fNtracks];
	99	fDeltPhi = new Float_t [fNtracks];
	100	fLabels = new Int_t[fNtracks];
	101	}
	102	else {
	103	fTh = 0;
	104	fPhi = 0;
	105	fDeltPhi = 0;
	106	fLabels = 0;
	107	}
	108	fNsingle = m.fNsingle;
	109	if(fNsingle>0){
	110	fThsingle = new Float_t [fNsingle];
	111	fPhisingle = new Float_t [fNsingle];
	112	}
	113	else {
	114	fThsingle = 0;
	115	fPhisingle = 0;
	116	}
	117	memcpy(fTh,m.fTh,fNtracks*sizeof(Float_t));
	118	memcpy(fPhi,m.fPhi,fNtracks*sizeof(Float_t));
	119	memcpy(fDeltPhi,m.fDeltPhi,fNtracks*sizeof(Float_t));
	120	memcpy(fLabels,m.fLabels,fNtracks*sizeof(Int_t));
	121	memcpy(fThsingle,m.fThsingle,fNsingle*sizeof(Float_t));
	122	memcpy(fPhisingle,m.fPhisingle,fNsingle*sizeof(Float_t));
	123	}
	124
	125	//______________________________________________________________________
	126	AliMultiplicity::~AliMultiplicity(){
	127	// Destructor
	128	if (fTh)delete [] fTh;
	129	if(fPhi)delete [] fPhi;
	130	if(fDeltPhi)delete [] fDeltPhi;
	131	if(fLabels)delete [] fLabels;
	132	if(fThsingle)delete [] fThsingle;
	133	if(fPhisingle)delete [] fPhisingle;
	134	}
	135
	136