X-Git-Url: http://git.uio.no/git/?a=blobdiff_plain;f=STEER%2FAliESD.cxx;h=5b82cb2c8263cc6d9f334cd2a740ae78e24d1e72;hb=383a295ac7dc9752055fe92388ad6e102a41dc69;hp=2d4cb0e58f05236c45edca82318a4376f7ec34a0;hpb=c028b974d1b31bf2058cd020d5827f6abf6317c5;p=u%2Fmrichter%2FAliRoot.git

diff --git a/STEER/AliESD.cxx b/STEER/AliESD.cxx
index 2d4cb0e58f0..5b82cb2c826 100644
--- a/STEER/AliESD.cxx
+++ b/STEER/AliESD.cxx
@@ -29,8 +29,13 @@ ClassImp(AliESD)
 
 //______________________________________________________________________________
 AliESD::AliESD():
-  fEventNumber(0),
+  fEventNumberInFile(0),
+  fBunchCrossNumber(0),
+  fOrbitNumber(0),
+  fPeriodNumber(0),
   fRunNumber(0),
+  fTimeStamp(0),
+  fEventType(0),
   fTriggerMask(0),
   fTriggerCluster(0),
   fRecoVersion(0),
@@ -46,6 +51,7 @@ AliESD::AliESD():
   fPrimaryVertex(),
   fSPDMult(),
   fT0timeStart(0),
+  fT0clock(0),
   fTracks("AliESDtrack",15000),
   fHLTConfMapTracks("AliESDHLTtrack",25000),
   fHLTHoughTracks("AliESDHLTtrack",15000),
@@ -55,24 +61,42 @@ AliESD::AliESD():
   fV0s("AliESDv0",200),  
   fCascades("AliESDcascade",20),
   fKinks("AliESDkink",4000),
-  fV0MIs("AliESDV0MI",4000),
   fCaloClusters("AliESDCaloCluster",10000),
   fEMCALClusters(0), 
   fFirstEMCALCluster(-1),
+  fEMCALTriggerPosition(0x0),
+  fEMCALTriggerAmplitudes(0x0),
   fPHOSClusters(0), 
   fFirstPHOSCluster(-1),
-  fESDFMD(0x0)
+  fPHOSTriggerPosition(0x0),
+  fPHOSTriggerAmplitudes(0x0),
+  fESDFMD(0x0),
+  fESDVZERO(0x0),
+  fESDACORDE(0x0),
+  fErrorLogs("AliRawDataErrorLog",5)
 {
+  // 
+  // Standar constructor
+  //
+
   for (Int_t i=0; i<24; i++) {
     fT0time[i] = 0;
     fT0amplitude[i] = 0;
   }
+  for (Int_t i=0; i<2; i++) fDiamondXY[i]=0.;
+  for (Int_t i=0; i<3; i++) fDiamondCovXY[i]=0.;
 }
+
 //______________________________________________________________________________
 AliESD::AliESD(const AliESD& esd):
   TObject(esd),
-  fEventNumber(esd.fEventNumber),
+  fEventNumberInFile(esd.fEventNumberInFile),
+  fBunchCrossNumber(esd.fBunchCrossNumber),
+  fOrbitNumber(esd.fOrbitNumber),
+  fPeriodNumber(esd.fPeriodNumber),
   fRunNumber(esd.fRunNumber),
+  fTimeStamp(esd.fTimeStamp),
+  fEventType(esd.fEventType),
   fTriggerMask(esd.fTriggerMask),
   fTriggerCluster(esd.fTriggerCluster),
   fRecoVersion(esd.fRecoVersion),
@@ -86,7 +110,9 @@ AliESD::AliESD(const AliESD& esd):
   fT0zVertex(esd.fT0zVertex),
   fSPDVertex(esd.fSPDVertex),
   fPrimaryVertex(esd.fPrimaryVertex),
+  fSPDMult(esd.fSPDMult),
   fT0timeStart(esd.fT0timeStart),
+  fT0clock(esd.fT0clock),
   fTracks(*((TClonesArray*)esd.fTracks.Clone())),
   fHLTConfMapTracks(*((TClonesArray*)esd.fHLTConfMapTracks.Clone())),
   fHLTHoughTracks(*((TClonesArray*)esd.fHLTHoughTracks.Clone())),
@@ -96,21 +122,31 @@ AliESD::AliESD(const AliESD& esd):
   fV0s(*((TClonesArray*)esd.fV0s.Clone())),  
   fCascades(*((TClonesArray*)esd.fCascades.Clone())),
   fKinks(*((TClonesArray*)esd.fKinks.Clone())),
-  fV0MIs(*((TClonesArray*)esd.fV0MIs.Clone())),
   fCaloClusters(*((TClonesArray*)esd.fCaloClusters.Clone())),
   fEMCALClusters(esd.fEMCALClusters), 
   fFirstEMCALCluster(esd.fFirstEMCALCluster),
+  fEMCALTriggerPosition(esd. fEMCALTriggerPosition),
+  fEMCALTriggerAmplitudes(esd.fEMCALTriggerAmplitudes),
   fPHOSClusters(esd.fPHOSClusters), 
   fFirstPHOSCluster(esd.fFirstPHOSCluster),
-  fESDFMD(esd.fESDFMD)
+  fPHOSTriggerPosition(esd.fPHOSTriggerPosition),
+  fPHOSTriggerAmplitudes(esd.fPHOSTriggerAmplitudes),
+  fESDFMD(esd.fESDFMD),
+  fESDVZERO(esd.fESDVZERO),
+  fESDACORDE(esd.fESDACORDE),
+  fErrorLogs(*((TClonesArray*)esd.fErrorLogs.Clone()))
 {
+  // 
+  // copy constructor
+  //
   for (Int_t i=0; i<24; i++) {
     fT0time[i] = esd.fT0time[i];
     fT0amplitude[i] = esd.fT0amplitude[i];
   }
+  for (Int_t i=0; i<2; i++) fDiamondXY[i]=esd.fDiamondXY[i];
+  for (Int_t i=0; i<3; i++) fDiamondCovXY[i]=esd.fDiamondCovXY[i];
 }
 
-
 //______________________________________________________________________________
 AliESD::~AliESD()
 {
@@ -126,36 +162,33 @@ AliESD::~AliESD()
   fV0s.Delete();
   fCascades.Delete();
   fKinks.Delete();
-  fV0MIs.Delete();
   fCaloClusters.Delete();
   delete fESDFMD;
-}
+  delete fESDVZERO;
+  delete fEMCALTriggerPosition;
+  delete fEMCALTriggerAmplitudes;
+  delete fPHOSTriggerPosition;
+  delete fPHOSTriggerAmplitudes;
+  delete fESDACORDE;
+
+  fErrorLogs.Delete();
 
-void AliESD::UpdateV0PIDs()
-{
-  //
-  //
-  //
-  Int_t nV0 = GetNumberOfV0MIs();
-  for (Int_t i=0;i<nV0;i++){
-    AliESDV0MI * v0 = GetV0MI(i);
-    AliESDtrack* tp = GetTrack(v0->GetIndex(0));
-    AliESDtrack* tm = GetTrack(v0->GetIndex(1));
-    if (!tm || !tp){
-      printf("BBBUUUUUUUGGGG\n");
-    }
-    Double_t pp[5],pm[5];
-    tp->GetESDpid(pp);
-    tm->GetESDpid(pm);
-    v0->UpdatePID(pp,pm);    
-  }
 }
 
 //______________________________________________________________________________
 void AliESD::Reset()
 {
-  fEventNumber=0;
+  // 
+  // Reset the contents and delete the entries in TClonesArrays
+  //
+
+  fEventNumberInFile=0;
+  fBunchCrossNumber=0;
+  fOrbitNumber=0;
+  fPeriodNumber=0;
   fRunNumber=0;
+  fTimeStamp = 0;
+  fEventType = 0;
   fTriggerMask=0;
   fTriggerCluster=0;
   fRecoVersion=0;
@@ -167,26 +200,339 @@ void AliESD::Reset()
   fZDCEMEnergy=0;
   fZDCParticipants=0;
   fT0zVertex=0;
+  
+  for (Int_t i=0; i<2; i++) fDiamondXY[i]=0.;
+  for (Int_t i=0; i<3; i++) fDiamondCovXY[i]=0.;
+
+  for (Int_t i=0; i<24; i++) {
+    fT0time[i] = 0;
+    fT0amplitude[i] = 0;
+  }
   fT0timeStart = 0;
+  fT0clock = 0;
+//
+  fSPDMult.~AliMultiplicity();
+  new (&fSPDMult) AliMultiplicity();
+  fSPDVertex.~AliESDVertex();
   new (&fSPDVertex) AliESDVertex();
+  fPrimaryVertex.~AliESDVertex();
   new (&fPrimaryVertex) AliESDVertex();
-  new (&fSPDMult) AliMultiplicity();
-  fTracks.Clear();
-  fHLTConfMapTracks.Clear();
-  fHLTHoughTracks.Clear();
-  fMuonTracks.Clear();
-  fPmdTracks.Clear();
-  fTrdTracks.Clear();
-  fV0s.Clear();
-  fCascades.Clear();
-  fCaloClusters.Clear();
+//
+  fTracks.Delete();
+  fHLTConfMapTracks.Delete();
+  fHLTHoughTracks.Delete();
+  fMuonTracks.Delete();
+  fPmdTracks.Delete();
+  fTrdTracks.Delete();
+  fV0s.Delete();
+  fCascades.Delete();
+  fKinks.Delete();
+  fCaloClusters.Delete();
+//
   fEMCALClusters=0; 
   fFirstEMCALCluster=-1; 
   fPHOSClusters=0; 
   fFirstPHOSCluster=-1; 
+//
+  if (fEMCALTriggerPosition)   fEMCALTriggerPosition  ->Reset();
+  if (fEMCALTriggerAmplitudes) fEMCALTriggerAmplitudes->Reset();
+  if (fPHOSTriggerPosition)    fPHOSTriggerPosition   ->Reset();
+  if (fPHOSTriggerAmplitudes)  fPHOSTriggerAmplitudes ->Reset();
+//
   if (fESDFMD) fESDFMD->Clear();
+//
+  if (fESDVZERO){
+      fESDVZERO->~AliESDVZERO();
+      new (fESDVZERO) AliESDVZERO();
+  } 
+//
+  if (fESDACORDE){
+      fESDACORDE->~AliESDACORDE();
+      new (fESDACORDE) AliESDACORDE();	
+  }
+//
+  fErrorLogs.Delete();
+}
+
+
+Bool_t  AliESD::RemoveKink(Int_t rm) {
+  // ---------------------------------------------------------
+  // Remove a kink candidate and references to it from ESD,
+  // if this candidate does not come from a reconstructed decay
+  // Not yet implemented...
+  // ---------------------------------------------------------
+  Int_t last=GetNumberOfKinks()-1;
+  if ((rm<0)||(rm>last)) return kFALSE;
+
+  return kTRUE;
 }
 
+Bool_t  AliESD::RemoveV0(Int_t rm) {
+  // ---------------------------------------------------------
+  // Remove a V0 candidate and references to it from ESD,
+  // if this candidate does not come from a reconstructed decay
+  // ---------------------------------------------------------
+  Int_t last=GetNumberOfV0s()-1;
+  if ((rm<0)||(rm>last)) return kFALSE;
+
+  AliESDv0 *v0=GetV0(rm);
+  Int_t idxP=v0->GetPindex(), idxN=v0->GetNindex();
+
+  v0=GetV0(last);
+  Int_t lastIdxP=v0->GetPindex(), lastIdxN=v0->GetNindex();
+
+  Int_t used=0;
+
+  // Check if this V0 comes from a reconstructed decay
+  Int_t ncs=GetNumberOfCascades();
+  for (Int_t n=0; n<ncs; n++) {
+    AliESDcascade *cs=GetCascade(n);
+
+    Int_t csIdxP=cs->GetPindex();
+    Int_t csIdxN=cs->GetNindex();
+
+    if (idxP==csIdxP)
+       if (idxN==csIdxN) return kFALSE;
+
+    if (csIdxP==lastIdxP)
+       if (csIdxN==lastIdxN) used++;
+  }
+
+  //Replace the removed V0 with the last V0 
+  TClonesArray &a=fV0s;
+  delete a.RemoveAt(rm);
+
+  if (rm==last) return kTRUE;
+
+  //v0 is pointing to the last V0 candidate... 
+  new (a[rm]) AliESDv0(*v0);
+  delete a.RemoveAt(last);
+
+  if (!used) return kTRUE;
+  
+
+  // Remap the indices of the daughters of reconstructed decays
+  for (Int_t n=0; n<ncs; n++) {
+    AliESDcascade *cs=GetCascade(n);
+
+
+    Int_t csIdxP=cs->GetPindex();
+    Int_t csIdxN=cs->GetNindex();
+
+    if (csIdxP==lastIdxP)
+      if (csIdxN==lastIdxN) {
+         cs->AliESDv0::SetIndex(1,idxP);
+         cs->AliESDv0::SetIndex(0,idxN);
+         used--;
+         if (!used) return kTRUE;
+      }
+  }
+
+  return kTRUE;
+}
+
+Bool_t  AliESD::RemoveTrack(Int_t rm) {
+  // ---------------------------------------------------------
+  // Remove a track and references to it from ESD,
+  // if this track does not come from a reconstructed decay
+  // ---------------------------------------------------------
+  Int_t last=GetNumberOfTracks()-1;
+  if ((rm<0)||(rm>last)) return kFALSE;
+
+  Int_t used=0;
+
+  // Check if this track comes from the reconstructed primary vertex
+  if (fPrimaryVertex.GetStatus()) {
+     UShort_t *primIdx=fPrimaryVertex.GetIndices();
+     Int_t n=fPrimaryVertex.GetNIndices();
+     while (n--) {
+       Int_t idx=Int_t(primIdx[n]);
+       if (rm==idx) return kFALSE;
+       if (idx==last) used++; 
+     }
+  }
+  
+  // Check if this track comes from a reconstructed decay
+  Int_t nv0=GetNumberOfV0s();
+  for (Int_t n=0; n<nv0; n++) {
+    AliESDv0 *v0=GetV0(n);
+
+    Int_t idx=v0->GetNindex();
+    if (rm==idx) return kFALSE;
+    if (idx==last) used++;
+
+    idx=v0->GetPindex();
+    if (rm==idx) return kFALSE;
+    if (idx==last) used++;
+  }
+
+  Int_t ncs=GetNumberOfCascades();
+  for (Int_t n=0; n<ncs; n++) {
+    AliESDcascade *cs=GetCascade(n);
+
+    Int_t idx=cs->GetIndex();
+    if (rm==idx) return kFALSE;
+    if (idx==last) used++;
+  }
+
+  Int_t nkn=GetNumberOfKinks();
+  for (Int_t n=0; n<nkn; n++) {
+    AliESDkink *kn=GetKink(n);
+
+    Int_t idx=kn->GetIndex(0);
+    if (rm==idx) return kFALSE;
+    if (idx==last) used++;
+
+    idx=kn->GetIndex(1);
+    if (rm==idx) return kFALSE;
+    if (idx==last) used++;
+  }
+
+
+  //Replace the removed track with the last track 
+  TClonesArray &a=fTracks;
+  delete a.RemoveAt(rm);
+
+  if (rm==last) return kTRUE;
+
+  AliESDtrack *t=GetTrack(last);
+  t->SetID(rm);
+  new (a[rm]) AliESDtrack(*t);
+  delete a.RemoveAt(last);
+
+
+  if (!used) return kTRUE;
+  
+
+  // Remap the indices of the tracks used for the primary vertex reconstruction
+  if (fPrimaryVertex.GetStatus()) {
+     UShort_t *primIdx=fPrimaryVertex.GetIndices();
+     Int_t n=fPrimaryVertex.GetNIndices();
+     while (n--) {
+       Int_t idx=Int_t(primIdx[n]);
+       if (idx==last) {
+          primIdx[n]=Short_t(rm); 
+          used--;
+          if (!used) return kTRUE;
+       }
+     }
+  }
+  
+  // Remap the indices of the daughters of reconstructed decays
+  for (Int_t n=0; n<nv0; n++) {
+    AliESDv0 *v0=GetV0(n);
+    if (v0->GetIndex(0)==last) {
+       v0->SetIndex(0,rm);
+       used--;
+       if (!used) return kTRUE;
+    }
+    if (v0->GetIndex(1)==last) {
+       v0->SetIndex(1,rm);
+       used--;
+       if (!used) return kTRUE;
+    }
+  }
+
+  for (Int_t n=0; n<ncs; n++) {
+    AliESDcascade *cs=GetCascade(n);
+    if (cs->GetIndex()==last) {
+       cs->SetIndex(rm);
+       used--;
+       if (!used) return kTRUE;
+    }
+  }
+
+  for (Int_t n=0; n<nkn; n++) {
+    AliESDkink *kn=GetKink(n);
+    if (kn->GetIndex(0)==last) {
+       kn->SetIndex(rm,0);
+       used--;
+       if (!used) return kTRUE;
+    }
+    if (kn->GetIndex(1)==last) {
+       kn->SetIndex(rm,1);
+       used--;
+       if (!used) return kTRUE;
+    }
+  }
+
+  return kTRUE;
+}
+
+
+Bool_t AliESD::Clean(Float_t *cleanPars) {
+  //
+  // Remove the data which are not needed for the physics analysis.
+  //
+  // 1) Cleaning the V0 candidates
+  //    ---------------------------
+  //    If the cosine of the V0 pointing angle "csp" and 
+  //    the DCA between the daughter tracks "dca" does not satisfy 
+  //    the conditions 
+  //
+  //     csp > cleanPars[1] + dca/cleanPars[0]*(1.- cleanPars[1])
+  //
+  //    an attempt to remove this V0 candidate from ESD is made.
+  //
+  //    The V0 candidate gets removed if it does not belong to any 
+  //    recosntructed cascade decay
+  //
+  //    12.11.2007, optimal values: cleanPars[0]=0.5, cleanPars[1]=0.999
+  //
+  // 2) Cleaning the tracks
+  //    ----------------------
+  //    If track's transverse parameter is larger than cleanPars[2]
+  //                       OR
+  //    track's longitudinal parameter is larger than cleanPars[3]
+  //    an attempt to remove this track from ESD is made.
+  //
+  //    The track gets removed if it does not come 
+  //    from a reconstructed decay
+  //
+  Bool_t rc=kFALSE;
+
+  Float_t dcaMax=cleanPars[0];
+  Float_t cspMin=cleanPars[1];
+
+  Int_t nV0s=GetNumberOfV0s();
+  for (Int_t i=nV0s-1; i>=0; i--) {
+    AliESDv0 *v0=GetV0(i);
+
+    Float_t dca=v0->GetDcaV0Daughters();
+    Float_t csp=v0->GetV0CosineOfPointingAngle();
+    Float_t cspcut=cspMin + dca/dcaMax*(1.-cspMin);
+    if (csp > cspcut) continue;
+
+    if (RemoveV0(i)) rc=kTRUE;
+  }
+
+
+  Float_t dmax=cleanPars[2], zmax=cleanPars[3];
+
+  const AliESDVertex *vertex=GetVertex();
+  Bool_t vtxOK=vertex->GetStatus();
+  
+  Int_t nTracks=GetNumberOfTracks();
+  for (Int_t i=nTracks-1; i>=0; i--) {
+    AliESDtrack *track=GetTrack(i);
+    Float_t xy,z; track->GetImpactParameters(xy,z);
+    if ((TMath::Abs(xy) > dmax) || (vtxOK && (TMath::Abs(z) > zmax))) {
+      if (RemoveTrack(i)) rc=kTRUE;
+    }
+  }
+
+  return rc;
+}
+
+Int_t AliESD::AddV0(const AliESDv0 *v) {
+  //
+  // Add V0
+  //
+    Int_t idx=fV0s.GetEntriesFast();
+    new(fV0s[idx]) AliESDv0(*v);
+    return idx;
+}  
+
 //______________________________________________________________________________
 void AliESD::Print(Option_t *) const 
 {
@@ -194,8 +540,11 @@ void AliESD::Print(Option_t *) const
   // Print header information of the event
   //
   printf("ESD run information\n");
-  printf("Event # %d Run # %d Trigger %lld Magnetic field %f \n",
-	 GetEventNumber(),
+  printf("Event # in file %d Bunch crossing # %d Orbit # %d Period # %d Run # %d Trigger %lld Magnetic field %f \n",
+	 GetEventNumberInFile(),
+	 GetBunchCrossNumber(),
+	 GetOrbitNumber(),
+	 GetPeriodNumber(),
 	 GetRunNumber(),
 	 GetTriggerMask(),
 	 GetMagneticField() );
@@ -203,6 +552,8 @@ void AliESD::Print(Option_t *) const
 	   fPrimaryVertex.GetXv(), fPrimaryVertex.GetXRes(),
 	   fPrimaryVertex.GetYv(), fPrimaryVertex.GetYRes(),
 	   fPrimaryVertex.GetZv(), fPrimaryVertex.GetZRes());
+    printf("Mean vertex in RUN: X=%.4f Y=%.4f cm\n",
+	   GetDiamondX(),GetDiamondY());
     printf("SPD Multiplicity. Number of tracklets %d \n",
            fSPDMult.GetNumberOfTracklets());
   printf("Event from reconstruction version %d \n",fRecoVersion);
@@ -216,11 +567,11 @@ void AliESD::Print(Option_t *) const
   printf("                 v0        %d\n", GetNumberOfV0s());
   printf("                 cascades  %d\n", GetNumberOfCascades());
   printf("                 kinks     %d\n", GetNumberOfKinks());
-  printf("                 V0MIs     %d\n", GetNumberOfV0MIs());
   printf("                 CaloClusters %d\n", GetNumberOfCaloClusters());
   printf("                 phos      %d\n", GetNumberOfPHOSClusters());
   printf("                 emcal     %d\n", GetNumberOfEMCALClusters());
   printf("                 FMD       %s\n", (fESDFMD ? "yes" : "no"));
+  printf("                 VZERO     %s\n", (fESDVZERO ? "yes" : "no"));
 }
 
 void AliESD::SetESDfriend(const AliESDfriend *ev) {
@@ -246,8 +597,25 @@ void AliESD::GetESDfriend(AliESDfriend *ev) const {
   Int_t ntrk=GetNumberOfTracks();
 
   for (Int_t i=0; i<ntrk; i++) {
-    const AliESDtrack *t=GetTrack(i);
+    AliESDtrack *t=GetTrack(i);
     const AliESDfriendTrack *f=t->GetFriendTrack();
     ev->AddTrack(f);
+
+    t->ReleaseESDfriendTrack();// Not to have two copies of "friendTrack"
+
   }
 }
+
+void AliESD::SetDiamond(const AliESDVertex *vertex)
+{
+  //
+  // Set the interaction diamond
+  //  
+    fDiamondXY[0]=vertex->GetXv();
+    fDiamondXY[1]=vertex->GetYv();
+    Double_t cov[6];
+    vertex->GetCovMatrix(cov);
+    fDiamondCovXY[0]=cov[0];
+    fDiamondCovXY[1]=cov[1];
+    fDiamondCovXY[2]=cov[2];
+  }