[u/mrichter/AliRoot.git] / STEER / STEERBase / AliMixedEvent.cxx

/**************************************************************************
 * 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();
}
Commit	Line	Data
7eb061fb	1	/**************************************************************************
	2	* Copyright(c) 1998-2007, 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	/* $Id$ */
	17
	18
	19	//-------------------------------------------------------------------------
	20	// Class AliMixedEvent
	21	// VEvent which is the container of several VEvents
	22	// Use Case: Event Mixing
	23	// Origin: Andreas Morsch, CERN, Andreas.Morsch@cern.ch
	24	//-------------------------------------------------------------------------
	25
	26
	27	#include "AliMixedEvent.h"
bbeb9cae	28	#include "AliExternalTrackParam.h"
bbeb9cae	29	#include "TVector3.h"
c79face6	30	#include "AliVVertex.h"
7eb061fb	31	#include <TMath.h>
bbeb9cae	32	#include <TMatrix.h>
bbeb9cae	33	#include <TMatrixD.h>
c8fe2783	34	#include "AliLog.h"
	35	#include "AliVCaloCells.h"
	36
7eb061fb	37
	38	ClassImp(AliMixedEvent)
	39
	40
	41	AliMixedEvent::AliMixedEvent() :
c8fe2783	42	AliVEvent(),
	43	fEventList(),
	44	fNEvents(0),
	45	fNumberOfTracks(0),
	46	fNumberOfCaloClusters(0),
	47	fNumberOfPHOSCells(0),
	48	fNumberOfEMCALCells(0),
	49	fNTracksCumul(0),
	50	fNCaloClustersCumul(0),
	51	fNPHOSCellsCumul(0),
	52	fNEMCALCellsCumul(0),
	53	fPHOSCells(NULL),
	54	fEMCALCells(NULL),
	55	fMeanVertex(0)
7eb061fb	56	{
	57	// Default constructor
	58	}
	59
7eb061fb	60	AliMixedEvent::AliMixedEvent(const AliMixedEvent& Evnt) :
c8fe2783	61	AliVEvent(Evnt),
	62	fEventList(),
	63	fNEvents(0),
	64	fNumberOfTracks(0),
	65	fNumberOfCaloClusters(0),
	66	fNumberOfPHOSCells(0),
	67	fNumberOfEMCALCells(0),
	68	fNTracksCumul(0),
	69	fNCaloClustersCumul(0),
	70	fNPHOSCellsCumul(0),
	71	fNEMCALCellsCumul(0),
	72	fPHOSCells(NULL),
	73	fEMCALCells(NULL),
	74	fMeanVertex(0)
a2813d8b	75	{ } // Copy constructor
7eb061fb	76
7eb061fb	77	AliMixedEvent& AliMixedEvent::operator=(const AliMixedEvent& vEvnt)
aa7e002c	78	{
	79	// Assignment operator
	80	if (this!=&vEvnt) {
7eb061fb	81	AliVEvent::operator=(vEvnt);
aa7e002c	82	}
7eb061fb	83
	84	return *this;
	85	}
	86
c8fe2783	87	AliMixedEvent::~AliMixedEvent()
	88	{
	89	// dtor
	90	Reset();
	91	delete fPHOSCells ;
	92	delete fEMCALCells ;
	93	}
	94
7eb061fb	95
	96	void AliMixedEvent::AddEvent(AliVEvent* evt)
	97	{
	98	// Add a new event to the list
bbeb9cae	99	fEventList.AddLast(evt);
7eb061fb	100	}
	101
	102
	103	void AliMixedEvent::Init()
	104	{
	105	// Initialize meta information
c8fe2783	106	fNEvents = fEventList.GetEntries();
	107	fNTracksCumul = new Int_t[fNEvents];
	108	fNumberOfTracks = 0;
	109	fNCaloClustersCumul = new Int_t[fNEvents];
	110	fNumberOfCaloClusters = 0;
	111	fNumberOfPHOSCells = 0;
	112	fNumberOfEMCALCells = 0;
	113	fNPHOSCellsCumul = new Int_t[fNEvents];
	114	fNEMCALCellsCumul = new Int_t[fNEvents];
	115
	116	TIter next(&fEventList);
	117	AliVEvent* event;
	118	Int_t iev = 0;
7eb061fb	119
c8fe2783	120	while((event = (AliVEvent*)next())) {
	121	fNTracksCumul[iev] = fNumberOfTracks;
	122	fNumberOfTracks += (event->GetNumberOfTracks());
	123	fNCaloClustersCumul[iev] = fNumberOfCaloClusters;
	124	fNumberOfCaloClusters += event->GetNumberOfCaloClusters();
	125	fNPHOSCellsCumul[iev] = fNumberOfPHOSCells;
	126	if (event->GetPHOSCells())
	127	fNumberOfPHOSCells += event->GetPHOSCells()->GetNumberOfCells();
	128	fNEMCALCellsCumul[iev] = fNumberOfEMCALCells;
	129	if (event->GetEMCALCells())
	130	fNumberOfEMCALCells += event->GetEMCALCells()->GetNumberOfCells();
	131	iev++ ;
	132	}
7eb061fb	133
c8fe2783	134	next.Reset() ;
c8fe2783	135	Short_t phosPos = 0, emcalPos = 0;
a02655c6	136	Int_t firstPHOSEvent = kTRUE;
	137	Int_t firstEMCALEvent = kTRUE;
	138
c8fe2783	139	while((event = (AliVEvent*)next())) {
ecff8f07	140	AliVCaloCells * phosCells = event->GetPHOSCells() ;
ecff8f07	141	if (phosCells) {
a02655c6	142
	143	//Create the container
	144	if(firstPHOSEvent)
	145	{
ecff8f07	146	if(!fPHOSCells) fPHOSCells = phosCells->CopyCaloCells(kFALSE) ;// Just recover the first event type: ESD/AOD
	147	else fPHOSCells->DeleteContainer(); //delete the previous container
	148	//Now create a new container with the adequate size
a02655c6	149	fPHOSCells->SetType(AliVCaloCells::kPHOSCell) ;
a02655c6	150	fPHOSCells->CreateContainer(fNumberOfPHOSCells) ;
a02655c6	151	firstPHOSEvent=kFALSE;
ecff8f07	152
	153	}//First event
	154
	155	Int_t ncells = event->GetPHOSCells()->GetNumberOfCells() ;
	156	for (Int_t icell = 0; icell < ncells; icell++) {
77e93dc2	157	fPHOSCells->SetCell(phosPos++, phosCells->GetCellNumber(icell), phosCells->GetAmplitude(icell),
77e93dc2	158	phosCells->GetTime(icell),phosCells->GetMCLabel(icell),phosCells->GetEFraction(icell)) ;
ecff8f07	159	}
	160
	161	}// phos cells
	162
	163	AliVCaloCells * emcalCells = event->GetEMCALCells() ;
	164	if (emcalCells) {
a02655c6	165
	166	//Create the container
	167	if(firstEMCALEvent)
	168	{
ecff8f07	169	if(!fEMCALCells)fEMCALCells = emcalCells->CopyCaloCells(kFALSE) ; // Just recover the first event type: ESD/AOD
	170	else fEMCALCells->DeleteContainer(); // delete the previous container
	171	//Now create a new container with the adequate size
a02655c6	172	fEMCALCells->SetType(AliVCaloCells::kEMCALCell) ;
a02655c6	173	fEMCALCells->CreateContainer(fNumberOfEMCALCells) ;
a02655c6	174	firstEMCALEvent=kFALSE;
ecff8f07	175	}//First event
	176
	177	Int_t ncells = emcalCells->GetNumberOfCells() ;
	178	for (Int_t icell = 0; icell < ncells; icell++) {
77e93dc2	179	fEMCALCells->SetCell(emcalPos++, emcalCells->GetCellNumber(icell), emcalCells->GetAmplitude(icell),
77e93dc2	180	emcalCells->GetTime(icell),emcalCells->GetMCLabel(icell),emcalCells->GetEFraction(icell)) ;
ecff8f07	181	}
	182	}//EMCAL cells
	183	}//while event
	184
c8fe2783	185	}
7eb061fb	186
	187	AliVParticle* AliMixedEvent::GetTrack(Int_t i) const
	188	{
	189	// Return track # i
	190	Int_t iEv = TMath::BinarySearch(fNEvents, fNTracksCumul, i);
18476ce9	191	while((iEv < (fNEvents - 1)) && (fNTracksCumul[iEv] == fNTracksCumul[iEv+1])) {iEv++;}
bbeb9cae	192
7eb061fb	193	Int_t irel = i - fNTracksCumul[iEv];
	194	AliVEvent* evt = (AliVEvent*) (fEventList.At(iEv));
	195	return (evt->GetTrack(irel));
	196	}
	197
c8fe2783	198	AliVCluster* AliMixedEvent::GetCaloCluster(Int_t i) const
	199	{
	200	// Return calo cluster # i
	201	Int_t iEv = TMath::BinarySearch(fNEvents, fNCaloClustersCumul, i);
	202	while((iEv < (fNEvents - 1)) && (fNCaloClustersCumul[iEv] == fNCaloClustersCumul[iEv+1])) {iEv++;}
	203
	204	Int_t irel = i - fNCaloClustersCumul[iEv];
	205	AliVEvent* evt = (AliVEvent*) (fEventList.At(iEv));
	206	return (evt->GetCaloCluster(irel));
	207	}
	208
bbeb9cae	209	const AliVVertex* AliMixedEvent::GetEventVertex(Int_t i) const
bbeb9cae	210	{
c8fe2783	211	// Return vertex of track # i
bbeb9cae	212	Int_t iEv = TMath::BinarySearch(fNEvents, fNTracksCumul, i);
	213	while((iEv < (fNEvents - 1)) && (fNTracksCumul[iEv] == fNTracksCumul[iEv+1])) {iEv++;}
	214	AliVEvent* evt = (AliVEvent*) (fEventList.At(iEv));
	215	return (evt->GetPrimaryVertex());
	216	}
7eb061fb	217
c8fe2783	218	const AliVVertex* AliMixedEvent::GetVertexOfEvent(Int_t i) const
	219	{
	220	// Return vertex of event # i
	221	if (i > fNEvents)
	222	AliFatal(Form("%d events in buffer, event %d requested", fNEvents, i)) ;
	223	AliVEvent* evt = (AliVEvent*) (fEventList.At(i));
	224	return (evt->GetPrimaryVertex());
	225	}
	226
7eb061fb	227	void AliMixedEvent::Reset()
	228	{
	229	// Reset the event
c8fe2783	230	fEventList.Clear();
	231	fNEvents = 0;
	232	fNumberOfTracks = 0;
	233	fNumberOfCaloClusters = 0;
	234	fNumberOfPHOSCells = 0;
	235	fNumberOfEMCALCells = 0;
	236	if (fNTracksCumul) {
	237	delete[] fNTracksCumul;
	238	fNTracksCumul = 0;
	239	}
	240	if (fNCaloClustersCumul) {
	241	delete[] fNCaloClustersCumul;
	242	fNCaloClustersCumul = 0;
	243	}
	244	if (fNPHOSCellsCumul) {
	245	delete[] fNPHOSCellsCumul;
	246	fNPHOSCellsCumul = 0;
	247	}
	248	if (fNEMCALCellsCumul) {
	249	delete[] fNEMCALCellsCumul;
	250	fNEMCALCellsCumul = 0;
	251	}
ecff8f07	252
	253	if (fPHOSCells) {
	254	fPHOSCells->DeleteContainer();
	255	}
	256	if (fEMCALCells) {
	257	fEMCALCells->DeleteContainer();
	258	}
	259
7eb061fb	260	}
7eb061fb	261
c8fe2783	262	Int_t AliMixedEvent::EventIndex(Int_t itrack) const
7eb061fb	263	{
	264	// Return the event index for track #itrack
	265	return TMath::BinarySearch(fNEvents, fNTracksCumul, itrack);
	266	}
bbeb9cae	267
c8fe2783	268	Int_t AliMixedEvent::EventIndexForCaloCluster(Int_t icluster) const
	269	{
	270	// Return the event index for track #itrack
	271	return TMath::BinarySearch(fNEvents, fNCaloClustersCumul, icluster);
	272	}
	273
	274	Int_t AliMixedEvent::EventIndexForPHOSCell(Int_t icell) const
	275	{
	276	// Return the event index for track #itrack
	277	return TMath::BinarySearch(fNEvents, fNPHOSCellsCumul, icell);
	278	}
	279
	280	Int_t AliMixedEvent::EventIndexForEMCALCell(Int_t icell) const
	281	{
	282	// Return the event index for track #itrack
	283	return TMath::BinarySearch(fNEvents, fNEMCALCellsCumul, icell);
	284	}
	285
aa7e002c	286	Bool_t AliMixedEvent::ComputeVtx(const TObjArray vertices, Double_t pos,Double_t sig,Int_t nContributors) {
bbeb9cae	287	//
	288	// Calculate the mean vertex psoitions from events in the buffer
	289
	290	Int_t nentries = vertices->GetEntriesFast();
	291	Double_t sum[3]={0.,0.,0.};
	292	Double_t sumsigma[6]={0.,0.,0.,0.,0.,0.};
b4a900dc	293
bbeb9cae	294
bbeb9cae	295	for(Int_t ivtx = 0; ivtx < nentries; ivtx++){
c79face6	296	AliVVertex vtx=(AliVVertex)vertices->UncheckedAt(ivtx);
bbeb9cae	297	Double_t covariance[6];
c79face6	298	vtx->GetCovarianceMatrix(covariance);
bbeb9cae	299	Double_t vtxPos[3];
bbeb9cae	300	vtx->GetXYZ(vtxPos);
b4a900dc	301	if(TMath::Abs(covariance[0])<1.e-13) {
	302	return kFALSE;
	303	}else{
bbeb9cae	304	sum[0]+=vtxPos[0]*(1./covariance[0]);
bbeb9cae	305	sumsigma[0]+=(1./covariance[0]);
b4a900dc	306	}
	307	if(TMath::Abs(covariance[2])<1.e-13) {
	308	return kFALSE;
	309	}else{
bbeb9cae	310	sum[1]+=vtxPos[1]*(1./covariance[2]);
bbeb9cae	311	sumsigma[2]+=(1./covariance[2]);
b4a900dc	312	}
	313	if(TMath::Abs(covariance[5])<1.e-13) {
	314	return kFALSE;
	315	}else{
bbeb9cae	316	sum[2]+=vtxPos[2]*(1./covariance[5]);
bbeb9cae	317	sumsigma[5]+=(1./covariance[5]);
b4a900dc	318	}
	319	if(TMath::Abs(covariance[1])<1.e-13) {
	320	sumsigma[1]+=0.;
	321	}else{
bbeb9cae	322	sumsigma[1]+=(1./covariance[1]);
b4a900dc	323	}
	324	if(TMath::Abs(covariance[3])<1.e-13) {
	325	sumsigma[3]+=0.;
	326	}else{
bbeb9cae	327	sumsigma[3]+=(1./covariance[3]);
b4a900dc	328	}
	329	if(TMath::Abs(covariance[4])<1.e-13) {
	330	sumsigma[4]+=0.;
	331	}else{
bbeb9cae	332	sumsigma[4]+=(1./covariance[4]);
b4a900dc	333	}
	334
	335	nContributors[0]=nContributors[0]+vtx->GetNContributors();
bbeb9cae	336	}
	337
	338	for(Int_t i=0;i<3;i++){
b4a900dc	339	if(TMath::Abs(sumsigma[i])<1.e-13) continue;
bbeb9cae	340	pos[i]=sum[i]/sumsigma[i];
bbeb9cae	341	}
531cd64c	342	for(Int_t i2=0;i2<3;i2++){
b4a900dc	343	if(TMath::Abs(sumsigma[i2])<1.e-13) {sig[i2]=0.; continue;}
bbeb9cae	344	sig[i2]=1./sumsigma[i2];
bbeb9cae	345	}
b4a900dc	346	return kTRUE;
bbeb9cae	347	}
bbeb9cae	348
a8f9624e	349
	350	Double_t AliMixedEvent::GetMagneticField() const
	351	{
	352	// Return magnetic field of the first event in the list
	353	if (fEventList.GetEntries() == 0) return -999.;
	354
	355	AliVEvent* evt = (AliVEvent*) (fEventList.At(0));
	356	return evt->GetMagneticField();
	357	}