[u/mrichter/AliRoot.git] / PWGCF / FEMTOSCOPY / Chaoticity / AliChaoticityEventCollection.cxx

////////////////////////////////////////////////////////////////////////////////
//
//  This class provides storage for event and track information which 
//  are used for same-event as well as mixed-event analyses in AliChaoticity 
//
//  authors: Dhevan Gangadharan (dhevan.raja.gangadharan@cern.ch)
//
////////////////////////////////////////////////////////////////////////////////

#include "AliChaoticityEventCollection.h"

AliChaoticityTrackStruct::AliChaoticityTrackStruct():
  fStatus(0),
  fFiltermap(0),
  fId(0),
  fPhi(0),
  fPt(0),
  fMom(0),
  fP(),
  fCharge(0),
  fEta(0),
  fMass(0),
  fDCAXY(0),
  fDCAZ(0),
  fDCA(0),
  fEaccepted(0),
  fKey(0),
  fClusterMap(0),
  fSharedMap(0),
  fX(),
  fTOFhit(0),
  fElectron(0),
  fMuon(0),
  fPion(0),
  fKaon(0),
  fProton(0),
  fLabel(0)// MC
{
  //Default constructor
}
AliChaoticityTrackStruct::AliChaoticityTrackStruct(const AliChaoticityTrackStruct &obj)
  : fStatus(obj.fStatus),
    fFiltermap(obj.fFiltermap),
    fId(obj.fId),
    fPhi(obj.fPhi),
    fPt(obj.fPt),
    fMom(obj.fMom),
    fP(),
    fCharge(obj.fCharge),
    fEta(obj.fEta),
    fMass(obj.fMass),
    fDCAXY(obj.fDCAXY),
    fDCAZ(obj.fDCAZ),
    fDCA(obj.fDCA),
    fEaccepted(obj.fEaccepted),
    fKey(obj.fKey),
    fClusterMap(obj.fClusterMap),
    fSharedMap(obj.fSharedMap),
    fX(),
    fTOFhit(obj.fTOFhit),
    fElectron(obj.fElectron),
    fMuon(obj.fMuon),
    fPion(obj.fPion),
    fKaon(obj.fKaon),
    fProton(obj.fProton),
    fLabel(obj.fLabel)// MC
{
  // copy constructor
}
AliChaoticityTrackStruct &AliChaoticityTrackStruct::operator=(const AliChaoticityTrackStruct &obj) 
{
  // Assignment operator  
  if (this == &obj)
    return *this;

  fStatus = obj.fStatus;
  fFiltermap = obj.fFiltermap;
  fId = obj.fId;
  fPhi = obj.fPhi;
  fPt = obj.fPt;
  fMom = obj.fMom;
  fP[0] = obj.fP[0];
  fP[1] = obj.fP[1];
  fP[2] = obj.fP[2];
  fCharge = obj.fCharge;
  fEta = obj.fEta;
  fMass = obj.fMass;
  fDCAXY = obj.fDCAXY;
  fDCAZ = obj.fDCAZ;
  fDCA = obj.fDCA;
  fEaccepted = obj.fEaccepted;
  fKey = obj.fKey;
  fClusterMap = obj.fClusterMap;
  fSharedMap = obj.fSharedMap;
  fX[0] = obj.fX[0];
  fX[1] = obj.fX[1];
  fX[2] = obj.fX[2];
  fTOFhit = obj.fTOFhit;
  fElectron = obj.fElectron;
  fMuon = obj.fMuon;
  fPion = obj.fPion;
  fKaon = obj.fKaon;
  fProton = obj.fProton;
  fLabel = obj.fLabel;// MC

  return (*this);
}
AliChaoticityTrackStruct::~AliChaoticityTrackStruct()
{
  // Destructor
}

//_____________________________________________________________________________
AliChaoticityPairStruct::AliChaoticityPairStruct():
  fP1(),
  fP2(),
  fE1(0),
  fE2(0),
  fCharge1(0),
  fCharge2(0),
  fIndex1(0),
  fIndex2(0),
  fQinv(0),
  fKey1(0),
  fKey2(0),
  fLabel1(0),
  fLabel2(0),
  fP1MC(),
  fP2MC()
{
  //Default constructor
}
AliChaoticityPairStruct::AliChaoticityPairStruct(const AliChaoticityPairStruct &obj)
  : fP1(),
    fP2(),
    fE1(obj.fE1),
    fE2(obj.fE2),
    fCharge1(obj.fCharge1),
    fCharge2(obj.fCharge2),
    fIndex1(obj.fIndex1),
    fIndex2(obj.fIndex2),
    fQinv(obj.fQinv),
    fKey1(obj.fKey1),
    fKey2(obj.fKey2),
    fLabel1(obj.fLabel1),
    fLabel2(obj.fLabel2),
    fP1MC(),
    fP2MC()
{
  // copy constructor
}
AliChaoticityPairStruct &AliChaoticityPairStruct::operator=(const AliChaoticityPairStruct &obj) 
{
  // Assignment operator  
  if (this == &obj)
    return *this;

  fP1[0] = obj.fP1[0];
  fP1[1] = obj.fP1[1];
  fP1[2] = obj.fP1[2];
  fP2[0] = obj.fP2[0];
  fP2[1] = obj.fP2[1];
  fP2[2] = obj.fP2[2];
  fE1 = obj.fE1;
  fE2 = obj.fE2;
  fCharge1 = obj.fCharge1;
  fCharge2 = obj.fCharge2;
  fIndex1 = obj.fIndex1;
  fIndex2 = obj.fIndex2;
  fQinv = obj.fQinv;
  fKey1 = obj.fKey1;
  fKey2 = obj.fKey2;
  fLabel1 = obj.fLabel1;
  fLabel2 = obj.fLabel2;
  fP1MC[0] = obj.fP1MC[0];
  fP1MC[1] = obj.fP1MC[1];
  fP1MC[2] = obj.fP1MC[2];
  fP2MC[0] = obj.fP2MC[0];
  fP2MC[1] = obj.fP2MC[1];
  fP2MC[2] = obj.fP2MC[2];
  
  return (*this);
}
AliChaoticityPairStruct::~AliChaoticityPairStruct()
{
  // Destructor
}

//_____________________________________________________________________________
AliChaoticityNormPairStruct::AliChaoticityNormPairStruct():
  fCharge1(0),
  fCharge2(0),
  fIndex1(0),
  fIndex2(0),
  fKey1(0),
  fKey2(0)
{
  //Default constructor
}
AliChaoticityNormPairStruct::AliChaoticityNormPairStruct(const AliChaoticityNormPairStruct &obj)
  : fCharge1(obj.fCharge1),
    fCharge2(obj.fCharge2),
    fIndex1(obj.fIndex1),
    fIndex2(obj.fIndex2),
    fKey1(obj.fKey1),
    fKey2(obj.fKey2)
{
  // copy constructor
}
AliChaoticityNormPairStruct &AliChaoticityNormPairStruct::operator=(const AliChaoticityNormPairStruct &obj) 
{
  // Assignment operator  
  if (this == &obj)
    return *this;

  fCharge1 = obj.fCharge1;
  fCharge2 = obj.fCharge2;
  fIndex1 = obj.fIndex1;
  fIndex2 = obj.fIndex2;
  fKey1 = obj.fKey1;
  fKey2 = obj.fKey2;

  return (*this);
}
AliChaoticityNormPairStruct::~AliChaoticityNormPairStruct()
{
  // Destructor
}

//_____________________________________________________________________________
AliChaoticityMCStruct::AliChaoticityMCStruct():
  fPx(0),
  fPy(0),
  fPz(0),
  fPtot(0)
{
  // Default constructor
}
AliChaoticityMCStruct::AliChaoticityMCStruct(const AliChaoticityMCStruct &obj)
  : fPx(obj.fPx),
    fPy(obj.fPy),
    fPz(obj.fPz),
    fPtot(obj.fPtot)
{
  // copy constructor
}
AliChaoticityMCStruct &AliChaoticityMCStruct::operator=(const AliChaoticityMCStruct &obj) 
{
  // Assignment operator  
  if (this == &obj)
    return *this;

  fPx = obj.fPx;
  fPy = obj.fPy;
  fPz = obj.fPz;
  fPtot = obj.fPtot;
  
  return (*this);
}
AliChaoticityMCStruct::~AliChaoticityMCStruct()
{
  // Destructor
}

//_____________________________________________________________________________
AliChaoticityEventStruct::AliChaoticityEventStruct():
  fFillStatus(0),
  fNtracks(0),
  fNpairsSE(0),
  fNpairsME(0),
  fMCarraySize(0),
  fTracks(0),
  fPairsSE(0),
  fPairsME(0),
  fMCtracks(0)
{
  // Default constructor
}
AliChaoticityEventStruct::AliChaoticityEventStruct(const AliChaoticityEventStruct &obj)
  : fFillStatus(obj.fFillStatus),
    fNtracks(obj.fNtracks),
    fNpairsSE(obj.fNpairsSE),
    fNpairsME(obj.fNpairsME),
    fMCarraySize(obj.fMCarraySize),
    fTracks(obj.fTracks),
    fPairsSE(obj.fPairsSE),
    fPairsME(obj.fPairsME),
    fMCtracks(obj.fMCtracks)
{
  // copy constructor
}
AliChaoticityEventStruct &AliChaoticityEventStruct::operator=(const AliChaoticityEventStruct &obj) 
{
  // Assignment operator  
  if (this == &obj)
    return *this;

  fFillStatus = obj.fFillStatus;
  fNtracks = obj.fNtracks;
  fNpairsSE = obj.fNpairsSE;
  fNpairsME = obj.fNpairsME;
  fMCarraySize = obj.fMCarraySize;
  fTracks = obj.fTracks;
  fPairsSE = obj.fPairsSE;
  fPairsME = obj.fPairsME;
  fMCtracks = obj.fMCtracks;
  
  return (*this);
}
AliChaoticityEventStruct::~AliChaoticityEventStruct()
{
  // Destructor
  if(fTracks) delete fTracks;
  if(fPairsSE) delete fPairsSE;
  if(fPairsME) delete fPairsME;
  if(fMCtracks) delete fMCtracks;
}

//_____________________________________________________________________________
AliChaoticityEventCollection::AliChaoticityEventCollection():
  fFIFO(0),
  fLimit(0),
  fPairLimit(0),
  fMCLimit(0),
  fEvtStr(0)
{
  // Default constructor
}
AliChaoticityEventCollection::AliChaoticityEventCollection(Short_t a, Int_t lim, Int_t plimit, Int_t mcarraylimit, Bool_t MCcase):
  fFIFO(0),
  fLimit(0),
  fPairLimit(0),
  fMCLimit(0),
  fEvtStr(0)
{
  
  // Main constructor
  SetBuffSize(a);
  
  fEvtStr = new AliChaoticityEventStruct[fFIFO];  //allocate pointer array of type particle_event
  fLimit = lim;
  fPairLimit = plimit;
  fMCLimit = mcarraylimit;

  for(Int_t ii = 0; ii < fFIFO; ii++){   //Initialize particle table pointers to NULL
    (fEvtStr + ii)->fNtracks = 0;
    (fEvtStr + ii)->fNpairsSE = 0;
    (fEvtStr + ii)->fNpairsME = 0;
    (fEvtStr + ii)->fFillStatus = 0;
    (fEvtStr + ii)->fMCarraySize = 0;
    //
    (fEvtStr + ii)->fTracks = NULL;
    (fEvtStr + ii)->fTracks = new AliChaoticityTrackStruct[fLimit];
    (fEvtStr + ii)->fPairsSE = NULL;
    (fEvtStr + ii)->fPairsSE = new AliChaoticityPairStruct[fPairLimit];
    (fEvtStr + ii)->fPairsME = NULL;
    (fEvtStr + ii)->fPairsME = new AliChaoticityPairStruct[Int_t(2*fPairLimit)];
    if(MCcase) (fEvtStr + ii)->fMCtracks = new AliChaoticityMCStruct[fMCLimit];
    
  }
}
AliChaoticityEventCollection::AliChaoticityEventCollection(const AliChaoticityEventCollection &obj)
  : fFIFO(obj.fFIFO),
    fLimit(obj.fLimit),
    fPairLimit(obj.fPairLimit),
    fMCLimit(obj.fMCLimit),
    fEvtStr(obj.fEvtStr)
{
  // copy constructor
}
AliChaoticityEventCollection &AliChaoticityEventCollection::operator=(const AliChaoticityEventCollection &obj) 
{
  // Assignment operator  
  if (this == &obj)
    return *this;

  fFIFO = obj.fFIFO;
  fLimit = obj.fLimit;
  fPairLimit = obj.fPairLimit;
  fMCLimit = obj.fMCLimit;
  fEvtStr = obj.fEvtStr;
  
  return (*this);
}
AliChaoticityEventCollection::~AliChaoticityEventCollection(){

    for(Int_t i = 0; i < fFIFO; i++){

	if((fEvtStr + i)->fTracks != NULL){
	  delete [] (fEvtStr + i)->fTracks;
	  delete [] (fEvtStr + i)->fPairsSE;
	  delete [] (fEvtStr + i)->fPairsME;
	  delete [] (fEvtStr + i)->fMCtracks;
        }	
	
    }
    
    delete [] fEvtStr;
    //remove histos from heap

}


//_____________________________________________________________________________
void AliChaoticityEventCollection::FIFOShift(){ //Shift elements in FIFO by one and clear last element in FIFO 
  
  
  for(UShort_t i=fFIFO-1 ; i > 0; i--){
    for(Int_t j=0; j<(fEvtStr + i-1)->fNtracks; j++) (fEvtStr + i)->fTracks[j] = (fEvtStr + i-1)->fTracks[j];
    for(Int_t j=0; j<(fEvtStr + i-1)->fNpairsSE; j++) (fEvtStr + i)->fPairsSE[j] = (fEvtStr + i-1)->fPairsSE[j];
    for(Int_t j=0; j<(fEvtStr + i-1)->fMCarraySize; j++) (fEvtStr + i)->fMCtracks[j] = (fEvtStr + i-1)->fMCtracks[j];

    (fEvtStr + i)->fFillStatus = (fEvtStr + i-1)->fFillStatus;
    (fEvtStr + i)->fNtracks = (fEvtStr + i-1)->fNtracks;
    (fEvtStr + i)->fNpairsSE = (fEvtStr + i-1)->fNpairsSE;
    (fEvtStr + i)->fNpairsME = 0;
    (fEvtStr + i)->fMCarraySize = (fEvtStr + i-1)->fMCarraySize;
    
  }// fifo loop


  (fEvtStr)->fNtracks=0;
  (fEvtStr)->fNpairsSE=0;
  (fEvtStr)->fNpairsME=0;
  (fEvtStr)->fFillStatus=0;
  (fEvtStr)->fMCarraySize=0;
}
Commit	Line	Data
cd12341d	1	////////////////////////////////////////////////////////////////////////////////
	2	//
	3	// This class provides storage for event and track information which
	4	// are used for same-event as well as mixed-event analyses in AliChaoticity
	5	//
	6	// authors: Dhevan Gangadharan (dhevan.raja.gangadharan@cern.ch)
	7	//
	8	////////////////////////////////////////////////////////////////////////////////
	9
	10	#include "AliChaoticityEventCollection.h"
	11
cd12341d	12	AliChaoticityTrackStruct::AliChaoticityTrackStruct():
	13	fStatus(0),
	14	fFiltermap(0),
	15	fId(0),
	16	fPhi(0),
	17	fPt(0),
	18	fMom(0),
	19	fP(),
	20	fCharge(0),
	21	fEta(0),
	22	fMass(0),
	23	fDCAXY(0),
	24	fDCAZ(0),
	25	fDCA(0),
	26	fEaccepted(0),
	27	fKey(0),
	28	fClusterMap(0),
	29	fSharedMap(0),
	30	fX(),
	31	fTOFhit(0),
	32	fElectron(0),
	33	fMuon(0),
	34	fPion(0),
	35	fKaon(0),
	36	fProton(0),
	37	fLabel(0)// MC
	38	{
	39	//Default constructor
	40	}
	41	AliChaoticityTrackStruct::AliChaoticityTrackStruct(const AliChaoticityTrackStruct &obj)
	42	: fStatus(obj.fStatus),
	43	fFiltermap(obj.fFiltermap),
	44	fId(obj.fId),
	45	fPhi(obj.fPhi),
	46	fPt(obj.fPt),
	47	fMom(obj.fMom),
	48	fP(),
	49	fCharge(obj.fCharge),
	50	fEta(obj.fEta),
	51	fMass(obj.fMass),
	52	fDCAXY(obj.fDCAXY),
	53	fDCAZ(obj.fDCAZ),
	54	fDCA(obj.fDCA),
	55	fEaccepted(obj.fEaccepted),
	56	fKey(obj.fKey),
	57	fClusterMap(obj.fClusterMap),
	58	fSharedMap(obj.fSharedMap),
	59	fX(),
	60	fTOFhit(obj.fTOFhit),
	61	fElectron(obj.fElectron),
	62	fMuon(obj.fMuon),
	63	fPion(obj.fPion),
	64	fKaon(obj.fKaon),
	65	fProton(obj.fProton),
	66	fLabel(obj.fLabel)// MC
	67	{
	68	// copy constructor
	69	}
	70	AliChaoticityTrackStruct &AliChaoticityTrackStruct::operator=(const AliChaoticityTrackStruct &obj)
	71	{
	72	// Assignment operator
	73	if (this == &obj)
	74	return *this;
	75
76	fStatus = obj.fStatus;
77	fFiltermap = obj.fFiltermap;
78	fId = obj.fId;
79	fPhi = obj.fPhi;
80	fPt = obj.fPt;
81	fMom = obj.fMom;
82	fP[0] = obj.fP[0];
83	fP[1] = obj.fP[1];
84	fP[2] = obj.fP[2];
85	fCharge = obj.fCharge;
86	fEta = obj.fEta;
87	fMass = obj.fMass;
88	fDCAXY = obj.fDCAXY;
89	fDCAZ = obj.fDCAZ;
90	fDCA = obj.fDCA;
91	fEaccepted = obj.fEaccepted;
92	fKey = obj.fKey;
93	fClusterMap = obj.fClusterMap;
94	fSharedMap = obj.fSharedMap;
95	fX[0] = obj.fX[0];
96	fX[1] = obj.fX[1];
97	fX[2] = obj.fX[2];
98	fTOFhit = obj.fTOFhit;
99	fElectron = obj.fElectron;
100	fMuon = obj.fMuon;
101	fPion = obj.fPion;
102	fKaon = obj.fKaon;
103	fProton = obj.fProton;
104	fLabel = obj.fLabel;// MC
105
106	return (*this);
107	}
108	AliChaoticityTrackStruct::~AliChaoticityTrackStruct()
109	{
110	// Destructor
111	}
112
113	//_____________________________________________________________________________
114	AliChaoticityPairStruct::AliChaoticityPairStruct():
115	fP1(),
116	fP2(),
117	fE1(0),
118	fE2(0),
119	fCharge1(0),
120	fCharge2(0),
121	fIndex1(0),
122	fIndex2(0),
123	fQinv(0),
124	fKey1(0),
125	fKey2(0),
126	fLabel1(0),
127	fLabel2(0),
128	fP1MC(),
129	fP2MC()
130	{
131	//Default constructor
132	}
133	AliChaoticityPairStruct::AliChaoticityPairStruct(const AliChaoticityPairStruct &obj)
134	: fP1(),
135	fP2(),
136	fE1(obj.fE1),
137	fE2(obj.fE2),
138	fCharge1(obj.fCharge1),
139	fCharge2(obj.fCharge2),
140	fIndex1(obj.fIndex1),
141	fIndex2(obj.fIndex2),
142	fQinv(obj.fQinv),
143	fKey1(obj.fKey1),
144	fKey2(obj.fKey2),
145	fLabel1(obj.fLabel1),
146	fLabel2(obj.fLabel2),
147	fP1MC(),
148	fP2MC()
149	{
150	// copy constructor
151	}
152	AliChaoticityPairStruct &AliChaoticityPairStruct::operator=(const AliChaoticityPairStruct &obj)
153	{
154	// Assignment operator
155	if (this == &obj)
156	return *this;
157
158	fP1[0] = obj.fP1[0];
159	fP1[1] = obj.fP1[1];
160	fP1[2] = obj.fP1[2];
161	fP2[0] = obj.fP2[0];
162	fP2[1] = obj.fP2[1];
163	fP2[2] = obj.fP2[2];
164	fE1 = obj.fE1;
165	fE2 = obj.fE2;
166	fCharge1 = obj.fCharge1;
167	fCharge2 = obj.fCharge2;
168	fIndex1 = obj.fIndex1;
169	fIndex2 = obj.fIndex2;
170	fQinv = obj.fQinv;
171	fKey1 = obj.fKey1;
172	fKey2 = obj.fKey2;
173	fLabel1 = obj.fLabel1;
174	fLabel2 = obj.fLabel2;
175	fP1MC[0] = obj.fP1MC[0];
176	fP1MC[1] = obj.fP1MC[1];
177	fP1MC[2] = obj.fP1MC[2];
178	fP2MC[0] = obj.fP2MC[0];
179	fP2MC[1] = obj.fP2MC[1];
180	fP2MC[2] = obj.fP2MC[2];
181
182	return (*this);
183	}
184	AliChaoticityPairStruct::~AliChaoticityPairStruct()
185	{
186	// Destructor
187	}
188
189	//_____________________________________________________________________________
190	AliChaoticityNormPairStruct::AliChaoticityNormPairStruct():
191	fCharge1(0),
192	fCharge2(0),
193	fIndex1(0),
194	fIndex2(0),
195	fKey1(0),
196	fKey2(0)
197	{
198	//Default constructor
199	}
200	AliChaoticityNormPairStruct::AliChaoticityNormPairStruct(const AliChaoticityNormPairStruct &obj)
201	: fCharge1(obj.fCharge1),
202	fCharge2(obj.fCharge2),
203	fIndex1(obj.fIndex1),
204	fIndex2(obj.fIndex2),
205	fKey1(obj.fKey1),
206	fKey2(obj.fKey2)
207	{
208	// copy constructor
209	}
210	AliChaoticityNormPairStruct &AliChaoticityNormPairStruct::operator=(const AliChaoticityNormPairStruct &obj)
211	{
212	// Assignment operator
213	if (this == &obj)
214	return *this;
215
216	fCharge1 = obj.fCharge1;
217	fCharge2 = obj.fCharge2;
218	fIndex1 = obj.fIndex1;
219	fIndex2 = obj.fIndex2;
220	fKey1 = obj.fKey1;
221	fKey2 = obj.fKey2;
222
223	return (*this);
224	}
225	AliChaoticityNormPairStruct::~AliChaoticityNormPairStruct()
226	{
227	// Destructor
228	}
229
230	//_____________________________________________________________________________
231	AliChaoticityMCStruct::AliChaoticityMCStruct():
232	fPx(0),
233	fPy(0),
234	fPz(0),
235	fPtot(0)
236	{
237	// Default constructor
238	}
239	AliChaoticityMCStruct::AliChaoticityMCStruct(const AliChaoticityMCStruct &obj)
240	: fPx(obj.fPx),
241	fPy(obj.fPy),
242	fPz(obj.fPz),
243	fPtot(obj.fPtot)
244	{
245	// copy constructor
246	}
247	AliChaoticityMCStruct &AliChaoticityMCStruct::operator=(const AliChaoticityMCStruct &obj)
248	{
249	// Assignment operator
250	if (this == &obj)
251	return *this;
252
253	fPx = obj.fPx;
254	fPy = obj.fPy;
255	fPz = obj.fPz;
256	fPtot = obj.fPtot;
257
258	return (*this);
259	}
260	AliChaoticityMCStruct::~AliChaoticityMCStruct()
261	{
262	// Destructor
263	}
264
265	//_____________________________________________________________________________
266	AliChaoticityEventStruct::AliChaoticityEventStruct():
267	fFillStatus(0),
268	fNtracks(0),
269	fNpairsSE(0),
270	fNpairsME(0),
271	fMCarraySize(0),
272	fTracks(0),
273	fPairsSE(0),
274	fPairsME(0),
275	fMCtracks(0)
276	{
277	// Default constructor
278	}
279	AliChaoticityEventStruct::AliChaoticityEventStruct(const AliChaoticityEventStruct &obj)
280	: fFillStatus(obj.fFillStatus),
281	fNtracks(obj.fNtracks),
282	fNpairsSE(obj.fNpairsSE),
283	fNpairsME(obj.fNpairsME),
284	fMCarraySize(obj.fMCarraySize),
285	fTracks(obj.fTracks),
286	fPairsSE(obj.fPairsSE),
287	fPairsME(obj.fPairsME),
288	fMCtracks(obj.fMCtracks)
289	{
290	// copy constructor
291	}
292	AliChaoticityEventStruct &AliChaoticityEventStruct::operator=(const AliChaoticityEventStruct &obj)
293	{
294	// Assignment operator
295	if (this == &obj)
296	return *this;
297
298	fFillStatus = obj.fFillStatus;
299	fNtracks = obj.fNtracks;
300	fNpairsSE = obj.fNpairsSE;
301	fNpairsME = obj.fNpairsME;
302	fMCarraySize = obj.fMCarraySize;
303	fTracks = obj.fTracks;
304	fPairsSE = obj.fPairsSE;
305	fPairsME = obj.fPairsME;
306	fMCtracks = obj.fMCtracks;
307
308	return (*this);
309	}
310	AliChaoticityEventStruct::~AliChaoticityEventStruct()
311	{
312	// Destructor
313	if(fTracks) delete fTracks;
314	if(fPairsSE) delete fPairsSE;
315	if(fPairsME) delete fPairsME;
316	if(fMCtracks) delete fMCtracks;
317	}
318
319	//_____________________________________________________________________________
320	AliChaoticityEventCollection::AliChaoticityEventCollection():
321	fFIFO(0),
322	fLimit(0),
323	fPairLimit(0),
6e805184	324	fMCLimit(0),
cd12341d	325	fEvtStr(0)
	326	{
	327	// Default constructor
	328	}
6e805184	329	AliChaoticityEventCollection::AliChaoticityEventCollection(Short_t a, Int_t lim, Int_t plimit, Int_t mcarraylimit, Bool_t MCcase):
23a2d019	330	fFIFO(0),
	331	fLimit(0),
	332	fPairLimit(0),
6e805184	333	fMCLimit(0),
23a2d019	334	fEvtStr(0)
	335	{
	336
cd12341d	337	// Main constructor
	338	SetBuffSize(a);
	339
	340	fEvtStr = new AliChaoticityEventStruct[fFIFO]; //allocate pointer array of type particle_event
	341	fLimit = lim;
	342	fPairLimit = plimit;
6e805184	343	fMCLimit = mcarraylimit;
cd12341d	344
	345	for(Int_t ii = 0; ii < fFIFO; ii++){ //Initialize particle table pointers to NULL
	346	(fEvtStr + ii)->fNtracks = 0;
	347	(fEvtStr + ii)->fNpairsSE = 0;
	348	(fEvtStr + ii)->fNpairsME = 0;
	349	(fEvtStr + ii)->fFillStatus = 0;
	350	(fEvtStr + ii)->fMCarraySize = 0;
	351	//
	352	(fEvtStr + ii)->fTracks = NULL;
	353	(fEvtStr + ii)->fTracks = new AliChaoticityTrackStruct[fLimit];
	354	(fEvtStr + ii)->fPairsSE = NULL;
	355	(fEvtStr + ii)->fPairsSE = new AliChaoticityPairStruct[fPairLimit];
	356	(fEvtStr + ii)->fPairsME = NULL;
	357	(fEvtStr + ii)->fPairsME = new AliChaoticityPairStruct[Int_t(2*fPairLimit)];
6e805184	358	if(MCcase) (fEvtStr + ii)->fMCtracks = new AliChaoticityMCStruct[fMCLimit];
cd12341d	359
	360	}
	361	}
	362	AliChaoticityEventCollection::AliChaoticityEventCollection(const AliChaoticityEventCollection &obj)
	363	: fFIFO(obj.fFIFO),
	364	fLimit(obj.fLimit),
	365	fPairLimit(obj.fPairLimit),
6e805184	366	fMCLimit(obj.fMCLimit),
cd12341d	367	fEvtStr(obj.fEvtStr)
	368	{
	369	// copy constructor
	370	}
	371	AliChaoticityEventCollection &AliChaoticityEventCollection::operator=(const AliChaoticityEventCollection &obj)
	372	{
	373	// Assignment operator
	374	if (this == &obj)
	375	return *this;
	376
	377	fFIFO = obj.fFIFO;
	378	fLimit = obj.fLimit;
	379	fPairLimit = obj.fPairLimit;
6e805184	380	fMCLimit = obj.fMCLimit;
cd12341d	381	fEvtStr = obj.fEvtStr;
	382
	383	return (*this);
	384	}
	385	AliChaoticityEventCollection::~AliChaoticityEventCollection(){
	386
	387	for(Int_t i = 0; i < fFIFO; i++){
	388
	389	if((fEvtStr + i)->fTracks != NULL){
	390	delete [] (fEvtStr + i)->fTracks;
	391	delete [] (fEvtStr + i)->fPairsSE;
	392	delete [] (fEvtStr + i)->fPairsME;
	393	delete [] (fEvtStr + i)->fMCtracks;
	394	}
	395
	396	}
	397
	398	delete [] fEvtStr;
	399	//remove histos from heap
	400
	401	}
	402
	403
	404	//_____________________________________________________________________________
	405	void AliChaoticityEventCollection::FIFOShift(){ //Shift elements in FIFO by one and clear last element in FIFO
	406
	407
	408	for(UShort_t i=fFIFO-1 ; i > 0; i--){
	409	for(Int_t j=0; j<(fEvtStr + i-1)->fNtracks; j++) (fEvtStr + i)->fTracks[j] = (fEvtStr + i-1)->fTracks[j];
	410	for(Int_t j=0; j<(fEvtStr + i-1)->fNpairsSE; j++) (fEvtStr + i)->fPairsSE[j] = (fEvtStr + i-1)->fPairsSE[j];
	411	for(Int_t j=0; j<(fEvtStr + i-1)->fMCarraySize; j++) (fEvtStr + i)->fMCtracks[j] = (fEvtStr + i-1)->fMCtracks[j];
	412
	413	(fEvtStr + i)->fFillStatus = (fEvtStr + i-1)->fFillStatus;
	414	(fEvtStr + i)->fNtracks = (fEvtStr + i-1)->fNtracks;
	415	(fEvtStr + i)->fNpairsSE = (fEvtStr + i-1)->fNpairsSE;
	416	(fEvtStr + i)->fNpairsME = 0;
	417	(fEvtStr + i)->fMCarraySize = (fEvtStr + i-1)->fMCarraySize;
	418
	419	}// fifo loop
	420
	421
	422	(fEvtStr)->fNtracks=0;
	423	(fEvtStr)->fNpairsSE=0;
	424	(fEvtStr)->fNpairsME=0;
	425	(fEvtStr)->fFillStatus=0;
	426	(fEvtStr)->fMCarraySize=0;
	427	}