TRD/AliTRDPreprocessor.cxx

   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 /* $Id$ */
  17
  18 ////////////////////////////////////////////////////////////////////////////
  19 //                                                                        //
  20 // This class is a first implementation for the TRD.                      //
  21 // It takes data from HLT and computes the parameters                     //
  22 // and stores both reference data and online calibration                  //
  23 // parameters in the CDB                                                  //
  24 // It alsotakes DCS data, does spline fits                                //
  25 // and stores both reference data and spline fits results                 //
  26 // in the CDB                                                             //
  27 //                                                                        //
  28 // Authors:                                                               //
  29 //   R. Bailhache (R.Bailhache@gsi.de)                                    //
  30 //   W. Monange   (w.monange@gsi.de)                                      //
  31 //   F. Kramer    (kramer@ikf.uni-frankfurt.de)                           //
  32 //                                                                        //
  33 ////////////////////////////////////////////////////////////////////////////
  34
  35 #include <fstream>
  36
  37 #include <TFile.h>
  38 #include <TProfile2D.h>
  39 #include <TObjString.h>
  40 #include <TString.h>
  41 #include <TList.h>
  42 #include <TSAXParser.h>
  43
  44 #include "AliCDBMetaData.h"
  45 #include "AliLog.h"
  46
  47 #include "AliTRDPreprocessor.h"
  48 #include "AliTRDSensorArray.h"
  49 #include "AliTRDCalibraFit.h"
  50 #include "AliTRDCalibraMode.h"
  51 #include "AliTRDCalibPadStatus.h"
  52 #include "AliTRDSaxHandler.h"
  53 #include "AliTRDgeometry.h"
  54 #include "Cal/AliTRDCalPad.h"
  55 #include "Cal/AliTRDCalPadStatus.h"
  56 #include "Cal/AliTRDCalDCS.h"
  57 #include "Cal/AliTRDCalSingleChamberStatus.h"
  58 #include "Cal/AliTRDCalROC.h"
  59
  60 ClassImp(AliTRDPreprocessor)
  61
  62 //______________________________________________________________________________________________
  63 AliTRDPreprocessor::AliTRDPreprocessor(AliShuttleInterface *shuttle)
  64   :AliPreprocessor("TRD", shuttle)
  65   ,fVdriftHLT(0)
  66 {
  67   //
  68   // Constructor
  69   //
  70
  71   AddRunType("PHYSICS");
  72   AddRunType("STANDALONE");
  73   AddRunType("PEDESTAL");
  74   AddRunType("DAQ");
  75
  76 }
  77
  78 //______________________________________________________________________________________________
  79 AliTRDPreprocessor::~AliTRDPreprocessor()
  80 {
  81   //
  82   // Destructor
  83   //
  84
  85 }
  86
  87 //______________________________________________________________________________________________
  88 void AliTRDPreprocessor::Initialize(Int_t run, UInt_t startTime, UInt_t endTime)
  89 {
  90   //
  91   // Initialization routine for the TRD preprocessor
  92   //
  93
  94   AliPreprocessor::Initialize(run,startTime,endTime);
  95
  96 }
  97
  98 //______________________________________________________________________________________________
  99 UInt_t AliTRDPreprocessor::Process(TMap* dcsAliasMap)
 100 {
 101   //
 102   // Process DCS and calibration part for HLT
 103   //
 104
 105   TString runType = GetRunType();
 106   Log(Form("runtype %s\n",runType.Data()));
 107
 108   // always process the configuration data
 109   Int_t DCSConfigReturn = ProcessDCSConfigData();
 110   if(DCSConfigReturn) return DCSConfigReturn;
 111
 112   if (runType=="PEDESTAL"){
 113     if(ExtractPedestals()) return 1;
 114     return 0;
 115   }
 116
 117   if ((runType=="PHYSICS") || (runType=="STANDALONE") || (runType=="DAQ")){
 118     // DCS
 119     if(ProcessDCS(dcsAliasMap)) return 1;
 120     if(runType=="PHYSICS"){
 121       // HLT if On
 122       //TString runPar = GetRunParameter("HLTStatus");
 123       //if(runPar=="1") {
 124       if(GetHLTStatus()) {
 125         //if(ExtractHLT()) return 1; // for testing!
 126         ExtractHLT();
 127       }
 128       // DAQ if HLT failed
 129       if(!fVdriftHLT) {
 130         //if(ExtractDriftVelocityDAQ()) return 1;
 131         ExtractDriftVelocityDAQ(); // for testing!
 132       }
 133     }
 134   }
 135
 136   return 0;
 137
 138 }
 139 //______________________________________________________________________________
 140 Bool_t AliTRDPreprocessor::ProcessDCS()
 141 {
 142   //
 143   // Default process DCS method
 144   //
 145
 146   TString runType = GetRunType();
 147   if ((runType == "PHYSICS") || (runType == "STANDALONE")) {
 148     return kTRUE;
 149   }
 150   return kFALSE;
 151
 152 }
 153
 154 //______________________________________________________________________________
 155 Bool_t AliTRDPreprocessor::ProcessDCS(TMap *dcsAliasMap)
 156 {
 157   //
 158   // Process DCS method
 159   //
 160
 161   Bool_t error = kFALSE;
 162
 163   AliCDBMetaData metaData;
 164   metaData.SetBeamPeriod(0);
 165   metaData.SetResponsible("Wilfried Monange/Raphaelle Bailhache");
 166   metaData.SetComment("TRD calib test");
 167
 168   Log("****** DCS ******\n");
 169
 170   TObjArray * list=AliTRDSensorArray::GetList ();
 171
 172   if (list == 0x0) {
 173     Log ("Error during AliTRDSensorArray::GetList");
 174     Log ("DCS will not be processing");
 175     return kTRUE;
 176   }
 177
 178   Int_t nEntries = list->GetEntries ();
 179   Log (Form ("%d alias loaded", nEntries));
 180
 181   Bool_t * results=new Bool_t [nEntries];
 182   Int_t  * nGraph=new Int_t [nEntries];
 183
 184   for (Int_t iAlias = 0; iAlias < nEntries; iAlias++) {
 185
 186     AliTRDSensorArray * oneTRDDCS = (AliTRDSensorArray *)list->At (iAlias);
 187
 188     oneTRDDCS->SetStartTime (TTimeStamp (fStartTime));
 189     oneTRDDCS->SetEndTime (TTimeStamp (fEndTime));
 190
 191     Log(Form("Processing DCS : \"%s\"", oneTRDDCS->GetStoreName ().Data ()));
 192
 193     TMap * map;
 194
 195     map=oneTRDDCS->ExtractDCS (dcsAliasMap);
 196
 197     nGraph [iAlias] = map->GetEntries ();
 198
 199     if (nGraph [iAlias] == 0) {
 200       Log("No TGraph for this dcsDatapointAlias : not stored");
 201       results [iAlias] = kFALSE;
 202       //error  = kTRUE;
 203       continue;
 204     }
 205
 206     oneTRDDCS->SetGraph(map);
 207     results[iAlias]=Store("Calib", oneTRDDCS->GetStoreName().Data(), oneTRDDCS, &metaData, 0, kFALSE);
 208     delete map;
 209
 210     //results [iAlias] = StoreReferenceData("Calib", oneTRDDCS->GetStoreName ().Data (), oneTRDDCS, &metaData);
 211
 212     if (!results[iAlias]) {
 213       AliError("Problem during StoreRef DCS");
 214       //error=kTRUE;
 215     }
 216
 217     //BEGIN TEST (should not be removed ...)
 218     /*
 219     oneTRDDCS->ClearGraph();
 220     oneTRDDCS->ClearFit();
 221     oneTRDDCS->SetDiffCut2 (0.1);
 222     map=oneTRDDCS->ExtractDCS (dcsAliasMap);
 223     oneTRDDCS->SetGraph (map);
 224     Store("Calib", ("cut_"+oneTRDDCS->GetStoreName()).Data(), oneTRDDCS, &metaData, 0, kTRUE);
 225     delete map;
 226
 227
 228     if(iAlias==1 || iAlias==19) continue;
 229
 230     oneTRDDCS->ClearGraph();
 231     oneTRDDCS->ClearFit();
 232     oneTRDDCS->SetDiffCut2(0);
 233     map=oneTRDDCS->ExtractDCS(dcsAliasMap);
 234     oneTRDDCS->MakeSplineFit(map);
 235     Store("Calib", ("fit_"+oneTRDDCS->GetStoreName()).Data() , oneTRDDCS, &metaData, 0, kTRUE);
 236     delete map;
 237
 238
 239     oneTRDDCS->ClearGraph();
 240     oneTRDDCS->ClearFit();
 241     oneTRDDCS->SetDiffCut2 (0.1);
 242     map=oneTRDDCS->ExtractDCS (dcsAliasMap);
 243     oneTRDDCS->MakeSplineFit(map);
 244     Store("Calib", ("cutfit_"+oneTRDDCS->GetStoreName()).Data() , oneTRDDCS, &metaData, 0, kTRUE);
 245     delete map;
 246     */
 247     //END TEST
 248
 249   }
 250
 251   // Check errors
 252   Int_t nbCount = 0;
 253   for (Int_t iAlias = 0; iAlias < nEntries; iAlias++) {
 254     if (results[iAlias]) {
 255       nbCount++;
 256     }
 257   }
 258   if(nbCount == 0) error = kTRUE;
 259
 260
 261   Log ("         Summury of DCS :\n");
 262   Log (Form("%30s %10s %10s", "dcsDatapointAlias", "Stored ?", "# graph"));
 263   for (Int_t iAlias = 0; iAlias < nEntries; iAlias++) {
 264     AliTRDSensorArray * oneTRDDCS = (AliTRDSensorArray *)list->At (iAlias);
 265     Log (Form ("%30s %10s %4d",
 266                oneTRDDCS->GetStoreName ().Data (),
 267                results[iAlias] ? "ok" : "X",
 268                nGraph [iAlias]));
 269   }
 270   Log ("*********** End of DCS **********");
 271
 272   delete results;
 273   delete nGraph;
 274
 275   return error;
 276
 277 }
 278
 279 //______________________________________________________________________________________________
 280 Bool_t AliTRDPreprocessor::ExtractPedestals()
 281 {
 282   //
 283   // Pedestal running on LDCs at the DAQ
 284   //
 285
 286   //
 287   // The reference data are stored in:
 288   // PadStatus1 for sm-00-01-02-09-10-11
 289   // PadStatus2 for sm-03-04-05-12-13-14
 290   // PadStatus3 for sm-06-07-08-15-16-17
 291   // PadStatus0 if nothing found..means problems
 292   //
 293
 294   Bool_t error = kFALSE;
 295
 296   // Init a AliTRDCalibPadStatus
 297   AliTRDCalibPadStatus calPedSum = AliTRDCalibPadStatus();
 298
 299   AliCDBMetaData metaData;
 300   metaData.SetBeamPeriod(0);
 301   metaData.SetResponsible("Raphaelle Bailhache");
 302   metaData.SetComment("TRD calib test");
 303
 304   // Sum the contributions of the LDCs
 305   TList * listpad = GetFileSources(kDAQ,"PADSTATUS");
 306   if (!listpad) {
 307     Log("No list found for the PEDESTRAL Run");
 308     return kTRUE;
 309   }
 310
 311   // loop through all files from LDCs
 312   UInt_t index = 0;
 313   while (listpad->At(index)!=NULL) {
 314     TObjString* fileNameEntry = (TObjString*) listpad->At(index);
 315     if (fileNameEntry != NULL)
 316       {
 317         TString fileName = GetFile(kDAQ, "PADSTATUS",
 318                                    fileNameEntry->GetString().Data());
 319         if(fileName.Length() ==0){
 320           Log(Form("Error by retrieving the file %d for the pedestal",(Int_t)index));
 321           delete listpad;
 322           return kTRUE;
 323         }
 324
 325         TFile *f = TFile::Open(fileName);
 326         AliTRDCalibPadStatus *calPed;
 327         f->GetObject("calibpadstatus",calPed);
 328
 329         if(calPed){
 330
 331           Int_t ldc = 0;
 332
 333           // analyse
 334           //calPed->AnalyseHisto();
 335
 336           // Add to the calPedSum
 337           for (Int_t idet=0; idet<540; idet++) {
 338             AliTRDCalROC *rocMean  = calPed->GetCalRocMean(idet, kFALSE);
 339             if ( rocMean )  {
 340               calPedSum.SetCalRocMean(rocMean,idet);
 341               ldc = (Int_t) (idet / 30);
 342             }
 343             AliTRDCalROC *rocRMS = calPed->GetCalRocRMS(idet, kFALSE);
 344             if ( rocRMS )  {
 345               calPedSum.SetCalRocRMS(rocRMS,idet);
 346             }
 347             AliTRDCalROC *rocMeand  = calPed->GetCalRocMeand(idet, kFALSE);
 348             if ( rocMeand )  {
 349               calPedSum.SetCalRocMeand(rocMeand,idet);
 350             }
 351             AliTRDCalROC *rocRMSd = calPed->GetCalRocRMSd(idet, kFALSE);
 352             if ( rocRMSd )  {
 353               calPedSum.SetCalRocRMSd(rocRMSd,idet);
 354             }
 355           }// det loop
 356
 357           if((ldc==0) || (ldc==1) || (ldc==2)) ldc = 1;
 358           if((ldc==3) || (ldc==4) || (ldc==5)) ldc = 2;
 359           if((ldc==6) || (ldc==7) || (ldc==8)) ldc = 3;
 360           if((ldc==9) || (ldc==10) || (ldc==11)) ldc = 4;
 361           if((ldc==12) || (ldc==13) || (ldc==14)) ldc = 5;
 362           if((ldc==15) || (ldc==16) || (ldc==17)) ldc = 6;
 363
 364           // store as reference data
 365           TString name("PadStatus");
 366           name += ldc;
 367           if(!StoreReferenceData("DAQData",(const char *)name,(TObject *) calPed,&metaData)){
 368             Log(Form("Error storing AliTRDCalibPadStatus object %d as reference data",(Int_t)index));
 369             error = kTRUE;
 370           }
 371
 372         } // calPed
 373       } // fileNameEntry
 374     ++index;
 375   }// while (list)
 376
 377   Log(Form("%d elements found in the list for the pedestal",(Int_t)index));
 378   if(index==0){
 379     delete listpad;
 380     return kTRUE;
 381   }
 382
 383   //
 384   // Create pedestal
 385   //
 386
 387   // Create Pad Status
 388   AliTRDCalPadStatus *calPadStatus = calPedSum.CreateCalPadStatus();
 389   // Create Noise
 390   //Make the AliTRDCalPad
 391   AliTRDCalPad *calPad2 = calPedSum.CreateCalPad();
 392   //Make the AliTRDCalDet correspondant
 393   AliTRDCalDet *calDet = calPedSum.CreateCalDet();
 394
 395   //
 396   // Take the noise and Pad status from the previous OCDB
 397   //
 398
 399   AliTRDCalPad *calPadPrevious=0;
 400   AliCDBEntry* entry = GetFromOCDB("Calib", "PadNoise");
 401   if (entry) calPadPrevious = (AliTRDCalPad*)entry->GetObject();
 402   if ( calPadPrevious==NULL ) {
 403      Log("AliTRDPreprocsessor: No previous TRD pad noise entry available.\n");
 404      calPadPrevious = new AliTRDCalPad("PadNoise", "PadNoise");
 405   }
 406
 407   AliTRDCalPadStatus *calPadStatusPrevious=0;
 408   entry = GetFromOCDB("Calib", "PadStatus");
 409   if (entry) calPadStatusPrevious = (AliTRDCalPadStatus*)entry->GetObject();
 410   if ( calPadStatusPrevious==NULL ) {
 411     Log("AliTRDPreprocsessor: No previous TRD pad status entry available.\n");
 412     calPadStatusPrevious = new AliTRDCalPadStatus("padstatus", "padstatus");
 413     for (Int_t idet=0; idet<540; ++idet)
 414       {
 415         AliTRDCalSingleChamberStatus *calROC = calPadStatusPrevious->GetCalROC(idet);
 416         for(Int_t k = 0; k < calROC->GetNchannels(); k++){
 417           calROC->SetStatus(k,AliTRDCalPadStatus::kMasked);
 418         }
 419       }
 420   }
 421
 422
 423   // Loop over detectors for check
 424   for (Int_t det=0; det<AliTRDgeometry::kNdet; ++det)  {
 425
 426     // noise
 427     AliTRDCalROC *calROCPreviousNoise = calPadPrevious->GetCalROC(det);
 428     AliTRDCalROC *calROCNoise         = calPad2->GetCalROC(det);
 429
 430     // padstatus
 431     AliTRDCalSingleChamberStatus *calROCPreviousStatus = calPadStatusPrevious->GetCalROC(det);
 432     AliTRDCalSingleChamberStatus *calROCStatus         = calPadStatus->GetCalROC(det);
 433
 434
 435     // loop over first half and second half chamber
 436     for(Int_t half = 0; half < 2; half++){
 437
 438       Bool_t data         = AreThereDataPedestal(calROCStatus,(Bool_t)half);
 439       //printf("There are data for the detector %d the half %d: %d\n",det,half,data);
 440       if(!data){
 441         // look if data in the OCDB
 442         Bool_t dataPrevious = AreThereDataPedestal(calROCPreviousStatus,(Bool_t)half);
 443         // if no data at all, set to default value
 444         if(!dataPrevious){
 445           SetDefaultStatus(*calROCStatus,(Bool_t)half);
 446           SetDefaultNoise(*calROCNoise,(Bool_t)half);
 447         }
 448         else{
 449           // if data, set to previous value
 450           SetStatus(*calROCStatus,calROCPreviousStatus,(Bool_t)half);
 451           SetNoise(*calROCNoise,calROCPreviousNoise,(Bool_t)half);
 452         }
 453       }
 454     }
 455   }
 456
 457   //
 458   // Store
 459   //
 460
 461   AliCDBMetaData md3;
 462   md3.SetObjectClassName("AliTRDCalPadStatus");
 463   md3.SetResponsible("Raphaelle Bailhache");
 464   md3.SetBeamPeriod(1);
 465   md3.SetComment("TRD calib test");
 466   if(!Store("Calib","PadStatus"    ,(TObject *)calPadStatus, &md3, 0, kTRUE)){
 467     Log("Error storing the pedestal");
 468     delete listpad;
 469     return kTRUE;
 470   }
 471
 472   AliCDBMetaData md4;
 473   md4.SetObjectClassName("AliTRDCalPad");
 474   md4.SetResponsible("Raphaelle Bailhache");
 475   md4.SetBeamPeriod(1);
 476   md4.SetComment("TRD calib test");
 477   if(!Store("Calib","PadNoise"    ,(TObject *)calPad2, &md4, 0, kTRUE)){
 478     Log("Error storing the pedestal");
 479     delete listpad;
 480     return kTRUE;
 481   }
 482
 483   AliCDBMetaData md5;
 484   md5.SetObjectClassName("AliTRDCalDet");
 485   md5.SetResponsible("Raphaelle Bailhache");
 486   md5.SetBeamPeriod(1);
 487   md5.SetComment("TRD calib test");
 488   if(!Store("Calib","DetNoise"    ,(TObject *)calDet, &md5, 0, kTRUE)){
 489     Log("Error storing the pedestal");
 490     delete listpad;
 491     return kTRUE;
 492   }
 493
 494   delete listpad;
 495   return error;
 496
 497 }
 498
 499 //__________________________________________________________________
 500 Bool_t AliTRDPreprocessor::AreThereDataPedestal(AliTRDCalSingleChamberStatus * const calROCStatus
 501                                               , Bool_t second)
 502 {
 503
 504   //
 505   // Data for this half chamber
 506   //
 507
 508   Bool_t data         = kFALSE;
 509   Int_t nCols         = calROCStatus->GetNcols();
 510   Int_t nCol0         = 0;
 511   Int_t nColE         = (Int_t) nCols/2 - 2;
 512   if(second) {
 513     nCol0 = nColE + 4;
 514     nColE = nCols;
 515   }
 516
 517   Int_t totalnumberofpads = 0;
 518   Int_t totalnumberofdata = 0;
 519
 520   for(Int_t col = nCol0; col < nColE; col++){
 521     for(Int_t row = 0; row < calROCStatus->GetNrows(); row++){
 522       totalnumberofpads++;
 523       //printf("ismasked %d\n",(Int_t)calROCStatus->IsMasked(col,row));
 524       if(!calROCStatus->GetStatus(col,row)) {
 525         data = kTRUE;
 526         totalnumberofdata++;
 527       }
 528     }
 529   }
 530   if(totalnumberofdata < (Int_t)(totalnumberofpads/2)) data = kFALSE;
 531
 532   return data;
 533
 534 }
 535 //__________________________________________________________________
 536 void AliTRDPreprocessor::SetDefaultStatus(AliTRDCalSingleChamberStatus &calROCStatus, Bool_t second){
 537
 538   //
 539   // default status for this half chamber
 540   //
 541
 542   Int_t nCols         = calROCStatus.GetNcols();
 543   Int_t nCol0         = 0;
 544   Int_t nColE         = (Int_t) nCols/2;
 545   if(second) {
 546     nCol0 = nColE;
 547     nColE = nCols;
 548   }
 549   for(Int_t col = nCol0; col < nColE; col++){
 550     for(Int_t row = 0; row < calROCStatus.GetNrows(); row++){
 551       calROCStatus.SetStatus(col,row,0);
 552     }
 553   }
 554 }
 555 //__________________________________________________________________
 556 void AliTRDPreprocessor::SetStatus(AliTRDCalSingleChamberStatus &calROCStatus, AliTRDCalSingleChamberStatus *calROCStatusPrevious,Bool_t second){
 557
 558   //
 559   // previous status for this half chamber
 560   //
 561
 562   Int_t nCols         = calROCStatus.GetNcols();
 563   Int_t nCol0         = 0;
 564   Int_t nColE         = (Int_t) nCols/2;
 565   if(second) {
 566     nCol0 = nColE;
 567     nColE = nCols;
 568   }
 569   for(Int_t col = nCol0; col < nColE; col++){
 570     for(Int_t row = 0; row < calROCStatus.GetNrows(); row++){
 571       calROCStatus.SetStatus(col,row,calROCStatusPrevious->GetStatus(col,row));
 572     }
 573   }
 574 }
 575 //__________________________________________________________________
 576 void AliTRDPreprocessor::SetDefaultNoise(AliTRDCalROC &calROCNoise, Bool_t second){
 577
 578   //
 579   // default noise for this half chamber
 580   //
 581
 582   Int_t nCols         = calROCNoise.GetNcols();
 583   Int_t nCol0         = 0;
 584   Int_t nColE         = (Int_t) nCols/2;
 585   if(second) {
 586     nCol0 = nColE;
 587     nColE = nCols;
 588   }
 589   for(Int_t col = nCol0; col < nColE; col++){
 590     for(Int_t row = 0; row < calROCNoise.GetNrows(); row++){
 591       calROCNoise.SetValue(col,row,0.12);
 592     }
 593   }
 594 }
 595 //__________________________________________________________________
 596 void AliTRDPreprocessor::SetNoise(AliTRDCalROC &calROCNoise, AliTRDCalROC *calROCNoisePrevious, Bool_t second){
 597
 598   //
 599   // previous noise for this half chamber
 600   //
 601
 602   Int_t nCols         = calROCNoise.GetNcols();
 603   Int_t nCol0         = 0;
 604   Int_t nColE         = (Int_t) nCols/2;
 605   if(second) {
 606     nCol0 = nColE;
 607     nColE = nCols;
 608   }
 609   for(Int_t col = nCol0; col < nColE; col++){
 610     for(Int_t row = 0; row < calROCNoise.GetNrows(); row++){
 611       calROCNoise.SetValue(col,row,calROCNoisePrevious->GetValue(col,row));
 612     }
 613   }
 614 }
 615 //______________________________________________________________________________________________
 616 Bool_t AliTRDPreprocessor::ExtractDriftVelocityDAQ()
 617 {
 618   //
 619   // Drift velocity DA running on monitoring servers at the DAQ
 620   //
 621
 622   Bool_t error = kFALSE;
 623
 624   // Objects for HLT and DAQ zusammen
 625   AliTRDCalibraFit *calibra = AliTRDCalibraFit::Instance();
 626   AliCDBMetaData metaData;
 627   metaData.SetBeamPeriod(0);
 628   metaData.SetResponsible("Raphaelle Bailhache");
 629   metaData.SetComment("TRD calib test");
 630   // Store the infos for the detector
 631   AliCDBMetaData md1;
 632   md1.SetObjectClassName("AliTRDCalDet");
 633   md1.SetResponsible("Raphaelle Bailhache");
 634   md1.SetBeamPeriod(0);
 635   md1.SetComment("TRD calib test");
 636   // Store the infos for the pads
 637   AliCDBMetaData md2;
 638   md2.SetObjectClassName("AliTRDCalPad");
 639   md2.SetResponsible("Raphaelle Bailhache");
 640   md2.SetBeamPeriod(0);
 641   md2.SetComment("TRD calib test");
 642
 643   // Take the file from the DAQ file exchange server
 644   TList *listdaq = GetFileSources(kDAQ,"VDRIFT");
 645   if (!listdaq) {
 646     Log("No list found for vdrift (DAQ)");
 647     return kTRUE;
 648   }
 649
 650   if(listdaq->GetSize() !=1){
 651     Log(Form("Problem on the size of the list: %d (DAQ)",listdaq->GetSize()));
 652     delete listdaq;
 653     return kTRUE;
 654   }
 655
 656   TObjString* fileNameEntry = (TObjString*) listdaq->At(0);
 657   if(fileNameEntry != NULL){
 658     TString fileName = GetFile(kDAQ, "VDRIFT",
 659                                fileNameEntry->GetString().Data());
 660     if(fileName.Length() ==0){
 661       Log("Error retrieving the file vdrift (DAQ)");
 662       delete listdaq;
 663       return kTRUE;
 664     }
 665     TFile *filedaq = TFile::Open(fileName);
 666     TProfile2D *histodriftvelocity = (TProfile2D *) filedaq->Get("PH2d");
 667     if (histodriftvelocity) {
 668
 669       // store as reference data
 670       if(!StoreReferenceData("DAQData","VdriftT0",(TObject *) histodriftvelocity,&metaData)){
 671         Log("Error storing 2D Profile for vdrift from the DAQ");
 672         error = kTRUE;
 673       }
 674
 675       // analyse
 676
 677       Log("Take the PH reference data. Now we will try to fit\n");
 678       calibra->SetMinEntries(2000); // If there is less than 2000
 679       calibra->AnalysePH(histodriftvelocity);
 680
 681       Int_t nbtg = 6*4*18*((Int_t) ((AliTRDCalibraMode *)calibra->GetCalibraMode())->GetDetChamb0(1))
 682         + 6*  18*((Int_t) ((AliTRDCalibraMode *)calibra->GetCalibraMode())->GetDetChamb2(1));
 683       Int_t nbfit        = calibra->GetNumberFit();
 684       Int_t nbfitSuccess = calibra->GetNumberFitSuccess();
 685       Int_t nbE        = calibra->GetNumberEnt();
 686
 687       // if enough statistics store the results
 688       if ((nbtg >                  0) &&
 689           (nbfit        >= 0.5*nbE) && (nbE > 30) && (nbfitSuccess > 30)) {
 690         // create the cal objects
 691         calibra->RemoveOutliers(1,kTRUE);
 692         calibra->PutMeanValueOtherVectorFit(1,kTRUE);
 693         calibra->RemoveOutliers2(kTRUE);
 694         calibra->PutMeanValueOtherVectorFit2(1,kTRUE);
 695         TObjArray object      = calibra->GetVectorFit();
 696         AliTRDCalDet *objdriftvelocitydet = calibra->CreateDetObjectVdrift(&object,kTRUE);
 697         TObject *objdriftvelocitypad = calibra->CreatePadObjectVdrift();
 698         object              = calibra->GetVectorFit2();
 699         AliTRDCalDet *objtime0det         = calibra->CreateDetObjectT0(&object,kTRUE);
 700         TObject *objtime0pad         = calibra->CreatePadObjectT0();
 701         calibra->ResetVectorFit();
 702         // store
 703         if(!Store("Calib","ChamberVdrift"    ,(TObject *) objdriftvelocitydet,&md1,0,kTRUE)){
 704           Log("Error storing the calibration object for the chamber vdrift (DAQ)");
 705           error = kTRUE;
 706         }
 707         if(!Store("Calib","ChamberT0"        ,(TObject *) objtime0det        ,&md1,0,kTRUE)){
 708           Log("Error storing the calibration object for the chamber t0 (DAQ)");
 709           error = kTRUE;
 710         }
 711         if(!Store("Calib","LocalVdrift"      ,(TObject *) objdriftvelocitypad,&md2,0,kTRUE)){
 712           Log("Error storing the calibration object for the local drift velocity (DAQ)");
 713           error = kTRUE;
 714         }
 715         if(!Store("Calib","LocalT0"          ,(TObject *) objtime0pad        ,&md2,0,kTRUE)){
 716           Log("Error storing the calibration object for the local time0 (DAQ)");
 717           error = kTRUE;
 718         }
 719       }
 720       else{
 721         Log("Not enough statistics for the average pulse height (DAQ)");
 722       }
 723     } // histo here
 724   }// if fileNameEntry
 725
 726   delete listdaq;
 727   return error;
 728
 729 }
 730
 731 //______________________________________________________________________________________________
 732 Bool_t AliTRDPreprocessor::ExtractHLT()
 733 {
 734   //
 735   // Gain, vdrift and PRF calibration running on HLT
 736   // return kTRUE if NULL pointer to the list
 737   //
 738
 739   Bool_t error = kFALSE;
 740
 741   // Objects for HLT and DAQ zusammen
 742   AliTRDCalibraFit *calibra = AliTRDCalibraFit::Instance();
 743   AliCDBMetaData metaData;
 744   metaData.SetBeamPeriod(0);
 745   metaData.SetResponsible("Raphaelle Bailhache");
 746   metaData.SetComment("TRD calib test");
 747   // Store the infos for the detector
 748   AliCDBMetaData md1;
 749   md1.SetObjectClassName("AliTRDCalDet");
 750   md1.SetResponsible("Raphaelle Bailhache");
 751   md1.SetBeamPeriod(0);
 752   md1.SetComment("TRD calib test");
 753   // Store the infos for the pads
 754   AliCDBMetaData md2;
 755   md2.SetObjectClassName("AliTRDCalPad");
 756   md2.SetResponsible("Raphaelle Bailhache");
 757   md2.SetBeamPeriod(0);
 758   md2.SetComment("TRD calib test");
 759
 760   // Take the file from the HLT file exchange server
 761   TList *listhlt = GetFileSources(kHLT,"GAINDRIFTPRF");
 762   if (!listhlt) {
 763     Log("No list found for the HLT");
 764     return kTRUE;
 765   }
 766
 767   if(listhlt->GetSize() != 1) {
 768     Log(Form("Problem on the size of the list: %d (HLT)",listhlt->GetSize()));
 769     delete listhlt;
 770     return kTRUE;
 771   }
 772
 773   TObjString* fileNameEntry = (TObjString*) listhlt->At(0);
 774   if(fileNameEntry != NULL){
 775     TString fileName = GetFile(kHLT, "GAINDRIFTPRF",
 776                                fileNameEntry->GetString().Data());
 777     if(fileName.Length() ==0){
 778       Log("Error retrieving the file (HLT)");
 779       delete listhlt;
 780       return kTRUE;
 781     }
 782     // Take the file
 783     TFile *filehlt = TFile::Open(fileName);
 784
 785     // gain
 786     TH2I *histogain = (TH2I *) filehlt->Get("CH2d");
 787     histogain->SetDirectory(0);
 788     if (histogain) {
 789       // store the reference data
 790       if(!StoreReferenceData("HLTData","Gain",(TObject *) histogain,&metaData)){
 791         Log("Error storing 2D histos for gain");
 792         error = kTRUE;
 793       }
 794       // analyse
 795       Log("Take the CH reference data. Now we will try to fit\n");
 796       calibra->SetMinEntries(800); // If there is less than 1000 entries in the histo: no fit
 797       calibra->AnalyseCH(histogain);
 798       Int_t nbtg = 6*4*18*((Int_t) ((AliTRDCalibraMode *)calibra->GetCalibraMode())->GetDetChamb0(0))
 799         + 6*  18*((Int_t) ((AliTRDCalibraMode *)calibra->GetCalibraMode())->GetDetChamb2(0));
 800       Int_t nbfit       = calibra->GetNumberFit();
 801       Int_t nbE         = calibra->GetNumberEnt();
 802       // enough statistics
 803       if ((nbtg >                  0) &&
 804           (nbfit        >= 0.5*nbE) && (nbE > 30)) {
 805         // create the cal objects
 806         calibra->PutMeanValueOtherVectorFit(1,kTRUE);
 807         TObjArray object           = calibra->GetVectorFit();
 808         AliTRDCalDet *objgaindet   = calibra->CreateDetObjectGain(&object);
 809         TObject *objgainpad        = calibra->CreatePadObjectGain();
 810         // store them
 811         if(!Store("Calib","ChamberGainFactor",(TObject *) objgaindet         ,&md1,0,kTRUE)){
 812           Log("Error storing the calibration object for the chamber gain");
 813           error = kTRUE;
 814         }
 815         if(!Store("Calib","LocalGainFactor"  ,(TObject *) objgainpad         ,&md2,0,kTRUE)){
 816           Log("Error storing the calibration object for the local gain factor");
 817           error = kTRUE;
 818         }
 819       }
 820       calibra->ResetVectorFit();
 821     }// if histogain
 822
 823     // vdrift
 824     fVdriftHLT = kFALSE;
 825     TProfile2D *histodriftvelocity = (TProfile2D *) filehlt->Get("PH2d");
 826     histodriftvelocity->SetDirectory(0);
 827     if (histodriftvelocity) {
 828       // store the reference data
 829       if(!StoreReferenceData("HLTData","VdriftT0",(TObject *) histodriftvelocity,&metaData)){
 830         Log("Error storing 2D Profile for average pulse height (HLT)");
 831         error = kTRUE;
 832       }
 833       // analyse
 834       Log("Take the PH reference data. Now we will try to fit\n");
 835       calibra->SetMinEntries(800*20); // If there is less than 20000
 836       calibra->AnalysePH(histodriftvelocity);
 837       Int_t nbtg = 6*4*18*((Int_t) ((AliTRDCalibraMode *)calibra->GetCalibraMode())->GetDetChamb0(1))
 838         + 6*  18*((Int_t) ((AliTRDCalibraMode *)calibra->GetCalibraMode())->GetDetChamb2(1));
 839       Int_t nbfit        = calibra->GetNumberFit();
 840       Int_t nbfitSuccess = calibra->GetNumberFitSuccess();
 841       Int_t nbE          = calibra->GetNumberEnt();
 842       // enough statistics
 843       if ((nbtg >                  0) &&
 844           (nbfit        >= 0.5*nbE) && (nbE > 30) && (nbfitSuccess > 30)) {
 845         // create the cal objects
 846         calibra->RemoveOutliers(1,kTRUE);
 847         calibra->PutMeanValueOtherVectorFit(1,kTRUE);
 848         calibra->RemoveOutliers2(kTRUE);
 849         calibra->PutMeanValueOtherVectorFit2(1,kTRUE);
 850         TObjArray object  = calibra->GetVectorFit();
 851         AliTRDCalDet *objdriftvelocitydet = calibra->CreateDetObjectVdrift(&object,kTRUE);
 852         TObject *objdriftvelocitypad      = calibra->CreatePadObjectVdrift();
 853         object              = calibra->GetVectorFit2();
 854         AliTRDCalDet *objtime0det  = calibra->CreateDetObjectT0(&object,kTRUE);
 855         TObject *objtime0pad       = calibra->CreatePadObjectT0();
 856         // store them
 857         if(!Store("Calib","ChamberVdrift"    ,(TObject *) objdriftvelocitydet,&md1,0,kTRUE)){
 858           Log("Error storing the calibration object for the chamber vdrift (HLT)");
 859           error = kTRUE;
 860         }
 861         if(!Store("Calib","ChamberT0"        ,(TObject *) objtime0det        ,&md1,0,kTRUE)){
 862           Log("Error storing the calibration object for the chamber t0 (HLT)");
 863           error = kTRUE;
 864         }
 865         if(!Store("Calib","LocalVdrift"      ,(TObject *) objdriftvelocitypad,&md2,0,kTRUE)){
 866           Log("Error storing the calibration object for the local drift velocity (HLT)");
 867           error = kTRUE;
 868         }
 869         if(!Store("Calib","LocalT0"          ,(TObject *) objtime0pad        ,&md2,0,kTRUE)){
 870           Log("Error storing the calibration object for the local time0 (HLT)");
 871           error = kTRUE;
 872         }
 873         fVdriftHLT = kTRUE;
 874       }
 875       calibra->ResetVectorFit();
 876     }// if TProfile2D
 877
 878     // prf
 879     TProfile2D *histoprf = (TProfile2D *) filehlt->Get("PRF2d");
 880     histoprf->SetDirectory(0);
 881     if (histoprf) {
 882       // store reference data
 883       if(!StoreReferenceData("HLTData","PRF",(TObject *) histoprf,&metaData)){
 884         Log("Error storing the 2D Profile for Pad Response Function");
 885         error = kTRUE;
 886       }
 887       // analyse
 888       Log("Take the PRF reference data. Now we will try to fit\n");
 889       calibra->SetMinEntries(600); // If there is less than 20000
 890       calibra->AnalysePRFMarianFit(histoprf);
 891       Int_t nbtg = 6*4*18*((Int_t) ((AliTRDCalibraMode *)calibra->GetCalibraMode())->GetDetChamb0(2))
 892         + 6*  18*((Int_t) ((AliTRDCalibraMode *)calibra->GetCalibraMode())->GetDetChamb2(2));
 893       Int_t nbfit        = calibra->GetNumberFit();
 894       Int_t nbE          = calibra->GetNumberEnt();
 895       // enough statistics
 896       if ((nbtg >                  0) &&
 897           (nbfit        >= 0.95*nbE) && (nbE > 30)) {
 898         // create cal pad objects
 899         TObjArray object            = calibra->GetVectorFit();
 900         TObject *objPRFpad          = calibra->CreatePadObjectPRF(&object);
 901         // store them
 902         if(!Store("Calib","PRFWidth"         ,(TObject *) objPRFpad          ,&md2,0,kTRUE)){
 903           Log("Error storing the calibration object for the Pad Response Function");
 904           error = kTRUE;
 905         }
 906       }
 907       calibra->ResetVectorFit();
 908     }// if PRF
 909   }// if fileNameEntry
 910
 911   delete listhlt;
 912   return error;
 913
 914 }
 915
 916 //_____________________________________________________________________________
 917 UInt_t AliTRDPreprocessor::ProcessDCSConfigData()
 918 {
 919   //
 920   // process the configuration of FEE, PTR and GTU
 921   // reteive XML filei(s) from the DCS FXS
 922   // parse it/them and store TObjArrays in the CDB
 923   //
 924   // return 0 for success, otherwise:
 925   //  5 : Could not get the (SOR and EOR) or SOR file from the FXS
 926   //  8 : Both files are not valid
 927   // 10 : SOR XML is not well-formed
 928   // 11 : EOR XML is not well-formed
 929   // 12 : ERROR in SOR XML SAX validation: something wrong with the content
 930   // 12 : ERROR in EOR XML SAX validation: something wrong with the content
 931   // 14 : ERROR while creating SOR calibration objects in the handler
 932   // 15 : ERROR while creating EOR calibration objects in the handler
 933   // 16 : ERROR while storing data in the CDB
 934   //
 935
 936   Log("Processing the DCS config summary files.");
 937
 938   // get the XML files
 939   Log("Requesting the 2 summaryfiles from the FXS..");
 940   TString xmlFileS = GetFile(kDCS,"CONFIGSUMMARYSOR","");
 941   TString xmlFileE = GetFile(kDCS,"CONFIGSUMMARYEOR","");
 942   // Request EOR and SOR files from the fxs, if both are not found exit
 943
 944   Bool_t fileExistE = kTRUE, fileExistS = kTRUE;
 945
 946   // check if the files are there
 947   if (xmlFileS.IsNull()) {
 948           Log(Form("Warning: SOR file %s not found!", xmlFileS.Data()));
 949     fileExistS = kFALSE;
 950   } else Log(Form("SOR file found: %s", xmlFileS.Data()));
 951
 952   if (xmlFileE.IsNull()) {
 953     Log(Form("Warning: EOR file %s not found!", xmlFileE.Data()));
 954     fileExistE = kFALSE;
 955   } else Log(Form("EOR file found: %s", xmlFileE.Data()));
 956
 957   if (fileExistS==0 && fileExistE==0) {
 958     Log(Form("ERROR: SOR and EOR files not found: %s and %s", xmlFileS.Data(), xmlFileE.Data()));
 959     return 5;
 960   }
 961
 962   // test the files
 963   if (fileExistS) {
 964     Log("Checking if SOR file is valid.");
 965     std::ifstream fileTestS;
 966     fileTestS.open(xmlFileS.Data(), std::ios_base::binary | std::ios_base::in);
 967     if (!fileTestS.good() || fileTestS.eof() || !fileTestS.is_open()) {
 968       Log(Form("Warning: File %s not valid!",xmlFileS.Data()));
 969       fileExistS = kFALSE;
 970       return 5;
 971     }
 972     Log("Checking if SOR file is not empty.");
 973     fileTestS.seekg(0, std::ios_base::end);
 974     if (static_cast<int>(fileTestS.tellg()) < 2) {
 975       Log(Form("Warning: File %s is empty!",xmlFileS.Data()));
 976       fileExistS = kFALSE;
 977       return 5;
 978     }
 979   }
 980
 981
 982   if (fileExistE) {
 983     Log("Checking if EOR file is valid.");
 984     std::ifstream fileTestE;
 985     fileTestE.open(xmlFileE.Data(), std::ios_base::binary | std::ios_base::in);
 986     if (!fileTestE.good() || fileTestE.eof() || !fileTestE.is_open()) {
 987       Log(Form("Warning: File %s not valid!",xmlFileE.Data()));
 988       fileExistE = kFALSE;
 989     }
 990     Log("Checking if EOR file is not empty.");
 991     fileTestE.seekg(0, std::ios_base::end);
 992     if (static_cast<int>(fileTestE.tellg()) < 2) {
 993       Log(Form("Warning: File %s is empty!",xmlFileE.Data()));
 994       fileExistE = kFALSE;
 995     }
 996   }
 997
 998   if (fileExistS==0 && fileExistE==0) {
 999     Log("ERROR: Both files (SOR/EOR) are not valid!");
1000     return 8;
1001   }
1002
1003   Log("One or both of the tested files are valid.");
1004
1005   // make a robust XML validation
1006   TSAXParser testParser;
1007   if (fileExistS && testParser.ParseFile(xmlFileS.Data()) < 0 ) {
1008     Log("ERROR: XML content (SOR) is not well-formed.");
1009     return 10;
1010   } else if (fileExistE && testParser.ParseFile(xmlFileE.Data()) < 0 ) {
1011     Log("ERROR: XML content (EOR) is not well-formed.");
1012     return 11;
1013   }
1014   Log("XML contents are well-formed.");
1015
1016   // create parser and parse
1017   TSAXParser saxParserS, saxParserE;
1018   AliTRDSaxHandler saxHandlerS, saxHandlerE;
1019   if (fileExistS) {
1020     saxParserS.ConnectToHandler("AliTRDSaxHandler", &saxHandlerS);
1021     saxParserS.ParseFile(xmlFileS.Data());
1022   }
1023   if (fileExistE) {
1024     saxParserE.ConnectToHandler("AliTRDSaxHandler", &saxHandlerE);
1025     saxParserE.ParseFile(xmlFileE.Data());
1026   }
1027   // report errors of the parser if present
1028   if (fileExistS && saxParserS.GetParseCode() != 0) {
1029     Log(Form("ERROR in XML file validation. SOR Parse Code: %s", saxParserS.GetParseCode()));
1030     return 12;
1031   }
1032   if (fileExistE && saxParserE.GetParseCode() != 0) {
1033     Log(Form("ERROR in XML file validation. EOR Parse Code: %s", saxParserE.GetParseCode()));
1034     return 13;
1035   }
1036   Log("XML file validation OK.");
1037   // report errors of the handler if present
1038   if (fileExistS && saxHandlerS.GetHandlerStatus() != 0) {
1039     Log(Form("ERROR while creating calibration objects. SOR Error code: %s", saxHandlerS.GetHandlerStatus()));
1040     return 14;
1041   }
1042   if (fileExistE && saxHandlerE.GetHandlerStatus() != 0) {
1043     Log(Form("ERROR while creating calibration objects. EOR Error code: %s", saxHandlerE.GetHandlerStatus()));
1044     return 15;
1045   }
1046   Log("SAX handler reports no errors.");
1047
1048   // put both objects in one TObjArray to store them
1049   TObjArray* fCalObjArray = new TObjArray(2);
1050   fCalObjArray->SetOwner();
1051
1052   // get the calibration object storing the data from the handler
1053   if (fileExistS) {
1054     AliTRDCalDCS* fCalDCSObjSOR = saxHandlerS.GetCalDCSObj();
1055     fCalDCSObjSOR->EvaluateGlobalParameters();
1056     fCalDCSObjSOR->SetRunType(GetRunType());
1057     fCalDCSObjSOR->SetStartTime(GetStartTimeDCSQuery());
1058     fCalDCSObjSOR->SetEndTime(GetEndTimeDCSQuery());
1059     fCalObjArray->AddAt(fCalDCSObjSOR,0);
1060     Log("TRDCalDCS object for SOR created.");
1061   }
1062
1063   if (fileExistE) {
1064     AliTRDCalDCS* fCalDCSObjEOR = saxHandlerE.GetCalDCSObj();
1065     fCalDCSObjEOR->EvaluateGlobalParameters();
1066     fCalDCSObjEOR->SetRunType(GetRunType());
1067     fCalDCSObjEOR->SetStartTime(GetStartTimeDCSQuery());
1068     fCalDCSObjEOR->SetEndTime(GetEndTimeDCSQuery());
1069     fCalObjArray->AddAt(fCalDCSObjEOR,1);
1070     Log("TRDCalDCS object for EOR created.");
1071   }
1072
1073   // store the DCS calib data in the CDB
1074   AliCDBMetaData metaData1;
1075   metaData1.SetBeamPeriod(0);
1076   metaData1.SetResponsible("Frederick Kramer");
1077   metaData1.SetComment("DCS configuration data in two AliTRDCalDCS objects in one TObjArray (0:SOR, 1:EOR).");
1078   if (!Store("Calib", "DCS", fCalObjArray, &metaData1, 0, kTRUE)) {
1079     Log("problems while storing DCS config data object");
1080     return 16;
1081   } else {
1082     Log("DCS config data object stored.");
1083   }
1084
1085   //delete fCalObjArray;
1086
1087   Log("SUCCESS: Processing of the DCS config summary file DONE.");
1088   return 0;
1089 }
1090
1091