[u/mrichter/AliRoot.git] / MUON / AliMUONRefitter.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 <cstdlib>
#include "AliMUONRefitter.h"
#include "AliMUONGeometryTransformer.h"
#include "AliMUONClusterFinderCOG.h"
#include "AliMUONClusterFinderMLEM.h"
#include "AliMUONClusterFinderSimpleFit.h"
#include "AliMUONPreClusterFinder.h"
#include "AliMUONPreClusterFinderV2.h"
#include "AliMUONPreClusterFinderV3.h"
#include "AliMUONSimpleClusterServer.h"
#include "AliMUONReconstructor.h"
#include "AliMUONTrackReconstructor.h"
#include "AliMUONTrackReconstructorK.h"
#include "AliMUONRecoParam.h"
#include "AliMUONESDInterface.h"
#include "AliMUONVClusterStore.h"
#include "AliMUONVTrackStore.h"
#include "AliMUONTrack.h"
#include "AliMUONTracker.h"
#include "AliMUONTrackParam.h"
#include "AliLog.h"

//-----------------------------------------------------------------------------
/// \class AliMUONRefitter
///
/// This class has been developped to simplify the re-reconstruction of the MUON tracks
/// stored into ESD with different recoParams and/or after having re-calibrated the digits.
/// It creates new MUON object from ESD objects given as input (through the ESDInterface) then:
///
/// - re-clusterize the ESD clusters using the attached ESD pads
///   (several new clusters can be reconstructed per ESD cluster)
/// - re-fit the ESD tracks using the attached ESD clusters
/// - reconstruct the ESD tracks from ESD pads (i.e. re-clusterized the attached clusters)
///
/// note:
/// - connexion between an ESD cluster and corresponding MUON clusters from re-clustering
///   can be made through the detection element ID
/// - connexion between an ESD track and the corresponding refitted MUON track
///   can be made through their unique ID
///
/// \author Philippe Pillot
//-----------------------------------------------------------------------------

/// \cond CLASSIMP
ClassImp(AliMUONRefitter)
/// \endcond

//_____________________________________________________________________________
AliMUONRefitter::AliMUONRefitter(const AliMUONRecoParam* recoParam)
: TObject(),
  fkRecoParam(recoParam),
  fkESDInterface(0x0),
  fGeometryTransformer(0x0),
  fClusterServer(0x0),
  fTracker(0x0)
{
  /// Default constructor
  CreateGeometryTransformer();
  CreateClusterServer(*fGeometryTransformer);
  if (fClusterServer) fTracker = AliMUONTracker::CreateTrackReconstructor(recoParam,fClusterServer);
  if (!fClusterServer || !fTracker) {
    AliFatal("refitter initialization failed");
    exit(-1);
  }
}

//_____________________________________________________________________________
AliMUONRefitter::~AliMUONRefitter()
{
  /// Destructor
  delete fGeometryTransformer;
  delete fClusterServer;
  delete fTracker;
}

//_____________________________________________________________________________
AliMUONVTrackStore* AliMUONRefitter::ReconstructFromDigits()
{
  /// re-reconstruct all tracks and attached clusters from the digits
  /// it is the responsability of the user to delete the returned store
  
  if (!fkESDInterface) {
    AliError("the refitter must be connected to an ESDInterface containing the ESD event to reconstruct");
    return 0x0;
  }
  
  // prepare new track(s)
  AliMUONVTrackStore* newTrackStore = AliMUONESDInterface::NewTrackStore();
  if (!newTrackStore) return 0x0;
  
  // loop over tracks and refit them (create new tracks)
  AliMUONTrack *track;
  TIter next(fkESDInterface->CreateTrackIterator());
  while ((track = static_cast<AliMUONTrack*>(next()))) {
    AliMUONTrack *newTrack = RetrackFromDigits(*track);
    newTrackStore->Add(newTrack);
    delete newTrack;
  }
  
  return newTrackStore;
}

//_____________________________________________________________________________
AliMUONVTrackStore* AliMUONRefitter::ReconstructFromClusters()
{
  /// refit all tracks from the attached clusters
  /// it is the responsability of the user to delete the returned store
  
  if (!fkESDInterface) {
    AliError("the refitter must be connected to an ESDInterface containing the ESD event to reconstruct");
    return 0x0;
  }
  
  // prepare new track(s)
  AliMUONVTrackStore* newTrackStore = AliMUONESDInterface::NewTrackStore();
  if (!newTrackStore) return 0x0;
  
  // loop over tracks and refit them (create new tracks)
  AliMUONTrack *track;
  TIter next(fkESDInterface->CreateTrackIterator());
  while ((track = static_cast<AliMUONTrack*>(next()))) {
    AliMUONTrack* newTrack = newTrackStore->Add(*track);
    if (!fTracker->RefitTrack(*newTrack)) newTrackStore->Remove(*newTrack);
  }
  
  return newTrackStore;
}

//_____________________________________________________________________________
AliMUONTrack* AliMUONRefitter::RetrackFromDigits(UInt_t trackId)
{
  /// refit track "trackId" from the digits (i.e. re-clusterized the attached clusters)
  /// it is the responsability of the user to delete the returned track
  
  if (!fkESDInterface) {
    AliError("the refitter must be connected to an ESDInterface containing the ESD event to reconstruct");
    return 0x0;
  }
  
  // get the track to refit
  AliMUONTrack* track = fkESDInterface->FindTrack(trackId);
  
  return track ? RetrackFromDigits(*track) : 0x0;
}

//_____________________________________________________________________________
AliMUONTrack* AliMUONRefitter::RetrackFromClusters(UInt_t trackId)
{
  /// refit track "trackId" from the clusters (i.e. do not re-clusterize)
  /// it is the responsability of the user to delete the returned track
  
  if (!fkESDInterface) {
    AliError("the refitter must be connected to an ESDInterface containing the ESD event to reconstruct");
    return 0x0;
  }
  
  // get the track to refit
  AliMUONTrack* track = fkESDInterface->FindTrack(trackId);
  if (!track) return 0x0;
  
  // refit the track (create a new one)
  AliMUONTrack* newTrack = new AliMUONTrack(*track);
  if (!fTracker->RefitTrack(*newTrack)) {
    delete newTrack;
    return 0x0;
  }
  
  return newTrack;
}

//_____________________________________________________________________________
AliMUONVClusterStore* AliMUONRefitter::ReClusterize(UInt_t trackId, UInt_t clusterId)
{
  /// re-clusterize cluster numbered "clusterId" in track "trackId"
  /// several new clusters may be reconstructed
  /// it is the responsability of the user to delete the returned store
  
  if (!fkESDInterface) {
    AliError("the refitter must be connected to an ESDInterface containing the ESD event to reconstruct");
    return 0x0;
  }
  
  // get the cluster to re-clusterize
  AliMUONVCluster* cluster = fkESDInterface->FindCluster(trackId,clusterId);
  if (!cluster) return 0x0;
  
  // check if digits exist
  if (cluster->GetNDigits() == 0) {
    AliError(Form("no digit attached to cluster #%d in track %d",clusterId,trackId));
    return 0x0;
  }
  
  // create the cluster store
  AliMUONVClusterStore* clusterStore = AliMUONESDInterface::NewClusterStore();
  if (!clusterStore) return 0x0;
  
  // re-clusterize
  TIter next(fkESDInterface->CreateDigitIterator(trackId, clusterId));
  fClusterServer->UseDigits(next,fkESDInterface->GetDigits());
  fClusterServer->Clusterize(cluster->GetChamberId(),*clusterStore,AliMpArea(),fkRecoParam);
  
  return clusterStore;
}

//_____________________________________________________________________________
AliMUONVClusterStore* AliMUONRefitter::ReClusterize(UInt_t clusterId)
{
  /// re-clusterize cluster "clusterId"
  /// several new clusters may be reconstructed
  /// it is the responsability of the user to delete the returned store
  
  if (!fkESDInterface) {
    AliError("the refitter must be connected to an ESDInterface containing the ESD event to reconstruct");
    return 0x0;
  }
  
  // get the cluster to re-clusterize
  AliMUONVCluster* cluster = fkESDInterface->FindCluster(clusterId);
  if (!cluster) return 0x0;
  
  // check if digits exist
  if (cluster->GetNDigits() == 0) {
    AliError(Form("no digit attached to cluster %d",clusterId));
    return 0x0;
  }
  
  // create the cluster store
  AliMUONVClusterStore* clusterStore = AliMUONESDInterface::NewClusterStore();
  if (!clusterStore) return 0x0;
  
  // re-clusterize
  TIter next(fkESDInterface->CreateDigitIteratorInCluster(clusterId));
  fClusterServer->UseDigits(next,fkESDInterface->GetDigits());
  fClusterServer->Clusterize(cluster->GetChamberId(),*clusterStore,AliMpArea(),fkRecoParam);
  
  return clusterStore;
}

//_____________________________________________________________________________
void AliMUONRefitter::CreateGeometryTransformer()
{
  /// Create geometry transformer (local<->global)
  /// and load geometry data
  fGeometryTransformer = new AliMUONGeometryTransformer();
  fGeometryTransformer->LoadGeometryData();
}

//_____________________________________________________________________________
void AliMUONRefitter::CreateClusterServer(AliMUONGeometryTransformer& transformer)
{
  /// Create cluster server
  AliMUONVClusterFinder* clusterFinder = AliMUONReconstructor::CreateClusterFinder(fkRecoParam->GetClusteringMode());
  fClusterServer = clusterFinder ? new AliMUONSimpleClusterServer(clusterFinder,transformer) : 0x0;
}

//_____________________________________________________________________________
AliMUONTrack* AliMUONRefitter::RetrackFromDigits(const AliMUONTrack& track)
{
  /// refit the given track from the digits (i.e. re-clusterized the attached clusters):
  /// several new clusters may be reconstructed per initial ESD cluster:
  /// -> all the combinations of clusters are considered to build the new tracks
  /// -> return the best track (largest number of clusters or best chi2 in case of equality)
  
  // check if digits exist
  UInt_t trackId = track.GetUniqueID();
  if (fkESDInterface->GetNDigits(trackId) == 0) {
    AliError(Form("no digit attached to track #%d",trackId));
    return 0x0;
  }
  
  // prepare new track(s)
  AliMUONVTrackStore* newTrackStore = AliMUONESDInterface::NewTrackStore();
  if (!newTrackStore) return 0x0;
  newTrackStore->Add(track)->Clear("C");
  
  // prepare new cluster store
  AliMUONVClusterStore* newClusterStore = AliMUONESDInterface::NewClusterStore();
  if (!newClusterStore) {
    delete newTrackStore;
    return 0x0;
  }
  
  // loop over clusters, re-clusterize and build new tracks
  AliMUONVCluster* cluster;
  TIter nextCluster(fkESDInterface->CreateClusterIterator(trackId));
  while ((cluster = static_cast<AliMUONVCluster*>(nextCluster()))) {
    
    // reset the new cluster store
    newClusterStore->Clear();
    
    // re-clusterize current cluster
    TIter nextDigit(fkESDInterface->CreateDigitIterator(trackId, cluster->GetUniqueID()));
    fClusterServer->UseDigits(nextDigit,fkESDInterface->GetDigits());
    Int_t nNewClusters = fClusterServer->Clusterize(cluster->GetChamberId(),*newClusterStore,AliMpArea(),fkRecoParam);
    
    // check that re-clusterizing succeeded
    if (nNewClusters == 0) {
      AliWarning(Form("refit gave no cluster (chamber %d)",cluster->GetChamberId()));
      AliInfo("initial ESD cluster:");
      cluster->Print("FULL");
      continue;
    }
    
    // add the new cluster(s) to the tracks
    AddClusterToTracks(*newClusterStore, *newTrackStore);
    
  }
  
  // refit the tracks and pick up the best one
  AliMUONTrack *currentTrack, *bestTrack = 0x0;
  Double_t currentChi2, bestChi2 = 1.e10;
  Int_t currentNCluster, bestNClusters = 0;
  TIter next(newTrackStore->CreateIterator());
  while ((currentTrack = static_cast<AliMUONTrack*>(next()))) {
    
    // set the track parameters at first cluster if any (used as seed in original tracking)
    AliMUONTrackParam* param = (AliMUONTrackParam*) currentTrack->GetTrackParamAtCluster()->First();
    if (param) *param = *((AliMUONTrackParam*) track.GetTrackParamAtCluster()->First());
    
    // refit the track
    if (!fTracker->RefitTrack(*currentTrack)) break;
    
    // find best track (the one with the higher number of cluster or the best chi2 in case of equality)
    currentNCluster = currentTrack->GetNClusters();
    currentChi2 = currentTrack->GetGlobalChi2();
    if (currentNCluster > bestNClusters || (currentNCluster == bestNClusters && currentChi2 < bestChi2)) {
      bestTrack = currentTrack;
      bestNClusters = currentNCluster;
      bestChi2 = currentChi2;
    }
    
  }
  
  // copy best track and free memory
  AliMUONTrack* newTrack = bestTrack ? new AliMUONTrack(*bestTrack) : 0x0;
  delete newClusterStore;
  delete newTrackStore;
  
  return newTrack;
}

//_____________________________________________________________________________
void AliMUONRefitter::AddClusterToTracks(const AliMUONVClusterStore &clusterStore, AliMUONVTrackStore &trackStore)
{
  /// add clusters to each of the given tracks
  /// duplicate the tracks if there are several clusters and add one cluster per copy
  
  // create new track store if there are more than 1 cluster to add per track
  Int_t nClusters = clusterStore.GetSize();
  if (nClusters < 1) return;
  
  AliMUONTrackParam dummyParam;
  AliMUONTrack *currentTrack, *track;
  AliMUONVCluster *newCluster;
  Int_t nTracks = trackStore.GetSize();
  Int_t iTrack = 0;
  Int_t iCluster = 0;
  
  // loop over existing tracks to add the cluster(s)
  TIter nextTrack(trackStore.CreateIterator());
  while ((currentTrack = static_cast<AliMUONTrack*>(nextTrack())) && (iTrack < nTracks)) {
    
    iTrack++;
    
    // add the new cluster(s) to the tracks
    // duplicate the tracks if there are several clusters
    // the loop after loading the last cluster which is added to the current track
    iCluster = 0;
    TIter nextCluster(clusterStore.CreateIterator());
    while ((newCluster = static_cast<AliMUONVCluster*>(nextCluster())) && (iCluster < nClusters - 1)) {
      
      iCluster++;
      
      // add a copy of the current track to the store
      track = trackStore.Add(AliMUONTrack(*currentTrack));
      
      // only set Z parameter to avoid error in AddTrackParamAtCluster()
      // the rest will be recomputed during refit
      dummyParam.SetZ(newCluster->GetZ());
      
      // add new cluster to the new track
      track->AddTrackParamAtCluster(dummyParam, *newCluster, kTRUE);
      
    }
    
    // only set Z parameter to avoid error in AddTrackParamAtCluster()
    // the rest will be recomputed during refit
    dummyParam.SetZ(newCluster->GetZ());
    
    // add new cluster to the current track
    currentTrack->AddTrackParamAtCluster(dummyParam, *newCluster, kTRUE);
    
  }
  
}
Commit	Line	Data
7deb8eb0	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
b09247a2	18	#include <cstdlib>
7deb8eb0	19	#include "AliMUONRefitter.h"
	20	#include "AliMUONGeometryTransformer.h"
	21	#include "AliMUONClusterFinderCOG.h"
	22	#include "AliMUONClusterFinderMLEM.h"
	23	#include "AliMUONClusterFinderSimpleFit.h"
	24	#include "AliMUONPreClusterFinder.h"
	25	#include "AliMUONPreClusterFinderV2.h"
	26	#include "AliMUONPreClusterFinderV3.h"
	27	#include "AliMUONSimpleClusterServer.h"
5a240757	28	#include "AliMUONReconstructor.h"
7deb8eb0	29	#include "AliMUONTrackReconstructor.h"
	30	#include "AliMUONTrackReconstructorK.h"
	31	#include "AliMUONRecoParam.h"
	32	#include "AliMUONESDInterface.h"
	33	#include "AliMUONVClusterStore.h"
	34	#include "AliMUONVTrackStore.h"
	35	#include "AliMUONTrack.h"
9bf6860b	36	#include "AliMUONTracker.h"
933daf4c	37	#include "AliMUONTrackParam.h"
7deb8eb0	38	#include "AliLog.h"
	39
	40	//-----------------------------------------------------------------------------
	41	/// \class AliMUONRefitter
	42	///
ad3c6eda	43	/// This class has been developped to simplify the re-reconstruction of the MUON tracks
	44	/// stored into ESD with different recoParams and/or after having re-calibrated the digits.
	45	/// It creates new MUON object from ESD objects given as input (through the ESDInterface) then:
7deb8eb0	46	///
	47	/// - re-clusterize the ESD clusters using the attached ESD pads
	48	/// (several new clusters can be reconstructed per ESD cluster)
	49	/// - re-fit the ESD tracks using the attached ESD clusters
	50	/// - reconstruct the ESD tracks from ESD pads (i.e. re-clusterized the attached clusters)
	51	///
	52	/// note:
	53	/// - connexion between an ESD cluster and corresponding MUON clusters from re-clustering
	54	/// can be made through the detection element ID
	55	/// - connexion between an ESD track and the corresponding refitted MUON track
	56	/// can be made through their unique ID
	57	///
	58	/// \author Philippe Pillot
	59	//-----------------------------------------------------------------------------
	60
	61	/// \cond CLASSIMP
	62	ClassImp(AliMUONRefitter)
	63	/// \endcond
	64
	65	//_____________________________________________________________________________
a0dc65b4	66	AliMUONRefitter::AliMUONRefitter(const AliMUONRecoParam* recoParam)
7deb8eb0	67	: TObject(),
5a240757	68	fkRecoParam(recoParam),
5a240757	69	fkESDInterface(0x0),
7deb8eb0	70	fGeometryTransformer(0x0),
7deb8eb0	71	fClusterServer(0x0),
5a240757	72	fTracker(0x0)
7deb8eb0	73	{
	74	/// Default constructor
	75	CreateGeometryTransformer();
	76	CreateClusterServer(*fGeometryTransformer);
a0dc65b4	77	if (fClusterServer) fTracker = AliMUONTracker::CreateTrackReconstructor(recoParam,fClusterServer);
7deb8eb0	78	if (!fClusterServer \|\| !fTracker) {
	79	AliFatal("refitter initialization failed");
	80	exit(-1);
	81	}
	82	}
	83
	84	//_____________________________________________________________________________
	85	AliMUONRefitter::~AliMUONRefitter()
	86	{
	87	/// Destructor
	88	delete fGeometryTransformer;
	89	delete fClusterServer;
	90	delete fTracker;
	91	}
	92
	93	//_____________________________________________________________________________
	94	AliMUONVTrackStore* AliMUONRefitter::ReconstructFromDigits()
	95	{
	96	/// re-reconstruct all tracks and attached clusters from the digits
	97	/// it is the responsability of the user to delete the returned store
	98
5a240757	99	if (!fkESDInterface) {
7deb8eb0	100	AliError("the refitter must be connected to an ESDInterface containing the ESD event to reconstruct");
	101	return 0x0;
	102	}
	103
	104	// prepare new track(s)
	105	AliMUONVTrackStore* newTrackStore = AliMUONESDInterface::NewTrackStore();
	106	if (!newTrackStore) return 0x0;
	107
	108	// loop over tracks and refit them (create new tracks)
630711ed	109	AliMUONTrack *track;
5a240757	110	TIter next(fkESDInterface->CreateTrackIterator());
630711ed	111	while ((track = static_cast<AliMUONTrack*>(next()))) {
	112	AliMUONTrack newTrack = RetrackFromDigits(track);
	113	newTrackStore->Add(newTrack);
	114	delete newTrack;
7deb8eb0	115	}
	116
	117	return newTrackStore;
	118	}
	119
	120	//_____________________________________________________________________________
	121	AliMUONVTrackStore* AliMUONRefitter::ReconstructFromClusters()
	122	{
	123	/// refit all tracks from the attached clusters
	124	/// it is the responsability of the user to delete the returned store
	125
5a240757	126	if (!fkESDInterface) {
7deb8eb0	127	AliError("the refitter must be connected to an ESDInterface containing the ESD event to reconstruct");
	128	return 0x0;
	129	}
	130
	131	// prepare new track(s)
	132	AliMUONVTrackStore* newTrackStore = AliMUONESDInterface::NewTrackStore();
	133	if (!newTrackStore) return 0x0;
	134
	135	// loop over tracks and refit them (create new tracks)
	136	AliMUONTrack *track;
5a240757	137	TIter next(fkESDInterface->CreateTrackIterator());
7deb8eb0	138	while ((track = static_cast<AliMUONTrack*>(next()))) {
	139	AliMUONTrack* newTrack = newTrackStore->Add(*track);
	140	if (!fTracker->RefitTrack(newTrack)) newTrackStore->Remove(newTrack);
	141	}
	142
	143	return newTrackStore;
	144	}
	145
	146	//_____________________________________________________________________________
630711ed	147	AliMUONTrack* AliMUONRefitter::RetrackFromDigits(UInt_t trackId)
7deb8eb0	148	{
630711ed	149	/// refit track "trackId" from the digits (i.e. re-clusterized the attached clusters)
7deb8eb0	150	/// it is the responsability of the user to delete the returned track
7deb8eb0	151
5a240757	152	if (!fkESDInterface) {
7deb8eb0	153	AliError("the refitter must be connected to an ESDInterface containing the ESD event to reconstruct");
	154	return 0x0;
	155	}
	156
	157	// get the track to refit
5a240757	158	AliMUONTrack* track = fkESDInterface->FindTrack(trackId);
7deb8eb0	159
630711ed	160	return track ? RetrackFromDigits(*track) : 0x0;
7deb8eb0	161	}
	162
	163	//_____________________________________________________________________________
630711ed	164	AliMUONTrack* AliMUONRefitter::RetrackFromClusters(UInt_t trackId)
7deb8eb0	165	{
2e2d0c44	166	/// refit track "trackId" from the clusters (i.e. do not re-clusterize)
7deb8eb0	167	/// it is the responsability of the user to delete the returned track
7deb8eb0	168
5a240757	169	if (!fkESDInterface) {
7deb8eb0	170	AliError("the refitter must be connected to an ESDInterface containing the ESD event to reconstruct");
	171	return 0x0;
	172	}
	173
	174	// get the track to refit
5a240757	175	AliMUONTrack* track = fkESDInterface->FindTrack(trackId);
7deb8eb0	176	if (!track) return 0x0;
	177
	178	// refit the track (create a new one)
	179	AliMUONTrack* newTrack = new AliMUONTrack(*track);
	180	if (!fTracker->RefitTrack(*newTrack)) {
	181	delete newTrack;
	182	return 0x0;
	183	}
	184
	185	return newTrack;
	186	}
	187
	188	//_____________________________________________________________________________
630711ed	189	AliMUONVClusterStore* AliMUONRefitter::ReClusterize(UInt_t trackId, UInt_t clusterId)
7deb8eb0	190	{
630711ed	191	/// re-clusterize cluster numbered "clusterId" in track "trackId"
7deb8eb0	192	/// several new clusters may be reconstructed
	193	/// it is the responsability of the user to delete the returned store
	194
5a240757	195	if (!fkESDInterface) {
7deb8eb0	196	AliError("the refitter must be connected to an ESDInterface containing the ESD event to reconstruct");
	197	return 0x0;
	198	}
	199
	200	// get the cluster to re-clusterize
5a240757	201	AliMUONVCluster* cluster = fkESDInterface->FindCluster(trackId,clusterId);
7deb8eb0	202	if (!cluster) return 0x0;
	203
	204	// check if digits exist
	205	if (cluster->GetNDigits() == 0) {
630711ed	206	AliError(Form("no digit attached to cluster #%d in track %d",clusterId,trackId));
7deb8eb0	207	return 0x0;
	208	}
	209
	210	// create the cluster store
	211	AliMUONVClusterStore* clusterStore = AliMUONESDInterface::NewClusterStore();
	212	if (!clusterStore) return 0x0;
	213
	214	// re-clusterize
5a240757	215	TIter next(fkESDInterface->CreateDigitIterator(trackId, clusterId));
2e2d0c44	216	fClusterServer->UseDigits(next,fkESDInterface->GetDigits());
5a240757	217	fClusterServer->Clusterize(cluster->GetChamberId(),*clusterStore,AliMpArea(),fkRecoParam);
7deb8eb0	218
	219	return clusterStore;
	220	}
	221
	222	//_____________________________________________________________________________
	223	AliMUONVClusterStore* AliMUONRefitter::ReClusterize(UInt_t clusterId)
	224	{
	225	/// re-clusterize cluster "clusterId"
	226	/// several new clusters may be reconstructed
	227	/// it is the responsability of the user to delete the returned store
	228
5a240757	229	if (!fkESDInterface) {
7deb8eb0	230	AliError("the refitter must be connected to an ESDInterface containing the ESD event to reconstruct");
	231	return 0x0;
	232	}
	233
	234	// get the cluster to re-clusterize
5a240757	235	AliMUONVCluster* cluster = fkESDInterface->FindCluster(clusterId);
7deb8eb0	236	if (!cluster) return 0x0;
	237
	238	// check if digits exist
	239	if (cluster->GetNDigits() == 0) {
	240	AliError(Form("no digit attached to cluster %d",clusterId));
	241	return 0x0;
	242	}
	243
	244	// create the cluster store
	245	AliMUONVClusterStore* clusterStore = AliMUONESDInterface::NewClusterStore();
	246	if (!clusterStore) return 0x0;
	247
	248	// re-clusterize
5a240757	249	TIter next(fkESDInterface->CreateDigitIteratorInCluster(clusterId));
2e2d0c44	250	fClusterServer->UseDigits(next,fkESDInterface->GetDigits());
5a240757	251	fClusterServer->Clusterize(cluster->GetChamberId(),*clusterStore,AliMpArea(),fkRecoParam);
7deb8eb0	252
	253	return clusterStore;
	254	}
	255
	256	//_____________________________________________________________________________
	257	void AliMUONRefitter::CreateGeometryTransformer()
	258	{
	259	/// Create geometry transformer (local<->global)
	260	/// and load geometry data
	261	fGeometryTransformer = new AliMUONGeometryTransformer();
	262	fGeometryTransformer->LoadGeometryData();
	263	}
	264
	265	//_____________________________________________________________________________
	266	void AliMUONRefitter::CreateClusterServer(AliMUONGeometryTransformer& transformer)
	267	{
	268	/// Create cluster server
5a240757	269	AliMUONVClusterFinder* clusterFinder = AliMUONReconstructor::CreateClusterFinder(fkRecoParam->GetClusteringMode());
9bf6860b	270	fClusterServer = clusterFinder ? new AliMUONSimpleClusterServer(clusterFinder,transformer) : 0x0;
7deb8eb0	271	}
7deb8eb0	272
630711ed	273	//_____________________________________________________________________________
	274	AliMUONTrack* AliMUONRefitter::RetrackFromDigits(const AliMUONTrack& track)
	275	{
	276	/// refit the given track from the digits (i.e. re-clusterized the attached clusters):
	277	/// several new clusters may be reconstructed per initial ESD cluster:
	278	/// -> all the combinations of clusters are considered to build the new tracks
	279	/// -> return the best track (largest number of clusters or best chi2 in case of equality)
	280
	281	// check if digits exist
	282	UInt_t trackId = track.GetUniqueID();
5a240757	283	if (fkESDInterface->GetNDigits(trackId) == 0) {
630711ed	284	AliError(Form("no digit attached to track #%d",trackId));
	285	return 0x0;
	286	}
	287
	288	// prepare new track(s)
	289	AliMUONVTrackStore* newTrackStore = AliMUONESDInterface::NewTrackStore();
	290	if (!newTrackStore) return 0x0;
	291	newTrackStore->Add(track)->Clear("C");
	292
	293	// prepare new cluster store
	294	AliMUONVClusterStore* newClusterStore = AliMUONESDInterface::NewClusterStore();
	295	if (!newClusterStore) {
	296	delete newTrackStore;
	297	return 0x0;
	298	}
	299
	300	// loop over clusters, re-clusterize and build new tracks
	301	AliMUONVCluster* cluster;
5a240757	302	TIter nextCluster(fkESDInterface->CreateClusterIterator(trackId));
630711ed	303	while ((cluster = static_cast<AliMUONVCluster*>(nextCluster()))) {
	304
	305	// reset the new cluster store
	306	newClusterStore->Clear();
	307
	308	// re-clusterize current cluster
5a240757	309	TIter nextDigit(fkESDInterface->CreateDigitIterator(trackId, cluster->GetUniqueID()));
2e2d0c44	310	fClusterServer->UseDigits(nextDigit,fkESDInterface->GetDigits());
5a240757	311	Int_t nNewClusters = fClusterServer->Clusterize(cluster->GetChamberId(),*newClusterStore,AliMpArea(),fkRecoParam);
630711ed	312
	313	// check that re-clusterizing succeeded
	314	if (nNewClusters == 0) {
	315	AliWarning(Form("refit gave no cluster (chamber %d)",cluster->GetChamberId()));
	316	AliInfo("initial ESD cluster:");
	317	cluster->Print("FULL");
	318	continue;
	319	}
	320
	321	// add the new cluster(s) to the tracks
	322	AddClusterToTracks(newClusterStore, newTrackStore);
	323
	324	}
	325
	326	// refit the tracks and pick up the best one
	327	AliMUONTrack currentTrack, bestTrack = 0x0;
	328	Double_t currentChi2, bestChi2 = 1.e10;
	329	Int_t currentNCluster, bestNClusters = 0;
	330	TIter next(newTrackStore->CreateIterator());
	331	while ((currentTrack = static_cast<AliMUONTrack*>(next()))) {
	332
	333	// set the track parameters at first cluster if any (used as seed in original tracking)
	334	AliMUONTrackParam* param = (AliMUONTrackParam*) currentTrack->GetTrackParamAtCluster()->First();
	335	if (param) param = ((AliMUONTrackParam*) track.GetTrackParamAtCluster()->First());
	336
	337	// refit the track
	338	if (!fTracker->RefitTrack(*currentTrack)) break;
	339
	340	// find best track (the one with the higher number of cluster or the best chi2 in case of equality)
	341	currentNCluster = currentTrack->GetNClusters();
	342	currentChi2 = currentTrack->GetGlobalChi2();
	343	if (currentNCluster > bestNClusters \|\| (currentNCluster == bestNClusters && currentChi2 < bestChi2)) {
	344	bestTrack = currentTrack;
	345	bestNClusters = currentNCluster;
	346	bestChi2 = currentChi2;
	347	}
	348
	349	}
	350
	351	// copy best track and free memory
	352	AliMUONTrack* newTrack = bestTrack ? new AliMUONTrack(*bestTrack) : 0x0;
	353	delete newClusterStore;
	354	delete newTrackStore;
	355
	356	return newTrack;
	357	}
	358
7deb8eb0	359	//_____________________________________________________________________________
	360	void AliMUONRefitter::AddClusterToTracks(const AliMUONVClusterStore &clusterStore, AliMUONVTrackStore &trackStore)
	361	{
	362	/// add clusters to each of the given tracks
	363	/// duplicate the tracks if there are several clusters and add one cluster per copy
	364
	365	// create new track store if there are more than 1 cluster to add per track
	366	Int_t nClusters = clusterStore.GetSize();
	367	if (nClusters < 1) return;
	368
	369	AliMUONTrackParam dummyParam;
	370	AliMUONTrack currentTrack, track;
	371	AliMUONVCluster *newCluster;
	372	Int_t nTracks = trackStore.GetSize();
	373	Int_t iTrack = 0;
	374	Int_t iCluster = 0;
	375
	376	// loop over existing tracks to add the cluster(s)
	377	TIter nextTrack(trackStore.CreateIterator());
	378	while ((currentTrack = static_cast<AliMUONTrack*>(nextTrack())) && (iTrack < nTracks)) {
	379
	380	iTrack++;
	381
	382	// add the new cluster(s) to the tracks
	383	// duplicate the tracks if there are several clusters
	384	// the loop after loading the last cluster which is added to the current track
	385	iCluster = 0;
	386	TIter nextCluster(clusterStore.CreateIterator());
	387	while ((newCluster = static_cast<AliMUONVCluster*>(nextCluster())) && (iCluster < nClusters - 1)) {
	388
	389	iCluster++;
	390
	391	// add a copy of the current track to the store
	392	track = trackStore.Add(AliMUONTrack(*currentTrack));
	393
	394	// only set Z parameter to avoid error in AddTrackParamAtCluster()
	395	// the rest will be recomputed during refit
	396	dummyParam.SetZ(newCluster->GetZ());
	397
	398	// add new cluster to the new track
	399	track->AddTrackParamAtCluster(dummyParam, *newCluster, kTRUE);
	400
	401	}
	402
	403	// only set Z parameter to avoid error in AddTrackParamAtCluster()
	404	// the rest will be recomputed during refit
	405	dummyParam.SetZ(newCluster->GetZ());
	406
	407	// add new cluster to the current track
	408	currentTrack->AddTrackParamAtCluster(dummyParam, *newCluster, kTRUE);
	409
	410	}
	411
	412	}
	413