HLT/TRD/AliHLTTRDOfflineClusterizerComponent.cxx

   1 // $Id$
   2
   3 //**************************************************************************
   4 //* This file is property of and copyright by the ALICE HLT Project        *
   5 //* ALICE Experiment at CERN, All rights reserved.                         *
   6 //*                                                                        *
   7 //* Primary Authors:                                                       *
   8 //*                  for The ALICE HLT Project.                            *
   9 //*                                                                        *
  10 //* Permission to use, copy, modify and distribute this software and its   *
  11 //* documentation strictly for non-commercial purposes is hereby granted   *
  12 //* without fee, provided that the above copyright notice appears in all   *
  13 //* copies and that both the copyright notice and this permission notice   *
  14 //* appear in the supporting documentation. The authors make no claims     *
  15 //* about the suitability of this software for any purpose. It is          *
  16 //* provided "as is" without express or implied warranty.                  *
  17 //**************************************************************************
  18
  19 /** @file   AliHLTTRDOfflineClusterizerComponent.cxx
  20     @author Theodor Rascanu
  21     @date
  22     @brief  Processes digits (with MC) and raw data (without MC). For debug purposes only
  23 */
  24
  25 // see header file for class documentation                                   //
  26 // or                                                                        //
  27 // refer to README to build package                                          //
  28 // or                                                                        //
  29 // visit http://web.ift.uib.no/~kjeks/doc/alice-hlt                          //
  30
  31 #include "AliHLTTRDOfflineClusterizerComponent.h"
  32 #include "AliHLTTRDDefinitions.h"
  33 #include "AliHLTTRDClusterizer.h"
  34 #include "AliHLTTRDUtils.h"
  35 #include "AliCDBManager.h"
  36 #include "TTree.h"
  37 #include "TClonesArray.h"
  38 #include "TObjString.h"
  39
  40 ClassImp(AliHLTTRDOfflineClusterizerComponent)
  41
  42 AliHLTTRDOfflineClusterizerComponent::AliHLTTRDOfflineClusterizerComponent()
  43   :AliHLTTRDClusterizerComponent()
  44 {
  45   // Default constructor
  46 }
  47
  48 AliHLTTRDOfflineClusterizerComponent::~AliHLTTRDOfflineClusterizerComponent()
  49 {
  50   // Destructor
  51   // Work is Done in DoDeInit()
  52 }
  53
  54 AliHLTComponent* AliHLTTRDOfflineClusterizerComponent::Spawn()
  55 {
  56   // Spawn function, return new instance of this class
  57   return new AliHLTTRDOfflineClusterizerComponent;
  58 };
  59
  60 const char* AliHLTTRDOfflineClusterizerComponent::GetComponentID()
  61 {
  62   // Return the component ID const char *
  63   return "TRDOfflineClusterizer"; // The ID of this component
  64 }
  65
  66 void AliHLTTRDOfflineClusterizerComponent::GetInputDataTypes( vector<AliHLTComponent_DataType>& list)
  67 {
  68   // Get the list of input data
  69   list.clear();
  70   AliHLTTRDClusterizerComponent::GetInputDataTypes(list);
  71   list.push_back(AliHLTTRDDefinitions::fgkDigitsDataType);
  72 }
  73
  74 AliHLTComponentDataType AliHLTTRDOfflineClusterizerComponent::GetOutputDataType()
  75 {
  76   // Get the output data type
  77   return kAliHLTMultipleDataType;
  78 }
  79
  80 int AliHLTTRDOfflineClusterizerComponent::GetOutputDataTypes(AliHLTComponentDataTypeList& tgtList)
  81 {
  82   // Get the output data types
  83   tgtList.clear();
  84   AliHLTTRDClusterizerComponent::GetOutputDataTypes(tgtList);
  85   tgtList.push_back(AliHLTTRDDefinitions::fgkHiLvlClusterDataType);
  86   return tgtList.size();
  87 }
  88
  89 void AliHLTTRDOfflineClusterizerComponent::GetOutputDataSize( unsigned long& constBase, double& inputMultiplier )
  90 {
  91   // Get the output data size
  92   AliHLTTRDClusterizerComponent::GetOutputDataSize(constBase, inputMultiplier);
  93   constBase += 500;
  94   inputMultiplier *= 10;
  95 }
  96
  97 int AliHLTTRDOfflineClusterizerComponent::SetParams()
  98 {
  99   int iResult =  AliHLTTRDClusterizerComponent::SetParams();
 100
 101   // here we need the coordinate transformation as we want to ship full flavoured clusters
 102   fClusterizer->SetSkipTransform(kFALSE);
 103 }
 104
 105
 106 int AliHLTTRDOfflineClusterizerComponent::DoEvent(const AliHLTComponent_EventData& evtData, const AliHLTComponent_BlockData* blocks,
 107                                                   AliHLTComponent_TriggerData& trigData, AliHLTUInt8_t* outputPtr,
 108                                                   AliHLTUInt32_t& size, vector<AliHLTComponent_BlockData>& outputBlocks )
 109 {
 110   if(!IsDataEvent())return 0;
 111
 112   if(!GetFirstInputBlock(AliHLTTRDDefinitions::fgkDigitsDataType))
 113     return AliHLTTRDClusterizerComponent::DoEvent(evtData, blocks, trigData, outputPtr, size, outputBlocks );
 114
 115   AliHLTUInt32_t offset = 0;
 116
 117   for(const TObject *iter = GetFirstInputObject(AliHLTTRDDefinitions::fgkDigitsDataType); iter; iter = GetNextInputObject())
 118     {
 119       AliTRDclusterizer* clusterizer = new AliTRDclusterizer("TRDCclusterizer", "TRDCclusterizer");
 120       clusterizer->SetReconstructor(fReconstructor);
 121       clusterizer->SetUseLabels(kTRUE);
 122
 123       TTree* digitsTree = dynamic_cast<TTree*>(const_cast<TObject*>(iter));
 124       clusterizer->ReadDigits(digitsTree);
 125       clusterizer->MakeClusters();
 126       TClonesArray* clusterArray = clusterizer->RecPoints();
 127       clusterizer->SetClustersOwner(kFALSE);
 128
 129       AliHLTUInt32_t spec = GetSpecification(iter);
 130       if(fHighLevelOutput){
 131         if(fEmulateHLTClusters){
 132           TClonesArray* temp = clusterArray;
 133           clusterArray = new TClonesArray(*temp);
 134           temp->Delete();
 135           delete temp;
 136           AliHLTTRDUtils::EmulateHLTClusters(clusterArray);
 137         }
 138         TObjString strg;
 139         strg.String() += clusterizer->GetNTimeBins();
 140         PushBack(clusterArray, AliHLTTRDDefinitions::fgkHiLvlClusterDataType, spec);
 141         PushBack(&strg, AliHLTTRDDefinitions::fgkHiLvlClusterDataType, spec);
 142       } else {
 143         Int_t nTimeBins = clusterizer->GetNTimeBins();
 144         Int_t addedSize = AliHLTTRDUtils::AddClustersToOutput(clusterArray, outputPtr+offset, nTimeBins);
 145
 146         AliHLTComponentBlockData bd;
 147         FillBlockData( bd );
 148         bd.fOffset = offset;
 149         bd.fSize = addedSize;
 150         bd.fSpecification = spec;
 151         bd.fDataType = AliHLTTRDDefinitions::fgkClusterDataType;
 152         outputBlocks.push_back( bd );
 153         HLTDebug( "BD ptr 0x%x, offset %i, size %i, dataType %s, spec 0x%x ", bd.fPtr, bd.fOffset, bd.fSize, DataType2Text(bd.fDataType).c_str(), bd.fSpecification);
 154         offset += addedSize;
 155       }
 156       clusterArray->Delete();
 157       delete clusterArray;
 158       delete clusterizer;
 159     }
 160
 161   return 0;
 162
 163 }