[u/mrichter/AliRoot.git] / ITS / AliITSClusterFinder.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.                  *
 **************************************************************************/
//
// Base Class used to find
// the reconstructed points for ITS
// See also AliITSClusterFinderSPD, AliITSClusterFinderSDD, 
// AliITSClusterFinderSDD
//

#include "AliITSClusterFinder.h"
#include "AliITSdigitSPD.h"
#include "AliITSdigitSDD.h"
#include "AliITSdigitSSD.h"
#include "AliRun.h"
#include "AliITS.h"

ClassImp(AliITSClusterFinder)

//----------------------------------------------------------------------
AliITSClusterFinder::AliITSClusterFinder(){
    // default cluster finder

    fSegmentation = 0;
    fResponse     = 0;
    fMap          = 0;
    fDigits       = 0;
    fNdigits      = 0;
    fNRawClusters = 0;
    fNperMax      = 0;
    fDeclusterFlag= 0;
    fClusterSize  = 0;
    fNPeaks       = 0;
}
//----------------------------------------------------------------------
AliITSClusterFinder::AliITSClusterFinder(AliITSsegmentation *seg, 
					 AliITSresponse *response, 
					 TClonesArray *digits){
  // cluster finder
    fSegmentation=seg;
    fResponse=response;
    fMap = 0;
    
    fDigits=digits;
    fNdigits = fDigits->GetEntriesFast();

    fNRawClusters=0;

    SetNperMax();
    SetClusterSize();
    SetDeclusterFlag();

    fNPeaks=-1;
}
//----------------------------------------------------------------------
AliITSClusterFinder::~AliITSClusterFinder(){
    // destructor cluster finder

    // Zero local pointers. Other classes own these pointers.
    fSegmentation = 0;
    fResponse     = 0;
    fMap          = 0;
    fDigits       = 0;
    fNdigits      = 0;
    fNRawClusters = 0;
    fNperMax      = 0;
    fDeclusterFlag= 0;
    fClusterSize  = 0;
    fNPeaks       = 0;
}
//__________________________________________________________________________
AliITSClusterFinder::AliITSClusterFinder(const AliITSClusterFinder &source) :
    TObject(source){
    //     Copy Constructor 
    if(&source == this) return;
    this->fDigits = source.fDigits;
    this->fNdigits = source.fNdigits;
    this->fResponse = source.fResponse;
    this->fSegmentation = source.fSegmentation;
    this->fNRawClusters = source.fNRawClusters;
    this->fMap = source.fMap;
    this->fNperMax = source.fNperMax;
    this->fDeclusterFlag = source.fDeclusterFlag;
    this->fClusterSize = source.fClusterSize;
    this->fNPeaks = source.fNPeaks;
    return;
}
//______________________________________________________________________
AliITSClusterFinder& AliITSClusterFinder::operator=(const AliITSClusterFinder &source) {
    //    Assignment operator

    if(&source == this) return *this;
    this->fDigits = source.fDigits;
    this->fNdigits = source.fNdigits;
    this->fResponse = source.fResponse;
    this->fSegmentation = source.fSegmentation;
    this->fNRawClusters = source.fNRawClusters;
    this->fMap = source.fMap;
    this->fNperMax = source.fNperMax;
    this->fDeclusterFlag = source.fDeclusterFlag;
    this->fClusterSize = source.fClusterSize;
    this->fNPeaks = source.fNPeaks;
    return *this;
}
//----------------------------------------------------------------------
void AliITSClusterFinder::AddCluster(Int_t branch, AliITSRawCluster *c){
    // Add a raw cluster copy to the list

    AliITS *iTS=(AliITS*)gAlice->GetModule("ITS");
    iTS->AddCluster(branch,c); 
    fNRawClusters++;
}
//----------------------------------------------------------------------
void AliITSClusterFinder::AddCluster(Int_t branch, AliITSRawCluster *c, 
				     AliITSRecPoint &rp){
    // Add a raw cluster copy to the list

    AliITS *iTS=(AliITS*)gAlice->GetModule("ITS");
    iTS->AddCluster(branch,c); 
    fNRawClusters++;
    iTS->AddRecPoint(rp); 
}
//______________________________________________________________________
void AliITSClusterFinder::FindRawClusters(Int_t module){
    // Default Cluster finder.
    // Input:
    //   Int_t module   Module number for which culster are to be found.
    // Output:
    //   none.
    // Return:
    //   none.
    const Int_t kelms = 10;
    Int_t ndigits = fDigits->GetEntriesFast();
    TObjArray *digs = new TObjArray(ndigits);
    TObjArray *clusts = new TObjArray(ndigits); // max # cluster
    TObjArray *clust0=0; // A spacific cluster of digits
    TObjArray *clust1=0; // A spacific cluster of digits
    AliITSdigit *dig=0; // locat pointer to a digit
    Int_t i=0,nc=0,j[4],k,k2=0;

    // Copy all digits for this module into a local TObjArray.
    for(i=0;i<ndigits;i++) digs->AddAt(new AliITSdigit(*((AliITSdigit*)(fDigits->At(i)))),i);
    digs->Sort();
    // First digit is a cluster.
    i  = 0;
    nc = 0;
    clusts->AddAt(new TObjArray(kelms),nc);
    clust0 = (TObjArray*)(clusts->At(nc));
    clust0->AddAtFree(digs->At(i)); // move owner ship from digs to clusts
    nc++;
    for(i=1;i<ndigits;i++){
	if(IsNeighbor(digs,i,j)){
	    dig = (AliITSdigit*)(digs->At(j[0]));
	    // Add to existing cluster. Find which cluster this digis 
	    for(k=0;k<nc;k++){
		clust0 = ((TObjArray*)(clusts->At(k)));
		if(clust0->IndexOf(dig)>=0) break;
	    } // end for k
	    if(k>=nc){
		Fatal("FindRawClusters","Digit not found as expected");
	    } // end if
	    if(j[1]>=0){
		dig = (AliITSdigit*)(digs->At(j[1]));
		// Add to existing cluster. Find which cluster this digis 
		for(k2=0;k2<nc;k2++){
		    clust1 = ((TObjArray*)(clusts->At(k2)));
		    if(clust1->IndexOf(dig)>=0) break;
		} // end for k2
		if(k2>=nc){
		    Fatal("FindRawClusters","Digit not found as expected");
		} // end if
	    } // end if j[1]>=0
	    // Found cluster with neighboring digits add this one to it.
	    if(clust0==clust1){ // same cluster
		clust0->AddAtFree(digs->At(i));
		clust0 = 0; // finished with cluster. zero for safty
		clust1 = 0; // finished wit hcluster. zero for safty
	    }else{ // two different clusters which need to be merged.
		clust0->AddAtFree(digs->At(i)); // Add digit to this cluster.
		for(k=0;k<clust1->GetEntriesFast();k++){
		    // move clust1 into clust0
		    clust0->AddAtFree(clust1->At(k));//move digit to this cluster
		    clust1->AddAt(0,k); // zero this one
		} // end for k
		delete clust1;
		clusts->AddAt(0,k2); // zero array of clusters element clust1
		clust0 = 0; // finished with cluster. zero for safty
		clust1 = 0; // finished wit hcluster. zero for safty
	    } // end if clust0==clust1
	}else{// New cluster
	    clusts->AddAt(new TObjArray(kelms),nc);
	    clust0 = ((TObjArray*)(clusts->At(nc)));
	    clust0->AddAtFree(digs->At(i));// move owner ship from digs to clusts
	    clust0 = 0; // finished with cluster. zero for safty
	    nc++;
	} // End if IsNeighbor
    } // end for i
    // There are now nc clusters in clusts. Each element of clust is an
    // array of digits which are clustered together.

    // For each cluster call detector specific CreateRecPoints
    for(i=0;i<nc;i++) CreateRecPoints((TObjArray*)(clusts->At(i)),module);

    // clean up at the end.
    for(i=0;i<nc;i++){ 
	clust0 =(TObjArray*)(clusts->At(i));
	// Digits deleted below, so zero this TObjArray
	for(k=0;k<clust0->GetEntriesFast();k++) clust0->AddAt(0,k);
	delete clust0; // Delete this TObjArray
	clusts->AddAt(0,i); // Contents deleted above, so zero it.
    } // end for i
    delete clusts; // Delete this TObjArray/
    // Delete the digits then the TObjArray which containted them.
    for(i=0;i<ndigits;i++) delete ((AliITSdigit*)(digs->At(i)));
    delete digs;
}
//______________________________________________________________________
Bool_t AliITSClusterFinder::IsNeighbor(TObjArray *digs,Int_t i,Int_t n[]) const{
    // Locagical function which checks to see if digit i has a neighbor.
    // If so, then it returns kTRUE and its neighbor index j.
    // This routine checks if the digits are side by side or one before the
    // other. Requires that the array of digits be in proper order.
    // Returns kTRUE in the following cases.
    //                 ji   0j   if kdiagonal  j0    0i
    //                 00   0i   if kdiagonal  0i    j0
    // Inputs:
    //    TObjArray *digs   Array to search for neighbors in
    //    Int_t      i      Index of digit for which we are searching for
    //                      a neighbor of.
    // Output:
    //    Int_t      j[4]   Index of one or more of the digits which is a
    //                      neighbor of digit a index i.
    // Return:
    //    Bool_t            kTRUE if a neighbor was found kFALSE otherwise.
    Int_t ix,jx,iz,jz,j;
    const Bool_t kdiagonal=kFALSE;
    Bool_t nei[4];

    // No neighbors found if array empty.
    if(digs->GetEntriesFast()<=0) return kFALSE;
    // can not be a digit with first element or elements out or range
    if(i<=0 || i>=digs->GetEntriesFast()) return kFALSE;

    for(j=0;j<4;j++){n[j] = -1;nei[j]=kFALSE;}
    ix = ((AliITSdigit*)(digs->At(i)))->GetCoord1();
    iz = ((AliITSdigit*)(digs->At(i)))->GetCoord2();
    for(j=0;j<i;j++){
	jx = ((AliITSdigit*)(digs->At(j)))->GetCoord1();
	jz = ((AliITSdigit*)(digs->At(j)))->GetCoord2();
	if(jx+1==ix && jz  ==iz){n[0] = j;nei[0] = kTRUE;}
	if(jx  ==ix && jz+1==iz){n[1] = j;nei[1] = kTRUE;}
	if(jx+1==ix && jz+1==iz){n[2] = j;nei[2] = kTRUE;}
	if(jx+1==ix && jz-1==iz){n[3] = j;nei[3] = kTRUE;}
    } // end for k
    if(nei[0]||nei[1]) return kTRUE;
    if(kdiagonal&&(nei[2]||nei[3])) return kTRUE;
    // no Neighbors found.
    return kFALSE;
}
Commit	Line	Data
b0f5e3fc	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	**************************************************************************/
bf3f2830	15	//
	16	// Base Class used to find
	17	// the reconstructed points for ITS
	18	// See also AliITSClusterFinderSPD, AliITSClusterFinderSDD,
	19	// AliITSClusterFinderSDD
	20	//
88cb7938	21
b0f5e3fc	22	#include "AliITSClusterFinder.h"
e869281d	23	#include "AliITSdigitSPD.h"
	24	#include "AliITSdigitSDD.h"
	25	#include "AliITSdigitSSD.h"
b0f5e3fc	26	#include "AliRun.h"
e8189707	27	#include "AliITS.h"
b0f5e3fc	28
b0f5e3fc	29	ClassImp(AliITSClusterFinder)
b0f5e3fc	30
9de0700b	31	//----------------------------------------------------------------------
	32	AliITSClusterFinder::AliITSClusterFinder(){
	33	// default cluster finder
	34
	35	fSegmentation = 0;
	36	fResponse = 0;
	37	fMap = 0;
	38	fDigits = 0;
	39	fNdigits = 0;
	40	fNRawClusters = 0;
	41	fNperMax = 0;
	42	fDeclusterFlag= 0;
	43	fClusterSize = 0;
	44	fNPeaks = 0;
	45	}
	46	//----------------------------------------------------------------------
	47	AliITSClusterFinder::AliITSClusterFinder(AliITSsegmentation *seg,
	48	AliITSresponse *response,
	49	TClonesArray *digits){
b0f5e3fc	50	// cluster finder
	51	fSegmentation=seg;
	52	fResponse=response;
	53	fMap = 0;
	54
	55	fDigits=digits;
	56	fNdigits = fDigits->GetEntriesFast();
	57
	58	fNRawClusters=0;
	59
	60	SetNperMax();
	61	SetClusterSize();
	62	SetDeclusterFlag();
	63
	64	fNPeaks=-1;
	65	}
9de0700b	66	//----------------------------------------------------------------------
	67	AliITSClusterFinder::~AliITSClusterFinder(){
	68	// destructor cluster finder
b0f5e3fc	69
9de0700b	70	// Zero local pointers. Other classes own these pointers.
55cd883f	71	fSegmentation = 0;
9de0700b	72	fResponse = 0;
	73	fMap = 0;
	74	fDigits = 0;
	75	fNdigits = 0;
	76	fNRawClusters = 0;
	77	fNperMax = 0;
	78	fDeclusterFlag= 0;
	79	fClusterSize = 0;
	80	fNPeaks = 0;
b0f5e3fc	81	}
b0f5e3fc	82	//__________________________________________________________________________
ac74f489	83	AliITSClusterFinder::AliITSClusterFinder(const AliITSClusterFinder &source) :
ac74f489	84	TObject(source){
9de0700b	85	// Copy Constructor
	86	if(&source == this) return;
	87	this->fDigits = source.fDigits;
	88	this->fNdigits = source.fNdigits;
	89	this->fResponse = source.fResponse;
	90	this->fSegmentation = source.fSegmentation;
	91	this->fNRawClusters = source.fNRawClusters;
	92	this->fMap = source.fMap;
	93	this->fNperMax = source.fNperMax;
	94	this->fDeclusterFlag = source.fDeclusterFlag;
	95	this->fClusterSize = source.fClusterSize;
	96	this->fNPeaks = source.fNPeaks;
	97	return;
b0f5e3fc	98	}
9de0700b	99	//______________________________________________________________________
	100	AliITSClusterFinder& AliITSClusterFinder::operator=(const AliITSClusterFinder &source) {
	101	// Assignment operator
	102
	103	if(&source == this) return *this;
	104	this->fDigits = source.fDigits;
	105	this->fNdigits = source.fNdigits;
	106	this->fResponse = source.fResponse;
	107	this->fSegmentation = source.fSegmentation;
	108	this->fNRawClusters = source.fNRawClusters;
	109	this->fMap = source.fMap;
	110	this->fNperMax = source.fNperMax;
	111	this->fDeclusterFlag = source.fDeclusterFlag;
	112	this->fClusterSize = source.fClusterSize;
	113	this->fNPeaks = source.fNPeaks;
	114	return *this;
b0f5e3fc	115	}
9de0700b	116	//----------------------------------------------------------------------
	117	void AliITSClusterFinder::AddCluster(Int_t branch, AliITSRawCluster *c){
	118	// Add a raw cluster copy to the list
b0f5e3fc	119
b0f5e3fc	120	AliITS iTS=(AliITS)gAlice->GetModule("ITS");
	121	iTS->AddCluster(branch,c);
	122	fNRawClusters++;
9355b256	123	}
9de0700b	124	//----------------------------------------------------------------------
	125	void AliITSClusterFinder::AddCluster(Int_t branch, AliITSRawCluster *c,
	126	AliITSRecPoint &rp){
	127	// Add a raw cluster copy to the list
9355b256	128
9355b256	129	AliITS iTS=(AliITS)gAlice->GetModule("ITS");
	130	iTS->AddCluster(branch,c);
	131	fNRawClusters++;
	132	iTS->AddRecPoint(rp);
b0f5e3fc	133	}
f8d9a5b8	134	//______________________________________________________________________
	135	void AliITSClusterFinder::FindRawClusters(Int_t module){
	136	// Default Cluster finder.
	137	// Input:
	138	// Int_t module Module number for which culster are to be found.
	139	// Output:
	140	// none.
	141	// Return:
	142	// none.
	143	const Int_t kelms = 10;
	144	Int_t ndigits = fDigits->GetEntriesFast();
	145	TObjArray *digs = new TObjArray(ndigits);
	146	TObjArray *clusts = new TObjArray(ndigits); // max # cluster
	147	TObjArray *clust0=0; // A spacific cluster of digits
	148	TObjArray *clust1=0; // A spacific cluster of digits
	149	AliITSdigit *dig=0; // locat pointer to a digit
f824982a	150	Int_t i=0,nc=0,j[4],k,k2=0;
f8d9a5b8	151
	152	// Copy all digits for this module into a local TObjArray.
	153	for(i=0;i<ndigits;i++) digs->AddAt(new AliITSdigit(((AliITSdigit)(fDigits->At(i)))),i);
	154	digs->Sort();
	155	// First digit is a cluster.
	156	i = 0;
	157	nc = 0;
	158	clusts->AddAt(new TObjArray(kelms),nc);
	159	clust0 = (TObjArray*)(clusts->At(nc));
	160	clust0->AddAtFree(digs->At(i)); // move owner ship from digs to clusts
	161	nc++;
	162	for(i=1;i<ndigits;i++){
	163	if(IsNeighbor(digs,i,j)){
	164	dig = (AliITSdigit*)(digs->At(j[0]));
	165	// Add to existing cluster. Find which cluster this digis
	166	for(k=0;k<nc;k++){
	167	clust0 = ((TObjArray*)(clusts->At(k)));
	168	if(clust0->IndexOf(dig)>=0) break;
	169	} // end for k
	170	if(k>=nc){
08d213d6	171	Fatal("FindRawClusters","Digit not found as expected");
f8d9a5b8	172	} // end if
	173	if(j[1]>=0){
	174	dig = (AliITSdigit*)(digs->At(j[1]));
	175	// Add to existing cluster. Find which cluster this digis
	176	for(k2=0;k2<nc;k2++){
	177	clust1 = ((TObjArray*)(clusts->At(k2)));
	178	if(clust1->IndexOf(dig)>=0) break;
	179	} // end for k2
	180	if(k2>=nc){
08d213d6	181	Fatal("FindRawClusters","Digit not found as expected");
f8d9a5b8	182	} // end if
	183	} // end if j[1]>=0
	184	// Found cluster with neighboring digits add this one to it.
	185	if(clust0==clust1){ // same cluster
	186	clust0->AddAtFree(digs->At(i));
	187	clust0 = 0; // finished with cluster. zero for safty
	188	clust1 = 0; // finished wit hcluster. zero for safty
	189	}else{ // two different clusters which need to be merged.
	190	clust0->AddAtFree(digs->At(i)); // Add digit to this cluster.
	191	for(k=0;k<clust1->GetEntriesFast();k++){
	192	// move clust1 into clust0
	193	clust0->AddAtFree(clust1->At(k));//move digit to this cluster
	194	clust1->AddAt(0,k); // zero this one
	195	} // end for k
	196	delete clust1;
	197	clusts->AddAt(0,k2); // zero array of clusters element clust1
	198	clust0 = 0; // finished with cluster. zero for safty
	199	clust1 = 0; // finished wit hcluster. zero for safty
	200	} // end if clust0==clust1
	201	}else{// New cluster
	202	clusts->AddAt(new TObjArray(kelms),nc);
	203	clust0 = ((TObjArray*)(clusts->At(nc)));
	204	clust0->AddAtFree(digs->At(i));// move owner ship from digs to clusts
	205	clust0 = 0; // finished with cluster. zero for safty
	206	nc++;
	207	} // End if IsNeighbor
	208	} // end for i
	209	// There are now nc clusters in clusts. Each element of clust is an
	210	// array of digits which are clustered together.
	211
	212	// For each cluster call detector specific CreateRecPoints
	213	for(i=0;i<nc;i++) CreateRecPoints((TObjArray*)(clusts->At(i)),module);
	214
	215	// clean up at the end.
	216	for(i=0;i<nc;i++){
	217	clust0 =(TObjArray*)(clusts->At(i));
	218	// Digits deleted below, so zero this TObjArray
	219	for(k=0;k<clust0->GetEntriesFast();k++) clust0->AddAt(0,k);
	220	delete clust0; // Delete this TObjArray
	221	clusts->AddAt(0,i); // Contents deleted above, so zero it.
	222	} // end for i
	223	delete clusts; // Delete this TObjArray/
	224	// Delete the digits then the TObjArray which containted them.
	225	for(i=0;i<ndigits;i++) delete ((AliITSdigit*)(digs->At(i)));
	226	delete digs;
	227	}
	228	//______________________________________________________________________
bf3f2830	229	Bool_t AliITSClusterFinder::IsNeighbor(TObjArray *digs,Int_t i,Int_t n[]) const{
f8d9a5b8	230	// Locagical function which checks to see if digit i has a neighbor.
	231	// If so, then it returns kTRUE and its neighbor index j.
	232	// This routine checks if the digits are side by side or one before the
	233	// other. Requires that the array of digits be in proper order.
	234	// Returns kTRUE in the following cases.
	235	// ji 0j if kdiagonal j0 0i
	236	// 00 0i if kdiagonal 0i j0
	237	// Inputs:
	238	// TObjArray *digs Array to search for neighbors in
	239	// Int_t i Index of digit for which we are searching for
	240	// a neighbor of.
	241	// Output:
	242	// Int_t j[4] Index of one or more of the digits which is a
	243	// neighbor of digit a index i.
	244	// Return:
	245	// Bool_t kTRUE if a neighbor was found kFALSE otherwise.
	246	Int_t ix,jx,iz,jz,j;
	247	const Bool_t kdiagonal=kFALSE;
	248	Bool_t nei[4];
	249
	250	// No neighbors found if array empty.
	251	if(digs->GetEntriesFast()<=0) return kFALSE;
	252	// can not be a digit with first element or elements out or range
	253	if(i<=0 \|\| i>=digs->GetEntriesFast()) return kFALSE;
	254
	255	for(j=0;j<4;j++){n[j] = -1;nei[j]=kFALSE;}
	256	ix = ((AliITSdigit*)(digs->At(i)))->GetCoord1();
	257	iz = ((AliITSdigit*)(digs->At(i)))->GetCoord2();
	258	for(j=0;j<i;j++){
	259	jx = ((AliITSdigit*)(digs->At(j)))->GetCoord1();
	260	jz = ((AliITSdigit*)(digs->At(j)))->GetCoord2();
	261	if(jx+1==ix && jz ==iz){n[0] = j;nei[0] = kTRUE;}
	262	if(jx ==ix && jz+1==iz){n[1] = j;nei[1] = kTRUE;}
	263	if(jx+1==ix && jz+1==iz){n[2] = j;nei[2] = kTRUE;}
	264	if(jx+1==ix && jz-1==iz){n[3] = j;nei[3] = kTRUE;}
	265	} // end for k
	266	if(nei[0]\|\|nei[1]) return kTRUE;
	267	if(kdiagonal&&(nei[2]\|\|nei[3])) return kTRUE;
	268	// no Neighbors found.
	269	return kFALSE;
	270	}