[u/mrichter/AliRoot.git] / MUON / Doxymodules_STEER.h

// $Id$
// The class categories definitions for Doxygen

/** @defgroup STEER STEER
 *  Category of AliRoot steering classes
 *  @{
 */

/** @defgroup STEERbase STEERbase
 *  Category of AliRoot steering classes
 *  @ingroup STEER
 *  @{
 */
// From STEERBaseLinkDef.h 56494 2012-05-15 20:58:42Z morsch

    enum   AliLog::EType_t {};
 
    class AliVParticle {};
    class AliVTrack {};
    class AliVCluster {};
    class AliVCaloCells {};
    class AliVVertex {};
    class AliVEvent {};
    class AliVHeader {};
    class AliVEventHandler {};
    class AliVEventPool {};
    class AliVCuts {};
    class AliVVZERO {};
    class AliVZDC {};
    class AliCentrality {};
    class AliEventplane {};

    class AliMixedEvent {};

    class AliPID {};
    class AliLog {};

    class AliRunTag {};
    class AliLHCTag {};
    class AliDetectorTag {};
    class AliEventTag {};
    class AliFileTag {};

    class AliRunTagCuts {};
    class AliLHCTagCuts {};
    class AliDetectorTagCuts {};
    class AliEventTagCuts {};

    class AliTagCreator {};

    class AliHeader {};
    class AliGenEventHeader {};
    class AliDetectorEventHeader {};
    class AliGenCocktailEventHeader {};
    class AliGenPythiaEventHeader {};
    class AliGenHijingEventHeader {};
    class AliCollisionGeometry {};
    class AliGenDPMjetEventHeader {};
    class AliGenHerwigEventHeader {};
    class AliGenGeVSimEventHeader {};
    class AliGenEposEventHeader {};
    class AliStack {};
    class AliMCEventHandler {};
    class AliInputEventHandler {};

    class AliTrackReference {};
    class AliSysInfo {};

    class AliMCEvent {};
    class AliMCParticle {};
    class AliMCVertex {};

    class  AliMagF {};
    class  AliMagWrapCheb {};
    class  AliCheb3DCalc {};
    class  AliCheb3D {};

    class  AliNeutralTrackParam {};

    class AliCodeTimer {};
    class AliCodeTimer::AliPair {};

    class  AliPDG {};

    class AliTimeStamp {};
    class AliTriggerScalers {};
    class AliTriggerScalersRecord {};

    class  AliExternalTrackParam {};
    class AliQA {};

    class AliTRDPIDReference {};
    class AliTRDPIDParams {};
    class AliTRDPIDParams::AliTRDPIDThresholds {};
    class AliITSPidParams {};
    class AliPIDResponse {};
    class AliITSPIDResponse {};
    class AliTPCPIDResponse {};
    class AliTPCdEdxInfo {};
    class AliTOFPIDResponse {};
    class AliTRDPIDResponse {};
    class AliEMCALPIDResponse {};
    class AliPIDCombined {};
    class AliTOFHeader {};

    class AliDAQ {};
    class AliRefArray {};

    class AliOADBContainer {};

    class AliMathBase {};
    class  TTreeDataElement {};
    class  TTreeStream {};
    class  TTreeSRedirector {};

    class AliVMFT {};
    class AliCounterCollection {};
    
    class AliVCaloTrigger {};

    class AliTOFPIDParams {};

/** @} */

/** @defgroup STEER0 STEER0
 *  Category of AliRoot steering classes
 *  @ingroup STEER
 *  @{
 */
// From STEERLinkDef.h 54207 2012-01-27 19:17:40Z hristov

    enum VertexSmear_t {};
    enum VertexSource_t {};

    class  AliGenerator {};
    class  AliVertexGenerator {};
    class  AliRun {};
    class  AliModule {};
    class  AliDetector {};
    class  AliDigit {};
    class  AliHit {};
    class  AliLego {};
    class  AliLegoGenerator {};
    class  AliLegoGeneratorXYZ {};
    class  AliLegoGeneratorPhiZ {};
    class  AliLegoGeneratorEta {};
    class  AliLegoGeneratorEtaR {};
    class  AliDigitNew {};
    class  AliGeometry {};
    class  AliRecPoint {};
    class  AliHitMap {};
    class  AliRndm {};
    class  AliDebugVolume {};
    class  AliConfig {};
    class  AliDigitizer {};
    class  AliDigitizationInput {};
    class  AliStream {};
    class  AliMergeCombi {};
    class  AliGausCorr {};
    class  AliLoader {};
    class  AliDataLoader {};
    class  AliBaseLoader {};
    class  AliObjectLoader {};
    class  AliTreeLoader {};
    class  AliRunLoader {};
    class  AliReconstructor {};
    class  AliMC {};
    class  AliSimulation {};
    class  AliReconstruction {};
    class  AliRecoInputHandler {};
    class  AliVertexGenFile {};
    class  AliVertexer {};

    class AliTriggerDetector {};
    class AliCentralTrigger {};
    class AliTriggerUtils {};

    class AliGeomManager {};
    class AliAlignObj {};
    class AliAlignObjParams {};
    class AliAlignObjMatrix {};
    class AliMisAligner {};

    class AliTrackFitter {};
    class AliTrackFitterRieman {};
    class AliTrackFitterKalman {};
    class AliTrackFitterStraight {};
    class AliTrackResiduals {};
    class AliTrackResidualsChi2 {};
    class AliTrackResidualsFast {};
    class AliTrackResidualsLinear {};
    class AliAlignmentTracks {};

    class  AliRieman {};

    class AliTriggerDetector {};
    class AliCentralTrigger {};
    class AliCTPRawStream {};
    class AliSignalProcesor {};
    class  AliHelix {};
    class  AliCluster {};
    class  AliCluster3D {};
    class  AliTracker {};
    class  AliTrackleter {};
    class  AliV0 {};
    class  AliKink {};

    class  AliSelectorRL {};

    class AliSurveyObj {};
    class AliSurveyPoint {};
    class AliSurveyToAlignObjs {};

    class AliFstream {};
    class AliCTPRawData {};

    class AliQADataMaker {};
    class AliQADataMakerSim {};
    class AliQADataMakerRec {};
    class AliCorrQADataMakerRec {};
    class AliGlobalQADataMaker {};
    class AliQAManager {};
    class AliQAChecker {};
    class AliCorrQAChecker {};
    class AliGlobalQAChecker {};
    class AliQACheckerBase {};
    class AliQAThresholds {};
    class AliMillepede {};

    class AliPlaneEff {};

    class AliTriggerRunScalers {};
    class AliGRPPreprocessor {};
    class AliGRPRecoParam {};

    class AliRelAlignerKalman {};

    class AliESDTagCreator {};

    class AliGRPObject {};

    class AliQAv1 {};

    class AliRunInfo {};
    class AliEventInfo {};
    class AliDetectorRecoParam {};
    class AliRecoParam {};

    class AliMillePede2 {};
    class AliMillePedeRecord {};
    class AliMinResSolve {};
    class AliMatrixSparse {};
    class AliVectorSparse {};
    class AliMatrixSq {};
    class AliSymMatrix {};
    class AliSymBDMatrix {};
    class AliRectMatrix {};
    class AliParamSolver {};

    class AliGRPManager {};
    class AliDCSArray {}; 	 
    class AliLHCReader {};
    class AliCTPTimeParams {};
    class AliCTPInputTimeParams {};

    class AliLHCDipValT<Double_t> {}; 	 
    class AliLHCDipValT<Int_t> {}; 	 
    class AliLHCDipValT<Float_t> {}; 	 
    class AliLHCDipValT<Char_t> {}; 	 
    class AliLHCData {};
    class AliLHCClockPhase {};

    class AliLTUConfig {};

    typedef AliLHCDipValD {}; 	 
    typedef AliLHCDipValI {}; 	 
    typedef AliLHCDipValF {}; 	 
    typedef AliLHCDipValC {};

/** @} */

/** @defgroup ESD ESD
 *  Category of AliRoot event sumary data classes
 *  @ingroup STEER
 *  @{
 */
// From ESDLinkDef.h 54829 2012-02-25 20:47:28Z morsch

    enum   AliESDEvent::ESDListIndex {};

    class  AliESD {};
    class  AliESDEvent {};
    class  AliESDInputHandler {};
    class  AliESDInputHandlerRP {};
    class  AliESDRun {};
    class  AliESDHeader {};
    class  AliESDHLTDecision {};
    class  AliESDZDC {};
    class  AliESDCaloTrigger {};
    class  AliESDfriend {};                                                                                                           
    class  AliESDtrack {};
    class  AliESDfriendTrack {};
    class  AliESDMuonTrack {};
    class  AliESDPmdTrack {};
    class  AliESDTrdTrigger {};
    class  AliESDTrdTrack {};
    class  AliESDTrdTracklet {};
    class  AliESDHLTtrack {};
    class  AliESDv0 {};
    class  AliESDcascade {};
    class  AliVertex {};
    class  AliESDVertex {};
    class  AliESDpid {};
    class  AliESDkink {};
    class  AliESDV0Params {};
    class  AliESDCaloCluster {};
    class  AliESDMuonCluster {};
    class  AliESDMuonPad {};

    class  AliKFParticleBase {};
    class  AliKFParticle {};
    class  AliKFVertex {};

    class  AliKalmanTrack {};
    class  AliVertexerTracks {};
    class  AliStrLine {};
    class  AliTrackPointArray {};
    class  AliTrackPoint {};

    class AliTrackPointArray {};
    class AliTrackPoint {};

    class  AliESDFMD {};
    class  AliFMDMap {};
    class  AliFMDFloatMap {};

    class  AliESDVZERO {};
    class  AliESDTZERO {};
    class  AliESDACORDE {};

    class  AliESDMultITS {};
    class  AliMultiplicity {};

    class  AliSelector {};

    class  AliRawDataErrorLog {};

    class  AliMeanVertex {};
    class  AliESDCaloCells {};

    class  AliESDVZEROfriend {};
    class  AliESDTZEROfriend {};

    class  AliESDHandler {};
    class  AliTrackerBase {};

    namespace AliESDUtils {};

    class  AliTriggerIR {};
    class  AliTriggerScalersESD {};
    class  AliTriggerScalersRecordESD {};
    class AliTriggerCluster {};
    class AliTriggerDescriptor {};
    class AliTriggerInput {};
    class AliTriggerInteraction {};
    class AliTriggerPFProtection {};
    class AliTriggerBCMask {};
    class AliTriggerClass {};
    class AliTriggerConfiguration {};
    class AliExpression {};
    class AliVariableExpression {};
    class AliESDCosmicTrack {};

    class  AliV0vertexer {};
    class  AliCascadeVertexer+ {};
    
/** @} */

/** @defgroup CDB CDB
 *  Category of AliRoot Conditions database classes
 *  @ingroup STEER
 *  @{
 */
// From CDBLinkDef.h 50616 2011-07-17 09:35:46Z hristov

    class AliCDBPath {};
    class AliCDBRunRange {};
    class AliCDBId {};
    class AliCDBMetaData {};
    class AliCDBEntry {};
    class AliCDBStorage {};
    class AliCDBStorageFactory {};
    class AliCDBManager {};
    class AliCDBParam {};
    class AliCDBLocal {};
    class AliCDBLocalFactory {};
    class AliCDBLocalParam {};
    class AliCDBDump {};
    class AliCDBDumpFactory {};
    class AliCDBDumpParam {}; 
    class AliCDBGrid {};
    class AliCDBGridFactory {};
    class AliCDBGridParam {};

    class AliDCSValue {};
    class AliDCSSensor {};
    class AliDCSSensorArray {};
    class AliDCSGenDB {};
    class  AliSplineFit {};

    class AliPreprocessor {};

    class AliShuttleInterface {};

    class AliGRPDCS {};
    class AliCDBHandler {};

    class  AliBaseCalibViewer {};
    class  AliBaseCalibViewerGUI {};
    class  AliCalibViewerGUItime {};

/** @} */

/** @defgroup AOD AOD
 *  Category of AliRoot AOD classes
 *  @ingroup STEER
 *  @{
 */
// From AODLinkDef.h 56945 2012-06-07 14:19:25Z fca

    enum   AliAODVertex::AODVtx_t {};
    enum   AliAODTrack::AODTrk_t {};
    enum   AliAODTrack::AODTrkPID_t {};

    class AliAODEvent {};
    class AliAODHeader {};
    class AliAODTrack {};
    class AliAODPid {};
    class AliAODVertex {};
    class AliAODCluster {};
    class AliAODCaloCluster {};
    class AliAODPmdCluster {};
    class AliAODFmdCluster {};
    class AliAODJet {};
    class AliAODJetEventBackground {};
    class AliAODPhoton {};
    class AliAODRedCov<3> {};
    class AliAODRedCov<4> {};
    class AliAODRedCov<6> {};
    class AliAODRecoDecay {};
    class AliAODv0 {};
    class AliAODcascade {};
    class AliAODHandler {};
    class AliAODExtension {};
    class AliAODBranchReplicator {};
    class AliAODInputHandler {};
    class AliAODTracklets {};
    class AliAODTagCreator {};
    class AliAODCaloCells {};
    class AliAODCaloTrigger {};
    class AliAODDiJet {};
    class AliAODMCParticle {};
    class AliAODMCHeader {};
    class AliAODPWG4Particle {};
    class AliAODPWG4ParticleCorrelation {};
    class AliAODDimuon {};
    class AliAODpidUtil {};
    class AliAODTZERO {};
    class AliAODVZERO {};
    class AliAODZDC {};

/** @} */

/** @} */
Commit	Line	Data
12628611	1	// $Id$
	2	// The class categories definitions for Doxygen
	3
	4	/** @defgroup STEER STEER
	5	* Category of AliRoot steering classes
	6	* @{
	7	*/
8169bb13	8
8bd49d3c	9	/** @defgroup STEERbase STEERbase
8169bb13	10	* Category of AliRoot steering classes
	11	* @ingroup STEER
	12	* @{
	13	*/
7c82dc6d	14	// From STEERBaseLinkDef.h 56494 2012-05-15 20:58:42Z morsch
8bd49d3c	15
7c82dc6d	16	enum AliLog::EType_t {};
51f8b997	17
8bd49d3c	18	class AliVParticle {};
c59ea36d	19	class AliVTrack {};
7c82dc6d	20	class AliVCluster {};
7c82dc6d	21	class AliVCaloCells {};
c59ea36d	22	class AliVVertex {};
8bd49d3c	23	class AliVEvent {};
	24	class AliVHeader {};
	25	class AliVEventHandler {};
c59ea36d	26	class AliVEventPool {};
00bd6b99	27	class AliVCuts {};
7c82dc6d	28	class AliVVZERO {};
	29	class AliVZDC {};
	30	class AliCentrality {};
	31	class AliEventplane {};
8bd49d3c	32
748b7435	33	class AliMixedEvent {};
748b7435	34
8bd49d3c	35	class AliPID {};
	36	class AliLog {};
	37
	38	class AliRunTag {};
	39	class AliLHCTag {};
	40	class AliDetectorTag {};
	41	class AliEventTag {};
7c82dc6d	42	class AliFileTag {};
7ca6fd03	43
8bd49d3c	44	class AliRunTagCuts {};
	45	class AliLHCTagCuts {};
	46	class AliDetectorTagCuts {};
	47	class AliEventTagCuts {};
	48
	49	class AliTagCreator {};
b1de9da0	50
b1de9da0	51	class AliHeader {};
b1de9da0	52	class AliGenEventHeader {};
8bd49d3c	53	class AliDetectorEventHeader {};
	54	class AliGenCocktailEventHeader {};
	55	class AliGenPythiaEventHeader {};
	56	class AliGenHijingEventHeader {};
b1de9da0	57	class AliCollisionGeometry {};
51f8b997	58	class AliGenDPMjetEventHeader {};
00bd6b99	59	class AliGenHerwigEventHeader {};
748b7435	60	class AliGenGeVSimEventHeader {};
77d07a56	61	class AliGenEposEventHeader {};
8bd49d3c	62	class AliStack {};
	63	class AliMCEventHandler {};
	64	class AliInputEventHandler {};
	65
	66	class AliTrackReference {};
	67	class AliSysInfo {};
	68
	69	class AliMCEvent {};
	70	class AliMCParticle {};
6614dfcc	71	class AliMCVertex {};
8bd49d3c	72
7c82dc6d	73	class AliMagF {};
	74	class AliMagWrapCheb {};
	75	class AliCheb3DCalc {};
	76	class AliCheb3D {};
c59ea36d	77
7c82dc6d	78	class AliNeutralTrackParam {};
8bd49d3c	79
51f8b997	80	class AliCodeTimer {};
	81	class AliCodeTimer::AliPair {};
	82
7c82dc6d	83	class AliPDG {};
51f8b997	84
	85	class AliTimeStamp {};
	86	class AliTriggerScalers {};
	87	class AliTriggerScalersRecord {};
7c82dc6d	88
7c82dc6d	89	class AliExternalTrackParam {};
934a7423	90	class AliQA {};
51f8b997	91
7c82dc6d	92	class AliTRDPIDReference {};
	93	class AliTRDPIDParams {};
	94	class AliTRDPIDParams::AliTRDPIDThresholds {};
00bd6b99	95	class AliITSPidParams {};
7c82dc6d	96	class AliPIDResponse {};
00bd6b99	97	class AliITSPIDResponse {};
00bd6b99	98	class AliTPCPIDResponse {};
7c82dc6d	99	class AliTPCdEdxInfo {};
00bd6b99	100	class AliTOFPIDResponse {};
aa3006a2	101	class AliTRDPIDResponse {};
7c82dc6d	102	class AliEMCALPIDResponse {};
	103	class AliPIDCombined {};
	104	class AliTOFHeader {};
aa3006a2	105
aa3006a2	106	class AliDAQ {};
7c82dc6d	107	class AliRefArray {};
	108
	109	class AliOADBContainer {};
	110
	111	class AliMathBase {};
	112	class TTreeDataElement {};
	113	class TTreeStream {};
	114	class TTreeSRedirector {};
	115
	116	class AliVMFT {};
	117	class AliCounterCollection {};
	118
	119	class AliVCaloTrigger {};
	120
	121	class AliTOFPIDParams {};
00bd6b99	122
8bd49d3c	123	/** @} */
	124
	125	/** @defgroup STEER0 STEER0
	126	* Category of AliRoot steering classes
	127	* @ingroup STEER
	128	* @{
	129	*/
7c82dc6d	130	// From STEERLinkDef.h 54207 2012-01-27 19:17:40Z hristov
8bd49d3c	131
	132	enum VertexSmear_t {};
	133	enum VertexSource_t {};
	134
8bd49d3c	135	class AliGenerator {};
	136	class AliVertexGenerator {};
	137	class AliRun {};
	138	class AliModule {};
	139	class AliDetector {};
	140	class AliDigit {};
	141	class AliHit {};
8bd49d3c	142	class AliLego {};
	143	class AliLegoGenerator {};
	144	class AliLegoGeneratorXYZ {};
	145	class AliLegoGeneratorPhiZ {};
	146	class AliLegoGeneratorEta {};
	147	class AliLegoGeneratorEtaR {};
	148	class AliDigitNew {};
	149	class AliGeometry {};
	150	class AliRecPoint {};
8bd49d3c	151	class AliHitMap {};
8bd49d3c	152	class AliRndm {};
8bd49d3c	153	class AliDebugVolume {};
	154	class AliConfig {};
	155	class AliDigitizer {};
f21fc003	156	class AliDigitizationInput {};
8bd49d3c	157	class AliStream {};
8bd49d3c	158	class AliMergeCombi {};
8bd49d3c	159	class AliGausCorr {};
	160	class AliLoader {};
	161	class AliDataLoader {};
	162	class AliBaseLoader {};
	163	class AliObjectLoader {};
	164	class AliTreeLoader {};
8bd49d3c	165	class AliRunLoader {};
8bd49d3c	166	class AliReconstructor {};
8bd49d3c	167	class AliMC {};
	168	class AliSimulation {};
	169	class AliReconstruction {};
7c82dc6d	170	class AliRecoInputHandler {};
8bd49d3c	171	class AliVertexGenFile {};
8bd49d3c	172	class AliVertexer {};
b1de9da0	173
7f1e3928	174	class AliTriggerDetector {};
7f1e3928	175	class AliCentralTrigger {};
7c82dc6d	176	class AliTriggerUtils {};
b1de9da0	177
4956a745	178	class AliGeomManager {};
b1de9da0	179	class AliAlignObj {};
90dbf5fb	180	class AliAlignObjParams {};
b1de9da0	181	class AliAlignObjMatrix {};
748b7435	182	class AliMisAligner {};
7f1e3928	183
b1de9da0	184	class AliTrackFitter {};
b1de9da0	185	class AliTrackFitterRieman {};
8169bb13	186	class AliTrackFitterKalman {};
7f1e3928	187	class AliTrackFitterStraight {};
b1de9da0	188	class AliTrackResiduals {};
b1de9da0	189	class AliTrackResidualsChi2 {};
7f1e3928	190	class AliTrackResidualsFast {};
3167d441	191	class AliTrackResidualsLinear {};
b1de9da0	192	class AliAlignmentTracks {};
b1de9da0	193
7c82dc6d	194	class AliRieman {};
7f1e3928	195
7f1e3928	196	class AliTriggerDetector {};
7f1e3928	197	class AliCentralTrigger {};
3167d441	198	class AliCTPRawStream {};
960f6e2a	199	class AliSignalProcesor {};
7ca6fd03	200	class AliHelix {};
7ca6fd03	201	class AliCluster {};
4956a745	202	class AliCluster3D {};
7ca6fd03	203	class AliTracker {};
7c82dc6d	204	class AliTrackleter {};
7ca6fd03	205	class AliV0 {};
	206	class AliKink {};
	207
	208	class AliSelectorRL {};
	209
8bd49d3c	210	class AliSurveyObj {};
8bd49d3c	211	class AliSurveyPoint {};
c59ea36d	212	class AliSurveyToAlignObjs {};
960f6e2a	213
8bd49d3c	214	class AliFstream {};
8bd49d3c	215	class AliCTPRawData {};
4956a745	216
8bd49d3c	217	class AliQADataMaker {};
51f8b997	218	class AliQADataMakerSim {};
51f8b997	219	class AliQADataMakerRec {};
c59ea36d	220	class AliCorrQADataMakerRec {};
8bd49d3c	221	class AliGlobalQADataMaker {};
60a46997	222	class AliQAManager {};
8bd49d3c	223	class AliQAChecker {};
c59ea36d	224	class AliCorrQAChecker {};
c59ea36d	225	class AliGlobalQAChecker {};
8bd49d3c	226	class AliQACheckerBase {};
7c82dc6d	227	class AliQAThresholds {};
8bd49d3c	228	class AliMillepede {};
4956a745	229
51f8b997	230	class AliPlaneEff {};
	231
	232	class AliTriggerRunScalers {};
	233	class AliGRPPreprocessor {};
c59ea36d	234	class AliGRPRecoParam {};
	235
	236	class AliRelAlignerKalman {};
	237
	238	class AliESDTagCreator {};
	239
	240	class AliGRPObject {};
	241
4e25ac79	242	class AliQAv1 {};
c59ea36d	243
	244	class AliRunInfo {};
	245	class AliEventInfo {};
	246	class AliDetectorRecoParam {};
	247	class AliRecoParam {};
	248
	249	class AliMillePede2 {};
	250	class AliMillePedeRecord {};
	251	class AliMinResSolve {};
	252	class AliMatrixSparse {};
934a7423	253	class AliVectorSparse {};
c59ea36d	254	class AliMatrixSq {};
c59ea36d	255	class AliSymMatrix {};
77d07a56	256	class AliSymBDMatrix {};
934a7423	257	class AliRectMatrix {};
77d07a56	258	class AliParamSolver {};
7f1e3928	259
934a7423	260	class AliGRPManager {};
7c82dc6d	261	class AliDCSArray {};
77d07a56	262	class AliLHCReader {};
	263	class AliCTPTimeParams {};
	264	class AliCTPInputTimeParams {};
00bd6b99	265
7c82dc6d	266	class AliLHCDipValT<Double_t> {};
	267	class AliLHCDipValT<Int_t> {};
	268	class AliLHCDipValT<Float_t> {};
	269	class AliLHCDipValT<Char_t> {};
00bd6b99	270	class AliLHCData {};
7c82dc6d	271	class AliLHCClockPhase {};
	272
	273	class AliLTUConfig {};
	274
	275	typedef AliLHCDipValD {};
	276	typedef AliLHCDipValI {};
	277	typedef AliLHCDipValF {};
	278	typedef AliLHCDipValC {};
00bd6b99	279
12628611	280	/** @} */
12628611	281
8169bb13	282	/** @defgroup ESD ESD
12628611	283	* Category of AliRoot event sumary data classes
8169bb13	284	* @ingroup STEER
12628611	285	* @{
12628611	286	*/
7c82dc6d	287	// From ESDLinkDef.h 54829 2012-02-25 20:47:28Z morsch
8bd49d3c	288
8bd49d3c	289	enum AliESDEvent::ESDListIndex {};
7ca6fd03	290
b1de9da0	291	class AliESD {};
8bd49d3c	292	class AliESDEvent {};
8bd49d3c	293	class AliESDInputHandler {};
51f8b997	294	class AliESDInputHandlerRP {};
4956a745	295	class AliESDRun {};
4956a745	296	class AliESDHeader {};
6614dfcc	297	class AliESDHLTDecision {};
4956a745	298	class AliESDZDC {};
4956a745	299	class AliESDCaloTrigger {};
7c82dc6d	300	class AliESDfriend {};
b1de9da0	301	class AliESDtrack {};
3167d441	302	class AliESDfriendTrack {};
b1de9da0	303	class AliESDMuonTrack {};
b1de9da0	304	class AliESDPmdTrack {};
7c82dc6d	305	class AliESDTrdTrigger {};
3167d441	306	class AliESDTrdTrack {};
7c82dc6d	307	class AliESDTrdTracklet {};
b1de9da0	308	class AliESDHLTtrack {};
	309	class AliESDv0 {};
	310	class AliESDcascade {};
3167d441	311	class AliVertex {};
960f6e2a	312	class AliESDVertex {};
b1de9da0	313	class AliESDpid {};
b1de9da0	314	class AliESDkink {};
960f6e2a	315	class AliESDV0Params {};
7f1e3928	316	class AliESDCaloCluster {};
8bd49d3c	317	class AliESDMuonCluster {};
51f8b997	318	class AliESDMuonPad {};
b1de9da0	319
4956a745	320	class AliKFParticleBase {};
	321	class AliKFParticle {};
	322	class AliKFVertex {};
	323
b1de9da0	324	class AliKalmanTrack {};
8169bb13	325	class AliVertexerTracks {};
8169bb13	326	class AliStrLine {};
7f1e3928	327	class AliTrackPointArray {};
	328	class AliTrackPoint {};
	329
7ca6fd03	330	class AliTrackPointArray {};
7ca6fd03	331	class AliTrackPoint {};
7f1e3928	332
	333	class AliESDFMD {};
	334	class AliFMDMap {};
	335	class AliFMDFloatMap {};
	336
7ca6fd03	337	class AliESDVZERO {};
4956a745	338	class AliESDTZERO {};
51f8b997	339	class AliESDACORDE {};
51f8b997	340
3167d441	341	class AliESDMultITS {};
960f6e2a	342	class AliMultiplicity {};
	343
	344	class AliSelector {};
3167d441	345
7ca6fd03	346	class AliRawDataErrorLog {};
7ca6fd03	347
8bd49d3c	348	class AliMeanVertex {};
	349	class AliESDCaloCells {};
	350
c59ea36d	351	class AliESDVZEROfriend {};
7c82dc6d	352	class AliESDTZEROfriend {};
c59ea36d	353
aa3006a2	354	class AliESDHandler {};
aa3006a2	355	class AliTrackerBase {};
7c82dc6d	356
	357	namespace AliESDUtils {};
	358
	359	class AliTriggerIR {};
	360	class AliTriggerScalersESD {};
	361	class AliTriggerScalersRecordESD {};
	362	class AliTriggerCluster {};
	363	class AliTriggerDescriptor {};
	364	class AliTriggerInput {};
	365	class AliTriggerInteraction {};
	366	class AliTriggerPFProtection {};
	367	class AliTriggerBCMask {};
	368	class AliTriggerClass {};
	369	class AliTriggerConfiguration {};
	370	class AliExpression {};
	371	class AliVariableExpression {};
	372	class AliESDCosmicTrack {};
	373
	374	class AliV0vertexer {};
	375	class AliCascadeVertexer+ {};
aa3006a2	376
12628611	377	/** @} */
960f6e2a	378
8169bb13	379	/** @defgroup CDB CDB
960f6e2a	380	* Category of AliRoot Conditions database classes
8169bb13	381	* @ingroup STEER
960f6e2a	382	* @{
960f6e2a	383	*/
7c82dc6d	384	// From CDBLinkDef.h 50616 2011-07-17 09:35:46Z hristov
960f6e2a	385
	386	class AliCDBPath {};
	387	class AliCDBRunRange {};
	388	class AliCDBId {};
	389	class AliCDBMetaData {};
	390	class AliCDBEntry {};
	391	class AliCDBStorage {};
	392	class AliCDBStorageFactory {};
	393	class AliCDBManager {};
	394	class AliCDBParam {};
	395	class AliCDBLocal {};
	396	class AliCDBLocalFactory {};
	397	class AliCDBLocalParam {};
	398	class AliCDBDump {};
	399	class AliCDBDumpFactory {};
	400	class AliCDBDumpParam {};
	401	class AliCDBGrid {};
	402	class AliCDBGridFactory {};
	403	class AliCDBGridParam {};
	404
8bd49d3c	405	class AliDCSValue {};
	406	class AliDCSSensor {};
	407	class AliDCSSensorArray {};
	408	class AliDCSGenDB {};
	409	class AliSplineFit {};
	410
960f6e2a	411	class AliPreprocessor {};
	412
	413	class AliShuttleInterface {};
	414
7ca6fd03	415	class AliGRPDCS {};
748b7435	416	class AliCDBHandler {};
7ca6fd03	417
7c82dc6d	418	class AliBaseCalibViewer {};
	419	class AliBaseCalibViewerGUI {};
	420	class AliCalibViewerGUItime {};
8bd49d3c	421
960f6e2a	422	/** @} */
960f6e2a	423
8169bb13	424	/** @defgroup AOD AOD
7ca6fd03	425	* Category of AliRoot AOD classes
8169bb13	426	* @ingroup STEER
7ca6fd03	427	* @{
7ca6fd03	428	*/
7c82dc6d	429	// From AODLinkDef.h 56945 2012-06-07 14:19:25Z fca
7ca6fd03	430
	431	enum AliAODVertex::AODVtx_t {};
	432	enum AliAODTrack::AODTrk_t {};
51f8b997	433	enum AliAODTrack::AODTrkPID_t {};
7ca6fd03	434
8bd49d3c	435	class AliAODEvent {};
	436	class AliAODHeader {};
	437	class AliAODTrack {};
	438	class AliAODPid {};
	439	class AliAODVertex {};
	440	class AliAODCluster {};
	441	class AliAODCaloCluster {};
	442	class AliAODPmdCluster {};
	443	class AliAODFmdCluster {};
	444	class AliAODJet {};
77d07a56	445	class AliAODJetEventBackground {};
8bd49d3c	446	class AliAODPhoton {};
	447	class AliAODRedCov<3> {};
	448	class AliAODRedCov<4> {};
	449	class AliAODRedCov<6> {};
	450	class AliAODRecoDecay {};
	451	class AliAODv0 {};
c59ea36d	452	class AliAODcascade {};
8bd49d3c	453	class AliAODHandler {};
748b7435	454	class AliAODExtension {};
7c82dc6d	455	class AliAODBranchReplicator {};
8bd49d3c	456	class AliAODInputHandler {};
	457	class AliAODTracklets {};
	458	class AliAODTagCreator {};
	459	class AliAODCaloCells {};
7c82dc6d	460	class AliAODCaloTrigger {};
51f8b997	461	class AliAODDiJet {};
c59ea36d	462	class AliAODMCParticle {};
c59ea36d	463	class AliAODMCHeader {};
6614dfcc	464	class AliAODPWG4Particle {};
6614dfcc	465	class AliAODPWG4ParticleCorrelation {};
aa3006a2	466	class AliAODDimuon {};
7c82dc6d	467	class AliAODpidUtil {};
	468	class AliAODTZERO {};
	469	class AliAODVZERO {};
	470	class AliAODZDC {};
8bd49d3c	471
8bd49d3c	472	/** @} */
7ca6fd03	473
7ca6fd03	474	/** @} */