#include "Utils.hpp"
-ClassImp(AliMUONHLT::ADCStream);
+ClassImp(AliMUONHLT::ADCStream)
namespace AliMUONHLT
{
ADCStream::ADCStream() : TObject()
{
fData.Set(0);
-};
+}
ADCStream::ADCStream(const UInt_t* data, const UInt_t size)
{
fData.Set(size, (Int_t*)data);
-};
+}
ADCStream::~ADCStream()
{
fData.Reset();
-};
+}
UInt_t ADCStream::Size()
{
return fData.GetSize();
-};
+}
void ADCStream::Size(const UInt_t size)
{
fData.Set(size);
-};
+}
void ADCStream::Fill(const UInt_t* data, const UInt_t size)
{
fData.Set(size, (Int_t*)data);
-};
+}
// UInt_t& ADCStream::operator [] (const UInt_t index)
{
Assert( index < (UInt_t) fData.GetSize() );
return fData[index];
-};
+}
ostream& operator << (ostream& os, const ADCStream& s)
char* str = (char*)&buffer[0];
sprintf(str, "0x%X", s.fData[i]);
os << i << "\t" << str << endl;
- };
+ }
return os;
-};
+}
-}; // AliMUONHLT
+} // AliMUONHLT
void Size(const UInt_t size);
void Fill(const UInt_t* data, const UInt_t size);
- UInt_t* Data() { return (UInt_t*) fData.GetArray(); };
- const UInt_t* Data() const { return (UInt_t*) fData.GetArray(); };
+ UInt_t* Data() { return (UInt_t*) fData.GetArray(); }
+ const UInt_t* Data() const { return (UInt_t*) fData.GetArray(); }
// UInt_t& operator [] (const UInt_t index);
UInt_t operator [] (const UInt_t index) const;
// TODO: complete the ADC stream specification.
TArrayI fData;
- ClassDef(ADCStream, 1); // ADC stream data.
+ ClassDef(ADCStream, 1) // ADC stream data.
};
-}; // AliMUONHLT
+} // AliMUONHLT
#endif // dHLT_ALIROOT_ADC_STREAM_HPP
// TODO: Change all the Error message statements to AliError at some stage.
-ClassImp(AliMUONHLT::ADCStreamSource);
-ClassImp(AliMUONHLT::ADCStreamSource::DataBlock);
+ClassImp(AliMUONHLT::ADCStreamSource)
+ClassImp(AliMUONHLT::ADCStreamSource::DataBlock)
namespace AliMUONHLT
{
ADCStreamSource::ADCStreamSource() : TObject()
{
fCurrentStream = -1;
-};
+}
ADCStreamSource::~ADCStreamSource()
{
// Everything is cleaned up implicitly.
-};
+}
void ADCStreamSource::FillFromFile(const TString& filename, const Int_t eventnumber)
);
DebugMsg(1, "Leaving FillFromFile");
-};
+}
void ADCStreamSource::FillFrom(const TString& directory, const Int_t eventnumber)
DebugMsg(1, "Leaving FillFrom");
-};
+}
void ADCStreamSource::FillFrom(const TString& dirprefix, const UInt_t firstevent, const UInt_t lastevent)
};
DebugMsg(1, "Leaving FillFrom");
-};
+}
void ADCStreamSource::Clear()
{
fCurrentStream = -1;
fList.erase( fList.begin(), fList.end() );
-};
+}
Int_t ADCStreamSource::NumberOfStreams() const
{
return fList.size();
-};
+}
Bool_t ADCStreamSource::GetStream(const Int_t index) const
index
);
return kFALSE;
- };
-};
+ }
+}
Bool_t ADCStreamSource::FirstStream() const
}
else
return kFALSE;
-};
+}
Bool_t ADCStreamSource::NextStream() const
{
Error("EventNumber", "No ADC stream selected.");
return -1;
- };
-};
+ }
+}
Bool_t ADCStreamSource::FetchStream(ADCStream& stream) const
{
Error("FetchStream", "No ADC stream selected.");
return kFALSE;
- };
-};
+ }
+}
Bool_t ADCStreamSource::FetchStream(const Int_t index, ADCStream& stream) const
return FetchStream(stream);
else
return kFALSE;
-};
+}
const ADCStream* ADCStreamSource::FetchStream() const
{
Error("FetchStream", "No ADC stream selected.");
return NULL;
- };
-};
+ }
+}
void ADCStreamSource::AddStream(ADCStream& stream, const UInt_t eventnumber)
fCurrentStream = fList.size() - 1;
DebugMsg(1, "Leaving AddStream");
-};
+}
-}; // AliMUONHLT
+} // AliMUONHLT
Int_t fEventNumber; // Event number of the stream.
ADCStream fStream; // The ADC stream block.
- ClassDef(DataBlock, 1); // Data per event.
+ ClassDef(DataBlock, 1) // Data per event.
};
private:
std::vector<DataBlock> fList; // List of ADC streams.
- ClassDef(ADCStreamSource, 1); // The source of ADC stream data for dHLT.
+ ClassDef(ADCStreamSource, 1) // The source of ADC stream data for dHLT.
};
-}; // AliMUONHLT
+} // AliMUONHLT
#endif // dHLT_ALIROOT_ADC_STREAM_SOURCE_HPP
#include "AliRoot/ClusterFinderCallback.hpp"
-ClassImp(AliMUONHLT::ClusterFinderCallback);
+ClassImp(AliMUONHLT::ClusterFinderCallback)
virtual void FoundClusters(const UInt_t numberfound) = 0;
virtual void NoClustersFound() = 0;
- ClassDef(ClusterFinderCallback, 0); // Abstract cluster finder callback class.
+ ClassDef(ClusterFinderCallback, 0) // Abstract cluster finder callback class.
};
};
-}; // AliMUONHLT
+} // AliMUONHLT
#endif // dHLT_ALIROOT_CLUSTER_FINDER_INTERFACE_HPP
: Clustering::ClusterFinder(), AliMUONHLT::ClusterFinderCallback()
{
clusterfinder = client;
-};
+}
void ClusterFinderProxy::FindClusters(const ADCStream* stream)
AliMUONHLT::ADCStream adc;
DebugMsg(6, "ClusterFinderProxy::FindClusters: " << adc);
clusterfinder->FindClusters(&adc);
-};
+}
UInt ClusterFinderProxy::FillClusterData(ClusterPoint* clusters, const UInt arraysize)
{
clusters[i] = Convert(points[i]);
DebugMsg(6, "\tpoints[" << i << "] = " << points[i] );
- };
+ }
}
finally
(
delete [] points;
- );
+ )
return result;
-};
+}
void ClusterFinderProxy::Reset()
{
DebugMsg(6, "ClusterFinderProxy::Reset");
clusterfinder->Reset();
-};
+}
void ClusterFinderProxy::FoundClusters(const UInt_t numberfound)
{
DebugMsg(6, "ClusterFinderProxy::FoundClusters");
Clustering::ClusterFinder::FoundClusters(numberfound);
-};
+}
void ClusterFinderProxy::NoClustersFound()
{
DebugMsg(6, "ClusterFinderProxy::NoClustersFound");
Clustering::ClusterFinder::NoClustersFound();
-};
+}
-}; // AliRoot
-}; // dHLT
+} // AliRoot
+} // dHLT
};
-}; // AliRoot
-}; // dHLT
+} // AliRoot
+} // dHLT
#endif // dHLT_ALIROOT_CLUSTER_FINDER_PROXY_HPP
#include <float.h>
#endif
-ClassImp(AliMUONHLT::ClusterSource);
-ClassImp(AliMUONHLT::ClusterSource::BlockData);
-ClassImp(AliMUONHLT::ClusterSource::EventData);
+ClassImp(AliMUONHLT::ClusterSource)
+ClassImp(AliMUONHLT::ClusterSource::BlockData)
+ClassImp(AliMUONHLT::ClusterSource::EventData)
namespace AliMUONHLT
{
fFilename = "";
fFoldername = "";
ResetAllPointers();
-};
+}
ClusterSource::ClusterSource(AliMUONDataInterface* data)
fFoldername = "";
ResetAllPointers();
FillFrom(data);
-};
+}
ClusterSource::~ClusterSource()
{
fEventList.Clear("C");
-};
+}
void ClusterSource::FillFrom(AliMUONDataInterface* data)
for (Int_t i = 0; i < data->NumberOfEvents(); i++)
{
AddEventFrom(data, i);
- };
- };
-};
+ }
+ }
+}
void ClusterSource::FillFrom(AliMUONDataInterface* data, const Int_t event)
if (FileAndFolderOk(data))
AddEventFrom(data, event);
-};
+}
void ClusterSource::FillFrom(AliMUONDataInterface* data, const Int_t event, const Int_t chamber)
{
AddEvent(event);
AddChamberFrom(data, chamber);
- };
- };
-};
+ }
+ }
+}
void ClusterSource::FillFrom(
AddBlock(chamber); // No block selected so we need to create a new block.
AddClusterFrom(data, chamber, cluster);
- };
-};
+ }
+}
void ClusterSource::Clear()
fFoldername = "";
ResetAllPointers();
fEventList.Clear("C");
-};
+}
Bool_t ClusterSource::GetEvent(const Int_t eventnumber) const
<< " , fClusterIndex = " << fClusterIndex
);
return kTRUE;
- };
- };
+ }
+ }
return kFALSE;
-};
+}
Bool_t ClusterSource::GetFirstEvent() const
<< " , fClusterIndex = " << fClusterIndex
);
return kFALSE;
- };
-};
+ }
+}
Bool_t ClusterSource::MoreEvents() const
{
return 0 <= fEventIndex and fEventIndex < fEventList.GetEntriesFast();
-};
+}
Bool_t ClusterSource::GetNextEvent() const
}
else
return fCurrentEvent->fBlocks.GetEntriesFast();
-};
+}
Bool_t ClusterSource::GetBlock(const Int_t index) const
index
);
return kFALSE;
- };
-};
+ }
+}
Bool_t ClusterSource::GetFirstBlock() const
}
else
return kFALSE;
-};
+}
Bool_t ClusterSource::MoreBlocks() const
{
return 0 <= fBlockIndex and fBlockIndex < NumberOfBlocks();
-};
+}
Bool_t ClusterSource::GetNextBlock() const
{
ResetBlockPointers();
return kFALSE;
- };
-};
+ }
+}
Int_t ClusterSource::Chamber() const
}
else
return fCurrentBlock->fChamber;
-};
+}
Int_t ClusterSource::NumberOfClusters() const
}
else
return fCurrentBlock->fClusters.GetEntriesFast();
-};
+}
const Point* ClusterSource::GetCluster(const Int_t index) const
index
);
return NULL;
- };
-};
+ }
+}
const Point* ClusterSource::GetFirstCluster() const
}
else
return NULL;
-};
+}
Bool_t ClusterSource::MoreClusters() const
{
Error("FetchCluster", "No cluster point selected.");
return kFALSE;
- };
-};
+ }
+}
void ClusterSource::AddEvent(const Int_t eventnumber)
DebugMsg(2, "\tfEventIndex = " << fEventIndex << " , fBlockIndex = " << fBlockIndex
<< " , fClusterIndex = " << fClusterIndex
);
-};
+}
void ClusterSource::AddBlock(const Int_t chamber)
DebugMsg(2, "\tfEventIndex = " << fEventIndex << " , fBlockIndex = " << fBlockIndex
<< " , fClusterIndex = " << fClusterIndex
);
-};
+}
void ClusterSource::AddPoint(const Float_t x, const Float_t y)
DebugMsg(2, "\tfEventIndex = " << fEventIndex << " , fBlockIndex = " << fBlockIndex
<< " , fClusterIndex = " << fClusterIndex
);
-};
+}
Bool_t ClusterSource::FileAndFolderOk(AliMUONDataInterface* data)
fFoldername.Data(), data->CurrentFolder().Data()
);
return kFALSE;
- };
+ }
return kTRUE;
-};
+}
void ClusterSource::AddEventFrom(AliMUONDataInterface* data, const Int_t event)
for (Int_t chamber = 0; chamber < AliMUONConstants::NTrackingCh(); chamber++)
{
AddChamberFrom(data, chamber);
- };
- };
-};
+ }
+ }
+}
void ClusterSource::AddChamberFrom(AliMUONDataInterface* data, const Int_t chamber)
AddBlock(chamber);
UInt_t currentblocksize = 0;
#ifndef __alpha
+#ifndef __sparc
Float_t x = NAN, y = NAN;
+#else
+ Float_t x = 0, y = 0;
+#endif
#else
Float_t x = FLT_QNAN, y = FLT_QNAN;
#endif
default:
Error("AddChamberFrom", "fDataToUse is not set to a valid value.");
- };
+ }
DebugMsg(1, "Leaving AddChamberFrom");
-};
+}
void ClusterSource::AddClusterFrom(
)
{
DebugMsg(1, "Entering AddClusterFrom");
-#ifndef __alpha
+#ifndef __alpha
+#ifndef __sparc
Float_t x = NAN, y = NAN;
+#else
+ Float_t x = 0, y = 0;
+#endif
#else
Float_t x = FLT_QNAN, y = FLT_QNAN;
#endif
DebugMsg(2, "\tfEventIndex = " << fEventIndex << " , fBlockIndex = " << fBlockIndex
<< " , fClusterIndex = " << fClusterIndex
);
-};
+}
void ClusterSource::ResetClusterPointers() const
DebugMsg(2, "\tfEventIndex = " << fEventIndex << " , fBlockIndex = " << fBlockIndex
<< " , fClusterIndex = " << fClusterIndex
);
-};
+}
ClusterSource::BlockData::BlockData() : fClusters(Point::Class())
{
fChamber = -1;
-};
+}
ClusterSource::BlockData::BlockData(const Int_t chamber) : fClusters(Point::Class())
{
fChamber = chamber;
-};
+}
ClusterSource::BlockData::~BlockData()
{
fClusters.Clear("C");
-};
+}
ClusterSource::EventData::EventData() : fBlocks(ClusterSource::BlockData::Class())
{
fEventNumber = -1;
-};
+}
ClusterSource::EventData::EventData(const Int_t eventnumber)
: fBlocks(ClusterSource::BlockData::Class())
// If the following is not set then we do not write the fBlocks properly.
fBlocks.BypassStreamer(kFALSE);
-};
+}
ClusterSource::EventData::~EventData()
{
fBlocks.Clear("C");
-};
+}
-}; // AliMUONHLT
+} // AliMUONHLT
TClonesArray fEventList; // List of clusters per event.
- ClassDef(ClusterSource, 1); // The source of cluster point blocks for dHLT.
+ ClassDef(ClusterSource, 1) // The source of cluster point blocks for dHLT.
};
-}; // AliMUONHLT
+} // AliMUONHLT
#endif // dHLT_ALIROOT_CLUSTER_SOURCE_HPP
virtual void RequestClusters(
Tracking::Tracker* tracker,
- const Float left, const Float right, const Float bottom, const Float top,
+ const Float /*left*/, const Float /*right*/, const Float /*bottom*/, const Float /*top*/,
const ChamberID chamber, const void* tag
)
{
};
- virtual void EndOfClusterRequests(Tracking::Tracker* tracker)
+ virtual void EndOfClusterRequests(Tracking::Tracker* /*tracker*/)
{
DebugMsg(2, "EndOfClusterRequests");
// We can ignore this. Nothing special to do here.
};
-}; // dHLT
+} // dHLT
////////////////////////////////////////////////////////////////////////////////
-ClassImp(AliMUONHLT::MicrodHLT);
+ClassImp(AliMUONHLT::MicrodHLT)
namespace AliMUONHLT
{
};
-}; // AliMUONHLT
+} // AliMUONHLT
#include "AliRoot/Point.hpp"
#include "TMath.h"
-ClassImp(AliMUONHLT::Point);
+ClassImp(AliMUONHLT::Point)
namespace AliMUONHLT
{
Point::Point() : TObject()
{
fX = fY = 0.0;
-};
+}
Point::Point(const Float_t x, const Float_t y) : TObject()
{
fX = x;
fY = y;
-};
+}
ostream& operator << (ostream& os, const Point& p)
{
os << "[" << p.fX << ", " << p.fY << "]";
return os;
-};
+}
-}; // AliMUONHLT
+} // AliMUONHLT
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(Point, 1) // A 2D space point.
};
-}; // AliMUONHLT
+} // AliMUONHLT
#endif // dHLT_ALIROOT_POINT_HPP
#include <TMath.h>
#include "Utils.hpp"
-ClassImp(AliMUONHLT::Region);
+ClassImp(AliMUONHLT::Region)
namespace AliMUONHLT
{
Region::Region() : TObject()
{
fLeft = fRight = fBottom = fTop = 0.0;
-};
+}
Region::Region(const Float_t left, const Float_t right, const Float_t bottom, const Float_t top)
fRight = right;
fBottom = bottom;
fTop = top;
- };
-};
+ }
+}
void Region::Left(const Float_t value)
Error("Left", "Trying to assign fLeft (%f) larger than fRight (%f).", value, fRight);
else
fLeft = value;
-};
+}
void Region::Right(const Float_t value)
Error("Right", "Trying to assign fRight (%f) smaller than fLeft (%f).", value, fLeft);
else
fRight = value;
-};
+}
void Region::Bottom(const Float_t value)
Error("Bottom", "Trying to assign fBottom (%f) larger than fTop (%f).", value, fTop);
else
fBottom = value;
-};
+}
void Region::Top(const Float_t value)
Error("Top", "Trying to assign fTop (%f) smaller than fBottom (%f).", value, fBottom);
else
fTop = value;
-};
+}
Bool_t Region::Contains(const Point& p) const
{
return fLeft <= p.fX and p.fX <= fRight and fBottom <= p.fY and p.fY <= fTop;
-};
+}
ostream& operator << (ostream& os, const Region& r)
{
os << "[(" << r.fLeft << ", " << r.fRight << "), (" << r.fLeft << ", " << r.fRight << ")]";
return os;
-};
+}
-}; // AliMUONHLT
+} // AliMUONHLT
*/
Region(const Float_t left, const Float_t right, const Float_t bottom, const Float_t top);
- virtual ~Region() {};
+ virtual ~Region() {}
/* Get/Set methods for the boundary lines.
Note: before assignment we check for the following parameter consistency:
and nothing is changed internally.
*/
void Left(const Float_t value);
- Float_t Left() const { return fLeft; };
+ Float_t Left() const { return fLeft; }
void Right(const Float_t value);
- Float_t Right() const { return fRight; };
+ Float_t Right() const { return fRight; }
void Bottom(const Float_t value);
- Float_t Bottom() const { return fBottom; };
+ Float_t Bottom() const { return fBottom; }
void Top(const Float_t value);
- Float_t Top() const { return fTop; };
+ Float_t Top() const { return fTop; }
/* Checks if the point is within this region. If it is then kTRUE is returned
otherwise kFALSE is returned.
Float_t fBottom; // Bottom boundary of boundary box.
Float_t fTop; // Top boundary of boundary box.
- ClassDef(Region, 1); // A boundary box region.
+ ClassDef(Region, 1) // A boundary box region.
};
-}; // AliMUONHLT
+} // AliMUONHLT
#endif // dHLT_ALIROOT_REGION_HPP
#include <TMath.h>
#include "Utils.hpp"
-ClassImp(AliMUONHLT::Track);
+ClassImp(AliMUONHLT::Track)
namespace AliMUONHLT
{
Track::Track() : TObject()
{
Init();
-};
+}
Track::Track(
{
fHit[i] = hits[i];
fRegionOfInterest[i] = regions[i];
- };
- };
-};
+ }
+ }
+}
void Track::Init()
fTriggerID = -1;
fParticleSign = 0;
fP = fPt = 0.0;
-};
+}
void Track::ParticleSign(const Int_t value)
"The particle sign must be a value of -1, 0 or +1, but got %d",
value
);
-};
+}
void Track::P(const Float_t value)
"Trying to assing momentum (%f) which is smaller than the pt value (%f).",
value, fPt
);
-};
+}
void Track::Pt(const Float_t value)
{
chamber
);
return fHit[0];
- };
-};
+ }
+}
const Point& Track::Hit(const UInt_t chamber) const
"The chamber is out of range. Got: %d, but should be in [0..9].",
chamber
);
-};
+}
Region& Track::RegionOfInterest(const UInt_t chamber)
chamber
);
return fRegionOfInterest[0];
- };
-};
+ }
+}
const Region& Track::RegionOfInterest(const UInt_t chamber) const
chamber
);
return fRegionOfInterest[0];
- };
-};
+ }
+}
void Track::RegionOfInterest(const UInt_t chamber, const Region& value)
"The chamber is out of range. Got: %d, but should be in [0..9].",
chamber
);
-};
+}
Bool_t Track::HitsInRegions() const
{
if ( not fRegionOfInterest[i].Contains(fHit[i]) )
return kFALSE;
- };
+ }
return kTRUE;
-};
+}
ostream& operator << (ostream& os, const Track& t)
os << "{trigid: " << t.fTriggerID << ", sign: " << t.fParticleSign
<< ", p: " << t.fP << ", pt: " << t.fPt << "}";
return os;
-};
+}
-}; // AliMUONHLT
+} // AliMUONHLT
const Point hits[10], const Region regions[10]
);
- virtual ~Track() {};
+ virtual ~Track() {}
// Get/et methods for the trigger ID.
Point fHit[10]; // Fitted track hit coordinates for the 10 tracking chambers.
Region fRegionOfInterest[10]; // Region of interest per chamber.
- ClassDef(Track, 1); // Track data.
+ ClassDef(Track, 1) // Track data.
};
-}; // AliMUONHLT
+} // AliMUONHLT
#endif // dHLT_ALIROOT_TRACK_HPP
#include "AliRoot/TrackSink.hpp"
#include "AliRoot/Base.hpp"
-ClassImp(AliMUONHLT::TrackSink);
-ClassImp(AliMUONHLT::TrackSink::EventData);
+ClassImp(AliMUONHLT::TrackSink)
+ClassImp(AliMUONHLT::TrackSink::EventData)
namespace AliMUONHLT
{
fFilename = "";
fFoldername = "";
ResetAllPointers();
-};
+}
TrackSink::~TrackSink()
{
DebugMsg(1, "TrackSink::~TrackSink()");
fEventList.Clear("C");
-};
+}
void TrackSink::AddEvent(const Int_t eventnumber)
DebugMsg(2, "\tfEventIndex = " << fEventIndex << " , fBlockIndex = " << fBlockIndex
<< " , fTrackIndex = " << fTrackIndex
);
-};
+}
void TrackSink::AddBlock()
DebugMsg(2, "\tfEventIndex = " << fEventIndex << " , fBlockIndex = " << fBlockIndex
<< " , fTrackIndex = " << fTrackIndex
);
-};
+}
void TrackSink::AddTrack(const Track& track)
DebugMsg(2, "\tfEventIndex = " << fEventIndex << " , fBlockIndex = " << fBlockIndex
<< " , fTrackIndex = " << fTrackIndex
);
-};
+}
Track* TrackSink::AddTrack()
DebugMsg(2, "\tfEventIndex = " << fEventIndex << " , fBlockIndex = " << fBlockIndex
<< " , fTrackIndex = " << fTrackIndex
);
-};
+}
void TrackSink::SetNames(const TriggerSource* triggersource)
{
fFilename = triggersource->FileName();
fFoldername = triggersource->FolderName();
-};
+}
void TrackSink::Clear()
fFoldername = "";
ResetAllPointers();
fEventList.Clear("C");
-};
+}
Bool_t TrackSink::GetEvent(const Int_t eventnumber) const
<< " , fTrackIndex = " << fTrackIndex
);
return kTRUE;
- };
- };
+ }
+ }
return kFALSE;
-};
+}
Bool_t TrackSink::GetFirstEvent() const
<< " , fTrackIndex = " << fTrackIndex
);
return kFALSE;
- };
-};
+ }
+}
Bool_t TrackSink::MoreEvents() const
{
return 0 <= fEventIndex and fEventIndex < fEventList.GetEntriesFast();
-};
+}
Bool_t TrackSink::GetNextEvent() const
return fCurrentEvent->fEventNumber;
else
return -1;
-};
+}
Int_t TrackSink::NumberOfBlocks() const
}
else
return fCurrentEvent->fBlocks.GetEntriesFast();
-};
+}
Bool_t TrackSink::GetBlock(const Int_t index) const
index
);
return kFALSE;
- };
-};
+ }
+}
Bool_t TrackSink::GetFirstBlock() const
}
else
return kFALSE;
-};
+}
Bool_t TrackSink::MoreBlocks() const
{
return 0 <= fBlockIndex and fBlockIndex < NumberOfBlocks();
-};
+}
Bool_t TrackSink::GetNextBlock() const
{
ResetBlockPointers();
return kFALSE;
- };
-};
+ }
+}
Int_t TrackSink::NumberOfTracks() const
index
);
return NULL;
- };
-};
+ }
+}
const Track* TrackSink::GetFirstTrack() const
}
else
return NULL;
-};
+}
Bool_t TrackSink::MoreTracks() const
{
return 0 <= fTrackIndex and fTrackIndex < NumberOfTracks();
-};
+}
const Track* TrackSink::GetNextTrack() const
{
ResetTrackPointers();
return NULL;
- };
-};
+ }
+}
void TrackSink::ResetAllPointers() const
DebugMsg(2, "\tfEventIndex = " << fEventIndex << " , fBlockIndex = " << fBlockIndex
<< " , fTrackIndex = " << fTrackIndex
);
-};
+}
void TrackSink::ResetBlockPointers() const
DebugMsg(2, "\tfEventIndex = " << fEventIndex << " , fBlockIndex = " << fBlockIndex
<< " , fTrackIndex = " << fTrackIndex
);
-};
+}
void TrackSink::ResetTrackPointers() const
DebugMsg(2, "\tfEventIndex = " << fEventIndex << " , fBlockIndex = " << fBlockIndex
<< " , fTrackIndex = " << fTrackIndex
);
-};
+}
TrackSink::EventData::EventData() : fBlocks(TClonesArray::Class())
{
fEventNumber = -1;
-};
+}
TrackSink::EventData::EventData(const Int_t eventnumber)
// If the following is not set then we do not write the fBlocks properly.
fBlocks.BypassStreamer(kFALSE);
-};
+}
TrackSink::EventData::~EventData()
{
DebugMsg(1, "TrackSink::EventData::~EventData()");
fBlocks.Clear("C");
-};
+}
-}; // AliMUONHLT
+} // AliMUONHLT
void Clear();
// Get methods for file and folder names.
- TString FileName() const { return fFilename; };
- TString FolderName() const { return fFoldername; };
+ TString FileName() const { return fFilename; }
+ TString FolderName() const { return fFoldername; }
/* Returns the number of events stored.
*/
TClonesArray fEventList; // List of tracks per event.
- ClassDef(TrackSink, 1); // The data sink for track blocks for dHLT.
+ ClassDef(TrackSink, 1) // The data sink for track blocks for dHLT.
};
-}; // AliMUONHLT
+} // AliMUONHLT
#endif // dHLT_ALIROOT_TRACK_SINK_HPP
#include "AliRoot/TrackerCallback.hpp"
-ClassImp(AliMUONHLT::TrackerCallback);
+ClassImp(AliMUONHLT::TrackerCallback)
virtual void FoundTrack() = 0;
virtual void NoTrackFound() = 0;
- ClassDef(TrackerCallback, 0); // Abstract tracker callback class.
+ ClassDef(TrackerCallback, 0) // Abstract tracker callback class.
};
};
-}; // AliMUONHLT
+} // AliMUONHLT
#endif // dHLT_ALIROOT_TRACKER_INTERFACE_HPP
: Tracking::Tracker(), AliMUONHLT::TrackerCallback()
{
tracker = client;
-};
+}
void TrackerProxy::FindTrack(const TriggerRecord& trigger)
AliMUONHLT::TriggerRecord rec = Convert(trigger, 0);
DebugMsg(6, "TrackerProxy::FindTrack : rec = " << rec);
tracker->FindTrack(rec);
-};
+}
void TrackerProxy::ReturnClusters(void* tag, const ClusterPoint* clusters, const UInt count)
finally
(
delete [] points;
- );
-};
+ )
+}
void TrackerProxy::EndOfClusters(void* tag)
{
DebugMsg(6, "TrackerProxy::EndOfClusters");
tracker->EndOfClusters(tag);
-};
+}
void TrackerProxy::FillTrackData(Track& track)
tracker->FillTrackData(data);
DebugMsg(6, "TrackerProxy::FillTrackData : data = " << data);
track = Convert(data);
-};
+}
void TrackerProxy::Reset()
{
DebugMsg(6, "TrackerProxy::Reset");
tracker->Reset();
-};
+}
void TrackerProxy::RequestClusters(
{
DebugMsg(6, "TrackerProxy::RequestClusters");
Tracking::Tracker::RequestClusters(left, right, bottom, top, (ChamberID)chamber, tag);
-};
+}
void TrackerProxy::EndOfClusterRequests()
{
DebugMsg(6, "TrackerProxy::EndOfClusterRequests");
Tracking::Tracker::EndOfClusterRequests();
-};
+}
void TrackerProxy::FoundTrack()
{
DebugMsg(6, "TrackerProxy::FoundTrack");
Tracking::Tracker::FoundTrack();
-};
+}
void TrackerProxy::NoTrackFound()
{
DebugMsg(6, "TrackerProxy::NoTrackFound");
Tracking::Tracker::NoTrackFound();
-};
+}
-}; // AliRoot
-}; // dHLT
+} // AliRoot
+} // dHLT
};
-}; // AliRoot
-}; // dHLT
+} // AliRoot
+} // dHLT
#endif // dHLT_ALIROOT_TRACKER_PROXY_HPP
#include "AliRoot/TriggerRecord.hpp"
#include "TMath.h"
-ClassImp(AliMUONHLT::TriggerRecord);
+ClassImp(AliMUONHLT::TriggerRecord)
namespace AliMUONHLT
{
TriggerRecord::TriggerRecord()
{
Init();
-};
+}
TriggerRecord::TriggerRecord(
fPt = pt;
fSt1Point = station1point;
fSt2Point = station2point;
- };
-};
+ }
+}
void TriggerRecord::Init()
fTriggerNumber = -1;
fParticleSign = 0;
fPt = 0.0;
-};
+}
void TriggerRecord::TriggerNumber(const Int_t value)
"The trigger number must be a positive number. Got: %d",
value
);
-};
+}
void TriggerRecord::ParticleSign(const Int_t value)
"The particle sign must a value of -1, 0 or +1. Got: %d",
value
);
-};
+}
void TriggerRecord::Pt(const Float_t value)
"The transverse momentum must be a positive number. Got: %f",
value
);
-};
+}
ostream& operator << (ostream& os, const TriggerRecord& r)
<< ", pt: " << r.fPt << ", st1: " << r.fSt1Point << ", st2: "
<< r.fSt2Point << "}";
return os;
-};
+}
-}; // AliMUONHLT
+} // AliMUONHLT
Point fSt1Point; // Coordinate on trigger station 1.
Point fSt2Point; // Coordinate on trigger station 2.
- ClassDef(TriggerRecord, 1); // Trigger information.
+ ClassDef(TriggerRecord, 1) // Trigger information.
};
-}; // AliMUONHLT
+} // AliMUONHLT
#endif // dHLT_ALIROOT_TRIGGER_RECORD_HPP
#include <float.h>
#endif
-ClassImp(AliMUONHLT::TriggerSource);
-ClassImp(AliMUONHLT::TriggerSource::EventData);
+ClassImp(AliMUONHLT::TriggerSource)
+ClassImp(AliMUONHLT::TriggerSource::EventData)
namespace AliMUONHLT
{
fFoldername = "";
ResetAllPointers();
fHadToLoadgAlice = kFALSE;
-};
+}
TriggerSource::TriggerSource(AliMUONDataInterface* data)
ResetAllPointers();
fHadToLoadgAlice = kFALSE;
FillFrom(data);
-};
+}
TriggerSource::~TriggerSource()
{
fEventList.Clear("C");
-};
+}
void TriggerSource::FillFrom(AliMUONDataInterface* data)
for (Int_t i = 0; i < data->NumberOfEvents(); i++)
{
AddEventFrom(data, module, i);
- };
+ }
FinishedWithAliMUON();
- };
-};
+ }
+}
void TriggerSource::FillFrom(AliMUONDataInterface* data, const Int_t event)
if ( not FetchAliMUON(module) ) return;
AddEventFrom(data, module, event);
FinishedWithAliMUON();
- };
-};
+ }
+}
void TriggerSource::FillFrom(
AddTriggerFrom(data, module, trigger);
FinishedWithAliMUON();
- };
-};
+ }
+}
void TriggerSource::Clear()
fFoldername = "";
ResetAllPointers();
fEventList.Clear("C");
-};
+}
Bool_t TriggerSource::GetEvent(const Int_t eventnumber) const
};
};
return kFALSE;
-};
+}
Bool_t TriggerSource::GetFirstEvent() const
<< " , fTriggerIndex = " << fTriggerIndex
);
return kFALSE;
- };
-};
+ }
+}
Bool_t TriggerSource::MoreEvents() const
{
return 0 <= fEventIndex and fEventIndex < fEventList.GetEntriesFast();
-};
+}
Bool_t TriggerSource::GetNextEvent() const
{
ResetAllPointers();
return kFALSE;
- };
-};
+ }
+}
Int_t TriggerSource::CurrentEvent() const
return fCurrentEvent->fEventNumber;
else
return -1;
-};
+}
Int_t TriggerSource::NumberOfBlocks() const
}
else
return fCurrentEvent->fBlocks.GetEntriesFast();
-};
+}
Bool_t TriggerSource::GetBlock(const Int_t index) const
index
);
return kFALSE;
- };
-};
+ }
+}
Bool_t TriggerSource::GetFirstBlock() const
}
else
return kFALSE;
-};
+}
Bool_t TriggerSource::MoreBlocks() const
{
return 0 <= fBlockIndex and fBlockIndex < NumberOfBlocks();
-};
+}
Bool_t TriggerSource::GetNextBlock() const
{
ResetBlockPointers();
return kFALSE;
- };
-};
+ }
+}
Int_t TriggerSource::NumberOfTriggers() const
}
else
return fCurrentBlock->GetEntriesFast();
-};
+}
const TriggerRecord* TriggerSource::GetTrigger(const Int_t triggernumber) const
<< " , fTriggerIndex = " << fTriggerIndex
);
return current;
- };
- };
+ }
+ }
return NULL;
-};
+}
const TriggerRecord* TriggerSource::GetFirstTrigger() const
Bool_t TriggerSource::MoreTriggers() const
{
return 0 <= fTriggerIndex and fTriggerIndex < NumberOfTriggers();
-};
+}
const TriggerRecord* TriggerSource::GetNextTrigger() const
{
Error("CurrentTrigger", "No trigger record selected.");
return -1;
- };
-};
+ }
+}
void TriggerSource::AddEvent(const Int_t eventnumber)
DebugMsg(2, "\tfEventIndex = " << fEventIndex << " , fBlockIndex = " << fBlockIndex
<< " , fTriggerIndex = " << fTriggerIndex
);
-};
+}
void TriggerSource::AddBlock()
DebugMsg(2, "\tfEventIndex = " << fEventIndex << " , fBlockIndex = " << fBlockIndex
<< " , fTriggerIndex = " << fTriggerIndex
);
-};
+}
void TriggerSource::AddTrigger(const TriggerRecord& data)
{
Error("AddTrigger", "No block selected.");
return;
- };
+ }
fTriggerIndex = fCurrentBlock->GetEntriesFast();
new ( (*fCurrentBlock)[fTriggerIndex] ) TriggerRecord(data);
DebugMsg(2, "\tfEventIndex = " << fEventIndex << " , fBlockIndex = " << fBlockIndex
<< " , fTriggerIndex = " << fTriggerIndex
);
-};
+}
Bool_t TriggerSource::FileAndFolderOk(AliMUONDataInterface* data)
};
return kTRUE;
-};
+}
void TriggerSource::AddEventFrom(AliMUONDataInterface* data, AliMUON* module, const Int_t event)
default:
Error("AddChamberFrom", "fDataToUse is not set to a valid value.");
- };
- }; // Loop on events.
-};
+ }
+ } // Loop on events.
+}
void TriggerSource::AddTriggerFrom(AliMUONDataInterface* data, AliMUON* module, const Int_t trigger)
AddTrigger(trigdata);
DebugMsg(1, "Leaving AddTriggerFrom");
-};
+}
Bool_t TriggerSource::InFillRegion(const TriggerRecord& data)
default:
Error("InFillRegion", "fAreaToUse is not set to a valid value.");
return kFALSE;
- };
-};
+ }
+}
void TriggerSource::FillTriggerFromLocalTrigger(
DebugMsg(2, "fStation1y = " << record.Station1Point().fY);
DebugMsg(2, "fStation2x = " << record.Station2Point().fX);
DebugMsg(2, "fStation2y = " << record.Station2Point().fY);
-};
+}
Bool_t TriggerSource::FillTriggerFromHits(AliMUONDataInterface* data, const Int_t track, TriggerRecord& record)
Float_t x1, y1, z1, x2, y2, z2, x3, y3, z3, x4, y4, z4;
#ifndef __alpha
+#ifndef __sparc
x1 = y1 = z1 = x2 = y2 = z2 = x3 = y3 = z3 = x4 = y4 = z4 = NAN;
+#else
+ x1 = y1 = z1 = x2 = y2 = z2 = x3 = y3 = z3 = x4 = y4 = z4 = 0;
+#endif
#else
x1 = y1 = z1 = x2 = y2 = z2 = x3 = y3 = z3 = x4 = y4 = z4 = FLT_QNAN;
#endif
DebugMsg(3, "Pt = " << record.Pt());
return kTRUE;
-};
+}
Bool_t TriggerSource::FetchAliMUON(AliMUON*& module)
// Get the MUON module pointer and return it.
module = dynamic_cast<AliMUON*>( alirun->GetModule("MUON") );
return kTRUE;
-};
+}
void TriggerSource::FinishedWithAliMUON()
// Only unload the gAlice object if we had to load it ourselves.
if (fHadToLoadgAlice)
AliRunLoader::GetRunLoader()->UnloadgAlice();
-};
+}
void TriggerSource::ResetAllPointers() const
DebugMsg(2, "\tfEventIndex = " << fEventIndex << " , fBlockIndex = " << fBlockIndex
<< " , fTriggerIndex = " << fTriggerIndex
);
-};
+}
void TriggerSource::ResetBlockPointers() const
DebugMsg(2, "\tfEventIndex = " << fEventIndex << " , fBlockIndex = " << fBlockIndex
<< " , fTriggerIndex = " << fTriggerIndex
);
-};
+}
void TriggerSource::ResetTriggerPointers() const
DebugMsg(2, "\tfEventIndex = " << fEventIndex << " , fBlockIndex = " << fBlockIndex
<< " , fTriggerIndex = " << fTriggerIndex
);
-};
+}
TriggerSource::EventData::EventData() : fBlocks(TClonesArray::Class())
{
fEventNumber = -1;
-};
+}
TriggerSource::EventData::EventData(const Int_t eventnumber)
// If the following is not set then we do not write the fBlocks properly.
fBlocks.BypassStreamer(kFALSE);
-};
+}
TriggerSource::EventData::~EventData()
{
fBlocks.Clear("C");
-};
+}
-}; // AliMUONHLT
+} // AliMUONHLT
Int_t fEventNumber; // Event number in AliMUONDataInterface from which the triggers were taken.
TClonesArray fBlocks; // The list of blocks of trigger records.
- ClassDef(EventData, 1); // Data per event.
+ ClassDef(EventData, 1) // Data per event.
};
private:
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(TriggerSource, 1) // The source of trigger records for dHLT.
};
-}; // AliMUONHLT
+} // AliMUONHLT
#endif // dHLT_ALIROOT_TRIGGER_SOURCE_HPP
{
DebugMsg(5, "Convert from dHLT::Point");
return AliMUONHLT::Point(point.x, point.y);
-};
+}
dHLT::Point Convert(const AliMUONHLT::Point& point)
{
DebugMsg(5, "Convert from AliMUONHLT::Point");
return dHLT::Point(point.fX, point.fY);
-};
+}
AliMUONHLT::TriggerRecord Convert(const dHLT::TriggerRecord& record, const Int_t triggernumber)
Convert( record.station1impact ),
Convert( record.station2impact )
);
- };
-};
+ }
+}
dHLT::TriggerRecord Convert(const AliMUONHLT::TriggerRecord& record)
Convert( record.Station1Point() ),
Convert( record.Station2Point() )
);
-};
+}
AliMUONHLT::Track Convert(const dHLT::Track& track)
// is filled with NaN's.
if (track.region[i] != dHLT::INVALID_ROI)
t.RegionOfInterest(i) = Convert( track.region[i] );
- };
+ }
return t;
-};
+}
dHLT::Track Convert(const AliMUONHLT::Track& track)
{
t.point[i] = Convert( track.Hit(i) );
t.region[i] = Convert( track.RegionOfInterest(i), i );
- };
+ }
return t;
-};
+}
AliMUONHLT::Region Convert(const dHLT::ROI region)
DebugMsg(5, "Convert from dHLT::ROI");
dHLT::RegionOfInterest roi(region);
return AliMUONHLT::Region( roi.Left(), roi.Right(), roi.Bottom(), roi.Top() );
-};
+}
dHLT::ROI Convert(const AliMUONHLT::Region& region, const UInt_t chamber)
dHLT::Chamber10
);
return roi;
- };
-};
+ }
+}
-}; // AliRoot
-}; // dHLT
+} // AliRoot
+} // dHLT
extern dHLT::ROI Convert(const AliMUONHLT::Region& region, const UInt_t chamber);
-}; // AliRoot
-}; // dHLT
+} // AliRoot
+} // dHLT
#endif // dHLT_ALIROOT_CONVERT_HPP
template <typename DataType>
class List
{
-protected:
+ //protected:
+
+public:
struct Node
{
Node* first;
-public:
-
class ConstIterator
{
public:
ConstIterator()
{
current = NULL;
- };
+ }
ConstIterator(const ConstIterator& iter)
{
current = iter.current;
- };
+ }
ConstIterator(Node* node)
{
current = node;
- };
+ }
const DataType& operator * () const
{
return current->data;
- };
+ }
const DataType* operator -> () const
{
return ¤t->data;
- };
+ }
ConstIterator& operator ++ ()
{
Assert( current != NULL );
current = current->next;
return *this;
- };
+ }
ConstIterator operator ++ (int)
{
ConstIterator copy = *this;
current = current->next;
return copy;
- };
+ }
operator const DataType* () const
{
return ¤t->data;
- };
+ }
friend bool operator == (const ConstIterator& a, const ConstIterator& b)
{
return a.current == b.current;
- };
+ }
friend bool operator != (const ConstIterator& a, const ConstIterator& b)
{
return a.current != b.current;
- };
+ }
protected:
Iterator() : ConstIterator()
{
previous = NULL;
- };
+ }
Iterator(const Iterator& iter) : ConstIterator(iter)
{
previous = iter.previous;
- };
+ }
Iterator(Node* current, Node* prev) : ConstIterator(current)
{
previous = prev;
- };
+ }
DataType& operator * ()
{
return ConstIterator::current->data;
- };
+ }
DataType* operator -> ()
{
return &ConstIterator::current->data;
- };
+ }
Iterator& operator ++ ()
{
previous = ConstIterator::current;
ConstIterator::current = ConstIterator::current->next;
return *this;
- };
+ }
Iterator operator ++ (int)
{
previous = ConstIterator::current;
ConstIterator::current = ConstIterator::current->next;
return copy;
- };
+ }
operator DataType* ()
{
return &ConstIterator::current->data;
else
return NULL;
- };
+ }
protected:
List()
{
first = NULL;
- };
+ }
~List()
Node* temp = current;
current = current->next;
delete temp;
- };
- };
+ }
+ }
bool Empty() const
{
return first == NULL;
- };
+ }
DataType* New()
newnode->next = first;
first = newnode;
return &newnode->data;
- };
+ }
inline DataType* Add()
{
return New();
- };
+ }
void Add(const DataType& data)
{
DataType* newdata = New();
*newdata = data;
- };
+ }
DataType* AddNew(const DataType& data)
DataType* newdata = Add();
*newdata = data;
return newdata;
- };
+ }
DataType* AddUniquely(const DataType& data)
return AddNew(data);
else
return result;
- };
+ }
void Remove(const UInt index)
Assert( current != NULL );
previous = current;
current = current->next;
- };
+ }
Node* temp;
if (previous == NULL)
{
{
temp = current;
previous->next = current->next;
- };
+ }
delete temp;
- };
+ }
bool Remove(const DataType& data)
}
else
return false;
- };
+ }
void Remove(Iterator& iter)
{
temp = current;
previous->next = current->next;
- };
+ }
delete temp;
- };
+ }
Iterator Find(const DataType& data)
return Iterator(current, previous);
previous = current;
current = current->next;
- };
+ }
return End();
- };
+ }
ConstIterator Find(const DataType& data) const
current = current->next;
};
return End();
- };
+ }
template <typename PredicateType>
return Iterator(current, previous);
previous = current;
current = current->next;
- };
+ }
return End();
- };
+ }
template <typename PredicateType>
if ( predicate(current->data) )
return current;
current = current->next;
- };
+ }
return End();
- };
+ }
bool Contains(const DataType& data) const
{
return Find(data) != End();
- };
+ }
void Clear()
delete temp;
};
first = NULL;
- };
+ }
Iterator First()
{
return Iterator(first, NULL);
- };
+ }
ConstIterator First() const
{
return first;
- };
+ }
Iterator End()
{
return Iterator(NULL, NULL);
- };
+ }
ConstIterator End() const
{
return NULL;
- };
+ }
# ifdef DEBUG
{
cout << current->data << endl;
current = current->next;
- };
- };
+ }
+ }
# endif // DEBUG
};
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;
-};
+}
CenterOfGravityFinder::~CenterOfGravityFinder()
{
// TODO
-};
+}
void CenterOfGravityFinder::FindClusters(const ADCStream* stream)
{
// TODO
-};
+}
UInt CenterOfGravityFinder::FillClusterData(
{
// TODO
return 0;
-};
+}
void CenterOfGravityFinder::Reset() {
// TODO
-};
+}
-}; // Clustering
-}; // dHLT
+} // Clustering
+} // dHLT
// The one and only pree allocated out of memory error object.
static dHLT::OutOfMemory _out_of_memory_;
-}; // end of namespace
+} // end of namespace
namespace dHLT
const char* OutOfMemory::Message() const throw()
{
return "Out of memory.";
-};
+}
Int OutOfMemory::ErrorCode() const throw()
{
return OUT_OF_MEMORY;
-};
+}
void ThrowOutOfMemory() throw (OutOfMemory)
{
throw _out_of_memory_;
-};
+}
-}; // dHLT
+} // dHLT
};
-}; // dHLT
+} // dHLT
#endif // dHLT_ERROR_HPP
{
x = 0.0;
y = 0.0;
- };
+ }
- Point(const Float x, const Float y)
+ Point(const Float x0, const Float y0)
{
- this->x = x;
- this->y = y;
- };
+ this->x = x0;
+ this->y = y0;
+ }
};
{
chamber = Chamber1;
left = right = top = bottom = 0.0;
- };
+ }
/* This constructor decodes the ROI bit pattern into a region of
interest object.
RegionOfInterest(const ROI& code)
{
Decode(code);
- };
+ }
/* Creates a region of interest around the given point for the
specified chamber.
*/
- RegionOfInterest(const ClusterPoint& point, const ChamberID chamber)
+ RegionOfInterest(const ClusterPoint& point0, const ChamberID chamber0)
{
- CreateToContain(point, chamber);
- };
+ CreateToContain(point0, chamber0);
+ }
/* Creates a region of interest around all the given points and for the
specified chamber.
*/
- RegionOfInterest(const ClusterPoint* points, const UInt count, const ChamberID chamber)
+ RegionOfInterest(const ClusterPoint* points0, const UInt count0, const ChamberID chamber0)
{
- CreateToContain(points, count, chamber);
- };
+ CreateToContain(points0, count0, chamber0);
+ }
/* Creates a region of interest with the specified boundaries and for
the specified chamber.
*/
- RegionOfInterest(const Float left, const Float right, const Float bottom, const Float top, const ChamberID chamber)
+ RegionOfInterest(const Float left0, const Float right0, const Float bottom0, const Float top0, const ChamberID chamber0)
{
- Assert( 0 <= chamber and chamber < NUMBER_OF_TRACKING_CHAMBERS );
- this->chamber = chamber;
- this->left = left;
- this->right = right;
- this->bottom = bottom;
- this->top = top;
- };
+ Assert( 0 <= chamber0 and chamber0 < NUMBER_OF_TRACKING_CHAMBERS );
+ this->chamber = chamber0;
+ this->left = left0;
+ this->right = right0;
+ this->bottom = bottom0;
+ this->top = top0;
+ }
/* Checks if the point is contained in this region of interest.
{
return left <= point.x and point.x <= right and
bottom <= point.y and point.y <= top;
- };
+ }
/* 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, const ChamberID chamber) const
+ bool Contains(const ClusterPoint& point, const ChamberID chamber0) const
{
return left <= point.x and point.x <= right and
bottom <= point.y and point.y <= top and
- this->chamber == chamber;
- };
+ this->chamber == chamber0;
+ }
/* Checks if the specified region of interest is contained in this
return chamber == roi.chamber and
left <= roi.left and right >= roi.right and
bottom <= roi.bottom and top >= roi.top;
- };
+ }
/* Creates a region of interest around the given point for the
static void SetZ13(const Float value) { z13 = value; };
-protected:
+ //protected:
class RegionOfInterest
Char* str = (Char*) &strbuf;
sprintf(str, "%d.%d.%d", MAJOR_VERSION, MINOR_VERSION, BUILD_NUMBER);
return str;
-};
+}
UInt MajorVersion()
{
return MAJOR_VERSION;
-};
+}
UInt MinorVersion()
{
return MINOR_VERSION;
-};
+}
UInt BuildNumber()
{
return BUILD_NUMBER;
-};
+}
-}; // dHLT
+} // dHLT
UInt BuildNumber();
-}; // dHLT
+} // dHLT
#endif // dHLT_VERSION_FUNCTIONS_HPP
git://git.uio.no / u / mrichter / AliRoot.git / commitdiff