1 /**************************************************************************
2 * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
4 * Author: The ALICE Off-line Project. *
5 * Contributors are mentioned in the code where appropriate. *
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 **************************************************************************/
18 #include "AliMUONClusterInput.h"
21 #include "AliMUONSegmentation.h"
22 #include "AliMUONConstants.h"
23 #include "AliMUONMathieson.h"
24 #include "AliMUONRawCluster.h"
25 #include "AliMUONDigit.h"
30 #include <TClonesArray.h>
33 AliMUONClusterInput* AliMUONClusterInput::fgClusterInput = 0;
34 TMinuit* AliMUONClusterInput::fgMinuit = 0;
35 AliMUONMathieson* AliMUONClusterInput::fgMathieson = 0;
37 ClassImp(AliMUONClusterInput)
39 AliMUONClusterInput::AliMUONClusterInput()
52 AliMUONClusterInput* AliMUONClusterInput::Instance()
54 // return pointer to the singleton instance
55 if (fgClusterInput == 0) {
56 fgClusterInput = new AliMUONClusterInput();
57 fgMinuit = new TMinuit(8);
60 return fgClusterInput;
63 AliMUONClusterInput::~AliMUONClusterInput()
70 AliMUONClusterInput::AliMUONClusterInput(const AliMUONClusterInput& clusterInput):TObject(clusterInput)
72 // Protected copy constructor
74 AliFatal("Not implemented.");
77 void AliMUONClusterInput::SetDigits(Int_t chamber, Int_t idDE, TClonesArray* dig1, TClonesArray* dig2)
79 // Set pointer to digits with corresponding segmentations and responses (two cathode planes)
84 fNDigits[0] = dig1->GetEntriesFast();
85 fNDigits[1] = dig2->GetEntriesFast();
87 fgMathieson = new AliMUONMathieson();
90 AliMUONSegmentation* pSegmentation;
92 pMUON = (AliMUON*) gAlice->GetModule("MUON");
93 pSegmentation = pMUON->GetSegmentation();
94 fSegmentation2[0]= pSegmentation->GetModuleSegmentation(chamber, 0);
95 fSegmentation2[1]= pSegmentation->GetModuleSegmentation(chamber, 1);
98 if (chamber < AliMUONConstants::NTrackingCh()) {
100 fgMathieson->SetPitch(AliMUONConstants::Pitch());
101 fgMathieson->SetSqrtKx3AndDeriveKx2Kx4(AliMUONConstants::SqrtKx3());
102 fgMathieson->SetSqrtKy3AndDeriveKy2Ky4(AliMUONConstants::SqrtKy3());
103 fChargeCorrel = AliMUONConstants::ChargeCorrel();
105 fgMathieson->SetPitch(AliMUONConstants::PitchSt1());
106 fgMathieson->SetSqrtKx3AndDeriveKx2Kx4(AliMUONConstants::SqrtKx3St1());
107 fgMathieson->SetSqrtKy3AndDeriveKy2Ky4(AliMUONConstants::SqrtKy3St1());
108 fChargeCorrel = AliMUONConstants::ChargeCorrelSt1();
113 void AliMUONClusterInput::SetDigits(Int_t chamber, Int_t idDE, TClonesArray* dig)
115 // Set pointer to digits with corresponding segmentations and responses (one cathode plane)
122 AliMUONSegmentation* pSegmentation;
124 pMUON = (AliMUON*) gAlice->GetModule("MUON");
125 pSegmentation = pMUON->GetSegmentation();
126 fSegmentation2[0]= pSegmentation->GetModuleSegmentation(chamber, 0);
131 void AliMUONClusterInput::SetCluster(AliMUONRawCluster* cluster)
133 // Set the current cluster
134 //PH printf("\n %p \n", cluster);
137 Int_t i, cath, ix, iy;
139 fNmul[0]=cluster->GetMultiplicity(0);
140 fNmul[1]=cluster->GetMultiplicity(1);
141 //PH printf("\n %p %p ", fDigits[0], fDigits[1]);
143 for (cath=0; cath<2; cath++) {
145 for (i=0; i<fNmul[cath]; i++) {
147 digit =(AliMUONDigit*)
148 (fDigits[cath]->UncheckedAt(cluster->GetIndex(i,cath)));
153 fCharge[i][cath] = digit->Signal();
154 // pad centre coordinates
155 // fSegmentation[cath]->GetPadCxy(ix, iy, x, y);
156 // globals kUsed in fitting functions
159 // total charge per cluster
160 qtot+=fCharge[i][cath];
163 fSegmentation2[cath]->GetPadC(fDetElemId,ix,iy,xc,yc,fZ);
164 } // loop over cluster digits
166 fChargeTot[cath]=Int_t(qtot);
167 } // loop over cathodes
172 Float_t AliMUONClusterInput::DiscrChargeS1(Int_t i,Double_t *par)
174 // Compute the charge on first cathod only.
175 return DiscrChargeCombiS1(i,par,0);
178 Float_t AliMUONClusterInput::DiscrChargeCombiS1(Int_t i,Double_t *par, Int_t cath)
180 // par[0] x-position of cluster
181 // par[1] y-position of cluster
184 fSegmentation2[cath]->SetPad(fDetElemId, fix[i][cath], fiy[i][cath]);
186 fSegmentation2[cath]->SetHit(fDetElemId, par[0],par[1],fZ);
187 q1 = fgMathieson->IntXY(fDetElemId, fSegmentation2[cath]);
189 Float_t value = fQtot[cath]*q1;
194 Float_t AliMUONClusterInput::DiscrChargeS2(Int_t i,Double_t *par)
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
205 fSegmentation2[0]->SetPad(fDetElemId, fix[i][0], fiy[i][0]);
207 fSegmentation2[0]->SetHit(fDetElemId, par[0],par[1],fZ);
208 q1 = fgMathieson->IntXY(fDetElemId, fSegmentation2[0]);
211 fSegmentation2[0]->SetHit(fDetElemId,par[2],par[3],fZ);
212 q2 = fgMathieson->IntXY(fDetElemId, fSegmentation2[0]);
214 Float_t value = fQtot[0]*(par[4]*q1+(1.-par[4])*q2);
218 Float_t AliMUONClusterInput::DiscrChargeCombiS2(Int_t i,Double_t *par, Int_t cath)
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
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
230 fSegmentation2[cath]->SetPad(fDetElemId,fix[i][cath], fiy[i][cath]);
232 fSegmentation2[cath]->SetHit(fDetElemId,par[0],par[1],fZ);
233 q1 = fgMathieson->IntXY(fDetElemId, fSegmentation2[cath]);
236 fSegmentation2[cath]->SetHit(fDetElemId,par[2],par[3],fZ);
237 q2 = fgMathieson->IntXY(fDetElemId, fSegmentation2[cath]);
241 value = fQtot[0]*(par[4]*q1+(1.-par[4])*q2);
243 value = fQtot[1]*(par[5]*q1+(1.-par[5])*q2);
248 AliMUONClusterInput& AliMUONClusterInput
249 ::operator = (const AliMUONClusterInput& rhs)
251 // Protected assignement operator
253 if (this == &rhs) return *this;
255 AliFatal("Not implemented.");