#include "TClass.h"
#include "TString.h"
+/// \cond CLASSIMP
ClassImp(AliMUONTriggerSegmentationV2)
+/// \endcond
namespace
{
fYhit(FMAX),
fLineNumber(-1)
{
- //
- // Default ctor (empty).
- //
+/// Default ctor (empty).
+
AliDebug(1,Form("this=%p default (empty) ctor",this));
}
fYhit(FMAX),
fLineNumber(-1)
{
- //
- // Normal ctor.
- //
+/// Normal ctor.
fSlatSegmentation = dynamic_cast<AliMpTriggerSegmentation*>(segmentation);
if (fSlatSegmentation)
fSlatSegmentation));
}
-//_____________________________________________________________________________
-AliMUONTriggerSegmentationV2::AliMUONTriggerSegmentationV2(const AliMUONTriggerSegmentationV2& rhs) : AliMUONVGeometryDESegmentation(rhs)
-{
-// Copy constructor
- AliFatal("Not implemented.");
-}
-
//_____________________________________________________________________________
AliMUONTriggerSegmentationV2::~AliMUONTriggerSegmentationV2()
{
- // Destructor
- AliDebug(1,Form("this=%p",this));
-}
+/// Destructor
-//_____________________________________________________________________________
-AliMUONTriggerSegmentationV2& AliMUONTriggerSegmentationV2::operator=(const AliMUONTriggerSegmentationV2& rhs)
-{
-// Protected assignement operator
- if (this == &rhs) return *this;
- AliFatal("Not implemented.");
- return *this;
+ AliDebug(1,Form("this=%p",this));
}
//_____________________________________________________________________________
TF1*
AliMUONTriggerSegmentationV2::CorrFunc(Int_t) const
{
-// Not implemented
+/// Not implemented
AliFatal("Not implemented");
return 0x0;
AliMUONTriggerSegmentationV2::Distance2AndOffset(Int_t, Int_t,
Float_t, Float_t, Int_t*)
{
-// Not implemented
+/// Not implemented
AliFatal("Not implemented");
return 0;
void
AliMUONTriggerSegmentationV2::Draw(Option_t*)
{
-// Not implemented
+/// Not implemented
AliFatal("Not Implemented");
}
Float_t
AliMUONTriggerSegmentationV2::Dpx() const
{
-// Not implemented
+/// Not implemented
AliFatal("Not Implemented");
return 0.0;
Float_t
AliMUONTriggerSegmentationV2::Dpy() const
{
-// Not implemented
+/// Not implemented
AliFatal("Not Implemented");
return 0.0;
Float_t
AliMUONTriggerSegmentationV2::Dpx(Int_t sectorCode) const
{
-// Get pad size in x
+/// Get pad size in x
Int_t ixLA, iyLA;
Decode(sectorCode,ixLA,iyLA);
Float_t
AliMUONTriggerSegmentationV2::Dpy(Int_t sectorCode) const
{
-// Get pad size in y
+/// Get pad size in y
Int_t ixLA, iyLA;
Decode(sectorCode,ixLA,iyLA);
AliMUONTriggerSegmentationV2::FirstPad(Float_t /*xhit*/, Float_t /*yhit*/, Float_t /*zhit*/,
Float_t /*dx*/, Float_t /*dy*/)
{
-// Not implemented
+/// Not implemented
AliFatal("Not implemented");
}
Float_t
AliMUONTriggerSegmentationV2::GetAnod(Float_t) const
{
-// Not implemented
+/// Not implemented
AliFatal("Not implemented");
return 0.0;
AliMUONGeometryDirection
AliMUONTriggerSegmentationV2::GetDirection()
{
-// Not implemented
+/// Not implemented
//AliWarning("Not Implemented");
return kDirUndefined;
const AliMpVSegmentation*
AliMUONTriggerSegmentationV2::GetMpSegmentation() const
{
-// Returns the mapping segmentation
-// (provides access to electronics info)
+/// Returns the mapping segmentation
+/// (provides access to electronics info)
return fSlatSegmentation;
}
void
AliMUONTriggerSegmentationV2::GetNParallelAndOffset(Int_t,Int_t,Int_t*,Int_t*)
{
-// Not implemented
+/// Not implemented
AliFatal("Not Implemented");
}
AliMUONTriggerSegmentationV2::GetPadC(Int_t ix, Int_t iy,
Float_t& x, Float_t& y, Float_t& z)
{
-// Transform from pad to real coordinates
+/// Transform from pad to real coordinates
z = 0;
GetPadC(ix,iy,x,y);
AliMUONTriggerSegmentationV2::GetPadC(Int_t ixGlo, Int_t iyGlo,
Float_t& x, Float_t& y)
{
-// Transform from pad to real coordinates
+/// Transform from pad to real coordinates
Int_t ixLA,iyLA;
IGlo2ILoc(ixGlo,iyGlo,ixLA,iyLA);
AliMUONTriggerSegmentationV2::GetPadI(Float_t x, Float_t y, Float_t,
Int_t& ix, Int_t& iy)
{
-// Returns pad coordinates (ix,iy) for given real coordinates (x,y)
+/// Returns pad coordinates (ix,iy) for given real coordinates (x,y)
GetPadI(x,y,ix,iy);
}
AliMUONTriggerSegmentationV2::GetPadI(Float_t x, Float_t y,
Int_t& ixGlo, Int_t& iyGlo)
{
-// Returns pad coordinates (ix,iy) for given real coordinates (x,y)
+/// Returns pad coordinates (ix,iy) for given real coordinates (x,y)
AliDebug(2,Form("%s x=%e y=%e ixGlo,iyGlo=%d,%d\n",
fSlatSegmentation->GetName(),
AliMUONTriggerSegmentationV2::GetPadLoc2Glo(Int_t ix, Int_t iy,
Int_t& ixGlo, Int_t& iyGlo) const
{
- //
- // Converts from local (in PC convention) to (ix,iy) to global (ix,iy)
- //
+/// Converts from local (in PC convention) to (ix,iy) to global (ix,iy)
ixGlo=iyGlo=-1; // starts with invalid values
AliMUONTriggerSegmentationV2::GetPadGlo2Loc(Int_t ixGlo, Int_t iyGlo,
Int_t& ix, Int_t& iy) const
{
- //
- // Converts from global (ix,iy) to local (ix,iy) (in PC convention)
- //
+/// Converts from global (ix,iy) to local (ix,iy) (in PC convention)
ix=iy=-1; // starts with invalid values
Bool_t
AliMUONTriggerSegmentationV2::HasPad(Float_t x, Float_t y, Float_t /*z*/)
{
-// Returns true if a pad exists in the given position
-
- //
- // Well, 2 implementations are possible here
- // Either reuse HasPad(int,int), or get it from scratch using
- // underlying fSlatSegmentation.
- // Took second option, but w/o checking whether this is the faster.
- // The second option is commented out below, for the record.
+/// Returns true if a pad exists in the given position
+///
+/// Well, 2 implementations are possible here
+/// Either reuse HasPad(int,int), or get it from scratch using
+/// underlying fSlatSegmentation.
+/// Took second option, but w/o checking whether this is the faster.
+/// The second option is commented out below, for the record.
// Int_t ix, iy;
// GetPadI(x,y,z,ix,iy);
Bool_t
AliMUONTriggerSegmentationV2::HasPad(Int_t ixGlo, Int_t iyGlo)
{
-// Returns true if a pad with given indices exists
+/// Returns true if a pad with given indices exists
Int_t ixLA, iyLA;
IGlo2ILoc(ixGlo,iyGlo,ixLA,iyLA);
AliMUONTriggerSegmentationV2::IGlo2ILoc(Int_t ixGlo, Int_t iyGlo,
Int_t& ixLA, Int_t& iyLA) const
{
-// FIXME: add comment
+/// \todo FIXME: add comment
Int_t ixPC, iyPC;
GetPadGlo2Loc(ixGlo,iyGlo,ixPC,iyPC);
AliMUONTriggerSegmentationV2::ILoc2IGlo(Int_t ixLA, Int_t iyLA,
Int_t& ixGlo, Int_t& iyGlo) const
{
-// FIXME: add comment
+/// \todo FIXME: add comment
Int_t ixPC, iyPC;
LA2PC(ixLA,iyLA,ixPC,iyPC);
Int_t
AliMUONTriggerSegmentationV2::ISector()
{
- // FIXME: remove the usage of ISector from all the code.
+/// \todo FIXME: remove the usage of ISector from all the code.
+
return -10;
}
Float_t& x3,
Float_t& x4)
{
- // x1 : hit x(y) position
- // x2 : x(y) coordinate of the main strip
- // x3 : current strip real x(y) coordinate
- // x4 : dist. between x(y) hit pos. and the closest border of the current strip
- //
- // Note : need to return (only) x4.
+/// \param x1 : hit x(y) position
+/// \param x2 : x(y) coordinate of the main strip
+/// \param x3 : current strip real x(y) coordinate
+/// \param x4 : dist. between x(y) hit pos. and the closest border of the current strip
+///
+/// Note : need to return (only) x4.
AliFatal("Check me before usage. ResponseTrigger does not use me, while"
"ResponseTriggerV1 does ?");
Int_t
AliMUONTriggerSegmentationV2::Ix()
{
-// Current pad cursor during disintegration
-// x, y-coordinate
+/// Current pad cursor during disintegration
+/// x, y-coordinate
if ( fCurrentPad.IsValid() )
{
Int_t
AliMUONTriggerSegmentationV2::Iy()
{
-// Current pad cursor during disintegration
-// x, y-coordinate
+/// Current pad cursor during disintegration
+/// x, y-coordinate
if ( fCurrentPad.IsValid() )
{
AliMUONTriggerSegmentationV2::LA2PC(Int_t ixLA, Int_t iyLA,
Int_t& ixPC, Int_t& iyPC) const
{
- //
- // From LA to PC conventions for integers indices.
- //
+/// From LA to PC conventions for integers indices.
+
ixPC=iyPC=-1;
if ( ixLA<0 || iyLA<0 ) return;
Int_t
AliMUONTriggerSegmentationV2::LineNumber() const
{
-// FIXME: add comment
+/// \todo FIXME: add comment
return 10-fLineNumber;
}
Int_t
AliMUONTriggerSegmentationV2::ModuleColNum(Int_t ixGlo) const
{
- // returns column number (from 0 to 6) in which the (global) module
- // ix is sitting (could return 7 if ix=isec)
+/// returns column number (from 0 to 6) in which the (global) module
+/// ix is sitting (could return 7 if ix=isec)
+
return TMath::Abs(ixGlo)-Int_t(TMath::Abs(ixGlo)/10)*10-1;
}
Int_t
AliMUONTriggerSegmentationV2::MorePads()
{
-// Not implemented
+/// Not implemented
AliFatal("Not implemented");
return 0;
Int_t /*Xlist*/[10],
Int_t /*Ylist*/[10])
{
+/// Not implemented
+
//-----------------BENDING-----------------------------------------
// Returns list of 10 next neighbours for given X strip (ix, iy)
// neighbour number 4 in the list -
void
AliMUONTriggerSegmentationV2::NextPad()
{
-// Not implemented
+/// Not implemented
AliFatal("Not implemented");
}
Int_t
AliMUONTriggerSegmentationV2::Npx() const
{
-// Maximum number of Pads in x
-// hard coded for the time being
+/// Maximum number of Pads in x
+/// hard coded for the time being
return 124;// FIXME: this should not have to be done, if only we'd stick
// to a local (ix,iy) convention !!!
Int_t
AliMUONTriggerSegmentationV2::Npy() const
{
-// Maximum number of Pads in y
-// hard coded for the time being
+/// Maximum number of Pads in y
+/// hard coded for the time being
return 64;
// return fSlatSegmentation->MaxPadIndexY()+1;
AliMUONTriggerSegmentationV2::PC2LA(Int_t ixPC, Int_t iyPC,
Int_t& ixLA, Int_t& iyLA) const
{
- //
- // From PC to LA conventions for integers indices.
- //
+/// From PC to LA conventions for integers indices.
+
ixLA=iyLA=-1;
if ( ixPC<0 || iyPC<0 ) return;
void
AliMUONTriggerSegmentationV2::Print(Option_t* opt) const
{
-// Printing
+/// Printing
TString sopt(opt);
Int_t
AliMUONTriggerSegmentationV2::Sector(Int_t ix, Int_t iy)
{
-// Calculate sector from pad coordinates
+/// Calculate sector from pad coordinates
Int_t ixLA, iyLA;
IGlo2ILoc(ix,iy,ixLA,iyLA);
Int_t
AliMUONTriggerSegmentationV2::Sector(Float_t, Float_t)
{
-// Not implemented
+/// Not implemented
AliFatal("Not implemented");
return 0;
void
AliMUONTriggerSegmentationV2::SetCorrFunc(Int_t,TF1*)
{
-// Not implemented
+/// Not implemented
AliFatal("Not Implemented");
}
void
AliMUONTriggerSegmentationV2::SetDAnod(Float_t)
{
-// Not implemented
+/// Not implemented
AliFatal("Not Implemented");
}
void
AliMUONTriggerSegmentationV2::SetHit(Float_t x, Float_t y)
{
-// Set hit position
-// Sets virtual hit position, needed for evaluating pad response
-// outside the tracking program
+/// Set hit position
+/// Sets virtual hit position, needed for evaluating pad response
+/// outside the tracking program
fXhit = x;
fYhit = y;
void
AliMUONTriggerSegmentationV2::SetHit(Float_t x, Float_t y, Float_t)
{
-// Set hit position
-// Sets virtual hit position, needed for evaluating pad response
-// outside the tracking program
+/// Set hit position
+/// Sets virtual hit position, needed for evaluating pad response
+/// outside the tracking program
SetHit(x,y);
}
void
AliMUONTriggerSegmentationV2::SetPad(Int_t ix, Int_t iy)
{
-// Set pad position.
-// Sets virtual pad coordinates, needed for evaluating pad response
-// outside the tracking program.
+/// Set pad position.
+/// Sets virtual pad coordinates, needed for evaluating pad response
+/// outside the tracking program.
Int_t ixLA, iyLA;
IGlo2ILoc(ix,iy,ixLA,iyLA);
void
AliMUONTriggerSegmentationV2::SetPadSize(Float_t,Float_t)
{
-// Not implemented
+/// Not implemented
AliFatal("Not Implemented");
}
Int_t
AliMUONTriggerSegmentationV2::SigGenCond(Float_t,Float_t,Float_t)
{
-// Not implemented
+/// Not implemented
AliFatal("Not Implemented");
return 0;
void
AliMUONTriggerSegmentationV2::SigGenInit(Float_t,Float_t,Float_t)
{
-// Not implemented
+/// Not implemented
AliFatal("Not Implemented");
}
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff