[u/mrichter/AliRoot.git] / HLT / TPCLib / comp / AliHLTTPCCompModelDeflaterComponent.cxx

// $Id$

//**************************************************************************
//* This file is property of and copyright by the ALICE HLT Project        * 
//* ALICE Experiment at CERN, All rights reserved.                         *
//*                                                                        *
//* Primary Authors: Timm Steinbeck <timm@kip.uni-heidelberg.de>           *
//*                  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   AliHLTTPCCompModelDeflaterComponent.cxx
    @author Timm Steinbeck
    @date   
    @brief  A copy processing component for the HLT. */

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

#include "AliHLTTPCCompModelDeflaterComponent.h"
#include "AliHLTTPCDefinitions.h"
#include <stdlib.h>
#include <errno.h>

/** ROOT macro for the implementation of ROOT specific class methods */
ClassImp(AliHLTTPCCompModelDeflaterComponent);
    
AliHLTTPCCompModelDeflaterComponent::AliHLTTPCCompModelDeflaterComponent():
  fModelDeflater(),
  fConverter(),
  fForwardIfUncompressed(true)
    {
      // see header file for class documentation
    }

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

const char* AliHLTTPCCompModelDeflaterComponent::GetComponentID()
    {
      // see header file for class documentation
      return "TPCCompModelDeflater"; // The ID of this component
    }

void AliHLTTPCCompModelDeflaterComponent::GetInputDataTypes( vector<AliHLTComponent_DataType>& list)
    {
      // see header file for class documentation
      list.clear(); // We do not have any requirements for our input data type(s).
      list.push_back( AliHLTTPCDefinitions::fgkClusterTracksModelDataType );
      list.push_back( AliHLTTPCDefinitions::fgkRemainingClustersModelDataType );
    }

AliHLTComponent_DataType AliHLTTPCCompModelDeflaterComponent::GetOutputDataType()
    {
      // see header file for class documentation
      return AliHLTTPCDefinitions::fgkClusterTracksCompressedDataType;
    }

void AliHLTTPCCompModelDeflaterComponent::GetOutputDataSize( unsigned long& constBase, double& inputMultiplier )
    {
      // see header file for class documentation
      constBase = 1+1+216; // Format versions + cluster count per patch
      inputMultiplier = 4.;
      //#warning Adapt input Multiplier to something more realistic
    }

// Spawn function, return new instance of this class
AliHLTComponent* AliHLTTPCCompModelDeflaterComponent::Spawn()
    {
      // see header file for class documentation
      return new AliHLTTPCCompModelDeflaterComponent;
    };

int AliHLTTPCCompModelDeflaterComponent::DoInit( int argc, const char** argv )
    {
      // see header file for class documentation
      //char* cpErr;
      if ( argc )
	{
	  Logging( kHLTLogDebug, "HLT::TPCCompModelDeflater::DoInit", "Arguments", "argv[0] == %s", argv[0] );
	  Logging(kHLTLogError, "HLT::TPCCompModelDeflater::DoInit", "Unknown Option", "Unknown option '%s'", argv[0] );
	  return EINVAL;
	}
    return 0;
    }

int AliHLTTPCCompModelDeflaterComponent::DoDeinit()
    {
      // see header file for class documentation
      return 0;
    }

int AliHLTTPCCompModelDeflaterComponent::DoEvent( const AliHLTComponent_EventData& evtData, const AliHLTComponent_BlockData* blocks, 
						   AliHLTComponent_TriggerData& /*trigData*/, AliHLTUInt8_t* outputPtr, 
				      AliHLTUInt32_t& size, vector<AliHLTComponent_BlockData>& outputBlocks )
    {
      // see header file for class documentation
      // Process an event
      // Loop over all input blocks in the event
      AliHLTUInt8_t* writePtr = outputPtr;
      AliHLTUInt32_t outputSize = 0, blockSize;
      int ret;
      AliHLTComponent_BlockData ob;
      AliHLTUInt8_t minSlice=0xFF, maxSlice=0xFF, minPatch=0xFF, maxPatch=0xFF;
      fConverter.Init();
      unsigned long long totalNonModelDataSize=0;
      
      for ( unsigned long n = 0; n < evtData.fBlockCnt; n++ )
	{
	  if ( blocks[n].fDataType == AliHLTTPCDefinitions::fgkClusterTracksModelDataType )
	    {
	      blockSize = size-outputSize;
	      ret = fModelDeflater.CompressTracks( (AliHLTUInt8_t*)blocks[n].fPtr, blocks[n].fSize, writePtr, blockSize );
	      if ( !ret && blockSize<blocks[n].fSize )
		{
		  // Let the structure be filled with the default values.
		  // This takes care of setting the shared memory and data type values to default values,
		  // so that they can be filled in by the calling code.
		  FillBlockData( ob );
		  // This block's start (offset) is after all other blocks written so far
		  ob.fOffset = outputSize;
		  // the size of this block's data.
		  ob.fSize = blockSize;
		  // The specification of the data is copied from the input block.
		  ob.fSpecification = blocks[n].fSpecification;
		  // The type of the data is copied from the input block.
		  ob.fDataType = AliHLTTPCDefinitions::fgkClusterTracksCompressedDataType;
		  // Place this block into the list of output blocks
		  outputBlocks.push_back( ob );
		  writePtr += blockSize;
		outputSize += blockSize;
		}
	      else if ( fForwardIfUncompressed )
		{
		  outputBlocks.push_back( blocks[n] );
		}
	      continue;
	    }
	  if ( blocks[n].fDataType == AliHLTTPCDefinitions::fgkRemainingClustersModelDataType )
	    {
	    blockSize = size-outputSize;
	    ret = fModelDeflater.CompressRemainingClusters( (AliHLTUInt8_t*)blocks[n].fPtr, blocks[n].fSize, writePtr, blockSize );
	    HLTDebug( "ret: %d - blockSize: %u - blocks[%u].fSize: %u", ret, (unsigned)blockSize, (unsigned)n, (unsigned)blocks[n].fSize );
	    if ( !ret && blockSize<blocks[n].fSize )
	      {
		// Let the structure be filled with the default values.
		// This takes care of setting the shared memory and data type values to default values,
		// so that they can be filled in by the calling code.
		FillBlockData( ob );
		// This block's start (offset) is after all other blocks written so far
		ob.fOffset = outputSize;
		// the size of this block's data.
		ob.fSize = blockSize;
		// The specification of the data is copied from the input block.
		ob.fSpecification = blocks[n].fSpecification;
		// The type of the data is copied from the input block.
		ob.fDataType = AliHLTTPCDefinitions::fgkRemainingClustersCompressedDataType;
		// Place this block into the list of output blocks
		outputBlocks.push_back( ob );
		writePtr += blockSize;
		outputSize += blockSize;
	      }
	    else if ( fForwardIfUncompressed )
	      {
		outputBlocks.push_back( blocks[n] );
	      }
	    continue;
	    }
	  AliHLTUInt8_t slice = 0;
	  AliHLTUInt8_t patch = 0;
	  if ( blocks[n].fDataType == AliHLTTPCDefinitions::fgkClustersDataType ||
	       blocks[n].fDataType == AliHLTTPCDefinitions::fgkTracksDataType )
	    {
	      slice = AliHLTTPCDefinitions::GetMinSliceNr( blocks[n].fSpecification );
	      patch = AliHLTTPCDefinitions::GetMinPatchNr( blocks[n].fSpecification );
	      if ( minSlice==0xFF || slice<minSlice )
		minSlice = slice;
	      if ( maxSlice==0xFF || slice>maxSlice )
		maxSlice = slice;
	      if ( minPatch==0xFF || patch<minPatch )
		minPatch = patch;
	      if ( maxPatch==0xFF || patch>maxPatch )
		maxPatch = patch;
	      totalNonModelDataSize += blocks[n].fSize;
	    }
	  if ( blocks[n].fDataType == AliHLTTPCDefinitions::fgkClustersDataType )
	    {
	    fConverter.SetInputClusters( (AliHLTTPCClusterData*)blocks[n].fPtr, slice, patch );
	    }
	  if ( blocks[n].fDataType == (kAliHLTDataTypeTrack|kAliHLTDataOriginTPC) )
	    {
	      fConverter.SetInputTracks( (AliHLTTracksData*)blocks[n].fPtr, blocks[n].fSize );
	    }
	  
	}
      
      if ( totalNonModelDataSize>0 )
	{
	  fConverter.Convert();
	  
	  unsigned long trackSize = fConverter.GetOutputModelDataSize();
	  AliHLTUInt8_t* trackModelData = new AliHLTUInt8_t[ trackSize ];
	  if ( !trackModelData )
	    {
	      HLTError( "Out of memory trying to allocate %lu bytes of trackmodeldata", trackSize );
	      return ENOMEM;
	    }
	  
	  fConverter.OutputModelData( trackModelData, trackSize );
	  
	  unsigned long clusterSize = fConverter.GetRemainingClustersOutputDataSize();
	  AliHLTUInt8_t* remainingClustersModelData = new AliHLTUInt8_t[ clusterSize ];
	  if ( !remainingClustersModelData )
	    {
	      HLTError( "Out of memory trying to allocate %lu bytes of remaining cluster model data", clusterSize );
	      delete [] trackModelData;
	      return ENOMEM;
	    }
	  
	  fConverter.GetRemainingClusters( remainingClustersModelData, clusterSize );
	  
	  bool forwardUncompressed = false;
	  
	  blockSize = size-outputSize;
	  ret = fModelDeflater.CompressTracks( trackModelData, trackSize, writePtr, blockSize );
	  unsigned long long totalCompressedModelData = blockSize;
	  if ( !ret )
	    {
	      // Let the structure be filled with the default values.
	      // This takes care of setting the shared memory and data type values to default values,
	      // so that they can be filled in by the calling code.
	      FillBlockData( ob );
	      // This block's start (offset) is after all other blocks written so far
	      ob.fOffset = outputSize;
	      // the size of this block's data.
	      ob.fSize = blockSize;
	      // The specification of the data is copied from the input block.
	      ob.fSpecification = AliHLTTPCDefinitions::EncodeDataSpecification( minSlice, maxSlice, minPatch, maxPatch );
	      // The type of the data is copied from the input block.
	      ob.fDataType = AliHLTTPCDefinitions::fgkClusterTracksCompressedDataType;
	      // Place this block into the list of output blocks
	      outputBlocks.push_back( ob );
	      writePtr += blockSize;
	      outputSize += blockSize;
	      
	      blockSize = size-outputSize;
	      ret = fModelDeflater.CompressRemainingClusters( remainingClustersModelData, clusterSize, writePtr, blockSize );
	      totalCompressedModelData += blockSize;
	      if ( !ret && totalCompressedModelData<totalNonModelDataSize )
		{
		  // Let the structure be filled with the default values.
		  // This takes care of setting the shared memory and data type values to default values,
		  // so that they can be filled in by the calling code.
		  FillBlockData( ob );
		  // This block's start (offset) is after all other blocks written so far
		  ob.fOffset = outputSize;
		  // the size of this block's data.
		  ob.fSize = blockSize;
		  // The specification of the data is copied from the input block.
		  ob.fSpecification = AliHLTTPCDefinitions::EncodeDataSpecification( minSlice, maxSlice, minPatch, maxPatch );
		  // The type of the data is copied from the input block.
		  ob.fDataType = AliHLTTPCDefinitions::fgkRemainingClustersCompressedDataType;
		  // Place this block into the list of output blocks
		  outputBlocks.push_back( ob );
		  writePtr += blockSize;
		  outputSize += blockSize;
		}
	      else if ( fForwardIfUncompressed )
		{
		  outputSize -= (outputBlocks.end()-1)->fSize;
		  outputBlocks.erase( outputBlocks.end()-1 );
		  forwardUncompressed = true;
		}
	      
	      
	    }
	  else if ( fForwardIfUncompressed )
	    forwardUncompressed = true;
	  
	  delete [] trackModelData;
	  delete [] remainingClustersModelData;
	  
	  if ( forwardUncompressed )
	    {
	      for ( unsigned long n = 0; n < evtData.fBlockCnt; n++ )
		{
		  if ( blocks[n].fDataType == AliHLTTPCDefinitions::fgkClustersDataType ||
		       blocks[n].fDataType == AliHLTTPCDefinitions::fgkTracksDataType )
		    {
		      outputBlocks.push_back( blocks[n] );
		    }
		  
		}
	    }
	}
      
      // Finally we set the total size of output memory we consumed.
      size = outputSize;
      return 0;
    }
Commit	Line	Data
7e914051	1	// $Id$
ff2f0f94	2
892210c7	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: Timm Steinbeck <timm@kip.uni-heidelberg.de> *
	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	//**************************************************************************
ff2f0f94	18
	19	/** @file AliHLTTPCCompModelDeflaterComponent.cxx
	20	@author Timm Steinbeck
	21	@date
	22	@brief A copy processing component for the HLT. */
	23
	24	#if __GNUC__ >= 3
	25	using namespace std;
	26	#endif
	27
	28	#include "AliHLTTPCCompModelDeflaterComponent.h"
	29	#include "AliHLTTPCDefinitions.h"
	30	#include <stdlib.h>
	31	#include <errno.h>
	32
672f8b8c	33	/** ROOT macro for the implementation of ROOT specific class methods */
ff2f0f94	34	ClassImp(AliHLTTPCCompModelDeflaterComponent);
	35
	36	AliHLTTPCCompModelDeflaterComponent::AliHLTTPCCompModelDeflaterComponent():
892210c7	37	fModelDeflater(),
f0d05e66	38	fConverter(),
f0d05e66	39	fForwardIfUncompressed(true)
ff2f0f94	40	{
	41	// see header file for class documentation
	42	}
	43
	44	AliHLTTPCCompModelDeflaterComponent::~AliHLTTPCCompModelDeflaterComponent()
	45	{
	46	// see header file for class documentation
	47	}
	48
	49	const char* AliHLTTPCCompModelDeflaterComponent::GetComponentID()
	50	{
	51	// see header file for class documentation
	52	return "TPCCompModelDeflater"; // The ID of this component
	53	}
	54
	55	void AliHLTTPCCompModelDeflaterComponent::GetInputDataTypes( vector<AliHLTComponent_DataType>& list)
	56	{
	57	// see header file for class documentation
	58	list.clear(); // We do not have any requirements for our input data type(s).
	59	list.push_back( AliHLTTPCDefinitions::fgkClusterTracksModelDataType );
	60	list.push_back( AliHLTTPCDefinitions::fgkRemainingClustersModelDataType );
	61	}
	62
	63	AliHLTComponent_DataType AliHLTTPCCompModelDeflaterComponent::GetOutputDataType()
	64	{
	65	// see header file for class documentation
	66	return AliHLTTPCDefinitions::fgkClusterTracksCompressedDataType;
	67	}
	68
	69	void AliHLTTPCCompModelDeflaterComponent::GetOutputDataSize( unsigned long& constBase, double& inputMultiplier )
	70	{
	71	// see header file for class documentation
	72	constBase = 1+1+216; // Format versions + cluster count per patch
	73	inputMultiplier = 4.;
	74	//#warning Adapt input Multiplier to something more realistic
	75	}
	76
	77	// Spawn function, return new instance of this class
	78	AliHLTComponent* AliHLTTPCCompModelDeflaterComponent::Spawn()
	79	{
	80	// see header file for class documentation
	81	return new AliHLTTPCCompModelDeflaterComponent;
	82	};
	83
	84	int AliHLTTPCCompModelDeflaterComponent::DoInit( int argc, const char** argv )
	85	{
	86	// see header file for class documentation
	87	//char* cpErr;
	88	if ( argc )
	89	{
	90	Logging( kHLTLogDebug, "HLT::TPCCompModelDeflater::DoInit", "Arguments", "argv[0] == %s", argv[0] );
	91	Logging(kHLTLogError, "HLT::TPCCompModelDeflater::DoInit", "Unknown Option", "Unknown option '%s'", argv[0] );
	92	return EINVAL;
	93	}
	94	return 0;
	95	}
	96
	97	int AliHLTTPCCompModelDeflaterComponent::DoDeinit()
	98	{
	99	// see header file for class documentation
	100	return 0;
	101	}
	102
	103	int AliHLTTPCCompModelDeflaterComponent::DoEvent( const AliHLTComponent_EventData& evtData, const AliHLTComponent_BlockData* blocks,
104	AliHLTComponent_TriggerData& /trigData/, AliHLTUInt8_t* outputPtr,
105	AliHLTUInt32_t& size, vector<AliHLTComponent_BlockData>& outputBlocks )
106	{
107	// see header file for class documentation
108	// Process an event
109	// Loop over all input blocks in the event
110	AliHLTUInt8_t* writePtr = outputPtr;
111	AliHLTUInt32_t outputSize = 0, blockSize;
112	int ret;
113	AliHLTComponent_BlockData ob;
114	AliHLTUInt8_t minSlice=0xFF, maxSlice=0xFF, minPatch=0xFF, maxPatch=0xFF;
115	fConverter.Init();
116	unsigned long long totalNonModelDataSize=0;
117
118	for ( unsigned long n = 0; n < evtData.fBlockCnt; n++ )
119	{
120	if ( blocks[n].fDataType == AliHLTTPCDefinitions::fgkClusterTracksModelDataType )
121	{
122	blockSize = size-outputSize;
123	ret = fModelDeflater.CompressTracks( (AliHLTUInt8_t*)blocks[n].fPtr, blocks[n].fSize, writePtr, blockSize );
124	if ( !ret && blockSize<blocks[n].fSize )
125	{
126	// Let the structure be filled with the default values.
127	// This takes care of setting the shared memory and data type values to default values,
128	// so that they can be filled in by the calling code.
129	FillBlockData( ob );
130	// This block's start (offset) is after all other blocks written so far
131	ob.fOffset = outputSize;
132	// the size of this block's data.
133	ob.fSize = blockSize;
134	// The specification of the data is copied from the input block.
135	ob.fSpecification = blocks[n].fSpecification;
136	// The type of the data is copied from the input block.
137	ob.fDataType = AliHLTTPCDefinitions::fgkClusterTracksCompressedDataType;
138	// Place this block into the list of output blocks
139	outputBlocks.push_back( ob );
140	writePtr += blockSize;
141	outputSize += blockSize;
142	}
143	else if ( fForwardIfUncompressed )
144	{
145	outputBlocks.push_back( blocks[n] );
146	}
147	continue;
148	}
149	if ( blocks[n].fDataType == AliHLTTPCDefinitions::fgkRemainingClustersModelDataType )
150	{
151	blockSize = size-outputSize;
152	ret = fModelDeflater.CompressRemainingClusters( (AliHLTUInt8_t*)blocks[n].fPtr, blocks[n].fSize, writePtr, blockSize );
153	HLTDebug( "ret: %d - blockSize: %u - blocks[%u].fSize: %u", ret, (unsigned)blockSize, (unsigned)n, (unsigned)blocks[n].fSize );
154	if ( !ret && blockSize<blocks[n].fSize )
155	{
156	// Let the structure be filled with the default values.
157	// This takes care of setting the shared memory and data type values to default values,
158	// so that they can be filled in by the calling code.
159	FillBlockData( ob );
160	// This block's start (offset) is after all other blocks written so far
161	ob.fOffset = outputSize;
162	// the size of this block's data.
163	ob.fSize = blockSize;
164	// The specification of the data is copied from the input block.
165	ob.fSpecification = blocks[n].fSpecification;
166	// The type of the data is copied from the input block.
167	ob.fDataType = AliHLTTPCDefinitions::fgkRemainingClustersCompressedDataType;
168	// Place this block into the list of output blocks
169	outputBlocks.push_back( ob );
170	writePtr += blockSize;
171	outputSize += blockSize;
172	}
173	else if ( fForwardIfUncompressed )
174	{
175	outputBlocks.push_back( blocks[n] );
176	}
177	continue;
178	}
5eefc803	179	AliHLTUInt8_t slice = 0;
5eefc803	180	AliHLTUInt8_t patch = 0;
ff2f0f94	181	if ( blocks[n].fDataType == AliHLTTPCDefinitions::fgkClustersDataType \|\|
	182	blocks[n].fDataType == AliHLTTPCDefinitions::fgkTracksDataType )
	183	{
	184	slice = AliHLTTPCDefinitions::GetMinSliceNr( blocks[n].fSpecification );
	185	patch = AliHLTTPCDefinitions::GetMinPatchNr( blocks[n].fSpecification );
	186	if ( minSlice==0xFF \|\| slice<minSlice )
	187	minSlice = slice;
	188	if ( maxSlice==0xFF \|\| slice>maxSlice )
	189	maxSlice = slice;
	190	if ( minPatch==0xFF \|\| patch<minPatch )
	191	minPatch = patch;
	192	if ( maxPatch==0xFF \|\| patch>maxPatch )
	193	maxPatch = patch;
	194	totalNonModelDataSize += blocks[n].fSize;
	195	}
	196	if ( blocks[n].fDataType == AliHLTTPCDefinitions::fgkClustersDataType )
	197	{
	198	fConverter.SetInputClusters( (AliHLTTPCClusterData*)blocks[n].fPtr, slice, patch );
	199	}
0708bc90	200	if ( blocks[n].fDataType == (kAliHLTDataTypeTrack\|kAliHLTDataOriginTPC) )
ff2f0f94	201	{
0708bc90	202	fConverter.SetInputTracks( (AliHLTTracksData*)blocks[n].fPtr, blocks[n].fSize );
ff2f0f94	203	}
	204
	205	}
	206
	207	if ( totalNonModelDataSize>0 )
	208	{
	209	fConverter.Convert();
	210
	211	unsigned long trackSize = fConverter.GetOutputModelDataSize();
	212	AliHLTUInt8_t* trackModelData = new AliHLTUInt8_t[ trackSize ];
	213	if ( !trackModelData )
	214	{
	215	HLTError( "Out of memory trying to allocate %lu bytes of trackmodeldata", trackSize );
	216	return ENOMEM;
	217	}
	218
0708bc90	219	fConverter.OutputModelData( trackModelData, trackSize );
ff2f0f94	220
	221	unsigned long clusterSize = fConverter.GetRemainingClustersOutputDataSize();
	222	AliHLTUInt8_t* remainingClustersModelData = new AliHLTUInt8_t[ clusterSize ];
	223	if ( !remainingClustersModelData )
	224	{
	225	HLTError( "Out of memory trying to allocate %lu bytes of remaining cluster model data", clusterSize );
	226	delete [] trackModelData;
	227	return ENOMEM;
	228	}
	229
	230	fConverter.GetRemainingClusters( remainingClustersModelData, clusterSize );
	231
	232	bool forwardUncompressed = false;
	233
	234	blockSize = size-outputSize;
	235	ret = fModelDeflater.CompressTracks( trackModelData, trackSize, writePtr, blockSize );
	236	unsigned long long totalCompressedModelData = blockSize;
	237	if ( !ret )
	238	{
	239	// Let the structure be filled with the default values.
	240	// This takes care of setting the shared memory and data type values to default values,
	241	// so that they can be filled in by the calling code.
	242	FillBlockData( ob );
	243	// This block's start (offset) is after all other blocks written so far
	244	ob.fOffset = outputSize;
	245	// the size of this block's data.
	246	ob.fSize = blockSize;
	247	// The specification of the data is copied from the input block.
	248	ob.fSpecification = AliHLTTPCDefinitions::EncodeDataSpecification( minSlice, maxSlice, minPatch, maxPatch );
	249	// The type of the data is copied from the input block.
	250	ob.fDataType = AliHLTTPCDefinitions::fgkClusterTracksCompressedDataType;
	251	// Place this block into the list of output blocks
	252	outputBlocks.push_back( ob );
	253	writePtr += blockSize;
	254	outputSize += blockSize;
	255
	256	blockSize = size-outputSize;
	257	ret = fModelDeflater.CompressRemainingClusters( remainingClustersModelData, clusterSize, writePtr, blockSize );
	258	totalCompressedModelData += blockSize;
	259	if ( !ret && totalCompressedModelData<totalNonModelDataSize )
	260	{
	261	// Let the structure be filled with the default values.
	262	// This takes care of setting the shared memory and data type values to default values,
	263	// so that they can be filled in by the calling code.
	264	FillBlockData( ob );
	265	// This block's start (offset) is after all other blocks written so far
	266	ob.fOffset = outputSize;
	267	// the size of this block's data.
	268	ob.fSize = blockSize;
	269	// The specification of the data is copied from the input block.
	270	ob.fSpecification = AliHLTTPCDefinitions::EncodeDataSpecification( minSlice, maxSlice, minPatch, maxPatch );
	271	// The type of the data is copied from the input block.
	272	ob.fDataType = AliHLTTPCDefinitions::fgkRemainingClustersCompressedDataType;
	273	// Place this block into the list of output blocks
	274	outputBlocks.push_back( ob );
	275	writePtr += blockSize;
	276	outputSize += blockSize;
	277	}
	278	else if ( fForwardIfUncompressed )
	279	{
	280	outputSize -= (outputBlocks.end()-1)->fSize;
	281	outputBlocks.erase( outputBlocks.end()-1 );
	282	forwardUncompressed = true;
	283	}
284
285
286	}
287	else if ( fForwardIfUncompressed )
288	forwardUncompressed = true;
289
290	delete [] trackModelData;
291	delete [] remainingClustersModelData;
292
293	if ( forwardUncompressed )
294	{
295	for ( unsigned long n = 0; n < evtData.fBlockCnt; n++ )
296	{
297	if ( blocks[n].fDataType == AliHLTTPCDefinitions::fgkClustersDataType \|\|
298	blocks[n].fDataType == AliHLTTPCDefinitions::fgkTracksDataType )
299	{
300	outputBlocks.push_back( blocks[n] );
301	}
302
303	}
304	}
305	}
306
307	// Finally we set the total size of output memory we consumed.
308	size = outputSize;
309	return 0;
310	}