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