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

#ifndef ALIHLTMUONCONSTANTS_H
#define ALIHLTMUONCONSTANTS_H
/**************************************************************************
 * 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.h
 * @author Indranil Das <indra.das@saha.ac.in>,
 *         Artur Szostak <artursz@iafrica.com>
 * @date   
 * @brief  Class containing various dimuon HLT constants used in the system.
 */

// Forward declare structures.
extern "C" {
struct AliHLTComponentDataType;
struct AliHLTMUONTriggerRecordStruct;
struct AliHLTMUONTrigRecInfoStruct;
struct AliHLTMUONRecHitStruct;
struct AliHLTMUONChannelStruct;
struct AliHLTMUONClusterStruct;
struct AliHLTMUONMansoTrackStruct;
struct AliHLTMUONMansoRoIStruct;
struct AliHLTMUONMansoCandidateStruct;
struct AliHLTMUONTrackDecisionStruct;
struct AliHLTMUONPairDecisionStruct;
} // extern "C"

/**
 * AliHLTMUONConstants contains a list of global dimuon HLT specific constants
 * and constant structures used in the system.
 * Static methods are provided to access these values.
 */
class AliHLTMUONConstants
{
public:

	static const AliHLTMUONTriggerRecordStruct& NilTriggerRecordStruct()
	{
		return fgkNilTriggerRecordStruct;
	}

	static const AliHLTMUONTrigRecInfoStruct& NilTrigRecInfoStruct()
	{
		return fgkNilTrigRecInfoStruct;
	}

	static const AliHLTMUONRecHitStruct& NilRecHitStruct()
	{
		return fgkNilRecHitStruct;
	}

	static const AliHLTMUONChannelStruct& NilChannelStruct()
	{
		return fgkNilChannelStruct;
	}

	static const AliHLTMUONClusterStruct& NilClusterStruct()
	{
		return fgkNilClusterStruct;
	}

	static const AliHLTMUONMansoTrackStruct& NilMansoTrackStruct()
	{
		return fgkNilMansoTrackStruct;
	}

	static const AliHLTMUONMansoRoIStruct& NilMansoRoIStruct()
	{
		return fgkNilMansoRoIStruct;
	}

	static const AliHLTMUONMansoCandidateStruct& NilMansoCandidateStruct()
	{
		return fgkNilMansoCandidateStruct;
	}

	static const AliHLTMUONTrackDecisionStruct& NilTrackDecisionStruct()
	{
		return fgkNilTrackDecisionStruct;
	}

	static const AliHLTMUONPairDecisionStruct& NilPairDecisionStruct()
	{
		return fgkNilPairDecisionStruct;
	}

	// Returns the raw data type for MUON DDLs. To figure out if the DDL format
	// will be for a tracking DDL or trigger DDL one needs to also check the
	// sepcification word of the input data block. If one of the first 20 least
	// significant bits are set then it is a tracker DDL otherwise if it is
	// the 21st or 22nd bit then it is from the muon trigger.
	static const AliHLTComponentDataType& DDLRawDataType()
	{
		return fgkDDLRawDataType;
	}

	static const AliHLTComponentDataType& TriggerRecordsBlockDataType()
	{
		return fgkTriggerRecordsBlockDataType;
	}

	static const AliHLTComponentDataType& TrigRecsDebugBlockDataType()
	{
		return fgkTrigRecsDebugBlockDataType;
	}

	static const AliHLTComponentDataType& RecHitsBlockDataType()
	{
		return fgkRecHitsBlockDataType;
	}

	static const AliHLTComponentDataType& ClusterBlockDataType()
	{
		return fgkClusterBlockDataType;
	}

	static const AliHLTComponentDataType& ChannelBlockDataType()
	{
		return fgkChannelBlockDataType;
	}

	static const AliHLTComponentDataType& MansoTracksBlockDataType()
	{
		return fgkMansoTracksBlockDataType;
	}

	static const AliHLTComponentDataType& MansoCandidatesBlockDataType()
	{
		return fgkMansoCandidatesBlockDataType;
	}

	static const AliHLTComponentDataType& SinglesDecisionBlockDataType()
	{
		return fgkSinglesDecisionBlockDataType;
	}

	static const AliHLTComponentDataType& PairsDecisionBlockDataType()
	{
		return fgkPairsDecisionBlockDataType;
	}
	
	static const char* RecHitsSourceId()
	{
		return fgkRecHitsSourceId;
	}
	
	static const char* TriggerRecordsSourceId()
	{
		return fgkTriggerRecordsSourceId;
	}
	
	static const char* TracksSourceId()
	{
		return fgkTracksSourceId;
	}
	
	static const char* DigitPublisherId()
	{
		return fgkDigitPublisherId;
	}
	
	static const char* TriggerReconstructorId()
	{
		return fgkTriggerReconstructorId;
	}
	
	static const char* HitReconstructorId()
	{
		return fgkHitReconstructorId;
	}
	
	static const char* MansoTrackerFSMId()
	{
		return fgkMansoTrackerFSMId;
	}
	
	static const char* DecisionComponentId()
	{
		return fgkDecisionComponentId;
	}
	
	static const char* RootifierComponentId()
	{
		return fgkRootifierComponentId;
	}
	
	static const char* EmptyEventFilterComponentId()
	{
		return fgkEmptyEventFilterComponentId;
	}
	
	static const char* DataCheckerComponentId()
	{
		return fgkDataCheckerComponentId;
	}
	
	static const char* HitReconstructorCDBPath()
	{
		return fgkHitReconstructorCDBPath;
	}
	
	static const char* MansoTrackerFSMCDBPath()
	{
		return fgkMansoTrackerFSMCDBPath;
	}
	
	static const char* DecisionComponentCDBPath()
	{
		return fgkDecisionComponentCDBPath;
	}

private:

	// Should never have to create, destroy or copy this object.
	AliHLTMUONConstants();
	AliHLTMUONConstants(const AliHLTMUONConstants& obj);
	~AliHLTMUONConstants();
	AliHLTMUONConstants& operator = (const AliHLTMUONConstants& obj);
	
	// The following are null/nil structures that can also be used as sentinels:
	static const AliHLTMUONTriggerRecordStruct fgkNilTriggerRecordStruct; // Nil trigger record.
	static const AliHLTMUONTrigRecInfoStruct fgkNilTrigRecInfoStruct; // Nil trigger record debug information.
	static const AliHLTMUONRecHitStruct fgkNilRecHitStruct; // Nil reconstructed hit.
	static const AliHLTMUONChannelStruct fgkNilChannelStruct; // Nil tracking chamber channel.
	static const AliHLTMUONClusterStruct fgkNilClusterStruct; // Nil tracking chamber cluster.
	static const AliHLTMUONMansoTrackStruct fgkNilMansoTrackStruct; // Nil manso track.
	static const AliHLTMUONMansoRoIStruct fgkNilMansoRoIStruct; // Nil manso region of interest.
	static const AliHLTMUONMansoCandidateStruct fgkNilMansoCandidateStruct; // Nil manso candidate track.
	static const AliHLTMUONTrackDecisionStruct fgkNilTrackDecisionStruct; // Nil decision for single track.
	static const AliHLTMUONPairDecisionStruct fgkNilPairDecisionStruct; // Nil decision for track pair.

	// HLT component input and output data block types:
	static const AliHLTComponentDataType fgkDDLRawDataType; // DDL packed data block type from dimuon spectrometer.
	static const AliHLTComponentDataType fgkTriggerRecordsBlockDataType; // Trigger records block type generated by trigger DDL translation components.
	static const AliHLTComponentDataType fgkTrigRecsDebugBlockDataType; // Debugging information block type generated by trigger DDL translation components.
	static const AliHLTComponentDataType fgkRecHitsBlockDataType; // Reconstructed hits block type generated by hit reconstruction components.
	static const AliHLTComponentDataType fgkClusterBlockDataType; // Debugging information block type for reconstructed hit clusters.
	static const AliHLTComponentDataType fgkChannelBlockDataType; // Debugging information block type for channels corresponding to clusters.
	static const AliHLTComponentDataType fgkMansoTracksBlockDataType; // Manso tracks block type generated by Manso tracker components.
	static const AliHLTComponentDataType fgkMansoCandidatesBlockDataType; // Debugging information about a track candidate generated by the Manso algorithm.
	static const AliHLTComponentDataType fgkSinglesDecisionBlockDataType; // Trigger decision block type for single track decisions.
	static const AliHLTComponentDataType fgkPairsDecisionBlockDataType; // Trigger decision block type for pairs of particles.
	
	// Component ID names:
	static const char* fgkRecHitsSourceId; // Name of source component for reconstructed hits for debugging.
	static const char* fgkTriggerRecordsSourceId; // Name of source component for trigger records for debugging.
	static const char* fgkTracksSourceId; // Name of source component for tracks for debugging.
	static const char* fgkDigitPublisherId; // Component name for publishing DDL streams from digits.
	static const char* fgkTriggerReconstructorId; // Trigger record reconstructor component name.
	static const char* fgkHitReconstructorId; // Centre of gravity cluster finder component name.
	static const char* fgkMansoTrackerFSMId; // Manso tracker FSM implementation component name.
	static const char* fgkDecisionComponentId; // dHLT decision component name.
	static const char* fgkRootifierComponentId; // The name of the event filter debugging component.
	static const char* fgkEmptyEventFilterComponentId; // The name of the event filter debugging component.
	static const char* fgkDataCheckerComponentId; // Name of data checking component for debugging.
	
	// CDB path entries to configuration information.
	static const char* fgkHitReconstructorCDBPath; // Path to CDB entry for the hit reconstruction component.
	static const char* fgkMansoTrackerFSMCDBPath; // Path to CDB entry for the Manso FSM tracker component.
	static const char* fgkDecisionComponentCDBPath; // Path to CDB entry for trigger decision component.
};

#endif // ALIHLTMUONCONSTANTS_H
Commit	Line	Data
	1	#ifndef ALIHLTMUONCONSTANTS_H
	2	#define ALIHLTMUONCONSTANTS_H
	3	/**************************************************************************
	4	* This file is property of and copyright by the ALICE HLT Project *
	5	* All rights reserved. *
	6	* *
	7	* Primary Authors: *
	8	* Indranil Das <indra.das@saha.ac.in> *
	9	* Artur Szostak <artursz@iafrica.com> *
	10	* *
	11	* Permission to use, copy, modify and distribute this software and its *
	12	* documentation strictly for non-commercial purposes is hereby granted *
	13	* without fee, provided that the above copyright notice appears in all *
	14	* copies and that both the copyright notice and this permission notice *
	15	* appear in the supporting documentation. The authors make no claims *
	16	* about the suitability of this software for any purpose. It is *
	17	* provided "as is" without express or implied warranty. *
	18	**************************************************************************/
	19
	20	/* $Id$ */
	21
	22	/**
	23	* @file AliHLTMUONConstants.h
	24	* @author Indranil Das <indra.das@saha.ac.in>,
	25	* Artur Szostak <artursz@iafrica.com>
	26	* @date
	27	* @brief Class containing various dimuon HLT constants used in the system.
	28	*/
	29
	30	// Forward declare structures.
	31	extern "C" {
	32	struct AliHLTComponentDataType;
	33	struct AliHLTMUONTriggerRecordStruct;
	34	struct AliHLTMUONTrigRecInfoStruct;
	35	struct AliHLTMUONRecHitStruct;
	36	struct AliHLTMUONChannelStruct;
	37	struct AliHLTMUONClusterStruct;
	38	struct AliHLTMUONMansoTrackStruct;
	39	struct AliHLTMUONMansoRoIStruct;
	40	struct AliHLTMUONMansoCandidateStruct;
	41	struct AliHLTMUONTrackDecisionStruct;
	42	struct AliHLTMUONPairDecisionStruct;
	43	} // extern "C"
	44
	45	/**
	46	* AliHLTMUONConstants contains a list of global dimuon HLT specific constants
	47	* and constant structures used in the system.
	48	* Static methods are provided to access these values.
	49	*/
	50	class AliHLTMUONConstants
	51	{
	52	public:
	53
	54	static const AliHLTMUONTriggerRecordStruct& NilTriggerRecordStruct()
	55	{
	56	return fgkNilTriggerRecordStruct;
	57	}
	58
	59	static const AliHLTMUONTrigRecInfoStruct& NilTrigRecInfoStruct()
	60	{
	61	return fgkNilTrigRecInfoStruct;
	62	}
	63
	64	static const AliHLTMUONRecHitStruct& NilRecHitStruct()
	65	{
	66	return fgkNilRecHitStruct;
	67	}
	68
	69	static const AliHLTMUONChannelStruct& NilChannelStruct()
	70	{
	71	return fgkNilChannelStruct;
	72	}
	73
	74	static const AliHLTMUONClusterStruct& NilClusterStruct()
	75	{
	76	return fgkNilClusterStruct;
	77	}
	78
	79	static const AliHLTMUONMansoTrackStruct& NilMansoTrackStruct()
	80	{
	81	return fgkNilMansoTrackStruct;
	82	}
	83
	84	static const AliHLTMUONMansoRoIStruct& NilMansoRoIStruct()
	85	{
	86	return fgkNilMansoRoIStruct;
	87	}
	88
	89	static const AliHLTMUONMansoCandidateStruct& NilMansoCandidateStruct()
	90	{
	91	return fgkNilMansoCandidateStruct;
	92	}
	93
	94	static const AliHLTMUONTrackDecisionStruct& NilTrackDecisionStruct()
	95	{
	96	return fgkNilTrackDecisionStruct;
	97	}
	98
	99	static const AliHLTMUONPairDecisionStruct& NilPairDecisionStruct()
	100	{
	101	return fgkNilPairDecisionStruct;
	102	}
	103
	104	// Returns the raw data type for MUON DDLs. To figure out if the DDL format
	105	// will be for a tracking DDL or trigger DDL one needs to also check the
	106	// sepcification word of the input data block. If one of the first 20 least
	107	// significant bits are set then it is a tracker DDL otherwise if it is
	108	// the 21st or 22nd bit then it is from the muon trigger.
	109	static const AliHLTComponentDataType& DDLRawDataType()
	110	{
	111	return fgkDDLRawDataType;
	112	}
	113
	114	static const AliHLTComponentDataType& TriggerRecordsBlockDataType()
	115	{
	116	return fgkTriggerRecordsBlockDataType;
	117	}
	118
	119	static const AliHLTComponentDataType& TrigRecsDebugBlockDataType()
	120	{
	121	return fgkTrigRecsDebugBlockDataType;
	122	}
	123
	124	static const AliHLTComponentDataType& RecHitsBlockDataType()
	125	{
	126	return fgkRecHitsBlockDataType;
	127	}
	128
	129	static const AliHLTComponentDataType& ClusterBlockDataType()
	130	{
	131	return fgkClusterBlockDataType;
	132	}
	133
	134	static const AliHLTComponentDataType& ChannelBlockDataType()
	135	{
	136	return fgkChannelBlockDataType;
	137	}
	138
	139	static const AliHLTComponentDataType& MansoTracksBlockDataType()
	140	{
	141	return fgkMansoTracksBlockDataType;
	142	}
	143
	144	static const AliHLTComponentDataType& MansoCandidatesBlockDataType()
	145	{
	146	return fgkMansoCandidatesBlockDataType;
	147	}
	148
	149	static const AliHLTComponentDataType& SinglesDecisionBlockDataType()
	150	{
	151	return fgkSinglesDecisionBlockDataType;
	152	}
	153
	154	static const AliHLTComponentDataType& PairsDecisionBlockDataType()
	155	{
	156	return fgkPairsDecisionBlockDataType;
	157	}
	158
	159	static const char* RecHitsSourceId()
	160	{
	161	return fgkRecHitsSourceId;
	162	}
	163
	164	static const char* TriggerRecordsSourceId()
	165	{
	166	return fgkTriggerRecordsSourceId;
	167	}
	168
	169	static const char* TracksSourceId()
	170	{
	171	return fgkTracksSourceId;
	172	}
	173
	174	static const char* DigitPublisherId()
	175	{
	176	return fgkDigitPublisherId;
	177	}
	178
	179	static const char* TriggerReconstructorId()
	180	{
	181	return fgkTriggerReconstructorId;
	182	}
	183
	184	static const char* HitReconstructorId()
	185	{
	186	return fgkHitReconstructorId;
	187	}
	188
	189	static const char* MansoTrackerFSMId()
	190	{
	191	return fgkMansoTrackerFSMId;
	192	}
	193
	194	static const char* DecisionComponentId()
	195	{
	196	return fgkDecisionComponentId;
	197	}
	198
	199	static const char* RootifierComponentId()
	200	{
	201	return fgkRootifierComponentId;
	202	}
	203
	204	static const char* EmptyEventFilterComponentId()
	205	{
	206	return fgkEmptyEventFilterComponentId;
	207	}
	208
	209	static const char* DataCheckerComponentId()
	210	{
	211	return fgkDataCheckerComponentId;
	212	}
	213
	214	static const char* HitReconstructorCDBPath()
	215	{
	216	return fgkHitReconstructorCDBPath;
	217	}
	218
	219	static const char* MansoTrackerFSMCDBPath()
	220	{
	221	return fgkMansoTrackerFSMCDBPath;
	222	}
	223
	224	static const char* DecisionComponentCDBPath()
	225	{
	226	return fgkDecisionComponentCDBPath;
	227	}
	228
	229	private:
	230
	231	// Should never have to create, destroy or copy this object.
	232	AliHLTMUONConstants();
	233	AliHLTMUONConstants(const AliHLTMUONConstants& obj);
	234	~AliHLTMUONConstants();
	235	AliHLTMUONConstants& operator = (const AliHLTMUONConstants& obj);
	236
	237	// The following are null/nil structures that can also be used as sentinels:
	238	static const AliHLTMUONTriggerRecordStruct fgkNilTriggerRecordStruct; // Nil trigger record.
	239	static const AliHLTMUONTrigRecInfoStruct fgkNilTrigRecInfoStruct; // Nil trigger record debug information.
	240	static const AliHLTMUONRecHitStruct fgkNilRecHitStruct; // Nil reconstructed hit.
	241	static const AliHLTMUONChannelStruct fgkNilChannelStruct; // Nil tracking chamber channel.
	242	static const AliHLTMUONClusterStruct fgkNilClusterStruct; // Nil tracking chamber cluster.
	243	static const AliHLTMUONMansoTrackStruct fgkNilMansoTrackStruct; // Nil manso track.
	244	static const AliHLTMUONMansoRoIStruct fgkNilMansoRoIStruct; // Nil manso region of interest.
	245	static const AliHLTMUONMansoCandidateStruct fgkNilMansoCandidateStruct; // Nil manso candidate track.
	246	static const AliHLTMUONTrackDecisionStruct fgkNilTrackDecisionStruct; // Nil decision for single track.
	247	static const AliHLTMUONPairDecisionStruct fgkNilPairDecisionStruct; // Nil decision for track pair.
	248
	249	// HLT component input and output data block types:
	250	static const AliHLTComponentDataType fgkDDLRawDataType; // DDL packed data block type from dimuon spectrometer.
	251	static const AliHLTComponentDataType fgkTriggerRecordsBlockDataType; // Trigger records block type generated by trigger DDL translation components.
	252	static const AliHLTComponentDataType fgkTrigRecsDebugBlockDataType; // Debugging information block type generated by trigger DDL translation components.
	253	static const AliHLTComponentDataType fgkRecHitsBlockDataType; // Reconstructed hits block type generated by hit reconstruction components.
	254	static const AliHLTComponentDataType fgkClusterBlockDataType; // Debugging information block type for reconstructed hit clusters.
	255	static const AliHLTComponentDataType fgkChannelBlockDataType; // Debugging information block type for channels corresponding to clusters.
	256	static const AliHLTComponentDataType fgkMansoTracksBlockDataType; // Manso tracks block type generated by Manso tracker components.
	257	static const AliHLTComponentDataType fgkMansoCandidatesBlockDataType; // Debugging information about a track candidate generated by the Manso algorithm.
	258	static const AliHLTComponentDataType fgkSinglesDecisionBlockDataType; // Trigger decision block type for single track decisions.
	259	static const AliHLTComponentDataType fgkPairsDecisionBlockDataType; // Trigger decision block type for pairs of particles.
	260
	261	// Component ID names:
	262	static const char* fgkRecHitsSourceId; // Name of source component for reconstructed hits for debugging.
	263	static const char* fgkTriggerRecordsSourceId; // Name of source component for trigger records for debugging.
	264	static const char* fgkTracksSourceId; // Name of source component for tracks for debugging.
	265	static const char* fgkDigitPublisherId; // Component name for publishing DDL streams from digits.
	266	static const char* fgkTriggerReconstructorId; // Trigger record reconstructor component name.
	267	static const char* fgkHitReconstructorId; // Centre of gravity cluster finder component name.
	268	static const char* fgkMansoTrackerFSMId; // Manso tracker FSM implementation component name.
	269	static const char* fgkDecisionComponentId; // dHLT decision component name.
	270	static const char* fgkRootifierComponentId; // The name of the event filter debugging component.
	271	static const char* fgkEmptyEventFilterComponentId; // The name of the event filter debugging component.
	272	static const char* fgkDataCheckerComponentId; // Name of data checking component for debugging.
	273
	274	// CDB path entries to configuration information.
	275	static const char* fgkHitReconstructorCDBPath; // Path to CDB entry for the hit reconstruction component.
	276	static const char* fgkMansoTrackerFSMCDBPath; // Path to CDB entry for the Manso FSM tracker component.
	277	static const char* fgkDecisionComponentCDBPath; // Path to CDB entry for trigger decision component.
	278	};
	279
	280	#endif // ALIHLTMUONCONSTANTS_H