[u/mrichter/AliRoot.git] / HLT / MUON / OfflineInterface / AliHLTMUONAgent.cxx

/**************************************************************************
 * Copyright(c) 1998-2007, ALICE Experiment at CERN, All rights reserved. *
 *                                                                        *
 * Author: The ALICE Off-line Project.                                    *
 * Contributors are mentioned in the code where appropriate.              *
 *                                                                        *
 * 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   AliHLTMUONAgent.cxx
/// @author Artur Szostak <artursz@iafrica.com>
/// @date   28 May 2007
/// @brief  Implementation of the AliHLTMUONAgent class.
///

#include "AliHLTMUONAgent.h"
#include "AliHLTMUONConstants.h"
#include "AliHLTMUONRecHitsSource.h"
#include "AliHLTMUONTriggerRecordsSource.h"
#include "AliHLTMUONDigitPublisherComponent.h"
#include "AliHLTMUONRootifierComponent.h"
#include "AliHLTMUONHitReconstructorComponent.h"
#include "AliHLTMUONTriggerReconstructorComponent.h"
#include "AliHLTMUONMansoTrackerFSMComponent.h"
#include "AliHLTMUONDecisionComponent.h"
#include "AliHLTMUONEmptyEventFilterComponent.h"
#include "AliHLTMUONDataCheckerComponent.h"
#include "AliRawReader.h"
#include "AliRunLoader.h"
#include "TSystem.h"
#include "TString.h"

// The single global instance of the dimuon HLT agent.
AliHLTMUONAgent AliHLTMUONAgent::fgkInstance;

ClassImp(AliHLTMUONAgent);


AliHLTMUONAgent::AliHLTMUONAgent() : AliHLTModuleAgent("MUON")
{
	///
	/// Default constructor.
	///
}

AliHLTMUONAgent::~AliHLTMUONAgent()
{
	///
	/// Default destructor.
	///
}

const char* AliHLTMUONAgent::GetReconstructionChains(AliRawReader* rawReader,
						     AliRunLoader* runloader
	) const
{
	///
	/// Inherited from AliHLTModuleAgent.
	/// Returns the top processing chain configurations for local event
	/// reconstruction.
	/// @param rawReader  [in] AliRoot rawreader instance.
	/// @param runloader  [in] AliRoot runloader
	/// @return string containing the top configurations separated by blanks.
	///
	/// If rawReader is not NULL then the standard dHLT chain is run taking
	/// data from raw DDL data. Otherwise runloader is checked and if it is
	/// not NULL then a dHLT chain is run with input data from digits.
	
	if (rawReader != NULL)
	{
		// Check if there is any data from the tracker and trigger.
		bool dataFromTracker = false;
		bool dataFromTrigger = false;
		rawReader->Select("MUONTRK", 0, 19);
		for (Int_t i = 0; i < 20; i++)
		{
			if (rawReader->ReadHeader()) dataFromTracker = true;
		}
		rawReader->Select("MUONTRG", 0, 1);
		for (Int_t i = 0; i < 2; i++)
		{
			if (rawReader->ReadHeader()) dataFromTrigger = true;
		}
		rawReader->RewindEvents();
		
		// If raw data was found for our detector then select the
		// appropriate chain.
		if (dataFromTracker and dataFromTrigger)
			return "dHLT-sim-fromRaw";
	}
	
	if (runloader != NULL)
	{
		if (runloader->GetLoader("MUONLoader") != NULL)
			return "dHLT-sim";
	}
	
	return "";
}

const char* AliHLTMUONAgent::GetRequiredComponentLibraries() const
{
	///
	/// Inherited from AliHLTModuleAgent.
	/// Returns a list of libraries which the configurations registered by
	/// this module agent depend on.
	/// @return list of component libraries as a blank-separated string.
	///
	
	// List of libraries that we depend on.
	static const char* libs[] =
	{
		"libCore.so",
		"libCint.so",
		"libGraf.so",
		"libRIO.so",
		"libNet.so",
		"libHist.so",
		"libMatrix.so",
		"libMathCore.so",
		"libMinuit.so",
		"libTree.so",
		"libGraf3d.so",
		"libGpad.so",
		"libPhysics.so",
		"libGui.so",
		"libProofPlayer.so",
		"libProof.so",
		"libThread.so",
		"libGeom.so",
		"libEG.so",
		"libTreePlayer.so",
		"libXMLIO.so",
		"libVMC.so",
		"libESD.so",
		"libCDB.so",
		"libSTEERBase.so",
		"libSTEER.so",
		"libGui.so",
		"libRAWDatasim.so",
		"libRAWDatarec.so",
		"libRAWDatabase.so",
		"libMUONcore.so",
		"libMUONraw.so",
		"libMUONbase.so",
		"libMUONgeometry.so",
		"libMUONmapping.so",
		"libMUONcalib.so",
		"libMUONsim.so",
		"libMUONtrigger.so",
		"libMUONevaluation.so",
		"libMUONrec.so",
		"libHLTbase.so",
		"libAliHLTUtil.so",
		NULL
	};
	
	// First check if the library is not already loaded. If it is then we have
	// no reason to declare it as needed, so that we do not load it again.
	static TString result;
	for (const char** lib = libs; *lib != NULL; lib++)
	{
		const char* list = gSystem->GetLibraries(*lib, "", kFALSE);
		if (list == NULL) continue;
		// Check if not found, i.e. result was an empty string.
		// If so then add the library to the required list.
		if (list[0] == '\0')
		{
			result += *lib;
			result += " ";
		}
	}
	return result.Data();
}


int AliHLTMUONAgent::CreateConfigurations(
		AliHLTConfigurationHandler* handler,
		AliRawReader* rawReader,
		AliRunLoader* runloader
	) const
{
	/// Register all processing configurations belonging to the dimuon HLT
	/// library with the AliHLTConfigurationHandler.
	/// @param handler      the configuration handler
	/// @param rawReader  [in] AliRoot rawreader instance.
	/// @param runloader    AliRoot runloader
	/// @return Zero on success and error code if failed.
	///
	/// Chains available:
	/// dHLT-sim          - standard dHLT simulation chain.
	/// dHLT-sim-fromRaw  - standard dHLT chain taking raw DDL data as input.
	/// dHLT-sim-fromMC   - dHLT chain taking Monte Carlo hit data as input.
	///                     So hit reconstruction is not checked, just the tracker.
	
	if (handler == NULL) return 0;
	
	const char* trackerId = AliHLTMUONConstants::MansoTrackerFSMId();
	const char* decCompId = AliHLTMUONConstants::DecisionComponentId();
	
	if (rawReader != NULL)
	{
		// Implement the dHLT-sim-fromRaw dHLT simulation chain reading
		// from raw data.
		const char* rawPubComp = "AliRawReaderPublisher";
		const char* cmd13 = "-minid 2572 -datatype 'DDL_RAW ' 'MUON' -dataspec 0x001000";
		const char* cmd14 = "-minid 2573 -datatype 'DDL_RAW ' 'MUON' -dataspec 0x002000";
		const char* cmd15 = "-minid 2574 -datatype 'DDL_RAW ' 'MUON' -dataspec 0x004000";
		const char* cmd16 = "-minid 2575 -datatype 'DDL_RAW ' 'MUON' -dataspec 0x008000";
		const char* cmd17 = "-minid 2576 -datatype 'DDL_RAW ' 'MUON' -dataspec 0x010000";
		const char* cmd18 = "-minid 2577 -datatype 'DDL_RAW ' 'MUON' -dataspec 0x020000";
		const char* cmd19 = "-minid 2578 -datatype 'DDL_RAW ' 'MUON' -dataspec 0x040000";
		const char* cmd20 = "-minid 2579 -datatype 'DDL_RAW ' 'MUON' -dataspec 0x080000";
		const char* cmd21 = "-minid 2816 -datatype 'DDL_RAW ' 'MUON' -dataspec 0x100000";
		const char* cmd22 = "-minid 2817 -datatype 'DDL_RAW ' 'MUON' -dataspec 0x200000";
		handler->CreateConfiguration("RawDDL13", rawPubComp, NULL, cmd13);
		handler->CreateConfiguration("RawDDL14", rawPubComp, NULL, cmd14);
		handler->CreateConfiguration("RawDDL15", rawPubComp, NULL, cmd15);
		handler->CreateConfiguration("RawDDL16", rawPubComp, NULL, cmd16);
		handler->CreateConfiguration("RawDDL17", rawPubComp, NULL, cmd17);
		handler->CreateConfiguration("RawDDL18", rawPubComp, NULL, cmd18);
		handler->CreateConfiguration("RawDDL19", rawPubComp, NULL, cmd19);
		handler->CreateConfiguration("RawDDL20", rawPubComp, NULL, cmd20);
		handler->CreateConfiguration("RawDDL21", rawPubComp, NULL, cmd21);
		handler->CreateConfiguration("RawDDL22", rawPubComp, NULL, cmd22);
		const char* hrId = AliHLTMUONConstants::HitReconstructorId();
		const char* trId = AliHLTMUONConstants::TriggerReconstructorId();
		handler->CreateConfiguration("RecoRawDDL13", hrId, "RawDDL13", "-ddl 13 -cdb");
		handler->CreateConfiguration("RecoRawDDL14", hrId, "RawDDL14", "-ddl 14 -cdb");
		handler->CreateConfiguration("RecoRawDDL15", hrId, "RawDDL15", "-ddl 15 -cdb");
		handler->CreateConfiguration("RecoRawDDL16", hrId, "RawDDL16", "-ddl 16 -cdb");
		handler->CreateConfiguration("RecoRawDDL17", hrId, "RawDDL17", "-ddl 17 -cdb");
		handler->CreateConfiguration("RecoRawDDL18", hrId, "RawDDL18", "-ddl 18 -cdb");
		handler->CreateConfiguration("RecoRawDDL19", hrId, "RawDDL19", "-ddl 19 -cdb");
		handler->CreateConfiguration("RecoRawDDL20", hrId, "RawDDL20", "-ddl 20 -cdb");
		handler->CreateConfiguration("RecoRawDDL21", trId, "RawDDL21", "-ddl 21 -cdb -suppress_partial_triggers");
		handler->CreateConfiguration("RecoRawDDL22", trId, "RawDDL22", "-ddl 22 -cdb -suppress_partial_triggers");
		
		const char* recoSrcs = "RecoRawDDL13 RecoRawDDL14 RecoRawDDL15 RecoRawDDL16 RecoRawDDL17"
			" RecoRawDDL18 RecoRawDDL19 RecoRawDDL20 RecoRawDDL21 RecoRawDDL22";
		handler->CreateConfiguration("MansoTrackerForRaw", trackerId, recoSrcs, "");
		
		handler->CreateConfiguration("dHLT-sim-fromRaw", decCompId, "MansoTrackerForRaw", "");
	}
	
	if (runloader != NULL)
	{
		// Implement the dHLT-sim dHLT simulation chain reading from
		// simulated digits.
		const char* digitPub = AliHLTMUONConstants::DigitPublisherId();
		handler->CreateConfiguration("DigitDDL13", digitPub, NULL, "-simdata -ddl 13");
		handler->CreateConfiguration("DigitDDL14", digitPub, NULL, "-simdata -ddl 14");
		handler->CreateConfiguration("DigitDDL15", digitPub, NULL, "-simdata -ddl 15");
		handler->CreateConfiguration("DigitDDL16", digitPub, NULL, "-simdata -ddl 16");
		handler->CreateConfiguration("DigitDDL17", digitPub, NULL, "-simdata -ddl 17");
		handler->CreateConfiguration("DigitDDL18", digitPub, NULL, "-simdata -ddl 18");
		handler->CreateConfiguration("DigitDDL19", digitPub, NULL, "-simdata -ddl 19");
		handler->CreateConfiguration("DigitDDL20", digitPub, NULL, "-simdata -ddl 20");
		handler->CreateConfiguration("DigitDDL21", digitPub, NULL, "-simdata -ddl 21");
		handler->CreateConfiguration("DigitDDL22", digitPub, NULL, "-simdata -ddl 22");
		const char* hrId = AliHLTMUONConstants::HitReconstructorId();
		const char* trId = AliHLTMUONConstants::TriggerReconstructorId();
		handler->CreateConfiguration("RecoDDL13", hrId, "DigitDDL13", "-ddl 13 -cdb");
		handler->CreateConfiguration("RecoDDL14", hrId, "DigitDDL14", "-ddl 14 -cdb");
		handler->CreateConfiguration("RecoDDL15", hrId, "DigitDDL15", "-ddl 15 -cdb");
		handler->CreateConfiguration("RecoDDL16", hrId, "DigitDDL16", "-ddl 16 -cdb");
		handler->CreateConfiguration("RecoDDL17", hrId, "DigitDDL17", "-ddl 17 -cdb");
		handler->CreateConfiguration("RecoDDL18", hrId, "DigitDDL18", "-ddl 18 -cdb");
		handler->CreateConfiguration("RecoDDL19", hrId, "DigitDDL19", "-ddl 19 -cdb");
		handler->CreateConfiguration("RecoDDL20", hrId, "DigitDDL20", "-ddl 20 -cdb");
		handler->CreateConfiguration("RecoDDL21", trId, "DigitDDL21", "-ddl 21 -cdb -suppress_partial_triggers");
		handler->CreateConfiguration("RecoDDL22", trId, "DigitDDL22", "-ddl 22 -cdb -suppress_partial_triggers");
		
		const char* recoSrcs = "RecoDDL13 RecoDDL14 RecoDDL15 RecoDDL16 RecoDDL17"
			" RecoDDL18 RecoDDL19 RecoDDL20 RecoDDL21 RecoDDL22";
		handler->CreateConfiguration("MansoTracker", trackerId, recoSrcs, "");
		
		handler->CreateConfiguration("dHLT-sim", decCompId, "MansoTracker", "");
	
		// Implement the dHLT-sim-fromMC dHLT simulation chain reading
		// Monte Carlo geant hits and putting those into a tracker component.
		const char* rhsId = AliHLTMUONConstants::RecHitsSourceId();
		const char* trsId = AliHLTMUONConstants::TriggerRecordsSourceId();
		handler->CreateConfiguration("HitsDDL13", rhsId, NULL, "-simdata -plane left  -chamber 7");
		handler->CreateConfiguration("HitsDDL14", rhsId, NULL, "-simdata -plane right -chamber 7");
		handler->CreateConfiguration("HitsDDL15", rhsId, NULL, "-simdata -plane left  -chamber 8");
		handler->CreateConfiguration("HitsDDL16", rhsId, NULL, "-simdata -plane right -chamber 8");
		handler->CreateConfiguration("HitsDDL17", rhsId, NULL, "-simdata -plane left  -chamber 9");
		handler->CreateConfiguration("HitsDDL18", rhsId, NULL, "-simdata -plane right -chamber 9");
		handler->CreateConfiguration("HitsDDL19", rhsId, NULL, "-simdata -plane left  -chamber 10");
		handler->CreateConfiguration("HitsDDL20", rhsId, NULL, "-simdata -plane right -chamber 10");
		handler->CreateConfiguration("TrigRecsDDL21", trsId, NULL, "-hitdata -plane left");
		handler->CreateConfiguration("TrigRecsDDL22", trsId, NULL, "-hitdata -plane right");
		
		const char* dataSrcs = "HitsDDL13 HitsDDL14 HitsDDL15 HitsDDL16 HitsDDL17"
			" HitsDDL18 HitsDDL19 HitsDDL20 TrigRecsDDL21 TrigRecsDDL22";
		handler->CreateConfiguration("MansoTrackerForMC", trackerId, dataSrcs, "");
		
		handler->CreateConfiguration("dHLT-sim-fromMC", decCompId, "MansoTrackerForMC", "");
	}
	
	return 0;
}


int AliHLTMUONAgent::RegisterComponents(AliHLTComponentHandler* pHandler) const
{
	///
	/// Registers all available components of this module.
	/// @param pHandler  [in] instance of the component handler.
	///
	
	if (pHandler == NULL) return -EINVAL;
	pHandler->AddComponent(new AliHLTMUONRecHitsSource);
	pHandler->AddComponent(new AliHLTMUONTriggerRecordsSource);
	pHandler->AddComponent(new AliHLTMUONDigitPublisherComponent);
	pHandler->AddComponent(new AliHLTMUONRootifierComponent);
	pHandler->AddComponent(new AliHLTMUONHitReconstructorComponent);
	pHandler->AddComponent(new AliHLTMUONTriggerReconstructorComponent);
	pHandler->AddComponent(new AliHLTMUONMansoTrackerFSMComponent);
	pHandler->AddComponent(new AliHLTMUONDecisionComponent);
	pHandler->AddComponent(new AliHLTMUONEmptyEventFilterComponent);
	pHandler->AddComponent(new AliHLTMUONDataCheckerComponent);
	return 0;
}
Commit	Line	Data
d1ff7c16	1	/**************************************************************************
	2	* Copyright(c) 1998-2007, ALICE Experiment at CERN, All rights reserved. *
	3	* *
	4	* Author: The ALICE Off-line Project. *
	5	* Contributors are mentioned in the code where appropriate. *
	6	* *
	7	* Permission to use, copy, modify and distribute this software and its *
	8	* documentation strictly for non-commercial purposes is hereby granted *
	9	* without fee, provided that the above copyright notice appears in all *
	10	* copies and that both the copyright notice and this permission notice *
	11	* appear in the supporting documentation. The authors make no claims *
	12	* about the suitability of this software for any purpose. It is *
	13	* provided "as is" without express or implied warranty. *
	14	**************************************************************************/
	15
	16	/* $Id$ */
	17
6253e09b	18	///
	19	/// @file AliHLTMUONAgent.cxx
	20	/// @author Artur Szostak <artursz@iafrica.com>
887a669c	21	/// @date 28 May 2007
6253e09b	22	/// @brief Implementation of the AliHLTMUONAgent class.
6253e09b	23	///
d1ff7c16	24
d1ff7c16	25	#include "AliHLTMUONAgent.h"
887a669c	26	#include "AliHLTMUONConstants.h"
6253e09b	27	#include "AliHLTMUONRecHitsSource.h"
6253e09b	28	#include "AliHLTMUONTriggerRecordsSource.h"
887a669c	29	#include "AliHLTMUONDigitPublisherComponent.h"
6253e09b	30	#include "AliHLTMUONRootifierComponent.h"
	31	#include "AliHLTMUONHitReconstructorComponent.h"
	32	#include "AliHLTMUONTriggerReconstructorComponent.h"
	33	#include "AliHLTMUONMansoTrackerFSMComponent.h"
c9537879	34	#include "AliHLTMUONDecisionComponent.h"
0528e93a	35	#include "AliHLTMUONEmptyEventFilterComponent.h"
dba14d7d	36	#include "AliHLTMUONDataCheckerComponent.h"
352670bf	37	#include "AliRawReader.h"
d1ff7c16	38	#include "AliRunLoader.h"
887a669c	39	#include "TSystem.h"
887a669c	40	#include "TString.h"
d1ff7c16	41
6253e09b	42	// The single global instance of the dimuon HLT agent.
6253e09b	43	AliHLTMUONAgent AliHLTMUONAgent::fgkInstance;
d1ff7c16	44
	45	ClassImp(AliHLTMUONAgent);
	46
	47
626bfcc1	48	AliHLTMUONAgent::AliHLTMUONAgent() : AliHLTModuleAgent("MUON")
d1ff7c16	49	{
6253e09b	50	///
	51	/// Default constructor.
	52	///
d1ff7c16	53	}
	54
	55	AliHLTMUONAgent::~AliHLTMUONAgent()
	56	{
6253e09b	57	///
	58	/// Default destructor.
	59	///
d1ff7c16	60	}
d1ff7c16	61
887a669c	62	const char* AliHLTMUONAgent::GetReconstructionChains(AliRawReader* rawReader,
887a669c	63	AliRunLoader* runloader
d1ff7c16	64	) const
d1ff7c16	65	{
6253e09b	66	///
	67	/// Inherited from AliHLTModuleAgent.
	68	/// Returns the top processing chain configurations for local event
	69	/// reconstruction.
	70	/// @param rawReader [in] AliRoot rawreader instance.
	71	/// @param runloader [in] AliRoot runloader
	72	/// @return string containing the top configurations separated by blanks.
	73	///
887a669c	74	/// If rawReader is not NULL then the standard dHLT chain is run taking
	75	/// data from raw DDL data. Otherwise runloader is checked and if it is
	76	/// not NULL then a dHLT chain is run with input data from digits.
6253e09b	77
887a669c	78	if (rawReader != NULL)
887a669c	79	{
352670bf	80	// Check if there is any data from the tracker and trigger.
	81	bool dataFromTracker = false;
	82	bool dataFromTrigger = false;
	83	rawReader->Select("MUONTRK", 0, 19);
	84	for (Int_t i = 0; i < 20; i++)
	85	{
	86	if (rawReader->ReadHeader()) dataFromTracker = true;
	87	}
	88	rawReader->Select("MUONTRG", 0, 1);
	89	for (Int_t i = 0; i < 2; i++)
	90	{
	91	if (rawReader->ReadHeader()) dataFromTrigger = true;
	92	}
	93	rawReader->RewindEvents();
	94
	95	// If raw data was found for our detector then select the
	96	// appropriate chain.
	97	if (dataFromTracker and dataFromTrigger)
	98	return "dHLT-sim-fromRaw";
887a669c	99	}
352670bf	100
352670bf	101	if (runloader != NULL)
887a669c	102	{
352670bf	103	if (runloader->GetLoader("MUONLoader") != NULL)
352670bf	104	return "dHLT-sim";
887a669c	105	}
352670bf	106
352670bf	107	return "";
d1ff7c16	108	}
	109
	110	const char* AliHLTMUONAgent::GetRequiredComponentLibraries() const
	111	{
6253e09b	112	///
	113	/// Inherited from AliHLTModuleAgent.
	114	/// Returns a list of libraries which the configurations registered by
	115	/// this module agent depend on.
	116	/// @return list of component libraries as a blank-separated string.
	117	///
	118
887a669c	119	// List of libraries that we depend on.
	120	static const char* libs[] =
	121	{
	122	"libCore.so",
	123	"libCint.so",
	124	"libGraf.so",
	125	"libRIO.so",
	126	"libNet.so",
	127	"libHist.so",
	128	"libMatrix.so",
	129	"libMathCore.so",
	130	"libMinuit.so",
	131	"libTree.so",
	132	"libGraf3d.so",
	133	"libGpad.so",
	134	"libPhysics.so",
	135	"libGui.so",
	136	"libProofPlayer.so",
	137	"libProof.so",
	138	"libThread.so",
	139	"libGeom.so",
887a669c	140	"libEG.so",
	141	"libTreePlayer.so",
	142	"libXMLIO.so",
	143	"libVMC.so",
	144	"libESD.so",
	145	"libCDB.so",
	146	"libSTEERBase.so",
	147	"libSTEER.so",
	148	"libGui.so",
	149	"libRAWDatasim.so",
	150	"libRAWDatarec.so",
	151	"libRAWDatabase.so",
	152	"libMUONcore.so",
	153	"libMUONraw.so",
	154	"libMUONbase.so",
	155	"libMUONgeometry.so",
	156	"libMUONmapping.so",
	157	"libMUONcalib.so",
	158	"libMUONsim.so",
	159	"libMUONtrigger.so",
	160	"libMUONevaluation.so",
	161	"libMUONrec.so",
	162	"libHLTbase.so",
	163	"libAliHLTUtil.so",
	164	NULL
	165	};
	166
	167	// First check if the library is not already loaded. If it is then we have
	168	// no reason to declare it as needed, so that we do not load it again.
	169	static TString result;
	170	for (const char** lib = libs; *lib != NULL; lib++)
	171	{
	172	const char* list = gSystem->GetLibraries(*lib, "", kFALSE);
	173	if (list == NULL) continue;
	174	// Check if not found, i.e. result was an empty string.
	175	// If so then add the library to the required list.
	176	if (list[0] == '\0')
	177	{
	178	result += *lib;
	179	result += " ";
	180	}
	181	}
	182	return result.Data();
d1ff7c16	183	}
	184
	185
	186	int AliHLTMUONAgent::CreateConfigurations(
	187	AliHLTConfigurationHandler* handler,
887a669c	188	AliRawReader* rawReader,
887a669c	189	AliRunLoader* runloader
d1ff7c16	190	) const
d1ff7c16	191	{
6253e09b	192	/// Register all processing configurations belonging to the dimuon HLT
	193	/// library with the AliHLTConfigurationHandler.
	194	/// @param handler the configuration handler
	195	/// @param rawReader [in] AliRoot rawreader instance.
	196	/// @param runloader AliRoot runloader
	197	/// @return Zero on success and error code if failed.
	198	///
887a669c	199	/// Chains available:
	200	/// dHLT-sim - standard dHLT simulation chain.
	201	/// dHLT-sim-fromRaw - standard dHLT chain taking raw DDL data as input.
	202	/// dHLT-sim-fromMC - dHLT chain taking Monte Carlo hit data as input.
	203	/// So hit reconstruction is not checked, just the tracker.
6253e09b	204
d1ff7c16	205	if (handler == NULL) return 0;
887a669c	206
	207	const char* trackerId = AliHLTMUONConstants::MansoTrackerFSMId();
	208	const char* decCompId = AliHLTMUONConstants::DecisionComponentId();
	209
	210	if (rawReader != NULL)
	211	{
	212	// Implement the dHLT-sim-fromRaw dHLT simulation chain reading
	213	// from raw data.
	214	const char* rawPubComp = "AliRawReaderPublisher";
	215	const char* cmd13 = "-minid 2572 -datatype 'DDL_RAW ' 'MUON' -dataspec 0x001000";
	216	const char* cmd14 = "-minid 2573 -datatype 'DDL_RAW ' 'MUON' -dataspec 0x002000";
	217	const char* cmd15 = "-minid 2574 -datatype 'DDL_RAW ' 'MUON' -dataspec 0x004000";
	218	const char* cmd16 = "-minid 2575 -datatype 'DDL_RAW ' 'MUON' -dataspec 0x008000";
	219	const char* cmd17 = "-minid 2576 -datatype 'DDL_RAW ' 'MUON' -dataspec 0x010000";
	220	const char* cmd18 = "-minid 2577 -datatype 'DDL_RAW ' 'MUON' -dataspec 0x020000";
	221	const char* cmd19 = "-minid 2578 -datatype 'DDL_RAW ' 'MUON' -dataspec 0x040000";
	222	const char* cmd20 = "-minid 2579 -datatype 'DDL_RAW ' 'MUON' -dataspec 0x080000";
	223	const char* cmd21 = "-minid 2816 -datatype 'DDL_RAW ' 'MUON' -dataspec 0x100000";
	224	const char* cmd22 = "-minid 2817 -datatype 'DDL_RAW ' 'MUON' -dataspec 0x200000";
	225	handler->CreateConfiguration("RawDDL13", rawPubComp, NULL, cmd13);
	226	handler->CreateConfiguration("RawDDL14", rawPubComp, NULL, cmd14);
	227	handler->CreateConfiguration("RawDDL15", rawPubComp, NULL, cmd15);
	228	handler->CreateConfiguration("RawDDL16", rawPubComp, NULL, cmd16);
	229	handler->CreateConfiguration("RawDDL17", rawPubComp, NULL, cmd17);
	230	handler->CreateConfiguration("RawDDL18", rawPubComp, NULL, cmd18);
	231	handler->CreateConfiguration("RawDDL19", rawPubComp, NULL, cmd19);
	232	handler->CreateConfiguration("RawDDL20", rawPubComp, NULL, cmd20);
	233	handler->CreateConfiguration("RawDDL21", rawPubComp, NULL, cmd21);
	234	handler->CreateConfiguration("RawDDL22", rawPubComp, NULL, cmd22);
	235	const char* hrId = AliHLTMUONConstants::HitReconstructorId();
	236	const char* trId = AliHLTMUONConstants::TriggerReconstructorId();
	237	handler->CreateConfiguration("RecoRawDDL13", hrId, "RawDDL13", "-ddl 13 -cdb");
	238	handler->CreateConfiguration("RecoRawDDL14", hrId, "RawDDL14", "-ddl 14 -cdb");
	239	handler->CreateConfiguration("RecoRawDDL15", hrId, "RawDDL15", "-ddl 15 -cdb");
	240	handler->CreateConfiguration("RecoRawDDL16", hrId, "RawDDL16", "-ddl 16 -cdb");
	241	handler->CreateConfiguration("RecoRawDDL17", hrId, "RawDDL17", "-ddl 17 -cdb");
	242	handler->CreateConfiguration("RecoRawDDL18", hrId, "RawDDL18", "-ddl 18 -cdb");
	243	handler->CreateConfiguration("RecoRawDDL19", hrId, "RawDDL19", "-ddl 19 -cdb");
	244	handler->CreateConfiguration("RecoRawDDL20", hrId, "RawDDL20", "-ddl 20 -cdb");
	245	handler->CreateConfiguration("RecoRawDDL21", trId, "RawDDL21", "-ddl 21 -cdb -suppress_partial_triggers");
	246	handler->CreateConfiguration("RecoRawDDL22", trId, "RawDDL22", "-ddl 22 -cdb -suppress_partial_triggers");
	247
	248	const char* recoSrcs = "RecoRawDDL13 RecoRawDDL14 RecoRawDDL15 RecoRawDDL16 RecoRawDDL17"
	249	" RecoRawDDL18 RecoRawDDL19 RecoRawDDL20 RecoRawDDL21 RecoRawDDL22";
	250	handler->CreateConfiguration("MansoTrackerForRaw", trackerId, recoSrcs, "");
	251
	252	handler->CreateConfiguration("dHLT-sim-fromRaw", decCompId, "MansoTrackerForRaw", "");
	253	}
	254
	255	if (runloader != NULL)
	256	{
	257	// Implement the dHLT-sim dHLT simulation chain reading from
	258	// simulated digits.
	259	const char* digitPub = AliHLTMUONConstants::DigitPublisherId();
	260	handler->CreateConfiguration("DigitDDL13", digitPub, NULL, "-simdata -ddl 13");
	261	handler->CreateConfiguration("DigitDDL14", digitPub, NULL, "-simdata -ddl 14");
	262	handler->CreateConfiguration("DigitDDL15", digitPub, NULL, "-simdata -ddl 15");
	263	handler->CreateConfiguration("DigitDDL16", digitPub, NULL, "-simdata -ddl 16");
	264	handler->CreateConfiguration("DigitDDL17", digitPub, NULL, "-simdata -ddl 17");
	265	handler->CreateConfiguration("DigitDDL18", digitPub, NULL, "-simdata -ddl 18");
	266	handler->CreateConfiguration("DigitDDL19", digitPub, NULL, "-simdata -ddl 19");
	267	handler->CreateConfiguration("DigitDDL20", digitPub, NULL, "-simdata -ddl 20");
	268	handler->CreateConfiguration("DigitDDL21", digitPub, NULL, "-simdata -ddl 21");
	269	handler->CreateConfiguration("DigitDDL22", digitPub, NULL, "-simdata -ddl 22");
270	const char* hrId = AliHLTMUONConstants::HitReconstructorId();
271	const char* trId = AliHLTMUONConstants::TriggerReconstructorId();
272	handler->CreateConfiguration("RecoDDL13", hrId, "DigitDDL13", "-ddl 13 -cdb");
273	handler->CreateConfiguration("RecoDDL14", hrId, "DigitDDL14", "-ddl 14 -cdb");
274	handler->CreateConfiguration("RecoDDL15", hrId, "DigitDDL15", "-ddl 15 -cdb");
275	handler->CreateConfiguration("RecoDDL16", hrId, "DigitDDL16", "-ddl 16 -cdb");
276	handler->CreateConfiguration("RecoDDL17", hrId, "DigitDDL17", "-ddl 17 -cdb");
277	handler->CreateConfiguration("RecoDDL18", hrId, "DigitDDL18", "-ddl 18 -cdb");
278	handler->CreateConfiguration("RecoDDL19", hrId, "DigitDDL19", "-ddl 19 -cdb");
279	handler->CreateConfiguration("RecoDDL20", hrId, "DigitDDL20", "-ddl 20 -cdb");
280	handler->CreateConfiguration("RecoDDL21", trId, "DigitDDL21", "-ddl 21 -cdb -suppress_partial_triggers");
281	handler->CreateConfiguration("RecoDDL22", trId, "DigitDDL22", "-ddl 22 -cdb -suppress_partial_triggers");
282
283	const char* recoSrcs = "RecoDDL13 RecoDDL14 RecoDDL15 RecoDDL16 RecoDDL17"
284	" RecoDDL18 RecoDDL19 RecoDDL20 RecoDDL21 RecoDDL22";
285	handler->CreateConfiguration("MansoTracker", trackerId, recoSrcs, "");
286
287	handler->CreateConfiguration("dHLT-sim", decCompId, "MansoTracker", "");
288
289	// Implement the dHLT-sim-fromMC dHLT simulation chain reading
290	// Monte Carlo geant hits and putting those into a tracker component.
291	const char* rhsId = AliHLTMUONConstants::RecHitsSourceId();
292	const char* trsId = AliHLTMUONConstants::TriggerRecordsSourceId();
293	handler->CreateConfiguration("HitsDDL13", rhsId, NULL, "-simdata -plane left -chamber 7");
294	handler->CreateConfiguration("HitsDDL14", rhsId, NULL, "-simdata -plane right -chamber 7");
295	handler->CreateConfiguration("HitsDDL15", rhsId, NULL, "-simdata -plane left -chamber 8");
296	handler->CreateConfiguration("HitsDDL16", rhsId, NULL, "-simdata -plane right -chamber 8");
297	handler->CreateConfiguration("HitsDDL17", rhsId, NULL, "-simdata -plane left -chamber 9");
298	handler->CreateConfiguration("HitsDDL18", rhsId, NULL, "-simdata -plane right -chamber 9");
299	handler->CreateConfiguration("HitsDDL19", rhsId, NULL, "-simdata -plane left -chamber 10");
300	handler->CreateConfiguration("HitsDDL20", rhsId, NULL, "-simdata -plane right -chamber 10");
301	handler->CreateConfiguration("TrigRecsDDL21", trsId, NULL, "-hitdata -plane left");
302	handler->CreateConfiguration("TrigRecsDDL22", trsId, NULL, "-hitdata -plane right");
303
304	const char* dataSrcs = "HitsDDL13 HitsDDL14 HitsDDL15 HitsDDL16 HitsDDL17"
305	" HitsDDL18 HitsDDL19 HitsDDL20 TrigRecsDDL21 TrigRecsDDL22";
306	handler->CreateConfiguration("MansoTrackerForMC", trackerId, dataSrcs, "");
307
308	handler->CreateConfiguration("dHLT-sim-fromMC", decCompId, "MansoTrackerForMC", "");
309	}
310
d1ff7c16	311	return 0;
d1ff7c16	312	}
6253e09b	313
	314
	315	int AliHLTMUONAgent::RegisterComponents(AliHLTComponentHandler* pHandler) const
	316	{
	317	///
	318	/// Registers all available components of this module.
	319	/// @param pHandler [in] instance of the component handler.
	320	///
	321
	322	if (pHandler == NULL) return -EINVAL;
	323	pHandler->AddComponent(new AliHLTMUONRecHitsSource);
	324	pHandler->AddComponent(new AliHLTMUONTriggerRecordsSource);
887a669c	325	pHandler->AddComponent(new AliHLTMUONDigitPublisherComponent);
6253e09b	326	pHandler->AddComponent(new AliHLTMUONRootifierComponent);
	327	pHandler->AddComponent(new AliHLTMUONHitReconstructorComponent);
	328	pHandler->AddComponent(new AliHLTMUONTriggerReconstructorComponent);
	329	pHandler->AddComponent(new AliHLTMUONMansoTrackerFSMComponent);
c9537879	330	pHandler->AddComponent(new AliHLTMUONDecisionComponent);
0528e93a	331	pHandler->AddComponent(new AliHLTMUONEmptyEventFilterComponent);
dba14d7d	332	pHandler->AddComponent(new AliHLTMUONDataCheckerComponent);
6253e09b	333	return 0;
	334	}
	335