HLT/TRD/AliHLTTRDCalibFitComponent.cxx

   1 // $Id: AliHLTTRDCalibFitComponent.cxx 40282 2010-04-09 13:29:10Z richterm $
   2
   3 /**************************************************************************
   4  * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
   5  *                                                                        *
   6  * Authors:                                                               *
   7  *          for The ALICE HLT Project.                                    *
   8  *                                                                        *
   9  * Permission to use, copy, modify and distribute this software and its   *
  10  * documentation strictly for non-commercial purposes is hereby granted   *
  11  * without fee, provided that the above copyright notice appears in all   *
  12  * copies and that both the copyright notice and this permission notice   *
  13  * appear in the supporting documentation. The authors make no claims     *
  14  * about the suitability of this software for any purpose. It is          *
  15  * provided "as is" without express or implied warranty.                  *
  16  **************************************************************************/
  17
  18 //  @file   AliHLTTRDCalibFitComponent.cxx
  19 //  @author Theodor Rascanu
  20 //  @date   25.04.2010
  21 //  @brief  A TRDCalibration fitting component for the HLT.
  22 //
  23
  24 #if __GNUC__ >= 3
  25 using namespace std;
  26 #endif
  27
  28 #include "TTree.h"
  29 #include "TFile.h"
  30 #include "TBranch.h"
  31 #include "TH2I.h"
  32 #include "TH2.h"
  33 #include "TProfile2D.h"
  34
  35 #include "AliHLTReadoutList.h"
  36
  37 #include "AliHLTTRDCalibFitComponent.h"
  38 #include "AliHLTTRDDefinitions.h"
  39 #include "AliHLTTRDUtils.h"
  40
  41 #include "AliRawReaderMemory.h"
  42
  43 #include "AliTRDCalPad.h"
  44 #include "AliTRDCalDet.h"
  45
  46 #include "AliTRDCalibraFillHisto.h"
  47 #include "AliTRDtrackV1.h"
  48
  49 #include "AliTRDCalibraFit.h"
  50 #include "AliTRDCalibraMode.h"
  51 #include "AliTRDCalibraVector.h"
  52 #include "AliTRDCalibraVdriftLinearFit.h"
  53 #include "AliTRDReconstructor.h"
  54 #include "AliTRDrecoParam.h"
  55
  56 #include <cstdlib>
  57 #include <cerrno>
  58 #include <string>
  59
  60 ClassImp(AliHLTTRDCalibFitComponent);
  61
  62 AliHLTTRDCalibFitComponent::AliHLTTRDCalibFitComponent()
  63   : AliHLTCalibrationProcessor(),
  64     fOutputSize(500000),
  65     fOutArray(NULL),
  66     fTempArray(NULL),
  67     fAfterRunArray(NULL)
  68 {
  69   // Default constructor
  70 }
  71
  72 AliHLTTRDCalibFitComponent::~AliHLTTRDCalibFitComponent()
  73 {
  74   // Destructor
  75 }
  76
  77 const char* AliHLTTRDCalibFitComponent::GetComponentID()
  78 {
  79   // Return the component ID const char *
  80   return "TRDCalibFit"; // The ID of this component
  81 }
  82
  83 void AliHLTTRDCalibFitComponent::GetInputDataTypes( vector<AliHLTComponentDataType>& list)
  84 {
  85   // Get the list of input data
  86   list.clear(); // We do not have any requirements for our input data type(s).
  87   list.push_back(AliHLTTRDDefinitions::fgkCalibrationDataType);
  88 }
  89
  90 AliHLTComponentDataType AliHLTTRDCalibFitComponent::GetOutputDataType()
  91 {
  92   // Get the output data type
  93   return kAliHLTMultipleDataType;
  94   //  return AliHLTTRDDefinitions::fgkCalibrationDataType;
  95
  96 }
  97
  98 int AliHLTTRDCalibFitComponent::GetOutputDataTypes(AliHLTComponentDataTypeList& tgtList)
  99 {
 100   // Get the output data type
 101   tgtList.clear();
 102   tgtList.push_back(AliHLTTRDDefinitions::fgkCalibrationDataType);
 103   tgtList.push_back(AliHLTTRDDefinitions::fgkEORCalibrationDataType);
 104   return tgtList.size();
 105 }
 106
 107 void AliHLTTRDCalibFitComponent::GetOutputDataSize( unsigned long& constBase, double& inputMultiplier )
 108 {
 109   // Get the output data size
 110   constBase = fOutputSize;
 111   inputMultiplier = 0;
 112 }
 113
 114 AliHLTComponent* AliHLTTRDCalibFitComponent::Spawn()
 115 {
 116   // Spawn function, return new instance of this class
 117   return new AliHLTTRDCalibFitComponent;
 118 };
 119
 120 Int_t AliHLTTRDCalibFitComponent::InitCalibration()
 121 {
 122   for(int i=0; i<18; i++)
 123     fIncSM[i]=kFALSE;
 124
 125   fOutArray = new TObjArray(4);
 126   fAfterRunArray=new TObjArray(5);
 127
 128   return 0;
 129 }
 130
 131 Int_t AliHLTTRDCalibFitComponent::DeinitCalibration()
 132 {
 133
 134   // Deinitialization of the component
 135
 136   HLTDebug("DeinitCalibration");
 137   //fOutArray->Delete();
 138   if(fTempArray){
 139     delete fTempArray; fTempArray=0;
 140   }
 141   delete fOutArray; fOutArray=0;
 142   fAfterRunArray->Delete();
 143   delete fAfterRunArray; fAfterRunArray=0;
 144   return 0;
 145 }
 146
 147 Int_t AliHLTTRDCalibFitComponent::ProcessCalibration(const AliHLTComponent_EventData& /*evtData*/,
 148                                                         const AliHLTComponent_BlockData* /*blocks*/,
 149                                                         AliHLTComponent_TriggerData& /*trigData*/,
 150                                                         AliHLTUInt8_t* /*outputPtr*/,
 151                                                         AliHLTUInt32_t& /*size*/,
 152                                                         vector<AliHLTComponent_BlockData>& /*outputBlocks*/)
 153 {
 154   // Process an event
 155
 156   if(!IsDataEvent())return 0;
 157
 158   int lastSM = -1;
 159
 160   for(const TObject* iter = GetFirstInputObject(AliHLTTRDDefinitions::fgkCalibrationDataType);
 161       iter != NULL; iter = GetNextInputObject() ) {
 162
 163     if(!dynamic_cast<const TObjArray*>(iter))
 164       continue;
 165
 166     AliHLTUInt32_t spec = GetSpecification(iter);
 167     int SM = AliHLTTRDUtils::GetSM(spec);
 168
 169     HLTInfo("Got Data from SM %i", SM);
 170
 171     if(SM!=lastSM){
 172       if(fIncSM[SM]){
 173         PushBack(fTempArray, AliHLTTRDDefinitions::fgkCalibrationDataType);
 174         fOutArray->Delete();
 175         delete fOutArray;
 176         fOutArray = fTempArray;
 177         fTempArray = NULL;
 178         for(int i=0; i<18; i++)
 179           fIncSM[i]=kFALSE;
 180       }
 181       lastSM = SM;
 182       fIncSM[SM]=kTRUE;
 183     }
 184
 185     if(!fTempArray) fTempArray = (TObjArray*)iter->Clone();
 186     else{
 187       TObjArray* inArr = (TObjArray*)iter;
 188       for(int i = inArr->GetEntriesFast(); i--;){
 189         const TH1* histo = dynamic_cast<const TH1*>(inArr->At(i));
 190         if(histo){
 191           if(fTempArray->At(i)){
 192             ((TH1*)fTempArray->At(i))->Add(histo);
 193           }else{
 194             fTempArray->AddAt(histo->Clone(), i);
 195           }
 196           continue;
 197         }
 198         AliTRDCalibraVdriftLinearFit* obj = dynamic_cast<AliTRDCalibraVdriftLinearFit*>(inArr->At(i));
 199         if(obj){
 200           if(fTempArray->At(i)){
 201             ((AliTRDCalibraVdriftLinearFit*)fTempArray->At(i))->Add(obj);
 202           }else{
 203             fTempArray->AddAt(new AliTRDCalibraVdriftLinearFit(*obj), i);
 204           }
 205         }
 206       }
 207     }
 208
 209   }
 210
 211   return 0;
 212 }
 213
 214 Int_t AliHLTTRDCalibFitComponent::ShipDataToFXS(const AliHLTComponentEventData& /*evtData*/, AliHLTComponentTriggerData& /*trigData*/)
 215 {
 216   //fTRDCalibraFillHisto->DestroyDebugStreamer();
 217
 218   AliHLTReadoutList rdList(AliHLTReadoutList::kTRD);
 219
 220   EORCalibration();
 221
 222   fOutArray->Remove(fOutArray->FindObject("AliTRDCalibraVdriftLinearFit"));
 223   //fOutArray->Remove(fOutArray->FindObject("PRF2d"));
 224   //fOutArray->Remove(fOutArray->FindObject("PH2d"));
 225   //fOutArray->Remove(fOutArray->FindObject("CH2d"));
 226
 227   if(!(fOutArray->FindObject("CH2d"))) {
 228     TH2I * ch2d = new TH2I("CH2d","Nz0Nrphi0",100,0.0,300.0,540,0,540);
 229     fOutArray->Add(ch2d);
 230   }
 231
 232   if(!(fOutArray->FindObject("PH2d"))) {
 233     TProfile2D * ph2d = new TProfile2D("PH2d","Nz0Nrphi0",30,-0.05,2.95,540,0,540);
 234     fOutArray->Add(ph2d);
 235   }
 236
 237   if(!(fOutArray->FindObject("PRF2d"))) {
 238     TProfile2D * prf2d = new TProfile2D("PRF2d","Nz0Nrphi0Ngp3",60,-9.0,9.0,540,0,540);
 239     fOutArray->Add(prf2d);
 240   }
 241
 242   HLTDebug("Size of the fOutArray is %d\n",fOutArray->GetEntriesFast());
 243
 244   PushToFXS((TObject*)fOutArray, "TRD", "GAINDRIFTPRF", rdList.Buffer() );
 245   //PushToFXS((TObject*)fOutArray->FindObject("CH2d"), "TRD", "GAINDRIFTPRF", rdList.Buffer() );
 246
 247   return 0;
 248 }
 249
 250 Int_t AliHLTTRDCalibFitComponent::EORCalibration()
 251 {
 252   //Also Fill histograms for the online display
 253   TH2I *hCH2d=(TH2I*)fOutArray->FindObject("CH2d");
 254   TProfile2D *hPH2d=(TProfile2D*)fOutArray->FindObject("PH2d");
 255   TProfile2D *hPRF2d= (TProfile2D*)fOutArray->FindObject("PRF2d");
 256   AliTRDCalibraVdriftLinearFit* hVdriftLinearFit = (AliTRDCalibraVdriftLinearFit*)fOutArray->FindObject("AliTRDCalibraVdriftLinearFit");
 257
 258
 259   if(!hCH2d || !hPH2d || !hPRF2d || !hVdriftLinearFit) return 0;
 260
 261   //Fit
 262   AliTRDCalibraFit *calibra = AliTRDCalibraFit::Instance();
 263
 264   //Gain
 265   calibra->SetMinEntries(100);
 266   calibra->AnalyseCH(hCH2d);
 267   Int_t nbtg = 6*4*18*((Int_t) ((AliTRDCalibraMode *)calibra->GetCalibraMode())->GetDetChamb0(0))
 268     + 6*  18*((Int_t) ((AliTRDCalibraMode *)calibra->GetCalibraMode())->GetDetChamb2(0));
 269   Int_t nbfit       = calibra->GetNumberFit();
 270   Int_t nbE         = calibra->GetNumberEnt();
 271   TH1F *coefgain = 0x0;
 272   // enough statistics
 273   //if ((nbtg >                  0) &&
 274   //   (nbfit        >= 0.2*nbE)) {
 275   // create the cal objects
 276   //calibra->PutMeanValueOtherVectorFit(1,kTRUE);
 277   TObjArray object           = calibra->GetVectorFit();
 278   AliTRDCalDet *objgaindet   = calibra->CreateDetObjectGain(&object,kFALSE);
 279   coefgain                   = objgaindet->MakeHisto1DAsFunctionOfDet();
 280   //}
 281   calibra->ResetVectorFit();
 282
 283   // vdrift second method
 284   calibra->SetMinEntries(100); // If there is less than 100
 285   hVdriftLinearFit->FillPEArray();
 286   calibra->AnalyseLinearFitters(hVdriftLinearFit);
 287   nbtg = 540;
 288   nbfit = calibra->GetNumberFit();
 289   nbE   = calibra->GetNumberEnt();
 290   TH1F *coefdriftsecond = 0x0;
 291   // enough statistics
 292   //if ((nbtg >                  0) &&
 293   // (nbfit        >= 0.1*nbE)) {
 294   // create the cal objects
 295   //calibra->PutMeanValueOtherVectorFit(1,kTRUE);
 296   object  = calibra->GetVectorFit();
 297   AliTRDCalDet *objdriftvelocitydetsecond = calibra->CreateDetObjectVdrift(&object,kTRUE);
 298   objdriftvelocitydetsecond->SetTitle("secondmethodvdrift");
 299   coefdriftsecond  = objdriftvelocitydetsecond->MakeHisto1DAsFunctionOfDet();
 300   //}
 301   calibra->ResetVectorFit();
 302
 303   // vdrift first method
 304   calibra->SetMinEntries(100*20); // If there is less than 20000
 305   calibra->AnalysePH(hPH2d);
 306   nbtg = 6*4*18*((Int_t) ((AliTRDCalibraMode *)calibra->GetCalibraMode())->GetDetChamb0(1))
 307     + 6*  18*((Int_t) ((AliTRDCalibraMode *)calibra->GetCalibraMode())->GetDetChamb2(1));
 308   nbfit        = calibra->GetNumberFit();
 309   nbE          = calibra->GetNumberEnt();
 310   TH1F *coefdrift = 0x0;
 311   TH1F *coeft0 = 0x0;
 312   // enough statistics
 313   //if ((nbtg >                  0) &&
 314   // (nbfit        >= 0.2*nbE)) {
 315   // create the cal objects
 316   //calibra->PutMeanValueOtherVectorFit(1,kTRUE);
 317   //calibra->PutMeanValueOtherVectorFit2(1,kTRUE);
 318   object  = calibra->GetVectorFit();
 319   AliTRDCalDet *objdriftvelocitydet = calibra->CreateDetObjectVdrift(&object,kTRUE);
 320   coefdrift        = objdriftvelocitydet->MakeHisto1DAsFunctionOfDet();
 321   object              = calibra->GetVectorFit2();
 322   AliTRDCalDet *objtime0det  = calibra->CreateDetObjectT0(&object,kTRUE);
 323   coeft0        = objtime0det->MakeHisto1DAsFunctionOfDet();
 324   //}
 325   calibra->ResetVectorFit();
 326
 327
 328   //PRF
 329   calibra->SetMinEntries(200);
 330   calibra->AnalysePRFMarianFit(hPRF2d);
 331   nbtg = 6*4*18*((Int_t) ((AliTRDCalibraMode *)calibra->GetCalibraMode())->GetDetChamb0(2))
 332     + 6*  18*((Int_t) ((AliTRDCalibraMode *)calibra->GetCalibraMode())->GetDetChamb2(2));
 333   nbfit        = calibra->GetNumberFit();
 334   nbE          = calibra->GetNumberEnt();
 335   TH1F *coefprf = 0x0;
 336   // enough statistics
 337   //if ((nbtg >                  0) &&
 338   //  (nbfit        >= 0.95*nbE)) {
 339   // create cal pad objects
 340   object            = calibra->GetVectorFit();
 341   TObject *objPRFpad          = calibra->CreatePadObjectPRF(&object);
 342   coefprf                     = ((AliTRDCalPad *) objPRFpad)->MakeHisto1D();
 343   //}
 344   calibra->ResetVectorFit();
 345
 346
 347   coefgain->SetName("coefgain");
 348   coefprf->SetName("coefprf");
 349   coefdrift->SetName("coefdrift");
 350   coefdriftsecond->SetName("coefdriftsecond");
 351   coeft0->SetName("coeft0");
 352   if(coefgain) fAfterRunArray->Add(coefgain);
 353   if(coefprf) fAfterRunArray->Add(coefprf);
 354   if(coefdrift) fAfterRunArray->Add(coefdrift);
 355   if(coefdriftsecond) fAfterRunArray->Add(coefdriftsecond);
 356   if(coeft0) fAfterRunArray->Add(coeft0);
 357
 358
 359   if(coefgain||coefprf||coefdrift||coeft0||coefdriftsecond) {
 360     PushBack(fAfterRunArray, AliHLTTRDDefinitions::fgkEORCalibrationDataType);
 361   }
 362
 363   // TString fileName="/tmp/CalibHistoDump_run";
 364   // fileName+=AliCDBManager::Instance()->GetRun();
 365   // fileName+=".root";
 366   // HLTInfo("Dumping Histogram file to %s",fileName.Data());
 367   // TFile* file = TFile::Open(fileName, "RECREATE");
 368   // fAfterRunArray->Write();
 369   // fOutArray->Write();
 370   // file->Close();
 371   // HLTInfo("Histogram file dumped");
 372
 373   return 0;
 374 }
 375