#include "AliHLTTRDTrackerV1Component.h"
#include "AliHLTTRDDefinitions.h"
+#include "AliHLTTRDCluster.h"
+#include "AliHLTTRDTrack.h"
#include "TFile.h"
#include "TChain.h"
#include "AliGeomManager.h"
#include "AliCDBManager.h"
#include "AliESDEvent.h"
-#include "AliMagFMaps.h"
+#include "AliMagF.h"
#include "AliESDfriend.h"
#include "AliTRDcalibDB.h"
#include <cerrno>
#include <string>
-// this is a global object used for automatic component registration, do not use this
-AliHLTTRDTrackerV1Component gAliHLTTRDTrackerV1Component;
+#ifdef HAVE_VALGRIND_CALLGRIND_H
+#include <valgrind/callgrind.h>
+#else
+#define CALLGRIND_START_INSTRUMENTATION() do { } while (0)
+#define CALLGRIND_STOP_INSTRUMENTATION() do { } while (0)
+#endif
ClassImp(AliHLTTRDTrackerV1Component);
-AliHLTTRDTrackerV1Component::AliHLTTRDTrackerV1Component()
- : AliHLTProcessor()
- , fOutputPercentage(100) // By default we copy to the output exactly what we got as input
- , fStrorageDBpath("local://$ALICE_ROOT")
- , fCDB(NULL)
- , fField(NULL)
- , fGeometryFileName("")
- , fGeometryFile(NULL)
- , fGeoManager(NULL)
- , fTracker(NULL)
- , fRecoParam(NULL)
- , fReconstructor(NULL)
+AliHLTTRDTrackerV1Component::AliHLTTRDTrackerV1Component():
+ AliHLTProcessor(),
+ fOutputPercentage(100), // By default we copy to the output exactly what we got as input
+ fStrorageDBpath("local://$ALICE_ROOT/OCDB"),
+ fCDB(NULL),
+ fGeometryFileName(""),
+ fUseHLTClusters(kFALSE),
+ fUseHLTTracks(kFALSE),
+ fTracker(NULL),
+ fRecoParam(NULL),
+ fReconstructor(NULL)
{
// Default constructor
return new AliHLTTRDTrackerV1Component;
};
+/**
+ * Convert AliTRDtrackV1 to AliHLTTRDTrack
+ * Add HLTTrack to the output, defined by pointer
+ * Fill block desctiptors
+ * Return size of the added to ouput objects
+ */
+//============================================================================
+AliHLTUInt32_t AliHLTTRDTrackerV1Component::AddToOutput(TClonesArray* inTrackArray, AliHLTUInt8_t* output)
+{
+ cout << "\nWriting tracks to the Memory\n ============= \n";
+ AliTRDtrackV1* track = 0;
+ AliHLTUInt32_t addedSize = 0;
+ AliHLTUInt8_t *iterPtr = output;
+ AliHLTTRDTrack * outPtr = (AliHLTTRDTrack*)iterPtr;
+
+ if (inTrackArray){
+ Int_t nbTracks = inTrackArray->GetEntries();
+ for (Int_t iTrack = 0; iTrack<nbTracks; iTrack++){
+ AliHLTUInt32_t trackSize=0;
+
+ track = dynamic_cast<AliTRDtrackV1*>(inTrackArray->At(iTrack));
+ //track->Print();
+
+ AliHLTTRDTrack *hltTrack = new (outPtr) AliHLTTRDTrack(track);
+ trackSize = hltTrack->GetSize();
+ addedSize += trackSize;
+ HLTDebug("addedSize %i, trackSize %i", addedSize, trackSize);
+
+ iterPtr += trackSize;
+ outPtr = (AliHLTTRDTrack*)iterPtr;
+ }
+ }
+ return addedSize;
+
+}
+
int AliHLTTRDTrackerV1Component::DoInit( int argc, const char** argv )
{
// perform initialization. We check whether our relative output size is specified in the arguments.
HLTDebug("Using standard offline tracking.");
i++;
}
+ else if ( strcmp( argv[i], "-useHLTClusters" ) == 0)
+ {
+ fUseHLTClusters = kTRUE;
+ i++;
+ HLTInfo("expecting AliHLTCluster as input");
+ }
+ else if ( strcmp( argv[i], "-useHLTTracks" ) == 0)
+ {
+ fUseHLTTracks = kTRUE;
+ i++;
+ HLTInfo("Using AliHLTTrack to pass data further in the chain");
+ }
else {
HLTError("Unknown option '%s'", argv[i] );
return EINVAL;
HLTWarning("No magnetic field switch stated. Use -magnetic_field_ON or -magnetic_field_OFF flag. Defaulting to OFF = NO MAGNETIC FIELD");
}
- if (iMagneticField == 0)
- {
- // magnetic field OFF
- fField = new AliMagFMaps("Maps","Maps", 2, 0., 10., 1);
- HLTDebug("Magnetic field is OFF.");
- }
-
- if (iMagneticField == 1)
- {
- // magnetic field ON
- fField = new AliMagFMaps("Maps","Maps", 2, 1., 10., 1);
- HLTDebug("Magnetic field is ON.");
- }
-
- if (fField == 0)
- {
- HLTError("Unable to init the field. Trouble at this point.");
- return -1;
- }
-
- // kTRUE sets the map uniform
- AliTracker::SetFieldMap(fField,kTRUE);
+ if (!TGeoGlobalMagField::Instance()->IsLocked()) {
+ if (iMagneticField == 0)
+ {
+ // magnetic field OFF
+ AliMagF* field = new AliMagF("Maps","Maps",2,0.,0., 10.,AliMagF::k5kGUniform);
+ TGeoGlobalMagField::Instance()->SetField(field);
+ HLTDebug("Magnetic field is OFF.");
+ }
+
+ if (iMagneticField == 1)
+ {
+ // magnetic field ON
+ AliMagF* field = new AliMagF("Maps","Maps",2,1.,1., 10.,AliMagF::k5kG);
+ TGeoGlobalMagField::Instance()->SetField(field);
+ HLTDebug("Magnetic field is ON.");
+ }
+ }
+ else {
+ HLTError("Magnetic field is already set and locked, cannot redefine it." );
+ }
// reconstruction parameters
if (iRecoParamType < 0 || iRecoParamType > 2)
}
fReconstructor = new AliTRDReconstructor();
-// fRecoParam->SetChi2Y(.1);
-// fRecoParam->SetChi2Z(5.);
+ // fRecoParam->SetChi2Y(.1);
+ // fRecoParam->SetChi2Z(5.);
fReconstructor->SetRecoParam(fRecoParam);
// write clusters [cw] = true
// track seeding (stand alone tracking) [sa] = true
// drift gas [ar] = false
// sl_tr_0 = StreamLevel_task_Level
// fReconstructor->SetOption("sa,!cw,hlt,sl_tr_0");
- TString recoOptions="sa,sl_cf_0";
+ TString recoOptions="sa,sl_tr_0";
if (bWriteClusters)
{
fReconstructor->SetOption(recoOptions.Data());
HLTDebug("Reconstructor options are: %s",recoOptions.Data());
- fGeometryFile = 0;
- fGeometryFile = TFile::Open(fGeometryFileName.c_str());
- if (fGeometryFile)
- {
+ if((AliGeomManager::GetGeometry()) == NULL){
+
+ if ( TFile::Open(fGeometryFileName.c_str())) {
AliGeomManager::LoadGeometry(fGeometryFileName.c_str());
}
- else
- {
- HLTError("Unable to open file. FATAL!");
- return -1;
+ else {
+ HLTError("Cannot load geometry from file %s",fGeometryFileName.c_str());
+ return EINVAL;
}
+ }
+ else
+ HLTInfo("Geometry Already Loaded");
// create the tracker
fTracker = new AliTRDtrackerV1();
{
// Deinitialization of the component
- delete fField;
- fField = 0x0;
-
- // fTracker->SetClustersOwner(kFALSE);
+ fTracker->SetClustersOwner(kFALSE);
delete fTracker;
fTracker = 0x0;
AliTRDcalibDB::Terminate();
- if (fGeometryFile)
- {
- fGeometryFile->Close();
- delete fGeometryFile;
- fGeometryFile = 0x0;
- }
-
return 0;
}
-int AliHLTTRDTrackerV1Component::DoEvent( const AliHLTComponentEventData & /*evtData*/,
- AliHLTComponentTriggerData & /*trigData*/ )
+int AliHLTTRDTrackerV1Component::DoEvent( const AliHLTComponentEventData& evtData,
+ const AliHLTComponentBlockData* blocks,
+ AliHLTComponent_TriggerData& /*trigData*/,
+ AliHLTUInt8_t* outputPtr,
+ AliHLTUInt32_t& size,
+ vector<AliHLTComponent_BlockData>& outputBlocks )
{
// Process an event
Bool_t bWriteClusters = fReconstructor->IsWritingClusters();
- HLTDebug("Output percentage set to %lu %%", fOutputPercentage );
- HLTDebug("NofBlocks %lu", GetNumberOfInputBlocks() );
+ HLTDebug("NofBlocks %lu", evtData.fBlockCnt );
+ AliHLTUInt32_t totalSize = 0, offset = 0;
AliHLTUInt32_t dBlockSpecification = 0;
-
- //implement a usage of the following
- // AliHLTUInt32_t triggerDataStructSize = trigData.fStructSize;
- // AliHLTUInt32_t triggerDataSize = trigData.fDataSize;
- // void *triggerData = trigData.fData;
- //HLTDebug("Struct size %d Data size %d Data location 0x%x", trigData.fStructSize, trigData.fDataSize, (UInt_t*)trigData.fData);
-
- AliHLTComponentBlockData *dblock = (AliHLTComponentBlockData *)GetFirstInputBlock( AliHLTTRDDefinitions::fgkClusterDataType );
- if (dblock != 0)
+ vector<AliHLTComponent_DataType> expectedDataTypes;
+ GetInputDataTypes(expectedDataTypes);
+ if (evtData.fEventID == 1)
+ CALLGRIND_START_INSTRUMENTATION();
+ for ( unsigned long iBlock = 0; iBlock < evtData.fBlockCnt; iBlock++ )
{
- AliHLTComponentDataType inputDataType = dblock->fDataType;
- HLTDebug( "Event 0x%08LX (%Lu) received datatype: %s",
- GetEventId(), GetEventId(),
- DataType2Text(inputDataType).c_str());
- dBlockSpecification = dblock->fSpecification;
- }
- else
- {
- HLTWarning("First Input Block not found! 0x%x", dblock);
- return 0;
+ const AliHLTComponentBlockData &block = blocks[iBlock];
+ offset = totalSize;
+ AliHLTComponentDataType inputDataType = block.fDataType;
+ Bool_t correctDataType = kFALSE;
+
+ for(UInt_t i = 0; i < expectedDataTypes.size(); i++)
+ if( expectedDataTypes.at(i) == inputDataType)
+ correctDataType = kTRUE;
+ if (!correctDataType)
+ {
+ HLTDebug( "Block # %i/%i; Event 0x%08LX (%Lu) Wrong received datatype: %s - Skipping",
+ iBlock, evtData.fBlockCnt-1,
+ evtData.fEventID, evtData.fEventID,
+ DataType2Text(inputDataType).c_str());
+ continue;
+ }
+ else
+ HLTDebug("We get the right data type: Block # %i/%i; Event 0x%08LX (%Lu) Received datatype: %s",
+ iBlock, evtData.fBlockCnt-1,
+ evtData.fEventID, evtData.fEventID,
+ DataType2Text(inputDataType).c_str());
+
+
+ TTree *clusterTree = 0x0;
+ TClonesArray* clusterArray = 0x0;
+ ReadAndLoadClusters(clusterTree, clusterArray, &block);
+
+ // maybe it is not so smart to create it each event? clear is enough ?
+ AliESDEvent *esd = new AliESDEvent();
+ esd->CreateStdContent();
+ fTracker->Clusters2Tracks(esd);
+
+ //here transport the esd tracks further
+ Int_t nTracks = esd->GetNumberOfTracks();
+ Int_t nTRDTracks = esd->GetNumberOfTrdTracks();
+ HLTInfo("Number of tracks == %d == Number of TRD tracks %d", nTracks, nTRDTracks);
+
+ TClonesArray* trdTracks = fTracker->GetListOfTracks();
+
+ if (trdTracks)
+ totalSize += TransportTracks(trdTracks, outputPtr, outputBlocks, offset, dBlockSpecification);
+ else
+ HLTDebug("Bad array trdTracks = 0x%x", trdTracks);
+ HLTDebug("totalSize: %i", totalSize);
+
+// if ( totalSize > allocSize )
+// {
+// HLTError("Too much data; Data written over allowed buffer. Amount written: %lu, allowed amount: %lu.",
+// totalSize, size );
+// return EMSGSIZE;
+// }
+
+ //here we are deleting clusters (but not the TClonesArray itself)
+ fTracker->UnloadClusters();
+
+ AliTRDReconstructor::SetClusters(0x0);
+ delete esd;
+ if (bWriteClusters)
+ delete clusterTree;
+ else{
+ //clusterArray->Delete();
+ delete clusterArray;
+ }
+
}
+ size = totalSize;
+ HLTDebug("Event is done. size written to the output is %i", size);
+ // CALLGRIND_STOP_INSTRUMENTATION();
+ return 0;
+}
+
+
+/**
+ * ReadClusters from the component input and load them to the tracker
+ */
+//============================================================================
+void AliHLTTRDTrackerV1Component::ReadAndLoadClusters(TTree *inClusterTree,
+ TClonesArray *inClusterArray, const AliHLTComponentBlockData *inBlock)
+{
+ Bool_t bWriteClusters = fReconstructor->IsWritingClusters();
+ const AliHLTComponentBlockData &block = *inBlock;
+
- int ibForce = 0;
-
TObject *tobjin = 0x0;
+ int ibForce = 0; // almost obsolet
- TTree *clusterTree = 0x0;
- TClonesArray *clusterArray = 0x0;
if (bWriteClusters){
tobjin = (TObject *)GetFirstInputObject( AliHLTTRDDefinitions::fgkClusterDataType, "TTree", ibForce);
HLTDebug("1stBLOCK; Pointer = 0x%x", tobjin);
- clusterTree = (TTree*)tobjin;
-
- // while (tobjin != 0)
- // {
- if (clusterTree)
- {
- HLTDebug("CLUSTERS; Pointer to TTree = 0x%x Name = %s", clusterTree, clusterTree->GetName());
- HLTDebug("TTree of clusters: nbEntries = %i", clusterTree->GetEntriesFast());
- fTracker->LoadClusters(clusterTree);
- }
- else
+ inClusterTree = (TTree*)tobjin;
+ if (inClusterTree)
{
- HLTError("First Input Block not a TTree 0x%x", tobjin);
- }
- }
- else{
- tobjin = (TObject *)GetFirstInputObject( AliHLTTRDDefinitions::fgkClusterDataType, "TClonesArray", ibForce);
- HLTDebug("1stBLOCK; Pointer = 0x%x", tobjin);
- clusterArray = (TClonesArray*)tobjin;
- if (clusterArray)
- {
- HLTDebug("CLUSTERS; Pointer to TClonesArray = 0x%x Name = %s", clusterArray, clusterArray->GetName());
- HLTDebug("TClonesArray of clusters: nbEntries = %i", clusterArray->GetEntriesFast());
- Int_t nb = clusterArray->GetEntriesFast();
- for (Int_t i=0; i<nb; i++){
- //AliTRDcluster * cluster = (AliTRDcluster* ) clusterArray->At(i);
- //HLTDebug("Cluster[%i]: detector %i", i, cluster->GetDetector());
- }
-
- fTracker->LoadClusters(clusterArray);
+ HLTDebug("CLUSTERS; Pointer to TTree = 0x%x Name = %s", inClusterTree, inClusterTree->GetName());
+ HLTDebug("TTree of clusters: nbEntries = %i", inClusterTree->GetEntriesFast());
+ fTracker->LoadClusters(inClusterTree);
}
else
{
- HLTError("First Input Block not a TClonesArray 0x%x", tobjin);
+ HLTError("First Input Block is not a TTree 0x%x", tobjin);
}
}
-
- // maybe it is not so smart to create it each event? clear is enough ?
- AliESDEvent *esd = new AliESDEvent();
- esd->CreateStdContent();
- fTracker->Clusters2Tracks(esd);
-
- //here transport the esd tracks further
- Int_t nTracks = esd->GetNumberOfTracks();
- Int_t nTRDTracks = esd->GetNumberOfTrdTracks();
- HLTInfo("Number of tracks == %d == Number of TRD tracks %d", nTracks, nTRDTracks);
- //esd->Print();
- //PushBack(esd, AliHLTTRDDefinitions::fgkTRDSAEsdDataType);
-
- // extract the friend ?
- // AliESDfriend *esdFriend = new AliESDfriend();
- // esd->GetESDfriend(esdFriend);
- // PushBack(esdFriend, AliHLTTRDDefinitions::fgkTRDSAEsdDataType);
- // delete esdFriend;
-
- TClonesArray* trdTracks = fTracker->GetListOfTracks();
-
- if (trdTracks)
+ else if (fUseHLTClusters)
{
- nTracks=trdTracks->GetEntriesFast();
- if (nTracks>0)
+ inClusterArray = new TClonesArray("AliTRDcluster"); // would be nice to allocate memory for all clusters here.
+ ReadClusters(inClusterArray, block.fPtr, block.fSize);
+ HLTDebug("TClonesArray of clusters: nbEntries = %i", inClusterArray->GetEntriesFast());
+ fTracker->LoadClusters(inClusterArray);
+ }
+ else
+ {
+ tobjin = (TObject *)GetFirstInputObject( AliHLTTRDDefinitions::fgkClusterDataType, "TClonesArray", ibForce);
+ HLTDebug("1stBLOCK; Pointer = 0x%x", tobjin);
+ inClusterArray = (TClonesArray*)tobjin;
+ if (inClusterArray)
{
- HLTDebug("We have an output array: pointer to trdTracks = 0x%x, nbEntries = %i", trdTracks, nTracks);
- HLTDebug("We have an output array: pointer to trdTracks = 0x%x, nbEntries = %i", trdTracks, nTracks);
-
- trdTracks->BypassStreamer(kFALSE);
- PushBack(trdTracks, AliHLTTRDDefinitions::fgkTRDSATracksDataType);
- //trdTracks->Delete();
- //delete trdTracks;
+ HLTDebug("CLUSTERS; Pointer to TClonesArray = 0x%x Name = %s", inClusterArray, inClusterArray->GetName());
+ HLTDebug("TClonesArray of clusters: nbEntries = %i", inClusterArray->GetEntriesFast());
+ fTracker->LoadClusters(inClusterArray);
+ }
+ else
+ {
+ HLTError("First Input Block not a TClonesArray 0x%x", tobjin);
}
}
- else {
- Bool_t foo; foo=kFALSE; //In order to supress warning in non-debug compile
- HLTDebug("Bad array trdTracks = 0x%x", trdTracks);
- }
+}
+/**
+ * Read cluster to the TClonesArray from the memory
+ */
+//============================================================================
+Int_t AliHLTTRDTrackerV1Component::ReadClusters(TClonesArray *outArray, void* inputPtr, AliHLTUInt32_t size)
+{
+ //HLTDebug("\nReading clusters from the Memory\n ============= \n");
+ AliHLTTRDCluster * curCluster;
+ UInt_t clusterSize = sizeof(AliHLTTRDCluster), curSize = 0;
+ Int_t i=0;
- //here we are deleting clusters (but not the TClonesArray itself)
- fTracker->UnloadClusters();
- delete esd;
- if (bWriteClusters)
- delete clusterTree;
- else
- delete clusterArray;
-
- HLTDebug("Event done.");
+ curCluster = (AliHLTTRDCluster*) inputPtr;
+ while (curSize + clusterSize <= size)
+ {
+ // HLTDebug(" fX = %f; fY = %f; fZ = %f", curCluster->fX, curCluster->fY, curCluster->fZ);
+
+ AliTRDcluster* curTRDCluster = new((*outArray)[i]) AliTRDcluster();
+ curCluster->ExportTRDCluster(curTRDCluster);
+ // HLTDebug(" fX = %f; fY = %f; fZ = %f", curTRDCluster->GetX(), curTRDCluster->GetY(), curTRDCluster->GetZ());
+ curSize += clusterSize;
+ i++;
+ curCluster++;
+ //cout << " current readed size is " << curSize << "/" << size << endl;
+ }
+
+ return i;
+}
+/**
+ * Transport tracks to the next component
+ * Return Numbers of bytes written to the output
+ */
+//============================================================================
+AliHLTUInt32_t AliHLTTRDTrackerV1Component::TransportTracks(TClonesArray *inTracksArray, AliHLTUInt8_t* output,
+ vector<AliHLTComponent_BlockData>& outputBlocks, AliHLTUInt32_t inOffset, AliHLTUInt32_t inSpec)
+{
+ Int_t nbTracks=inTracksArray->GetEntriesFast();
+ if (nbTracks>0)
+ {
+ HLTDebug("We have an output array: pointer to inTracksArray = 0x%x, nbEntries = %i", inTracksArray, nbTracks);
+ if (fUseHLTTracks){
+ // Using low-level interface
+ // with interface classes
+ AliHLTUInt32_t addedSize = AddToOutput(inTracksArray, output);
+
+ // Fill block
+ AliHLTComponentBlockData bd;
+ FillBlockData( bd );
+
+ bd.fPtr = output;
+ bd.fOffset = inOffset;
+ bd.fSize = addedSize;
+ bd.fSpecification = inSpec;
+ bd.fDataType = AliHLTTRDDefinitions::fgkTRDSATracksDataType;
+ outputBlocks.push_back( bd );
+ HLTDebug("BD fPtr 0x%x, fOffset %i, fSize %i, fSpec 0x%x", bd.fPtr, bd.fOffset, bd.fSize, bd.fSpecification);
+
+ return addedSize;
+ }
+ else{
+ inTracksArray->BypassStreamer(kFALSE);
+ PushBack(inTracksArray, AliHLTTRDDefinitions::fgkTRDSATracksDataType);
+ return 0;
+ }
+
+ }
return 0;
+
}
-
-///////////////////////////////
-/*
- consider transporting TRD tracks only as they might have signigicantly smaller size... on the other hand you will need to prodece ESDs at some point...
-
- // this is for ESDtrack
- // for (Int_t it = 0; it < nTracks; it++)
- // {
- // AliESDtrack* track = esd->GetTrack(it);
- // HLTInfo("Track %d 0x%x Pt %1.2f", it, track, track->Pt());
- // //PushBack(track, AliHLTTRDDefinitions::fgkTRDSATracksDataType, ++dBlockSpecification);
- // PushBack(track, AliHLTTRDDefinitions::fgkTRDSATracksDataType);
- // }
-
- // one can do similar things with the TRDtrack
- esd->GetNumberOfTrdTracks();
- and then
- for (i;;)
- AliESDTrdTrack *trdtrack = esd->GetTrdTrack(i)
-*/
-
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff