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 // Author:                                                                //
  29 //   R. Bailhache (R.Bailhache@gsi.de)                                    //
  30 //   W. Monange   (w.monange@gsi.de)                                      //
  31 //                                                                        //
  32 ////////////////////////////////////////////////////////////////////////////
  33
  34 #include "AliTRDPreprocessor.h"
  35
  36 #include <TFile.h>
  37 #include <TProfile2D.h>
  38 #include <TStopwatch.h>
  39 #include <TObjString.h>
  40 #include <TString.h>
  41 #include <TList.h>
  42 #include <TCollection.h>
  43
  44 #include "AliCDBMetaData.h"
  45 #include "AliLog.h"
  46
  47 #include "AliTRDSensorArray.h"
  48 #include "AliTRDCalibraFit.h"
  49 #include "AliTRDCalibraMode.h"
  50 #include "AliTRDCalibPadStatus.h"
  51 #include "Cal/AliTRDCalDet.h"
  52 #include "Cal/AliTRDCalPadStatus.h"
  53
  54 ClassImp(AliTRDPreprocessor)
  55
  56 //______________________________________________________________________________________________
  57 AliTRDPreprocessor::AliTRDPreprocessor(AliShuttleInterface *shuttle)
  58   :AliPreprocessor("TRD", shuttle),
  59   fResult(0),
  60   fVdriftHLT(0)
  61 {
  62   //
  63   // Constructor
  64   //
  65
  66 }
  67
  68 //______________________________________________________________________________________________
  69 AliTRDPreprocessor::~AliTRDPreprocessor()
  70 {
  71   //
  72   // Destructor
  73   //
  74
  75 }
  76
  77 //______________________________________________________________________________________________
  78 void AliTRDPreprocessor::Initialize(Int_t run, UInt_t startTime, UInt_t endTime)
  79 {
  80   //
  81   // Initialization routine for the TRD preprocessor
  82   //
  83
  84   AliPreprocessor::Initialize(run,startTime,endTime);
  85
  86 }
  87
  88 //______________________________________________________________________________________________
  89 UInt_t AliTRDPreprocessor::Process(TMap* dcsAliasMap)
  90 {
  91   //
  92   // Process DCS and calibration part for HLT
  93   //
  94
  95   fResult = 0;
  96
  97   //
  98   // DCS
  99   //
 100
 101   ProcessDCS(dcsAliasMap);
 102
 103   //
 104   // Process the calibration data for the HLT and DAQ part
 105   //
 106
 107   TString runType = GetRunType();
 108   printf("runtype %s\n",(const char*)runType);
 109
 110
 111   if (strcmp(runType, "PEDESTAL") == 0){
 112     ExtractPedestals();
 113   }
 114
 115   if (strcmp(runType, "PHYSICS") == 0){
 116     printf("test\n");
 117     //if(GetRunParameter("HLTStatus")==1) ExtractHLT();
 118     ExtractHLT();
 119     ExtractDriftVelocityDAQ();
 120   }
 121   printf("result is %d\n",fResult);
 122   return fResult;
 123
 124 }
 125
 126
 127 //______________________________________________________________________________
 128 void AliTRDPreprocessor::ProcessDCS(TMap * dcsAliasMap)
 129 {
 130
 131   AliCDBMetaData metaData;
 132   metaData.SetBeamPeriod(0);
 133   metaData.SetResponsible("Wilfried Monange/Raphaelle Bailhache");
 134   metaData.SetComment("TRD calib test");
 135
 136
 137   Log ("****** DCS ******\n");
 138
 139   TObjArray * list = AliTRDSensorArray::GetList ();
 140
 141   if (list == 0x0) {
 142     Log ("Error during AliTRDSensorArray::GetList");
 143     Log ("DCS will not be processing");
 144     return;
 145   }
 146
 147   Int_t nEntries = list->GetEntries ();
 148   Log (Form ("%d alias loaded", nEntries));
 149
 150   Bool_t * results=new Bool_t [nEntries];
 151   Int_t  * nGraph=new Int_t [nEntries];
 152
 153   for (Int_t iAlias = 0; iAlias < nEntries; iAlias++) {
 154
 155     AliTRDSensorArray * oneTRDDCS = (AliTRDSensorArray *)list->At (iAlias);
 156
 157     oneTRDDCS->SetStartTime (TTimeStamp (fStartTime));
 158     oneTRDDCS->SetEndTime (TTimeStamp (fEndTime));
 159
 160     Log (Form("Processing DCS : \"%s\"", oneTRDDCS->GetStoreName ().Data ()));
 161
 162     TMap * map;
 163
 164     map=oneTRDDCS->ExtractDCS (dcsAliasMap);
 165
 166     nGraph [iAlias] = map->GetEntries ();
 167
 168     if (nGraph [iAlias] == 0) {
 169       Log("No TGraph for this dcsDatapointAlias : not stored");
 170       results [iAlias] = kFALSE;
 171       continue;
 172     }
 173
 174     oneTRDDCS->SetGraph(map);
 175     results[iAlias]=Store("Calib", oneTRDDCS->GetStoreName().Data(), oneTRDDCS, &metaData, 0, kTRUE);
 176     delete map;
 177
 178     //results [iAlias] = StoreReferenceData("Calib", oneTRDDCS->GetStoreName ().Data (), oneTRDDCS, &metaData);
 179
 180
 181     if (!results[iAlias]) {
 182       AliError("Problem during StoreRef DCS");
 183       fResult|=kEStore;
 184     }
 185
 186
 187     //BEGIN TEST (should not be removed ...)
 188     /*
 189     oneTRDDCS->ClearGraph();
 190     oneTRDDCS->ClearFit();
 191     oneTRDDCS->SetDiffCut2 (0.1);
 192     map=oneTRDDCS->ExtractDCS (dcsAliasMap);
 193     oneTRDDCS->SetGraph (map);
 194     Store("Calib", ("cut_"+oneTRDDCS->GetStoreName()).Data(), oneTRDDCS, &metaData, 0, kTRUE);
 195     delete map;
 196
 197
 198     if(iAlias==1 || iAlias==19) continue;
 199
 200     oneTRDDCS->ClearGraph();
 201     oneTRDDCS->ClearFit();
 202     oneTRDDCS->SetDiffCut2(0);
 203     map=oneTRDDCS->ExtractDCS(dcsAliasMap);
 204     oneTRDDCS->MakeSplineFit(map);
 205     Store("Calib", ("fit_"+oneTRDDCS->GetStoreName()).Data() , oneTRDDCS, &metaData, 0, kTRUE);
 206     delete map;
 207
 208
 209     oneTRDDCS->ClearGraph();
 210     oneTRDDCS->ClearFit();
 211     oneTRDDCS->SetDiffCut2 (0.1);
 212     map=oneTRDDCS->ExtractDCS (dcsAliasMap);
 213     oneTRDDCS->MakeSplineFit(map);
 214     Store("Calib", ("cutfit_"+oneTRDDCS->GetStoreName()).Data() , oneTRDDCS, &metaData, 0, kTRUE);
 215     delete map;
 216     */
 217     //END TEST
 218
 219
 220
 221   }
 222
 223   Log ("         Summury of DCS :\n");
 224   Log (Form("%30s %10s %10s", "dcsDatapointAlias", "Stored ?", "# graph"));
 225   for (Int_t iAlias = 0; iAlias < nEntries; iAlias++) {
 226     AliTRDSensorArray * oneTRDDCS = (AliTRDSensorArray *)list->At (iAlias);
 227     Log (Form ("%30s %10s %4d",
 228                oneTRDDCS->GetStoreName ().Data (),
 229                results[iAlias] ? "ok" : "X",
 230                nGraph [iAlias]));
 231   }
 232   Log ("*********** End of DCS **********");
 233
 234   delete results;
 235   delete nGraph;
 236
 237
 238 }
 239
 240 //______________________________________________________________________________________________
 241 void AliTRDPreprocessor::ExtractPedestals()
 242 {
 243   //
 244   // Pedestal running on LDCs at the DAQ
 245   //
 246
 247   // Init a AliTRDCalibPadStatus
 248   AliTRDCalibPadStatus calPedSum = AliTRDCalibPadStatus();
 249
 250   AliCDBMetaData metaData;
 251   metaData.SetBeamPeriod(0);
 252   metaData.SetResponsible("Raphaelle Bailhache");
 253   metaData.SetComment("TRD calib test");
 254
 255   // Sum the contributions of the LDCs
 256   TList * listpad = GetFileSources(kDAQ,"PADSTATUS");
 257   if (listpad) {
 258
 259     // loop through all files from LDCs
 260
 261     UInt_t index = 0;
 262     while (listpad->At(index)!=NULL) {
 263       TObjString* fileNameEntry = (TObjString*) listpad->At(index);
 264       if (fileNameEntry != NULL) {
 265         TString fileName = GetFile(kDAQ, "PADSTATUS",
 266                                    fileNameEntry->GetString().Data());
 267         if(fileName.Length() !=0){
 268           TFile *f = TFile::Open(fileName);
 269           AliTRDCalibPadStatus *calPed;
 270           f->GetObject("calibpadstatus",calPed);
 271
 272           if(calPed){
 273
 274             // analyse
 275             calPed->AnalyseHisto();
 276
 277             // store as reference data
 278             TString name("PadStatus");
 279             name += (Int_t)index;
 280             if(!StoreReferenceData("DAQData",(const char *)name,(TObject *) calPed,&metaData)){
 281               Log(Form("Error storing AliTRDCalibPadStatus object %d as reference data",(Int_t)index));
 282               fResult |= kEStore;
 283             }
 284
 285
 286             // Add to the calPedSum
 287             for (Int_t idet=0; idet<540; idet++) {
 288               AliTRDCalROC *rocMean  = calPed->GetCalRocMean(idet, kFALSE);
 289               if ( rocMean )  calPedSum.SetCalRocMean(rocMean,idet);
 290               AliTRDCalROC *rocRMS = calPed->GetCalRocRMS(idet, kFALSE);
 291               if ( rocRMS )  calPedSum.SetCalRocRMS(rocRMS,idet);
 292             }// det loop
 293
 294           } // calPed
 295         }
 296         else{
 297           Log(Form("Error by retrieving the file %d for the pedestal",(Int_t)index));
 298           fResult |= kEGetFileDAQ;
 299         }
 300       }// fileNameEntry length
 301       ++index;
 302     }// while (list)
 303     Log(Form("%d elements found in the list for the pedestal",(Int_t)index));
 304     if(index==0){
 305       fResult |= kEEmptyListDAQ;
 306     }
 307     //
 308     // Store pedestal entry to OCDB
 309     //
 310
 311
 312     // Create Pad Status
 313     AliTRDCalPadStatus *calPadStatus = calPedSum.CreateCalPadStatus();
 314     AliCDBMetaData md3;
 315     md3.SetObjectClassName("AliTRDCalPadStatus");
 316     md3.SetResponsible("Raphaelle Bailhache");
 317     md3.SetBeamPeriod(1);
 318     md3.SetComment("TRD calib test");
 319     if(!Store("Calib","PadStatus"    ,(TObject *)calPadStatus, &md3, 0, kTRUE)){
 320       Log("Error storing the pedestal");
 321       fResult |= kEStore;
 322     }
 323     delete listpad;
 324   }
 325   else {
 326     Log("No list found for the PEDESTRAL Run");
 327     fResult |= kEGetFileDAQ;
 328   }
 329
 330
 331 }
 332 //______________________________________________________________________________________________
 333 void AliTRDPreprocessor::ExtractDriftVelocityDAQ()
 334 {
 335   //
 336   // Drift velocity DA running on monitoring servers at the DAQ
 337   //
 338
 339
 340   // Objects for HLT and DAQ zusammen
 341   AliTRDCalibraFit *calibra = AliTRDCalibraFit::Instance();
 342   AliCDBMetaData metaData;
 343   metaData.SetBeamPeriod(0);
 344   metaData.SetResponsible("Raphaelle Bailhache");
 345   metaData.SetComment("TRD calib test");
 346   // Store the infos for the detector
 347   AliCDBMetaData md1;
 348   md1.SetObjectClassName("AliTRDCalDet");
 349   md1.SetResponsible("Raphaelle Bailhache");
 350   md1.SetBeamPeriod(0);
 351   md1.SetComment("TRD calib test");
 352   // Store the infos for the pads
 353   AliCDBMetaData md2;
 354   md2.SetObjectClassName("AliTRDCalPad");
 355   md2.SetResponsible("Raphaelle Bailhache");
 356   md2.SetBeamPeriod(0);
 357   md2.SetComment("TRD calib test");
 358
 359
 360
 361
 362   // Take the file from the DAQ file exchange server
 363   TList *listdaq = GetFileSources(kDAQ,"VDRIFT");
 364   if (listdaq) {
 365     if(listdaq->GetSize() ==1){
 366       TObjString* fileNameEntry = (TObjString*) listdaq->At(0);
 367       if(fileNameEntry != NULL){
 368         TString fileName = GetFile(kDAQ, "VDRIFT",
 369                                    fileNameEntry->GetString().Data());
 370         if(fileName.Length() !=0){
 371           TFile *filedaq = TFile::Open(fileName);
 372           TProfile2D *histodriftvelocity = (TProfile2D *) filedaq->Get("PH2d");
 373           if (histodriftvelocity) {
 374
 375             // store as reference data
 376             if(!StoreReferenceData("DAQData","VdriftT0",(TObject *) histodriftvelocity,&metaData)){
 377               Log("Error storing 2D Profile for vdrift from the DAQ");
 378               fResult |= kEStore;
 379             }
 380
 381             // analyse
 382             if(!fVdriftHLT){
 383               Log("Take the PH reference data. Now we will try to fit\n");
 384               calibra->SetMinEntries(2000); // If there is less than 2000
 385               calibra->AnalysePH(histodriftvelocity);
 386
 387               Int_t nbtg = 6*4*18*((Int_t) ((AliTRDCalibraMode *)calibra->GetCalibraMode())->GetDetChamb0(1))
 388                 + 6*  18*((Int_t) ((AliTRDCalibraMode *)calibra->GetCalibraMode())->GetDetChamb2(1));
 389               Int_t nbfit        = calibra->GetNumberFit();
 390               Int_t nbE        = calibra->GetNumberEnt();
 391
 392               // if enough statistics store the results
 393               if ((nbtg >                  0) &&
 394                   (nbfit        >= 0.95*nbE)) {
 395                 // create the cal objects
 396                 TObjArray object      = calibra->GetVectorFit();
 397                 AliTRDCalDet *objdriftvelocitydet = calibra->CreateDetObjectVdrift(&object,kTRUE);
 398                 TObject *objdriftvelocitypad = calibra->CreatePadObjectVdrift();
 399                 object              = calibra->GetVectorFit2();
 400                 AliTRDCalDet *objtime0det         = calibra->CreateDetObjectT0(&object,kTRUE);
 401                 TObject *objtime0pad         = calibra->CreatePadObjectT0();
 402                 calibra->ResetVectorFit();
 403                 // store
 404                 if(!Store("Calib","ChamberVdrift"    ,(TObject *) objdriftvelocitydet,&md1,0,kTRUE)){
 405                   Log("Error storing the calibration object for the chamber vdrift (DAQ)");
 406                   fResult |= kEStore;
 407                 }
 408                 if(!Store("Calib","ChamberT0"        ,(TObject *) objtime0det        ,&md1,0,kTRUE)){
 409                   Log("Error storing the calibration object for the chamber t0 (DAQ)");
 410                   fResult |= kEStore;
 411                 }
 412                 if(!Store("Calib","LocalVdrift"      ,(TObject *) objdriftvelocitypad,&md2,0,kTRUE)){
 413                   Log("Error storing the calibration object for the local drift velocity (DAQ)");
 414                   fResult |= kEStore;
 415                 }
 416                 if(!Store("Calib","LocalT0"          ,(TObject *) objtime0pad        ,&md2,0,kTRUE)){
 417                   Log("Error storing the calibration object for the local time0 (DAQ)");
 418                   fResult |= kEStore;
 419                 }
 420               }
 421               else{
 422                 Log("Not enough statistics for the average pulse height (DAQ)");
 423               }
 424             } // analyse
 425           } // histo here
 426         }
 427         else{
 428           Log("Error retrieving the file vdrift (DAQ)");
 429           if(!fVdriftHLT) fResult |= kEGetFileDAQ;
 430         }
 431       }// if fileNameEntry
 432     } // size DAQ list
 433     else{
 434       Log(Form("Problem on the size of the list: %d (DAQ)",listdaq->GetSize()));
 435       if(!fVdriftHLT) fResult |= kEEmptyListDAQ;
 436     }
 437     delete listdaq;
 438   }
 439   else{
 440     Log("No list found for vdrift (DAQ)");
 441     if(!fVdriftHLT){
 442       fResult |= kEGetFileDAQ;
 443     }
 444   }
 445
 446 }
 447 //______________________________________________________________________________________________
 448 void AliTRDPreprocessor::ExtractHLT()
 449 {
 450   //
 451   // Gain, vdrift and PRF calibration running on HLT
 452   // return kFALSE if NULL pointer to the list
 453   //
 454
 455
 456   // Objects for HLT and DAQ zusammen
 457   AliTRDCalibraFit *calibra = AliTRDCalibraFit::Instance();
 458   AliCDBMetaData metaData;
 459   metaData.SetBeamPeriod(0);
 460   metaData.SetResponsible("Raphaelle Bailhache");
 461   metaData.SetComment("TRD calib test");
 462   // Store the infos for the detector
 463   AliCDBMetaData md1;
 464   md1.SetObjectClassName("AliTRDCalDet");
 465   md1.SetResponsible("Raphaelle Bailhache");
 466   md1.SetBeamPeriod(0);
 467   md1.SetComment("TRD calib test");
 468   // Store the infos for the pads
 469   AliCDBMetaData md2;
 470   md2.SetObjectClassName("AliTRDCalPad");
 471   md2.SetResponsible("Raphaelle Bailhache");
 472   md2.SetBeamPeriod(0);
 473   md2.SetComment("TRD calib test");
 474
 475
 476   // Take the file from the HLT file exchange server
 477   TList *listhlt = GetFileSources(kHLT,"GAINDRIFTPRF");
 478   if (listhlt) {
 479     if (listhlt->GetSize() == 1) {
 480       TObjString* fileNameEntry = (TObjString*) listhlt->At(0);
 481       if(fileNameEntry != NULL){
 482         TString fileName = GetFile(kHLT, "GAINDRIFTPRF",
 483                                    fileNameEntry->GetString().Data());
 484         if(fileName.Length() !=0){
 485           // Take the file
 486           TFile *filehlt = TFile::Open(fileName);
 487
 488
 489           // gain
 490           TH2I *histogain = (TH2I *) filehlt->Get("CH2d");
 491           histogain->SetDirectory(0);
 492           if (histogain) {
 493             // store the reference data
 494             if(!StoreReferenceData("HLTData","Gain",(TObject *) histogain,&metaData)){
 495               Log("Error storing 2D histos for gain");
 496               fResult |= kEStore;
 497             }
 498             // analyse
 499             Log("Take the CH reference data. Now we will try to fit\n");
 500             calibra->SetMinEntries(1000); // If there is less than 1000 entries in the histo: no fit
 501             calibra->AnalyseCH(histogain);
 502             Int_t nbtg = 6*4*18*((Int_t) ((AliTRDCalibraMode *)calibra->GetCalibraMode())->GetDetChamb0(0))
 503               + 6*  18*((Int_t) ((AliTRDCalibraMode *)calibra->GetCalibraMode())->GetDetChamb2(0));
 504             Int_t nbfit       = calibra->GetNumberFit();
 505             Int_t nbE         = calibra->GetNumberEnt();
 506             // enough statistics
 507             if ((nbtg >                  0) &&
 508                 (nbfit        >= 0.95*nbE)) {
 509               // create the cal objects
 510               TObjArray object           = calibra->GetVectorFit();
 511               AliTRDCalDet *objgaindet   = calibra->CreateDetObjectGain(&object,calibra->GetScaleFitFactor(),kTRUE);
 512               TObject *objgainpad        = calibra->CreatePadObjectGain();
 513               // store them
 514               if(!Store("Calib","ChamberGainFactor",(TObject *) objgaindet         ,&md1,0,kTRUE)){
 515                 Log("Error storing the calibration object for the chamber gain");
 516                 fResult |= kEStore;
 517               }
 518               if(!Store("Calib","LocalGainFactor"  ,(TObject *) objgainpad         ,&md2,0,kTRUE)){
 519                 Log("Error storing the calibration object for the local gain factor");
 520                 fResult |= kEStore;
 521               }
 522             }
 523             calibra->ResetVectorFit();
 524           }// if histogain
 525
 526
 527
 528           // vdrift
 529           fVdriftHLT = kFALSE;
 530           TProfile2D *histodriftvelocity = (TProfile2D *) filehlt->Get("PH2d");
 531           histodriftvelocity->SetDirectory(0);
 532           if (histodriftvelocity) {
 533             // store the reference data
 534             if(!StoreReferenceData("HLTData","VdriftT0",(TObject *) histodriftvelocity,&metaData)){
 535               Log("Error storing 2D Profile for average pulse height (HLT)");
 536               fResult |= kEStore;
 537             }
 538             // analyse
 539             Log("Take the PH reference data. Now we will try to fit\n");
 540             calibra->SetMinEntries(1000*20); // If there is less than 20000
 541             calibra->AnalysePH(histodriftvelocity);
 542             Int_t nbtg = 6*4*18*((Int_t) ((AliTRDCalibraMode *)calibra->GetCalibraMode())->GetDetChamb0(1))
 543               + 6*  18*((Int_t) ((AliTRDCalibraMode *)calibra->GetCalibraMode())->GetDetChamb2(1));
 544             Int_t nbfit        = calibra->GetNumberFit();
 545             Int_t nbE          = calibra->GetNumberEnt();
 546             // enough statistics
 547             if ((nbtg >                  0) &&
 548                 (nbfit        >= 0.95*nbE)) {
 549               // create the cal objects
 550               TObjArray object  = calibra->GetVectorFit();
 551               AliTRDCalDet *objdriftvelocitydet = calibra->CreateDetObjectVdrift(&object,kTRUE);
 552               TObject *objdriftvelocitypad      = calibra->CreatePadObjectVdrift();
 553               object              = calibra->GetVectorFit2();
 554               AliTRDCalDet *objtime0det  = calibra->CreateDetObjectT0(&object,kTRUE);
 555               TObject *objtime0pad       = calibra->CreatePadObjectT0();
 556               // store them
 557               if(!Store("Calib","ChamberVdrift"    ,(TObject *) objdriftvelocitydet,&md1,0,kTRUE)){
 558                 Log("Error storing the calibration object for the chamber vdrift (HLT)");
 559                 fResult |= kEStore;
 560               }
 561               if(!Store("Calib","ChamberT0"        ,(TObject *) objtime0det        ,&md1,0,kTRUE)){
 562                 Log("Error storing the calibration object for the chamber t0 (HLT)");
 563                 fResult |= kEStore;
 564               }
 565               if(!Store("Calib","LocalVdrift"      ,(TObject *) objdriftvelocitypad,&md2,0,kTRUE)){
 566                 Log("Error storing the calibration object for the local drift velocity (HLT)");
 567                 fResult |= kEStore;
 568               }
 569               if(!Store("Calib","LocalT0"          ,(TObject *) objtime0pad        ,&md2,0,kTRUE)){
 570                 Log("Error storing the calibration object for the local time0 (HLT)");
 571                 fResult |= kEStore;
 572               }
 573               fVdriftHLT = kTRUE;
 574             }
 575             calibra->ResetVectorFit();
 576           }// if TProfile2D
 577
 578
 579           // prf
 580           TProfile2D *histoprf = (TProfile2D *) filehlt->Get("PRF2d");
 581           histoprf->SetDirectory(0);
 582           if (histoprf) {
 583             // store reference data
 584             if(!StoreReferenceData("HLTData","PRF",(TObject *) histoprf,&metaData)){
 585               Log("Error storing the 2D Profile for Pad Response Function");
 586               fResult |= kEStore;
 587             }
 588             // analyse
 589             Log("Take the PRF reference data. Now we will try to fit\n");
 590             calibra->SetMinEntries(600); // If there is less than 20000
 591             calibra->AnalysePRFMarianFit(histoprf);
 592             Int_t nbtg = 6*4*18*((Int_t) ((AliTRDCalibraMode *)calibra->GetCalibraMode())->GetDetChamb0(2))
 593               + 6*  18*((Int_t) ((AliTRDCalibraMode *)calibra->GetCalibraMode())->GetDetChamb2(2));
 594             Int_t nbfit        = calibra->GetNumberFit();
 595             Int_t nbE          = calibra->GetNumberEnt();
 596             // enough statistics
 597             if ((nbtg >                  0) &&
 598                 (nbfit        >= 0.95*nbE)) {
 599               // create cal pad objects
 600               TObjArray object            = calibra->GetVectorFit();
 601               TObject *objPRFpad          = calibra->CreatePadObjectPRF(&object);
 602               // store them
 603               if(!Store("Calib","PRFWidth"         ,(TObject *) objPRFpad          ,&md2,0,kTRUE)){
 604                 Log("Error storing the calibration object for the Pad Response Function");
 605                 fResult |= kEStore;
 606               }
 607             }
 608             calibra->ResetVectorFit();
 609           }// if PRF
 610         }
 611         else{
 612           Log("Error retrieving the file (HLT)");
 613           fResult |= kEGetFileHLT;
 614         }
 615       } // fileNameEntry
 616     } // if HLT size of tlist
 617     else{
 618       Log(Form("Problem on the size of the list: %d (HLT)",listhlt->GetSize()));
 619       fResult |= kEEmptyListHLT;
 620     }
 621     delete listhlt;
 622   } //if HLT tlist
 623   else{
 624     Log("No list found for the HLT");
 625     fResult |= kEGetFileHLT;
 626   }
 627
 628 }