[u/mrichter/AliRoot.git] / HLT / TPCLib / AliHLTTPCAgent.cxx

// @(#) $Id$

/**************************************************************************
 * This file is property of and copyright by the ALICE HLT Project        * 
 * ALICE Experiment at CERN, All rights reserved.                         *
 *                                                                        *
 * Primary Authors: Matthias Richter <Matthias.Richter@ift.uib.no>        *
 *                  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   AliHLTTPCAgent.cxx
    @author Matthias Richter
    @date   
    @brief  Agent of the libAliHLTTPC library
*/

#include "AliHLTTPCAgent.h"
#include "AliHLTConfiguration.h"
#include "AliHLTTPCDefinitions.h"
#include "AliHLTOUT.h"

/** global instance for agent registration */
AliHLTTPCAgent gAliHLTTPCAgent;

// component headers
#include "AliHLTTPCRunStatisticsProducerComponent.h"
#include "AliHLTTPCEventStatisticsProducerComponent.h"
#include "AliHLTTPCCompModelInflaterComponent.h"
#include "AliHLTTPCCompModelDeflaterComponent.h"
#include "AliHLTTPCCompModelDeconverterComponent.h"
#include "AliHLTTPCCompModelConverterComponent.h"
#include "AliHLTTPCCompDumpComponent.h"
#include "AliHLTTPCCalibCEComponent.h"
#include "AliHLTTPCCalibPulserComponent.h"
#include "AliHLTTPCCalibPedestalComponent.h"
#include "AliHLTTPCCATrackerComponent.h"
#include "AliHLTTPCGlobalMergerComponent.h"
#include "AliHLTTPCSliceTrackerComponent.h"
#include "AliHLTTPCVertexFinderComponent.h"
#include "AliHLTTPCClusterFinderComponent.h"
#include "AliHLTTPCRawDataUnpackerComponent.h"
#include "AliHLTTPCDigitPublisherComponent.h"
#include "AliHLTTPCZeroSuppressionComponent.h"
#include "AliHLTTPCDigitDumpComponent.h"
#include "AliHLTTPCEsdWriterComponent.h"

/** ROOT macro for the implementation of ROOT specific class methods */
ClassImp(AliHLTTPCAgent)

AliHLTTPCAgent::AliHLTTPCAgent()
  :
  AliHLTModuleAgent("TPC"),
  fRawDataHandler(NULL),
  fNofRawDataHandler(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
}

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

int AliHLTTPCAgent::CreateConfigurations(AliHLTConfigurationHandler* handler,
					 AliRawReader* /*rawReader*/,
					 AliRunLoader* /*runloader*/) const
{
  // see header file for class documentation
  if (handler) {

    // This the tracking configuration for the full TPC
    // - 216 clusterfinders (1 per partition)
    // - 36 slice trackers
    // - one global merger
    // - the esd converter
    // The ESD is shipped embedded into a TTree
    int iMinSlice=0; 
    int iMaxSlice=35;
    int iMinPart=0;
    int iMaxPart=5;
    TString mergerInput;
    for (int slice=iMinSlice; slice<=iMaxSlice; slice++) {
      TString trackerInput;
      for (int part=iMinPart; part<=iMaxPart; part++) {
	TString arg, publisher, cf;

	// digit publisher components
	arg.Form("-slice %d -partition %d", slice, part);
	publisher.Form("TPC-DP_%02d_%d", slice, part);
	handler->CreateConfiguration(publisher.Data(), "TPCDigitPublisher", NULL , arg.Data());

	// cluster finder components
	cf.Form("TPC-CF_%02d_%d", slice, part);
	handler->CreateConfiguration(cf.Data(), "TPCClusterFinderUnpacked", publisher.Data(), "pp-run timebins 446");
	if (trackerInput.Length()>0) trackerInput+=" ";
	trackerInput+=cf;
      }
      TString tracker;
      // tracker finder components
      tracker.Form("TPC-TR_%02d", slice);
      handler->CreateConfiguration(tracker.Data(), "TPCSliceTracker", trackerInput.Data(), "-pp-run -bfield 0.5");

      if (mergerInput.Length()>0) mergerInput+=" ";
      mergerInput+=tracker;

    }

    // GlobalMerger component
    handler->CreateConfiguration("TPC-globalmerger","TPCGlobalMerger",mergerInput.Data(),"");

    // the esd converter configuration
    handler->CreateConfiguration("TPC-esd-converter", "TPCEsdConverter"   , "TPC-globalmerger", "-tree");
  }
  return 0;
}

const char* AliHLTTPCAgent::GetReconstructionChains(AliRawReader* /*rawReader*/,
						    AliRunLoader* runloader) const
{
  // see header file for class documentation
  if (runloader) {
    // reconstruction chains for AliRoot simulation
    // Note: run loader is only available while running embedded into
    // AliRoot simulation
    return "TPC-esd-converter";
  }
  return NULL;
}

const char* AliHLTTPCAgent::GetRequiredComponentLibraries() const
{
  // see header file for class documentation

  // actually, the TPC library has dependencies to Util and RCU
  // so the two has to be loaded anyhow before we get here
  //return "libAliHLTUtil.so libAliHLTRCU.so";
  return NULL;
}

int AliHLTTPCAgent::RegisterComponents(AliHLTComponentHandler* pHandler) const
{
  // see header file for class documentation
  if (!pHandler) return -EINVAL;

  pHandler->AddComponent(new AliHLTTPCRunStatisticsProducerComponent);
  pHandler->AddComponent(new AliHLTTPCEventStatisticsProducerComponent);
  pHandler->AddComponent(new AliHLTTPCCalibCEComponent);
  pHandler->AddComponent(new AliHLTTPCCalibPulserComponent);
  pHandler->AddComponent(new AliHLTTPCCalibPedestalComponent);
  pHandler->AddComponent(new AliHLTTPCCompModelInflaterComponent);
  pHandler->AddComponent(new AliHLTTPCCompModelDeflaterComponent);
  pHandler->AddComponent(new AliHLTTPCCompModelDeconverterComponent);
  pHandler->AddComponent(new AliHLTTPCCompModelConverterComponent);
  pHandler->AddComponent(new AliHLTTPCCompDumpComponent);
  pHandler->AddComponent(new AliHLTTPCCATrackerComponent);
  pHandler->AddComponent(new AliHLTTPCGlobalMergerComponent);
  pHandler->AddComponent(new AliHLTTPCSliceTrackerComponent);
  pHandler->AddComponent(new AliHLTTPCVertexFinderComponent);
  pHandler->AddComponent(new AliHLTTPCClusterFinderComponent(AliHLTTPCClusterFinderComponent::kClusterFinderPacked));
  pHandler->AddComponent(new AliHLTTPCClusterFinderComponent(AliHLTTPCClusterFinderComponent::kClusterFinderUnpacked));
  pHandler->AddComponent(new AliHLTTPCClusterFinderComponent(AliHLTTPCClusterFinderComponent::kClusterFinderDecoder));
  pHandler->AddComponent(new AliHLTTPCRawDataUnpackerComponent);
  pHandler->AddComponent(new AliHLTTPCDigitPublisherComponent);
  pHandler->AddComponent(new AliHLTTPCZeroSuppressionComponent);
  pHandler->AddComponent(new AliHLTTPCDigitDumpComponent);
  pHandler->AddComponent(new AliHLTTPCEsdWriterComponent::AliWriter);
  pHandler->AddComponent(new AliHLTTPCEsdWriterComponent::AliConverter);

  return 0;
}

int AliHLTTPCAgent::GetHandlerDescription(AliHLTComponentDataType dt,
					  AliHLTUInt32_t spec,
					  AliHLTOUTHandlerDesc& desc) const
{
  // see header file for class documentation
  if (dt==(kAliHLTDataTypeDDLRaw|kAliHLTDataOriginTPC)) {
    int slice=AliHLTTPCDefinitions::GetMinSliceNr(spec);
    int part=AliHLTTPCDefinitions::GetMinPatchNr(spec);
    if (slice==AliHLTTPCDefinitions::GetMaxSliceNr(spec) &&
	part==AliHLTTPCDefinitions::GetMaxPatchNr(spec)) {
      desc=AliHLTOUTHandlerDesc(kRawReader, dt, GetModuleId());
      return 1;
    } else {
      HLTWarning("handler can not process merged data from multiple ddls:"
		 " min slice %d, max slice %d, min part %d, max part %d",
		 slice, AliHLTTPCDefinitions::GetMaxSliceNr(spec),
		 part, AliHLTTPCDefinitions::GetMaxPatchNr(spec));
      return 0;
    }
  }
  return 0;
}

AliHLTOUTHandler* AliHLTTPCAgent::GetOutputHandler(AliHLTComponentDataType dt,
						   AliHLTUInt32_t /*spec*/)
{
  // see header file for class documentation
  if (dt==(kAliHLTDataTypeDDLRaw|kAliHLTDataOriginTPC)) {
    if (!fRawDataHandler) {
      fRawDataHandler=new AliHLTTPCAgent::AliHLTTPCRawDataHandler;
    }
    fNofRawDataHandler++;
    return fRawDataHandler;
  }
  return NULL;
}

int AliHLTTPCAgent::DeleteOutputHandler(AliHLTOUTHandler* pInstance)
{
  // see header file for class documentation
  if (pInstance==NULL) return -EINVAL;

  if (pInstance==fRawDataHandler) {
    if (--fNofRawDataHandler<=0) {
      delete fRawDataHandler;
      fRawDataHandler=NULL;
    }
  }
  return 0;
}

AliHLTTPCAgent::AliHLTTPCRawDataHandler::AliHLTTPCRawDataHandler()
{
  // see header file for class documentation
}

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

int AliHLTTPCAgent::AliHLTTPCRawDataHandler::ProcessData(AliHLTOUT* pData)
{
  // see header file for class documentation
  if (!pData) return -EINVAL;
  AliHLTComponentDataType dt=kAliHLTVoidDataType;
  AliHLTUInt32_t spec=kAliHLTVoidDataSpec;
  int iResult=pData->GetDataBlockDescription(dt, spec);
  if (iResult>=0) {
    int slice=AliHLTTPCDefinitions::GetMinSliceNr(spec);
    int part=AliHLTTPCDefinitions::GetMinPatchNr(spec);
    if (slice==AliHLTTPCDefinitions::GetMaxSliceNr(spec) &&
	part==AliHLTTPCDefinitions::GetMaxPatchNr(spec)) {
      iResult=768;
      if (part>1) iResult+=72+4*slice+(part-2);
      else iResult+=2*slice+part;
    } else {
      HLTError("handler can not process merged data from multiple ddls:"
	       " min slice %d, max slice %d, min part %d, max part %d",
	       slice, AliHLTTPCDefinitions::GetMaxSliceNr(spec),
	       part, AliHLTTPCDefinitions::GetMaxPatchNr(spec));
      iResult=-EBADMSG;
    }
  }
  return iResult;
}
Commit	Line	Data
5578cf60	1	// @(#) $Id$
	2
	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: Matthias Richter <Matthias.Richter@ift.uib.no> *
	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	**************************************************************************/
	18
	19	/** @file AliHLTTPCAgent.cxx
	20	@author Matthias Richter
	21	@date
	22	@brief Agent of the libAliHLTTPC library
	23	*/
	24
	25	#include "AliHLTTPCAgent.h"
	26	#include "AliHLTConfiguration.h"
626bfcc1	27	#include "AliHLTTPCDefinitions.h"
626bfcc1	28	#include "AliHLTOUT.h"
5578cf60	29
	30	/** global instance for agent registration */
	31	AliHLTTPCAgent gAliHLTTPCAgent;
	32
e1440dab	33	// component headers
672f8b8c	34	#include "AliHLTTPCRunStatisticsProducerComponent.h"
	35	#include "AliHLTTPCEventStatisticsProducerComponent.h"
	36	#include "AliHLTTPCCompModelInflaterComponent.h"
	37	#include "AliHLTTPCCompModelDeflaterComponent.h"
	38	#include "AliHLTTPCCompModelDeconverterComponent.h"
	39	#include "AliHLTTPCCompModelConverterComponent.h"
	40	#include "AliHLTTPCCompDumpComponent.h"
	41	#include "AliHLTTPCCalibCEComponent.h"
	42	#include "AliHLTTPCCalibPulserComponent.h"
	43	#include "AliHLTTPCCalibPedestalComponent.h"
	44	#include "AliHLTTPCCATrackerComponent.h"
	45	#include "AliHLTTPCGlobalMergerComponent.h"
	46	#include "AliHLTTPCSliceTrackerComponent.h"
	47	#include "AliHLTTPCVertexFinderComponent.h"
	48	#include "AliHLTTPCClusterFinderComponent.h"
	49	#include "AliHLTTPCRawDataUnpackerComponent.h"
	50	#include "AliHLTTPCDigitPublisherComponent.h"
	51	#include "AliHLTTPCZeroSuppressionComponent.h"
e1440dab	52	#include "AliHLTTPCDigitDumpComponent.h"
f32b83e1	53	#include "AliHLTTPCEsdWriterComponent.h"
e1440dab	54
5578cf60	55	/** ROOT macro for the implementation of ROOT specific class methods */
	56	ClassImp(AliHLTTPCAgent)
	57
	58	AliHLTTPCAgent::AliHLTTPCAgent()
626bfcc1	59	:
	60	AliHLTModuleAgent("TPC"),
	61	fRawDataHandler(NULL),
	62	fNofRawDataHandler(0)
5578cf60	63	{
	64	// see header file for class documentation
	65	// or
	66	// refer to README to build package
	67	// or
	68	// visit http://web.ift.uib.no/~kjeks/doc/alice-hlt
	69	}
	70
	71	AliHLTTPCAgent::~AliHLTTPCAgent()
	72	{
	73	// see header file for class documentation
	74	}
	75
	76	int AliHLTTPCAgent::CreateConfigurations(AliHLTConfigurationHandler* handler,
dee38f1b	77	AliRawReader* /rawReader/,
298ef463	78	AliRunLoader* /runloader/) const
5578cf60	79	{
	80	// see header file for class documentation
	81	if (handler) {
672f8b8c	82
	83	// This the tracking configuration for the full TPC
	84	// - 216 clusterfinders (1 per partition)
	85	// - 36 slice trackers
	86	// - one global merger
	87	// - the esd converter
	88	// The ESD is shipped embedded into a TTree
dfa1592e	89	int iMinSlice=0;
672f8b8c	90	int iMaxSlice=35;
dfa1592e	91	int iMinPart=0;
672f8b8c	92	int iMaxPart=5;
672f8b8c	93	TString mergerInput;
dfa1592e	94	for (int slice=iMinSlice; slice<=iMaxSlice; slice++) {
	95	TString trackerInput;
	96	for (int part=iMinPart; part<=iMaxPart; part++) {
	97	TString arg, publisher, cf;
	98
	99	// digit publisher components
	100	arg.Form("-slice %d -partition %d", slice, part);
0ba35c53	101	publisher.Form("TPC-DP_%02d_%d", slice, part);
dfa1592e	102	handler->CreateConfiguration(publisher.Data(), "TPCDigitPublisher", NULL , arg.Data());
	103
	104	// cluster finder components
0ba35c53	105	cf.Form("TPC-CF_%02d_%d", slice, part);
dfa1592e	106	handler->CreateConfiguration(cf.Data(), "TPCClusterFinderUnpacked", publisher.Data(), "pp-run timebins 446");
	107	if (trackerInput.Length()>0) trackerInput+=" ";
	108	trackerInput+=cf;
	109	}
	110	TString tracker;
	111	// tracker finder components
0ba35c53	112	tracker.Form("TPC-TR_%02d", slice);
672f8b8c	113	handler->CreateConfiguration(tracker.Data(), "TPCSliceTracker", trackerInput.Data(), "-pp-run -bfield 0.5");
dfa1592e	114
672f8b8c	115	if (mergerInput.Length()>0) mergerInput+=" ";
672f8b8c	116	mergerInput+=tracker;
dfa1592e	117
dfa1592e	118	}
5578cf60	119
672f8b8c	120	// GlobalMerger component
0ba35c53	121	handler->CreateConfiguration("TPC-globalmerger","TPCGlobalMerger",mergerInput.Data(),"");
672f8b8c	122
672f8b8c	123	// the esd converter configuration
0ba35c53	124	handler->CreateConfiguration("TPC-esd-converter", "TPCEsdConverter" , "TPC-globalmerger", "-tree");
5578cf60	125	}
	126	return 0;
	127	}
	128
dee38f1b	129	const char* AliHLTTPCAgent::GetReconstructionChains(AliRawReader* /rawReader/,
ff6648de	130	AliRunLoader* runloader) const
5578cf60	131	{
5578cf60	132	// see header file for class documentation
ff6648de	133	if (runloader) {
	134	// reconstruction chains for AliRoot simulation
	135	// Note: run loader is only available while running embedded into
	136	// AliRoot simulation
	137	return "TPC-esd-converter";
	138	}
	139	return NULL;
5578cf60	140	}
	141
	142	const char* AliHLTTPCAgent::GetRequiredComponentLibraries() const
	143	{
	144	// see header file for class documentation
5ad1e184	145
	146	// actually, the TPC library has dependencies to Util and RCU
	147	// so the two has to be loaded anyhow before we get here
	148	//return "libAliHLTUtil.so libAliHLTRCU.so";
5578cf60	149	return NULL;
5578cf60	150	}
f3506ea2	151
e1440dab	152	int AliHLTTPCAgent::RegisterComponents(AliHLTComponentHandler* pHandler) const
f3506ea2	153	{
e1440dab	154	// see header file for class documentation
e1440dab	155	if (!pHandler) return -EINVAL;
672f8b8c	156
	157	pHandler->AddComponent(new AliHLTTPCRunStatisticsProducerComponent);
	158	pHandler->AddComponent(new AliHLTTPCEventStatisticsProducerComponent);
	159	pHandler->AddComponent(new AliHLTTPCCalibCEComponent);
	160	pHandler->AddComponent(new AliHLTTPCCalibPulserComponent);
	161	pHandler->AddComponent(new AliHLTTPCCalibPedestalComponent);
	162	pHandler->AddComponent(new AliHLTTPCCompModelInflaterComponent);
	163	pHandler->AddComponent(new AliHLTTPCCompModelDeflaterComponent);
	164	pHandler->AddComponent(new AliHLTTPCCompModelDeconverterComponent);
	165	pHandler->AddComponent(new AliHLTTPCCompModelConverterComponent);
	166	pHandler->AddComponent(new AliHLTTPCCompDumpComponent);
	167	pHandler->AddComponent(new AliHLTTPCCATrackerComponent);
	168	pHandler->AddComponent(new AliHLTTPCGlobalMergerComponent);
	169	pHandler->AddComponent(new AliHLTTPCSliceTrackerComponent);
	170	pHandler->AddComponent(new AliHLTTPCVertexFinderComponent);
	171	pHandler->AddComponent(new AliHLTTPCClusterFinderComponent(AliHLTTPCClusterFinderComponent::kClusterFinderPacked));
	172	pHandler->AddComponent(new AliHLTTPCClusterFinderComponent(AliHLTTPCClusterFinderComponent::kClusterFinderUnpacked));
	173	pHandler->AddComponent(new AliHLTTPCClusterFinderComponent(AliHLTTPCClusterFinderComponent::kClusterFinderDecoder));
	174	pHandler->AddComponent(new AliHLTTPCRawDataUnpackerComponent);
	175	pHandler->AddComponent(new AliHLTTPCDigitPublisherComponent);
	176	pHandler->AddComponent(new AliHLTTPCZeroSuppressionComponent);
e1440dab	177	pHandler->AddComponent(new AliHLTTPCDigitDumpComponent);
f32b83e1	178	pHandler->AddComponent(new AliHLTTPCEsdWriterComponent::AliWriter);
	179	pHandler->AddComponent(new AliHLTTPCEsdWriterComponent::AliConverter);
	180
f3506ea2	181	return 0;
f3506ea2	182	}
626bfcc1	183
	184	int AliHLTTPCAgent::GetHandlerDescription(AliHLTComponentDataType dt,
	185	AliHLTUInt32_t spec,
	186	AliHLTOUTHandlerDesc& desc) const
	187	{
	188	// see header file for class documentation
	189	if (dt==(kAliHLTDataTypeDDLRaw\|kAliHLTDataOriginTPC)) {
	190	int slice=AliHLTTPCDefinitions::GetMinSliceNr(spec);
	191	int part=AliHLTTPCDefinitions::GetMinPatchNr(spec);
	192	if (slice==AliHLTTPCDefinitions::GetMaxSliceNr(spec) &&
	193	part==AliHLTTPCDefinitions::GetMaxPatchNr(spec)) {
	194	desc=AliHLTOUTHandlerDesc(kRawReader, dt, GetModuleId());
	195	return 1;
	196	} else {
	197	HLTWarning("handler can not process merged data from multiple ddls:"
	198	" min slice %d, max slice %d, min part %d, max part %d",
	199	slice, AliHLTTPCDefinitions::GetMaxSliceNr(spec),
	200	part, AliHLTTPCDefinitions::GetMaxPatchNr(spec));
	201	return 0;
	202	}
	203	}
	204	return 0;
	205	}
	206
	207	AliHLTOUTHandler* AliHLTTPCAgent::GetOutputHandler(AliHLTComponentDataType dt,
b0914d2e	208	AliHLTUInt32_t /spec/)
626bfcc1	209	{
	210	// see header file for class documentation
	211	if (dt==(kAliHLTDataTypeDDLRaw\|kAliHLTDataOriginTPC)) {
	212	if (!fRawDataHandler) {
	213	fRawDataHandler=new AliHLTTPCAgent::AliHLTTPCRawDataHandler;
	214	}
	215	fNofRawDataHandler++;
	216	return fRawDataHandler;
	217	}
	218	return NULL;
	219	}
	220
	221	int AliHLTTPCAgent::DeleteOutputHandler(AliHLTOUTHandler* pInstance)
	222	{
	223	// see header file for class documentation
	224	if (pInstance==NULL) return -EINVAL;
	225
	226	if (pInstance==fRawDataHandler) {
	227	if (--fNofRawDataHandler<=0) {
	228	delete fRawDataHandler;
	229	fRawDataHandler=NULL;
	230	}
	231	}
	232	return 0;
	233	}
	234
	235	AliHLTTPCAgent::AliHLTTPCRawDataHandler::AliHLTTPCRawDataHandler()
	236	{
	237	// see header file for class documentation
	238	}
	239
	240	AliHLTTPCAgent::AliHLTTPCRawDataHandler::~AliHLTTPCRawDataHandler()
	241	{
	242	// see header file for class documentation
	243	}
	244
	245	int AliHLTTPCAgent::AliHLTTPCRawDataHandler::ProcessData(AliHLTOUT* pData)
	246	{
	247	// see header file for class documentation
	248	if (!pData) return -EINVAL;
	249	AliHLTComponentDataType dt=kAliHLTVoidDataType;
	250	AliHLTUInt32_t spec=kAliHLTVoidDataSpec;
	251	int iResult=pData->GetDataBlockDescription(dt, spec);
	252	if (iResult>=0) {
	253	int slice=AliHLTTPCDefinitions::GetMinSliceNr(spec);
	254	int part=AliHLTTPCDefinitions::GetMinPatchNr(spec);
	255	if (slice==AliHLTTPCDefinitions::GetMaxSliceNr(spec) &&
	256	part==AliHLTTPCDefinitions::GetMaxPatchNr(spec)) {
	257	iResult=768;
	258	if (part>1) iResult+=72+4*slice+(part-2);
	259	else iResult+=2*slice+part;
	260	} else {
	261	HLTError("handler can not process merged data from multiple ddls:"
	262	" min slice %d, max slice %d, min part %d, max part %d",
	263	slice, AliHLTTPCDefinitions::GetMaxSliceNr(spec),
	264	part, AliHLTTPCDefinitions::GetMaxPatchNr(spec));
	265	iResult=-EBADMSG;
	266	}
	267	}
	268	return iResult;
	269	}