[u/mrichter/AliRoot.git] / HLT / BASE / AliHLTCalibrationProcessor.cxx

/**************************************************************************
 * This file is property of and copyright by the ALICE HLT Project        * 
 * ALICE Experiment at CERN, All rights reserved.                         *
 *                                                                        *
 * Primary Authors: Jochen Thaeder <thaeder@kip.uni-heidelberg.de>        *
 *                  Sebastian Bablok                                      *
 *                  for The ALICE HLT Project.                            *
 *                                                                        *
 * Permission to use, copy, modify and distribute this software and its   *
 * documentation strictly for non-commercial purposes is hereby granted   *
 * without fee, provided that the above copyright notice appears in all   *
 * copies and that both the copyright notice and this permission notice   *
 * appear in the supporting documentation. The authors make no claims     *
 * about the suitability of this software for any purpose. It is          *
 * provided "as is" without express or implied warranty.                  *
 **************************************************************************/

/** 
 * @file   AliHLTCalibrationProcessor.cxx
 * @author Jochen Thaeder, Sebastian Bablok
 * @date 
 * @brief  Base class of HLT calibration components.  */

// see header file for class documentation
// or
// refer to README to build package
// or
// visit http://web.ift.uib.no/~kjeks/doc/alice-hlt

#if __GNUC__ >= 3
using namespace std;
#endif

#include "AliHLTCalibrationProcessor.h"
#include "AliHLTMemoryFile.h"

#include <cstdlib>
#include <cerrno>
#include <string.h>
#include <TObjString.h>
#include <TFile.h>

ClassImp(AliHLTCalibrationProcessor);


const AliHLTUInt32_t AliHLTCalibrationProcessor::fgkFXSProtocolHeaderSize = 204;
const AliHLTUInt32_t AliHLTCalibrationProcessor::fgkFXSProtocolHeaderVersion = 1;

/*
 * ################ Constructor / Destructor ####################
 */

AliHLTCalibrationProcessor::AliHLTCalibrationProcessor() : 
  fEventModulo(0),
  fUseCorruptEvents(kFALSE),
  fEventCounter(0),
  fDDLNumber(),
  fDummy(0) {

  // see header file for class documentation
  // or
  // refer to README to build package
  // or
  // visit http://web.ift.uib.no/~kjeks/doc/alice-hlt
}

AliHLTCalibrationProcessor::~AliHLTCalibrationProcessor() {
  // see header file for class documentation
}

/*
 * ######################## InitCalibration #####################
 */

Int_t AliHLTCalibrationProcessor::DoInit( int argc, const char** argv ) {
  // see header file for class documentation

  Int_t iResult = 0;
  TString argument = "";
  TString parameter = "";
  Int_t bMissingParam=0;
  
  for ( Int_t ii=0; ii<argc && iResult>=0; ii++ ) {
    argument = argv[ii];

    if ( argument.IsNull() ) continue;

    // -eventmodulo
    if ( argument.CompareTo("-eventmodulo") == 0 ) {
      if ( ( bMissingParam=( ++ii >= argc ) ) ) break;
      parameter = argv[ii];  
      parameter.Remove(TString::kLeading, ' '); // remove all blanks
      if (parameter.IsDigit()) {
	fEventModulo = parameter.Atoi();
	HLTInfo("EventModulo is set to %d.", fEventModulo);
      } 
      else {
	HLTError("Cannot convert EventModulo specifier '%s'.", argv[ii]);
	iResult = -EINVAL;
	break;
      }
    } 
    // -usecorruptevents
    else if ( argument.CompareTo( "-usecorruptevents" ) == 0 ) {
      HLTInfo( "Passing through of corrupted events enabled." );
      fUseCorruptEvents = kTRUE;
    } 
    // not known by calibration processor
    else {
      if ( ( iResult = ScanArgument( argc-ii, &argv[ii] ) ) == -EINVAL ) {
	HLTError( "unknown argument %s", argument.Data() );
	break;
      } 
      else if ( iResult == -EPROTO ) {
	bMissingParam = 1;
	break;
      } 
      else if ( iResult >= 0 ) {
	ii += iResult;
	iResult = 0;
      }
    }
  }
  
  if ( bMissingParam ) {
    HLTError( "missing parameter for argument %s", argument.Data() );
    iResult = -EPROTO;
  }

  if ( iResult >= 0 ) {
    iResult = InitCalibration();
  }

  // Reset the DDLNumberList
  memset( fDDLNumber, 0, gkAliHLTFXSHeaderfDDLNumberSize);

  return iResult;
}

Int_t AliHLTCalibrationProcessor::InitCalibration() {
  // see header file for class documentation
  
  // fDummy is just touched here to avoid coding convention violation RC11. 
  // The function can not be declared  const since it is just the default implementation, 
  // overloaded virtual function might not be const.
  fDummy = 0;

  return 0;
}


Int_t AliHLTCalibrationProcessor::ScanArgument(int argc, const char** argv) {
  // see header file for class documentation
  
  // there are no other arguments than the standard ones
  if ( argc == 0 && argv == NULL) {
    // this is just to get rid of the warning "unused parameter"
  }
  
  // fDummy is just touched here to avoid coding convention violation RC11. 
  // The function can not be declared  const since it is just the default implementation, 
  // overloaded virtual function might not be const.
  fDummy = 0;

  return -EINVAL;
}

/*
 * ######################## DeinitCalibration #####################
 */

Int_t AliHLTCalibrationProcessor::DoDeinit() {
  // see header file for class documentation
 
  int iResult = DeinitCalibration();
 
  return iResult;
}

Int_t AliHLTCalibrationProcessor::DeinitCalibration() {
  // see header file for class documentation

  // fDummy is just touched here to avoid coding convention violation RC11. 
  // The function can not be declared  const since it is just the default implementation, 
  // overloaded virtual function might not be const.
  fDummy = 0;

  return 0;
}

/*
 * ######################## DoEvent #####################
 */

Int_t AliHLTCalibrationProcessor::DoEvent( const AliHLTComponentEventData& evtData,
	       const AliHLTComponentBlockData* blocks, 
	       AliHLTComponentTriggerData& trigData,
	       AliHLTUInt8_t* outputPtr, 
	       AliHLTUInt32_t& size,
	       vector<AliHLTComponentBlockData>& outputBlocks )
{
  // see header file for class documentation

  Int_t iResult = 0;

  const AliHLTComponentBlockData* blkSOR = NULL;
  blkSOR = GetFirstInputBlock( kAliHLTDataTypeSOR );
  const AliHLTComponentBlockData* blkEOR = NULL;
  blkEOR = GetFirstInputBlock( kAliHLTDataTypeEOR );

  // ** if event Type is not SOR or EOR -> fill DDLNumber list and process data
  if ( ! blkEOR  && !blkSOR ) {
    
    // ** Set DDLNumber List
    if ( trigData.fData != NULL) {
      AliHLTEventTriggerData* trg = ( AliHLTEventTriggerData* ) trigData.fData;
      if ( trg != NULL) {
	AliHLTEventDDL list = (AliHLTEventDDL) trg->fReadoutList;        
	  
	Int_t wordNdx = GetFirstUsedDDLWord(list);
	if ( wordNdx >=0 ) {
	  
	  Int_t wordCount = 1;
	  // Handle special TPC and TOF case
	  if ( wordNdx == 3 )
	    wordCount = 8;
	  else if ( wordNdx == 12 )
	    wordCount = 3;
	  
	  // check word for word and binary OR it with existing DDLNumberList
	  for ( Int_t ndx = 0; ndx < wordCount; ndx++ ) {
	    AliHLTUInt32_t word = list.fList[wordNdx+ndx];
	
	    // set only 4 bit into one Char_t
	    for ( Int_t charNdx = 0; charNdx < 8; charNdx++) {
	      fDDLNumber[(8*ndx)+charNdx] |= (Char_t) word & 0x0000000F;
	      word = word >> 4;
	    }
	  }
	} // if ( wordNdx > 0 ) {
      } // if ( trg != NULL) {
    } // if ( trigData.fData != NULL) {
    
    // ** ProcessData
    iResult = ProcessCalibration( evtData, blocks, trigData, outputPtr, size, outputBlocks );
    fEventCounter++; 
  }  

  // - if event Type is EOR or event modulo is set -> ship data to FXS
  // - use event modulo ship data also during the run 
  if ( ( fEventModulo > 0 && fEventCounter == fEventModulo ) || blkEOR ){
    HLTDebug ( "Ship Data to FXS!" );
    iResult = ShipDataToFXS( evtData, blocks, trigData, outputPtr, size, outputBlocks );
    fEventCounter = 0;
  }

  return iResult;
}

/*
 * ######################## ProcessCalibration #####################
 */

Int_t AliHLTCalibrationProcessor::ProcessCalibration( const AliHLTComponentEventData& evtData,
						      const AliHLTComponentBlockData* /*blocks*/, 
						      AliHLTComponentTriggerData& trigData,
						      AliHLTUInt8_t* /*outputPtr*/, 
						      AliHLTUInt32_t& /*size*/,
						      vector<AliHLTComponentBlockData>& /*outputBlocks*/ ) {
  // see header file for class documentation

  // we just forward to the high level method, all other parameters already
  // have been stored internally
  return ProcessCalibration( evtData, trigData );
}

Int_t AliHLTCalibrationProcessor::ProcessCalibration( const AliHLTComponentEventData& /*evtData*/, 
						      AliHLTComponentTriggerData& /*trigData*/) {
  // see header file for class documentation

  HLTFatal( "no processing method implemented" );
  return -ENOSYS;
}

/*
 * ######################## ShipDataToFXS #####################
 */

Int_t AliHLTCalibrationProcessor::ShipDataToFXS( const AliHLTComponentEventData& evtData,
						 const AliHLTComponentBlockData* /*blocks*/, 
						 AliHLTComponentTriggerData& trigData,
						 AliHLTUInt8_t* /*outputPtr*/, 
						 AliHLTUInt32_t& /*size*/,
						 vector<AliHLTComponentBlockData>& /*outputBlocks*/ ) {
  // see header file for class documentation

  // we just forward to the high level method, all other parameters already
  // have been stored internally
  return ShipDataToFXS( evtData, trigData );
}


Int_t AliHLTCalibrationProcessor::ShipDataToFXS( const AliHLTComponentEventData& /*evtData*/, 
						 AliHLTComponentTriggerData& /*trigData*/) {
  // see header file for class documentation

  HLTFatal( "no processing method implemented" );
  return -ENOSYS;
}

/*
 * ######################## CreateFXSHeader #####################
 */

Int_t AliHLTCalibrationProcessor::CreateFXSHeader( AliHLTFXSHeader &pHeader, const char* pDetector, const char* pFileID, AliHLTEventDDL* pDDLList ) {
  // see header file for class documentation

  Int_t iResult = 0;

  // ** Fill header version
  pHeader.fHeaderVersion = AliHLTCalibrationProcessor::fgkFXSProtocolHeaderVersion;

  // ** Fill run number
  pHeader.fRunNumber = GetRunNo(); 
  
  // ** Fill origin
  HLTDebug( "FXS Header Detector  size max %i - actual %i .",gkAliHLTFXSHeaderfOriginSize, strlen( pDetector ) );
  strncpy ( pHeader.fOrigin, pDetector, gkAliHLTFXSHeaderfOriginSize ) ; 

  // To take care if fileIDs which are longer than gkAliHLTFXSHeaderfOriginSize, write one 0 is cheaper than an if.
  pHeader.fOrigin[gkAliHLTFXSHeaderfOriginSize] = 0;

  // ** Fill file ID
  HLTInfo( "FXS Header FileID size max %i - actual %i .",gkAliHLTFXSHeaderfFileIDSize, strlen( pFileID ) );
  strncpy ( pHeader.fFileID, pFileID, gkAliHLTFXSHeaderfFileIDSize ) ; 

  // To take care if fileIDs which are longer than gkAliHLTFXSHeaderfFileIDSize, write one 0 is cheaper than an if.
  pHeader.fFileID[gkAliHLTFXSHeaderfFileIDSize] = 0;

  // ** Fill DDL number

  // -- if component provides list, convert to fDDLNumber
  if ( pDDLList ) {
    // use user list
    
    Int_t wordNdx = GetFirstUsedDDLWord( *(pDDLList) );
    if ( wordNdx >=0 ) {
	  
      Int_t wordCount = 1;
      // Handle special TPC and TOF case
      if ( wordNdx == 3 )
	wordCount = 8;
      else if ( wordNdx == 12 )
	wordCount = 3;
	  
      // check word for word 
      for ( Int_t ndx = 0; ndx < wordCount; ndx++ ) {
	AliHLTUInt32_t word = pDDLList->fList[wordNdx+ndx];
	
	// set only 4 bit into one Char_t
	for ( Int_t charNdx = 0; charNdx < 8; charNdx++) {
	  fDDLNumber[(8*ndx)+charNdx] = (Char_t) word & 0x0000000F;
	  word = word >> 4;
	}
      }
    } // if ( wordNdx > 0 ) {
    else
      iResult = wordNdx;
  } //   if ( pDDLList ) {

  // -- fill header with ascii chars
  for (Int_t ndx = 0; ndx < gkAliHLTFXSHeaderfDDLNumberSize; ndx++ ){
    Int_t numberToChar = (Int_t) fDDLNumber[ndx];
    // Get ASCII
    if ( numberToChar > 9 ) numberToChar += 55;
    else numberToChar += 48;
    
    pHeader.fDDLNumber[ndx] = (Char_t) numberToChar;
  }
  
  return iResult;
}  // Int_t AliHLTCalibrationProcessor::CreateFXSHeader( AliHLTXSHeader &pHeader, const char* pDetector, const char* pFileID, AliHLTEventDDL* pDDLList ) {

/*
 * ######################## PushToFXS #####################
 */

Int_t AliHLTCalibrationProcessor::PushToFXS(TObject* pObject, const char* pDetector, const char* pFileID, AliHLTEventDDL* pDDLList ) {
  // see header file for class documentation

  Int_t iResult = 0;
  
  AliHLTFXSHeader pHeader;

  CreateFXSHeader( pHeader, pDetector, pFileID, pDDLList );
  
  if ( pObject ) {
    
    AliHLTMemoryFile* pMemFile = CreateMemoryFile( kAliHLTDataTypeFXSCalib, kAliHLTVoidDataSpec );
    if ( pMemFile ) {
      
      iResult = pMemFile->WriteHeaderBuffer( (const char*) &pHeader, AliHLTCalibrationProcessor::fgkFXSProtocolHeaderSize );

      if ( iResult ) {
	HLTError( "Buffer size to small - for header!" ); 
      }
      else {
	iResult = Write( pMemFile, pObject );
	if ( !iResult ) {
	  HLTError( "Buffer size to small - for data!" ); 
	}
	else {
	  iResult = CloseMemoryFile( pMemFile );  
	}
      }
    } 
    else {
      iResult = -ENOMEM;
    }
  } 
  else {
    iResult=-EINVAL;
  }

  return iResult;

} // Int_t AliHLTCalibrationProcessor::PushToFXS(TObject* pObject, const char* detector, const char* pFileID, AliHLTEventDDL* pDDLList ) {

Int_t AliHLTCalibrationProcessor::PushToFXS( void* pBuffer, int iSize, const char* pDetector, const char* pFileID, AliHLTEventDDL* pDDLList ) {
  // see header file for class documentation

  Int_t iResult = 0;
  
  AliHLTFXSHeader pHeader;

  CreateFXSHeader( pHeader, pDetector, pFileID, pDDLList );
  
  iResult = PushBack( pBuffer, iSize, kAliHLTDataTypeFXSCalib, kAliHLTVoidDataSpec, (void*) (&pHeader), AliHLTCalibrationProcessor::fgkFXSProtocolHeaderSize );

  return iResult;

} // Int_t AliHLTCalibrationProcessor::PushToFXS(void* pBuffer, int iSize, const char* pDdetector, const char* pFileID, AliHLTEventDDL* pDDLList ) {
Commit	Line	Data
9d9ffd37	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	* Sebastian Bablok *
	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	/**
	19	* @file AliHLTCalibrationProcessor.cxx
	20	* @author Jochen Thaeder, Sebastian Bablok
	21	* @date
	22	* @brief Base class of HLT calibration components. */
	23
3a7c0444	24	// see header file for class documentation
	25	// or
	26	// refer to README to build package
	27	// or
	28	// visit http://web.ift.uib.no/~kjeks/doc/alice-hlt
	29
9d9ffd37	30	#if __GNUC__ >= 3
	31	using namespace std;
	32	#endif
	33
	34	#include "AliHLTCalibrationProcessor.h"
	35	#include "AliHLTMemoryFile.h"
	36
	37	#include <cstdlib>
	38	#include <cerrno>
	39	#include <string.h>
	40	#include <TObjString.h>
	41	#include <TFile.h>
	42
773aff84	43	ClassImp(AliHLTCalibrationProcessor);
9d9ffd37	44
	45
	46	const AliHLTUInt32_t AliHLTCalibrationProcessor::fgkFXSProtocolHeaderSize = 204;
	47	const AliHLTUInt32_t AliHLTCalibrationProcessor::fgkFXSProtocolHeaderVersion = 1;
	48
	49	/*
	50	* ################ Constructor / Destructor ####################
	51	*/
	52
	53	AliHLTCalibrationProcessor::AliHLTCalibrationProcessor() :
	54	fEventModulo(0),
	55	fUseCorruptEvents(kFALSE),
	56	fEventCounter(0),
	57	fDDLNumber(),
	58	fDummy(0) {
	59
	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	AliHLTCalibrationProcessor::~AliHLTCalibrationProcessor() {
	68	// see header file for class documentation
	69	}
	70
	71	/*
	72	* ######################## InitCalibration #####################
	73	*/
	74
7c4091c1	75	Int_t AliHLTCalibrationProcessor::DoInit( int argc, const char** argv ) {
9d9ffd37	76	// see header file for class documentation
	77
	78	Int_t iResult = 0;
	79	TString argument = "";
	80	TString parameter = "";
	81	Int_t bMissingParam=0;
	82
	83	for ( Int_t ii=0; ii<argc && iResult>=0; ii++ ) {
	84	argument = argv[ii];
	85
	86	if ( argument.IsNull() ) continue;
	87
	88	// -eventmodulo
	89	if ( argument.CompareTo("-eventmodulo") == 0 ) {
	90	if ( ( bMissingParam=( ++ii >= argc ) ) ) break;
	91	parameter = argv[ii];
	92	parameter.Remove(TString::kLeading, ' '); // remove all blanks
	93	if (parameter.IsDigit()) {
	94	fEventModulo = parameter.Atoi();
	95	HLTInfo("EventModulo is set to %d.", fEventModulo);
	96	}
	97	else {
	98	HLTError("Cannot convert EventModulo specifier '%s'.", argv[ii]);
	99	iResult = -EINVAL;
	100	break;
	101	}
	102	}
	103	// -usecorruptevents
	104	else if ( argument.CompareTo( "-usecorruptevents" ) == 0 ) {
	105	HLTInfo( "Passing through of corrupted events enabled." );
	106	fUseCorruptEvents = kTRUE;
	107	}
	108	// not known by calibration processor
	109	else {
	110	if ( ( iResult = ScanArgument( argc-ii, &argv[ii] ) ) == -EINVAL ) {
	111	HLTError( "unknown argument %s", argument.Data() );
	112	break;
	113	}
	114	else if ( iResult == -EPROTO ) {
	115	bMissingParam = 1;
	116	break;
	117	}
	118	else if ( iResult >= 0 ) {
	119	ii += iResult;
	120	iResult = 0;
	121	}
	122	}
	123	}
	124
	125	if ( bMissingParam ) {
	126	HLTError( "missing parameter for argument %s", argument.Data() );
	127	iResult = -EPROTO;
	128	}
	129
	130	if ( iResult >= 0 ) {
	131	iResult = InitCalibration();
	132	}
	133
ed504011	134	// Reset the DDLNumberList
	135	memset( fDDLNumber, 0, gkAliHLTFXSHeaderfDDLNumberSize);
	136
9d9ffd37	137	return iResult;
	138	}
	139
	140	Int_t AliHLTCalibrationProcessor::InitCalibration() {
	141	// see header file for class documentation
	142
	143	// fDummy is just touched here to avoid coding convention violation RC11.
	144	// The function can not be declared const since it is just the default implementation,
	145	// overloaded virtual function might not be const.
	146	fDummy = 0;
	147
	148	return 0;
	149	}
	150
	151
7c4091c1	152	Int_t AliHLTCalibrationProcessor::ScanArgument(int argc, const char** argv) {
9d9ffd37	153	// see header file for class documentation
	154
	155	// there are no other arguments than the standard ones
	156	if ( argc == 0 && argv == NULL) {
	157	// this is just to get rid of the warning "unused parameter"
	158	}
	159
	160	// fDummy is just touched here to avoid coding convention violation RC11.
	161	// The function can not be declared const since it is just the default implementation,
	162	// overloaded virtual function might not be const.
	163	fDummy = 0;
	164
	165	return -EINVAL;
	166	}
	167
	168	/*
	169	* ######################## DeinitCalibration #####################
	170	*/
	171
	172	Int_t AliHLTCalibrationProcessor::DoDeinit() {
	173	// see header file for class documentation
	174
	175	int iResult = DeinitCalibration();
	176
	177	return iResult;
	178	}
	179
	180	Int_t AliHLTCalibrationProcessor::DeinitCalibration() {
	181	// see header file for class documentation
	182
	183	// fDummy is just touched here to avoid coding convention violation RC11.
	184	// The function can not be declared const since it is just the default implementation,
	185	// overloaded virtual function might not be const.
	186	fDummy = 0;
	187
	188	return 0;
	189	}
	190
	191	/*
	192	* ######################## DoEvent #####################
	193	*/
	194
	195	Int_t AliHLTCalibrationProcessor::DoEvent( const AliHLTComponentEventData& evtData,
	196	const AliHLTComponentBlockData* blocks,
	197	AliHLTComponentTriggerData& trigData,
	198	AliHLTUInt8_t* outputPtr,
	199	AliHLTUInt32_t& size,
	200	vector<AliHLTComponentBlockData>& outputBlocks )
	201	{
	202	// see header file for class documentation
	203
	204	Int_t iResult = 0;
9d9ffd37	205
9d9ffd37	206	const AliHLTComponentBlockData* blkSOR = NULL;
1a04dcde	207	blkSOR = GetFirstInputBlock( kAliHLTDataTypeSOR );
9d9ffd37	208	const AliHLTComponentBlockData* blkEOR = NULL;
1a04dcde	209	blkEOR = GetFirstInputBlock( kAliHLTDataTypeEOR );
1a04dcde	210
ed504011	211	// ** if event Type is not SOR or EOR -> fill DDLNumber list and process data
9d9ffd37	212	if ( ! blkEOR && !blkSOR ) {
ed504011	213
	214	// ** Set DDLNumber List
	215	if ( trigData.fData != NULL) {
	216	AliHLTEventTriggerData* trg = ( AliHLTEventTriggerData* ) trigData.fData;
	217	if ( trg != NULL) {
	218	AliHLTEventDDL list = (AliHLTEventDDL) trg->fReadoutList;
	219
	220	Int_t wordNdx = GetFirstUsedDDLWord(list);
	221	if ( wordNdx >=0 ) {
	222
	223	Int_t wordCount = 1;
	224	// Handle special TPC and TOF case
	225	if ( wordNdx == 3 )
	226	wordCount = 8;
	227	else if ( wordNdx == 12 )
	228	wordCount = 3;
	229
	230	// check word for word and binary OR it with existing DDLNumberList
	231	for ( Int_t ndx = 0; ndx < wordCount; ndx++ ) {
	232	AliHLTUInt32_t word = list.fList[wordNdx+ndx];
	233
	234	// set only 4 bit into one Char_t
	235	for ( Int_t charNdx = 0; charNdx < 8; charNdx++) {
	236	fDDLNumber[(8*ndx)+charNdx] \|= (Char_t) word & 0x0000000F;
	237	word = word >> 4;
	238	}
	239	}
	240	} // if ( wordNdx > 0 ) {
	241	} // if ( trg != NULL) {
	242	} // if ( trigData.fData != NULL) {
	243
	244	// ** ProcessData
9d9ffd37	245	iResult = ProcessCalibration( evtData, blocks, trigData, outputPtr, size, outputBlocks );
	246	fEventCounter++;
	247	}
	248
	249	// - if event Type is EOR or event modulo is set -> ship data to FXS
	250	// - use event modulo ship data also during the run
	251	if ( ( fEventModulo > 0 && fEventCounter == fEventModulo ) \|\| blkEOR ){
	252	HLTDebug ( "Ship Data to FXS!" );
	253	iResult = ShipDataToFXS( evtData, blocks, trigData, outputPtr, size, outputBlocks );
	254	fEventCounter = 0;
	255	}
	256
	257	return iResult;
	258	}
	259
	260	/*
	261	* ######################## ProcessCalibration #####################
	262	*/
	263
	264	Int_t AliHLTCalibrationProcessor::ProcessCalibration( const AliHLTComponentEventData& evtData,
29312178	265	const AliHLTComponentBlockData* /blocks/,
	266	AliHLTComponentTriggerData& trigData,
	267	AliHLTUInt8_t* /outputPtr/,
	268	AliHLTUInt32_t& /size/,
	269	vector<AliHLTComponentBlockData>& /outputBlocks/ ) {
9d9ffd37	270	// see header file for class documentation
	271
	272	// we just forward to the high level method, all other parameters already
	273	// have been stored internally
	274	return ProcessCalibration( evtData, trigData );
	275	}
	276
29312178	277	Int_t AliHLTCalibrationProcessor::ProcessCalibration( const AliHLTComponentEventData& /evtData/,
29312178	278	AliHLTComponentTriggerData& /trigData/) {
9d9ffd37	279	// see header file for class documentation
	280
	281	HLTFatal( "no processing method implemented" );
	282	return -ENOSYS;
	283	}
	284
	285	/*
	286	* ######################## ShipDataToFXS #####################
	287	*/
	288
	289	Int_t AliHLTCalibrationProcessor::ShipDataToFXS( const AliHLTComponentEventData& evtData,
29312178	290	const AliHLTComponentBlockData* /blocks/,
	291	AliHLTComponentTriggerData& trigData,
	292	AliHLTUInt8_t* /outputPtr/,
	293	AliHLTUInt32_t& /size/,
	294	vector<AliHLTComponentBlockData>& /outputBlocks/ ) {
9d9ffd37	295	// see header file for class documentation
	296
	297	// we just forward to the high level method, all other parameters already
	298	// have been stored internally
	299	return ShipDataToFXS( evtData, trigData );
	300	}
	301
	302
29312178	303	Int_t AliHLTCalibrationProcessor::ShipDataToFXS( const AliHLTComponentEventData& /evtData/,
29312178	304	AliHLTComponentTriggerData& /trigData/) {
9d9ffd37	305	// see header file for class documentation
	306
	307	HLTFatal( "no processing method implemented" );
	308	return -ENOSYS;
	309	}
	310
	311	/*
	312	* ######################## CreateFXSHeader #####################
	313	*/
	314
ed504011	315	Int_t AliHLTCalibrationProcessor::CreateFXSHeader( AliHLTFXSHeader &pHeader, const char* pDetector, const char* pFileID, AliHLTEventDDL* pDDLList ) {
9d9ffd37	316	// see header file for class documentation
	317
	318	Int_t iResult = 0;
	319
ed504011	320	// ** Fill header version
9d9ffd37	321	pHeader.fHeaderVersion = AliHLTCalibrationProcessor::fgkFXSProtocolHeaderVersion;
9d9ffd37	322
ed504011	323	// ** Fill run number
ed504011	324	pHeader.fRunNumber = GetRunNo();
9d9ffd37	325
ed504011	326	// ** Fill origin
9d9ffd37	327	HLTDebug( "FXS Header Detector size max %i - actual %i .",gkAliHLTFXSHeaderfOriginSize, strlen( pDetector ) );
	328	strncpy ( pHeader.fOrigin, pDetector, gkAliHLTFXSHeaderfOriginSize ) ;
	329
	330	// To take care if fileIDs which are longer than gkAliHLTFXSHeaderfOriginSize, write one 0 is cheaper than an if.
	331	pHeader.fOrigin[gkAliHLTFXSHeaderfOriginSize] = 0;
	332
ed504011	333	// ** Fill file ID
9d9ffd37	334	HLTInfo( "FXS Header FileID size max %i - actual %i .",gkAliHLTFXSHeaderfFileIDSize, strlen( pFileID ) );
	335	strncpy ( pHeader.fFileID, pFileID, gkAliHLTFXSHeaderfFileIDSize ) ;
	336
	337	// To take care if fileIDs which are longer than gkAliHLTFXSHeaderfFileIDSize, write one 0 is cheaper than an if.
	338	pHeader.fFileID[gkAliHLTFXSHeaderfFileIDSize] = 0;
	339
ed504011	340	// ** Fill DDL number
9d9ffd37	341
ed504011	342	// -- if component provides list, convert to fDDLNumber
	343	if ( pDDLList ) {
	344	// use user list
	345
	346	Int_t wordNdx = GetFirstUsedDDLWord( *(pDDLList) );
	347	if ( wordNdx >=0 ) {
	348
	349	Int_t wordCount = 1;
	350	// Handle special TPC and TOF case
	351	if ( wordNdx == 3 )
	352	wordCount = 8;
	353	else if ( wordNdx == 12 )
	354	wordCount = 3;
	355
	356	// check word for word
	357	for ( Int_t ndx = 0; ndx < wordCount; ndx++ ) {
	358	AliHLTUInt32_t word = pDDLList->fList[wordNdx+ndx];
	359
	360	// set only 4 bit into one Char_t
	361	for ( Int_t charNdx = 0; charNdx < 8; charNdx++) {
	362	fDDLNumber[(8*ndx)+charNdx] = (Char_t) word & 0x0000000F;
	363	word = word >> 4;
	364	}
	365	}
	366	} // if ( wordNdx > 0 ) {
	367	else
	368	iResult = wordNdx;
	369	} // if ( pDDLList ) {
	370
	371	// -- fill header with ascii chars
	372	for (Int_t ndx = 0; ndx < gkAliHLTFXSHeaderfDDLNumberSize; ndx++ ){
	373	Int_t numberToChar = (Int_t) fDDLNumber[ndx];
	374	// Get ASCII
	375	if ( numberToChar > 9 ) numberToChar += 55;
	376	else numberToChar += 48;
	377
	378	pHeader.fDDLNumber[ndx] = (Char_t) numberToChar;
	379	}
	380
e83e889b	381	return iResult;
ed504011	382	} // Int_t AliHLTCalibrationProcessor::CreateFXSHeader( AliHLTXSHeader &pHeader, const char* pDetector, const char* pFileID, AliHLTEventDDL* pDDLList ) {
9d9ffd37	383
	384	/*
	385	* ######################## PushToFXS #####################
	386	*/
	387
ed504011	388	Int_t AliHLTCalibrationProcessor::PushToFXS(TObject* pObject, const char* pDetector, const char* pFileID, AliHLTEventDDL* pDDLList ) {
9d9ffd37	389	// see header file for class documentation
	390
	391	Int_t iResult = 0;
	392
	393	AliHLTFXSHeader pHeader;
	394
ed504011	395	CreateFXSHeader( pHeader, pDetector, pFileID, pDDLList );
9d9ffd37	396
	397	if ( pObject ) {
	398
	399	AliHLTMemoryFile* pMemFile = CreateMemoryFile( kAliHLTDataTypeFXSCalib, kAliHLTVoidDataSpec );
	400	if ( pMemFile ) {
	401
29312178	402	iResult = pMemFile->WriteHeaderBuffer( (const char*) &pHeader, AliHLTCalibrationProcessor::fgkFXSProtocolHeaderSize );
9d9ffd37	403
	404	if ( iResult ) {
	405	HLTError( "Buffer size to small - for header!" );
	406	}
	407	else {
	408	iResult = Write( pMemFile, pObject );
	409	if ( !iResult ) {
	410	HLTError( "Buffer size to small - for data!" );
	411	}
	412	else {
	413	iResult = CloseMemoryFile( pMemFile );
	414	}
	415	}
	416	}
	417	else {
	418	iResult = -ENOMEM;
	419	}
	420	}
	421	else {
	422	iResult=-EINVAL;
	423	}
	424
	425	return iResult;
	426
ed504011	427	} // Int_t AliHLTCalibrationProcessor::PushToFXS(TObject* pObject, const char* detector, const char* pFileID, AliHLTEventDDL* pDDLList ) {
9d9ffd37	428
ed504011	429	Int_t AliHLTCalibrationProcessor::PushToFXS( void* pBuffer, int iSize, const char* pDetector, const char* pFileID, AliHLTEventDDL* pDDLList ) {
3a7c0444	430	// see header file for class documentation
9d9ffd37	431
	432	Int_t iResult = 0;
	433
	434	AliHLTFXSHeader pHeader;
	435
ed504011	436	CreateFXSHeader( pHeader, pDetector, pFileID, pDDLList );
9d9ffd37	437
	438	iResult = PushBack( pBuffer, iSize, kAliHLTDataTypeFXSCalib, kAliHLTVoidDataSpec, (void*) (&pHeader), AliHLTCalibrationProcessor::fgkFXSProtocolHeaderSize );
	439
	440	return iResult;
	441
ed504011	442	} // Int_t AliHLTCalibrationProcessor::PushToFXS(void* pBuffer, int iSize, const char* pDdetector, const char* pFileID, AliHLTEventDDL* pDDLList ) {
9d9ffd37	443