[u/mrichter/AliRoot.git] / HLT / EMCAL / AliHLTEMCALTrackerComponent.cxx

/**************************************************************************
 * This file is property of and copyright by the ALICE HLT Project        * 
 * ALICE Experiment at CERN, All rights reserved.                         *
 *                                                                        *
 * Primary Authors: Matthias Richter <Matthias.Richter@ift.uib.no>        *
 *                  Timm Steinbeck <timm@kip.uni-heidelberg.de>           *
 *                  for The ALICE HLT Project.                            *
 *                                                                        *
 * Permission to use, copy, modify and distribute this software and its   *
 * documentation strictly for non-commercial purposes is hereby granted   *
 * without fee, provided that the above copyright notice appears in all   *
 * copies and that both the copyright notice and this permission notice   *
 * appear in the supporting documentation. The authors make no claims     *
 * about the suitability of this software for any purpose. It is          *
 * provided "as is" without express or implied warranty.                  *
 **************************************************************************/

/** @file   AliHLTEMCALTrackerComponent.cxx
    @author Mateusz Ploskon
    @date   
    @brief  EMCAL tracker component for HLT. */

#if __GNUC__== 3
using namespace std;
#endif

#include "AliHLTEMCALTrackerComponent.h"
#include "AliHLTEMCALDefinitions.h"
#include "AliHLTEMCALUtils.h"

#include "TString.h"
#include "TObjString.h"
#include "TObjArray.h"
#include "TTree.h"
#include "AliCDBEntry.h"
#include "AliCDBManager.h"
#include "AliRawReaderMemory.h"
#include "AliESDEvent.h"

// this is a global object used for automatic component registration, do not use this
AliHLTEMCALTrackerComponent gAliHLTEMCALTrackerComponent;

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

AliHLTEMCALTrackerComponent::AliHLTEMCALTrackerComponent()
  : AliHLTProcessor()
  , fOutputPercentage(100)
  , fStorageDBpath("local://$ALICE_ROOT/OCDB")
  , fCDB(NULL)
  , fGeometryFileName("")
{
  // see header file for class documentation
  // or
  // refer to README to build package
  // or
  // visit http://web.ift.uib.no/~kjeks/doc/alice-hlt
}

AliHLTEMCALTrackerComponent::AliHLTEMCALTrackerComponent(const AliHLTEMCALTrackerComponent &/*c*/)
  : AliHLTProcessor()
  , fOutputPercentage(100)
  , fStorageDBpath("local://$ALICE_ROOT/OCDB")
  , fCDB(NULL)
  , fGeometryFileName("")
{
  // may not use the copy contructor
  HLTError("May not use.");
}

AliHLTEMCALTrackerComponent& AliHLTEMCALTrackerComponent::operator=(const AliHLTEMCALTrackerComponent&)
{
  // may not use the copy contructor
  HLTError("May not use.");
  return *this;
}

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

AliHLTComponentDataType AliHLTEMCALTrackerComponent::GetOutputDataType()
{
  //return AliHLTEMCALDefinitions::fgkClusterDataType | AliHLTEMCALDefinitions::fgkDigitDataType;
  return AliHLTEMCALDefinitions::fgkClusterDataType;
}

const char* AliHLTEMCALTrackerComponent::GetComponentID()
{ 
  return "EMCALTracker";
}

void AliHLTEMCALTrackerComponent::GetInputDataTypes( vector<AliHLTComponentDataType>& list) 
{
  list.push_back(kAliHLTAnyDataType);
}

void AliHLTEMCALTrackerComponent::GetOutputDataSize( unsigned long& constBase, double& inputMultiplier ) 
{
  constBase = 0;
  inputMultiplier = ((double)fOutputPercentage)/100.0;
}

int AliHLTEMCALTrackerComponent::DoInit( int argc, const char** argv )
{
  // see header file for class documentation
  int iResult=0;
  HLTInfo("parsing %d arguments", argc);

  TString argument="";
  TString configuration=""; 
  int bMissingParam=0;
  bool bHaveMandatory1=false;
  bool bHaveMandatory2=false;

  char *cpErr = 0;

  for (int i=0; i<argc && iResult>=0; i++) 
    {
      argument=argv[i];
      if (argument.IsNull()) continue;

    // -mandatory1
    if (argument.CompareTo("-cdb")==0) 
      {
	bHaveMandatory1|=1;
	if ((bMissingParam=(++i>=argc))) break;
	HLTInfo("got \'-cdb\' argument: %s", argv[i]);
	fStorageDBpath = argv[i];
	HLTInfo("CDB path is: %s", fStorageDBpath.c_str());
	// -mandatory2
      } 
    else if (argument.CompareTo("-geometry")==0) 
      {
	bHaveMandatory2|=1;
	if ((bMissingParam=(++i>=argc))) break;
	HLTInfo("got \'-geometry\' argument");
	fGeometryFileName = argv[i];
	HLTInfo("Geometry file is: %s", fGeometryFileName.c_str());
	// -optional1
      } 
    else if (argument.CompareTo("-output_percentage")==0) 
      {
	if ((bMissingParam=(++i>=argc))) break;
	HLTInfo("got \'-output_percentage\' argument: %s", argv[i]);
	fOutputPercentage = strtoul(argv[i], &cpErr, 0);
	if ( *cpErr )
	  {
	    HLTError("Unable to convert ouput_percentage to a number %s", argv[i]);
	    return -EINVAL;
	  }
      } 
    else 
      {
	// the remaining arguments are treated as configuration
	if (!configuration.IsNull()) configuration+=" ";
	configuration+=argument;
      }
    }

  if (bMissingParam) 
    {
      HLTError("missing parameter for argument %s", argument.Data());
      iResult=-EINVAL;
    }

  if (iResult>=0 && !bHaveMandatory1) 
    {
      HLTError("mandatory argument \'-cdb\' missing");
      iResult=-EPROTO;
    }

  if (iResult>=0 && !bHaveMandatory2) 
    {
      HLTError("mandatory argument \'-geometry\' missing");
      iResult=-EPROTO;
    }
  
  if (iResult>=0 && !configuration.IsNull()) 
    {
      iResult=Configure(configuration.Data());
    } 
  else 
    {
      iResult=Reconfigure(NULL, NULL);
    }
  
  // Initialize here
  // raw reader

  // geometry
  if (AliHLTEMCALUtils::GetGeometry() == NULL)
    {
      HLTError("unable to init geometry");
      iResult=-EPROTO;      
    }

  // OCDB

  // tracker and raw utils
  if (AliHLTEMCALUtils::GetRawUtils() == NULL)
    {
      HLTError("unable to init rawutils");
      iResult=-EPROTO;      
    }

  if (AliHLTEMCALUtils::GetRawUtils() == NULL)
    {
      HLTError("unable to init rawutils");
      iResult=-EPROTO;      
    }

  if (AliHLTEMCALUtils::GetRecParam() == NULL)
    {
      HLTError("unable to init reco params");
      iResult=-EPROTO;      
    }      

  return iResult;
}

int AliHLTEMCALTrackerComponent::DoDeinit()
{
  // see header file for class documentation
  AliHLTEMCALUtils::Cleanup();
  HLTInfo("processing cleanup");
  return 0;
}

int AliHLTEMCALTrackerComponent::DoEvent( const AliHLTComponentEventData & /*evtData*/,
					  AliHLTComponentTriggerData & /*trigData*/ )
{
  //
  // see header file for class documentation
  //

  // check if the input data are there at all - empty events possible
  
  HLTDebug("HLT::TRDTracker::DoEvent", "BLOCKS", "NofBlocks %lu", GetNumberOfInputBlocks() );

  //implement a usage of the following
  //   AliHLTUInt32_t triggerDataStructSize = trigData.fStructSize;
  //   AliHLTUInt32_t triggerDataSize = trigData.fDataSize;
  //   void *triggerData = trigData.fData;
  //HLTDebug("Struct size %d Data size %d Data location 0x%x", trigData.fStructSize, trigData.fDataSize, (UInt_t*)trigData.fData);

  //   another way to check the blocks
  //   AliHLTComponentBlockData *dblock = (AliHLTComponentBlockData *)GetFirstInputBlock( AliHLTEMCALDefinitions::fgkClusterDataType );
  //   if (dblock == 0)
  //     {
  //       HLTError(Form("First Input Block not found! 0x%x", dblock));
  //       return -1;
  //     }

  // all those should be received by the component
  AliESDEvent *esd = 0; // we assume we receive this one from a global merger component
  TTree *clustersTree = 0;
  TTree *digitsTree = 0;

  Int_t ibForce = 0;
  TObject  *tobjin = 0;
  tobjin = (TObject *)GetFirstInputObject( AliHLTEMCALDefinitions::fgkClusterDataType, "TTree", ibForce);
  if (tobjin)
    {
      clustersTree = (TTree*)tobjin;
    }

  tobjin = (TObject *)GetFirstInputObject( AliHLTEMCALDefinitions::fgkDigitDataType, "TTree", ibForce);
  if (tobjin)
    {
      digitsTree = (TTree*)tobjin;
    }

  // the data type used here is a prototype
  // esd eventually should come from TPC alone or TPC+TRD matched tracks
  // check the AliHLTEMCALDefinitions for extra comments
  tobjin = (TObject *)GetFirstInputObject( AliHLTEMCALDefinitions::fgkESDDataType, "TTree", ibForce);
  if (tobjin)
    {
      esd = (AliESDEvent*)tobjin;
    }

  if (digitsTree != 0 && clustersTree != 0 && esd != 0)
    {
      Bool_t retValue = AliHLTEMCALUtils::FillESD(digitsTree, clustersTree, esd);
      
      if (retValue == kTRUE)
	{
	  PushBack(esd, AliHLTEMCALDefinitions::fgkEMCALESDDataType);
	}
      else
	{
	  HLTWarning("Fill ESD failed.");
	}
    }
  
  if (clustersTree)
    delete clustersTree;

  if (digitsTree)
    delete digitsTree;
  
  if (esd)
    delete esd;

  return 0;
}

int AliHLTEMCALTrackerComponent::Configure(const char* arguments)
{
  // see header file for class documentation
  int iResult=0;
  if (!arguments) return iResult;
  HLTInfo("parsing configuration string \'%s\'", arguments);

  TString allArgs = arguments;
  TString argument;
  int bMissingParam=0;

  TObjArray* pTokens = allArgs.Tokenize(" ");
  if (pTokens) 
    {
      for (int i=0; i<pTokens->GetEntries() && iResult>=0; i++) 
	{
	  argument=((TObjString*)pTokens->At(i))->GetString();
	  if (argument.IsNull()) continue;
	  HLTInfo("processing argument %\n", argument.Data());
	  // -config1
	  if (argument.CompareTo("-cdb")==0) 
	    {
	      if ((bMissingParam=(++i>=pTokens->GetEntries()))) break;
	      HLTInfo("got \'-cdb\': %s", ((TObjString*)pTokens->At(i))->GetString().Data());	      
	      // -config2
	    } 
	  else if (argument.CompareTo("-geometry")==0) 
	    {
	      if ((bMissingParam=(++i>=pTokens->GetEntries()))) break;
	      HLTInfo("got \'-geometry\'");
	    } 
	  else if (argument.CompareTo("-output_percentage")==0) 
	    {
	      if ((bMissingParam=(++i>=pTokens->GetEntries()))) break;
	      HLTInfo("got \'-output_percentage\'");
	    } 
	  else 
	    {
	      HLTError("unknown argument %s", argument.Data());
	      iResult=-EINVAL;
	      break;
	    }
	}
      delete pTokens;
    }

  if (bMissingParam) 
    {
      HLTError("missing parameter for argument %s", argument.Data());
      iResult=-EINVAL;
    }

  return iResult;
}

int AliHLTEMCALTrackerComponent::Reconfigure(const char* cdbEntry, const char* chainId)
{
  // see header file for class documentation
  int iResult=0;
  const char* path="HLT/ConfigEMCAL/EMCALTrackerComponent";
  const char* defaultNotify="";
  if (cdbEntry) 
    {
      path=cdbEntry;
      defaultNotify=" (default)";
    }
  if (path) 
    {
      HLTInfo("reconfigure from entry %s%s, chain id %s", path, defaultNotify,(chainId!=NULL && chainId[0]!=0)?chainId:"<none>");
      AliCDBEntry *pEntry = AliCDBManager::Instance()->Get(path/*,GetRunNo()*/);
      if (pEntry) 
	{
	  TObjString* pString=dynamic_cast<TObjString*>(pEntry->GetObject());
	  if (pString) 
	    {
	      HLTInfo("received configuration object string: \'%s\'", pString->GetString().Data());
	      iResult=Configure(pString->GetString().Data());
	    } else 
	    {
	      HLTError("configuration object \"%s\" has wrong type, required TObjString", path);
	    }
	} 
      else 
	{
	  HLTError("can not fetch object \"%s\" from CDB", path);
	}
    }
  return iResult;
}

int AliHLTEMCALTrackerComponent::ReadPreprocessorValues(const char* modules)
{
  // see header file for class documentation
  int iResult=0;
  TString detectors(modules!=NULL?modules:"");
  HLTInfo("read preprocessor values for detector(s): %s", detectors.IsNull()?"none":detectors.Data());
  return iResult;
}
Commit	Line	Data
	1	/**************************************************************************
	2	* This file is property of and copyright by the ALICE HLT Project *
	3	* ALICE Experiment at CERN, All rights reserved. *
	4	* *
	5	* Primary Authors: Matthias Richter <Matthias.Richter@ift.uib.no> *
	6	* Timm Steinbeck <timm@kip.uni-heidelberg.de> *
	7	* for The ALICE HLT Project. *
	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 *
	14	* about the suitability of this software for any purpose. It is *
	15	* provided "as is" without express or implied warranty. *
	16	**************************************************************************/
	17
	18	/** @file AliHLTEMCALTrackerComponent.cxx
	19	@author Mateusz Ploskon
	20	@date
	21	@brief EMCAL tracker component for HLT. */
	22
	23	#if __GNUC__== 3
	24	using namespace std;
	25	#endif
	26
	27	#include "AliHLTEMCALTrackerComponent.h"
	28	#include "AliHLTEMCALDefinitions.h"
	29	#include "AliHLTEMCALUtils.h"
	30
	31	#include "TString.h"
	32	#include "TObjString.h"
	33	#include "TObjArray.h"
	34	#include "TTree.h"
	35	#include "AliCDBEntry.h"
	36	#include "AliCDBManager.h"
	37	#include "AliRawReaderMemory.h"
	38	#include "AliESDEvent.h"
	39
	40	// this is a global object used for automatic component registration, do not use this
	41	AliHLTEMCALTrackerComponent gAliHLTEMCALTrackerComponent;
	42
	43	/** ROOT macro for the implementation of ROOT specific class methods */
	44	ClassImp(AliHLTEMCALTrackerComponent)
	45
	46	AliHLTEMCALTrackerComponent::AliHLTEMCALTrackerComponent()
	47	: AliHLTProcessor()
	48	, fOutputPercentage(100)
	49	, fStorageDBpath("local://$ALICE_ROOT/OCDB")
	50	, fCDB(NULL)
	51	, fGeometryFileName("")
	52	{
	53	// see header file for class documentation
	54	// or
	55	// refer to README to build package
	56	// or
	57	// visit http://web.ift.uib.no/~kjeks/doc/alice-hlt
	58	}
	59
	60	AliHLTEMCALTrackerComponent::AliHLTEMCALTrackerComponent(const AliHLTEMCALTrackerComponent &/c/)
	61	: AliHLTProcessor()
	62	, fOutputPercentage(100)
	63	, fStorageDBpath("local://$ALICE_ROOT/OCDB")
	64	, fCDB(NULL)
	65	, fGeometryFileName("")
	66	{
	67	// may not use the copy contructor
	68	HLTError("May not use.");
	69	}
	70
	71	AliHLTEMCALTrackerComponent& AliHLTEMCALTrackerComponent::operator=(const AliHLTEMCALTrackerComponent&)
	72	{
	73	// may not use the copy contructor
	74	HLTError("May not use.");
	75	return *this;
	76	}
	77
	78	AliHLTEMCALTrackerComponent::~AliHLTEMCALTrackerComponent()
	79	{
	80	// see header file for class documentation
	81	}
	82
	83	AliHLTComponentDataType AliHLTEMCALTrackerComponent::GetOutputDataType()
	84	{
	85	//return AliHLTEMCALDefinitions::fgkClusterDataType \| AliHLTEMCALDefinitions::fgkDigitDataType;
	86	return AliHLTEMCALDefinitions::fgkClusterDataType;
	87	}
	88
	89	const char* AliHLTEMCALTrackerComponent::GetComponentID()
	90	{
	91	return "EMCALTracker";
	92	}
	93
	94	void AliHLTEMCALTrackerComponent::GetInputDataTypes( vector<AliHLTComponentDataType>& list)
	95	{
	96	list.push_back(kAliHLTAnyDataType);
	97	}
	98
	99	void AliHLTEMCALTrackerComponent::GetOutputDataSize( unsigned long& constBase, double& inputMultiplier )
	100	{
	101	constBase = 0;
	102	inputMultiplier = ((double)fOutputPercentage)/100.0;
	103	}
	104
	105	int AliHLTEMCALTrackerComponent::DoInit( int argc, const char** argv )
	106	{
	107	// see header file for class documentation
	108	int iResult=0;
	109	HLTInfo("parsing %d arguments", argc);
	110
	111	TString argument="";
	112	TString configuration="";
	113	int bMissingParam=0;
	114	bool bHaveMandatory1=false;
	115	bool bHaveMandatory2=false;
	116
	117	char *cpErr = 0;
	118
	119	for (int i=0; i<argc && iResult>=0; i++)
	120	{
	121	argument=argv[i];
	122	if (argument.IsNull()) continue;
	123
	124	// -mandatory1
	125	if (argument.CompareTo("-cdb")==0)
	126	{
	127	bHaveMandatory1\|=1;
	128	if ((bMissingParam=(++i>=argc))) break;
	129	HLTInfo("got \'-cdb\' argument: %s", argv[i]);
	130	fStorageDBpath = argv[i];
	131	HLTInfo("CDB path is: %s", fStorageDBpath.c_str());
	132	// -mandatory2
	133	}
	134	else if (argument.CompareTo("-geometry")==0)
	135	{
	136	bHaveMandatory2\|=1;
	137	if ((bMissingParam=(++i>=argc))) break;
	138	HLTInfo("got \'-geometry\' argument");
	139	fGeometryFileName = argv[i];
	140	HLTInfo("Geometry file is: %s", fGeometryFileName.c_str());
	141	// -optional1
	142	}
	143	else if (argument.CompareTo("-output_percentage")==0)
	144	{
	145	if ((bMissingParam=(++i>=argc))) break;
	146	HLTInfo("got \'-output_percentage\' argument: %s", argv[i]);
	147	fOutputPercentage = strtoul(argv[i], &cpErr, 0);
	148	if ( *cpErr )
	149	{
	150	HLTError("Unable to convert ouput_percentage to a number %s", argv[i]);
	151	return -EINVAL;
	152	}
	153	}
	154	else
	155	{
	156	// the remaining arguments are treated as configuration
	157	if (!configuration.IsNull()) configuration+=" ";
	158	configuration+=argument;
	159	}
	160	}
	161
	162	if (bMissingParam)
	163	{
	164	HLTError("missing parameter for argument %s", argument.Data());
	165	iResult=-EINVAL;
	166	}
	167
	168	if (iResult>=0 && !bHaveMandatory1)
	169	{
	170	HLTError("mandatory argument \'-cdb\' missing");
	171	iResult=-EPROTO;
	172	}
	173
	174	if (iResult>=0 && !bHaveMandatory2)
	175	{
	176	HLTError("mandatory argument \'-geometry\' missing");
	177	iResult=-EPROTO;
	178	}
	179
	180	if (iResult>=0 && !configuration.IsNull())
	181	{
	182	iResult=Configure(configuration.Data());
	183	}
	184	else
	185	{
	186	iResult=Reconfigure(NULL, NULL);
	187	}
	188
	189	// Initialize here
	190	// raw reader
	191
	192	// geometry
	193	if (AliHLTEMCALUtils::GetGeometry() == NULL)
	194	{
	195	HLTError("unable to init geometry");
	196	iResult=-EPROTO;
	197	}
	198
	199	// OCDB
	200
	201	// tracker and raw utils
	202	if (AliHLTEMCALUtils::GetRawUtils() == NULL)
	203	{
	204	HLTError("unable to init rawutils");
	205	iResult=-EPROTO;
	206	}
	207
	208	if (AliHLTEMCALUtils::GetRawUtils() == NULL)
	209	{
	210	HLTError("unable to init rawutils");
	211	iResult=-EPROTO;
	212	}
	213
	214	if (AliHLTEMCALUtils::GetRecParam() == NULL)
	215	{
	216	HLTError("unable to init reco params");
	217	iResult=-EPROTO;
	218	}
	219
	220	return iResult;
	221	}
	222
	223	int AliHLTEMCALTrackerComponent::DoDeinit()
	224	{
	225	// see header file for class documentation
	226	AliHLTEMCALUtils::Cleanup();
	227	HLTInfo("processing cleanup");
	228	return 0;
	229	}
	230
	231	int AliHLTEMCALTrackerComponent::DoEvent( const AliHLTComponentEventData & /evtData/,
	232	AliHLTComponentTriggerData & /trigData/ )
	233	{
	234	//
	235	// see header file for class documentation
	236	//
	237
	238	// check if the input data are there at all - empty events possible
	239
	240	HLTDebug("HLT::TRDTracker::DoEvent", "BLOCKS", "NofBlocks %lu", GetNumberOfInputBlocks() );
	241
	242	//implement a usage of the following
	243	// AliHLTUInt32_t triggerDataStructSize = trigData.fStructSize;
	244	// AliHLTUInt32_t triggerDataSize = trigData.fDataSize;
	245	// void *triggerData = trigData.fData;
	246	//HLTDebug("Struct size %d Data size %d Data location 0x%x", trigData.fStructSize, trigData.fDataSize, (UInt_t*)trigData.fData);
	247
	248	// another way to check the blocks
	249	// AliHLTComponentBlockData dblock = (AliHLTComponentBlockData )GetFirstInputBlock( AliHLTEMCALDefinitions::fgkClusterDataType );
	250	// if (dblock == 0)
	251	// {
	252	// HLTError(Form("First Input Block not found! 0x%x", dblock));
	253	// return -1;
	254	// }
	255
	256	// all those should be received by the component
	257	AliESDEvent *esd = 0; // we assume we receive this one from a global merger component
	258	TTree *clustersTree = 0;
	259	TTree *digitsTree = 0;
	260
	261	Int_t ibForce = 0;
	262	TObject *tobjin = 0;
	263	tobjin = (TObject *)GetFirstInputObject( AliHLTEMCALDefinitions::fgkClusterDataType, "TTree", ibForce);
	264	if (tobjin)
	265	{
	266	clustersTree = (TTree*)tobjin;
	267	}
	268
	269	tobjin = (TObject *)GetFirstInputObject( AliHLTEMCALDefinitions::fgkDigitDataType, "TTree", ibForce);
	270	if (tobjin)
	271	{
	272	digitsTree = (TTree*)tobjin;
	273	}
	274
	275	// the data type used here is a prototype
	276	// esd eventually should come from TPC alone or TPC+TRD matched tracks
	277	// check the AliHLTEMCALDefinitions for extra comments
	278	tobjin = (TObject *)GetFirstInputObject( AliHLTEMCALDefinitions::fgkESDDataType, "TTree", ibForce);
	279	if (tobjin)
	280	{
	281	esd = (AliESDEvent*)tobjin;
	282	}
	283
	284	if (digitsTree != 0 && clustersTree != 0 && esd != 0)
	285	{
	286	Bool_t retValue = AliHLTEMCALUtils::FillESD(digitsTree, clustersTree, esd);
	287
	288	if (retValue == kTRUE)
	289	{
	290	PushBack(esd, AliHLTEMCALDefinitions::fgkEMCALESDDataType);
	291	}
	292	else
	293	{
	294	HLTWarning("Fill ESD failed.");
	295	}
	296	}
	297
	298	if (clustersTree)
	299	delete clustersTree;
	300
	301	if (digitsTree)
	302	delete digitsTree;
	303
	304	if (esd)
	305	delete esd;
	306
	307	return 0;
	308	}
	309
	310	int AliHLTEMCALTrackerComponent::Configure(const char* arguments)
	311	{
	312	// see header file for class documentation
	313	int iResult=0;
	314	if (!arguments) return iResult;
	315	HLTInfo("parsing configuration string \'%s\'", arguments);
	316
	317	TString allArgs = arguments;
	318	TString argument;
	319	int bMissingParam=0;
	320
	321	TObjArray* pTokens = allArgs.Tokenize(" ");
	322	if (pTokens)
	323	{
	324	for (int i=0; i<pTokens->GetEntries() && iResult>=0; i++)
	325	{
	326	argument=((TObjString*)pTokens->At(i))->GetString();
	327	if (argument.IsNull()) continue;
	328	HLTInfo("processing argument %\n", argument.Data());
	329	// -config1
	330	if (argument.CompareTo("-cdb")==0)
	331	{
	332	if ((bMissingParam=(++i>=pTokens->GetEntries()))) break;
	333	HLTInfo("got \'-cdb\': %s", ((TObjString*)pTokens->At(i))->GetString().Data());
	334	// -config2
	335	}
	336	else if (argument.CompareTo("-geometry")==0)
	337	{
	338	if ((bMissingParam=(++i>=pTokens->GetEntries()))) break;
	339	HLTInfo("got \'-geometry\'");
	340	}
	341	else if (argument.CompareTo("-output_percentage")==0)
	342	{
	343	if ((bMissingParam=(++i>=pTokens->GetEntries()))) break;
	344	HLTInfo("got \'-output_percentage\'");
	345	}
	346	else
	347	{
	348	HLTError("unknown argument %s", argument.Data());
	349	iResult=-EINVAL;
	350	break;
	351	}
	352	}
	353	delete pTokens;
	354	}
	355
	356	if (bMissingParam)
	357	{
	358	HLTError("missing parameter for argument %s", argument.Data());
	359	iResult=-EINVAL;
	360	}
	361
	362	return iResult;
	363	}
	364
	365	int AliHLTEMCALTrackerComponent::Reconfigure(const char* cdbEntry, const char* chainId)
	366	{
	367	// see header file for class documentation
	368	int iResult=0;
	369	const char* path="HLT/ConfigEMCAL/EMCALTrackerComponent";
	370	const char* defaultNotify="";
	371	if (cdbEntry)
	372	{
	373	path=cdbEntry;
	374	defaultNotify=" (default)";
	375	}
	376	if (path)
	377	{
	378	HLTInfo("reconfigure from entry %s%s, chain id %s", path, defaultNotify,(chainId!=NULL && chainId[0]!=0)?chainId:"<none>");
	379	AliCDBEntry pEntry = AliCDBManager::Instance()->Get(path/,GetRunNo()*/);
	380	if (pEntry)
	381	{
	382	TObjString* pString=dynamic_cast<TObjString*>(pEntry->GetObject());
	383	if (pString)
	384	{
	385	HLTInfo("received configuration object string: \'%s\'", pString->GetString().Data());
	386	iResult=Configure(pString->GetString().Data());
	387	} else
	388	{
	389	HLTError("configuration object \"%s\" has wrong type, required TObjString", path);
	390	}
	391	}
	392	else
	393	{
	394	HLTError("can not fetch object \"%s\" from CDB", path);
	395	}
	396	}
	397	return iResult;
	398	}
	399
	400	int AliHLTEMCALTrackerComponent::ReadPreprocessorValues(const char* modules)
	401	{
	402	// see header file for class documentation
	403	int iResult=0;
	404	TString detectors(modules!=NULL?modules:"");
	405	HLTInfo("read preprocessor values for detector(s): %s", detectors.IsNull()?"none":detectors.Data());
	406	return iResult;
	407	}