a1dcd98df427c20aa6b8ec5124740b648f0ce478
[u/mrichter/AliRoot.git] / ITS / AliITSOnlineSPDphysAnalyzer.cxx
1 /**************************************************************************
2  * Copyright(c) 2007-2009, 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
16 ////////////////////////////////////////////////////////////
17 // Author: Henrik Tydesjo                                 //
18 // This class is used in the detector algorithm framework //
19 // to process the data stored in special container files  //
20 // (see AliITSOnlineSPDphys).                             //
21 ////////////////////////////////////////////////////////////
22
23 #include "AliITSOnlineSPDphysAnalyzer.h"
24 #include "AliITSOnlineSPDphys.h"
25 #include "AliITSOnlineCalibrationSPDhandler.h"
26 #include "AliITSRawStreamSPD.h"
27 #include "AliITSIntMap.h"
28 #include <TStyle.h>
29 #include <TMath.h>
30 #include <TF1.h>
31 #include <TGraph.h>
32 #include <TH2F.h>
33 #include <TError.h>
34 #include <iostream>
35 #include <fstream>
36
37 AliITSOnlineSPDphysAnalyzer::AliITSOnlineSPDphysAnalyzer(const Char_t *fileName, AliITSOnlineCalibrationSPDhandler* handler) :
38   fFileName(fileName),fPhysObj(NULL),fHandler(handler),
39   fNrEnoughStatChips(0),fNrDeadChips(0),fNrInefficientChips(0),
40   fNrEqHits(0),fbDeadProcessed(kFALSE),
41   fThreshNoisy(1),fThreshNoisyExp(-12),fThreshDead(1),fThreshDeadExp(-12),
42   fMinEventsForNoisy(10000),fMinEventsForDead(10000),
43   fDefinitelyNoisyRatio(0.1),
44   fMinNrEqHitsForDeadChips(60000),fRatioToMeanForInefficientChip(0.1)//!!!
45 {
46   // constructor  
47   Init();
48 }
49
50 AliITSOnlineSPDphysAnalyzer::AliITSOnlineSPDphysAnalyzer(AliITSOnlineSPDphys* physObj, AliITSOnlineCalibrationSPDhandler* handler) :
51   fFileName("test.root"),fPhysObj(NULL),fHandler(handler),
52   fNrEnoughStatChips(0),fNrDeadChips(0),fNrInefficientChips(0),
53   fNrEqHits(0),fbDeadProcessed(kFALSE),
54   fThreshNoisy(1),fThreshNoisyExp(-12),fThreshDead(1),fThreshDeadExp(-12),
55   fMinEventsForNoisy(10000),fMinEventsForDead(10000),
56   fDefinitelyNoisyRatio(0.1),
57   fMinNrEqHitsForDeadChips(60000),fRatioToMeanForInefficientChip(0.1)//!!!
58 {
59   // alt constructor
60   fPhysObj = physObj;
61 }
62
63 AliITSOnlineSPDphysAnalyzer::AliITSOnlineSPDphysAnalyzer(const AliITSOnlineSPDphysAnalyzer& handle) :
64   fFileName("test.root"),fPhysObj(NULL),fHandler(NULL),
65   fNrEnoughStatChips(0),fNrDeadChips(0),fNrInefficientChips(0),
66   fNrEqHits(0),fbDeadProcessed(kFALSE),
67   fThreshNoisy(1),fThreshNoisyExp(-12),fThreshDead(1),fThreshDeadExp(-12),
68   fMinEventsForNoisy(10000),fMinEventsForDead(10000),
69   fDefinitelyNoisyRatio(0.1),
70   fMinNrEqHitsForDeadChips(60000),fRatioToMeanForInefficientChip(0.1)//!!!
71 {
72   // copy constructor, only copies the filename and params (not the processed data)
73   fFileName=handle.fFileName;
74   fThreshNoisy = handle.fThreshNoisy;
75   fThreshNoisyExp = handle.fThreshNoisyExp;
76   fThreshDead = handle.fThreshDead;
77   fThreshDeadExp = handle.fThreshDeadExp;
78   fMinEventsForNoisy = handle.fMinEventsForNoisy;
79   fMinEventsForDead = handle.fMinEventsForDead;
80   fDefinitelyNoisyRatio = handle.fDefinitelyNoisyRatio;
81   fMinNrEqHitsForDeadChips = handle.fMinNrEqHitsForDeadChips;
82   fRatioToMeanForInefficientChip = handle.fRatioToMeanForInefficientChip;
83
84   Init();
85 }
86
87 AliITSOnlineSPDphysAnalyzer::~AliITSOnlineSPDphysAnalyzer() {
88   // destructor
89   if (fPhysObj!=NULL) delete fPhysObj;
90 }
91
92 AliITSOnlineSPDphysAnalyzer& AliITSOnlineSPDphysAnalyzer::operator=(const AliITSOnlineSPDphysAnalyzer& handle) {
93   // assignment operator, only copies the filename and params (not the processed data)
94   if (this!=&handle) {
95     if (fPhysObj!=NULL) delete fPhysObj;
96     
97     fFileName=handle.fFileName;
98     fThreshNoisy = handle.fThreshNoisy;
99     fThreshNoisyExp = handle.fThreshNoisyExp;
100     fThreshDead = handle.fThreshDead;
101     fThreshDeadExp = handle.fThreshDeadExp;
102     fMinEventsForNoisy = handle.fMinEventsForNoisy;
103     fMinEventsForDead = handle.fMinEventsForDead;
104     fDefinitelyNoisyRatio = handle.fDefinitelyNoisyRatio;
105     fMinNrEqHitsForDeadChips = handle.fMinNrEqHitsForDeadChips;
106     fRatioToMeanForInefficientChip = handle.fRatioToMeanForInefficientChip;
107
108     fPhysObj = NULL;
109     fHandler = NULL;
110     fNrEnoughStatChips = 0;
111     fNrDeadChips = 0;
112     fNrInefficientChips = 0;
113     fNrEqHits = 0;
114     fbDeadProcessed = kFALSE;
115
116     Init();    
117   }
118   return *this;
119 }
120
121 void AliITSOnlineSPDphysAnalyzer::Init() {
122   // initialize container obj
123   FILE* fp0 = fopen(fFileName.Data(), "r");
124   if (fp0 == NULL) {
125     return;
126   }
127   else {
128     fclose(fp0);
129   }
130   fPhysObj = new AliITSOnlineSPDphys(fFileName.Data());
131 }
132
133 void AliITSOnlineSPDphysAnalyzer::SetParam(const Char_t *pname, const Char_t *pval) {
134   // set a parameter
135   TString name = pname;
136   TString val = pval;
137   //  printf("Setting Param %s  to %s\n",name.Data(),val.Data());
138   if (name.CompareTo("MistakeProbabilityNoisy")==0) {
139     Double_t mistakeProbabilityNoisy = val.Atof();
140     fThreshNoisy = mistakeProbabilityNoisy;
141     fThreshNoisyExp = 0;
142     Exponent(fThreshNoisy,fThreshNoisyExp);
143     fThreshNoisy/=(20*6*10*32*256);
144     Exponent(fThreshNoisy,fThreshNoisyExp);
145   }
146   else if (name.CompareTo("MistakeProbabilityDead")==0) {
147     Double_t mistakeProbabilityDead = val.Atof();
148     fThreshDead = mistakeProbabilityDead;
149     fThreshDeadExp = 0;
150     Exponent(fThreshDead,fThreshDeadExp);
151     fThreshDead/=(20*6*10*32*256);
152     Exponent(fThreshDead,fThreshDeadExp);
153   }
154   else if (name.CompareTo("fMinEventsForNoisy")==0) {
155     fMinEventsForNoisy = val.Atoi();
156   }
157   else if (name.CompareTo("fMinEventsForDead")==0) {
158     fMinEventsForDead = val.Atoi();
159   }
160   else if (name.CompareTo("fDefinitelyNoisyRatio")==0) {
161     fDefinitelyNoisyRatio = val.Atof();
162   }
163   else if (name.CompareTo("fMinNrEqHitsForDeadChips")==0) {
164     fMinNrEqHitsForDeadChips = val.Atof();
165   }
166   else if (name.CompareTo("fRatioToMeanForInefficientChip")==0) {
167     fRatioToMeanForInefficientChip = val.Atof();
168   }
169   else {
170     Error("AliITSOnlineSPDphysAnalyzer::SetParam","Parameter %s in configuration file unknown.",name.Data());
171   }
172 }
173
174 void AliITSOnlineSPDphysAnalyzer::ReadParamsFromLocation(const Char_t *dirName) {
175   // opens file (default name) in dir dirName and reads parameters from it
176   TString paramsFileName = Form("%s/physics_params.txt",dirName);
177   ifstream paramsFile;
178   paramsFile.open(paramsFileName, ifstream::in);
179   if (paramsFile.fail()) {
180     printf("No config file (%s) present. Using default tuning parameters.\n",paramsFileName.Data());
181   }
182   else {
183     while(1) {
184       Char_t paramN[50];
185       Char_t paramV[50];
186       paramsFile >> paramN;
187       if (paramsFile.eof()) break;
188       paramsFile >> paramV;
189       SetParam(paramN,paramV);
190       if (paramsFile.eof()) break;
191     }
192     paramsFile.close();
193   }
194 }
195
196
197 UInt_t AliITSOnlineSPDphysAnalyzer::ProcessNoisyPixels() {
198   // process noisy pixel data , returns number of chips with enough statistics
199   if (fPhysObj==NULL) {
200     Warning("AliITSOnlineSPDphysAnalyzer::ProcessNoisyPixels","No data!");
201     return 0;
202   }
203   // do we have enough events to even try the algorithm?
204   if (GetNrEvents() < fMinEventsForNoisy) {
205     Warning("AliITSOnlineSPDphysAnalyzer::ProcessNoisyPixels","Nr events (%d) < fMinEventsForNoisy (%d)!",GetNrEvents(),fMinEventsForNoisy);
206     return 0;
207   }
208   // handler should be initialized
209   if (fHandler==NULL) {
210     Error("AliITSOnlineSPDphysAnalyzer::ProcessNoisyPixels","Calibration handler is not initialized!");
211     return 0;
212   }
213   
214   UInt_t nrEnoughStatChips = 0;
215
216   for (UInt_t hs=0; hs<6; hs++) {
217     for (UInt_t chip=0; chip<10; chip++) {
218
219       UInt_t nrPixels = 0;
220       UInt_t nrChipHits = 0;
221       UInt_t nrMostHits = 0;
222       for (UInt_t col=0; col<32; col++) {
223         for (UInt_t row=0; row<256; row++) {
224           UInt_t nrHits = fPhysObj->GetHits(hs,chip,col,row);
225           nrChipHits += nrHits;
226           //      if (nrHits>0) nrPixels++; // don't include pixels that might be dead
227           nrPixels++;
228           if (nrHits>fDefinitelyNoisyRatio*GetNrEvents()) {
229             fHandler->SetNoisyPixel(GetEqNr(),hs,chip,col,row);
230             nrPixels--;
231             nrChipHits-=nrHits;
232           }
233           else {
234             if (nrMostHits<nrHits) nrMostHits=nrHits;
235           }
236         }
237       }
238
239       if (nrChipHits>0) { // otherwise there are for sure no noisy
240         // Binomial with n events and probability p for pixel hit
241         UInt_t n = GetNrEvents();
242         if (nrPixels>0 && n>0) {
243
244           Double_t p = (Double_t)nrChipHits/nrPixels/n;
245
246           Double_t bin = 1;
247           Int_t binExp = 0;
248           // Bin(n,k=0):
249           for (UInt_t i=0; i<n; i++) {
250             bin*=(1-p);
251             Exponent(bin,binExp);
252           }
253           // Bin(n,k)
254           UInt_t k=1;
255           while (((binExp>fThreshNoisyExp || (binExp==fThreshNoisyExp && bin>fThreshNoisy)) || k<n*p) && k<=n) {
256             k++;
257             bin = bin*(n-k+1)/k*p/(1-p);
258             Exponent(bin,binExp);
259           }
260           
261           // can we find noisy pixels...?
262           if (k<=n) {
263             //      printf("eq %d , hs %d , chip %d : Noisy level = %d\n",GetEqNr(),hs,chip,k);
264             nrEnoughStatChips++;
265             // add noisy pixels to handler
266             UInt_t noiseLimit=k;
267             if (nrMostHits>=noiseLimit) {
268               for (UInt_t col=0; col<32; col++) {
269                 for (UInt_t row=0; row<256; row++) {
270                   UInt_t nrHits = fPhysObj->GetHits(hs,chip,col,row);
271                   if (nrHits >= noiseLimit) {
272                     fHandler->SetNoisyPixel(GetEqNr(),hs,chip,col,row);
273                   }
274                 }
275               }
276             }
277           }
278         }
279
280       }
281
282     } // for chip
283   } // for hs
284
285   return nrEnoughStatChips;
286 }
287
288
289 UInt_t AliITSOnlineSPDphysAnalyzer::ProcessDeadPixels() {
290   // process dead pixel data , returns number of chips with enough statistics
291   if (fPhysObj==NULL) {
292     Warning("AliITSOnlineSPDphysAnalyzer::ProcessDeadPixels","No data!");
293     return 0;
294   }
295   // do we have enough events to even try the algorithm?
296   if (GetNrEvents() < fMinEventsForDead) {
297     Warning("AliITSOnlineSPDphysAnalyzer::ProcessDeadPixels","Nr events (%d) < fMinEventsForDead (%d)!",GetNrEvents(),fMinEventsForDead);
298     return 0;
299   }
300   // handler should be initialized
301   if (fHandler==NULL) {
302     Error("AliITSOnlineSPDphysAnalyzer::ProcessDeadPixels","Calibration handler is not initialized!");
303     return 0;
304   }
305
306   AliITSIntMap* possiblyDead  = new AliITSIntMap();
307   AliITSIntMap* possiblyIneff = new AliITSIntMap();
308
309   fNrEnoughStatChips = 0;
310   fNrDeadChips = 0;
311   fNrInefficientChips = 0;
312   UInt_t nrPossiblyDeadChips = 0;
313   fNrEqHits = 0;
314
315
316   AliITSOnlineCalibrationSPDhandler *deadPixelHandler = new AliITSOnlineCalibrationSPDhandler();
317
318   for (UInt_t hs=0; hs<6; hs++) {
319     if (!(fHandler->IsActiveHS(GetEqNr(),hs))) {
320       fNrDeadChips+=10;
321     }
322     else {
323       for (UInt_t chip=0; chip<10; chip++) {
324         if (!(fHandler->IsActiveChip(GetEqNr(),hs,chip))) {
325           fNrDeadChips++;
326         }
327         else {
328           // perform search for individual dead pixels...
329           deadPixelHandler->ResetDead();
330           Bool_t good=kFALSE;
331
332           UInt_t nrPossiblyDeadPixels = 0;
333           UInt_t nrPixels = 0;
334           UInt_t nrChipHits = 0;
335           for (UInt_t col=0; col<32; col++) {
336             for (UInt_t row=0; row<256; row++) {
337               UInt_t nrHits = fPhysObj->GetHits(hs,chip,col,row);
338               nrChipHits += nrHits;
339               if (!fHandler->IsPixelNoisy(GetEqNr(),hs,chip,col,row)) {
340                 // don't include noisy pixels
341                 nrPixels++;
342                 if (nrHits==0) {
343                   nrPossiblyDeadPixels++;
344                   deadPixelHandler->SetDeadPixel(GetEqNr(),hs,chip,col,row);
345                 }
346               }
347               else {
348                 nrChipHits -= nrHits; // this is needed when running offline (online nrHits should be 0 already)
349               }
350             }
351           }
352           fNrEqHits+=nrChipHits;
353
354           // check all pixels that were declared dead from before...
355           UInt_t nrDeadBefore = fHandler->GetNrDeadC(GetEqNr(),hs,chip);
356           AliITSOnlineCalibrationSPDhandler *tmpHand = new AliITSOnlineCalibrationSPDhandler();
357           for (UInt_t index=0; index<nrDeadBefore; index++) {
358             UInt_t col = fHandler->GetDeadColAtC(GetEqNr(),hs,chip,index);
359             UInt_t row = fHandler->GetDeadRowAtC(GetEqNr(),hs,chip,index);
360             if (fPhysObj->GetHits(hs,chip,col,row)>0) {
361               //            fHandler->UnSetDeadPixel(GetEqNr(),hs,chip,col,row); // This was a bug - cannot delete while moving through indices, use tmpHand instead
362               tmpHand->SetDeadPixel(GetEqNr(),hs,chip,col,row);
363             }
364           }
365           UInt_t nrToRemove = tmpHand->GetNrDead();
366           for (UInt_t index=0; index<nrToRemove; index++) {
367             fHandler->UnSetDeadPixel(GetEqNr(),hs,chip,tmpHand->GetDeadColAtC(GetEqNr(),hs,chip,index),tmpHand->GetDeadRowAtC(GetEqNr(),hs,chip,index));
368           }
369           delete tmpHand;
370
371
372
373           if (nrPossiblyDeadPixels==0) {
374             // no need to see if we have enough statistics...
375             fNrEnoughStatChips++;
376             good=kTRUE;
377             //  printf("%3d",good);
378             //  if (chip==9) printf("\n");
379             continue;
380           }
381
382           if (nrChipHits==0) {
383             nrPossiblyDeadChips++;
384             //!!!           deadChipHandler->SetDeadChip(GetEqNr(),hs,chip);
385             possiblyDead->Insert(hs,chip);
386             good=kFALSE;
387             //  printf("%3d",good);
388             //  if (chip==9) printf("\n");
389             continue;
390           }
391
392           // Binomial with n events and probability p for pixel hit
393           UInt_t n = GetNrEvents();
394           if (nrPixels>0 && n>0) {
395
396             Double_t p = (Double_t)nrChipHits/nrPixels/n;
397
398             // probability of falsely assigning a dead pixel
399             Double_t falselyDeadProb = 1;
400             Int_t falselyDeadProbExp = 0;
401             for (UInt_t i=0; i<n; i++) {
402               falselyDeadProb*=(1-p);
403               Exponent(falselyDeadProb,falselyDeadProbExp);
404               // can we find dead pixels...?
405               if (falselyDeadProbExp<fThreshDeadExp || (falselyDeadProbExp==fThreshDeadExp && falselyDeadProb<fThreshDead)) {
406                 fNrEnoughStatChips++;
407                 good=kTRUE;
408                 // add dead pixels to handler
409                 fHandler->AddDeadFrom(deadPixelHandler);
410                 break;
411               }
412             }
413             if (!good) {
414               // this might be an inefficient chip
415               possiblyIneff->Insert(hs*10+chip,nrChipHits);
416             }
417
418           }
419           else {
420             if (n>0) {
421               // this is a completely noisy chip... put in category enough stat
422               fNrEnoughStatChips++;
423               good=kTRUE;
424             }
425           }
426
427           //      printf("%3d",good);
428           //      if (chip==9) printf("\n");
429
430         }
431       } // for chip
432     }
433   } // for hs
434  
435   delete deadPixelHandler;
436
437   Int_t key,val;
438   // dead chips?
439   if (fNrEqHits>fMinNrEqHitsForDeadChips) {
440     while (possiblyDead->Pop(key,val)) {
441       fHandler->ActivateChip(GetEqNr(),key,val,kFALSE);
442     }
443     fNrDeadChips+=nrPossiblyDeadChips;
444   }
445   delete possiblyDead;
446
447   // inefficient chips?
448   while (possiblyIneff->Pop(key,val)) {
449     if (val<fNrEqHits/60*fRatioToMeanForInefficientChip) {
450       fNrInefficientChips++;
451     }
452   }
453   delete possiblyIneff;
454
455
456   fbDeadProcessed = kTRUE;
457
458   return fNrEnoughStatChips;
459 }
460
461
462 UInt_t AliITSOnlineSPDphysAnalyzer::GetNrEnoughStatChips() {
463   // returns nr of enough stat chips
464   if (!fbDeadProcessed) ProcessDeadPixels();
465   return fNrEnoughStatChips;
466 }
467 UInt_t AliITSOnlineSPDphysAnalyzer::GetNrDeadChips() {
468   // returns nr of dead chips
469   if (!fbDeadProcessed) ProcessDeadPixels();
470   return fNrDeadChips;
471 }
472 UInt_t AliITSOnlineSPDphysAnalyzer::GetNrInefficientChips() {
473   // returns nr of inefficient chips
474   if (!fbDeadProcessed) ProcessDeadPixels();
475   return fNrInefficientChips;
476 }
477 UInt_t AliITSOnlineSPDphysAnalyzer::GetNrNeedsMoreStatChips() {
478   // returns nr of needs more stat chips
479   if (!fbDeadProcessed) ProcessDeadPixels();
480   return 60-fNrEnoughStatChips-fNrDeadChips-fNrInefficientChips;
481 }
482
483 UInt_t AliITSOnlineSPDphysAnalyzer::GetEqNr() const {
484   // returns the eq nr of phys obj
485   if (fPhysObj!=NULL) return fPhysObj->GetEqNr(); 
486   else return 999;
487 }
488
489 UInt_t AliITSOnlineSPDphysAnalyzer::GetNrEvents() const {
490   // returns the nr of events of phys obj
491   if (fPhysObj!=NULL) return fPhysObj->GetNrEvents(); 
492   else return 0;
493 }
494
495 void AliITSOnlineSPDphysAnalyzer::Exponent(Double_t &val, Int_t &valExp) const {
496   // put double in format with val and exp so that 1<val<10 - The actual value is val*10e(valExp)
497   while (val>10) {
498     val/=10;
499     valExp++;
500   }
501   while (val<1) {
502     val*=10;
503     valExp--;
504   }
505 }
506
507
508
509 TH2F* AliITSOnlineSPDphysAnalyzer::GetHitMapTot() {
510   // creates and returns a pointer to a hitmap histo (half sector style a la spdmood)
511   if (fPhysObj==NULL) {
512     Error("AliITSOnlineSPDphysAnalyzer::GetHitMapTot","No data!");
513     return NULL;
514   }
515   TString histoname = Form("Eq %d",GetEqNr());
516   TH2F* fHitMapTot = new TH2F(histoname.Data(),histoname.Data(),32*10,-0.5,32*10-0.5,256*6,-0.5,256*6-0.5);
517   fHitMapTot->SetNdivisions(-10,"X");
518   fHitMapTot->SetNdivisions(-006,"Y");
519   fHitMapTot->SetTickLength(0,"X");
520   fHitMapTot->SetTickLength(0,"Y");
521   fHitMapTot->GetXaxis()->SetLabelColor(gStyle->GetCanvasColor());
522   fHitMapTot->GetYaxis()->SetLabelColor(gStyle->GetCanvasColor());
523   for (UInt_t hs=0; hs<6; hs++) {
524     for (UInt_t chipNr=0; chipNr<10; chipNr++) {
525       for (UInt_t col=0; col<32; col++) {
526         for (UInt_t row=0; row<256; row++) {
527           fHitMapTot->Fill(chipNr*32+col,(5-hs)*256+row,fPhysObj->GetHits(hs,chipNr,col,row));
528         }
529       }
530     }
531   }
532   return fHitMapTot;
533 }
534
535 TH2F* AliITSOnlineSPDphysAnalyzer::GetHitMapChip(UInt_t hs, UInt_t chip) {
536   // creates and returns a pointer to a hitmap histo (chip style a la spdmood)
537   if (fPhysObj==NULL) {
538     Error("AliITSOnlineSPDphysAnalyzer::GetHitMapChip","No data!");
539     return NULL;
540   }
541
542   TString histoName;
543   TString histoTitle;
544   histoName = Form("fChipHisto_%d_%d_%d", GetEqNr(), hs, chip);
545   histoTitle = Form("Eq ID %d, Half Stave %d, Chip %d", GetEqNr(), hs, chip);
546
547   TH2F *returnHisto = new TH2F(histoName.Data(), histoTitle.Data(), 32, -0.5, 31.5, 256, -0.5, 255.5);
548   returnHisto->SetMinimum(0);
549   for (UInt_t col=0; col<32; col++) {
550     for (UInt_t row=0; row<256; row++) {
551       returnHisto->Fill(col,row,fPhysObj->GetHits(hs,chip,col,row));
552     }
553   }
554
555   return returnHisto;
556 }