ROOT logo
/**************************************************************************
 * Copyright(c) 1998-2007, 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.                  *
 **************************************************************************/

/* $Id$ */


//-------------------------------------------------------------------------
//                          Class AliMixedEvent
// VEvent which is the container of several VEvents 
// Use Case: Event Mixing     
// Origin: Andreas Morsch, CERN, Andreas.Morsch@cern.ch 
//-------------------------------------------------------------------------


#include "AliMixedEvent.h"
#include "AliExternalTrackParam.h"
#include "TVector3.h"
#include "AliVVertex.h"
#include <TMath.h>
#include <TMatrix.h>
#include <TMatrixD.h>
#include "AliLog.h"
#include "AliVCaloCells.h"


ClassImp(AliMixedEvent)


AliMixedEvent::AliMixedEvent() :
  AliVEvent(),
  fEventList(),
  fNEvents(0),       
  fNumberOfTracks(0),
  fNumberOfCaloClusters(0), 
  fNumberOfPHOSCells(0), 
  fNumberOfEMCALCells(0),
  fNTracksCumul(0),
  fNCaloClustersCumul(0),
  fNPHOSCellsCumul(0), 
  fNEMCALCellsCumul(0), 
  fPHOSCells(NULL), 
  fEMCALCells(NULL), 
  fMeanVertex(0)
{
    // Default constructor
}

AliMixedEvent::AliMixedEvent(const AliMixedEvent& Evnt) :
  AliVEvent(Evnt),
  fEventList(),
  fNEvents(0),
  fNumberOfTracks(0),
  fNumberOfCaloClusters(0), 
  fNumberOfPHOSCells(0), 
  fNumberOfEMCALCells(0),
  fNTracksCumul(0),
  fNCaloClustersCumul(0),
  fNPHOSCellsCumul(0), 
  fNEMCALCellsCumul(0), 
  fPHOSCells(NULL), 
  fEMCALCells(NULL), 
  fMeanVertex(0)
{ } // Copy constructor

AliMixedEvent& AliMixedEvent::operator=(const AliMixedEvent& vEvnt)
{ 
// Assignment operator
    if (this!=&vEvnt) { 
    AliVEvent::operator=(vEvnt); 
}
  
  return *this; 
}

AliMixedEvent::~AliMixedEvent() 
{
    // dtor
  Reset();
  delete fPHOSCells ; 
  delete fEMCALCells ; 
} 


void AliMixedEvent::AddEvent(AliVEvent* evt)
{
    // Add a new event to the list
    fEventList.AddLast(evt);
}


void AliMixedEvent::Init()
{
    // Initialize meta information
  fNEvents = fEventList.GetEntries();
  fNTracksCumul = new Int_t[fNEvents];
  fNumberOfTracks = 0;
  fNCaloClustersCumul = new Int_t[fNEvents];
  fNumberOfCaloClusters = 0;
  fNumberOfPHOSCells    = 0;  
  fNumberOfEMCALCells   = 0; 
  fNPHOSCellsCumul  = new Int_t[fNEvents];
  fNEMCALCellsCumul = new Int_t[fNEvents];

  TIter next(&fEventList);
  AliVEvent* event;
  Int_t iev = 0;
    
  while((event = (AliVEvent*)next())) {
    fNTracksCumul[iev] = fNumberOfTracks;
    fNumberOfTracks += (event->GetNumberOfTracks());
    fNCaloClustersCumul[iev] = fNumberOfCaloClusters;
    fNumberOfCaloClusters += event->GetNumberOfCaloClusters(); 
    fNPHOSCellsCumul[iev] = fNumberOfPHOSCells;
    if (event->GetPHOSCells()) 
      fNumberOfPHOSCells += event->GetPHOSCells()->GetNumberOfCells(); 
    fNEMCALCellsCumul[iev] = fNumberOfEMCALCells;
    if (event->GetEMCALCells()) 
      fNumberOfEMCALCells += event->GetEMCALCells()->GetNumberOfCells(); 
    iev++ ;  
  }

  next.Reset() ; 
  Short_t phosPos = 0, emcalPos = 0; 
  Int_t firstPHOSEvent  = kTRUE;
  Int_t firstEMCALEvent = kTRUE;
  
  while((event = (AliVEvent*)next())) {
    AliVCaloCells * phosCells = event->GetPHOSCells() ; 
    if (phosCells) {
      
      //Create the container
      if(firstPHOSEvent)
      {
        if(!fPHOSCells) fPHOSCells = phosCells->CopyCaloCells(kFALSE) ;// Just recover the first event type:  ESD/AOD
        else fPHOSCells->DeleteContainer(); //delete the previous container 
        //Now create a new container with the adequate size
        fPHOSCells->SetType(AliVCaloCells::kPHOSCell) ; 
        fPHOSCells->CreateContainer(fNumberOfPHOSCells) ;
        firstPHOSEvent=kFALSE;

      }//First event

      Int_t ncells = event->GetPHOSCells()->GetNumberOfCells() ;
      for (Int_t icell = 0; icell < ncells; icell++) {
          fPHOSCells->SetCell(phosPos++, phosCells->GetCellNumber(icell), phosCells->GetAmplitude(icell), 
                              phosCells->GetTime(icell),phosCells->GetMCLabel(icell),phosCells->GetEFraction(icell)) ; 
      }
     
    }// phos cells
    
    AliVCaloCells * emcalCells = event->GetEMCALCells() ; 
    if (emcalCells) {
      
      //Create the container
      if(firstEMCALEvent)
      {
        if(!fEMCALCells)fEMCALCells = emcalCells->CopyCaloCells(kFALSE) ; // Just recover the first event type:  ESD/AOD
        else fEMCALCells->DeleteContainer();       // delete the previous container
        //Now create a new container with the adequate size
        fEMCALCells->SetType(AliVCaloCells::kEMCALCell) ; 
        fEMCALCells->CreateContainer(fNumberOfEMCALCells) ;
        firstEMCALEvent=kFALSE;
      }//First event
      
      Int_t ncells = emcalCells->GetNumberOfCells() ;
      for (Int_t icell = 0; icell < ncells; icell++) {
          fEMCALCells->SetCell(emcalPos++, emcalCells->GetCellNumber(icell), emcalCells->GetAmplitude(icell), 
                               emcalCells->GetTime(icell),emcalCells->GetMCLabel(icell),emcalCells->GetEFraction(icell)) ; 
      }
    }//EMCAL cells
  }//while event
  
}

AliVParticle* AliMixedEvent::GetTrack(Int_t i) const
{
    // Return track # i
    Int_t iEv  = TMath::BinarySearch(fNEvents, fNTracksCumul, i);
    while((iEv < (fNEvents - 1)) && (fNTracksCumul[iEv] == fNTracksCumul[iEv+1])) {iEv++;}

    Int_t irel = i - fNTracksCumul[iEv];
    AliVEvent* evt = (AliVEvent*) (fEventList.At(iEv));
    return (evt->GetTrack(irel));
}

AliVCluster* AliMixedEvent::GetCaloCluster(Int_t i) const
{
    // Return calo cluster # i
  Int_t iEv  = TMath::BinarySearch(fNEvents, fNCaloClustersCumul, i);
  while((iEv < (fNEvents - 1)) && (fNCaloClustersCumul[iEv] == fNCaloClustersCumul[iEv+1])) {iEv++;}
  
  Int_t irel = i - fNCaloClustersCumul[iEv];
  AliVEvent* evt = (AliVEvent*) (fEventList.At(iEv));
  return (evt->GetCaloCluster(irel));
}

const AliVVertex* AliMixedEvent::GetEventVertex(Int_t i) const
{
    // Return vertex of track # i
    Int_t iEv  = TMath::BinarySearch(fNEvents, fNTracksCumul, i);
    while((iEv < (fNEvents - 1)) && (fNTracksCumul[iEv] == fNTracksCumul[iEv+1])) {iEv++;}
    AliVEvent* evt = (AliVEvent*) (fEventList.At(iEv));
    return (evt->GetPrimaryVertex());
}

const AliVVertex* AliMixedEvent::GetVertexOfEvent(Int_t i) const
{
    // Return vertex of event # i
  if (i > fNEvents)
    AliFatal(Form("%d events in buffer, event %d requested", fNEvents, i)) ;  
  AliVEvent* evt = (AliVEvent*) (fEventList.At(i));
  return (evt->GetPrimaryVertex());
}

void AliMixedEvent::Reset()
{
    // Reset the event
  fEventList.Clear();
  fNEvents = 0;
  fNumberOfTracks = 0;
  fNumberOfCaloClusters = 0;
  fNumberOfPHOSCells = 0;
  fNumberOfEMCALCells = 0;
  if (fNTracksCumul) {
    delete[]  fNTracksCumul;
    fNTracksCumul = 0;
  }
  if (fNCaloClustersCumul) {
    delete[]  fNCaloClustersCumul;
    fNCaloClustersCumul = 0;
  }
  if (fNPHOSCellsCumul) {
    delete[]  fNPHOSCellsCumul;
    fNPHOSCellsCumul = 0;
  }
  if (fNEMCALCellsCumul) {
    delete[]  fNEMCALCellsCumul;
    fNEMCALCellsCumul = 0;
  }
  
  if (fPHOSCells) {	 
    fPHOSCells->DeleteContainer();	 
  }	 
  if (fEMCALCells) {	 
    fEMCALCells->DeleteContainer();	 
  }
  
}

Int_t AliMixedEvent::EventIndex(Int_t itrack) const
{
  // Return the event index for track #itrack
  return  TMath::BinarySearch(fNEvents, fNTracksCumul, itrack);
}

Int_t AliMixedEvent::EventIndexForCaloCluster(Int_t icluster) const
{
    // Return the event index for track #itrack
  return  TMath::BinarySearch(fNEvents, fNCaloClustersCumul, icluster);
}

Int_t AliMixedEvent::EventIndexForPHOSCell(Int_t icell) const
{
    // Return the event index for track #itrack
  return  TMath::BinarySearch(fNEvents, fNPHOSCellsCumul, icell);
}

Int_t AliMixedEvent::EventIndexForEMCALCell(Int_t icell) const
{
    // Return the event index for track #itrack
  return  TMath::BinarySearch(fNEvents, fNEMCALCellsCumul, icell);
}

Bool_t AliMixedEvent::ComputeVtx(const TObjArray *vertices, Double_t *pos,Double_t *sig,Int_t *nContributors)  {
//
// Calculate the mean vertex psoitions from events in the buffer
 
    Int_t nentries = vertices->GetEntriesFast();
    Double_t sum[3]={0.,0.,0.};
    Double_t sumsigma[6]={0.,0.,0.,0.,0.,0.};

    
    for(Int_t ivtx = 0; ivtx < nentries; ivtx++){
	AliVVertex *vtx=(AliVVertex*)vertices->UncheckedAt(ivtx);
	Double_t covariance[6];
	vtx->GetCovarianceMatrix(covariance);
	Double_t vtxPos[3];
	vtx->GetXYZ(vtxPos);
	if(TMath::Abs(covariance[0])<1.e-13) {
	return kFALSE;
	}else{
	sum[0]+=vtxPos[0]*(1./covariance[0]);
	sumsigma[0]+=(1./covariance[0]);
	}
	if(TMath::Abs(covariance[2])<1.e-13) {
	return kFALSE;
	}else{
	sum[1]+=vtxPos[1]*(1./covariance[2]);
	sumsigma[2]+=(1./covariance[2]);
	}
	if(TMath::Abs(covariance[5])<1.e-13) {
	return kFALSE;
	}else{
	sum[2]+=vtxPos[2]*(1./covariance[5]);
	sumsigma[5]+=(1./covariance[5]);
	}
	if(TMath::Abs(covariance[1])<1.e-13) {
         sumsigma[1]+=0.;
	}else{
	sumsigma[1]+=(1./covariance[1]);
	}
	if(TMath::Abs(covariance[3])<1.e-13) {
	sumsigma[3]+=0.;
	}else{
	sumsigma[3]+=(1./covariance[3]);
	}
	if(TMath::Abs(covariance[4])<1.e-13) {
	sumsigma[4]+=0.;
	}else{
	sumsigma[4]+=(1./covariance[4]);
	}

     nContributors[0]=nContributors[0]+vtx->GetNContributors();
    }
    
    for(Int_t i=0;i<3;i++){
	if(TMath::Abs(sumsigma[i])<1.e-13) continue;
	pos[i]=sum[i]/sumsigma[i];
    }
    for(Int_t i2=0;i2<3;i2++){
	if(TMath::Abs(sumsigma[i2])<1.e-13) {sig[i2]=0.; continue;}
	sig[i2]=1./sumsigma[i2];
    }
    return kTRUE;
}


Double_t AliMixedEvent::GetMagneticField() const
{
    // Return magnetic field of the first event in the list
    if (fEventList.GetEntries() == 0) return -999.;
    
    AliVEvent* evt = (AliVEvent*) (fEventList.At(0));
    return evt->GetMagneticField();
}

AliVEvent::EDataLayoutType AliMixedEvent::GetDataLayoutType() const
{
  return AliVEvent::kMixed;
}
 AliMixedEvent.cxx:1
 AliMixedEvent.cxx:2
 AliMixedEvent.cxx:3
 AliMixedEvent.cxx:4
 AliMixedEvent.cxx:5
 AliMixedEvent.cxx:6
 AliMixedEvent.cxx:7
 AliMixedEvent.cxx:8
 AliMixedEvent.cxx:9
 AliMixedEvent.cxx:10
 AliMixedEvent.cxx:11
 AliMixedEvent.cxx:12
 AliMixedEvent.cxx:13
 AliMixedEvent.cxx:14
 AliMixedEvent.cxx:15
 AliMixedEvent.cxx:16
 AliMixedEvent.cxx:17
 AliMixedEvent.cxx:18
 AliMixedEvent.cxx:19
 AliMixedEvent.cxx:20
 AliMixedEvent.cxx:21
 AliMixedEvent.cxx:22
 AliMixedEvent.cxx:23
 AliMixedEvent.cxx:24
 AliMixedEvent.cxx:25
 AliMixedEvent.cxx:26
 AliMixedEvent.cxx:27
 AliMixedEvent.cxx:28
 AliMixedEvent.cxx:29
 AliMixedEvent.cxx:30
 AliMixedEvent.cxx:31
 AliMixedEvent.cxx:32
 AliMixedEvent.cxx:33
 AliMixedEvent.cxx:34
 AliMixedEvent.cxx:35
 AliMixedEvent.cxx:36
 AliMixedEvent.cxx:37
 AliMixedEvent.cxx:38
 AliMixedEvent.cxx:39
 AliMixedEvent.cxx:40
 AliMixedEvent.cxx:41
 AliMixedEvent.cxx:42
 AliMixedEvent.cxx:43
 AliMixedEvent.cxx:44
 AliMixedEvent.cxx:45
 AliMixedEvent.cxx:46
 AliMixedEvent.cxx:47
 AliMixedEvent.cxx:48
 AliMixedEvent.cxx:49
 AliMixedEvent.cxx:50
 AliMixedEvent.cxx:51
 AliMixedEvent.cxx:52
 AliMixedEvent.cxx:53
 AliMixedEvent.cxx:54
 AliMixedEvent.cxx:55
 AliMixedEvent.cxx:56
 AliMixedEvent.cxx:57
 AliMixedEvent.cxx:58
 AliMixedEvent.cxx:59
 AliMixedEvent.cxx:60
 AliMixedEvent.cxx:61
 AliMixedEvent.cxx:62
 AliMixedEvent.cxx:63
 AliMixedEvent.cxx:64
 AliMixedEvent.cxx:65
 AliMixedEvent.cxx:66
 AliMixedEvent.cxx:67
 AliMixedEvent.cxx:68
 AliMixedEvent.cxx:69
 AliMixedEvent.cxx:70
 AliMixedEvent.cxx:71
 AliMixedEvent.cxx:72
 AliMixedEvent.cxx:73
 AliMixedEvent.cxx:74
 AliMixedEvent.cxx:75
 AliMixedEvent.cxx:76
 AliMixedEvent.cxx:77
 AliMixedEvent.cxx:78
 AliMixedEvent.cxx:79
 AliMixedEvent.cxx:80
 AliMixedEvent.cxx:81
 AliMixedEvent.cxx:82
 AliMixedEvent.cxx:83
 AliMixedEvent.cxx:84
 AliMixedEvent.cxx:85
 AliMixedEvent.cxx:86
 AliMixedEvent.cxx:87
 AliMixedEvent.cxx:88
 AliMixedEvent.cxx:89
 AliMixedEvent.cxx:90
 AliMixedEvent.cxx:91
 AliMixedEvent.cxx:92
 AliMixedEvent.cxx:93
 AliMixedEvent.cxx:94
 AliMixedEvent.cxx:95
 AliMixedEvent.cxx:96
 AliMixedEvent.cxx:97
 AliMixedEvent.cxx:98
 AliMixedEvent.cxx:99
 AliMixedEvent.cxx:100
 AliMixedEvent.cxx:101
 AliMixedEvent.cxx:102
 AliMixedEvent.cxx:103
 AliMixedEvent.cxx:104
 AliMixedEvent.cxx:105
 AliMixedEvent.cxx:106
 AliMixedEvent.cxx:107
 AliMixedEvent.cxx:108
 AliMixedEvent.cxx:109
 AliMixedEvent.cxx:110
 AliMixedEvent.cxx:111
 AliMixedEvent.cxx:112
 AliMixedEvent.cxx:113
 AliMixedEvent.cxx:114
 AliMixedEvent.cxx:115
 AliMixedEvent.cxx:116
 AliMixedEvent.cxx:117
 AliMixedEvent.cxx:118
 AliMixedEvent.cxx:119
 AliMixedEvent.cxx:120
 AliMixedEvent.cxx:121
 AliMixedEvent.cxx:122
 AliMixedEvent.cxx:123
 AliMixedEvent.cxx:124
 AliMixedEvent.cxx:125
 AliMixedEvent.cxx:126
 AliMixedEvent.cxx:127
 AliMixedEvent.cxx:128
 AliMixedEvent.cxx:129
 AliMixedEvent.cxx:130
 AliMixedEvent.cxx:131
 AliMixedEvent.cxx:132
 AliMixedEvent.cxx:133
 AliMixedEvent.cxx:134
 AliMixedEvent.cxx:135
 AliMixedEvent.cxx:136
 AliMixedEvent.cxx:137
 AliMixedEvent.cxx:138
 AliMixedEvent.cxx:139
 AliMixedEvent.cxx:140
 AliMixedEvent.cxx:141
 AliMixedEvent.cxx:142
 AliMixedEvent.cxx:143
 AliMixedEvent.cxx:144
 AliMixedEvent.cxx:145
 AliMixedEvent.cxx:146
 AliMixedEvent.cxx:147
 AliMixedEvent.cxx:148
 AliMixedEvent.cxx:149
 AliMixedEvent.cxx:150
 AliMixedEvent.cxx:151
 AliMixedEvent.cxx:152
 AliMixedEvent.cxx:153
 AliMixedEvent.cxx:154
 AliMixedEvent.cxx:155
 AliMixedEvent.cxx:156
 AliMixedEvent.cxx:157
 AliMixedEvent.cxx:158
 AliMixedEvent.cxx:159
 AliMixedEvent.cxx:160
 AliMixedEvent.cxx:161
 AliMixedEvent.cxx:162
 AliMixedEvent.cxx:163
 AliMixedEvent.cxx:164
 AliMixedEvent.cxx:165
 AliMixedEvent.cxx:166
 AliMixedEvent.cxx:167
 AliMixedEvent.cxx:168
 AliMixedEvent.cxx:169
 AliMixedEvent.cxx:170
 AliMixedEvent.cxx:171
 AliMixedEvent.cxx:172
 AliMixedEvent.cxx:173
 AliMixedEvent.cxx:174
 AliMixedEvent.cxx:175
 AliMixedEvent.cxx:176
 AliMixedEvent.cxx:177
 AliMixedEvent.cxx:178
 AliMixedEvent.cxx:179
 AliMixedEvent.cxx:180
 AliMixedEvent.cxx:181
 AliMixedEvent.cxx:182
 AliMixedEvent.cxx:183
 AliMixedEvent.cxx:184
 AliMixedEvent.cxx:185
 AliMixedEvent.cxx:186
 AliMixedEvent.cxx:187
 AliMixedEvent.cxx:188
 AliMixedEvent.cxx:189
 AliMixedEvent.cxx:190
 AliMixedEvent.cxx:191
 AliMixedEvent.cxx:192
 AliMixedEvent.cxx:193
 AliMixedEvent.cxx:194
 AliMixedEvent.cxx:195
 AliMixedEvent.cxx:196
 AliMixedEvent.cxx:197
 AliMixedEvent.cxx:198
 AliMixedEvent.cxx:199
 AliMixedEvent.cxx:200
 AliMixedEvent.cxx:201
 AliMixedEvent.cxx:202
 AliMixedEvent.cxx:203
 AliMixedEvent.cxx:204
 AliMixedEvent.cxx:205
 AliMixedEvent.cxx:206
 AliMixedEvent.cxx:207
 AliMixedEvent.cxx:208
 AliMixedEvent.cxx:209
 AliMixedEvent.cxx:210
 AliMixedEvent.cxx:211
 AliMixedEvent.cxx:212
 AliMixedEvent.cxx:213
 AliMixedEvent.cxx:214
 AliMixedEvent.cxx:215
 AliMixedEvent.cxx:216
 AliMixedEvent.cxx:217
 AliMixedEvent.cxx:218
 AliMixedEvent.cxx:219
 AliMixedEvent.cxx:220
 AliMixedEvent.cxx:221
 AliMixedEvent.cxx:222
 AliMixedEvent.cxx:223
 AliMixedEvent.cxx:224
 AliMixedEvent.cxx:225
 AliMixedEvent.cxx:226
 AliMixedEvent.cxx:227
 AliMixedEvent.cxx:228
 AliMixedEvent.cxx:229
 AliMixedEvent.cxx:230
 AliMixedEvent.cxx:231
 AliMixedEvent.cxx:232
 AliMixedEvent.cxx:233
 AliMixedEvent.cxx:234
 AliMixedEvent.cxx:235
 AliMixedEvent.cxx:236
 AliMixedEvent.cxx:237
 AliMixedEvent.cxx:238
 AliMixedEvent.cxx:239
 AliMixedEvent.cxx:240
 AliMixedEvent.cxx:241
 AliMixedEvent.cxx:242
 AliMixedEvent.cxx:243
 AliMixedEvent.cxx:244
 AliMixedEvent.cxx:245
 AliMixedEvent.cxx:246
 AliMixedEvent.cxx:247
 AliMixedEvent.cxx:248
 AliMixedEvent.cxx:249
 AliMixedEvent.cxx:250
 AliMixedEvent.cxx:251
 AliMixedEvent.cxx:252
 AliMixedEvent.cxx:253
 AliMixedEvent.cxx:254
 AliMixedEvent.cxx:255
 AliMixedEvent.cxx:256
 AliMixedEvent.cxx:257
 AliMixedEvent.cxx:258
 AliMixedEvent.cxx:259
 AliMixedEvent.cxx:260
 AliMixedEvent.cxx:261
 AliMixedEvent.cxx:262
 AliMixedEvent.cxx:263
 AliMixedEvent.cxx:264
 AliMixedEvent.cxx:265
 AliMixedEvent.cxx:266
 AliMixedEvent.cxx:267
 AliMixedEvent.cxx:268
 AliMixedEvent.cxx:269
 AliMixedEvent.cxx:270
 AliMixedEvent.cxx:271
 AliMixedEvent.cxx:272
 AliMixedEvent.cxx:273
 AliMixedEvent.cxx:274
 AliMixedEvent.cxx:275
 AliMixedEvent.cxx:276
 AliMixedEvent.cxx:277
 AliMixedEvent.cxx:278
 AliMixedEvent.cxx:279
 AliMixedEvent.cxx:280
 AliMixedEvent.cxx:281
 AliMixedEvent.cxx:282
 AliMixedEvent.cxx:283
 AliMixedEvent.cxx:284
 AliMixedEvent.cxx:285
 AliMixedEvent.cxx:286
 AliMixedEvent.cxx:287
 AliMixedEvent.cxx:288
 AliMixedEvent.cxx:289
 AliMixedEvent.cxx:290
 AliMixedEvent.cxx:291
 AliMixedEvent.cxx:292
 AliMixedEvent.cxx:293
 AliMixedEvent.cxx:294
 AliMixedEvent.cxx:295
 AliMixedEvent.cxx:296
 AliMixedEvent.cxx:297
 AliMixedEvent.cxx:298
 AliMixedEvent.cxx:299
 AliMixedEvent.cxx:300
 AliMixedEvent.cxx:301
 AliMixedEvent.cxx:302
 AliMixedEvent.cxx:303
 AliMixedEvent.cxx:304
 AliMixedEvent.cxx:305
 AliMixedEvent.cxx:306
 AliMixedEvent.cxx:307
 AliMixedEvent.cxx:308
 AliMixedEvent.cxx:309
 AliMixedEvent.cxx:310
 AliMixedEvent.cxx:311
 AliMixedEvent.cxx:312
 AliMixedEvent.cxx:313
 AliMixedEvent.cxx:314
 AliMixedEvent.cxx:315
 AliMixedEvent.cxx:316
 AliMixedEvent.cxx:317
 AliMixedEvent.cxx:318
 AliMixedEvent.cxx:319
 AliMixedEvent.cxx:320
 AliMixedEvent.cxx:321
 AliMixedEvent.cxx:322
 AliMixedEvent.cxx:323
 AliMixedEvent.cxx:324
 AliMixedEvent.cxx:325
 AliMixedEvent.cxx:326
 AliMixedEvent.cxx:327
 AliMixedEvent.cxx:328
 AliMixedEvent.cxx:329
 AliMixedEvent.cxx:330
 AliMixedEvent.cxx:331
 AliMixedEvent.cxx:332
 AliMixedEvent.cxx:333
 AliMixedEvent.cxx:334
 AliMixedEvent.cxx:335
 AliMixedEvent.cxx:336
 AliMixedEvent.cxx:337
 AliMixedEvent.cxx:338
 AliMixedEvent.cxx:339
 AliMixedEvent.cxx:340
 AliMixedEvent.cxx:341
 AliMixedEvent.cxx:342
 AliMixedEvent.cxx:343
 AliMixedEvent.cxx:344
 AliMixedEvent.cxx:345
 AliMixedEvent.cxx:346
 AliMixedEvent.cxx:347
 AliMixedEvent.cxx:348
 AliMixedEvent.cxx:349
 AliMixedEvent.cxx:350
 AliMixedEvent.cxx:351
 AliMixedEvent.cxx:352
 AliMixedEvent.cxx:353
 AliMixedEvent.cxx:354
 AliMixedEvent.cxx:355
 AliMixedEvent.cxx:356
 AliMixedEvent.cxx:357
 AliMixedEvent.cxx:358
 AliMixedEvent.cxx:359
 AliMixedEvent.cxx:360
 AliMixedEvent.cxx:361
 AliMixedEvent.cxx:362