Line data Source code
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 :
16 :
17 : /*
18 : Checks the quality assurance. Under construction.
19 : By comparing with reference data
20 :
21 : */
22 :
23 : // --- ROOT system ---
24 : #include <TClass.h>
25 : #include <TH1F.h>
26 : #include <TH1I.h>
27 : #include <TIterator.h>
28 : #include <TKey.h>
29 : #include <TFile.h>
30 :
31 : // --- Standard library ---
32 :
33 : // --- AliRoot header files ---
34 : #include "AliLog.h"
35 : #include "AliQAv1.h"
36 : #include "AliQAChecker.h"
37 : #include "AliVZEROQAChecker.h"
38 : #include "AliVZEROQADataMakerRec.h"
39 :
40 44 : ClassImp(AliVZEROQAChecker)
41 :
42 : //__________________________________________________________________
43 3 : AliVZEROQAChecker::AliVZEROQAChecker() : AliQACheckerBase("VZERO","VZERO Quality Assurance Data Checker"),
44 3 : fLowEventCut(1000),
45 3 : fORvsANDCut(0.2),
46 3 : fBGvsBBCut(0.2)
47 15 : {
48 : // Default constructor
49 : // Nothing else here
50 6 : }
51 :
52 : //__________________________________________________________________
53 : void AliVZEROQAChecker::Check(Double_t * check, AliQAv1::ALITASK_t index, TObjArray ** list, const AliDetectorRecoParam * /*recoParam*/)
54 : {
55 : // Main check function: Depending on the TASK, different checks will be applied
56 : // Check for missing channels and check on the trigger type for raw data
57 : // Check for missing disk or rings for esd (to be redone)
58 :
59 117 : for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) {
60 45 : check[specie] = 1.0;
61 : // no check on cosmic or calibration events
62 81 : if (AliRecoParam::ConvertIndex(specie) == AliRecoParam::kCosmic || AliRecoParam::ConvertIndex(specie) == AliRecoParam::kCalib)
63 : continue;
64 27 : if ( !AliQAv1::Instance()->IsEventSpecieSet(specie) )
65 : continue;
66 0 : if (index == AliQAv1::kRAW) {
67 0 : check[specie] = CheckRaws(list[specie]);
68 0 : } else if (index == AliQAv1::kESD) {
69 : // Check for one disk missing (FATAL) or one ring missing (ERROR) in ESDs (to be redone)
70 0 : check[specie] = CheckEsds(list[specie]);
71 0 : }
72 : }
73 9 : }
74 :
75 : //_________________________________________________________________
76 : Double_t AliVZEROQAChecker::CheckRaws(TObjArray * list) const
77 : {
78 :
79 : // Check on the QA histograms on the raw-data input list:
80 : // Two things are checked: the presence of data in all channels and
81 : // the ratio between different trigger types
82 :
83 : Double_t test = 1.0;
84 0 : if (list->GetEntries() == 0){
85 0 : AliWarning("There are no histograms to be checked");
86 0 : } else {
87 0 : TH1F *hTriggers = (TH1F*)list->At(AliVZEROQADataMakerRec::kTriggers);
88 0 : if (!hTriggers) {
89 0 : AliWarning("Trigger type histogram is not found");
90 0 : }
91 0 : else if (hTriggers->GetEntries() < fLowEventCut) {
92 0 : AliInfo("Not enough events to perform QA checks");
93 0 : }
94 : else {
95 0 : Double_t nANDs = hTriggers->GetBinContent(hTriggers->FindBin(0));
96 0 : Double_t nORs = hTriggers->GetBinContent(hTriggers->FindBin(1));
97 0 : Double_t nBGAs = hTriggers->GetBinContent(hTriggers->FindBin(2));
98 0 : Double_t nBGCs = hTriggers->GetBinContent(hTriggers->FindBin(3));
99 0 : if ((nORs - nANDs) > fORvsANDCut*nANDs) test = 0.001;
100 0 : if ((nBGAs + nBGCs) > fBGvsBBCut*nANDs) test = 0.002;
101 : }
102 0 : TH1F *hBBflags = (TH1F*)list->At(AliVZEROQADataMakerRec::kBBFlagsPerChannel);
103 0 : if (!hBBflags) {
104 0 : AliWarning("BB-flags per channel histogram is not found");
105 0 : }
106 0 : else if (hBBflags->GetEntries() < fLowEventCut) {
107 0 : AliInfo("Not enough events to perform QA checks");
108 0 : }
109 : else {
110 0 : for(Int_t iBin = 1; iBin <= 64; ++iBin) {
111 0 : if (hBBflags->GetBinContent(iBin) < 1.0) test = -1.0;
112 : }
113 : }
114 : }
115 0 : return test ;
116 : }
117 :
118 : //_________________________________________________________________
119 : Double_t AliVZEROQAChecker::CheckEsds(TObjArray * list) const
120 : {
121 :
122 : // check the ESDs for missing disk or ring
123 : // printf(" Number of entries in ESD list = %d\n", list->GetEntries());
124 : // list->Print();
125 :
126 : Double_t test = 1.0; // initialisation to OK
127 : Int_t histonb = 0;
128 : Double_t multV0A = 0.0;
129 : Double_t multV0C = 0.0;
130 0 : Double_t v0ABBRing[4], v0CBBRing[4];
131 0 : Double_t v0ABGRing[4], v0CBGRing[4];
132 0 : for (Int_t i=0; i<4; i++) {
133 0 : v0ABBRing[i]= v0CBBRing[i]= 0.0;
134 0 : v0ABGRing[i]= v0CBGRing[i]= 0.0;
135 : }
136 0 : TIter next(list) ;
137 : TH1 * hdata ;
138 :
139 0 : while ( (hdata = dynamic_cast<TH1 *>(next())) ) {
140 0 : if (hdata) {
141 0 : switch (histonb) {
142 : case AliVZEROQADataMakerRec::kCellMultiV0A:
143 0 : multV0A = hdata->GetMean();
144 0 : break;
145 : case AliVZEROQADataMakerRec::kCellMultiV0C:
146 0 : multV0C = hdata->GetMean();
147 0 : break;
148 : case AliVZEROQADataMakerRec::kBBFlag:
149 0 : for (Int_t i=0; i<8; i++) {
150 0 : if(i<4) v0CBBRing[i] = hdata->Integral((i*8)+1, (i*8) +8);
151 0 : else v0ABBRing[i-4] = hdata->Integral((i*8)+1, (i*8) +8);
152 : }
153 0 : break;
154 : case AliVZEROQADataMakerRec::kBGFlag:
155 0 : for (Int_t i=0; i<8; i++) {
156 0 : if(i<4) v0CBGRing[i] = hdata->Integral((i*8)+1, (i*8) +8);
157 0 : else v0ABGRing[i-4] = hdata->Integral((i*8)+1, (i*8) +8);
158 : }
159 0 : break;
160 : }
161 : }
162 0 : histonb++;
163 : }
164 :
165 0 : if(multV0A == 0.0 || multV0C == 0.0) {
166 0 : AliWarning(Form("One of the two disks is missing !") );
167 : test = 0.0; // bit FATAL set
168 0 : }
169 0 : if( v0ABBRing[0]+v0ABGRing[0] == 0.0 ||
170 0 : v0ABBRing[1]+v0ABGRing[1] == 0.0 ||
171 0 : v0ABBRing[2]+v0ABGRing[2] == 0.0 ||
172 0 : v0ABBRing[3]+v0ABGRing[3] == 0.0 ||
173 0 : v0CBBRing[0]+v0CBGRing[0] == 0.0 ||
174 0 : v0CBBRing[1]+v0CBGRing[1] == 0.0 ||
175 0 : v0CBBRing[2]+v0CBGRing[2] == 0.0 ||
176 0 : v0CBBRing[3]+v0CBGRing[3] == 0.0 ){
177 0 : AliWarning(Form("One ring is missing !") );
178 : test = 0.1; // bit ERROR set
179 0 : }
180 :
181 : return test ;
182 0 : }
183 :
184 : //______________________________________________________________________________
185 : void AliVZEROQAChecker::Init(const AliQAv1::DETECTORINDEX_t det)
186 : {
187 : // intialises QA and QA checker settings
188 18 : AliQAv1::Instance(det) ;
189 9 : Float_t * hiValue = new Float_t[AliQAv1::kNBIT] ;
190 9 : Float_t * lowValue = new Float_t[AliQAv1::kNBIT] ;
191 9 : lowValue[AliQAv1::kINFO] = 0.5 ;
192 9 : hiValue[AliQAv1::kINFO] = 1.0 ;
193 9 : lowValue[AliQAv1::kWARNING] = 0.2 ;
194 9 : hiValue[AliQAv1::kWARNING] = 0.5 ;
195 9 : lowValue[AliQAv1::kERROR] = 0.0 ;
196 9 : hiValue[AliQAv1::kERROR] = 0.2 ;
197 9 : lowValue[AliQAv1::kFATAL] = -1.0 ;
198 9 : hiValue[AliQAv1::kFATAL] = 0.0 ;
199 9 : SetHiLo(hiValue, lowValue) ;
200 18 : delete [] hiValue;
201 18 : delete [] lowValue;
202 9 : }
203 :
204 : //______________________________________________________________________________
205 : void AliVZEROQAChecker::SetQA(AliQAv1::ALITASK_t index, Double_t * value) const
206 : {
207 : // sets the QA word according to return value of the Check
208 18 : AliQAv1 * qa = AliQAv1::Instance(index);
209 108 : for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) {
210 45 : qa->UnSet(AliQAv1::kFATAL, specie);
211 45 : qa->UnSet(AliQAv1::kWARNING, specie);
212 45 : qa->UnSet(AliQAv1::kERROR, specie);
213 45 : qa->UnSet(AliQAv1::kINFO, specie);
214 45 : if ( ! value ) { // No checker is implemented, set all QA to Fatal
215 0 : qa->Set(AliQAv1::kFATAL, specie) ;
216 0 : } else {
217 90 : if ( value[specie] >= fLowTestValue[AliQAv1::kFATAL] && value[specie] < fUpTestValue[AliQAv1::kFATAL] )
218 0 : qa->Set(AliQAv1::kFATAL, specie) ;
219 90 : else if ( value[specie] > fLowTestValue[AliQAv1::kERROR] && value[specie] <= fUpTestValue[AliQAv1::kERROR] )
220 0 : qa->Set(AliQAv1::kERROR, specie) ;
221 90 : else if ( value[specie] > fLowTestValue[AliQAv1::kWARNING] && value[specie] <= fUpTestValue[AliQAv1::kWARNING] )
222 0 : qa->Set(AliQAv1::kWARNING, specie) ;
223 90 : else if ( value[specie] > fLowTestValue[AliQAv1::kINFO] && value[specie] <= fUpTestValue[AliQAv1::kINFO] )
224 45 : qa->Set(AliQAv1::kINFO, specie) ;
225 : }
226 : }
227 9 : }
228 :
|
