source: trunk/MagicSoft/Mars/mbadpixels/MBadPixelsCam.cc@ 8256

Last change on this file since 8256 was 8165, checked in by tbretz, 19 years ago
*** empty log message ***
File size: 21.5 KB
Line 
1/* ======================================================================== *\
2!
3! *
4! * This file is part of MARS, the MAGIC Analysis and Reconstruction
5! * Software. It is distributed to you in the hope that it can be a useful
6! * and timesaving tool in analysing Data of imaging Cerenkov telescopes.
7! * It is distributed WITHOUT ANY WARRANTY.
8! *
9! * Permission to use, copy, modify and distribute this software and its
10! * documentation for any purpose is hereby granted without fee,
11! * provided that the above copyright notice appear in all copies and
12! * that both that copyright notice and this permission notice appear
13! * in supporting documentation. It is provided "as is" without express
14! * or implied warranty.
15! *
16!
17!
18! Author(s): Thomas Bretz 1/2004 <mailto:tbretz@astro.uni-wuerzburg.de>
19! Markus Gaug 3/2004 <mailto:markus@ifae.es>
20!
21! Copyright: MAGIC Software Development, 2000-2004
22!
23!
24\* ======================================================================== */
25
26/////////////////////////////////////////////////////////////////////////////
27//
28// MBadPixelsCam
29//
30//
31// Storage container to store bad pixel of the camera...
32//
33/////////////////////////////////////////////////////////////////////////////
34#include "MBadPixelsCam.h"
35
36#include <iostream>
37
38#include <TClonesArray.h>
39
40#include "MLog.h"
41#include "MLogManip.h"
42
43#include "MBadPixelsPix.h"
44
45#include "MGeomCam.h"
46#include "MGeomPix.h"
47
48ClassImp(MBadPixelsCam);
49
50using namespace std;
51
52// --------------------------------------------------------------------------
53//
54// Default constructor.
55//
56MBadPixelsCam::MBadPixelsCam(const char *name, const char *title)
57{
58 fName = name ? name : "MBadPixelsCam";
59 fTitle = title ? title : "Storage container to store bad pixel information";
60
61 fArray = new TClonesArray("MBadPixelsPix", 1);
62}
63
64MBadPixelsCam::MBadPixelsCam(const MBadPixelsCam &cam)
65{
66 fName = "MBadPixelsCam";
67 fTitle = "Storage container to store bad pixel information";
68
69 fArray = new TClonesArray("MBadPixelsPix", 1);
70 cam.Copy(*this);
71}
72
73// --------------------------------------------------------------------------
74//
75// Delete the array conatining the bad pixel information
76//
77MBadPixelsCam::~MBadPixelsCam()
78{
79 delete fArray;
80}
81
82// --------------------------------------------------------------------------
83//
84// Set the size of the camera
85//
86void MBadPixelsCam::InitSize(const UInt_t i)
87{
88 fArray->ExpandCreate(i);
89}
90
91// --------------------------------------------------------------------------
92//
93// Get the size of the MBadPixelsCam
94//
95Int_t MBadPixelsCam::GetSize() const
96{
97 return fArray->GetEntriesFast();
98}
99
100// --------------------------------------------------------------------------
101//
102// Copy 'constructor'
103//
104void MBadPixelsCam::Copy(TObject &object) const
105{
106 MBadPixelsCam &cam = (MBadPixelsCam&)object;
107
108 const Int_t n = GetSize();
109
110 if (n==0)
111 return;
112
113 cam.InitSize(n);
114 for (int i=0; i<n; i++)
115 (*this)[i].Copy(cam[i]);
116}
117
118// --------------------------------------------------------------------------
119//
120// Get i-th pixel (pixel number)
121//
122MBadPixelsPix &MBadPixelsCam::operator[](Int_t i)
123{
124 return *static_cast<MBadPixelsPix*>(fArray->UncheckedAt(i));
125}
126
127// --------------------------------------------------------------------------
128//
129// Get i-th pixel (pixel number)
130//
131const MBadPixelsPix &MBadPixelsCam::operator[](Int_t i) const
132{
133 return *static_cast<MBadPixelsPix*>(fArray->UncheckedAt(i));
134}
135
136// --------------------------------------------------------------------------
137//
138// Merge MBadPixelsCam cam into this, see also MBadPixelsPix::Merge
139//
140void MBadPixelsCam::Merge(const MBadPixelsCam &cam)
141{
142 const Int_t n = cam.GetSize();
143 if (n==0)
144 {
145 *fLog << inf << "MBadPixelsCam::Merge: Container empty." << endl;
146 return;
147 }
148
149 if (GetSize()==0)
150 InitSize(n);
151
152 if (GetSize()<n)
153 {
154 *fLog << warn << "MBadPixelsCam::Merge: Size mismatch (" << n << "," << GetSize() << ")... ignored." << endl;
155 return;
156 }
157
158 for (int i=0; i<n; i++)
159 (*this)[i].Merge(cam[i]);
160}
161
162// --------------------------------------------------------------------------
163//
164// Clear the contents of all bad pixels (set=0 means Ok)
165//
166void MBadPixelsCam::Clear(Option_t *o)
167{
168 fArray->R__FOR_EACH(TObject, Clear)();
169}
170
171// --------------------------------------------------------------------------
172//
173// Reset event depending bits
174//
175void MBadPixelsCam::Reset()
176{
177 fArray->R__FOR_EACH(MParContainer, Reset)();
178}
179
180// --------------------------------------------------------------------------
181//
182// Calculate the number of pixels without the given type-flags.
183//
184// The second argument aidx is the area index (see MGeomCam, MGeomPix)
185// The default (or any value less than 0) means: all
186//
187// Returns -1 if the geometry doesn't match.
188//
189Short_t MBadPixelsCam::GetNumSuitable(MBadPixelsPix::UnsuitableType_t type, const MGeomCam *geom, Int_t aidx) const
190{
191 const UInt_t n = GetSize();
192
193 if (aidx>=0 && (!geom || geom->GetNumPixels()!=n))
194 {
195 *fLog << err << GetDescriptor() << "ERROR - Geometry (" << geom->ClassName() << ") size mismatch!" << endl;
196 return -1;
197 }
198
199 Short_t rc = 0;
200 for (UInt_t i=0; i<n; i++)
201 {
202 if (aidx>=0 && geom && (*geom)[i].GetAidx()!=aidx)
203 continue;
204
205 if (!(*this)[i].IsUnsuitable(type))
206 rc++;
207 }
208 return rc;
209}
210
211// --------------------------------------------------------------------------
212//
213// Calculate the number of pixels with the given type-flags.
214//
215// The second argument aidx is the area index (see MGeomCam, MGeomPix)
216// The default (or any value less than 0) means: all
217//
218// Returns -1 if the geometry doesn't match.
219//
220Short_t MBadPixelsCam::GetNumUnsuitable(MBadPixelsPix::UnsuitableType_t type, const MGeomCam *geom, Int_t aidx) const
221{
222 const UInt_t n = GetSize();
223
224 if (aidx>=0 && geom && geom->GetNumPixels()!=n)
225 {
226 *fLog << err << GetDescriptor() << "ERROR - Geometry (" << geom->ClassName() << ") size mismatch!" << endl;
227 return -1;
228 }
229
230 Short_t rc = 0;
231 for (UInt_t i=0; i<n; i++)
232 {
233 if (aidx>=0 && geom && (*geom)[i].GetAidx()!=aidx)
234 continue;
235
236 if ((*this)[i].IsUnsuitable(type))
237 rc++;
238 }
239 return rc;
240}
241
242// --------------------------------------------------------------------------
243//
244// Count the number of unsuitable pixels.
245//
246Short_t MBadPixelsCam::GetNumUnsuitable() const
247{
248 const UInt_t n = GetSize();
249
250 Short_t rc = 0;
251 for (UInt_t i=0; i<n; i++)
252 if ((*this)[i].IsUnsuitable())
253 rc++;
254
255 return rc;
256}
257
258// --------------------------------------------------------------------------
259//
260// Counts the number of neighbors matching NOT UnsuitableType type
261//
262Short_t MBadPixelsCam::GetNumSuitableNeighbors(MBadPixelsPix::UnsuitableType_t type, const MGeomPix &pix) const
263{
264 const Int_t n2 = pix.GetNumNeighbors();
265
266 Int_t cnt=0;
267 for (int j=0; j<n2; j++)
268 {
269 const Int_t id2 = pix.GetNeighbor(j);
270 if (!(*this)[id2].IsUnsuitable(type))
271 cnt++;
272 }
273
274 return cnt;
275}
276
277// --------------------------------------------------------------------------
278//
279// Calculate the number of pixels which are - under no circumstances -
280// interpolatable, called isolated. This means that a pixel (its own status
281// doesn't matter) has less than two reliable neighbor pixels.
282//
283// The second argument aidx is the area index (see MGeomCam, MGeomPix)
284// The default (or any value less than 0) means: all
285//
286// Returns -1 if the geometry doesn't match.
287//
288Short_t MBadPixelsCam::GetNumIsolated(MBadPixelsPix::UnsuitableType_t type, const MGeomCam &geom, Int_t aidx) const
289{
290 const Int_t n = geom.GetNumPixels();
291
292 if (n!=GetSize())
293 {
294 *fLog << err << GetDescriptor() << "ERROR - Geometry (" << geom.ClassName() << ") size mismatch!" << endl;
295 return -1;
296 }
297
298 Short_t rc = 0;
299 for (int i=0; i<n; i++)
300 {
301 const MGeomPix &pix = geom[i];
302 if (aidx>=0 && pix.GetAidx()!=aidx)
303 continue;
304
305 if (GetNumSuitableNeighbors(type, pix)<2)
306 rc++;
307 }
308 return rc;
309}
310
311// --------------------------------------------------------------------------
312//
313// This is a helper function which calculates the size of a single cluster
314// by iterative calling.
315//
316// If a pixel matches the criterias the counter is increased by 1 and
317// the function is called for all its neighbors. If
318//
319// The second argument aidx is the area index (see MGeomCam, MGeomPix)
320// The default (or any value less than 0) means: all
321//
322// Returns -1 if the geometry doesn't match.
323//
324Short_t MBadPixelsCam::GetNumMaxCluster(MBadPixelsPix::UnsuitableType_t type, TObjArray &list, Int_t idx, Int_t aidx) const
325{
326 const MGeomPix *pix = (MGeomPix*)list[idx];
327 if (!pix)
328 return 0;
329
330 // Check whether more than one neighbor contains useful information,
331 // which mean it can later be interpolated
332 if (GetNumSuitableNeighbors(type, *pix)>1)
333 return 0;
334
335 // If the requested area-index is valid check whether it is the requested one
336 if (aidx>=0 && pix->GetAidx()!=aidx)
337 return 1;
338
339 // Remove the pixel from the list of pixels to be checked
340 list.RemoveAt(idx);
341
342 // Do the same for the neighbor pixels recursively and count the 1-results
343 Short_t cnt = 1;
344 const Int_t n = pix->GetNumNeighbors();
345 for (int i=0; i<n; i++)
346 cnt += GetNumMaxCluster(type, list, pix->GetNeighbor(i), aidx);
347
348 // return the number of neighbor pixels/clusters which have unsuitable-type type
349 return cnt;
350}
351
352// --------------------------------------------------------------------------
353//
354// Returns the size of the biggest cluster with the given UnsuitableType
355// type and the given area index.
356//
357// The second argument aidx is the area index (see MGeomCam, MGeomPix)
358// The default (or any value less than 0) means: all
359//
360// Returns -1 if the geometry doesn't match.
361//
362Short_t MBadPixelsCam::GetNumMaxCluster(MBadPixelsPix::UnsuitableType_t type, const MGeomCam &geom, Int_t aidx) const
363{
364 const Int_t n = geom.GetNumPixels();
365
366 if (n!=GetSize())
367 {
368 *fLog << err << GetDescriptor() << "ERROR - Geometry (" << geom.ClassName() << ") size mismatch!" << endl;
369 return -1;
370 }
371
372 TObjArray list(n);
373 for (int i=0; i<n; i++)
374 list.AddAt(&geom[i], i);
375
376 Short_t max = 0;
377 for (int i=0; i<n; i++)
378 max = TMath::Max(GetNumMaxCluster(type, list, i, aidx), max);
379
380 return max;
381}
382
383// --------------------------------------------------------------------------
384//
385// Print the contents of all bad pixels
386//
387void MBadPixelsCam::Print(Option_t *o) const
388{
389 *fLog << all << GetDescriptor() << ":" << endl;
390 *fLog << "Pixels without problems:" << endl;
391
392 Int_t count = 0;
393 Int_t full = 0;
394
395 for (Int_t i=0; i<GetSize(); i++)
396 {
397 if (!(*this)[i].IsUnsuitable(MBadPixelsPix::kUnsuitableRun))
398 {
399 *fLog << i << " ";
400 full++;
401 count ++;
402 }
403
404 if (count == 0)
405 continue;
406
407 if (!(full % 25))
408 {
409 full = 0;
410 *fLog << endl;
411 }
412 }
413 *fLog << endl;
414 *fLog << count << " normal pixels" << endl;
415 *fLog << endl;
416
417 *fLog << "Pixels unsuited for the whole run:" << endl;
418
419 full = 0;
420 count = 0;
421 for (Int_t i=0; i<GetSize(); i++)
422 {
423 if ((*this)[i].IsUnsuitable(MBadPixelsPix::kUnsuitableRun))
424 {
425 *fLog << i << " ";
426 full++;
427 count ++;
428 }
429
430 if (count == 0)
431 continue;
432
433 if (!(full % 25))
434 {
435 full = 0;
436 *fLog << endl;
437 }
438 }
439
440 *fLog << endl;
441 *fLog << count << " unsuited pixels per run :-(" << endl;
442 *fLog << endl;
443
444 *fLog << "Pixels unsuited for this event:" << endl;
445
446 full = 0;
447 count = 0;
448 for (Int_t i=0; i<GetSize(); i++)
449 {
450 if ((*this)[i].IsUnsuitable(MBadPixelsPix::kUnsuitableEvt))
451 {
452 *fLog << i << " ";
453 full++;
454 count ++;
455 }
456
457 if (count == 0)
458 continue;
459
460 if (!(full % 25))
461 {
462 full = 0;
463 *fLog << endl;
464 }
465 }
466
467 *fLog << endl;
468 *fLog << count << " unsuited pixels per event :-(" << endl;
469 *fLog << endl;
470
471 full = 0;
472 count = 0;
473
474 *fLog << all << "Pixels unreliable for the whole run:" << endl;
475
476 for (Int_t i=0; i<GetSize(); i++)
477 {
478 if ((*this)[i].IsUnsuitable(MBadPixelsPix::kUnreliableRun))
479 {
480 *fLog << i << " ";
481 full++;
482 count ++;
483 }
484
485 if (count == 0)
486 continue;
487
488 if (!(full % 25))
489 {
490 full = 0;
491 *fLog << endl;
492 }
493 }
494
495 *fLog << endl;
496 *fLog << count << " unreliable pixels :-(" << endl;
497 *fLog << endl;
498 *fLog << endl;
499 *fLog << all << "Unsuited pixels statistics:" << endl;
500 *fLog << endl;
501
502 PrintBadPixels(MBadPixelsPix::kPreviouslyExcluded,"Previously excluded");
503 PrintBadPixels(MBadPixelsPix::kChargeIsPedestal,"Signal smaller 3 Pedestal RMS");
504 PrintBadPixels(MBadPixelsPix::kChargeRelErrNotValid,"Signal Rel. error too large");
505 PrintBadPixels(MBadPixelsPix::kLoGainSaturation,"Low Gain Saturation");
506 PrintBadPixels(MBadPixelsPix::kMeanTimeInFirstBin,"Mean Arr. Time In First Extraction Bin");
507 PrintBadPixels(MBadPixelsPix::kMeanTimeInLast2Bins,"Mean Arr. Time In Last 2 Extraction Bins");
508 PrintBadPixels(MBadPixelsPix::kDeviatingNumPhes,"Deviating Number of Photo-electrons");
509 PrintBadPixels(MBadPixelsPix::kDeviatingNumPhots,"Deviating Number of Photons");
510 PrintBadPixels(MBadPixelsPix::kHiGainOverFlow,"High-Gain Histogram Overflow");
511 PrintBadPixels(MBadPixelsPix::kLoGainOverFlow,"Low-Gain Histogram Overflow");
512 PrintBadPixels(MBadPixelsPix::kDeadPedestalRms,"Presumably dead from Ped. Rms");
513 PrintBadPixels(MBadPixelsPix::kFluctuatingArrivalTimes,"Fluctuating Pulse Arrival Times");
514
515 *fLog << endl;
516 *fLog << all << "Unreliable pixels statistics:" << endl;
517 *fLog << endl;
518
519 PrintBadPixels(MBadPixelsPix::kChargeSigmaNotValid,"Signal Sigma smaller Pedestal RMS");
520 PrintBadPixels(MBadPixelsPix::kHiGainNotFitted ,"High Gain Signals could not be fitted");
521 PrintBadPixels(MBadPixelsPix::kLoGainNotFitted ,"Low Gain Signals could not be fitted");
522 PrintBadPixels(MBadPixelsPix::kRelTimeNotFitted ,"Relative Arr. Times could not be fitted");
523 PrintBadPixels(MBadPixelsPix::kHiGainOscillating ,"High Gain Signals Oscillation");
524 PrintBadPixels(MBadPixelsPix::kLoGainOscillating ,"Low Gain Signals Oscillation");
525 PrintBadPixels(MBadPixelsPix::kRelTimeOscillating ,"Relative Arr. Times Oscillation");
526 PrintBadPixels(MBadPixelsPix::kDeviatingFFactor ,"Deviating global F-Factor");
527}
528
529void MBadPixelsCam::PrintBadPixels( MBadPixelsPix::UncalibratedType_t typ, const char *text) const
530{
531 *fLog << "Pixels with " << text << ": " << endl;
532 UInt_t count = 0;
533 UInt_t full = 0;
534
535 for (Int_t i=0; i<GetSize(); i++)
536 {
537 if ((*this)[i].IsUncalibrated(typ))
538 {
539 *fLog << i << " ";
540 full++;
541 count++;
542 }
543
544 if (count == 0)
545 continue;
546
547 if (!(full % 25))
548 {
549 full = 0;
550 *fLog << endl;
551 }
552 }
553
554 *fLog << endl;
555 *fLog << Form("%3i",count) << " pixels in total " << endl;
556}
557
558// --------------------------------------------------------------------------
559//
560// Read from an ascii file of the format:
561// pixel1
562// pixel2
563// pixel3
564// pixel4
565// while pixel1,2,3,4 are the pixel indices used in the software.
566//
567void MBadPixelsCam::AsciiRead(istream &fin)
568{
569 TString str;
570
571 while (1)
572 {
573 str.ReadLine(fin);
574 if (!fin)
575 break;
576
577 if (str[0]=='#')
578 continue;
579
580 const Int_t idx = str.Atoi();
581
582 if (idx>=GetSize())
583 InitSize(idx+1);
584
585 (*this)[idx].SetUnsuitable(MBadPixelsPix::kUnsuitableRun);
586 (*this)[idx].SetUncalibrated(MBadPixelsPix::kPreviouslyExcluded);
587 }
588}
589
590// --------------------------------------------------------------------------
591//
592// Write the information into an ascii file.
593//
594Bool_t MBadPixelsCam::AsciiWrite(ostream &fout) const
595{
596 for (int i=0; i<GetSize(); i++)
597 if ((*this)[i].IsUnsuitable(MBadPixelsPix::kUnsuitableRun))
598 fout << i << endl;
599
600 return kTRUE;
601}
602
603// --------------------------------------------------------------------------
604//
605// The types are the following:
606// 0: MBadPixelsPix::GetInfo()[0]
607// 1: MBadPixelsPix::IsUnsuitable(MBadPixelsPix::kUnsuitableRun)
608// 2: MBadPixelsPix::IsUnsuitable(MBadPixelsPix::kUnsuitableEvt)
609// 3: MBadPixelsPix::IsUnsuitable(MBadPixelsPix::kUnreliableRun)
610// 4: MBadPixelsPix::IsHiGainBad()
611// 5: MBadPixelsPix::IsLoGainBad()
612// 6: MBadPixelsPix::GetUnsuitableCalLevel()
613// 7: MBadPixelsPix::GetUnreliableCalLevel()
614// 8: MBadPixelsPix::IsUncalibrated(MBadPixelsPix::kHiGainNotFitted)
615// 9: MBadPixelsPix::IsUncalibrated(MBadPixelsPix::kLoGainNotFitted)
616// 10: MBadPixelsPix::IsUncalibrated(MBadPixelsPix::kHiGainOscillating)
617// 11: MBadPixelsPix::IsUncalibrated(MBadPixelsPix::kLoGainOscillating)
618// 12: MBadPixelsPix::IsUncalibrated(MBadPixelsPix::kLoGainSaturation )
619// 13: MBadPixelsPix::IsUncalibrated(MBadPixelsPix::kChargeIsPedestal )
620// 14: MBadPixelsPix::IsUncalibrated(MBadPixelsPix::kChargeErrNotValid)
621// 15: MBadPixelsPix::IsUncalibrated(MBadPixelsPix::kChargeRelErrNotValid)
622// 16: MBadPixelsPix::IsUncalibrated(MBadPixelsPix::kChargeSigmaNotValid )
623// 17: MBadPixelsPix::IsUncalibrated(MBadPixelsPix::kMeanTimeInFirstBin )
624// 18: MBadPixelsPix::IsUncalibrated(MBadPixelsPix::kMeanTimeInLast2Bins )
625// 19: MBadPixelsPix::IsUncalibrated(MBadPixelsPix::kDeviatingNumPhes )
626// 20: MBadPixelsPix::IsUncalibrated(MBadPixelsPix::kRelTimeNotFitted )
627// 21: MBadPixelsPix::IsUncalibrated(MBadPixelsPix::kRelTimeOscillating )
628// 22: MBadPixelsPix::IsUncalibrated(MBadPixelsPix::kDeviatingNumPhots )
629// 23: MBadPixelsPix::IsUncalibrated(MBadPixelsPix::kHiGainOverFlow )
630// 24: MBadPixelsPix::IsUncalibrated(MBadPixelsPix::kLoGainOverFlow )
631// 102: MBadPixelsPix::IsUnsuitable()
632//
633Bool_t MBadPixelsCam::GetPixelContent(Double_t &val, Int_t idx, const MGeomCam &cam, Int_t type) const
634{
635
636 if (idx >= GetSize())
637 return kFALSE;
638
639 switch (type)
640 {
641 case 0:
642 return (*this)[idx].GetInfo()[0];
643 case 1:
644 if (!(*this)[idx].IsUnsuitable(MBadPixelsPix::kUnsuitableRun))
645 return kFALSE;
646 val = 1;
647 break;
648 case 2:
649 if (!(*this)[idx].IsUnsuitable(MBadPixelsPix::kUnsuitableEvt))
650 return kFALSE;
651 val = 1;
652 break;
653 case 3:
654 if (!(*this)[idx].IsUnsuitable(MBadPixelsPix::kUnreliableRun))
655 return kFALSE;
656 val = 1;
657 break;
658 case 4:
659 if (!(*this)[idx].IsHiGainBad())
660 return kFALSE;
661 val = 1;
662 break;
663 case 5:
664 if (!(*this)[idx].IsLoGainBad())
665 return kFALSE;
666 val = 1;
667 break;
668 case 6:
669 if (!(*this)[idx].GetUnsuitableCalLevel())
670 return kFALSE;
671 val = (*this)[idx].GetUnsuitableCalLevel();
672 break;
673 case 7:
674 if (!(*this)[idx].GetUnreliableCalLevel())
675 return kFALSE;
676 val = (*this)[idx].GetUnreliableCalLevel();
677 break;
678 case 8:
679 if (!(*this)[idx].IsUncalibrated(MBadPixelsPix::kHiGainNotFitted))
680 return kFALSE;
681 val = 1;
682 break;
683 case 9:
684 if (!(*this)[idx].IsUncalibrated(MBadPixelsPix::kLoGainNotFitted))
685 return kFALSE;
686 val = 1;
687 break;
688 case 10:
689 if (!(*this)[idx].IsUncalibrated(MBadPixelsPix::kHiGainOscillating))
690 return kFALSE;
691 val = 1;
692 break;
693 case 11:
694 if (!(*this)[idx].IsUncalibrated(MBadPixelsPix::kLoGainOscillating))
695 return kFALSE;
696 val = 1;
697 break;
698 case 12:
699 if (!(*this)[idx].IsUncalibrated(MBadPixelsPix::kLoGainSaturation ))
700 return kFALSE;
701 val = 1;
702 break;
703 case 13:
704 if (!(*this)[idx].IsUncalibrated(MBadPixelsPix::kChargeIsPedestal ))
705 return kFALSE;
706 val = 1;
707 break;
708 case 14:
709 if (!(*this)[idx].IsUncalibrated(MBadPixelsPix::kChargeErrNotValid))
710 return kFALSE;
711 val = 1;
712 break;
713 case 15:
714 if (!(*this)[idx].IsUncalibrated(MBadPixelsPix::kChargeRelErrNotValid))
715 return kFALSE;
716 val = 1;
717 break;
718 case 16:
719 if (!(*this)[idx].IsUncalibrated(MBadPixelsPix::kChargeSigmaNotValid ))
720 return kFALSE;
721 val = 1;
722 break;
723 case 17:
724 if (!(*this)[idx].IsUncalibrated(MBadPixelsPix::kMeanTimeInFirstBin ))
725 return kFALSE;
726 val = 1;
727 break;
728 case 18:
729 if (!(*this)[idx].IsUncalibrated(MBadPixelsPix::kMeanTimeInLast2Bins ))
730 return kFALSE;
731 val = 1;
732 break;
733 case 19:
734 if (!(*this)[idx].IsUncalibrated(MBadPixelsPix::kDeviatingNumPhes ))
735 return kFALSE;
736 val = 1;
737 break;
738 case 20:
739 if (!(*this)[idx].IsUncalibrated(MBadPixelsPix::kRelTimeNotFitted ))
740 return kFALSE;
741 val = 1;
742 break;
743 case 21:
744 if (!(*this)[idx].IsUncalibrated(MBadPixelsPix::kRelTimeOscillating))
745 return kFALSE;
746 val = 1;
747 break;
748 case 22:
749 if (!(*this)[idx].IsUncalibrated(MBadPixelsPix::kDeviatingNumPhots))
750 return kFALSE;
751 val = 1;
752 break;
753 case 23:
754 if (!(*this)[idx].IsUncalibrated(MBadPixelsPix::kHiGainOverFlow ))
755 return kFALSE;
756 val = 1;
757 break;
758 case 24:
759 if (!(*this)[idx].IsUncalibrated(MBadPixelsPix::kLoGainOverFlow ))
760 return kFALSE;
761 val = 1;
762 break;
763 case 102:
764 if (!(*this)[idx].IsUnsuitable())
765 return kFALSE;
766 val = 1;
767 break;
768 default:
769 return kFALSE;
770 }
771
772 return kTRUE;
773}
774
775void MBadPixelsCam::DrawPixelContent(Int_t num) const
776{
777 *fLog << warn << "MBadPixelsCam::DrawPixelContent - not available." << endl;
778}
Note: See TracBrowser for help on using the repository browser.