#--------------------------------------------------------------------------------#
set ( CLASS_HDRS
+ AliHLTGlobalFlatEsdTestComponent.h
AliHLTGlobalFlatEsdConverterComponent.h
AliHLTGlobalEsdConverterComponent.h
AliHLTGlobalTrackMergerComponent.h
AliFlatESDV0.h
AliFlatExternalTrackParam.h
AliFlatTPCCluster.h
+ AliFlatESDFriend.h
+ AliFlatESDFriendTrack.h
physics/AliHLTV0HistoComponent.h
physics/AliHLTCaloHistoComponent.h
physics/AliHLTCaloHistoProducer.h
--- /dev/null
+/* $Id$ */
+
+/**************************************************************************
+ * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ * *
+ * Author: The ALICE Off-line Project. *
+ * Contributors are mentioned in the code where appropriate. *
+ * *
+ * Permission to use, copy, modify and distribute this software and its *
+ * documentation strictly for non-commercial purposes is hereby granted *
+ * without fee, provided that the above copyright notice appears in all *
+ * copies and that both the copyright notice and this permission notice *
+ * appear in the supporting documentation. The authors make no claims *
+ * about the suitability of this software for any purpose. It is *
+ * provided "as is" without express or implied warranty. *
+ **************************************************************************/
+
+/**
+ * >> Flat structure representing an ESD friend <<
+ *
+ * To be used in the online and offline calibration schema.
+ *
+ * Class provides interface methods for
+ * - Filling from AliESDfriend, but also from HLT
+ * - Getter methods
+ *
+ * In the online case, the structure can be directly written into a shared
+ * memory, in the offline case, the size has to be estimated first.
+ *
+ *
+ * Primary Authors : Sergey Gorbunov, Jochen Thaeder, Chiara Zampolli
+ *
+ * ************************************************************************
+ **/
+
+#include "AliFlatESDFriend.h"
+#include "AliFlatESDFriendTrack.h"
+#include "Riostream.h"
+
+// _______________________________________________________________________________________________________
+AliFlatESDFriend::AliFlatESDFriend() :
+ fContentSize(0),
+ fBitFlags(0),
+ fNTracks(0),
+ fNTrackEntries(0),
+ fTrackTablePointer(0),
+ fTracksPointer(0)
+{
+ // Default constructor
+ Reset();
+}
+
+void AliFlatESDFriend::Reset()
+{
+ fBitFlags = 0;
+ fNTracks = 0;
+ fNTrackEntries = 0;
+ fTrackTablePointer = 0;
+ fTracksPointer = 0;
+ for( int i=0; i<72; i++ ){
+ fNclustersTPC[i]=0;
+ fNclustersTPCused[i]=0;
+ }
+ // We set size of the fContent array such, that it reaches the end of the AliFlatESDFriend structure.
+ // To be sure that actual GetSize() is always >= size of the structure.
+ // First, it makes the memory alignment better. Second, just for a case..
+ fContentSize = sizeof(AliFlatESDFriend) - (fContent - reinterpret_cast<const Byte_t*>(this));
+ for( UInt_t i=0; i<fContentSize; i++ ) fContent[i]=0;
+}
+
+// _______________________________________________________________________________________________________
+AliFlatESDFriend::AliFlatESDFriend(AliFlatESDSpecialConstructorFlag f) :
+ fContentSize(),
+ fBitFlags(),
+ fNTracks(),
+ fNTrackEntries(),
+ fTrackTablePointer(),
+ fTracksPointer()
+{
+ //special constructor, used to restore the vtable pointer
+ //uses the special dummy constructors of contained objects
+
+ // the vtable pointer for this AliFlatESDFriend object is already reset when this constructor is called
+ // we should only initialise vtable pointers for all contained objects
+
+ if(f == AliFlatESDReinitialize){
+ for( int i=0; i<fNTracks; i++ ){
+ AliFlatESDFriendTrack *tr = GetFlatTrackNonConst(i);
+ if( tr ) tr->Reinitialize();
+ }
+ }
+ else{
+ AliFlatESDFriend();
+ }
+}
+
+void AliFlatESDFriend::Ls() const
+{
+ cout<<"Flat ESD friend: "<<endl;
+ cout<<" N tracks: "<<fNTracks<<endl;
+ cout<<" N track entries: "<<fNTrackEntries<<endl;
+}
--- /dev/null
+#ifndef ALIFLATESDFRIEND_H
+#define ALIFLATESDFRIEND_H
+
+/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ * See cxx source for full Copyright notice *
+ * Primary Authors : Sergey Gorbunov, Jochen Thaeder, Chiara Zampolli */
+
+/*
+ * See implementation file for documentation
+ */
+
+#include "Rtypes.h"
+#include "AliFlatESDMisc.h"
+#include "AliVVeventFriend.h"
+#include "AliFlatESDFriendTrack.h"
+
+class AliVVVZEROfriend;
+class AliVVTZEROfriend;
+
+//_____________________________________________________________________________
+class AliFlatESDFriend : public AliVVfriend {
+public:
+ AliFlatESDFriend();
+ ~AliFlatESDFriend() {}
+
+ // Implementation of virtual methods of AliVVfriend
+
+ Int_t GetNumberOfTracks() const { return fNTracks; }
+ Int_t GetEntriesInTracks() const { return fNTrackEntries; }
+ const AliVVfriendTrack* GetTrack(Int_t i) const {return GetFlatTrack(i); }
+
+ AliVVVZEROfriend *GetVZEROfriend(){ return NULL; }
+ AliVVTZEROfriend *GetTZEROfriend(){ return NULL; }
+
+ void Ls() const;
+
+ void Reset();
+
+ Bool_t TestSkipBit() const { return (fBitFlags!=0); }
+
+ Int_t GetNclustersTPC(UInt_t sector) const { return (sector<72)?fNclustersTPC[sector]:0; }
+ Int_t GetNclustersTPCused(UInt_t sector) const { return (sector<72)?fNclustersTPCused[sector]:0; }
+
+ //virtual void AddTrack(const AliVVfriendTrack *t) {}
+ //virtual void AddTrackAt(const AliVVfriendTrack* /*t*/, Int_t /*i*/) {}
+ //virtual void SetVZEROfriend(AliESDVZEROfriend* /*obj*/) {}
+ //virtual void SetTZEROfriend(AliESDTZEROfriend * obj) {}
+ //void SetSkipBit(Bool_t skip){}
+
+ // Own methods
+
+ void SetSkipBit(Bool_t skip){ fBitFlags = skip; }
+ void SetNclustersTPC(UInt_t sector, Int_t occupancy ) { if (sector<72) fNclustersTPC[sector]=occupancy; }
+ void SetNclustersTPCused(UInt_t sector, Int_t occupancy ) {if (sector<72) fNclustersTPCused[sector]=occupancy; }
+
+ const AliFlatESDFriendTrack *GetFlatTrack( Int_t i ) const {
+ const Long64_t *table = reinterpret_cast<const Long64_t*> (fContent + fTrackTablePointer);
+ if( i<0 || i>fNTracks || table[i]<0 ) return NULL;
+ return reinterpret_cast<const AliFlatESDFriendTrack*>( fContent + table[i] );
+ }
+
+ // -- Size methods
+
+ ULong64_t GetSize() const { return fContent - reinterpret_cast<const Byte_t*>(this) + fContentSize; }
+
+ void Reinitialize()
+ {
+ new (this) AliFlatESDFriend(AliFlatESDReinitialize);
+ }
+
+private:
+
+ AliFlatESDFriend(const AliFlatESDFriend&);
+ AliFlatESDFriend& operator=(const AliFlatESDFriend& );
+
+ // special constructor, to be called by placement new,
+ // when accessing information after reinterpret_cast
+ // so that vtable is generated, but values are not overwritten
+ AliFlatESDFriend(AliFlatESDSpecialConstructorFlag);
+
+ AliFlatESDFriendTrack *GetFlatTrackNonConst( Int_t i ){
+ const Long64_t *table = reinterpret_cast<const Long64_t*> (fContent + fTrackTablePointer);
+ if( i<0 || i>fNTracks || table[i]<0 ) return NULL;
+ return reinterpret_cast<AliFlatESDFriendTrack*>( fContent + table[i] );
+ }
+
+ size_t fContentSize; // Size of fContent
+ UInt_t fBitFlags; // bit flags
+ Int_t fNTracks; // Number of tracks in vector
+ Int_t fNTrackEntries; // Number of non-empty track friends in vector
+ Int_t fNclustersTPC[72]; //cluster occupancy per sector per sector
+ Int_t fNclustersTPCused[72]; //number of clusters used in tracking per sector
+
+ // Pointers to specific data in fContent
+
+ size_t fTrackTablePointer; // position of the first track in fContent
+ size_t fTracksPointer; // position of the first track in fContent
+
+ // -- Variable Size Object
+
+ Byte_t fContent[1]; // Variale size object, which contains all data
+};
+
+#endif
--- /dev/null
+/* $Id$ */
+
+/**************************************************************************
+ * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ * *
+ * Author: The ALICE Off-line Project. *
+ * Contributors are mentioned in the code where appropriate. *
+ * *
+ * Permission to use, copy, modify and distribute this software and its *
+ * documentation strictly for non-commercial purposes is hereby granted *
+ * without fee, provided that the above copyright notice appears in all *
+ * copies and that both the copyright notice and this permission notice *
+ * appear in the supporting documentation. The authors make no claims *
+ * about the suitability of this software for any purpose. It is *
+ * provided "as is" without express or implied warranty. *
+ **************************************************************************/
+
+/**
+ * >> Flat structure representing an ESDTrack <<
+ *
+ * To be used in the online and offline calibration schema.
+ *
+ * Class provides interface methods for
+ * - Filling from AliESDtrack and AliExternalTrackParam, as well
+ * as clusters from ESD friends (if requested)
+ * - HLT Filling to be added
+ *
+ *
+ * Primary Authors : Sergey Gorbunov, Jochen Thaeder, Chiara Zampolli
+ *
+ **************************************************************************/
+
+
+#include "AliFlatESDFriendTrack.h"
+#include "AliExternalTrackParam.h"
+#include "Riostream.h"
+
+// _______________________________________________________________________________________________________
+AliFlatESDFriendTrack::AliFlatESDFriendTrack() :
+ AliVVfriendTrack()
+{
+ // Default constructor
+}
+
+
+// _______________________________________________________________________________________________________
+AliFlatESDFriendTrack::AliFlatESDFriendTrack(AliFlatESDSpecialConstructorFlag f) :
+ AliVVfriendTrack()
+{
+ //special constructor, used to restore the vtable pointer
+ //uses the special dummy constructors of contained objects
+
+ // the vtable pointer for this AliFlatESDFriend object is already reset when this constructor is called
+ // we should only initialise vtable pointers for all contained objects
+
+ if(f == AliFlatESDReinitialize){
+ }
+ else{
+ AliFlatESDFriendTrack();
+ }
+}
--- /dev/null
+#ifndef ALIFLATESDFRIENDTRACK_H
+#define ALIFLATESDFRIENDTRACK_H
+
+/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ * See cxx source for full Copyright notice *
+ * Primary Authors : Sergey Gorbunov, Jochen Thaeder, Chiara Zampolli */
+
+/*
+ * See implementation file for documentation
+ */
+
+/*
+Cp - Track parameters constrained to the primary vertex
+Ip - Track parameters estimated at the inner wall of TPC
+TPCInner - Track parameters estimated at the inner wall of TPC using the TPC stand-alone
+Op - Track parameters estimated at the point of maximal radial coordinate reached during the tracking
+*/
+
+#include "Rtypes.h"
+
+#include "AliFlatTPCCluster.h"
+#include "AliVVfriendTrack.h"
+#include "AliFlatESDMisc.h"
+
+class AliESDtrack;
+class AliESDfriendTrack;
+class AliExternalTrackParam;
+
+class AliFlatESDFriendTrack :public AliVVfriendTrack
+{
+ public:
+ AliFlatESDFriendTrack();
+ ~AliFlatESDFriendTrack() {}
+
+ //implementation of AliVVfriendTrack methods
+
+ AliVVTPCseed* GetTPCseed() const {return NULL;}
+ AliVVTRDseed* GetTRDseed() const {return NULL;}
+ const AliTrackPointArray *GetTrackPointArray() const { return NULL; }
+ const AliExternalTrackParam * GetITSOut() const { return NULL; }
+ const AliExternalTrackParam * GetTPCOut() const { return NULL; }
+ const AliExternalTrackParam * GetTRDIn() const { return NULL; }
+
+ // own methods
+
+ void Reinitialize()
+ {
+ new (this) AliFlatESDFriendTrack(AliFlatESDReinitialize);
+ }
+
+private:
+ AliFlatESDFriendTrack(const AliFlatESDFriendTrack &);
+ AliFlatESDFriendTrack& operator=(const AliFlatESDFriendTrack& );
+
+ // special constructor, to be called by placement new,
+ // when accessing information after reinterpret_cast
+ // so that vtable is generated, but values are not overwritten
+ AliFlatESDFriendTrack(AliFlatESDSpecialConstructorFlag);
+
+};
+
+
+#endif
#include "AliHLTConfigurationHandler.h"
#include "TObjString.h"
#include "TObjArray.h"
+#include "AliHLTGlobalFlatEsdTestComponent.h"
// header files of library components
#include "AliHLTGlobalTrackMergerComponent.h"
// see header file for class documentation
assert(pHandler);
if (!pHandler) return -EINVAL;
+ pHandler->AddComponent(new AliHLTGlobalFlatEsdTestComponent);
pHandler->AddComponent(new AliHLTGlobalTrackMergerComponent);
pHandler->AddComponent(new AliHLTGlobalFlatEsdConverterComponent);
pHandler->AddComponent(new AliHLTGlobalEsdConverterComponent);
pHandler->CreateConfiguration("GLOBAL-flat-esd-converter", "GlobalFlatEsdConverter", esdInputs.Data(), "");
pHandler->CreateConfiguration("GLOBAL-esd-converter", "GlobalEsdConverter", esdInputs.Data(), "");
+ pHandler->CreateConfiguration("GLOBAL-flat-esd-test", "GlobalFlatEsdTest", "GLOBAL-esd-converter GLOBAL-flat-esd-converter", "");
///////////////////////////////////////////////////////////////////////////////////////////////////
//
--- /dev/null
+// $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 AliHLTGlobalFlatEsdTestComponent.cxx
+// @author Matthias Richter
+// @date
+// @brief Global ESD converter component.
+//
+
+// see header file for class documentation
+// or
+// refer to README to build package
+// or
+// visit http://web.ift.uib.no/~kjeks/doc/alice-hlt
+
+#include <cassert>
+#include "AliHLTGlobalFlatEsdTestComponent.h"
+#include "AliFlatESDEvent.h"
+#include "AliFlatESDTrack.h"
+#include "AliFlatExternalTrackParam.h"
+#include "AliExternalTrackParam.h"
+
+#include "AliHLTGlobalBarrelTrack.h"
+#include "AliHLTExternalTrackParam.h"
+#include "AliHLTTrackMCLabel.h"
+#include "AliHLTCTPData.h"
+#include "AliHLTErrorGuard.h"
+#include "AliESDEvent.h"
+#include "AliESDtrack.h"
+#include "AliESDMuonTrack.h"
+#include "AliESDMuonCluster.h"
+#include "AliCDBEntry.h"
+#include "AliCDBManager.h"
+#include "AliPID.h"
+#include "TTree.h"
+#include "TList.h"
+#include "TClonesArray.h"
+//#include "AliHLTESDCaloClusterMaker.h"
+//#include "AliHLTCaloClusterDataStruct.h"
+//#include "AliHLTCaloClusterReader.h"
+//#include "AliESDCaloCluster.h"
+//#include "AliESDVZERO.h"
+#include "AliHLTGlobalVertexerComponent.h"
+#include "AliHLTVertexFinderBase.h"
+#include "AliHLTTPCSpacePointData.h"
+#include "AliHLTTPCClusterDataFormat.h"
+#include "AliHLTTPCDefinitions.h"
+#include "AliHLTTPCClusterMCData.h"
+#include "AliHLTTPCTransform.h"
+
+/** ROOT macro for the implementation of ROOT specific class methods */
+ClassImp(AliHLTGlobalFlatEsdTestComponent)
+
+AliHLTGlobalFlatEsdTestComponent::AliHLTGlobalFlatEsdTestComponent()
+ : AliHLTProcessor()
+ , fWriteClusters(0)
+ , fVerbosity(0)
+ , fSolenoidBz(-5.00668)
+ , fBenchmark("FlatEsdTest")
+{
+ // see header file for class documentation
+ // or
+ // refer to README to build package
+ // or
+ // visit http://web.ift.uib.no/~kjeks/doc/alice-hlt
+}
+
+AliHLTGlobalFlatEsdTestComponent::~AliHLTGlobalFlatEsdTestComponent()
+{
+ // see header file for class documentation
+}
+
+int AliHLTGlobalFlatEsdTestComponent::Configure(const char* arguments)
+{
+ // see header file for class documentation
+ int iResult=0;
+ if (!arguments) return iResult;
+
+ 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))->String();
+ if (argument.IsNull()) continue;
+ 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 AliHLTGlobalFlatEsdTestComponent::Reconfigure(const char* cdbEntry, const char* chainId)
+{
+ // see header file for class documentation
+ int iResult=0;
+ const char* path=NULL;
+ 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->String().Data());
+ iResult=Configure(pString->String().Data());
+ } else {
+ HLTError("configuration object \"%s\" has wrong type, required TObjString", path);
+ }
+ } else {
+ HLTError("can not fetch object \"%s\" from CDB", path);
+ }
+ }
+
+ return iResult;
+}
+
+void AliHLTGlobalFlatEsdTestComponent::GetInputDataTypes(AliHLTComponentDataTypeList& list)
+{
+ // see header file for class documentation
+ list.push_back(kAliHLTDataTypeFlatESD|kAliHLTDataOriginOut);
+ list.push_back(kAliHLTDataTypeESDObject|kAliHLTDataOriginOut);
+}
+
+AliHLTComponentDataType AliHLTGlobalFlatEsdTestComponent::GetOutputDataType()
+{
+ // see header file for class documentation
+ return kAliHLTDataTypeFlatESD|kAliHLTDataOriginOut;
+}
+
+void AliHLTGlobalFlatEsdTestComponent::GetOutputDataSize(unsigned long& constBase, double& inputMultiplier)
+{
+ // see header file for class documentation
+ constBase=2000000;
+ inputMultiplier=10.0;
+}
+
+int AliHLTGlobalFlatEsdTestComponent::DoInit(int argc, const char** argv)
+{
+ // see header file for class documentation
+ int iResult=0;
+ TString argument="";
+ int bMissingParam=0;
+
+ // default list of skiped ESD objects
+ TString skipObjects=
+ // "AliESDRun,"
+ // "AliESDHeader,"
+ // "AliESDZDC,"
+ "AliESDFMD,"
+ // "AliESDVZERO,"
+ // "AliESDTZERO,"
+ // "TPCVertex,"
+ // "SPDVertex,"
+ // "PrimaryVertex,"
+ // "AliMultiplicity,"
+ // "PHOSTrigger,"
+ // "EMCALTrigger,"
+ // "SPDPileupVertices,"
+ // "TrkPileupVertices,"
+ "Cascades,"
+ "Kinks,"
+ "AliRawDataErrorLogs,"
+ "AliESDACORDE";
+
+ iResult=Reconfigure(NULL, NULL);
+ TString allArgs = "";
+ for ( int i = 0; i < argc; i++ ) {
+ if ( !allArgs.IsNull() ) allArgs += " ";
+ allArgs += argv[i];
+ }
+
+ TObjArray* pTokens=allArgs.Tokenize(" ");
+ if (pTokens) {
+ for (int i=0; i<pTokens->GetEntries() && iResult>=0; i++) {
+ argument=((TObjString*)pTokens->At(i))->String();
+ if (argument.IsNull()) continue;
+
+ // -noclusters
+ if (argument.CompareTo("-noclusters")==0) {
+ fWriteClusters=0;
+ // -clusters
+ } else if (argument.CompareTo("-clusters")==0) {
+ fWriteClusters=1;
+ } else if (argument.Contains("-skipobject=")) {
+ argument.ReplaceAll("-skipobject=", "");
+ skipObjects=argument;
+ } else {
+ HLTError("unknown argument %s", argument.Data());
+ iResult=-EINVAL;
+ break;
+ }
+ }
+ }
+ if (bMissingParam) {
+ HLTError("missing parameter for argument %s", argument.Data());
+ iResult=-EINVAL;
+ }
+
+ fSolenoidBz=GetBz();
+
+ if (iResult>=0) {
+ SetupCTPData();
+ }
+
+ fBenchmark.SetTimer(0,"total");
+
+ return iResult;
+}
+
+int AliHLTGlobalFlatEsdTestComponent::DoDeinit()
+{
+ // see header file for class documentation
+
+ return 0;
+}
+
+int AliHLTGlobalFlatEsdTestComponent::DoEvent( const AliHLTComponentEventData& /*evtData*/,
+ const AliHLTComponentBlockData* /*blocks*/,
+ AliHLTComponentTriggerData& /*trigData*/,
+ AliHLTUInt8_t* outputPtr,
+ AliHLTUInt32_t& size,
+ AliHLTComponentBlockDataList& outputBlocks )
+{
+ // see header file for class documentation
+ int iResult=0;
+
+ if (!IsDataEvent()) return iResult;
+
+ fBenchmark.StartNewEvent();
+ fBenchmark.Start(0);
+
+ size_t maxOutputSize = size;
+ size = 0;
+
+ fBenchmark.Stop(0);
+ HLTWarning( fBenchmark.GetStatistics() );
+
+ return iResult;
+}
+
--- /dev/null
+//-*- Mode: C++ -*-
+// $Id$
+#ifndef ALIHLTGLOBALFLATESDTESTCOMPONENT_H
+#define ALIHLTGLOBALFLATESDTESTCOMPONENT_H
+//* This file is property of and copyright by the ALICE HLT Project *
+//* ALICE Experiment at CERN, All rights reserved. *
+//* See cxx source for full Copyright notice *
+
+// @file AliHLTGlobalFlatEsdTestComponent.h
+// @author Matthias Richter
+// @date
+// @brief Global ESD converter component.
+// @note
+
+#include "AliHLTProcessor.h"
+#include "AliHLTComponentBenchmark.h"
+#include <vector>
+
+
+/**
+ * @class AliHLTGlobalFlatEsdTestComponent
+ * Global collector for information designated for the HLT ESD.
+ *
+ * componentid: \b GlobalEsdConverter <br>
+ * componentlibrary: \b libAliHLTGlobal.so <br>
+ * Arguments: <br>
+ * <!-- NOTE: ignore the \li. <i> and </i>: it's just doxygen formatting -->
+ * \li -notree <br>
+ * write ESD directly to output (::kAliHLTDataTypeESDObject)
+ * this has been made the default behavior in Sep 2008.
+ * \li -tree <br>
+ * write ESD directly to TTree and to output (::kAliHLTDataTypeESDTree)
+ * \li -skipobject=name1,name2,... <br>
+ * comma separated list of ESD object names to be skipped, default is
+ * AliESDZDC,AliESDFMD,Cascades,Kinks,AliRawDataErrorLogs,AliESDACORDE
+ * leave blank to disable the option
+ *
+ * @ingroup alihlt_tpc_components
+ */
+class AliHLTGlobalFlatEsdTestComponent : public AliHLTProcessor
+{
+ public:
+ /** standard constructor */
+ AliHLTGlobalFlatEsdTestComponent();
+ /** destructor */
+ virtual ~AliHLTGlobalFlatEsdTestComponent();
+
+ // interface methods of base class
+ const char* GetComponentID() {return "GlobalFlatEsdTest";};
+ void GetInputDataTypes(AliHLTComponentDataTypeList& list);
+ AliHLTComponentDataType GetOutputDataType();
+ void GetOutputDataSize(unsigned long& constBase, double& inputMultiplier);
+ AliHLTComponent* Spawn() {return new AliHLTGlobalFlatEsdTestComponent;}
+
+ protected:
+ // interface methods of base class
+ int DoInit(int argc, const char** argv);
+ int DoDeinit();
+ int DoEvent( const AliHLTComponentEventData& evtData,
+ const AliHLTComponentBlockData* blocks,
+ AliHLTComponentTriggerData& trigData,
+ AliHLTUInt8_t* outputPtr,
+ AliHLTUInt32_t& size,
+ AliHLTComponentBlockDataList& outputBlocks );
+
+ using AliHLTProcessor::DoEvent;
+
+
+ private:
+ /** copy constructor prohibited */
+ AliHLTGlobalFlatEsdTestComponent(const AliHLTGlobalFlatEsdTestComponent&);
+ /** assignment operator prohibited */
+ AliHLTGlobalFlatEsdTestComponent& operator=(const AliHLTGlobalFlatEsdTestComponent&);
+
+ /**
+ * (Re)Configure from the CDB
+ * Loads the following objects:
+ * - HLT/ConfigHLT/SolenoidBz
+ */
+ int Reconfigure(const char* cdbEntry, const char* chainId);
+
+ /**
+ * Configure the component.
+ * Parse a string for the configuration arguments and set the component
+ * properties.
+ */
+ int Configure(const char* arguments);
+
+ int fWriteClusters; //!transient
+
+ /// verbosity level
+ int fVerbosity; //!transient
+
+protected:
+
+ /// solenoid b field
+ Double_t fSolenoidBz; //! transient
+ AliHLTComponentBenchmark fBenchmark; // benchmark
+
+ ClassDef(AliHLTGlobalFlatEsdTestComponent, 0)
+};
+#endif
class AliVVVZEROfriend;
class AliVVTZEROfriend;
+class AliVVfriendTrack;
//_____________________________________________________________________________
class AliVVfriend {
public:
- AliVVfriend();
- virtual ~AliVVfriendEvent();
+ AliVVfriend() {}
+ virtual ~AliVVfriend() {}
virtual Int_t GetNumberOfTracks() const {return 0;}
AliVVfriendTrack* GetTrack(Int_t /*i*/) const {return NULL;}
virtual Int_t GetEntriesInTracks() const {return 0;}
- virtual AliESDVZEROfriend *GetVZEROfriend(){ return NULL; }
- virtual AliESDTZEROfriend *GetTZEROfriend(){ return NULL; }
+ virtual AliVVVZEROfriend *GetVZEROfriend(){ return NULL; }
+ virtual AliVVTZEROfriend *GetTZEROfriend(){ return NULL; }
- virtual void Ls() {}
+ virtual void Ls() const {}
virtual void Reset() {}
- Bool_t TestSkipBit() {return kFALSE;}
+ Bool_t TestSkipBit() const { return kFALSE; }
virtual Int_t GetNclustersTPC(UInt_t /*sector*/) const {return 0;}
virtual Int_t GetNclustersTPCused(UInt_t /*sector*/) const {return 0;}
//used in calibration
virtual Bool_t TestSkipBit() {return kFALSE;}
virtual Int_t GetNumberOfTracks() const {return 0;}
- virtual AliESDfriendTrack *GetTrack(Int_t /*i*/) const {return NULL;}
+ virtual const AliESDfriendTrack *GetTrack(Int_t /*i*/) const {return NULL;}
private:
AliVVfriendEvent(const AliVVfriendEvent &);
#define ALIVVFRIENDTRACK_H
//_____________________________________________________________________________
+
+class AliVVTPCseed;
+class AliVVTRDseed;
+class AliTrackPointArray;
+class AliExternalTrackParam;
+
class AliVVfriendTrack {
public:
- AliVVfriendTrack();
- virtual ~AliVVfriendTrack();
+ AliVVfriendTrack(){}
+ virtual ~AliVVfriendTrack(){}
//used in calibration
virtual AliVVTPCseed* GetTPCseed() const {return NULL;}
virtual AliVVTRDseed* GetTRDseed() const {return NULL;}
- virtual const AliTrackPointArray *GetTrackPointArray() const {return fPoints;}
- virtual const AliExternalTrackParam * GetITSOut() const {return fITSOut;}
- virtual const AliExternalTrackParam * GetTPCOut() const {return fTPCOut;}
- virtual const AliExternalTrackParam * GetTRDIn() const {return fTRDIn;}
+ virtual const AliTrackPointArray *GetTrackPointArray() const {return NULL;}
+ virtual const AliExternalTrackParam * GetITSOut() const {return NULL;}
+ virtual const AliExternalTrackParam * GetTPCOut() const {return NULL;}
+ virtual const AliExternalTrackParam * GetTRDIn() const {return NULL;}
private:
- AliVVfriendTrack(const AliVVfriendTrack &);
- AliVVfriendTrack& operator=(const AliVVfriendTrack& esd);
+ AliVVfriendTrack(const AliVVfriendTrack &){}
+ AliVVfriendTrack& operator=(const AliVVfriendTrack& ){}
};
#endif
git://git.uio.no / u / mrichter / AliRoot.git / commitdiff