Coding conventions
authoralibrary <alibrary@f7af4fe6-9843-0410-8265-dc069ae4e863>
Fri, 14 Apr 2006 06:28:19 +0000 (06:28 +0000)
committeralibrary <alibrary@f7af4fe6-9843-0410-8265-dc069ae4e863>
Fri, 14 Apr 2006 06:28:19 +0000 (06:28 +0000)
20 files changed:
HLT/MUON/src/AliRoot/AliHLTMUONTracker.cxx
HLT/MUON/src/AliRoot/ClusterSource.cxx
HLT/MUON/src/AliRoot/ClusterSource.hpp
HLT/MUON/src/AliRoot/MUONHLTLinkDef.hpp
HLT/MUON/src/AliRoot/MicrodHLT.cxx
HLT/MUON/src/AliRoot/MicrodHLT.hpp
HLT/MUON/src/AliRoot/TrackSink.cxx
HLT/MUON/src/AliRoot/TrackSink.hpp
HLT/MUON/src/AliRoot/TriggerSource.cxx
HLT/MUON/src/AliRoot/TriggerSource.hpp
HLT/MUON/src/AliRoot/convert.cxx
HLT/MUON/src/Clustering/CenterOfGravityFinder.cxx
HLT/MUON/src/Clustering/CenterOfGravityFinder.hpp
HLT/MUON/src/Error.cxx
HLT/MUON/src/Error.hpp
HLT/MUON/src/RegionOfInterest.cxx
HLT/MUON/src/RegionOfInterest.hpp
HLT/MUON/src/Tracking/Calculations.cxx
HLT/MUON/src/Tracking/MansoTracker.cxx
HLT/MUON/src/Tracking/MansoTracker.hpp

index d8a1970b6e97530cba5f435eeec8a4e4af9671c1..20df374edb333072e5db7aeab1c4cabb2e260246 100644 (file)
@@ -57,7 +57,7 @@ Int_t AliHLTMUONTracker::LoadClusters(TTree* data)
        AliDebug(2, Form("Loading for event %d", di.CurrentEvent()));
 
        // Load the trigger records.
-       fTriggers->DataToUse(AliHLTMUONTriggerSource::FromLocalTriggers);
+       fTriggers->DataToUse(AliHLTMUONTriggerSource::kFromLocalTriggers);
        fTriggers->FillFrom(&di, di.CurrentEvent());
 
 #ifndef LOG_NO_DEBUG
@@ -86,7 +86,7 @@ Int_t AliHLTMUONTracker::LoadClusters(TTree* data)
 #endif // LOG_NO_DEBUG
 
        // Load cluster points (reconstructed hits)
-       fClusters->DataToUse(AliHLTMUONClusterSource::FromRawClusters);
+       fClusters->DataToUse(AliHLTMUONClusterSource::kFromRawClusters);
        fClusters->FillFrom(&di, di.CurrentEvent());
 
 #ifndef LOG_NO_DEBUG
index f1ab056957bb1502a12eb387730bfffd8813c2f4..62a6b3c07c5faabfd97bc15917cda6ae6655298c 100644 (file)
@@ -5,6 +5,11 @@
 //
 ////////////////////////////////////////////////////////////////////////////////
 
+/* AliHLTMUONClusterSource is used to extract cluster points from the data
+   stored in a root file for a AliRoot simulated event.
+   It is used by AliHLTMUONMicrodHLT as the input data set object.
+ */
+
 #include "AliRoot/ClusterSource.hpp"
 #include "AliRoot/Base.hpp"
 #include "AliMUONConstants.h"
 #endif
 
 ClassImp(AliHLTMUONClusterSource)
-ClassImp(AliHLTMUONClusterSource::BlockData)
-ClassImp(AliHLTMUONClusterSource::EventData)
+ClassImp(AliHLTMUONClusterSource::AliBlockData)
+ClassImp(AliHLTMUONClusterSource::AliEventData)
 
 
 AliHLTMUONClusterSource::AliHLTMUONClusterSource()
-       : TObject(), fEventList(AliHLTMUONClusterSource::EventData::Class())
+       : TObject(), fEventList(AliHLTMUONClusterSource::AliEventData::Class())
 {
-       fAreaToUse = FromWholePlane;
-       fDataToUse = FromRawClusters;
+// Default contructor.
+
+       fAreaToUse = kFromWholePlane;
+       fDataToUse = kFromRawClusters;
        fMaxBlockSize = 0xFFFFFFFF;
        fFilename = "";
        fFoldername = "";
@@ -35,10 +42,12 @@ AliHLTMUONClusterSource::AliHLTMUONClusterSource()
 
 
 AliHLTMUONClusterSource::AliHLTMUONClusterSource(AliMUONDataInterface* data)
-       : TObject(), fEventList(AliHLTMUONClusterSource::EventData::Class())
+       : TObject(), fEventList(AliHLTMUONClusterSource::AliEventData::Class())
 {
-       fAreaToUse = FromWholePlane;
-       fDataToUse = FromRawClusters;
+// Creates a new cluster source object and fills it with data from 'data'.
+
+       fAreaToUse = kFromWholePlane;
+       fDataToUse = kFromRawClusters;
        fMaxBlockSize = 0xFFFFFFFF;
        fFilename = "";
        fFoldername = "";
@@ -55,6 +64,9 @@ AliHLTMUONClusterSource::~AliHLTMUONClusterSource()
 
 void AliHLTMUONClusterSource::FillFrom(AliMUONDataInterface* data)
 {
+// Fills the internal data structures from the specified data interface
+// for all the events found in AliMUONDataInterface.
+
        DebugMsg(1, "FillFrom(AliMUONDataInterface*)");
        
        if (FileAndFolderOk(data))
@@ -69,6 +81,9 @@ void AliHLTMUONClusterSource::FillFrom(AliMUONDataInterface* data)
 
 void AliHLTMUONClusterSource::FillFrom(AliMUONDataInterface* data, Int_t event)
 {
+// Fills the internal data structures from the specified data interface
+// for the given event.
+
        DebugMsg(1, "FillFrom(AliMUONDataInterface*, Int_t)");
        
        if (FileAndFolderOk(data))
@@ -78,6 +93,9 @@ void AliHLTMUONClusterSource::FillFrom(AliMUONDataInterface* data, Int_t event)
 
 void AliHLTMUONClusterSource::FillFrom(AliMUONDataInterface* data, Int_t event, Int_t chamber)
 {
+// Fills the internal data structures from the specified data interface
+// for the given event and chamber.
+
        DebugMsg(1, "FillFrom(AliMUONDataInterface*, Int_t)");
        
        if (FileAndFolderOk(data))
@@ -97,6 +115,16 @@ void AliHLTMUONClusterSource::FillFrom(
                Bool_t newblock
        )
 {
+// Fills the internal data structures from the specified data interface
+// for the given event, chamber and cluster number.
+// If 'newblock' is set to true then the new cluster point is added to
+// a new block. Otherwise the point is added to the current block.
+// Note: This method ignores the fAreaToUse and fMaxBlockSize flags.
+// This is very usefull for custom cluster source filling.
+// For the case of adding data from AliMUONHit objects the 'cluster' parameter
+// becomes the track number in TreeH and not the index of the AliMUONRawCluster
+// object.
+
        DebugMsg(1, "FillFrom(AliMUONDataInterface*, Int_t, Int_t, Int_t, Bool_t)");
        
        if (FileAndFolderOk(data))
@@ -113,7 +141,7 @@ void AliHLTMUONClusterSource::FillFrom(
                }
                else
                {
-                       if (fCurrentEvent->fEventNumber != event)
+                       if (fCurrentEvent->EventNumber() != event)
                        {
                                Bool_t found = GetEvent(event);
                                if ( ! found) AddEvent(event);
@@ -124,7 +152,7 @@ void AliHLTMUONClusterSource::FillFrom(
                {
                        Assert( fCurrentEvent != NULL );
                        
-                       if ( fCurrentBlock->fChamber != chamber)
+                       if ( fCurrentBlock->Chamber() != chamber)
                        {
                                // Create a new block if the current blocks chamber number does
                                // not correspond to the specified chamber.
@@ -146,6 +174,8 @@ void AliHLTMUONClusterSource::FillFrom(
 
 void AliHLTMUONClusterSource::Clear(Option_t* /*option*/)
 {
+// Clears all the internal arrays.
+
        fFilename = "";
        fFoldername = "";
        ResetAllPointers();
@@ -155,13 +185,19 @@ void AliHLTMUONClusterSource::Clear(Option_t* /*option*/)
 
 Bool_t AliHLTMUONClusterSource::GetEvent(Int_t eventnumber) const
 {
+// Fetches the specified event number stored in this AliHLTMUONClusterSource.
+// Sets the current block and cluster point to the first block and cluster
+// point respectively. If there are no blocks or clusters then these pointers
+// are set to NULL.
+// kTRUE is returned if the event was found, kFALSE otherwise.
+
        DebugMsg(1, "AliHLTMUONClusterSource::GetEvent(" << eventnumber << ")" );
        
        // Try find the corresponding event in the list of events.
        for (Int_t i = 0; i < fEventList.GetEntriesFast(); i++)
        {
-               EventData* current = (EventData*) fEventList[i];
-               if (current->fEventNumber == eventnumber)
+               AliEventData* current = (AliEventData*) fEventList[i];
+               if (current->EventNumber() == eventnumber)
                {
                        fEventIndex = i;
                        fCurrentEvent = current;
@@ -178,11 +214,17 @@ Bool_t AliHLTMUONClusterSource::GetEvent(Int_t eventnumber) const
 
 Bool_t AliHLTMUONClusterSource::GetFirstEvent() const
 {
+// Fetches the first event stored in this AliHLTMUONClusterSource.
+// Sets the current block and cluster point to the first block and cluster
+// point respectively. If there are no blocks or clusters then these pointers
+// are set to NULL.
+// kTRUE is returned if the event was found, kFALSE otherwise.
+
        DebugMsg(1, "AliHLTMUONClusterSource::GetFirstEvent()");
        if (fEventList.GetEntriesFast() > 0)
        {
                fEventIndex = 0;
-               fCurrentEvent = (EventData*) fEventList[0];
+               fCurrentEvent = (AliEventData*) fEventList[0];
                GetFirstBlock();
                DebugMsg(2, "\tfEventIndex = " << fEventIndex << " , fBlockIndex = " << fBlockIndex
                        << " , fClusterIndex = " << fClusterIndex
@@ -201,16 +243,21 @@ Bool_t AliHLTMUONClusterSource::GetFirstEvent() const
 
 Bool_t AliHLTMUONClusterSource::MoreEvents() const
 {
+// Returns kTRUE if there are more events to interate over.
+
        return 0 <= fEventIndex && fEventIndex < fEventList.GetEntriesFast();
 }
 
 
 Bool_t AliHLTMUONClusterSource::GetNextEvent() const
 {
+// Fetches the next event stored following the currently selected one.
+// kTRUE is returned if the event was found, kFALSE otherwise.
+
        DebugMsg(1, "AliHLTMUONClusterSource::GetNextEvent()");
        if (fEventIndex < fEventList.GetEntriesFast() - 1)
        {
-               fCurrentEvent = (EventData*) fEventList[ ++fEventIndex ];
+               fCurrentEvent = (AliEventData*) fEventList[ ++fEventIndex ];
                GetFirstBlock();
                DebugMsg(2, "\tfEventIndex = " << fEventIndex << " , fBlockIndex = " << fBlockIndex
                        << " , fClusterIndex = " << fClusterIndex
@@ -227,8 +274,11 @@ Bool_t AliHLTMUONClusterSource::GetNextEvent() const
 
 Int_t AliHLTMUONClusterSource::CurrentEvent() const
 {
+// Returns the corresponding AliRoot event number for the current event.
+// -1 is returned if no event is selected.
+
        if (fCurrentEvent != NULL)
-               return fCurrentEvent->fEventNumber;
+               return fCurrentEvent->EventNumber();
        else
                return -1;
 }
@@ -236,6 +286,9 @@ Int_t AliHLTMUONClusterSource::CurrentEvent() const
 
 Int_t AliHLTMUONClusterSource::NumberOfBlocks() const
 {
+// Returns the number of cluster blocks in the current event.
+// -1 is returned if no event is selected.
+
        DebugMsg(1, "AliHLTMUONClusterSource::NumberOfBlocks()");
        if (fCurrentEvent == NULL)
        {
@@ -243,12 +296,17 @@ Int_t AliHLTMUONClusterSource::NumberOfBlocks() const
                return -1;
        }
        else
-               return fCurrentEvent->fBlocks.GetEntriesFast();
+               return fCurrentEvent->Blocks().GetEntriesFast();
 }
 
 
 Bool_t AliHLTMUONClusterSource::GetBlock(Int_t index) const
 {
+// Fetches the index'th block in the current event.
+// Sets the current cluster point to the first cluster point in the block.
+// If there are no cluster points then this pointer is set to NULL.
+// kTRUE is returned if the block was found, kFALSE otherwise.
+
        DebugMsg(1, "AliHLTMUONClusterSource::GetBlock(" << index << ")");
        
        // Note NumberOfBlocks() also checks if the event was selected.
@@ -258,7 +316,7 @@ Bool_t AliHLTMUONClusterSource::GetBlock(Int_t index) const
        if ( 0 <= index && index < numberofblocks )
        {
                fBlockIndex = index;
-               fCurrentBlock = (BlockData*) fCurrentEvent->fBlocks[index];
+               fCurrentBlock = (AliBlockData*) fCurrentEvent->Blocks()[index];
                GetFirstCluster();
                DebugMsg(2, "\tfEventIndex = " << fEventIndex << " , fBlockIndex = " << fBlockIndex
                        << " , fClusterIndex = " << fClusterIndex
@@ -285,12 +343,17 @@ Bool_t AliHLTMUONClusterSource::GetBlock(Int_t index) const
 
 Bool_t AliHLTMUONClusterSource::GetFirstBlock() const
 {
+// Fetches the first block in the current event.
+// Sets the current cluster point to the first cluster point in the block.
+// If there are no cluster points then this pointer is set to NULL.
+// kTRUE is returned if the block was found, kFALSE otherwise.
+
        DebugMsg(1, "AliHLTMUONClusterSource::GetFirstBlock()");
        // Note: NumberOfBlocks() also checks if fCurrentEvent != NULL.
        if (NumberOfBlocks() > 0)
        {
                fBlockIndex = 0;
-               fCurrentBlock = (BlockData*) fCurrentEvent->fBlocks[fBlockIndex];
+               fCurrentBlock = (AliBlockData*) fCurrentEvent->Blocks()[fBlockIndex];
                GetFirstCluster();
                DebugMsg(2, "\tfEventIndex = " << fEventIndex << " , fBlockIndex = " << fBlockIndex
                        << " , fClusterIndex = " << fClusterIndex
@@ -304,19 +367,24 @@ Bool_t AliHLTMUONClusterSource::GetFirstBlock() const
 
 Bool_t AliHLTMUONClusterSource::MoreBlocks() const
 {
+// Returns kTRUE if there are more blocks to interate over.
+
        return 0 <= fBlockIndex && fBlockIndex < NumberOfBlocks();
 }
 
 
 Bool_t AliHLTMUONClusterSource::GetNextBlock() const
 {
+// Fetches the next block in the current event.
+// kTRUE is returned if the block was found, kFALSE otherwise.
+
        DebugMsg(1, "AliHLTMUONClusterSource::GetNextBlock()");
 
        // Note: NumberOfBlocks() checks if fCurrentEvent != NULL. If it is then it returns -1
        // and since fBlockIndex is always >= -1 the if statement must go to the else part.
        if (fBlockIndex < NumberOfBlocks() - 1)
        {
-               fCurrentBlock = (BlockData*) fCurrentEvent->fBlocks[ ++fBlockIndex ];
+               fCurrentBlock = (AliBlockData*) fCurrentEvent->Blocks()[ ++fBlockIndex ];
                GetFirstCluster();
                DebugMsg(2, "\tfEventIndex = " << fEventIndex << " , fBlockIndex = " << fBlockIndex
                        << " , fClusterIndex = " << fClusterIndex
@@ -333,18 +401,24 @@ Bool_t AliHLTMUONClusterSource::GetNextBlock() const
 
 Int_t AliHLTMUONClusterSource::Chamber() const
 {
+// Returns the chamber number of the current block.
+// -1 is returned if no block is selected.
+
        if (fCurrentBlock == NULL)
        {
                Error("Chamber", "No block selected.");
                return -1;
        }
        else
-               return fCurrentBlock->fChamber;
+               return fCurrentBlock->Chamber();
 }
 
 
 Int_t AliHLTMUONClusterSource::NumberOfClusters() const
 {
+// Returns the number of cluster points in the current block.
+// -1 is returned if no block is selected.
+
        DebugMsg(1, "AliHLTMUONClusterSource::NumberOfClusters()");
        if (fCurrentBlock == NULL)
        {
@@ -352,12 +426,15 @@ Int_t AliHLTMUONClusterSource::NumberOfClusters() const
                return -1;
        }
        else
-               return fCurrentBlock->fClusters.GetEntriesFast();
+               return fCurrentBlock->Clusters().GetEntriesFast();
 }
 
 
 const AliHLTMUONPoint* AliHLTMUONClusterSource::GetCluster(Int_t index) const
 {
+// Fetches the index'th cluster point in the current block.
+// kTRUE is returned if the point was found, kFALSE otherwise.
+
        DebugMsg(1, "AliHLTMUONClusterSource::GetCluster(" << index << ")");
 
        // Note NumberOfClusters() also checks if the event and block was selected.
@@ -367,7 +444,7 @@ const AliHLTMUONPoint* AliHLTMUONClusterSource::GetCluster(Int_t index) const
        if ( 0 <= index && index < numberofclusters )
        {
                fClusterIndex = index;
-               fCurrentCluster = (AliHLTMUONPoint*) fCurrentBlock->fClusters[index];
+               fCurrentCluster = (AliHLTMUONPoint*) fCurrentBlock->Clusters()[index];
                DebugMsg(2, "\tfEventIndex = " << fEventIndex << " , fBlockIndex = " << fBlockIndex
                        << " , fClusterIndex = " << fClusterIndex
                );
@@ -393,12 +470,15 @@ const AliHLTMUONPoint* AliHLTMUONClusterSource::GetCluster(Int_t index) const
 
 const AliHLTMUONPoint* AliHLTMUONClusterSource::GetFirstCluster() const
 {
+// Fetches the first cluster point in the current block.
+// NULL is returned if the point was not found.
+
        DebugMsg(1, "AliHLTMUONClusterSource::GetFirstCluster()");
        // Note: NumberOfClusters() also checks if fCurrentBlock != NULL.
        if (NumberOfClusters() > 0)
        {
                fClusterIndex = 0;
-               fCurrentCluster = (AliHLTMUONPoint*) fCurrentBlock->fClusters[0];
+               fCurrentCluster = (AliHLTMUONPoint*) fCurrentBlock->Clusters()[0];
                DebugMsg(2, "\tfEventIndex = " << fEventIndex << " , fBlockIndex = " << fBlockIndex
                        << " , fClusterIndex = " << fClusterIndex
                );
@@ -411,19 +491,24 @@ const AliHLTMUONPoint* AliHLTMUONClusterSource::GetFirstCluster() const
 
 Bool_t AliHLTMUONClusterSource::MoreClusters() const
 {
+// Returns kTRUE if there are more cluster points to interate over.
+
        return 0 <= fClusterIndex && fClusterIndex < NumberOfClusters();
 }
 
 
 const AliHLTMUONPoint* AliHLTMUONClusterSource::GetNextCluster() const
 {
+// Fetches the next cluster point in the current block.
+// NULL is returned if the point was not found.
+
        DebugMsg(1, "AliHLTMUONClusterSource::GetNextCluster()");
        
        // Note: NumberOfClusters() checks if fCurrentBlock != NULL. If it is then it returns -1
        // and since fClusterIndex is always >= -1 the if statement must go to the else part.
        if (fClusterIndex < NumberOfClusters() - 1)
        {
-               fCurrentCluster = (AliHLTMUONPoint*) fCurrentBlock->fClusters[ ++fClusterIndex ];
+               fCurrentCluster = (AliHLTMUONPoint*) fCurrentBlock->Clusters()[ ++fClusterIndex ];
                DebugMsg(2, "\tfEventIndex = " << fEventIndex << " , fBlockIndex = " << fBlockIndex
                        << " , fClusterIndex = " << fClusterIndex
                );
@@ -439,6 +524,9 @@ const AliHLTMUONPoint* AliHLTMUONClusterSource::GetNextCluster() const
 
 Bool_t AliHLTMUONClusterSource::FetchCluster(Float_t& x, Float_t& y) const
 {
+// Returns the x and y coordinate of the current cluster point.
+// kFALSE is returned if there is no cluster point selected.
+
        if (fCurrentCluster != NULL)
        {
                x = fCurrentCluster->fX;
@@ -455,13 +543,16 @@ Bool_t AliHLTMUONClusterSource::FetchCluster(Float_t& x, Float_t& y) const
 
 void AliHLTMUONClusterSource::AddEvent(Int_t eventnumber)
 {
+// Adds a new AliEventData block to the fEventList and updates the fCurrentEvent,
+// fCurrentBlock and fCurrentCluster pointers.
+
        DebugMsg(1, "AliHLTMUONClusterSource::AddEvent(" << eventnumber << ")");
        Assert( eventnumber >= 0 );
 
        // Assume the eventnumber does not already exist in the event list.
        fEventIndex = fEventList.GetEntriesFast();
-       new ( fEventList[fEventIndex] ) EventData(eventnumber);
-       fCurrentEvent = (EventData*) fEventList[fEventIndex];
+       new ( fEventList[fEventIndex] ) AliEventData(eventnumber);
+       fCurrentEvent = (AliEventData*) fEventList[fEventIndex];
        
        // Remember to reset the other pointers because the new event is empty.
        ResetBlockPointers();
@@ -474,6 +565,9 @@ void AliHLTMUONClusterSource::AddEvent(Int_t eventnumber)
 
 void AliHLTMUONClusterSource::AddBlock(Int_t chamber)
 {
+// Adds a new block to the current event and updates fCurrentBlock and fCurrentCluster.
+// The chamber number is assigned to the blocks fChamber value.
+
        DebugMsg(1, "AliHLTMUONClusterSource::AddBlock()");
        
        if (fCurrentEvent == NULL)
@@ -482,9 +576,9 @@ void AliHLTMUONClusterSource::AddBlock(Int_t chamber)
                return;
        }
        
-       fBlockIndex = fCurrentEvent->fBlocks.GetEntriesFast();
-       new ( fCurrentEvent->fBlocks[fBlockIndex] ) BlockData(chamber);
-       fCurrentBlock = (BlockData*) fCurrentEvent->fBlocks[fBlockIndex];
+       fBlockIndex = fCurrentEvent->Blocks().GetEntriesFast();
+       new ( fCurrentEvent->Blocks()[fBlockIndex] ) AliBlockData(chamber);
+       fCurrentBlock = (AliBlockData*) fCurrentEvent->Blocks()[fBlockIndex];
        
        // Remember to reset the trigger pointer because the new block is empty.
        ResetClusterPointers();
@@ -497,6 +591,9 @@ void AliHLTMUONClusterSource::AddBlock(Int_t chamber)
 
 void AliHLTMUONClusterSource::AddPoint(Float_t x, Float_t y)
 {
+// Adds a new cluster point to the current event and block.
+// The fCurrentCluster is updated appropriately.
+
        DebugMsg(1, "AliHLTMUONClusterSource::AddPoint(" << x << ", " << y << ")");
 
        if (fCurrentBlock == NULL)
@@ -505,9 +602,9 @@ void AliHLTMUONClusterSource::AddPoint(Float_t x, Float_t y)
                return;
        }
        
-       fClusterIndex = fCurrentBlock->fClusters.GetEntriesFast();
-       new ( fCurrentBlock->fClusters[fClusterIndex] ) AliHLTMUONPoint(x, y);
-       fCurrentCluster = (AliHLTMUONPoint*) fCurrentBlock->fClusters[fClusterIndex];
+       fClusterIndex = fCurrentBlock->Clusters().GetEntriesFast();
+       new ( fCurrentBlock->Clusters()[fClusterIndex] ) AliHLTMUONPoint(x, y);
+       fCurrentCluster = (AliHLTMUONPoint*) fCurrentBlock->Clusters()[fClusterIndex];
        
        DebugMsg(2, "\tfEventIndex = " << fEventIndex << " , fBlockIndex = " << fBlockIndex
                << " , fClusterIndex = " << fClusterIndex
@@ -517,6 +614,11 @@ void AliHLTMUONClusterSource::AddPoint(Float_t x, Float_t y)
 
 Bool_t AliHLTMUONClusterSource::FileAndFolderOk(AliMUONDataInterface* data)
 {
+// Checks if the file and folder names correspond to this AliHLTMUONClusterSource's
+// file and folder names. kTRUE is returned if they do.
+// If the file and folder names are empty then they are assigned the names
+// as found in the data interface and kTRUE is returned.
+
        if (fFilename == "")
        {
                // Nothing filled yet so set the file and folder names.
@@ -549,6 +651,10 @@ Bool_t AliHLTMUONClusterSource::FileAndFolderOk(AliMUONDataInterface* data)
 
 void AliHLTMUONClusterSource::AddEventFrom(AliMUONDataInterface* data, Int_t event)
 {
+// Adds the whole event from the data interface to the internal data structures.
+// It is assumed that FileAndFolderOk(data) returns true just before calling
+// this method.
+
        if ( data->GetEvent(event) )
        {
                AddEvent(event);
@@ -562,6 +668,10 @@ void AliHLTMUONClusterSource::AddEventFrom(AliMUONDataInterface* data, Int_t eve
 
 void AliHLTMUONClusterSource::AddChamberFrom(AliMUONDataInterface* data, Int_t chamber)
 {
+// Adds all cluster points found on the given chamber from the specified data
+// interface. The data interface should be initialised correctly, that is the
+// event should already be selected before calling this method.
+
        DebugMsg(1, "Entering AddChamberFrom");
        
        AddBlock(chamber);
@@ -578,7 +688,7 @@ void AliHLTMUONClusterSource::AddChamberFrom(AliMUONDataInterface* data, Int_t c
        
        switch (fDataToUse)
        {
-       case FromHits:
+       case kFromHits:
                for (Int_t track = 0; track < data->NumberOfTracks(); track++)
                {
                        // Find the hit that corresponds to the current chamber number.
@@ -619,7 +729,7 @@ void AliHLTMUONClusterSource::AddChamberFrom(AliMUONDataInterface* data, Int_t c
                }
                break;
 
-       case FromRawClusters:
+       case kFromRawClusters:
                for (Int_t i = 0; i < data->NumberOfRawClusters(chamber); i++)
                {
                        AliMUONRawCluster* rc = data->RawCluster(chamber, i);
@@ -652,6 +762,10 @@ void AliHLTMUONClusterSource::AddClusterFrom(
                AliMUONDataInterface* data, Int_t chamber, Int_t cluster
        )
 {
+// Adds the cluster point from the specified data interface.
+// The data interface should be initialised correctly, that is the event
+// should already be selected before calling this method.
+
        DebugMsg(1, "Entering AddClusterFrom");
 #ifndef __alpha
 #ifndef __sun  
@@ -665,7 +779,7 @@ void AliHLTMUONClusterSource::AddClusterFrom(
 
        switch (fDataToUse)
        {
-       case FromHits:
+       case kFromHits:
                {
                Int_t i;
                // Note: cluster is now treated as the track number.
@@ -693,7 +807,7 @@ void AliHLTMUONClusterSource::AddClusterFrom(
                }
                break;
 
-       case FromRawClusters:
+       case kFromRawClusters:
                {
                AliMUONRawCluster* rc = data->RawCluster(chamber, cluster);
                x = rc->GetX(0);
@@ -712,13 +826,17 @@ void AliHLTMUONClusterSource::AddClusterFrom(
 }
 
 
-Bool_t AliHLTMUONClusterSource::InFillRegion(Float_t x, Float_t /*y*/)
+Bool_t AliHLTMUONClusterSource::InFillRegion(Float_t x, Float_t /*y*/) const
 {
+// Checks to see if the x and y coordinate of the cluster point are in the
+// chamber region we want to fill from.
+// kTRUE is returned if (x, y) is in the region, and kFALSE otherwise.
+
        switch (fAreaToUse)
        {
-       case FromWholePlane:     return kTRUE;
-       case FromLeftHalfPlane:  return x <= 0;
-       case FromRightHalfPlane: return x > 0;
+       case kFromWholePlane:     return kTRUE;
+       case kFromLeftHalfPlane:  return x <= 0;
+       case kFromRightHalfPlane: return x > 0;
 
        default:
                Error("InFillRegion", "fAreaToUse is not set to a valid value.");
@@ -729,6 +847,8 @@ Bool_t AliHLTMUONClusterSource::InFillRegion(Float_t x, Float_t /*y*/)
 
 void AliHLTMUONClusterSource::ResetAllPointers() const
 {
+// Sets all the current pointers to NULL and indices to -1.
+
        fEventIndex = -1;
        fCurrentEvent = NULL;
        fBlockIndex = -1;
@@ -743,6 +863,8 @@ void AliHLTMUONClusterSource::ResetAllPointers() const
 
 void AliHLTMUONClusterSource::ResetBlockPointers() const
 {
+// Sets the block and trigger pointers to NULL and indices to -1.
+
        fBlockIndex = -1;
        fCurrentBlock = NULL;
        fClusterIndex = -1;
@@ -755,6 +877,8 @@ void AliHLTMUONClusterSource::ResetBlockPointers() const
 
 void AliHLTMUONClusterSource::ResetClusterPointers() const
 {
+// Sets just the current cluster point pointer to NULL and index to -1.
+
        fClusterIndex = -1;
        fCurrentCluster = NULL;
        DebugMsg(2, "\tfEventIndex = " << fEventIndex << " , fBlockIndex = " << fBlockIndex
@@ -763,36 +887,38 @@ void AliHLTMUONClusterSource::ResetClusterPointers() const
 }
 
 
-AliHLTMUONClusterSource::BlockData::BlockData() : fClusters(AliHLTMUONPoint::Class())
+AliHLTMUONClusterSource::AliBlockData::AliBlockData() : fClusters(AliHLTMUONPoint::Class())
 {
        fChamber = -1;
 }
 
-AliHLTMUONClusterSource::BlockData::BlockData(Int_t chamber) : fClusters(AliHLTMUONPoint::Class())
+AliHLTMUONClusterSource::AliBlockData::AliBlockData(Int_t chamber) : fClusters(AliHLTMUONPoint::Class())
 {
        fChamber = chamber;
 }
 
-AliHLTMUONClusterSource::BlockData::~BlockData()
+AliHLTMUONClusterSource::AliBlockData::~AliBlockData()
 {
        fClusters.Clear("C");
 }
 
-AliHLTMUONClusterSource::EventData::EventData() : fBlocks(AliHLTMUONClusterSource::BlockData::Class())
+AliHLTMUONClusterSource::AliEventData::AliEventData() : fBlocks(AliHLTMUONClusterSource::AliBlockData::Class())
 {
        fEventNumber = -1;
 }
 
-AliHLTMUONClusterSource::EventData::EventData(Int_t eventnumber)
-       : fBlocks(AliHLTMUONClusterSource::BlockData::Class())
+AliHLTMUONClusterSource::AliEventData::AliEventData(Int_t eventnumber)
+       : fBlocks(AliHLTMUONClusterSource::AliBlockData::Class())
 {
+// Creates a new event data block with specified event number.
+
        fEventNumber = eventnumber;
 
        // If the following is not set then we do not write the fBlocks properly.
        fBlocks.BypassStreamer(kFALSE);
 }
 
-AliHLTMUONClusterSource::EventData::~EventData()
+AliHLTMUONClusterSource::AliEventData::~AliEventData()
 {
        fBlocks.Clear("C");
 }
index 5ea99cf5bd27123e63cb65ae2c8f906afa77179c..8c7285e287806e64cfe60825d4be2e9b9afbea99 100644 (file)
@@ -5,6 +5,11 @@
 //
 ////////////////////////////////////////////////////////////////////////////////
 
+/* AliHLTMUONClusterSource is used to extract cluster points from the data
+   stored in a root file for a AliRoot simulated event.
+   It is used by AliHLTMUONMicrodHLT as the input data set object.
+ */
+
 #ifndef ALIHLTMUONCLUSTERSOURCE_H
 #define ALIHLTMUONCLUSTERSOURCE_H
 
@@ -23,15 +28,15 @@ public:
 
        enum AreaType
        {
-               FromWholePlane,
-               FromLeftHalfPlane,
-               FromRightHalfPlane
+               kFromWholePlane,
+               kFromLeftHalfPlane,
+               kFromRightHalfPlane
        };
        
        enum SourceType
        {
-               FromHits,
-               FromRawClusters
+               kFromHits,
+               kFromRawClusters
        };
 
        AliHLTMUONClusterSource();
@@ -196,7 +201,7 @@ public:
 
 private:
 
-       /* Adds a new EventData block to the fEventList and updates the fCurrentEvent,
+       /* Adds a new AliEventData block to the fEventList and updates the fCurrentEvent,
           fCurrentBlock and fCurrentCluster pointers.
         */ 
        void AddEvent(Int_t eventnumber);
@@ -240,7 +245,7 @@ private:
           chamber region we want to fill from.
           kTRUE is returned if (x, y) is in the region, and kFALSE otherwise.
         */
-       Bool_t InFillRegion(Float_t x, Float_t y);
+       Bool_t InFillRegion(Float_t x, Float_t y) const;
 
        /* Sets all the current pointers to NULL and indices to -1.
         */
@@ -257,35 +262,49 @@ private:
 
 public:  // Unfortunately ROOT requires the following to be public.
        
-       class BlockData : public TObject
+       class AliBlockData : public TObject
        {
        public:
-               BlockData();
-               BlockData(Int_t chamber);
-               virtual ~BlockData();
+               AliBlockData();
+               AliBlockData(Int_t chamber);
+               virtual ~AliBlockData();
+
+               Int_t& Chamber() { return fChamber; };
+               TClonesArray& Clusters() { return fClusters; };
+
+       private:
 
                Int_t fChamber;  // The chamber number this block of clusters came from.
                TClonesArray fClusters;  // The cluster points in this block.
                
-               ClassDef(BlockData, 1);  // Data per block.
+               ClassDef(AliBlockData, 1);  // Data per block.
        };
        
-       class EventData : public TObject
+       class AliEventData : public TObject
        {
        public:
-               EventData();
-               EventData(Int_t eventnumber);
-               virtual ~EventData();
+               AliEventData();
+               AliEventData(Int_t eventnumber);
+               virtual ~AliEventData();
+
+               Int_t& EventNumber() { return fEventNumber; };
+               TClonesArray& Blocks() { return fBlocks; };
+
+       private:
 
                Int_t fEventNumber;  // Event number in AliMUONDataInterface from which the clusters were taken.
                TClonesArray fBlocks;  // The list of cluster blocks for this event.
                
-               ClassDef(EventData, 1);  // Data per event.
+               ClassDef(AliEventData, 1);  // Data per event.
        };
 
 
 private:
 
+       // Dont allow copying.
+       AliHLTMUONClusterSource(const AliHLTMUONClusterSource& /*object*/) : TObject() {};
+       AliHLTMUONClusterSource& operator = (const AliHLTMUONClusterSource& /*object*/) { return *this; };
+
        AreaType fAreaToUse;    //! The part of the chamber to fill from.
        SourceType fDataToUse;  //! The type of raw AliRoot data to fill from.
        UInt_t fMaxBlockSize;   //! The maximum block size to create in the fill methods.
@@ -294,9 +313,9 @@ private:
        TString fFoldername;  // The folder name from which cluster data was taken.
        
        mutable Int_t fEventIndex;             //! The index number of the currently selected event.
-       mutable EventData* fCurrentEvent;      //! Pointer to the currently selected event.
+       mutable AliEventData* fCurrentEvent;      //! Pointer to the currently selected event.
        mutable Int_t fBlockIndex;             //! The index number of the currently selected block.
-       mutable BlockData* fCurrentBlock;      //! Pointer to the currently selected block.
+       mutable AliBlockData* fCurrentBlock;      //! Pointer to the currently selected block.
        mutable Int_t fClusterIndex;           //! The index number of the currently selected cluster point.
        mutable AliHLTMUONPoint* fCurrentCluster;        //! Pointer to the currently selected cluster point.
 
index e8983734013150cf2f3e08a9ec3bfed89ee50bb2..23ff255f0766f31f2d137ec8032582921108c800 100644 (file)
 #pragma link C++ class AliHLTMUONTriggerSource+;
 #pragma link C++ enum AliHLTMUONTriggerSource::AreaType+;
 #pragma link C++ enum AliHLTMUONTriggerSource::SourceType+;
-#pragma link C++ class AliHLTMUONTriggerSource::EventData+;
+#pragma link C++ class AliHLTMUONTriggerSource::AliEventData+;
 
 #pragma link C++ class AliHLTMUONClusterSource+;
 #pragma link C++ enum AliHLTMUONClusterSource::AreaType+;
 #pragma link C++ enum AliHLTMUONClusterSource::SourceType+;
-#pragma link C++ class AliHLTMUONClusterSource::BlockData+;
-#pragma link C++ class AliHLTMUONClusterSource::EventData+;
+#pragma link C++ class AliHLTMUONClusterSource::AliBlockData+;
+#pragma link C++ class AliHLTMUONClusterSource::AliEventData+;
 
 #pragma link C++ class AliHLTMUONTrackSink+;
-#pragma link C++ class AliHLTMUONTrackSink::EventData+;
+#pragma link C++ class AliHLTMUONTrackSink::AliEventData+;
 
 #pragma link C++ class AliHLTMUONTrackerInterface+;
 #pragma link C++ class AliHLTMUONTrackerCallback+;
index 1af2ae4adb12a1fef158b9737a31d8a682c3a97c..2d296cf9c754fb43a5c01824776a91096386f7d2 100644 (file)
@@ -5,6 +5,30 @@
 //
 ////////////////////////////////////////////////////////////////////////////////
 
+/* AliHLTMUONMicrodHLT is a minimalist framework for the dHLT tracking algorithm
+   to run in. It integrates all the internal components to execute the algorithm
+   properly.
+   To run the dHLT with the default Manso algorithm one performs the following
+   steps (Assuming we have an initialise AliMUONDataInterface object called
+   data):
+
+     // Create a trigger source for the track seeds and populate it with data.
+     AliHLTMUONTriggerSource ts(data);
+     // We also need the cluster points.
+     AliHLTMUONClusterSource cs(data);
+     // Need a track sink to store the output data.
+     AliHLTMUONTrackSink output;
+
+     // Now we need the framework created and hook up the input and output.
+     AliHLTMUONMicrodHLT dhlt;
+     dhlt.SetTriggerSource(&ts);
+     dhlt.SetClusterSource(&ts);
+     dhlt.SetTrackSink(&output);
+
+     // And finally run the algorithm.
+     dhlt.Run();
+ */
+
 #include "AliRoot/MicrodHLT.hpp"
 
 #include "TMethodCall.h"
 #include "new.hpp"
 
 
-namespace  // MicroFramework should be hidden.
+namespace  // AliMicroFramework should be hidden.
 {
 
 
-class MicroFramework : public AliHLTMUONCoreTrackerCallback
+class AliMicroFramework : public AliHLTMUONCoreTrackerCallback
 {
 public:
 
-       virtual ~MicroFramework() {}
+       virtual ~AliMicroFramework() {}
 
        virtual void RequestClusters(
                        AliHLTMUONCoreTracker* tracker,
                        Float /*left*/, Float /*right*/, Float /*bottom*/, Float /*top*/,
                        AliHLTMUONCoreChamberID chamber, const void* tag
-               )
-       {
-               Assert( 0 <= chamber && chamber <= 10 );
-               DebugMsg(2, "RequestClusters: tag = " << tag);
-               register void* ctag = const_cast<void*>(tag);  // We never modify tag so this is OK.
-               if (fClusters[chamber] != NULL)
-                       tracker->ReturnClusters(ctag, fClusters[chamber], fClusterCount[chamber]);
-               tracker->EndOfClusters(ctag);
-       }
+               );
 
        virtual void EndOfClusterRequests(AliHLTMUONCoreTracker* /*tracker*/)
        {
@@ -54,20 +70,7 @@ public:
        }
 
        
-       virtual void FoundTrack(AliHLTMUONCoreTracker* tracker)
-       {
-               DebugMsg(2, "FoundTrack");
-               
-               // Fetch the track data from the tracker.
-               AliHLTMUONCoreTrack newtrack;
-               tracker->FillTrackData(newtrack);
-               
-               // Don't forget to fill the trigger ID number, this is not done by the tracker.
-               newtrack.fTriggerid = fCurrentTriggerNumber;
-
-               *fTrackOutput->AddTrack() = AliHLTMUONConvert(newtrack);
-       }
-       
+       virtual void FoundTrack(AliHLTMUONCoreTracker* tracker);
        
        virtual void NoTrackFound(AliHLTMUONCoreTracker* /*tracker*/)
        {
@@ -82,149 +85,223 @@ public:
                        const AliHLTMUONClusterSource* clustersource,
                        AliHLTMUONTrackSink* tracksink,
                        AliHLTMUONCoreTracker* tracker
-               )
-       {
-               if ( ! triggersource->GetFirstEvent()) return;
-               while (triggersource->MoreEvents())
-               {
-                       Run(triggersource, clustersource, tracksink, tracker, triggersource->CurrentEvent());
-                       triggersource->GetNextEvent();
-               }
-       }
-
+               );
 
        void Run(
                        const AliHLTMUONTriggerSource* triggersource,
                        const AliHLTMUONClusterSource* clustersource,
                        AliHLTMUONTrackSink* tracksink,
                        AliHLTMUONCoreTracker* tracker, const Int eventnumber
-               )
-       {
-               // Tell the tracker to make callbacks to this framework object.
-               tracker->SetCallback(this);
-               fTrackOutput = tracksink;
-               fTrackOutput->SetNames(triggersource);  // Want the file and folder names to correspond.
-               
-               CreateClusterBlocks(clustersource, eventnumber);
-               try
-               {
-                       fTrackOutput->AddEvent(eventnumber);
-                       fTrackOutput->AddBlock();
-                       ProcessTriggers(triggersource, tracker);
-               }
-               finally
-               (
-                       FreeClusterBlocks();
                );
+
+private:
+
+       void CountClusterPoints(const AliHLTMUONClusterSource* cs);
+       void CreateClusterBlocks(const AliHLTMUONClusterSource* cs, Int eventnumber);
+       void FreeClusterBlocks();
+       void ProcessTriggers(const AliHLTMUONTriggerSource* ts, AliHLTMUONCoreTracker* tracker);
+       
+       UInt fClusterCount[10];     // Number of clusters in fClusters.
+       AliHLTMUONCoreClusterPoint* fClusters[10];  // Buffers for cluster points received.
+       AliHLTMUONTrackSink* fTrackOutput;  // The current track output object.
+       UInt fCurrentTriggerNumber;   // The current trigger, trigger number to use.
+};
+
+//-----------------------------------------------------------------------------
+
+
+void AliMicroFramework::RequestClusters(
+               AliHLTMUONCoreTracker* tracker,
+               Float /*left*/, Float /*right*/, Float /*bottom*/, Float /*top*/,
+               AliHLTMUONCoreChamberID chamber, const void* tag
+       )
+{
+// We return the clusters requested by the tracker.
+
+       Assert( 0 <= chamber && chamber <= 10 );
+       DebugMsg(2, "RequestClusters: tag = " << tag);
+       register void* ctag = const_cast<void*>(tag);  // We never modify tag so this is OK.
+       if (fClusters[chamber] != NULL)
+               tracker->ReturnClusters(ctag, fClusters[chamber], fClusterCount[chamber]);
+       tracker->EndOfClusters(ctag);
+}
+
+
+void AliMicroFramework::FoundTrack(AliHLTMUONCoreTracker* tracker)
+{
+// Callback method for the tracker.
+// We need to add the found track to the track sink.
+
+       DebugMsg(2, "FoundTrack");
+       
+       // Fetch the track data from the tracker.
+       AliHLTMUONCoreTrack newtrack;
+       tracker->FillTrackData(newtrack);
+       
+       // Don't forget to fill the trigger ID number, this is not done by the tracker.
+       newtrack.fTriggerid = fCurrentTriggerNumber;
+
+       *fTrackOutput->AddTrack() = AliHLTMUONConvert(newtrack);
+}
+       
+
+void AliMicroFramework::Run(
+               const AliHLTMUONTriggerSource* triggersource,
+               const AliHLTMUONClusterSource* clustersource,
+               AliHLTMUONTrackSink* tracksink,
+               AliHLTMUONCoreTracker* tracker
+       )
+{
+// Run the micro dHLT chain.
+
+       if ( ! triggersource->GetFirstEvent()) return;
+       while (triggersource->MoreEvents())
+       {
+               Run(triggersource, clustersource, tracksink, tracker, triggersource->CurrentEvent());
+               triggersource->GetNextEvent();
        }
+}
 
 
-private:
+void AliMicroFramework::Run(
+               const AliHLTMUONTriggerSource* triggersource,
+               const AliHLTMUONClusterSource* clustersource,
+               AliHLTMUONTrackSink* tracksink,
+               AliHLTMUONCoreTracker* tracker, const Int eventnumber
+       )
+{
+// Process a particlar event from the trigger and cluster source.
 
-       void CountClusterPoints(const AliHLTMUONClusterSource* cs)
+       // Tell the tracker to make callbacks to this framework object.
+       tracker->SetCallback(this);
+       fTrackOutput = tracksink;
+       fTrackOutput->SetNames(triggersource);  // Want the file and folder names to correspond.
+       
+       CreateClusterBlocks(clustersource, eventnumber);
+       try
        {
-               for (Int i = 0; i < 10; i++)
-                       fClusterCount[i] = 0;
+               fTrackOutput->AddEvent(eventnumber);
+               fTrackOutput->AddBlock();
+               ProcessTriggers(triggersource, tracker);
+       }
+       finally
+       (
+               FreeClusterBlocks();
+       );
+}
+
+
+void AliMicroFramework::CountClusterPoints(const AliHLTMUONClusterSource* cs)
+{
+// Count the number of clusters on each chamber in the cluster source.
+
+       for (Int i = 0; i < 10; i++)
+               fClusterCount[i] = 0;
 
-               cs->GetFirstBlock();
-               while (cs->MoreBlocks())
+       cs->GetFirstBlock();
+       while (cs->MoreBlocks())
+       {
+               Int chamber = cs->Chamber();
+               if (0 <= chamber && chamber < 10)
                {
-                       Int chamber = cs->Chamber();
-                       if (0 <= chamber && chamber < 10)
-                       {
-                               fClusterCount[chamber] += cs->NumberOfClusters();
-                       }
-                       cs->GetNextBlock();
+                       fClusterCount[chamber] += cs->NumberOfClusters();
                }
+               cs->GetNextBlock();
        }
+}
        
 
-       void CreateClusterBlocks(const AliHLTMUONClusterSource* cs, Int eventnumber)
+void AliMicroFramework::CreateClusterBlocks(
+               const AliHLTMUONClusterSource* cs, Int eventnumber
+       )
+{
+// Fill the fClusters buffers from cluster source.
+
+       // Must select the proper event before counting or filling the arrays.
+       if ( ! cs->GetEvent(eventnumber) ) return;
+       
+       CountClusterPoints(cs);
+       
+       UInt currentcount[10];
+       for (Int i = 0; i < 10; i++)
        {
-               // Must select the proper event before counting or filling the arrays.
-               if ( ! cs->GetEvent(eventnumber) ) return;
-               
-               CountClusterPoints(cs);
-               
-               UInt currentcount[10];
-               for (Int i = 0; i < 10; i++)
-               {
-                       // Initialise currentcount.
-                       currentcount[i] = 0;
-
-                       // Allocate arrays.
-                       if (fClusterCount[i] > 0)
-                               fClusters[i] = new AliHLTMUONCoreClusterPoint[ fClusterCount[i] ];
-                       else
-                               fClusters[i] = NULL;
-               }
+               // Initialise currentcount.
+               currentcount[i] = 0;
+
+               // Allocate arrays.
+               if (fClusterCount[i] > 0)
+                       fClusters[i] = new AliHLTMUONCoreClusterPoint[ fClusterCount[i] ];
+               else
+                       fClusters[i] = NULL;
+       }
 
-               // Copy all the cluster data into arrays.
-               cs->GetFirstBlock();
-               while (cs->MoreBlocks())
+       // Copy all the cluster data into arrays.
+       cs->GetFirstBlock();
+       while (cs->MoreBlocks())
+       {
+               Int chamber = cs->Chamber();
+               if (0 <= chamber && chamber < 10)
                {
-                       Int chamber = cs->Chamber();
-                       if (0 <= chamber && chamber < 10)
+                       cs->GetFirstCluster();
+                       while (cs->MoreClusters())
                        {
-                               cs->GetFirstCluster();
-                               while (cs->MoreClusters())
-                               {
-                                       AliHLTMUONCoreClusterPoint newpoint;
-                                       cs->FetchCluster(newpoint.fX, newpoint.fY);
-                                       fClusters[chamber][currentcount[chamber]++] = newpoint;
-                                       cs->GetNextCluster();
-                               }
+                               AliHLTMUONCoreClusterPoint newpoint;
+                               cs->FetchCluster(newpoint.fX, newpoint.fY);
+                               fClusters[chamber][currentcount[chamber]++] = newpoint;
+                               cs->GetNextCluster();
                        }
-                       cs->GetNextBlock();
                }
+               cs->GetNextBlock();
        }
+}
+
 
+void AliMicroFramework::FreeClusterBlocks()
+{
+// Release the fClusters buffers.
 
-       void FreeClusterBlocks()
+       for (Int i = 0; i < 10; i++)
        {
-               for (Int i = 0; i < 10; i++)
+               if (fClusters[i] != NULL)
                {
-                       if (fClusters[i] != NULL)
-                               delete [] fClusters[i];
+                       delete [] fClusters[i];
+                       fClusters[i] = NULL;
                }
        }
+}
        
        
-       void ProcessTriggers(const AliHLTMUONTriggerSource* ts, AliHLTMUONCoreTracker* tracker)
-       {
-               // The proper event must be selected before calling this method.
+void AliMicroFramework::ProcessTriggers(
+               const AliHLTMUONTriggerSource* ts, AliHLTMUONCoreTracker* tracker
+       )
+{
+// Go through the list of triggers and have tracker try find the track using
+// the trigger as a seed.
+// Note: The proper event must be selected before calling this method.
        
-               ts->GetFirstBlock();
-               while (ts->MoreBlocks())
+       ts->GetFirstBlock();
+       while (ts->MoreBlocks())
+       {
+               ts->GetFirstTrigger();
+               while (ts->MoreTriggers())
                {
-                       ts->GetFirstTrigger();
-                       while (ts->MoreTriggers())
-                       {
-                               const AliHLTMUONTriggerRecord* trigdata = ts->GetTrigger();
-                               Assert( trigdata != NULL );
-                               fCurrentTriggerNumber = (UInt)trigdata->TriggerNumber();
+                       const AliHLTMUONTriggerRecord* trigdata = ts->GetTrigger();
+                       Assert( trigdata != NULL );
+                       fCurrentTriggerNumber = (UInt)trigdata->TriggerNumber();
 
-                               AliHLTMUONCoreTriggerRecord trigger = AliHLTMUONConvert(*trigdata);
+                       AliHLTMUONCoreTriggerRecord trigger = AliHLTMUONConvert(*trigdata);
 
-                               DebugMsg(2, "Finding track:");
-                               tracker->FindTrack(trigger);
+                       DebugMsg(2, "Finding track:");
+                       tracker->FindTrack(trigger);
 
-                               DebugMsg(2, "Reset tracker.");
-                               tracker->Reset();
-                               
-                               ts->GetNextTrigger();
-                       }
-                       ts->GetNextBlock();
+                       DebugMsg(2, "Reset tracker.");
+                       tracker->Reset();
+                       
+                       ts->GetNextTrigger();
                }
+               ts->GetNextBlock();
        }
-       
-       
-       UInt fClusterCount[10];
-       AliHLTMUONCoreClusterPoint* fClusters[10];
-       
-       AliHLTMUONTrackSink* fTrackOutput;  // The current track output object.
-       UInt fCurrentTriggerNumber;   // The current trigger, trigger number to use.
-};
+}
 
 
 } // end of namespace
@@ -260,6 +337,8 @@ UInt_t AliHLTMUONBuildNumber()
 
 AliHLTMUONMicrodHLT::AliHLTMUONMicrodHLT() : TObject()
 {
+// Default constructor
+
        fTriggerSource = NULL;
        fClusterSource = NULL;
        fTrackSink = NULL;
@@ -287,6 +366,10 @@ void AliHLTMUONMicrodHLT::SetClusterSource(const AliHLTMUONClusterSource* source
 
 void AliHLTMUONMicrodHLT::Run()
 {
+// The entry point routine for the dHLT algorithm in the micro format.
+// To run the dHLT set the input and output objects with the set methods
+// provided and then call this Run method.
+
        DebugMsg(1, "Run");
 
        //AliHLTMUONCoreClusterFinder* clusterfinder;
@@ -346,7 +429,7 @@ void AliHLTMUONMicrodHLT::Run()
                        tracker = trackerproxy;
                }
 
-               MicroFramework framework;
+               AliMicroFramework framework;
                framework.Run(fTriggerSource, fClusterSource, fTrackSink, tracker);
        }
        finally
@@ -369,6 +452,8 @@ void AliHLTMUONMicrodHLT::DebugLevel(Int_t /*value*/) {}
 
 Int_t AliHLTMUONMicrodHLT::DebugLevel()
 {
+// Returns the debug level for the dHLT module.
+
 #ifdef DEBUG
        return gAliHLTMUONDebugLevel;
 #else // DEBUG
index 8b98a325f482e7fd6d694160ba6c4fb3a0aca040..cd0c91d691bec63c32aa59eafcfe9c4c2b1d6954 100644 (file)
@@ -5,6 +5,30 @@
 //
 ////////////////////////////////////////////////////////////////////////////////
 
+/* AliHLTMUONMicrodHLT is a minimalist framework for the dHLT tracking algorithm
+   to run in. It integrates all the internal components to execute the algorithm
+   properly.
+   To run the dHLT with the default Manso algorithm one performs the following
+   steps (Assuming we have an initialise AliMUONDataInterface object called
+   data):
+
+     // Create a trigger source for the track seeds and populate it with data.
+     AliHLTMUONTriggerSource ts(data);
+     // We also need the cluster points.
+     AliHLTMUONClusterSource cs(data);
+     // Need a track sink to store the output data.
+     AliHLTMUONTrackSink output;
+
+     // Now we need the framework created and hook up the input and output.
+     AliHLTMUONMicrodHLT dhlt;
+     dhlt.SetTriggerSource(&ts);
+     dhlt.SetClusterSource(&ts);
+     dhlt.SetTrackSink(&output);
+
+     // And finally run the algorithm.
+     dhlt.Run();
+ */
+
 #ifndef ALIHLTMUONMICRODHLT_H
 #define ALIHLTMUONMICRODHLT_H
 
@@ -87,6 +111,10 @@ public:
        static Int_t DebugLevel();
        
 private:
+       
+       // Do not allow copying of this object.
+       AliHLTMUONMicrodHLT(const AliHLTMUONMicrodHLT& /*object*/) : TObject() {}
+       AliHLTMUONMicrodHLT& operator = (const AliHLTMUONMicrodHLT& /*object*/) { return *this; }
 
        AliHLTMUONTriggerSource* fTriggerSource;           //! Trigger record input source.
        AliHLTMUONClusterSource* fClusterSource;           //! Cluster point input source.
index e158aef5c7e1fb183c057cd4732ec574067cba92..eb0c8e16174eb53c1ffb6250bf5e056e4dd6bac2 100644 (file)
@@ -5,16 +5,23 @@
 //
 ////////////////////////////////////////////////////////////////////////////////
 
+/* AliHLTMUONTrackSink is used as the output target object by AliHLTMUONMicrodHLT.
+   It is just a fancy buffer to store tracks that are found by the dHLT
+   algorithm.
+ */
 #include "AliRoot/TrackSink.hpp"
 #include "AliRoot/Base.hpp"
 
 ClassImp(AliHLTMUONTrackSink)
-ClassImp(AliHLTMUONTrackSink::EventData)
+ClassImp(AliHLTMUONTrackSink::AliEventData)
 
 
 AliHLTMUONTrackSink::AliHLTMUONTrackSink() :
-       TObject(), fEventList(AliHLTMUONTrackSink::EventData::Class())
+       TObject(), fEventList(AliHLTMUONTrackSink::AliEventData::Class())
 {
+// Default constructor
+
        fFilename = "";
        fFoldername = "";
        ResetAllPointers();
@@ -23,6 +30,8 @@ AliHLTMUONTrackSink::AliHLTMUONTrackSink() :
 
 AliHLTMUONTrackSink::~AliHLTMUONTrackSink()
 {
+// destructor.
+
        DebugMsg(1, "AliHLTMUONTrackSink::~AliHLTMUONTrackSink()");
        fEventList.Clear("C");
 }
@@ -30,6 +39,10 @@ AliHLTMUONTrackSink::~AliHLTMUONTrackSink()
 
 void AliHLTMUONTrackSink::AddEvent(Int_t eventnumber)
 {
+// Adds a new AliEventData block to the fEventList and updates internal pointers.
+// Cannot have duplicate event numbers so this method will display an error
+// message if one attempts to add the same event number more than once.
+
        DebugMsg(1, "AliHLTMUONTrackSink::AddEvent(" << eventnumber << ")");
        
        if (eventnumber < 0)
@@ -40,10 +53,10 @@ void AliHLTMUONTrackSink::AddEvent(Int_t eventnumber)
        
        // Make sure that the event number is not already added to the list of events.
        TIter next(&fEventList);
-       EventData* current;
-       while ((current = (EventData*)next()))
+       AliEventData* current;
+       while ((current = (AliEventData*)next()))
        {
-               if (current->fEventNumber == eventnumber)
+               if (current->EventNumber() == eventnumber)
                {
                        Error("AddEvent", "The event number %d is already stored.", eventnumber);
                        return;
@@ -51,8 +64,8 @@ void AliHLTMUONTrackSink::AddEvent(Int_t eventnumber)
        };
        
        fEventIndex = fEventList.GetEntriesFast();
-       new ( fEventList[fEventIndex] ) EventData(eventnumber); 
-       fCurrentEvent = (EventData*) fEventList[fEventIndex];
+       new ( fEventList[fEventIndex] ) AliEventData(eventnumber); 
+       fCurrentEvent = (AliEventData*) fEventList[fEventIndex];
        
        // Remember to reset the other pointers because the new event is empty.
        ResetBlockPointers();
@@ -65,6 +78,9 @@ void AliHLTMUONTrackSink::AddEvent(Int_t eventnumber)
 
 void AliHLTMUONTrackSink::AddBlock()
 {
+// Adds a new block to the current event and updates fCurrentBlock and
+// fCurrentTrack.
+
        DebugMsg(1, "AliHLTMUONTrackSink::AddBlock()");
        
        if (fCurrentEvent == NULL)
@@ -73,9 +89,9 @@ void AliHLTMUONTrackSink::AddBlock()
                return;
        };
        
-       fBlockIndex = fCurrentEvent->fBlocks.GetEntriesFast();
-       new ( fCurrentEvent->fBlocks[fBlockIndex] ) TClonesArray(AliHLTMUONTrack::Class());
-       fCurrentBlock = (TClonesArray*) fCurrentEvent->fBlocks[fBlockIndex];
+       fBlockIndex = fCurrentEvent->Blocks().GetEntriesFast();
+       new ( fCurrentEvent->Blocks()[fBlockIndex] ) TClonesArray(AliHLTMUONTrack::Class());
+       fCurrentBlock = (TClonesArray*) fCurrentEvent->Blocks()[fBlockIndex];
        
        // Remember to reset the track pointer because the new block is empty.
        ResetTrackPointers();
@@ -88,6 +104,9 @@ void AliHLTMUONTrackSink::AddBlock()
 
 void AliHLTMUONTrackSink::AddTrack(const AliHLTMUONTrack& track)
 {
+// Adds the given track to the current block.
+// If no current block is selected then an error message is displayed.
+
        DebugMsg(1, "AliHLTMUONTrackSink::AddTrack()");
 
        if (fCurrentBlock == NULL)
@@ -108,6 +127,11 @@ void AliHLTMUONTrackSink::AddTrack(const AliHLTMUONTrack& track)
 
 AliHLTMUONTrack* AliHLTMUONTrackSink::AddTrack()
 {
+// Adds a new track to the current event and block, and returns a pointer
+// to this track object to be filled by the caller.
+// The fCurrentTrack is updated appropriately.
+// If no current block is selected then NULL is returned.
+
        DebugMsg(1, "AliHLTMUONTrackSink::AddTrack()");
 
        if (fCurrentBlock == NULL)
@@ -131,6 +155,9 @@ void AliHLTMUONTrackSink::AddTrack(
                Float_t pt, const AliHLTMUONPoint hits[10], const AliHLTMUONRegion regions[10]
        )
 {
+// Adds the specified track parameters as a new track.
+// The fCurrentTrack is updated appropriately.
+
        DebugMsg(1, "AliHLTMUONTrackSink::AddTrack(" << triggerid << ", " << sign << ", "
                << momentum << ", " << pt << ", " << (void*)(&hits[0]) << ", "
                << (void*)(&regions[0]) << ")"
@@ -154,6 +181,8 @@ void AliHLTMUONTrackSink::AddTrack(
 
 void AliHLTMUONTrackSink::SetNames(const AliHLTMUONTriggerSource* triggersource)
 {
+// Sets the internal file and folder names from the trigger source.
+
        fFilename = triggersource->FileName();
        fFoldername = triggersource->FolderName();
 }
@@ -161,6 +190,8 @@ void AliHLTMUONTrackSink::SetNames(const AliHLTMUONTriggerSource* triggersource)
 
 void AliHLTMUONTrackSink::Clear(Option_t* /*option*/)
 {
+// Clears all the internal arrays.
+
        fFilename = "";
        fFoldername = "";
        ResetAllPointers();
@@ -170,13 +201,20 @@ void AliHLTMUONTrackSink::Clear(Option_t* /*option*/)
 
 Bool_t AliHLTMUONTrackSink::GetEvent(Int_t eventnumber) const
 {
+// Fetches the event data corresponding to the given event number.
+// Sets the current block and track to the first block and track for 
+// the newly selected event.
+// If there are no blocks or tracks then these pointers are set to NULL.
+// kTRUE is returned if the event was found. kFALSE is returned if the
+// event was not found and the internal pointers left untouched.
+
        DebugMsg(1, "AliHLTMUONTrackSink::GetEvent(" << eventnumber << ")" );
        
        // Try find the corresponding event in the list of events.
        for (Int_t i = 0; i < fEventList.GetEntriesFast(); i++)
        {
-               EventData* current = (EventData*) fEventList[i];
-               if (current->fEventNumber == eventnumber)
+               AliEventData* current = (AliEventData*) fEventList[i];
+               if (current->EventNumber() == eventnumber)
                {
                        fEventIndex = i;
                        fCurrentEvent = current;
@@ -193,11 +231,18 @@ Bool_t AliHLTMUONTrackSink::GetEvent(Int_t eventnumber) const
 
 Bool_t AliHLTMUONTrackSink::GetFirstEvent() const
 {
+// Fetches the first event stored in this AliHLTMUONTrackSink.
+// Sets the current block and track to the first block and track of the
+// first event.
+// If there are no blocks or tracks then these pointers are set to NULL.
+// kFALSE is returned if there are no events stored, kTRUE is returned
+// on success.
+
        DebugMsg(1, "AliHLTMUONTrackSink::GetFirstEvent()");
        if (fEventList.GetEntriesFast() > 0)
        {
                fEventIndex = 0;
-               fCurrentEvent = (EventData*) fEventList[0];
+               fCurrentEvent = (AliEventData*) fEventList[0];
                GetFirstBlock();
                DebugMsg(2, "\tfEventIndex = " << fEventIndex << " , fBlockIndex = " << fBlockIndex
                        << " , fTrackIndex = " << fTrackIndex
@@ -216,16 +261,23 @@ Bool_t AliHLTMUONTrackSink::GetFirstEvent() const
 
 Bool_t AliHLTMUONTrackSink::MoreEvents() const
 {
+// Returns kTRUE if there are more events to iterate over, kFALSE otherwise.
+
        return 0 <= fEventIndex && fEventIndex < fEventList.GetEntriesFast();
 }
 
 
 Bool_t AliHLTMUONTrackSink::GetNextEvent() const
 {
+// Fetches the next event stored following the currently selected one.
+// Sets the current block and track pointers to the first block and track
+// in the newly selected event. These pointers are set to NULL if there
+// are no blocks or tracks for this event.
+
        DebugMsg(1, "AliHLTMUONTrackSink::GetNextEvent()");
        if (fEventIndex < fEventList.GetEntriesFast() - 1)
        {
-               fCurrentEvent = (EventData*) fEventList[ ++fEventIndex ];
+               fCurrentEvent = (AliEventData*) fEventList[ ++fEventIndex ];
                GetFirstBlock();
                DebugMsg(2, "\tfEventIndex = " << fEventIndex << " , fBlockIndex = " << fBlockIndex
                        << " , fTrackIndex = " << fTrackIndex
@@ -242,8 +294,11 @@ Bool_t AliHLTMUONTrackSink::GetNextEvent() const
 
 Int_t AliHLTMUONTrackSink::CurrentEvent() const
 {
+// Returns the corresponding AliRoot event number for the current event.
+// -1 is returned if no event is selected.
+
        if (fCurrentEvent != NULL)
-               return fCurrentEvent->fEventNumber;
+               return fCurrentEvent->EventNumber();
        else
                return -1;
 }
@@ -251,6 +306,9 @@ Int_t AliHLTMUONTrackSink::CurrentEvent() const
 
 Int_t AliHLTMUONTrackSink::NumberOfBlocks() const
 {
+// Returns the number of track blocks in the current event.
+// -1 is returned if no event is selected.
+
        DebugMsg(1, "AliHLTMUONTrackSink::NumberOfBlocks()");
        if (fCurrentEvent == NULL)
        {
@@ -258,12 +316,17 @@ Int_t AliHLTMUONTrackSink::NumberOfBlocks() const
                return -1;
        }
        else
-               return fCurrentEvent->fBlocks.GetEntriesFast();
+               return fCurrentEvent->Blocks().GetEntriesFast();
 }
 
 
 Bool_t AliHLTMUONTrackSink::GetBlock(Int_t index) const
 {
+// Fetches the index'th block in the current event.
+// Sets the current track to the first track in the block.
+// If there are no tracks then the track pointers are reset.
+// kTRUE is returned if the block was found, kFALSE otherwise.
+
        DebugMsg(1, "AliHLTMUONTrackSink::GetBlock(" << index << ")");
        
        // Note NumberOfBlocks() also checks if the event was selected.
@@ -273,7 +336,7 @@ Bool_t AliHLTMUONTrackSink::GetBlock(Int_t index) const
        if ( 0 <= index && index < numberofblocks )
        {
                fBlockIndex = index;
-               fCurrentBlock = (TClonesArray*) fCurrentEvent->fBlocks[index];
+               fCurrentBlock = (TClonesArray*) fCurrentEvent->Blocks()[index];
                GetFirstTrack();
                DebugMsg(2, "\tfEventIndex = " << fEventIndex << " , fBlockIndex = " << fBlockIndex
                        << " , fTrackIndex = " << fTrackIndex
@@ -300,12 +363,16 @@ Bool_t AliHLTMUONTrackSink::GetBlock(Int_t index) const
 
 Bool_t AliHLTMUONTrackSink::GetFirstBlock() const
 {
+// Fetches the first block in the current event.
+// Sets the current track to the first track in the block.
+// If there are no tracks then the fCurrentTracks pointer is set to NULL.
+
        DebugMsg(1, "AliHLTMUONTrackSink::GetFirstBlock()");
        // Note: NumberOfBlocks() also checks if fCurrentEvent != NULL.
        if (NumberOfBlocks() > 0)
        {
                fBlockIndex = 0;
-               fCurrentBlock = (TClonesArray*) fCurrentEvent->fBlocks[fBlockIndex];
+               fCurrentBlock = (TClonesArray*) fCurrentEvent->Blocks()[fBlockIndex];
                GetFirstTrack();
                DebugMsg(2, "\tfEventIndex = " << fEventIndex << " , fBlockIndex = " << fBlockIndex
                        << " , fTrackIndex = " << fTrackIndex
@@ -319,19 +386,25 @@ Bool_t AliHLTMUONTrackSink::GetFirstBlock() const
 
 Bool_t AliHLTMUONTrackSink::MoreBlocks() const
 {
+// Returns kTRUE if there are more blocks to iterate over.
+
        return 0 <= fBlockIndex && fBlockIndex < NumberOfBlocks();
 }
 
 
 Bool_t AliHLTMUONTrackSink::GetNextBlock() const
 {
+// Fetches the next block in the current event.
+// kTRUE is returned if the block was found, kFALSE otherwise.
+// The current track pointers are reset if no more blocks are found.
+
        DebugMsg(1, "AliHLTMUONTrackSink::GetNextBlock()");
 
        // Note: NumberOfBlocks() checks if fCurrentEvent != NULL. If it is then it returns -1
        // and since fBlockIndex is always >= -1 the if statement must go to the else part.
        if (fBlockIndex < NumberOfBlocks() - 1)
        {
-               fCurrentBlock = (TClonesArray*) fCurrentEvent->fBlocks[ ++fBlockIndex ];
+               fCurrentBlock = (TClonesArray*) fCurrentEvent->Blocks()[ ++fBlockIndex ];
                GetFirstTrack();
                DebugMsg(2, "\tfEventIndex = " << fEventIndex << " , fBlockIndex = " << fBlockIndex
                        << " , fTrackIndex = " << fTrackIndex
@@ -348,6 +421,9 @@ Bool_t AliHLTMUONTrackSink::GetNextBlock() const
 
 Int_t AliHLTMUONTrackSink::NumberOfTracks() const
 {
+// Returns the number of tracks in the current block.
+// -1 is returned if no block is selected.
+
        DebugMsg(1, "AliHLTMUONTrackSink::NumberOfTracks()");
        if (fCurrentBlock == NULL)
        {
@@ -361,6 +437,9 @@ Int_t AliHLTMUONTrackSink::NumberOfTracks() const
 
 const AliHLTMUONTrack* AliHLTMUONTrackSink::GetTrack(Int_t index) const
 {
+// Fetches the index'th track in the current block.
+// NULL is returned if the track was not found.
+
        DebugMsg(1, "AliHLTMUONTrackSink::GetTrack(" << index << ")");
 
        // Note NumberOfTracks() also checks if the event and block was selected.
@@ -396,6 +475,9 @@ const AliHLTMUONTrack* AliHLTMUONTrackSink::GetTrack(Int_t index) const
 
 const AliHLTMUONTrack* AliHLTMUONTrackSink::GetFirstTrack() const
 {
+// Fetches the first track in the current block.
+// NULL is returned if the track was not found.
+
        DebugMsg(1, "AliHLTMUONTrackSink::GetFirstTrack()");
        // Note: NumberOfTracks() also checks if fCurrentBlock != NULL.
        if (NumberOfTracks() > 0)
@@ -414,12 +496,18 @@ const AliHLTMUONTrack* AliHLTMUONTrackSink::GetFirstTrack() const
 
 Bool_t AliHLTMUONTrackSink::MoreTracks() const
 {
+// Returns kTRUE if there are more tracks to iterate over in
+// the current block. kFALSE is returned otherwise.
+
        return 0 <= fTrackIndex && fTrackIndex < NumberOfTracks();
 }
 
 
 const AliHLTMUONTrack* AliHLTMUONTrackSink::GetNextTrack() const
 {
+// Fetches the next track in the current block.
+// NULL is returned if the track was not found.
+
        DebugMsg(1, "AliHLTMUONTrackSink::GetNextTrack()");
        
        // Note: NumberOfTracks() checks if fCurrentBlock != NULL. If it is then it returns -1
@@ -442,6 +530,8 @@ const AliHLTMUONTrack* AliHLTMUONTrackSink::GetNextTrack() const
 
 void AliHLTMUONTrackSink::ResetAllPointers() const
 {
+// Sets all the current pointers to NULL and indices to -1.
+
        fEventIndex = -1;
        fCurrentEvent = NULL;
        fBlockIndex = -1;
@@ -456,6 +546,8 @@ void AliHLTMUONTrackSink::ResetAllPointers() const
 
 void AliHLTMUONTrackSink::ResetBlockPointers() const
 {
+// Sets the block and track pointers to NULL and indices to -1.
+
        fBlockIndex = -1;
        fCurrentBlock = NULL;
        fTrackIndex = -1;
@@ -468,6 +560,8 @@ void AliHLTMUONTrackSink::ResetBlockPointers() const
 
 void AliHLTMUONTrackSink::ResetTrackPointers() const
 {
+// Sets just the current track pointer to NULL and index to -1.
+
        fTrackIndex = -1;
        fCurrentTrack = NULL;
        DebugMsg(2, "\tfEventIndex = " << fEventIndex << " , fBlockIndex = " << fBlockIndex
@@ -476,15 +570,17 @@ void AliHLTMUONTrackSink::ResetTrackPointers() const
 }
 
 
-AliHLTMUONTrackSink::EventData::EventData() : fBlocks(TClonesArray::Class())
+AliHLTMUONTrackSink::AliEventData::AliEventData() : fBlocks(TClonesArray::Class())
 {
        fEventNumber = -1;
 }
 
 
-AliHLTMUONTrackSink::EventData::EventData(Int_t eventnumber)
+AliHLTMUONTrackSink::AliEventData::AliEventData(Int_t eventnumber)
        : fBlocks(TClonesArray::Class())
 {
+// Creates a new event data block with the specified event number.
+
        fEventNumber = eventnumber;
        
        // If the following is not set then we do not write the fBlocks properly.
@@ -492,9 +588,9 @@ AliHLTMUONTrackSink::EventData::EventData(Int_t eventnumber)
 }
 
 
-AliHLTMUONTrackSink::EventData::~EventData()
+AliHLTMUONTrackSink::AliEventData::~AliEventData()
 {
-       DebugMsg(1, "AliHLTMUONTrackSink::EventData::~EventData()");
+       DebugMsg(1, "AliHLTMUONTrackSink::AliEventData::~AliEventData()");
        fBlocks.Clear("C");
 }
 
index 44d9ef6b6bab5e693116165a4a9bbeaedea87a7b..c624298c985d599fabdb026ba61bc30bc871f145 100644 (file)
@@ -5,6 +5,11 @@
 //
 ////////////////////////////////////////////////////////////////////////////////
 
+/* AliHLTMUONTrackSink is used as the output target object by AliHLTMUONMicrodHLT.
+   It is just a fancy buffer to store tracks that are found by the dHLT
+   algorithm.
+ */
+
 #ifndef ALIHLTMUONTRACKSINK_H
 #define ALIHLTMUONTRACKSINK_H
 
@@ -25,7 +30,7 @@ public:
        AliHLTMUONTrackSink();
        virtual ~AliHLTMUONTrackSink();
        
-       /* Adds a new EventData block to the fEventList and updates internal pointers.
+       /* Adds a new AliEventData block to the fEventList and updates internal pointers.
           Cannot have duplicate event numbers so this method will display an error
           message if one attempts to add the same event number more than once.
         */ 
@@ -178,21 +183,30 @@ public:
 
 public:  // Unfortunately ROOT requires the following to be public.
 
-       class EventData : public TObject
+       class AliEventData : public TObject
        {
        public:
-               EventData();
-               EventData(Int_t eventnumber);
-               virtual ~EventData();
+               AliEventData();
+               AliEventData(Int_t eventnumber);
+               virtual ~AliEventData();
+
+               Int_t& EventNumber() { return fEventNumber; }
+               TClonesArray& Blocks() { return fBlocks; }
 
+       private:
+       
                Int_t fEventNumber;  // Event number for this set of track blocks.
                TClonesArray fBlocks;  // The list of track blocks for this event.
                
-               ClassDef(EventData, 1);  // Data per event.
+               ClassDef(AliEventData, 1);  // Data per event.
        };
 
 private:
 
+       // Do not allow copying of this object.
+       AliHLTMUONTrackSink(const AliHLTMUONTrackSink& /*object*/) : TObject() {}
+       AliHLTMUONTrackSink& operator = (const AliHLTMUONTrackSink& /*object*/) { return *this; }
+
        /* Sets all the current pointers to NULL and indices to -1.
         */
        void ResetAllPointers() const;
@@ -209,7 +223,7 @@ private:
        TString fFoldername;  // The folder name from which track data was taken.
        
        mutable Int_t fEventIndex;            //! The current event index number.
-       mutable EventData* fCurrentEvent;     //! Pointer to the currently selected event.
+       mutable AliEventData* fCurrentEvent;     //! Pointer to the currently selected event.
        mutable Int_t fBlockIndex;            //! The current block index number.
        mutable TClonesArray* fCurrentBlock;  //! Pointer to the currently selected block.
        mutable Int_t fTrackIndex;            //! The current track index number.
index 6a69377de2c7c5066ea8a420774b9d2eef042da5..20af321179be59578be95b0ca1e750596677c801 100644 (file)
@@ -5,6 +5,12 @@
 //
 ////////////////////////////////////////////////////////////////////////////////
 
+/* AliHLTMUONTriggerSource is used to extract L0 trigger information for
+   the muon spectrometer from a simulated event stored in .root files by AliRoot.
+   It is used by the AliHLTMUONMicrodHLT class as a input data set for the
+   dHLT algorithm.
+ */
 #include "AliRoot/TriggerSource.hpp"
 #include "AliRoot/Base.hpp"
 #include "Tracking/Calculations.hpp"
 #endif
 
 ClassImp(AliHLTMUONTriggerSource)
-ClassImp(AliHLTMUONTriggerSource::EventData)
+ClassImp(AliHLTMUONTriggerSource::AliEventData)
 
 
 AliHLTMUONTriggerSource::AliHLTMUONTriggerSource()
-       : TObject(), fEventList(AliHLTMUONTriggerSource::EventData::Class())
+       : TObject(), fEventList(AliHLTMUONTriggerSource::AliEventData::Class())
 {
-       fAreaToUse = FromWholePlane;
-       fDataToUse = FromLocalTriggers;
+// Default constructor.
+
+       fAreaToUse = kFromWholePlane;
+       fDataToUse = kFromLocalTriggers;
        fMaxBlockSize = 0xFFFFFFFF;
        fUseLookupTable = kTRUE;
        fFilename = "";
@@ -43,10 +51,12 @@ AliHLTMUONTriggerSource::AliHLTMUONTriggerSource()
 
 
 AliHLTMUONTriggerSource::AliHLTMUONTriggerSource(AliMUONDataInterface* data)
-       : TObject(), fEventList(AliHLTMUONTriggerSource::EventData::Class())
+       : TObject(), fEventList(AliHLTMUONTriggerSource::AliEventData::Class())
 {
-       fAreaToUse = FromWholePlane;
-       fDataToUse = FromLocalTriggers;
+// Creates a new trigger source object by filling data from the data interface.
+
+       fAreaToUse = kFromWholePlane;
+       fDataToUse = kFromLocalTriggers;
        fMaxBlockSize = 0xFFFFFFFF;
        fUseLookupTable = kTRUE;
        fFilename = "";
@@ -65,6 +75,9 @@ AliHLTMUONTriggerSource::~AliHLTMUONTriggerSource()
 
 void AliHLTMUONTriggerSource::FillFrom(AliMUONDataInterface* data)
 {
+// Fills the internal data structures from the specified data interface
+// for all the events found in AliMUONDataInterface.
+          
        DebugMsg(1, "FillFrom(AliMUONDataInterface*)");
        
        if (FileAndFolderOk(data))
@@ -84,6 +97,9 @@ void AliHLTMUONTriggerSource::FillFrom(AliMUONDataInterface* data)
 
 void AliHLTMUONTriggerSource::FillFrom(AliMUONDataInterface* data, Int_t event)
 {
+// Fills the internal data structures from the specified data interface
+// for the given event.
+
        DebugMsg(1, "FillFrom(AliMUONDataInterface*, Int_t)");
        
        if (FileAndFolderOk(data))
@@ -101,6 +117,16 @@ void AliHLTMUONTriggerSource::FillFrom(
                Int_t event, Int_t trigger, Bool_t newblock
        )
 {
+// Fills the internal data structures from the specified data interface
+// for the given event and trigger number.
+// If 'newblock' is set to true then the new trigger record is added to 
+// a new block. Otherwise the point is added to the current block.
+// Note: This method ignores the fAreaToUse and fMaxBlockSize flags.
+// This is very usefull for custom trigger source filling.
+// For the case of adding data from AliMUONHit objects the 'trigger'
+// parameter becomes the track number in TreeH and not the index of the
+// AliMUONLocalTrigger object.
+
        DebugMsg(1, "FillFrom(AliMUONDataInterface*, Int_t, Int_t, Bool_t)");
        
        if (FileAndFolderOk(data))
@@ -119,7 +145,7 @@ void AliHLTMUONTriggerSource::FillFrom(
                }
                else
                {
-                       if (fCurrentEvent->fEventNumber != event)
+                       if (fCurrentEvent->EventNumber() != event)
                        {
                                Bool_t found = GetEvent(event);
                                if ( ! found) AddEvent(event);
@@ -143,6 +169,8 @@ void AliHLTMUONTriggerSource::FillFrom(
 
 void AliHLTMUONTriggerSource::Clear(Option_t* /*option*/)
 {
+// Clears all the internal arrays.
+
        fFilename = "";
        fFoldername = "";
        ResetAllPointers();
@@ -152,13 +180,18 @@ void AliHLTMUONTriggerSource::Clear(Option_t* /*option*/)
 
 Bool_t AliHLTMUONTriggerSource::GetEvent(Int_t eventnumber) const
 {
+// Fetches the specified event number stored in this AliHLTMUONTriggerSource.
+// Sets the current block and trigger to the first block and trigger record in
+// the event. If there are no blocks or trigger records then these pointers are
+// set to NULL. kTRUE is returned if the event was found, kFALSE otherwise.
+
        DebugMsg(1, "AliHLTMUONTriggerSource::GetEvent(" << eventnumber << ")" );
        
        // Try find the corresponding event in the list of events.
        for (Int_t i = 0; i < fEventList.GetEntriesFast(); i++)
        {
-               EventData* current = (EventData*) fEventList[i];
-               if (current->fEventNumber == eventnumber)
+               AliEventData* current = (AliEventData*) fEventList[i];
+               if (current->EventNumber() == eventnumber)
                {
                        fEventIndex = i;
                        fCurrentEvent = current;
@@ -175,11 +208,16 @@ Bool_t AliHLTMUONTriggerSource::GetEvent(Int_t eventnumber) const
 
 Bool_t AliHLTMUONTriggerSource::GetFirstEvent() const
 {
+// Fetches the first event stored in this AliHLTMUONTriggerSource.
+// Sets the current block and trigger record to the first block and trigger
+// in the event. If there are no blocks or trigger records then these pointers
+// are set to NULL. kTRUE is returned if the event was found, kFALSE otherwise.
+
        DebugMsg(1, "AliHLTMUONTriggerSource::GetFirstEvent()");
        if (fEventList.GetEntriesFast() > 0)
        {
                fEventIndex = 0;
-               fCurrentEvent = (EventData*) fEventList[0];
+               fCurrentEvent = (AliEventData*) fEventList[0];
                GetFirstBlock();
                DebugMsg(2, "\tfEventIndex = " << fEventIndex << " , fBlockIndex = " << fBlockIndex
                        << " , fTriggerIndex = " << fTriggerIndex
@@ -198,16 +236,22 @@ Bool_t AliHLTMUONTriggerSource::GetFirstEvent() const
 
 Bool_t AliHLTMUONTriggerSource::MoreEvents() const
 {
+// Returns kTRUE if there are more events to iterate over.
+
        return 0 <= fEventIndex && fEventIndex < fEventList.GetEntriesFast();
 }
 
 
 Bool_t AliHLTMUONTriggerSource::GetNextEvent() const
 {
+// Fetches the next event stored following the currently selected one.
+// kTRUE is returned if the event was found, kFALSE otherwise.
+// The internal pointers are reset if we reached the last event.
+          
        DebugMsg(1, "AliHLTMUONTriggerSource::GetNextEvent()");
        if (fEventIndex < fEventList.GetEntriesFast() - 1)
        {
-               fCurrentEvent = (EventData*) fEventList[ ++fEventIndex ];
+               fCurrentEvent = (AliEventData*) fEventList[ ++fEventIndex ];
                GetFirstBlock();
                DebugMsg(2, "\tfEventIndex = " << fEventIndex << " , fBlockIndex = " << fBlockIndex
                        << " , fTriggerIndex = " << fTriggerIndex
@@ -224,8 +268,11 @@ Bool_t AliHLTMUONTriggerSource::GetNextEvent() const
 
 Int_t AliHLTMUONTriggerSource::CurrentEvent() const
 {
+// Returns the corresponding AliRoot event number for the current event.
+// -1 is returned if no event is selected.
+          
        if (fCurrentEvent != NULL)
-               return fCurrentEvent->fEventNumber;
+               return fCurrentEvent->EventNumber();
        else
                return -1;
 }
@@ -233,6 +280,9 @@ Int_t AliHLTMUONTriggerSource::CurrentEvent() const
 
 Int_t AliHLTMUONTriggerSource::NumberOfBlocks() const
 {
+// Returns the number of trigger record blocks in the current event.
+// -1 is returned if no event is selected.
+          
        DebugMsg(1, "AliHLTMUONTriggerSource::NumberOfBlocks()");
        if (fCurrentEvent == NULL)
        {
@@ -240,12 +290,17 @@ Int_t AliHLTMUONTriggerSource::NumberOfBlocks() const
                return -1;
        }
        else
-               return fCurrentEvent->fBlocks.GetEntriesFast();
+               return fCurrentEvent->Blocks().GetEntriesFast();
 }
 
 
 Bool_t AliHLTMUONTriggerSource::GetBlock(Int_t index) const
 {
+// Fetches the index'th block in the current event.
+// Sets the current trigger record to the first trigger in the block.
+// If there are no trigger records then this pointer is set to NULL.
+// kTRUE is returned if the block was found, kFALSE otherwise.
+
        DebugMsg(1, "AliHLTMUONTriggerSource::GetBlock(" << index << ")");
        
        // Note NumberOfBlocks() also checks if the event was selected.
@@ -255,7 +310,7 @@ Bool_t AliHLTMUONTriggerSource::GetBlock(Int_t index) const
        if ( 0 <= index && index < numberofblocks )
        {
                fBlockIndex = index;
-               fCurrentBlock = (TClonesArray*) fCurrentEvent->fBlocks[index];
+               fCurrentBlock = (TClonesArray*) fCurrentEvent->Blocks()[index];
                GetFirstTrigger();
                DebugMsg(2, "\tfEventIndex = " << fEventIndex << " , fBlockIndex = " << fBlockIndex
                        << " , fTriggerIndex = " << fTriggerIndex
@@ -282,12 +337,17 @@ Bool_t AliHLTMUONTriggerSource::GetBlock(Int_t index) const
 
 Bool_t AliHLTMUONTriggerSource::GetFirstBlock() const
 {
+// Fetches the first block in the current event.
+// Sets the current trigger record to the first trigger in the block.
+// If there are no trigger records then this pointer is set to NULL.
+// kTRUE is returned if the block was found, kFALSE otherwise.
+          
        DebugMsg(1, "AliHLTMUONTriggerSource::GetFirstBlock()");
        // Note: NumberOfBlocks() also checks if fCurrentEvent != NULL.
        if (NumberOfBlocks() > 0)
        {
                fBlockIndex = 0;
-               fCurrentBlock = (TClonesArray*) fCurrentEvent->fBlocks[fBlockIndex];
+               fCurrentBlock = (TClonesArray*) fCurrentEvent->Blocks()[fBlockIndex];
                GetFirstTrigger();
                DebugMsg(2, "\tfEventIndex = " << fEventIndex << " , fBlockIndex = " << fBlockIndex
                        << " , fTriggerIndex = " << fTriggerIndex
@@ -301,19 +361,24 @@ Bool_t AliHLTMUONTriggerSource::GetFirstBlock() const
 
 Bool_t AliHLTMUONTriggerSource::MoreBlocks() const
 {
+// Returns kTRUE if there are more blocks to be traversed.
+
        return 0 <= fBlockIndex && fBlockIndex < NumberOfBlocks();
 }
 
 
 Bool_t AliHLTMUONTriggerSource::GetNextBlock() const
 {
+// Fetches the next block in the current event.
+// kTRUE is returned if the block was found, kFALSE otherwise.
+          
        DebugMsg(1, "AliHLTMUONTriggerSource::GetNextBlock()");
 
        // Note: NumberOfBlocks() checks if fCurrentEvent != NULL. If it is then it returns -1
        // and since fBlockIndex is always >= -1 the if statement must go to the else part.
        if (fBlockIndex < NumberOfBlocks() - 1)
        {
-               fCurrentBlock = (TClonesArray*) fCurrentEvent->fBlocks[ ++fBlockIndex ];
+               fCurrentBlock = (TClonesArray*) fCurrentEvent->Blocks()[ ++fBlockIndex ];
                GetFirstTrigger();
                DebugMsg(2, "\tfEventIndex = " << fEventIndex << " , fBlockIndex = " << fBlockIndex
                        << " , fTriggerIndex = " << fTriggerIndex
@@ -330,6 +395,9 @@ Bool_t AliHLTMUONTriggerSource::GetNextBlock() const
 
 Int_t AliHLTMUONTriggerSource::NumberOfTriggers() const
 {
+// Returns the number of trigger records in the current block.
+// -1 is returned if no block is selected.
+
        DebugMsg(1, "AliHLTMUONTriggerSource::NumberOfTriggers()");
        if (fCurrentBlock == NULL)
        {
@@ -343,6 +411,10 @@ Int_t AliHLTMUONTriggerSource::NumberOfTriggers() const
 
 const AliHLTMUONTriggerRecord* AliHLTMUONTriggerSource::GetTrigger(Int_t triggernumber) const
 {
+// Fetches the trigger record with the specified trigger number from
+// the current block.
+// NULL is returned if the record was not found.
+
        DebugMsg(1, "AliHLTMUONTriggerSource::GetTrigger(" << triggernumber << ")");
 
        if (fCurrentBlock == NULL)
@@ -371,6 +443,9 @@ const AliHLTMUONTriggerRecord* AliHLTMUONTriggerSource::GetTrigger(Int_t trigger
 
 const AliHLTMUONTriggerRecord* AliHLTMUONTriggerSource::GetFirstTrigger() const
 {
+// Fetches the first trigger record in the current block.
+// NULL is returned if the record was not found.
+
        DebugMsg(1, "AliHLTMUONTriggerSource::GetFirstTrigger()");
        // Note: NumberOfTriggers() also checks if fCurrentBlock != NULL.
        if (NumberOfTriggers() > 0)
@@ -389,12 +464,17 @@ const AliHLTMUONTriggerRecord* AliHLTMUONTriggerSource::GetFirstTrigger() const
 
 Bool_t AliHLTMUONTriggerSource::MoreTriggers() const
 {
+// Returns kTRUE if there are more triggers to iterate over.
+
        return 0 <= fTriggerIndex && fTriggerIndex < NumberOfTriggers();
 }
 
 
 const AliHLTMUONTriggerRecord* AliHLTMUONTriggerSource::GetNextTrigger() const
 {
+// Fetches the next trigger record in the current block.
+// NULL is returned if the record was not found.
+
        DebugMsg(1, "AliHLTMUONTriggerSource::GetNextTrigger()");
        
        // Note: NumberOfTriggers() checks if fCurrentBlock != NULL. If it is then it returns -1
@@ -417,6 +497,11 @@ const AliHLTMUONTriggerRecord* AliHLTMUONTriggerSource::GetNextTrigger() const
 
 Int_t AliHLTMUONTriggerSource::CurrentTrigger() const
 {
+// Returns the trigger record number for the currently selected trigger record.
+// This number corresponds to the index'th AliMUONLocalTrigger object for the
+// current event.
+// -1 is returned if no trigger record is selected.
+
        if (fCurrentTrigger != NULL)
        {
                return fCurrentTrigger->TriggerNumber();
@@ -431,13 +516,16 @@ Int_t AliHLTMUONTriggerSource::CurrentTrigger() const
 
 void AliHLTMUONTriggerSource::AddEvent(Int_t eventnumber)
 {
+// Adds a new AliEventData block to the fEventList and updates the fCurrentEvent,
+// fCurrentBlock and fCurrentTrigger pointers.
+
        DebugMsg(1, "AliHLTMUONTriggerSource::AddEvent(" << eventnumber << ")");
        Assert( eventnumber >= 0 );
 
        // Assume the eventnumber does not already exist in the event list.
        fEventIndex = fEventList.GetEntriesFast();
-       new ( fEventList[fEventIndex] ) EventData(eventnumber);
-       fCurrentEvent = (EventData*) fEventList[fEventIndex];
+       new ( fEventList[fEventIndex] ) AliEventData(eventnumber);
+       fCurrentEvent = (AliEventData*) fEventList[fEventIndex];
        
        // Remember to reset the other pointers because the new event is empty.
        ResetBlockPointers();
@@ -450,6 +538,8 @@ void AliHLTMUONTriggerSource::AddEvent(Int_t eventnumber)
 
 void AliHLTMUONTriggerSource::AddBlock()
 {
+// Adds a new block to the current event and updates fCurrentBlock and fCurrentTrigger.
+
        DebugMsg(1, "AliHLTMUONTriggerSource::AddBlock()");
        
        if (fCurrentEvent == NULL)
@@ -458,9 +548,9 @@ void AliHLTMUONTriggerSource::AddBlock()
                return;
        }
        
-       fBlockIndex = fCurrentEvent->fBlocks.GetEntriesFast();
-       new ( fCurrentEvent->fBlocks[fBlockIndex] ) TClonesArray(AliHLTMUONTriggerRecord::Class());
-       fCurrentBlock = (TClonesArray*) fCurrentEvent->fBlocks[fBlockIndex];
+       fBlockIndex = fCurrentEvent->Blocks().GetEntriesFast();
+       new ( fCurrentEvent->Blocks()[fBlockIndex] ) TClonesArray(AliHLTMUONTriggerRecord::Class());
+       fCurrentBlock = (TClonesArray*) fCurrentEvent->Blocks()[fBlockIndex];
        
        // Remember to reset the trigger pointer because the new block is empty.
        ResetTriggerPointers();
@@ -473,6 +563,9 @@ void AliHLTMUONTriggerSource::AddBlock()
 
 void AliHLTMUONTriggerSource::AddTrigger(const AliHLTMUONTriggerRecord& data)
 {
+// Adds a new trigger record to the current event and block.
+// The fCurrentTrigger is updated appropriately.
+
        DebugMsg(1, "AliHLTMUONTriggerSource::AddTrigger(" << (void*)&data << ")");
 
        if (fCurrentBlock == NULL)
@@ -493,6 +586,11 @@ void AliHLTMUONTriggerSource::AddTrigger(const AliHLTMUONTriggerRecord& data)
 
 Bool_t AliHLTMUONTriggerSource::FileAndFolderOk(AliMUONDataInterface* data)
 {
+// Checks if the file and folder names correspond to this AliHLTMUONTriggerSource's 
+// file and folder names. kTRUE is returned if they do.
+// If the file and folder names are empty then they are assigned the names
+// as found in the data interface and kTRUE is returned.
+
        if (fFilename == "")
        {
                // Nothing filled yet so set the file and folder names.
@@ -525,6 +623,10 @@ Bool_t AliHLTMUONTriggerSource::FileAndFolderOk(AliMUONDataInterface* data)
 
 void AliHLTMUONTriggerSource::AddEventFrom(AliMUONDataInterface* data, AliMUON* module, Int_t event)
 {
+// Adds the whole event from the data interface to the internal data structures.
+// It is assumed that FileAndFolderOk(data) returns true just before calling
+// this method.
+
        if ( data->GetEvent(event) )
        {
                AddEvent(event);
@@ -535,7 +637,7 @@ void AliHLTMUONTriggerSource::AddEventFrom(AliMUONDataInterface* data, AliMUON*
 
                switch (fDataToUse)
                {
-               case FromHits:
+               case kFromHits:
                        for (Int_t track = 0; track < data->NumberOfTracks(); track++)
                        {
                                if ( ! FillTriggerFromHits(data, track, trigdata) )
@@ -555,9 +657,9 @@ void AliHLTMUONTriggerSource::AddEventFrom(AliMUONDataInterface* data, AliMUON*
                        }
                        break;
 
-               case FromLocalTriggers:
+               case kFromLocalTriggers:
                        Assert( module != NULL );
-                       DebugMsg(4, "Taking FromLocalTriggers branch...");
+                       DebugMsg(4, "Taking kFromLocalTriggers branch...");
                        for (Int_t i = 0; i < data->NumberOfLocalTriggers(); i++)
                        {
                                DebugMsg(4, "for loop: i = " << i);
@@ -588,13 +690,17 @@ void AliHLTMUONTriggerSource::AddEventFrom(AliMUONDataInterface* data, AliMUON*
 
 void AliHLTMUONTriggerSource::AddTriggerFrom(AliMUONDataInterface* data, AliMUON* module, Int_t trigger)
 {
+// Adds the specified trigger record from the given data interface.
+// The data interface should be initialised correctly, that is the event
+// should already be selected before calling this method.
+
        DebugMsg(1, "Entering AddTriggerFrom");
 
        AliHLTMUONTriggerRecord trigdata;
 
        switch (fDataToUse)
        {
-       case FromHits:
+       case kFromHits:
                {
                // Note: in this case we treat the trigger parameter as a track number.
                if ( ! FillTriggerFromHits(data, trigger, trigdata) )
@@ -602,7 +708,7 @@ void AliHLTMUONTriggerSource::AddTriggerFrom(AliMUONDataInterface* data, AliMUON
                }
                break;
 
-       case FromLocalTriggers:
+       case kFromLocalTriggers:
                {
                Assert( module != NULL );
                AliMUONLocalTrigger* lt = data->LocalTrigger(trigger);
@@ -622,13 +728,17 @@ void AliHLTMUONTriggerSource::AddTriggerFrom(AliMUONDataInterface* data, AliMUON
 }
 
 
-Bool_t AliHLTMUONTriggerSource::InFillRegion(const AliHLTMUONTriggerRecord& data)
+Bool_t AliHLTMUONTriggerSource::InFillRegion(const AliHLTMUONTriggerRecord& data) const
 {
+// Checks to see if the specified trigger record is in the chamber region
+// we want to fill from.
+// kTRUE is returned if (x, y) is in the region, and kFALSE otherwise.
+
        switch (fAreaToUse)
        {
-       case FromWholePlane:     return kTRUE;
-       case FromLeftHalfPlane:  return data.Station1Point().fX <= 0;
-       case FromRightHalfPlane: return data.Station1Point().fX > 0;
+       case kFromWholePlane:     return kTRUE;
+       case kFromLeftHalfPlane:  return data.Station1Point().fX <= 0;
+       case kFromRightHalfPlane: return data.Station1Point().fX > 0;
 
        default:
                Error("InFillRegion", "fAreaToUse is not set to a valid value.");
@@ -641,6 +751,11 @@ void AliHLTMUONTriggerSource::FillTriggerFromLocalTrigger(
                AliMUONLocalTrigger* trigger, AliMUON* module, AliHLTMUONTriggerRecord& record
        )
 {
+// Fills the trigger data from the AliMUONLocalTrigger object.
+// if the fUseLookupTable is set to true then we use the L0 lookup table to
+// fill the Pt value otherwise we use the PtCal method in AliMUONTriggerCircuit.
+// Note the fTriggerNumber parameter is not filled in to 'record'.
+
        DebugMsg(2, "Creating TriggerRecord from AliMUONLocalTrigger object: " << (void*)trigger );
        AliMUONTriggerCircuit& circuit = module->TriggerCircuit(trigger->LoCircuit());
 
@@ -689,6 +804,10 @@ Bool_t AliHLTMUONTriggerSource::FillTriggerFromHits(
                AliMUONDataInterface* data, Int_t track, AliHLTMUONTriggerRecord& record
        )
 {
+// Fills the TriggerRecord structure from AliMUONHit objects.
+// The hits on the last 4 chambers are used (i.e. chambers 11 to 14).
+// kTRUE is returned if the structure was filled successfully.
+
        DebugMsg(2, "Creating TriggerRecord from hits on track: " << track );
        
        Float_t x1, y1, z1, x2, y2, z2, x3, y3, z3, x4, y4, z4;
@@ -807,9 +926,17 @@ Bool_t AliHLTMUONTriggerSource::FillTriggerFromHits(
 
 Bool_t AliHLTMUONTriggerSource::FetchAliMUON(AliMUON*& module)
 {
+// Fetches the AliMUON module from the AliRun global object. AliRun will be loaded
+// by the runloader if it has not yet been loaded. In such a case the AliRun object
+// will also we unloaded when we are done with it.
+// kTRUE is returned if no error occured and kFALSE otherwise.
+// Note that if fDataToUse is set to kFromHits then gAlice is not loaded and 'module'
+// will be left untouched. The method will still return kTRUE however since this is
+// not an error. We do not need the AliMUON module when filling from hits.
+
        // Check if we even need the MUON module. Not having to load it will
        // save a lot of loading time for AliRoot.
-       if (fDataToUse == FromHits)
+       if (fDataToUse == kFromHits)
        {
                // Make sure we do not attempt to unload gAlice in FinishedWithAliMUON,
                // by setting the fHadToLoadgAlice to false.
@@ -849,6 +976,11 @@ Bool_t AliHLTMUONTriggerSource::FetchAliMUON(AliMUON*& module)
 
 void AliHLTMUONTriggerSource::FinishedWithAliMUON()
 {
+// After one is finished with the AliMUON object returned by GetAliMUON, one
+// should call this method.
+// If the gAlice object was loaded by GetAliMUON then it will be unloaded at
+// this point, otherwise nothing is done.
+
        // Only unload the gAlice object if we had to load it ourselves.
        if (fHadToLoadgAlice)
                AliRunLoader::GetRunLoader()->UnloadgAlice();
@@ -857,6 +989,8 @@ void AliHLTMUONTriggerSource::FinishedWithAliMUON()
 
 void AliHLTMUONTriggerSource::ResetAllPointers() const
 {
+// Sets all the current pointers to NULL and indices to -1.
+
        fEventIndex = -1;
        fCurrentEvent = NULL;
        fBlockIndex = -1;
@@ -871,6 +1005,8 @@ void AliHLTMUONTriggerSource::ResetAllPointers() const
 
 void AliHLTMUONTriggerSource::ResetBlockPointers() const
 {
+// Sets the block and trigger pointers to NULL and indices to -1.
+
        fBlockIndex = -1;
        fCurrentBlock = NULL;
        fTriggerIndex = -1;
@@ -883,6 +1019,8 @@ void AliHLTMUONTriggerSource::ResetBlockPointers() const
 
 void AliHLTMUONTriggerSource::ResetTriggerPointers() const
 {
+// Sets just the current trigger record pointer to NULL and index to -1.
+
        fTriggerIndex = -1;
        fCurrentTrigger = NULL;
        DebugMsg(2, "\tfEventIndex = " << fEventIndex << " , fBlockIndex = " << fBlockIndex
@@ -891,15 +1029,17 @@ void AliHLTMUONTriggerSource::ResetTriggerPointers() const
 }
 
 
-AliHLTMUONTriggerSource::EventData::EventData() : fBlocks(TClonesArray::Class())
+AliHLTMUONTriggerSource::AliEventData::AliEventData() : fBlocks(TClonesArray::Class())
 {
        fEventNumber = -1;
 }
 
 
-AliHLTMUONTriggerSource::EventData::EventData(Int_t eventnumber)
+AliHLTMUONTriggerSource::AliEventData::AliEventData(Int_t eventnumber)
        : fBlocks(TClonesArray::Class())
 {
+// Create a new event data block with specified event number.
+
        fEventNumber = eventnumber;
 
        // If the following is not set then we do not write the fBlocks properly.
@@ -907,7 +1047,7 @@ AliHLTMUONTriggerSource::EventData::EventData(Int_t eventnumber)
 }
 
 
-AliHLTMUONTriggerSource::EventData::~EventData()
+AliHLTMUONTriggerSource::AliEventData::~AliEventData()
 {
        //fBlocks.Clear("C");  // Done in fBlocks destructor 
 }
index 3371c34fa3ce7956ea476e92c4363b3412caa991..c0ecd6f80aee484d0ee8f276b4de93d10ac0be8a 100644 (file)
@@ -5,6 +5,12 @@
 //
 ////////////////////////////////////////////////////////////////////////////////
 
+/* AliHLTMUONTriggerSource is used to extract L0 trigger information for
+   the muon spectrometer from a simulated event stored in .root files by AliRoot.
+   It is used by the AliHLTMUONMicrodHLT class as a input data set for the
+   dHLT algorithm.
+ */
+
 #ifndef ALIHLTMUONTRIGGERSOURCE_H
 #define ALIHLTMUONTRIGGERSOURCE_H
 
@@ -25,15 +31,15 @@ public:
 
        enum AreaType
        {
-               FromWholePlane,
-               FromLeftHalfPlane,
-               FromRightHalfPlane
+               kFromWholePlane,
+               kFromLeftHalfPlane,
+               kFromRightHalfPlane
        };
        
        enum SourceType
        {
-               FromHits,
-               FromLocalTriggers
+               kFromHits,
+               kFromLocalTriggers
        };
 
 
@@ -196,7 +202,7 @@ public:
 
 private:
 
-       /* Adds a new EventData block to the fEventList and updates the fCurrentEvent,
+       /* Adds a new AliEventData block to the fEventList and updates the fCurrentEvent,
           fCurrentBlock and fCurrentTrigger pointers.
         */ 
        void AddEvent(Int_t eventnumber);
@@ -233,7 +239,7 @@ private:
           we want to fill from.
           kTRUE is returned if (x, y) is in the region, and kFALSE otherwise.
         */
-       Bool_t InFillRegion(const AliHLTMUONTriggerRecord& data);
+       Bool_t InFillRegion(const AliHLTMUONTriggerRecord& data) const;
        
        /* Fills the trigger data from the AliMUONLocalTrigger object.
           if the fUseLookupTable is set to true then we use the L0 lookup table to
@@ -254,7 +260,7 @@ private:
           by the runloader if it has not yet been loaded. In such a case the AliRun object
           will also we unloaded when we are done with it.
           kTRUE is returned if no error occured and kFALSE otherwise.
-          Note that if fDataToUse is set to FromHits then gAlice is not loaded and 'module'
+          Note that if fDataToUse is set to kFromHits then gAlice is not loaded and 'module'
           will be left untouched. The method will still return kTRUE however since this is
           not an error. We do not need the AliMUON module when filling from hits.
         */
@@ -282,21 +288,31 @@ private:
 
 public:  // Unfortunately ROOT requires the following to be public.
 
-       class EventData : public TObject
+       class AliEventData : public TObject
        {
        public:
-               EventData();
-               EventData(Int_t eventnumber);
-               virtual ~EventData();
+               AliEventData();
+               AliEventData(Int_t eventnumber);
+               virtual ~AliEventData();
+               
+               Int_t& EventNumber() { return fEventNumber; }
+               TClonesArray& Blocks() { return fBlocks; }
 
+       private:
+       
                Int_t fEventNumber;  // Event number in AliMUONDataInterface from which the triggers were taken.
                TClonesArray fBlocks; // The list of blocks of trigger records.
                
-               ClassDef(EventData, 1)  // Data per event.
+               ClassDef(AliEventData, 1)  // Data per event.
        };
        
 private:
 
+       // Do not allow copying of this object.
+       AliHLTMUONTriggerSource(const AliHLTMUONTriggerSource& /*object*/) : TObject() {}
+       AliHLTMUONTriggerSource& operator = (const AliHLTMUONTriggerSource& /*object*/) { return *this; }
+
+
        AreaType fAreaToUse;    //! The part of the chamber to fill from.
        SourceType fDataToUse;  //! The type of raw AliRoot data to fill from.
        UInt_t fMaxBlockSize;   //! The maximum block size to create in the fill methods.
@@ -306,7 +322,7 @@ private:
        TString fFoldername;  // The folder name from which trigger data was taken.
        
        mutable Int_t fEventIndex;               //! The index number of the currently selected event.
-       mutable EventData* fCurrentEvent;        //! Pointer to the currently selected event.
+       mutable AliEventData* fCurrentEvent;        //! Pointer to the currently selected event.
        mutable Int_t fBlockIndex;               //! The index number of the currently selected block.
        mutable TClonesArray* fCurrentBlock;     //! Pointer to the currently selected block.
        mutable Int_t fTriggerIndex;             //! The index number of the currently selected trigger record.
index 4b2a5744e20b1274ba1afde30126afe3f356da29..2237888e5a1322e91e35294e70b4100dc575dbd9 100644 (file)
@@ -77,7 +77,7 @@ AliHLTMUONTrack AliHLTMUONConvert(const AliHLTMUONCoreTrack& track)
                
                // Only convert if the ROI is valid. Otherwise the Region object
                // is filled with NaN's.
-               if (track.fRegion[i] != kINVALID_ROI)
+               if (track.fRegion[i] != kInvalidROI)
                        t.RegionOfInterest(i) = AliHLTMUONConvert( track.fRegion[i] );
        }
        return t;
index 3daa69afded9e3c778735861811560d46052dabb..a2e047d651405b1249cd4a16aa84640d745834cb 100644 (file)
@@ -12,6 +12,7 @@
 AliHLTMUONCoreCenterOfGravityFinder::AliHLTMUONCoreCenterOfGravityFinder()
        : AliHLTMUONCoreClusterFinder()
 {
+/*
        fDiff_Y = 0.5; // 5000 micron slat size in Y
        fDiff_X = 1.0; // 10000 micron slat size in X
        fX = 56;
@@ -19,6 +20,7 @@ AliHLTMUONCoreCenterOfGravityFinder::AliHLTMUONCoreCenterOfGravityFinder()
        fDigitMax = 35; // maximum number of padhits in columns or rows.
        fDDLMax = 200; // Maximum number of padhits in one ddl;
        fDDLTot = 500; // totoal number of padhits in one ddl;
+*/
 }
 
 
index 866434f62bfd44f7cabe2a5443953ad1972196e2..c04baf6378c6c793c34747b9450cd82d18054cad 100644 (file)
@@ -25,7 +25,7 @@ public:
        virtual void Reset();
 
 private:
-
+/*
        FILE* fLut13;
        FILE* fLut14;
        FILE* fLut15;
@@ -42,7 +42,7 @@ private:
        UInt_t fDigitMax; // maximum number of padhits in columns or rows.
        UInt_t fDDLMax; // Maximum number of padhits in one ddl;
        UInt_t fDDLTot; // totoal number of padhits in one ddl;
-
+*/
 };
 
 
index a4de13f131a5c2b80967aceb97069cdddbdc017a..f1e6474af660b97a98a00723ded866c6fd0dcc19 100644 (file)
@@ -5,13 +5,22 @@
 //
 ////////////////////////////////////////////////////////////////////////////////
 
+/* AliHLTMUONCoreError is the base excpetion class used by the dHLT subsystem.
+   All child classes used to throw exception should be derived from this
+   class to allow easy catching of classes of errors.
+   
+   AliHLTMUONCoreOutOfMemory is also defined to be used when the system runs
+   out of memory. Do not throw this object directly but rather use
+   AliHLTMUONCoreThrowOutOfMemory which throws a pree allocated static object.
+ */
 #include "Error.hpp"
 #include "Utils.hpp"
 
 namespace
 {
        // The one and only pree allocated out of memory error object.
-       static AliHLTMUONCoreOutOfMemory _out_of_memory_;
+       static AliHLTMUONCoreOutOfMemory gAliOutOfMemObject;
 
 } // end of namespace
 
@@ -23,11 +32,11 @@ const char* AliHLTMUONCoreOutOfMemory::Message() const throw()
 
 Int AliHLTMUONCoreOutOfMemory::ErrorCode() const throw()
 {
-       return kOUT_OF_MEMORY;
+       return kOutOfMemory;
 }
 
 void AliHLTMUONCoreThrowOutOfMemory() throw (AliHLTMUONCoreOutOfMemory)
 {
-       throw _out_of_memory_;
+       throw gAliOutOfMemObject;
 }
 
index 04a9b3d0c36dfb19a7c8ec290be719911f4633fe..c7041320eea96239168fa1fba3bb44382c896e99 100644 (file)
@@ -5,6 +5,15 @@
 //
 ////////////////////////////////////////////////////////////////////////////////
 
+/* AliHLTMUONCoreError is the base excpetion class used by the dHLT subsystem.
+   All child classes used to throw exception should be derived from this
+   class to allow easy catching of classes of errors.
+   
+   AliHLTMUONCoreOutOfMemory is also defined to be used when the system runs
+   out of memory. Do not throw this object directly but rather use
+   AliHLTMUONCoreThrowOutOfMemory which throws a pree allocated static object.
+ */
+
 #ifndef ALIHLTMUONCOREERROR_H
 #define ALIHLTMUONCOREERROR_H
 
 
 class AliHLTMUONCoreError : public std::exception
 {
+       /* Define the << operator for streams to be able to do something like:
+
+               Error myerror;
+               cout << myerror << endl;
+       */
+       friend ostream& operator << (ostream& os, const AliHLTMUONCoreError& error)
+       {
+               os << error.Message();
+               return os;
+       };
+       
 public:
 
        AliHLTMUONCoreError() throw() {};
@@ -34,17 +54,6 @@ public:
        {
                return Message();
        };
-       
-       /* Define the << operator for streams to be able to do something like:
-
-               Error myerror;
-               cout << myerror << endl;
-       */
-       friend ostream& operator << (ostream& os, const AliHLTMUONCoreError& error)
-       {
-               os << error.Message();
-               return os;
-       };
 };
 
 
@@ -57,7 +66,7 @@ public:
 
 
 /* When one needs to indicate that no more memory is available one should use the
-   ThrowOutOfMemory method rather than explicitly using the code
+   AliHLTMUONCoreThrowOutOfMemory method rather than explicitly using the code
        throw OutOfMemory();
    This is because the ThrowOutOfMemory routine throws a preallocated object so
    we are safe from having to allocate more (nonexistant) memory.
@@ -68,7 +77,7 @@ void AliHLTMUONCoreThrowOutOfMemory() throw (AliHLTMUONCoreOutOfMemory);
 // Error code declarations.
 enum
 {
-       kOUT_OF_MEMORY = 0x10000001
+       kOutOfMemory = 0x10000001
 };
 
 
index 2869d178ceee952ab5fcf0404ed5eee4c0ee7d5e..15f894ef458831fc2eafd3569dafd27c6933ae78 100644 (file)
@@ -5,44 +5,38 @@
 //
 ////////////////////////////////////////////////////////////////////////////////
 
+/* The region of interest object is used to encode/decode and work with boundary
+   box type regions of interest. The 32 bit ROI codes are used to communicate
+   regions of interest between different parts of the dHLT system. This is more
+   efficient than sending 20 byte long region of interest objects.
+ */
+
 #include "RegionOfInterest.hpp"
 #include <math.h>
 
 
-Float AliHLTMUONCoreRegionOfInterest::fgPlaneScale[gkNUMBER_OF_TRACKING_CHAMBERS]
-///*
-       = {     100.0f,
-               100.0f,
-               130.0f,
+Float AliHLTMUONCoreRegionOfInterest::fgPlaneScale[AliHLTMUONCoreRegionOfInterest::kNumberOfTrackingChambers]
+       = {     102.0f,
+               104.0f,
                130.0f,
-               180.0f,
-               180.0f,
-               240.0f,
-               240.0f,
-               250.0f,
-               250.0f
+               132.0f,
+               184.0f,
+               188.0f,
+               238.0f,
+               244.0f,
+               270.0f,
+               275.0f
        };
-//*/
-/*
-       = {     101.397718695768f,
-               103.868515964831f,
-               128.956611312237f,
-               131.807531238079f,
-               183.219120567424f,
-               187.400469791991f,
-               237.861752479389f,
-               242.993408345904f,
-               269.221871663647f,
-               274.353527530162f
-       };
-*/
 
 
 void AliHLTMUONCoreRegionOfInterest::CreateToContain(
                const AliHLTMUONCoreClusterPoint& point, AliHLTMUONCoreChamberID chamber
        )
 {
-       Assert( 0 <= chamber && chamber < gkNUMBER_OF_TRACKING_CHAMBERS );
+// Creates a region of interest around the given point for the
+// specified chamber.
+
+       Assert( 0 <= chamber && chamber < (AliHLTMUONCoreChamberID)kNumberOfTrackingChambers );
        fChamber = chamber;
        fLeft = fRight = point.fX;
        fBottom = fTop = point.fY;
@@ -51,6 +45,8 @@ void AliHLTMUONCoreRegionOfInterest::CreateToContain(
 
 void AliHLTMUONCoreRegionOfInterest::ExpandToContain(const AliHLTMUONCoreClusterPoint& point)
 {
+// Extends the region of interest to contain the specified point.
+
        if (point.fX < fLeft)
                fLeft = point.fX;
        else
@@ -67,7 +63,10 @@ void AliHLTMUONCoreRegionOfInterest::CreateToContain(
                AliHLTMUONCoreChamberID chamber
        )
 {
-       Assert( 0 <= chamber && chamber < gkNUMBER_OF_TRACKING_CHAMBERS );
+// Creates a region of interest around all the given points and for the
+// specified chamber.
+
+       Assert( 0 <= chamber && chamber < (AliHLTMUONCoreChamberID)kNumberOfTrackingChambers );
        Assert( count > 0 );
        
        CreateToContain(points[0], chamber);
@@ -78,7 +77,11 @@ void AliHLTMUONCoreRegionOfInterest::CreateToContain(
 
 bool AliHLTMUONCoreRegionOfInterest::InBounds()
 {
-       Assert( 0 <= fChamber && fChamber < gkNUMBER_OF_TRACKING_CHAMBERS );
+// Checks if the region of interest is within the boundaries imposed on
+// the specific chamber plane. This boundary is aproximately the square
+// box around the chamber's detection region.
+
+       Assert( 0 <= fChamber && fChamber < (AliHLTMUONCoreChamberID)kNumberOfTrackingChambers );
        register Float bound = fgPlaneScale[fChamber];
        return -bound <= fLeft
          && fRight <= bound
@@ -129,7 +132,12 @@ inline void AliHLTMUONCoreRegionOfInterest::ConvertToGrid(
                register UInt& l, register UInt& r, register UInt& b, register UInt& t
        ) const
 {
-       Assert( 0 <= fChamber && fChamber < gkNUMBER_OF_TRACKING_CHAMBERS );
+// Converts the internal region of interest boundary box, which is
+// specified in as floats, into a regular integer grid.
+// l = left boundary, r = right boundary, b = bottom boundary, 
+// t = top boundary.
+
+       Assert( 0 <= fChamber && fChamber < (AliHLTMUONCoreChamberID)kNumberOfTrackingChambers );
 
        register Float scale = fgPlaneScale[fChamber];
        l = (UInt) floor( (fLeft / scale + 1.0f) * 0.5f * GRID_SIZE );
@@ -152,12 +160,16 @@ inline void AliHLTMUONCoreRegionOfInterest::ConvertBackFromGrid(
                register UInt l, register UInt r, register UInt b, register UInt t
        )
 {
+// Performs the inverse conversion of the method ConvertToGrid.
+// That is converts from a regular integer grid back to the internal
+// floating point boundary box specification.
+
        Assert( l <= GRID_SIZE );
        Assert( r <= GRID_SIZE );
        Assert( b <= GRID_SIZE );
        Assert( t <= GRID_SIZE );
 
-       Assert( 0 <= fChamber && fChamber < gkNUMBER_OF_TRACKING_CHAMBERS );
+       Assert( 0 <= fChamber && fChamber < (AliHLTMUONCoreChamberID)kNumberOfTrackingChambers );
        register Float scale = fgPlaneScale[fChamber];
        fLeft = ((Float)l / (Float)GRID_SIZE - 0.5f) * 2.0f * scale;
        fRight = ((Float)r / (Float)GRID_SIZE - 0.5f) * 2.0f * scale;
@@ -168,6 +180,8 @@ inline void AliHLTMUONCoreRegionOfInterest::ConvertBackFromGrid(
 
 AliHLTMUONCoreROI AliHLTMUONCoreRegionOfInterest::Encode() const
 {
+// Encodes the region of interest into a 32 bit code.
+
        UInt l, r, b, t, maxwidth, index;
 
        ConvertToGrid(l, r, b, t);
@@ -310,6 +324,10 @@ AliHLTMUONCoreROI AliHLTMUONCoreRegionOfInterest::Encode() const
 
 AliHLTMUONCoreROI AliHLTMUONCoreRegionOfInterest::Encode(UChar& level, UInt& l, UInt& b) const
 {
+// Encodes the region of interest into a 32 bit code, and returns the
+// hierarchal level the region was encoded at and the left and right
+// grid coordinate of the bottom left corner of the region boundary box.
+
        UInt r, t, maxwidth, index;
 
        ConvertToGrid(l, r, b, t);
@@ -466,6 +484,8 @@ AliHLTMUONCoreROI AliHLTMUONCoreRegionOfInterest::Encode(UChar& level, UInt& l,
 
 void AliHLTMUONCoreRegionOfInterest::Decode(AliHLTMUONCoreROI code)
 {
+// Decodes a 32 bit region of interest code into this region of interest object.
+
        UInt l, r, b, t;
        UChar colevel;
        DecodeBits(code, fChamber, colevel, l, b);
@@ -487,6 +507,10 @@ void AliHLTMUONCoreRegionOfInterest::Decode(
                UChar& level, UInt& l, UInt& b
        )
 {
+// Decodes the 32 bit region of interest code into the chamber number,
+// hierarchal level, left and right grid coordinates of the region
+// boundary box.
+
        UChar colevel;
        DecodeBits(code, chamber, colevel, l, b);
        level = MAX_LEVELS - colevel;
@@ -635,6 +659,8 @@ void AliHLTMUONCoreRegionOfInterest::DecodeBits(
 
 AliHLTMUONCoreChamberID AliHLTMUONCoreRegionOfInterest::DecodeChamber(AliHLTMUONCoreROI code)
 {
+// Decodes the chamber number of the region of interest 32 bit code.
+
        return (AliHLTMUONCoreChamberID)(code / MAX_INDICES);
 }
 
index 8d33fc2ea8906905e2741f06215feb68a4311c4a..06880435a6783189bdb2a13b9ea8d88cb75a72dc 100644 (file)
@@ -5,6 +5,12 @@
 //
 ////////////////////////////////////////////////////////////////////////////////
 
+/* The region of interest object is used to encode/decode and work with boundary
+   box type regions of interest. The 32 bit ROI codes are used to communicate
+   regions of interest between different parts of the dHLT system. This is more
+   efficient than sending 20 byte long region of interest objects.
+ */
+
 #ifndef ALIHLTMUONCOREREGIONOFINTEREST_H
 #define ALIHLTMUONCOREREGIONOFINTEREST_H
 
 #include "Cluster.hpp"
 
 
-const Int gkNUMBER_OF_TRACKING_CHAMBERS = 10;
-
 typedef UInt AliHLTMUONCoreROI;
 
 enum
 {
-       kINVALID_ROI = 0xFFFFFFFF
+       kInvalidROI = 0xFFFFFFFF
 };
 
 
@@ -42,11 +46,6 @@ enum AliHLTMUONCoreChamberID
 };
 
 
-/* The region of interest object is used to encode/decode and work with boundary
-   box type regions of interest. The 32 bit ROI codes are used to communicate
-   regions of interest between different parts of the dHLT system. This is more
-   efficient than sending 20 byte long region of interest objects.
- */
 class AliHLTMUONCoreRegionOfInterest
 {
 public:
@@ -91,29 +90,13 @@ public:
           the specified chamber.
         */
        AliHLTMUONCoreRegionOfInterest(
-                       Float left0, Float right0, Float bottom0, Float top0,
-                       AliHLTMUONCoreChamberID chamber0
-               )
-       {
-               Assert( 0 <= chamber0 && chamber0 < gkNUMBER_OF_TRACKING_CHAMBERS );
-               this->fChamber = chamber0;
-               this->fLeft = left0;
-               this->fRight = right0;
-               this->fBottom = bottom0;
-               this->fTop = top0;
-       }
-
+                       Float left, Float right, Float bottom, Float top,
+                       AliHLTMUONCoreChamberID chamber
+               );
 
        /* Checks if the point is contained in this region of interest.
         */
-       bool Contains(const AliHLTMUONCoreClusterPoint& point) const
-       {
-               return fLeft <= point.fX
-                 && point.fX <= fRight
-                 && fBottom <= point.fY
-                 && point.fY <= fTop;
-       }
-
+       bool Contains(const AliHLTMUONCoreClusterPoint& point) const;
 
        /* Checks if the point is contained in this region of interest and the
           chamber number corresponds to this region object.
@@ -121,28 +104,12 @@ public:
        bool Contains(
                        const AliHLTMUONCoreClusterPoint& point,
                        AliHLTMUONCoreChamberID chamber
-               ) const
-       {
-               return fLeft <= point.fX
-                 && point.fX <= fRight
-                 && fBottom <= point.fY
-                 && point.fY <= fTop
-                 && this->fChamber == chamber;
-       }
-
+               ) const;
 
        /* Checks if the specified region of interest is contained in this
           region of interest object.
         */
-       bool Contains(const AliHLTMUONCoreRegionOfInterest& roi) const
-       {
-               return fChamber == roi.fChamber
-                 && fLeft <= roi.fLeft
-                 && fRight >= roi.fRight
-                 && fBottom <= roi.fBottom
-                 && fTop >= roi.fTop;
-       }
-
+       bool Contains(const AliHLTMUONCoreRegionOfInterest& roi) const;
 
        /* Creates a region of interest around the given point for the
           specified chamber.
@@ -247,10 +214,11 @@ private:
                        UChar& colevel, UInt& l, UInt& b
                );
 
+       enum {kNumberOfTrackingChambers = 10};  // Number of tracking chambers.
 
        // Boundary box scale numbers for each chamber. These are the boundary
        // boxes around the chambers detection surface.
-       static Float fgPlaneScale[gkNUMBER_OF_TRACKING_CHAMBERS];
+       static Float fgPlaneScale[kNumberOfTrackingChambers];  // scale numbers.
 
        static UInt fgIndexOffsets[13];  // Offset numbers used in the encoding and decoding process.
 
@@ -263,4 +231,68 @@ private:
 };
 
 
+//-----------------------------------------------------------------------------
+// Inline methods:
+
+
+inline AliHLTMUONCoreRegionOfInterest::AliHLTMUONCoreRegionOfInterest(
+               Float left, Float right, Float bottom, Float top,
+               AliHLTMUONCoreChamberID chamber
+       )
+{
+// Creates a region of interest with the specified boundaries and for
+// the specified chamber.
+
+       Assert( 0 <= chamber && chamber < (AliHLTMUONCoreChamberID)kNumberOfTrackingChambers );
+       fChamber = chamber;
+       fLeft = left;
+       fRight = right;
+       fBottom = bottom;
+       fTop = top;
+}
+
+
+inline bool AliHLTMUONCoreRegionOfInterest::Contains(const AliHLTMUONCoreClusterPoint& point) const
+{
+// Checks if the point is contained in this region of interest.
+
+       return fLeft <= point.fX
+         && point.fX <= fRight
+         && fBottom <= point.fY
+         && point.fY <= fTop;
+}
+
+
+inline bool AliHLTMUONCoreRegionOfInterest::Contains(
+               const AliHLTMUONCoreClusterPoint& point,
+               AliHLTMUONCoreChamberID chamber
+       ) const
+{
+// Checks if the point is contained in this region of interest and the
+// chamber number corresponds to this region object.
+
+       return fLeft <= point.fX
+         && point.fX <= fRight
+         && fBottom <= point.fY
+         && point.fY <= fTop
+         && fChamber == chamber;
+}
+
+
+inline bool AliHLTMUONCoreRegionOfInterest::Contains(
+               const AliHLTMUONCoreRegionOfInterest& roi
+       ) const
+{
+// Checks if the specified region of interest is contained in this
+// region of interest object.
+
+       return fChamber == roi.fChamber
+         && fLeft <= roi.fLeft
+         && fRight >= roi.fRight
+         && fBottom <= roi.fBottom
+         && fTop >= roi.fTop;
+}
+
+
 #endif // ALIHLTMUONCOREREGIONOFINTEREST_H
+
index 74d05681d91cc8622d9d1133f5d4ede446e3cf2f..24ec416d58ab97cac1436f60ffa48ff452564807 100644 (file)
@@ -18,16 +18,16 @@ Float AliHLTMUONCoreCalculateSignedPt(
 {
        register Float qBL = 3.0;
        register Float zf = 975.0;
-       Float theta_times_zf = - (y1*z2 - y2*z1) / (z2-z1);
+       Float thetaTimesZf = - (y1*z2 - y2*z1) / (z2-z1);
        Float xf = x1 * zf / z1;
        Float yf = y2 - ((y2-y1) * (z2-zf)) / (z2-z1);
 
-       Float p_div_zf = (qBL * 0.3 / theta_times_zf);
-       p = (Float) fabs( p_div_zf * zf );
+       Float pDivZf = (qBL * 0.3 / thetaTimesZf);
+       p = (Float) fabs( pDivZf * zf );
        
        // Note: the 0.3 is a conversion factor to GeV. it is 1e9 / c where c is
        // the speed of light.
-       Float pt = p_div_zf * sqrt(xf*xf+yf*yf);
+       Float pt = pDivZf * sqrt(xf*xf+yf*yf);
        return pt;
 };
 
@@ -40,16 +40,16 @@ Float AliHLTMUONCoreCalculateSignedPt(
                Float& p
        )
 {
-       Float theta_times_zf = - (y1*z2 - y2*z1) / (z2-z1);
+       Float thetaTimesZf = - (y1*z2 - y2*z1) / (z2-z1);
        Float xf = x1 * zf / z1;
        Float yf = y2 - ((y2-y1) * (z2-zf)) / (z2-z1);
 
-       Float p_div_zf = (qBL * 0.3 / theta_times_zf);
-       p = (Float) fabs( p_div_zf * zf );
+       Float pDivZf = (qBL * 0.3 / thetaTimesZf);
+       p = (Float) fabs( pDivZf * zf );
 
        // Note: the 0.3 is a conversion factor to GeV. it is 1e9 / c where c is
        // the speed of light.
-       Float pt = p_div_zf * sqrt(xf*xf+yf*yf);
+       Float pt = pDivZf * sqrt(xf*xf+yf*yf);
        return pt;
 };
 
@@ -62,13 +62,13 @@ Float AliHLTMUONCoreCalculateSignedPt(
 {
        register Float qBL = 3.0;
        register Float zf = 975.0;
-       Float theta_times_zf = - (y1*z2 - y2*z1) / (z2-z1);
+       Float thetaTimesZf = - (y1*z2 - y2*z1) / (z2-z1);
        Float xf = x1 * zf / z1;
        Float yf = y2 - ((y2-y1) * (z2-zf)) / (z2-z1);
 
        // Note: the 0.3 is a conversion factor to GeV. it is 1e9 / c where c is
        // the speed of light.
-       Float pt = (qBL * 0.3 / theta_times_zf) * sqrt(xf*xf+yf*yf);
+       Float pt = (qBL * 0.3 / thetaTimesZf) * sqrt(xf*xf+yf*yf);
        return pt;
 };
 
@@ -80,13 +80,13 @@ Float AliHLTMUONCoreCalculateSignedPt(
                register Float zf, register Float qBL
        )
 {
-       Float theta_times_zf = - (y1*z2 - y2*z1) / (z2-z1);
+       Float thetaTimesZf = - (y1*z2 - y2*z1) / (z2-z1);
        Float xf = x1 * zf / z1;
        Float yf = y2 - ((y2-y1) * (z2-zf)) / (z2-z1);
 
        // Note: the 0.3 is a conversion factor to GeV. it is 1e9 / c where c is
        // the speed of light.
-       Float pt = (qBL * 0.3 / theta_times_zf) * sqrt(xf*xf+yf*yf);
+       Float pt = (qBL * 0.3 / thetaTimesZf) * sqrt(xf*xf+yf*yf);
        return pt;
 };
 
index 07160e57743f0265ec25e6d4dc03229cdf36fa1a..b4b1fadd1b131c62be3cd6db4902a2f9ebd48e60 100644 (file)
@@ -73,8 +73,11 @@ Float AliHLTMUONCoreMansoTracker::fgZ11 = 1603.5f;
 Float AliHLTMUONCoreMansoTracker::fgZ13 = 1703.5f;
 
 
-void AliHLTMUONCoreMansoTracker::RegionOfInterest::Create(AliHLTMUONCorePoint p, Float a, Float b)
+void AliHLTMUONCoreMansoTracker::AliRegionOfInterest::Create(AliHLTMUONCorePoint p, Float a, Float b)
 {
+// Creates a region of interest specific to the Manso algorithm from a point and
+// two Manso specific parameters.
+
        fCentre = p;
        // Compute the radius Rp
        Float Rp = (Float) sqrt( p.fX * p.fX + p.fY * p.fY );
@@ -90,7 +93,7 @@ void AliHLTMUONCoreMansoTracker::RegionOfInterest::Create(AliHLTMUONCorePoint p,
 }
 
 
-bool AliHLTMUONCoreMansoTracker::RegionOfInterest::Contains(AliHLTMUONCorePoint p) const
+bool AliHLTMUONCoreMansoTracker::AliRegionOfInterest::Contains(AliHLTMUONCorePoint p) const
 {
        // Compute the distance between the centre of the region of interest and
        // the point p. This distance must be less than the radius of the region
@@ -98,15 +101,19 @@ bool AliHLTMUONCoreMansoTracker::RegionOfInterest::Contains(AliHLTMUONCorePoint
        register Float lx = fCentre.fX - p.fX;
        register Float ly = fCentre.fY - p.fY;
        register Float r = (Float) sqrt( lx * lx + ly * ly );
-       DebugMsg(4, "\tRegionOfInterest::Contains : p = " << p
+       DebugMsg(4, "\tAliRegionOfInterest::Contains : p = " << p
                << " , centre = " << fCentre << " , r = " << r << " , Rs = " << fRs
        );
        return r <= fRs;
 }
 
 
-void AliHLTMUONCoreMansoTracker::RegionOfInterest::GetBoundaryBox(Float& left, Float& right, Float& bottom, Float& top)
+void AliHLTMUONCoreMansoTracker::AliRegionOfInterest::GetBoundaryBox(
+               Float& left, Float& right, Float& bottom, Float& top
+       ) const
 {
+// Works out the smallest boundary box that will contain the region of interest.
+
        left = fCentre.fX - fRs;
        right = fCentre.fX + fRs;
        bottom = fCentre.fY - fRs;
@@ -114,60 +121,74 @@ void AliHLTMUONCoreMansoTracker::RegionOfInterest::GetBoundaryBox(Float& left, F
 }
 
 
-AliHLTMUONCoreMansoTracker::Vertex::Vertex(Float x, Float y, Float z)
+AliHLTMUONCoreMansoTracker::AliVertex::AliVertex(Float x, Float y, Float z)
 {
+// Constructor for vertex.
+
        fX = x;
        fY = y;
        fZ = z;
 }
 
 
-AliHLTMUONCoreMansoTracker::Vertex::Vertex(AliHLTMUONCorePoint xy, Float z)
+AliHLTMUONCoreMansoTracker::AliVertex::AliVertex(AliHLTMUONCorePoint xy, Float z)
 {
+// Construct vertex from a point on the XY plane and z coordinate.
+
        fX = xy.fX;
        fY = xy.fY;
        fZ = z;
 }
 
 
-AliHLTMUONCoreMansoTracker::Line::Line(
-        Float Ax, Float Ay, Float Az,
-        Float Bx, Float By, Float Bz
+AliHLTMUONCoreMansoTracker::AliLine::AliLine(
+        Float ax, Float ay, Float az,
+        Float bx, Float by, Float bz
     )
 {
-       fMx = Ax - Bx;
-       fMy = Ay - By;
-       fMz = Az - Bz;
-       fCx = Bx;
-       fCy = By;
-       fCz = Bz;
+// Construct a line defined by L = M*t + C = (A-B)*t + B
+// where M and C are 3D vectors and t is a free parameter.
+// A = (ax, ay, az) and B = (bx, by, bz)
+
+       fMx = ax - bx;
+       fMy = ay - by;
+       fMz = az - bz;
+       fCx = bx;
+       fCy = by;
+       fCz = bz;
 }
 
 
-AliHLTMUONCoreMansoTracker::Line::Line(Vertex A, Vertex B)
+AliHLTMUONCoreMansoTracker::AliLine::AliLine(AliVertex a, AliVertex b)
 {
-       fMx = A.fX - B.fX;
-       fMy = A.fY - B.fY;
-       fMz = A.fZ - B.fZ;
-       fCx = B.fX;
-       fCy = B.fY;
-       fCz = B.fZ;
+// Contruct a line to go through two vertices a and b.
+
+       fMx = a.X() - b.X();
+       fMy = a.Y() - b.Y();
+       fMz = a.Z() - b.Z();
+       fCx = b.X();
+       fCy = b.Y();
+       fCz = b.Z();
 }
 
 
-AliHLTMUONCorePoint AliHLTMUONCoreMansoTracker::Line::FindIntersectWithXYPlain(Float z) const
+AliHLTMUONCorePoint AliHLTMUONCoreMansoTracker::AliLine::FindIntersectWithXYPlain(Float z) const
 {
+// Find the point of intersection of the line and the XY plane at z.
+
        Assert( fMz != 0.0 );    // Should not have a ray perpendicular to the beam axis.
        Float t = (z - fCz) / fMz;
-       Float Lx = fMx*t + fCx;
-       Float Ly = fMy*t + fCy;
+       Float lx = fMx*t + fCx;
+       Float ly = fMy*t + fCy;
 
-       return AliHLTMUONCorePoint(Lx, Ly);
+       return AliHLTMUONCorePoint(lx, ly);
 }
 
 
 AliHLTMUONCoreMansoTracker::AliHLTMUONCoreMansoTracker() : AliHLTMUONCoreTracker()
 {
+// Default constructor 
+
        fSm4state = kSM4Idle;
        fSm5state = kSM5Idle;
        fRequestsCompleted = 0;
@@ -176,14 +197,16 @@ AliHLTMUONCoreMansoTracker::AliHLTMUONCoreMansoTracker() : AliHLTMUONCoreTracker
 
 void AliHLTMUONCoreMansoTracker::FindTrack(const AliHLTMUONCoreTriggerRecord& trigger)
 {
+// Tries to find the track from the trigger seed.
+
        DebugMsg(4, "SM5 state = " << fSm5state << " , SM4 state = " << fSm4state);
        DebugMsg(1, "Processing trigger with pt = " << trigger.fPt);
-       fV1 = Vertex( trigger.fStation1impact, fgZ11 );
-       Vertex v2 = Vertex( trigger.fStation2impact, fgZ13 );
+       fV1 = AliVertex( trigger.fStation1impact, fgZ11 );
+       AliVertex v2 = AliVertex( trigger.fStation2impact, fgZ13 );
 
        // Form the vector line between the above two impact points and
        // find the crossing point of the line with chamber 10 (i.e. station 5).
-       fMc1.fLine = Line(fV1, v2);
+       fMc1.fLine = AliLine(fV1, v2);
        AliHLTMUONCorePoint p10 = fMc1.fLine.FindIntersectWithXYPlain( fgZ10 );
 
        // Build a region of interest for tracking station 5 (chamber 10).
@@ -204,10 +227,12 @@ void AliHLTMUONCoreMansoTracker::FindTrack(const AliHLTMUONCoreTriggerRecord& tr
 
 void AliHLTMUONCoreMansoTracker::ReturnClusters(void* tag, const AliHLTMUONCoreClusterPoint* clusters, UInt count)
 {
+// Implementation of AliHLTMUONCoreTracker::ReturnClusters.
+
        Assert( count > 0 );
        Assert( clusters != NULL );
        
-       TagData* data = (TagData*)tag;
+       AliTagData* data = (AliTagData*)tag;
        DebugMsg(4, "Got AliHLTMUONCoreMansoTracker::ReturnClusters(tag = " << tag
                << ", chamber = " << data->fChamber
                << ", clusters = " << clusters <<  ", count = " << count << ")"
@@ -229,7 +254,9 @@ void AliHLTMUONCoreMansoTracker::ReturnClusters(void* tag, const AliHLTMUONCoreC
 
 void AliHLTMUONCoreMansoTracker::EndOfClusters(void* tag)
 {
-       TagData* data = (TagData*)tag;
+// Implementation of AliHLTMUONCoreTracker::EndOfClusters.
+
+       AliTagData* data = (AliTagData*)tag;
        DebugMsg(4, "Got AliHLTMUONCoreMansoTracker::EndOfClusters(chamber = " << data->fChamber << ")");
        DebugMsg(4, "SM5 state = " << fSm5state << " , SM4 state = " << fSm4state);
 
@@ -248,6 +275,8 @@ void AliHLTMUONCoreMansoTracker::EndOfClusters(void* tag)
 
 void AliHLTMUONCoreMansoTracker::FillTrackData(AliHLTMUONCoreTrack& track)
 {
+// Implementation of AliHLTMUONCoreTracker::FillTrackData
+
        DebugMsg(4, "FillTrack: st5 = " << fSt5rec->fClusterPoint << ", st4 = " << fFoundPoint->fClusterPoint);
        
        Float x1 = fFoundPoint->fClusterPoint.fX;
@@ -272,7 +301,7 @@ void AliHLTMUONCoreMansoTracker::FillTrackData(AliHLTMUONCoreTrack& track)
        for (UInt i = 0; i < 6; i++)
        {
                track.fPoint[i] = AliHLTMUONCorePoint(0.0, 0.0);
-               track.fRegion[i] = kINVALID_ROI;
+               track.fRegion[i] = kInvalidROI;
        }
 
        Float left, right, bottom, top;
@@ -288,7 +317,7 @@ void AliHLTMUONCoreMansoTracker::FillTrackData(AliHLTMUONCoreTrack& track)
        if (fSt4chamber == kChamber8)
        {
                track.fPoint[6] = AliHLTMUONCorePoint(0.0, 0.0);
-               track.fRegion[6] = kINVALID_ROI;
+               track.fRegion[6] = kInvalidROI;
                track.fPoint[7] = fFoundPoint->fClusterPoint;
                track.fRegion[7] = region4;
        }
@@ -297,12 +326,12 @@ void AliHLTMUONCoreMansoTracker::FillTrackData(AliHLTMUONCoreTrack& track)
                track.fPoint[6] = fFoundPoint->fClusterPoint;
                track.fRegion[6] = region4;
                track.fPoint[7] = AliHLTMUONCorePoint(0.0, 0.0);
-               track.fRegion[7] = kINVALID_ROI;
+               track.fRegion[7] = kInvalidROI;
        }
        if (fMc1.fChamber == kChamber10)
        {
                track.fPoint[8] = AliHLTMUONCorePoint(0.0, 0.0);
-               track.fRegion[8] = kINVALID_ROI;
+               track.fRegion[8] = kInvalidROI;
                track.fPoint[9] = fSt5rec->fClusterPoint;
                track.fRegion[9] = region5;
        }
@@ -311,13 +340,15 @@ void AliHLTMUONCoreMansoTracker::FillTrackData(AliHLTMUONCoreTrack& track)
                track.fPoint[8] = fSt5rec->fClusterPoint;
                track.fRegion[8] = region5;
                track.fPoint[9] = AliHLTMUONCorePoint(0.0, 0.0);
-               track.fRegion[9] = kINVALID_ROI;
+               track.fRegion[9] = kInvalidROI;
        }
 }
 
 
 void AliHLTMUONCoreMansoTracker::Reset()
 {
+// Implementation of AliHLTMUONCoreTracker::Reset
+
        DebugMsg(4, "SM5 state = " << fSm5state << " , SM4 state = " << fSm4state);
        fSt5data.Clear();
        fSt4points.Clear();
@@ -337,9 +368,11 @@ void AliHLTMUONCoreMansoTracker::Reset()
 // following routines.
 
 void AliHLTMUONCoreMansoTracker::ReceiveClustersChamber7(
-               const AliHLTMUONCoreClusterPoint* clusters, UInt count, const TagData* data
+               const AliHLTMUONCoreClusterPoint* clusters, UInt count, const AliTagData* data
        )
 {
+// State change method for Station 4 state machine.
+
        switch (fSm4state)
        {
        case kWaitChamber7:
@@ -353,7 +386,7 @@ void AliHLTMUONCoreMansoTracker::ReceiveClustersChamber7(
                        if ( data->fRoi.Contains(cluster) )
                        {
                                DebugMsg(4, "Adding cluster [" << cluster.fX << ", " << cluster.fY << "] from chamber 7.");
-                               Station4Data* newdata = fSt4points.New();
+                               AliStation4Data* newdata = fSt4points.New();
                                newdata->fClusterPoint = cluster;
                                newdata->fSt5tag = data;
                        }
@@ -367,9 +400,11 @@ void AliHLTMUONCoreMansoTracker::ReceiveClustersChamber7(
 
 
 void AliHLTMUONCoreMansoTracker::ReceiveClustersChamber8(
-               const AliHLTMUONCoreClusterPoint* clusters, UInt count, const TagData* data
+               const AliHLTMUONCoreClusterPoint* clusters, UInt count, const AliTagData* data
        )
 {
+// State change method for Station 4 state machine.
+
        switch (fSm4state)
        {
        case kWaitChamber8:
@@ -385,7 +420,7 @@ void AliHLTMUONCoreMansoTracker::ReceiveClustersChamber8(
                        if ( data->fRoi.Contains(cluster) )
                        {
                                DebugMsg(4, "Adding cluster [" << cluster.fX << ", " << cluster.fY << "] from chamber 8.");
-                               Station4Data* newdata = fSt4points.New();
+                               AliStation4Data* newdata = fSt4points.New();
                                newdata->fClusterPoint = cluster;
                                newdata->fSt5tag = data;
                        }
@@ -400,6 +435,8 @@ void AliHLTMUONCoreMansoTracker::ReceiveClustersChamber8(
 
 void AliHLTMUONCoreMansoTracker::ReceiveClustersChamber9(const AliHLTMUONCoreClusterPoint* clusters, UInt count)
 {
+// State change method for Station 5 state machine.
+
        switch (fSm5state)
        {
        case kWaitChamber9:
@@ -414,7 +451,7 @@ void AliHLTMUONCoreMansoTracker::ReceiveClustersChamber9(const AliHLTMUONCoreClu
                        if ( fMc1.fRoi.Contains(cluster) )
                        {
                                DebugMsg(4, "Adding cluster [" << cluster.fX << ", " << cluster.fY << "] from chamber 9.");
-                               Station5Data* data = fSt5data.New();
+                               AliStation5Data* data = fSt5data.New();
                                data->fClusterPoint = cluster;
                                ProjectToStation4(data, fgZ9);  // This adds a new request for station 4.
                        }
@@ -429,6 +466,8 @@ void AliHLTMUONCoreMansoTracker::ReceiveClustersChamber9(const AliHLTMUONCoreClu
 
 void AliHLTMUONCoreMansoTracker::ReceiveClustersChamber10(const AliHLTMUONCoreClusterPoint* clusters, UInt count)
 {
+// State change method for Station 5 state machine.
+
        switch (fSm5state)
        {
        case kWaitChamber10:
@@ -444,7 +483,7 @@ void AliHLTMUONCoreMansoTracker::ReceiveClustersChamber10(const AliHLTMUONCoreCl
                        if ( fMc1.fRoi.Contains(cluster) )
                        {
                                DebugMsg(4, "Adding cluster [" << cluster.fX << ", " << cluster.fY << "] from chamber 10.");
-                               Station5Data* data = fSt5data.New();
+                               AliStation5Data* data = fSt5data.New();
                                data->fClusterPoint = cluster;
                                ProjectToStation4(data, fgZ10);  // This adds a new request for station 4.
                        }
@@ -459,6 +498,8 @@ void AliHLTMUONCoreMansoTracker::ReceiveClustersChamber10(const AliHLTMUONCoreCl
 
 void AliHLTMUONCoreMansoTracker::EndOfClustersChamber7()
 {
+// State change method for Station 4 state machine.
+
        fRequestsCompleted++;  // Increment the number of requests completed for station 4.
        DebugMsg(4, "fRequestsCompleted = " << fRequestsCompleted );
 
@@ -483,6 +524,8 @@ void AliHLTMUONCoreMansoTracker::EndOfClustersChamber7()
 
 void AliHLTMUONCoreMansoTracker::EndOfClustersChamber8()
 {
+// State change method for Station 4 state machine.
+
        fRequestsCompleted++;  // Increment the number of requests completed for station 4.
        DebugMsg(4, "fRequestsCompleted = " << fRequestsCompleted );
 
@@ -507,7 +550,7 @@ void AliHLTMUONCoreMansoTracker::EndOfClustersChamber8()
                for (UInt i = 0; i < reqlistsize; i++, rec++)
                {
                        // Need to create a new st5 data block for the request.
-                       Station5Data* data = fSt5data.New();
+                       AliStation5Data* data = fSt5data.New();
                        data->fClusterPoint = rec->fClusterPoint;
                        data->fTag.fLine = rec->fTag.fLine;
 
@@ -538,6 +581,8 @@ void AliHLTMUONCoreMansoTracker::EndOfClustersChamber8()
 
 void AliHLTMUONCoreMansoTracker::EndOfClustersChamber9()
 {
+// State change method for Station 5 state machine.
+
        switch (fSm5state)
        {
        case kWaitChamber9:
@@ -561,6 +606,8 @@ void AliHLTMUONCoreMansoTracker::EndOfClustersChamber9()
 
 void AliHLTMUONCoreMansoTracker::EndOfClustersChamber10()
 {
+// State change method for Station 5 state machine.
+
        switch (fSm5state)
        {
        case kWaitChamber10:
@@ -596,7 +643,7 @@ void AliHLTMUONCoreMansoTracker::EndOfClustersChamber10()
 }
 
 
-void AliHLTMUONCoreMansoTracker::ProjectToStation4(Station5Data* data, register Float station5z)
+void AliHLTMUONCoreMansoTracker::ProjectToStation4(AliStation5Data* data, register Float station5z)
 {
        // Perform chamber specific operations:
        // Since certain states of SM4 means that it is fetching for Chamber8
@@ -607,12 +654,12 @@ void AliHLTMUONCoreMansoTracker::ProjectToStation4(Station5Data* data, register
                || fSm4state == kWaitChamber7
                || fSm4state == kWaitMoreChamber7
        );
-       TagData* tag = &data->fTag;
+       AliTagData* tag = &data->fTag;
        if (fSm4state == kWaitChamber8 || fSm4state == kWaitMoreChamber8)
        {
                // Form the vector line between trigger station 1 and tracking station 5,
                // and find the intersection point of the line with station 4 (chamber8).
-               Line line51( Vertex(data->fClusterPoint, station5z), fV1 );
+               AliLine line51( AliVertex(data->fClusterPoint, station5z), fV1 );
                AliHLTMUONCorePoint intercept = line51.FindIntersectWithXYPlain( fgZ8 );
                tag->fLine = line51;
                
@@ -624,7 +671,7 @@ void AliHLTMUONCoreMansoTracker::ProjectToStation4(Station5Data* data, register
        {
                // Form the vector line between trigger station 1 and tracking station 5,
                // and find the intersection point of the line with station 4 (chamber7).
-               Line line51( Vertex(data->fClusterPoint, station5z), fV1 );
+               AliLine line51( AliVertex(data->fClusterPoint, station5z), fV1 );
                AliHLTMUONCorePoint intercept = line51.FindIntersectWithXYPlain( fgZ7 );
                tag->fLine = line51;
                
@@ -642,6 +689,9 @@ void AliHLTMUONCoreMansoTracker::ProjectToStation4(Station5Data* data, register
 
 void AliHLTMUONCoreMansoTracker::ProcessClusters()
 {
+// Process clusters that have been received.
+// This is called once all clusters have been found.
+
        DebugMsg(2, "ProcessClusters...");
        
        // Check if the cluster point list on station 4 is empty.
index 4337114a3bcfda30ecad06cbd6815361733e3ceb..4cbcad5fcf664014f26b26571d63977038c750ce 100644 (file)
@@ -70,13 +70,13 @@ public:
 
 protected:
 
-       class RegionOfInterest
+       class AliRegionOfInterest
        {
        public:
                
-               RegionOfInterest() {};
+               AliRegionOfInterest() {};
 
-               RegionOfInterest(AliHLTMUONCorePoint p, Float a, Float b)
+               AliRegionOfInterest(AliHLTMUONCorePoint p, Float a, Float b)
                {
                        Create(p, a, b);
                };
@@ -98,7 +98,7 @@ protected:
                 */
                bool Contains(AliHLTMUONCorePoint p) const;
 
-               void GetBoundaryBox(Float& left, Float& right, Float& bottom, Float& top);
+               void GetBoundaryBox(Float& left, Float& right, Float& bottom, Float& top) const;
 
        private:
 
@@ -107,38 +107,51 @@ protected:
        };
 
 
-       class Vertex
+       class AliVertex
        {
        public:
 
-               Float fX, fY, fZ;
-
-               Vertex(Float x = 0.0, Float y = 0.0, Float z = 0.0);
-               Vertex(AliHLTMUONCorePoint xy, Float z);
+               AliVertex(Float x = 0.0, Float y = 0.0, Float z = 0.0);
+               AliVertex(AliHLTMUONCorePoint xy, Float z);
 
                AliHLTMUONCorePoint AsXYPoint() const
                {
                        return AliHLTMUONCorePoint(fX, fY);
                };
+
+               // Get/set methods:
+               Float X() const { return fX; };
+               Float Y() const { return fY; };
+               Float Z() const { return fZ; };
+               Float& X() { return fX; };
+               Float& Y() { return fY; };
+               Float& Z() { return fZ; };
+               void X(Float value) { fX = value; };
+               void Y(Float value) { fY = value; };
+               void Z(Float value) { fZ = value; };
+
+       private:
+
+               Float fX, fY, fZ; // 3D coordinates.
        };
 
        
-       class Line
+       class AliLine
        {
        public:
 
                /* Creates a vector line between points A and B.
-                  Ax, Ay, Az are x, y and z coordinates for space point A respectively.
+                  ax, ay, az are x, y and z coordinates for space point A respectively.
                   simmilarly for B.
                 */
-               Line(
-                       Float Ax = 0.0, Float Ay = 0.0, Float Az = 0.0,
-                       Float Bx = 0.0, Float By = 0.0, Float Bz = 0.0
+               AliLine(
+                       Float ax = 0.0, Float ay = 0.0, Float az = 0.0,
+                       Float bx = 0.0, Float by = 0.0, Float bz = 0.0
                );
 
                /* Creates a vector line between vertices A and B.
                 */
-               Line(Vertex A, Vertex B);
+               AliLine(AliVertex a, AliVertex b);
 
                /* Finds the intersection point with the xy plain specified by the z coordinate.
                   The z coordiante would be the distance of the n'th chamber to the interaction
@@ -149,36 +162,36 @@ protected:
        private:
 
                // Parameters for the vector line:  L = M*t + C
-               Float fMx, fMy, fMz, fCx, fCy, fCz;
+               Float fMx, fMy, fMz, fCx, fCy, fCz;  // line parameters.
        };
 
        
-       struct TagData
+       struct AliTagData
        {
                AliHLTMUONCoreChamberID fChamber;     // The chamber on which the region of interest lies.
-               RegionOfInterest fRoi;  // Region of interest on the next station.
-               Line fLine;             // line between a cluster point and the previous station.
+               AliRegionOfInterest fRoi;  // Region of interest on the next station.
+               AliLine fLine;             // line between a cluster point and the previous station.
        };
        
-       struct Station5Data
+       struct AliStation5Data
        {
                AliHLTMUONCoreClusterPoint fClusterPoint;  // Cluster point found on station 5.
-               TagData fTag;
+               AliTagData fTag;  // Chamber, ROI and line data for station 5.
        };
        
-       typedef AliHLTMUONCoreCountedList<Station5Data> Station5List;
+       typedef AliHLTMUONCoreCountedList<AliStation5Data> Station5List;
 
-       struct Station4Data
+       struct AliStation4Data
        {
                AliHLTMUONCoreClusterPoint fClusterPoint;  // Cluster point found on station 4.
-               const TagData* fSt5tag;      // Corresponding station 5 tag.
+               const AliTagData* fSt5tag;      // Corresponding station 5 tag.
        };
 
-       typedef AliHLTMUONCoreList<Station4Data> Station4List;
+       typedef AliHLTMUONCoreList<AliStation4Data> Station4List;
        
        
-       void ReceiveClustersChamber7(const AliHLTMUONCoreClusterPoint* clusters, UInt count, const TagData* data);
-       void ReceiveClustersChamber8(const AliHLTMUONCoreClusterPoint* clusters, UInt count, const TagData* data);
+       void ReceiveClustersChamber7(const AliHLTMUONCoreClusterPoint* clusters, UInt count, const AliTagData* data);
+       void ReceiveClustersChamber8(const AliHLTMUONCoreClusterPoint* clusters, UInt count, const AliTagData* data);
        void ReceiveClustersChamber9(const AliHLTMUONCoreClusterPoint* clusters, UInt count);
        void ReceiveClustersChamber10(const AliHLTMUONCoreClusterPoint* clusters, UInt count);
        void EndOfClustersChamber7();
@@ -186,7 +199,7 @@ protected:
        void EndOfClustersChamber9();
        void EndOfClustersChamber10();
 
-       void ProjectToStation4(Station5Data* data, register Float station5z);
+       void ProjectToStation4(AliStation5Data* data, register Float station5z);
        void ProcessClusters();
 
 #if defined(DEBUG) || (defined(USE_ALILOG) && ! defined(LOG_NO_DEBUG))
@@ -220,8 +233,8 @@ protected:
        UInt fRequestsCompleted;  // Number of requests for station 4 that have completed.
        AliHLTMUONCoreChamberID fSt4chamber;     // The chamber on station 4 that data was retreived from.
        
-       Vertex fV1;    // The impact (hit) vertex for trigger station 1.
-       TagData fMc1;  // Trigger station 1 data.
+       AliVertex fV1;    // The impact (hit) vertex for trigger station 1.
+       AliTagData fMc1;  // Trigger station 1 data.
 
        Float fSt5z;   // The z coordinate to use for station 5.
        Station5List fSt5data;  // List of found cluster points for station 5 and their tag data.
@@ -229,8 +242,8 @@ protected:
        Station4List fSt4points;  // The found cluster points for station 4.
 
        // Iterators used in the FoundTrack, FillTrackData methods.
-       Station5List::Iterator fSt5rec;
-       Station4List::Iterator fFoundPoint;
+       Station5List::Iterator fSt5rec;      // current station 5 record
+       Station4List::Iterator fFoundPoint;  // current found point
 
 private: