ITS/AliITSOnlineSPDscan.cxx

   1 ////////////////////////////////////////////////////////////
   2 // Author: Henrik Tydesjo                                 //
   3 // Interface class to the containers of an online scan.   //
   4 // Directly connected to a TFile with all containers.     //
   5 // Handles reading and writing of this TFile.             //
   6 // Hitmaps and information on nr of events with hits      //
   7 // is stored in this file (AliITSOnlineSPDHitArray and    //
   8 // AliITSOnlineSPDHitEvent). Also some general            //
   9 // information is stored (AliITSOnlineSPDscanInfo).       //
  10 // When switching between different steps of the scan,    //
  11 // the previous step is automatically stored on the file. //
  12 // With this scheme there is no risk of running out of    //
  13 // memory.                                                //
  14 ////////////////////////////////////////////////////////////
  15
  16 #include <math.h>
  17
  18 #include <TFile.h>
  19 #include "AliITSOnlineSPDscan.h"
  20 #include "AliITSOnlineSPDscanInfo.h"
  21 #include "AliITSOnlineSPDHitArray.h"
  22 #include "AliITSOnlineSPDHitEvent.h"
  23
  24 AliITSOnlineSPDscan::AliITSOnlineSPDscan(const Char_t *fileName, Bool_t readFromGridFile) :
  25   fFile(NULL),
  26   fWrite(kFALSE),
  27   fCurrentStep(-1),
  28   fModified(kFALSE),
  29   fInfoModified(kFALSE),
  30   fScanInfo(NULL),
  31   fFileName(fileName)
  32 {
  33   // constructor, open file for reading or writing
  34   // look for a previously saved info object
  35   // (if file not found create a new one and return, else read)
  36
  37   for(Int_t ihs=0; ihs<6; ihs++){
  38   fCurrentHitArray[ihs]=0x0;
  39   fCurrentHitEvent[ihs]=0x0;
  40   }
  41
  42   Bool_t bRead = readFromGridFile;
  43
  44   if (!bRead) {
  45     FILE* fp0 = fopen(fFileName.Data(), "r");
  46     if (fp0 != NULL) {
  47       bRead=kTRUE;
  48       fclose(fp0);
  49     }
  50   }
  51
  52   if (bRead) { // open file for reading
  53     fFile = TFile::Open(fFileName.Data(), "READ");
  54     if (fFile==NULL) { // grid file not found, create new local default file
  55       printf("ERROR: AliITSOnlineSPDscan: File %s not found! Creating 'test999.root' file instead\n",fFileName.Data());
  56       // create default empty file:
  57       fFileName = "test999.root";
  58       fScanInfo = new AliITSOnlineSPDscanInfo();
  59       fInfoModified=kTRUE;
  60       fFile = new TFile(fFileName.Data(), "RECREATE");
  61       fWrite=kTRUE;
  62     }
  63     else { // read from file (grid or local)
  64       fWrite=kFALSE;
  65       fFile->GetObject("AliITSOnlineSPDscanInfo", fScanInfo);
  66     }
  67   }
  68   else { // create new local file
  69     fScanInfo = new AliITSOnlineSPDscanInfo();
  70     fInfoModified=kTRUE;
  71     fFile = new TFile(fFileName.Data(), "RECREATE");
  72     fWrite=kTRUE;
  73   }
  74
  75   Init();
  76 }
  77
  78 AliITSOnlineSPDscan::AliITSOnlineSPDscan(const AliITSOnlineSPDscan& /*scan*/) :
  79   fFile(NULL),
  80   fWrite(kFALSE),
  81   fCurrentStep(-1),
  82   fModified(kFALSE),
  83   fInfoModified(kFALSE),
  84   fScanInfo(NULL),
  85   fFileName(".")
  86 {
  87
  88   for(Int_t ihs=0; ihs<6; ihs++){
  89   fCurrentHitArray[ihs]=0x0;
  90   fCurrentHitEvent[ihs]=0x0;
  91   }
  92
  93   printf("This object should not be copied!");
  94 }
  95
  96 AliITSOnlineSPDscan::~AliITSOnlineSPDscan() {
  97   // destructor
  98   if (fModified) {
  99     SaveCurrentStep();
 100   }
 101   for (UInt_t hs=0; hs<6; hs++) {
 102     if (fCurrentHitArray[hs]!=NULL) {
 103       delete fCurrentHitArray[hs];
 104       fCurrentHitArray[hs]=NULL;
 105     }
 106     if (fCurrentHitEvent[hs]!=NULL) {
 107       delete fCurrentHitEvent[hs];
 108       fCurrentHitEvent[hs]=NULL;
 109     }
 110   }
 111   if (fInfoModified) {
 112     if (!fWrite) {
 113       fFile->Close();
 114       delete fFile;
 115       fFile = new TFile(fFileName.Data(), "UPDATE");
 116       fWrite=kTRUE;
 117     }
 118     fFile->Delete("AliITSOnlineSPDscanInfo;*");
 119     fFile->WriteTObject(fScanInfo, "AliITSOnlineSPDscanInfo");
 120   }
 121   if (fFile!=NULL) {
 122     delete fFile;
 123   }
 124 }
 125
 126 AliITSOnlineSPDscan& AliITSOnlineSPDscan::operator=(const AliITSOnlineSPDscan& scan) {
 127   // assignment operator (should not be used)
 128   printf("This object should not be copied!");
 129   if (this!=&scan) {
 130     // still do nothing...
 131   }
 132   return *this;
 133 }
 134
 135 void AliITSOnlineSPDscan::ClearThis() {
 136   // clear this scan, close file and open new
 137   for (UInt_t hs=0; hs<6; hs++) {
 138     if (fCurrentHitArray[hs]!=NULL) {
 139       delete fCurrentHitArray[hs];
 140     }
 141     fCurrentHitArray[hs] = NULL;
 142     if (fCurrentHitEvent[hs]!=NULL) {
 143       delete fCurrentHitEvent[hs];
 144     }
 145     fCurrentHitEvent[hs] = NULL;
 146   }
 147   fScanInfo->ClearThis();
 148   fFile->Close();
 149   delete fFile;
 150   fFile = new TFile(fFileName.Data(), "RECREATE");
 151   fWrite=kTRUE;
 152   fFile->WriteTObject(fScanInfo, "AliITSOnlineSPDscanInfo");
 153   fInfoModified=kTRUE;
 154 }
 155
 156 void AliITSOnlineSPDscan::Init() {
 157   // init hit arrays and hit events
 158   for (UInt_t hs=0; hs<6; hs++) {
 159     fCurrentHitArray[hs]=NULL;
 160     fCurrentHitEvent[hs]=NULL;
 161   }
 162
 163 }
 164
 165 UInt_t AliITSOnlineSPDscan::AddScanStep() {
 166   // add a new scan step
 167   CreateNewStep();
 168   return fScanInfo->AddScanStep();
 169 }
 170
 171 void AliITSOnlineSPDscan::CreateNewStep() {
 172   // create a new step
 173   // save current step to file (if modified)
 174   if (fModified) {
 175     SaveCurrentStep();
 176   }
 177   // create new step
 178   for (UInt_t hs=0; hs<6; hs++) {
 179     if (fCurrentHitArray[hs]!=NULL) {
 180       delete fCurrentHitArray[hs];
 181     }
 182     fCurrentHitArray[hs] = new AliITSOnlineSPDHitArray();
 183     if (fCurrentHitEvent[hs]!=NULL) {
 184       delete fCurrentHitEvent[hs];
 185     }
 186     fCurrentHitEvent[hs] = new AliITSOnlineSPDHitEvent();
 187   }
 188   fCurrentStep = fScanInfo->GetNSteps();
 189   fModified=kTRUE;
 190   fInfoModified=kTRUE;
 191 }
 192
 193 void AliITSOnlineSPDscan::SwitchToStep(UInt_t nsi) {
 194   // switch to step nsi (save current step first if needed)
 195   if ((Int_t)nsi!=fCurrentStep) {
 196     if (fModified) {
 197       SaveCurrentStep();
 198     }
 199     for (UInt_t hs=0; hs<6; hs++) {
 200       if (fCurrentHitArray[hs]!=NULL) {
 201         delete fCurrentHitArray[hs];
 202         fCurrentHitArray[hs]=NULL;
 203       }
 204       if (fCurrentHitEvent[hs]!=NULL) {
 205         delete fCurrentHitEvent[hs];
 206         fCurrentHitEvent[hs]=NULL;
 207       }
 208     }
 209     if (nsi>=GetNSteps()) {
 210       FillGap(nsi); // makes fCurrentStep = nsi
 211     }
 212     else {
 213       fCurrentStep=nsi;
 214       ReadCurrentStep();
 215     }
 216   }
 217 }
 218
 219 void AliITSOnlineSPDscan::FillGap(UInt_t nsi) {
 220   //create new steps until nsi is reached
 221   while (nsi>=GetNSteps()) {
 222     fCurrentStep = AddScanStep();
 223   }
 224 }
 225
 226 void AliITSOnlineSPDscan::ReadCurrentStep() {
 227   // read current step index into memory
 228   for (UInt_t hs=0; hs<6; hs++) {
 229     TString stepName = Form("HitArray_HS%d_Step%d",hs,fCurrentStep);
 230     fFile->GetObject(stepName.Data(), fCurrentHitArray[hs]);
 231     TString stepName2 = Form("HitEvent_HS%d_Step%d",hs,fCurrentStep);
 232     fFile->GetObject(stepName2, fCurrentHitEvent[hs]);
 233   }
 234 }
 235
 236 void AliITSOnlineSPDscan::SaveCurrentStep() {
 237   // save current step to file
 238   if (!fWrite) {
 239     fFile->Close();
 240     delete fFile;
 241     fFile = new TFile(fFileName.Data(), "UPDATE");
 242     fWrite=kTRUE;
 243   }
 244   for (UInt_t hs=0; hs<6; hs++) {
 245     TString stepName = Form("HitArray_HS%d_Step%d",hs,fCurrentStep);
 246     TString stepDelete = Form("%s;*",stepName.Data());
 247     fFile->Delete(stepDelete.Data());
 248     fFile->WriteTObject(fCurrentHitArray[hs], stepName.Data());
 249     TString stepName2 = Form("HitEvent_HS%d_Step%d",hs,fCurrentStep);
 250     TString stepDelete2 = Form("%s;*",stepName2.Data());
 251     fFile->Delete(stepDelete2.Data());
 252     fFile->WriteTObject(fCurrentHitEvent[hs], stepName2.Data());
 253   }
 254   fModified=kFALSE;
 255 }
 256
 257 void AliITSOnlineSPDscan::SetHits(UInt_t nsi, UInt_t hs, UInt_t chipi, UInt_t coli, UInt_t rowi, UInt_t val) {
 258   // set nr of hits for pixel
 259   SwitchToStep(nsi);
 260   fCurrentHitArray[hs]->SetHits(chipi,coli,rowi,val);
 261   fModified=kTRUE;
 262 }
 263 void AliITSOnlineSPDscan::IncrementHits(UInt_t nsi, UInt_t hs, UInt_t chipi, UInt_t coli, UInt_t rowi) {
 264   // increment nr of hits for pixel
 265   SwitchToStep(nsi);
 266   fCurrentHitArray[hs]->IncrementHits(chipi,coli,rowi);
 267   fModified=kTRUE;
 268 }
 269 void AliITSOnlineSPDscan::SetHitEvents(UInt_t nsi, UInt_t hs, UInt_t chipi, Int_t val) {
 270   // set nr of hit events for a chip
 271   SwitchToStep(nsi);
 272   fCurrentHitEvent[hs]->SetHitEvent(chipi,val);
 273   fModified=kTRUE;
 274 }
 275 void AliITSOnlineSPDscan::SetHitEventsTot(UInt_t nsi, UInt_t hs, Int_t val) {
 276   // set nr of hit events for 10 chips together
 277   SetHitEvents(nsi,hs,10,val);
 278 }
 279 void AliITSOnlineSPDscan::IncrementHitEvents(UInt_t nsi, UInt_t hs, UInt_t chipi) {
 280   // increment nr of hit events for a chip
 281   SwitchToStep(nsi);
 282   fCurrentHitEvent[hs]->IncrementHitEvent(chipi);
 283   fModified=kTRUE;
 284 }
 285 void AliITSOnlineSPDscan::IncrementHitEventsTot(UInt_t nsi, UInt_t hs) {
 286   // increment nr of hit events for 10 chips
 287   IncrementHitEvents(nsi,hs,10);
 288 }
 289
 290
 291 UInt_t AliITSOnlineSPDscan::GetHits(UInt_t nsi, UInt_t hs, UInt_t chipi, UInt_t coli, UInt_t rowi) {
 292   // get nr of hits for pixel
 293   if (nsi<GetNSteps()) {
 294     SwitchToStep(nsi);
 295     return fCurrentHitArray[hs]->GetHits(chipi,coli,rowi);
 296   }
 297   else {
 298     return 0;
 299   }
 300 }
 301 Float_t AliITSOnlineSPDscan::GetHitsEfficiency(UInt_t nsi, UInt_t hs, UInt_t chipi, UInt_t coli, UInt_t rowi) {
 302   // get the hit efficiency for pixel
 303   UInt_t ntr = GetTriggers(nsi);
 304   if (ntr>0) {
 305     return ((Float_t)GetHits(nsi,hs,chipi,coli,rowi))/ntr;
 306   }
 307   else {
 308     return 0;
 309   }
 310 }
 311 Float_t AliITSOnlineSPDscan::GetHitsEfficiencyError(UInt_t nsi, UInt_t hs, UInt_t chipi, UInt_t coli, UInt_t rowi) {
 312   // get error in hit efficiency for pixel
 313   Float_t hits = GetHits(nsi,hs,chipi,coli,rowi);
 314   UInt_t ntr = GetTriggers(nsi);
 315   return sqrt(hits*(ntr-hits)/ntr)/ntr;
 316 }
 317 UInt_t AliITSOnlineSPDscan::GetHitEvents(UInt_t nsi, UInt_t hs, UInt_t chipi) {
 318   // get nr of hit events for a chip
 319   if (nsi<GetNSteps()) {
 320     SwitchToStep(nsi);
 321     return fCurrentHitEvent[hs]->GetHitEvent(chipi);
 322   }
 323   else {
 324     return 0;
 325   }
 326 }
 327 UInt_t AliITSOnlineSPDscan::GetHitEventsTot(UInt_t nsi, UInt_t hs) {
 328   // get nr of hit events for 10 chips
 329   return GetHitEvents(nsi,hs,10);
 330 }
 331 Float_t AliITSOnlineSPDscan::GetHitEventsEfficiency(UInt_t nsi, UInt_t hs, UInt_t chipi) {
 332   // get the hit events efficiency for a chip
 333   UInt_t ntr = GetTriggers(nsi);
 334   if (ntr>0) {
 335     return ((Float_t)GetHitEvents(nsi,hs,chipi))/ntr;
 336   }
 337   else {
 338     return 0;
 339   }
 340 }
 341 Float_t AliITSOnlineSPDscan::GetHitEventsTotEfficiency(UInt_t nsi, UInt_t hs) {
 342   // get the hit events efficiency for 10 chips
 343   return GetHitEventsEfficiency(nsi,hs,10);
 344 }
 345 Float_t AliITSOnlineSPDscan::GetHitEventsEfficiencyError(UInt_t nsi, UInt_t hs, UInt_t chipi) {
 346   // get error in hit events efficiency for a chip
 347   Float_t hitevents = (Float_t) GetHitEvents(nsi,hs,chipi);
 348   UInt_t ntr = GetTriggers(nsi);
 349   return sqrt(hitevents*(ntr-hitevents)/ntr)/ntr;
 350 }
 351 Float_t AliITSOnlineSPDscan::GetHitEventsTotEfficiencyError(UInt_t nsi, UInt_t hs) {
 352   // get error in hit events efficiency for 10 chips
 353   return GetHitEventsEfficiencyError(nsi,hs,10);
 354 }
 355 Float_t AliITSOnlineSPDscan::GetAverageMultiplicity(UInt_t nsi, UInt_t hs, UInt_t chipi) {
 356   // get average multiplicity for a chip
 357   Float_t nrhits = 0;
 358   for (UInt_t chip=0;chip<10;chip++) {
 359     if (chipi==10 || chip==chipi) {
 360       for (Int_t col=0; col<32; col++) {
 361         for (Int_t row=0; row<256; row++) {
 362           nrhits+=GetHits(nsi,hs,chip,col,row);
 363         }
 364       }
 365     }
 366   }
 367   UInt_t ntr = GetTriggers(nsi);
 368   if (ntr>0) {
 369     return nrhits/ntr;
 370   }
 371   else {
 372     return 0;
 373   }
 374 }
 375 Float_t AliITSOnlineSPDscan::GetAverageMultiplicityTot(UInt_t nsi, UInt_t hs) {
 376   // get average multiplicity for 10 chips
 377   return GetAverageMultiplicity(nsi,hs,10);
 378 }
 379
 380
 381 void AliITSOnlineSPDscan::SetType(UInt_t val) {
 382   // set type
 383   fScanInfo->SetType(val);
 384   fInfoModified=kTRUE;
 385 }
 386 void AliITSOnlineSPDscan::SetRunNr(UInt_t val) {
 387   // set run nr
 388   fScanInfo->SetRunNr(val);
 389   fInfoModified=kTRUE;
 390 }
 391 void AliITSOnlineSPDscan::SetRouterNr(UInt_t val) {
 392   // set router nr
 393   fScanInfo->SetRouterNr(val);
 394   fInfoModified=kTRUE;
 395 }
 396 void AliITSOnlineSPDscan::SetHalfStaveScanned(UInt_t val, Bool_t b) {
 397   // set half stave scanned
 398   fScanInfo->SetHalfStaveScanned(val,b);
 399   fInfoModified=kTRUE;
 400 }
 401 void AliITSOnlineSPDscan::SetDataFormat(UInt_t val) {
 402   // set data format (0=normal 1=histogram)
 403   fScanInfo->SetDataFormat(val);
 404   fInfoModified=kTRUE;
 405 }
 406 void AliITSOnlineSPDscan::SetTriggers(UInt_t nsi, UInt_t val) {
 407   // set nr of triggers
 408   SwitchToStep(nsi);
 409   fScanInfo->SetTriggers(nsi,val);
 410   fInfoModified=kTRUE;
 411 }
 412 void AliITSOnlineSPDscan::SetChipPresent(UInt_t hs, UInt_t chipi, Bool_t val){
 413   // set chip present
 414   fScanInfo->SetChipPresent(hs,chipi,val);
 415   fInfoModified=kTRUE;
 416 }
 417 void AliITSOnlineSPDscan::SetRowStart(UInt_t val){
 418   // set row start
 419   fScanInfo->SetRowStart(val);
 420   fInfoModified=kTRUE;
 421 }
 422 void AliITSOnlineSPDscan::SetRowEnd(UInt_t val){
 423   // set row end
 424   fScanInfo->SetRowEnd(val);
 425   fInfoModified=kTRUE;
 426 }
 427 void AliITSOnlineSPDscan::SetDacStart(UInt_t val){
 428   // set dac start
 429   fScanInfo->SetDacStart(val);
 430   fInfoModified=kTRUE;
 431 }
 432 void AliITSOnlineSPDscan::SetDacEnd(UInt_t val){
 433   // set dac end
 434   fScanInfo->SetDacEnd(val);
 435   fInfoModified=kTRUE;
 436 }
 437 void AliITSOnlineSPDscan::SetDacStep(UInt_t val){
 438   // set dac step
 439   fScanInfo->SetDacStep(val);
 440   fInfoModified=kTRUE;
 441 }
 442 void AliITSOnlineSPDscan::SetDCSVersion(UInt_t val){
 443   // set dcs db version
 444   fScanInfo->SetDCSVersion(val);
 445   fInfoModified=kTRUE;
 446 }
 447 void AliITSOnlineSPDscan::IncrementTriggers(UInt_t nsi) {
 448   // increment nr of triggers
 449   SwitchToStep(nsi);
 450   fScanInfo->IncrementTriggers(nsi);
 451   fInfoModified=kTRUE;
 452 }
 453
 454
 455
 456 UInt_t AliITSOnlineSPDscan::GetNSteps() const {
 457   return fScanInfo->GetNSteps();
 458 }
 459 UInt_t AliITSOnlineSPDscan::GetType() const {
 460   return fScanInfo->GetType();
 461 }
 462 UInt_t AliITSOnlineSPDscan::GetRunNr() const {
 463   return fScanInfo->GetRunNr();
 464 }
 465 UInt_t AliITSOnlineSPDscan::GetRouterNr() const {
 466   return fScanInfo->GetRouterNr();
 467 }
 468 Bool_t AliITSOnlineSPDscan::GetHalfStaveScanned(UInt_t val) const {
 469   return fScanInfo->GetHalfStaveScanned(val);
 470 }
 471 UInt_t AliITSOnlineSPDscan::GetDataFormat() const {
 472   return fScanInfo->GetDataFormat();
 473 }
 474 UInt_t AliITSOnlineSPDscan::GetTriggers(UInt_t nsi) const {
 475   return fScanInfo->GetTriggers(nsi);
 476 }
 477 Bool_t AliITSOnlineSPDscan::GetChipPresent(UInt_t hs, UInt_t chipi) const {
 478   return fScanInfo->GetChipPresent(hs,chipi);
 479 }
 480 UInt_t AliITSOnlineSPDscan::GetRowStart() const {
 481   return fScanInfo->GetRowStart();
 482 }
 483 UInt_t AliITSOnlineSPDscan::GetRowEnd() const {
 484   return fScanInfo->GetRowEnd();
 485 }
 486 UInt_t AliITSOnlineSPDscan::GetDacStart() const {
 487   return fScanInfo->GetDacStart();
 488 }
 489 UInt_t AliITSOnlineSPDscan::GetDacEnd() const {
 490   return fScanInfo->GetDacEnd();
 491 }
 492 UInt_t AliITSOnlineSPDscan::GetDacStep() const {
 493   return fScanInfo->GetDacStep();
 494 }
 495 UInt_t AliITSOnlineSPDscan::GetDCSVersion() const {
 496   return fScanInfo->GetDCSVersion();
 497 }