[u/mrichter/AliRoot.git] / MUON / AliMUONClusterFinderVS.h

#ifndef ALIMUONCLUSTERFINDERVS_H
#define ALIMUONCLUSTERFINDERVS_H
/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
 * See cxx source for full Copyright notice                               */

/* $Id$ */

////////////////////////////////////////////////
//  MUON Cluster Finder Class                 //
////////////////////////////////////////////////
#include "AliMUONHitMap.h"
#include "TF1.h"
#include "AliMUONClusterFinder.h"
#include "AliMUONSegmentation.h"

class AliMUONClusterFinderVS : 
 public AliMUONClusterFinder
{
 public:
    AliMUONClusterFinderVS
	(AliMUONSegmentation *segmentation1, AliMUONSegmentation *segmentation2,
	 AliMUONResponse *response,
	 TClonesArray *digits1, TClonesArray *digits2,
	 Int_t chamber);
    AliMUONClusterFinderVS();
    AliMUONClusterFinderVS(const AliMUONClusterFinderVS& clusterFinder);
    virtual ~AliMUONClusterFinderVS(){;}
// Set segmentation model    
    virtual void SetSegmentation(AliMUONSegmentation *seg1, AliMUONSegmentation *seg2)
	{
	fSegmentation[0]=seg1;
	fSegmentation[1]=seg2;
	}
// Set pointer to digits
    virtual void SetDigits(TClonesArray *MUONdigits1, TClonesArray *MUONdigits2);
    
// Get Segmentation
    virtual AliMUONSegmentation*  Segmentation(Int_t i);
// Get Number of Digits
    virtual Int_t NDigits(Int_t i);
// Get Digits
    virtual TClonesArray* Digits(Int_t i);
// Get HitMap
    virtual AliMUONHitMap* HitMap(Int_t i);
    
// Search for raw clusters
    virtual void FindRawClusters();
// Find cluster    
    virtual void  FindCluster(Int_t i, Int_t j, Int_t cath, AliMUONRawCluster &c);
// Decluster
    virtual void Decluster(AliMUONRawCluster *cluster);
//  Perform split by local maxima  
    virtual void   SplitByLocalMaxima(AliMUONRawCluster *cluster);
    virtual void   FindLocalMaxima(AliMUONRawCluster *cluster);
    virtual void   Split(AliMUONRawCluster * cluster);
    
//  Perform Double Mathieson Fit
    Bool_t DoubleMathiesonFit(AliMUONRawCluster *c, Int_t cath);
    Float_t CombiDoubleMathiesonFit(AliMUONRawCluster *c);
    Float_t SingleMathiesonFit(AliMUONRawCluster *c, Int_t cath);
    Float_t CombiSingleMathiesonFit(AliMUONRawCluster *c);    
//  Build up full cluster information    
    virtual void   FillCluster(AliMUONRawCluster *cluster, Int_t flag, Int_t cath);
    virtual void   FillCluster(AliMUONRawCluster *cluster, Int_t cath);
    virtual void   FillCluster(AliMUONRawCluster *cluster) {
	FillCluster(cluster,1,0);}
    // Add a new raw cluster    
    virtual void AddRawCluster(const AliMUONRawCluster cluster);
    
    virtual void SetTracks(Int_t t1, Int_t t2) 
	{
	    fTrack[0]=t1;
	    fTrack[1]=t2;
	}
    
    virtual Bool_t TestTrack(Int_t t) {
	if (fTrack[0]==-1 || fTrack[1]==-1) {
	    return kTRUE;
	} else if (t==fTrack[0] || t==fTrack[1]) {
	    return kTRUE;
	} else {
	    return kFALSE;
	}
    }
    //  Assignment operator
    AliMUONClusterFinderVS & operator = (const AliMUONClusterFinderVS& rhs);
protected:
    TClonesArray*           fDigits2;            // Digits
    Int_t                   fNdigits2;           // Number of Digits    
    AliMUONHitMapA1*        fHitMap2;            // Hit Map
    AliMUONDigit*           fDig[100][2];        // current list of digits 
    Int_t                   fIx[100][2];         // current list of x-pad-coord.
    Int_t                   fIy[100][2];         // current list of y-pad-coord.
    Float_t                 fX[100][2];          // current list of x-coord.
    Float_t                 fY[100][2];          // current list of y-coord.
    Int_t                   fIndLocal[100][2];   // indices of local maxima
    Int_t                   fNLocal[2];          // Number of local maxima
    Int_t                   fQ[100][2];          // current list of charges
    Int_t                   fMul[2];             // current multiplicity
// Current Fit
    Double_t                 fXFit[2];         // x-coordinate
    Double_t                 fYFit[2];         // y-coordinate
    Double_t                 fQrFit[2];        // charge ratio
    Float_t                  fChi2[2];         // chi2 of fit
    Float_t                  fXInit[2];        // start values
    Float_t                  fYInit[2];        // start values
    Float_t                  fQrInit[2];       // start values
    Int_t                    fFitStat;         // status of fit
    
// Selected track for debugging
    Int_t                    fTrack[2];        // Only digits with main contributions from these tracks are
                                               // considered 
//  Return pointer to raw clusters    
    ClassDef(AliMUONClusterFinderVS,1) //Class for clustering and reconstruction of space points
};
#endif
Commit	Line	Data
a9e2aefa	1	#ifndef ALIMUONCLUSTERFINDERVS_H
	2	#define ALIMUONCLUSTERFINDERVS_H
	3	/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
	4	* See cxx source for full Copyright notice */
	5
	6	/* $Id$ */
	7
	8	////////////////////////////////////////////////
	9	// MUON Cluster Finder Class //
	10	////////////////////////////////////////////////
	11	#include "AliMUONHitMap.h"
	12	#include "TF1.h"
	13	#include "AliMUONClusterFinder.h"
9825400f	14	#include "AliMUONSegmentation.h"
9825400f	15
a9e2aefa	16	class AliMUONClusterFinderVS :
	17	public AliMUONClusterFinder
	18	{
	19	public:
	20	AliMUONClusterFinderVS
	21	(AliMUONSegmentation segmentation1, AliMUONSegmentation segmentation2,
	22	AliMUONResponse *response,
	23	TClonesArray digits1, TClonesArray digits2,
	24	Int_t chamber);
	25	AliMUONClusterFinderVS();
	26	AliMUONClusterFinderVS(const AliMUONClusterFinderVS& clusterFinder);
	27	virtual ~AliMUONClusterFinderVS(){;}
	28	// Set segmentation model
	29	virtual void SetSegmentation(AliMUONSegmentation seg1, AliMUONSegmentation seg2)
	30	{
9825400f	31	fSegmentation[0]=seg1;
9825400f	32	fSegmentation[1]=seg2;
a9e2aefa	33	}
	34	// Set pointer to digits
	35	virtual void SetDigits(TClonesArray MUONdigits1, TClonesArray MUONdigits2);
	36
	37	// Get Segmentation
	38	virtual AliMUONSegmentation* Segmentation(Int_t i);
	39	// Get Number of Digits
	40	virtual Int_t NDigits(Int_t i);
	41	// Get Digits
	42	virtual TClonesArray* Digits(Int_t i);
	43	// Get HitMap
	44	virtual AliMUONHitMap* HitMap(Int_t i);
	45
	46	// Search for raw clusters
	47	virtual void FindRawClusters();
	48	// Find cluster
	49	virtual void FindCluster(Int_t i, Int_t j, Int_t cath, AliMUONRawCluster &c);
	50	// Decluster
	51	virtual void Decluster(AliMUONRawCluster *cluster);
	52	// Perform split by local maxima
	53	virtual void SplitByLocalMaxima(AliMUONRawCluster *cluster);
	54	virtual void FindLocalMaxima(AliMUONRawCluster *cluster);
	55	virtual void Split(AliMUONRawCluster * cluster);
	56
	57	// Perform Double Mathieson Fit
	58	Bool_t DoubleMathiesonFit(AliMUONRawCluster *c, Int_t cath);
	59	Float_t CombiDoubleMathiesonFit(AliMUONRawCluster *c);
	60	Float_t SingleMathiesonFit(AliMUONRawCluster *c, Int_t cath);
	61	Float_t CombiSingleMathiesonFit(AliMUONRawCluster *c);
	62	// Build up full cluster information
	63	virtual void FillCluster(AliMUONRawCluster *cluster, Int_t flag, Int_t cath);
	64	virtual void FillCluster(AliMUONRawCluster *cluster, Int_t cath);
	65	virtual void FillCluster(AliMUONRawCluster *cluster) {
	66	FillCluster(cluster,1,0);}
	67	// Add a new raw cluster
	68	virtual void AddRawCluster(const AliMUONRawCluster cluster);
	69
	70	virtual void SetTracks(Int_t t1, Int_t t2)
	71	{
	72	fTrack[0]=t1;
	73	fTrack[1]=t2;
	74	}
	75
	76	virtual Bool_t TestTrack(Int_t t) {
	77	if (fTrack[0]==-1 \|\| fTrack[1]==-1) {
	78	return kTRUE;
	79	} else if (t==fTrack[0] \|\| t==fTrack[1]) {
	80	return kTRUE;
	81	} else {
	82	return kFALSE;
	83	}
	84	}
	85	// Assignment operator
	86	AliMUONClusterFinderVS & operator = (const AliMUONClusterFinderVS& rhs);
	87	protected:
	88	TClonesArray* fDigits2; // Digits
	89	Int_t fNdigits2; // Number of Digits
a9e2aefa	90	AliMUONHitMapA1* fHitMap2; // Hit Map
	91	AliMUONDigit* fDig[100][2]; // current list of digits
	92	Int_t fIx[100][2]; // current list of x-pad-coord.
	93	Int_t fIy[100][2]; // current list of y-pad-coord.
	94	Float_t fX[100][2]; // current list of x-coord.
	95	Float_t fY[100][2]; // current list of y-coord.
	96	Int_t fIndLocal[100][2]; // indices of local maxima
	97	Int_t fNLocal[2]; // Number of local maxima
	98	Int_t fQ[100][2]; // current list of charges
	99	Int_t fMul[2]; // current multiplicity
	100	// Current Fit
	101	Double_t fXFit[2]; // x-coordinate
	102	Double_t fYFit[2]; // y-coordinate
	103	Double_t fQrFit[2]; // charge ratio
	104	Float_t fChi2[2]; // chi2 of fit
	105	Float_t fXInit[2]; // start values
	106	Float_t fYInit[2]; // start values
	107	Float_t fQrInit[2]; // start values
	108	Int_t fFitStat; // status of fit
	109
	110	// Selected track for debugging
	111	Int_t fTrack[2]; // Only digits with main contributions from these tracks are
	112	// considered
	113	// Return pointer to raw clusters
	114	ClassDef(AliMUONClusterFinderVS,1) //Class for clustering and reconstruction of space points
	115	};
	116	#endif
	117
	118
	119
	120
	121
	122
	123
	124
	125
	126