[u/mrichter/AliRoot.git] / HLT / MUON / AliHLTMUONConstants.cxx

/**************************************************************************
 * This file is property of and copyright by the ALICE HLT Project        *
 * All rights reserved.                                                   *
 *                                                                        *
 * Primary Authors:                                                       *
 *   Indranil Das <indra.das@saha.ac.in>                                  *
 *   Artur Szostak <artursz@iafrica.com>                                  *
 *                                                                        *
 * 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.                  *
 **************************************************************************/

// $Id$

/**
 * @file   AliHLTMUONConstants.cxx
 * @author Indranil Das <indra.das@saha.ac.in>,
 *         Artur Szostak <artursz@iafrica.com>
 * @date   17 May 2007
 * @brief  Definitions of the various dimuon HLT constants.
 */

#include "AliHLTMUONConstants.h"
#include "AliHLTMUONTriggerRecordsBlockStruct.h"
#include "AliHLTMUONTrigRecsDebugBlockStruct.h"
#include "AliHLTMUONRecHitsBlockStruct.h"
#include "AliHLTMUONClustersBlockStruct.h"
#include "AliHLTMUONChannelsBlockStruct.h"
#include "AliHLTMUONMansoTracksBlockStruct.h"
#include "AliHLTMUONMansoCandidatesBlockStruct.h"
#include "AliHLTMUONTracksBlockStruct.h"
#include "AliHLTMUONSinglesDecisionBlockStruct.h"
#include "AliHLTMUONPairsDecisionBlockStruct.h"

ClassImp(AliHLTMUONConstants);


const AliHLTMUONTriggerRecordStruct& AliHLTMUONConstants::NilTriggerRecordStruct()
{
	// Returns a nil trigger record structure.
	static const AliHLTMUONTriggerRecordStruct nilTriggerRecordStruct = {
		0, 0, 0, 0, 0,
		{
			AliHLTMUONConstants::NilRecHitStruct(),
			AliHLTMUONConstants::NilRecHitStruct(),
			AliHLTMUONConstants::NilRecHitStruct(),
			AliHLTMUONConstants::NilRecHitStruct()
		}
	};
	return nilTriggerRecordStruct;
}


const AliHLTMUONTrigRecInfoStruct& AliHLTMUONConstants::NilTrigRecInfoStruct()
{
	// Returns a nil trigger record debug information structure.
	static const AliHLTMUONTrigRecInfoStruct nilTrigRecInfoStruct = {
		0, {0, 0, 0, 0}, 0, 0,
		{0, 0, 0, 0, 0}, {0, 0, 0, 0, 0}, {0, 0, 0, 0, 0}
	};
	return nilTrigRecInfoStruct;
}


const AliHLTMUONRecHitStruct& AliHLTMUONConstants::NilRecHitStruct()
{
	// Returns a nil reconstructed hit structure.
	static const AliHLTMUONRecHitStruct nilRecHitStruct = {0, 0, 0, 0};
	return nilRecHitStruct;
}


const AliHLTMUONChannelStruct& AliHLTMUONConstants::NilChannelStruct()
{
	// Returns a nil tracking chamber channel structure.
	static const AliHLTMUONChannelStruct nilChannelStruct = {0, 0, 0, 0, 0, 0};
	return nilChannelStruct;
}


const AliHLTMUONClusterStruct& AliHLTMUONConstants::NilClusterStruct()
{
	// Returns a nil tracking chamber cluster.
	static const AliHLTMUONClusterStruct nilClusterStruct = {
		0, AliHLTMUONConstants::NilRecHitStruct(), 0, 0, 0, 0, 0
	};
	return nilClusterStruct;
}


const AliHLTMUONMansoTrackStruct& AliHLTMUONConstants::NilMansoTrackStruct()
{
	// Returns a nil Manso track structure.
	static const AliHLTMUONMansoTrackStruct nilMansoTrackStruct = {
		0, 0, 0, 0, 0, 0, 0,
		{
			AliHLTMUONConstants::NilRecHitStruct(),
			AliHLTMUONConstants::NilRecHitStruct(),
			AliHLTMUONConstants::NilRecHitStruct(),
			AliHLTMUONConstants::NilRecHitStruct()
		}
	};
	return nilMansoTrackStruct;
}


const AliHLTMUONMansoRoIStruct& AliHLTMUONConstants::NilMansoRoIStruct()
{
	// Returns a nil Manso region of interest structure.
	static const AliHLTMUONMansoRoIStruct nilMansoRoIStruct = {0, 0, 0, 0};
	return nilMansoRoIStruct;
}


const AliHLTMUONMansoCandidateStruct& AliHLTMUONConstants::NilMansoCandidateStruct()
{
	// Returns a nil Manso candidate track structure.
	static const AliHLTMUONMansoCandidateStruct nilMansoCandidateStruct = {
		AliHLTMUONConstants::NilMansoTrackStruct(),
		{
			AliHLTMUONConstants::NilMansoRoIStruct(),
			AliHLTMUONConstants::NilMansoRoIStruct(),
			AliHLTMUONConstants::NilMansoRoIStruct(),
			AliHLTMUONConstants::NilMansoRoIStruct()
		},
		0, 0
	};
	return nilMansoCandidateStruct;
}


const AliHLTMUONTrackStruct& AliHLTMUONConstants::NilTrackStruct()
{
	// Returns a nil track structure.
	static const AliHLTMUONTrackStruct nilTrackStruct = {
		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
		{
			AliHLTMUONConstants::NilRecHitStruct(),
			AliHLTMUONConstants::NilRecHitStruct(),
			AliHLTMUONConstants::NilRecHitStruct(),
			AliHLTMUONConstants::NilRecHitStruct(),
			AliHLTMUONConstants::NilRecHitStruct(),
			AliHLTMUONConstants::NilRecHitStruct(),
			AliHLTMUONConstants::NilRecHitStruct(),
			AliHLTMUONConstants::NilRecHitStruct(),
			AliHLTMUONConstants::NilRecHitStruct(),
			AliHLTMUONConstants::NilRecHitStruct(),
			AliHLTMUONConstants::NilRecHitStruct(),
			AliHLTMUONConstants::NilRecHitStruct(),
			AliHLTMUONConstants::NilRecHitStruct(),
			AliHLTMUONConstants::NilRecHitStruct(),
			AliHLTMUONConstants::NilRecHitStruct(),
			AliHLTMUONConstants::NilRecHitStruct()
		}
	};
	return nilTrackStruct;
}


const AliHLTMUONTrackDecisionStruct& AliHLTMUONConstants::NilTrackDecisionStruct()
{
	// Returns a nil decision structure for single track.
	static const AliHLTMUONTrackDecisionStruct nilTrackDecisionStruct = {0, 0, 0};
	return nilTrackDecisionStruct;
}


const AliHLTMUONPairDecisionStruct& AliHLTMUONConstants::NilPairDecisionStruct()
{
	// Returns a nil decision structure for track pair.
	static const AliHLTMUONPairDecisionStruct nilPairDecisionStruct = {0, 0, 0, 0};
	return nilPairDecisionStruct;
}


const AliHLTComponentDataType& AliHLTMUONConstants::DDLRawDataType()
{
	// Returns the raw data type for MUON DDLs.
	static const AliHLTComponentDataType ddlRawDataType = AliHLTComponentDataTypeInitializer(kAliHLTDataTypeDDLRaw.fID, kAliHLTDataOriginMUON);
	return ddlRawDataType;
}


const AliHLTComponentDataType& AliHLTMUONConstants::TriggerRecordsBlockDataType()
{
	// Returns a trigger records block type generated by trigger DDL translation components.
	static const AliHLTComponentDataType triggerRecordsBlockDataType = AliHLTComponentDataTypeInitializer("TRIGRECS", kAliHLTDataOriginMUON);
	return triggerRecordsBlockDataType;
}


const AliHLTComponentDataType& AliHLTMUONConstants::TrigRecsDebugBlockDataType()
{
	// Returns a debugging information block type generated by trigger DDL translation components.
	static const AliHLTComponentDataType trigRecsDebugBlockDataType = AliHLTComponentDataTypeInitializer("TRIGRDBG", kAliHLTDataOriginMUON);
	return trigRecsDebugBlockDataType;
}


const AliHLTComponentDataType& AliHLTMUONConstants::RecHitsBlockDataType()
{
	// Returns a reconstructed hits block type generated by hit reconstruction components.
	static const AliHLTComponentDataType recHitsBlockDataType = AliHLTComponentDataTypeInitializer("RECHITS ", kAliHLTDataOriginMUON);
	return recHitsBlockDataType;
}


const AliHLTComponentDataType& AliHLTMUONConstants::ClusterBlockDataType()
{
	// Returns a debugging information block type for reconstructed hit clusters.
	static const AliHLTComponentDataType clusterBlockDataType = AliHLTComponentDataTypeInitializer("CLUSTERS", kAliHLTDataOriginMUON);
	return clusterBlockDataType;
}


const AliHLTComponentDataType& AliHLTMUONConstants::ChannelBlockDataType()
{
	// Returns a debugging information block type for channels corresponding to clusters.
	static const AliHLTComponentDataType channelBlockDataType = AliHLTComponentDataTypeInitializer("CHANNELS", kAliHLTDataOriginMUON);
	return channelBlockDataType;
}


const AliHLTComponentDataType& AliHLTMUONConstants::MansoTracksBlockDataType()
{
	// Returns a Manso tracks block type generated by Manso tracker components.
	static const AliHLTComponentDataType mansoTracksBlockDataType = AliHLTComponentDataTypeInitializer("MANTRACK", kAliHLTDataOriginMUON);
	return mansoTracksBlockDataType;
}


const AliHLTComponentDataType& AliHLTMUONConstants::MansoCandidatesBlockDataType()
{
	// Returns a data type for debugging information data blocks about track candidates generated by the Manso algorithm.
	static const AliHLTComponentDataType mansoCandidatesBlockDataType = AliHLTComponentDataTypeInitializer("MNCANDID", kAliHLTDataOriginMUON);
	return mansoCandidatesBlockDataType;
}


const AliHLTComponentDataType& AliHLTMUONConstants::TracksBlockDataType()
{
	// Returns a full tracks block type generated by the tracker components.
	static const AliHLTComponentDataType tracksBlockDataType = AliHLTComponentDataTypeInitializer("TRACKS  ", kAliHLTDataOriginMUON);
	return tracksBlockDataType;
}


const AliHLTComponentDataType& AliHLTMUONConstants::SinglesDecisionBlockDataType()
{
	// Returns a trigger decision block type for single track decisions.
	static const AliHLTComponentDataType singlesDecisionBlockDataType = AliHLTComponentDataTypeInitializer("DECIDSIN", kAliHLTDataOriginMUON);
	return singlesDecisionBlockDataType;
}


const AliHLTComponentDataType& AliHLTMUONConstants::PairsDecisionBlockDataType()
{
	// Returns a trigger decision block type for pairs of particles.
	static const AliHLTComponentDataType pairsDecisionBlockDataType = AliHLTComponentDataTypeInitializer("DECIDPAR", kAliHLTDataOriginMUON);
	return pairsDecisionBlockDataType;
}


const AliHLTComponentDataType& AliHLTMUONConstants::RootifiedEventDataType()
{
	// Returns an AliHLTMUONEvent ROOT object data type.
	static const AliHLTComponentDataType rootifiedEventDataType = AliHLTComponentDataTypeInitializer("ROOTEVNT", kAliHLTDataOriginMUON);
	return rootifiedEventDataType;
}


const AliHLTComponentDataType& AliHLTMUONConstants::ESDDataType()
{
	// Returns the ESD data type with origin equal to MUON.
	static const AliHLTComponentDataType esdDataType = AliHLTComponentDataTypeInitializer(kAliHLTDataTypeESDObject.fID, kAliHLTDataOriginMUON);
	return esdDataType;
}


const AliHLTComponentDataType& AliHLTMUONConstants::ClusterStoreDataType()
{
	// Returns the offline algorithm's cluster store object type.
	static const AliHLTComponentDataType clusterStoreDataType = AliHLTComponentDataTypeInitializer("CLUSTORE", kAliHLTDataOriginMUON);
	return clusterStoreDataType;
}


const AliHLTComponentDataType& AliHLTMUONConstants::HistogramDataType()
{
	// Returns the TH1/2/3 histogram data type.
	static const AliHLTComponentDataType histogramDataType = AliHLTComponentDataTypeInitializer("ROOTHIST", kAliHLTDataOriginMUON);
	return histogramDataType;
}


const char* AliHLTMUONConstants::RecHitsSourceId()
{
	// Returns the name of source component for reconstructed hits for debugging.
	static const char* recHitsSourceId = "MUONRecHitsSource";
	return recHitsSourceId;
}


const char* AliHLTMUONConstants::TriggerRecordsSourceId()
{
	// Returns the name of source component for trigger records for debugging.
	static const char* triggerRecordsSourceId = "MUONTriggerRecordsSource";
	return triggerRecordsSourceId;
}


const char* AliHLTMUONConstants::TracksSourceId()
{
	// Returns the name of source component for tracks for debugging.
	static const char* tracksSourceId = "MUONTracksSource";
	return tracksSourceId;
}


const char* AliHLTMUONConstants::DigitPublisherId()
{
	// Returns the component name for publishing DDL streams from digits.
	static const char* digitPublisherId = "MUONDigitPublisher";
	return digitPublisherId;
}

const char* AliHLTMUONConstants::TriggerReconstructorId()
{
	// Returns the trigger record reconstructor component name.
	static const char* triggerReconstructorId = "MUONTriggerReconstructor";
	return triggerReconstructorId;
}


const char* AliHLTMUONConstants::HitReconstructorId()
{
	// Returns the centre of gravity cluster finder component name.
	static const char* hitReconstructorId = "MUONHitReconstructor";
	return hitReconstructorId;
}


const char* AliHLTMUONConstants::MansoTrackerFSMId()
{
	// Returns the Manso tracker FSM implementation component name.
	static const char* mansoTrackerFSMId = "MUONMansoTrackerFSM";
	return mansoTrackerFSMId;
}


const char* AliHLTMUONConstants::FullTrackerId()
{
	// Returns the full tracker implementation component name.
	static const char* fullTrackerId = "MUONFullTracker";
	return fullTrackerId;
}


const char* AliHLTMUONConstants::DecisionComponentId()
{
	// Returns the dHLT decision component name.
	static const char* decisionComponentId = "MUONDecisionComponent";
	return decisionComponentId;
}


const char* AliHLTMUONConstants::ESDMakerId()
{
	// Returns the name of ESD maker component which converts dHLT data to AliESDEvent classes. 
	static const char* esdMakerId = "MUONESDMaker";
	return esdMakerId;
}


const char* AliHLTMUONConstants::RootifierComponentId()
{
	// Returns the name of the event filter debugging component.
	static const char* rootifierComponentId = "MUONRootifier";
	return rootifierComponentId;
}


const char* AliHLTMUONConstants::EmptyEventFilterComponentId()
{
	// Returns the name of the event filter debugging component.
	static const char* emptyEventFilterComponentId = "MUONEmptyEventFilter";
	return emptyEventFilterComponentId;
}


const char* AliHLTMUONConstants::DataCheckerComponentId()
{
	// Returns the name of data checking component for debugging.
	static const char* dataCheckerComponentId = "MUONDataChecker";
	return dataCheckerComponentId;
}


const char* AliHLTMUONConstants::ClusterFinderId()
{
	// Returns the name of cluster finder implementing offline algorithms.
	static const char* clusterFinderId = "MUONClusterFinder";
	return clusterFinderId;
}


const char* AliHLTMUONConstants::RawDataHistogrammerId()
{
	// Returns the raw data histogrammer component name.
	static const char* rawDataHistogrammerId = "MUONRawDataHistogrammer";
	return rawDataHistogrammerId;
}


const char* AliHLTMUONConstants::ClusterHistogrammerId()
{
	// Returns the cluster data histogrammer component name.
	static const char* clusterHistogrammerId = "MUONClusterHistogrammer";
	return clusterHistogrammerId;
}


const char* AliHLTMUONConstants::TriggerReconstructorCDBPath()
{
	// Returns the path to the CDB entry for the trigger reconstruction component.
	static const char* triggerReconstructorCDBPath = "HLT/ConfigMUON/TriggerReconstructor";
	return triggerReconstructorCDBPath;
}


const char* AliHLTMUONConstants::HitReconstructorCDBPath()
{
	// Returns the path to the CDB entry for the hit reconstruction component.
	static const char* hitReconstructorCDBPath = "HLT/ConfigMUON/HitReconstructor";
	return hitReconstructorCDBPath;
}


const char* AliHLTMUONConstants::MansoTrackerFSMCDBPath()
{
	// Returns the path to the CDB entry for the Manso FSM tracker component.
	static const char* mansoTrackerFSMCDBPath = "HLT/ConfigMUON/MansoTrackerFSM";
	return mansoTrackerFSMCDBPath;
}


const char* AliHLTMUONConstants::DecisionComponentCDBPath()
{
	// Returns the path to the CDB entry for trigger decision component.
	static const char* decisionComponentCDBPath = "HLT/ConfigMUON/DecisionComponent";
	return decisionComponentCDBPath;
}


const char* AliHLTMUONConstants::FieldIntegralsCDBPath()
{
	// Returns the path to the CDB entry for magnetic field integrals.
	static const char* fieldIntegralsCDBPath = "HLT/ConfigMUON/FieldIntegrals";
	return fieldIntegralsCDBPath;
}


double AliHLTMUONConstants::DefaultNonBendingReso()
{
	// Returns the typical X (non-bending plane) resolution of the hit reconstruction (units = cm).
	static const double resolution = 0.144;
	return resolution;
}


double AliHLTMUONConstants::DefaultBendingReso()
{
	// Returns the typical Y (bending plane) resolution of the hit reconstruction (units = cm).
	static const double resolution = 0.01;
	return resolution;
}
Commit	Line	Data
26a4668d	1	/**************************************************************************
1d8ae082	2	* This file is property of and copyright by the ALICE HLT Project *
e6357f88	3	* All rights reserved. *
26a4668d	4	* *
e6357f88	5	* Primary Authors: *
	6	* Indranil Das <indra.das@saha.ac.in> *
	7	* Artur Szostak <artursz@iafrica.com> *
26a4668d	8	* *
	9	* Permission to use, copy, modify and distribute this software and its *
	10	* documentation strictly for non-commercial purposes is hereby granted *
	11	* without fee, provided that the above copyright notice appears in all *
	12	* copies and that both the copyright notice and this permission notice *
	13	* appear in the supporting documentation. The authors make no claims *
1d8ae082	14	* about the suitability of this software for any purpose. It is *
26a4668d	15	* provided "as is" without express or implied warranty. *
	16	**************************************************************************/
	17
1d8ae082	18	// $Id$
26a4668d	19
	20	/**
	21	* @file AliHLTMUONConstants.cxx
	22	* @author Indranil Das <indra.das@saha.ac.in>,
	23	* Artur Szostak <artursz@iafrica.com>
4d76a068	24	* @date 17 May 2007
26a4668d	25	* @brief Definitions of the various dimuon HLT constants.
	26	*/
	27
	28	#include "AliHLTMUONConstants.h"
b12fe461	29	#include "AliHLTMUONTriggerRecordsBlockStruct.h"
b12fe461	30	#include "AliHLTMUONTrigRecsDebugBlockStruct.h"
b12fe461	31	#include "AliHLTMUONRecHitsBlockStruct.h"
	32	#include "AliHLTMUONClustersBlockStruct.h"
	33	#include "AliHLTMUONChannelsBlockStruct.h"
	34	#include "AliHLTMUONMansoTracksBlockStruct.h"
	35	#include "AliHLTMUONMansoCandidatesBlockStruct.h"
a8982f78	36	#include "AliHLTMUONTracksBlockStruct.h"
b12fe461	37	#include "AliHLTMUONSinglesDecisionBlockStruct.h"
b12fe461	38	#include "AliHLTMUONPairsDecisionBlockStruct.h"
26a4668d	39
33b1e2f2	40	ClassImp(AliHLTMUONConstants);
910807dd	41
bfd48318	42
	43	const AliHLTMUONTriggerRecordStruct& AliHLTMUONConstants::NilTriggerRecordStruct()
	44	{
	45	// Returns a nil trigger record structure.
	46	static const AliHLTMUONTriggerRecordStruct nilTriggerRecordStruct = {
	47	0, 0, 0, 0, 0,
	48	{
	49	AliHLTMUONConstants::NilRecHitStruct(),
	50	AliHLTMUONConstants::NilRecHitStruct(),
	51	AliHLTMUONConstants::NilRecHitStruct(),
	52	AliHLTMUONConstants::NilRecHitStruct()
	53	}
	54	};
	55	return nilTriggerRecordStruct;
	56	}
	57
	58
	59	const AliHLTMUONTrigRecInfoStruct& AliHLTMUONConstants::NilTrigRecInfoStruct()
	60	{
	61	// Returns a nil trigger record debug information structure.
	62	static const AliHLTMUONTrigRecInfoStruct nilTrigRecInfoStruct = {
	63	0, {0, 0, 0, 0}, 0, 0,
	64	{0, 0, 0, 0, 0}, {0, 0, 0, 0, 0}, {0, 0, 0, 0, 0}
	65	};
	66	return nilTrigRecInfoStruct;
	67	}
	68
	69
	70	const AliHLTMUONRecHitStruct& AliHLTMUONConstants::NilRecHitStruct()
	71	{
	72	// Returns a nil reconstructed hit structure.
	73	static const AliHLTMUONRecHitStruct nilRecHitStruct = {0, 0, 0, 0};
	74	return nilRecHitStruct;
	75	}
	76
	77
	78	const AliHLTMUONChannelStruct& AliHLTMUONConstants::NilChannelStruct()
	79	{
	80	// Returns a nil tracking chamber channel structure.
	81	static const AliHLTMUONChannelStruct nilChannelStruct = {0, 0, 0, 0, 0, 0};
	82	return nilChannelStruct;
	83	}
	84
	85
	86	const AliHLTMUONClusterStruct& AliHLTMUONConstants::NilClusterStruct()
	87	{
	88	// Returns a nil tracking chamber cluster.
	89	static const AliHLTMUONClusterStruct nilClusterStruct = {
	90	0, AliHLTMUONConstants::NilRecHitStruct(), 0, 0, 0, 0, 0
	91	};
	92	return nilClusterStruct;
	93	}
	94
	95
	96	const AliHLTMUONMansoTrackStruct& AliHLTMUONConstants::NilMansoTrackStruct()
	97	{
	98	// Returns a nil Manso track structure.
	99	static const AliHLTMUONMansoTrackStruct nilMansoTrackStruct = {
	100	0, 0, 0, 0, 0, 0, 0,
	101	{
	102	AliHLTMUONConstants::NilRecHitStruct(),
	103	AliHLTMUONConstants::NilRecHitStruct(),
	104	AliHLTMUONConstants::NilRecHitStruct(),
	105	AliHLTMUONConstants::NilRecHitStruct()
106	}
107	};
108	return nilMansoTrackStruct;
109	}
110
111
112	const AliHLTMUONMansoRoIStruct& AliHLTMUONConstants::NilMansoRoIStruct()
113	{
114	// Returns a nil Manso region of interest structure.
115	static const AliHLTMUONMansoRoIStruct nilMansoRoIStruct = {0, 0, 0, 0};
116	return nilMansoRoIStruct;
117	}
118
119
120	const AliHLTMUONMansoCandidateStruct& AliHLTMUONConstants::NilMansoCandidateStruct()
121	{
122	// Returns a nil Manso candidate track structure.
123	static const AliHLTMUONMansoCandidateStruct nilMansoCandidateStruct = {
124	AliHLTMUONConstants::NilMansoTrackStruct(),
125	{
126	AliHLTMUONConstants::NilMansoRoIStruct(),
127	AliHLTMUONConstants::NilMansoRoIStruct(),
128	AliHLTMUONConstants::NilMansoRoIStruct(),
129	AliHLTMUONConstants::NilMansoRoIStruct()
130	},
131	0, 0
132	};
133	return nilMansoCandidateStruct;
134	}
135
136
137	const AliHLTMUONTrackStruct& AliHLTMUONConstants::NilTrackStruct()
138	{
139	// Returns a nil track structure.
140	static const AliHLTMUONTrackStruct nilTrackStruct = {
141	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
142	{
143	AliHLTMUONConstants::NilRecHitStruct(),
144	AliHLTMUONConstants::NilRecHitStruct(),
145	AliHLTMUONConstants::NilRecHitStruct(),
146	AliHLTMUONConstants::NilRecHitStruct(),
147	AliHLTMUONConstants::NilRecHitStruct(),
148	AliHLTMUONConstants::NilRecHitStruct(),
149	AliHLTMUONConstants::NilRecHitStruct(),
150	AliHLTMUONConstants::NilRecHitStruct(),
151	AliHLTMUONConstants::NilRecHitStruct(),
152	AliHLTMUONConstants::NilRecHitStruct(),
153	AliHLTMUONConstants::NilRecHitStruct(),
154	AliHLTMUONConstants::NilRecHitStruct(),
155	AliHLTMUONConstants::NilRecHitStruct(),
156	AliHLTMUONConstants::NilRecHitStruct(),
157	AliHLTMUONConstants::NilRecHitStruct(),
158	AliHLTMUONConstants::NilRecHitStruct()
159	}
160	};
161	return nilTrackStruct;
162	}
163
164
165	const AliHLTMUONTrackDecisionStruct& AliHLTMUONConstants::NilTrackDecisionStruct()
166	{
167	// Returns a nil decision structure for single track.
168	static const AliHLTMUONTrackDecisionStruct nilTrackDecisionStruct = {0, 0, 0};
169	return nilTrackDecisionStruct;
170	}
171
172
173	const AliHLTMUONPairDecisionStruct& AliHLTMUONConstants::NilPairDecisionStruct()
174	{
175	// Returns a nil decision structure for track pair.
176	static const AliHLTMUONPairDecisionStruct nilPairDecisionStruct = {0, 0, 0, 0};
177	return nilPairDecisionStruct;
178	}
179
180
181	const AliHLTComponentDataType& AliHLTMUONConstants::DDLRawDataType()
182	{
183	// Returns the raw data type for MUON DDLs.
184	static const AliHLTComponentDataType ddlRawDataType = AliHLTComponentDataTypeInitializer(kAliHLTDataTypeDDLRaw.fID, kAliHLTDataOriginMUON);
185	return ddlRawDataType;
186	}
187
188
189	const AliHLTComponentDataType& AliHLTMUONConstants::TriggerRecordsBlockDataType()
190	{
191	// Returns a trigger records block type generated by trigger DDL translation components.
192	static const AliHLTComponentDataType triggerRecordsBlockDataType = AliHLTComponentDataTypeInitializer("TRIGRECS", kAliHLTDataOriginMUON);
193	return triggerRecordsBlockDataType;
194	}
195
196
197	const AliHLTComponentDataType& AliHLTMUONConstants::TrigRecsDebugBlockDataType()
198	{
199	// Returns a debugging information block type generated by trigger DDL translation components.
200	static const AliHLTComponentDataType trigRecsDebugBlockDataType = AliHLTComponentDataTypeInitializer("TRIGRDBG", kAliHLTDataOriginMUON);
201	return trigRecsDebugBlockDataType;
202	}
203
204
205	const AliHLTComponentDataType& AliHLTMUONConstants::RecHitsBlockDataType()
206	{
207	// Returns a reconstructed hits block type generated by hit reconstruction components.
208	static const AliHLTComponentDataType recHitsBlockDataType = AliHLTComponentDataTypeInitializer("RECHITS ", kAliHLTDataOriginMUON);
209	return recHitsBlockDataType;
210	}
211
212
213	const AliHLTComponentDataType& AliHLTMUONConstants::ClusterBlockDataType()
214	{
215	// Returns a debugging information block type for reconstructed hit clusters.
216	static const AliHLTComponentDataType clusterBlockDataType = AliHLTComponentDataTypeInitializer("CLUSTERS", kAliHLTDataOriginMUON);
217	return clusterBlockDataType;
218	}
219
220
221	const AliHLTComponentDataType& AliHLTMUONConstants::ChannelBlockDataType()
222	{
223	// Returns a debugging information block type for channels corresponding to clusters.
224	static const AliHLTComponentDataType channelBlockDataType = AliHLTComponentDataTypeInitializer("CHANNELS", kAliHLTDataOriginMUON);
225	return channelBlockDataType;
226	}
227
228
229	const AliHLTComponentDataType& AliHLTMUONConstants::MansoTracksBlockDataType()
230	{
231	// Returns a Manso tracks block type generated by Manso tracker components.
232	static const AliHLTComponentDataType mansoTracksBlockDataType = AliHLTComponentDataTypeInitializer("MANTRACK", kAliHLTDataOriginMUON);
233	return mansoTracksBlockDataType;
234	}
235
236
237	const AliHLTComponentDataType& AliHLTMUONConstants::MansoCandidatesBlockDataType()
238	{
239	// Returns a data type for debugging information data blocks about track candidates generated by the Manso algorithm.
240	static const AliHLTComponentDataType mansoCandidatesBlockDataType = AliHLTComponentDataTypeInitializer("MNCANDID", kAliHLTDataOriginMUON);
241	return mansoCandidatesBlockDataType;
242	}
243
244
245	const AliHLTComponentDataType& AliHLTMUONConstants::TracksBlockDataType()
246	{
247	// Returns a full tracks block type generated by the tracker components.
248	static const AliHLTComponentDataType tracksBlockDataType = AliHLTComponentDataTypeInitializer("TRACKS ", kAliHLTDataOriginMUON);
249	return tracksBlockDataType;
250	}
251
252
253	const AliHLTComponentDataType& AliHLTMUONConstants::SinglesDecisionBlockDataType()
254	{
255	// Returns a trigger decision block type for single track decisions.
256	static const AliHLTComponentDataType singlesDecisionBlockDataType = AliHLTComponentDataTypeInitializer("DECIDSIN", kAliHLTDataOriginMUON);
257	return singlesDecisionBlockDataType;
258	}
259
260
261	const AliHLTComponentDataType& AliHLTMUONConstants::PairsDecisionBlockDataType()
262	{
263	// Returns a trigger decision block type for pairs of particles.
264	static const AliHLTComponentDataType pairsDecisionBlockDataType = AliHLTComponentDataTypeInitializer("DECIDPAR", kAliHLTDataOriginMUON);
265	return pairsDecisionBlockDataType;
266	}
267
268
269	const AliHLTComponentDataType& AliHLTMUONConstants::RootifiedEventDataType()
270	{
271	// Returns an AliHLTMUONEvent ROOT object data type.
272	static const AliHLTComponentDataType rootifiedEventDataType = AliHLTComponentDataTypeInitializer("ROOTEVNT", kAliHLTDataOriginMUON);
273	return rootifiedEventDataType;
274	}
275
276
277	const AliHLTComponentDataType& AliHLTMUONConstants::ESDDataType()
278	{
279	// Returns the ESD data type with origin equal to MUON.
280	static const AliHLTComponentDataType esdDataType = AliHLTComponentDataTypeInitializer(kAliHLTDataTypeESDObject.fID, kAliHLTDataOriginMUON);
281	return esdDataType;
282	}
283
284
285	const AliHLTComponentDataType& AliHLTMUONConstants::ClusterStoreDataType()
286	{
287	// Returns the offline algorithm's cluster store object type.
288	static const AliHLTComponentDataType clusterStoreDataType = AliHLTComponentDataTypeInitializer("CLUSTORE", kAliHLTDataOriginMUON);
289	return clusterStoreDataType;
290	}
291
292
293	const AliHLTComponentDataType& AliHLTMUONConstants::HistogramDataType()
294	{
295	// Returns the TH1/2/3 histogram data type.
296	static const AliHLTComponentDataType histogramDataType = AliHLTComponentDataTypeInitializer("ROOTHIST", kAliHLTDataOriginMUON);
297	return histogramDataType;
298	}
299
300
301	const char* AliHLTMUONConstants::RecHitsSourceId()
302	{
303	// Returns the name of source component for reconstructed hits for debugging.
304	static const char* recHitsSourceId = "MUONRecHitsSource";
305	return recHitsSourceId;
306	}
307
308
309	const char* AliHLTMUONConstants::TriggerRecordsSourceId()
310	{
311	// Returns the name of source component for trigger records for debugging.
312	static const char* triggerRecordsSourceId = "MUONTriggerRecordsSource";
313	return triggerRecordsSourceId;
314	}
315
316
317	const char* AliHLTMUONConstants::TracksSourceId()
318	{
319	// Returns the name of source component for tracks for debugging.
320	static const char* tracksSourceId = "MUONTracksSource";
321	return tracksSourceId;
322	}
323
324
325	const char* AliHLTMUONConstants::DigitPublisherId()
326	{
327	// Returns the component name for publishing DDL streams from digits.
328	static const char* digitPublisherId = "MUONDigitPublisher";
329	return digitPublisherId;
330	}
331
332	const char* AliHLTMUONConstants::TriggerReconstructorId()
333	{
334	// Returns the trigger record reconstructor component name.
335	static const char* triggerReconstructorId = "MUONTriggerReconstructor";
336	return triggerReconstructorId;
337	}
338
339
340	const char* AliHLTMUONConstants::HitReconstructorId()
341	{
342	// Returns the centre of gravity cluster finder component name.
343	static const char* hitReconstructorId = "MUONHitReconstructor";
344	return hitReconstructorId;
345	}
346
347
348	const char* AliHLTMUONConstants::MansoTrackerFSMId()
349	{
350	// Returns the Manso tracker FSM implementation component name.
351	static const char* mansoTrackerFSMId = "MUONMansoTrackerFSM";
352	return mansoTrackerFSMId;
353	}
354
355
356	const char* AliHLTMUONConstants::FullTrackerId()
357	{
358	// Returns the full tracker implementation component name.
359	static const char* fullTrackerId = "MUONFullTracker";
360	return fullTrackerId;
361	}
362
363
364	const char* AliHLTMUONConstants::DecisionComponentId()
365	{
366	// Returns the dHLT decision component name.
367	static const char* decisionComponentId = "MUONDecisionComponent";
368	return decisionComponentId;
369	}
370
371
372	const char* AliHLTMUONConstants::ESDMakerId()
373	{
374	// Returns the name of ESD maker component which converts dHLT data to AliESDEvent classes.
375	static const char* esdMakerId = "MUONESDMaker";
376	return esdMakerId;
377	}
378
379
380	const char* AliHLTMUONConstants::RootifierComponentId()
381	{
382	// Returns the name of the event filter debugging component.
383	static const char* rootifierComponentId = "MUONRootifier";
384	return rootifierComponentId;
385	}
386
387
388	const char* AliHLTMUONConstants::EmptyEventFilterComponentId()
389	{
390	// Returns the name of the event filter debugging component.
391	static const char* emptyEventFilterComponentId = "MUONEmptyEventFilter";
392	return emptyEventFilterComponentId;
393	}
394
395
396	const char* AliHLTMUONConstants::DataCheckerComponentId()
397	{
398	// Returns the name of data checking component for debugging.
399	static const char* dataCheckerComponentId = "MUONDataChecker";
400	return dataCheckerComponentId;
401	}
402
403
404	const char* AliHLTMUONConstants::ClusterFinderId()
405	{
406	// Returns the name of cluster finder implementing offline algorithms.
407	static const char* clusterFinderId = "MUONClusterFinder";
408	return clusterFinderId;
409	}
410
411
412	const char* AliHLTMUONConstants::RawDataHistogrammerId()
413	{
414	// Returns the raw data histogrammer component name.
415	static const char* rawDataHistogrammerId = "MUONRawDataHistogrammer";
416	return rawDataHistogrammerId;
417	}
418
419
420	const char* AliHLTMUONConstants::ClusterHistogrammerId()
421	{
422	// Returns the cluster data histogrammer component name.
423	static const char* clusterHistogrammerId = "MUONClusterHistogrammer";
424	return clusterHistogrammerId;
425	}
426
427
428	const char* AliHLTMUONConstants::TriggerReconstructorCDBPath()
429	{
430	// Returns the path to the CDB entry for the trigger reconstruction component.
431	static const char* triggerReconstructorCDBPath = "HLT/ConfigMUON/TriggerReconstructor";
432	return triggerReconstructorCDBPath;
433	}
434
435
436	const char* AliHLTMUONConstants::HitReconstructorCDBPath()
437	{
438	// Returns the path to the CDB entry for the hit reconstruction component.
439	static const char* hitReconstructorCDBPath = "HLT/ConfigMUON/HitReconstructor";
440	return hitReconstructorCDBPath;
441	}
442
443
444	const char* AliHLTMUONConstants::MansoTrackerFSMCDBPath()
445	{
446	// Returns the path to the CDB entry for the Manso FSM tracker component.
447	static const char* mansoTrackerFSMCDBPath = "HLT/ConfigMUON/MansoTrackerFSM";
448	return mansoTrackerFSMCDBPath;
449	}
450
451
452	const char* AliHLTMUONConstants::DecisionComponentCDBPath()
453	{
454	// Returns the path to the CDB entry for trigger decision component.
455	static const char* decisionComponentCDBPath = "HLT/ConfigMUON/DecisionComponent";
456	return decisionComponentCDBPath;
457	}
458
459
460	const char* AliHLTMUONConstants::FieldIntegralsCDBPath()
461	{
462	// Returns the path to the CDB entry for magnetic field integrals.
463	static const char* fieldIntegralsCDBPath = "HLT/ConfigMUON/FieldIntegrals";
464	return fieldIntegralsCDBPath;
465	}
466
467
468	double AliHLTMUONConstants::DefaultNonBendingReso()
469	{
470	// Returns the typical X (non-bending plane) resolution of the hit reconstruction (units = cm).
471	static const double resolution = 0.144;
472	return resolution;
473	}
474
475
476	double AliHLTMUONConstants::DefaultBendingReso()
477	{
478	// Returns the typical Y (bending plane) resolution of the hit reconstruction (units = cm).
479	static const double resolution = 0.01;
480	return resolution;
481	}
482