[u/mrichter/AliRoot.git] / HLT / trigger / AliHLTTriggerAgent.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   AliHLTTriggerAgent.cxx
    @author Matthias Richter
    @date   
    @brief  Agent of the libAliHLTTrigger library
*/

#include <cassert>
#include "AliHLTTriggerAgent.h"
#include "AliHLTTriggerDecision.h"
#include "AliHLTGlobalTriggerDecision.h"
#include "AliHLTOUT.h"
#include "AliHLTMessage.h"
#include "AliESDEvent.h"
#include "TObjString.h"
#include "TObjArray.h"
#include "TArrayC.h"
#include "TFile.h"
#include "TTree.h"

// header files of library components
#include "AliHLTTriggerBarrelMultiplicity.h"
#include "AliHLTD0Trigger.h"
#include "AliHLTTriggerITSMultiplicity.h"
#include "AliHLTTriggerBarrelGeomMultiplicity.h"
#include "AliHLTGlobalTriggerComponent.h"
#include "AliHLTTriggerPhosClusterEnergy.h"
#include "AliHLTTriggerEmcalClusterEnergy.h"
#include "AliHLTTriggerPhosMip.h"
#include "AliHLTTriggerTrdClusterMultiplicity.h"
#include "AliHLTTriggerGammaConversion.h"
#include "AliHLTMuonSpectroTriggerComponent.h"
#include "AliHLTUpcTriggerComponent.h"
#include "AliHLTTriggerCosmics.h"
#include "AliHLTTriggerCounterComponent.h"


/** global instance for agent registration */
AliHLTTriggerAgent gAliHLTTriggerAgent;

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

AliHLTTriggerAgent::AliHLTTriggerAgent()
  : AliHLTModuleAgent("Trigger")
  , fTriggerDecisionHandler(NULL)
{
  // see header file for class documentation
  // or
  // refer to README to build package
  // or
  // visit http://web.ift.uib.no/~kjeks/doc/alice-hlt
}

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

int AliHLTTriggerAgent::RegisterComponents(AliHLTComponentHandler* pHandler) const
{
  // see header file for class documentation
  assert(pHandler);
  if (!pHandler) return -EINVAL;
  pHandler->AddComponent(new AliHLTGlobalTriggerComponent);
  pHandler->AddComponent(new AliHLTTriggerBarrelMultiplicity);
  pHandler->AddComponent(new AliHLTTriggerITSMultiplicity);
  pHandler->AddComponent(new AliHLTD0Trigger);
  pHandler->AddComponent(new AliHLTTriggerBarrelGeomMultiplicity);
  pHandler->AddComponent(new AliHLTTriggerPhosClusterEnergy); 
  pHandler->AddComponent(new AliHLTTriggerEmcalClusterEnergy); 
  pHandler->AddComponent(new AliHLTTriggerPhosMip); 
  pHandler->AddComponent(new AliHLTTriggerTrdClusterMultiplicity);
  pHandler->AddComponent(new AliHLTTriggerGammaConversion);
  pHandler->AddComponent(new AliHLTMuonSpectroTriggerComponent);
  pHandler->AddComponent(new AliHLTUpcTriggerComponent);
  pHandler->AddComponent(new AliHLTTriggerCosmics);
  pHandler->AddComponent(new AliHLTTriggerCounterComponent);
  return 0;
}

int AliHLTTriggerAgent::CreateConfigurations(AliHLTConfigurationHandler* pHandler,
					    AliRawReader* rawReader,
					    AliRunLoader* runloader) const
{
  // see header file for class documentation
  if (!pHandler) return -EINVAL;

  TString triggerInputs;
  TString triggerOutputs;
  TString configurationId;
  /////////////////////////////////////////////////////////////////////////////////////
  //
  // a central barrel charged particle multiplicity trigger
  configurationId="TRIGGER-Barrel-Multiplicity";

  // define the inputs for the BarrelMultiplicityTrigger
  triggerInputs="GLOBAL-esd-converter";

  // check for the availibility
  TObjArray* pTokens=triggerInputs.Tokenize(" ");
  triggerInputs="";
  if (pTokens) {
    for (int n=0; n<pTokens->GetEntriesFast(); n++) {
      TString module=((TObjString*)pTokens->At(n))->GetString();
      if (pHandler->FindConfiguration(module.Data())) {
	triggerInputs+=module;
	triggerInputs+=" ";
      }
    }
    delete pTokens;
  }

  TString arg;
  if (triggerInputs.Length()>0) {
    // define multiple instances of the BarrelMultiplicityTrigger with different settings
    HLTInfo("Configuring inputs for %s: %s", configurationId.Data(), triggerInputs.Data());
    pHandler->CreateConfiguration(configurationId.Data(), "BarrelMultiplicityTrigger", triggerInputs.Data(), "");
    if (triggerOutputs.Length()>0) triggerOutputs+=" ";
    triggerOutputs+=configurationId;

    configurationId="TRIGGER-Barrel-HighMultiplicity";
    arg="-triggername BarrelHighMultiplicity";
    pHandler->CreateConfiguration(configurationId.Data(), "BarrelMultiplicityTrigger", triggerInputs.Data(), arg.Data());
    if (triggerOutputs.Length()>0) triggerOutputs+=" ";
    triggerOutputs+=configurationId;

    configurationId="TRIGGER-Barrel-Pt_v01";
    arg="-triggername BarrelPt_v01";
    pHandler->CreateConfiguration(configurationId.Data(), "BarrelMultiplicityTrigger", triggerInputs.Data(), arg.Data());
    if (triggerOutputs.Length()>0) triggerOutputs+=" ";
    triggerOutputs+=configurationId;

    configurationId="TRIGGER-Barrel-Pt_v02";
    arg="-triggername BarrelPt_v02";
    pHandler->CreateConfiguration(configurationId.Data(), "BarrelMultiplicityTrigger", triggerInputs.Data(), arg.Data());
    if (triggerOutputs.Length()>0) triggerOutputs+=" ";
    triggerOutputs+=configurationId;

    configurationId="TRIGGER-Barrel-Pt_v03";
    arg="-triggername BarrelPt_v03";
    pHandler->CreateConfiguration(configurationId.Data(), "BarrelMultiplicityTrigger", triggerInputs.Data(), arg.Data());
    if (triggerOutputs.Length()>0) triggerOutputs+=" ";
    triggerOutputs+=configurationId;
  } else {
    HLTWarning("No inputs for %s found, skipping component", configurationId.Data());
  }
  
  /////////////////////////////////////////////////////////////////////////////////////
  // The muon spectrometer trigger
  configurationId = "TRIGGER-Muon-Spectrometer";

  // define the inputsfor the muon spectrometer trigger.
  if (pHandler->FindConfiguration("dHLT-sim-fromRaw")) {
    triggerInputs = "dHLT-sim-fromRaw";
  }
  else if (pHandler->FindConfiguration("dHLT-sim")) {
    triggerInputs = "dHLT-sim";
  }
  else if (pHandler->FindConfiguration("dHLT-sim-fromMC")) {
    triggerInputs = "dHLT-sim-fromMC";
  }

  if (triggerInputs.Length() > 0) {
    HLTInfo("Configuring inputs for %s: %s", configurationId.Data(), triggerInputs.Data());
    pHandler->CreateConfiguration(configurationId.Data(), "MuonSpectroTrigger", triggerInputs.Data(), "-makestats");
    if (triggerOutputs.Length() > 0) triggerOutputs += " ";
    triggerOutputs += configurationId;
  } else {
    HLTWarning("No inputs for %s found, skipping component.", configurationId.Data());
  }

  /////////////////////////////////////////////////////////////////////////////////////
  // D0 trigger
  configurationId = "TRIGGER-D0";
  if(runloader && !rawReader){
    // simulation without simulated raw data
    // use ESD as input
    triggerInputs="GLOBAL-esd-converter ";
  }
  else{
    // simulation with simulated raw data, or raw data reconstruction
    // use input from ITS tracker and vertexer directly
    triggerInputs="ITS-tracker GLOBAL-vertexer";
  }

  // check for the availibility of inputs
  pTokens=triggerInputs.Tokenize(" ");
  triggerInputs="";
  if (pTokens) {
    for (int n=0; n<pTokens->GetEntriesFast(); n++) {
      TString module=((TObjString*)pTokens->At(n))->GetString();
      if (pHandler->FindConfiguration(module.Data())) {
	triggerInputs+=module;
	triggerInputs+=" ";
      }
    }
    delete pTokens;
  }

  TString argD0 = "";
  if (triggerInputs.Length()>0) {
    HLTInfo("Configuring inputs for %s: %s", configurationId.Data(), triggerInputs.Data());
    pHandler->CreateConfiguration(configurationId.Data(), "D0Trigger", triggerInputs.Data(), argD0.Data());
    // FIXME: due to a rare segfault for reconstruction of PbPb data the
    // component is temporarily excluded
    // https://savannah.cern.ch/bugs/?72590
    //if (triggerOutputs.Length()>0) triggerOutputs+=" ";
    //triggerOutputs+=configurationId;
  } else {
    HLTWarning("No inputs for %s found, skipping component", configurationId.Data());
  }

  /////////////////////////////////////////////////////////////////////////////////////
  //
  // the global trigger component
  configurationId="GLOBAL-Trigger";
  HLTInfo("setting inputs for %s: %s", configurationId.Data(), triggerOutputs.IsNull()?"none":triggerOutputs.Data());
  pHandler->CreateConfiguration(configurationId.Data(), "HLTGlobalTrigger", triggerOutputs.Data(), "");
  
  return 0;
}

const char* AliHLTTriggerAgent::GetReconstructionChains(AliRawReader* /*rawReader*/,
						    AliRunLoader* runloader) const
{
  // see header file for class documentation
  if (runloader) {
    // reconstruction chains for AliRoot simulation
    // Note: run loader is only available while running embedded into
    // AliRoot simulation

    // currently disabled due to a problem compiling the runtime trigger library
    return "GLOBAL-Trigger";
  }
  return NULL;
}

const char* AliHLTTriggerAgent::GetRequiredComponentLibraries() const
{
  // see header file for class documentation

  return "";
}

int AliHLTTriggerAgent::GetHandlerDescription(AliHLTComponentDataType dt,
					   AliHLTUInt32_t /*spec*/,
					  AliHLTOUTHandlerDesc& desc) const
{
  // see header file for class documentation

  // handler of the trigger decisions {'ROOTTOBJ':'HLT '}
  // currently stored as a TObject with the common data type and origin
  // HLTOUT. However we might need a separate data type in order to
  // avoid interference with other handlers
  // the handler produces an ESD object in order to be merged to the
  // hltEsd afterwards
  // 2009-11-17 adding the data tyepes for (global) trigger decisions
  // the TObject data types stays for a while in order to preserve
  // backward compatibility
  if (dt==(kAliHLTDataTypeTObject|kAliHLTDataOriginOut) ||
      dt==kAliHLTDataTypeTriggerDecision ||
      dt==kAliHLTDataTypeGlobalTrigger) {
    desc=AliHLTOUTHandlerDesc(AliHLTModuleAgent::kEsd, dt, GetModuleId());
    return 1;
  }

  // handler for the HLT readou list and trigger data data blocks {'HLTRDLST':'HLT '}
  if (dt==AliHLTComponentDataTypeInitializer("HLTRDLST", kAliHLTDataOriginOut) ||
      dt==AliHLTComponentDataTypeInitializer("HLTTRGDT", kAliHLTDataOriginOut)) {
      desc=AliHLTOUTHandlerDesc(kProprietary, dt, GetModuleId());
      return 1;
  }

  return 0;
}

AliHLTOUTHandler* AliHLTTriggerAgent::GetOutputHandler(AliHLTComponentDataType dt,
						       AliHLTUInt32_t /*spec*/)
{
  // see header file for class documentation

  // raw data blocks to be fed into offline reconstruction
  if ((dt==(kAliHLTDataTypeTObject|kAliHLTDataOriginOut) ||
       (dt==kAliHLTDataTypeTriggerDecision) ||
       (dt==kAliHLTDataTypeGlobalTrigger))) {
    if (!fTriggerDecisionHandler) {
      fTriggerDecisionHandler=new AliHLTTriggerAgent::AliHLTTriggerDecisionHandler;
    }
    return fTriggerDecisionHandler;
  }

  // handler for the HLT readou list and trigger data data blocks {'HLTRDLST':'HLT '}
  if (dt==AliHLTComponentDataTypeInitializer("HLTRDLST", kAliHLTDataOriginOut) ||
      dt==AliHLTComponentDataTypeInitializer("HLTTRGDT", kAliHLTDataOriginOut)) {
    return NULL;
  }

  return NULL;
}

int AliHLTTriggerAgent::DeleteOutputHandler(AliHLTOUTHandler* pInstance)
{
  // see header file for class documentation
  if (pInstance==NULL) return -EINVAL;

  if (pInstance==fTriggerDecisionHandler) {
    delete fTriggerDecisionHandler;
    fTriggerDecisionHandler=NULL;
  }

  return 0;
}

AliHLTTriggerAgent::AliHLTTriggerDecisionHandler::AliHLTTriggerDecisionHandler()
  : AliHLTOUTHandler() 
  , fESD(NULL)
  , fpData(NULL)
  , fSize(0)
  , fpESDfile(NULL)
  , fpESDtree(NULL)
{
  // see header file for class documentation
}

AliHLTTriggerAgent::AliHLTTriggerDecisionHandler::~AliHLTTriggerDecisionHandler()
{
  // see header file for class documentation
  if (fpESDtree) {
    fpESDtree->GetUserInfo()->Clear();
    delete fpESDtree;
  }
  fpESDtree=NULL;

  if (fpESDfile) {
    fpESDfile->Close();
    delete fpESDfile;
  }
  fpESDfile=NULL;

  if (fESD) delete fESD;
  fESD=NULL;

  if (fpData) delete fpData;
  fpData=NULL;
  fSize=0;
}

int AliHLTTriggerAgent::AliHLTTriggerDecisionHandler::ProcessData(AliHLTOUT* pData)
{
  // see header file for class documentation
  if (!pData) return -EINVAL;
  int iResult=0;
  AliHLTGlobalTriggerDecision* pGlobalDecision=NULL;
  TObjArray triggerDecisions;
  triggerDecisions.SetOwner(kTRUE);
  for (iResult=pData->SelectFirstDataBlock(); iResult>=0; iResult=pData->SelectNextDataBlock()) {
    AliHLTComponentDataType dt=kAliHLTVoidDataType;
    AliHLTUInt32_t spec=kAliHLTVoidDataSpec;
    if ((iResult=pData->GetDataBlockDescription(dt, spec))<0) break;
    TObject* pObject=pData->GetDataObject();
    if (pObject) {
      if(dt==kAliHLTDataTypeGlobalTrigger) {
	if (!pGlobalDecision) {
	  if ((pGlobalDecision=dynamic_cast<AliHLTGlobalTriggerDecision*>(pObject))==NULL ||
	      (pGlobalDecision=dynamic_cast<AliHLTGlobalTriggerDecision*>(pGlobalDecision->Clone()))==NULL) {
	    HLTFatal("can not convert object of name %s (%s) to HLTGlobalTriggerDecsion according to data type", pObject->GetName(), pObject->Class()->GetName());
	  }
	} else {
	  HLTWarning("multiple HLT GlobalTrigger decision objects, ignoring all but the first one");
	}
      } else if (dt==kAliHLTDataTypeTriggerDecision) {
	if (pObject->IsA() == AliHLTTriggerDecision::Class() &&
	    !(pObject->IsA() == AliHLTGlobalTriggerDecision::Class())) {
	  AliHLTTriggerDecision* pDecision=dynamic_cast<AliHLTTriggerDecision*>(pObject);
	  if (pDecision) {
	    if (pGlobalDecision) {
	      // add directly
	      pGlobalDecision->AddTriggerInput(*pDecision);
	    } else {
	      // schedule
	      triggerDecisions.Add(pDecision->Clone());
	    }
	  } else {
	    HLTFatal("can not convert object of name %s (%s) to HLT TriggerDecsion according to data type", pObject->GetName(), pObject->Class()->GetName());
	  }
	}
      } else if (dt==(kAliHLTDataTypeTObject|kAliHLTDataOriginOut)){
	// this is the branch for keeping compatibility
	// the first version of the trigger framework was using the kAliHLTDataTypeTObject
	// data type instead of the specific data types for HLT triggers
	  // this effects the cosmic data taken Sep to Oct 2009
	if (pObject->IsA() == AliHLTGlobalTriggerDecision::Class()) {
	  if (!pGlobalDecision) {
	    if ((pGlobalDecision=dynamic_cast<AliHLTGlobalTriggerDecision*>(pObject))==NULL ||
		(pGlobalDecision=dynamic_cast<AliHLTGlobalTriggerDecision*>(pGlobalDecision->Clone()))==NULL) {
	      HLTFatal("can not convert object of name %s (%s) to HLTGlobalTriggerDecsion according to data type", pObject->GetName(), pObject->Class()->GetName());
	    }
	  } else {
	    HLTWarning("multiple HLT GlobalTrigger decision objects, ignoring all but the first one");
	  }
	} else if (pObject->IsA() == AliHLTTriggerDecision::Class()) {
	  AliHLTTriggerDecision* pDecision=dynamic_cast<AliHLTTriggerDecision*>(pObject);
	  if (pDecision) {
	    if (pGlobalDecision) {
	      // add directly
	      pGlobalDecision->AddTriggerInput(*pDecision);
	    } else {
	      // schedule
	      triggerDecisions.Add(pDecision->Clone());
	    }
	  } else {
	    HLTFatal("can not convert object of name %s (%s) to HLT TriggerDecsion according to data type", pObject->GetName(), pObject->Class()->GetName());
	  }
	}
      }
      pData->ReleaseDataObject(pObject);
      pObject=NULL;
    } else {
      HLTError("can not get TObject from HLTOUT buffer");
      iResult=-ENODATA;
    }
  }
  // -ENOENT just signals that there  are no more entries
  if (iResult==-ENOENT) iResult=0;

  if (pGlobalDecision) {
    for (int i=0; i<triggerDecisions.GetEntriesFast(); i++) {
      if (triggerDecisions[i]) {
	pGlobalDecision->AddTriggerInput(*((AliHLTTriggerDecision*)triggerDecisions[i]));
      }
    }
    triggerDecisions.Delete();
    AliHLTTriggerDecision* pDecision=pGlobalDecision;
    {
      if (pDecision) {
	//pDecision->Print();
	HLTDebug("extracted %s", pDecision->GetName());
	if (!fESD) {
	  // create the ESD container, but without std content
	  fESD = new AliESDEvent;
	}
	if (!fpData) fpData=new TArrayC;
	if (fESD && fpData) {
	  fESD->Reset();
	  TObject* pESDObject=fESD->FindListObject("HLTGlobalTrigger");
	  if (pESDObject) {
	    // copy the content to the already existing object
	    pDecision->Copy(*pESDObject);
	  } else {
	    // add a new object
	    fESD->AddObject(pDecision->Clone());
	  }
	  WriteESD();
	  AliHLTMessage* pMsg=AliHLTMessage::Stream(fESD);
	  if (pMsg) {
	    if (!pMsg->CompBuffer()) {
	      fSize=pMsg->Length();
	      fpData->Set(fSize, pMsg->Buffer());
	    } else {
	      fSize=pMsg->CompLength();
	      fpData->Set(fSize, pMsg->CompBuffer());
	    }
	    delete pMsg;
	    pMsg=NULL;
	  } else {
	    HLTError("streaming of objects failed");
	  }
	} else {
	  HLTError("memory allocation failed");
	  iResult=-ENOMEM;
	}
      }
    }
    delete pGlobalDecision;
    pGlobalDecision=NULL;
  } else {
    HLTError("no global trigger found in data collection");
  }

  if (iResult>=0) {
    return fSize;
  }
  fSize=0;
  return iResult;
}

int AliHLTTriggerAgent::AliHLTTriggerDecisionHandler::GetProcessedData(const AliHLTUInt8_t* &pData)
{
  // see header file for class documentation
  if (!fpData) {
    pData=NULL;
    return 0;
  }

  pData=reinterpret_cast<AliHLTUInt8_t*>(fpData->GetArray());
  return fSize;
}

int AliHLTTriggerAgent::AliHLTTriggerDecisionHandler::ReleaseProcessedData(const AliHLTUInt8_t* pData, int size)
{
  // see header file for class documentation
  int iResult=0;
  if (!fpData || size != fSize ||
      const_cast<AliHLTUInt8_t*>(pData) != reinterpret_cast<AliHLTUInt8_t*>(fpData->GetArray())) {
    HLTError("attempt to release to wrong data buffer %p size %d, expected %p size %d", pData, size, fpData?fpData->GetArray():NULL, fSize);
  }
  fSize=0;
  return iResult;
}

int AliHLTTriggerAgent::AliHLTTriggerDecisionHandler::WriteESD()
{
  // see header file for class documentation
  int iResult=0;
  if (!fESD) return 0;
  if (!fpESDfile) {
    fpESDfile=new TFile("HLTdecision.root", "RECREATE");
  }
  if (!fpESDtree) {
    fpESDtree=new TTree("HLTesdTree", "Tree with HLT ESD containing HLT decision");
    if (fpESDtree) {
      fESD->WriteToTree(fpESDtree);
      fpESDtree->GetUserInfo()->Add(fESD);
    }
  }
  if (!fpESDfile || !fpESDtree) return -ENOMEM;

  fpESDtree->Fill();
  fpESDfile->cd();
  fpESDtree->Write(fpESDtree->GetName(),TObject::kOverwrite);

  return iResult;
}
Commit	Line	Data
89858ccc	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 AliHLTTriggerAgent.cxx
	20	@author Matthias Richter
	21	@date
	22	@brief Agent of the libAliHLTTrigger library
	23	*/
	24
	25	#include <cassert>
	26	#include "AliHLTTriggerAgent.h"
18a9a5ad	27	#include "AliHLTTriggerDecision.h"
8a8ea98b	28	#include "AliHLTGlobalTriggerDecision.h"
18a9a5ad	29	#include "AliHLTOUT.h"
	30	#include "AliHLTMessage.h"
	31	#include "AliESDEvent.h"
c86017ac	32	#include "TObjString.h"
c86017ac	33	#include "TObjArray.h"
18a9a5ad	34	#include "TArrayC.h"
8a8ea98b	35	#include "TFile.h"
8a8ea98b	36	#include "TTree.h"
89858ccc	37
89858ccc	38	// header files of library components
c86017ac	39	#include "AliHLTTriggerBarrelMultiplicity.h"
5f4502cc	40	#include "AliHLTD0Trigger.h"
5f4502cc	41	#include "AliHLTTriggerITSMultiplicity.h"
fde46e9e	42	#include "AliHLTTriggerBarrelGeomMultiplicity.h"
5d79eb88	43	#include "AliHLTGlobalTriggerComponent.h"
765d85f8	44	#include "AliHLTTriggerPhosClusterEnergy.h"
739e2587	45	#include "AliHLTTriggerEmcalClusterEnergy.h"
f86ecd3e	46	#include "AliHLTTriggerPhosMip.h"
495570cd	47	#include "AliHLTTriggerTrdClusterMultiplicity.h"
fc2b0c6d	48	#include "AliHLTTriggerGammaConversion.h"
c1550d2c	49	#include "AliHLTMuonSpectroTriggerComponent.h"
4d097162	50	#include "AliHLTUpcTriggerComponent.h"
411a92da	51	#include "AliHLTTriggerCosmics.h"
742ae1c4	52	#include "AliHLTTriggerCounterComponent.h"
4d097162	53
89858ccc	54
	55	/** global instance for agent registration */
	56	AliHLTTriggerAgent gAliHLTTriggerAgent;
	57
	58	/** ROOT macro for the implementation of ROOT specific class methods */
	59	ClassImp(AliHLTTriggerAgent)
	60
	61	AliHLTTriggerAgent::AliHLTTriggerAgent()
18a9a5ad	62	: AliHLTModuleAgent("Trigger")
18a9a5ad	63	, fTriggerDecisionHandler(NULL)
89858ccc	64	{
	65	// see header file for class documentation
	66	// or
	67	// refer to README to build package
	68	// or
	69	// visit http://web.ift.uib.no/~kjeks/doc/alice-hlt
	70	}
	71
	72	AliHLTTriggerAgent::~AliHLTTriggerAgent()
	73	{
	74	// see header file for class documentation
	75	}
	76
	77	int AliHLTTriggerAgent::RegisterComponents(AliHLTComponentHandler* pHandler) const
	78	{
	79	// see header file for class documentation
	80	assert(pHandler);
	81	if (!pHandler) return -EINVAL;
5d79eb88	82	pHandler->AddComponent(new AliHLTGlobalTriggerComponent);
c86017ac	83	pHandler->AddComponent(new AliHLTTriggerBarrelMultiplicity);
5f4502cc	84	pHandler->AddComponent(new AliHLTTriggerITSMultiplicity);
5f4502cc	85	pHandler->AddComponent(new AliHLTD0Trigger);
fde46e9e	86	pHandler->AddComponent(new AliHLTTriggerBarrelGeomMultiplicity);
765d85f8	87	pHandler->AddComponent(new AliHLTTriggerPhosClusterEnergy);
739e2587	88	pHandler->AddComponent(new AliHLTTriggerEmcalClusterEnergy);
f86ecd3e	89	pHandler->AddComponent(new AliHLTTriggerPhosMip);
fc2b0c6d	90	pHandler->AddComponent(new AliHLTTriggerTrdClusterMultiplicity);
fc2b0c6d	91	pHandler->AddComponent(new AliHLTTriggerGammaConversion);
c1550d2c	92	pHandler->AddComponent(new AliHLTMuonSpectroTriggerComponent);
4d097162	93	pHandler->AddComponent(new AliHLTUpcTriggerComponent);
411a92da	94	pHandler->AddComponent(new AliHLTTriggerCosmics);
742ae1c4	95	pHandler->AddComponent(new AliHLTTriggerCounterComponent);
89858ccc	96	return 0;
	97	}
	98
c86017ac	99	int AliHLTTriggerAgent::CreateConfigurations(AliHLTConfigurationHandler* pHandler,
f7aab453	100	AliRawReader* rawReader,
f7aab453	101	AliRunLoader* runloader) const
c86017ac	102	{
	103	// see header file for class documentation
	104	if (!pHandler) return -EINVAL;
	105
	106	TString triggerInputs;
	107	TString triggerOutputs;
	108	TString configurationId;
	109	/////////////////////////////////////////////////////////////////////////////////////
	110	//
	111	// a central barrel charged particle multiplicity trigger
	112	configurationId="TRIGGER-Barrel-Multiplicity";
	113
feb0a3ff	114	// define the inputs for the BarrelMultiplicityTrigger
c86017ac	115	triggerInputs="GLOBAL-esd-converter";
	116
	117	// check for the availibility
	118	TObjArray* pTokens=triggerInputs.Tokenize(" ");
	119	triggerInputs="";
	120	if (pTokens) {
	121	for (int n=0; n<pTokens->GetEntriesFast(); n++) {
	122	TString module=((TObjString*)pTokens->At(n))->GetString();
	123	if (pHandler->FindConfiguration(module.Data())) {
	124	triggerInputs+=module;
	125	triggerInputs+=" ";
	126	}
	127	}
	128	delete pTokens;
	129	}
	130
feb0a3ff	131	TString arg;
c86017ac	132	if (triggerInputs.Length()>0) {
feb0a3ff	133	// define multiple instances of the BarrelMultiplicityTrigger with different settings
c86017ac	134	HLTInfo("Configuring inputs for %s: %s", configurationId.Data(), triggerInputs.Data());
	135	pHandler->CreateConfiguration(configurationId.Data(), "BarrelMultiplicityTrigger", triggerInputs.Data(), "");
	136	if (triggerOutputs.Length()>0) triggerOutputs+=" ";
	137	triggerOutputs+=configurationId;
feb0a3ff	138
	139	configurationId="TRIGGER-Barrel-HighMultiplicity";
	140	arg="-triggername BarrelHighMultiplicity";
	141	pHandler->CreateConfiguration(configurationId.Data(), "BarrelMultiplicityTrigger", triggerInputs.Data(), arg.Data());
	142	if (triggerOutputs.Length()>0) triggerOutputs+=" ";
	143	triggerOutputs+=configurationId;
	144
	145	configurationId="TRIGGER-Barrel-Pt_v01";
	146	arg="-triggername BarrelPt_v01";
	147	pHandler->CreateConfiguration(configurationId.Data(), "BarrelMultiplicityTrigger", triggerInputs.Data(), arg.Data());
	148	if (triggerOutputs.Length()>0) triggerOutputs+=" ";
	149	triggerOutputs+=configurationId;
	150
	151	configurationId="TRIGGER-Barrel-Pt_v02";
	152	arg="-triggername BarrelPt_v02";
	153	pHandler->CreateConfiguration(configurationId.Data(), "BarrelMultiplicityTrigger", triggerInputs.Data(), arg.Data());
	154	if (triggerOutputs.Length()>0) triggerOutputs+=" ";
	155	triggerOutputs+=configurationId;
	156
	157	configurationId="TRIGGER-Barrel-Pt_v03";
	158	arg="-triggername BarrelPt_v03";
	159	pHandler->CreateConfiguration(configurationId.Data(), "BarrelMultiplicityTrigger", triggerInputs.Data(), arg.Data());
	160	if (triggerOutputs.Length()>0) triggerOutputs+=" ";
	161	triggerOutputs+=configurationId;
c86017ac	162	} else {
	163	HLTWarning("No inputs for %s found, skipping component", configurationId.Data());
	164	}
c1550d2c	165
	166	/////////////////////////////////////////////////////////////////////////////////////
	167	// The muon spectrometer trigger
	168	configurationId = "TRIGGER-Muon-Spectrometer";
	169
	170	// define the inputsfor the muon spectrometer trigger.
	171	if (pHandler->FindConfiguration("dHLT-sim-fromRaw")) {
	172	triggerInputs = "dHLT-sim-fromRaw";
	173	}
	174	else if (pHandler->FindConfiguration("dHLT-sim")) {
	175	triggerInputs = "dHLT-sim";
	176	}
	177	else if (pHandler->FindConfiguration("dHLT-sim-fromMC")) {
	178	triggerInputs = "dHLT-sim-fromMC";
	179	}
	180
	181	if (triggerInputs.Length() > 0) {
	182	HLTInfo("Configuring inputs for %s: %s", configurationId.Data(), triggerInputs.Data());
	183	pHandler->CreateConfiguration(configurationId.Data(), "MuonSpectroTrigger", triggerInputs.Data(), "-makestats");
	184	if (triggerOutputs.Length() > 0) triggerOutputs += " ";
	185	triggerOutputs += configurationId;
	186	} else {
	187	HLTWarning("No inputs for %s found, skipping component.", configurationId.Data());
	188	}
c86017ac	189
f7aab453	190	/////////////////////////////////////////////////////////////////////////////////////
	191	// D0 trigger
	192	configurationId = "TRIGGER-D0";
	193	if(runloader && !rawReader){
	194	// simulation without simulated raw data
0f4240c3	195	// use ESD as input
f7aab453	196	triggerInputs="GLOBAL-esd-converter ";
f7aab453	197	}
	198	else{
	199	// simulation with simulated raw data, or raw data reconstruction
	200	// use input from ITS tracker and vertexer directly
	201	triggerInputs="ITS-tracker GLOBAL-vertexer";
	202	}
	203
	204	// check for the availibility of inputs
	205	pTokens=triggerInputs.Tokenize(" ");
	206	triggerInputs="";
	207	if (pTokens) {
	208	for (int n=0; n<pTokens->GetEntriesFast(); n++) {
	209	TString module=((TObjString*)pTokens->At(n))->GetString();
	210	if (pHandler->FindConfiguration(module.Data())) {
	211	triggerInputs+=module;
	212	triggerInputs+=" ";
	213	}
	214	}
	215	delete pTokens;
	216	}
	217
	218	TString argD0 = "";
	219	if (triggerInputs.Length()>0) {
	220	HLTInfo("Configuring inputs for %s: %s", configurationId.Data(), triggerInputs.Data());
	221	pHandler->CreateConfiguration(configurationId.Data(), "D0Trigger", triggerInputs.Data(), argD0.Data());
94001d9d	222	// FIXME: due to a rare segfault for reconstruction of PbPb data the
	223	// component is temporarily excluded
	224	// https://savannah.cern.ch/bugs/?72590
	225	//if (triggerOutputs.Length()>0) triggerOutputs+=" ";
	226	//triggerOutputs+=configurationId;
f7aab453	227	} else {
	228	HLTWarning("No inputs for %s found, skipping component", configurationId.Data());
	229	}
	230
c86017ac	231	/////////////////////////////////////////////////////////////////////////////////////
	232	//
	233	// the global trigger component
	234	configurationId="GLOBAL-Trigger";
	235	HLTInfo("setting inputs for %s: %s", configurationId.Data(), triggerOutputs.IsNull()?"none":triggerOutputs.Data());
	236	pHandler->CreateConfiguration(configurationId.Data(), "HLTGlobalTrigger", triggerOutputs.Data(), "");
	237
	238	return 0;
	239	}
	240
	241	const char* AliHLTTriggerAgent::GetReconstructionChains(AliRawReader* /rawReader/,
	242	AliRunLoader* runloader) const
	243	{
	244	// see header file for class documentation
	245	if (runloader) {
	246	// reconstruction chains for AliRoot simulation
	247	// Note: run loader is only available while running embedded into
	248	// AliRoot simulation
	249
	250	// currently disabled due to a problem compiling the runtime trigger library
18a9a5ad	251	return "GLOBAL-Trigger";
c86017ac	252	}
	253	return NULL;
	254	}
	255
	256	const char* AliHLTTriggerAgent::GetRequiredComponentLibraries() const
	257	{
	258	// see header file for class documentation
	259
86aebdca	260	return "";
c86017ac	261	}
c86017ac	262
89858ccc	263	int AliHLTTriggerAgent::GetHandlerDescription(AliHLTComponentDataType dt,
	264	AliHLTUInt32_t /spec/,
	265	AliHLTOUTHandlerDesc& desc) const
	266	{
	267	// see header file for class documentation
	268
18a9a5ad	269	// handler of the trigger decisions {'ROOTTOBJ':'HLT '}
	270	// currently stored as a TObject with the common data type and origin
	271	// HLTOUT. However we might need a separate data type in order to
	272	// avoid interference with other handlers
	273	// the handler produces an ESD object in order to be merged to the
	274	// hltEsd afterwards
8a8ea98b	275	// 2009-11-17 adding the data tyepes for (global) trigger decisions
	276	// the TObject data types stays for a while in order to preserve
	277	// backward compatibility
	278	if (dt==(kAliHLTDataTypeTObject\|kAliHLTDataOriginOut) \|\|
	279	dt==kAliHLTDataTypeTriggerDecision \|\|
	280	dt==kAliHLTDataTypeGlobalTrigger) {
18a9a5ad	281	desc=AliHLTOUTHandlerDesc(AliHLTModuleAgent::kEsd, dt, GetModuleId());
	282	return 1;
	283	}
	284
89858ccc	285	// handler for the HLT readou list and trigger data data blocks {'HLTRDLST':'HLT '}
	286	if (dt==AliHLTComponentDataTypeInitializer("HLTRDLST", kAliHLTDataOriginOut) \|\|
	287	dt==AliHLTComponentDataTypeInitializer("HLTTRGDT", kAliHLTDataOriginOut)) {
	288	desc=AliHLTOUTHandlerDesc(kProprietary, dt, GetModuleId());
	289	return 1;
	290	}
	291
	292	return 0;
	293	}
	294
	295	AliHLTOUTHandler* AliHLTTriggerAgent::GetOutputHandler(AliHLTComponentDataType dt,
18a9a5ad	296	AliHLTUInt32_t /spec/)
89858ccc	297	{
	298	// see header file for class documentation
	299
18a9a5ad	300	// raw data blocks to be fed into offline reconstruction
8a8ea98b	301	if ((dt==(kAliHLTDataTypeTObject\|kAliHLTDataOriginOut) \|\|
	302	(dt==kAliHLTDataTypeTriggerDecision) \|\|
	303	(dt==kAliHLTDataTypeGlobalTrigger))) {
18a9a5ad	304	if (!fTriggerDecisionHandler) {
	305	fTriggerDecisionHandler=new AliHLTTriggerAgent::AliHLTTriggerDecisionHandler;
	306	}
	307	return fTriggerDecisionHandler;
	308	}
	309
89858ccc	310	// handler for the HLT readou list and trigger data data blocks {'HLTRDLST':'HLT '}
	311	if (dt==AliHLTComponentDataTypeInitializer("HLTRDLST", kAliHLTDataOriginOut) \|\|
	312	dt==AliHLTComponentDataTypeInitializer("HLTTRGDT", kAliHLTDataOriginOut)) {
	313	return NULL;
	314	}
	315
	316	return NULL;
	317	}
	318
	319	int AliHLTTriggerAgent::DeleteOutputHandler(AliHLTOUTHandler* pInstance)
	320	{
	321	// see header file for class documentation
	322	if (pInstance==NULL) return -EINVAL;
	323
18a9a5ad	324	if (pInstance==fTriggerDecisionHandler) {
	325	delete fTriggerDecisionHandler;
	326	fTriggerDecisionHandler=NULL;
	327	}
	328
89858ccc	329	return 0;
89858ccc	330	}
18a9a5ad	331
	332	AliHLTTriggerAgent::AliHLTTriggerDecisionHandler::AliHLTTriggerDecisionHandler()
	333	: AliHLTOUTHandler()
	334	, fESD(NULL)
	335	, fpData(NULL)
	336	, fSize(0)
8a8ea98b	337	, fpESDfile(NULL)
8a8ea98b	338	, fpESDtree(NULL)
18a9a5ad	339	{
	340	// see header file for class documentation
	341	}
	342
	343	AliHLTTriggerAgent::AliHLTTriggerDecisionHandler::~AliHLTTriggerDecisionHandler()
	344	{
	345	// see header file for class documentation
8a8ea98b	346	if (fpESDtree) {
	347	fpESDtree->GetUserInfo()->Clear();
	348	delete fpESDtree;
	349	}
	350	fpESDtree=NULL;
	351
	352	if (fpESDfile) {
	353	fpESDfile->Close();
	354	delete fpESDfile;
	355	}
	356	fpESDfile=NULL;
	357
18a9a5ad	358	if (fESD) delete fESD;
	359	fESD=NULL;
	360
	361	if (fpData) delete fpData;
	362	fpData=NULL;
	363	fSize=0;
	364	}
	365
	366	int AliHLTTriggerAgent::AliHLTTriggerDecisionHandler::ProcessData(AliHLTOUT* pData)
	367	{
	368	// see header file for class documentation
	369	if (!pData) return -EINVAL;
8a8ea98b	370	int iResult=0;
	371	AliHLTGlobalTriggerDecision* pGlobalDecision=NULL;
	372	TObjArray triggerDecisions;
	373	triggerDecisions.SetOwner(kTRUE);
	374	for (iResult=pData->SelectFirstDataBlock(); iResult>=0; iResult=pData->SelectNextDataBlock()) {
	375	AliHLTComponentDataType dt=kAliHLTVoidDataType;
	376	AliHLTUInt32_t spec=kAliHLTVoidDataSpec;
	377	if ((iResult=pData->GetDataBlockDescription(dt, spec))<0) break;
18a9a5ad	378	TObject* pObject=pData->GetDataObject();
18a9a5ad	379	if (pObject) {
8a8ea98b	380	if(dt==kAliHLTDataTypeGlobalTrigger) {
	381	if (!pGlobalDecision) {
	382	if ((pGlobalDecision=dynamic_cast<AliHLTGlobalTriggerDecision*>(pObject))==NULL \|\|
	383	(pGlobalDecision=dynamic_cast<AliHLTGlobalTriggerDecision*>(pGlobalDecision->Clone()))==NULL) {
	384	HLTFatal("can not convert object of name %s (%s) to HLTGlobalTriggerDecsion according to data type", pObject->GetName(), pObject->Class()->GetName());
	385	}
	386	} else {
	387	HLTWarning("multiple HLT GlobalTrigger decision objects, ignoring all but the first one");
	388	}
	389	} else if (dt==kAliHLTDataTypeTriggerDecision) {
	390	if (pObject->IsA() == AliHLTTriggerDecision::Class() &&
	391	!(pObject->IsA() == AliHLTGlobalTriggerDecision::Class())) {
	392	AliHLTTriggerDecision* pDecision=dynamic_cast<AliHLTTriggerDecision*>(pObject);
	393	if (pDecision) {
	394	if (pGlobalDecision) {
	395	// add directly
	396	pGlobalDecision->AddTriggerInput(*pDecision);
	397	} else {
	398	// schedule
	399	triggerDecisions.Add(pDecision->Clone());
	400	}
	401	} else {
	402	HLTFatal("can not convert object of name %s (%s) to HLT TriggerDecsion according to data type", pObject->GetName(), pObject->Class()->GetName());
	403	}
	404	}
	405	} else if (dt==(kAliHLTDataTypeTObject\|kAliHLTDataOriginOut)){
	406	// this is the branch for keeping compatibility
	407	// the first version of the trigger framework was using the kAliHLTDataTypeTObject
	408	// data type instead of the specific data types for HLT triggers
	409	// this effects the cosmic data taken Sep to Oct 2009
	410	if (pObject->IsA() == AliHLTGlobalTriggerDecision::Class()) {
	411	if (!pGlobalDecision) {
	412	if ((pGlobalDecision=dynamic_cast<AliHLTGlobalTriggerDecision*>(pObject))==NULL \|\|
	413	(pGlobalDecision=dynamic_cast<AliHLTGlobalTriggerDecision*>(pGlobalDecision->Clone()))==NULL) {
	414	HLTFatal("can not convert object of name %s (%s) to HLTGlobalTriggerDecsion according to data type", pObject->GetName(), pObject->Class()->GetName());
	415	}
	416	} else {
	417	HLTWarning("multiple HLT GlobalTrigger decision objects, ignoring all but the first one");
	418	}
	419	} else if (pObject->IsA() == AliHLTTriggerDecision::Class()) {
	420	AliHLTTriggerDecision* pDecision=dynamic_cast<AliHLTTriggerDecision*>(pObject);
	421	if (pDecision) {
	422	if (pGlobalDecision) {
	423	// add directly
	424	pGlobalDecision->AddTriggerInput(*pDecision);
	425	} else {
	426	// schedule
	427	triggerDecisions.Add(pDecision->Clone());
	428	}
	429	} else {
	430	HLTFatal("can not convert object of name %s (%s) to HLT TriggerDecsion according to data type", pObject->GetName(), pObject->Class()->GetName());
	431	}
	432	}
	433	}
	434	pData->ReleaseDataObject(pObject);
	435	pObject=NULL;
	436	} else {
	437	HLTError("can not get TObject from HLTOUT buffer");
	438	iResult=-ENODATA;
	439	}
	440	}
	441	// -ENOENT just signals that there are no more entries
	442	if (iResult==-ENOENT) iResult=0;
	443
444	if (pGlobalDecision) {
445	for (int i=0; i<triggerDecisions.GetEntriesFast(); i++) {
446	if (triggerDecisions[i]) {
447	pGlobalDecision->AddTriggerInput(((AliHLTTriggerDecision)triggerDecisions[i]));
448	}
449	}
450	triggerDecisions.Delete();
451	AliHLTTriggerDecision* pDecision=pGlobalDecision;
452	{
30d84601	453	if (pDecision) {
e13512e4	454	//pDecision->Print();
30d84601	455	HLTDebug("extracted %s", pDecision->GetName());
18a9a5ad	456	if (!fESD) {
	457	// create the ESD container, but without std content
	458	fESD = new AliESDEvent;
	459	}
	460	if (!fpData) fpData=new TArrayC;
	461	if (fESD && fpData) {
	462	fESD->Reset();
30d84601	463	TObject* pESDObject=fESD->FindListObject("HLTGlobalTrigger");
	464	if (pESDObject) {
	465	// copy the content to the already existing object
8a8ea98b	466	pDecision->Copy(*pESDObject);
30d84601	467	} else {
30d84601	468	// add a new object
8a8ea98b	469	fESD->AddObject(pDecision->Clone());
30d84601	470	}
8a8ea98b	471	WriteESD();
18a9a5ad	472	AliHLTMessage* pMsg=AliHLTMessage::Stream(fESD);
	473	if (pMsg) {
	474	if (!pMsg->CompBuffer()) {
	475	fSize=pMsg->Length();
	476	fpData->Set(fSize, pMsg->Buffer());
	477	} else {
	478	fSize=pMsg->CompLength();
	479	fpData->Set(fSize, pMsg->CompBuffer());
	480	}
d2f8c983	481	delete pMsg;
d2f8c983	482	pMsg=NULL;
18a9a5ad	483	} else {
	484	HLTError("streaming of objects failed");
	485	}
	486	} else {
	487	HLTError("memory allocation failed");
	488	iResult=-ENOMEM;
	489	}
18a9a5ad	490	}
18a9a5ad	491	}
8a8ea98b	492	delete pGlobalDecision;
	493	pGlobalDecision=NULL;
	494	} else {
	495	HLTError("no global trigger found in data collection");
18a9a5ad	496	}
8a8ea98b	497
e13512e4	498	if (iResult>=0) {
e13512e4	499	return fSize;
e13512e4	500	}
18a9a5ad	501	fSize=0;
	502	return iResult;
	503	}
	504
	505	int AliHLTTriggerAgent::AliHLTTriggerDecisionHandler::GetProcessedData(const AliHLTUInt8_t* &pData)
	506	{
	507	// see header file for class documentation
	508	if (!fpData) {
	509	pData=NULL;
	510	return 0;
	511	}
	512
	513	pData=reinterpret_cast<AliHLTUInt8_t*>(fpData->GetArray());
	514	return fSize;
	515	}
	516
	517	int AliHLTTriggerAgent::AliHLTTriggerDecisionHandler::ReleaseProcessedData(const AliHLTUInt8_t* pData, int size)
	518	{
	519	// see header file for class documentation
	520	int iResult=0;
	521	if (!fpData \|\| size != fSize \|\|
	522	const_cast<AliHLTUInt8_t>(pData) != reinterpret_cast<AliHLTUInt8_t>(fpData->GetArray())) {
	523	HLTError("attempt to release to wrong data buffer %p size %d, expected %p size %d", pData, size, fpData?fpData->GetArray():NULL, fSize);
	524	}
	525	fSize=0;
	526	return iResult;
	527	}
8a8ea98b	528
	529	int AliHLTTriggerAgent::AliHLTTriggerDecisionHandler::WriteESD()
	530	{
	531	// see header file for class documentation
	532	int iResult=0;
	533	if (!fESD) return 0;
	534	if (!fpESDfile) {
	535	fpESDfile=new TFile("HLTdecision.root", "RECREATE");
	536	}
	537	if (!fpESDtree) {
	538	fpESDtree=new TTree("HLTesdTree", "Tree with HLT ESD containing HLT decision");
	539	if (fpESDtree) {
	540	fESD->WriteToTree(fpESDtree);
	541	fpESDtree->GetUserInfo()->Add(fESD);
	542	}
	543	}
	544	if (!fpESDfile \|\| !fpESDtree) return -ENOMEM;
	545
	546	fpESDtree->Fill();
	547	fpESDfile->cd();
	548	fpESDtree->Write(fpESDtree->GetName(),TObject::kOverwrite);
	549
	550	return iResult;
	551	}