//-----------------------------------------------------------------------------
#include "AliMpPad.h"
+#include "AliMpEncodePair.h"
#include "AliLog.h"
#include <TClonesArray.h>
#include <Riostream.h>
+using std::cout;
+using std::endl;
/// \cond CLASSIMP
ClassImp(AliMpPad)
/// \endcond
const Int_t AliMpPad::fgkMaxNofLocations = 6;
-//
-// foreign operators
-//
-
//_____________________________________________________________________________
-Bool_t operator==(const TVector2& v1,const TVector2& v2)
-{
- return v1.X()==v2.X() && v1.Y()==v2.Y();
-}
-
-
-//_____________________________________________________________________________
-ostream& operator<<(ostream& out,const TVector2& v)
+AliMpPad::AliMpPad(Int_t manuId, Int_t channel,
+ Int_t ix, Int_t iy,
+ Double_t x, Double_t y,
+ Double_t dx, Double_t dy,
+ Bool_t validity)
+ : TObject(),
+ fNofLocations(0),
+ fLLocations(0),
+ fLLocation(AliMp::Pair(manuId, channel)),
+ fLIndices(AliMp::Pair(ix, iy)),
+ fPositionX(x),
+ fPositionY(y),
+ fDimensionX(dx),
+ fDimensionY(dy),
+ fValidity(validity)
{
- out << '(' << v.X() << ',' << v.Y() << ')';
- return out;
+/// Standard constructor \n
+/// Be carefull : this constructor doesn't check the validity of
+/// the correspondance between location and indices.
+/// By default, validity is set true.
+/// It is aimed to be used by MSegmentation methods, and never from outside....
}
-
//_____________________________________________________________________________
-AliMpPad::AliMpPad(const AliMpIntPair& location,const AliMpIntPair& indices,
- const TVector2& position,const TVector2& dimensions,
+AliMpPad::AliMpPad(Int_t manuId, Int_t channel,
+ MpPair_t indices,
+ Double_t x, Double_t y,
+ Double_t dx, Double_t dy,
Bool_t validity)
: TObject(),
- fLocations(0),
fNofLocations(0),
- fLocation(location),
- fIndices(indices),
- fPosition(position),
- fDimensions(dimensions),
+ fLLocations(0),
+ fLLocation(AliMp::Pair(manuId, channel)),
+ fLIndices(indices),
+ fPositionX(x),
+ fPositionY(y),
+ fDimensionX(dx),
+ fDimensionY(dy),
fValidity(validity)
{
/// Standard constructor \n
/// It is aimed to be used by MSegmentation methods, and never from outside....
}
-
//_____________________________________________________________________________
AliMpPad::AliMpPad()
: TObject(),
- fLocations(0),
fNofLocations(0),
- fLocation(AliMpIntPair::Invalid()),
- fIndices(AliMpIntPair::Invalid()),
- fPosition(-1.,-1.),
- fDimensions(0.,0.),
+ fLLocations(0),
+ fLLocation(0),
+ fLIndices(0),
+ fPositionX(-1.),
+ fPositionY(-1.),
+ fDimensionX(-1.),
+ fDimensionY(-1.),
fValidity(false)
{
/// Default constructor - creates pad in invalid state
}
-
//_____________________________________________________________________________
AliMpPad::AliMpPad(const AliMpPad& rhs)
- : TObject(rhs),
- fLocations(0),
+ : TObject(),
fNofLocations(0),
- fLocation(AliMpIntPair::Invalid()),
- fIndices(AliMpIntPair::Invalid()),
- fPosition(-1.,-1.),
- fDimensions(0.,0.),
+ fLLocations(0),
+ fLLocation(0),
+ fLIndices(0),
+ fPositionX(-1.),
+ fPositionY(-1.),
+ fDimensionX(-1.),
+ fDimensionY(-1.),
fValidity(false)
{
/// Copy constructor
{
/// Destructor
- delete [] fLocations;
+ delete [] fLLocations;
}
//_____________________________________________________________________________
TObject::operator=(rhs);
// assignment operator
- fLocation = rhs.fLocation;
- fIndices = rhs.fIndices;
- fPosition.Set(rhs.fPosition);
- fDimensions.Set(rhs.fDimensions);
+ fLLocation = rhs.fLLocation;
+ fLIndices = rhs.fLIndices;
+ fPositionX = rhs.fPositionX;
+ fPositionY = rhs.fPositionY;
+ fDimensionX = rhs.fDimensionX;
+ fDimensionY = rhs.fDimensionY;
fValidity = rhs.fValidity;
- fLocations = 0;
+ delete [] fLLocations;
+ fLLocations = 0;
fNofLocations = rhs.fNofLocations;
if ( rhs.GetNofLocations() ) {
- fLocations = new AliMpIntPair[fgkMaxNofLocations];
+ fLLocations = new MpPair_t[fgkMaxNofLocations];
for ( UInt_t i=0; i<rhs.fNofLocations; i++ )
- fLocations[i] = rhs.fLocations[i];
+ fLLocations[i] = rhs.fLLocations[i];
}
return *this;
sameLocations = false;
}
- return (fLocation == rhs.fLocation)
- && (fIndices == rhs.fIndices)
- && (fPosition == rhs.fPosition)
- && (fDimensions == rhs.fDimensions)
+ return ( fLLocation == rhs.fLLocation )
+ && ( fLIndices == rhs.fLIndices )
+ && ( fPositionX == rhs.fPositionX )
+ && ( fPositionY == rhs.fPositionY )
+ && ( fDimensionX == rhs.fDimensionX )
&& sameLocations;
}
//_____________________________________________________________________________
{
/// Less operator
- return left.GetIndices()<right.GetIndices();
+ if ( left.GetIx() < right.GetIx() ) return kTRUE;
+ if ( left.GetIx() > right.GetIx() ) return kFALSE;
+ if ( left.GetIy() < right.GetIy() ) return kTRUE;
+ return kFALSE;
}
//_____________________________________________________________________________
-Bool_t AliMpPad::AddLocation(const AliMpIntPair& location, Bool_t warn)
+Bool_t AliMpPad::AddLocation(Int_t localBoardId, Int_t localBoardChannel,
+ Bool_t warn)
{
/// Add location to the collection if not yet present and
/// if collection is not yet full \n
// Check maximum number limit
if ( GetNofLocations() == fgkMaxNofLocations ) {
if (warn) {
- AliWarningStream() << "Cannot add location: "
- << location
- << " Maximum number has been reached." << endl;
+ AliWarningStream() << "Cannot add location: ("
+ << localBoardId << "," << localBoardChannel << ")."
+ << " Maximum number has been reached." << endl;
}
return false;
}
// Check if location is present
- if ( HasLocation(location) ) {
+ if ( HasLocation(localBoardId, localBoardChannel) ) {
if (warn) {
AliWarningStream() << "Cannot add location: "
- << location
- << " Location is already present." << endl;
+ << localBoardId << "," << localBoardChannel << ")."
+ << " Location is already present." << endl;
}
return false;
}
// Add location
- if ( ! fLocations)
- fLocations = new AliMpIntPair[fgkMaxNofLocations];
+ if ( ! fLLocations)
+ fLLocations = new MpPair_t[fgkMaxNofLocations];
- fLocations[fNofLocations++] = location;
+ fLLocations[fNofLocations++]
+ = AliMp::Pair(localBoardId, localBoardChannel);
+
return true;
}
+//_____________________________________________________________________________
+Int_t AliMpPad::GetManuId() const
+{
+/// Return pad manu Id
+
+ return AliMp::PairFirst(fLLocation);
+}
+
+//_____________________________________________________________________________
+Int_t AliMpPad::GetManuChannel() const
+{
+/// Return pad manu channel
+
+ return AliMp::PairSecond(fLLocation);
+}
+
+//_____________________________________________________________________________
+Int_t AliMpPad::GetIx() const
+{
+/// Return pad index ix
+
+ return AliMp::PairFirst(fLIndices);
+}
+
+//_____________________________________________________________________________
+Int_t AliMpPad::GetIy() const
+{
+/// Return pad index iy
+
+ return AliMp::PairSecond(fLIndices);
+}
+
//_____________________________________________________________________________
void AliMpPad::PrintOn(ostream& out) const
{
return;
}
- out << "Pad: Location " << fLocation
- << " Indices " << fIndices
- << " Position " << fPosition
- << " Dimensions " << fDimensions;
+ out << "Pad: Location ";
+ AliMp::PairPut(out, fLLocation)
+ << " Indices ";
+ AliMp::PairPut(out,fLIndices)
+ << " Position "
+ << "(" << fPositionX << "," << fPositionY << ")"
+ << " Dimensions "
+ << "(" << fDimensionX << "," << fDimensionY << ")";
if ( GetNofLocations() ) {
out << endl;
out << " Other locations: ";
for (Int_t i=0; i<GetNofLocations(); i++)
- out << GetLocation(i) << " ";
+ AliMp::PairPut(out,GetLocation(i)) << " ";
}
}
{
/// Return number of other locations associated with this pad
- if (!fLocations) return 0;
+ if (!fLLocations) return 0;
return fNofLocations;
}
//_____________________________________________________________________________
-AliMpIntPair AliMpPad::GetLocation(Int_t i) const
+MpPair_t AliMpPad::GetLocation(Int_t i) const
{
/// Return i-th other location associated with this pad
- if ( !fLocations || i<0 || i>=GetNofLocations() )
- return AliMpIntPair::Invalid();
+ if ( !fLLocations || i<0 || i>=GetNofLocations() )
+ return 0;
- return fLocations[i];
+ return fLLocations[i];
}
//_____________________________________________________________________________
-Bool_t AliMpPad::HasLocation(const AliMpIntPair& location) const
+Int_t AliMpPad::GetLocalBoardId(Int_t i) const
{
-/// Return true if given location is present either as fLocation
+/// Return i-th other local board Id associated with this pad
+
+ if ( !fLLocations || i<0 || i>=GetNofLocations() )
+ return 0;
+
+ return AliMp::PairFirst(fLLocations[i]);
+}
+
+//_____________________________________________________________________________
+Int_t AliMpPad::GetLocalBoardChannel(Int_t i) const
+{
+/// Return i-th other local board channel associated with this pad
+
+ if ( !fLLocations || i<0 || i>=GetNofLocations() )
+ return 0;
+
+ return AliMp::PairSecond(fLLocations[i]);
+}
+
+//_____________________________________________________________________________
+Bool_t AliMpPad::HasLocation(Int_t localBoardId, Int_t localBoardChannel) const
+{
+/// Return true if given location is present either as fLLocation
/// or in the collectio
- if (fLocation == location) return true;
+ MpPair_t location = AliMp::Pair(localBoardId, localBoardChannel);
+
+ if (fLLocation == location) return true;
for ( Int_t i=0; i<GetNofLocations(); i++ ) {
if ( GetLocation(i) == location ) return true;