[u/mrichter/AliRoot.git] / STEER / STEER / AliHLTSimulation.cxx

// $Id$

//**************************************************************************
//* 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>        *
//*                  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   AliHLTSimulation.cxx
    @author Matthias Richter
    @date   
    @brief  Binding class for HLT simulation in AliRoot. */

#include <cassert>
#include <cerrno>
#include "TObjArray.h"
#include "TObjString.h"
#include "AliHLTSimulation.h"
#include "AliSimulation.h"
#include "AliLog.h"
#include "AliRun.h"
#include "AliRunLoader.h"
#include "AliHeader.h"
#include "AliCDBManager.h"
#include "AliCDBEntry.h"
#include "AliCDBPath.h"
#include "AliCDBId.h"
#include "AliCDBMetaData.h"
#include "AliCDBStorage.h"
#include "AliGRPObject.h"
#include "AliGRPManager.h"
#include "AliHLTSystem.h"
#include "AliHLTConfigurationHandler.h"
#include "AliHLTPluginBase.h"
#include "AliRawReaderFile.h"
#include "AliRawReaderDate.h"
#include "AliRawReaderRoot.h"
#include "AliESDEvent.h"
#include "AliHLTOUTComponent.h"
#include "AliTracker.h"
#include "TGeoGlobalMagField.h"
#include "TSystem.h"
#include "TMath.h"
#include "TGeoGlobalMagField.h"

#if ALIHLTSIMULATION_LIBRARY_VERSION != LIBHLTSIM_VERSION
#error library version in header file and lib*.pkg do not match
#endif

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

AliHLTSimulation::AliHLTSimulation()
  : fOptions()
  , fpPluginBase(new AliHLTPluginBase)
  , fpRawReader(NULL)
  , fNEvents(-1)
{
  // see header file for class documentation
  // or
  // refer to README to build package
  // or
  // visit http://web.ift.uib.no/~kjeks/doc/alice-hlt
}

AliHLTSimulation::~AliHLTSimulation()
{
  // see header file for function documentation
  if (fpPluginBase) delete fpPluginBase;
  fpPluginBase=NULL;

  if (fpRawReader) {
    delete fpRawReader;
  }
  fpRawReader=NULL;
}

AliHLTSimulation* AliHLTSimulation::CreateInstance()
{
  // see header file for function documentation
  return new AliHLTSimulation;
}

int AliHLTSimulation::DeleteInstance(AliHLTSimulation* pSim)
{
  // see header file for function documentation
  assert(pSim!=NULL);
  delete pSim;
  return 0;
}

int AliHLTSimulation::Init(AliRunLoader* pRunLoader, const char* options)
{
  // init the simulation
  fOptions=options;
  TString sysOp;

  if(!fpPluginBase) {
    AliError("internal initialization failed");
    return -EINVAL;
  }

  AliHLTSystem* pSystem=fpPluginBase->GetInstance();
  if (!pSystem) {
    AliError("can not get AliHLTSystem instance");
    return -ENOMEM;
  }
  if (pSystem->CheckStatus(AliHLTSystem::kError)) {
    AliError("HLT system in error state");
    return -EFAULT;
  }

  // scan options for specific entries
  TObjArray* pTokens=fOptions.Tokenize(" ");
  if (pTokens) {
    int iEntries=pTokens->GetEntries();
    for (int i=0; i<iEntries; i++) {
      TString token=(((TObjString*)pTokens->At(i))->GetString());
      if (token.Contains("rawfile=")) {
	TString param=token.ReplaceAll("rawfile=", "");
	if (param.EndsWith("/")) {
	  AliInfo(Form("creating AliRawReaderFile (%s)", param.Data()));
	  fpRawReader = new AliRawReaderFile(param);
	} else if (param.EndsWith(".root")) {
	  AliInfo(Form("creating AliRawReaderRoot (%s)", param.Data()));
	  fpRawReader = new AliRawReaderRoot(param);
	} else if (!param.IsNull()) {
	  AliInfo(Form("creating AliRawReaderDate (%s)", param.Data()));
	  fpRawReader = new AliRawReaderDate(param);
	}
	if (fpRawReader) {
	    fpRawReader->RewindEvents();
	    int count=0;
	    for ( ; fpRawReader->NextEvent(); count++) {/* empty body */};
	    if (count!=pRunLoader->GetNumberOfEvents()) {
	      AliError(Form("mismatch in event count: runloader %d, rawreader %d; ignoring rawreader", 
			    pRunLoader->GetNumberOfEvents(), count));
	      count=0;
	    }
	    if (count>0) {
	      fpRawReader->RewindEvents();
	      fpRawReader->NextEvent();
	    } else {
	      delete fpRawReader;
	      fpRawReader=NULL;
	    }
	}
      } else if (token.Contains("writerawfiles=")) {
	if (!token.ReplaceAll("writerawfiles=", "").Contains("HLT")) {
	  if (TestBit(kOneChain) && AliHLTOUTComponent::TestGlobalOption(AliHLTOUTComponent::kWriteRawFiles)) {
	    AliWarning("empty argument 'writerawfiles=' disables HLTOUTComponent mode 'raw' which was set by argument 'hltout-mode'");
	  }
	  AliHLTOUTComponent::ClearGlobalOption(AliHLTOUTComponent::kWriteRawFiles);
	}
      } else if (token.BeginsWith("hltout-mode=")) {
	// this is a legacy mode to emulate the behavior before Dec 2010 where only
	// one chain was executed on either digits or simulated raw data and the output
	// was controlled via global flags
	// add to the arguments for AliHLTSystem as also there the information is needed
	if (sysOp.Length()>0) sysOp+=" ";
	sysOp+=token;
	TString param=token.ReplaceAll("hltout-mode=", "");
	SetBit(kOneChain);
	if (param.CompareTo("raw")==0) {
	  // please note that this option
	  AliHLTOUTComponent::SetGlobalOption(AliHLTOUTComponent::kWriteRawFiles);
	  AliHLTOUTComponent::ClearGlobalOption(AliHLTOUTComponent::kWriteDigits);
	} else if (param.CompareTo("digits")==0) {
	  // please note that this option
	  AliHLTOUTComponent::ClearGlobalOption(AliHLTOUTComponent::kWriteRawFiles);
	  AliHLTOUTComponent::SetGlobalOption(AliHLTOUTComponent::kWriteDigits);
	} else if (param.CompareTo("legacy")==0) {
	  AliHLTOUTComponent::SetGlobalOption(AliHLTOUTComponent::kWriteRawFiles);
	  AliHLTOUTComponent::SetGlobalOption(AliHLTOUTComponent::kWriteDigits);
	} else {
	  AliError(Form("invalid parameter for argument 'hltout-mode=' %s, allowed: raw, digits, legacy ... ignoring argument  and using the standard simulation", param.Data()));
	  ResetBit(kOneChain);
	}
      } else if (token.Contains("events=")) {
	fNEvents=token.ReplaceAll("events=", "").Atoi();
      } else {
	if (sysOp.Length()>0) sysOp+=" ";
	sysOp+=token;
      }
    }
    delete pTokens;
  }
  // only store the options for AliHLTSystem
  fOptions=sysOp;

  // if no specific hltout-mode has been chosen set the split mode for
  // running separate chains for digits and raw data
  if (!fOptions.Contains("hltout-mode=")) fOptions+=" hltout-mode=split";

  AliCDBManager* man = AliCDBManager::Instance();
  if (man && man->IsDefaultStorageSet())
  {
    // init solenoid field
    // 2009-11-07 magnetic field handling fo HLT components has been switched to the
    // global AliMagF instance, the HLT/ConfigHLT/SolenoidBz entry is obsolete
    // The global instance is either established by the AliRoot environment or the
    // component external interface.
    if (TGeoGlobalMagField::Instance()->GetField()) {
      AliDebug(0, Form("magnetic field: %f", AliTracker::GetBz()));
    } else {
      // workaround for bug #51285
      AliGRPManager grpman;
      if (grpman.ReadGRPEntry() &&
	  grpman.SetMagField()) {
	// nothing to do any more
      }
      AliError(Form("can not get the AliMagF instance, falling back to GRP entry (%f)", AliTracker::GetBz()));
    }
  } else if (man) {
    AliError("OCDB default storage not yet set, can not prepare OCDB entries");    
  } else {
    AliError("unable to get instance of AliCDBMetaData, can not prepare OCDB entries");    
  }

  // configure the main HLTSystem instance for digit simulation (pRawReader NULL)
  return ConfigureHLTSystem(pSystem, fOptions.Data(), pRunLoader, TestBit(kOneChain)?fpRawReader:NULL);
}

int AliHLTSimulation::ConfigureHLTSystem(AliHLTSystem* pSystem, const char* options, AliRunLoader* pRunLoader, AliRawReader* pRawReader) const
{
  // scan options and configure AliHLTSystem
  if (pSystem->ScanOptions(options)<0) {
    AliError("error setting options for HLT system");
    return -EINVAL;	
  }

  if (!pSystem->CheckStatus(AliHLTSystem::kReady)) {
    if ((pSystem->Configure(pRawReader, pRunLoader))<0) {
      AliError("error during HLT system configuration");
      return -EFAULT;
    }
  }

  return 0;
}

int AliHLTSimulation::Run(AliRunLoader* pRunLoader)
{
  // HLT reconstruction for simulated data  
  if(!fpPluginBase) {
    AliError("internal initialization failed");
    return -EINVAL;
  }

  if(!pRunLoader) {
    AliError("Missing RunLoader! 0x0");
    return -EINVAL;
  }

  int iResult=0;

  AliHLTSystem* pSystem=fpPluginBase->GetInstance();
  if (!pSystem) {
    AliError("can not get AliHLTSystem instance");
    return -ENOMEM;
  }

  if (pSystem->CheckStatus(AliHLTSystem::kError)) {
    AliError("HLT system in error state");
    return -EFAULT;
  }

  // run the main HLTSystem instance for digit simulation (pRawReader NULL)
  // in legacy mode only one chain is run and the output is controlled via
  // global flags
  if (!TestBit(kOneChain)) AliInfo("running HLT simulation for digits");
  iResult=RunHLTSystem(pSystem, pRunLoader, TestBit(kOneChain)?fpRawReader:NULL);

  // now run once again with the raw data as input, a completely new HLT system
  // with new configurations is used
  if (fpRawReader && !TestBit(kOneChain)) {
    AliInfo("running HLT simulation for raw data");
    int iLocalResult=0;
    AliHLTConfigurationHandler* confHandler=new AliHLTConfigurationHandler;
    // note that the configuration handler is owned by the
    // AliHLTSystem instance from now on
    AliHLTSystem rawSimulation(kHLTLogDefault, "", NULL, confHandler);
    if ((iLocalResult=ConfigureHLTSystem(&rawSimulation, fOptions.Data(), pRunLoader, fpRawReader))>=0) {
      iLocalResult=RunHLTSystem(&rawSimulation, pRunLoader, fpRawReader);
    }
    if (iResult>=0) iResult=iLocalResult;
  }

  return iResult;
}

int AliHLTSimulation::RunHLTSystem(AliHLTSystem* pSystem, AliRunLoader* pRunLoader, AliRawReader* pRawReader) const
{
  // run reconstruction cycle for AliHLTSystem
  int nEvents = (fNEvents<0 || fNEvents>pRunLoader->GetNumberOfEvents())?pRunLoader->GetNumberOfEvents():fNEvents;
  int iResult=0;

  // Note: the rawreader is already placed at the first event
  if ((iResult=pSystem->Reconstruct(1, pRunLoader, pRawReader))>=0) {
    pSystem->FillESD(0, pRunLoader, NULL);
    for (int i=1; i<nEvents; i++) {
      if (pRawReader && !pRawReader->NextEvent()) {
	AliError("mismatch in event count, rawreader corrupted");
	break;
      }
      pSystem->Reconstruct(1, pRunLoader, pRawReader);
      pSystem->FillESD(i, pRunLoader, NULL);
    }
    // send specific 'event' to execute the stop sequence
    pSystem->Reconstruct(0, NULL, NULL);
  }
  return iResult;
}

AliHLTSimulation* AliHLTSimulationCreateInstance()
{
  // see header file for function documentation
  return AliHLTSimulation::CreateInstance();
}

int AliHLTSimulationDeleteInstance(AliHLTSimulation* pSim)
{
  // see header file for function documentation
  return AliHLTSimulation::DeleteInstance(pSim);
}

int AliHLTSimulationInit(AliHLTSimulation* pSim, AliRunLoader* pRunLoader, const char* options)
{
  assert(pSim!=NULL);
  if (pSim) {
    return pSim->Init(pRunLoader, options);
  }
  return -ENODEV;
}

int AliHLTSimulationRun(AliHLTSimulation* pSim, AliRunLoader* pRunLoader)
{
  assert(pSim!=NULL);
  if (pSim) {
    return pSim->Run(pRunLoader);
  }
  return -ENODEV;
}

int AliHLTSimulationGetLibraryVersion()
{
  // see header file for function documentation
  return LIBHLTSIM_VERSION;
}

int AliHLTSimulationSetup(AliHLTSimulation* /*pHLTSim*/, AliSimulation* pSim, const char* specificObjects)
{
  // see header file for function documentation

  // this is an attempt to solve issue #48360
  // since there are many jobs running in parallel during the production,
  // all the jobs want to put entries into the OCDB. The solution is to
  // make them temporary, since they are only used to propagate information
  // from the simulation to the reconstruction.

  if (!pSim) return -EINVAL;
  const char* entries[]={
    NULL
  };

  TString specificStorage; 
  specificStorage.Form("local://%s",gSystem->pwd());
  for (const char** pEntry=entries; *pEntry!=NULL; pEntry++) {
    const char* pObject=specificObjects?strstr(specificObjects, *pEntry):NULL;
    if (pObject) {
      // skip this entry if it is found in the list and either
      // last one or separated by a blank
      pObject+=strlen(*pEntry);
      if (*pObject==0 || *pObject==' ') continue;
    }
    pSim->SetSpecificStorage(*pEntry, specificStorage.Data());
  }

  return 0;
}

#ifndef HAVE_COMPILEINFO
extern "C" void CompileInfo(const char*& date, const char*& time)
{
  // the fall back compile info of the HLTsim library
  // this is not up-to-date if other files have been changed and recompiled
  date=__DATE__; time=__TIME__;
  return;
}
#endif
Commit	Line	Data
adf1619a	1	// $Id$
	2
	3	//**************************************************************************
	4	//* This file is property of and copyright by the ALICE HLT Project *
	5	//* ALICE Experiment at CERN, All rights reserved. *
	6	//* *
	7	//* Primary Authors: Matthias Richter <Matthias.Richter@ift.uib.no> *
	8	//* for The ALICE HLT Project. *
	9	//* *
	10	//* Permission to use, copy, modify and distribute this software and its *
	11	//* documentation strictly for non-commercial purposes is hereby granted *
	12	//* without fee, provided that the above copyright notice appears in all *
	13	//* copies and that both the copyright notice and this permission notice *
	14	//* appear in the supporting documentation. The authors make no claims *
	15	//* about the suitability of this software for any purpose. It is *
	16	//* provided "as is" without express or implied warranty. *
	17	//**************************************************************************
	18
	19	/** @file AliHLTSimulation.cxx
	20	@author Matthias Richter
	21	@date
	22	@brief Binding class for HLT simulation in AliRoot. */
	23
	24	#include <cassert>
	25	#include <cerrno>
	26	#include "TObjArray.h"
	27	#include "TObjString.h"
	28	#include "AliHLTSimulation.h"
	29	#include "AliSimulation.h"
	30	#include "AliLog.h"
	31	#include "AliRun.h"
	32	#include "AliRunLoader.h"
	33	#include "AliHeader.h"
	34	#include "AliCDBManager.h"
	35	#include "AliCDBEntry.h"
	36	#include "AliCDBPath.h"
	37	#include "AliCDBId.h"
	38	#include "AliCDBMetaData.h"
	39	#include "AliCDBStorage.h"
	40	#include "AliGRPObject.h"
	41	#include "AliGRPManager.h"
	42	#include "AliHLTSystem.h"
	43	#include "AliHLTConfigurationHandler.h"
	44	#include "AliHLTPluginBase.h"
	45	#include "AliRawReaderFile.h"
	46	#include "AliRawReaderDate.h"
	47	#include "AliRawReaderRoot.h"
	48	#include "AliESDEvent.h"
	49	#include "AliHLTOUTComponent.h"
	50	#include "AliTracker.h"
	51	#include "TGeoGlobalMagField.h"
	52	#include "TSystem.h"
	53	#include "TMath.h"
	54	#include "TGeoGlobalMagField.h"
	55
	56	#if ALIHLTSIMULATION_LIBRARY_VERSION != LIBHLTSIM_VERSION
	57	#error library version in header file and lib*.pkg do not match
	58	#endif
	59
	60	/** ROOT macro for the implementation of ROOT specific class methods */
	61	ClassImp(AliHLTSimulation);
	62
	63	AliHLTSimulation::AliHLTSimulation()
	64	: fOptions()
65	, fpPluginBase(new AliHLTPluginBase)
66	, fpRawReader(NULL)
67	, fNEvents(-1)
68	{
69	// see header file for class documentation
70	// or
71	// refer to README to build package
72	// or
73	// visit http://web.ift.uib.no/~kjeks/doc/alice-hlt
74	}
75
76	AliHLTSimulation::~AliHLTSimulation()
77	{
78	// see header file for function documentation
79	if (fpPluginBase) delete fpPluginBase;
80	fpPluginBase=NULL;
81
82	if (fpRawReader) {
83	delete fpRawReader;
84	}
85	fpRawReader=NULL;
86	}
87
88	AliHLTSimulation* AliHLTSimulation::CreateInstance()
89	{
90	// see header file for function documentation
91	return new AliHLTSimulation;
92	}
93
94	int AliHLTSimulation::DeleteInstance(AliHLTSimulation* pSim)
95	{
96	// see header file for function documentation
97	assert(pSim!=NULL);
98	delete pSim;
99	return 0;
100	}
101
102	int AliHLTSimulation::Init(AliRunLoader* pRunLoader, const char* options)
103	{
104	// init the simulation
105	fOptions=options;
106	TString sysOp;
107
108	if(!fpPluginBase) {
109	AliError("internal initialization failed");
110	return -EINVAL;
111	}
112
113	AliHLTSystem* pSystem=fpPluginBase->GetInstance();
114	if (!pSystem) {
115	AliError("can not get AliHLTSystem instance");
116	return -ENOMEM;
117	}
118	if (pSystem->CheckStatus(AliHLTSystem::kError)) {
119	AliError("HLT system in error state");
120	return -EFAULT;
121	}
122
123	// scan options for specific entries
124	TObjArray* pTokens=fOptions.Tokenize(" ");
125	if (pTokens) {
126	int iEntries=pTokens->GetEntries();
127	for (int i=0; i<iEntries; i++) {
128	TString token=(((TObjString*)pTokens->At(i))->GetString());
129	if (token.Contains("rawfile=")) {
130	TString param=token.ReplaceAll("rawfile=", "");
131	if (param.EndsWith("/")) {
132	AliInfo(Form("creating AliRawReaderFile (%s)", param.Data()));
133	fpRawReader = new AliRawReaderFile(param);
134	} else if (param.EndsWith(".root")) {
135	AliInfo(Form("creating AliRawReaderRoot (%s)", param.Data()));
136	fpRawReader = new AliRawReaderRoot(param);
137	} else if (!param.IsNull()) {
138	AliInfo(Form("creating AliRawReaderDate (%s)", param.Data()));
139	fpRawReader = new AliRawReaderDate(param);
140	}
141	if (fpRawReader) {
142	fpRawReader->RewindEvents();
143	int count=0;
144	for ( ; fpRawReader->NextEvent(); count++) {/* empty body */};
145	if (count!=pRunLoader->GetNumberOfEvents()) {
146	AliError(Form("mismatch in event count: runloader %d, rawreader %d; ignoring rawreader",
147	pRunLoader->GetNumberOfEvents(), count));
148	count=0;
149	}
150	if (count>0) {
151	fpRawReader->RewindEvents();
152	fpRawReader->NextEvent();
153	} else {
154	delete fpRawReader;
155	fpRawReader=NULL;
156	}
157	}
158	} else if (token.Contains("writerawfiles=")) {
159	if (!token.ReplaceAll("writerawfiles=", "").Contains("HLT")) {
160	if (TestBit(kOneChain) && AliHLTOUTComponent::TestGlobalOption(AliHLTOUTComponent::kWriteRawFiles)) {
161	AliWarning("empty argument 'writerawfiles=' disables HLTOUTComponent mode 'raw' which was set by argument 'hltout-mode'");
162	}
163	AliHLTOUTComponent::ClearGlobalOption(AliHLTOUTComponent::kWriteRawFiles);
164	}
165	} else if (token.BeginsWith("hltout-mode=")) {
166	// this is a legacy mode to emulate the behavior before Dec 2010 where only
167	// one chain was executed on either digits or simulated raw data and the output
168	// was controlled via global flags
169	// add to the arguments for AliHLTSystem as also there the information is needed
170	if (sysOp.Length()>0) sysOp+=" ";
171	sysOp+=token;
172	TString param=token.ReplaceAll("hltout-mode=", "");
173	SetBit(kOneChain);
174	if (param.CompareTo("raw")==0) {
175	// please note that this option
176	AliHLTOUTComponent::SetGlobalOption(AliHLTOUTComponent::kWriteRawFiles);
177	AliHLTOUTComponent::ClearGlobalOption(AliHLTOUTComponent::kWriteDigits);
178	} else if (param.CompareTo("digits")==0) {
179	// please note that this option
180	AliHLTOUTComponent::ClearGlobalOption(AliHLTOUTComponent::kWriteRawFiles);
181	AliHLTOUTComponent::SetGlobalOption(AliHLTOUTComponent::kWriteDigits);
182	} else if (param.CompareTo("legacy")==0) {
183	AliHLTOUTComponent::SetGlobalOption(AliHLTOUTComponent::kWriteRawFiles);
184	AliHLTOUTComponent::SetGlobalOption(AliHLTOUTComponent::kWriteDigits);
185	} else {
186	AliError(Form("invalid parameter for argument 'hltout-mode=' %s, allowed: raw, digits, legacy ... ignoring argument and using the standard simulation", param.Data()));
187	ResetBit(kOneChain);
188	}
189	} else if (token.Contains("events=")) {
190	fNEvents=token.ReplaceAll("events=", "").Atoi();
191	} else {
192	if (sysOp.Length()>0) sysOp+=" ";
193	sysOp+=token;
194	}
195	}
196	delete pTokens;
197	}
198	// only store the options for AliHLTSystem
199	fOptions=sysOp;
200
201	// if no specific hltout-mode has been chosen set the split mode for
202	// running separate chains for digits and raw data
203	if (!fOptions.Contains("hltout-mode=")) fOptions+=" hltout-mode=split";
204
205	AliCDBManager* man = AliCDBManager::Instance();
206	if (man && man->IsDefaultStorageSet())
207	{
208	// init solenoid field
209	// 2009-11-07 magnetic field handling fo HLT components has been switched to the
210	// global AliMagF instance, the HLT/ConfigHLT/SolenoidBz entry is obsolete
211	// The global instance is either established by the AliRoot environment or the
212	// component external interface.
213	if (TGeoGlobalMagField::Instance()->GetField()) {
214	AliDebug(0, Form("magnetic field: %f", AliTracker::GetBz()));
215	} else {
216	// workaround for bug #51285
217	AliGRPManager grpman;
218	if (grpman.ReadGRPEntry() &&
219	grpman.SetMagField()) {
220	// nothing to do any more
221	}
222	AliError(Form("can not get the AliMagF instance, falling back to GRP entry (%f)", AliTracker::GetBz()));
223	}
224	} else if (man) {
225	AliError("OCDB default storage not yet set, can not prepare OCDB entries");
226	} else {
227	AliError("unable to get instance of AliCDBMetaData, can not prepare OCDB entries");
228	}
229
230	// configure the main HLTSystem instance for digit simulation (pRawReader NULL)
231	return ConfigureHLTSystem(pSystem, fOptions.Data(), pRunLoader, TestBit(kOneChain)?fpRawReader:NULL);
232	}
233
234	int AliHLTSimulation::ConfigureHLTSystem(AliHLTSystem* pSystem, const char* options, AliRunLoader* pRunLoader, AliRawReader* pRawReader) const
235	{
236	// scan options and configure AliHLTSystem
237	if (pSystem->ScanOptions(options)<0) {
238	AliError("error setting options for HLT system");
239	return -EINVAL;
240	}
241
242	if (!pSystem->CheckStatus(AliHLTSystem::kReady)) {
243	if ((pSystem->Configure(pRawReader, pRunLoader))<0) {
244	AliError("error during HLT system configuration");
245	return -EFAULT;
246	}
247	}
248
249	return 0;
250	}
251
252	int AliHLTSimulation::Run(AliRunLoader* pRunLoader)
253	{
254	// HLT reconstruction for simulated data
255	if(!fpPluginBase) {
256	AliError("internal initialization failed");
257	return -EINVAL;
258	}
259
260	if(!pRunLoader) {
261	AliError("Missing RunLoader! 0x0");
262	return -EINVAL;
263	}
264
265	int iResult=0;
266
267	AliHLTSystem* pSystem=fpPluginBase->GetInstance();
268	if (!pSystem) {
269	AliError("can not get AliHLTSystem instance");
270	return -ENOMEM;
271	}
272
273	if (pSystem->CheckStatus(AliHLTSystem::kError)) {
274	AliError("HLT system in error state");
275	return -EFAULT;
276	}
277
278	// run the main HLTSystem instance for digit simulation (pRawReader NULL)
279	// in legacy mode only one chain is run and the output is controlled via
280	// global flags
281	if (!TestBit(kOneChain)) AliInfo("running HLT simulation for digits");
282	iResult=RunHLTSystem(pSystem, pRunLoader, TestBit(kOneChain)?fpRawReader:NULL);
283
284	// now run once again with the raw data as input, a completely new HLT system
285	// with new configurations is used
286	if (fpRawReader && !TestBit(kOneChain)) {
287	AliInfo("running HLT simulation for raw data");
288	int iLocalResult=0;
289	AliHLTConfigurationHandler* confHandler=new AliHLTConfigurationHandler;
290	// note that the configuration handler is owned by the
291	// AliHLTSystem instance from now on
292	AliHLTSystem rawSimulation(kHLTLogDefault, "", NULL, confHandler);
293	if ((iLocalResult=ConfigureHLTSystem(&rawSimulation, fOptions.Data(), pRunLoader, fpRawReader))>=0) {
294	iLocalResult=RunHLTSystem(&rawSimulation, pRunLoader, fpRawReader);
295	}
296	if (iResult>=0) iResult=iLocalResult;
297	}
298
299	return iResult;
300	}
301
302	int AliHLTSimulation::RunHLTSystem(AliHLTSystem* pSystem, AliRunLoader* pRunLoader, AliRawReader* pRawReader) const
303	{
304	// run reconstruction cycle for AliHLTSystem
305	int nEvents = (fNEvents<0 \|\| fNEvents>pRunLoader->GetNumberOfEvents())?pRunLoader->GetNumberOfEvents():fNEvents;
306	int iResult=0;
307
308	// Note: the rawreader is already placed at the first event
309	if ((iResult=pSystem->Reconstruct(1, pRunLoader, pRawReader))>=0) {
310	pSystem->FillESD(0, pRunLoader, NULL);
311	for (int i=1; i<nEvents; i++) {
312	if (pRawReader && !pRawReader->NextEvent()) {
313	AliError("mismatch in event count, rawreader corrupted");
314	break;
315	}
316	pSystem->Reconstruct(1, pRunLoader, pRawReader);
317	pSystem->FillESD(i, pRunLoader, NULL);
318	}
319	// send specific 'event' to execute the stop sequence
320	pSystem->Reconstruct(0, NULL, NULL);
321	}
322	return iResult;
323	}
324
325	AliHLTSimulation* AliHLTSimulationCreateInstance()
326	{
327	// see header file for function documentation
328	return AliHLTSimulation::CreateInstance();
329	}
330
331	int AliHLTSimulationDeleteInstance(AliHLTSimulation* pSim)
332	{
333	// see header file for function documentation
334	return AliHLTSimulation::DeleteInstance(pSim);
335	}
336
337	int AliHLTSimulationInit(AliHLTSimulation* pSim, AliRunLoader* pRunLoader, const char* options)
338	{
339	assert(pSim!=NULL);
340	if (pSim) {
341	return pSim->Init(pRunLoader, options);
342	}
343	return -ENODEV;
344	}
345
346	int AliHLTSimulationRun(AliHLTSimulation* pSim, AliRunLoader* pRunLoader)
347	{
348	assert(pSim!=NULL);
349	if (pSim) {
350	return pSim->Run(pRunLoader);
351	}
352	return -ENODEV;
353	}
354
355	int AliHLTSimulationGetLibraryVersion()
356	{
357	// see header file for function documentation
358	return LIBHLTSIM_VERSION;
359	}
360
361	int AliHLTSimulationSetup(AliHLTSimulation* /pHLTSim/, AliSimulation* pSim, const char* specificObjects)
362	{
363	// see header file for function documentation
364
365	// this is an attempt to solve issue #48360
366	// since there are many jobs running in parallel during the production,
367	// all the jobs want to put entries into the OCDB. The solution is to
368	// make them temporary, since they are only used to propagate information
369	// from the simulation to the reconstruction.
370
371	if (!pSim) return -EINVAL;
372	const char* entries[]={
373	NULL
374	};
375
376	TString specificStorage;
377	specificStorage.Form("local://%s",gSystem->pwd());
378	for (const char** pEntry=entries; *pEntry!=NULL; pEntry++) {
379	const char* pObject=specificObjects?strstr(specificObjects, *pEntry):NULL;
380	if (pObject) {
381	// skip this entry if it is found in the list and either
382	// last one or separated by a blank
383	pObject+=strlen(*pEntry);
384	if (pObject==0 \|\| pObject==' ') continue;
385	}
386	pSim->SetSpecificStorage(*pEntry, specificStorage.Data());
387	}
388
389	return 0;
390	}
391
392	#ifndef HAVE_COMPILEINFO
393	extern "C" void CompileInfo(const char& date, const char& time)
394	{
395	// the fall back compile info of the HLTsim library
396	// this is not up-to-date if other files have been changed and recompiled
397	date=__DATE__; time=__TIME__;
398	return;
399	}
400	#endif