[u/mrichter/AliRoot.git] / ITS / AliITSClusterFinderSSD.h

#ifndef ALIITSCLUSTERFINDERSSD_H
#define ALIITSCLUSTERFINDERSSD_H
/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
 * See cxx source for full Copyright notice                               */
/////////////////////////////////////////////////////////////////////////////
//          SSD Cluster Finder                                             //
//                                                                         //
/////////////////////////////////////////////////////////////////////////////
//#include <TMath.h>
#include "AliITSClusterFinder.h"
//#include "AliITSsegmentationSSD.h"

class TArrayI;
class AliITSclusterSSD;
class AliITSpackageSSD;
class AliITSsegmentation;
class AliITSsegmentationSSD;
class AliITSresponse;
class AliITSresponseSSD;

class AliITSClusterFinderSSD: public AliITSClusterFinder{
  public:
    AliITSClusterFinderSSD();
    AliITSClusterFinderSSD(AliITSsegmentation *seg,AliITSresponse *resp);
    AliITSClusterFinderSSD(AliITSsegmentation *seg, TClonesArray *digits);
    virtual ~AliITSClusterFinderSSD();
    void FindRawClusters(Int_t module);

  protected:
    // copy constructor
    AliITSClusterFinderSSD(const AliITSClusterFinderSSD &source);
    // assignment operator
    AliITSClusterFinderSSD& operator=(const AliITSClusterFinderSSD &source);
    virtual AliITSresponseSSD* GetResp()const{
        return (AliITSresponseSSD*) GetResponse();}//Return Response
    //Returns fSegmentation
    virtual AliITSsegmentationSSD* GetSeg()const{
        return (AliITSsegmentationSSD*)GetSegmentation();} 
    void      InitReconstruction();
    Bool_t    CreateNewRecPoint(Double_t P,Double_t dP,Double_t N,Double_t dN,
                                Double_t Sig,Double_t dSig,
                                AliITSclusterSSD *clusterP,
                                AliITSclusterSSD *clusterN,Stat_t prob);
    AliITSclusterSSD* GetPSideCluster(Int_t idx);
    AliITSclusterSSD* GetNSideCluster(Int_t idx);
    AliITSclusterSSD* GetCluster(Int_t idx, Bool_t side){
    return (side) ? GetPSideCluster(idx) : GetNSideCluster(idx);};
    void   FindNeighbouringDigits();
    void   SeparateOverlappedClusters();
    void   SplitCluster(TArrayI *list,Int_t nsplits,Int_t indx,Bool_t side);
    Int_t  SortDigitsP(Int_t start, Int_t end);
    Int_t  SortDigitsN(Int_t start, Int_t end);
    void   FillDigitsIndex();
    void   SortDigits();
    void   FillClIndexArrays(Int_t* arrayP, Int_t *arrayN) const;
    void   SortClusters(Int_t* arrayP, Int_t *arrayN);
    Int_t  SortClustersP(Int_t start, Int_t end,Int_t *array);
    Int_t  SortClustersN(Int_t start, Int_t end,Int_t *array);
    void   ClustersToPackages();
    Int_t  GetDiff(Double_t */*retx*/, Double_t */*rety*/) const {return 0;}
    void   CalcStepFactor(Double_t Psteo, Double_t Nsteo );
    Bool_t GetCrossing(Double_t &x, Double_t &z); //x, y of strips crossing
    //x, y of strips crossing err.
    void   GetCrossingError(Double_t& dp, Double_t& dn);

    // Data memebers
    TClonesArray    *fClusterP;      //!
    Int_t            fNClusterP;     //!Number of P side clusters in the array
    TClonesArray    *fClusterN;      //!Number of N side clusters in the array
    Int_t            fNClusterN;     //!
    TClonesArray    *fPackages;      //!packages  
    Int_t            fNPackages;     //!
    TArrayI         *fDigitsIndexP;  //!Digits on P side
    Int_t            fNDigitsP;      //!Number of Digits on P side
    TArrayI         *fDigitsIndexN;  //!Digits on N side
    Int_t            fNDigitsN;      //!Number of Digits on N side

    Double_t          fPitch;         //!Strip pitch
    Double_t          fTanP;          //!Pside stereo angle tangent
    Double_t          fTanN;          //!Nside stereo angle tangent

/*************************************************/
/**  parameters for reconstruction            ****/
/**  to be tune when slow simulation raliable ****/
/*************************************************/

    //Double_t fAlpha1;         //!
    //Double_t fAlpha2;         //!
    //Double_t fAlpha3;         //!
    Double_t fPNsignalRatio;  //!
    
    static const Bool_t fgkSIDEP;  //!
    static const Bool_t fgkSIDEN;  //!

    Int_t fSFF;              //!forward stepping factor 
    Int_t fSFB;              //!backward stepping factor 

    ClassDef(AliITSClusterFinderSSD,1) //Class for clustering and reconstruction of space points in SSDs 

};


#endif
Commit	Line	Data
b0f5e3fc	1	#ifndef ALIITSCLUSTERFINDERSSD_H
	2	#define ALIITSCLUSTERFINDERSSD_H
	3	/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
	4	* See cxx source for full Copyright notice */
04366a57	5	/////////////////////////////////////////////////////////////////////////////
	6	// SSD Cluster Finder //
	7	// //
	8	/////////////////////////////////////////////////////////////////////////////
aacedc3e	9	//#include <TMath.h>
b0f5e3fc	10	#include "AliITSClusterFinder.h"
aacedc3e	11	//#include "AliITSsegmentationSSD.h"
b0f5e3fc	12
eb08b98f	13	class TArrayI;
e8189707	14	class AliITSclusterSSD;
e8189707	15	class AliITSpackageSSD;
aacedc3e	16	class AliITSsegmentation;
	17	class AliITSsegmentationSSD;
	18	class AliITSresponse;
	19	class AliITSresponseSSD;
e8189707	20
fe15e140	21	class AliITSClusterFinderSSD: public AliITSClusterFinder{
aacedc3e	22	public:
fe15e140	23	AliITSClusterFinderSSD();
aacedc3e	24	AliITSClusterFinderSSD(AliITSsegmentation seg,AliITSresponse resp);
fe15e140	25	AliITSClusterFinderSSD(AliITSsegmentation seg, TClonesArray digits);
fe15e140	26	virtual ~AliITSClusterFinderSSD();
aacedc3e	27	void FindRawClusters(Int_t module);
b0f5e3fc	28
aacedc3e	29	protected:
04366a57	30	// copy constructor
	31	AliITSClusterFinderSSD(const AliITSClusterFinderSSD &source);
	32	// assignment operator
	33	AliITSClusterFinderSSD& operator=(const AliITSClusterFinderSSD &source);
aacedc3e	34	virtual AliITSresponseSSD* GetResp()const{
	35	return (AliITSresponseSSD*) GetResponse();}//Return Response
	36	//Returns fSegmentation
	37	virtual AliITSsegmentationSSD* GetSeg()const{
	38	return (AliITSsegmentationSSD*)GetSegmentation();}
fe15e140	39	void InitReconstruction();
aacedc3e	40	Bool_t CreateNewRecPoint(Double_t P,Double_t dP,Double_t N,Double_t dN,
	41	Double_t Sig,Double_t dSig,
	42	AliITSclusterSSD *clusterP,
	43	AliITSclusterSSD *clusterN,Stat_t prob);
fe15e140	44	AliITSclusterSSD* GetPSideCluster(Int_t idx);
fe15e140	45	AliITSclusterSSD* GetNSideCluster(Int_t idx);
aacedc3e	46	AliITSclusterSSD* GetCluster(Int_t idx, Bool_t side){
	47	return (side) ? GetPSideCluster(idx) : GetNSideCluster(idx);};
	48	void FindNeighbouringDigits();
	49	void SeparateOverlappedClusters();
	50	void SplitCluster(TArrayI *list,Int_t nsplits,Int_t indx,Bool_t side);
	51	Int_t SortDigitsP(Int_t start, Int_t end);
	52	Int_t SortDigitsN(Int_t start, Int_t end);
	53	void FillDigitsIndex();
	54	void SortDigits();
	55	void FillClIndexArrays(Int_t* arrayP, Int_t *arrayN) const;
	56	void SortClusters(Int_t* arrayP, Int_t *arrayN);
	57	Int_t SortClustersP(Int_t start, Int_t end,Int_t *array);
	58	Int_t SortClustersN(Int_t start, Int_t end,Int_t *array);
	59	void ClustersToPackages();
	60	Int_t GetDiff(Double_t /retx/, Double_t /rety/) const {return 0;}
	61	void CalcStepFactor(Double_t Psteo, Double_t Nsteo );
	62	Bool_t GetCrossing(Double_t &x, Double_t &z); //x, y of strips crossing
	63	//x, y of strips crossing err.
	64	void GetCrossingError(Double_t& dp, Double_t& dn);
fe15e140	65
fe15e140	66	// Data memebers
fe15e140	67	TClonesArray *fClusterP; //!
	68	Int_t fNClusterP; //!Number of P side clusters in the array
	69	TClonesArray *fClusterN; //!Number of N side clusters in the array
	70	Int_t fNClusterN; //!
	71	TClonesArray *fPackages; //!packages
	72	Int_t fNPackages; //!
	73	TArrayI *fDigitsIndexP; //!Digits on P side
	74	Int_t fNDigitsP; //!Number of Digits on P side
	75	TArrayI *fDigitsIndexN; //!Digits on N side
	76	Int_t fNDigitsN; //!Number of Digits on N side
	77
aacedc3e	78	Double_t fPitch; //!Strip pitch
	79	Double_t fTanP; //!Pside stereo angle tangent
	80	Double_t fTanN; //!Nside stereo angle tangent
b0f5e3fc	81
	82	/*************************************************/
	83	/ parameters for reconstruction **/
	84	/ to be tune when slow simulation raliable **/
fe15e140	85	/*************************************************/
e8189707	86
aacedc3e	87	//Double_t fAlpha1; //!
	88	//Double_t fAlpha2; //!
	89	//Double_t fAlpha3; //!
	90	Double_t fPNsignalRatio; //!
b0f5e3fc	91
fe15e140	92	static const Bool_t fgkSIDEP; //!
fe15e140	93	static const Bool_t fgkSIDEN; //!
be33dccb	94
fe15e140	95	Int_t fSFF; //!forward stepping factor
fe15e140	96	Int_t fSFB; //!backward stepping factor
b0f5e3fc	97
aacedc3e	98	ClassDef(AliITSClusterFinderSSD,1) //Class for clustering and reconstruction of space points in SSDs
b0f5e3fc	99
	100	};
	101
	102
	103	#endif