Coding conventions (A.Szostak)
authorhristov <hristov@f7af4fe6-9843-0410-8265-dc069ae4e863>
Tue, 11 Apr 2006 07:11:44 +0000 (07:11 +0000)
committerhristov <hristov@f7af4fe6-9843-0410-8265-dc069ae4e863>
Tue, 11 Apr 2006 07:11:44 +0000 (07:11 +0000)
66 files changed:
HLT/MUON/src/ADCStream.hpp
HLT/MUON/src/AliRoot/ADCStream.cxx
HLT/MUON/src/AliRoot/ADCStream.hpp
HLT/MUON/src/AliRoot/ADCStreamSource.cxx
HLT/MUON/src/AliRoot/ADCStreamSource.hpp
HLT/MUON/src/AliRoot/AliHLTMUONTracker.cxx
HLT/MUON/src/AliRoot/AliHLTMUONTracker.h
HLT/MUON/src/AliRoot/Base.hpp
HLT/MUON/src/AliRoot/ClusterFinder.hpp
HLT/MUON/src/AliRoot/ClusterFinderCallback.cxx
HLT/MUON/src/AliRoot/ClusterFinderCallback.hpp
HLT/MUON/src/AliRoot/ClusterFinderInterface.hpp
HLT/MUON/src/AliRoot/ClusterFinderProxy.cxx
HLT/MUON/src/AliRoot/ClusterFinderProxy.hpp
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/Point.cxx
HLT/MUON/src/AliRoot/Point.hpp
HLT/MUON/src/AliRoot/Region.cxx
HLT/MUON/src/AliRoot/Region.hpp
HLT/MUON/src/AliRoot/Track.cxx
HLT/MUON/src/AliRoot/Track.hpp
HLT/MUON/src/AliRoot/TrackSink.cxx
HLT/MUON/src/AliRoot/TrackSink.hpp
HLT/MUON/src/AliRoot/Tracker.hpp
HLT/MUON/src/AliRoot/TrackerCallback.cxx
HLT/MUON/src/AliRoot/TrackerCallback.hpp
HLT/MUON/src/AliRoot/TrackerInterface.hpp
HLT/MUON/src/AliRoot/TrackerProxy.cxx
HLT/MUON/src/AliRoot/TrackerProxy.hpp
HLT/MUON/src/AliRoot/TriggerRecord.cxx
HLT/MUON/src/AliRoot/TriggerRecord.hpp
HLT/MUON/src/AliRoot/TriggerSource.cxx
HLT/MUON/src/AliRoot/TriggerSource.hpp
HLT/MUON/src/AliRoot/convert.cxx
HLT/MUON/src/AliRoot/convert.hpp
HLT/MUON/src/BasicTypes.hpp
HLT/MUON/src/Buffers/CountedList.hpp
HLT/MUON/src/Buffers/List.hpp
HLT/MUON/src/Cluster.hpp
HLT/MUON/src/Clustering/CenterOfGravityFinder.cxx
HLT/MUON/src/Clustering/CenterOfGravityFinder.hpp
HLT/MUON/src/Clustering/ClusterFinder.hpp
HLT/MUON/src/Debug/print.cxx
HLT/MUON/src/Debug/print.hpp
HLT/MUON/src/Decision/DecisionMaker.hpp
HLT/MUON/src/Error.cxx
HLT/MUON/src/Error.hpp
HLT/MUON/src/EventID.hpp
HLT/MUON/src/Point.hpp
HLT/MUON/src/RegionOfInterest.cxx
HLT/MUON/src/RegionOfInterest.hpp
HLT/MUON/src/Track.hpp
HLT/MUON/src/Tracking/Calculations.cxx
HLT/MUON/src/Tracking/Calculations.hpp
HLT/MUON/src/Tracking/MansoTracker.cxx
HLT/MUON/src/Tracking/MansoTracker.hpp
HLT/MUON/src/Tracking/Tracker.hpp
HLT/MUON/src/TriggerRecord.hpp
HLT/MUON/src/Utils.cxx
HLT/MUON/src/Utils.hpp
HLT/MUON/src/new.cxx
HLT/MUON/src/new.hpp

index d2463adb1aec6fdcd3797aeb1c05e02f7bb1ee3d..51bd8ed7d94d4f8145190f8bc10d4fe987be400b 100644 (file)
@@ -5,20 +5,15 @@
 //
 ////////////////////////////////////////////////////////////////////////////////
 
-#ifndef dHLT_ADC_STREAM_HPP
-#define dHLT_ADC_STREAM_HPP
+#ifndef ALIHLTMUONCOREADCSTREAM_H
+#define ALIHLTMUONCOREADCSTREAM_H
 
 #include "BasicTypes.hpp"
 
-namespace dHLT
-{
-
 
-class ADCStream
+class AliHLTMUONCoreADCStream
 {
 };
 
 
-} // dHLT
-
-#endif // dHLT_ADC_STREAM_HPP
+#endif // ALIHLTMUONCOREADCSTREAM_H
index 8d0fae3e2af37e8f56bb1ac6e8391bff856caa22..ef2d53ae7c849c6fc20ab5a0578a22fed10252b8 100644 (file)
 #include "Utils.hpp"
 
 
-ClassImp(AliMUONHLT::ADCStream)
-
-namespace AliMUONHLT
-{
+ClassImp(AliHLTMUONADCStream)
 
 
-ADCStream::ADCStream() : TObject()
+AliHLTMUONADCStream::AliHLTMUONADCStream() : TObject()
 {
        fData.Set(0);
 }
 
 
-ADCStream::ADCStream(const UInt_t* data, UInt_t size)
+AliHLTMUONADCStream::AliHLTMUONADCStream(const UInt_t* data, UInt_t size)
 {
        fData.Set(size, (Int_t*)data);
 }
 
 
-ADCStream::~ADCStream()
+AliHLTMUONADCStream::~AliHLTMUONADCStream()
 {
        fData.Reset();
 }
 
 
-UInt_t ADCStream::Size()
+UInt_t AliHLTMUONADCStream::Size()
 {
        return fData.GetSize();
 }
 
 
-void ADCStream::Size(UInt_t size)
+void AliHLTMUONADCStream::Size(UInt_t size)
 {
        fData.Set(size);
 }
 
 
-void ADCStream::Fill(const UInt_t* data, UInt_t size)
+void AliHLTMUONADCStream::Fill(const UInt_t* data, UInt_t size)
 {
        fData.Set(size, (Int_t*)data);
 }
 
 
-// UInt_t& ADCStream::operator [] (const UInt_t index)
+// UInt_t& AliHLTMUONADCStream::operator [] (const UInt_t index)
 // {
 //     Assert( index < (UInt_t) fData.GetSize() );
 //     return (UInt_t) fData[index];
 // };
 
 
-UInt_t ADCStream::operator [] (UInt_t index) const
+UInt_t AliHLTMUONADCStream::operator [] (UInt_t index) const
 {
        Assert( index < (UInt_t) fData.GetSize() );
        return fData[index];
 }
 
 
-ostream& operator << (ostream& os, const ADCStream& s)
+ostream& operator << (ostream& os, const AliHLTMUONADCStream& s)
 {
-       os << "{ADCStream: " << (void*)s.Data() << "}";
+       os << "{AliHLTMUONADCStream: " << (void*)s.Data() << "}";
        os << endl;
        for (Int_t i = 0; i < s.fData.GetSize(); i++)
        {
@@ -80,5 +77,3 @@ ostream& operator << (ostream& os, const ADCStream& s)
        return os;
 }
 
-
-} // AliMUONHLT
index 4898213f7258364b2fd0b1d936975653c147a4d0..74ae83cc8fce229d4d6352f7ec5b0c3b6be095b3 100644 (file)
@@ -5,29 +5,25 @@
 //
 ////////////////////////////////////////////////////////////////////////////////
 
-#ifndef dHLT_ALIROOT_ADC_STREAM_HPP
-#define dHLT_ALIROOT_ADC_STREAM_HPP
+#ifndef ALIHLTMUONSTREAM_H
+#define ALIHLTMUONSTREAM_H
 
 #include <TObject.h>
 #include <TArrayI.h>
 #include <Riostream.h>
 
 
-namespace AliMUONHLT
-{
-
-
-class ADCStream : public TObject
+class AliHLTMUONADCStream : public TObject
 {
 public:
 
        /* Default constructor initialises everything to zero.
         */
-       ADCStream();
+       AliHLTMUONADCStream();
        
-       ADCStream(const UInt_t* data, UInt_t size);
+       AliHLTMUONADCStream(const UInt_t* data, UInt_t size);
 
-       virtual ~ADCStream();
+       virtual ~AliHLTMUONADCStream();
        
        UInt_t Size();
        void Size(UInt_t size);
@@ -40,17 +36,15 @@ public:
        UInt_t operator [] (UInt_t index) const;
 
        // ostream operator usefull for text output.
-       friend ostream& operator << (ostream& os, const ADCStream& s);
+       friend ostream& operator << (ostream& os, const AliHLTMUONADCStream& s);
 
 private:
 
        // TODO: complete the ADC stream specification.
        TArrayI fData;
 
-       ClassDef(ADCStream, 1)  // ADC stream data.
+       ClassDef(AliHLTMUONADCStream, 1)  // ADC stream data.
 };
 
 
-} // AliMUONHLT
-
-#endif // dHLT_ALIROOT_ADC_STREAM_HPP
+#endif // ALIHLTMUONSTREAM_H
index da970947149ee1681209780c546f75ae7d4ad051..0a23816e8e7e1f2b30fd1e36cc7771537562144c 100644 (file)
 
 // TODO: Change all the Error message statements to AliError at some stage.
 
+ClassImp(AliHLTMUONADCStreamSource)
+ClassImp(AliHLTMUONADCStreamSource::DataBlock)
 
-ClassImp(AliMUONHLT::ADCStreamSource)
-ClassImp(AliMUONHLT::ADCStreamSource::DataBlock)
 
-namespace AliMUONHLT
-{
-
-
-ADCStreamSource::ADCStreamSource() : TObject()
+AliHLTMUONADCStreamSource::AliHLTMUONADCStreamSource() : TObject()
 {
        fCurrentStream = -1;
 }
 
 
-ADCStreamSource::~ADCStreamSource()
+AliHLTMUONADCStreamSource::~AliHLTMUONADCStreamSource()
 {
        // Everything is cleaned up implicitly.
 }
 
 
-void ADCStreamSource::FillFromFile(const TString& filename, Int_t eventnumber)
+void AliHLTMUONADCStreamSource::FillFromFile(const TString& filename, Int_t eventnumber)
 {
        DebugMsg(1, "Entering FillFromFile, file = " << filename.Data()
                << ", event number = " << eventnumber
@@ -47,7 +43,7 @@ void ADCStreamSource::FillFromFile(const TString& filename, Int_t eventnumber)
                if ( gSystem->GetPathInfo(filename, &id, &size, &flags, &modtime) == 0 )
                {
                        DebugMsg(2, "Size of file: " << filename.Data() << " is " << size << " bytes");
-                       ADCStream stream;
+                       AliHLTMUONADCStream stream;
                        stream.Size(size/sizeof(Int_t));
                        size_t bytesread = fread(stream.Data(), 1, size, file);
                        if (bytesread == (size_t)size)
@@ -67,7 +63,7 @@ void ADCStreamSource::FillFromFile(const TString& filename, Int_t eventnumber)
 }
 
 
-void ADCStreamSource::FillFrom(const TString& directory, Int_t eventnumber)
+void AliHLTMUONADCStreamSource::FillFrom(const TString& directory, Int_t eventnumber)
 {
        DebugMsg(1, "Entering FillFrom, directory = " << directory.Data()
                << ", event number = " << eventnumber
@@ -95,7 +91,7 @@ void ADCStreamSource::FillFrom(const TString& directory, Int_t eventnumber)
 }
 
 
-void ADCStreamSource::FillFrom(const TString& dirprefix, UInt_t firstevent, UInt_t lastevent)
+void AliHLTMUONADCStreamSource::FillFrom(const TString& dirprefix, UInt_t firstevent, UInt_t lastevent)
 {
        DebugMsg(1, "Entering FillFrom");
        
@@ -110,20 +106,20 @@ void ADCStreamSource::FillFrom(const TString& dirprefix, UInt_t firstevent, UInt
 }
 
 
-void ADCStreamSource::Clear(Option_t* /*option*/)
+void AliHLTMUONADCStreamSource::Clear(Option_t* /*option*/)
 {
        fCurrentStream = -1;
        fList.erase( fList.begin(), fList.end() );
 }
 
 
-Int_t ADCStreamSource::NumberOfStreams() const
+Int_t AliHLTMUONADCStreamSource::NumberOfStreams() const
 {
        return fList.size();
 }
 
 
-Bool_t ADCStreamSource::GetStream(Int_t index) const
+Bool_t AliHLTMUONADCStreamSource::GetStream(Int_t index) const
 {
        if ( 0 <= index && index < NumberOfStreams() )
        {
@@ -148,7 +144,7 @@ Bool_t ADCStreamSource::GetStream(Int_t index) const
 }
 
 
-Bool_t ADCStreamSource::FirstStream() const
+Bool_t AliHLTMUONADCStreamSource::FirstStream() const
 {
        if (NumberOfStreams() > 0)
        {
@@ -160,7 +156,7 @@ Bool_t ADCStreamSource::FirstStream() const
 }
 
 
-Bool_t ADCStreamSource::NextStream() const
+Bool_t AliHLTMUONADCStreamSource::NextStream() const
 {
        if ( 0 <= fCurrentStream && fCurrentStream < NumberOfStreams() - 1 )
        {
@@ -172,7 +168,7 @@ Bool_t ADCStreamSource::NextStream() const
 };
 
 
-Int_t ADCStreamSource::EventNumber() const
+Int_t AliHLTMUONADCStreamSource::EventNumber() const
 {
        if (fCurrentStream >= 0)
        {
@@ -187,7 +183,7 @@ Int_t ADCStreamSource::EventNumber() const
 }
 
 
-Bool_t ADCStreamSource::FetchStream(ADCStream& stream) const
+Bool_t AliHLTMUONADCStreamSource::FetchStream(AliHLTMUONADCStream& stream) const
 {
        if (fCurrentStream >= 0)
        {
@@ -203,7 +199,7 @@ Bool_t ADCStreamSource::FetchStream(ADCStream& stream) const
 }
 
 
-Bool_t ADCStreamSource::FetchStream(Int_t index, ADCStream& stream) const
+Bool_t AliHLTMUONADCStreamSource::FetchStream(Int_t index, AliHLTMUONADCStream& stream) const
 {
        if ( GetStream(index) )
                return FetchStream(stream);
@@ -212,7 +208,7 @@ Bool_t ADCStreamSource::FetchStream(Int_t index, ADCStream& stream) const
 }
 
 
-const ADCStream* ADCStreamSource::FetchStream() const
+const AliHLTMUONADCStream* AliHLTMUONADCStreamSource::FetchStream() const
 {
        if (fCurrentStream >= 0)
        {
@@ -227,7 +223,7 @@ const ADCStream* ADCStreamSource::FetchStream() const
 }
 
 
-void ADCStreamSource::AddStream(ADCStream& stream, UInt_t eventnumber)
+void AliHLTMUONADCStreamSource::AddStream(AliHLTMUONADCStream& stream, UInt_t eventnumber)
 {
        DebugMsg(1, "Entering AddStream");
        
@@ -240,5 +236,3 @@ void ADCStreamSource::AddStream(ADCStream& stream, UInt_t eventnumber)
        DebugMsg(1, "Leaving AddStream");
 }
 
-
-} // AliMUONHLT
index 2f42c1f9663a59decd65a2febbb6618d26831f00..6fa5d444cb02c719f763a9885bf782fb8d6f0d20 100644 (file)
@@ -5,8 +5,8 @@
 //
 ////////////////////////////////////////////////////////////////////////////////
 
-#ifndef dHLT_ALIROOT_ADC_STREAM_SOURCE_HPP
-#define dHLT_ALIROOT_ADC_STREAM_SOURCE_HPP
+#ifndef ALIHLTMUONADCSTREAMSOURCE_H
+#define ALIHLTMUONADCSTREAMSOURCE_H
 
 #include "TROOT.h"
 #include "TObject.h"
 
 #include <vector>
 
-namespace AliMUONHLT
-{
-
 
-class ADCStreamSource : public TObject
+class AliHLTMUONADCStreamSource : public TObject
 {
 public:
 
-       ADCStreamSource();
-       virtual ~ADCStreamSource();
+       AliHLTMUONADCStreamSource();
+       virtual ~AliHLTMUONADCStreamSource();
 
        /* Fills the internal data structures from the specified file
         */
@@ -76,23 +73,23 @@ public:
        /* Returns the current ADC stream selected.
           kFALSE is returned if there is no stream selected.
         */
-       Bool_t FetchStream(ADCStream& stream) const;
+       Bool_t FetchStream(AliHLTMUONADCStream& stream) const;
        
        /* Returns the index'th ADC stream.
           kTRUE is returned if the stream was found, kFALSE otherwise.
         */
-       Bool_t FetchStream(Int_t index, ADCStream& stream) const;
+       Bool_t FetchStream(Int_t index, AliHLTMUONADCStream& stream) const;
        
        /* Returns the current ADC stream selected.
           A NULL pointer is returned if no ADC stream is selected.
         */
-       const ADCStream* FetchStream() const;
+       const AliHLTMUONADCStream* FetchStream() const;
 
 private:
 
-       /* Adds a new ADCStream object to the internal arrays.
+       /* Adds a new AliHLTMUONADCStream object to the internal arrays.
         */
-       void AddStream(ADCStream& stream, UInt_t eventnumber);
+       void AddStream(AliHLTMUONADCStream& stream, UInt_t eventnumber);
 
        mutable Int_t fCurrentStream;  //! The currently selected stream index.
        
@@ -104,7 +101,7 @@ public:  // Unfortunately ROOT requires the following to be public.
                virtual ~DataBlock() {};
 
                Int_t fEventNumber;  // Event number of the stream.
-               ADCStream fStream;  // The ADC stream block.
+               AliHLTMUONADCStream fStream;  // The ADC stream block.
                
                ClassDef(DataBlock, 1)  // Data per event.
        };
@@ -113,10 +110,8 @@ private:
 
        std::vector<DataBlock> fList;  // List of ADC streams.
 
-       ClassDef(ADCStreamSource, 1)  // The source of ADC stream data for dHLT.
+       ClassDef(AliHLTMUONADCStreamSource, 1)  // The source of ADC stream data for dHLT.
 };
 
 
-} // AliMUONHLT
-
-#endif // dHLT_ALIROOT_ADC_STREAM_SOURCE_HPP
+#endif // ALIHLTMUONADCSTREAMSOURCE_H
index 9d962d162d793ea8abbdac66c42cde8cea52aaa7..d8a1970b6e97530cba5f435eeec8a4e4af9671c1 100644 (file)
@@ -14,16 +14,16 @@ ClassImp(AliHLTMUONTracker)
 
 AliHLTMUONTracker::AliHLTMUONTracker(AliRunLoader* runloader) : AliTracker()
 {
-// Creates the the MicrodHLT object and its associated data source and sink
-// objects. The MicrodHLT object is then initialised by hooking to these objects.
+// Creates the the AliHLTMUONMicrodHLT object and its associated data source and sink
+// objects. The AliHLTMUONMicrodHLT object is then initialised by hooking to these objects.
 
        AliDebug(2, Form("Called for object 0x%X and with runloader = 0x%X", (ULong_t)this, (ULong_t)runloader));
 
        // Create the dHLT objects.
-       fdHLT = new AliMUONHLT::MicrodHLT();
-       fTriggers = new AliMUONHLT::TriggerSource();
-       fClusters = new AliMUONHLT::ClusterSource();
-       fTracks = new AliMUONHLT::TrackSink();
+       fdHLT = new AliHLTMUONMicrodHLT();
+       fTriggers = new AliHLTMUONTriggerSource();
+       fClusters = new AliHLTMUONClusterSource();
+       fTracks = new AliHLTMUONTrackSink();
 
        // Hook up all the objects.
        fdHLT->SetTriggerSource(fTriggers);
@@ -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(AliMUONHLT::TriggerSource::FromLocalTriggers);
+       fTriggers->DataToUse(AliHLTMUONTriggerSource::FromLocalTriggers);
        fTriggers->FillFrom(&di, di.CurrentEvent());
 
 #ifndef LOG_NO_DEBUG
@@ -66,7 +66,7 @@ Int_t AliHLTMUONTracker::LoadClusters(TTree* data)
        for (fTriggers->GetFirstBlock(); fTriggers->MoreBlocks(); fTriggers->GetNextBlock())
        for (fTriggers->GetFirstTrigger(); fTriggers->MoreTriggers(); fTriggers->GetNextTrigger())
        {
-               const AliMUONHLT::TriggerRecord* trig = fTriggers->GetTrigger();
+               const AliHLTMUONTriggerRecord* trig = fTriggers->GetTrigger();
                str += trig->TriggerNumber();
                str += "\t";
                str += trig->ParticleSign();
@@ -86,7 +86,7 @@ Int_t AliHLTMUONTracker::LoadClusters(TTree* data)
 #endif // LOG_NO_DEBUG
 
        // Load cluster points (reconstructed hits)
-       fClusters->DataToUse(AliMUONHLT::ClusterSource::FromRawClusters);
+       fClusters->DataToUse(AliHLTMUONClusterSource::FromRawClusters);
        fClusters->FillFrom(&di, di.CurrentEvent());
 
 #ifndef LOG_NO_DEBUG
@@ -125,8 +125,8 @@ void AliHLTMUONTracker::UnloadClusters()
 }
 
 
-const AliMUONHLT::TriggerRecord*
-AliHLTMUONTracker::FindTriggerRecord(const AliMUONHLT::Track* track) const
+const AliHLTMUONTriggerRecord*
+AliHLTMUONTracker::FindTriggerRecord(const AliHLTMUONTrack* track) const
 {
 // Finds the corresponding trigger record object for the given track.
 // This is doen by matching up the trigger record number with the trigger
@@ -136,7 +136,7 @@ AliHLTMUONTracker::FindTriggerRecord(const AliMUONHLT::Track* track) const
        for (fTriggers->GetFirstBlock(); fTriggers->MoreBlocks(); fTriggers->GetNextBlock())
        for (fTriggers->GetFirstTrigger(); fTriggers->MoreTriggers(); fTriggers->GetNextTrigger())
        {
-               const AliMUONHLT::TriggerRecord* trigrec = fTriggers->GetTrigger();
+               const AliHLTMUONTriggerRecord* trigrec = fTriggers->GetTrigger();
                if ( trigrec->TriggerNumber() == track->TriggerID() )
                        return trigrec;
        }
@@ -167,11 +167,11 @@ void AliHLTMUONTracker::LeastSquaresFit(const Double_t x[4], const Double_t y[4]
 }
 
 
-Double_t AliHLTMUONTracker::ComputeChi2(const AliMUONHLT::Track* track) const
+Double_t AliHLTMUONTracker::ComputeChi2(const AliHLTMUONTrack* track) const
 {
 // Computes the Chi^2 for the line fit of the found track fragment.
 
-       const AliMUONHLT::TriggerRecord* trigrec = FindTriggerRecord(track);
+       const AliHLTMUONTriggerRecord* trigrec = FindTriggerRecord(track);
        if (trigrec == NULL) return -1.;
        AliDebug(10, Form("Found trigger #%d, particle sign = %d, pt = %f",
                        trigrec->TriggerNumber(),
@@ -186,25 +186,25 @@ Double_t AliHLTMUONTracker::ComputeChi2(const AliMUONHLT::Track* track) const
        {
                st4x = track->Hit(7).fX;
                st4y = track->Hit(7).fY;
-               st4z = dHLT::Tracking::MansoTracker::GetZ8();
+               st4z = AliHLTMUONCoreMansoTracker::GetZ8();
        }
        else
        {
                st4x = track->Hit(6).fX;
                st4y = track->Hit(6).fY;
-               st4z = dHLT::Tracking::MansoTracker::GetZ7();
+               st4z = AliHLTMUONCoreMansoTracker::GetZ7();
        }
        if (track->Hit(8).fX == 0. && track->Hit(8).fY == 0.)
        {
                st5x = track->Hit(9).fX;
                st5y = track->Hit(9).fY;
-               st5z = dHLT::Tracking::MansoTracker::GetZ10();
+               st5z = AliHLTMUONCoreMansoTracker::GetZ10();
        }
        else
        {
                st5x = track->Hit(8).fX;
                st5y = track->Hit(8).fY;
-               st5z = dHLT::Tracking::MansoTracker::GetZ9();
+               st5z = AliHLTMUONCoreMansoTracker::GetZ9();
        }
 
        Double_t x[4] = {st4x, st5x,
@@ -214,8 +214,8 @@ Double_t AliHLTMUONTracker::ComputeChi2(const AliMUONHLT::Track* track) const
                        trigrec->Station1Point().fY, trigrec->Station2Point().fY
                };
        Double_t z[4] = {st4z, st5z,
-                       dHLT::Tracking::MansoTracker::GetZ11(),
-                       dHLT::Tracking::MansoTracker::GetZ13()
+                       AliHLTMUONCoreMansoTracker::GetZ11(),
+                       AliHLTMUONCoreMansoTracker::GetZ13()
                };
 
        // Fit a line to the x, y, z data points.
@@ -244,8 +244,8 @@ Double_t AliHLTMUONTracker::ComputeChi2(const AliMUONHLT::Track* track) const
 
 Int_t AliHLTMUONTracker::Clusters2Tracks(AliESD* event)
 {
-// Runs the dHLT tracking algorithm via the MicrodHLT fdHLT object. The found tracks are
-// filled by MicrodHLT in fTracks, which then need to be unpacked into the AliRoot ESD.
+// Runs the dHLT tracking algorithm via the AliHLTMUONMicrodHLT fdHLT object. The found tracks are
+// filled by AliHLTMUONMicrodHLT in fTracks, which then need to be unpacked into the AliRoot ESD.
 
        AliDebug(1, Form("Called for object 0x%X and ESD object = 0x%X", (ULong_t)this, (ULong_t)event));
 
@@ -261,7 +261,7 @@ Int_t AliHLTMUONTracker::Clusters2Tracks(AliESD* event)
        for (fTracks->GetFirstBlock(); fTracks->MoreBlocks(); fTracks->GetNextBlock())
        for (fTracks->GetFirstTrack(); fTracks->MoreTracks(); fTracks->GetNextTrack())
        {
-               const AliMUONHLT::Track* track = fTracks->GetTrack();
+               const AliHLTMUONTrack* track = fTracks->GetTrack();
 
 #ifndef LOG_NO_DEBUG
                // Build some debug logging information.
@@ -291,11 +291,11 @@ Int_t AliHLTMUONTracker::Clusters2Tracks(AliESD* event)
                str += "\n";
 #endif // LOG_NO_DEBUG
 
-               Double_t z = dHLT::Tracking::MansoTracker::GetZ7();
+               Double_t z = AliHLTMUONCoreMansoTracker::GetZ7();
                Double_t x = track->Hit(6).fX;
                if (track->Hit(6).fX == 0. && track->Hit(6).fY == 0.)
                {
-                       z = dHLT::Tracking::MansoTracker::GetZ8();
+                       z = AliHLTMUONCoreMansoTracker::GetZ8();
                        x = track->Hit(7).fX;
                };
 
index 3dd36c933a5cb43c57c321289cbae06ecf4944d2..55ef39a7e2978faf63ae812f6ef67be131355c05 100644 (file)
@@ -35,20 +35,20 @@ public:
        virtual Int_t Clusters2Tracks(AliESD* event);
 
 private:
-       const AliMUONHLT::TriggerRecord*
-       FindTriggerRecord(const AliMUONHLT::Track* track) const;
+       const AliHLTMUONTriggerRecord*
+       FindTriggerRecord(const AliHLTMUONTrack* track) const;
 
        void LeastSquaresFit(
                        const Double_t x[4], const Double_t y[4],
                        Double_t& m, Double_t& c
                ) const;
 
-       Double_t ComputeChi2(const AliMUONHLT::Track* track) const;
+       Double_t ComputeChi2(const AliHLTMUONTrack* track) const;
 
-       AliMUONHLT::MicrodHLT*     fdHLT;      // dHLT tracker algorithm interface object.
-       AliMUONHLT::TriggerSource* fTriggers;  // Trigger record input data object.
-       AliMUONHLT::ClusterSource* fClusters;  // Reconstructed hit input data object (sorry about the poor object naming).
-       AliMUONHLT::TrackSink*     fTracks;    // Track output data object.
+       AliHLTMUONMicrodHLT*     fdHLT;      // dHLT tracker algorithm interface object.
+       AliHLTMUONTriggerSource* fTriggers;  // Trigger record input data object.
+       AliHLTMUONClusterSource* fClusters;  // Reconstructed hit input data object (sorry about the poor object naming).
+       AliHLTMUONTrackSink*     fTracks;    // Track output data object.
 
        ClassDef(AliHLTMUONTracker, 1)  // dHLT tracker algorithm
 };
index a8e92cfb6626480c4ab6ec229f16e7facc46f796..86e411b6ef594d3cdf66006f73f721f0ec67e64d 100644 (file)
@@ -5,8 +5,8 @@
 //
 ////////////////////////////////////////////////////////////////////////////////
 
-#ifndef dHLT_ALIROOT_BASE_HPP
-#define dHLT_ALIROOT_BASE_HPP
+#ifndef ALIHLTMUONBASE_H
+#define ALIHLTMUONBASE_H
 
 #include "TError.h"
 #include "TMath.h"
@@ -24,4 +24,4 @@
 #endif // COMPILE_ROOT_ASSERT
 
 
-#endif // dHLT_ALIROOT_BASE_HPP
+#endif // ALIHLTMUONBASE_H
index 1e96579cc467c71986e6a263f2bfea23ef61042e..df8ce416a800fa52611b6dbc84d692ffaf645802 100644 (file)
@@ -5,29 +5,25 @@
 //
 ////////////////////////////////////////////////////////////////////////////////
 
-#ifndef dHLT_CLUSTERING_CLUSTER_FINDER_HPP
-#define dHLT_CLUSTERING_CLUSTER_FINDER_HPP
+#ifndef ALIHLTMUONDUMMYCLUSTERFINDER_H
+#define ALIHLTMUONDUMMYCLUSTERFINDER_H
 
 #ifndef __CINT__
-#include "BasicTypes.hpp"
-#include "Cluster.hpp"
-#include "ADCStream.hpp"
-#include "Utils.hpp"
+#include "AliRoot/Point.hpp"
+#include "AliRoot/ADCStream.hpp"
 #endif // __CINT__
 
-namespace AliMUONHLT
-{
 
-class ClusterFinder
+class AliHLTMUONDummyClusterFinder
 {
 public:
 
-       ClusterFinder() :fInterface(this)
+       AliHLTMUONDummyClusterFinder() : fInterface(this)
        {
                fCallback = NULL;
        };
 
-       virtual ~ClusterFinder() {};
+       virtual ~AliHLTMUONDummyClusterFinder() {};
 
        /* This is the starting point of the cluster finding algorithm.
           Deriving cluster finders should implement all processing in this method
@@ -35,7 +31,7 @@ public:
           the FoundClusters method should be called to indicate that processing is
           complete. If no clusters could be found then call NoClustersFound instead.
         */
-       virtual void FindClusters(const ADCStream * stream) = 0;
+       virtual void FindClusters(const AliHLTMUONADCStream * stream) = 0;
 
        /* After a call to FoundClusters this method will be called to retreive the
           cluster points. The clusters array should be filled consecutively with 
@@ -49,7 +45,7 @@ public:
           the cluster finder must resume writing clusters at the point it stopped at
           in the previous call to FillClusterData.
          */
-       virtual UInt_t FillClusterData(Point * clusters, UInt_t arraysize) = 0;
+       virtual UInt_t FillClusterData(AliHLTMUONPoint* clusters, UInt_t arraysize) = 0;
 
        /* This is called when the cluster finder should be reset to an initial state.
           All extra internal memory allocated during processing should be released.
@@ -58,47 +54,46 @@ public:
 
        /* Sets the ClusterFinderCallback callback interface.
         */
-       inline void SetCallback(ClusterFinderCallback * callback) {
+       inline void SetCallback(AliHLTMUONClusterFinderCallback * callback) {
                this->fCallback = callback;
        };
 
-       ClusterFinderInterface* Interface()
+       AliHLTMUONClusterFinderInterface* Interface()
        {
                return &fInterface;
        };
 
 private:
 
-       ClusterFinderInterface fInterface;
-       ClusterFinderCallback * fCallback;
+       AliHLTMUONClusterFinderInterface fInterface;
+       AliHLTMUONClusterFinderCallback * fCallback;
 };
 
 
-void ClusterFinderInterface::FindClusters(const ADCStream * stream)
+void AliHLTMUONClusterFinderInterface::FindClusters(const AliHLTMUONADCStream* stream)
 {
        fClusterFinder->FindClusters(stream);
 };
 
-UInt_t ClusterFinderInterface::FillClusterData(Point * clusters, UInt_t arraysize)
+UInt_t AliHLTMUONClusterFinderInterface::FillClusterData(AliHLTMUONPoint* clusters, UInt_t arraysize)
 {
-       return fClusterFinder->FillClusterData(clusters,arraysize);
+       return fClusterFinder->FillClusterData(clusters, arraysize);
 };
 
-void ClusterFinderInterface::Reset()
+void AliHLTMUONClusterFinderInterface::Reset()
 {
         fClusterFinder->Reset();
 };
 
-void ClusterFinderInterface::SetCallback(ClusterFinderCallback* callback)
+void AliHLTMUONClusterFinderInterface::SetCallback(AliHLTMUONClusterFinderCallback* callback)
 {
        fClusterFinder->SetCallback(callback);
 };
 
-void MicrodHLT::SetClusterFinder(ClusterFinder* clusterfinder)
+void AliHLTMUONMicrodHLT::SetClusterFinder(AliHLTMUONDummyClusterFinder* clusterfinder)
 {
        SetClusterFinder(clusterfinder->Interface());
 };
 
-}                              // AliMUONHLT
 
-#endif                         // dHLT_CLUSTERING_CLUSTER_FINDER_HPP
+#endif // ALIHLTMUONDUMMYCLUSTERFINDER_H
index 22168e06492741490523b66143cc651b994d6a0c..6eaa228cf7138f6bf44b36c294868ddede9b1cca 100644 (file)
@@ -7,4 +7,4 @@
 
 #include "AliRoot/ClusterFinderCallback.hpp"
 
-ClassImp(AliMUONHLT::ClusterFinderCallback)
+ClassImp(AliHLTMUONClusterFinderCallback)
index 0a2c6aa7041c1046f43ce1fd8f465bcfafe8063d..3f5fca416d5e94b1d7b3f17a9d88d347abb5d3a6 100644 (file)
@@ -5,29 +5,23 @@
 //
 ////////////////////////////////////////////////////////////////////////////////
 
-#ifndef dHLT_ALIROOT_CLUSTER_FINDER_CALLBACK_HPP
-#define dHLT_ALIROOT_CLUSTER_FINDER_CALLBACK_HPP
+#ifndef ALIHLTMUONCLUSTERFINDERCALLBACK_H
+#define ALIHLTMUONCLUSTERFINDERCALLBACK_H
 
 #include "TObject.h"
 
 
-namespace AliMUONHLT
-{
-
-
-class ClusterFinderCallback : public TObject
+class AliHLTMUONClusterFinderCallback : public TObject
 {
 public:
 
-       virtual ~ClusterFinderCallback() {};
+       virtual ~AliHLTMUONClusterFinderCallback() {};
 
        virtual void FoundClusters(UInt_t numberfound) = 0;
        virtual void NoClustersFound() = 0;
        
-       ClassDef(ClusterFinderCallback, 0)  // Abstract cluster finder callback class.
+       ClassDef(AliHLTMUONClusterFinderCallback, 0)  // Abstract cluster finder callback class.
 };
 
 
-} // AliMUONHLT
-
-#endif // dHLT_ALIROOT_CLUSTER_FINDER_CALLBACK_HPP
+#endif // ALIHLTMUONCLUSTERFINDERCALLBACK_H
index d1638dd2bbb1bd66fcad53a0033e45b364820451..6c347bc576d8b4ab31c1e63facf54d70fbb8f3ef 100644 (file)
@@ -5,45 +5,39 @@
 //
 ////////////////////////////////////////////////////////////////////////////////
 
-#ifndef dHLT_ALIROOT_CLUSTER_FINDER_INTERFACE_HPP
-#define dHLT_ALIROOT_CLUSTER_FINDER_INTERFACE_HPP
+#ifndef ALIHLTMUONCLUSTERFINDERINTERFACE_H
+#define ALIHLTMUONCLUSTERFINDERINTERFACE_H
 
 #include "Rtypes.h"
 
+class AliHLTMUONPoint;
+class AliHLTMUONADCStream;
+class AliHLTMUONClusterFinderCallback;
+class AliHLTMUONDummyClusterFinder;
 
-namespace AliMUONHLT
-{
-
-class Point;
-class ADCStream;
-class ClusterFinder;
-class ClusterFinderCallback;
 
-
-class ClusterFinderInterface
+class AliHLTMUONClusterFinderInterface
 {
 public:
-       ClusterFinderInterface(ClusterFinder* clusterfinder)
+       AliHLTMUONClusterFinderInterface(AliHLTMUONDummyClusterFinder* clusterfinder)
        {
                fClusterFinder = clusterfinder;
        };
        
-       const ClusterFinder* GetClusterFinder() const
+       const AliHLTMUONDummyClusterFinder* GetClusterFinder() const
        {
                return fClusterFinder;
        };
        
-        void FindClusters(const ADCStream* stream);
-       UInt_t FillClusterData(Point* clusters, UInt_t arraysize);
+        void FindClusters(const AliHLTMUONADCStream* stream);
+       UInt_t FillClusterData(AliHLTMUONPoint* clusters, UInt_t arraysize);
        void Reset();
-        void SetCallback(ClusterFinderCallback* callback);
+        void SetCallback(AliHLTMUONClusterFinderCallback* callback);
 
 private:
 
-       ClusterFinder* fClusterFinder;   //! Pointer to interpreted cluster finder class.
+       AliHLTMUONDummyClusterFinder* fClusterFinder;   //! Pointer to interpreted cluster finder class.
 };
 
 
-} // AliMUONHLT
-
-#endif // dHLT_ALIROOT_CLUSTER_FINDER_INTERFACE_HPP
+#endif // ALIHLTMUONCLUSTERFINDERINTERFACE_H
index 438bffb269b43c262885bece73990094ce637266..77d54a1b6fe0d4aa8afc193b2f44ae0760d2a304 100644 (file)
 #include "Utils.hpp"
 #include "new.hpp"
 
-namespace dHLT
-{
-namespace AliRoot
-{
-
 
-ClusterFinderProxy::ClusterFinderProxy(AliMUONHLT::ClusterFinderInterface* client)
-       : Clustering::ClusterFinder(), AliMUONHLT::ClusterFinderCallback()
+AliHLTMUONClusterFinderProxy::AliHLTMUONClusterFinderProxy(AliHLTMUONClusterFinderInterface* client)
+       : AliHLTMUONCoreClusterFinder(), AliHLTMUONClusterFinderCallback()
 {
        clusterfinder = client;
 }
 
 
-void ClusterFinderProxy::FindClusters(const ADCStream* stream)
+void AliHLTMUONClusterFinderProxy::FindClusters(const AliHLTMUONCoreADCStream* /*stream*/)
 {
        // TODO: perform conversion
-       //AliMUONHLT::ADCStream stream = Convert(stream);
-       AliMUONHLT::ADCStream adc;
-       DebugMsg(6, "ClusterFinderProxy::FindClusters: " << adc);
+       //ADCStream adc = AliHLTMUONConvert(stream);
+       AliHLTMUONADCStream adc;
+       DebugMsg(6, "AliHLTMUONClusterFinderProxy::FindClusters: " << adc);
        clusterfinder->FindClusters(&adc);
 }
 
 
-UInt ClusterFinderProxy::FillClusterData(ClusterPoint* clusters, UInt arraysize)
+UInt AliHLTMUONClusterFinderProxy::FillClusterData(AliHLTMUONCoreClusterPoint* clusters, UInt arraysize)
 {
        UInt result;
-       AliMUONHLT::Point* points = new AliMUONHLT::Point[arraysize];
+       AliHLTMUONPoint* points = new AliHLTMUONPoint[arraysize];
        try
        {
-               DebugMsg(6, "ClusterFinderProxy::FillClusterData");
+               DebugMsg(6, "AliHLTMUONClusterFinderProxy::FillClusterData");
                result = clusterfinder->FillClusterData(points, arraysize);
                for (UInt i = 0; i < arraysize; i++)
                {
-                       clusters[i] = Convert(points[i]);
+                       clusters[i] = AliHLTMUONConvert(points[i]);
                        DebugMsg(6, "\tpoints[" << i << "] = " << points[i] );
                }
        }
@@ -56,26 +51,22 @@ UInt ClusterFinderProxy::FillClusterData(ClusterPoint* clusters, UInt arraysize)
 }
 
 
-void ClusterFinderProxy::Reset()
+void AliHLTMUONClusterFinderProxy::Reset()
 {
-       DebugMsg(6, "ClusterFinderProxy::Reset");
+       DebugMsg(6, "AliHLTMUONClusterFinderProxy::Reset");
        clusterfinder->Reset();
 }
 
 
-void ClusterFinderProxy::FoundClusters(UInt_t numberfound)
+void AliHLTMUONClusterFinderProxy::FoundClusters(UInt_t numberfound)
 {
-       DebugMsg(6, "ClusterFinderProxy::FoundClusters");
-       Clustering::ClusterFinder::FoundClusters(numberfound);
+       DebugMsg(6, "AliHLTMUONClusterFinderProxy::FoundClusters");
+       AliHLTMUONCoreClusterFinder::FoundClusters(numberfound);
 }
 
 
-void ClusterFinderProxy::NoClustersFound()
+void AliHLTMUONClusterFinderProxy::NoClustersFound()
 {
-       DebugMsg(6, "ClusterFinderProxy::NoClustersFound");
-       Clustering::ClusterFinder::NoClustersFound();
+       DebugMsg(6, "AliHLTMUONClusterFinderProxy::NoClustersFound");
+       AliHLTMUONCoreClusterFinder::NoClustersFound();
 }
-
-
-} // AliRoot
-} // dHLT
index c231389311f390490e8abf75320768a32157f914..e15e57aa7585f4b84e77c2917be8fe7479f58d2d 100644 (file)
@@ -5,29 +5,24 @@
 //
 ////////////////////////////////////////////////////////////////////////////////
 
-#ifndef dHLT_ALIROOT_CLUSTER_FINDER_PROXY_HPP
-#define dHLT_ALIROOT_CLUSTER_FINDER_PROXY_HPP
+#ifndef ALIHLTMUONCLUSTERFINDERPROXY_H
+#define ALIHLTMUONCLUSTERFINDERPROXY_H
 
 #include "Clustering/ClusterFinder.hpp"
 #include "AliRoot/ClusterFinderCallback.hpp"
 #include "AliRoot/ClusterFinderInterface.hpp"
 
-namespace dHLT
-{
-namespace AliRoot
-{
 
-
-class ClusterFinderProxy : public Clustering::ClusterFinder, public AliMUONHLT::ClusterFinderCallback
+class AliHLTMUONClusterFinderProxy : public AliHLTMUONCoreClusterFinder, public AliHLTMUONClusterFinderCallback
 {
 public:
 
-       ClusterFinderProxy(AliMUONHLT::ClusterFinderInterface* client);
-       virtual ~ClusterFinderProxy() {};
+       AliHLTMUONClusterFinderProxy(AliHLTMUONClusterFinderInterface* client);
+       virtual ~AliHLTMUONClusterFinderProxy() {};
 
        // inherited methods from Clustering::ClusterFinder:
-       virtual void FindClusters(const ADCStream* stream);
-       virtual UInt FillClusterData(ClusterPoint* clusters, UInt arraysize);
+       virtual void FindClusters(const AliHLTMUONCoreADCStream* stream);
+       virtual UInt FillClusterData(AliHLTMUONCoreClusterPoint* clusters, UInt arraysize);
        virtual void Reset();
 
        // inherited methods from AliMUONHLT::ClusterFinderCallback:
@@ -36,11 +31,8 @@ public:
 
 private:
 
-       AliMUONHLT::ClusterFinderInterface* clusterfinder;  // The clusterfinder we are proxying for.
+       AliHLTMUONClusterFinderInterface* clusterfinder;  // The clusterfinder we are proxying for.
 };
 
 
-} // AliRoot
-} // dHLT
-
-#endif // dHLT_ALIROOT_CLUSTER_FINDER_PROXY_HPP
+#endif // ALIHLTMUONCLUSTERFINDERPROXY_H
index ec545cf220da80fa16acc4e1a541338f14711561..f1ab056957bb1502a12eb387730bfffd8813c2f4 100644 (file)
 #include <float.h>
 #endif
 
-ClassImp(AliMUONHLT::ClusterSource)
-ClassImp(AliMUONHLT::ClusterSource::BlockData)
-ClassImp(AliMUONHLT::ClusterSource::EventData)
-
-namespace AliMUONHLT
-{
+ClassImp(AliHLTMUONClusterSource)
+ClassImp(AliHLTMUONClusterSource::BlockData)
+ClassImp(AliHLTMUONClusterSource::EventData)
 
 
-ClusterSource::ClusterSource()
-       : TObject(), fEventList(ClusterSource::EventData::Class())
+AliHLTMUONClusterSource::AliHLTMUONClusterSource()
+       : TObject(), fEventList(AliHLTMUONClusterSource::EventData::Class())
 {
        fAreaToUse = FromWholePlane;
        fDataToUse = FromRawClusters;
@@ -37,8 +34,8 @@ ClusterSource::ClusterSource()
 }
 
 
-ClusterSource::ClusterSource(AliMUONDataInterface* data)
-       : TObject(), fEventList(ClusterSource::EventData::Class())
+AliHLTMUONClusterSource::AliHLTMUONClusterSource(AliMUONDataInterface* data)
+       : TObject(), fEventList(AliHLTMUONClusterSource::EventData::Class())
 {
        fAreaToUse = FromWholePlane;
        fDataToUse = FromRawClusters;
@@ -50,13 +47,13 @@ ClusterSource::ClusterSource(AliMUONDataInterface* data)
 }
 
 
-ClusterSource::~ClusterSource()
+AliHLTMUONClusterSource::~AliHLTMUONClusterSource()
 {
        fEventList.Clear("C");
 }
 
 
-void ClusterSource::FillFrom(AliMUONDataInterface* data)
+void AliHLTMUONClusterSource::FillFrom(AliMUONDataInterface* data)
 {
        DebugMsg(1, "FillFrom(AliMUONDataInterface*)");
        
@@ -70,7 +67,7 @@ void ClusterSource::FillFrom(AliMUONDataInterface* data)
 }
 
 
-void ClusterSource::FillFrom(AliMUONDataInterface* data, Int_t event)
+void AliHLTMUONClusterSource::FillFrom(AliMUONDataInterface* data, Int_t event)
 {
        DebugMsg(1, "FillFrom(AliMUONDataInterface*, Int_t)");
        
@@ -79,7 +76,7 @@ void ClusterSource::FillFrom(AliMUONDataInterface* data, Int_t event)
 }
 
 
-void ClusterSource::FillFrom(AliMUONDataInterface* data, Int_t event, Int_t chamber)
+void AliHLTMUONClusterSource::FillFrom(AliMUONDataInterface* data, Int_t event, Int_t chamber)
 {
        DebugMsg(1, "FillFrom(AliMUONDataInterface*, Int_t)");
        
@@ -94,7 +91,7 @@ void ClusterSource::FillFrom(AliMUONDataInterface* data, Int_t event, Int_t cham
 }
 
 
-void ClusterSource::FillFrom(
+void AliHLTMUONClusterSource::FillFrom(
                AliMUONDataInterface* data,
                Int_t event, Int_t chamber, Int_t cluster,
                Bool_t newblock
@@ -147,7 +144,7 @@ void ClusterSource::FillFrom(
 }
 
 
-void ClusterSource::Clear(Option_t* /*option*/)
+void AliHLTMUONClusterSource::Clear(Option_t* /*option*/)
 {
        fFilename = "";
        fFoldername = "";
@@ -156,9 +153,9 @@ void ClusterSource::Clear(Option_t* /*option*/)
 }
 
 
-Bool_t ClusterSource::GetEvent(Int_t eventnumber) const
+Bool_t AliHLTMUONClusterSource::GetEvent(Int_t eventnumber) const
 {
-       DebugMsg(1, "ClusterSource::GetEvent(" << eventnumber << ")" );
+       DebugMsg(1, "AliHLTMUONClusterSource::GetEvent(" << eventnumber << ")" );
        
        // Try find the corresponding event in the list of events.
        for (Int_t i = 0; i < fEventList.GetEntriesFast(); i++)
@@ -179,9 +176,9 @@ Bool_t ClusterSource::GetEvent(Int_t eventnumber) const
 }
 
 
-Bool_t ClusterSource::GetFirstEvent() const
+Bool_t AliHLTMUONClusterSource::GetFirstEvent() const
 {
-       DebugMsg(1, "ClusterSource::GetFirstEvent()");
+       DebugMsg(1, "AliHLTMUONClusterSource::GetFirstEvent()");
        if (fEventList.GetEntriesFast() > 0)
        {
                fEventIndex = 0;
@@ -202,15 +199,15 @@ Bool_t ClusterSource::GetFirstEvent() const
 }
 
 
-Bool_t ClusterSource::MoreEvents() const
+Bool_t AliHLTMUONClusterSource::MoreEvents() const
 {
        return 0 <= fEventIndex && fEventIndex < fEventList.GetEntriesFast();
 }
 
 
-Bool_t ClusterSource::GetNextEvent() const
+Bool_t AliHLTMUONClusterSource::GetNextEvent() const
 {
-       DebugMsg(1, "ClusterSource::GetNextEvent()");
+       DebugMsg(1, "AliHLTMUONClusterSource::GetNextEvent()");
        if (fEventIndex < fEventList.GetEntriesFast() - 1)
        {
                fCurrentEvent = (EventData*) fEventList[ ++fEventIndex ];
@@ -228,7 +225,7 @@ Bool_t ClusterSource::GetNextEvent() const
 }
 
 
-Int_t ClusterSource::CurrentEvent() const
+Int_t AliHLTMUONClusterSource::CurrentEvent() const
 {
        if (fCurrentEvent != NULL)
                return fCurrentEvent->fEventNumber;
@@ -237,9 +234,9 @@ Int_t ClusterSource::CurrentEvent() const
 }
 
 
-Int_t ClusterSource::NumberOfBlocks() const
+Int_t AliHLTMUONClusterSource::NumberOfBlocks() const
 {
-       DebugMsg(1, "ClusterSource::NumberOfBlocks()");
+       DebugMsg(1, "AliHLTMUONClusterSource::NumberOfBlocks()");
        if (fCurrentEvent == NULL)
        {
                Error("NumberOfBlocks", "No event selected.");
@@ -250,9 +247,9 @@ Int_t ClusterSource::NumberOfBlocks() const
 }
 
 
-Bool_t ClusterSource::GetBlock(Int_t index) const
+Bool_t AliHLTMUONClusterSource::GetBlock(Int_t index) const
 {
-       DebugMsg(1, "ClusterSource::GetBlock(" << index << ")");
+       DebugMsg(1, "AliHLTMUONClusterSource::GetBlock(" << index << ")");
        
        // Note NumberOfBlocks() also checks if the event was selected.
        Int_t numberofblocks = NumberOfBlocks();
@@ -286,9 +283,9 @@ Bool_t ClusterSource::GetBlock(Int_t index) const
 }
 
 
-Bool_t ClusterSource::GetFirstBlock() const
+Bool_t AliHLTMUONClusterSource::GetFirstBlock() const
 {
-       DebugMsg(1, "ClusterSource::GetFirstBlock()");
+       DebugMsg(1, "AliHLTMUONClusterSource::GetFirstBlock()");
        // Note: NumberOfBlocks() also checks if fCurrentEvent != NULL.
        if (NumberOfBlocks() > 0)
        {
@@ -305,15 +302,15 @@ Bool_t ClusterSource::GetFirstBlock() const
 }
 
 
-Bool_t ClusterSource::MoreBlocks() const
+Bool_t AliHLTMUONClusterSource::MoreBlocks() const
 {
        return 0 <= fBlockIndex && fBlockIndex < NumberOfBlocks();
 }
 
 
-Bool_t ClusterSource::GetNextBlock() const
+Bool_t AliHLTMUONClusterSource::GetNextBlock() const
 {
-       DebugMsg(1, "ClusterSource::GetNextBlock()");
+       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.
@@ -334,7 +331,7 @@ Bool_t ClusterSource::GetNextBlock() const
 }
 
 
-Int_t ClusterSource::Chamber() const
+Int_t AliHLTMUONClusterSource::Chamber() const
 {
        if (fCurrentBlock == NULL)
        {
@@ -346,9 +343,9 @@ Int_t ClusterSource::Chamber() const
 }
 
 
-Int_t ClusterSource::NumberOfClusters() const
+Int_t AliHLTMUONClusterSource::NumberOfClusters() const
 {
-       DebugMsg(1, "ClusterSource::NumberOfClusters()");
+       DebugMsg(1, "AliHLTMUONClusterSource::NumberOfClusters()");
        if (fCurrentBlock == NULL)
        {
                Error("NumberOfClusters", "No block selected.");
@@ -359,9 +356,9 @@ Int_t ClusterSource::NumberOfClusters() const
 }
 
 
-const Point* ClusterSource::GetCluster(Int_t index) const
+const AliHLTMUONPoint* AliHLTMUONClusterSource::GetCluster(Int_t index) const
 {
-       DebugMsg(1, "ClusterSource::GetCluster(" << index << ")");
+       DebugMsg(1, "AliHLTMUONClusterSource::GetCluster(" << index << ")");
 
        // Note NumberOfClusters() also checks if the event and block was selected.
        Int_t numberofclusters = NumberOfClusters();
@@ -370,7 +367,7 @@ const Point* ClusterSource::GetCluster(Int_t index) const
        if ( 0 <= index && index < numberofclusters )
        {
                fClusterIndex = index;
-               fCurrentCluster = (Point*) fCurrentBlock->fClusters[index];
+               fCurrentCluster = (AliHLTMUONPoint*) fCurrentBlock->fClusters[index];
                DebugMsg(2, "\tfEventIndex = " << fEventIndex << " , fBlockIndex = " << fBlockIndex
                        << " , fClusterIndex = " << fClusterIndex
                );
@@ -394,14 +391,14 @@ const Point* ClusterSource::GetCluster(Int_t index) const
 }
 
 
-const Point* ClusterSource::GetFirstCluster() const
+const AliHLTMUONPoint* AliHLTMUONClusterSource::GetFirstCluster() const
 {
-       DebugMsg(1, "ClusterSource::GetFirstCluster()");
+       DebugMsg(1, "AliHLTMUONClusterSource::GetFirstCluster()");
        // Note: NumberOfClusters() also checks if fCurrentBlock != NULL.
        if (NumberOfClusters() > 0)
        {
                fClusterIndex = 0;
-               fCurrentCluster = (Point*) fCurrentBlock->fClusters[0];
+               fCurrentCluster = (AliHLTMUONPoint*) fCurrentBlock->fClusters[0];
                DebugMsg(2, "\tfEventIndex = " << fEventIndex << " , fBlockIndex = " << fBlockIndex
                        << " , fClusterIndex = " << fClusterIndex
                );
@@ -412,21 +409,21 @@ const Point* ClusterSource::GetFirstCluster() const
 }
 
 
-Bool_t ClusterSource::MoreClusters() const
+Bool_t AliHLTMUONClusterSource::MoreClusters() const
 {
        return 0 <= fClusterIndex && fClusterIndex < NumberOfClusters();
 }
 
 
-const Point* ClusterSource::GetNextCluster() const
+const AliHLTMUONPoint* AliHLTMUONClusterSource::GetNextCluster() const
 {
-       DebugMsg(1, "ClusterSource::GetNextCluster()");
+       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 = (Point*) fCurrentBlock->fClusters[ ++fClusterIndex ];
+               fCurrentCluster = (AliHLTMUONPoint*) fCurrentBlock->fClusters[ ++fClusterIndex ];
                DebugMsg(2, "\tfEventIndex = " << fEventIndex << " , fBlockIndex = " << fBlockIndex
                        << " , fClusterIndex = " << fClusterIndex
                );
@@ -440,7 +437,7 @@ const Point* ClusterSource::GetNextCluster() const
 }
 
 
-Bool_t ClusterSource::FetchCluster(Float_t& x, Float_t& y) const
+Bool_t AliHLTMUONClusterSource::FetchCluster(Float_t& x, Float_t& y) const
 {
        if (fCurrentCluster != NULL)
        {
@@ -456,9 +453,9 @@ Bool_t ClusterSource::FetchCluster(Float_t& x, Float_t& y) const
 }
 
 
-void ClusterSource::AddEvent(Int_t eventnumber)
+void AliHLTMUONClusterSource::AddEvent(Int_t eventnumber)
 {
-       DebugMsg(1, "ClusterSource::AddEvent(" << eventnumber << ")");
+       DebugMsg(1, "AliHLTMUONClusterSource::AddEvent(" << eventnumber << ")");
        Assert( eventnumber >= 0 );
 
        // Assume the eventnumber does not already exist in the event list.
@@ -475,9 +472,9 @@ void ClusterSource::AddEvent(Int_t eventnumber)
 }
 
 
-void ClusterSource::AddBlock(Int_t chamber)
+void AliHLTMUONClusterSource::AddBlock(Int_t chamber)
 {
-       DebugMsg(1, "ClusterSource::AddBlock()");
+       DebugMsg(1, "AliHLTMUONClusterSource::AddBlock()");
        
        if (fCurrentEvent == NULL)
        {
@@ -498,9 +495,9 @@ void ClusterSource::AddBlock(Int_t chamber)
 }
 
 
-void ClusterSource::AddPoint(Float_t x, Float_t y)
+void AliHLTMUONClusterSource::AddPoint(Float_t x, Float_t y)
 {
-       DebugMsg(1, "ClusterSource::AddPoint(" << x << ", " << y << ")");
+       DebugMsg(1, "AliHLTMUONClusterSource::AddPoint(" << x << ", " << y << ")");
 
        if (fCurrentBlock == NULL)
        {
@@ -509,8 +506,8 @@ void ClusterSource::AddPoint(Float_t x, Float_t y)
        }
        
        fClusterIndex = fCurrentBlock->fClusters.GetEntriesFast();
-       new ( fCurrentBlock->fClusters[fClusterIndex] ) Point(x, y);
-       fCurrentCluster = (Point*) fCurrentBlock->fClusters[fClusterIndex];
+       new ( fCurrentBlock->fClusters[fClusterIndex] ) AliHLTMUONPoint(x, y);
+       fCurrentCluster = (AliHLTMUONPoint*) fCurrentBlock->fClusters[fClusterIndex];
        
        DebugMsg(2, "\tfEventIndex = " << fEventIndex << " , fBlockIndex = " << fBlockIndex
                << " , fClusterIndex = " << fClusterIndex
@@ -518,7 +515,7 @@ void ClusterSource::AddPoint(Float_t x, Float_t y)
 }
 
 
-Bool_t ClusterSource::FileAndFolderOk(AliMUONDataInterface* data)
+Bool_t AliHLTMUONClusterSource::FileAndFolderOk(AliMUONDataInterface* data)
 {
        if (fFilename == "")
        {
@@ -550,7 +547,7 @@ Bool_t ClusterSource::FileAndFolderOk(AliMUONDataInterface* data)
 }
 
 
-void ClusterSource::AddEventFrom(AliMUONDataInterface* data, Int_t event)
+void AliHLTMUONClusterSource::AddEventFrom(AliMUONDataInterface* data, Int_t event)
 {
        if ( data->GetEvent(event) )
        {
@@ -563,7 +560,7 @@ void ClusterSource::AddEventFrom(AliMUONDataInterface* data, Int_t event)
 }
 
 
-void ClusterSource::AddChamberFrom(AliMUONDataInterface* data, Int_t chamber)
+void AliHLTMUONClusterSource::AddChamberFrom(AliMUONDataInterface* data, Int_t chamber)
 {
        DebugMsg(1, "Entering AddChamberFrom");
        
@@ -651,7 +648,7 @@ void ClusterSource::AddChamberFrom(AliMUONDataInterface* data, Int_t chamber)
 }
 
 
-void ClusterSource::AddClusterFrom(
+void AliHLTMUONClusterSource::AddClusterFrom(
                AliMUONDataInterface* data, Int_t chamber, Int_t cluster
        )
 {
@@ -715,7 +712,7 @@ void ClusterSource::AddClusterFrom(
 }
 
 
-Bool_t ClusterSource::InFillRegion(Float_t x, Float_t /*y*/)
+Bool_t AliHLTMUONClusterSource::InFillRegion(Float_t x, Float_t /*y*/)
 {
        switch (fAreaToUse)
        {
@@ -730,7 +727,7 @@ Bool_t ClusterSource::InFillRegion(Float_t x, Float_t /*y*/)
 }
 
 
-void ClusterSource::ResetAllPointers() const
+void AliHLTMUONClusterSource::ResetAllPointers() const
 {
        fEventIndex = -1;
        fCurrentEvent = NULL;
@@ -744,7 +741,7 @@ void ClusterSource::ResetAllPointers() const
 }
 
 
-void ClusterSource::ResetBlockPointers() const
+void AliHLTMUONClusterSource::ResetBlockPointers() const
 {
        fBlockIndex = -1;
        fCurrentBlock = NULL;
@@ -756,7 +753,7 @@ void ClusterSource::ResetBlockPointers() const
 }
 
 
-void ClusterSource::ResetClusterPointers() const
+void AliHLTMUONClusterSource::ResetClusterPointers() const
 {
        fClusterIndex = -1;
        fCurrentCluster = NULL;
@@ -766,28 +763,28 @@ void ClusterSource::ResetClusterPointers() const
 }
 
 
-ClusterSource::BlockData::BlockData() : fClusters(Point::Class())
+AliHLTMUONClusterSource::BlockData::BlockData() : fClusters(AliHLTMUONPoint::Class())
 {
        fChamber = -1;
 }
 
-ClusterSource::BlockData::BlockData(Int_t chamber) : fClusters(Point::Class())
+AliHLTMUONClusterSource::BlockData::BlockData(Int_t chamber) : fClusters(AliHLTMUONPoint::Class())
 {
        fChamber = chamber;
 }
 
-ClusterSource::BlockData::~BlockData()
+AliHLTMUONClusterSource::BlockData::~BlockData()
 {
        fClusters.Clear("C");
 }
 
-ClusterSource::EventData::EventData() : fBlocks(ClusterSource::BlockData::Class())
+AliHLTMUONClusterSource::EventData::EventData() : fBlocks(AliHLTMUONClusterSource::BlockData::Class())
 {
        fEventNumber = -1;
 }
 
-ClusterSource::EventData::EventData(Int_t eventnumber)
-       : fBlocks(ClusterSource::BlockData::Class())
+AliHLTMUONClusterSource::EventData::EventData(Int_t eventnumber)
+       : fBlocks(AliHLTMUONClusterSource::BlockData::Class())
 {
        fEventNumber = eventnumber;
 
@@ -795,10 +792,8 @@ ClusterSource::EventData::EventData(Int_t eventnumber)
        fBlocks.BypassStreamer(kFALSE);
 }
 
-ClusterSource::EventData::~EventData()
+AliHLTMUONClusterSource::EventData::~EventData()
 {
        fBlocks.Clear("C");
 }
 
-
-} // AliMUONHLT
index 25540e3ff712cb1ac95c45cb110af51508763214..5ea99cf5bd27123e63cb65ae2c8f906afa77179c 100644 (file)
@@ -5,8 +5,8 @@
 //
 ////////////////////////////////////////////////////////////////////////////////
 
-#ifndef dHLT_ALIROOT_CLUSTER_SOURCE_HPP
-#define dHLT_ALIROOT_CLUSTER_SOURCE_HPP
+#ifndef ALIHLTMUONCLUSTERSOURCE_H
+#define ALIHLTMUONCLUSTERSOURCE_H
 
 #include "TROOT.h"
 #include "TObject.h"
 
 class AliMUONDataInterface;
 
-namespace AliMUONHLT
-{
-
 
-class ClusterSource : public TObject
+class AliHLTMUONClusterSource : public TObject
 {
 public:
 
@@ -37,10 +34,10 @@ public:
                FromRawClusters
        };
 
-       ClusterSource();
-       ClusterSource(AliMUONDataInterface* data);
+       AliHLTMUONClusterSource();
+       AliHLTMUONClusterSource(AliMUONDataInterface* data);
        
-       virtual ~ClusterSource();
+       virtual ~AliHLTMUONClusterSource();
        
        /* Get and set methods to specify how the FillFrom methods should fill the
           internal data structures.
@@ -95,7 +92,7 @@ public:
         */
        Int_t NumberOfEvents() const { return fEventList.GetEntriesFast(); };
        
-       /* Fetches the specified event number stored in this ClusterSource.
+       /* 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.
@@ -103,7 +100,7 @@ public:
         */
        Bool_t GetEvent(Int_t eventnumber) const;
        
-       /* Fetches the first event stored in this ClusterSource.
+       /* 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.
@@ -171,12 +168,12 @@ public:
        /* Fetches the index'th cluster point in the current block.
           kTRUE is returned if the point was found, kFALSE otherwise.
         */
-       const Point* GetCluster(Int_t index) const;
+       const AliHLTMUONPoint* GetCluster(Int_t index) const;
        
        /* Fetches the first cluster point in the current block.
           NULL is returned if the point was not found.
         */
-       const Point* GetFirstCluster() const;
+       const AliHLTMUONPoint* GetFirstCluster() const;
        
        /* Returns kTRUE if there are more cluster points to interate over.
         */
@@ -185,7 +182,7 @@ public:
        /* Fetches the next cluster point in the current block.
           NULL is returned if the point was not found.
         */
-       const Point* GetNextCluster() const;
+       const AliHLTMUONPoint* GetNextCluster() const;
        
        /* Returns the x and y coordinate of the current cluster point.
           kFALSE is returned if there is no cluster point selected.
@@ -195,7 +192,7 @@ public:
        /* Returns the current cluster point.
           NULL is returned if no cluster point is selected.
         */
-       const Point* GetCluster() const { return fCurrentCluster; };
+       const AliHLTMUONPoint* GetCluster() const { return fCurrentCluster; };
 
 private:
 
@@ -214,7 +211,7 @@ private:
         */
        void AddPoint(Float_t x, Float_t y);
        
-       /* Checks if the file and folder names correspond to this ClusterSource's 
+       /* 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.
@@ -301,14 +298,12 @@ private:
        mutable Int_t fBlockIndex;             //! The index number of the currently selected block.
        mutable BlockData* fCurrentBlock;      //! Pointer to the currently selected block.
        mutable Int_t fClusterIndex;           //! The index number of the currently selected cluster point.
-       mutable Point* fCurrentCluster;        //! Pointer to the currently selected cluster point.
+       mutable AliHLTMUONPoint* fCurrentCluster;        //! Pointer to the currently selected cluster point.
 
        TClonesArray fEventList;  // List of clusters per event.
 
-       ClassDef(ClusterSource, 1)  // The source of cluster point blocks for dHLT.
+       ClassDef(AliHLTMUONClusterSource, 1)  // The source of cluster point blocks for dHLT.
 };
 
 
-} // AliMUONHLT
-
-#endif // dHLT_ALIROOT_CLUSTER_SOURCE_HPP
+#endif // ALIHLTMUONCLUSTERSOURCE_H
index 230946ed1c72632979903a3c0b09530017cc1cd6..e8983734013150cf2f3e08a9ec3bfed89ee50bb2 100644 (file)
 #pragma link off all functions;
 #pragma link off all typedefs;
 
-#pragma link C++ nestedclass;    // Makes the namespaces work properly.
-#pragma link C++ nestedtypedef;  // Makes the namespaces work properly.
-#pragma link C++ nestedfunction; // Makes the namespaces work properly.
+#pragma link C++ nestedclass;
+#pragma link C++ nestedtypedef;
+#pragma link C++ nestedfunction;
 
-#pragma link C++ namespace AliMUONHLT;
+#pragma link C++ function AliHLTMUONVersion;
+#pragma link C++ function AliHLTMUONMajorVersion;
+#pragma link C++ function AliHLTMUONMinorVersion;
+#pragma link C++ function AliHLTMUONBuildNumber;
 
-#pragma link C++ function AliMUONHLT::Version;
-#pragma link C++ function AliMUONHLT::MajorVersion;
-#pragma link C++ function AliMUONHLT::MinorVersion;
-#pragma link C++ function AliMUONHLT::BuildNumber;
+#pragma link C++ class AliHLTMUONRegion+;
+#pragma link C++ class AliHLTMUONPoint+;
+#pragma link C++ class AliHLTMUONTriggerRecord+;
+#pragma link C++ class AliHLTMUONADCStream+;
+#pragma link C++ class AliHLTMUONTrack+;
 
-#pragma link C++ class AliMUONHLT::Region+;
-#pragma link C++ class AliMUONHLT::Point+;
-#pragma link C++ class AliMUONHLT::TriggerRecord+;
-#pragma link C++ class AliMUONHLT::ADCStream+;
-#pragma link C++ class AliMUONHLT::Track+;
+#pragma link C++ class AliHLTMUONMicrodHLT+;
 
-#pragma link C++ class AliMUONHLT::MicrodHLT+;
+#pragma link C++ class AliHLTMUONADCStreamSource+;
+#pragma link C++ struct AliHLTMUONADCStreamSource::DataBlock+;
 
-#pragma link C++ class AliMUONHLT::ADCStreamSource+;
-#pragma link C++ struct AliMUONHLT::ADCStreamSource::DataBlock+;
+#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 AliMUONHLT::TriggerSource+;
-#pragma link C++ enum AliMUONHLT::TriggerSource::AreaType+;
-#pragma link C++ enum AliMUONHLT::TriggerSource::SourceType+;
-#pragma link C++ class AliMUONHLT::TriggerSource::EventData+;
+#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 AliMUONHLT::ClusterSource+;
-#pragma link C++ enum AliMUONHLT::ClusterSource::AreaType+;
-#pragma link C++ enum AliMUONHLT::ClusterSource::SourceType+;
-#pragma link C++ class AliMUONHLT::ClusterSource::BlockData+;
-#pragma link C++ class AliMUONHLT::ClusterSource::EventData+;
+#pragma link C++ class AliHLTMUONTrackSink+;
+#pragma link C++ class AliHLTMUONTrackSink::EventData+;
 
-#pragma link C++ class AliMUONHLT::TrackSink+;
-#pragma link C++ class AliMUONHLT::TrackSink::EventData+;
+#pragma link C++ class AliHLTMUONTrackerInterface+;
+#pragma link C++ class AliHLTMUONTrackerCallback+;
 
-#pragma link C++ class AliMUONHLT::TrackerInterface+;
-#pragma link C++ class AliMUONHLT::TrackerCallback+;
-
-#pragma link C++ class AliMUONHLT::ClusterFinderInterface+;
-#pragma link C++ class AliMUONHLT::ClusterFinderCallback+;
+#pragma link C++ class AliHLTMUONClusterFinderInterface+;
+#pragma link C++ class AliHLTMUONClusterFinderCallback+;
 
 #pragma link C++ class AliHLTMUONTracker+;
 
index 21ee06e8c1100b5921d50c9496cc0e7b4ac288fb..1af2ae4adb12a1fef158b9737a31d8a682c3a97c 100644 (file)
 #include "new.hpp"
 
 
-namespace dHLT
+namespace  // MicroFramework should be hidden.
 {
 
-using namespace dHLT::AliRoot;
 
-
-class MicroFramework : public Tracking::TrackerCallback
+class MicroFramework : public AliHLTMUONCoreTrackerCallback
 {
 public:
 
        virtual ~MicroFramework() {}
 
        virtual void RequestClusters(
-                       Tracking::Tracker* tracker, 
+                       AliHLTMUONCoreTracker* tracker,
                        Float /*left*/, Float /*right*/, Float /*bottom*/, Float /*top*/,
-                       ChamberID chamber, const void* tag
+                       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 (clusters[chamber] != NULL)
-                       tracker->ReturnClusters(ctag, clusters[chamber], clustercount[chamber]);
+               if (fClusters[chamber] != NULL)
+                       tracker->ReturnClusters(ctag, fClusters[chamber], fClusterCount[chamber]);
                tracker->EndOfClusters(ctag);
        }
 
-       
-  virtual void EndOfClusterRequests(Tracking::Tracker* /*tracker*/)
+       virtual void EndOfClusterRequests(AliHLTMUONCoreTracker* /*tracker*/)
        {
                DebugMsg(2, "EndOfClusterRequests");
                // We can ignore this. Nothing special to do here.
        }
 
        
-       virtual void FoundTrack(Tracking::Tracker* tracker)
+       virtual void FoundTrack(AliHLTMUONCoreTracker* tracker)
        {
                DebugMsg(2, "FoundTrack");
                
                // Fetch the track data from the tracker.
-               dHLT::Track newtrack;
+               AliHLTMUONCoreTrack newtrack;
                tracker->FillTrackData(newtrack);
                
                // Don't forget to fill the trigger ID number, this is not done by the tracker.
-               newtrack.triggerid = currenttriggernumber;
+               newtrack.fTriggerid = fCurrentTriggerNumber;
 
-               *trackoutput->AddTrack() = Convert(newtrack);
+               *fTrackOutput->AddTrack() = AliHLTMUONConvert(newtrack);
        }
        
        
-       virtual void NoTrackFound(Tracking::Tracker* /*tracker*/)
+       virtual void NoTrackFound(AliHLTMUONCoreTracker* /*tracker*/)
        {
                DebugMsg(2, "NoTrackFound");
                // Again nothing special to do here. The allocated memory is released
@@ -81,10 +78,10 @@ public:
 
 
        void Run(
-                       const AliMUONHLT::TriggerSource* triggersource,
-                       const AliMUONHLT::ClusterSource* clustersource,
-                       AliMUONHLT::TrackSink* tracksink,
-                       Tracking::Tracker* tracker
+                       const AliHLTMUONTriggerSource* triggersource,
+                       const AliHLTMUONClusterSource* clustersource,
+                       AliHLTMUONTrackSink* tracksink,
+                       AliHLTMUONCoreTracker* tracker
                )
        {
                if ( ! triggersource->GetFirstEvent()) return;
@@ -97,22 +94,22 @@ public:
 
 
        void Run(
-                       const AliMUONHLT::TriggerSource* triggersource,
-                       const AliMUONHLT::ClusterSource* clustersource,
-                       AliMUONHLT::TrackSink* tracksink,
-                       Tracking::Tracker* tracker, const Int eventnumber
+                       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);
-               trackoutput = tracksink;
-               trackoutput->SetNames(triggersource);  // Want the file and folder names to correspond.
+               fTrackOutput = tracksink;
+               fTrackOutput->SetNames(triggersource);  // Want the file and folder names to correspond.
                
                CreateClusterBlocks(clustersource, eventnumber);
                try
                {
-                       trackoutput->AddEvent(eventnumber);
-                       trackoutput->AddBlock();
+                       fTrackOutput->AddEvent(eventnumber);
+                       fTrackOutput->AddBlock();
                        ProcessTriggers(triggersource, tracker);
                }
                finally
@@ -124,10 +121,10 @@ public:
 
 private:
 
-       void CountClusterPoints(const AliMUONHLT::ClusterSource* cs)
+       void CountClusterPoints(const AliHLTMUONClusterSource* cs)
        {
                for (Int i = 0; i < 10; i++)
-                       clustercount[i] = 0;
+                       fClusterCount[i] = 0;
 
                cs->GetFirstBlock();
                while (cs->MoreBlocks())
@@ -135,14 +132,14 @@ private:
                        Int chamber = cs->Chamber();
                        if (0 <= chamber && chamber < 10)
                        {
-                               clustercount[chamber] += cs->NumberOfClusters();
+                               fClusterCount[chamber] += cs->NumberOfClusters();
                        }
                        cs->GetNextBlock();
                }
        }
        
 
-       void CreateClusterBlocks(const AliMUONHLT::ClusterSource* cs, Int eventnumber)
+       void CreateClusterBlocks(const AliHLTMUONClusterSource* cs, Int eventnumber)
        {
                // Must select the proper event before counting or filling the arrays.
                if ( ! cs->GetEvent(eventnumber) ) return;
@@ -156,10 +153,10 @@ private:
                        currentcount[i] = 0;
 
                        // Allocate arrays.
-                       if (clustercount[i] > 0)
-                               clusters[i] = new ClusterPoint[ clustercount[i] ];
+                       if (fClusterCount[i] > 0)
+                               fClusters[i] = new AliHLTMUONCoreClusterPoint[ fClusterCount[i] ];
                        else
-                               clusters[i] = NULL;
+                               fClusters[i] = NULL;
                }
 
                // Copy all the cluster data into arrays.
@@ -172,9 +169,9 @@ private:
                                cs->GetFirstCluster();
                                while (cs->MoreClusters())
                                {
-                                       ClusterPoint newpoint;
-                                       cs->FetchCluster(newpoint.x, newpoint.y);
-                                       clusters[chamber][currentcount[chamber]++] = newpoint;
+                                       AliHLTMUONCoreClusterPoint newpoint;
+                                       cs->FetchCluster(newpoint.fX, newpoint.fY);
+                                       fClusters[chamber][currentcount[chamber]++] = newpoint;
                                        cs->GetNextCluster();
                                }
                        }
@@ -187,13 +184,13 @@ private:
        {
                for (Int i = 0; i < 10; i++)
                {
-                       if (clusters[i] != NULL)
-                               delete [] clusters[i];
+                       if (fClusters[i] != NULL)
+                               delete [] fClusters[i];
                }
        }
        
        
-       void ProcessTriggers(const AliMUONHLT::TriggerSource* ts, Tracking::Tracker* tracker)
+       void ProcessTriggers(const AliHLTMUONTriggerSource* ts, AliHLTMUONCoreTracker* tracker)
        {
                // The proper event must be selected before calling this method.
        
@@ -203,11 +200,11 @@ private:
                        ts->GetFirstTrigger();
                        while (ts->MoreTriggers())
                        {
-                               const AliMUONHLT::TriggerRecord* trigdata = ts->GetTrigger();
+                               const AliHLTMUONTriggerRecord* trigdata = ts->GetTrigger();
                                Assert( trigdata != NULL );
-                               currenttriggernumber = (UInt)trigdata->TriggerNumber();
+                               fCurrentTriggerNumber = (UInt)trigdata->TriggerNumber();
 
-                               TriggerRecord trigger = Convert(*trigdata);
+                               AliHLTMUONCoreTriggerRecord trigger = AliHLTMUONConvert(*trigdata);
 
                                DebugMsg(2, "Finding track:");
                                tracker->FindTrack(trigger);
@@ -222,49 +219,46 @@ private:
        }
        
        
-       UInt clustercount[10];
-       ClusterPoint* clusters[10];
+       UInt fClusterCount[10];
+       AliHLTMUONCoreClusterPoint* fClusters[10];
        
-       AliMUONHLT::TrackSink* trackoutput;  // The current track output object.
-       UInt currenttriggernumber;   // The current trigger, trigger number to use.
+       AliHLTMUONTrackSink* fTrackOutput;  // The current track output object.
+       UInt fCurrentTriggerNumber;   // The current trigger, trigger number to use.
 };
 
 
-} // dHLT
+} // end of namespace
 
 
 ////////////////////////////////////////////////////////////////////////////////
 
 
-ClassImp(AliMUONHLT::MicrodHLT)
-
-namespace AliMUONHLT
-{
+ClassImp(AliHLTMUONMicrodHLT)
 
 
-TString Version()
+TString AliHLTMUONVersion()
 {
        TString str = dHLT::VersionString();
        return str;
 }
 
-UInt_t MajorVersion()
+UInt_t AliHLTMUONMajorVersion()
 {
        return dHLT::MajorVersion();
 }
 
-UInt_t MinorVersion()
+UInt_t AliHLTMUONMinorVersion()
 {
        return dHLT::MinorVersion();
 }
 
-UInt_t BuildNumber()
+UInt_t AliHLTMUONBuildNumber()
 {
        return dHLT::BuildNumber();
 }
 
 
-MicrodHLT::MicrodHLT() : TObject()
+AliHLTMUONMicrodHLT::AliHLTMUONMicrodHLT() : TObject()
 {
        fTriggerSource = NULL;
        fClusterSource = NULL;
@@ -274,30 +268,30 @@ MicrodHLT::MicrodHLT() : TObject()
 }
 
 
-MicrodHLT::~MicrodHLT()
+AliHLTMUONMicrodHLT::~AliHLTMUONMicrodHLT()
 {
        // Nothing to do here.
 }
 
 
-void MicrodHLT::SetTriggerSource(const TriggerSource* source)
+void AliHLTMUONMicrodHLT::SetTriggerSource(const AliHLTMUONTriggerSource* source)
 {
-       fTriggerSource = const_cast<TriggerSource*>( source );
+       fTriggerSource = const_cast<AliHLTMUONTriggerSource*>( source );
 }
 
-void MicrodHLT::SetClusterSource(const ClusterSource* source)
+void AliHLTMUONMicrodHLT::SetClusterSource(const AliHLTMUONClusterSource* source)
 {
-       fClusterSource = const_cast<ClusterSource*>( source );
+       fClusterSource = const_cast<AliHLTMUONClusterSource*>( source );
 }
 
 
-void MicrodHLT::Run()
+void AliHLTMUONMicrodHLT::Run()
 {
        DebugMsg(1, "Run");
 
-       //dHLT::Clustering::ClusterFinder* clusterfinder;
+       //AliHLTMUONCoreClusterFinder* clusterfinder;
        //dHLT::Decision::DecisionMaker* decisionmaker;
-       //dHLT::Tracking::Tracker* tracker;
+       //AliHLTMUONCoreTracker* tracker;
        
        if (fTriggerSource == NULL)
        {
@@ -321,20 +315,20 @@ void MicrodHLT::Run()
                Warning("Run", "The file and folder names of the trigger source and cluster source do not correspond.");
        }
 
-       dHLT::Clustering::ClusterFinder* clusterfinder = NULL;
-       dHLT::Tracking::Tracker* tracker = NULL;
+       AliHLTMUONCoreClusterFinder* clusterfinder = NULL;
+       AliHLTMUONCoreTracker* tracker = NULL;
        try
        {
                // Assign the dHLT cluster finder object. If the fClusterFinder field is
                // not set then use the default CenterOfGravityFinder.
                if (fClusterFinder == NULL)
                {
-                       clusterfinder = new dHLT::Clustering::CenterOfGravityFinder();
+                       clusterfinder = new AliHLTMUONCoreCenterOfGravityFinder();
                }
                else
                {
-                       dHLT::AliRoot::ClusterFinderProxy* clusterfinderproxy
-                               = new dHLT::AliRoot::ClusterFinderProxy(fClusterFinder);
+                       AliHLTMUONClusterFinderProxy* clusterfinderproxy
+                               = new AliHLTMUONClusterFinderProxy(fClusterFinder);
                        fClusterFinder->SetCallback(clusterfinderproxy);
                        clusterfinder = clusterfinderproxy;
                }
@@ -343,16 +337,16 @@ void MicrodHLT::Run()
                // use the default MansoTracker implementation.
                if (fTracker == NULL)
                {
-                       tracker = new dHLT::Tracking::MansoTracker();
+                       tracker = new AliHLTMUONCoreMansoTracker();
                }
                else
                {
-                       dHLT::AliRoot::TrackerProxy* trackerproxy = new dHLT::AliRoot::TrackerProxy(fTracker);
+                       AliHLTMUONTrackerProxy* trackerproxy = new AliHLTMUONTrackerProxy(fTracker);
                        fTracker->SetCallback(trackerproxy);
                        tracker = trackerproxy;
                }
 
-               dHLT::MicroFramework framework;
+               MicroFramework framework;
                framework.Run(fTriggerSource, fClusterSource, fTrackSink, tracker);
        }
        finally
@@ -364,23 +358,20 @@ void MicrodHLT::Run()
 
 
 #ifdef DEBUG
-void MicrodHLT::DebugLevel(Int_t value)
+void AliHLTMUONMicrodHLT::DebugLevel(Int_t value)
 {
-       dHLT::DebugLevel = value;
+       gAliHLTMUONDebugLevel = value;
 }
 #else // DEBUG
-void MicrodHLT::DebugLevel(Int_t /*value*/) {}
+void AliHLTMUONMicrodHLT::DebugLevel(Int_t /*value*/) {}
 #endif // DEBUG
 
 
-Int_t MicrodHLT::DebugLevel()
+Int_t AliHLTMUONMicrodHLT::DebugLevel()
 {
 #ifdef DEBUG
-       return dHLT::DebugLevel;
+       return gAliHLTMUONDebugLevel;
 #else // DEBUG
        return -1;
 #endif // DEBUG
 }
-
-
-} // AliMUONHLT
index 857de67542f941cfb8181939f7c461fcd00b1f44..8b98a325f482e7fd6d694160ba6c4fb3a0aca040 100644 (file)
@@ -5,8 +5,8 @@
 //
 ////////////////////////////////////////////////////////////////////////////////
 
-#ifndef dHLT_ALIROOT_MICRODHLT_HPP
-#define dHLT_ALIROOT_MICRODHLT_HPP
+#ifndef ALIHLTMUONMICRODHLT_H
+#define ALIHLTMUONMICRODHLT_H
 
 #include "TROOT.h"
 #include "TObject.h"
 #include "AliRoot/TrackSink.hpp"
 #include "AliRoot/TrackerCallback.hpp"
 
-namespace AliMUONHLT
-{
-
 
-class ClusterFinder;
-class ClusterFinderInterface;
-class Tracker;
-class TrackerInterface;
+class AliHLTMUONDummyClusterFinder;
+class AliHLTMUONClusterFinderInterface;
+class AliHLTMUONDummyTracker;
+class AliHLTMUONTrackerInterface;
 
 
 /* Routines for getting dHLT version information.
 */
-TString Version();
-UInt_t MajorVersion();
-UInt_t MinorVersion();
-UInt_t BuildNumber();
+TString AliHLTMUONVersion();
+UInt_t AliHLTMUONMajorVersion();
+UInt_t AliHLTMUONMinorVersion();
+UInt_t AliHLTMUONBuildNumber();
 
 
-class MicrodHLT : public TObject
+class AliHLTMUONMicrodHLT : public TObject
 {
 public:
 
-       MicrodHLT();
-       virtual ~MicrodHLT();
+       AliHLTMUONMicrodHLT();
+       virtual ~AliHLTMUONMicrodHLT();
 
        /* Get/Set methods for the trigger data source.
           Note: The source object must be cleaned up by the caller.
         */
-       void SetTriggerSource(const TriggerSource* source);
-       const TriggerSource* GetTriggerSource() const { return fTriggerSource; };
+       void SetTriggerSource(const AliHLTMUONTriggerSource* source);
+       const AliHLTMUONTriggerSource* GetTriggerSource() const { return fTriggerSource; };
        
        /* Get/Set methods for the cluster data source.
           Note: The source object must be cleaned up by the caller.
         */
-       void SetClusterSource(const ClusterSource* source);
-       const ClusterSource* GetClusterSource() const { return fClusterSource; };
+       void SetClusterSource(const AliHLTMUONClusterSource* source);
+       const AliHLTMUONClusterSource* GetClusterSource() const { return fClusterSource; };
        
        /* Get/Set methods for the track data sink (output target).
           Note: The output object must be cleaned up by the caller.
         */
-       void SetTrackSink(TrackSink* sink)    { fTrackSink = sink; };
-       const TrackSink* GetTrackSink() const { return fTrackSink; };
+       void SetTrackSink(AliHLTMUONTrackSink* sink)    { fTrackSink = sink; };
+       const AliHLTMUONTrackSink* GetTrackSink() const { return fTrackSink; };
        
        /* Get/Set methods for the cluster finder interface.
           Note: The cluster finder object must be cleaned up by the caller.
           This field is optional. Use it if a custom cluster finder should be used.
         */
-       void SetClusterFinder(ClusterFinderInterface* clusterfinder) { fClusterFinder = clusterfinder; };
-       const ClusterFinderInterface* GetClusterFinder() const { return fClusterFinder; };
-       void SetClusterFinder(ClusterFinder* clusterfinder);
+       void SetClusterFinder(AliHLTMUONClusterFinderInterface* clusterfinder)
+       {
+               fClusterFinder = clusterfinder;
+       }
+
+       const AliHLTMUONClusterFinderInterface* GetClusterFinder() const { return fClusterFinder; };
+       void SetClusterFinder(AliHLTMUONDummyClusterFinder* clusterfinder);
        
        /* Get/Set methods for the tracker interface.
           Note: The tracker object must be cleaned up by the caller.
           This field is optional. Use it if a custom tracker should be used.
         */
-       void SetTracker(TrackerInterface* tracker) { fTracker = tracker; };
-       const TrackerInterface* GetTracker() const { return fTracker; };
-       void SetTracker(Tracker* tracker);
+       void SetTracker(AliHLTMUONTrackerInterface* tracker) { fTracker = tracker; };
+       const AliHLTMUONTrackerInterface* GetTracker() const { return fTracker; };
+       void SetTracker(AliHLTMUONDummyTracker* tracker);
        
        /* 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
@@ -87,16 +88,14 @@ public:
        
 private:
 
-       TriggerSource* fTriggerSource;           //! Trigger record input source.
-       ClusterSource* fClusterSource;           //! Cluster point input source.
-       TrackSink* fTrackSink;                   //! Track output sink.
-       ClusterFinderInterface* fClusterFinder;  //! Interface to a custom cluster finder.
-       TrackerInterface* fTracker;              //! Interface to a custom tracker.
+       AliHLTMUONTriggerSource* fTriggerSource;           //! Trigger record input source.
+       AliHLTMUONClusterSource* fClusterSource;           //! Cluster point input source.
+       AliHLTMUONTrackSink* fTrackSink;                   //! Track output sink.
+       AliHLTMUONClusterFinderInterface* fClusterFinder;  //! Interface to a custom cluster finder.
+       AliHLTMUONTrackerInterface* fTracker;              //! Interface to a custom tracker.
 
-       ClassDef(MicrodHLT, 0);  // A very minimal implementation of the dHLT algorithm.
+       ClassDef(AliHLTMUONMicrodHLT, 0);  // A very minimal implementation of the dHLT algorithm.
 };
 
 
-} // AliMUONHLT
-
-#endif // dHLT_ALIROOT_MICRODHLT_HPP
+#endif // ALIHLTMUONMICRODHLT_H
index 6a379a486e1156c794f1201d8fab3698e50e4cf4..9a392ae42a89da3cbf7e844c62f01092c8629590 100644 (file)
@@ -8,27 +8,22 @@
 #include "AliRoot/Point.hpp"
 #include "TMath.h"
 
-ClassImp(AliMUONHLT::Point)
+ClassImp(AliHLTMUONPoint)
 
-namespace AliMUONHLT
-{
 
-Point::Point() : TObject()
+AliHLTMUONPoint::AliHLTMUONPoint() : TObject()
 {
        fX = fY = 0.0;
 }
 
-Point::Point(Float_t x, Float_t y) : TObject()
+AliHLTMUONPoint::AliHLTMUONPoint(Float_t x, Float_t y) : TObject()
 {
        fX = x;
        fY = y;
 }
 
-ostream& operator << (ostream& os, const Point& p)
+ostream& operator << (ostream& os, const AliHLTMUONPoint& p)
 {
        os << "[" << p.fX << ", " << p.fY << "]";
        return os;
 }
-
-} // AliMUONHLT
-
index 0153593d2b00116f44e45dc5c7b3e209377f1b61..20054ba2265b2753f6838fab5a836e87435dd27f 100644 (file)
@@ -5,42 +5,36 @@
 //
 ////////////////////////////////////////////////////////////////////////////////
 
-#ifndef dHLT_ALIROOT_POINT_HPP
-#define dHLT_ALIROOT_POINT_HPP
+#ifndef ALIHLTMUONPOINT_H
+#define ALIHLTMUONPOINT_H
 
 #include <TObject.h>
 #include <Riostream.h>
 
 
-namespace AliMUONHLT
-{
-
-
-class Point : public TObject
+class AliHLTMUONPoint : public TObject
 {
 public:
 
        /* Default constructor initialises everything to zero.
         */
-       Point();
+       AliHLTMUONPoint();
        
        /* Constructs the point from the specified x and y coordinates.
         */
-       Point(Float_t x, Float_t y);
+       AliHLTMUONPoint(Float_t x, Float_t y);
 
-       virtual ~Point() {};
+       virtual ~AliHLTMUONPoint() {};
        
        // ostream operator usefull for text output.
-       friend ostream& operator << (ostream& os, const Point& p);
+       friend ostream& operator << (ostream& os, const AliHLTMUONPoint& p);
 
 
        Float_t fX;    // X coordinate of the 2D point.
        Float_t fY;    // Y coordinate of the 2D point.
 
-       ClassDef(Point, 1)  // A 2D space point.
+       ClassDef(AliHLTMUONPoint, 1)  // A 2D space point.
 };
 
 
-} // AliMUONHLT
-
-#endif // dHLT_ALIROOT_POINT_HPP
+#endif // ALIHLTMUONPOINT_H
index 2b202f15e8052b3ee05c48de94b7f23974fd384d..ae42348778b7d4836643fa57347a43ad75d73686 100644 (file)
 #include <TMath.h>
 #include "Utils.hpp"
 
-ClassImp(AliMUONHLT::Region)
-
-namespace AliMUONHLT
-{
+ClassImp(AliHLTMUONRegion)
 
 
-Region::Region() : TObject()
+AliHLTMUONRegion::AliHLTMUONRegion() : TObject()
 {
        fLeft = fRight = fBottom = fTop = 0.0;
 }
 
 
-Region::Region(Float_t left, Float_t right, Float_t bottom, Float_t top)
+AliHLTMUONRegion::AliHLTMUONRegion(Float_t left, Float_t right, Float_t bottom, Float_t top)
         : TObject()
 {
        if (left > right)
        {
                fLeft = fRight = fBottom = fTop = 0.0;
-               Error("Region", "parameter left (%f) is larger than right (%f).", left, right);
+               Error("AliHLTMUONRegion", "parameter left (%f) is larger than right (%f).", left, right);
        }
        else if (bottom > top)
        {
                fLeft = fRight = fBottom = fTop = 0.0;
-               Error("Region", "parameter bottom (%f) is larger than top (%f).", bottom, top);
+               Error("AliHLTMUONRegion", "parameter bottom (%f) is larger than top (%f).", bottom, top);
        }
        else
        {
@@ -45,7 +42,7 @@ Region::Region(Float_t left, Float_t right, Float_t bottom, Float_t top)
 }
 
 
-void Region::Left(Float_t value)
+void AliHLTMUONRegion::Left(Float_t value)
 {
        if (value > fRight)
                Error("Left", "Trying to assign fLeft (%f) larger than fRight (%f).", value, fRight);
@@ -54,7 +51,7 @@ void Region::Left(Float_t value)
 }
 
 
-void Region::Right(Float_t value)
+void AliHLTMUONRegion::Right(Float_t value)
 {
        if (value < fLeft)
                Error("Right", "Trying to assign fRight (%f) smaller than fLeft (%f).", value, fLeft);
@@ -63,7 +60,7 @@ void Region::Right(Float_t value)
 }
 
 
-void Region::Bottom(Float_t value)
+void AliHLTMUONRegion::Bottom(Float_t value)
 {
        if (value > fTop)
                Error("Bottom", "Trying to assign fBottom (%f) larger than fTop (%f).", value, fTop);
@@ -72,7 +69,7 @@ void Region::Bottom(Float_t value)
 }
 
 
-void Region::Top(Float_t value)
+void AliHLTMUONRegion::Top(Float_t value)
 {
        if (value < fBottom)
                Error("Top", "Trying to assign fTop (%f) smaller than fBottom (%f).", value, fBottom);
@@ -81,7 +78,7 @@ void Region::Top(Float_t value)
 }
 
 
-Bool_t Region::Contains(const Point& p) const
+Bool_t AliHLTMUONRegion::Contains(const AliHLTMUONPoint& p) const
 {
        return 
          fLeft <= p.fX 
@@ -91,11 +88,9 @@ Bool_t Region::Contains(const Point& p) const
 }
 
 
-ostream& operator << (ostream& os, const Region& r)
+ostream& operator << (ostream& os, const AliHLTMUONRegion& r)
 {
        os << "[(" << r.fLeft << ", " << r.fRight << "), (" << r.fLeft << ", " << r.fRight << ")]";
        return os;
 }
 
-
-} // AliMUONHLT
index ca704dbcb8c7e8536125bbfca8ca4704ef4c2b51..ed22f1cfd46c80415010740c53a4d5c54ac8a3e3 100644 (file)
@@ -5,35 +5,31 @@
 //
 ////////////////////////////////////////////////////////////////////////////////
 
-#ifndef dHLT_ALIROOT_REGION_HPP
-#define dHLT_ALIROOT_REGION_HPP
+#ifndef ALIHLTMUONREGION_H
+#define ALIHLTMUONREGION_H
 
 #include <TObject.h>
 #include <Riostream.h>
 
+class AliHLTMUONPoint;
 
-namespace AliMUONHLT
-{
-
-class Point;
 
-
-class Region : public TObject
+class AliHLTMUONRegion : public TObject
 {
 public:
 
        /* Default constructor initialises everything to zero.
         */
-       Region();
+       AliHLTMUONRegion();
        
        /* Constructs the boundary box from the specified boundary parameters.
           Note: the following conditions must apply: left <= right and bottom <= top
           If this is not the case then an error message is shown and everything
           is set to zero.
         */
-       Region(Float_t left, Float_t right, Float_t bottom, Float_t top);
+       AliHLTMUONRegion(Float_t left, Float_t right, Float_t bottom, Float_t top);
 
-       virtual ~Region() {}
+       virtual ~AliHLTMUONRegion() {}
        
        /* Get/Set methods for the boundary lines.
           Note: before assignment we check for the following parameter consistency:
@@ -53,10 +49,10 @@ public:
        /* Checks if the point is within this region. If it is then kTRUE is returned
           otherwise kFALSE is returned.
         */
-       Bool_t Contains(const Point& p) const;
+       Bool_t Contains(const AliHLTMUONPoint& p) const;
 
        // ostream operator usefull for text output.
-       friend ostream& operator << (ostream& os, const Region& r);
+       friend ostream& operator << (ostream& os, const AliHLTMUONRegion& r);
 
 private:
 
@@ -65,10 +61,8 @@ private:
        Float_t fBottom;  // Bottom boundary of boundary box.
        Float_t fTop;     // Top boundary of boundary box.
 
-       ClassDef(Region, 1)  // A boundary box region.
+       ClassDef(AliHLTMUONRegion, 1)  // A boundary box region.
 };
 
 
-} // AliMUONHLT
-
-#endif // dHLT_ALIROOT_REGION_HPP
+#endif // ALIHLTMUONREGION_H
index 396bdd088472ea9bc250ed83af33e9013394eb42..eda232c35dd38c1aab5fdc80ea8e4befeb8ad3c2 100644 (file)
@@ -9,39 +9,36 @@
 #include <TMath.h>
 #include "Utils.hpp"
 
-ClassImp(AliMUONHLT::Track)
-
-namespace AliMUONHLT
-{
+ClassImp(AliHLTMUONTrack)
 
 
-Track::Track() : TObject()
+AliHLTMUONTrack::AliHLTMUONTrack() : TObject()
 {
        Init();
 }
 
 
-Track::Track(
+AliHLTMUONTrack::AliHLTMUONTrack(
                Int_t triggerid, Int_t sign, Float_t momentum, Float_t pt,
-               const Point hits[10], const Region regions[10]
+               const AliHLTMUONPoint hits[10], const AliHLTMUONRegion regions[10]
        ) : TObject()
 {
        if (sign < -1 || +1 < sign)
        {
                Init();
-               Error("Track", "The particle sign was not one of -1, 0 or +1. Got %d", sign);
+               Error("AliHLTMUONTrack", "The particle sign was not one of -1, 0 or +1. Got %d", sign);
        }
        else if (momentum < pt)
        {
                Init();
-               Error("Track", "The momentum (%f) must be larger or equal to the pt (%f).",
+               Error("AliHLTMUONTrack", "The momentum (%f) must be larger or equal to the pt (%f).",
                        momentum, pt
                );
        }
        else if (pt < 0.0)
        {
                Init();
-               Error("Track", "The pt must be a positive number. Got: %f", pt);
+               Error("AliHLTMUONTrack", "The pt must be a positive number. Got: %f", pt);
        }
        else
        {
@@ -58,7 +55,7 @@ Track::Track(
 }
 
 
-void Track::Init()
+void AliHLTMUONTrack::Init()
 {
        fTriggerID = -1;
        fParticleSign = 0;
@@ -66,7 +63,7 @@ void Track::Init()
 }
 
 
-void Track::ParticleSign(Int_t value)
+void AliHLTMUONTrack::ParticleSign(Int_t value)
 {
        if (-1 <= value && value <= +1)
                fParticleSign = value;
@@ -78,7 +75,7 @@ void Track::ParticleSign(Int_t value)
 }
 
 
-void Track::P(Float_t value)
+void AliHLTMUONTrack::P(Float_t value)
 {
        if (value >= fPt)
                fP = value;
@@ -89,7 +86,7 @@ void Track::P(Float_t value)
                );
 }
 
-void Track::Pt(Float_t value)
+void AliHLTMUONTrack::Pt(Float_t value)
 {
        if (value >= 0.0)
        {
@@ -106,7 +103,7 @@ void Track::Pt(Float_t value)
 };
 
 
-Point& Track::Hit(UInt_t chamber)
+AliHLTMUONPoint& AliHLTMUONTrack::Hit(UInt_t chamber)
 {
        if (chamber < 10)
                return fHit[chamber];
@@ -121,7 +118,7 @@ Point& Track::Hit(UInt_t chamber)
 }
 
 
-const Point& Track::Hit(UInt_t chamber) const
+const AliHLTMUONPoint& AliHLTMUONTrack::Hit(UInt_t chamber) const
 {
        if (chamber < 10)
                return fHit[chamber];
@@ -136,7 +133,7 @@ const Point& Track::Hit(UInt_t chamber) const
 };
 
 
-void Track::Hit(UInt_t chamber, const Point& value)
+void AliHLTMUONTrack::Hit(UInt_t chamber, const AliHLTMUONPoint& value)
 {
        if (chamber < 10)
                fHit[chamber] = value;
@@ -148,7 +145,7 @@ void Track::Hit(UInt_t chamber, const Point& value)
 }
 
 
-Region& Track::RegionOfInterest(UInt_t chamber)
+AliHLTMUONRegion& AliHLTMUONTrack::RegionOfInterest(UInt_t chamber)
 {
        if (chamber < 10)
                return fRegionOfInterest[chamber];
@@ -163,7 +160,7 @@ Region& Track::RegionOfInterest(UInt_t chamber)
 }
 
 
-const Region& Track::RegionOfInterest(UInt_t chamber) const
+const AliHLTMUONRegion& AliHLTMUONTrack::RegionOfInterest(UInt_t chamber) const
 {
        if (chamber < 10)
                return fRegionOfInterest[chamber];
@@ -178,7 +175,7 @@ const Region& Track::RegionOfInterest(UInt_t chamber) const
 }
 
 
-void Track::RegionOfInterest(UInt_t chamber, const Region& value)
+void AliHLTMUONTrack::RegionOfInterest(UInt_t chamber, const AliHLTMUONRegion& value)
 {
        if (chamber < 10)
                fRegionOfInterest[chamber] = value;
@@ -190,7 +187,7 @@ void Track::RegionOfInterest(UInt_t chamber, const Region& value)
 }
 
 
-Bool_t Track::HitsInRegions() const
+Bool_t AliHLTMUONTrack::HitsInRegions() const
 {
        for (Int_t i = 0; i < 10; i++)
        {
@@ -201,12 +198,10 @@ Bool_t Track::HitsInRegions() const
 }
 
 
-ostream& operator << (ostream& os, const Track& t)
+ostream& operator << (ostream& os, const AliHLTMUONTrack& t)
 {
        os << "{trigid: " << t.fTriggerID << ", sign: " << t.fParticleSign
           << ", p: " << t.fP << ", pt: " << t.fPt << "}";
        return os;
 }
 
-
-} // AliMUONHLT
index f7e8041bdeb9fafdf404f963943efb99a20289a8..8a66bbcbe074cd0e18c712aa5803c6ab3dbaabc0 100644 (file)
@@ -5,8 +5,8 @@
 //
 ////////////////////////////////////////////////////////////////////////////////
 
-#ifndef dHLT_ALIROOT_TRACK_HPP
-#define dHLT_ALIROOT_TRACK_HPP
+#ifndef ALIHLTMUONTRACK_H
+#define ALIHLTMUONTRACK_H
 
 #include <TObject.h>
 #include <Riostream.h>
 #include "AliRoot/Region.hpp"
 
 
-namespace AliMUONHLT
-{
-
-
-class Track : public TObject
+class AliHLTMUONTrack : public TObject
 {
 public:
 
        /* Default constructor initialises everything to zero and fTriggerID to -1.
         */
-       Track();
+       AliHLTMUONTrack();
        
        /* Create a track object from the given parameters.
           This constructor checks that momentum >= pt and sign is one of the
@@ -33,12 +29,12 @@ public:
           the internal data is initialised as in the default constructor and an
           error message is displayed.
         */
-       Track(
+       AliHLTMUONTrack(
                Int_t triggerid, Int_t sign, Float_t momentum, Float_t pt,
-               const Point hits[10], const Region regions[10]
+               const AliHLTMUONPoint hits[10], const AliHLTMUONRegion regions[10]
        );
 
-       virtual ~Track() {}
+       virtual ~AliHLTMUONTrack() {}
        
        
        // Get/et methods for the trigger ID.
@@ -67,23 +63,23 @@ public:
           If the chamber number in out of bounds the point on the first
           chamber is returned and an error message displayed.
         */
-       Point& Hit(UInt_t chamber);
-       const Point& Hit(UInt_t chamber) const;
+       AliHLTMUONPoint& Hit(UInt_t chamber);
+       const AliHLTMUONPoint& Hit(UInt_t chamber) const;
        
        /* Set method for hits. The chamber must be in the range [0..9]
         */
-       void Hit(UInt_t chamber, const Point& value);
+       void Hit(UInt_t chamber, const AliHLTMUONPoint& value);
        
        /* Returns the region of interest for the specified chamber.
           If the chamber number in out of bounds the region on the first
           chamber is returned and an error message displayed.
         */
-       Region& RegionOfInterest(UInt_t chamber);
-       const Region& RegionOfInterest(UInt_t chamber) const;
+       AliHLTMUONRegion& RegionOfInterest(UInt_t chamber);
+       const AliHLTMUONRegion& RegionOfInterest(UInt_t chamber) const;
        
        /* Set method for regions. The chamber must be in the range [0..9]
         */
-       void RegionOfInterest(UInt_t chamber, const Region& value);
+       void RegionOfInterest(UInt_t chamber, const AliHLTMUONRegion& value);
        
        /* Checks to see if the all the hits are within their respective regions
           of interest for each chamber. kTRUE is returned if they are and kFALSE
@@ -92,7 +88,7 @@ public:
        Bool_t HitsInRegions() const;
 
        // ostream operator usefull for text output.
-       friend ostream& operator << (ostream& os, const Track& t);
+       friend ostream& operator << (ostream& os, const AliHLTMUONTrack& t);
 
 private:
 
@@ -103,13 +99,11 @@ private:
        Int_t fParticleSign;  // The sign of the particle.
        Float_t fP;       // momentum of particle.
        Float_t fPt;      // transverse momentum.
-       Point fHit[10];   // Fitted track hit coordinates for the 10 tracking chambers.
-       Region fRegionOfInterest[10];  // Region of interest per chamber.
+       AliHLTMUONPoint fHit[10];   // Fitted track hit coordinates for the 10 tracking chambers.
+       AliHLTMUONRegion fRegionOfInterest[10];  // Region of interest per chamber.
 
-       ClassDef(Track, 1)  // Track data.
+       ClassDef(AliHLTMUONTrack, 1)  // Track data.
 };
 
 
-} // AliMUONHLT
-
-#endif // dHLT_ALIROOT_TRACK_HPP
+#endif // ALIHLTMUONTRACK_H
index 9436280433830378f42a15f10f6bb4d05b58167f..e158aef5c7e1fb183c057cd4732ec574067cba92 100644 (file)
@@ -8,15 +8,12 @@
 #include "AliRoot/TrackSink.hpp"
 #include "AliRoot/Base.hpp"
 
-ClassImp(AliMUONHLT::TrackSink)
-ClassImp(AliMUONHLT::TrackSink::EventData)
-
-namespace AliMUONHLT
-{
+ClassImp(AliHLTMUONTrackSink)
+ClassImp(AliHLTMUONTrackSink::EventData)
 
 
-TrackSink::TrackSink() :
-       TObject(), fEventList(TrackSink::EventData::Class())
+AliHLTMUONTrackSink::AliHLTMUONTrackSink() :
+       TObject(), fEventList(AliHLTMUONTrackSink::EventData::Class())
 {
        fFilename = "";
        fFoldername = "";
@@ -24,16 +21,16 @@ TrackSink::TrackSink() :
 }
 
 
-TrackSink::~TrackSink()
+AliHLTMUONTrackSink::~AliHLTMUONTrackSink()
 {
-       DebugMsg(1, "TrackSink::~TrackSink()");
+       DebugMsg(1, "AliHLTMUONTrackSink::~AliHLTMUONTrackSink()");
        fEventList.Clear("C");
 }
 
 
-void TrackSink::AddEvent(Int_t eventnumber)
+void AliHLTMUONTrackSink::AddEvent(Int_t eventnumber)
 {
-       DebugMsg(1, "TrackSink::AddEvent(" << eventnumber << ")");
+       DebugMsg(1, "AliHLTMUONTrackSink::AddEvent(" << eventnumber << ")");
        
        if (eventnumber < 0)
        {
@@ -66,9 +63,9 @@ void TrackSink::AddEvent(Int_t eventnumber)
 }
 
 
-void TrackSink::AddBlock()
+void AliHLTMUONTrackSink::AddBlock()
 {
-       DebugMsg(1, "TrackSink::AddBlock()");
+       DebugMsg(1, "AliHLTMUONTrackSink::AddBlock()");
        
        if (fCurrentEvent == NULL)
        {
@@ -77,7 +74,7 @@ void TrackSink::AddBlock()
        };
        
        fBlockIndex = fCurrentEvent->fBlocks.GetEntriesFast();
-       new ( fCurrentEvent->fBlocks[fBlockIndex] ) TClonesArray(Track::Class());
+       new ( fCurrentEvent->fBlocks[fBlockIndex] ) TClonesArray(AliHLTMUONTrack::Class());
        fCurrentBlock = (TClonesArray*) fCurrentEvent->fBlocks[fBlockIndex];
        
        // Remember to reset the track pointer because the new block is empty.
@@ -89,9 +86,9 @@ void TrackSink::AddBlock()
 }
 
 
-void TrackSink::AddTrack(const Track& track)
+void AliHLTMUONTrackSink::AddTrack(const AliHLTMUONTrack& track)
 {
-       DebugMsg(1, "TrackSink::AddTrack()");
+       DebugMsg(1, "AliHLTMUONTrackSink::AddTrack()");
 
        if (fCurrentBlock == NULL)
        {
@@ -100,8 +97,8 @@ void TrackSink::AddTrack(const Track& track)
        };
        
        fTrackIndex = fCurrentBlock->GetEntriesFast();
-       new ( (*fCurrentBlock)[fTrackIndex] ) Track(track);
-       fCurrentTrack = (Track*) (*fCurrentBlock)[fTrackIndex];
+       new ( (*fCurrentBlock)[fTrackIndex] ) AliHLTMUONTrack(track);
+       fCurrentTrack = (AliHLTMUONTrack*) (*fCurrentBlock)[fTrackIndex];
        
        DebugMsg(2, "\tfEventIndex = " << fEventIndex << " , fBlockIndex = " << fBlockIndex
                << " , fTrackIndex = " << fTrackIndex
@@ -109,9 +106,9 @@ void TrackSink::AddTrack(const Track& track)
 }
 
 
-Track* TrackSink::AddTrack()
+AliHLTMUONTrack* AliHLTMUONTrackSink::AddTrack()
 {
-       DebugMsg(1, "TrackSink::AddTrack()");
+       DebugMsg(1, "AliHLTMUONTrackSink::AddTrack()");
 
        if (fCurrentBlock == NULL)
        {
@@ -120,7 +117,7 @@ Track* TrackSink::AddTrack()
        };
        
        fTrackIndex = fCurrentBlock->GetEntriesFast();
-       fCurrentTrack = (Track*) fCurrentBlock->New(fTrackIndex);
+       fCurrentTrack = (AliHLTMUONTrack*) fCurrentBlock->New(fTrackIndex);
        
        DebugMsg(2, "\tfEventIndex = " << fEventIndex << " , fBlockIndex = " << fBlockIndex
                << " , fTrackIndex = " << fTrackIndex
@@ -129,12 +126,12 @@ Track* TrackSink::AddTrack()
 };
 
 
-void TrackSink::AddTrack(
+void AliHLTMUONTrackSink::AddTrack(
                Int_t triggerid, Int_t sign, Float_t momentum,
-               Float_t pt, const Point hits[10], const Region regions[10]
+               Float_t pt, const AliHLTMUONPoint hits[10], const AliHLTMUONRegion regions[10]
        )
 {
-       DebugMsg(1, "TrackSink::AddTrack(" << triggerid << ", " << sign << ", "
+       DebugMsg(1, "AliHLTMUONTrackSink::AddTrack(" << triggerid << ", " << sign << ", "
                << momentum << ", " << pt << ", " << (void*)(&hits[0]) << ", "
                << (void*)(&regions[0]) << ")"
        );
@@ -146,8 +143,8 @@ void TrackSink::AddTrack(
        };
        
        fTrackIndex = fCurrentBlock->GetEntriesFast();
-       new ( (*fCurrentBlock)[fTrackIndex] ) Track(triggerid, sign, momentum, pt, hits, regions);
-       fCurrentTrack = (Track*) (*fCurrentBlock)[fTrackIndex];
+       new ( (*fCurrentBlock)[fTrackIndex] ) AliHLTMUONTrack(triggerid, sign, momentum, pt, hits, regions);
+       fCurrentTrack = (AliHLTMUONTrack*) (*fCurrentBlock)[fTrackIndex];
        
        DebugMsg(2, "\tfEventIndex = " << fEventIndex << " , fBlockIndex = " << fBlockIndex
                << " , fTrackIndex = " << fTrackIndex
@@ -155,14 +152,14 @@ void TrackSink::AddTrack(
 }
 
 
-void TrackSink::SetNames(const TriggerSource* triggersource)
+void AliHLTMUONTrackSink::SetNames(const AliHLTMUONTriggerSource* triggersource)
 {
        fFilename = triggersource->FileName();
        fFoldername = triggersource->FolderName();
 }
 
 
-void TrackSink::Clear(Option_t* /*option*/)
+void AliHLTMUONTrackSink::Clear(Option_t* /*option*/)
 {
        fFilename = "";
        fFoldername = "";
@@ -171,9 +168,9 @@ void TrackSink::Clear(Option_t* /*option*/)
 }
 
 
-Bool_t TrackSink::GetEvent(Int_t eventnumber) const
+Bool_t AliHLTMUONTrackSink::GetEvent(Int_t eventnumber) const
 {
-       DebugMsg(1, "TrackSink::GetEvent(" << eventnumber << ")" );
+       DebugMsg(1, "AliHLTMUONTrackSink::GetEvent(" << eventnumber << ")" );
        
        // Try find the corresponding event in the list of events.
        for (Int_t i = 0; i < fEventList.GetEntriesFast(); i++)
@@ -194,9 +191,9 @@ Bool_t TrackSink::GetEvent(Int_t eventnumber) const
 }
 
 
-Bool_t TrackSink::GetFirstEvent() const
+Bool_t AliHLTMUONTrackSink::GetFirstEvent() const
 {
-       DebugMsg(1, "TrackSink::GetFirstEvent()");
+       DebugMsg(1, "AliHLTMUONTrackSink::GetFirstEvent()");
        if (fEventList.GetEntriesFast() > 0)
        {
                fEventIndex = 0;
@@ -217,15 +214,15 @@ Bool_t TrackSink::GetFirstEvent() const
 }
 
 
-Bool_t TrackSink::MoreEvents() const
+Bool_t AliHLTMUONTrackSink::MoreEvents() const
 {
        return 0 <= fEventIndex && fEventIndex < fEventList.GetEntriesFast();
 }
 
 
-Bool_t TrackSink::GetNextEvent() const
+Bool_t AliHLTMUONTrackSink::GetNextEvent() const
 {
-       DebugMsg(1, "TrackSink::GetNextEvent()");
+       DebugMsg(1, "AliHLTMUONTrackSink::GetNextEvent()");
        if (fEventIndex < fEventList.GetEntriesFast() - 1)
        {
                fCurrentEvent = (EventData*) fEventList[ ++fEventIndex ];
@@ -243,7 +240,7 @@ Bool_t TrackSink::GetNextEvent() const
 };
 
 
-Int_t TrackSink::CurrentEvent() const
+Int_t AliHLTMUONTrackSink::CurrentEvent() const
 {
        if (fCurrentEvent != NULL)
                return fCurrentEvent->fEventNumber;
@@ -252,9 +249,9 @@ Int_t TrackSink::CurrentEvent() const
 }
 
 
-Int_t TrackSink::NumberOfBlocks() const
+Int_t AliHLTMUONTrackSink::NumberOfBlocks() const
 {
-       DebugMsg(1, "TrackSink::NumberOfBlocks()");
+       DebugMsg(1, "AliHLTMUONTrackSink::NumberOfBlocks()");
        if (fCurrentEvent == NULL)
        {
                Error("NumberOfBlocks", "No event selected.");
@@ -265,9 +262,9 @@ Int_t TrackSink::NumberOfBlocks() const
 }
 
 
-Bool_t TrackSink::GetBlock(Int_t index) const
+Bool_t AliHLTMUONTrackSink::GetBlock(Int_t index) const
 {
-       DebugMsg(1, "TrackSink::GetBlock(" << index << ")");
+       DebugMsg(1, "AliHLTMUONTrackSink::GetBlock(" << index << ")");
        
        // Note NumberOfBlocks() also checks if the event was selected.
        Int_t numberofblocks = NumberOfBlocks();
@@ -301,9 +298,9 @@ Bool_t TrackSink::GetBlock(Int_t index) const
 }
 
 
-Bool_t TrackSink::GetFirstBlock() const
+Bool_t AliHLTMUONTrackSink::GetFirstBlock() const
 {
-       DebugMsg(1, "TrackSink::GetFirstBlock()");
+       DebugMsg(1, "AliHLTMUONTrackSink::GetFirstBlock()");
        // Note: NumberOfBlocks() also checks if fCurrentEvent != NULL.
        if (NumberOfBlocks() > 0)
        {
@@ -320,15 +317,15 @@ Bool_t TrackSink::GetFirstBlock() const
 }
 
 
-Bool_t TrackSink::MoreBlocks() const
+Bool_t AliHLTMUONTrackSink::MoreBlocks() const
 {
        return 0 <= fBlockIndex && fBlockIndex < NumberOfBlocks();
 }
 
 
-Bool_t TrackSink::GetNextBlock() const
+Bool_t AliHLTMUONTrackSink::GetNextBlock() const
 {
-       DebugMsg(1, "TrackSink::GetNextBlock()");
+       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.
@@ -349,9 +346,9 @@ Bool_t TrackSink::GetNextBlock() const
 }
 
 
-Int_t TrackSink::NumberOfTracks() const
+Int_t AliHLTMUONTrackSink::NumberOfTracks() const
 {
-       DebugMsg(1, "TrackSink::NumberOfTracks()");
+       DebugMsg(1, "AliHLTMUONTrackSink::NumberOfTracks()");
        if (fCurrentBlock == NULL)
        {
                Error("NumberOfTracks", "No block selected.");
@@ -362,9 +359,9 @@ Int_t TrackSink::NumberOfTracks() const
 };
 
 
-const Track* TrackSink::GetTrack(Int_t index) const
+const AliHLTMUONTrack* AliHLTMUONTrackSink::GetTrack(Int_t index) const
 {
-       DebugMsg(1, "TrackSink::GetTrack(" << index << ")");
+       DebugMsg(1, "AliHLTMUONTrackSink::GetTrack(" << index << ")");
 
        // Note NumberOfTracks() also checks if the event and block was selected.
        Int_t numberoftracks = NumberOfTracks();
@@ -373,7 +370,7 @@ const Track* TrackSink::GetTrack(Int_t index) const
        if ( 0 <= index && index < numberoftracks )
        {
                fTrackIndex = index;
-               fCurrentTrack = (Track*) fCurrentBlock->At(index);
+               fCurrentTrack = (AliHLTMUONTrack*) fCurrentBlock->At(index);
                DebugMsg(2, "\tfEventIndex = " << fEventIndex << " , fBlockIndex = " << fBlockIndex
                        << " , fTrackIndex = " << fTrackIndex
                );
@@ -397,14 +394,14 @@ const Track* TrackSink::GetTrack(Int_t index) const
 }
 
 
-const Track* TrackSink::GetFirstTrack() const
+const AliHLTMUONTrack* AliHLTMUONTrackSink::GetFirstTrack() const
 {
-       DebugMsg(1, "TrackSink::GetFirstTrack()");
+       DebugMsg(1, "AliHLTMUONTrackSink::GetFirstTrack()");
        // Note: NumberOfTracks() also checks if fCurrentBlock != NULL.
        if (NumberOfTracks() > 0)
        {
                fTrackIndex = 0;
-               fCurrentTrack = (Track*) fCurrentBlock->At(0);
+               fCurrentTrack = (AliHLTMUONTrack*) fCurrentBlock->At(0);
                DebugMsg(2, "\tfEventIndex = " << fEventIndex << " , fBlockIndex = " << fBlockIndex
                        << " , fTrackIndex = " << fTrackIndex
                );
@@ -415,21 +412,21 @@ const Track* TrackSink::GetFirstTrack() const
 }
 
 
-Bool_t TrackSink::MoreTracks() const
+Bool_t AliHLTMUONTrackSink::MoreTracks() const
 {
        return 0 <= fTrackIndex && fTrackIndex < NumberOfTracks();
 }
 
 
-const Track* TrackSink::GetNextTrack() const
+const AliHLTMUONTrack* AliHLTMUONTrackSink::GetNextTrack() const
 {
-       DebugMsg(1, "TrackSink::GetNextTrack()");
+       DebugMsg(1, "AliHLTMUONTrackSink::GetNextTrack()");
        
        // Note: NumberOfTracks() checks if fCurrentBlock != NULL. If it is then it returns -1
        // and since fTrackIndex is always >= -1 the if statement must go to the else part.
        if (fTrackIndex < NumberOfTracks() - 1)
        {
-               fCurrentTrack = (Track*) fCurrentBlock->At( ++fTrackIndex );
+               fCurrentTrack = (AliHLTMUONTrack*) fCurrentBlock->At( ++fTrackIndex );
                DebugMsg(2, "\tfEventIndex = " << fEventIndex << " , fBlockIndex = " << fBlockIndex
                        << " , fTrackIndex = " << fTrackIndex
                );
@@ -443,7 +440,7 @@ const Track* TrackSink::GetNextTrack() const
 }
 
 
-void TrackSink::ResetAllPointers() const
+void AliHLTMUONTrackSink::ResetAllPointers() const
 {
        fEventIndex = -1;
        fCurrentEvent = NULL;
@@ -457,7 +454,7 @@ void TrackSink::ResetAllPointers() const
 }
 
 
-void TrackSink::ResetBlockPointers() const
+void AliHLTMUONTrackSink::ResetBlockPointers() const
 {
        fBlockIndex = -1;
        fCurrentBlock = NULL;
@@ -469,7 +466,7 @@ void TrackSink::ResetBlockPointers() const
 }
 
 
-void TrackSink::ResetTrackPointers() const
+void AliHLTMUONTrackSink::ResetTrackPointers() const
 {
        fTrackIndex = -1;
        fCurrentTrack = NULL;
@@ -479,13 +476,13 @@ void TrackSink::ResetTrackPointers() const
 }
 
 
-TrackSink::EventData::EventData() : fBlocks(TClonesArray::Class())
+AliHLTMUONTrackSink::EventData::EventData() : fBlocks(TClonesArray::Class())
 {
        fEventNumber = -1;
 }
 
 
-TrackSink::EventData::EventData(Int_t eventnumber)
+AliHLTMUONTrackSink::EventData::EventData(Int_t eventnumber)
        : fBlocks(TClonesArray::Class())
 {
        fEventNumber = eventnumber;
@@ -495,11 +492,9 @@ TrackSink::EventData::EventData(Int_t eventnumber)
 }
 
 
-TrackSink::EventData::~EventData()
+AliHLTMUONTrackSink::EventData::~EventData()
 {
-       DebugMsg(1, "TrackSink::EventData::~EventData()");
+       DebugMsg(1, "AliHLTMUONTrackSink::EventData::~EventData()");
        fBlocks.Clear("C");
 }
 
-
-} // AliMUONHLT
index c7c2ab8f5da2e07a8c586bfa0c600b4e5b40cea1..44d9ef6b6bab5e693116165a4a9bbeaedea87a7b 100644 (file)
@@ -5,8 +5,8 @@
 //
 ////////////////////////////////////////////////////////////////////////////////
 
-#ifndef dHLT_ALIROOT_TRACK_SINK_HPP
-#define dHLT_ALIROOT_TRACK_SINK_HPP
+#ifndef ALIHLTMUONTRACKSINK_H
+#define ALIHLTMUONTRACKSINK_H
 
 #include "TROOT.h"
 #include "TObject.h"
 
 #include <vector>
 
-namespace AliMUONHLT
-{
-
 
-class TrackSink : public TObject
+class AliHLTMUONTrackSink : public TObject
 {
 public:
 
-       TrackSink();
-       virtual ~TrackSink();
+       AliHLTMUONTrackSink();
+       virtual ~AliHLTMUONTrackSink();
        
        /* Adds a new EventData block to the fEventList and updates internal pointers.
           Cannot have duplicate event numbers so this method will display an error
@@ -44,24 +41,24 @@ public:
           The fCurrentTrack is updated appropriately.
           If no current block is selected then NULL is returned.
         */
-       Track* AddTrack();
+       AliHLTMUONTrack* AddTrack();
        
        /* Adds the given track to the current block.
           If no current block is selected then an error message is displayed.
         */
-       void AddTrack(const Track& track);
+       void AddTrack(const AliHLTMUONTrack& track);
        
        /* Adds the specified track parameters as a new track.
           The fCurrentTrack is updated appropriately.
         */
        void AddTrack(
                        Int_t triggerid, Int_t sign, Float_t momentum,
-                       Float_t pt, const Point hits[10], const Region regions[10]
+                       Float_t pt, const AliHLTMUONPoint hits[10], const AliHLTMUONRegion regions[10]
                );
        
        /* Sets the internal file and folder names from the trigger source.
         */
-       void SetNames(const TriggerSource* triggersource);
+       void SetNames(const AliHLTMUONTriggerSource* triggersource);
        
        /* Clears all the internal arrays.
         */
@@ -84,7 +81,7 @@ public:
         */
        Bool_t GetEvent(Int_t eventnumber) const;
        
-       /* Fetches the first event stored in this TrackSink.
+       /* 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.
@@ -151,12 +148,12 @@ public:
        /* Fetches the index'th track in the current block.
           NULL is returned if the track was not found.
         */
-       const Track* GetTrack(Int_t index) const;
+       const AliHLTMUONTrack* GetTrack(Int_t index) const;
        
        /* Fetches the first track in the current block.
           NULL is returned if the track was not found.
         */
-       const Track* GetFirstTrack() const;
+       const AliHLTMUONTrack* GetFirstTrack() const;
        
        /* Returns kTRUE if there are more tracks to iterate over in
           the current block. kFALSE is returned otherwise.
@@ -166,12 +163,12 @@ public:
        /* Fetches the next track in the current block.
           NULL is returned if the track was not found.
         */
-       const Track* GetNextTrack() const;
+       const AliHLTMUONTrack* GetNextTrack() const;
        
        /* Returns the currently selected track.
           NULL is returned if there is no track selected.
         */
-       const Track* GetTrack() const { return fCurrentTrack; };
+       const AliHLTMUONTrack* GetTrack() const { return fCurrentTrack; };
        
        /* Returns the currently selected track index.
           -1 is returned if no track was selected.
@@ -216,14 +213,12 @@ private:
        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.
-       mutable Track* fCurrentTrack;         //! Pointer to the currently selected track.
+       mutable AliHLTMUONTrack* fCurrentTrack;         //! Pointer to the currently selected track.
 
        TClonesArray fEventList;  // List of tracks per event.
 
-       ClassDef(TrackSink, 1)  // The data sink for track blocks for dHLT.
+       ClassDef(AliHLTMUONTrackSink, 1)  // The data sink for track blocks for dHLT.
 };
 
 
-} // AliMUONHLT
-
-#endif // dHLT_ALIROOT_TRACK_SINK_HPP
+#endif // ALIHLTMUONTRACKSINK_H
index d999da25a9401ccbf009b50e5404fa9c8012afe8..73ae232a48942f2a6fb20c7c92105b6eb812c7e9 100644 (file)
@@ -5,8 +5,8 @@
 //
 ////////////////////////////////////////////////////////////////////////////////
 
-#ifndef dHLT_ALIROOT_TRACKER_HPP
-#define dHLT_ALIROOT_TRACKER_HPP
+#ifndef ALIHLTMUONDUMMYTRACKER_H
+#define ALIHLTMUONDUMMYTRACKER_H
 
 #ifndef __CINT__
 #include "AliRoot/Point.hpp"
 #endif // __CINT__
 
 
-namespace AliMUONHLT
-{
-
-
-class Tracker
+class AliHLTMUONDummyTracker
 {
 public:
 
-       Tracker() : fInterface(this)
+       AliHLTMUONDummyTracker() : fInterface(this)
        {
                fCallback = NULL;
        };
 
-       virtual ~Tracker() {};
+       virtual ~AliHLTMUONDummyTracker() {};
 
        /* Methods required to be implemented by the tracker.
           These correspond to the dHLT::Tracker specification, refer to that
           class for more information.
         */
-       virtual void FindTrack(const TriggerRecord& trigger) = 0;
-       virtual void ReturnClusters(void* tag, const Point* clusters, const UInt_t count) = 0;
+       virtual void FindTrack(const AliHLTMUONTriggerRecord& trigger) = 0;
+       virtual void ReturnClusters(void* tag, const AliHLTMUONPoint* clusters, const UInt_t count) = 0;
        virtual void EndOfClusters(void* tag) = 0;
-       virtual void FillTrackData(Track& track) = 0;
+       virtual void FillTrackData(AliHLTMUONTrack& track) = 0;
        virtual void Reset() = 0;
 
        /* Set the callback for the tracker, so that the tracker can communicate
           with the framework.
         */
-       void SetCallback(TrackerCallback* callback)
+       void SetCallback(AliHLTMUONTrackerCallback* callback)
        {
                fCallback = callback;
        };
@@ -52,7 +48,7 @@ public:
        /* Returns the TrackerInterface object to this tracker.
           This is required by the MicrodHLT object.
         */
-       TrackerInterface* Interface()
+       AliHLTMUONTrackerInterface* Interface()
        {
                return &fInterface;
        };
@@ -113,8 +109,8 @@ protected:
 
 private:
 
-       TrackerInterface fInterface;  // The interface via which compiled code communicates with this object.
-       TrackerCallback* fCallback;   // Callback interface to framework.
+       AliHLTMUONTrackerInterface fInterface;  // The interface via which compiled code communicates with this object.
+       AliHLTMUONTrackerCallback* fCallback;   // Callback interface to framework.
 };
 
 
@@ -122,44 +118,42 @@ private:
 // This must come here so that it gets interpreted together with the rest
 // of the AliMUONHLT::Tracker.
 
-void TrackerInterface::FindTrack(const TriggerRecord& trigger)
+void AliHLTMUONTrackerInterface::FindTrack(const AliHLTMUONTriggerRecord& trigger)
 {
        fTracker->FindTrack(trigger);
 };
 
-void TrackerInterface::ReturnClusters(void* tag, const Point* clusters, const UInt_t count)
+void AliHLTMUONTrackerInterface::ReturnClusters(void* tag, const AliHLTMUONPoint* clusters, const UInt_t count)
 {
        fTracker->ReturnClusters(tag, clusters, count);
 };
 
-void TrackerInterface::EndOfClusters(void* tag)
+void AliHLTMUONTrackerInterface::EndOfClusters(void* tag)
 {
        fTracker->EndOfClusters(tag);
 };
 
-void TrackerInterface::FillTrackData(Track& track)
+void AliHLTMUONTrackerInterface::FillTrackData(AliHLTMUONTrack& track)
 {
        fTracker->FillTrackData(track);
 };
 
-void TrackerInterface::Reset()
+void AliHLTMUONTrackerInterface::Reset()
 {
        fTracker->Reset();
 };
 
-void TrackerInterface::SetCallback(TrackerCallback* callback)
+void AliHLTMUONTrackerInterface::SetCallback(AliHLTMUONTrackerCallback* callback)
 {
        fTracker->SetCallback(callback);
 };
 
 
 // Implementation of the SetTracker method which is undefined in MicrodHLT.
-void MicrodHLT::SetTracker(Tracker* tracker)
+void AliHLTMUONMicrodHLT::SetTracker(AliHLTMUONDummyTracker* tracker)
 {
        SetTracker(tracker->Interface());
 };
 
 
-}; // AliMUONHLT
-
-#endif // dHLT_ALIROOT_TRACKER_HPP
+#endif // ALIHLTMUONDUMMYTRACKER_H
index 13ce16d0a4170ec337a970ed666b37891a5a8574..d6753b40b4ce6a00c5d86cf04645dd1d08b5c618 100644 (file)
@@ -7,4 +7,4 @@
 
 #include "AliRoot/TrackerCallback.hpp"
 
-ClassImp(AliMUONHLT::TrackerCallback)
+ClassImp(AliHLTMUONTrackerCallback)
index 3bbe192fc23e619a13528d4f5fc41d68d7adfca0..90a9e6c1b7dfc7c3d7e090584bfa6084ad28a9bb 100644 (file)
@@ -5,17 +5,13 @@
 //
 ////////////////////////////////////////////////////////////////////////////////
 
-#ifndef dHLT_ALIROOT_TRACKER_CALLBACK_HPP
-#define dHLT_ALIROOT_TRACKER_CALLBACK_HPP
+#ifndef ALIHLTMUONTRACKERCALLBACK_H
+#define ALIHLTMUONTRACKERCALLBACK_H
 
 #include "TObject.h"
 
 
-namespace AliMUONHLT
-{
-
-
-class TrackerCallback : public TObject
+class AliHLTMUONTrackerCallback : public TObject
 {
 public:
 
@@ -27,10 +23,8 @@ public:
        virtual void FoundTrack() = 0;
        virtual void NoTrackFound() = 0;
        
-       ClassDef(TrackerCallback, 0)  // Abstract tracker callback class.
+       ClassDef(AliHLTMUONTrackerCallback, 0)  // Abstract tracker callback class.
 };
 
 
-} // AliMUONHLT
-
-#endif // dHLT_ALIROOT_TRACKER_CALLBACK_HPP
+#endif // ALIHLTMUONTRACKERCALLBACK_H
index 0f7143796acb99fabdd9c123d3544bbe72835a5c..a342b7cbcfad0daf2cf6af87969edd5a3d71b335 100644 (file)
@@ -5,48 +5,42 @@
 //
 ////////////////////////////////////////////////////////////////////////////////
 
-#ifndef dHLT_ALIROOT_TRACKER_INTERFACE_HPP
-#define dHLT_ALIROOT_TRACKER_INTERFACE_HPP
+#ifndef ALIHLTMUONTRACKERINTERFACE_H
+#define ALIHLTMUONTRACKERINTERFACE_H
 
 #include "Rtypes.h"
 
+class AliHLTMUONPoint;
+class AliHLTMUONTriggerRecord;
+class AliHLTMUONTrack;
+class AliHLTMUONTrackerCallback;
+class AliHLTMUONDummyTracker;
 
-namespace AliMUONHLT
-{
-
-class Point;
-class TriggerRecord;
-class Track;
-class Tracker;
-class TrackerCallback;
 
-
-class TrackerInterface
+class AliHLTMUONTrackerInterface
 {
 public:
-       TrackerInterface(Tracker* tracker)
+       AliHLTMUONTrackerInterface(AliHLTMUONDummyTracker* tracker)
        {
                fTracker = tracker;
        };
        
-       const Tracker* GetTracker() const
+       const AliHLTMUONDummyTracker* GetTracker() const
        {
                return fTracker;
        };
        
-       void FindTrack(const TriggerRecord& trigger);
-       void ReturnClusters(void* tag, const Point* clusters, UInt_t count);
+       void FindTrack(const AliHLTMUONTriggerRecord& trigger);
+       void ReturnClusters(void* tag, const AliHLTMUONPoint* clusters, UInt_t count);
        void EndOfClusters(void* tag);
-       void FillTrackData(Track& track);
+       void FillTrackData(AliHLTMUONTrack& track);
        void Reset();
-       void SetCallback(TrackerCallback* callback);
+       void SetCallback(AliHLTMUONTrackerCallback* callback);
 
 private:
 
-       Tracker* fTracker;   //! Pointer to interpreted tracker class.
+       AliHLTMUONDummyTracker* fTracker;   //! Pointer to interpreted tracker class.
 };
 
 
-} // AliMUONHLT
-
-#endif // dHLT_ALIROOT_TRACKER_INTERFACE_HPP
+#endif // ALIHLTMUONTRACKERINTERFACE_H
index 7792a3af827b90d547f0d70a1c01b1be58a2a9b4..24649ee67ea36c1a2aee7eb85349d54d473971ec 100644 (file)
 #include "Utils.hpp"
 #include "new.hpp"
 
-namespace dHLT
-{
-namespace AliRoot
-{
 
-
-TrackerProxy::TrackerProxy(AliMUONHLT::TrackerInterface* client)
-       : Tracking::Tracker(), AliMUONHLT::TrackerCallback()
+AliHLTMUONTrackerProxy::AliHLTMUONTrackerProxy(AliHLTMUONTrackerInterface* client)
+       : AliHLTMUONCoreTracker(), AliHLTMUONTrackerCallback()
 {
        tracker = client;
 }
 
 
-void TrackerProxy::FindTrack(const TriggerRecord& trigger)
+void AliHLTMUONTrackerProxy::FindTrack(const AliHLTMUONCoreTriggerRecord& trigger)
 {
-       AliMUONHLT::TriggerRecord rec = Convert(trigger, 0);
-       DebugMsg(6, "TrackerProxy::FindTrack : rec = " << rec);
+       AliHLTMUONTriggerRecord rec = AliHLTMUONConvert(trigger, 0);
+       DebugMsg(6, "AliHLTMUONTrackerProxy::FindTrack : rec = " << rec);
        tracker->FindTrack(rec);
 }
 
 
-void TrackerProxy::ReturnClusters(void* tag, const ClusterPoint* clusters, UInt count)
+void AliHLTMUONTrackerProxy::ReturnClusters(void* tag, const AliHLTMUONCoreClusterPoint* clusters, UInt count)
 {
-       AliMUONHLT::Point* points = new AliMUONHLT::Point[count];
+       AliHLTMUONPoint* points = new AliHLTMUONPoint[count];
        try
        {
-               DebugMsg(6, "TrackerProxy::ReturnClusters");
+               DebugMsg(6, "AliHLTMUONTrackerProxy::ReturnClusters");
                for (UInt i = 0; i < count; i++)
                {
-                       points[i] = Convert(clusters[i]);
+                       points[i] = AliHLTMUONConvert(clusters[i]);
                        DebugMsg(6, "\tpoints[" << i << "] = " << points[i] );
                };
                tracker->ReturnClusters(tag, points, count);
@@ -51,59 +46,56 @@ void TrackerProxy::ReturnClusters(void* tag, const ClusterPoint* clusters, UInt
 }
 
 
-void TrackerProxy::EndOfClusters(void* tag)
+void AliHLTMUONTrackerProxy::EndOfClusters(void* tag)
 {
-       DebugMsg(6, "TrackerProxy::EndOfClusters");
+       DebugMsg(6, "AliHLTMUONTrackerProxy::EndOfClusters");
        tracker->EndOfClusters(tag);
 }
 
 
-void TrackerProxy::FillTrackData(Track& track)
+void AliHLTMUONTrackerProxy::FillTrackData(AliHLTMUONCoreTrack& track)
 {
-       AliMUONHLT::Track data;
+       AliHLTMUONTrack data;
        tracker->FillTrackData(data);
-       DebugMsg(6, "TrackerProxy::FillTrackData : data = " << data);
-       track = Convert(data);
+       DebugMsg(6, "AliHLTMUONTrackerProxy::FillTrackData : data = " << data);
+       track = AliHLTMUONConvert(data);
 }
 
 
-void TrackerProxy::Reset()
+void AliHLTMUONTrackerProxy::Reset()
 {
-       DebugMsg(6, "TrackerProxy::Reset");
+       DebugMsg(6, "AliHLTMUONTrackerProxy::Reset");
        tracker->Reset();
 }
 
 
-void TrackerProxy::RequestClusters(
+void AliHLTMUONTrackerProxy::RequestClusters(
                Float_t left, Float_t right, Float_t bottom, Float_t top,
                Int_t chamber, const void* tag
        )
 {
-       DebugMsg(6, "TrackerProxy::RequestClusters");
-       Tracking::Tracker::RequestClusters(left, right, bottom, top, (ChamberID)chamber, tag);
+       DebugMsg(6, "AliHLTMUONTrackerProxy::RequestClusters");
+       AliHLTMUONCoreTracker::RequestClusters(left, right, bottom, top, (AliHLTMUONCoreChamberID)chamber, tag);
 }
 
 
-void TrackerProxy::EndOfClusterRequests()
+void AliHLTMUONTrackerProxy::EndOfClusterRequests()
 {
-       DebugMsg(6, "TrackerProxy::EndOfClusterRequests");
-       Tracking::Tracker::EndOfClusterRequests();
+       DebugMsg(6, "AliHLTMUONTrackerProxy::EndOfClusterRequests");
+       AliHLTMUONCoreTracker::EndOfClusterRequests();
 }
 
 
-void TrackerProxy::FoundTrack()
+void AliHLTMUONTrackerProxy::FoundTrack()
 {
-       DebugMsg(6, "TrackerProxy::FoundTrack");
-       Tracking::Tracker::FoundTrack();
+       DebugMsg(6, "AliHLTMUONTrackerProxy::FoundTrack");
+       AliHLTMUONCoreTracker::FoundTrack();
 }
 
 
-void TrackerProxy::NoTrackFound()
+void AliHLTMUONTrackerProxy::NoTrackFound()
 {
-       DebugMsg(6, "TrackerProxy::NoTrackFound");
-       Tracking::Tracker::NoTrackFound();
+       DebugMsg(6, "AliHLTMUONTrackerProxy::NoTrackFound");
+       AliHLTMUONCoreTracker::NoTrackFound();
 }
 
-
-} // AliRoot
-} // dHLT
index b67b3ba0f64545c2c4fc2edad30095f1e4934a8e..057d1af40db1a2e49bc4e31add6357512b3c1174 100644 (file)
@@ -5,34 +5,29 @@
 //
 ////////////////////////////////////////////////////////////////////////////////
 
-#ifndef dHLT_ALIROOT_TRACKER_PROXY_HPP
-#define dHLT_ALIROOT_TRACKER_PROXY_HPP
+#ifndef ALIHLTMUONTRACKERPROXY_H
+#define ALIHLTMUONTRACKERPROXY_H
 
 #include "Tracking/Tracker.hpp"
 #include "AliRoot/TrackerCallback.hpp"
 #include "AliRoot/TrackerInterface.hpp"
 
-namespace dHLT
-{
-namespace AliRoot
-{
 
-
-class TrackerProxy : public Tracking::Tracker, public AliMUONHLT::TrackerCallback
+class AliHLTMUONTrackerProxy : public AliHLTMUONCoreTracker, public AliHLTMUONTrackerCallback
 {
 public:
 
-       TrackerProxy(AliMUONHLT::TrackerInterface* client);
-       virtual ~TrackerProxy() {};
+       AliHLTMUONTrackerProxy(AliHLTMUONTrackerInterface* client);
+       virtual ~AliHLTMUONTrackerProxy() {};
 
        // inherited methods from Tracking::Tracker:
-       virtual void FindTrack(const TriggerRecord& trigger);
-       virtual void ReturnClusters(void* tag, const ClusterPoint* clusters, UInt count);
+       virtual void FindTrack(const AliHLTMUONCoreTriggerRecord& trigger);
+       virtual void ReturnClusters(void* tag, const AliHLTMUONCoreClusterPoint* clusters, UInt count);
        virtual void EndOfClusters(void* tag);
-       virtual void FillTrackData(Track& track);
+       virtual void FillTrackData(AliHLTMUONCoreTrack& track);
        virtual void Reset();
 
-       // inherited methods from AliMUONHLT::TrackerCallback:
+       // inherited methods from AliHLTMUONTrackerCallback:
        virtual void RequestClusters(
                        Float_t left, Float_t right, Float_t bottom, Float_t top,
                        Int_t chamber, const void* tag = NULL
@@ -43,11 +38,8 @@ public:
 
 private:
 
-       AliMUONHLT::TrackerInterface* tracker;  // The tracker we are proxying for.
+       AliHLTMUONTrackerInterface* tracker;  // The tracker we are proxying for.
 };
 
 
-} // AliRoot
-} // dHLT
-
-#endif // dHLT_ALIROOT_TRACKER_PROXY_HPP
+#endif // ALIHLTMUONTRACKERPROXY_H
index d0a2ddd206fd1e2312b488aaa2f5c760dad478bf..861602dbdde5bf6b2349459748a8779acaf23140 100644 (file)
@@ -8,26 +8,24 @@
 #include "AliRoot/TriggerRecord.hpp"
 #include "TMath.h"
 
-ClassImp(AliMUONHLT::TriggerRecord)
+ClassImp(AliHLTMUONTriggerRecord)
 
-namespace AliMUONHLT
-{
 
-TriggerRecord::TriggerRecord()
+AliHLTMUONTriggerRecord::AliHLTMUONTriggerRecord()
 {
        Init();
 }
 
 
-TriggerRecord::TriggerRecord(
+AliHLTMUONTriggerRecord::AliHLTMUONTriggerRecord(
                Int_t triggernumber, Int_t sign, Float_t pt,
-               const Point& station1point, const Point& station2point
+               const AliHLTMUONPoint& station1point, const AliHLTMUONPoint& station2point
        )
 {
        if (triggernumber < 0)
        {
                Init();
-               Error("TriggerRecord",
+               Error("AliHLTMUONTriggerRecord",
                        "The trigger number must be a positive number. Got: %d",
                        triggernumber
                );
@@ -35,7 +33,7 @@ TriggerRecord::TriggerRecord(
        else if (sign < -1 || +1 < sign)
        {
                Init();
-               Error("TriggerRecord",
+               Error("AliHLTMUONTriggerRecord",
                        "The particle sign must a value of -1, 0 or +1. Got: %d",
                        sign
                );
@@ -43,7 +41,7 @@ TriggerRecord::TriggerRecord(
        else if (pt < 0.0)
        {
                Init();
-               Error("TriggerRecord",
+               Error("AliHLTMUONTriggerRecord",
                        "The transverse momentum must be a positive number. Got: %f",
                        pt
                );
@@ -59,7 +57,7 @@ TriggerRecord::TriggerRecord(
 }
 
 
-void TriggerRecord::Init()
+void AliHLTMUONTriggerRecord::Init()
 {
        fTriggerNumber = -1;
        fParticleSign = 0;
@@ -67,7 +65,7 @@ void TriggerRecord::Init()
 }
 
 
-void TriggerRecord::TriggerNumber(Int_t value)
+void AliHLTMUONTriggerRecord::TriggerNumber(Int_t value)
 {
        if (value >= 0)
                fTriggerNumber = value;
@@ -79,7 +77,7 @@ void TriggerRecord::TriggerNumber(Int_t value)
 }
 
 
-void TriggerRecord::ParticleSign(Int_t value)
+void AliHLTMUONTriggerRecord::ParticleSign(Int_t value)
 {
        if (-1 <= value && value <= +1)
                fParticleSign = value;
@@ -91,7 +89,7 @@ void TriggerRecord::ParticleSign(Int_t value)
 }
 
 
-void TriggerRecord::Pt(Float_t value)
+void AliHLTMUONTriggerRecord::Pt(Float_t value)
 {
        if (value >= 0)
                fPt = value;
@@ -103,7 +101,7 @@ void TriggerRecord::Pt(Float_t value)
 }
 
 
-ostream& operator << (ostream& os, const TriggerRecord& r)
+ostream& operator << (ostream& os, const AliHLTMUONTriggerRecord& r)
 {
        os << "{trig#: " << r.fTriggerNumber << ", sign: " << r.fParticleSign
           << ", pt: " << r.fPt << ", st1: " << r.fSt1Point << ", st2: "
@@ -111,5 +109,3 @@ ostream& operator << (ostream& os, const TriggerRecord& r)
        return os;
 }
 
-
-} // AliMUONHLT
index c28ea516060ea3cf2d4b9e01ead3f2ec873f7516..4aaa94603bc7996a126632abd9e4ea22caac34f2 100644 (file)
@@ -5,25 +5,22 @@
 //
 ////////////////////////////////////////////////////////////////////////////////
 
-#ifndef dHLT_ALIROOT_TRIGGER_RECORD_HPP
-#define dHLT_ALIROOT_TRIGGER_RECORD_HPP
+#ifndef ALIHLTMUONTRIGGERRECORD_H
+#define ALIHLTMUONTRIGGERRECORD_H
 
 #include <TObject.h>
 #include "AliRoot/Point.hpp"
 #include "Utils.hpp"
 
-namespace AliMUONHLT
-{
-
 
-class TriggerRecord : public TObject
+class AliHLTMUONTriggerRecord : public TObject
 {
 public:
 
        /* Default constructor initialises everything to zero and the trigger
           number to -1.
         */
-       TriggerRecord();
+       AliHLTMUONTriggerRecord();
        
        /* Creates a trigger record from the specified parameters.
           Note: the trigger number must be greater or equal to zero. The particle
@@ -32,12 +29,12 @@ public:
           If these conditions are not met then an error message is displayed and
           the object is filled like it is in the default constructor. 
         */
-       TriggerRecord(
+       AliHLTMUONTriggerRecord(
                        Int_t triggernumber, Int_t sign, Float_t pt,
-                       const Point& station1point, const Point& station2point
+                       const AliHLTMUONPoint& station1point, const AliHLTMUONPoint& station2point
                );
 
-       virtual ~TriggerRecord() {};
+       virtual ~AliHLTMUONTriggerRecord() {};
        
        /* Get/Set method for the trigger number. 
           The trigger number must be positive when assigning the trigger number.
@@ -65,15 +62,15 @@ public:
        
        /* Get/Set methods for the two trigger stations.
         */
-       void Station1Point(const Point& value) { fSt1Point = value; };
-       Point& Station1Point() { return fSt1Point; };
-       const Point& Station1Point() const { return fSt1Point; };
-       void Station2Point(const Point& value) { fSt2Point = value; };
-       Point& Station2Point() { return fSt2Point; };
-       const Point& Station2Point() const { return fSt2Point; };
+       void Station1Point(const AliHLTMUONPoint& value) { fSt1Point = value; };
+       AliHLTMUONPoint& Station1Point() { return fSt1Point; };
+       const AliHLTMUONPoint& Station1Point() const { return fSt1Point; };
+       void Station2Point(const AliHLTMUONPoint& value) { fSt2Point = value; };
+       AliHLTMUONPoint& Station2Point() { return fSt2Point; };
+       const AliHLTMUONPoint& Station2Point() const { return fSt2Point; };
 
        // ostream operator usefull for text output.
-       friend ostream& operator << (ostream& os, const TriggerRecord& r);
+       friend ostream& operator << (ostream& os, const AliHLTMUONTriggerRecord& r);
 
 private:
 
@@ -83,13 +80,11 @@ private:
        Int_t fTriggerNumber;  // The trigger number/index in AliMUONDataInterface.
        Int_t fParticleSign;   // -1 = negative, 0 = unknown, +1 = positive.
        Float_t fPt;           // Transverse momentum of the particle.
-       Point fSt1Point;       // Coordinate on trigger station 1.
-       Point fSt2Point;       // Coordinate on trigger station 2.
+       AliHLTMUONPoint fSt1Point;       // Coordinate on trigger station 1.
+       AliHLTMUONPoint fSt2Point;       // Coordinate on trigger station 2.
 
-       ClassDef(TriggerRecord, 1)  // Trigger information.
+       ClassDef(AliHLTMUONTriggerRecord, 1)  // Trigger information.
 };
 
 
-} // AliMUONHLT
-
-#endif // dHLT_ALIROOT_TRIGGER_RECORD_HPP
+#endif // ALIHLTMUONTRIGGERRECORD_H
index 8cb50d20beec92fce5172ae2fe2e93b1daf0318e..6a69377de2c7c5066ea8a420774b9d2eef042da5 100644 (file)
 #include <float.h>
 #endif
 
-ClassImp(AliMUONHLT::TriggerSource)
-ClassImp(AliMUONHLT::TriggerSource::EventData)
+ClassImp(AliHLTMUONTriggerSource)
+ClassImp(AliHLTMUONTriggerSource::EventData)
 
-namespace AliMUONHLT
-{
 
-TriggerSource::TriggerSource()
-       : TObject(), fEventList(TriggerSource::EventData::Class())
+AliHLTMUONTriggerSource::AliHLTMUONTriggerSource()
+       : TObject(), fEventList(AliHLTMUONTriggerSource::EventData::Class())
 {
        fAreaToUse = FromWholePlane;
        fDataToUse = FromLocalTriggers;
@@ -44,8 +42,8 @@ TriggerSource::TriggerSource()
 }
 
 
-TriggerSource::TriggerSource(AliMUONDataInterface* data)
-       : TObject(), fEventList(TriggerSource::EventData::Class())
+AliHLTMUONTriggerSource::AliHLTMUONTriggerSource(AliMUONDataInterface* data)
+       : TObject(), fEventList(AliHLTMUONTriggerSource::EventData::Class())
 {
        fAreaToUse = FromWholePlane;
        fDataToUse = FromLocalTriggers;
@@ -59,13 +57,13 @@ TriggerSource::TriggerSource(AliMUONDataInterface* data)
 }
 
 
-TriggerSource::~TriggerSource()
+AliHLTMUONTriggerSource::~AliHLTMUONTriggerSource()
 {
        fEventList.Delete();
 }
 
 
-void TriggerSource::FillFrom(AliMUONDataInterface* data)
+void AliHLTMUONTriggerSource::FillFrom(AliMUONDataInterface* data)
 {
        DebugMsg(1, "FillFrom(AliMUONDataInterface*)");
        
@@ -84,7 +82,7 @@ void TriggerSource::FillFrom(AliMUONDataInterface* data)
 }
 
 
-void TriggerSource::FillFrom(AliMUONDataInterface* data, Int_t event)
+void AliHLTMUONTriggerSource::FillFrom(AliMUONDataInterface* data, Int_t event)
 {
        DebugMsg(1, "FillFrom(AliMUONDataInterface*, Int_t)");
        
@@ -98,7 +96,7 @@ void TriggerSource::FillFrom(AliMUONDataInterface* data, Int_t event)
 }
 
 
-void TriggerSource::FillFrom(
+void AliHLTMUONTriggerSource::FillFrom(
                AliMUONDataInterface* data,
                Int_t event, Int_t trigger, Bool_t newblock
        )
@@ -143,7 +141,7 @@ void TriggerSource::FillFrom(
 }
 
 
-void TriggerSource::Clear(Option_t* /*option*/)
+void AliHLTMUONTriggerSource::Clear(Option_t* /*option*/)
 {
        fFilename = "";
        fFoldername = "";
@@ -152,9 +150,9 @@ void TriggerSource::Clear(Option_t* /*option*/)
 }
 
 
-Bool_t TriggerSource::GetEvent(Int_t eventnumber) const
+Bool_t AliHLTMUONTriggerSource::GetEvent(Int_t eventnumber) const
 {
-       DebugMsg(1, "TriggerSource::GetEvent(" << eventnumber << ")" );
+       DebugMsg(1, "AliHLTMUONTriggerSource::GetEvent(" << eventnumber << ")" );
        
        // Try find the corresponding event in the list of events.
        for (Int_t i = 0; i < fEventList.GetEntriesFast(); i++)
@@ -175,9 +173,9 @@ Bool_t TriggerSource::GetEvent(Int_t eventnumber) const
 }
 
 
-Bool_t TriggerSource::GetFirstEvent() const
+Bool_t AliHLTMUONTriggerSource::GetFirstEvent() const
 {
-       DebugMsg(1, "TriggerSource::GetFirstEvent()");
+       DebugMsg(1, "AliHLTMUONTriggerSource::GetFirstEvent()");
        if (fEventList.GetEntriesFast() > 0)
        {
                fEventIndex = 0;
@@ -198,15 +196,15 @@ Bool_t TriggerSource::GetFirstEvent() const
 }
 
 
-Bool_t TriggerSource::MoreEvents() const
+Bool_t AliHLTMUONTriggerSource::MoreEvents() const
 {
        return 0 <= fEventIndex && fEventIndex < fEventList.GetEntriesFast();
 }
 
 
-Bool_t TriggerSource::GetNextEvent() const
+Bool_t AliHLTMUONTriggerSource::GetNextEvent() const
 {
-       DebugMsg(1, "TriggerSource::GetNextEvent()");
+       DebugMsg(1, "AliHLTMUONTriggerSource::GetNextEvent()");
        if (fEventIndex < fEventList.GetEntriesFast() - 1)
        {
                fCurrentEvent = (EventData*) fEventList[ ++fEventIndex ];
@@ -224,7 +222,7 @@ Bool_t TriggerSource::GetNextEvent() const
 }
 
 
-Int_t TriggerSource::CurrentEvent() const
+Int_t AliHLTMUONTriggerSource::CurrentEvent() const
 {
        if (fCurrentEvent != NULL)
                return fCurrentEvent->fEventNumber;
@@ -233,9 +231,9 @@ Int_t TriggerSource::CurrentEvent() const
 }
 
 
-Int_t TriggerSource::NumberOfBlocks() const
+Int_t AliHLTMUONTriggerSource::NumberOfBlocks() const
 {
-       DebugMsg(1, "TriggerSource::NumberOfBlocks()");
+       DebugMsg(1, "AliHLTMUONTriggerSource::NumberOfBlocks()");
        if (fCurrentEvent == NULL)
        {
                Error("NumberOfBlocks", "No event selected.");
@@ -246,9 +244,9 @@ Int_t TriggerSource::NumberOfBlocks() const
 }
 
 
-Bool_t TriggerSource::GetBlock(Int_t index) const
+Bool_t AliHLTMUONTriggerSource::GetBlock(Int_t index) const
 {
-       DebugMsg(1, "TriggerSource::GetBlock(" << index << ")");
+       DebugMsg(1, "AliHLTMUONTriggerSource::GetBlock(" << index << ")");
        
        // Note NumberOfBlocks() also checks if the event was selected.
        Int_t numberofblocks = NumberOfBlocks();
@@ -282,9 +280,9 @@ Bool_t TriggerSource::GetBlock(Int_t index) const
 }
 
 
-Bool_t TriggerSource::GetFirstBlock() const
+Bool_t AliHLTMUONTriggerSource::GetFirstBlock() const
 {
-       DebugMsg(1, "TriggerSource::GetFirstBlock()");
+       DebugMsg(1, "AliHLTMUONTriggerSource::GetFirstBlock()");
        // Note: NumberOfBlocks() also checks if fCurrentEvent != NULL.
        if (NumberOfBlocks() > 0)
        {
@@ -301,15 +299,15 @@ Bool_t TriggerSource::GetFirstBlock() const
 }
 
 
-Bool_t TriggerSource::MoreBlocks() const
+Bool_t AliHLTMUONTriggerSource::MoreBlocks() const
 {
        return 0 <= fBlockIndex && fBlockIndex < NumberOfBlocks();
 }
 
 
-Bool_t TriggerSource::GetNextBlock() const
+Bool_t AliHLTMUONTriggerSource::GetNextBlock() const
 {
-       DebugMsg(1, "TriggerSource::GetNextBlock()");
+       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.
@@ -330,9 +328,9 @@ Bool_t TriggerSource::GetNextBlock() const
 }
 
 
-Int_t TriggerSource::NumberOfTriggers() const
+Int_t AliHLTMUONTriggerSource::NumberOfTriggers() const
 {
-       DebugMsg(1, "TriggerSource::NumberOfTriggers()");
+       DebugMsg(1, "AliHLTMUONTriggerSource::NumberOfTriggers()");
        if (fCurrentBlock == NULL)
        {
                Error("NumberOfTriggers", "No block selected.");
@@ -343,9 +341,9 @@ Int_t TriggerSource::NumberOfTriggers() const
 }
 
 
-const TriggerRecord* TriggerSource::GetTrigger(Int_t triggernumber) const
+const AliHLTMUONTriggerRecord* AliHLTMUONTriggerSource::GetTrigger(Int_t triggernumber) const
 {
-       DebugMsg(1, "TriggerSource::GetTrigger(" << triggernumber << ")");
+       DebugMsg(1, "AliHLTMUONTriggerSource::GetTrigger(" << triggernumber << ")");
 
        if (fCurrentBlock == NULL)
        {
@@ -356,7 +354,7 @@ const TriggerRecord* TriggerSource::GetTrigger(Int_t triggernumber) const
        // Try find the corresponding trigger record in the list of events.
        for (Int_t i = 0; i < fCurrentBlock->GetEntriesFast(); i++)
        {
-               TriggerRecord* current = (TriggerRecord*) fCurrentBlock->At(i);
+               AliHLTMUONTriggerRecord* current = (AliHLTMUONTriggerRecord*) fCurrentBlock->At(i);
                if (current->TriggerNumber() == triggernumber)
                {
                        fTriggerIndex = i;
@@ -371,14 +369,14 @@ const TriggerRecord* TriggerSource::GetTrigger(Int_t triggernumber) const
 }
 
 
-const TriggerRecord* TriggerSource::GetFirstTrigger() const
+const AliHLTMUONTriggerRecord* AliHLTMUONTriggerSource::GetFirstTrigger() const
 {
-       DebugMsg(1, "TriggerSource::GetFirstTrigger()");
+       DebugMsg(1, "AliHLTMUONTriggerSource::GetFirstTrigger()");
        // Note: NumberOfTriggers() also checks if fCurrentBlock != NULL.
        if (NumberOfTriggers() > 0)
        {
                fTriggerIndex = 0;
-               fCurrentTrigger = (TriggerRecord*) fCurrentBlock->At(0);
+               fCurrentTrigger = (AliHLTMUONTriggerRecord*) fCurrentBlock->At(0);
                DebugMsg(2, "\tfEventIndex = " << fEventIndex << " , fBlockIndex = " << fBlockIndex
                        << " , fTriggerIndex = " << fTriggerIndex
                );
@@ -389,21 +387,21 @@ const TriggerRecord* TriggerSource::GetFirstTrigger() const
 }
 
 
-Bool_t TriggerSource::MoreTriggers() const
+Bool_t AliHLTMUONTriggerSource::MoreTriggers() const
 {
        return 0 <= fTriggerIndex && fTriggerIndex < NumberOfTriggers();
 }
 
 
-const TriggerRecord* TriggerSource::GetNextTrigger() const
+const AliHLTMUONTriggerRecord* AliHLTMUONTriggerSource::GetNextTrigger() const
 {
-       DebugMsg(1, "TriggerSource::GetNextTrigger()");
+       DebugMsg(1, "AliHLTMUONTriggerSource::GetNextTrigger()");
        
        // Note: NumberOfTriggers() checks if fCurrentBlock != NULL. If it is then it returns -1
        // and since fTriggerIndex is always >= -1 the if statement must go to the else part.
        if (fTriggerIndex < NumberOfTriggers() - 1)
        {
-               fCurrentTrigger = (TriggerRecord*) fCurrentBlock->At( ++fTriggerIndex );
+               fCurrentTrigger = (AliHLTMUONTriggerRecord*) fCurrentBlock->At( ++fTriggerIndex );
                DebugMsg(2, "\tfEventIndex = " << fEventIndex << " , fBlockIndex = " << fBlockIndex
                        << " , fTriggerIndex = " << fTriggerIndex
                );
@@ -417,7 +415,7 @@ const TriggerRecord* TriggerSource::GetNextTrigger() const
 }
 
 
-Int_t TriggerSource::CurrentTrigger() const
+Int_t AliHLTMUONTriggerSource::CurrentTrigger() const
 {
        if (fCurrentTrigger != NULL)
        {
@@ -431,9 +429,9 @@ Int_t TriggerSource::CurrentTrigger() const
 }
 
 
-void TriggerSource::AddEvent(Int_t eventnumber)
+void AliHLTMUONTriggerSource::AddEvent(Int_t eventnumber)
 {
-       DebugMsg(1, "TriggerSource::AddEvent(" << eventnumber << ")");
+       DebugMsg(1, "AliHLTMUONTriggerSource::AddEvent(" << eventnumber << ")");
        Assert( eventnumber >= 0 );
 
        // Assume the eventnumber does not already exist in the event list.
@@ -450,9 +448,9 @@ void TriggerSource::AddEvent(Int_t eventnumber)
 }
 
 
-void TriggerSource::AddBlock()
+void AliHLTMUONTriggerSource::AddBlock()
 {
-       DebugMsg(1, "TriggerSource::AddBlock()");
+       DebugMsg(1, "AliHLTMUONTriggerSource::AddBlock()");
        
        if (fCurrentEvent == NULL)
        {
@@ -461,7 +459,7 @@ void TriggerSource::AddBlock()
        }
        
        fBlockIndex = fCurrentEvent->fBlocks.GetEntriesFast();
-       new ( fCurrentEvent->fBlocks[fBlockIndex] ) TClonesArray(TriggerRecord::Class());
+       new ( fCurrentEvent->fBlocks[fBlockIndex] ) TClonesArray(AliHLTMUONTriggerRecord::Class());
        fCurrentBlock = (TClonesArray*) fCurrentEvent->fBlocks[fBlockIndex];
        
        // Remember to reset the trigger pointer because the new block is empty.
@@ -473,9 +471,9 @@ void TriggerSource::AddBlock()
 }
 
 
-void TriggerSource::AddTrigger(const TriggerRecord& data)
+void AliHLTMUONTriggerSource::AddTrigger(const AliHLTMUONTriggerRecord& data)
 {
-       DebugMsg(1, "TriggerSource::AddTrigger(" << (void*)&data << ")");
+       DebugMsg(1, "AliHLTMUONTriggerSource::AddTrigger(" << (void*)&data << ")");
 
        if (fCurrentBlock == NULL)
        {
@@ -484,8 +482,8 @@ void TriggerSource::AddTrigger(const TriggerRecord& data)
        }
        
        fTriggerIndex = fCurrentBlock->GetEntriesFast();
-       new ( (*fCurrentBlock)[fTriggerIndex] ) TriggerRecord(data);
-       fCurrentTrigger = (TriggerRecord*) (*fCurrentBlock)[fTriggerIndex];
+       new ( (*fCurrentBlock)[fTriggerIndex] ) AliHLTMUONTriggerRecord(data);
+       fCurrentTrigger = (AliHLTMUONTriggerRecord*) (*fCurrentBlock)[fTriggerIndex];
        
        DebugMsg(2, "\tfEventIndex = " << fEventIndex << " , fBlockIndex = " << fBlockIndex
                << " , fTriggerIndex = " << fTriggerIndex
@@ -493,7 +491,7 @@ void TriggerSource::AddTrigger(const TriggerRecord& data)
 }
 
 
-Bool_t TriggerSource::FileAndFolderOk(AliMUONDataInterface* data)
+Bool_t AliHLTMUONTriggerSource::FileAndFolderOk(AliMUONDataInterface* data)
 {
        if (fFilename == "")
        {
@@ -525,7 +523,7 @@ Bool_t TriggerSource::FileAndFolderOk(AliMUONDataInterface* data)
 }
 
 
-void TriggerSource::AddEventFrom(AliMUONDataInterface* data, AliMUON* module, Int_t event)
+void AliHLTMUONTriggerSource::AddEventFrom(AliMUONDataInterface* data, AliMUON* module, Int_t event)
 {
        if ( data->GetEvent(event) )
        {
@@ -533,7 +531,7 @@ void TriggerSource::AddEventFrom(AliMUONDataInterface* data, AliMUON* module, In
 
                AddBlock();
                UInt_t currentblocksize = 0;
-               TriggerRecord trigdata;
+               AliHLTMUONTriggerRecord trigdata;
 
                switch (fDataToUse)
                {
@@ -588,11 +586,11 @@ void TriggerSource::AddEventFrom(AliMUONDataInterface* data, AliMUON* module, In
 }
 
 
-void TriggerSource::AddTriggerFrom(AliMUONDataInterface* data, AliMUON* module, Int_t trigger)
+void AliHLTMUONTriggerSource::AddTriggerFrom(AliMUONDataInterface* data, AliMUON* module, Int_t trigger)
 {
        DebugMsg(1, "Entering AddTriggerFrom");
 
-       TriggerRecord trigdata;
+       AliHLTMUONTriggerRecord trigdata;
 
        switch (fDataToUse)
        {
@@ -624,7 +622,7 @@ void TriggerSource::AddTriggerFrom(AliMUONDataInterface* data, AliMUON* module,
 }
 
 
-Bool_t TriggerSource::InFillRegion(const TriggerRecord& data)
+Bool_t AliHLTMUONTriggerSource::InFillRegion(const AliHLTMUONTriggerRecord& data)
 {
        switch (fAreaToUse)
        {
@@ -639,8 +637,8 @@ Bool_t TriggerSource::InFillRegion(const TriggerRecord& data)
 }
 
 
-void TriggerSource::FillTriggerFromLocalTrigger(
-               AliMUONLocalTrigger* trigger, AliMUON* module, TriggerRecord& record
+void AliHLTMUONTriggerSource::FillTriggerFromLocalTrigger(
+               AliMUONLocalTrigger* trigger, AliMUON* module, AliHLTMUONTriggerRecord& record
        )
 {
        DebugMsg(2, "Creating TriggerRecord from AliMUONLocalTrigger object: " << (void*)trigger );
@@ -687,7 +685,9 @@ void TriggerSource::FillTriggerFromLocalTrigger(
 }
 
 
-Bool_t TriggerSource::FillTriggerFromHits(AliMUONDataInterface* data, Int_t track, TriggerRecord& record)
+Bool_t AliHLTMUONTriggerSource::FillTriggerFromHits(
+               AliMUONDataInterface* data, Int_t track, AliHLTMUONTriggerRecord& record
+       )
 {
        DebugMsg(2, "Creating TriggerRecord from hits on track: " << track );
        
@@ -792,7 +792,7 @@ Bool_t TriggerSource::FillTriggerFromHits(AliMUONDataInterface* data, Int_t trac
                        << ", z2 = " << z2
                );
        // Calculate and assign the transverse momentum.
-       Float_t pt = dHLT::Tracking::CalculatePt(
+       Float_t pt = AliHLTMUONCoreCalculatePt(
                                record.Station1Point().fX,
                                record.Station1Point().fY, record.Station2Point().fY,
                                z1, z2
@@ -805,7 +805,7 @@ Bool_t TriggerSource::FillTriggerFromHits(AliMUONDataInterface* data, Int_t trac
 }
 
 
-Bool_t TriggerSource::FetchAliMUON(AliMUON*& module)
+Bool_t AliHLTMUONTriggerSource::FetchAliMUON(AliMUON*& module)
 {
        // Check if we even need the MUON module. Not having to load it will
        // save a lot of loading time for AliRoot.
@@ -847,7 +847,7 @@ Bool_t TriggerSource::FetchAliMUON(AliMUON*& module)
 }
 
 
-void TriggerSource::FinishedWithAliMUON()
+void AliHLTMUONTriggerSource::FinishedWithAliMUON()
 {
        // Only unload the gAlice object if we had to load it ourselves.
        if (fHadToLoadgAlice)
@@ -855,7 +855,7 @@ void TriggerSource::FinishedWithAliMUON()
 }
 
 
-void TriggerSource::ResetAllPointers() const
+void AliHLTMUONTriggerSource::ResetAllPointers() const
 {
        fEventIndex = -1;
        fCurrentEvent = NULL;
@@ -869,7 +869,7 @@ void TriggerSource::ResetAllPointers() const
 }
 
 
-void TriggerSource::ResetBlockPointers() const
+void AliHLTMUONTriggerSource::ResetBlockPointers() const
 {
        fBlockIndex = -1;
        fCurrentBlock = NULL;
@@ -881,7 +881,7 @@ void TriggerSource::ResetBlockPointers() const
 }
 
 
-void TriggerSource::ResetTriggerPointers() const
+void AliHLTMUONTriggerSource::ResetTriggerPointers() const
 {
        fTriggerIndex = -1;
        fCurrentTrigger = NULL;
@@ -891,13 +891,13 @@ void TriggerSource::ResetTriggerPointers() const
 }
 
 
-TriggerSource::EventData::EventData() : fBlocks(TClonesArray::Class())
+AliHLTMUONTriggerSource::EventData::EventData() : fBlocks(TClonesArray::Class())
 {
        fEventNumber = -1;
 }
 
 
-TriggerSource::EventData::EventData(Int_t eventnumber)
+AliHLTMUONTriggerSource::EventData::EventData(Int_t eventnumber)
        : fBlocks(TClonesArray::Class())
 {
        fEventNumber = eventnumber;
@@ -907,10 +907,8 @@ TriggerSource::EventData::EventData(Int_t eventnumber)
 }
 
 
-TriggerSource::EventData::~EventData()
+AliHLTMUONTriggerSource::EventData::~EventData()
 {
        //fBlocks.Clear("C");  // Done in fBlocks destructor 
 }
 
-
-} // AliMUONHLT
index 4e7a916f0c9afc594acbd7404318a7a48f65de00..3371c34fa3ce7956ea476e92c4363b3412caa991 100644 (file)
@@ -5,8 +5,8 @@
 //
 ////////////////////////////////////////////////////////////////////////////////
 
-#ifndef dHLT_ALIROOT_TRIGGER_SOURCE_HPP
-#define dHLT_ALIROOT_TRIGGER_SOURCE_HPP
+#ifndef ALIHLTMUONTRIGGERSOURCE_H
+#define ALIHLTMUONTRIGGERSOURCE_H
 
 #include "TROOT.h"
 #include "TObject.h"
@@ -19,11 +19,7 @@ class AliMUONLocalTrigger;
 class AliMUONDataInterface;
 
 
-namespace AliMUONHLT
-{
-
-
-class TriggerSource : public TObject
+class AliHLTMUONTriggerSource : public TObject
 {
 public:
 
@@ -41,13 +37,13 @@ public:
        };
 
 
-       TriggerSource();
+       AliHLTMUONTriggerSource();
        
        /* Creates a new trigger source object by filling data from the data interface.
         */
-       TriggerSource(AliMUONDataInterface* data);
+       AliHLTMUONTriggerSource(AliMUONDataInterface* data);
        
-       virtual ~TriggerSource();
+       virtual ~AliHLTMUONTriggerSource();
        
        /* Get and set methods to specify how the FillFrom methods should fill the
           internal data structures.
@@ -98,14 +94,14 @@ public:
         */
        Int_t NumberOfEvents() const { return fEventList.GetEntriesFast(); };
        
-       /* Fetches the specified event number stored in this TriggerSource.
+       /* 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.
         */
        Bool_t GetEvent(Int_t eventnumber) const;
        
-       /* Fetches the first event stored in this TriggerSource.
+       /* 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.
@@ -169,12 +165,12 @@ public:
           the current block.
           NULL is returned if the record was not found.
         */
-       const TriggerRecord* GetTrigger(Int_t triggernumber) const;
+       const AliHLTMUONTriggerRecord* GetTrigger(Int_t triggernumber) const;
        
        /* Fetches the first trigger record in the current block.
           NULL is returned if the record was not found.
         */
-       const TriggerRecord* GetFirstTrigger() const;
+       const AliHLTMUONTriggerRecord* GetFirstTrigger() const;
        
        /* Returns kTRUE if there are more triggers to iterate over.
         */
@@ -183,12 +179,12 @@ public:
        /* Fetches the next trigger record in the current block.
           NULL is returned if the record was not found.
         */
-       const TriggerRecord* GetNextTrigger() const;
+       const AliHLTMUONTriggerRecord* GetNextTrigger() const;
        
        /* Returns the current trigger record.
           NULL is returned if the record was not found.
         */
-       const TriggerRecord* GetTrigger() const { return fCurrentTrigger; };
+       const AliHLTMUONTriggerRecord* GetTrigger() const { return fCurrentTrigger; };
        
        /* Returns the trigger record number for the currently selected trigger record.
           This number corresponds to the index'th AliMUONLocalTrigger object for the
@@ -212,9 +208,9 @@ private:
        /* Adds a new trigger record to the current event and block.
           The fCurrentTrigger is updated appropriately.
         */
-       void AddTrigger(const TriggerRecord& data);
+       void AddTrigger(const AliHLTMUONTriggerRecord& data);
        
-       /* Checks if the file and folder names correspond to this TriggerSource's 
+       /* 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.
@@ -237,7 +233,7 @@ private:
           we want to fill from.
           kTRUE is returned if (x, y) is in the region, and kFALSE otherwise.
         */
-       Bool_t InFillRegion(const TriggerRecord& data);
+       Bool_t InFillRegion(const AliHLTMUONTriggerRecord& data);
        
        /* Fills the trigger data from the AliMUONLocalTrigger object.
           if the fUseLookupTable is set to true then we use the L0 lookup table to
@@ -245,14 +241,14 @@ private:
           Note the fTriggerNumber parameter is not filled in to 'record'.
         */
        void FillTriggerFromLocalTrigger(
-                       AliMUONLocalTrigger* trigger, AliMUON* module, TriggerRecord& record
+                       AliMUONLocalTrigger* trigger, AliMUON* module, 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.
         */
-       Bool_t FillTriggerFromHits(AliMUONDataInterface* data, Int_t track, TriggerRecord& record);
+       Bool_t FillTriggerFromHits(AliMUONDataInterface* data, Int_t track, AliHLTMUONTriggerRecord& record);
        
        /* 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
@@ -314,16 +310,14 @@ private:
        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.
-       mutable TriggerRecord* fCurrentTrigger;  //! Pointer to the currently selected trigger record.
+       mutable AliHLTMUONTriggerRecord* fCurrentTrigger;  //! Pointer to the currently selected trigger record.
 
        TClonesArray fEventList;   // List of trigger records per event.
        
        Bool_t fHadToLoadgAlice;  //! Flag indicating if this object had to load the AliRun object.
 
-       ClassDef(TriggerSource, 1)  // The source of trigger records for dHLT.
+       ClassDef(AliHLTMUONTriggerSource, 1)  // The source of trigger records for dHLT.
 };
 
 
-} // AliMUONHLT
-
-#endif // dHLT_ALIROOT_TRIGGER_SOURCE_HPP
+#endif // ALIHLTMUONTRIGGERSOURCE_H
index 87e391056b2de393a24e18b3c2ad2ab48ae073f4..4b2a5744e20b1274ba1afde30126afe3f356da29 100644 (file)
 #include "Utils.hpp"
 #include "Error.hpp"
 
-namespace dHLT
-{
-namespace AliRoot
-{
 
-
-AliMUONHLT::Point Convert(const dHLT::Point& point)
+AliHLTMUONPoint AliHLTMUONConvert(const AliHLTMUONCorePoint& point)
 {
-       DebugMsg(5, "Convert from dHLT::Point");
-       return AliMUONHLT::Point(point.x, point.y);
+       DebugMsg(5, "Convert from AliHLTMUONCorePoint");
+       return AliHLTMUONPoint(point.fX, point.fY);
 }
 
 
-dHLT::Point Convert(const AliMUONHLT::Point& point)
+AliHLTMUONCorePoint AliHLTMUONConvert(const AliHLTMUONPoint& point)
 {
-       DebugMsg(5, "Convert from AliMUONHLT::Point");
-       return dHLT::Point(point.fX, point.fY);
+       DebugMsg(5, "Convert from AliHLTMUONPoint");
+       return AliHLTMUONCorePoint(point.fX, point.fY);
 }
 
 
-AliMUONHLT::TriggerRecord Convert(const dHLT::TriggerRecord& record, Int_t triggernumber)
+AliHLTMUONTriggerRecord AliHLTMUONConvert(const AliHLTMUONCoreTriggerRecord& record, Int_t triggernumber)
 {
        DebugMsg(5, "Convert from dHLT::TriggerRecord");
        // If the trigger number is negative then set it to zero.
        if (triggernumber >= 0)
        {
-               return AliMUONHLT::TriggerRecord(
+               return AliHLTMUONTriggerRecord(
                                        triggernumber,
-                                       record.sign,
-                                       record.pt,
-                                       Convert( record.station1impact ),
-                                       Convert( record.station2impact )
+                                       record.fSign,
+                                       record.fPt,
+                                       AliHLTMUONConvert( record.fStation1impact ),
+                                       AliHLTMUONConvert( record.fStation2impact )
                                );
        }
        else
        {
-               return AliMUONHLT::TriggerRecord(
+               return AliHLTMUONTriggerRecord(
                                        0,
-                                       record.sign,
-                                       record.pt,
-                                       Convert( record.station1impact ),
-                                       Convert( record.station2impact )
+                                       record.fSign,
+                                       record.fPt,
+                                       AliHLTMUONConvert( record.fStation1impact ),
+                                       AliHLTMUONConvert( record.fStation2impact )
                                );
        }
 }
 
 
-dHLT::TriggerRecord Convert(const AliMUONHLT::TriggerRecord& record)
+AliHLTMUONCoreTriggerRecord AliHLTMUONConvert(const AliHLTMUONTriggerRecord& record)
 {
-       DebugMsg(5, "Convert from AliMUONHLT::TriggerRecord");
-       return dHLT::TriggerRecord(
-                               (dHLT::ParticleSign) record.ParticleSign(),
+       DebugMsg(5, "Convert from AliHLTMUONTriggerRecord");
+       return AliHLTMUONCoreTriggerRecord(
+                               (AliHLTMUONCoreParticleSign) record.ParticleSign(),
                                record.Pt(),
-                               Convert( record.Station1Point() ),
-                               Convert( record.Station2Point() )
+                               AliHLTMUONConvert( record.Station1Point() ),
+                               AliHLTMUONConvert( record.Station2Point() )
                        );
 }
 
 
-AliMUONHLT::Track Convert(const dHLT::Track& track)
+AliHLTMUONTrack AliHLTMUONConvert(const AliHLTMUONCoreTrack& track)
 {
        DebugMsg(5, "Convert from dHLT::Track");
-       AliMUONHLT::Track t;
-       t.TriggerID( track.triggerid );
-       t.ParticleSign( track.sign );
-       t.P( track.p );
-       t.Pt( track.pt );
+       AliHLTMUONTrack t;
+       t.TriggerID( track.fTriggerid );
+       t.ParticleSign( track.fSign );
+       t.P( track.fP );
+       t.Pt( track.fPt );
        for (Int_t i = 0; i < 10; i++)
        {
-               t.Hit(i) = Convert( track.point[i] );
+               t.Hit(i) = AliHLTMUONConvert( track.fPoint[i] );
                
                // Only convert if the ROI is valid. Otherwise the Region object
                // is filled with NaN's.
-               if (track.region[i] != dHLT::INVALID_ROI)
-                       t.RegionOfInterest(i) = Convert( track.region[i] );
+               if (track.fRegion[i] != kINVALID_ROI)
+                       t.RegionOfInterest(i) = AliHLTMUONConvert( track.fRegion[i] );
        }
        return t;
 }
 
 
-dHLT::Track Convert(const AliMUONHLT::Track& track)
+AliHLTMUONCoreTrack AliHLTMUONConvert(const AliHLTMUONTrack& track)
 {
-       DebugMsg(5, "Convert from AliMUONHLT::Track");
-       dHLT::Track t;
-       t.triggerid = track.TriggerID();
-       t.sign = (dHLT::ParticleSign) track.ParticleSign();
-       t.p = track.P();
-       t.pt = track.Pt();
+       DebugMsg(5, "Convert from AliHLTMUONTrack");
+       AliHLTMUONCoreTrack t;
+       t.fTriggerid = track.TriggerID();
+       t.fSign = (AliHLTMUONCoreParticleSign) track.ParticleSign();
+       t.fP = track.P();
+       t.fPt = track.Pt();
        for (Int_t i = 0; i < 10; i++)
        {
-               t.point[i] = Convert( track.Hit(i) );
-               t.region[i] = Convert( track.RegionOfInterest(i), i );
+               t.fPoint[i] = AliHLTMUONConvert( track.Hit(i) );
+               t.fRegion[i] = AliHLTMUONConvert( track.RegionOfInterest(i), i );
        }
        return t;
 }
 
 
-AliMUONHLT::Region Convert(const dHLT::ROI region)
+AliHLTMUONRegion AliHLTMUONConvert(const AliHLTMUONCoreROI region)
 {
-       DebugMsg(5, "Convert from dHLT::ROI");
-       dHLT::RegionOfInterest roi(region);
-       return AliMUONHLT::Region( roi.Left(), roi.Right(), roi.Bottom(), roi.Top() );
+       DebugMsg(5, "Convert from AliHLTMUONCoreROI");
+       AliHLTMUONCoreRegionOfInterest roi(region);
+       return AliHLTMUONRegion( roi.Left(), roi.Right(), roi.Bottom(), roi.Top() );
 }
 
 
-dHLT::ROI Convert(const AliMUONHLT::Region& region, UInt_t chamber)
+AliHLTMUONCoreROI AliHLTMUONConvert(const AliHLTMUONRegion& region, UInt_t chamber)
 {
-       DebugMsg(5, "Convert from AliMUONHLT::Region");
+       DebugMsg(5, "Convert from AliHLTMUONRegion");
        // If the chamber number is too big then truncate it.
        if (chamber < 10)
        {
-               dHLT::RegionOfInterest roi(
+               AliHLTMUONCoreRegionOfInterest roi(
                                region.Left(), region.Right(), region.Bottom(), region.Top(),
-                               (dHLT::ChamberID) chamber
+                               (AliHLTMUONCoreChamberID) chamber
                        );
                return roi;
        }
        else
        {
-               dHLT::RegionOfInterest roi(
+               AliHLTMUONCoreRegionOfInterest roi(
                                region.Left(), region.Right(), region.Bottom(), region.Top(),
-                               dHLT::Chamber10
+                               kChamber10
                        );
                return roi;
        }
 }
 
-
-} // AliRoot
-} // dHLT
index 71ef9195606fd21b8c5e80b2fe4315b348e6bb31..e369531adf915bbffc468a45086db79cb1783255 100644 (file)
@@ -5,8 +5,8 @@
 //
 ////////////////////////////////////////////////////////////////////////////////
 
-#ifndef dHLT_ALIROOT_CONVERT_HPP
-#define dHLT_ALIROOT_CONVERT_HPP
+#ifndef ALIHLTMUONCONVERT_H
+#define ALIHLTMUONCONVERT_H
 
 #include "../Point.hpp"
 #include "AliRoot/Point.hpp"
 #include "../RegionOfInterest.hpp"
 #include "AliRoot/Region.hpp"
 
-namespace dHLT
-{
-namespace AliRoot
-{
-
-
 /* Conversion routines to convert from dHLT structures to AliRoot structures
    and back again.
  */
-extern AliMUONHLT::Point         Convert(const dHLT::Point&               point);
-extern dHLT::Point               Convert(const AliMUONHLT::Point&         point);
-extern AliMUONHLT::TriggerRecord Convert(const dHLT::TriggerRecord&       record, Int_t triggernumber);
-extern dHLT::TriggerRecord       Convert(const AliMUONHLT::TriggerRecord& record);
-extern AliMUONHLT::Track         Convert(const dHLT::Track&               track);
-extern dHLT::Track               Convert(const AliMUONHLT::Track&         track);
-extern AliMUONHLT::Region        Convert(const dHLT::ROI                  region);
-extern dHLT::ROI                 Convert(const AliMUONHLT::Region&        region, UInt_t chamber);
-
+extern AliHLTMUONPoint             AliHLTMUONConvert(const AliHLTMUONCorePoint&         point);
+extern AliHLTMUONCorePoint         AliHLTMUONConvert(const AliHLTMUONPoint&             point);
+extern AliHLTMUONTriggerRecord     AliHLTMUONConvert(const AliHLTMUONCoreTriggerRecord& record, Int_t triggernumber);
+extern AliHLTMUONCoreTriggerRecord AliHLTMUONConvert(const AliHLTMUONTriggerRecord&     record);
+extern AliHLTMUONTrack             AliHLTMUONConvert(const AliHLTMUONCoreTrack&         track);
+extern AliHLTMUONCoreTrack         AliHLTMUONConvert(const AliHLTMUONTrack&             track);
+extern AliHLTMUONRegion            AliHLTMUONConvert(const AliHLTMUONCoreROI            region);
+extern AliHLTMUONCoreROI           AliHLTMUONConvert(const AliHLTMUONRegion&            region, UInt_t chamber);
 
-} // AliRoot
-} // dHLT
 
-#endif // dHLT_ALIROOT_CONVERT_HPP
+#endif // ALIHLTMUONCONVERT_H
index aed3c656e140aeded86ec82e5570e5b1ab59977b..7c78bb4ca45580efbaed296b438ef6acd1279fd9 100644 (file)
@@ -5,11 +5,8 @@
 //
 ////////////////////////////////////////////////////////////////////////////////
 
-#ifndef dHLT_BASIC_TYPES_HPP
-#define dHLT_BASIC_TYPES_HPP
-
-namespace dHLT
-{
+#ifndef ALIHLTMUONBASICTYPES_H
+#define ALIHLTMUONBASICTYPES_H
 
 
 #ifndef NULL
@@ -31,6 +28,4 @@ typedef double Double;
 typedef char* NullString;
 
 
-} // dHLT
-
-#endif // dHLT_BASIC_TYPES_HPP
+#endif // ALIHLTMUONBASICTYPES_H
index f40742582755e81714c1dc414ab6603bd94422a3..61d3f8725ec8cc27359e30caab20eda595854462 100644 (file)
@@ -5,8 +5,8 @@
 //
 ////////////////////////////////////////////////////////////////////////////////
 
-#ifndef dHLT_BUFFERS_COUNTED_LIST_HPP
-#define dHLT_BUFFERS_COUNTED_LIST_HPP
+#ifndef ALIHLTMUONCORECOUNTEDLIST_H
+#define ALIHLTMUONCORECOUNTEDLIST_H
 
 #include "BasicTypes.hpp"
 #include "Utils.hpp"
@@ -20,31 +20,26 @@ using std::endl;
 using std::cout;
 #endif // DEBUG
 
-namespace dHLT
-{
-namespace Buffers
-{
-
 
 template <typename DataType>
-class CountedList : public List<DataType>
+class AliHLTMUONCoreCountedList : public AliHLTMUONCoreList<DataType>
 {
 public:
 
-       typedef typename List<DataType>::Iterator Iterator;
-       typedef typename List<DataType>::ConstIterator ConstIterator;
+       typedef typename AliHLTMUONCoreList<DataType>::Iterator Iterator;
+       typedef typename AliHLTMUONCoreList<DataType>::ConstIterator ConstIterator;
 
 
-       CountedList() : List<DataType>()
+       AliHLTMUONCoreCountedList() : AliHLTMUONCoreList<DataType>()
        {
-               count = 0;
+               fCount = 0;
        };
 
        
        DataType* New()
        {
-               DataType* newdata = List<DataType>::New();
-               count++;
+               DataType* newdata = AliHLTMUONCoreList<DataType>::New();
+               fCount++;
                return newdata;
        };
        
@@ -57,15 +52,15 @@ public:
 
        void Add(const DataType& data)
        {
-               List<DataType>::Add(data);
-               count++;
+               AliHLTMUONCoreList<DataType>::Add(data);
+               fCount++;
        };
        
 
        DataType* AddNew(const DataType& data)
        {
-               DataType* newdata = List<DataType>::AddNew(data);
-               count++;
+               DataType* newdata = AliHLTMUONCoreList<DataType>::AddNew(data);
+               fCount++;
                return newdata;
        };
 
@@ -82,8 +77,8 @@ public:
        
        void Remove(const UInt index)
        {
-               List<DataType>::Remove(index);
-               count--;
+               AliHLTMUONCoreList<DataType>::Remove(index);
+               fCount--;
        };
        
 
@@ -102,31 +97,28 @@ public:
 
        void Remove(Iterator& iter)
        {
-               List<DataType>::Remove(iter);
-               count--;
+               AliHLTMUONCoreList<DataType>::Remove(iter);
+               fCount--;
        };
 
 
        void Clear()
        {
-               List<DataType>::Clear();
-               count = 0;
+               AliHLTMUONCoreList<DataType>::Clear();
+               fCount = 0;
        };
        
        
        UInt Count() const
        {
-               return count;
+               return fCount;
        };
 
 
 protected:
 
-       UInt count;
+       UInt fCount;
 };
 
 
-} // Buffers
-} // dHLT
-
-#endif // dHLT_BUFFERS_COUNTED_LIST_HPP
+#endif // ALIHLTMUONCORECOUNTEDLIST_H
index 8a72c67577f05802316656e389fd349cdd230de1..b8d9a5eaf8f4bdc5182bf34d5ec653a9b7aad731 100644 (file)
@@ -5,8 +5,8 @@
 //
 ////////////////////////////////////////////////////////////////////////////////
 
-#ifndef dHLT_BUFFERS_LIST_HPP
-#define dHLT_BUFFERS_LIST_HPP
+#ifndef ALIHLTMUONCOREBUFFERSLIST_H
+#define ALIHLTMUONCOREBUFFERSLIST_H
 
 #include "BasicTypes.hpp"
 #include "Utils.hpp"
@@ -19,26 +19,22 @@ using std::endl;
 using std::cout;
 #endif // DEBUG
 
-namespace dHLT
-{
-namespace Buffers
-{
-
 
 template <typename DataType>
-class List
+class AliHLTMUONCoreList
 {
-  //protected:
-
-public:
+protected:
 
        struct Node
        {
-               Node* next;
-               DataType data;
+               Node* fNext;
+               DataType fData;
        };
 
-       Node* first;
+       Node* fFirst;
+
+public:
+
 
        class ConstIterator
        {
@@ -46,64 +42,64 @@ public:
 
                ConstIterator()
                {
-                       current = NULL;
+                       fCurrent = NULL;
                }
 
                ConstIterator(const ConstIterator& iter)
                {
-                       current = iter.current;
+                       fCurrent = iter.fCurrent;
                }
 
                ConstIterator(Node* node)
                {
-                       current = node;
+                       fCurrent = node;
                }
 
                const DataType& operator * () const
                {
-                       return current->data;
+                       return fCurrent->fData;
                }
 
                const DataType* operator -> () const
                {
-                       return &current->data;
+                       return &fCurrent->fData;
                }
 
                ConstIterator& operator ++ ()
                {
-                       Assert( current != NULL );
-                       current = current->next;
+                       Assert( fCurrent != NULL );
+                       fCurrent = fCurrent->fNext;
                        return *this;
                }
 
                ConstIterator operator ++ (int)
                {
-                       Assert( current != NULL );
+                       Assert( fCurrent != NULL );
                        ConstIterator copy = *this;
-                       current = current->next;
+                       fCurrent = fCurrent->fNext;
                        return copy;
                }
                
                operator const DataType* () const
                {
-                       return &current->data;
+                       return &fCurrent->fData;
                }
 
                friend bool operator == (const ConstIterator& a, const ConstIterator& b)
                {
-                       return a.current == b.current;
+                       return a.fCurrent == b.fCurrent;
                }
 
                friend bool operator != (const ConstIterator& a, const ConstIterator& b)
                {
-                       return a.current != b.current;
+                       return a.fCurrent != b.fCurrent;
                }
 
        protected:
        
-               friend class List;
+               friend class AliHLTMUONCore;
 
-               Node* current;
+               Node* fCurrent;
        };
        
 
@@ -113,75 +109,75 @@ public:
 
                Iterator() : ConstIterator()
                {
-                       previous = NULL;
+                       fPrevious = NULL;
                }
 
                Iterator(const Iterator& iter) : ConstIterator(iter)
                {
-                       previous = iter.previous;
+                       fPrevious = iter.fPrevious;
                }
 
                Iterator(Node* current, Node* prev) : ConstIterator(current)
                {
-                       previous = prev;
+                       fPrevious = prev;
                }
 
                DataType& operator * ()
                {
-                       return ConstIterator::current->data;
+                       return ConstIterator::fCurrent->fData;
                }
 
                DataType* operator -> ()
                {
-                       return &ConstIterator::current->data;
+                       return &ConstIterator::fCurrent->fData;
                }
 
                Iterator& operator ++ ()
                {
-                       Assert( ConstIterator::current != NULL );
-                       previous = ConstIterator::current;
-                       ConstIterator::current = ConstIterator::current->next;
+                       Assert( ConstIterator::fCurrent != NULL );
+                       fPrevious = ConstIterator::fCurrent;
+                       ConstIterator::fCurrent = ConstIterator::fCurrent->fNext;
                        return *this;
                }
 
                Iterator operator ++ (int)
                {
-                       Assert( ConstIterator::current != NULL );
+                       Assert( ConstIterator::fCurrent != NULL );
                        Iterator copy = *this;
-                       previous = ConstIterator::current;
-                       ConstIterator::current = ConstIterator::current->next;
+                       fPrevious = ConstIterator::fCurrent;
+                       ConstIterator::fCurrent = ConstIterator::fCurrent->fNext;
                        return copy;
                }
                
                operator DataType* ()
                {
-                       if (ConstIterator::current != NULL)
-                               return &ConstIterator::current->data;
+                       if (ConstIterator::fCurrent != NULL)
+                               return &ConstIterator::fCurrent->fData;
                        else
                                return NULL;
                }
 
        protected:
        
-               friend class List;
+               friend class AliHLTMUONCore;
 
-               Node* previous;
+               Node* fPrevious;
        };
 
        
-       List()
+       AliHLTMUONCoreList()
        {
-               first = NULL;
+               fFirst = NULL;
        }
        
        
-       ~List()
+       ~AliHLTMUONCoreList()
        {
-               Node* current = first;
+               Node* current = fFirst;
                while (current != NULL)
                {
                        Node* temp = current;
-                       current = current->next;
+                       current = current->fNext;
                        delete temp;
                }
        }
@@ -189,16 +185,16 @@ public:
 
        bool Empty() const
        {
-               return first == NULL;
+               return fFirst == NULL;
        }
 
        
        DataType* New()
        {
                Node* newnode = new Node();
-               newnode->next = first;
-               first = newnode;
-               return &newnode->data;
+               newnode->fNext = fFirst;
+               fFirst = newnode;
+               return &newnode->fData;
        }
        
        
@@ -236,23 +232,23 @@ public:
        void Remove(const UInt index)
        {
                Node* previous = NULL;
-               Node* current = first;
+               Node* current = fFirst;
                for (UInt i = 0; i < index; i++)
                {
                        Assert( current != NULL );
                        previous = current;
-                       current = current->next;
+                       current = current->fNext;
                }
                Node* temp;
                if (previous == NULL)
                {
-                       temp = first;
-                       first = first->next;
+                       temp = fFirst;
+                       fFirst = fFirst->fNext;
                }
                else
                {
                        temp = current;
-                       previous->next = current->next;
+                       previous->fNext = current->fNext;
                }
                delete temp;
        }
@@ -280,13 +276,13 @@ public:
                Node* temp;
                if (previous == NULL)
                {
-                       temp = first;
-                       first = first->next;
+                       temp = fFirst;
+                       fFirst = fFirst->fNext;
                }
                else
                {
                        temp = current;
-                       previous->next = current->next;
+                       previous->fNext = current->fNext;
                }
                delete temp;
        }
@@ -295,13 +291,13 @@ public:
        Iterator Find(const DataType& data)
        {
                Node* previous = NULL;
-               Node* current = first;
+               Node* current = fFirst;
                while (current != NULL)
                {
-                       if (current->data == data)
+                       if (current->fData == data)
                                return Iterator(current, previous);
                        previous = current;
-                       current = current->next;
+                       current = current->fNext;
                }
                return End();
        }
@@ -309,12 +305,12 @@ public:
 
        ConstIterator Find(const DataType& data) const
        {
-               Node* current = first;
+               Node* current = fFirst;
                while (current != NULL)
                {
-                       if (current->data == data)
+                       if (current->fData == data)
                                return current;
-                       current = current->next;
+                       current = current->fNext;
                };
                return End();
        }
@@ -324,13 +320,13 @@ public:
        Iterator Find(PredicateType predicate)
        {
                Node* previous = NULL;
-               Node* current = first;
+               Node* current = fFirst;
                while (current != NULL)
                {
-                       if ( predicate(current->data) )
+                       if ( predicate(current->fData) )
                                return Iterator(current, previous);
                        previous = current;
-                       current = current->next;
+                       current = current->fNext;
                }
                return End();
        }
@@ -339,12 +335,12 @@ public:
        template <typename PredicateType>
        ConstIterator Find(PredicateType predicate) const
        {
-               Node* current = first;
+               Node* current = fFirst;
                while (current != NULL)
                {
-                       if ( predicate(current->data) )
+                       if ( predicate(current->fData) )
                                return current;
-                       current = current->next;
+                       current = current->fNext;
                }
                return End();
        }
@@ -358,26 +354,26 @@ public:
 
        void Clear()
        {
-               Node* current = first;
+               Node* current = fFirst;
                while (current != NULL)
                {
                        Node* temp = current;
-                       current = current->next;
+                       current = current->fNext;
                        delete temp;
                };
-               first = NULL;
+               fFirst = NULL;
        }
 
 
        Iterator First()
        {
-               return Iterator(first, NULL);
+               return Iterator(fFirst, NULL);
        }
 
 
        ConstIterator First() const
        {
-               return first;
+               return fFirst;
        }
 
 
@@ -397,11 +393,11 @@ public:
 
        void Dump()
        {
-               Node* current = first;
+               Node* current = fFirst;
                while (current != NULL)
                {
-                       cout << current->data << endl;
-                       current = current->next;
+                       cout << current->fData << endl;
+                       current = current->fNext;
                }
        }
 
@@ -409,7 +405,4 @@ public:
 };
 
 
-} // Buffers
-} // dHLT
-
-#endif // dHLT_BUFFERS_LIST_HPP
+#endif // ALIHLTMUONCOREBUFFERSLIST_H
index 6484d6cde403632f7a75a3c12b14d93195f291fe..641650906fd58c92268c6ff57748c4798a929529 100644 (file)
@@ -5,18 +5,13 @@
 //
 ////////////////////////////////////////////////////////////////////////////////
 
-#ifndef dHLT_CLUSTER_HPP
-#define dHLT_CLUSTER_HPP
+#ifndef ALIHLTMUONCORECLUSTER_H
+#define ALIHLTMUONCORECLUSTER_H
 
 #include "Point.hpp"
 
-namespace dHLT
-{
 
+typedef AliHLTMUONCorePoint AliHLTMUONCoreClusterPoint;
 
-typedef Point ClusterPoint;
 
-
-} // dHLT
-
-#endif // dHLT_POINT_HPP
+#endif // ALIHLTMUONCORECLUSTER_H
index 91d3f566d9011267947da096fc6b1a49329e1743..3daa69afded9e3c778735861811560d46052dabb 100644 (file)
@@ -8,38 +8,36 @@
 #include "Clustering/CenterOfGravityFinder.hpp"
 #include "Error.hpp"
 
-namespace dHLT
-{
-namespace Clustering
-{
 
-
-CenterOfGravityFinder::CenterOfGravityFinder() : ClusterFinder()
+AliHLTMUONCoreCenterOfGravityFinder::AliHLTMUONCoreCenterOfGravityFinder()
+       : AliHLTMUONCoreClusterFinder()
 {
-       Diff_Y = 0.5; // 5000 micron slat size in Y
-       Diff_X = 1.0; // 10000 micron slat size in X
-       X = 56;
-       Y = 128;
-       DigitMax = 35; // maximum number of padhits in columns or rows.
-       DDLMax = 200; // Maximum number of padhits in one ddl;
-       DDLTot = 500; // totoal number of padhits in one ddl;
+       fDiff_Y = 0.5; // 5000 micron slat size in Y
+       fDiff_X = 1.0; // 10000 micron slat size in X
+       fX = 56;
+       fY = 128;
+       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;
 }
 
 
-CenterOfGravityFinder::~CenterOfGravityFinder()
+AliHLTMUONCoreCenterOfGravityFinder::~AliHLTMUONCoreCenterOfGravityFinder()
 {
        // TODO
 }
 
 
-void CenterOfGravityFinder::FindClusters(const ADCStream* stream)
+void AliHLTMUONCoreCenterOfGravityFinder::FindClusters(
+               const AliHLTMUONCoreADCStream* /*stream*/
+       )
 {
        // TODO
 }
 
 
-UInt CenterOfGravityFinder::FillClusterData(
-               ClusterPoint* clusters, UInt arraysize
+UInt AliHLTMUONCoreCenterOfGravityFinder::FillClusterData(
+               AliHLTMUONCoreClusterPoint* /*clusters*/, UInt /*arraysize*/
        )
 {
        // TODO
@@ -47,11 +45,8 @@ UInt CenterOfGravityFinder::FillClusterData(
 }
 
 
-void CenterOfGravityFinder::Reset() {
-           // TODO
+void AliHLTMUONCoreCenterOfGravityFinder::Reset()
+{
+       // TODO
 }
 
-
-} // Clustering
-} // dHLT
-
index 6c0df81d1322205f470f60bdc2802041c2f99757..866434f62bfd44f7cabe2a5443953ad1972196e2 100644 (file)
@@ -5,53 +5,46 @@
 //
 ////////////////////////////////////////////////////////////////////////////////
 
-#ifndef dHLT_CLUSTERING_CENTER_OF_GRAVITY_FINDER_HPP
-#define dHLT_CLUSTERING_CENTER_OF_GRAVITY_FINDER_HPP
+#ifndef ALIHLTMUONCORECENTEROFGRAVITYFINDER_H
+#define ALIHLTMUONCORECENTEROFGRAVITYFINDER_H
 
 #include "Clustering/ClusterFinder.hpp"
 
-namespace dHLT
-{
-namespace Clustering
-{
-      
-      
-class CenterOfGravityFinder : public ClusterFinder
+
+class AliHLTMUONCoreCenterOfGravityFinder : public AliHLTMUONCoreClusterFinder
 {
 public:
        
-       CenterOfGravityFinder();
+       AliHLTMUONCoreCenterOfGravityFinder();
        
-       virtual ~ CenterOfGravityFinder();
+       virtual ~AliHLTMUONCoreCenterOfGravityFinder();
        
        // Inherited from ClusterFinder
-       virtual void FindClusters(const ADCStream * stream);
-       virtual UInt FillClusterData(ClusterPoint * clusters,
-                                    UInt arraysize);
+       virtual void FindClusters(const AliHLTMUONCoreADCStream* stream);
+       virtual UInt FillClusterData(AliHLTMUONCoreClusterPoint* clusters, UInt arraysize);
        virtual void Reset();
+
 private:
-       FILE* lut13;
-       FILE* lut14;
-       FILE* lut15;
-       FILE* lut16;
-       FILE* lut17;
-       FILE* lut18;
-       FILE* lut19;
-       FILE* lut20;
+
+       FILE* fLut13;
+       FILE* fLut14;
+       FILE* fLut15;
+       FILE* fLut16;
+       FILE* fLut17;
+       FILE* fLut18;
+       FILE* fLut19;
+       FILE* fLut20;
        
-       Float_t Diff_Y; // 5000 micron slat size in Y
-       Float_t Diff_X; // 10000 micron slat size in X
-       UInt_t X; // number of columns in bending plane
-       UInt_t Y; // number of rows in non-bending plane
-       UInt_t DigitMax; // maximum number of padhits in columns or rows.
-       UInt_t DDLMax; // Maximum number of padhits in one ddl;
-       UInt_t DDLTot; // totoal number of padhits in one ddl;
+       Float_t fDiff_Y; // 5000 micron slat size in Y
+       Float_t fDiff_X; // 10000 micron slat size in X
+       UInt_t fX; // number of columns in bending plane
+       UInt_t fY; // number of rows in non-bending plane
+       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;
 
 };
-      
 
-} // Clustering
-} // dHLT
 
-#endif // dHLT_CLUSTERING_CENTER_OF_GRAVITY_FINDER_HPP
+#endif // ALIHLTMUONCORECENTEROFGRAVITYFINDER_H
 
index 81d15df95a0950891df826b085abd5bcaaa97ce3..0fea152414a80a59aeb4a9f7e97e3a7157b36eed 100644 (file)
@@ -5,8 +5,8 @@
 //
 ////////////////////////////////////////////////////////////////////////////////
 
-#ifndef dHLT_CLUSTERING_CLUSTER_FINDER_HPP
-#define dHLT_CLUSTERING_CLUSTER_FINDER_HPP
+#ifndef ALIHLTMUONCORECLUSTERFINDER_H
+#define ALIHLTMUONCORECLUSTERFINDER_H
 
 #include "BasicTypes.hpp"
 #include "Cluster.hpp"
 #include "Utils.hpp"
 
 
-namespace dHLT {
-    namespace Clustering {
+class AliHLTMUONCoreClusterFinder;
 
 
-       class ClusterFinder;
+class AliHLTMUONCoreClusterFinderCallback
+{
+public:
 
+       /* Called when the cluster finder has found all clusters in the ADC stream.
+          At this point the ADC stream is no longer is use by the cluster finder and
+          the stream can be released.
+          The numberfound parameter indicated how many clusters were actually found.
+       */
+       virtual void FoundClusters(AliHLTMUONCoreClusterFinder* clusterfinder, UInt numberfound) = 0;
 
-       class ClusterFinderCallback {
-         public:
+       /* Called when the cluster finder has finished its job however no clusters were
+          found in the ADC stream. At this point the ADC stream is no longer is use by
+          the cluster finder and the stream can be released.
+        */
+       virtual void NoClustersFound(AliHLTMUONCoreClusterFinder* clusterfinder) = 0;
 
-           /* Called when the cluster finder has found all clusters in the ADC stream.
-              At this point the ADC stream is no longer is use by the cluster finder and
-              the stream can be released.
-              The numberfound parameter indicated how many clusters were actually found.
-            */
-           virtual void FoundClusters(ClusterFinder * clusterfinder,
-                                      UInt numberfound) = 0;
+};
 
-           /* Called when the cluster finder has finished its job however no clusters were
-              found in the ADC stream. At this point the ADC stream is no longer is use by
-              the cluster finder and the stream can be released.
-            */
-           virtual void NoClustersFound(ClusterFinder * clusterfinder) =
-               0;
 
+class AliHLTMUONCoreClusterFinder
+{
+public:
+
+       AliHLTMUONCoreClusterFinder()
+       {
+               fCallback = NULL;
        };
 
+       /* This is the starting point of the cluster finding algorithm.
+          Deriving cluster finders should implement all processing in this method
+          to find clusters in the specified ADC stream. When all clusters are found
+          the FoundClusters method should be called to indicate that processing is
+          complete. If no clusters could be found then call NoClustersFound instead.
+        */
+       virtual void FindClusters(const AliHLTMUONCoreADCStream* stream) = 0;
+
+       /* After a call to FoundClusters this method will be called to retreive the
+          cluster points. The clusters array should be filled consecutively with 
+          the points that were found. However no more than 'arraysize' number of 
+          points should be written to the clusters array.
+          This method should also return the actual number of cluster points written
+          to the array.
+          If the number of clusters written is less that the number specified in the
+          'numberfound' parameter of the FoundClusters method, then this method will
+          be called again by the framework. Thus on successive calls to this method,
+          the cluster finder must resume writing clusters at the point it stopped at
+          in the previous call to FillClusterData.
+        */
+       virtual UInt FillClusterData(AliHLTMUONCoreClusterPoint* clusters, UInt arraysize) = 0;
+
+       /* This is called when the cluster finder should be reset to an initial state.
+          All extra internal memory allocated during processing should be released.
+        */
+       virtual void Reset() = 0;
+
+       /* Sets the ClusterFinderCallback callback interface.
+        */
+       inline void SetCallback(AliHLTMUONCoreClusterFinderCallback* callback)
+       {
+               fCallback = callback;
+       };
 
-       class ClusterFinder {
-         public:
-
-           ClusterFinder() {
-               callback = NULL;
-           };
-
-           /* This is the starting point of the cluster finding algorithm.
-              Deriving cluster finders should implement all processing in this method
-              to find clusters in the specified ADC stream. When all clusters are found
-              the FoundClusters method should be called to indicate that processing is
-              complete. If no clusters could be found then call NoClustersFound instead.
-            */
-           virtual void FindClusters(const ADCStream * stream) = 0;
-
-           /* After a call to FoundClusters this method will be called to retreive the
-              cluster points. The clusters array should be filled consecutively with 
-              the points that were found. However no more than 'arraysize' number of 
-              points should be written to the clusters array.
-              This method should also return the actual number of cluster points written
-              to the array.
-              If the number of clusters written is less that the number specified in the
-              'numberfound' parameter of the FoundClusters method, then this method will
-              be called again by the framework. Thus on successive calls to this method,
-              the cluster finder must resume writing clusters at the point it stopped at
-              in the previous call to FillClusterData.
-            */
-           virtual UInt FillClusterData(ClusterPoint * clusters,
-                                        UInt arraysize) = 0;
-
-           /* This is called when the cluster finder should be reset to an initial state.
-              All extra internal memory allocated during processing should be released.
-            */
-           virtual void Reset() = 0;
-
-           /* Sets the ClusterFinderCallback callback interface.
-            */
-           inline void SetCallback(ClusterFinderCallback * callback) {
-               this->callback = callback;
-           };
-
-         protected:
-
-           /* Called by the cluster finder algorithm when all clusters in the ADC stream
-              were found. At this point the ADC stream should be considered released and
-              the memory block MUST NOT be accessed.
-              The numberfound parameter should indicate how many clusters were found.
-            */
-            inline void FoundClusters(UInt numberfound) {
-               Assert(callback != NULL);
-               callback->FoundClusters(this, numberfound);
-           };
-
-           /* When the cluster finding algorithm is finished processing but no clusters
-              could be found then this method should be called. At this point the ADC stream
-              should be considered released and the memory block MUST NOT be accessed.
-            */
-           inline void NoClustersFound() {
-               Assert(callback != NULL);
-               callback->NoClustersFound(this);
-           };
-
-         private:
-
-           ClusterFinderCallback * callback;
+protected:
+
+       /* Called by the cluster finder algorithm when all clusters in the ADC stream
+          were found. At this point the ADC stream should be considered released and
+          the memory block MUST NOT be accessed.
+          The numberfound parameter should indicate how many clusters were found.
+        */
+       inline void FoundClusters(UInt numberfound)
+       {
+               Assert(fCallback != NULL);
+               fCallback->FoundClusters(this, numberfound);
        };
 
+       /* When the cluster finding algorithm is finished processing but no clusters
+          could be found then this method should be called. At this point the ADC stream
+          should be considered released and the memory block MUST NOT be accessed.
+        */
+       inline void NoClustersFound()
+       {
+               Assert(fCallback != NULL);
+               fCallback->NoClustersFound(this);
+       };
+
+private:
+
+       AliHLTMUONCoreClusterFinderCallback* fCallback;
+};
 
-    }                          // Clustering
-}                              // dHLT
 
-#endif                         // dHLT_CLUSTERING_CLUSTER_FINDER_HPP
+#endif  // ALIHLTMUONCORECLUSTERFINDER_H
index 972b67674fdddeaa86edb55177e4a1f079afc15a..b0a504e53b76a4f36119edc72c0613a2ba700f59 100644 (file)
@@ -12,56 +12,54 @@ using std::endl;
 using std::cout;
 using std::ostream;
 
-namespace dHLT
-{
 
-ostream& operator << (ostream& os, const EventID& id)
+ostream& operator << (ostream& os, const AliHLTMUONCoreEventID& id)
 {
-       os << "<" << id.bunch << ":" << id.timestamp << ">";
+       os << "<" << id.fBunch << ":" << id.fTimeStamp << ">";
        return os;
 }
 
 
-ostream& operator << (ostream& os, const Point& p)
+ostream& operator << (ostream& os, const AliHLTMUONCorePoint& p)
 {
-       os << "[" << p.x << ", " << p.y << "]";
+       os << "[" << p.fX << ", " << p.fY << "]";
        return os;
 }
 
 
-ostream& operator << (ostream& os, const ParticleSign s)
+ostream& operator << (ostream& os, const AliHLTMUONCoreParticleSign s)
 {
        switch (s)
        {
-       case Minus:       os << "Minus";   break;
-       case Plus:        os << "Plus";    break;
-       case UnknownSign: os << "Unknown"; break;
-       default:          os << "FAULT!";
+       case kSignMinus:   os << "Minus";   break;
+       case kSignPlus:    os << "Plus";    break;
+       case kUnknownSign: os << "Unknown"; break;
+       default:           os << "FAULT!";
        }
        return os;
 }
 
 
-ostream& operator << (ostream& os, const TriggerRecord& rec)
+ostream& operator << (ostream& os, const AliHLTMUONCoreTriggerRecord& rec)
 {
        char* signstr;
-       switch (rec.sign)
+       switch (rec.fSign)
        {
-       case Minus:       signstr = "Minus  "; break;
-       case Plus:        signstr = "Plus   "; break;
-       case UnknownSign: signstr = "Unknown"; break;
-       default:          signstr = "FAULT!!";
+       case kSignMinus:   signstr = "Minus  "; break;
+       case kSignPlus:    signstr = "Plus   "; break;
+       case kUnknownSign: signstr = "Unknown"; break;
+       default:           signstr = "FAULT!!";
        }
        
        os << "{ sign = " << signstr << ", pt = " 
-          << rec.pt << ", impact on station 1: "
-          << rec.station1impact << " , station 2: "
-          << rec.station2impact << " }";
+          << rec.fPt << ", impact on station 1: "
+          << rec.fStation1impact << " , station 2: "
+          << rec.fStation2impact << " }";
        return os;
 }
 
 
-ostream& operator << (ostream& os, const ChamberID chamber)
+ostream& operator << (ostream& os, const AliHLTMUONCoreChamberID chamber)
 {
        Int ch = (Int)chamber;
        if (0 <= ch && ch <= 9)
@@ -71,5 +69,3 @@ ostream& operator << (ostream& os, const ChamberID chamber)
        return os;
 }
 
-
-} // dHLT
index 521ad08ae4b807a42ea287bc469a1273da30c4d4..a618d4f72420e6a21c89f8a33bdea12e51291fc9 100644 (file)
 #include "TriggerRecord.hpp"
 #include "RegionOfInterest.hpp"
 
-namespace dHLT
-{
-
-std::ostream& operator << (std::ostream& os, const EventID& id);
-std::ostream& operator << (std::ostream& os, const Point& p);
-std::ostream& operator << (std::ostream& os, const ParticleSign s);
-std::ostream& operator << (std::ostream& os, const TriggerRecord& rec);
-std::ostream& operator << (std::ostream& os, const ChamberID chamber);
-
-}; // dHLT
+std::ostream& operator << (std::ostream& os, const AliHLTMUONCoreEventID& id);
+std::ostream& operator << (std::ostream& os, const AliHLTMUONCorePoint& p);
+std::ostream& operator << (std::ostream& os, const AliHLTMUONCoreParticleSign s);
+std::ostream& operator << (std::ostream& os, const AliHLTMUONCoreTriggerRecord& rec);
+std::ostream& operator << (std::ostream& os, const AliHLTMUONCoreChamberID chamber);
 
 #endif // dHLT_DEBUG_PRINT_ROUTINES_HPP
index 3621740096c21b459dea92baa47b54a7a32690a8..3de4e530a41a16b86e346d038e3f7ecc392c0005 100644 (file)
@@ -61,7 +61,7 @@ public:
           is called with the relevant track. Most of the actual decision algorithm 
           will go into this method on a per track basis.
         */
-       virtual void AddTrack(const Track& track) = 0;
+       virtual void AddTrack(const AliHLTMUONCoreTrack& track) = 0;
        
        /* When no more tracks are available for the decision then this method is called.
           Final processing of the decision algorithm should go in to this method.
index 948ec933d0ce4ff7353e4d92edae92768edaf25c..a4de13f131a5c2b80967aceb97069cdddbdc017a 100644 (file)
 namespace
 {
        // The one and only pree allocated out of memory error object.
-       static dHLT::OutOfMemory _out_of_memory_;
+       static AliHLTMUONCoreOutOfMemory _out_of_memory_;
 
 } // end of namespace
 
 
-namespace dHLT
-{
-
-
-const char* OutOfMemory::Message() const throw()
+const char* AliHLTMUONCoreOutOfMemory::Message() const throw()
 {
        return "Out of memory.";
 }
 
-Int OutOfMemory::ErrorCode() const throw()
+Int AliHLTMUONCoreOutOfMemory::ErrorCode() const throw()
 {
-       return OUT_OF_MEMORY;
+       return kOUT_OF_MEMORY;
 }
 
-void ThrowOutOfMemory() throw (OutOfMemory)
+void AliHLTMUONCoreThrowOutOfMemory() throw (AliHLTMUONCoreOutOfMemory)
 {
        throw _out_of_memory_;
 }
 
-
-} // dHLT
index bafb8763dba3a62e8eb5fce212dd9abe20cc1699..04a9b3d0c36dfb19a7c8ec290be719911f4633fe 100644 (file)
@@ -5,23 +5,20 @@
 //
 ////////////////////////////////////////////////////////////////////////////////
 
-#ifndef dHLT_ERROR_HPP
-#define dHLT_ERROR_HPP
+#ifndef ALIHLTMUONCOREERROR_H
+#define ALIHLTMUONCOREERROR_H
 
 #include "BasicTypes.hpp"
 #include <exception>
 #include <Riostream.h>
 
-namespace dHLT
-{
-
 
-class Error : public std::exception
+class AliHLTMUONCoreError : public std::exception
 {
 public:
 
-       Error() throw() {};
-       virtual ~Error() throw() {};
+       AliHLTMUONCoreError() throw() {};
+       virtual ~AliHLTMUONCoreError() throw() {};
 
        /* Should return a human readable string containing a description of the
           error.
@@ -43,7 +40,7 @@ public:
                Error myerror;
                cout << myerror << endl;
        */
-       friend ostream& operator << (ostream& os, const dHLT::Error& error)
+       friend ostream& operator << (ostream& os, const AliHLTMUONCoreError& error)
        {
                os << error.Message();
                return os;
@@ -51,7 +48,7 @@ public:
 };
 
 
-class OutOfMemory : public Error
+class AliHLTMUONCoreOutOfMemory : public AliHLTMUONCoreError
 {
 public:
        virtual const char* Message() const throw();
@@ -65,16 +62,14 @@ public:
    This is because the ThrowOutOfMemory routine throws a preallocated object so
    we are safe from having to allocate more (nonexistant) memory.
  */
-void ThrowOutOfMemory() throw (OutOfMemory);
+void AliHLTMUONCoreThrowOutOfMemory() throw (AliHLTMUONCoreOutOfMemory);
 
 
 // Error code declarations.
 enum
 {
-       OUT_OF_MEMORY = 0x10000001
+       kOUT_OF_MEMORY = 0x10000001
 };
 
 
-} // dHLT
-
-#endif // dHLT_ERROR_HPP
+#endif // ALIHLTMUONCOREERROR_H
index 628535833a0f93be3343dcc316fcf1d16ce9c5df..af7bbf0522f4cc4eecd97772fe20c532a5a724fd 100644 (file)
@@ -5,42 +5,37 @@
 //
 ////////////////////////////////////////////////////////////////////////////////
 
-#ifndef dHLT_EVENT_ID_HPP
-#define dHLT_EVENT_ID_HPP
+#ifndef ALIHLTMUONCOREEVENTID_H
+#define ALIHLTMUONCOREEVENTID_H
 
 #include "BasicTypes.hpp"
 #include "Utils.hpp"
 
-namespace dHLT
-{
-
 
 // Must correct this definition!!!!
-struct EventID
+struct AliHLTMUONCoreEventID
 {
-       UInt bunch;
-       UInt timestamp;
+       UInt fBunch;
+       UInt fTimeStamp;
 
 
-       EventID(UInt bunch = 0, UInt timestamp = 0)
+       AliHLTMUONCoreEventID(UInt bunch = 0, UInt timestamp = 0)
        {
-               this->bunch = bunch;
-               this->timestamp = timestamp;
+               fBunch = bunch;
+               fTimeStamp = timestamp;
        };
 
 
-       bool operator == (const EventID& rhs)
+       bool operator == (const AliHLTMUONCoreEventID& rhs)
        {
-               return bunch == rhs.bunch and timestamp == rhs.timestamp;
+               return fBunch == rhs.fBunch and fTimeStamp == rhs.fTimeStamp;
        };
 
-       bool operator != (const EventID& rhs)
+       bool operator != (const AliHLTMUONCoreEventID& rhs)
        {
                return not (*this == rhs);
        };
 };
 
 
-} // dHLT
-
-#endif // dHLT_EVENT_ID_HPP
+#endif // ALIHLTMUONCOREEVENTID_H
index 4be695c2ccdb5b163fcab6651fe5435b7082a0d5..5a45dd454129bd7fe86f0e159831a3d1b1d9988d 100644 (file)
@@ -5,39 +5,34 @@
 //
 ////////////////////////////////////////////////////////////////////////////////
 
-#ifndef dHLT_POINT_HPP
-#define dHLT_POINT_HPP
+#ifndef ALIHLTMUONCOREPOINT_H
+#define ALIHLTMUONCOREPOINT_H
 
 #include "BasicTypes.hpp"
 
-namespace dHLT
-{
-
 
 /* A 2D point structure using floats.
    These are used to store impact points on the trigger chambers and 
    cluster centroids.
  */
-class Point
+class AliHLTMUONCorePoint
 {
 public:
 
-       Float x, y;
+       Float fX, fY;
 
-       Point()
+       AliHLTMUONCorePoint()
        {
-               x = 0.0;
-               y = 0.0;
+               fX = 0.0;
+               fY = 0.0;
        }
 
-       Point(Float x0, Float y0)
+       AliHLTMUONCorePoint(Float x, Float y)
        {
-               this->x = x0;
-               this->y = y0;
+               fX = x;
+               fY = y;
        }
 };
 
 
-} // dHLT
-
-#endif // dHLT_POINT_HPP
+#endif // ALIHLTMUONCOREPOINT_H
index 726af3050684e28bcbd5a6374838c5b92ab8e28b..2869d178ceee952ab5fcf0404ed5eee4c0ee7d5e 100644 (file)
@@ -8,11 +8,8 @@
 #include "RegionOfInterest.hpp"
 #include <math.h>
 
-namespace dHLT
-{
-
 
-Float RegionOfInterest::planescale[NUMBER_OF_TRACKING_CHAMBERS]
+Float AliHLTMUONCoreRegionOfInterest::fgPlaneScale[gkNUMBER_OF_TRACKING_CHAMBERS]
 ///*
        = {     100.0f,
                100.0f,
@@ -41,31 +38,36 @@ Float RegionOfInterest::planescale[NUMBER_OF_TRACKING_CHAMBERS]
 */
 
 
-void RegionOfInterest::CreateToContain(const ClusterPoint& point, ChamberID chamber)
+void AliHLTMUONCoreRegionOfInterest::CreateToContain(
+               const AliHLTMUONCoreClusterPoint& point, AliHLTMUONCoreChamberID chamber
+       )
 {
-       Assert( 0 <= chamber && chamber < NUMBER_OF_TRACKING_CHAMBERS );
-       this->chamber = chamber;
-       left = right = point.x;
-       bottom = top = point.y;
+       Assert( 0 <= chamber && chamber < gkNUMBER_OF_TRACKING_CHAMBERS );
+       fChamber = chamber;
+       fLeft = fRight = point.fX;
+       fBottom = fTop = point.fY;
 }
 
 
-void RegionOfInterest::ExpandToContain(const ClusterPoint& point)
+void AliHLTMUONCoreRegionOfInterest::ExpandToContain(const AliHLTMUONCoreClusterPoint& point)
 {
-       if (point.x < left)
-               left = point.x;
+       if (point.fX < fLeft)
+               fLeft = point.fX;
        else
-               if (point.x > right) right = point.x;
-       if (point.y < bottom)
-               bottom = point.y;
+               if (point.fX > fRight) fRight = point.fX;
+       if (point.fY < fBottom)
+               fBottom = point.fY;
        else
-               if (point.y > top) top = point.y;
+               if (point.fY > fTop) fTop = point.fY;
 }
 
 
-void RegionOfInterest::CreateToContain(const ClusterPoint* points, UInt count, ChamberID chamber)
+void AliHLTMUONCoreRegionOfInterest::CreateToContain(
+               const AliHLTMUONCoreClusterPoint* points, UInt count,
+               AliHLTMUONCoreChamberID chamber
+       )
 {
-       Assert( 0 <= chamber && chamber < NUMBER_OF_TRACKING_CHAMBERS );
+       Assert( 0 <= chamber && chamber < gkNUMBER_OF_TRACKING_CHAMBERS );
        Assert( count > 0 );
        
        CreateToContain(points[0], chamber);
@@ -74,14 +76,14 @@ void RegionOfInterest::CreateToContain(const ClusterPoint* points, UInt count, C
 }
 
 
-bool RegionOfInterest::InBounds()
+bool AliHLTMUONCoreRegionOfInterest::InBounds()
 {
-       Assert( 0 <= chamber && chamber < NUMBER_OF_TRACKING_CHAMBERS );
-       register Float bound = planescale[chamber];
-       return -bound <= left
-         && right <= bound
-         && -bound <= bottom
-         && top <= bound;
+       Assert( 0 <= fChamber && fChamber < gkNUMBER_OF_TRACKING_CHAMBERS );
+       register Float bound = fgPlaneScale[fChamber];
+       return -bound <= fLeft
+         && fRight <= bound
+         && -bound <= fBottom
+         && fTop <= bound;
 }
 
 
@@ -106,7 +108,7 @@ bool RegionOfInterest::InBounds()
 #define INDICES_TO_LEVEL_1   1
 
 
-UInt RegionOfInterest::indexoffsets[13] 
+UInt AliHLTMUONCoreRegionOfInterest::fgIndexOffsets[13]
        = {     INDICES_TO_LEVEL_1,
                INDICES_TO_LEVEL_2,
                INDICES_TO_LEVEL_3,
@@ -123,15 +125,17 @@ UInt RegionOfInterest::indexoffsets[13]
        };
 
 
-inline void RegionOfInterest::ConvertToGrid(register UInt& l, register UInt& r, register UInt& b, register UInt& t) const
+inline void AliHLTMUONCoreRegionOfInterest::ConvertToGrid(
+               register UInt& l, register UInt& r, register UInt& b, register UInt& t
+       ) const
 {
-       Assert( 0 <= chamber && chamber < NUMBER_OF_TRACKING_CHAMBERS );
+       Assert( 0 <= fChamber && fChamber < gkNUMBER_OF_TRACKING_CHAMBERS );
 
-       register Float scale = planescale[chamber];
-       l = (UInt) floor( (left / scale + 1.0f) * 0.5f * GRID_SIZE );
-       r = (UInt) ceil( (right / scale + 1.0f) * 0.5f * GRID_SIZE );
-       b = (UInt) floor( (bottom / scale + 1.0f) * 0.5f * GRID_SIZE );
-       t = (UInt) ceil( (top / scale + 1.0f) * 0.5f * GRID_SIZE );
+       register Float scale = fgPlaneScale[fChamber];
+       l = (UInt) floor( (fLeft / scale + 1.0f) * 0.5f * GRID_SIZE );
+       r = (UInt) ceil( (fRight / scale + 1.0f) * 0.5f * GRID_SIZE );
+       b = (UInt) floor( (fBottom / scale + 1.0f) * 0.5f * GRID_SIZE );
+       t = (UInt) ceil( (fTop / scale + 1.0f) * 0.5f * GRID_SIZE );
 
        /* 
        // Not required with proper coding. This case is handled properly by
@@ -144,23 +148,25 @@ inline void RegionOfInterest::ConvertToGrid(register UInt& l, register UInt& r,
 }
 
 
-inline void RegionOfInterest::ConvertBackFromGrid(register UInt l, register UInt r, register UInt b, register UInt t)
+inline void AliHLTMUONCoreRegionOfInterest::ConvertBackFromGrid(
+               register UInt l, register UInt r, register UInt b, register UInt t
+       )
 {
        Assert( l <= GRID_SIZE );
        Assert( r <= GRID_SIZE );
        Assert( b <= GRID_SIZE );
        Assert( t <= GRID_SIZE );
 
-       Assert( 0 <= chamber && chamber < NUMBER_OF_TRACKING_CHAMBERS );
-       register Float scale = planescale[chamber];
-       left = ((Float)l / (Float)GRID_SIZE - 0.5f) * 2.0f * scale;
-       right = ((Float)r / (Float)GRID_SIZE - 0.5f) * 2.0f * scale;
-       bottom = ((Float)b / (Float)GRID_SIZE - 0.5f) * 2.0f * scale;
-       top = ((Float)t / (Float)GRID_SIZE - 0.5f) * 2.0f * scale;
+       Assert( 0 <= fChamber && fChamber < gkNUMBER_OF_TRACKING_CHAMBERS );
+       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;
+       fBottom = ((Float)b / (Float)GRID_SIZE - 0.5f) * 2.0f * scale;
+       fTop = ((Float)t / (Float)GRID_SIZE - 0.5f) * 2.0f * scale;
 }
 
 
-ROI RegionOfInterest::Encode() const
+AliHLTMUONCoreROI AliHLTMUONCoreRegionOfInterest::Encode() const
 {
        UInt l, r, b, t, maxwidth, index;
 
@@ -298,11 +304,11 @@ ROI RegionOfInterest::Encode() const
        if ( l > maxwidth - 1 ) l = maxwidth - 1;
        if ( b > maxwidth - 1 ) b = maxwidth - 1;
        
-       return MAX_INDICES * chamber + b * maxwidth + l + index;
+       return MAX_INDICES * fChamber + b * maxwidth + l + index;
 }
 
 
-ROI RegionOfInterest::Encode(UChar& level, UInt& l, UInt& b) const
+AliHLTMUONCoreROI AliHLTMUONCoreRegionOfInterest::Encode(UChar& level, UInt& l, UInt& b) const
 {
        UInt r, t, maxwidth, index;
 
@@ -454,15 +460,15 @@ ROI RegionOfInterest::Encode(UChar& level, UInt& l, UInt& b) const
        if ( l > maxwidth - 1 ) l = maxwidth - 1;
        if ( b > maxwidth - 1 ) b = maxwidth - 1;
        
-       return MAX_INDICES * chamber + b * maxwidth + l + index;
+       return MAX_INDICES * fChamber + b * maxwidth + l + index;
 }
 
 
-void RegionOfInterest::Decode(ROI code)
+void AliHLTMUONCoreRegionOfInterest::Decode(AliHLTMUONCoreROI code)
 {
        UInt l, r, b, t;
        UChar colevel;
-       DecodeBits(code, chamber, colevel, l, b);
+       DecodeBits(code, fChamber, colevel, l, b);
 
        // Complete decoding of bottom left corner.
        b = b << colevel;
@@ -476,7 +482,10 @@ void RegionOfInterest::Decode(ROI code)
 }
 
 
-void RegionOfInterest::Decode(ROI code, ChamberID& chamber, UChar& level, UInt& l, UInt& b)
+void AliHLTMUONCoreRegionOfInterest::Decode(
+               AliHLTMUONCoreROI code, AliHLTMUONCoreChamberID& chamber,
+               UChar& level, UInt& l, UInt& b
+       )
 {
        UChar colevel;
        DecodeBits(code, chamber, colevel, l, b);
@@ -484,11 +493,14 @@ void RegionOfInterest::Decode(ROI code, ChamberID& chamber, UChar& level, UInt&
 }
 
 
-void RegionOfInterest::DecodeBits(ROI code, ChamberID& chamber, UChar& colevel, UInt& l, UInt& b)
+void AliHLTMUONCoreRegionOfInterest::DecodeBits(
+               AliHLTMUONCoreROI code, AliHLTMUONCoreChamberID& chamber,
+               UChar& colevel, UInt& l, UInt& b
+       )
 {
        // First decode the chamber number and the remainder 
        // contains the location index.
-       chamber = (ChamberID)(code / MAX_INDICES);
+       chamber = (AliHLTMUONCoreChamberID)(code / MAX_INDICES);
        UInt index = code % MAX_INDICES;
        
        UInt width;
@@ -621,10 +633,8 @@ void RegionOfInterest::DecodeBits(ROI code, ChamberID& chamber, UChar& colevel,
 }
 
 
-ChamberID RegionOfInterest::DecodeChamber(ROI code)
+AliHLTMUONCoreChamberID AliHLTMUONCoreRegionOfInterest::DecodeChamber(AliHLTMUONCoreROI code)
 {
-       return (ChamberID)(code / MAX_INDICES);
+       return (AliHLTMUONCoreChamberID)(code / MAX_INDICES);
 }
 
-
-} // dHLT
index 4ef121ef0446fa37bd0514dd8e617f20a8845a30..8d33fc2ea8906905e2741f06215feb68a4311c4a 100644 (file)
@@ -5,43 +5,40 @@
 //
 ////////////////////////////////////////////////////////////////////////////////
 
-#ifndef dHLT_REGION_OF_INTEREST_HPP
-#define dHLT_REGION_OF_INTEREST_HPP
+#ifndef ALIHLTMUONCOREREGIONOFINTEREST_H
+#define ALIHLTMUONCOREREGIONOFINTEREST_H
 
 #include "BasicTypes.hpp"
 #include "Utils.hpp"
 #include "Cluster.hpp"
 
-namespace dHLT
-{
-
 
-const Int NUMBER_OF_TRACKING_CHAMBERS = 10;
+const Int gkNUMBER_OF_TRACKING_CHAMBERS = 10;
 
-typedef UInt ROI;
+typedef UInt AliHLTMUONCoreROI;
 
 enum
 {
-       INVALID_ROI = 0xFFFFFFFF
+       kINVALID_ROI = 0xFFFFFFFF
 };
 
 
 /* Identification numbers specifying the tracking chambers of the dimuon
    spectrometer.
  */
-enum ChamberID
+enum AliHLTMUONCoreChamberID
 {
-       UnknownChamber = -1,
-       Chamber1 = 0,
-       Chamber2 = 1,
-       Chamber3 = 2,
-       Chamber4 = 3,
-       Chamber5 = 4,
-       Chamber6 = 5,
-       Chamber7 = 6,
-       Chamber8 = 7,
-       Chamber9 = 8,
-       Chamber10 = 9
+       kUnknownChamber = -1,
+       kChamber1 = 0,
+       kChamber2 = 1,
+       kChamber3 = 2,
+       kChamber4 = 3,
+       kChamber5 = 4,
+       kChamber6 = 5,
+       kChamber7 = 6,
+       kChamber8 = 7,
+       kChamber9 = 8,
+       kChamber10 = 9
 };
 
 
@@ -50,20 +47,20 @@ enum ChamberID
    regions of interest between different parts of the dHLT system. This is more
    efficient than sending 20 byte long region of interest objects.
  */
-class RegionOfInterest
+class AliHLTMUONCoreRegionOfInterest
 {
 public:
 
-       RegionOfInterest()
+       AliHLTMUONCoreRegionOfInterest()
        {
-               chamber = Chamber1;
-               left = right = top = bottom = 0.0;
+               fChamber = kChamber1;
+               fLeft = fRight = fTop = fBottom = 0.0;
        }
        
        /* This constructor decodes the ROI bit pattern into a region of
           interest object.
         */
-       RegionOfInterest(const ROI& code)
+       AliHLTMUONCoreRegionOfInterest(const AliHLTMUONCoreROI& code)
        {
                Decode(code);
        }
@@ -71,7 +68,10 @@ public:
        /* Creates a region of interest around the given point for the
           specified chamber.
         */
-       RegionOfInterest(const ClusterPoint& point0, ChamberID chamber0)
+       AliHLTMUONCoreRegionOfInterest(
+                       const AliHLTMUONCoreClusterPoint& point0,
+                       AliHLTMUONCoreChamberID chamber0
+               )
        {
                CreateToContain(point0, chamber0);
        }
@@ -79,7 +79,10 @@ public:
        /* Creates a region of interest around all the given points and for the
           specified chamber.
         */
-       RegionOfInterest(const ClusterPoint* points0, UInt count0, ChamberID chamber0)
+       AliHLTMUONCoreRegionOfInterest(
+                       const AliHLTMUONCoreClusterPoint* points0, UInt count0,
+                       AliHLTMUONCoreChamberID chamber0
+               )
        {
                CreateToContain(points0, count0, chamber0);
        }
@@ -87,67 +90,79 @@ public:
        /* Creates a region of interest with the specified boundaries and for
           the specified chamber.
         */
-       RegionOfInterest(Float left0, Float right0, Float bottom0, Float top0, ChamberID chamber0)
+       AliHLTMUONCoreRegionOfInterest(
+                       Float left0, Float right0, Float bottom0, Float top0,
+                       AliHLTMUONCoreChamberID chamber0
+               )
        {
-               Assert( 0 <= chamber0 && chamber0 < NUMBER_OF_TRACKING_CHAMBERS );
-               this->chamber = chamber0;
-               this->left = left0;
-               this->right = right0;
-               this->bottom = bottom0;
-               this->top = top0;
+               Assert( 0 <= chamber0 && chamber0 < gkNUMBER_OF_TRACKING_CHAMBERS );
+               this->fChamber = chamber0;
+               this->fLeft = left0;
+               this->fRight = right0;
+               this->fBottom = bottom0;
+               this->fTop = top0;
        }
 
 
        /* Checks if the point is contained in this region of interest.
         */
-       bool Contains(const ClusterPoint& point) const
+       bool Contains(const AliHLTMUONCoreClusterPoint& point) const
        {
-               return left <= point.x 
-                 && point.x <= right 
-                 && bottom <= point.y
-                 && point.y <= top;
+               return fLeft <= point.fX
+                 && point.fX <= fRight
+                 && fBottom <= point.fY
+                 && point.fY <= fTop;
        }
 
 
        /* Checks if the point is contained in this region of interest and the
           chamber number corresponds to this region object.
         */
-       bool Contains(const ClusterPoint& point, ChamberID chamber0) const
+       bool Contains(
+                       const AliHLTMUONCoreClusterPoint& point,
+                       AliHLTMUONCoreChamberID chamber
+               ) const
        {
-               return left <= point.x 
-                 && point.x <= right
-                 && bottom <= point.y
-                 && point.y <= top
-                 && this->chamber == chamber0;
+               return fLeft <= point.fX
+                 && point.fX <= fRight
+                 && fBottom <= point.fY
+                 && point.fY <= fTop
+                 && this->fChamber == chamber;
        }
 
 
        /* Checks if the specified region of interest is contained in this
           region of interest object.
         */
-       bool Contains(const RegionOfInterest& roi) const
+       bool Contains(const AliHLTMUONCoreRegionOfInterest& roi) const
        {
-               return chamber == roi.chamber
-                 && left <= roi.left
-                 && right >= roi.right
-                 && bottom <= roi.bottom
-                 && top >= roi.top;
+               return fChamber == roi.fChamber
+                 && fLeft <= roi.fLeft
+                 && fRight >= roi.fRight
+                 && fBottom <= roi.fBottom
+                 && fTop >= roi.fTop;
        }
 
 
        /* Creates a region of interest around the given point for the
           specified chamber.
         */
-       void CreateToContain(const ClusterPoint& point, ChamberID chamber);
+       void CreateToContain(
+                       const AliHLTMUONCoreClusterPoint& point,
+                       AliHLTMUONCoreChamberID chamber
+               );
 
        /* Extends the region of interest to contain the specified point.
         */
-       void ExpandToContain(const ClusterPoint& point);
+       void ExpandToContain(const AliHLTMUONCoreClusterPoint& point);
 
        /* Creates a region of interest around all the given points and for the
           specified chamber.
         */
-       void CreateToContain(const ClusterPoint* points, UInt count, ChamberID chamber);
+       void CreateToContain(
+                       const AliHLTMUONCoreClusterPoint* points, UInt count,
+                       AliHLTMUONCoreChamberID chamber
+               );
 
        /* Checks if the region of interest is within the boundaries imposed on
           the specific chamber plane. This boundary is aproximately the square
@@ -157,53 +172,56 @@ public:
 
        /* Encodes the region of interest into a 32 bit code.
         */
-       ROI Encode() const;
+       AliHLTMUONCoreROI Encode() 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.
         */
-       ROI Encode(UChar& level, UInt& l, UInt& b) const;
+       AliHLTMUONCoreROI Encode(UChar& level, UInt& l, UInt& b) const;
 
        /* Decodes a 32 bit region of interest code into this region of interest
           object.
         */
-       void Decode(ROI code);
+       void Decode(AliHLTMUONCoreROI code);
 
        /* Decodes the chamber number of the region of interest 32 bit code.
         */
-       static ChamberID DecodeChamber(ROI code);
+       static AliHLTMUONCoreChamberID DecodeChamber(AliHLTMUONCoreROI code);
 
        /* Decodes the 32 bit region of interest code into the chamber number,
           hierarchal level, left and right grid coordinates of the region
           boundary box. 
         */
-       static void Decode(ROI code, ChamberID& chamber, UChar& level, UInt& l, UInt& b);
+       static void Decode(
+                       AliHLTMUONCoreROI code, AliHLTMUONCoreChamberID& chamber,
+                       UChar& level, UInt& l, UInt& b
+               );
 
        /* Returns the chamber number of the region of interest.
         */
-       ChamberID Chamber() const { return chamber; };
+       AliHLTMUONCoreChamberID Chamber() const { return fChamber; };
        
        /* Returns the left hand boundary of the region of interest.
         */
-       Float Left() const    { return left; };
+       Float Left() const    { return fLeft; };
        
        /* Returns the right hand boundary of the region of interest.
         */
-       Float Right() const   { return right; };
+       Float Right() const   { return fRight; };
        
        /* Returns the bottom boundary of the region of interest.
         */
-       Float Bottom() const  { return bottom; };
+       Float Bottom() const  { return fBottom; };
        
        /* Returns the top boundary of the region of interest.
         */
-       Float Top() const     { return top; };
+       Float Top() const     { return fTop; };
 
 
        /* Typecast operator for implicit typecasing to 32 bit ROI codes.
         */
-       operator ROI () const { return Encode(); };
+       operator AliHLTMUONCoreROI () const { return Encode(); };
 
 
 private:
@@ -224,24 +242,25 @@ private:
        /* Internal method for decoding 32 bit region codes. This method is
           called by the Decode methods.
         */
-       static void DecodeBits(ROI code, ChamberID& chamber, UChar& colevel, UInt& l, UInt& b);
+       static void DecodeBits(
+                       AliHLTMUONCoreROI code, AliHLTMUONCoreChamberID& chamber,
+                       UChar& colevel, UInt& l, UInt& b
+               );
 
 
        // Boundary box scale numbers for each chamber. These are the boundary
        // boxes around the chambers detection surface.
-       static Float planescale[NUMBER_OF_TRACKING_CHAMBERS];
+       static Float fgPlaneScale[gkNUMBER_OF_TRACKING_CHAMBERS];
 
-       static UInt indexoffsets[13];  // Offset numbers used in the encoding and decoding process.
+       static UInt fgIndexOffsets[13];  // Offset numbers used in the encoding and decoding process.
 
 
-       ChamberID chamber; // Specifies the chamber the region of interest is on.
-       Float left;        // Left boundary of boundary box.
-       Float right;       // Right boundary of boundary box.
-       Float bottom;      // Bottom boundary of boundary box.
-       Float top;         // Top boundary of boundary box.
+       AliHLTMUONCoreChamberID fChamber; // Specifies the chamber the region of interest is on.
+       Float fLeft;        // Left boundary of boundary box.
+       Float fRight;       // Right boundary of boundary box.
+       Float fBottom;      // Bottom boundary of boundary box.
+       Float fTop;         // Top boundary of boundary box.
 };
 
 
-} // dHLT
-
-#endif // dHLT_REGION_OF_INTEREST_HPP
+#endif // ALIHLTMUONCOREREGIONOFINTEREST_H
index 8eaffd444d29264014490b851e832e1460dc4fe2..fcb30628ec03514e6e1c47c05bfe65845c8c451b 100644 (file)
@@ -5,33 +5,28 @@
 //
 ////////////////////////////////////////////////////////////////////////////////
 
-#ifndef dHLT_TRACK_HPP
-#define dHLT_TRACK_HPP
+#ifndef ALIHLTMUONCORETRACK_H
+#define ALIHLTMUONCORETRACK_H
 
 #include "Point.hpp"
 #include "RegionOfInterest.hpp"
 #include "TriggerRecord.hpp"
 
-namespace dHLT
-{
-
 
-typedef UInt TrackID;
+typedef UInt AliHLTMUONCoreTrackID;
 
 
-struct Track
+struct AliHLTMUONCoreTrack
 {
 
-       TriggerRecordID triggerid;
-       ParticleSign sign;
-       Float p;   // momentum.
-       Float pt;  // transverse momentum.
-       Point point[10];  // Computed track coordinates on the 10 tracking chambers.
-       ROI region[10];   // Regions of interest from which clusters were used to compute this track.
+       AliHLTMUONCoreTriggerRecordID fTriggerid;
+       AliHLTMUONCoreParticleSign fSign;
+       Float fP;   // momentum.
+       Float fPt;  // transverse momentum.
+       AliHLTMUONCorePoint fPoint[10];  // Computed track coordinates on the 10 tracking chambers.
+       AliHLTMUONCoreROI fRegion[10];   // Regions of interest from which clusters were used to compute this track.
 
 };
 
 
-} // dHLT
-
-#endif // dHLT_TRACK_HPP
+#endif // ALIHLTMUONCORETRACK_H
index 19cb709e899a8c739f26021572de2f3aebf352a3..74d05681d91cc8622d9d1133f5d4ede446e3cf2f 100644 (file)
@@ -8,13 +8,8 @@
 #include "Calculations.hpp"
 #include <math.h>
 
-namespace dHLT
-{
-namespace Tracking
-{
 
-
-Float CalculateSignedPt(
+Float AliHLTMUONCoreCalculateSignedPt(
                register Float x1,
                register Float y1, register Float y2,
                register Float z1, register Float z2,
@@ -37,7 +32,7 @@ Float CalculateSignedPt(
 };
 
 
-Float CalculateSignedPt(
+Float AliHLTMUONCoreCalculateSignedPt(
                register Float x1,
                register Float y1, register Float y2,
                register Float z1, register Float z2,
@@ -59,7 +54,7 @@ Float CalculateSignedPt(
 };
 
 
-Float CalculateSignedPt(
+Float AliHLTMUONCoreCalculateSignedPt(
                register Float x1,
                register Float y1, register Float y2,
                register Float z1, register Float z2
@@ -78,7 +73,7 @@ Float CalculateSignedPt(
 };
 
 
-Float CalculateSignedPt(
+Float AliHLTMUONCoreCalculateSignedPt(
                register Float x1,
                register Float y1, register Float y2,
                register Float z1, register Float z2,
@@ -96,26 +91,23 @@ Float CalculateSignedPt(
 };
 
 
-Float CalculatePt(
+Float AliHLTMUONCoreCalculatePt(
                register Float x1,
                register Float y1, register Float y2,
                register Float z1, register Float z2
        )
 {
-       return (Float) fabs(CalculateSignedPt(x1, y1, y2, z1, z2));
+       return (Float) fabs(AliHLTMUONCoreCalculateSignedPt(x1, y1, y2, z1, z2));
 };
 
 
-Float CalculatePt(
+Float AliHLTMUONCoreCalculatePt(
                register Float x1,
                register Float y1, register Float y2,
                register Float z1, register Float z2,
                register Float zf, register Float qBL
        )
 {
-       return (Float) fabs(CalculateSignedPt(x1, y1, y2, z1, z2, zf, qBL));
+       return (Float) fabs(AliHLTMUONCoreCalculateSignedPt(x1, y1, y2, z1, z2, zf, qBL));
 };
 
-
-} // Tracking
-} // dHLT
index 7ef25d3582ea128bb90b033687ff5c1a98889694..4bee765f0ba6c1b6eafdb5410733c3fef35a768a 100644 (file)
@@ -7,10 +7,6 @@
 
 #include "BasicTypes.hpp"
 
-namespace dHLT
-{
-namespace Tracking
-{
 
 /* Computes the Pt (transverse mementum) based on the equations given in the
    ALICE dimuon spectrometer Technical Design Report (TDR-5): trigger section.
@@ -25,7 +21,7 @@ namespace Tracking
    Input can be in meters, cm or mm. 
    Output is in GeV.
  */
-Float CalculatePt(
+Float AliHLTMUONCoreCalculatePt(
                register Float x1,
                register Float y1, register Float y2,
                register Float z1, register Float z2
@@ -34,7 +30,7 @@ Float CalculatePt(
 /* Performs the same calculation as above however alows the zf and qBL
    parameters to be specified.
  */
-Float CalculatePt(
+Float AliHLTMUONCoreCalculatePt(
                register Float x1,
                register Float y1, register Float y2,
                register Float z1, register Float z2,
@@ -44,7 +40,7 @@ Float CalculatePt(
 /* The same Pt calculation as above however the sign of the result indicates
    the sign of the particle.
  */
-Float CalculateSignedPt(
+Float AliHLTMUONCoreCalculateSignedPt(
                register Float x1,
                register Float y1, register Float y2,
                register Float z1, register Float z2
@@ -53,7 +49,7 @@ Float CalculateSignedPt(
 /* Performs the same calculation as above however alows the zf and qBL
    parameters to be specified.
  */
-Float CalculateSignedPt(
+Float AliHLTMUONCoreCalculateSignedPt(
                register Float x1,
                register Float y1, register Float y2,
                register Float z1, register Float z2,
@@ -63,7 +59,7 @@ Float CalculateSignedPt(
 /* The same Pt calculation as above however the sign of the result indicates
    the sign of the particle. The momentum is also computed and returned.
  */
-Float CalculateSignedPt(
+Float AliHLTMUONCoreCalculateSignedPt(
                register Float x1,
                register Float y1, register Float y2,
                register Float z1, register Float z2,
@@ -73,7 +69,7 @@ Float CalculateSignedPt(
 /* Performs the same calculation as above however alows the zf and qBL
    parameters to be specified.
  */
-Float CalculateSignedPt(
+Float AliHLTMUONCoreCalculateSignedPt(
                register Float x1,
                register Float y1, register Float y2,
                register Float z1, register Float z2,
@@ -81,6 +77,3 @@ Float CalculateSignedPt(
                Float& p
        );
 
-
-} // Tracking
-} // dHLT
index 97a469a496ada0476a167ba1fca9e43d3a699752..07160e57743f0265ec25e6d4dc03229cdf36fa1a 100644 (file)
 namespace
 {
 
-using dHLT::Tracking::MansoTracker;
-
-std::ostream& operator << (std::ostream& os, MansoTracker::StatesSM4 state)
+std::ostream& operator << (std::ostream& os, AliHLTMUONCoreMansoTracker::StatesSM4 state)
 {
        switch (state)
        {
-       case MansoTracker::SM4Idle:          os << "SM4Idle"; break;
-       case MansoTracker::WaitChamber8:     os << "WaitChamber8"; break;
-       case MansoTracker::WaitMoreChamber8: os << "WaitMoreChamber8"; break;
-       case MansoTracker::WaitChamber7:     os << "WaitChamber7"; break;
-       case MansoTracker::WaitMoreChamber7: os << "WaitMoreChamber7"; break;
+       case AliHLTMUONCoreMansoTracker::kSM4Idle:          os << "kSM4Idle"; break;
+       case AliHLTMUONCoreMansoTracker::kWaitChamber8:     os << "kWaitChamber8"; break;
+       case AliHLTMUONCoreMansoTracker::kWaitMoreChamber8: os << "kWaitMoreChamber8"; break;
+       case AliHLTMUONCoreMansoTracker::kWaitChamber7:     os << "kWaitChamber7"; break;
+       case AliHLTMUONCoreMansoTracker::kWaitMoreChamber7: os << "kWaitMoreChamber7"; break;
        default:                             os << "FAULT!!"; 
        }
        return os;
 }
 
-std::ostream& operator << (std::ostream& os, MansoTracker::StatesSM5 state)
+std::ostream& operator << (std::ostream& os, AliHLTMUONCoreMansoTracker::StatesSM5 state)
 {
        switch (state)
        {
-       case MansoTracker::SM5Idle:           os << "SM5Idle"; break;
-       case MansoTracker::WaitChamber10:     os << "WaitChamber10"; break;
-       case MansoTracker::WaitMoreChamber10: os << "WaitMoreChamber10"; break;
-       case MansoTracker::WaitChamber9:      os << "WaitChamber9"; break;
-       case MansoTracker::WaitMoreChamber9:  os << "WaitMoreChamber9"; break;
-       case MansoTracker::SM5Done:           os << "SM5Done"; break;
+       case AliHLTMUONCoreMansoTracker::kSM5Idle:           os << "kSM5Idle"; break;
+       case AliHLTMUONCoreMansoTracker::kWaitChamber10:     os << "kWaitChamber10"; break;
+       case AliHLTMUONCoreMansoTracker::kWaitMoreChamber10: os << "kWaitMoreChamber10"; break;
+       case AliHLTMUONCoreMansoTracker::kWaitChamber9:      os << "kWaitChamber9"; break;
+       case AliHLTMUONCoreMansoTracker::kWaitMoreChamber9:  os << "kWaitMoreChamber9"; break;
+       case AliHLTMUONCoreMansoTracker::kSM5Done:           os << "kSM5Done"; break;
        default:                              os << "FAULT!!"; 
        }
        return os;
@@ -54,38 +52,32 @@ std::ostream& operator << (std::ostream& os, MansoTracker::StatesSM5 state)
 #endif // DEBUG
 
 
-namespace dHLT
-{
-namespace Tracking
-{
-
-
 // Deviate from the Manso implementation by allowing a and b
 // parameters per chamber and not just per station.
 // The default values are derived from the work done in
 //    "A first algorithm for dimuon High Level Trigger"
 //    Ref ID:  ALICE-INT-2002-04 version 1.0
-Float MansoTracker::a7  = 0.016f;
-Float MansoTracker::b7  = 2.0f;
-Float MansoTracker::a8  = 0.016f;
-Float MansoTracker::b8  = 2.0f;
-Float MansoTracker::a9  = 0.020f;
-Float MansoTracker::b9  = 3.0f;
-Float MansoTracker::a10 = 0.020f;
-Float MansoTracker::b10 = 3.0f;
-Float MansoTracker::z7  = 1274.5f;
-Float MansoTracker::z8  = 1305.5f;
-Float MansoTracker::z9  = 1408.6f;
-Float MansoTracker::z10 = 1439.6f;
-Float MansoTracker::z11 = 1603.5f;
-Float MansoTracker::z13 = 1703.5f;
-
-
-void MansoTracker::RegionOfInterest::Create(Point p, Float a, Float b)
+Float AliHLTMUONCoreMansoTracker::fgA7  = 0.016f;
+Float AliHLTMUONCoreMansoTracker::fgB7  = 2.0f;
+Float AliHLTMUONCoreMansoTracker::fgA8  = 0.016f;
+Float AliHLTMUONCoreMansoTracker::fgB8  = 2.0f;
+Float AliHLTMUONCoreMansoTracker::fgA9  = 0.020f;
+Float AliHLTMUONCoreMansoTracker::fgB9  = 3.0f;
+Float AliHLTMUONCoreMansoTracker::fgA10 = 0.020f;
+Float AliHLTMUONCoreMansoTracker::fgB10 = 3.0f;
+Float AliHLTMUONCoreMansoTracker::fgZ7  = 1274.5f;
+Float AliHLTMUONCoreMansoTracker::fgZ8  = 1305.5f;
+Float AliHLTMUONCoreMansoTracker::fgZ9  = 1408.6f;
+Float AliHLTMUONCoreMansoTracker::fgZ10 = 1439.6f;
+Float AliHLTMUONCoreMansoTracker::fgZ11 = 1603.5f;
+Float AliHLTMUONCoreMansoTracker::fgZ13 = 1703.5f;
+
+
+void AliHLTMUONCoreMansoTracker::RegionOfInterest::Create(AliHLTMUONCorePoint p, Float a, Float b)
 {
-       centre = p;
+       fCentre = p;
        // Compute the radius Rp
-       Float Rp = (Float) sqrt( p.x * p.x + p.y * p.y );
+       Float Rp = (Float) sqrt( p.fX * p.fX + p.fY * p.fY );
 
        // The radius Rs for the region of interest is computed from the
        // specification given in the document:
@@ -94,244 +86,244 @@ void MansoTracker::RegionOfInterest::Create(Point p, Float a, Float b)
        //   equation:
        //     Rs = a * Rp + b
        //   given on page 3 section 4.
-       Rs = a * Rp + b;
+       fRs = a * Rp + b;
 }
 
 
-bool MansoTracker::RegionOfInterest::Contains(Point p) const
+bool AliHLTMUONCoreMansoTracker::RegionOfInterest::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
        // of interest for p to be contained in the region of interest.
-       register Float lx = centre.x - p.x;
-       register Float ly = centre.y - p.y;
+       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
-               << " , centre = " << centre << " , r = " << r << " , Rs = " << Rs
+               << " , centre = " << fCentre << " , r = " << r << " , Rs = " << fRs
        );
-       return r <= Rs;
+       return r <= fRs;
 }
 
 
-void MansoTracker::RegionOfInterest::GetBoundaryBox(Float& left, Float& right, Float& bottom, Float& top)
+void AliHLTMUONCoreMansoTracker::RegionOfInterest::GetBoundaryBox(Float& left, Float& right, Float& bottom, Float& top)
 {
-       left = centre.x - Rs;
-       right = centre.x + Rs;
-       bottom = centre.y - Rs;
-       top = centre.y + Rs;
+       left = fCentre.fX - fRs;
+       right = fCentre.fX + fRs;
+       bottom = fCentre.fY - fRs;
+       top = fCentre.fY + fRs;
 }
 
 
-MansoTracker::Vertex::Vertex(Float x, Float y, Float z)
+AliHLTMUONCoreMansoTracker::Vertex::Vertex(Float x, Float y, Float z)
 {
-       this->x = x;
-       this->y = y;
-       this->z = z;
+       fX = x;
+       fY = y;
+       fZ = z;
 }
 
 
-MansoTracker::Vertex::Vertex(Point xy, Float z)
+AliHLTMUONCoreMansoTracker::Vertex::Vertex(AliHLTMUONCorePoint xy, Float z)
 {
-       x = xy.x;
-       y = xy.y;
-       this->z = z;
+       fX = xy.fX;
+       fY = xy.fY;
+       fZ = z;
 }
 
 
-MansoTracker::Line::Line(
+AliHLTMUONCoreMansoTracker::Line::Line(
         Float Ax, Float Ay, Float Az,
         Float Bx, Float By, Float Bz
     )
 {
-       Mx = Ax - Bx;
-       My = Ay - By;
-       Mz = Az - Bz;
-       Cx = Bx;
-       Cy = By;
-       Cz = Bz;
+       fMx = Ax - Bx;
+       fMy = Ay - By;
+       fMz = Az - Bz;
+       fCx = Bx;
+       fCy = By;
+       fCz = Bz;
 }
 
 
-MansoTracker::Line::Line(Vertex A, Vertex B)
+AliHLTMUONCoreMansoTracker::Line::Line(Vertex A, Vertex B)
 {
-       Mx = A.x - B.x;
-       My = A.y - B.y;
-       Mz = A.z - B.z;
-       Cx = B.x;
-       Cy = B.y;
-       Cz = B.z;
+       fMx = A.fX - B.fX;
+       fMy = A.fY - B.fY;
+       fMz = A.fZ - B.fZ;
+       fCx = B.fX;
+       fCy = B.fY;
+       fCz = B.fZ;
 }
 
 
-Point MansoTracker::Line::FindIntersectWithXYPlain(Float z) const
+AliHLTMUONCorePoint AliHLTMUONCoreMansoTracker::Line::FindIntersectWithXYPlain(Float z) const
 {
-       Assert( Mz != 0.0 );    // Should not have a ray perpendicular to the beam axis.
-       Float t = (z - Cz) / Mz;
-       Float Lx = Mx*t + Cx;
-       Float Ly = My*t + Cy;
+       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;
 
-       return Point(Lx, Ly);
+       return AliHLTMUONCorePoint(Lx, Ly);
 }
 
 
-MansoTracker::MansoTracker() : Tracker()
+AliHLTMUONCoreMansoTracker::AliHLTMUONCoreMansoTracker() : AliHLTMUONCoreTracker()
 {
-       sm4state = SM4Idle;
-       sm5state = SM5Idle;
-       requests_completed = 0;
+       fSm4state = kSM4Idle;
+       fSm5state = kSM5Idle;
+       fRequestsCompleted = 0;
 }
 
 
-void MansoTracker::FindTrack(const TriggerRecord& trigger)
+void AliHLTMUONCoreMansoTracker::FindTrack(const AliHLTMUONCoreTriggerRecord& trigger)
 {
-       DebugMsg(4, "SM5 state = " << sm5state << " , SM4 state = " << sm4state);
-       DebugMsg(1, "Processing trigger with pt = " << trigger.pt);
-       v1 = Vertex( trigger.station1impact, z11 );
-       Vertex v2 = Vertex( trigger.station2impact, z13 );
+       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 );
 
        // 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).
-       mc1.line = Line(v1, v2);
-       Point p10 = mc1.line.FindIntersectWithXYPlain( z10 );
+       fMc1.fLine = Line(fV1, v2);
+       AliHLTMUONCorePoint p10 = fMc1.fLine.FindIntersectWithXYPlain( fgZ10 );
 
        // Build a region of interest for tracking station 5 (chamber 10).
        // Remember the parameters a and b are station specific.
-       mc1.chamber = Chamber10;
-       mc1.roi.Create(p10, a10, b10);
+       fMc1.fChamber = kChamber10;
+       fMc1.fRoi.Create(p10, fgA10, fgB10);
        
        // Make SM5 state transition before the call to RequestClusters since
        // that method could call one of our methods again, so we need to be
        // in a consistant internal state.
-       sm5state = WaitChamber10;
+       fSm5state = kWaitChamber10;
 
        Float left, right, bottom, top;
-       mc1.roi.GetBoundaryBox(left, right, bottom, top);
-       RequestClusters(left, right, bottom, top, Chamber10, &mc1);
+       fMc1.fRoi.GetBoundaryBox(left, right, bottom, top);
+       RequestClusters(left, right, bottom, top, kChamber10, &fMc1);
 }
 
 
-void MansoTracker::ReturnClusters(void* tag, const ClusterPoint* clusters, UInt count)
+void AliHLTMUONCoreMansoTracker::ReturnClusters(void* tag, const AliHLTMUONCoreClusterPoint* clusters, UInt count)
 {
        Assert( count > 0 );
        Assert( clusters != NULL );
        
        TagData* data = (TagData*)tag;
-       DebugMsg(4, "Got MansoTracker::ReturnClusters(tag = " << tag
-               << ", chamber = " << data->chamber
+       DebugMsg(4, "Got AliHLTMUONCoreMansoTracker::ReturnClusters(tag = " << tag
+               << ", chamber = " << data->fChamber
                << ", clusters = " << clusters <<  ", count = " << count << ")"
        );
-       DebugMsg(4, "SM5 state = " << sm5state << " , SM4 state = " << sm4state);
+       DebugMsg(4, "SM5 state = " << fSm5state << " , SM4 state = " << fSm4state);
 
-       switch (data->chamber)
+       switch (data->fChamber)
        {
-       case Chamber7:  ReceiveClustersChamber7(clusters, count, data); break;
-       case Chamber8:  ReceiveClustersChamber8(clusters, count, data); break;
-       case Chamber9:  ReceiveClustersChamber9(clusters, count); break;
-       case Chamber10: ReceiveClustersChamber10(clusters, count); break;
+       case kChamber7:  ReceiveClustersChamber7(clusters, count, data); break;
+       case kChamber8:  ReceiveClustersChamber8(clusters, count, data); break;
+       case kChamber9:  ReceiveClustersChamber9(clusters, count); break;
+       case kChamber10: ReceiveClustersChamber10(clusters, count); break;
        default:
                // Error
-               DebugMsg(1, "ERROR: Got tag with an invalid value: " << data->chamber);
+               DebugMsg(1, "ERROR: Got tag with an invalid value: " << data->fChamber);
        }
 }
 
 
-void MansoTracker::EndOfClusters(void* tag)
+void AliHLTMUONCoreMansoTracker::EndOfClusters(void* tag)
 {
        TagData* data = (TagData*)tag;
-       DebugMsg(4, "Got MansoTracker::EndOfClusters(chamber = " << data->chamber << ")");
-       DebugMsg(4, "SM5 state = " << sm5state << " , SM4 state = " << sm4state);
+       DebugMsg(4, "Got AliHLTMUONCoreMansoTracker::EndOfClusters(chamber = " << data->fChamber << ")");
+       DebugMsg(4, "SM5 state = " << fSm5state << " , SM4 state = " << fSm4state);
 
-       switch (data->chamber)
+       switch (data->fChamber)
        {
-       case Chamber7:  EndOfClustersChamber7(); break;
-       case Chamber8:  EndOfClustersChamber8(); break;
-       case Chamber9:  EndOfClustersChamber9(); break;
-       case Chamber10: EndOfClustersChamber10(); break;
+       case kChamber7:  EndOfClustersChamber7(); break;
+       case kChamber8:  EndOfClustersChamber8(); break;
+       case kChamber9:  EndOfClustersChamber9(); break;
+       case kChamber10: EndOfClustersChamber10(); break;
        default:
                // Error
-               DebugMsg(1, "ERROR: Got tag with an invalid value: " << data->chamber);
+               DebugMsg(1, "ERROR: Got tag with an invalid value: " << data->fChamber);
        }
 }
 
 
-void MansoTracker::FillTrackData(Track& track)
+void AliHLTMUONCoreMansoTracker::FillTrackData(AliHLTMUONCoreTrack& track)
 {
-       DebugMsg(4, "FillTrack: st5 = " << st5rec->clusterpoint << ", st4 = " << foundpoint->clusterpoint);
+       DebugMsg(4, "FillTrack: st5 = " << fSt5rec->fClusterPoint << ", st4 = " << fFoundPoint->fClusterPoint);
        
-       Float x1 = foundpoint->clusterpoint.x;
-       Float y1 = foundpoint->clusterpoint.y;
-       Float y2 = st5rec->clusterpoint.y;
+       Float x1 = fFoundPoint->fClusterPoint.fX;
+       Float y1 = fFoundPoint->fClusterPoint.fY;
+       Float y2 = fSt5rec->fClusterPoint.fY;
        Float momentum;
-       Float pt = CalculateSignedPt(x1, y1, y2, st4z, st5z, momentum);
+       Float pt = AliHLTMUONCoreCalculateSignedPt(x1, y1, y2, fSt4z, fSt5z, momentum);
        DebugMsg(1, "Calculated Pt = " << pt);
        DebugMsg(1, "\tusing x1 = " << x1 << " , y1 = " << y1 << " , y2 = " << y2
-               << " , z1 = " << st4z << " , z2 = " << st5z
+               << " , z1 = " << fSt4z << " , z2 = " << fSt5z
        );
 
        if (pt < 0)
-               track.sign = Minus;
+               track.fSign = kSignMinus;
        else if (pt > 0)
-               track.sign = Plus;
+               track.fSign = kSignPlus;
        else
-               track.sign = UnknownSign;
+               track.fSign = kUnknownSign;
 
-       track.p = momentum;
-       track.pt = (Float) fabs(pt);
+       track.fP = momentum;
+       track.fPt = (Float) fabs(pt);
        for (UInt i = 0; i < 6; i++)
        {
-               track.point[i] = Point(0.0, 0.0);
-               track.region[i] = INVALID_ROI;
+               track.fPoint[i] = AliHLTMUONCorePoint(0.0, 0.0);
+               track.fRegion[i] = kINVALID_ROI;
        }
 
        Float left, right, bottom, top;
        
        // Have to create the ROI numbers from the internal region of interest structures.
-       st5rec->tag.roi.GetBoundaryBox(left, right, bottom, top);
-       dHLT::RegionOfInterest region4(left, right, bottom, top, st4chamber);
-       mc1.roi.GetBoundaryBox(left, right, bottom, top);
-       dHLT::RegionOfInterest region5(left, right, bottom, top, mc1.chamber);
+       fSt5rec->fTag.fRoi.GetBoundaryBox(left, right, bottom, top);
+       AliHLTMUONCoreRegionOfInterest region4(left, right, bottom, top, fSt4chamber);
+       fMc1.fRoi.GetBoundaryBox(left, right, bottom, top);
+       AliHLTMUONCoreRegionOfInterest region5(left, right, bottom, top, fMc1.fChamber);
        
        // Depending on the chamber we received cluster points from, fill the appropriate
        // point and ROI number. This is done for station 4 then 5.
-       if (st4chamber == Chamber8)
+       if (fSt4chamber == kChamber8)
        {
-               track.point[6] = Point(0.0, 0.0);
-               track.region[6] = INVALID_ROI;
-               track.point[7] = foundpoint->clusterpoint;
-               track.region[7] = region4;
+               track.fPoint[6] = AliHLTMUONCorePoint(0.0, 0.0);
+               track.fRegion[6] = kINVALID_ROI;
+               track.fPoint[7] = fFoundPoint->fClusterPoint;
+               track.fRegion[7] = region4;
        }
        else
        {
-               track.point[6] = foundpoint->clusterpoint;
-               track.region[6] = region4;
-               track.point[7] = Point(0.0, 0.0);
-               track.region[7] = INVALID_ROI;
+               track.fPoint[6] = fFoundPoint->fClusterPoint;
+               track.fRegion[6] = region4;
+               track.fPoint[7] = AliHLTMUONCorePoint(0.0, 0.0);
+               track.fRegion[7] = kINVALID_ROI;
        }
-       if (mc1.chamber == Chamber10)
+       if (fMc1.fChamber == kChamber10)
        {
-               track.point[8] = Point(0.0, 0.0);
-               track.region[8] = INVALID_ROI;
-               track.point[9] = st5rec->clusterpoint;
-               track.region[9] = region5;
+