From Laurent:
[u/mrichter/AliRoot.git] / MUON / AliMUONClusterInput.cxx
CommitLineData
9825400f 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
88cb7938 16/* $Id$ */
d4fa40b7 17
30178c30 18#include <TClonesArray.h>
19#include <TMinuit.h>
20
9825400f 21#include "AliRun.h"
22#include "AliMUON.h"
23#include "AliMUONChamber.h"
7e4a628d 24#include "AliMUONConstants.h"
9825400f 25#include "AliMUONClusterInput.h"
7e4a628d 26#include "AliMUONMathieson.h"
9825400f 27#include "AliMUONRawCluster.h"
28#include "AliMUONDigit.h"
8c343c7c 29#include "AliLog.h"
9825400f 30
9825400f 31ClassImp(AliMUONClusterInput)
32
33AliMUONClusterInput* AliMUONClusterInput::fgClusterInput = 0;
34TMinuit* AliMUONClusterInput::fgMinuit = 0;
7e4a628d 35AliMUONMathieson* AliMUONClusterInput::fgMathieson = 0;
9825400f 36
30178c30 37AliMUONClusterInput::AliMUONClusterInput()
7e4a628d 38 : TObject(),
39 fCluster(0),
fed772f3 40 fChargeCorrel(1.),
fed772f3 41 fDetElemId(0)
b137f8b9 42
30178c30 43{
3f5cf0b3 44 fDigits[0]=0;
45 fDigits[1]=0;
fed772f3 46 fSegmentation2[0]=0;
47 fSegmentation2[1]=0;
3f5cf0b3 48}
49
9825400f 50AliMUONClusterInput* AliMUONClusterInput::Instance()
51{
52// return pointer to the singleton instance
53 if (fgClusterInput == 0) {
54 fgClusterInput = new AliMUONClusterInput();
e357fc46 55 fgMinuit = new TMinuit(8);
9825400f 56 }
57
58 return fgClusterInput;
59}
60
d4fa40b7 61AliMUONClusterInput::~AliMUONClusterInput()
62{
63// Destructor
64 delete fgMinuit;
7e4a628d 65 delete fgMathieson;
d4fa40b7 66}
30178c30 67
7b4177a6 68AliMUONClusterInput::AliMUONClusterInput(const AliMUONClusterInput& clusterInput):TObject(clusterInput)
69{
30178c30 70// Protected copy constructor
71
8c343c7c 72 AliFatal("Not implemented.");
7b4177a6 73}
d4fa40b7 74
a713db22 75void AliMUONClusterInput::SetDigits(Int_t chamber, Int_t idDE, TClonesArray* dig1, TClonesArray* dig2)
76{
77 // Set pointer to digits with corresponding segmentations and responses (two cathode planes)
78 fChamber = chamber;
79 fDetElemId = idDE;
80 fDigits[0] = dig1;
81 fDigits[1] = dig2;
82 fNDigits[0] = dig1->GetEntriesFast();
83 fNDigits[1] = dig2->GetEntriesFast();
84
85 AliMUON *pMUON;
86 AliMUONChamber* iChamber;
87
88 pMUON = (AliMUON*) gAlice->GetModule("MUON");
89 iChamber = &(pMUON->Chamber(chamber));
90
91 fgMathieson = new AliMUONMathieson();
a713db22 92
93 fSegmentation2[0]=iChamber->SegmentationModel2(1);
94 fSegmentation2[1]=iChamber->SegmentationModel2(2);
95
96 fNseg = 2;
97 if (chamber < AliMUONConstants::NTrackingCh()) {
98 if (chamber > 1 ) {
99 fgMathieson->SetPitch(AliMUONConstants::Pitch());
100 fgMathieson->SetSqrtKx3AndDeriveKx2Kx4(AliMUONConstants::SqrtKx3());
101 fgMathieson->SetSqrtKy3AndDeriveKy2Ky4(AliMUONConstants::SqrtKy3());
102 fChargeCorrel = AliMUONConstants::ChargeCorrel();
103 } else {
104 fgMathieson->SetPitch(AliMUONConstants::PitchSt1());
105 fgMathieson->SetSqrtKx3AndDeriveKx2Kx4(AliMUONConstants::SqrtKx3St1());
106 fgMathieson->SetSqrtKy3AndDeriveKy2Ky4(AliMUONConstants::SqrtKy3St1());
107 fChargeCorrel = AliMUONConstants::ChargeCorrelSt1();
108 }
109 }
110}
111
112void AliMUONClusterInput::SetDigits(Int_t chamber, Int_t idDE, TClonesArray* dig)
113{
114// Set pointer to digits with corresponding segmentations and responses (one cathode plane)
115
116 fChamber = chamber;
117 fDetElemId = idDE;
118 fDigits[0] = dig;
119
120 AliMUON *pMUON;
121 AliMUONChamber* iChamber;
122
123 pMUON = (AliMUON*) gAlice->GetModule("MUON");
124 iChamber = &(pMUON->Chamber(chamber));
fed772f3 125
a713db22 126 fSegmentation2[0]=iChamber->SegmentationModel2(1);
127
9825400f 128 fNseg=1;
129}
130
131void AliMUONClusterInput::SetCluster(AliMUONRawCluster* cluster)
132{
133// Set the current cluster
b137f8b9 134 //PH printf("\n %p \n", cluster);
135 fCluster=cluster;
136 Float_t qtot;
137 Int_t i, cath, ix, iy;
138 AliMUONDigit* digit;
139 fNmul[0]=cluster->GetMultiplicity(0);
140 fNmul[1]=cluster->GetMultiplicity(1);
141 //PH printf("\n %p %p ", fDigits[0], fDigits[1]);
142
143 for (cath=0; cath<2; cath++) {
144 qtot=0;
145 for (i=0; i<fNmul[cath]; i++) {
146 // pointer to digit
147 digit =(AliMUONDigit*)
0164904a 148 (fDigits[cath]->UncheckedAt(cluster->GetIndex(i,cath)));
9825400f 149 // pad coordinates
08a636a8 150 ix = digit->PadX();
151 iy = digit->PadY();
9825400f 152 // pad charge
08a636a8 153 fCharge[i][cath] = digit->Signal();
9825400f 154 // pad centre coordinates
155// fSegmentation[cath]->GetPadCxy(ix, iy, x, y);
156 // globals kUsed in fitting functions
157 fix[i][cath]=ix;
158 fiy[i][cath]=iy;
159 // total charge per cluster
160 qtot+=fCharge[i][cath];
e357fc46 161 // Current z
162 Float_t xc, yc;
002920d1 163 fSegmentation2[cath]->GetPadC(fDetElemId,ix,iy,xc,yc,fZ);
9825400f 164 } // loop over cluster digits
165 fQtot[cath]=qtot;
166 fChargeTot[cath]=Int_t(qtot);
167 } // loop over cathodes
168}
169
170
171
172Float_t AliMUONClusterInput::DiscrChargeS1(Int_t i,Double_t *par)
173{
a1b02be9 174// Compute the charge on first cathod only.
175return DiscrChargeCombiS1(i,par,0);
9825400f 176}
177
178Float_t AliMUONClusterInput::DiscrChargeCombiS1(Int_t i,Double_t *par, Int_t cath)
179{
180// par[0] x-position of cluster
181// par[1] y-position of cluster
182
a713db22 183 Float_t q1;
002920d1 184 fSegmentation2[cath]->SetPad(fDetElemId, fix[i][cath], fiy[i][cath]);
185 // First Cluster
186 fSegmentation2[cath]->SetHit(fDetElemId, par[0],par[1],fZ);
187 q1 = fgMathieson->IntXY(fDetElemId, fSegmentation2[cath]);
188
9825400f 189 Float_t value = fQtot[cath]*q1;
190 return value;
191}
192
193
194Float_t AliMUONClusterInput::DiscrChargeS2(Int_t i,Double_t *par)
195{
196// par[0] x-position of first cluster
197// par[1] y-position of first cluster
198// par[2] x-position of second cluster
199// par[3] y-position of second cluster
200// par[4] charge fraction of first cluster
201// 1-par[4] charge fraction of second cluster
202
a713db22 203 Float_t q1, q2;
204
002920d1 205 fSegmentation2[0]->SetPad(fDetElemId, fix[i][0], fiy[i][0]);
206 // First Cluster
207 fSegmentation2[0]->SetHit(fDetElemId, par[0],par[1],fZ);
208 q1 = fgMathieson->IntXY(fDetElemId, fSegmentation2[0]);
209
210 // Second Cluster
211 fSegmentation2[0]->SetHit(fDetElemId,par[2],par[3],fZ);
212 q2 = fgMathieson->IntXY(fDetElemId, fSegmentation2[0]);
213
a713db22 214 Float_t value = fQtot[0]*(par[4]*q1+(1.-par[4])*q2);
215 return value;
9825400f 216}
217
218Float_t AliMUONClusterInput::DiscrChargeCombiS2(Int_t i,Double_t *par, Int_t cath)
219{
220// par[0] x-position of first cluster
221// par[1] y-position of first cluster
222// par[2] x-position of second cluster
223// par[3] y-position of second cluster
a1b02be9 224// par[4] charge fraction of first cluster - first cathode
225// 1-par[4] charge fraction of second cluster
226// par[5] charge fraction of first cluster - second cathode
9825400f 227
a713db22 228 Float_t q1, q2;
229
002920d1 230 fSegmentation2[cath]->SetPad(fDetElemId,fix[i][cath], fiy[i][cath]);
231 // First Cluster
232 fSegmentation2[cath]->SetHit(fDetElemId,par[0],par[1],fZ);
233 q1 = fgMathieson->IntXY(fDetElemId, fSegmentation2[cath]);
234
235 // Second Cluster
236 fSegmentation2[cath]->SetHit(fDetElemId,par[2],par[3],fZ);
237 q2 = fgMathieson->IntXY(fDetElemId, fSegmentation2[cath]);
238
a713db22 239 Float_t value;
240 if (cath==0) {
241 value = fQtot[0]*(par[4]*q1+(1.-par[4])*q2);
242 } else {
243 value = fQtot[1]*(par[5]*q1+(1.-par[5])*q2);
244 }
245 return value;
9825400f 246}
247
6a9bc541 248AliMUONClusterInput& AliMUONClusterInput
30178c30 249::operator = (const AliMUONClusterInput& rhs)
6a9bc541 250{
30178c30 251// Protected assignement operator
252
253 if (this == &rhs) return *this;
254
8c343c7c 255 AliFatal("Not implemented.");
30178c30 256
257 return *this;
6a9bc541 258}