T0/AliT0Preprocessor.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 /*
  17 $Log: AliT0Preprocessor.cxx,v $
  18 Revision 1.8  2007/12/07 15:22:51  alla
  19 bug fixed by Alberto
  20
  21 Revision 1.7  2007/12/06 16:35:24  alla
  22 new bugs fixed by Tomek
  23
  24 Revision 1.5  2007/11/23 19:28:52  alla
  25 bug fixed
  26
  27 Version 2.1  2007/11/21
  28 Preprocessor storing data to OCDB (T.Malkiewicz)
  29
  30 Version 1.1  2006/10
  31 Preliminary test version (T.Malkiewicz)
  32 */
  33 // T0 preprocessor:
  34 // 1) takes data from DCS and passes it to the class AliTOFDataDCS
  35 // for processing and writes the result to the Reference DB.
  36 // 2) takes data form DAQ (both from Laser Calibration and Physics runs),
  37 // processes it, and stores either to OCDB or to Reference DB.
  38
  39
  40 #include "AliT0Preprocessor.h"
  41 #include "AliT0DataDCS.h"
  42 #include "AliT0CalibWalk.h"
  43 #include "AliT0CalibTimeEq.h"
  44
  45 #include "AliCDBMetaData.h"
  46 #include "AliDCSValue.h"
  47 #include "AliCDBEntry.h"
  48 #include "AliLog.h"
  49
  50 #include <TTimeStamp.h>
  51 #include <TFile.h>
  52 #include <TObjString.h>
  53 #include <TNamed.h>
  54 #include "AliT0Dqclass.h"
  55 #include "TClass.h"
  56
  57 #include "iostream"
  58
  59
  60 ClassImp(AliT0Preprocessor)
  61
  62 //____________________________________________________
  63 AliT0Preprocessor::AliT0Preprocessor(AliShuttleInterface* shuttle) :
  64   AliPreprocessor("T00", shuttle),
  65   fData(0)
  66 {
  67   //constructor
  68   AddRunType("PHYSICS");
  69   AddRunType("STANDALONE");
  70   AddRunType("LASER");
  71 }
  72 //____________________________________________________
  73
  74 AliT0Preprocessor::~AliT0Preprocessor()
  75 {
  76   //destructor
  77   delete fData;
  78   fData = 0;
  79 }
  80 //____________________________________________________
  81
  82 void AliT0Preprocessor::Initialize(Int_t run, UInt_t startTime, UInt_t endTime)
  83 {
  84   // Creates AliT0DataDCS object
  85   AliPreprocessor::Initialize(run, startTime, endTime);
  86   AliInfo(Form("\n\tRun %d \n\tStartTime %s \n\tEndTime %s", run, TTimeStamp(startTime).AsString(), TTimeStamp(endTime).AsString()));
  87   fData = new AliT0DataDCS(fRun, fStartTime, fEndTime, GetStartTimeDCSQuery(), GetEndTimeDCSQuery());
  88 }
  89 //____________________________________________________
  90
  91 Bool_t AliT0Preprocessor::ProcessDCS(){
  92         // Check whether DCS should be processed or not...
  93         TString runType = GetRunType();
  94         Log(Form("ProcessDCS - RunType: %s",runType.Data()));
  95
  96         if((runType == "STANDALONE")||
  97            (runType == "PHYSICS")||
  98            (runType == "LASER")){
  99           return kFALSE;
 100           //    return kTRUE;
 101         }else{
 102         return kFALSE;
 103         }
 104 }
 105 //____________________________________________________
 106
 107 UInt_t AliT0Preprocessor::ProcessDCSDataPoints(TMap* dcsAliasMap){
 108         // Fills data into AliT0DataDCS object
 109         Log("Processing DCS DP");
 110         Bool_t resultDCSMap=kFALSE;
 111         Bool_t resultDCSStore=kFALSE;
 112
 113         if(!dcsAliasMap)
 114         {
 115           Log("No DCS input data");
 116           return 1;
 117         }
 118         else
 119         {
 120           resultDCSMap=fData->ProcessData(*dcsAliasMap);
 121           if(!resultDCSMap)
 122           {
 123             Log("Error when processing DCS data");
 124             return 2;// return error Code for processed DCS data not stored
 125           }
 126           else
 127           {
 128             AliCDBMetaData metaDataDCS;
 129             metaDataDCS.SetBeamPeriod(0);
 130             metaDataDCS.SetResponsible("Tomasz Malkiewicz");
 131             metaDataDCS.SetComment("This preprocessor fills an AliTODataDCS object.");
 132             AliInfo("Storing DCS Data");
 133             resultDCSStore = StoreReferenceData("Calib","DCSData",fData, &metaDataDCS);
 134             if (!resultDCSStore)
 135             {
 136               Log("Some problems occurred while storing DCS data results in ReferenceDB");
 137               return 2;// return error Code for processed DCS data not stored
 138             }
 139           }
 140         }
 141         return 0;
 142 }
 143 //____________________________________________________
 144
 145 UInt_t AliT0Preprocessor::ProcessLaser(){
 146         // Processing data from DAQ Standalone run
 147   Log("Processing Laser calibration - Walk Correction");
 148
 149   //Retrieve the last T0 calibration object
 150
 151   Float_t parqtcold[24][2], parledold[24][2],parqtcnew[24][2], parlednew[24][2] , goodled[24][2], goodqtc[24][2];
 152
 153   //  std::cout<<"sizeof "<<sizeof(parqtcold)<<std::endl;
 154   memset(parqtcold, 0, sizeof(parqtcold));
 155   memset(parqtcnew, 0, sizeof(parqtcnew));
 156   memset(parledold, 0, sizeof(parledold));
 157   memset(parlednew, 0, sizeof(parlednew));
 158   Int_t iStore=0;
 159   Bool_t clbold = true;
 160
 161   AliT0CalibWalk* clb=0;
 162   AliCDBEntry* entryCalib = GetFromOCDB("Calib", "Slewing_Walk");
 163   if(!entryCalib)
 164     Log(Form("Cannot find any AliCDBEntry for [Calib, SlewingWalk]!"));
 165   else {
 166     clb =dynamic_cast<AliT0CalibWalk*>(entryCalib->GetObject());
 167     if(entryCalib->GetObject()->Class()->GetClassVersion() >3)
 168       {
 169         //   std::cout<<" clb->Class()->GetClassVersion() < 4  "<<entryCalib->GetObject()->Class()->GetClassVersion()<<std::endl;
 170         clbold=false;
 171         for(Int_t i=0; i<24; i++)
 172           {
 173             for(Int_t ipar=0; ipar<2; ipar++)
 174               {
 175                 //    std::cout<<"parqtcold "<<parqtcold[i][ipar]<<std::endl;
 176                 parqtcold[i][ipar] = clb->GetQTCpar(i,ipar);
 177                 parledold[i][ipar] = clb->GetLEDpar(i, ipar);
 178                 goodqtc[i][ipar] = 999;
 179                 goodled[i][ipar] = 999;
 180                 //          cout<<" old "<<i<<" "<<ipar<<" qtc "<< parqtcold[i][ipar]<<" led "<<parledold[i][ipar]<<endl;
 181               }
 182           }
 183       }
 184   } // object in existing OCDB
 185
 186     Bool_t resultLaser=kFALSE;
 187     //processing DAQ
 188     TList* list = GetFileSources(kDAQ, "LASER");
 189     if (list)
 190       {
 191         TIter iter(list);
 192         TObjString *source;
 193         while ((source = dynamic_cast<TObjString *> (iter.Next())))
 194           {
 195             const char *laserFile = GetFile(kDAQ, "LASER", source->GetName());
 196             if (laserFile)
 197               {
 198                 Log(Form("File with Id LASER found in source %s!", source->GetName()));
 199                 AliT0CalibWalk *laser = new AliT0CalibWalk();
 200                 laser->MakeWalkCorrGraph(laserFile);
 201                 //check difference with what was before
 202                 if(laser && clb && !clbold){
 203                   iStore = 1;
 204                   for(Int_t i=0; i<24; i++)
 205                     {
 206                       for(Int_t ifit=0; ifit<2; ifit++)
 207                         {
 208                           parqtcnew[i][ifit] = laser->GetQTCpar(i,ifit);
 209                           if( parqtcold[i][ifit] != 0 && parqtcnew[i][ifit] !=0)
 210                             {
 211                               goodqtc[i][ifit] =
 212                                 (parqtcnew[i][ifit] - parqtcold[i][ifit])/parqtcold[i][ifit];
 213                               //                              cout<<"qtc "<<i<<" "<<ifit<<" "<< goodqtc[i][ifit]<<endl;
 214                             }
 215                           parlednew[i][ifit] = laser->GetLEDpar(i,ifit);
 216                           if(parledold[i][ifit] != 0 && parlednew[i][ifit]!= 0 )
 217                             {
 218                               goodled[i][ifit]=
 219                                 (parlednew[i][ifit] - parledold[i][ifit])/parledold[i][ifit];
 220                               //                              cout<<"led "<<i<<" "<<ifit<<" "<< goodled[i][ifit]<<endl;
 221                             }
 222                           if(TMath::Abs(goodqtc[i][ifit])>0.1 ||
 223                              TMath::Abs(goodled[i][ifit])>0.1)
 224                             iStore = 0;
 225                         }
 226                     }
 227                 }
 228
 229                 AliCDBMetaData metaData;
 230                 metaData.SetBeamPeriod(0);
 231                 metaData.SetResponsible("Tomek&Michal");
 232                 metaData.SetComment("Walk correction from laser runs.");
 233                 if( iStore>0)
 234                   resultLaser=Store("Calib","Slewing_Walk", laser, &metaData, 0, 1);
 235                 delete laser;
 236                 Log(Form("resultLaser = %d",resultLaser));
 237               }
 238               else
 239               {
 240                 Log(Form("Could not find file with Id LASER in source %s!", source->GetName()));
 241                 return 1;
 242               }
 243             }
 244             if (!resultLaser)
 245             {
 246               Log("No Laser Data stored");
 247               return 3;//return error code for failure in storing Laser Data
 248             }
 249           } else {
 250                 Log("No sources found for id LASER!");
 251                 return 1;
 252           }
 253         return 0;
 254 }
 255 //____________________________________________________
 256
 257 UInt_t AliT0Preprocessor::ProcessPhysics(){
 258         //Processing data from DAQ Physics run
 259         Log("Processing Physics");
 260
 261         Bool_t resultOnline=kFALSE;
 262         //processing DAQ
 263         TList* listPhys = GetFileSources(kDAQ, "PHYSICS");
 264         if (listPhys)
 265           {
 266             TIter iter(listPhys);
 267             TObjString *sourcePhys;
 268             while ((sourcePhys = dynamic_cast<TObjString *> (iter.Next())))
 269             {
 270               const char *filePhys = GetFile(kDAQ, "PHYSICS", sourcePhys->GetName());
 271               if (filePhys)
 272               {
 273                 AliT0CalibTimeEq *online = new AliT0CalibTimeEq();
 274                 online->Reset();
 275                 online->ComputeOnlineParams(filePhys);
 276                 AliCDBMetaData metaData;
 277                 metaData.SetBeamPeriod(0);
 278                 metaData.SetResponsible("Tomek&Michal");
 279                 metaData.SetComment("Time equalizing result.");
 280                 resultOnline = Store("Calib","TimeDelay", online, &metaData, 0, 1);
 281                 Log(Form("resultOnline = %d",resultOnline));
 282                 delete online;
 283               }
 284                 else
 285               {
 286                 Log(Form("Could not find file with Id PHYSICS in source %s!", sourcePhys->GetName()));
 287                 return 1;
 288               }
 289
 290             }
 291             if (!resultOnline)
 292             {
 293               Log("No Data stored");
 294               return 4;//return error code for failure in storing OCDB Data
 295             }
 296           } else {
 297                 Log("No sources found for id PHYSICS!");
 298                 return 1;
 299           }
 300         return 0;
 301 }
 302 //____________________________________________________
 303
 304 UInt_t AliT0Preprocessor::ProcessCosmic(){
 305         //Processing data from DAQ Physics run
 306         Log("Processing Laser Physics");
 307
 308         Bool_t resultLaserOnline=kFALSE;
 309         //processing DAQ
 310         TList* listLaser = GetFileSources(kDAQ, "COSMIC");
 311         if (listLaser)
 312           {
 313             TIter iter(listLaser);
 314             TObjString *sourceLaser;
 315             while ((sourceLaser = dynamic_cast<TObjString *> (iter.Next())))
 316             {
 317               const char *fileLaser = GetFile(kDAQ, "COSMIC", sourceLaser->GetName());
 318               if (fileLaser)
 319               {
 320                 AliT0CalibTimeEq *onlineLaser = new AliT0CalibTimeEq();
 321                 onlineLaser->Reset();
 322                 onlineLaser->ComputeOnlineParams(fileLaser);
 323                 AliCDBMetaData metaData;
 324                 metaData.SetBeamPeriod(0);
 325                 metaData.SetResponsible("Tomek&Michal");
 326                 metaData.SetComment("Time equalizing result.");
 327                 resultLaserOnline = Store("Calib","LaserTimeDelay", onlineLaser, &metaData, 0, 1);
 328                 Log(Form("resultLaserOnline = %d",resultLaserOnline));
 329                 delete onlineLaser;
 330               }
 331                 else
 332               {
 333                 Log(Form("Could not find file with Id COSMIC in source %s!", sourceLaser->GetName()));
 334                 return 0;
 335               }
 336
 337             }
 338             if (!resultLaserOnline)
 339             {
 340               Log("No Laser Data stored");
 341               return 0;//return error code for failure in storing OCDB Data
 342             }
 343           } else {
 344                 Log("No sources found for id COSMIC!");
 345                 return 0;
 346           }
 347         return 0;
 348 }
 349 //____________________________________________________
 350
 351 UInt_t AliT0Preprocessor::Process(TMap* dcsAliasMap )
 352 {
 353   // T0 preprocessor return codes:
 354   // return=0 : all ok
 355   // return=1 : no DCS input data
 356   // return=2 : failed to store DCS data
 357   // return=3 : no Laser data (Walk correction)
 358   // return=4 : failed to store OCDB time equalized data
 359   // return=5 : no DAQ input for OCDB
 360   // return=6 : failed to retrieve DAQ data from OCDB
 361   // return=7 : failed to store T0 OCDB data
 362         Bool_t dcsDP = ProcessDCS();
 363         Log(Form("dcsDP = %d",dcsDP));
 364         TString runType = GetRunType();
 365         Log(Form("RunType: %s",runType.Data()));
 366         //processing
 367         if(runType == "STANDALONE"){
 368           if(dcsDP==1){
 369             Int_t iresultDCS = ProcessDCSDataPoints(dcsAliasMap);
 370             return iresultDCS;
 371           }
 372         }
 373         if(runType == "LASER"){
 374           Int_t iresultLaser = ProcessLaser();
 375           if(dcsDP==1){
 376             Int_t iresultDCS = ProcessDCSDataPoints(dcsAliasMap);
 377             return iresultDCS;
 378           }
 379           Log(Form("iresultLaser = %d",iresultLaser));
 380           return iresultLaser;
 381         }
 382         else if(runType == "PHYSICS"){
 383           Int_t iresultPhysics = ProcessPhysics();
 384          //      Int_t iresultCosmic = ProcessCosmic();
 385           if(dcsDP==1){
 386             Int_t iresultDCS = ProcessDCSDataPoints(dcsAliasMap);
 387             return iresultDCS;
 388           }
 389           Log(Form("iresultPhysics = %d",iresultPhysics));
 390           return iresultPhysics;
 391           //            Log(Form("iresultPhysics =iresultCosmic %d",iresultCosmic));
 392           //    return iresultCosmic;
 393         }
 394
 395         return 0;
 396 }