[u/mrichter/AliRoot.git] / HLT / BASE / AliHLTDAQ.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   AliHLTDAQ.cxx
/// @author Matthias Richter
/// @date   24.10.2008
/// @brief  Virtual Interface to the AliDAQ class.
///

#include "AliHLTDAQ.h"
#include "AliHLTLogging.h"
#include "AliHLTDataTypes.h"
#include "AliHLTMisc.h"
#include "TClass.h"
#include "TSystem.h"

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

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

AliHLTDAQ* AliHLTDAQ::fgpInstance=NULL;
const char* AliHLTDAQ::fgkImplName="AliHLTDAQInterfaceImplementation";
const char* AliHLTDAQ::fgkImplLibrary="libHLTrec.so";
const char* AliHLTDAQ::fgkOriginMapping[] = {
  kAliHLTDataOriginITSSPD,  
  kAliHLTDataOriginITSSDD,
  kAliHLTDataOriginITSSSD,
  kAliHLTDataOriginTPC,
  kAliHLTDataOriginTRD,
  kAliHLTDataOriginTOF,
  kAliHLTDataOriginHMPID,
  kAliHLTDataOriginPHOS,
  kAliHLTDataOriginCPV,
  kAliHLTDataOriginPMD,
  kAliHLTDataOriginMUON,
  "", // MUONTRG
  kAliHLTDataOriginFMD,
  kAliHLTDataOriginT0,
  kAliHLTDataOriginVZERO,
  kAliHLTDataOriginZDC,
  kAliHLTDataOriginACORDE,
  kAliHLTDataOriginTRG,
  kAliHLTDataOriginEMCAL,
  NULL
};

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

Int_t       AliHLTDAQ::NumberOfDetectors()
{
  // see header file for class documentation
  if (!fgpInstance) GetInstance();
  if (fgpInstance) return fgpInstance->VirtNumberOfDetectors();
  return -1;
}

Int_t       AliHLTDAQ::DetectorID(const char *detectorName)
{
  // get the detector ID from the detector name
  // forwards to AliDAQ::DetectorName
  if (!fgpInstance) GetInstance();
  if (fgpInstance) return fgpInstance->VirtDetectorID(detectorName);
  return -1;
}

const char *AliHLTDAQ::DetectorName(Int_t detectorID)
{
  // get the detector name from the detector ID
  // forwards to AliDAQ::DetectorName
  if (!fgpInstance) GetInstance();
  if (fgpInstance) return fgpInstance->VirtDetectorName(detectorID);
  return NULL;
}

Int_t       AliHLTDAQ::DetectorIDFromHLTOrigin(const char dataorigin[kAliHLTComponentDataTypefOriginSize])
{
  // get the detector id from HLT origin
  for (int i=0; fgkOriginMapping[i]!=NULL; i++) {
    if (strncmp(fgkOriginMapping[i], dataorigin, kAliHLTComponentDataTypefOriginSize)==0) {
      return i;
    }
  }

  return -1;
}

const char *AliHLTDAQ::DetectorName(const char dataorigin[kAliHLTComponentDataTypefOriginSize])
{
  // get the detector name from HLT origin
  Int_t detectorID=DetectorIDFromHLTOrigin(dataorigin);
  if (detectorID<0) return NULL;

  return DetectorName(detectorID);
}

Int_t       AliHLTDAQ::DdlIDOffset(const char *detectorName)
{
  // get ID of the first DDL of a detector
  // forwards to AliDAQ::DdlIDOffset
  if (!fgpInstance) GetInstance();
  if (fgpInstance) return fgpInstance->VirtDdlIDOffset(detectorName);
  return -1;
}

Int_t       AliHLTDAQ::DdlIDOffset(Int_t detectorID)
{
  // get ID of the first DDL of a detector
  // forwards to AliDAQ::DdlIDOffset
  if (!fgpInstance) GetInstance();
  if (fgpInstance) return fgpInstance->VirtDdlIDOffset(detectorID);
  return -1;
}

const char *AliHLTDAQ::DetectorNameFromDdlID(Int_t ddlID, Int_t &ddlIndex)
{
  // get detector name from global DDL ID and index of DDL within the detector
  // forwards to AliDAQ::DetectorNameFromDdlID
  if (!fgpInstance) GetInstance();
  if (fgpInstance) return fgpInstance->VirtDetectorNameFromDdlID(ddlID, ddlIndex);
  return NULL;
}

Int_t       AliHLTDAQ::DetectorIDFromDdlID(Int_t ddlID, Int_t &ddlIndex)
{
  // get detector ID from global DDL ID and index of DDL within the detector
  // forwards to AliDAQ::DetectorNameFromDdlID
  if (!fgpInstance) GetInstance();
  if (fgpInstance) return fgpInstance->VirtDetectorIDFromDdlID(ddlID, ddlIndex);
  return -1;
}

Int_t       AliHLTDAQ::DdlID(const char *detectorName, Int_t ddlIndex)
{
  // get global DDL ID from detector name and index of DDL within the detector
  // forwards to AliDAQ::DdlID
  if (!fgpInstance) GetInstance();
  if (fgpInstance) return fgpInstance->VirtDdlID(detectorName, ddlIndex);
  return -1;
}

Int_t       AliHLTDAQ::DdlID(Int_t detectorID, Int_t ddlIndex)
{
  // get global DDL ID from detector ID and index of DDL within the detector
  // forwards to AliDAQ::DdlID
  if (!fgpInstance) GetInstance();
  if (fgpInstance) return fgpInstance->VirtDdlID(detectorID, ddlIndex);
  return -1;
}

const char *AliHLTDAQ::DdlFileName(const char *detectorName, Int_t ddlIndex)
{
  // see header file for class documentation
  if (!fgpInstance) GetInstance();
  if (fgpInstance) return fgpInstance->VirtDdlFileName(detectorName, ddlIndex);
  return NULL;
}

const char *AliHLTDAQ::DdlFileName(Int_t detectorID, Int_t ddlIndex)
{
  // see header file for class documentation
  if (!fgpInstance) GetInstance();
  if (fgpInstance) return fgpInstance->VirtDdlFileName(detectorID, ddlIndex);
  return NULL;
}

Int_t       AliHLTDAQ::NumberOfDdls(const char *detectorName)
{
  // see header file for class documentation
  if (!fgpInstance) GetInstance();
  if (fgpInstance) return fgpInstance->VirtNumberOfDdls(detectorName);
  return -1;
}

Int_t       AliHLTDAQ::NumberOfDdls(Int_t detectorID)
{
  // see header file for class documentation
  if (!fgpInstance) GetInstance();
  if (fgpInstance) return fgpInstance->VirtNumberOfDdls(detectorID);
  return -1;
}

const char *AliHLTDAQ::ListOfTriggeredDetectors(UInt_t detectorPattern)
{
  // see header file for class documentation
  if (!fgpInstance) GetInstance();
  if (fgpInstance) return fgpInstance->VirtListOfTriggeredDetectors(detectorPattern);
  return NULL;
}

UInt_t      AliHLTDAQ::DetectorPattern(const char *detectorList)
{
  // see header file for class documentation
  if (!fgpInstance) GetInstance();
  if (fgpInstance) return fgpInstance->VirtDetectorPattern(detectorList);
  return 0;
}

const char *AliHLTDAQ::OfflineModuleName(const char *detectorName)
{
  // see header file for class documentation
  if (!fgpInstance) GetInstance();
  if (fgpInstance) return fgpInstance->VirtOfflineModuleName(detectorName);
  return NULL;
}
const char *AliHLTDAQ::OfflineModuleName(Int_t detectorID)
{
  // see header file for class documentation
  if (!fgpInstance) GetInstance();
  if (fgpInstance) return fgpInstance->VirtOfflineModuleName(detectorID);
  return NULL;
}

const char *AliHLTDAQ::OnlineName(const char *detectorName)
{
  // see header file for class documentation
  if (!fgpInstance) GetInstance();
  if (fgpInstance) return fgpInstance->VirtOnlineName(detectorName);
  return NULL;
}
const char *AliHLTDAQ::OnlineName(Int_t detectorID)
{
  // see header file for class documentation
  if (!fgpInstance) GetInstance();
  if (fgpInstance) return fgpInstance->VirtOnlineName(detectorID);
  return NULL;
}

string AliHLTDAQ::HLTOrigin(const char *detectorName)
{
  // get HLT origin from detector name
  return HLTOrigin(DetectorID(detectorName));
}

string AliHLTDAQ::HLTOrigin(Int_t detectorID)
{
  // get HLT origin from detector ID
  string origin;
  if (detectorID>=0 && (unsigned)detectorID<sizeof(fgkOriginMapping)/sizeof(const char*)) {
    origin.append(fgkOriginMapping[detectorID], kAliHLTComponentDataTypefOriginSize);
  }
  return origin;
}

string AliHLTDAQ::HLTSpecificationFromDdlID(Int_t ddlID)
{
  // get the HLT data specification from equipment id
  string result = "";
  Int_t ddlIndex=0;
  Int_t detectorID = DetectorIDFromDdlID(ddlID, ddlIndex);
  if (detectorID < 0)
    return result;
  Int_t TPCID = DetectorID("TPC");
  const int strtmplength=11;
  char strtmp[strtmplength];
  memset(strtmp, 0, strtmplength);
  if (detectorID == TPCID) {
    int partition;
    int slice;
    if (ddlID < 840) {
      partition = ddlID % 2;
      slice = (ddlID - 768) / 2;
    } else {
      partition = (ddlID % 4) + 2;
      slice = (ddlID - 840) / 4;
    }
    snprintf(strtmp, strtmplength, "0x%02x%02x%02x%02x", slice, slice, partition, partition);
    result = strtmp;
  }
  else if (detectorID == DetectorID("TOF")) {
    AliHLTLogging log;
    log.Logging(kHLTLogWarning, "AliHLTDAQ::HLTSpecificationFromDdlID", "HLT Analysis", "Mapping of data specification not implemented for TOF");
  }
  else { // default
    snprintf(strtmp, strtmplength, "0x%08x", 0x1 << ddlIndex);
    result = strtmp;
  }
  return result;
}

Int_t AliHLTDAQ::DdlIDFromHLTBlockData(const char dataorigin[kAliHLTComponentDataTypefOriginSize], UInt_t specification)
{
  // get the DDL ID (global equipment ID) from HLT origin and data specification
  Int_t detectorID=DetectorIDFromHLTOrigin(dataorigin);
  if (detectorID<0) return -1;
  Int_t ddlID=DdlIDOffset(detectorID);
  if (ddlID<0) return -1;

  if (detectorID == DetectorID("TPC")) {
    int minPartition= specification     &0xff;
    int maxPartition=(specification>>8) &0xff;
    int minSlice    =(specification>>16)&0xff;
    int maxSlice    =(specification>>24)&0xff;
    if (minPartition<0 || minPartition>5 ||
	maxPartition<0 || maxPartition>5 ||
	minSlice<0 || minSlice>35 ||
	maxSlice<0 || maxSlice>35) {
      AliHLTLogging log;
      log.Logging(kHLTLogError, "AliHLTDAQ::DdlID", "HLT Analysis", "invalid data specification 0x%08x", specification);
      return -1;
    }
    else if (minPartition!=maxPartition || 
	     minSlice!=maxSlice) {
      AliHLTLogging log;
      log.Logging(kHLTLogError, "AliHLTDAQ::DdlID", "HLT Analysis", "ambiguous data specification 0x%08x", specification);
      return -1;
    }
    if (minPartition<2) ddlID+=2*minSlice+minPartition;        // inner sector
    else                ddlID+=4*minSlice+(minPartition-2)+72; // outer sector
  }
  else if (detectorID == DetectorID("TOF")) {
    AliHLTLogging log;
    log.Logging(kHLTLogWarning, "AliHLTDAQ::DdlID", "HLT Analysis", "Mapping of data specification not implemented for TOF");
    return -1;
  }
  else { // default
    for (int i=0; i<32; i++) {
      if ((specification&(0x1<<i))==0) continue; // if bit not set
      if ((specification&(0xffffffff^(0x1<<i)))!=0) { // check if other bits set
	AliHLTLogging log;
	log.Logging(kHLTLogError, "AliHLTDAQ::DdlID", "HLT Analysis", "ambiguous data specification 0x%08x", specification);
	return -1;
      }
      ddlID+=i;
      break;
    }
  }

  return ddlID;
}

AliHLTDAQ* AliHLTDAQ::GetInstance()
{
  // see header file for class documentation
  if (!fgpInstance) {
    fgpInstance=AliHLTMisc::LoadInstance((AliHLTDAQ*)NULL, fgkImplName, fgkImplLibrary);
    if (!fgpInstance) {
      AliHLTLogging log;
      log.Logging(kHLTLogError, "AliHLTDAQ::Instance", "HLT Analysis", "failed to load AliHLTDAQ implementation");
    }
  }
  return fgpInstance;
}
Commit	Line	Data
	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 AliHLTDAQ.cxx
	20	/// @author Matthias Richter
	21	/// @date 24.10.2008
	22	/// @brief Virtual Interface to the AliDAQ class.
	23	///
	24
	25	#include "AliHLTDAQ.h"
	26	#include "AliHLTLogging.h"
	27	#include "AliHLTDataTypes.h"
	28	#include "AliHLTMisc.h"
	29	#include "TClass.h"
	30	#include "TSystem.h"
	31
	32	/** ROOT macro for the implementation of ROOT specific class methods */
	33	ClassImp(AliHLTDAQ)
	34
	35	AliHLTDAQ::AliHLTDAQ()
	36	{
	37	// see header file for class documentation
	38	// or
	39	// refer to README to build package
	40	// or
	41	// visit http://web.ift.uib.no/~kjeks/doc/alice-hlt
	42	}
	43
	44	AliHLTDAQ* AliHLTDAQ::fgpInstance=NULL;
	45	const char* AliHLTDAQ::fgkImplName="AliHLTDAQInterfaceImplementation";
	46	const char* AliHLTDAQ::fgkImplLibrary="libHLTrec.so";
	47	const char* AliHLTDAQ::fgkOriginMapping[] = {
	48	kAliHLTDataOriginITSSPD,
	49	kAliHLTDataOriginITSSDD,
	50	kAliHLTDataOriginITSSSD,
	51	kAliHLTDataOriginTPC,
	52	kAliHLTDataOriginTRD,
	53	kAliHLTDataOriginTOF,
	54	kAliHLTDataOriginHMPID,
	55	kAliHLTDataOriginPHOS,
	56	kAliHLTDataOriginCPV,
	57	kAliHLTDataOriginPMD,
	58	kAliHLTDataOriginMUON,
	59	"", // MUONTRG
	60	kAliHLTDataOriginFMD,
	61	kAliHLTDataOriginT0,
	62	kAliHLTDataOriginVZERO,
	63	kAliHLTDataOriginZDC,
	64	kAliHLTDataOriginACORDE,
	65	kAliHLTDataOriginTRG,
	66	kAliHLTDataOriginEMCAL,
	67	NULL
	68	};
	69
	70	AliHLTDAQ::~AliHLTDAQ()
	71	{
	72	// see header file for class documentation
	73	}
	74
	75	Int_t AliHLTDAQ::NumberOfDetectors()
	76	{
	77	// see header file for class documentation
	78	if (!fgpInstance) GetInstance();
	79	if (fgpInstance) return fgpInstance->VirtNumberOfDetectors();
	80	return -1;
	81	}
	82
	83	Int_t AliHLTDAQ::DetectorID(const char *detectorName)
	84	{
	85	// get the detector ID from the detector name
	86	// forwards to AliDAQ::DetectorName
	87	if (!fgpInstance) GetInstance();
	88	if (fgpInstance) return fgpInstance->VirtDetectorID(detectorName);
	89	return -1;
	90	}
	91
	92	const char *AliHLTDAQ::DetectorName(Int_t detectorID)
	93	{
	94	// get the detector name from the detector ID
	95	// forwards to AliDAQ::DetectorName
	96	if (!fgpInstance) GetInstance();
	97	if (fgpInstance) return fgpInstance->VirtDetectorName(detectorID);
	98	return NULL;
	99	}
	100
	101	Int_t AliHLTDAQ::DetectorIDFromHLTOrigin(const char dataorigin[kAliHLTComponentDataTypefOriginSize])
	102	{
	103	// get the detector id from HLT origin
	104	for (int i=0; fgkOriginMapping[i]!=NULL; i++) {
	105	if (strncmp(fgkOriginMapping[i], dataorigin, kAliHLTComponentDataTypefOriginSize)==0) {
	106	return i;
	107	}
	108	}
	109
	110	return -1;
	111	}
	112
	113	const char *AliHLTDAQ::DetectorName(const char dataorigin[kAliHLTComponentDataTypefOriginSize])
	114	{
	115	// get the detector name from HLT origin
	116	Int_t detectorID=DetectorIDFromHLTOrigin(dataorigin);
	117	if (detectorID<0) return NULL;
	118
	119	return DetectorName(detectorID);
	120	}
	121
	122	Int_t AliHLTDAQ::DdlIDOffset(const char *detectorName)
	123	{
	124	// get ID of the first DDL of a detector
	125	// forwards to AliDAQ::DdlIDOffset
	126	if (!fgpInstance) GetInstance();
	127	if (fgpInstance) return fgpInstance->VirtDdlIDOffset(detectorName);
	128	return -1;
	129	}
	130
	131	Int_t AliHLTDAQ::DdlIDOffset(Int_t detectorID)
	132	{
	133	// get ID of the first DDL of a detector
	134	// forwards to AliDAQ::DdlIDOffset
	135	if (!fgpInstance) GetInstance();
	136	if (fgpInstance) return fgpInstance->VirtDdlIDOffset(detectorID);
	137	return -1;
	138	}
	139
	140	const char *AliHLTDAQ::DetectorNameFromDdlID(Int_t ddlID, Int_t &ddlIndex)
	141	{
	142	// get detector name from global DDL ID and index of DDL within the detector
	143	// forwards to AliDAQ::DetectorNameFromDdlID
	144	if (!fgpInstance) GetInstance();
	145	if (fgpInstance) return fgpInstance->VirtDetectorNameFromDdlID(ddlID, ddlIndex);
	146	return NULL;
	147	}
	148
	149	Int_t AliHLTDAQ::DetectorIDFromDdlID(Int_t ddlID, Int_t &ddlIndex)
	150	{
	151	// get detector ID from global DDL ID and index of DDL within the detector
	152	// forwards to AliDAQ::DetectorNameFromDdlID
	153	if (!fgpInstance) GetInstance();
	154	if (fgpInstance) return fgpInstance->VirtDetectorIDFromDdlID(ddlID, ddlIndex);
	155	return -1;
	156	}
	157
	158	Int_t AliHLTDAQ::DdlID(const char *detectorName, Int_t ddlIndex)
	159	{
	160	// get global DDL ID from detector name and index of DDL within the detector
	161	// forwards to AliDAQ::DdlID
	162	if (!fgpInstance) GetInstance();
	163	if (fgpInstance) return fgpInstance->VirtDdlID(detectorName, ddlIndex);
	164	return -1;
	165	}
	166
	167	Int_t AliHLTDAQ::DdlID(Int_t detectorID, Int_t ddlIndex)
	168	{
	169	// get global DDL ID from detector ID and index of DDL within the detector
	170	// forwards to AliDAQ::DdlID
	171	if (!fgpInstance) GetInstance();
	172	if (fgpInstance) return fgpInstance->VirtDdlID(detectorID, ddlIndex);
	173	return -1;
	174	}
	175
	176	const char AliHLTDAQ::DdlFileName(const char detectorName, Int_t ddlIndex)
	177	{
	178	// see header file for class documentation
	179	if (!fgpInstance) GetInstance();
	180	if (fgpInstance) return fgpInstance->VirtDdlFileName(detectorName, ddlIndex);
	181	return NULL;
	182	}
	183
	184	const char *AliHLTDAQ::DdlFileName(Int_t detectorID, Int_t ddlIndex)
	185	{
	186	// see header file for class documentation
	187	if (!fgpInstance) GetInstance();
	188	if (fgpInstance) return fgpInstance->VirtDdlFileName(detectorID, ddlIndex);
	189	return NULL;
	190	}
	191
	192	Int_t AliHLTDAQ::NumberOfDdls(const char *detectorName)
	193	{
	194	// see header file for class documentation
	195	if (!fgpInstance) GetInstance();
	196	if (fgpInstance) return fgpInstance->VirtNumberOfDdls(detectorName);
	197	return -1;
	198	}
	199
	200	Int_t AliHLTDAQ::NumberOfDdls(Int_t detectorID)
	201	{
	202	// see header file for class documentation
	203	if (!fgpInstance) GetInstance();
	204	if (fgpInstance) return fgpInstance->VirtNumberOfDdls(detectorID);
	205	return -1;
	206	}
	207
	208	const char *AliHLTDAQ::ListOfTriggeredDetectors(UInt_t detectorPattern)
	209	{
	210	// see header file for class documentation
	211	if (!fgpInstance) GetInstance();
	212	if (fgpInstance) return fgpInstance->VirtListOfTriggeredDetectors(detectorPattern);
	213	return NULL;
	214	}
	215
	216	UInt_t AliHLTDAQ::DetectorPattern(const char *detectorList)
	217	{
	218	// see header file for class documentation
	219	if (!fgpInstance) GetInstance();
	220	if (fgpInstance) return fgpInstance->VirtDetectorPattern(detectorList);
	221	return 0;
	222	}
	223
	224	const char AliHLTDAQ::OfflineModuleName(const char detectorName)
	225	{
	226	// see header file for class documentation
	227	if (!fgpInstance) GetInstance();
	228	if (fgpInstance) return fgpInstance->VirtOfflineModuleName(detectorName);
	229	return NULL;
	230	}
	231	const char *AliHLTDAQ::OfflineModuleName(Int_t detectorID)
	232	{
	233	// see header file for class documentation
	234	if (!fgpInstance) GetInstance();
	235	if (fgpInstance) return fgpInstance->VirtOfflineModuleName(detectorID);
	236	return NULL;
	237	}
	238
	239	const char AliHLTDAQ::OnlineName(const char detectorName)
	240	{
	241	// see header file for class documentation
	242	if (!fgpInstance) GetInstance();
	243	if (fgpInstance) return fgpInstance->VirtOnlineName(detectorName);
	244	return NULL;
	245	}
	246	const char *AliHLTDAQ::OnlineName(Int_t detectorID)
	247	{
	248	// see header file for class documentation
	249	if (!fgpInstance) GetInstance();
	250	if (fgpInstance) return fgpInstance->VirtOnlineName(detectorID);
	251	return NULL;
	252	}
	253
	254	string AliHLTDAQ::HLTOrigin(const char *detectorName)
	255	{
	256	// get HLT origin from detector name
	257	return HLTOrigin(DetectorID(detectorName));
	258	}
	259
	260	string AliHLTDAQ::HLTOrigin(Int_t detectorID)
	261	{
	262	// get HLT origin from detector ID
	263	string origin;
	264	if (detectorID>=0 && (unsigned)detectorID<sizeof(fgkOriginMapping)/sizeof(const char*)) {
	265	origin.append(fgkOriginMapping[detectorID], kAliHLTComponentDataTypefOriginSize);
	266	}
	267	return origin;
	268	}
	269
	270	string AliHLTDAQ::HLTSpecificationFromDdlID(Int_t ddlID)
	271	{
	272	// get the HLT data specification from equipment id
	273	string result = "";
	274	Int_t ddlIndex=0;
	275	Int_t detectorID = DetectorIDFromDdlID(ddlID, ddlIndex);
	276	if (detectorID < 0)
	277	return result;
	278	Int_t TPCID = DetectorID("TPC");
	279	const int strtmplength=11;
	280	char strtmp[strtmplength];
	281	memset(strtmp, 0, strtmplength);
	282	if (detectorID == TPCID) {
	283	int partition;
	284	int slice;
	285	if (ddlID < 840) {
	286	partition = ddlID % 2;
	287	slice = (ddlID - 768) / 2;
	288	} else {
	289	partition = (ddlID % 4) + 2;
	290	slice = (ddlID - 840) / 4;
	291	}
	292	snprintf(strtmp, strtmplength, "0x%02x%02x%02x%02x", slice, slice, partition, partition);
	293	result = strtmp;
	294	}
	295	else if (detectorID == DetectorID("TOF")) {
	296	AliHLTLogging log;
	297	log.Logging(kHLTLogWarning, "AliHLTDAQ::HLTSpecificationFromDdlID", "HLT Analysis", "Mapping of data specification not implemented for TOF");
	298	}
	299	else { // default
	300	snprintf(strtmp, strtmplength, "0x%08x", 0x1 << ddlIndex);
	301	result = strtmp;
	302	}
	303	return result;
	304	}
	305
	306	Int_t AliHLTDAQ::DdlIDFromHLTBlockData(const char dataorigin[kAliHLTComponentDataTypefOriginSize], UInt_t specification)
	307	{
	308	// get the DDL ID (global equipment ID) from HLT origin and data specification
	309	Int_t detectorID=DetectorIDFromHLTOrigin(dataorigin);
	310	if (detectorID<0) return -1;
	311	Int_t ddlID=DdlIDOffset(detectorID);
	312	if (ddlID<0) return -1;
	313
	314	if (detectorID == DetectorID("TPC")) {
	315	int minPartition= specification &0xff;
	316	int maxPartition=(specification>>8) &0xff;
	317	int minSlice =(specification>>16)&0xff;
	318	int maxSlice =(specification>>24)&0xff;
	319	if (minPartition<0 \|\| minPartition>5 \|\|
	320	maxPartition<0 \|\| maxPartition>5 \|\|
	321	minSlice<0 \|\| minSlice>35 \|\|
	322	maxSlice<0 \|\| maxSlice>35) {
	323	AliHLTLogging log;
	324	log.Logging(kHLTLogError, "AliHLTDAQ::DdlID", "HLT Analysis", "invalid data specification 0x%08x", specification);
	325	return -1;
	326	}
	327	else if (minPartition!=maxPartition \|\|
	328	minSlice!=maxSlice) {
	329	AliHLTLogging log;
	330	log.Logging(kHLTLogError, "AliHLTDAQ::DdlID", "HLT Analysis", "ambiguous data specification 0x%08x", specification);
	331	return -1;
	332	}
	333	if (minPartition<2) ddlID+=2*minSlice+minPartition; // inner sector
	334	else ddlID+=4*minSlice+(minPartition-2)+72; // outer sector
	335	}
	336	else if (detectorID == DetectorID("TOF")) {
	337	AliHLTLogging log;
	338	log.Logging(kHLTLogWarning, "AliHLTDAQ::DdlID", "HLT Analysis", "Mapping of data specification not implemented for TOF");
	339	return -1;
	340	}
	341	else { // default
	342	for (int i=0; i<32; i++) {
	343	if ((specification&(0x1<<i))==0) continue; // if bit not set
	344	if ((specification&(0xffffffff^(0x1<<i)))!=0) { // check if other bits set
	345	AliHLTLogging log;
	346	log.Logging(kHLTLogError, "AliHLTDAQ::DdlID", "HLT Analysis", "ambiguous data specification 0x%08x", specification);
	347	return -1;
	348	}
	349	ddlID+=i;
	350	break;
	351	}
	352	}
	353
	354	return ddlID;
	355	}
	356
	357	AliHLTDAQ* AliHLTDAQ::GetInstance()
	358	{
	359	// see header file for class documentation
	360	if (!fgpInstance) {
	361	fgpInstance=AliHLTMisc::LoadInstance((AliHLTDAQ*)NULL, fgkImplName, fgkImplLibrary);
	362	if (!fgpInstance) {
	363	AliHLTLogging log;
	364	log.Logging(kHLTLogError, "AliHLTDAQ::Instance", "HLT Analysis", "failed to load AliHLTDAQ implementation");
	365	}
	366	}
	367	return fgpInstance;
	368	}