[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>

// this is a global object used for automatic component registration, do not use this
AliHLTTPCCompModelDeflaterComponent gAliHLTTPCCompClusterModelDeflaterComponent;

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