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
  21     @date
  22     @brief
  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   ,fOffClusterizer(NULL)
  45 {
  46   // Default constructor
  47 }
  48
  49 AliHLTTRDOfflineClusterizerComponent::~AliHLTTRDOfflineClusterizerComponent()
  50 {
  51   // Destructor
  52   // Work is Done in DoDeInit()
  53 }
  54
  55 AliHLTComponent* AliHLTTRDOfflineClusterizerComponent::Spawn()
  56 {
  57   // Spawn function, return new instance of this class
  58   return new AliHLTTRDOfflineClusterizerComponent;
  59 };
  60
  61 const char* AliHLTTRDOfflineClusterizerComponent::GetComponentID()
  62 {
  63   // Return the component ID const char *
  64   return "TRDOfflineClusterizer"; // The ID of this component
  65 }
  66
  67 void AliHLTTRDOfflineClusterizerComponent::GetInputDataTypes( vector<AliHLTComponent_DataType>& list)
  68 {
  69   // Get the list of input data
  70   list.clear();
  71   AliHLTTRDClusterizerComponent::GetInputDataTypes(list);
  72   list.push_back(AliHLTTRDDefinitions::fgkDigitsDataType);
  73 }
  74
  75 AliHLTComponentDataType AliHLTTRDOfflineClusterizerComponent::GetOutputDataType()
  76 {
  77   // Get the output data type
  78   return kAliHLTMultipleDataType;
  79 }
  80
  81 int AliHLTTRDOfflineClusterizerComponent::GetOutputDataTypes(AliHLTComponentDataTypeList& tgtList)
  82 {
  83   // Get the output data types
  84   tgtList.clear();
  85   AliHLTTRDClusterizerComponent::GetOutputDataTypes(tgtList);
  86   tgtList.push_back(AliHLTTRDDefinitions::fgkHiLvlClusterDataType);
  87   return tgtList.size();
  88 }
  89
  90 void AliHLTTRDOfflineClusterizerComponent::GetOutputDataSize( unsigned long& constBase, double& inputMultiplier )
  91 {
  92   // Get the output data size
  93   AliHLTTRDClusterizerComponent::GetOutputDataSize(constBase, inputMultiplier);
  94   constBase += 500;
  95   inputMultiplier *= 10;
  96 }
  97
  98 int AliHLTTRDOfflineClusterizerComponent::DoInit( int argc, const char** argv )
  99 {
 100   int iResult = 0;
 101   iResult=AliHLTTRDClusterizerComponent::DoInit(argc, argv);
 102
 103   return iResult;
 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 ( GetFirstInputBlock( kAliHLTDataTypeSOR ) || GetFirstInputBlock( kAliHLTDataTypeEOR ) )
 111     return 0;
 112
 113   if(!GetFirstInputBlock(AliHLTTRDDefinitions::fgkDigitsDataType))
 114     return AliHLTTRDClusterizerComponent::DoEvent(evtData, blocks, trigData, outputPtr, size, outputBlocks );
 115
 116   AliHLTUInt32_t offset = 0;
 117
 118   for(const TObject *iter = GetFirstInputObject(AliHLTTRDDefinitions::fgkDigitsDataType); iter; iter = GetNextInputObject())
 119     {
 120       AliTRDclusterizer* clusterizer = new AliTRDclusterizer("TRDCclusterizer", "TRDCclusterizer");
 121       clusterizer->SetReconstructor(fReconstructor);
 122       clusterizer->SetUseLabels(kTRUE);
 123
 124       TTree* digitsTree = dynamic_cast<TTree*>(const_cast<TObject*>(iter));
 125       clusterizer->ReadDigits(digitsTree);
 126       clusterizer->MakeClusters();
 127       TClonesArray* clusterArray = clusterizer->RecPoints();
 128       clusterizer->SetClustersOwner(kFALSE);
 129
 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, 0);
 141         PushBack(&strg, AliHLTTRDDefinitions::fgkHiLvlClusterDataType, 0);
 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 = 1;
 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 }