TOF/TOFda.cxx

   1 /*
   2
   3 TOF DA for online calibration
   4
   5 Contact: Chiara.Zampolli@bo.infn.it
   6          Roberto.Preghenella@bo.infn.it
   7
   8 Run Type: PHYSICS
   9 DA Type: MON
  10 Number of events needed:
  11 Input Files: no input
  12 Output Files: TOFdaHits.root
  13 Event types used: PHYSICS_EVENT
  14
  15 */
  16
  17 #define FILE_HITS "TOFdaHits.root"
  18 #define FILE_CALIB "TOFdaCalib.root"
  19
  20 // DATE
  21 #include "event.h"
  22 #include "monitor.h"
  23 #include "daqDA.h"
  24
  25 #include <stdio.h>
  26 #include <stdlib.h>
  27
  28 //AliRoot
  29 #include "TROOT.h"
  30 #include "AliTOFRawStream.h"
  31 #include "AliRawReaderDate.h"
  32 #include "AliRawReader.h"
  33 #include "AliDAQ.h"
  34 #include "AliTOFHitData.h"
  35 #include "AliTOFHitDataBuffer.h"
  36 #include "AliTOFDaConfigHandler.h"
  37 #include "AliTOFHitField.h"
  38 #include "AliLog.h"
  39 #include "AliTOFGeometry.h"
  40
  41 //ROOT
  42 #include "TFile.h"
  43 #include "TKey.h"
  44 #include "TH2S.h"
  45 #include "TObject.h"
  46 #include "TMath.h"
  47 #include "TSystem.h"
  48 #include "TROOT.h"
  49 #include "TPluginManager.h"
  50 #include "TSAXParser.h"
  51 #include "TTree.h"
  52
  53 /* Main routine
  54       Arguments:
  55       1- monitoring data source
  56 */
  57 int
  58 main(int argc, char **argv)
  59 {
  60
  61   /* magic line from Rene */
  62   gROOT->GetPluginManager()->AddHandler("TVirtualStreamerInfo",
  63                                         "*",
  64                                         "TStreamerInfo",
  65                                         "RIO",
  66                                         "TStreamerInfo()");
  67
  68
  69   /* log start of process */
  70   printf("TOF DA started\n");
  71
  72   /* check that we got some arguments = list of files */
  73   if (argc!=2) {
  74     printf("Wrong number of arguments\n");
  75     return -1;
  76   }
  77
  78   /*
  79    * CONFIG
  80    */
  81
  82   /* retrieve config file */
  83   int getConfigFile = daqDA_DB_getFile("TOFPhysicsConfig.xml","TOFPhysicsConfig.xml");
  84   if (getConfigFile != 0){
  85     printf("Failed to retrieve config file from DB! returning...\n");
  86     return -1;
  87   }
  88   /* parse config file */
  89   AliTOFDaConfigHandler* tofHandler = new AliTOFDaConfigHandler();
  90   TSAXParser *parser = new TSAXParser();
  91   parser->ConnectToHandler("AliTOFDaConfigHandler", tofHandler);
  92   if (parser->ParseFile("./TOFPhysicsConfig.xml") != 0) {
  93     printf("Failed parsing config file! retunring... \n");
  94     return -1;
  95   }
  96   /* setup config params */
  97   Int_t meanMultiplicity = tofHandler->GetMeanMultiplicity(); /* average expected TOF multiplicity */
  98   Int_t maxHits = tofHandler->GetMaxHits(); /* max number of hits to be collected */
  99   printf("current settings:\n");
 100   printf(" - meanMultiplicity = %d\n", meanMultiplicity);
 101   printf(" - maxHits          = %d\n", maxHits);
 102   /* constants */
 103   const Int_t nChannels = 157248;
 104   Int_t noiseCheckTrigger = 10; /* first noise check after 10 events */
 105          Float_t meanChannelRate = (Float_t)meanMultiplicity / (Float_t)nChannels; /* average expected channel rate (hits/event) */
 106   Float_t noiseThreshold = 10. * meanChannelRate; /* noise threshold (hits/event) */
 107   Int_t minNoiseHits = 10; /* min number of channel hits to check noise */
 108   /* counters and flags */
 109   Int_t nPhysicsEvents, nCalibEvents, totHits;
 110   Int_t nChHits[nChannels];
 111   Bool_t inhibitCollection;
 112   Bool_t noiseFlag[nChannels];
 113   /* variables */
 114   Int_t nhits, ddl, slot, trm, chain, tdc, channel, index, timebin, totbin, deltaBC, l0l1latency, det[5], dummy;
 115   Float_t noiseHitThreshold;
 116
 117   /*
 118    * INIT
 119    */
 120
 121   /* init counters and flags */
 122   nPhysicsEvents = 0;
 123   nCalibEvents = 0;
 124   totHits = 0;
 125   inhibitCollection = kFALSE;
 126   for (Int_t ich = 0; ich < nChannels; ich++) {
 127     nChHits[ich] = 0;
 128     noiseFlag[ich] = kFALSE;
 129   }
 130
 131   /* TOF raw data handling */
 132   AliTOFRawStream *rawStream = new AliTOFRawStream();
 133   AliTOFHitDataBuffer *pdb = NULL;
 134   AliTOFHitData *hit = NULL;
 135
 136   /* open HITS output file */
 137   TFile *fileOutHits = new TFile(FILE_HITS, "RECREATE");
 138   /* create hit field data structure */
 139   AliTOFHitField *hitField = new AliTOFHitField();
 140   /* create temporary tree */
 141   TTree *tempTree = new TTree("tempTree", "temporary tree");
 142   tempTree->Branch("hit", "AliTOFHitField", &hitField);
 143   /* create output tree */
 144   TTree *outTree = new TTree("hitTree", "hit tree");
 145   outTree->Branch("hit", "AliTOFHitField", &hitField);
 146
 147   /* open CALIB output file */
 148   TFile *fileOutCalib = new TFile(FILE_CALIB, "RECREATE");
 149   /* create calib hit histo */
 150   TH1F *hCalibHit = new TH1F("hCalibHit", "Calibration events;index;N_{hits}/N_{events}", nChannels, 0., nChannels);
 151
 152   /*
 153    * ONLINE MONITOR
 154    */
 155
 156   AliLog::SetGlobalLogLevel(AliLog::kFatal);
 157   struct eventHeaderStruct *event;
 158   int ret;
 159   /* define data source : this is argument 1 */
 160   ret = monitorSetDataSource(argv[1]);
 161   if (ret != 0) {
 162     printf("monitorSetDataSource() failed : %s\n",monitorDecodeError(ret));
 163     return -1;
 164   }
 165   /* declare monitoring program */
 166   ret = monitorDeclareMp("tofDA");
 167   if (ret != 0) {
 168     printf("monitorDeclareMp() failed : %s\n",monitorDecodeError(ret));
 169     return -1;
 170   }
 171   /* define wait event timeout - 1s max */
 172   monitorSetNowait();
 173   monitorSetNoWaitNetworkTimeout(1000);
 174
 175   /* loop over events */
 176   while (1) {
 177
 178     /* check shutdown condition */
 179     if (daqDA_checkShutdown()) break;
 180
 181     /*
 182      * NOISE CHECK
 183      */
 184
 185     /* check inhibit collection */
 186     if (!inhibitCollection) {
 187       /* check number of events and check noise */
 188       if (nPhysicsEvents >= noiseCheckTrigger || totHits >= maxHits) {
 189         noiseHitThreshold = noiseThreshold * nPhysicsEvents;
 190         printf("noise check triggered after %d events: threshold is %f hits\n", nPhysicsEvents, noiseHitThreshold);
 191         /* loop over all channels */
 192         for (Int_t ich = 0; ich < nChannels; ich++) {
 193           /* check */
 194           if (nChHits[ich] < minNoiseHits || noiseFlag[ich] || nChHits[ich] < noiseHitThreshold) continue;
 195           printf("channel %d tagged as noisy (%d hits): disabled\n", ich, nChHits[ich]);
 196           noiseFlag[ich] = kTRUE;
 197           totHits -= nChHits[ich];
 198         } /* end of loop over all channels */
 199         /* set new noise check trigger value */
 200         noiseCheckTrigger *= 10;
 201       } /* end of noise check */
 202
 203       /* inhibit hit collection when maximum number of hits exceeded */
 204       if (totHits >= maxHits) {
 205         printf("maximum number of hits exceeded (%d): inhibit hit collection\n", maxHits);
 206         inhibitCollection = kTRUE;
 207       }
 208     }
 209
 210     /*
 211      * GET EVENT
 212      */
 213
 214     /* get next event (blocking call until timeout) */
 215     ret = monitorGetEventDynamic((void **)&event);
 216     if (ret == MON_ERR_EOF) {
 217       printf ("End of File detected\n");
 218       break; /* end of monitoring file has been reached */
 219     }
 220     if (ret != 0) {
 221       printf("monitorGetEventDynamic() failed : %s\n",monitorDecodeError(ret));
 222       break;
 223     }
 224     /* retry if got no event */
 225     if (event==NULL) continue;
 226     /* check event type */
 227     if (event->eventType != PHYSICS_EVENT && event->eventType != CALIBRATION_EVENT) continue;
 228     /* check inhibit collection */
 229     if (event->eventType == PHYSICS_EVENT && inhibitCollection) continue;
 230     /* increment number of physics events */
 231     if (event->eventType == PHYSICS_EVENT) nPhysicsEvents++;
 232     /* increment number of calib events */
 233     if (event->eventType == CALIBRATION_EVENT) nCalibEvents++;
 234
 235     /*
 236      * DECODE EVENT
 237      */
 238
 239     /* create raw reader */
 240     AliRawReader *rawReader = new AliRawReaderDate((void *)event);
 241     /* setup raw stream */
 242     rawStream->SetRawReader(rawReader);
 243     /* reset buffers */
 244     rawStream->ResetBuffers();
 245     /* decode */
 246     rawStream->DecodeDDL(0, AliDAQ::NumberOfDdls("TOF") - 1, 0);
 247
 248     /*
 249      * HIT MANIPULATION
 250      */
 251
 252     /* loop over DDLs */
 253     for (Int_t iddl = 0; iddl < AliDAQ::NumberOfDdls("TOF"); iddl++) {
 254       /* get packed-data buffer */
 255       pdb = rawStream->GetPackedDataBuffer(iddl);
 256       nhits = pdb->GetEntries();
 257       /* loop over hits in buffer */
 258       for (Int_t ihit = 0; ihit < nhits; ihit++) {
 259         /* get hit */
 260         hit = pdb->GetHit(ihit);
 261         /* get channel info */
 262         ddl = iddl;
 263         slot = hit->GetSlotID();
 264         trm = slot - 3;
 265         chain = hit->GetChain();
 266         tdc = hit->GetTDC();
 267         channel = hit->GetChan();
 268         /* get index */
 269         rawStream->EquipmentId2VolumeId(ddl, slot, chain, tdc, channel, det);
 270         dummy = det[4];
 271         det[4] = det[3];
 272         det[3] = dummy;
 273         /* check valid index */
 274         if (det[0] < 0 || det[0] > 17 ||
 275             det[1] < 0 || det[1] > 5 ||
 276             det[2] < 0 || det[2] > 18 ||
 277             det[3] < 0 || det[3] > 1 ||
 278             det[4] < 0 || det[4] > 47) continue;
 279         index = AliTOFGeometry::GetIndex(det);
 280
 281         /* switch event type */
 282         switch (event->eventType) {
 283
 284           /*
 285            * PHYSICS EVENT
 286            */
 287
 288         case PHYSICS_EVENT:
 289           /* check noise flag */
 290           if (noiseFlag[index]) continue;
 291           /* increment number of channel hits and total hits */
 292           nChHits[index]++;
 293           totHits++;
 294           /* get signal info */
 295           timebin = hit->GetTimeBin();
 296           totbin = hit->GetTOTBin();
 297           deltaBC = hit->GetDeltaBunchID();
 298           l0l1latency = hit->GetL0L1Latency();
 299           /* set hit field data */
 300           hitField->SetIndex(index);
 301           hitField->SetTimeBin(timebin);
 302           hitField->SetTOTBin(totbin);
 303           hitField->SetDeltaBC(deltaBC);
 304           hitField->SetL0L1Latency(l0l1latency);
 305           /* fill temp tree */
 306           tempTree->Fill();
 307           break;
 308
 309           /*
 310            * CALIBRATION EVENT
 311            */
 312
 313         case CALIBRATION_EVENT:
 314           /* fill calib hit histo */
 315           hCalibHit->Fill(index);
 316           break;
 317
 318         } /* end of switch event type */
 319       } /* end of loop over hits in buffer */
 320     } /* end of loop over DDLs */
 321
 322     /* delete raw reader */
 323     delete rawReader;
 324
 325   } /* end of loop over events */
 326
 327   /* final noise check */
 328   noiseHitThreshold = noiseThreshold * nPhysicsEvents;
 329   printf("final noise check after %d events: threshold is %f hits\n", nPhysicsEvents, noiseHitThreshold);
 330   /* loop over all channels */
 331   for (Int_t ich = 0; ich < nChannels; ich++) {
 332     /* check */
 333     if (nChHits[ich] < minNoiseHits || noiseFlag[ich] || nChHits[ich] < noiseHitThreshold) continue;
 334     printf("channel %d tagged as noisy (%d hits): disabled\n", ich, nChHits[ich]);
 335     noiseFlag[ich] = kTRUE;
 336     totHits -= nChHits[ich];
 337   } /* end of loop over all channels */
 338
 339   /* copy hits into output tree from temp tree */
 340   printf("copy hits from temporary tree into output tree\n");
 341   printf("temporary tree contains %d hits\n", (Int_t)tempTree->GetEntries());
 342   for (Int_t ihit = 0; ihit < tempTree->GetEntries(); ihit++) {
 343     /* get entry */
 344     tempTree->GetEntry(ihit);
 345     /* check noise flag */
 346     if (noiseFlag[hitField->GetIndex()]) continue;
 347     /* fill output tree */
 348     outTree->Fill();
 349   } /* end of copy hits into output tree from temp tree */
 350   printf("output tree contains %d hits\n", (Int_t)outTree->GetEntries());
 351
 352   /* write output tree on HITS file */
 353   fileOutHits->cd();
 354   outTree->Write();
 355   fileOutHits->Close();
 356   /* export file to FXS */
 357   if (daqDA_FES_storeFile(FILE_HITS, "HITS"))
 358     return -2;
 359
 360   /* scale calib hit histo by number of calib events */
 361   hCalibHit->Sumw2();
 362   hCalibHit->Scale(1. / nCalibEvents);
 363
 364   /* write calib hit histo on CALIB file */
 365   fileOutCalib->cd();
 366   hCalibHit->Write();
 367   fileOutCalib->Close();
 368   /* export file to FXS */
 369   if (daqDA_FES_storeFile(FILE_CALIB, "CALIB"))
 370     return -2;
 371
 372   return 0;
 373 }