[u/mrichter/AliRoot.git] / HLT / comp / AliHLTCOMPHuffmanAltroCalibComponent.cxx

/**************************************************************************
 * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
 *                                                                        *
 * Authors: Jochen Thaeder <thaeder@kip.uni-heidelberg.de>                *
 *          for The ALICE Off-line 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   AliHLTCOMPHuffmanAltroCalibComponent.cxx
    @author Jochen Thaeder
    @date   
    @brief  A calibration component for the Huffman code creation.
*/

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

#include "AliHLTCOMPHuffmanAltroCalibComponent.h"
#include "AliHLTCOMPHuffmanAltro.h"
#include "AliHLTCompDefinitions.h"
#include "AliHLTStdIncludes.h"
#include "AliHLTReadoutList.h"
#include "TFile.h" // necessary for HuffmanData writing

ClassImp(AliHLTCOMPHuffmanAltroCalibComponent)

AliHLTCOMPHuffmanAltroCalibComponent::AliHLTCOMPHuffmanAltroCalibComponent()
  :
  fHuffmanCompressor(NULL),
  fHuffmanData(NULL),
  fOrigin(kAliHLTVoidDataOrigin),
  fRunNumber(0),
  fSpecification(0),
  fTablePath(),
  fNRCUTrailerWords(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
}

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

// Public functions to implement AliHLTComponent's interface.
// These functions are required for the registration process

const char* AliHLTCOMPHuffmanAltroCalibComponent::GetComponentID() {
  // see header file for class documentation

  return "COMPHuffmanTrainer";
}

void AliHLTCOMPHuffmanAltroCalibComponent::GetInputDataTypes( vector<AliHLTComponentDataType>& list) {
  // see header file for class documentation
  list.clear(); 
  list.push_back( kAliHLTDataTypeDDLRaw );
}

AliHLTComponentDataType AliHLTCOMPHuffmanAltroCalibComponent::GetOutputDataType() {
  // see header file for class documentation
  AliHLTComponentDataType dt=AliHLTCompDefinitions::fgkHuffmanAltroCalDataType;
  if (!fOrigin.IsNull()) dt=dt|fOrigin.Data();
  return dt;
 
}

void AliHLTCOMPHuffmanAltroCalibComponent::GetOutputDataSize( unsigned long& constBase, double& inputMultiplier ) {
  // see header file for class documentation
  constBase = sizeof(AliHLTCOMPHuffmanData);
  inputMultiplier = (0.0);
}

AliHLTComponent* AliHLTCOMPHuffmanAltroCalibComponent::Spawn() {
  // see header file for class documentation

  return new AliHLTCOMPHuffmanAltroCalibComponent();
}  


Int_t AliHLTCOMPHuffmanAltroCalibComponent::ScanArgument( Int_t argc, const char** argv ) {
  // see header file for class documentation

  Int_t iResult = 0;
  TString argument = " ";
  TString parameter = " ";

  if ( !argc ) 
    return -EINVAL;

  argument = argv[iResult];
  
  if ( argument.IsNull() ) 
    return -EINVAL;

  // get data origin
  if ( argument.CompareTo("-origin") == 0 ) 
    {

      if ( ++iResult >= argc  ) 
	{
	  iResult = -EPROTO;
	}
      else 
	{
	  fOrigin = argv[1];

	  while(fOrigin.Length() <  kAliHLTComponentDataTypefOriginSize)
	    {
	      fOrigin.Append(" ");
	    }
	
	  HLTInfo("Origin is set to %s.", fOrigin.Data());	  

	}
    }

  else
    {
      // get run number   
      if ( argument.CompareTo("-runnumber") == 0 ) 
	{
	  
	if ( ++iResult >= argc  ) 
	  {
	    iResult = -EPROTO;
	  }
	else 
	  {
	    parameter = argv[1];
	    
	    // get run number
	 
	    fRunNumber =  atoi(parameter.Data());
	       
	    HLTInfo( "Run number is set to %d (Dec) = %X (Hex).", fRunNumber, fRunNumber ); 
	  }
	}
      else
	{
	  // get data specification
	  if(argument.CompareTo("-dataspec") == 0 ) 
	    {
	      if ( ++iResult >= argc  ) 
		{
		  iResult = -EPROTO;
		}
	      else 
		{
		  // get data specification
		  fSpecification = strtoul( argv[1], NULL, 16);
		  
		  HLTInfo( "Specification is set to %d (Dec) = %08X (Hex).", fSpecification, fSpecification ); 
		}
	    }
	  // get number of trailer words
	  else 
	    {
	      
	      if ( argument.CompareTo("-tablepath") == 0)
		{
		  if ( ++iResult >= argc  ) 
		    {
		      iResult = -EPROTO;
		    }
		  else 
		    {
		      // get table path
		      fTablePath = argv[1];
		      HLTInfo( "Path for Huffman table output is set to %s.", fTablePath.Data() ); 
		      if (!fTablePath.IsNull() && !fTablePath.EndsWith("/"))
			fTablePath+="/";		      
		    }
		}

	      else 
		{
		  if ( argument.CompareTo("-trailerwords") == 0 ) 
		    { 
		      
		      if ( ++iResult >= argc  ) 
			{
			  iResult = -EPROTO;
			}
		      else 
			{
			  parameter = argv[1];
			  if ( parameter.CompareTo("1") == 0 ) 
			    {
			      fNRCUTrailerWords = 1;
			      HLTInfo( "Number of trailer words is set to 1." );
			    }
			  else if ( parameter.CompareTo("2") == 0 ) 
			    {
			      fNRCUTrailerWords = 2;
			  HLTInfo( "Number of trailer words is set to 2." );
			    }
			  else if ( parameter.CompareTo("3") == 0 ) 
			    {
			      fNRCUTrailerWords = 3;
			  HLTInfo( "Number of trailer words is set to 3." );
			    }
			  else 
			    {
			      HLTError( "Invalid number of trailerwords: '%s'.", argv[1] );
			      iResult = -EPROTO;
			    }
			} 
		    }
		  else 
		    {
		      iResult = -EINVAL;
		    }
		}
	    }
	}
    }
  
  return iResult;
}

Int_t AliHLTCOMPHuffmanAltroCalibComponent::InitCalibration() {
  // see header file for class documentation
    
  // ** Create a calibration instance to train the Huffman code table
  if ( fHuffmanCompressor )
    return EINPROGRESS;
  
  if ( fHuffmanData )
    return EINPROGRESS;

  // create a new instance of HuffmanData to write results from training in
  fHuffmanData = new AliHLTCOMPHuffmanData();

  fHuffmanCompressor = new AliHLTCOMPHuffmanAltro(kTRUE, kTRUE, NULL, fNRCUTrailerWords);

  // initialise new training table
  fHuffmanCompressor->InitNewTrainingTable(); 
 
  return 0;
}

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

  if ( fHuffmanCompressor )
    delete fHuffmanCompressor; 
  fHuffmanCompressor = NULL;

  if ( fHuffmanData )
    delete fHuffmanData; 
  fHuffmanData = NULL;

  return 0;
}

/** function to do the calibration */
Int_t AliHLTCOMPHuffmanAltroCalibComponent::ProcessCalibration( const AliHLTComponentEventData& evtData, AliHLTComponentTriggerData& /*trigData*/ ) {
  // see header file for class documentation
 
  if (evtData.fEventID==0) {
    // this is only to avoid missing parameter warning when compiling for non
    // debug. The parameter is used in the HLTDebug message only.
  }

  const AliHLTComponentBlockData* iter = NULL;

  //AliHLTUInt8_t slice, patch;
 
  // ** Loop over all input blocks and specify which data format should be read - only select Raw Data
  iter = GetFirstInputBlock( kAliHLTDataTypeDDLRaw );

  if ( iter != NULL ) do {
    
    // ** Print Debug output which data format was received
    HLTDebug ( "Event received - Event 0x%08LX (%Lu) received datatype: %s - required datatype: %s", 
	       evtData.fEventID, evtData.fEventID, DataType2Text(iter->fDataType).c_str(), DataType2Text(kAliHLTDataTypeDDLRaw).c_str());

    
    TString blockorigin("");
    blockorigin.Insert(0, iter->fDataType.fOrigin, kAliHLTComponentDataTypefOriginSize);
    
    if (fOrigin.IsNull())
      {
	// if origin is not explicitly set by command line, take origin from data block
	fOrigin=blockorigin;
	HLTDebug("Origin of current data block set by block itself is %s.", blockorigin.Data());
      }
    else
      {
	// if set origin is not equal to current block origin, printout warning! 
	if(fOrigin.CompareTo(blockorigin)!=0) {
	  HLTWarning("Origin %s of current data block does not match origin set by command line argument %s.", blockorigin.Data(), fOrigin.Data());
	  continue;
	}
      }

    // ** Get DDL ID in order to tell the memory reader which slice/patch to use
    //fSlice = AliHLTCompDefinitions::GetMinSliceNr( *iter );
    //fPatch = AliHLTCompDefinitions::GetMinPatchNr( *iter );

    //HLTDebug ( "Input Raw Data - Slice/Patch: %d/%d.", fSlice, fPatch);

    fHuffmanCompressor->SetInputData(iter->fPtr, iter->fSize);

    // only necessary for output in binary file
    //fHuffmanCompressor->SetSlice(fSlice);
    //fHuffmanCompressor->SetPatch(fPatch);
   
    fHuffmanCompressor->ProcessData();
  
    // ** Get next input block, with the same specification as defined in GetFirstInputBlock()
  } while ( (iter = GetNextInputBlock()) != NULL );

  // ** Get output specification
  // commented out for the moment to read spec in from command line argument
  //fSpecification = AliHLTCompDefinitions::EncodeDataSpecification( fSlice, fSlice, fPatch, fPatch );
  //fSpecification = fSlice<<24 | fSlice<<16 | fPatch<<8 | fPatch;

  // ** PushBack data to shared memory ... 

  // DATA TYE to DEFINE !!! XXXX
  PushBack( (TObject*) fHuffmanData, AliHLTCompDefinitions::fgkHuffmanAltroCalDataType|fOrigin.Data(), fSpecification);
 
  return 0;
} // Int_t AliHLTCOMPHuffmanAltroCalibComponent::ProcessCalibration( const AliHLTComponentEventData& evtData, AliHLTComponentTriggerData& trigData ) {


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

  // create code from training table
  fHuffmanCompressor->CreateCodeTable();

  // write code table and occurrence table to HuffmanData instance
  fHuffmanCompressor->SetHuffmanData(fHuffmanData);

  TString rootfilename;
  if(fTablePath.IsNull() )
    {
      // if there is no explicit table path, take current path
      rootfilename.Form("huffmanData_%s_%08X_%08X.root", fOrigin.Data(), fRunNumber, fSpecification);      
    }
  else
    {
      rootfilename.Form("%shuffmanData_%s_%08X_%08X.root", fTablePath.Data(), fOrigin.Data(), fRunNumber, fSpecification);
    }
 
  TFile* huffmanrootfile = new TFile(rootfilename, "RECREATE");
  huffmanrootfile->WriteObject(fHuffmanData,"HuffmanData");
  huffmanrootfile->Write();
  huffmanrootfile->Close();

  // ** PushBack data to FXS ...
  // currently specification has to be put in by command line argument!
  Int_t dataspec = (Int_t) fSpecification;

  fHuffmanData->SetOCDBSpecifications(fOrigin, dataspec);
  static AliHLTReadoutList rdList(AliHLTReadoutList::kTPC);
  PushToFXS( (TObject*) fHuffmanData, "TPC", "HuffmanData", &rdList ) ;
  
  return 0;
} // Int_t AliHLTCOMPHuffmanAltroCalibComponent::ShipDataToFXS( const AliHLTComponentEventData& evtData, AliHLTComponentTriggerData& trigData ) {
Commit	Line	Data
c2440081	1	/**************************************************************************
	2	* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
	3	* *
	4	* Authors: Jochen Thaeder <thaeder@kip.uni-heidelberg.de> *
	5	* for The ALICE Off-line Project. *
	6	* *
	7	* Permission to use, copy, modify and distribute this software and its *
	8	* documentation strictly for non-commercial purposes is hereby granted *
	9	* without fee, provided that the above copyright notice appears in all *
	10	* copies and that both the copyright notice and this permission notice *
	11	* appear in the supporting documentation. The authors make no claims *
	12	* about the suitability of this software for any purpose. It is *
	13	* provided "as is" without express or implied warranty. *
	14	**************************************************************************/
	15
	16	/** @file AliHLTCOMPHuffmanAltroCalibComponent.cxx
	17	@author Jochen Thaeder
	18	@date
	19	@brief A calibration component for the Huffman code creation.
	20	*/
	21
	22	#if __GNUC__>= 3
	23	using namespace std;
	24	#endif
	25
	26	#include "AliHLTCOMPHuffmanAltroCalibComponent.h"
	27	#include "AliHLTCOMPHuffmanAltro.h"
	28	#include "AliHLTCompDefinitions.h"
	29	#include "AliHLTStdIncludes.h"
8d53dca2	30	#include "AliHLTReadoutList.h"
c2440081	31	#include "TFile.h" // necessary for HuffmanData writing
	32
	33	ClassImp(AliHLTCOMPHuffmanAltroCalibComponent)
	34
	35	AliHLTCOMPHuffmanAltroCalibComponent::AliHLTCOMPHuffmanAltroCalibComponent()
	36	:
	37	fHuffmanCompressor(NULL),
af2ed151	38	fHuffmanData(NULL),
5eefc803	39	fOrigin(kAliHLTVoidDataOrigin),
c2440081	40	fRunNumber(0),
	41	fSpecification(0),
	42	fTablePath(),
	43	fNRCUTrailerWords(0) {
	44	// see header file for class documentation
	45	// or
	46	// refer to README to build package
	47	// or
	48	// visit http://web.ift.uib.no/~kjeks/doc/alice-hlt
	49	}
	50
	51	AliHLTCOMPHuffmanAltroCalibComponent::~AliHLTCOMPHuffmanAltroCalibComponent() {
	52	// see header file for class documentation
	53	}
	54
	55	// Public functions to implement AliHLTComponent's interface.
	56	// These functions are required for the registration process
	57
	58	const char* AliHLTCOMPHuffmanAltroCalibComponent::GetComponentID() {
	59	// see header file for class documentation
	60
	61	return "COMPHuffmanTrainer";
	62	}
	63
	64	void AliHLTCOMPHuffmanAltroCalibComponent::GetInputDataTypes( vector<AliHLTComponentDataType>& list) {
	65	// see header file for class documentation
c2440081	66	list.clear();
	67	list.push_back( kAliHLTDataTypeDDLRaw );
	68	}
	69
	70	AliHLTComponentDataType AliHLTCOMPHuffmanAltroCalibComponent::GetOutputDataType() {
	71	// see header file for class documentation
c2440081	72	AliHLTComponentDataType dt=AliHLTCompDefinitions::fgkHuffmanAltroCalDataType;
	73	if (!fOrigin.IsNull()) dt=dt\|fOrigin.Data();
	74	return dt;
bf7a3243	75
c2440081	76	}
	77
	78	void AliHLTCOMPHuffmanAltroCalibComponent::GetOutputDataSize( unsigned long& constBase, double& inputMultiplier ) {
	79	// see header file for class documentation
c2440081	80	constBase = sizeof(AliHLTCOMPHuffmanData);
	81	inputMultiplier = (0.0);
	82	}
	83
	84	AliHLTComponent* AliHLTCOMPHuffmanAltroCalibComponent::Spawn() {
	85	// see header file for class documentation
	86
	87	return new AliHLTCOMPHuffmanAltroCalibComponent();
	88	}
	89
	90
	91	Int_t AliHLTCOMPHuffmanAltroCalibComponent::ScanArgument( Int_t argc, const char** argv ) {
	92	// see header file for class documentation
	93
	94	Int_t iResult = 0;
	95	TString argument = " ";
	96	TString parameter = " ";
	97
	98	if ( !argc )
	99	return -EINVAL;
	100
	101	argument = argv[iResult];
	102
	103	if ( argument.IsNull() )
	104	return -EINVAL;
	105
	106	// get data origin
	107	if ( argument.CompareTo("-origin") == 0 )
	108	{
	109
	110	if ( ++iResult >= argc )
	111	{
	112	iResult = -EPROTO;
	113	}
	114	else
	115	{
	116	fOrigin = argv[1];
	117
bf7a3243	118	while(fOrigin.Length() < kAliHLTComponentDataTypefOriginSize)
	119	{
	120	fOrigin.Append(" ");
	121	}
	122
c2440081	123	HLTInfo("Origin is set to %s.", fOrigin.Data());
	124
	125	}
	126	}
	127
	128	else
	129	{
	130	// get run number
	131	if ( argument.CompareTo("-runnumber") == 0 )
	132	{
	133
	134	if ( ++iResult >= argc )
	135	{
	136	iResult = -EPROTO;
	137	}
	138	else
	139	{
	140	parameter = argv[1];
	141
	142	// get run number
	143
	144	fRunNumber = atoi(parameter.Data());
	145
	146	HLTInfo( "Run number is set to %d (Dec) = %X (Hex).", fRunNumber, fRunNumber );
	147	}
	148	}
	149	else
	150	{
	151	// get data specification
	152	if(argument.CompareTo("-dataspec") == 0 )
	153	{
	154	if ( ++iResult >= argc )
	155	{
	156	iResult = -EPROTO;
	157	}
	158	else
	159	{
	160	// get data specification
	161	fSpecification = strtoul( argv[1], NULL, 16);
	162
	163	HLTInfo( "Specification is set to %d (Dec) = %08X (Hex).", fSpecification, fSpecification );
	164	}
	165	}
	166	// get number of trailer words
	167	else
	168	{
	169
	170	if ( argument.CompareTo("-tablepath") == 0)
	171	{
	172	if ( ++iResult >= argc )
	173	{
	174	iResult = -EPROTO;
	175	}
	176	else
	177	{
	178	// get table path
	179	fTablePath = argv[1];
bf7a3243	180	HLTInfo( "Path for Huffman table output is set to %s.", fTablePath.Data() );
c2440081	181	if (!fTablePath.IsNull() && !fTablePath.EndsWith("/"))
bf7a3243	182	fTablePath+="/";
c2440081	183	}
	184	}
	185
	186	else
	187	{
	188	if ( argument.CompareTo("-trailerwords") == 0 )
	189	{
	190
	191	if ( ++iResult >= argc )
	192	{
	193	iResult = -EPROTO;
	194	}
	195	else
	196	{
	197	parameter = argv[1];
	198	if ( parameter.CompareTo("1") == 0 )
	199	{
	200	fNRCUTrailerWords = 1;
	201	HLTInfo( "Number of trailer words is set to 1." );
	202	}
	203	else if ( parameter.CompareTo("2") == 0 )
	204	{
	205	fNRCUTrailerWords = 2;
	206	HLTInfo( "Number of trailer words is set to 2." );
	207	}
	208	else if ( parameter.CompareTo("3") == 0 )
	209	{
	210	fNRCUTrailerWords = 3;
	211	HLTInfo( "Number of trailer words is set to 3." );
	212	}
	213	else
	214	{
	215	HLTError( "Invalid number of trailerwords: '%s'.", argv[1] );
	216	iResult = -EPROTO;
	217	}
	218	}
	219	}
	220	else
	221	{
	222	iResult = -EINVAL;
	223	}
	224	}
	225	}
	226	}
	227	}
	228
	229	return iResult;
	230	}
	231
	232	Int_t AliHLTCOMPHuffmanAltroCalibComponent::InitCalibration() {
	233	// see header file for class documentation
	234
	235	// ** Create a calibration instance to train the Huffman code table
	236	if ( fHuffmanCompressor )
	237	return EINPROGRESS;
	238
	239	if ( fHuffmanData )
	240	return EINPROGRESS;
	241
	242	// create a new instance of HuffmanData to write results from training in
	243	fHuffmanData = new AliHLTCOMPHuffmanData();
	244
	245	fHuffmanCompressor = new AliHLTCOMPHuffmanAltro(kTRUE, kTRUE, NULL, fNRCUTrailerWords);
	246
247	// initialise new training table
248	fHuffmanCompressor->InitNewTrainingTable();
249
250	return 0;
251	}
252
253	Int_t AliHLTCOMPHuffmanAltroCalibComponent::DeinitCalibration() {
254	// see header file for class documentation
255
256	if ( fHuffmanCompressor )
257	delete fHuffmanCompressor;
258	fHuffmanCompressor = NULL;
259
260	if ( fHuffmanData )
261	delete fHuffmanData;
262	fHuffmanData = NULL;
263
264	return 0;
265	}
266
267	/** function to do the calibration */
a2ba9ae9	268	Int_t AliHLTCOMPHuffmanAltroCalibComponent::ProcessCalibration( const AliHLTComponentEventData& evtData, AliHLTComponentTriggerData& /trigData/ ) {
c2440081	269	// see header file for class documentation
c2440081	270
a2ba9ae9	271	if (evtData.fEventID==0) {
	272	// this is only to avoid missing parameter warning when compiling for non
	273	// debug. The parameter is used in the HLTDebug message only.
	274	}
	275
c2440081	276	const AliHLTComponentBlockData* iter = NULL;
	277
	278	//AliHLTUInt8_t slice, patch;
	279
	280	// ** Loop over all input blocks and specify which data format should be read - only select Raw Data
	281	iter = GetFirstInputBlock( kAliHLTDataTypeDDLRaw );
c2440081	282
bf7a3243	283	if ( iter != NULL ) do {
bf7a3243	284
c2440081	285	// ** Print Debug output which data format was received
	286	HLTDebug ( "Event received - Event 0x%08LX (%Lu) received datatype: %s - required datatype: %s",
	287	evtData.fEventID, evtData.fEventID, DataType2Text(iter->fDataType).c_str(), DataType2Text(kAliHLTDataTypeDDLRaw).c_str());
	288
	289
	290	TString blockorigin("");
	291	blockorigin.Insert(0, iter->fDataType.fOrigin, kAliHLTComponentDataTypefOriginSize);
	292
	293	if (fOrigin.IsNull())
	294	{
	295	// if origin is not explicitly set by command line, take origin from data block
	296	fOrigin=blockorigin;
	297	HLTDebug("Origin of current data block set by block itself is %s.", blockorigin.Data());
	298	}
	299	else
	300	{
bf7a3243	301	// if set origin is not equal to current block origin, printout warning!
c2440081	302	if(fOrigin.CompareTo(blockorigin)!=0) {
	303	HLTWarning("Origin %s of current data block does not match origin set by command line argument %s.", blockorigin.Data(), fOrigin.Data());
	304	continue;
	305	}
	306	}
	307
	308	// ** Get DDL ID in order to tell the memory reader which slice/patch to use
	309	//fSlice = AliHLTCompDefinitions::GetMinSliceNr( *iter );
	310	//fPatch = AliHLTCompDefinitions::GetMinPatchNr( *iter );
	311
	312	//HLTDebug ( "Input Raw Data - Slice/Patch: %d/%d.", fSlice, fPatch);
	313
	314	fHuffmanCompressor->SetInputData(iter->fPtr, iter->fSize);
	315
	316	// only necessary for output in binary file
	317	//fHuffmanCompressor->SetSlice(fSlice);
	318	//fHuffmanCompressor->SetPatch(fPatch);
	319
	320	fHuffmanCompressor->ProcessData();
	321
	322	// ** Get next input block, with the same specification as defined in GetFirstInputBlock()
	323	} while ( (iter = GetNextInputBlock()) != NULL );
	324
	325	// ** Get output specification
	326	// commented out for the moment to read spec in from command line argument
	327	//fSpecification = AliHLTCompDefinitions::EncodeDataSpecification( fSlice, fSlice, fPatch, fPatch );
	328	//fSpecification = fSlice<<24 \| fSlice<<16 \| fPatch<<8 \| fPatch;
	329
	330	// ** PushBack data to shared memory ...
	331
	332	// DATA TYE to DEFINE !!! XXXX
	333	PushBack( (TObject*) fHuffmanData, AliHLTCompDefinitions::fgkHuffmanAltroCalDataType\|fOrigin.Data(), fSpecification);
	334
	335	return 0;
	336	} // Int_t AliHLTCOMPHuffmanAltroCalibComponent::ProcessCalibration( const AliHLTComponentEventData& evtData, AliHLTComponentTriggerData& trigData ) {
	337
	338
5eefc803	339	Int_t AliHLTCOMPHuffmanAltroCalibComponent::ShipDataToFXS( const AliHLTComponentEventData& /evtData/, AliHLTComponentTriggerData& /trigData/ ) {
c2440081	340	// see header file for class documentation
	341
	342	// create code from training table
	343	fHuffmanCompressor->CreateCodeTable();
	344
	345	// write code table and occurrence table to HuffmanData instance
	346	fHuffmanCompressor->SetHuffmanData(fHuffmanData);
	347
	348	TString rootfilename;
	349	if(fTablePath.IsNull() )
	350	{
	351	// if there is no explicit table path, take current path
bf7a3243	352	rootfilename.Form("huffmanData_%s_%08X_%08X.root", fOrigin.Data(), fRunNumber, fSpecification);
c2440081	353	}
	354	else
	355	{
bf7a3243	356	rootfilename.Form("%shuffmanData_%s_%08X_%08X.root", fTablePath.Data(), fOrigin.Data(), fRunNumber, fSpecification);
c2440081	357	}
	358
	359	TFile* huffmanrootfile = new TFile(rootfilename, "RECREATE");
	360	huffmanrootfile->WriteObject(fHuffmanData,"HuffmanData");
	361	huffmanrootfile->Write();
	362	huffmanrootfile->Close();
	363
	364	// ** PushBack data to FXS ...
92272b35	365	// currently specification has to be put in by command line argument!
92272b35	366	Int_t dataspec = (Int_t) fSpecification;
c2440081	367
92272b35	368	fHuffmanData->SetOCDBSpecifications(fOrigin, dataspec);
8d53dca2	369	static AliHLTReadoutList rdList(AliHLTReadoutList::kTPC);
89413559	370	PushToFXS( (TObject*) fHuffmanData, "TPC", "HuffmanData", &rdList ) ;
c2440081	371
	372	return 0;
	373	} // Int_t AliHLTCOMPHuffmanAltroCalibComponent::ShipDataToFXS( const AliHLTComponentEventData& evtData, AliHLTComponentTriggerData& trigData ) {