[u/mrichter/AliRoot.git] / STEER / ESD / AliESDTOFCluster.cxx

/**************************************************************************
 * Copyright(c) 1998-1999, 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:  $ */

//_________________________________________________________________________//
//_________________________________________________________________________//

#include "AliESDTOFCluster.h"
#include "TClonesArray.h"
#include "AliESDEvent.h"

ClassImp(AliESDTOFCluster)

//_________________________________________________________________________
AliESDTOFCluster::AliESDTOFCluster(Int_t clID) :
  fID(clID),
  fNTOFhits(0),
  fStatus(0),
  fNmatchableTracks(0)
{
  //
  // default ctor
  //

  for(Int_t i=kMaxHits;i--;)    fHitIndex[i] = -1;
  for(Int_t i=kMaxMatches;i--;) fMatchIndex[i] = -1;
}

//_________________________________________________________________________
AliESDTOFCluster::AliESDTOFCluster(Int_t ,Int_t ,Float_t ,Float_t ,Float_t ,Int_t*,Int_t ,Int_t ,
				   Bool_t ,Float_t ,Float_t ,Float_t ,
				   Int_t ,Float_t ,Float_t ,Float_t ,Float_t ,Double_t*) :
  fID(-1),
  fNTOFhits(0),
  fStatus(1),
  fNmatchableTracks(1)
{
  //
  // Constructor of AliESDTOFCluster object
  //

  // to be replaced with hit creation
  for(Int_t i=kMaxHits;i--;) fHitIndex[i] = -1;
  for(Int_t i=kMaxMatches;i--;) fMatchIndex[i] = -1;
  //
}

//_________________________________________________________________________
AliESDTOFCluster::AliESDTOFCluster(Int_t ,Int_t ,Float_t ,Float_t ,Float_t ,Int_t*,Int_t ,Int_t ,
				   Bool_t ,Float_t ,Float_t ,Float_t ) :
  fID(-1),
  fNTOFhits(0),
  fStatus(1),
  fNmatchableTracks(0)
{
  //
  // Constructor of AliESDTOFCluster object
  //

  // to be replaced with hit creation
  for(Int_t i=kMaxHits;i--;) fHitIndex[i] = -1;
  for(Int_t i=kMaxMatches;i--;) fMatchIndex[i] = -1;

}

//_________________________________________________________________________
AliESDTOFCluster::AliESDTOFCluster(const AliESDTOFCluster & source) :
  AliVTOFcluster(source),
  fID(source.fID),
  fNTOFhits(source.fNTOFhits),
  fStatus(source.fStatus),
  fNmatchableTracks(source.fNmatchableTracks)
{
  // 
  // copy ctor for AliESDTOFCluster object
  //

  SetEvent(source.GetEvent());

  for(Int_t i=kMaxHits;i--;)    fHitIndex[i] = source.fHitIndex[i];
  for(Int_t i=kMaxMatches;i--;) fMatchIndex[i] = source.fMatchIndex[i];

}

//_________________________________________________________________________
AliESDTOFCluster & AliESDTOFCluster::operator=(const AliESDTOFCluster & source)
{
  // 
  // assignment op-r
  //
  if (this == &source) return *this;
  AliVTOFcluster::operator=(source);
  fID = source.fID;
  fNTOFhits = source.fNTOFhits;
  fStatus = source.fStatus;
  fNmatchableTracks = source.fNmatchableTracks;

  for(Int_t i=kMaxHits;i--;)    fHitIndex[i] = source.fHitIndex[i];
  for(Int_t i=kMaxMatches;i--;) fMatchIndex[i] = source.fMatchIndex[i];

  return *this;
}

//_________________________________________________________________________
Int_t AliESDTOFCluster::Update(Int_t trackIndex,Float_t dX,Float_t dY,Float_t dZ,
			       Float_t length,Double_t expTimes[AliPID::kSPECIESC])
{
  // update cluster info by new track
  //  AliInfo(Form("TOF %d %d",fNmatchableTracks,fNTOFhits));

  if(fNmatchableTracks >= kMaxMatches) return 2; // max number reached
  //
  // check if the track is not already stored
  for (Int_t ii=fNmatchableTracks; ii--;) if (trackIndex==GetTrackIndex(ii)) return 1;
  //
  const AliESDEvent *event = (AliESDEvent *) GetEvent();
  TClonesArray *matchAr = event->GetESDTOFMatches();
  int ntr = matchAr->GetEntriesFast();
  new((*matchAr)[ntr]) AliESDTOFMatch(trackIndex,expTimes,dX,dY,dZ,length);
  int nmt = fNmatchableTracks++;
  fMatchIndex[nmt] = ntr;
  //
  return 0;
  //
}

//_________________________________________________________________________
void AliESDTOFCluster::AddESDTOFHitIndex(Int_t hitID)
{
  // register new hit in the cluster
  if(fNTOFhits >= kMaxHits) return;
  int nth = fNTOFhits++;
  fHitIndex[nth] = hitID; // add the hit to the array
}

//_________________________________________________________________________
void AliESDTOFCluster::AddTOFhit(AliESDTOFHit *hit)
{
  // add new hit
  if(fNTOFhits >= kMaxHits) return;
  // add the hit to the array
  const AliESDEvent *event = (AliESDEvent *) GetEvent();
  TClonesArray *hitAr = event->GetESDTOFHits();
  int nh = hitAr->GetEntriesFast();
  new((*hitAr)[nh]) AliESDTOFHit(*hit);
  //   hitN->SetIndex(nh); // RS: why do we need this
  int nth = fNTOFhits++;
  fHitIndex[nth] = nh;
  //
}

//_________________________________________________________________________
void AliESDTOFCluster::AddTOFhit(Int_t ,Int_t ,Float_t ,Float_t ,Float_t ,Int_t*,Int_t ,Int_t , Bool_t ,Float_t ,Float_t ,Float_t )
{
}

//_________________________________________________________________________
Int_t AliESDTOFCluster::GetClusterIndex(int ihit) const
{
  AliESDTOFHit* hit = GetTOFHit(ihit);
  return hit ? hit->GetClusterIndex() : -1;
} 

//_________________________________________________________________________
Int_t AliESDTOFCluster::GetTOFchannel(int ihit) const 
{
  AliESDTOFHit* hit = GetTOFHit(ihit);
  return hit ? hit->GetTOFchannel() : -1;
}

//_________________________________________________________________________
Float_t AliESDTOFCluster::GetTime(int ihit) const 
{
  AliESDTOFHit* hit = GetTOFHit(ihit);
  return hit ? hit->GetTime() : 0;
}

//_________________________________________________________________________
Float_t AliESDTOFCluster::GetTimeRaw(Int_t ihit) const 
{
 AliESDTOFHit* hit = GetTOFHit(ihit);
 return hit ? hit->GetTimeRaw() : 0;
} // TOF raw time

//_________________________________________________________________________
Float_t AliESDTOFCluster::GetTOT(Int_t ihit) const 
{
  AliESDTOFHit* hit = GetTOFHit(ihit);
  return hit ? hit->GetTOT() : 0;
} // TOF tot

//_________________________________________________________________________
Float_t AliESDTOFCluster::GetTOFsignalToT(Int_t ihit) const 
{
  AliESDTOFHit* hit = GetTOFHit(ihit);
  return hit ? hit->GetTOT() : 0; // RS: Why signalTot and TOT are the same?
} // TOF tot

//_________________________________________________________________________
Int_t AliESDTOFCluster::GetLabel(Int_t i,Int_t ihit) const 
{
  AliESDTOFHit* hit = GetTOFHit(ihit);
  if (!hit || i>=3) return -999;
  return hit->GetTOFLabel(i);
}

//_________________________________________________________________________
Int_t AliESDTOFCluster::GetDeltaBC(Int_t ihit) const 
{
  AliESDTOFHit* hit = GetTOFHit(ihit);
  return hit ? hit->GetDeltaBC() : 0;
}

//_________________________________________________________________________
Int_t AliESDTOFCluster::GetL0L1Latency(Int_t ihit) const 
{
  AliESDTOFHit* hit = GetTOFHit(ihit);  
  return hit ? hit->GetL0L1Latency() : 0;
}

//_________________________________________________________________________
Bool_t AliESDTOFCluster::GetStatus() const 
{
  if(!fEvent){
    AliInfo("No AliESDEvent available here!");
    return 0;
  }
  return fStatus;
}

//_________________________________________________________________________
Float_t AliESDTOFCluster::GetZ() const 
{
  AliESDTOFHit* hit = GetTOFHit(0);
  return hit ? hit->GetZ() : 0;
}

//_________________________________________________________________________
Float_t AliESDTOFCluster::GetPhi() const 
{
  AliESDTOFHit* hit = GetTOFHit(0);
  return hit ? hit->GetPhi() : 0;
}

//_________________________________________________________________________
Float_t AliESDTOFCluster::GetR() const 
{
  AliESDTOFHit* hit = GetTOFHit(0);
  return hit ? hit->GetR() : 0;
}

//_________________________________________________________________________
Int_t AliESDTOFCluster::GetNMatchableTracks() const 
{
  return fNmatchableTracks;
}

//_________________________________________________________________________
Int_t AliESDTOFCluster::GetNTOFhits() const 
{
  return fNTOFhits;
}

//_________________________________________________________________________
Int_t AliESDTOFCluster::GetTrackIndex(Int_t i) const 
{
  AliESDTOFMatch* match = 0;
  return (i<fNmatchableTracks && (match=GetTOFMatch(i))) ? match->GetTrackIndex() : -999;
}

//_________________________________________________________________________
Float_t AliESDTOFCluster::GetDistanceInStripPlane(Int_t i) const 
{
  // distance
  AliESDTOFMatch* match = 0;
  if (i>=fNmatchableTracks || !(match=GetTOFMatch(i))) return -999;
  Double_t dz = match->GetDz();
  Double_t dx = match->GetDx();
  return TMath::Sqrt(dx*dx+dz*dz);
}

//_________________________________________________________________________
Float_t AliESDTOFCluster::GetDx(Int_t i)  const 
{
  AliESDTOFMatch* match = 0;  
  return (i<fNmatchableTracks && (match=GetTOFMatch(i))) ? match->GetDx() : -999;
} // distance, X component

//_________________________________________________________________________
Float_t AliESDTOFCluster::GetDy(Int_t i)  const 
{
  AliESDTOFMatch* match = 0;  
  return (i<fNmatchableTracks && (match=GetTOFMatch(i))) ? match->GetDy() : -999;
} // distance, Y component

//_________________________________________________________________________
Float_t AliESDTOFCluster::GetDz(Int_t i)  const 
{
  AliESDTOFMatch* match = 0;  
  return (i<fNmatchableTracks && (match=GetTOFMatch(i))) ? match->GetDz() : -999;
} // distance, Z component

//_________________________________________________________________________
Float_t AliESDTOFCluster::GetLength(Int_t i) const 
{
  AliESDTOFMatch* match = 0;  
  return (i<fNmatchableTracks && (match=GetTOFMatch(i))) ? match->GetTrackLength() : -999.;
} // reconstructed track length at TOF

//_________________________________________________________________________
Double_t AliESDTOFCluster::GetIntegratedTime(Int_t iPart,Int_t i) const 
{
  AliESDTOFMatch* match = 0;  
  return (i<fNmatchableTracks && (match=GetTOFMatch(i))) ? match->GetIntegratedTimes(iPart) : -999.;
} // reconstructed track length at TOF

//_________________________________________________________________________
void AliESDTOFCluster::Print(const Option_t*) const
{
  // print full chain
  printf("#%5d TOF Cluster %5d of %d Hits, %d Matchable Tracks\n",GetESDID(),fID, fNTOFhits, fNmatchableTracks);
  for (int ih=0;ih<fNTOFhits;ih++) {
    AliESDTOFHit* ht = GetTOFHit(ih);
    if (ht) {
      printf("%d: ",ih);
      ht->Print();
    }
  }
  //
  for (int it=0;it<fNmatchableTracks;it++) {
    AliESDTOFMatch* mt = GetTOFMatch(it);
    if (mt) {
      printf("%d: ",it);
      mt->Print();
    }
  }
  //
}

//_________________________________________________________________________
AliESDTOFHit* AliESDTOFCluster::GetTOFHit(Int_t i) const
{
  return fEvent ? ((AliESDTOFHit *) ((AliESDEvent *) GetEvent())->GetESDTOFHits()->At(fHitIndex[i])):0;
}

//_________________________________________________________________________
AliESDTOFMatch* AliESDTOFCluster::GetTOFMatch(Int_t i) const 
{
  return fEvent ? ((AliESDTOFMatch *) ((AliESDEvent *) GetEvent())->GetESDTOFMatches()->At(fMatchIndex[i])) : 0;
}

//_________________________________________________________________________
void AliESDTOFCluster::SuppressMatchedTrack(Int_t id)
{
  // suppress the reference to track id
  for (int it=fNmatchableTracks;it--;) {
    AliESDTOFMatch* mtc = GetTOFMatch(it);
    if (mtc->GetTrackIndex()!=id) continue;
    // need to suprress the match: simply remove reference to it
    int rmID = fMatchIndex[it];
    for (int jt=it+1;jt<fNmatchableTracks;jt++) fMatchIndex[jt-1] = fMatchIndex[jt];
    fNmatchableTracks--;
    // remove match rmID
    TClonesArray* arrMatch = ((AliESDEvent *)GetEvent())->GetESDTOFMatches();
    int last = arrMatch->GetEntriesFast()-1;
    AliESDTOFMatch* mtcL = (AliESDTOFMatch*)arrMatch->At(last);
    if (rmID!=last) {
      *mtc = *mtcL; // assign the last match to removed slot
      int trID = mtc->GetTrackIndex();
      AliESDtrack* trc = ((AliESDEvent *)GetEvent())->GetTrack(trID);
      trc->ReplaceTOFMatchID(last,rmID); // fix the reference to reassigned match
      // fix the 
    }
    arrMatch->RemoveAt(last);
    break;
  }
  //
  if (!fNmatchableTracks) { // no matches left, clear all hits: prepare for selfelimination
    // first remove associated hits
    TClonesArray* arrHits = ((AliESDEvent *)GetEvent())->GetESDTOFHits();
    TClonesArray* arrClus = ((AliESDEvent *)GetEvent())->GetESDTOFClusters();
    int last = arrHits->GetEntriesFast()-1;
    for (;fNTOFhits--;) { // remove hits
      int hID = fHitIndex[int(fNTOFhits)];
      AliESDTOFHit* hit = (AliESDTOFHit*)arrHits->At(hID);
      AliESDTOFHit* hitL = (AliESDTOFHit*)arrHits->At(last);
      if (hID!=last) {
	*hit = *hitL; // assign the last match to removed slot
	// fix reference on hitL in the owner cluster
	int clID = hit->GetESDTOFClusterIndex();
	AliESDTOFCluster* clusL = (AliESDTOFCluster*)arrClus->At(clID);
	clusL->ReplaceHitID(last,hID);
      }
      arrHits->RemoveAt(last--);
    }
  }

}

//_________________________________________________________________________
void AliESDTOFCluster::ReplaceHitID(int oldID, int newID)
{
  // replace the reference to hit from oldID by newID
  for (int it=fNTOFhits;it--;) {
    if (fHitIndex[it]==oldID) {
      fHitIndex[it]=newID;
      return;
    }
  }
}

//_________________________________________________________________________
void AliESDTOFCluster::ReplaceMatchID(int oldID, int newID)
{
  // replace the reference to match from oldID by newID
  for (int it=fNmatchableTracks;it--;) {
    if (fMatchIndex[it]==oldID) {
      fMatchIndex[it]=newID;
      return;
    }
  }
}

//_________________________________________________________________________
void AliESDTOFCluster::ReplaceMatchedTrackID(int oldID, int newID)
{
  // replace the reference to track oldID by newID
  for (int it=fNmatchableTracks;it--;) {
    AliESDTOFMatch* mtc = GetTOFMatch(it);
    if (mtc->GetTrackIndex()!=oldID) continue;
    mtc->SetTrackIndex(newID);
    break;
  }
  //
}

//_________________________________________________________________________
void AliESDTOFCluster::FixSelfReferences(int oldID, int newID)
{
  // replace the references (in tracks and hist) to this cluster from oldID by newID  
  for (int it=fNmatchableTracks;it--;) {
    int trID = GetTOFMatch(it)->GetTrackIndex();
    AliESDtrack* trc = ((AliESDEvent *)GetEvent())->GetTrack(trID);
    trc->ReplaceTOFClusterID(oldID,newID);
  }
  for (int it=fNTOFhits;it--;) {
    AliESDTOFHit* hit = GetTOFHit(it);
    if (hit) hit->SetESDTOFClusterIndex(newID);
  }
  //
}
Commit	Line	Data
2874a2f5	1	/**************************************************************************
	2	* Copyright(c) 1998-1999, 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
	21	#include "AliESDTOFCluster.h"
	22	#include "TClonesArray.h"
	23	#include "AliESDEvent.h"
	24
	25	ClassImp(AliESDTOFCluster)
	26
	27	//_________________________________________________________________________
	28	AliESDTOFCluster::AliESDTOFCluster(Int_t clID) :
	29	fID(clID),
	30	fNTOFhits(0),
	31	fStatus(0),
	32	fNmatchableTracks(0)
	33	{
	34	//
	35	// default ctor
	36	//
	37
	38	for(Int_t i=kMaxHits;i--;) fHitIndex[i] = -1;
	39	for(Int_t i=kMaxMatches;i--;) fMatchIndex[i] = -1;
	40	}
	41
	42	//_________________________________________________________________________
	43	AliESDTOFCluster::AliESDTOFCluster(Int_t ,Int_t ,Float_t ,Float_t ,Float_t ,Int_t*,Int_t ,Int_t ,
	44	Bool_t ,Float_t ,Float_t ,Float_t ,
	45	Int_t ,Float_t ,Float_t ,Float_t ,Float_t ,Double_t*) :
	46	fID(-1),
	47	fNTOFhits(0),
	48	fStatus(1),
	49	fNmatchableTracks(1)
	50	{
	51	//
	52	// Constructor of AliESDTOFCluster object
	53	//
	54
	55	// to be replaced with hit creation
	56	for(Int_t i=kMaxHits;i--;) fHitIndex[i] = -1;
	57	for(Int_t i=kMaxMatches;i--;) fMatchIndex[i] = -1;
	58	//
	59	}
	60
	61	//_________________________________________________________________________
	62	AliESDTOFCluster::AliESDTOFCluster(Int_t ,Int_t ,Float_t ,Float_t ,Float_t ,Int_t*,Int_t ,Int_t ,
	63	Bool_t ,Float_t ,Float_t ,Float_t ) :
	64	fID(-1),
65	fNTOFhits(0),
66	fStatus(1),
67	fNmatchableTracks(0)
68	{
69	//
70	// Constructor of AliESDTOFCluster object
71	//
72
73	// to be replaced with hit creation
74	for(Int_t i=kMaxHits;i--;) fHitIndex[i] = -1;
75	for(Int_t i=kMaxMatches;i--;) fMatchIndex[i] = -1;
76
77	}
78
79	//_________________________________________________________________________
80	AliESDTOFCluster::AliESDTOFCluster(const AliESDTOFCluster & source) :
81	AliVTOFcluster(source),
82	fID(source.fID),
83	fNTOFhits(source.fNTOFhits),
84	fStatus(source.fStatus),
85	fNmatchableTracks(source.fNmatchableTracks)
86	{
87	//
88	// copy ctor for AliESDTOFCluster object
89	//
90
91	SetEvent(source.GetEvent());
92
93	for(Int_t i=kMaxHits;i--;) fHitIndex[i] = source.fHitIndex[i];
94	for(Int_t i=kMaxMatches;i--;) fMatchIndex[i] = source.fMatchIndex[i];
95
96	}
97
98	//_________________________________________________________________________
99	AliESDTOFCluster & AliESDTOFCluster::operator=(const AliESDTOFCluster & source)
100	{
101	//
102	// assignment op-r
103	//
104	if (this == &source) return *this;
105	AliVTOFcluster::operator=(source);
106	fID = source.fID;
107	fNTOFhits = source.fNTOFhits;
108	fStatus = source.fStatus;
109	fNmatchableTracks = source.fNmatchableTracks;
110
111	for(Int_t i=kMaxHits;i--;) fHitIndex[i] = source.fHitIndex[i];
112	for(Int_t i=kMaxMatches;i--;) fMatchIndex[i] = source.fMatchIndex[i];
113
114	return *this;
115	}
116
117	//_________________________________________________________________________
118	Int_t AliESDTOFCluster::Update(Int_t trackIndex,Float_t dX,Float_t dY,Float_t dZ,
119	Float_t length,Double_t expTimes[AliPID::kSPECIESC])
120	{
121	// update cluster info by new track
122	// AliInfo(Form("TOF %d %d",fNmatchableTracks,fNTOFhits));
123
124	if(fNmatchableTracks >= kMaxMatches) return 2; // max number reached
125	//
126	// check if the track is not already stored
127	for (Int_t ii=fNmatchableTracks; ii--;) if (trackIndex==GetTrackIndex(ii)) return 1;
128	//
129	const AliESDEvent event = (AliESDEvent ) GetEvent();
130	TClonesArray *matchAr = event->GetESDTOFMatches();
131	int ntr = matchAr->GetEntriesFast();
132	new((*matchAr)[ntr]) AliESDTOFMatch(trackIndex,expTimes,dX,dY,dZ,length);
a853160f	133	int nmt = fNmatchableTracks++;
a853160f	134	fMatchIndex[nmt] = ntr;
2874a2f5	135	//
	136	return 0;
	137	//
	138	}
	139
	140	//_________________________________________________________________________
	141	void AliESDTOFCluster::AddESDTOFHitIndex(Int_t hitID)
	142	{
	143	// register new hit in the cluster
	144	if(fNTOFhits >= kMaxHits) return;
a853160f	145	int nth = fNTOFhits++;
a853160f	146	fHitIndex[nth] = hitID; // add the hit to the array
2874a2f5	147	}
	148
	149	//_________________________________________________________________________
	150	void AliESDTOFCluster::AddTOFhit(AliESDTOFHit *hit)
	151	{
	152	// add new hit
	153	if(fNTOFhits >= kMaxHits) return;
	154	// add the hit to the array
	155	const AliESDEvent event = (AliESDEvent ) GetEvent();
	156	TClonesArray *hitAr = event->GetESDTOFHits();
	157	int nh = hitAr->GetEntriesFast();
	158	new((hitAr)[nh]) AliESDTOFHit(hit);
	159	// hitN->SetIndex(nh); // RS: why do we need this
a853160f	160	int nth = fNTOFhits++;
a853160f	161	fHitIndex[nth] = nh;
2874a2f5	162	//
	163	}
	164
	165	//_________________________________________________________________________
	166	void AliESDTOFCluster::AddTOFhit(Int_t ,Int_t ,Float_t ,Float_t ,Float_t ,Int_t*,Int_t ,Int_t , Bool_t ,Float_t ,Float_t ,Float_t )
	167	{
	168	}
	169
	170	//_________________________________________________________________________
	171	Int_t AliESDTOFCluster::GetClusterIndex(int ihit) const
	172	{
	173	AliESDTOFHit* hit = GetTOFHit(ihit);
	174	return hit ? hit->GetClusterIndex() : -1;
	175	}
	176
	177	//_________________________________________________________________________
	178	Int_t AliESDTOFCluster::GetTOFchannel(int ihit) const
	179	{
	180	AliESDTOFHit* hit = GetTOFHit(ihit);
	181	return hit ? hit->GetTOFchannel() : -1;
	182	}
	183
	184	//_________________________________________________________________________
	185	Float_t AliESDTOFCluster::GetTime(int ihit) const
	186	{
	187	AliESDTOFHit* hit = GetTOFHit(ihit);
	188	return hit ? hit->GetTime() : 0;
	189	}
	190
	191	//_________________________________________________________________________
	192	Float_t AliESDTOFCluster::GetTimeRaw(Int_t ihit) const
	193	{
	194	AliESDTOFHit* hit = GetTOFHit(ihit);
	195	return hit ? hit->GetTimeRaw() : 0;
	196	} // TOF raw time
	197
	198	//_________________________________________________________________________
	199	Float_t AliESDTOFCluster::GetTOT(Int_t ihit) const
	200	{
	201	AliESDTOFHit* hit = GetTOFHit(ihit);
	202	return hit ? hit->GetTOT() : 0;
	203	} // TOF tot
	204
	205	//_________________________________________________________________________
	206	Float_t AliESDTOFCluster::GetTOFsignalToT(Int_t ihit) const
	207	{
	208	AliESDTOFHit* hit = GetTOFHit(ihit);
	209	return hit ? hit->GetTOT() : 0; // RS: Why signalTot and TOT are the same?
	210	} // TOF tot
	211
	212	//_________________________________________________________________________
	213	Int_t AliESDTOFCluster::GetLabel(Int_t i,Int_t ihit) const
	214	{
	215	AliESDTOFHit* hit = GetTOFHit(ihit);
	216	if (!hit \|\| i>=3) return -999;
	217	return hit->GetTOFLabel(i);
	218	}
	219
	220	//_________________________________________________________________________
	221	Int_t AliESDTOFCluster::GetDeltaBC(Int_t ihit) const
	222	{
	223	AliESDTOFHit* hit = GetTOFHit(ihit);
	224	return hit ? hit->GetDeltaBC() : 0;
	225	}
226
227	//_________________________________________________________________________
228	Int_t AliESDTOFCluster::GetL0L1Latency(Int_t ihit) const
229	{
230	AliESDTOFHit* hit = GetTOFHit(ihit);
231	return hit ? hit->GetL0L1Latency() : 0;
232	}
233
234	//_________________________________________________________________________
235	Bool_t AliESDTOFCluster::GetStatus() const
236	{
237	if(!fEvent){
238	AliInfo("No AliESDEvent available here!");
239	return 0;
240	}
241	return fStatus;
242	}
243
244	//_________________________________________________________________________
245	Float_t AliESDTOFCluster::GetZ() const
246	{
247	AliESDTOFHit* hit = GetTOFHit(0);
248	return hit ? hit->GetZ() : 0;
249	}
250
251	//_________________________________________________________________________
252	Float_t AliESDTOFCluster::GetPhi() const
253	{
254	AliESDTOFHit* hit = GetTOFHit(0);
255	return hit ? hit->GetPhi() : 0;
256	}
257
258	//_________________________________________________________________________
259	Float_t AliESDTOFCluster::GetR() const
260	{
261	AliESDTOFHit* hit = GetTOFHit(0);
262	return hit ? hit->GetR() : 0;
263	}
264
265	//_________________________________________________________________________
266	Int_t AliESDTOFCluster::GetNMatchableTracks() const
267	{
268	return fNmatchableTracks;
269	}
270
271	//_________________________________________________________________________
272	Int_t AliESDTOFCluster::GetNTOFhits() const
273	{
274	return fNTOFhits;
275	}
276
277	//_________________________________________________________________________
278	Int_t AliESDTOFCluster::GetTrackIndex(Int_t i) const
279	{
280	AliESDTOFMatch* match = 0;
281	return (i<fNmatchableTracks && (match=GetTOFMatch(i))) ? match->GetTrackIndex() : -999;
282	}
283
284	//_________________________________________________________________________
285	Float_t AliESDTOFCluster::GetDistanceInStripPlane(Int_t i) const
286	{
287	// distance
288	AliESDTOFMatch* match = 0;
289	if (i>=fNmatchableTracks \|\| !(match=GetTOFMatch(i))) return -999;
290	Double_t dz = match->GetDz();
291	Double_t dx = match->GetDx();
292	return TMath::Sqrt(dxdx+dzdz);
293	}
294
295	//_________________________________________________________________________
296	Float_t AliESDTOFCluster::GetDx(Int_t i) const
297	{
298	AliESDTOFMatch* match = 0;
299	return (i<fNmatchableTracks && (match=GetTOFMatch(i))) ? match->GetDx() : -999;
300	} // distance, X component
301
302	//_________________________________________________________________________
303	Float_t AliESDTOFCluster::GetDy(Int_t i) const
304	{
305	AliESDTOFMatch* match = 0;
306	return (i<fNmatchableTracks && (match=GetTOFMatch(i))) ? match->GetDy() : -999;
307	} // distance, Y component
308
309	//_________________________________________________________________________
310	Float_t AliESDTOFCluster::GetDz(Int_t i) const
311	{
312	AliESDTOFMatch* match = 0;
313	return (i<fNmatchableTracks && (match=GetTOFMatch(i))) ? match->GetDz() : -999;
314	} // distance, Z component
315
316	//_________________________________________________________________________
317	Float_t AliESDTOFCluster::GetLength(Int_t i) const
318	{
319	AliESDTOFMatch* match = 0;
320	return (i<fNmatchableTracks && (match=GetTOFMatch(i))) ? match->GetTrackLength() : -999.;
321	} // reconstructed track length at TOF
322
323	//_________________________________________________________________________
324	Double_t AliESDTOFCluster::GetIntegratedTime(Int_t iPart,Int_t i) const
325	{
326	AliESDTOFMatch* match = 0;
327	return (i<fNmatchableTracks && (match=GetTOFMatch(i))) ? match->GetIntegratedTimes(iPart) : -999.;
328	} // reconstructed track length at TOF
329
330	//_________________________________________________________________________
331	void AliESDTOFCluster::Print(const Option_t*) const
332	{
333	// print full chain
334	printf("#%5d TOF Cluster %5d of %d Hits, %d Matchable Tracks\n",GetESDID(),fID, fNTOFhits, fNmatchableTracks);
335	for (int ih=0;ih<fNTOFhits;ih++) {
336	AliESDTOFHit* ht = GetTOFHit(ih);
337	if (ht) {
338	printf("%d: ",ih);
339	ht->Print();
340	}
341	}
342	//
343	for (int it=0;it<fNmatchableTracks;it++) {
344	AliESDTOFMatch* mt = GetTOFMatch(it);
345	if (mt) {
346	printf("%d: ",it);
347	mt->Print();
348	}
349	}
350	//
351	}
352
353	//_________________________________________________________________________
354	AliESDTOFHit* AliESDTOFCluster::GetTOFHit(Int_t i) const
355	{
356	return fEvent ? ((AliESDTOFHit ) ((AliESDEvent ) GetEvent())->GetESDTOFHits()->At(fHitIndex[i])):0;
357	}
358
359	//_________________________________________________________________________
360	AliESDTOFMatch* AliESDTOFCluster::GetTOFMatch(Int_t i) const
361	{
362	return fEvent ? ((AliESDTOFMatch ) ((AliESDEvent ) GetEvent())->GetESDTOFMatches()->At(fMatchIndex[i])) : 0;
363	}
364
365	//_________________________________________________________________________
366	void AliESDTOFCluster::SuppressMatchedTrack(Int_t id)
367	{
368	// suppress the reference to track id
369	for (int it=fNmatchableTracks;it--;) {
370	AliESDTOFMatch* mtc = GetTOFMatch(it);
371	if (mtc->GetTrackIndex()!=id) continue;
372	// need to suprress the match: simply remove reference to it
373	int rmID = fMatchIndex[it];
374	for (int jt=it+1;jt<fNmatchableTracks;jt++) fMatchIndex[jt-1] = fMatchIndex[jt];
375	fNmatchableTracks--;
376	// remove match rmID
377	TClonesArray* arrMatch = ((AliESDEvent *)GetEvent())->GetESDTOFMatches();
378	int last = arrMatch->GetEntriesFast()-1;
379	AliESDTOFMatch* mtcL = (AliESDTOFMatch*)arrMatch->At(last);
380	if (rmID!=last) {
381	mtc = mtcL; // assign the last match to removed slot
382	int trID = mtc->GetTrackIndex();
383	AliESDtrack* trc = ((AliESDEvent *)GetEvent())->GetTrack(trID);
384	trc->ReplaceTOFMatchID(last,rmID); // fix the reference to reassigned match
385	// fix the
386	}
387	arrMatch->RemoveAt(last);
388	break;
389	}
390	//
391	if (!fNmatchableTracks) { // no matches left, clear all hits: prepare for selfelimination
392	// first remove associated hits
393	TClonesArray* arrHits = ((AliESDEvent *)GetEvent())->GetESDTOFHits();
394	TClonesArray* arrClus = ((AliESDEvent *)GetEvent())->GetESDTOFClusters();
395	int last = arrHits->GetEntriesFast()-1;
396	for (;fNTOFhits--;) { // remove hits
a853160f	397	int hID = fHitIndex[int(fNTOFhits)];
2874a2f5	398	AliESDTOFHit* hit = (AliESDTOFHit*)arrHits->At(hID);
	399	AliESDTOFHit* hitL = (AliESDTOFHit*)arrHits->At(last);
	400	if (hID!=last) {
	401	hit = hitL; // assign the last match to removed slot
	402	// fix reference on hitL in the owner cluster
	403	int clID = hit->GetESDTOFClusterIndex();
	404	AliESDTOFCluster* clusL = (AliESDTOFCluster*)arrClus->At(clID);
	405	clusL->ReplaceHitID(last,hID);
	406	}
	407	arrHits->RemoveAt(last--);
	408	}
	409	}
	410
	411	}
	412
	413	//_________________________________________________________________________
	414	void AliESDTOFCluster::ReplaceHitID(int oldID, int newID)
	415	{
	416	// replace the reference to hit from oldID by newID
	417	for (int it=fNTOFhits;it--;) {
	418	if (fHitIndex[it]==oldID) {
	419	fHitIndex[it]=newID;
	420	return;
	421	}
	422	}
	423	}
	424
	425	//_________________________________________________________________________
	426	void AliESDTOFCluster::ReplaceMatchID(int oldID, int newID)
	427	{
	428	// replace the reference to match from oldID by newID
	429	for (int it=fNmatchableTracks;it--;) {
	430	if (fMatchIndex[it]==oldID) {
	431	fMatchIndex[it]=newID;
	432	return;
	433	}
	434	}
	435	}
	436
	437	//_________________________________________________________________________
	438	void AliESDTOFCluster::ReplaceMatchedTrackID(int oldID, int newID)
	439	{
	440	// replace the reference to track oldID by newID
	441	for (int it=fNmatchableTracks;it--;) {
	442	AliESDTOFMatch* mtc = GetTOFMatch(it);
	443	if (mtc->GetTrackIndex()!=oldID) continue;
	444	mtc->SetTrackIndex(newID);
	445	break;
	446	}
	447	//
	448	}
	449
	450	//_________________________________________________________________________
	451	void AliESDTOFCluster::FixSelfReferences(int oldID, int newID)
	452	{
	453	// replace the references (in tracks and hist) to this cluster from oldID by newID
	454	for (int it=fNmatchableTracks;it--;) {
	455	int trID = GetTOFMatch(it)->GetTrackIndex();
	456	AliESDtrack* trc = ((AliESDEvent *)GetEvent())->GetTrack(trID);
	457	trc->ReplaceTOFClusterID(oldID,newID);
	458	}
	459	for (int it=fNTOFhits;it--;) {
	460	AliESDTOFHit* hit = GetTOFHit(it);
683f60ae	461	if (hit) hit->SetESDTOFClusterIndex(newID);
2874a2f5	462	}
	463	//
	464	}