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
  73 AliHLTTRDCalibFitComponent::~AliHLTTRDCalibFitComponent()
  74 {
  75   // Destructor
  76 }
  77
  78 const char* AliHLTTRDCalibFitComponent::GetComponentID()
  79 {
  80   // Return the component ID const char *
  81   return "TRDCalibFit"; // The ID of this component
  82 }
  83
  84 void AliHLTTRDCalibFitComponent::GetInputDataTypes( vector<AliHLTComponentDataType>& list)
  85 {
  86   // Get the list of input data
  87   list.clear(); // We do not have any requirements for our input data type(s).
  88   list.push_back(AliHLTTRDDefinitions::fgkCalibrationDataType);
  89 }
  90
  91 AliHLTComponentDataType AliHLTTRDCalibFitComponent::GetOutputDataType()
  92 {
  93   // Get the output data type
  94   return kAliHLTMultipleDataType;
  95   //  return AliHLTTRDDefinitions::fgkCalibrationDataType;
  96
  97 }
  98
  99 int AliHLTTRDCalibFitComponent::GetOutputDataTypes(AliHLTComponentDataTypeList& tgtList)
 100 {
 101   // Get the output data type
 102   tgtList.clear();
 103   tgtList.push_back(AliHLTTRDDefinitions::fgkCalibrationDataType);
 104   tgtList.push_back(AliHLTTRDDefinitions::fgkEORCalibrationDataType);
 105   return tgtList.size();
 106 }
 107
 108 void AliHLTTRDCalibFitComponent::GetOutputDataSize( unsigned long& constBase, double& inputMultiplier )
 109 {
 110   // Get the output data size
 111   constBase = fOutputSize;
 112   inputMultiplier = 0;
 113 }
 114
 115 AliHLTComponent* AliHLTTRDCalibFitComponent::Spawn()
 116 {
 117   // Spawn function, return new instance of this class
 118   return new AliHLTTRDCalibFitComponent;
 119 };
 120
 121 Int_t AliHLTTRDCalibFitComponent::InitCalibration()
 122 {
 123   for(int i=0; i<18; i++)
 124     fIncSM[i]=kFALSE;
 125
 126   fOutArray = new TObjArray(4);
 127   fAfterRunArray=new TObjArray(5);
 128
 129   return 0;
 130 }
 131
 132 Int_t AliHLTTRDCalibFitComponent::DeinitCalibration()
 133 {
 134
 135   // Deinitialization of the component
 136
 137   HLTDebug("DeinitCalibration");
 138   //fOutArray->Delete();
 139   delete fOutArray; fOutArray=0;
 140   fAfterRunArray->Delete();
 141   delete fAfterRunArray; fAfterRunArray=0;
 142   return 0;
 143 }
 144
 145 Int_t AliHLTTRDCalibFitComponent::ProcessCalibration(const AliHLTComponent_EventData& /*evtData*/,
 146                                                         const AliHLTComponent_BlockData* /*blocks*/,
 147                                                         AliHLTComponent_TriggerData& /*trigData*/,
 148                                                         AliHLTUInt8_t* /*outputPtr*/,
 149                                                         AliHLTUInt32_t& /*size*/,
 150                                                         vector<AliHLTComponent_BlockData>& /*outputBlocks*/)
 151 {
 152   // Process an event
 153
 154   if(!IsDataEvent())return 0;
 155
 156   int lastSM = -1;
 157
 158   for(const TObject* iter = GetFirstInputObject(AliHLTTRDDefinitions::fgkCalibrationDataType);
 159       iter != NULL; iter = GetNextInputObject() ) {
 160
 161     if(!dynamic_cast<const TObjArray*>(iter))
 162       continue;
 163
 164     AliHLTUInt32_t spec = GetSpecification(iter);
 165     int SM = AliHLTTRDUtils::GetSM(spec);
 166
 167     HLTInfo("Got Data from SM %i", SM);
 168
 169     if(SM!=lastSM){
 170       if(fIncSM[SM]){
 171         if(fNoOfIncSM<fNoOfSM)
 172           return 0;
 173         fNoOfSM=fNoOfIncSM;
 174         PushBack(fOutArray, AliHLTTRDDefinitions::fgkCalibrationDataType);
 175         fOutArray->Delete();
 176         delete fOutArray;
 177         fOutArray = NULL;
 178         for(int i=0; i<18; i++)
 179           fIncSM[i]=kFALSE;
 180         fNoOfIncSM=0;
 181       }
 182       lastSM = SM;
 183       fIncSM[SM]=kTRUE;
 184       fNoOfIncSM++;
 185     }
 186
 187     if(!fOutArray) fOutArray = (TObjArray*)iter->Clone();
 188     else{
 189       TObjArray* inArr = (TObjArray*)iter;
 190       for(int i = inArr->GetEntriesFast(); i--;){
 191         const TH1* histo = dynamic_cast<const TH1*>(inArr->At(i));
 192         if(histo){
 193           if(fOutArray->At(i)){
 194             ((TH1*)fOutArray->At(i))->Add(histo);
 195           }else{
 196             fOutArray->AddAt(histo->Clone(), i);
 197           }
 198           continue;
 199         }
 200         AliTRDCalibraVdriftLinearFit* obj = dynamic_cast<AliTRDCalibraVdriftLinearFit*>(inArr->At(i));
 201         if(obj){
 202           if(fOutArray->At(i)){
 203             ((AliTRDCalibraVdriftLinearFit*)fOutArray->At(i))->Add(obj);
 204           }else{
 205             fOutArray->AddAt(new AliTRDCalibraVdriftLinearFit(*obj), i);
 206           }
 207         }
 208       }
 209     }
 210
 211   }
 212
 213   return 0;
 214 }
 215
 216 Int_t AliHLTTRDCalibFitComponent::ShipDataToFXS(const AliHLTComponentEventData& /*evtData*/, AliHLTComponentTriggerData& /*trigData*/)
 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 );
 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