[u/mrichter/AliRoot.git] / ITS / AliITSRawClusterSDD.cxx

/**************************************************************************
 * Copyright(c) 2000-2004, 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.                  *
 **************************************************************************/
#include <Riostream.h>
#include <TMath.h>
 
#include "AliITSRawClusterSDD.h"

////////////////////////////////////////////////////
//  Cluster classes for set:ITS                   //
//  Raw Clusters for SDD                          //
//                                                //
////////////////////////////////////////////////////

ClassImp(AliITSRawClusterSDD)
//______________________________________________________________________
AliITSRawClusterSDD::AliITSRawClusterSDD(){
	// default constructor
	fX=fZ=fQ=0;
	fWing=0;
	fNanodes=1;
	fAnode=fTime=fPeakAmplitude=0;
	fPeakPosition=-1;
	fMultiplicity=0;
	fTstart=fTstop=fTstartf=fTstopf=0;
	fAstart=fAstop=0;
}

//______________________________________________________________________
AliITSRawClusterSDD::AliITSRawClusterSDD(Int_t wing,
					 Float_t Anode,Float_t Time,
					 Float_t Charge,Float_t PeakAmplitude,
					 Int_t PeakPosition,
					 Float_t Asigma,Float_t Tsigma,
					 Float_t DriftPath,
					 Float_t AnodeOffset,
					 Int_t Samples,Int_t Tstart,
					 Int_t Tstop,Int_t Tstartf,
					 Int_t Tstopf,Int_t Anodes, 
					 Int_t Astart, Int_t Astop){
    // constructor

    fWing          = wing;
    fAnode         = Anode;
    fTime          = Time;
    fQ             = Charge;
    fPeakAmplitude = PeakAmplitude;
    fPeakPosition  = PeakPosition;
    fAsigma        = Asigma;
    fTsigma        = Tsigma;
    fNanodes       = Anodes;
    fTstart        = Tstart;
    fTstop         = Tstop;
    fTstartf       = Tstartf;
    fTstopf        = Tstopf;
    fAstart        = Astart;
    fAstop         = Astop;
    fMultiplicity  = Samples;
    fSumAmplitude  = 0;

    Int_t sign = 1;
    for(Int_t i=0;i<fWing; i++) sign *= (-1);
    fX = DriftPath*sign/10000.;
    fZ = AnodeOffset/10000.;
}
//______________________________________________________________________
AliITSRawClusterSDD::AliITSRawClusterSDD(const AliITSRawClusterSDD & source):
    AliITSRawCluster(source){
    // copy constructor

    fWing          = source.fWing;
    fAnode         = source.fAnode;
    fTime          = source.fTime;
    fQ             = source.fQ;
    fPeakAmplitude = source.fPeakAmplitude;
    fPeakPosition  = source.fPeakPosition;
    fAsigma        = source.fAsigma;
    fTsigma        = source.fTsigma;
    fNanodes       = source.fNanodes;
    fTstart        = source.fTstart;
    fTstop         = source.fTstop;
    fTstartf       = source.fTstartf;
    fTstopf        = source.fTstopf;
    fAstart        = source.fAstart;
    fAstop         = source.fAstop;

    fMultiplicity  = source.fMultiplicity;
    fSumAmplitude  = source.fSumAmplitude;
    fX             = source.fX;
    fZ             = source.fZ;
}
//______________________________________________________________________
void AliITSRawClusterSDD::Add(AliITSRawClusterSDD* clJ) {
    // add

    fAnode = (fAnode*fQ + clJ->A()*clJ->Q())/(fQ+clJ->Q());
    fTime  = ( fTime*fQ + clJ->T()*clJ->Q())/(fQ+clJ->Q());
    fX     = (    fX*fQ + clJ->X()*clJ->Q())/(fQ+clJ->Q());
    fZ     = (    fZ*fQ + clJ->Z()*clJ->Q())/(fQ+clJ->Q());
    fQ += clJ->Q();
    if(fSumAmplitude == 0) fSumAmplitude += fPeakAmplitude;
    /*
      fAnode = (fAnode*fSumAmplitude+clJ->A()*clJ->PeakAmpl())/
               (fSumAmplitude+clJ->PeakAmpl());
      fTime = (fTime*fSumAmplitude +clJ->T()*clJ->PeakAmpl())/
              (fSumAmplitude+clJ->PeakAmpl());
      fX = (fX*fSumAmplitude +clJ->X()*clJ->PeakAmpl())/
           (fSumAmplitude+clJ->PeakAmpl());
      fZ = (fZ*fSumAmplitude +clJ->Z()*clJ->PeakAmpl())/
           (fSumAmplitude+clJ->PeakAmpl());
    */
    fSumAmplitude += clJ->PeakAmpl();

    fTstart = clJ->Tstart();
    fTstop  = clJ->Tstop();
    if(fTstartf > clJ->Tstartf()) fTstartf = clJ->Tstartf();
    if( fTstopf < clJ->Tstopf() ) fTstopf  = clJ->Tstopf();
    if(  fAstop < clJ->Astop()  ) fAstop   = clJ->Astop();

    fMultiplicity += (Int_t) (clJ->Samples());
    (fNanodes)++;
    if(clJ->PeakAmpl() > fPeakAmplitude) {
	fPeakAmplitude = clJ->PeakAmpl();
	fPeakPosition = clJ->PeakPos();
    } // end if

    return;
}
//______________________________________________________________________
Bool_t AliITSRawClusterSDD::Brother(AliITSRawClusterSDD* cluster,
				    Float_t danode,Float_t dtime) {
  // compare this with "cluster"
    Bool_t brother = kFALSE;
    Bool_t test2 = kFALSE;
    Bool_t test3 = kFALSE;
    Bool_t test4 = kFALSE;
    Bool_t test5 = kFALSE;
  
    if(fWing != cluster->W()) return brother;

    if(fTstopf >= cluster->Tstart() &&
       fTstartf <= cluster->Tstop()) test2 = kTRUE;
    if(cluster->Astop() == (fAstop+1)) test3 = kTRUE;

    if(TMath::Abs(fTime-cluster->T()) < dtime) test4 = kTRUE;
    if(TMath::Abs(fAnode-cluster->A()) < danode) test5 = kTRUE;

    if((test2 && test3) || (test4 && test5) ) {
	return brother = kTRUE;
    } // end if
  
    return brother;
}
//______________________________________________________________________
void AliITSRawClusterSDD::PrintInfo() const {
    // print

    cout << ", Anode " << fAnode << ", Time: " << fTime << ", Charge: " << fQ;
    cout << ", Samples: " << fMultiplicity;
    cout << ", X: " << fX << ", Z: " << fZ << "tstart " << fTstart 
	 << "tstop "<< fTstop <<endl;
}
Commit	Line	Data
41b19549	1	/**************************************************************************
	2	* Copyright(c) 2000-2004, 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	#include <Riostream.h>
	16	#include <TMath.h>
	17
	18	#include "AliITSRawClusterSDD.h"
	19
	20	////////////////////////////////////////////////////
	21	// Cluster classes for set:ITS //
	22	// Raw Clusters for SDD //
	23	// //
	24	////////////////////////////////////////////////////
	25
	26	ClassImp(AliITSRawClusterSDD)
	27	//______________________________________________________________________
	28	AliITSRawClusterSDD::AliITSRawClusterSDD(){
	29	// default constructor
	30	fX=fZ=fQ=0;
	31	fWing=0;
	32	fNanodes=1;
	33	fAnode=fTime=fPeakAmplitude=0;
	34	fPeakPosition=-1;
	35	fMultiplicity=0;
	36	fTstart=fTstop=fTstartf=fTstopf=0;
	37	fAstart=fAstop=0;
	38	}
	39
	40	//______________________________________________________________________
	41	AliITSRawClusterSDD::AliITSRawClusterSDD(Int_t wing,
	42	Float_t Anode,Float_t Time,
	43	Float_t Charge,Float_t PeakAmplitude,
	44	Int_t PeakPosition,
	45	Float_t Asigma,Float_t Tsigma,
	46	Float_t DriftPath,
	47	Float_t AnodeOffset,
	48	Int_t Samples,Int_t Tstart,
	49	Int_t Tstop,Int_t Tstartf,
	50	Int_t Tstopf,Int_t Anodes,
	51	Int_t Astart, Int_t Astop){
	52	// constructor
	53
	54	fWing = wing;
	55	fAnode = Anode;
	56	fTime = Time;
	57	fQ = Charge;
	58	fPeakAmplitude = PeakAmplitude;
	59	fPeakPosition = PeakPosition;
	60	fAsigma = Asigma;
	61	fTsigma = Tsigma;
	62	fNanodes = Anodes;
	63	fTstart = Tstart;
	64	fTstop = Tstop;
65	fTstartf = Tstartf;
66	fTstopf = Tstopf;
67	fAstart = Astart;
68	fAstop = Astop;
69	fMultiplicity = Samples;
70	fSumAmplitude = 0;
71
72	Int_t sign = 1;
73	for(Int_t i=0;i<fWing; i++) sign *= (-1);
74	fX = DriftPath*sign/10000.;
75	fZ = AnodeOffset/10000.;
76	}
77	//______________________________________________________________________
78	AliITSRawClusterSDD::AliITSRawClusterSDD(const AliITSRawClusterSDD & source):
79	AliITSRawCluster(source){
80	// copy constructor
81
82	fWing = source.fWing;
83	fAnode = source.fAnode;
84	fTime = source.fTime;
85	fQ = source.fQ;
86	fPeakAmplitude = source.fPeakAmplitude;
87	fPeakPosition = source.fPeakPosition;
88	fAsigma = source.fAsigma;
89	fTsigma = source.fTsigma;
90	fNanodes = source.fNanodes;
91	fTstart = source.fTstart;
92	fTstop = source.fTstop;
93	fTstartf = source.fTstartf;
94	fTstopf = source.fTstopf;
95	fAstart = source.fAstart;
96	fAstop = source.fAstop;
97
98	fMultiplicity = source.fMultiplicity;
99	fSumAmplitude = source.fSumAmplitude;
100	fX = source.fX;
101	fZ = source.fZ;
102	}
103	//______________________________________________________________________
104	void AliITSRawClusterSDD::Add(AliITSRawClusterSDD* clJ) {
105	// add
106
107	fAnode = (fAnodefQ + clJ->A()clJ->Q())/(fQ+clJ->Q());
108	fTime = ( fTimefQ + clJ->T()clJ->Q())/(fQ+clJ->Q());
109	fX = ( fXfQ + clJ->X()clJ->Q())/(fQ+clJ->Q());
110	fZ = ( fZfQ + clJ->Z()clJ->Q())/(fQ+clJ->Q());
111	fQ += clJ->Q();
112	if(fSumAmplitude == 0) fSumAmplitude += fPeakAmplitude;
113	/*
114	fAnode = (fAnodefSumAmplitude+clJ->A()clJ->PeakAmpl())/
115	(fSumAmplitude+clJ->PeakAmpl());
116	fTime = (fTimefSumAmplitude +clJ->T()clJ->PeakAmpl())/
117	(fSumAmplitude+clJ->PeakAmpl());
118	fX = (fXfSumAmplitude +clJ->X()clJ->PeakAmpl())/
119	(fSumAmplitude+clJ->PeakAmpl());
120	fZ = (fZfSumAmplitude +clJ->Z()clJ->PeakAmpl())/
121	(fSumAmplitude+clJ->PeakAmpl());
122	*/
123	fSumAmplitude += clJ->PeakAmpl();
124
125	fTstart = clJ->Tstart();
126	fTstop = clJ->Tstop();
127	if(fTstartf > clJ->Tstartf()) fTstartf = clJ->Tstartf();
128	if( fTstopf < clJ->Tstopf() ) fTstopf = clJ->Tstopf();
129	if( fAstop < clJ->Astop() ) fAstop = clJ->Astop();
130
131	fMultiplicity += (Int_t) (clJ->Samples());
132	(fNanodes)++;
133	if(clJ->PeakAmpl() > fPeakAmplitude) {
134	fPeakAmplitude = clJ->PeakAmpl();
135	fPeakPosition = clJ->PeakPos();
136	} // end if
137
138	return;
139	}
140	//______________________________________________________________________
141	Bool_t AliITSRawClusterSDD::Brother(AliITSRawClusterSDD* cluster,
142	Float_t danode,Float_t dtime) {
143	// compare this with "cluster"
144	Bool_t brother = kFALSE;
145	Bool_t test2 = kFALSE;
146	Bool_t test3 = kFALSE;
147	Bool_t test4 = kFALSE;
148	Bool_t test5 = kFALSE;
149
150	if(fWing != cluster->W()) return brother;
151
152	if(fTstopf >= cluster->Tstart() &&
153	fTstartf <= cluster->Tstop()) test2 = kTRUE;
154	if(cluster->Astop() == (fAstop+1)) test3 = kTRUE;
155
156	if(TMath::Abs(fTime-cluster->T()) < dtime) test4 = kTRUE;
157	if(TMath::Abs(fAnode-cluster->A()) < danode) test5 = kTRUE;
158
159	if((test2 && test3) \|\| (test4 && test5) ) {
160	return brother = kTRUE;
161	} // end if
162
163	return brother;
164	}
165	//______________________________________________________________________
166	void AliITSRawClusterSDD::PrintInfo() const {
167	// print
168
169	cout << ", Anode " << fAnode << ", Time: " << fTime << ", Charge: " << fQ;
170	cout << ", Samples: " << fMultiplicity;
171	cout << ", X: " << fX << ", Z: " << fZ << "tstart " << fTstart
172	<< "tstop "<< fTstop <<endl;
173	}