ZDC/AliZDCPreprocessor.cxx

   1 // --- ROOT system
   2 #include <TFile.h>
   3 #include <TClonesArray.h>
   4 #include <TList.h>
   5 #include <TObjString.h>
   6 #include <TTimeStamp.h>
   7
   8 #include "AliZDCPreprocessor.h"
   9 #include "AliCDBManager.h"
  10 #include "AliCDBEntry.h"
  11 #include "AliCDBMetaData.h"
  12 #include "AliDCSValue.h"
  13 #include "AliAlignObj.h"
  14 #include "AliAlignObjParams.h"
  15 #include "AliLog.h"
  16 #include "AliZDCDataDCS.h"
  17 #include "AliZDCChMap.h"
  18 #include "AliZDCPedestals.h"
  19 #include "AliZDCLaserCalib.h"
  20 #include "AliZDCCalib.h"
  21
  22 /////////////////////////////////////////////////////////////////////
  23 //                                                                 //
  24 // Class implementing ZDC pre-processor.                           //
  25 // It takes data from DCS and passes it to the class AliZDCDataDCS //
  26 // The class is then written to the CDB.                           //
  27 //                                                                 //
  28 /////////////////////////////////////////////////////////////////////
  29
  30 ClassImp(AliZDCPreprocessor)
  31
  32 //______________________________________________________________________________________________
  33 AliZDCPreprocessor::AliZDCPreprocessor(AliShuttleInterface* shuttle) :
  34   AliPreprocessor("ZDC", shuttle),
  35   fData(0)
  36 {
  37   // constructor
  38   AddRunType("STANDALONE_PEDESTAL");
  39   AddRunType("STANDALONE_LASER");
  40   AddRunType("STANDALONE_EMD");
  41   AddRunType("STANDALONE_COSMIC");
  42   AddRunType("STANDALONE_BC");
  43   AddRunType("PHYSICS");
  44 }
  45
  46
  47 //______________________________________________________________________________________________
  48 AliZDCPreprocessor::~AliZDCPreprocessor()
  49 {
  50   // destructor
  51 }
  52
  53
  54 //______________________________________________________________________________________________
  55 void AliZDCPreprocessor::Initialize(Int_t run, UInt_t startTime,
  56         UInt_t endTime)
  57 {
  58   // Creates AliZDCDataDCS object
  59
  60   AliPreprocessor::Initialize(run, startTime, endTime);
  61
  62         Log(Form("\n\tRun %d \n\tStartTime %s \n\tEndTime %s", run,
  63                 TTimeStamp(startTime).AsString(),
  64                 TTimeStamp(endTime).AsString()));
  65
  66         fRun = run;
  67         fStartTime = startTime;
  68         fEndTime = endTime;
  69
  70         fData = new AliZDCDataDCS(fRun, fStartTime, fEndTime);
  71 }
  72
  73 //______________________________________________________________________________________________
  74 UInt_t AliZDCPreprocessor::ProcessChMap(TString runType)
  75 {
  76   // Writing channel map in the OCDB
  77   TList* daqSource;
  78   if(runType.CompareTo("STANDALONE_PEDESTAL"))
  79     daqSource = GetFileSources(kDAQ, "PEDESTALS");
  80   else if(runType.CompareTo("STANDALONE_LASER"))
  81     daqSource = GetFileSources(kDAQ, "LASER");
  82   else if(runType.CompareTo("STANDALONE_EMD"))
  83     daqSource = GetFileSources(kDAQ, "EMDCALIB");
  84   else if(runType.CompareTo("STANDALONE_COSMIC"))
  85     daqSource = GetFileSources(kDAQ, "COSMICS");
  86   else if(runType.CompareTo("STANDALONE_BC"))
  87     daqSource = GetFileSources(kDAQ, "BC");
  88   else if(runType.CompareTo("PHYSICS"))
  89     daqSource = GetFileSources(kDAQ, "PHYSICS");
  90
  91   if(!daqSource){
  92     AliError(Form("No sources run %d for run type %s!", fRun, runType));
  93     return 1;
  94   }
  95   Log("\t List of sources "); daqSource->Print();
  96   //
  97   TIter iter(daqSource);
  98   TObjString* source = 0;
  99   Int_t isou=0;
 100   while((source = dynamic_cast<TObjString*> (iter.Next()))){
 101      Log(Form("\n\t Getting file #%d\n",++isou));
 102      TString fileName;
 103      if(runType.CompareTo("STANDALONE_PEDESTAL"))
 104       fileName = GetFile(kDAQ, "PEDESTALS", source->GetName());
 105      else if(runType.CompareTo("STANDALONE_LASER"))
 106       fileName = GetFile(kDAQ, "LASER", source->GetName());
 107      else if(runType.CompareTo("STANDALONE_EMD"))
 108       fileName = GetFile(kDAQ, "EMDCALIB", source->GetName());
 109      else if(runType.CompareTo("STANDALONE_COSMIC"))
 110       fileName = GetFile(kDAQ, "COSMICS", source->GetName());
 111      else if(runType.CompareTo("STANDALONE_BC"))
 112       fileName = GetFile(kDAQ, "BC", source->GetName());
 113      else if(runType.CompareTo("PHYSICS"))
 114       fileName = GetFile(kDAQ, "PHYSICS", source->GetName());
 115
 116      if(fileName.Length() <= 0){
 117        Log(Form("No file from source %s!", source->GetName()));
 118        return 1;
 119      }
 120      // --- Initializing pedestal calibration object
 121      AliZDCChMap *mapCalib = new AliZDCChMap("ZDC");
 122      // --- Reading file with pedestal calibration data
 123      const char* fname = fileName.Data();
 124      if(fname){
 125        FILE *file;
 126        if((file = fopen(fname,"r")) == NULL){
 127          printf("Cannot open file %s \n",fname);
 128          return 1;
 129        }
 130        Log(Form("File %s connected to process data for ADC mapping", fname));
 131        //
 132        Int_t chMap[48][6];
 133        for(Int_t j=0; j<48; j++){
 134            for(Int_t k=0; k<6; k++){
 135              fscanf(file,"%d",&chMap[j][k]);
 136            }
 137            mapCalib->SetADCModule(j,chMap[j][1]);
 138            mapCalib->SetADCChannel(j,chMap[j][2]);
 139            mapCalib->SetDetector(j,chMap[j][4]);
 140            mapCalib->SetSector(j,chMap[j][5]);
 141        }
 142        fclose(file);
 143      }
 144      else{
 145        Log(Form("File %s not found", fname));
 146        return 1;
 147      }
 148      //mapCalib->Print("");
 149     //
 150     AliCDBMetaData metaData;
 151     metaData.SetBeamPeriod(0);
 152     metaData.SetResponsible("Chiara Oppedisano");
 153     metaData.SetComment("Filling AliZDCChMap object");
 154     //
 155     Int_t res = Store("Calib","ChMap",mapCalib, &metaData, 0, 1);
 156     return res;
 157   }
 158   delete daqSource; daqSource=0;
 159
 160 }
 161
 162 //______________________________________________________________________________________________
 163 UInt_t AliZDCPreprocessor::Process(TMap* dcsAliasMap)
 164 {
 165   // *************** From DCS ******************
 166   // Fills data into a AliZDCDataDCS object
 167   if(!dcsAliasMap) return 1;
 168
 169   // The processing of the DCS input data is forwarded to AliZDCDataDCS
 170   Float_t dcsValues[28]; // DCSAliases=28
 171   fData->SetCalibData(dcsValues);
 172   fData->ProcessData(*dcsAliasMap);
 173   // Store DCS data for reference
 174   AliCDBMetaData metadata;
 175   metadata.SetResponsible("Chiara Oppedisano");
 176   metadata.SetComment("DCS data for ZDC");
 177   Bool_t resDCSRef = kTRUE;
 178   resDCSRef = StoreReferenceData("DCS","Data",fData,&metadata);
 179   //dcsAliasMap->Print("");
 180   //
 181   // --- Writing ZDC table positions into alignment object
 182   TClonesArray *array = new TClonesArray("AliAlignObjParams",10);
 183   TClonesArray &alobj = *array;
 184   AliAlignObjParams a;
 185   Double_t dx=0., dz=0., dpsi=0., dtheta=0., dphi=0.;
 186   // Vertical table position in mm from DCS
 187   Double_t dyZN1 = (Double_t) (dcsValues[0]/10.);
 188   Double_t dyZP1 = (Double_t) (dcsValues[1]/10.);
 189   Double_t dyZN2 = (Double_t) (dcsValues[2]/10.);
 190   Double_t dyZP2 = (Double_t) (dcsValues[3]/10.);
 191   const char *n1ZDC="ZDC/NeutronZDC1";
 192   const char *p1ZDC="ZDC/ProtonZDC1";
 193   const char *n2ZDC="ZDC/NeutronZDC2";
 194   const char *p2ZDC="ZDC/ProtonZDC2";
 195   UShort_t iIndex=0;
 196   AliGeomManager::ELayerID iLayer = AliGeomManager::kInvalidLayer;
 197   UShort_t volid = AliGeomManager::LayerToVolUID(iLayer,iIndex);
 198   //
 199   new(alobj[0]) AliAlignObjParams(n1ZDC, volid, dx, dyZN1, dz, dpsi, dtheta, dphi, kTRUE);
 200   new(alobj[1]) AliAlignObjParams(p1ZDC, volid, dx, dyZP1, dz, dpsi, dtheta, dphi, kTRUE);
 201   new(alobj[2]) AliAlignObjParams(n2ZDC, volid, dx, dyZN2, dz, dpsi, dtheta, dphi, kTRUE);
 202   new(alobj[3]) AliAlignObjParams(p2ZDC, volid, dx, dyZP2, dz, dpsi, dtheta, dphi, kTRUE);
 203   // save in CDB storage
 204   AliCDBMetaData md;
 205   md.SetResponsible("Chiara Oppedisano");
 206   md.SetComment("Alignment object for ZDC");
 207   Bool_t resultAl = kTRUE;
 208   resultAl = Store("Align","Data", array, &md, 0, 0);
 209
 210 // *************** From DAQ ******************
 211 Bool_t resChMap=kTRUE, resPedCal=kTRUE, resLaserCal=kTRUE, resECal=kTRUE;
 212 //
 213 const char* beamType = GetRunParameter("beamType");
 214 TString runType = GetRunType();
 215 printf("\n\t AliZDCPreprocessor -> beamType %s\n",beamType);
 216 printf("\t AliZDCPreprocessor -> runType  %s\n\n",runType.Data());
 217
 218 if(strcmp(beamType,"p-p")==0){
 219
 220    // --- Initializing pedestal calibration object
 221    AliZDCCalib *eCalib = new AliZDCCalib("ZDC");
 222    //
 223    for(Int_t j=0; j<6; j++) eCalib->SetEnCalib(j,1.);
 224    for(Int_t j=0; j<5; j++){
 225         eCalib->SetZN1EqualCoeff(j, 1.);
 226         eCalib->SetZP1EqualCoeff(j, 1.);
 227         eCalib->SetZN2EqualCoeff(j, 1.);
 228         eCalib->SetZP2EqualCoeff(j, 1.);
 229    }
 230    //eCalib->Print("");
 231    //
 232    AliCDBMetaData metaData;
 233    metaData.SetBeamPeriod(0);
 234    metaData.SetResponsible("Chiara Oppedisano");
 235    metaData.SetComment("AliZDCCalib object");
 236    //
 237    resECal = Store("Calib","EMDCalib",eCalib, &metaData, 0, 1);
 238 }
 239 // ******************************************
 240 //   ZDC ADC channel mapping
 241 // ******************************************
 242 resChMap = ProcessChMap(runType);
 243 //
 244 // *****************************************************
 245 // [a] PEDESTALS -> Pedestal subtraction
 246 // *****************************************************
 247 //
 248 if(runType=="STANDALONE_PEDESTAL"){
 249   TList* daqSources = GetFileSources(kDAQ, "PEDESTALS");
 250   if(!daqSources){
 251     Log(Form("No source for STANDALONE_PEDESTAL run %d !", fRun));
 252     return 1;
 253   }
 254   Log("\t List of sources for STANDALONE_PEDESTAL");
 255   daqSources->Print();
 256   //
 257   TIter iter(daqSources);
 258   TObjString* source = 0;
 259   Int_t i=0;
 260   while((source = dynamic_cast<TObjString*> (iter.Next()))){
 261        Log(Form("\n\t Getting file #%d\n",++i));
 262        TString stringPedFileName = GetFile(kDAQ, "PEDESTALS", source->GetName());
 263        if(stringPedFileName.Length() <= 0){
 264           Log(Form("No PEDESTAL file from source %s!", source->GetName()));
 265           return 1;
 266        }
 267        // --- Initializing pedestal calibration object
 268        AliZDCPedestals *pedCalib = new AliZDCPedestals("ZDC");
 269        // --- Reading file with pedestal calibration data
 270        const char* pedFileName = stringPedFileName.Data();
 271        // no. ADCch = (22 signal ch. + 2 reference PMs) * 2 gain chain = 48
 272        const Int_t knZDCch = 48;
 273        if(pedFileName){
 274          FILE *file;
 275          if((file = fopen(pedFileName,"r")) == NULL){
 276            printf("Cannot open file %s \n",pedFileName);
 277            return 1;
 278          }
 279          Log(Form("File %s connected to process pedestal data", pedFileName));
 280          Float_t pedVal[(3*knZDCch)][3];
 281          for(Int_t k=0; k<(3*knZDCch); k++){
 282             for(Int_t j=0; j<3; j++){
 283                fscanf(file,"%f",&pedVal[k][j]);
 284                //if(j==1) printf("pedVal[%d] -> %f, %f \n",k,pedVal[k][0],pedVal[k][1]);
 285             }
 286             if(k<knZDCch){
 287               pedCalib->SetMeanPed(k,pedVal[k][1]);
 288               pedCalib->SetMeanPedWidth(i,pedVal[k][2]);
 289             }
 290             else if(k>=knZDCch && k<(2*knZDCch)){
 291               pedCalib->SetOOTPed(k-knZDCch,pedVal[k][1]);
 292               pedCalib->SetOOTPedWidth(k-knZDCch,pedVal[k][2]);
 293             }
 294             else if(k>=(2*knZDCch) && k<(3*knZDCch)){
 295               pedCalib->SetPedCorrCoeff(k-(2*knZDCch),pedVal[k][1],pedVal[k][2]);
 296             }
 297          }
 298          fclose(file);
 299        }
 300        else{
 301           Log(Form("File %s not found", pedFileName));
 302           return 1;
 303        }
 304        //
 305       //pedCalib->Print("");
 306       //
 307       AliCDBMetaData metaData;
 308       metaData.SetBeamPeriod(0);
 309       metaData.SetResponsible("Chiara Oppedisano");
 310       metaData.SetComment("Filling AliZDCPedestals object");
 311       //
 312       resPedCal = Store("Calib","Pedestals",pedCalib, &metaData, 0, 1);
 313   }
 314   delete daqSources; daqSources = 0;
 315 }
 316 // *****************************************************
 317 // [b] STANDALONE_LASER EVENTS -> Signal stability
 318 // *****************************************************
 319 else if(runType=="STANDALONE_LASER"){
 320   TList* daqSources = GetFileSources(kDAQ, "LASER");
 321   if(!daqSources){
 322     AliError(Form("No sources for STANDALONE_LASER run %d !", fRun));
 323     return 1;
 324   }
 325   Log("\t List of sources for STANDALONE_LASER");
 326   daqSources->Print();
 327   //
 328   TIter iter2(daqSources);
 329   TObjString* source = 0;
 330   Int_t i=0;
 331   while((source = dynamic_cast<TObjString*> (iter2.Next()))){
 332        Log(Form("\n\t Getting file #%d\n",++i));
 333        TString stringLASERFileName = GetFile(kDAQ, "LASER", source->GetName());
 334        if(stringLASERFileName.Length() <= 0){
 335          Log(Form("No LASER file from source %s!", source->GetName()));
 336          return 1;
 337        }
 338        // --- Initializing pedestal calibration object
 339        AliZDCLaserCalib *lCalib = new AliZDCLaserCalib("ZDC");
 340        // --- Reading file with pedestal calibration data
 341        const char* laserFileName = stringLASERFileName.Data();
 342        if(laserFileName){
 343          FILE *file;
 344          if((file = fopen(laserFileName,"r")) == NULL){
 345            printf("Cannot open file %s \n",laserFileName);
 346            return 1;
 347          }
 348          Log(Form("File %s connected to process data from LASER events", laserFileName));
 349          //
 350          Float_t ivalRef[2], ivalRead[2][4];
 351          for(Int_t j=0; j<3; j++){
 352            if(j==0){
 353              for(Int_t k=0; k<2; k++){
 354                fscanf(file,"%f",&ivalRef[k]);
 355                printf(" %1.0f  ",ivalRef[k]);
 356                lCalib->SetReferenceValue(k,ivalRef[k]);
 357              }
 358            }
 359            else{
 360              for(Int_t k=0; k<4; k++){
 361                fscanf(file,"%f",&ivalRead[j-1][k]);
 362                printf(" %d %1.0f  ",k, ivalRead[j-1][k]);
 363              }
 364              lCalib->SetSector(j-1, ivalRead[j-1][0]);
 365              lCalib->SetGain(j-1, ivalRead[j-1][1]);
 366              lCalib->SetfPMRefValue(j-1, ivalRead[j-1][2]);
 367              lCalib->SetfPMRefWidth(j-1, ivalRead[j-1][3]);
 368            }
 369            printf("\n");
 370          }
 371          fclose(file);
 372        }
 373        else{
 374          Log(Form("File %s not found", laserFileName));
 375          return 1;
 376        }
 377        //lCalib->Print("");
 378        //
 379        AliCDBMetaData metaData;
 380        metaData.SetBeamPeriod(0);
 381        metaData.SetResponsible("Chiara Oppedisano");
 382        metaData.SetComment("Filling AliZDCLaserCalib object");
 383        //
 384        resLaserCal = Store("Calib","LaserCalib",lCalib, &metaData, 0, 1);
 385   }
 386
 387 }
 388 // *****************************************************
 389 // [c] EMD EVENTS -> Energy calibration and equalization
 390 // *****************************************************
 391 else if(runType=="STANDALONE_EMD"){
 392   TList* daqSources = GetFileSources(kDAQ, "EMDCALIB");
 393   if(!daqSources){
 394     AliError(Form("No sources for STANDALONE_EMD run %d !", fRun));
 395     return 1;
 396   }
 397   Log("\t List of sources for STANDALONE_EMD");
 398   daqSources->Print();
 399   //
 400   TIter iter2(daqSources);
 401   TObjString* source = 0;
 402   Int_t i=0;
 403   while((source = dynamic_cast<TObjString*> (iter2.Next()))){
 404        Log(Form("\n\t Getting file #%d\n",++i));
 405        TString stringEMDFileName = GetFile(kDAQ, "EMDCALIB", source->GetName());
 406        if(stringEMDFileName.Length() <= 0){
 407          Log(Form("No EMDCALIB file from source %s!", source->GetName()));
 408          return 1;
 409        }
 410        // --- Initializing pedestal calibration object
 411        AliZDCCalib *eCalib = new AliZDCCalib("ZDC");
 412        // --- Reading file with pedestal calibration data
 413        const char* emdFileName = stringEMDFileName.Data();
 414        if(emdFileName){
 415          FILE *file;
 416          if((file = fopen(emdFileName,"r")) == NULL){
 417            printf("Cannot open file %s \n",emdFileName);
 418            return 1;
 419          }
 420          Log(Form("File %s connected to process data from EM dissociation events", emdFileName));
 421          //
 422          Float_t fitValEMD[6]; Float_t equalCoeff[5][4];
 423          Float_t calibVal[4];
 424          for(Int_t j=0; j<10; j++){
 425            if(j<6){
 426              fscanf(file,"%f",&fitValEMD[j]);
 427              if(j<4){
 428                calibVal[j] = 2.76/fitValEMD[j];
 429                eCalib->SetEnCalib(j,calibVal[j]);
 430              }
 431              else eCalib->SetEnCalib(j,fitValEMD[j]);
 432            }
 433            else{
 434              for(Int_t k=0; k<5; k++){
 435                 fscanf(file,"%f",&equalCoeff[j][k]);
 436                 if(j==6)      eCalib->SetZN1EqualCoeff(k, equalCoeff[j][k]);
 437                 else if(j==7) eCalib->SetZP1EqualCoeff(k, equalCoeff[j][k]);
 438                 else if(j==8) eCalib->SetZN2EqualCoeff(k, equalCoeff[j][k]);
 439                 else if(j==9) eCalib->SetZP2EqualCoeff(k, equalCoeff[j][k]);
 440              }
 441            }
 442          }
 443          fclose(file);
 444        }
 445        else{
 446          Log(Form("File %s not found", emdFileName));
 447          return 1;
 448        }
 449        eCalib->Print("");
 450       //
 451       AliCDBMetaData metaData;
 452       metaData.SetBeamPeriod(0);
 453       metaData.SetResponsible("Chiara Oppedisano");
 454       metaData.SetComment("Filling AliZDCCalib object");
 455       //
 456       resECal = Store("Calib","EMDCalib",eCalib, &metaData, 0, 1);
 457   }
 458 }
 459
 460
 461   // note that the parameters are returned as character strings!
 462   const char* nEvents = GetRunParameter("totalEvents");
 463   if(nEvents) Log(Form("Number of events for run %d: %s",fRun, nEvents));
 464   else Log(Form("Number of events not put in logbook!"));
 465
 466   UInt_t result = 0;
 467   if(resDCSRef==kFALSE || resultAl==kFALSE || resPedCal==kFALSE ||
 468      resLaserCal==kFALSE || resECal==kFALSE || resChMap==kFALSE){
 469     if(resDCSRef == kFALSE)        result = 1;
 470     else if(resultAl == kFALSE)    result = 2;
 471     else if(resChMap == kFALSE)    result = 3;
 472     else if(resPedCal == kFALSE)   result = 4;
 473     else if(resLaserCal == kFALSE) result = 5;
 474     else if(resECal == kFALSE)     result = 6;
 475   }
 476
 477   return result;
 478
 479 }