Changes to compile with Root6
[u/mrichter/AliRoot.git] / ITS / UPGRADE / AliITSUSuze02.cxx
CommitLineData
5e2539d9 1#include <Riostream.h>
e417d616
IB
2#include "TMath.h"
3#include "AliITSUSuze02.h"
4
5//*******************************************************************
6//
7// Simulation of the SUZE02 readout
8// Origin: Serhiy.Senuykov@cern.ch
9//
10//*******************************************************************
11
5e2539d9 12using std::cout;
13using std::endl;
14
e417d616
IB
15ClassImp(AliITSUSuze02)
16
64c3da7b 17AliITSUSuze02::AliITSUSuze02(Int_t Nrows, Int_t Ncols):
852af72e 18 fNRowsChip(Nrows),
19 fNColsChip(Ncols),
20 fChip(new TMatrixF(Nrows,Ncols)),
64c3da7b 21 fTestColumnSize(2),
22 fTestRowSize(2),
23 fNWindowsPer32colsMax(0),
24 fNWindowsPerHalfFSBBMax(0),
25 fNWindowsPerFSBBMax(0),
26 fNDigitsEncoded(0),
27 fNEncodedWindows(0),
28 fNDigitsLost(0),
29 fNLostWindows(0),
852af72e 30 fDataSizePerChip(0),
64c3da7b 31 fNWindowsPer32colsMin(0),
32 fNWindowsPerHalfFSBBMin(0),
33 fNWindowsPerFSBBMin(0)
34{
35 if (Ncols%(kNumberOfFSBB*kNumberOfHalfFSBB) != 0) {
e417d616
IB
36 printf("Number of columns should be multiple of %d. SUZE matrix wasn't created\n",kNumberOfFSBB*kNumberOfHalfFSBB);
37 }
38}
39
64c3da7b 40AliITSUSuze02::AliITSUSuze02(const AliITSUSuze02& suze):
852af72e 41 fNRowsChip(suze.fNRowsChip),
42 fNColsChip(suze.fNColsChip),
43 fChip(new TMatrixF(*suze.fChip)),
64c3da7b 44 fTestColumnSize(suze.fTestColumnSize),
45 fTestRowSize(suze.fTestRowSize),
46 fNWindowsPer32colsMax(suze.fNWindowsPer32colsMax),
47 fNWindowsPerHalfFSBBMax(suze.fNWindowsPerHalfFSBBMax),
48 fNWindowsPerFSBBMax(suze.fNWindowsPerFSBBMax),
49 fNDigitsEncoded(suze.fNDigitsEncoded),
50 fNEncodedWindows(suze.fNEncodedWindows),
51 fNDigitsLost(suze.fNDigitsLost),
52 fNLostWindows(suze.fNLostWindows),
852af72e 53 fDataSizePerChip(suze.fDataSizePerChip),
64c3da7b 54 fNWindowsPer32colsMin(suze.fNWindowsPer32colsMin),
55 fNWindowsPerHalfFSBBMin(suze.fNWindowsPerHalfFSBBMin),
56 fNWindowsPerFSBBMin(suze.fNWindowsPerFSBBMin)
57{
58}
59
60AliITSUSuze02 &AliITSUSuze02::operator=(const AliITSUSuze02& suze) {
61 if (&suze == this) return *this;
62
852af72e 63 fNRowsChip = suze.fNRowsChip;
64 fNColsChip = suze.fNColsChip;
65 fChip = new TMatrixF(*suze.fChip);
64c3da7b 66 fTestColumnSize = suze.fTestColumnSize;
67 fTestRowSize = suze.fTestRowSize;
68 fNWindowsPer32colsMax = suze.fNWindowsPer32colsMax;
69 fNWindowsPerHalfFSBBMax = suze.fNWindowsPerHalfFSBBMax;
70 fNWindowsPerFSBBMax = suze.fNWindowsPerFSBBMax;
71 fNDigitsEncoded = suze.fNDigitsEncoded;
72 fNEncodedWindows = suze.fNEncodedWindows;
73 fNDigitsLost = suze.fNDigitsLost;
74 fNLostWindows = suze.fNLostWindows;
852af72e 75 fDataSizePerChip = suze.fDataSizePerChip;
64c3da7b 76 fNWindowsPer32colsMin = suze.fNWindowsPer32colsMin;
77 fNWindowsPerHalfFSBBMin = suze.fNWindowsPerHalfFSBBMin;
78 fNWindowsPerFSBBMin = suze.fNWindowsPerFSBBMin;
79
80 return *this;
81}
82
e417d616 83AliITSUSuze02::~AliITSUSuze02() {
852af72e 84 if(fChip) delete fChip;
e417d616
IB
85}
86
87void AliITSUSuze02::SetEncodingWindowSize(Int_t Wrows, Int_t Wcols){
88 fTestColumnSize=Wrows;
89 fTestRowSize=Wcols;
90}
91
92void AliITSUSuze02::SetQuotas(Int_t q32, Int_t qHalfFSBB, Int_t qFSBB){
93 fNWindowsPer32colsMax=q32;
94 fNWindowsPerHalfFSBBMax=qHalfFSBB;
95 fNWindowsPerFSBBMax=qFSBB;
96}
97
98void AliITSUSuze02::AddDigit(Int_t row, Int_t col){
852af72e 99 (*fChip)(row,col)++;
e417d616
IB
100}
101
102//void AliITSUSuze02::Process(Bool_t Verbose){
103void AliITSUSuze02::Process(TH1F* OverflowCodes, TH1F* NDigitsPerEncodingWindowDist, Bool_t Verbose) {
104
105 //cout<<"Processing"<<endl;
852af72e 106 //fChip->Print();
e417d616 107
852af72e 108 Int_t NRowsFSBB=fNRowsChip;
109 Int_t NColsFSBB=fNColsChip/kNumberOfFSBB;
e417d616
IB
110 TMatrixF FSBB(NRowsFSBB,NColsFSBB);
111
112 Int_t NRowsSuperLine=fTestColumnSize;
113 Int_t NColsSuperLine=NColsFSBB;
114 TMatrixF SuperLineUp(NRowsSuperLine,NColsSuperLine);
115 TMatrixF SuperLineDown(NRowsSuperLine,NColsSuperLine);
116
117 Int_t NRowsSuperLineX2=NRowsSuperLine*2;
118 Int_t NColsSuperLineX2=NColsSuperLine; //SuperLineX2 and SuperLine size in columns is equal to FSBB.
119 TMatrixF SuperLineX2(NRowsSuperLineX2,NColsSuperLineX2);
120
121 TMatrixF TestRow(1,fTestRowSize);
122 TMatrixF TestColumn(fTestColumnSize,1);
123 Int_t TestRowSum=0;
124 TMatrixF EncodingWindow(fTestColumnSize,fTestRowSize);
125
126 Int_t EncodingWindowStartRow=0;
127 Int_t EncodingWindowStopRow=0;
128 Int_t EncodingWindowStartCol=0;
129 Int_t EncodingWindowStopCol=0;
130
131 Int_t nMasks=fTestRowSize-1;
132 Int_t MaskSize=NRowsSuperLineX2-1;
133 TMatrixF Masks(MaskSize,nMasks);
134
135 //parameters for internal data size calculation
136 Int_t DataSizePerWindowInRow=8+fTestColumnSize*fTestRowSize+TMath::Ceil(TMath::Log2(fTestColumnSize));
137 Int_t DataSizePerSuperLineX2Header=30;
138
139 Int_t DataSizePerSuperLineX2=0;
140
141 Bool_t Overflow32=kFALSE;
142 Bool_t OverflowHalfFSBB=kFALSE;
143 Bool_t OverflowFSBB=kFALSE;
144
145 Int_t nWindowsPer32cols=fNWindowsPer32colsMax;
146 Int_t nWindowsPerHalfFSBB=fNWindowsPerHalfFSBBMax;
147 Int_t nWindowsPerFSBB=fNWindowsPerFSBBMax;
148
149 fNWindowsPer32colsMin=fNWindowsPer32colsMax;
150 fNWindowsPerHalfFSBBMin=fNWindowsPerHalfFSBBMax;
151 fNWindowsPerFSBBMin=fNWindowsPerFSBBMax;
152
153 fNEncodedWindows=0;
154 fNDigitsEncoded=0;
155 fNLostWindows=0;
156 fNDigitsLost=0;
852af72e 157 fDataSizePerChip=0;
e417d616
IB
158
159 for(Int_t FSBBindex=0; FSBBindex<kNumberOfFSBB; FSBBindex++){
852af72e 160 FSBB=fChip->GetSub(0,NRowsFSBB-1,FSBBindex*NColsFSBB,(FSBBindex+1)*NColsFSBB-1);
e417d616
IB
161 SuperLineDown=FSBB.GetSub(0,NRowsSuperLine-1,0,NColsSuperLine-1);
162 for(Int_t SuperLineX2StartRow=0; SuperLineX2StartRow<NRowsFSBB; SuperLineX2StartRow+=NRowsSuperLine){
163 if(nWindowsPerFSBB<fNWindowsPerFSBBMin) {fNWindowsPerFSBBMin=nWindowsPerFSBB;} //saving the lowest number of remaining windows
164 nWindowsPerFSBB=fNWindowsPerFSBBMax; //Reset number of available encoding windows for the new double SuperLine
165 OverflowFSBB=kFALSE;
166 SuperLineUp=SuperLineDown;
167 if(SuperLineX2StartRow+NRowsSuperLineX2<=NRowsFSBB){
168 SuperLineDown=FSBB.GetSub(SuperLineX2StartRow+NRowsSuperLine,SuperLineX2StartRow+NRowsSuperLineX2-1,0,NColsSuperLine-1);
169 }
170 else if(SuperLineX2StartRow+NRowsSuperLine<NRowsFSBB){
171 SuperLineDown.Zero();
172 SuperLineDown.SetSub(0,0,FSBB.GetSub(SuperLineX2StartRow+NRowsSuperLine,NRowsFSBB-1,0,NColsSuperLine-1));
173 }
174 else{
175 SuperLineDown.Zero();
176 }
177 if(SuperLineUp.Sum()>0){
178 DataSizePerSuperLineX2=0;
179 SuperLineX2.SetSub(0,0,SuperLineUp);
180 SuperLineX2.SetSub(NRowsSuperLine,0,SuperLineDown);
181 for(Int_t HalfFSBBindex=0; HalfFSBBindex<kNumberOfHalfFSBB; HalfFSBBindex++){
182 if(nWindowsPerHalfFSBB<fNWindowsPerHalfFSBBMin) {fNWindowsPerHalfFSBBMin=nWindowsPerHalfFSBB;}
183 nWindowsPerHalfFSBB=fNWindowsPerHalfFSBBMax; //reset counter per HalfFSBB
184 OverflowHalfFSBB=kFALSE;
185 for(Int_t i=0; i<MaskSize; i++){ //reset masks to 1111111
186 for(Int_t j=0; j<nMasks; j++){
187 Masks(i,j)=1;
188 }
189 }
190
191 for(Int_t TestRowStartCol=HalfFSBBindex*NColsSuperLineX2/kNumberOfHalfFSBB; TestRowStartCol<(HalfFSBBindex+1)*NColsSuperLineX2/kNumberOfHalfFSBB; TestRowStartCol++){
192 if(TestRowStartCol%32==0){
193 if(nWindowsPer32cols<fNWindowsPer32colsMin) fNWindowsPer32colsMin=nWindowsPer32cols;
194 nWindowsPer32cols=fNWindowsPer32colsMax; //reset nWindowsPer32cols counter every 32 columns
195 Overflow32=kFALSE;
196 }
197 //apply masks
198 for(Int_t RowIndex=0; RowIndex<MaskSize; RowIndex++){
199 for(Int_t MaskIndex=0; MaskIndex<nMasks; MaskIndex++){
200 if(Masks(RowIndex,MaskIndex)==0){
201 // cout<<"Mask has zero bit at pos:"<<RowIndex<<":"<<MaskIndex<<endl;
202 // cout<<"will clean the pixels at row:"<<RowIndex<<" from pos.:"<<TestRowStartCol<<" till "<< TestRowStartCol+(nMasks-MaskIndex)<<endl;
203 for(Int_t ColIndex=TestRowStartCol; ColIndex<TestRowStartCol+(nMasks-MaskIndex); ColIndex++){
204 if(ColIndex<(HalfFSBBindex+1)*NColsSuperLineX2/kNumberOfHalfFSBB){
205 SuperLineX2(RowIndex,ColIndex)=0;
206 // cout<<"Mask has zero bit. Cleaning at pos:"<<RowIndex<<":"<<ColIndex<<endl;
207 if(RowIndex>=fTestColumnSize){
208 SuperLineDown(RowIndex-fTestColumnSize,ColIndex)=0;
209 }
210 }
211 }
212 break;
213 }
214 }
215 }
216 //shift masks
217 for(Int_t RowIndex=0; RowIndex<MaskSize; RowIndex++){
218 for(Int_t MaskIndex=nMasks-1; MaskIndex>0; MaskIndex--){
219 Masks(RowIndex,MaskIndex)=Masks(RowIndex,MaskIndex-1);
220 }
221 Masks(RowIndex,0)=1;
222 }
223
224 for(Int_t TestRowStartRow=0; TestRowStartRow<fTestColumnSize; TestRowStartRow++){
225 TestRowSum=0;
226 for(Int_t TestRowIndex=0; TestRowIndex<fTestRowSize; TestRowIndex++){
227 if(TestRowStartCol+TestRowIndex<(HalfFSBBindex+1)*NColsSuperLineX2/kNumberOfHalfFSBB){
228 TestRowSum+=SuperLineX2(TestRowStartRow,TestRowStartCol+TestRowIndex);
229 }
230 if(TestRowSum>0){
231 //cout<<"TestR at col n."<<TestRowStartCol<<" and row n."<<TestRowStartRow<<" has a hit"<<endl;
232 break;
233 }
234 }
235 if(TestRowSum>0){
236 TestColumn=SuperLineX2.GetSub(TestRowStartRow,TestRowStartRow+fTestColumnSize-1,TestRowStartCol,TestRowStartCol);
237 if(TestColumn.Sum()>0){
238 EncodingWindowStartRow=TestRowStartRow;
239 EncodingWindowStopRow=EncodingWindowStartRow+fTestColumnSize-1;
240 EncodingWindowStartCol=TestRowStartCol;
241
242 if(TestRowStartCol+fTestRowSize>(HalfFSBBindex+1)*NColsSuperLineX2/kNumberOfHalfFSBB){
243 EncodingWindowStopCol=((HalfFSBBindex+1)*NColsSuperLineX2/kNumberOfHalfFSBB)-1;
244 }
245 else{
246 EncodingWindowStopCol=EncodingWindowStartCol+fTestRowSize-1;
247 }
248
249 EncodingWindow.Zero();
250 EncodingWindow.SetSub(0,0,SuperLineX2.GetSub(EncodingWindowStartRow,EncodingWindowStopRow,EncodingWindowStartCol,EncodingWindowStopCol));
251
252 if(nWindowsPer32cols && nWindowsPerHalfFSBB && nWindowsPerFSBB){
253 //cout<<"Will encode window starting at "<<TestRowStartRow<<":"<<TestRowStartCol<<endl;
254 fNDigitsEncoded+=EncodingWindow.Sum();
255 fNEncodedWindows++;
256 OverflowCodes->Fill(0);
257 NDigitsPerEncodingWindowDist->Fill(EncodingWindow.Sum());
258 nWindowsPerFSBB--;
259 nWindowsPerHalfFSBB--;
260 nWindowsPer32cols--;
261 DataSizePerSuperLineX2+=DataSizePerWindowInRow;
262 //cout<<"Windows left:"<<nWindowsPerFSBB<<":"<<nWindowsPerHalfFSBB<<":"<<nWindowsPer32cols<<endl;
263 }
264 else{
265 fNDigitsLost+=EncodingWindow.Sum();
266 fNLostWindows++;
267 //cout<<"------ No encoding at col.:"<<TestRowStartCol<<" at SuperLineX2 that starts at row:"<<SuperLineX2StartRow<<endl;
268 if(!nWindowsPer32cols) Overflow32=kTRUE;
269 if(!nWindowsPerHalfFSBB) OverflowHalfFSBB=kTRUE;
270 if(!nWindowsPerFSBB) OverflowFSBB=kTRUE;
271 OverflowCodes->Fill(Overflow32+2*OverflowHalfFSBB+4*OverflowFSBB);
272 }
273 for(Int_t k=TestRowStartRow;k<TestRowStartRow+fTestColumnSize; k++){
274 Masks(k,0)=0;
275 //cout<<"Setting Mask to 0 at "<<k<<endl;
276 //Setting to 0 the first column of the encoding window. This part if probably present in the real SUZE.
277 SuperLineX2(k,TestRowStartCol)=0;
278 if(k>=fTestColumnSize){
279 SuperLineDown(k-fTestColumnSize,TestRowStartCol)=0;
280 }
281 }
282 }
283 break;
284 }
285 }
286 }
287 }
852af72e 288 fDataSizePerChip+=(DataSizePerSuperLineX2+DataSizePerSuperLineX2Header);
e417d616
IB
289 }
290 }
291 }
292 if(Verbose){
293 cout<<fNDigitsEncoded<<" digits encoded in "<<fNEncodedWindows<<" windows"<<endl;
294 cout<<fNDigitsLost<<" digits lost in "<<fNLostWindows<<" windows"<<endl;
295 }
296}
297
298void AliITSUSuze02::GetResults(){
299
300}
301/*
302void AliITSUSuze02::InitHistos(){
303 fOverflowCodes = new TH1F("OverflowCodes","Overflow codes",8,0,8);
852af72e 304 if(fNRowsChip*fNColsChip){
305 fNDigitsPerEncodingWindowDist = new TH1F("nDigitsPerEncodingWindowPerChip","nDigitsPerEncodingWindowPerChip",fTestColumnSize*fTestRowSize,1,fTestColumnSize*fTestRowSize+1);
e417d616
IB
306 }
307 else{
308 printf("Run AliITSUSuze02::SetEncodingWindowSize first\n");
309 }
310}
311*/
852af72e 312void AliITSUSuze02::ResetChip(){
313 fChip->Zero();
e417d616 314}