HLT/TPCLib/AliHLTTPCCalibPedestalComponent.cxx

   1 /**************************************************************************
   2  * This file is property of and copyright by the ALICE HLT Project        *
   3  * ALICE Experiment at CERN, All rights reserved.                         *
   4  *                                                                        *
   5  * Primary Authors: Jochen Thaeder <thaeder@kip.uni-heidelberg.de>        *
   6  *                  for The ALICE HLT Project.                            *
   7  *                                                                        *
   8  * Permission to use, copy, modify and distribute this software and its   *
   9  * documentation strictly for non-commercial purposes is hereby granted   *
  10  * without fee, provided that the above copyright notice appears in all   *
  11  * copies and that both the copyright notice and this permission notice   *
  12  * appear in the supporting documentation. The authors make no claims     *
  13  * about the suitability of this software for any purpose. It is          *
  14  * provided "as is" without express or implied warranty.                  *
  15  **************************************************************************/
  16
  17 /** @file   AliHLTTPCCalibPedestalComponent.cxx
  18     @author Jochen Thaeder
  19     @date
  20     @brief  A pedestal calibration component for the TPC.
  21 */
  22
  23 // see header file for class documentation
  24 // or
  25 // refer to README to build package
  26 // or
  27 // visit http://web.ift.uib.no/~kjeks/doc/alice-hlt
  28
  29 #if __GNUC__>= 3
  30 using namespace std;
  31 #endif
  32
  33 #include "AliHLTTPCLogging.h"
  34 #include "AliHLTTPCTransform.h"
  35
  36 #include "AliHLTTPCCalibPedestalComponent.h"
  37
  38 #include "AliRawDataHeader.h"
  39 #include "AliRawReaderMemory.h"
  40 #include "AliTPCRawStream.h"
  41
  42 #include "AliTPCCalibPedestal.h"
  43
  44 #include <stdlib.h>
  45 #include <errno.h>
  46 #include "TString.h"
  47
  48 /** ROOT macro for the implementation of ROOT specific class methods */
  49 ClassImp(AliHLTTPCCalibPedestalComponent)
  50
  51 AliHLTTPCCalibPedestalComponent::AliHLTTPCCalibPedestalComponent()
  52   :
  53   fRawReader(NULL),
  54   fRawStream(NULL),
  55   fCalibPedestal(NULL),
  56   fMinPatch(5),
  57   fMaxPatch(0),
  58   fSpecification(0) ,
  59   fEnableAnalysis(kFALSE) {
  60   // see header file for class documentation
  61   // or
  62   // refer to README to build package
  63   // or
  64   // visit http://web.ift.uib.no/~kjeks/doc/alice-hlt
  65 }
  66
  67 AliHLTTPCCalibPedestalComponent::~AliHLTTPCCalibPedestalComponent() {
  68   // see header file for class documentation
  69 }
  70
  71 // Public functions to implement AliHLTComponent's interface.
  72 // These functions are required for the registration process
  73
  74 const char* AliHLTTPCCalibPedestalComponent::GetComponentID() {
  75   // see header file for class documentation
  76
  77   return "TPCCalibPedestal";
  78 }
  79
  80 void AliHLTTPCCalibPedestalComponent::GetInputDataTypes( vector<AliHLTComponentDataType>& list) {
  81   // see header file for class documentation
  82
  83   list.clear();
  84   list.push_back( AliHLTTPCDefinitions::fgkDDLPackedRawDataType );
  85 }
  86
  87 AliHLTComponentDataType AliHLTTPCCalibPedestalComponent::GetOutputDataType() {
  88   // see header file for class documentation
  89
  90   return AliHLTTPCDefinitions::fgkCalibPedestalDataType;
  91 }
  92
  93 void AliHLTTPCCalibPedestalComponent::GetOutputDataSize( unsigned long& constBase, double& inputMultiplier ) {
  94   // see header file for class documentation
  95
  96   // XXX TODO: Find more realistic values.
  97   constBase = 0;
  98   inputMultiplier = (2.0);
  99 }
 100
 101 AliHLTComponent* AliHLTTPCCalibPedestalComponent::Spawn() {
 102   // see header file for class documentation
 103
 104   return new AliHLTTPCCalibPedestalComponent();
 105 }
 106
 107
 108 Int_t AliHLTTPCCalibPedestalComponent::ScanArgument( Int_t argc, const char** argv ) {
 109   // see header file for class documentation
 110
 111   Int_t iResult = 0;
 112   TString argument = "";
 113   TString parameter = "";
 114
 115   if ( !argc )
 116     return -EINVAL;
 117
 118   argument = argv[iResult];
 119
 120   if ( argument.IsNull() )
 121     return -EINVAL;
 122
 123   // -rcuformat
 124   if ( argument.CompareTo("-rcuformat") == 0 ) {
 125
 126     if ( ++iResult >= argc  ) {
 127       iResult = -EPROTO;
 128     }
 129     else {
 130       parameter = argv[1];
 131       if ( parameter.CompareTo("old") == 0 ) {
 132         HLTInfo( "RCU Format is set to old." );
 133       }
 134       else if ( parameter.CompareTo("new") == 0 ) {
 135         HLTInfo( "RCU Format is set to new." );
 136       }
 137       else {
 138         HLTError( "Cannot convert rcu format specifier '%s'.", argv[1] );
 139         iResult = -EPROTO;
 140       }
 141     }
 142   }
 143   else if ( argument.CompareTo("-enableanalysis") == 0 ) {
 144     HLTInfo( "Analysis before shipping data to FXS enabled." );
 145     fEnableAnalysis = kTRUE;
 146   }
 147   else {
 148     iResult = -EINVAL;
 149   }
 150
 151   return iResult;
 152 }
 153
 154 Int_t AliHLTTPCCalibPedestalComponent::InitCalibration() {
 155   // see header file for class documentation
 156
 157   // ** Create pedestal calibration
 158   if ( fCalibPedestal )
 159     return EINPROGRESS;
 160
 161   fCalibPedestal = new AliTPCCalibPedestal();
 162
 163   // **  Create AliRoot Memory Reader
 164   if (fRawReader)
 165     return EINPROGRESS;
 166
 167   fRawReader = new AliRawReaderMemory();
 168
 169   return 0;
 170 }
 171
 172 Int_t AliHLTTPCCalibPedestalComponent::DeinitCalibration() {
 173   // see header file for class documentation
 174
 175   if ( fRawReader )
 176     delete fRawReader;
 177   fRawReader = NULL;
 178
 179   if ( fCalibPedestal )
 180     delete fCalibPedestal;
 181   fCalibPedestal = NULL;
 182
 183   return 0;
 184 }
 185
 186 Int_t AliHLTTPCCalibPedestalComponent::ProcessCalibration( const AliHLTComponentEventData& /*evtData*/,
 187                                                            AliHLTComponentTriggerData& /*trigData*/ ) {
 188   // see header file for class documentation
 189
 190   const AliHLTComponentBlockData* iter = NULL;
 191
 192   AliHLTUInt8_t slice=0, patch=0;
 193   Int_t ddlId = 0;
 194
 195   // ** Loop over all input blocks and specify which data format should be read - only select Raw Data
 196   iter = GetFirstInputBlock( kAliHLTDataTypeDDLRaw | kAliHLTDataOriginTPC);
 197
 198   while ( iter != NULL ) {
 199
 200     // ** Print Debug output which data format was received
 201     //    char tmp1[14], tmp2[14];
 202     //    DataType2Text( iter->fDataType, tmp1 );
 203     //    DataType2Text( AliHLTTPCDefinitions::fgkDDLPackedRawDataType, tmp2 );
 204     //    HLTDebug ( "Event received - Event 0x%08LX (%Lu) received datatype: %s - required datatype: %s",
 205     //    evtData.fEventID, evtData.fEventID, tmp1, tmp2 );
 206
 207     // ** Get DDL ID in order to tell the memory reader which slice/patch to use
 208     slice = AliHLTTPCDefinitions::GetMinSliceNr( *iter );
 209     patch = AliHLTTPCDefinitions::GetMinPatchNr( *iter );
 210
 211     if (patch < 2) ddlId = 768 + (2 * slice) + patch;
 212     else ddlId = 838 + (4*slice) + patch;
 213
 214     HLTDebug ( "Input Raw Data - Slice/Patch: %d/%d - EquipmentID : %d.", slice, patch, ddlId );
 215
 216     // ** Get min and max patch, used for output specification
 217     if ( patch < fMinPatch ) fMinPatch =  patch;
 218     if ( patch > fMaxPatch ) fMaxPatch =  patch;
 219
 220     // ** Init TPCRawStream
 221     fRawReader->SetMemory( reinterpret_cast<UChar_t*>( iter->fPtr ), iter->fSize );
 222     fRawReader->SetEquipmentID(ddlId);
 223
 224     fRawStream = new AliTPCRawStream( fRawReader );
 225
 226     // ** Process actual Pedestal Calibration - Fill histograms
 227     fCalibPedestal->ProcessEvent( fRawStream );
 228
 229     // ** Delete TPCRawStream
 230     if ( fRawStream )
 231       delete fRawStream;
 232     fRawStream = NULL;
 233
 234     // ** Get next input block, with the same specification as defined in GetFirstInputBlock()
 235     iter = GetNextInputBlock();
 236
 237   } //  while ( iter != NULL ) {
 238
 239   // ** Get output specification
 240   fSpecification = AliHLTTPCDefinitions::EncodeDataSpecification( slice, slice, fMinPatch, fMaxPatch );
 241
 242   // ** PushBack data to shared memory ...
 243   PushBack( (TObject*) fCalibPedestal, AliHLTTPCDefinitions::fgkCalibPedestalDataType, fSpecification);
 244
 245   return 0;
 246 } // Int_t AliHLTTPCCalibPedestalComponent::ProcessCalibration( const AliHLTComponentEventData& evtData, AliHLTComponentTriggerData& trigData ) {
 247
 248
 249 Int_t AliHLTTPCCalibPedestalComponent::ShipDataToFXS( const AliHLTComponentEventData& /*evtData*/,
 250                                                       AliHLTComponentTriggerData& /*trigData*/ ) {
 251   // see header file for class documentation
 252
 253   if ( fEnableAnalysis )
 254     fCalibPedestal->Analyse();
 255
 256   // ** PushBack data to FXS ...
 257   PushToFXS( (TObject*) fCalibPedestal, "TPC", "Pedestal" ) ;
 258
 259   return 0;
 260 } // Int_t AliHLTTPCCalibPedestalComponent::ShipDataToFXS( const AliHLTComponentEventData& evtData, AliHLTComponentTriggerData& trigData ) {
 261
 262