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     fAfterRunArray(NULL),
  67     fNoOfSM(0),
  68     fNoOfIncSM(0)
  69 {
  70   // Default constructor
  71
  72   for(int i=0; i<18; i++)
  73     fIncSM[i]=kFALSE;
  74
  75 }
  76
  77 AliHLTTRDCalibFitComponent::~AliHLTTRDCalibFitComponent()
  78 {
  79   // Destructor
  80 }
  81
  82 const char* AliHLTTRDCalibFitComponent::GetComponentID()
  83 {
  84   // Return the component ID const char *
  85   return "TRDCalibFit"; // The ID of this component
  86 }
  87
  88 void AliHLTTRDCalibFitComponent::GetInputDataTypes( vector<AliHLTComponentDataType>& list)
  89 {
  90   // Get the list of input data
  91   list.clear(); // We do not have any requirements for our input data type(s).
  92   list.push_back(AliHLTTRDDefinitions::fgkCalibrationDataType);
  93 }
  94
  95 AliHLTComponentDataType AliHLTTRDCalibFitComponent::GetOutputDataType()
  96 {
  97   // Get the output data type
  98   return kAliHLTMultipleDataType;
  99   //  return AliHLTTRDDefinitions::fgkCalibrationDataType;
 100
 101 }
 102
 103 int AliHLTTRDCalibFitComponent::GetOutputDataTypes(AliHLTComponentDataTypeList& tgtList)
 104 {
 105   // Get the output data type
 106   tgtList.clear();
 107   tgtList.push_back(AliHLTTRDDefinitions::fgkCalibrationDataType);
 108   tgtList.push_back(AliHLTTRDDefinitions::fgkEORCalibrationDataType);
 109   return tgtList.size();
 110 }
 111
 112 void AliHLTTRDCalibFitComponent::GetOutputDataSize( unsigned long& constBase, double& inputMultiplier )
 113 {
 114   // Get the output data size
 115   constBase = fOutputSize;
 116   inputMultiplier = 0;
 117 }
 118
 119 AliHLTComponent* AliHLTTRDCalibFitComponent::Spawn()
 120 {
 121   // Spawn function, return new instance of this class
 122   return new AliHLTTRDCalibFitComponent;
 123 };
 124
 125 Int_t AliHLTTRDCalibFitComponent::InitCalibration()
 126 {
 127   for(int i=0; i<18; i++)
 128     fIncSM[i]=kFALSE;
 129
 130   fOutArray = new TObjArray(4);
 131   fAfterRunArray=new TObjArray(5);
 132
 133   return 0;
 134 }
 135
 136 Int_t AliHLTTRDCalibFitComponent::DeinitCalibration()
 137 {
 138
 139   // Deinitialization of the component
 140
 141   HLTDebug("DeinitCalibration");
 142   //fOutArray->Delete();
 143   delete fOutArray; fOutArray=0;
 144   fAfterRunArray->Delete();
 145   delete fAfterRunArray; fAfterRunArray=0;
 146   return 0;
 147 }
 148
 149 Int_t AliHLTTRDCalibFitComponent::ProcessCalibration(const AliHLTComponent_EventData& /*evtData*/,
 150                                                         const AliHLTComponent_BlockData* /*blocks*/,
 151                                                         AliHLTComponent_TriggerData& /*trigData*/,
 152                                                         AliHLTUInt8_t* /*outputPtr*/,
 153                                                         AliHLTUInt32_t& /*size*/,
 154                                                         vector<AliHLTComponent_BlockData>& /*outputBlocks*/)
 155 {
 156   // Process an event
 157
 158   if(!IsDataEvent())return 0;
 159
 160   int lastSM = -1;
 161
 162   for(const TObject* iter = GetFirstInputObject(AliHLTTRDDefinitions::fgkCalibrationDataType);
 163       iter != NULL; iter = GetNextInputObject() ) {
 164
 165     if(!dynamic_cast<const TObjArray*>(iter))
 166       continue;
 167
 168     AliHLTUInt32_t spec = GetSpecification(iter);
 169     int SM = AliHLTTRDUtils::GetSM(spec);
 170
 171     HLTInfo("Got Data from SM %i", SM);
 172
 173     if(SM!=lastSM){
 174       if(fIncSM[SM]){
 175         if(fNoOfIncSM<fNoOfSM)
 176           return 0;
 177         fNoOfSM=fNoOfIncSM;
 178         PushBack(fOutArray, AliHLTTRDDefinitions::fgkCalibrationDataType);
 179         fOutArray->Delete();
 180         delete fOutArray;
 181         fOutArray = NULL;
 182         for(int i=0; i<18; i++)
 183           fIncSM[i]=kFALSE;
 184         fNoOfIncSM=0;
 185       }
 186       lastSM = SM;
 187       fIncSM[SM]=kTRUE;
 188       fNoOfIncSM++;
 189     }
 190
 191     if(!fOutArray) fOutArray = (TObjArray*)iter->Clone();
 192     else{
 193       TObjArray* inArr = (TObjArray*)iter;
 194       for(int i = inArr->GetEntriesFast(); i--;){
 195         const TH1* histo = dynamic_cast<const TH1*>(inArr->At(i));
 196         if(histo){
 197           if(fOutArray->At(i)){
 198             ((TH1*)fOutArray->At(i))->Add(histo);
 199           }else{
 200             fOutArray->AddAt(histo->Clone(), i);
 201           }
 202           continue;
 203         }
 204         AliTRDCalibraVdriftLinearFit* obj = dynamic_cast<AliTRDCalibraVdriftLinearFit*>(inArr->At(i));
 205         if(obj){
 206           if(fOutArray->At(i)){
 207             ((AliTRDCalibraVdriftLinearFit*)fOutArray->At(i))->Add(obj);
 208           }else{
 209             fOutArray->AddAt(new AliTRDCalibraVdriftLinearFit(*obj), i);
 210           }
 211         }
 212       }
 213     }
 214
 215   }
 216
 217   return 0;
 218 }
 219
 220 Int_t AliHLTTRDCalibFitComponent::ShipDataToFXS(const AliHLTComponentEventData& /*evtData*/, AliHLTComponentTriggerData& /*trigData*/)
 221 {
 222   AliHLTReadoutList rdList(AliHLTReadoutList::kTRD);
 223
 224   EORCalibration();
 225
 226   fOutArray->Remove(fOutArray->FindObject("AliTRDCalibraVdriftLinearFit"));
 227   //fOutArray->Remove(fOutArray->FindObject("PRF2d"));
 228   //fOutArray->Remove(fOutArray->FindObject("PH2d"));
 229   //fOutArray->Remove(fOutArray->FindObject("CH2d"));
 230
 231   if(!(fOutArray->FindObject("CH2d"))) {
 232     TH2I * ch2d = new TH2I("CH2d","Nz0Nrphi0",100,0.0,300.0,540,0,540);
 233     fOutArray->Add(ch2d);
 234   }
 235
 236   if(!(fOutArray->FindObject("PH2d"))) {
 237     TProfile2D * ph2d = new TProfile2D("PH2d","Nz0Nrphi0",30,-0.05,2.95,540,0,540);
 238     fOutArray->Add(ph2d);
 239   }
 240
 241   if(!(fOutArray->FindObject("PRF2d"))) {
 242     TProfile2D * prf2d = new TProfile2D("PRF2d","Nz0Nrphi0Ngp3",60,-9.0,9.0,540,0,540);
 243     fOutArray->Add(prf2d);
 244   }
 245
 246   HLTDebug("Size of the fOutArray is %d\n",fOutArray->GetEntriesFast());
 247
 248   PushToFXS((TObject*)fOutArray, "TRD", "GAINDRIFTPRF", &rdList );
 249   //PushToFXS((TObject*)fOutArray->FindObject("CH2d"), "TRD", "GAINDRIFTPRF", rdList.Buffer() );
 250
 251   return 0;
 252 }
 253
 254 Int_t AliHLTTRDCalibFitComponent::EORCalibration()
 255 {
 256   //Also Fill histograms for the online display
 257   TH2I *hCH2d=(TH2I*)fOutArray->FindObject("CH2d");
 258   TProfile2D *hPH2d=(TProfile2D*)fOutArray->FindObject("PH2d");
 259   TProfile2D *hPRF2d= (TProfile2D*)fOutArray->FindObject("PRF2d");
 260   AliTRDCalibraVdriftLinearFit* hVdriftLinearFit = (AliTRDCalibraVdriftLinearFit*)fOutArray->FindObject("AliTRDCalibraVdriftLinearFit");
 261
 262
 263   if(!hCH2d || !hPH2d || !hPRF2d || !hVdriftLinearFit) return 0;
 264
 265   //Fit
 266   AliTRDCalibraFit *calibra = AliTRDCalibraFit::Instance();
 267
 268   //Gain
 269   calibra->SetMinEntries(100);
 270   calibra->AnalyseCH(hCH2d);
 271   //Int_t nbtg = 6*4*18*((Int_t) ((AliTRDCalibraMode *)calibra->GetCalibraMode())->GetDetChamb0(0))
 272   //  + 6*  18*((Int_t) ((AliTRDCalibraMode *)calibra->GetCalibraMode())->GetDetChamb2(0));
 273   //Int_t nbfit       = calibra->GetNumberFit();
 274   //Int_t nbE         = calibra->GetNumberEnt();
 275   TH1F *coefgain = 0x0;
 276   // enough statistics
 277   //if ((nbtg >                  0) &&
 278   //   (nbfit        >= 0.2*nbE)) {
 279   // create the cal objects
 280   //calibra->PutMeanValueOtherVectorFit(1,kTRUE);
 281   TObjArray object           = calibra->GetVectorFit();
 282   AliTRDCalDet *objgaindet   = calibra->CreateDetObjectGain(&object,kFALSE);
 283   coefgain                   = objgaindet->MakeHisto1DAsFunctionOfDet();
 284   //}
 285   calibra->ResetVectorFit();
 286
 287   // vdrift second method
 288   calibra->SetMinEntries(100); // If there is less than 100
 289   hVdriftLinearFit->FillPEArray();
 290   calibra->AnalyseLinearFitters(hVdriftLinearFit);
 291   //nbtg = 540;
 292   //nbfit = calibra->GetNumberFit();
 293   //nbE   = calibra->GetNumberEnt();
 294   TH1F *coefdriftsecond = 0x0;
 295   // enough statistics
 296   //if ((nbtg >                  0) &&
 297   // (nbfit        >= 0.1*nbE)) {
 298   // create the cal objects
 299   //calibra->PutMeanValueOtherVectorFit(1,kTRUE);
 300   object  = calibra->GetVectorFit();
 301   AliTRDCalDet *objdriftvelocitydetsecond = calibra->CreateDetObjectVdrift(&object,kTRUE);
 302   objdriftvelocitydetsecond->SetTitle("secondmethodvdrift");
 303   coefdriftsecond  = objdriftvelocitydetsecond->MakeHisto1DAsFunctionOfDet();
 304   //}
 305   calibra->ResetVectorFit();
 306
 307   // vdrift first method
 308   calibra->SetMinEntries(100*20); // If there is less than 20000
 309   calibra->AnalysePH(hPH2d);
 310   //nbtg = 6*4*18*((Int_t) ((AliTRDCalibraMode *)calibra->GetCalibraMode())->GetDetChamb0(1))
 311   //  + 6*  18*((Int_t) ((AliTRDCalibraMode *)calibra->GetCalibraMode())->GetDetChamb2(1));
 312   //nbfit        = calibra->GetNumberFit();
 313   //nbE          = calibra->GetNumberEnt();
 314   TH1F *coefdrift = 0x0;
 315   TH1F *coeft0 = 0x0;
 316   // enough statistics
 317   //if ((nbtg >                  0) &&
 318   // (nbfit        >= 0.2*nbE)) {
 319   // create the cal objects
 320   //calibra->PutMeanValueOtherVectorFit(1,kTRUE);
 321   //calibra->PutMeanValueOtherVectorFit2(1,kTRUE);
 322   object  = calibra->GetVectorFit();
 323   AliTRDCalDet *objdriftvelocitydet = calibra->CreateDetObjectVdrift(&object,kTRUE);
 324   coefdrift        = objdriftvelocitydet->MakeHisto1DAsFunctionOfDet();
 325   object              = calibra->GetVectorFit2();
 326   AliTRDCalDet *objtime0det  = calibra->CreateDetObjectT0(&object,kTRUE);
 327   coeft0        = objtime0det->MakeHisto1DAsFunctionOfDet();
 328   //}
 329   calibra->ResetVectorFit();
 330
 331
 332   //PRF
 333   calibra->SetMinEntries(200);
 334   calibra->AnalysePRFMarianFit(hPRF2d);
 335   //nbtg = 6*4*18*((Int_t) ((AliTRDCalibraMode *)calibra->GetCalibraMode())->GetDetChamb0(2))
 336   //  + 6*  18*((Int_t) ((AliTRDCalibraMode *)calibra->GetCalibraMode())->GetDetChamb2(2));
 337   //nbfit        = calibra->GetNumberFit();
 338   //nbE          = calibra->GetNumberEnt();
 339   TH1F *coefprf = 0x0;
 340   // enough statistics
 341   //if ((nbtg >                  0) &&
 342   //  (nbfit        >= 0.95*nbE)) {
 343   // create cal pad objects
 344   object            = calibra->GetVectorFit();
 345   TObject *objPRFpad          = calibra->CreatePadObjectPRF(&object);
 346   coefprf                     = ((AliTRDCalPad *) objPRFpad)->MakeHisto1D();
 347   //}
 348   calibra->ResetVectorFit();
 349
 350
 351   coefgain->SetName("coefgain");
 352   coefprf->SetName("coefprf");
 353   coefdrift->SetName("coefdrift");
 354   coefdriftsecond->SetName("coefdriftsecond");
 355   coeft0->SetName("coeft0");
 356   fAfterRunArray->Add(coefgain);
 357   fAfterRunArray->Add(coefprf);
 358   fAfterRunArray->Add(coefdrift);
 359   fAfterRunArray->Add(coefdriftsecond);
 360   fAfterRunArray->Add(coeft0);
 361
 362   PushBack(fAfterRunArray, AliHLTTRDDefinitions::fgkEORCalibrationDataType);
 363
 364   // TString fileName="/tmp/CalibHistoDump_run";
 365   // fileName+=AliCDBManager::Instance()->GetRun();
 366   // fileName+=".root";
 367   // HLTInfo("Dumping Histogram file to %s",fileName.Data());
 368   // TFile* file = TFile::Open(fileName, "RECREATE");
 369   // fAfterRunArray->Write();
 370   // fOutArray->Write();
 371   // file->Close();
 372   // HLTInfo("Histogram file dumped");
 373
 374   return 0;
 375 }
 376