/* $Id$ */
-#include "AliMUONTriggerSegmentationV2.h"
+// -------------------------------------
+// Class AliMUONTriggerSegmentation
+// -------------------------------------
+// Segmentation for MUON trigger stations using
+// the mapping package
-#include "AliLog.h"
+#include "AliMUONTriggerSegmentationV2.h"
#include "AliMpPCB.h"
#include "AliMpTrigger.h"
#include "AliMpTriggerSegmentation.h"
#include "AliMpSlat.h"
-#include "AliMUONSegmentationManager.h"
+#include "AliLog.h"
#include "Riostream.h"
#include "TClass.h"
}
//_____________________________________________________________________________
-AliMUONTriggerSegmentationV2::AliMUONTriggerSegmentationV2(Int_t detElemId,
- AliMpPlaneType bendingOrNonBending)
+AliMUONTriggerSegmentationV2::AliMUONTriggerSegmentationV2(
+ AliMpVSegmentation* segmentation,
+ Int_t detElemId, AliMpPlaneType bendingOrNonBending)
: AliMUONVGeometryDESegmentation(),
fDetElemId(detElemId),
fPlaneType(bendingOrNonBending),
//
// Normal ctor.
//
- ReadMappingData();
+
+ fSlatSegmentation = dynamic_cast<AliMpTriggerSegmentation*>(segmentation);
+ if (fSlatSegmentation)
+ fSlat = fSlatSegmentation->Slat();
+ else
+ AliFatal("Wrong mapping segmentation type");
+
+ TString id(fSlat->GetID());
+ Ssiz_t pos = id.Last('L');
+ if ( pos <= 0 )
+ {
+ AliFatal(Form("Cannot infer line number for slat %s",id.Data()));
+ }
+ fLineNumber = TString(id(pos+1),1).Atoi();
AliDebug(1,Form("this=%p detElemId=%3d %s fSlatSegmentation=%p",this,detElemId,
( (bendingOrNonBending==kBendingPlane)?"Bending":"NonBending" ),
//_____________________________________________________________________________
AliMUONTriggerSegmentationV2::AliMUONTriggerSegmentationV2(const AliMUONTriggerSegmentationV2& rhs) : AliMUONVGeometryDESegmentation(rhs)
{
+// Copy constructor
AliFatal("Not implemented.");
}
//_____________________________________________________________________________
AliMUONTriggerSegmentationV2::~AliMUONTriggerSegmentationV2()
{
- AliDebug(1,Form("this=%p",this));
// Destructor
+ AliDebug(1,Form("this=%p",this));
}
//_____________________________________________________________________________
TF1*
AliMUONTriggerSegmentationV2::CorrFunc(Int_t) const
{
+// Not implemented
+
AliFatal("Not implemented");
return 0x0;
}
AliMUONTriggerSegmentationV2::Distance2AndOffset(Int_t, Int_t,
Float_t, Float_t, Int_t*)
{
+// Not implemented
+
AliFatal("Not implemented");
return 0;
}
void
AliMUONTriggerSegmentationV2::Draw(Option_t*)
{
+// Not implemented
+
AliFatal("Not Implemented");
}
Float_t
AliMUONTriggerSegmentationV2::Dpx() const
{
+// Not implemented
+
AliFatal("Not Implemented");
return 0.0;
}
Float_t
AliMUONTriggerSegmentationV2::Dpy() const
{
+// Not implemented
+
AliFatal("Not Implemented");
return 0.0;
}
//_____________________________________________________________________________
Float_t
-AliMUONTriggerSegmentationV2::Dpx(int sectorCode) const
+AliMUONTriggerSegmentationV2::Dpx(Int_t sectorCode) const
{
- Int_t ixLA, iyLA;
+// Get pad size in x
+
+ Int_t ixLA, iyLA;
Decode(sectorCode,ixLA,iyLA);
AliMpPad pad = fSlatSegmentation->PadByIndices(AliMpIntPair(ixLA,iyLA),kFALSE);
if ( !pad.IsValid() ) return 0.0;
//_____________________________________________________________________________
Float_t
-AliMUONTriggerSegmentationV2::Dpy(int sectorCode) const
+AliMUONTriggerSegmentationV2::Dpy(Int_t sectorCode) const
{
+// Get pad size in y
+
Int_t ixLA, iyLA;
Decode(sectorCode,ixLA,iyLA);
AliMpPad pad = fSlatSegmentation->PadByIndices(AliMpIntPair(ixLA,iyLA),kFALSE);
//_____________________________________________________________________________
void
-AliMUONTriggerSegmentationV2::FirstPad(Float_t /*xhit*/, Float_t /*yhit*/,
- Float_t /*zhit*/,
- Float_t /*dx*/, Float_t /*dy*/)
+AliMUONTriggerSegmentationV2::FirstPad(Float_t /*xhit*/, Float_t /*yhit*/, Float_t /*zhit*/,
+ Float_t /*dx*/, Float_t /*dy*/)
{
+// Not implemented
+
AliFatal("Not implemented");
}
Float_t
AliMUONTriggerSegmentationV2::GetAnod(Float_t) const
{
+// Not implemented
+
AliFatal("Not implemented");
return 0.0;
}
AliMUONGeometryDirection
AliMUONTriggerSegmentationV2::GetDirection()
{
+// Not implemented
+
//AliWarning("Not Implemented");
return kDirUndefined;
}
+//______________________________________________________________________________
+const AliMpVSegmentation*
+AliMUONTriggerSegmentationV2::GetMpSegmentation() const
+{
+// Returns the mapping segmentation
+// (provides access to electronics info)
+
+ return fSlatSegmentation;
+}
+
//_____________________________________________________________________________
void
AliMUONTriggerSegmentationV2::GetNParallelAndOffset(Int_t,Int_t,Int_t*,Int_t*)
{
+// 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
+
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
+
Int_t ixLA,iyLA;
IGlo2ILoc(ixGlo,iyGlo,ixLA,iyLA);
AliMpPad pad = fSlatSegmentation->PadByIndices(AliMpIntPair(ixLA,iyLA),kTRUE);
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)
+
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)
+
AliDebug(2,Form("%s x=%e y=%e ixGlo,iyGlo=%d,%d\n",
fSlatSegmentation->GetName(),
x,y,ixGlo,iyGlo));
- Double_t slatx = fSlat->DX();
- Double_t slaty = fSlat->DY();
AliMpPad pad =
- fSlatSegmentation->PadByPosition(TVector2(x+slatx,y+slaty), kTRUE);
+ fSlatSegmentation->PadByPosition(TVector2(x,y), kTRUE);
if ( pad != AliMpPad::Invalid() )
{
//_____________________________________________________________________________
void
-AliMUONTriggerSegmentationV2::GiveTestPoints(Int_t&,Float_t*,Float_t*) const
+AliMUONTriggerSegmentationV2::GiveTestPoints(Int_t& /*n*/,
+ Float_t* /*x*/, Float_t*/*y*/) const
{
+// Not implemented
+
AliFatal("Not Implemented");
}
//_____________________________________________________________________________
Bool_t
-AliMUONTriggerSegmentationV2::HasPad(Float_t x, Float_t y, Float_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
// Bool_t ok1 = HasPad(ixPC,iyPC);
AliMpPad pad =
- fSlatSegmentation->PadByPosition(TVector2(x+fSlat->DX(),y+fSlat->DY()),
- kFALSE);
+ fSlatSegmentation->PadByPosition(TVector2(x,y),kFALSE);
return pad.IsValid();
}
Bool_t
AliMUONTriggerSegmentationV2::HasPad(Int_t ixGlo, Int_t iyGlo)
{
+// Returns true if a pad with given indices exists
+
Int_t ixLA, iyLA;
IGlo2ILoc(ixGlo,iyGlo,ixLA,iyLA);
return fSlatSegmentation->HasPad(AliMpIntPair(ixLA,iyLA));
//_____________________________________________________________________________
void
AliMUONTriggerSegmentationV2::IGlo2ILoc(Int_t ixGlo, Int_t iyGlo,
- Int_t& ixLA, Int_t& iyLA)
+ Int_t& ixLA, Int_t& iyLA) const
{
+// FIXME: add comment
+
Int_t ixPC, iyPC;
GetPadGlo2Loc(ixGlo,iyGlo,ixPC,iyPC);
PC2LA(ixPC,iyPC,ixLA,iyLA);
//_____________________________________________________________________________
void
AliMUONTriggerSegmentationV2::ILoc2IGlo(Int_t ixLA, Int_t iyLA,
- Int_t& ixGlo, Int_t& iyGlo)
+ Int_t& ixGlo, Int_t& iyGlo) const
{
+// FIXME: add comment
+
Int_t ixPC, iyPC;
LA2PC(ixLA,iyLA,ixPC,iyPC);
GetPadLoc2Glo(ixPC,iyPC,ixGlo,iyGlo);
}
-//_____________________________________________________________________________
-void
-AliMUONTriggerSegmentationV2::Init(int)
-{
- AliWarning("Not Implemented because not needed ;-)");
-}
-
//_____________________________________________________________________________
Int_t
AliMUONTriggerSegmentationV2::ISector()
Int_t
AliMUONTriggerSegmentationV2::Ix()
{
+// Current pad cursor during disintegration
+// x, y-coordinate
+
if ( fCurrentPad.IsValid() )
{
Int_t ixGlo,iyGlo;
Int_t
AliMUONTriggerSegmentationV2::Iy()
{
+// Current pad cursor during disintegration
+// x, y-coordinate
+
if ( fCurrentPad.IsValid() )
{
Int_t ixGlo,iyGlo;
//_____________________________________________________________________________
void
AliMUONTriggerSegmentationV2::LA2PC(Int_t ixLA, Int_t iyLA,
- Int_t& ixPC, Int_t& iyPC)
+ Int_t& ixPC, Int_t& iyPC) const
{
//
// From LA to PC conventions for integers indices.
Int_t
AliMUONTriggerSegmentationV2::LineNumber() const
{
- return 10-fLineNumber;
+// FIXME: add comment
+
+ return 10-fLineNumber;
}
//_____________________________________________________________________________
Int_t
AliMUONTriggerSegmentationV2::MorePads()
{
+// Not implemented
+
AliFatal("Not implemented");
return 0;
}
void
AliMUONTriggerSegmentationV2::NextPad()
{
+// Not implemented
+
AliFatal("Not implemented");
}
Int_t
AliMUONTriggerSegmentationV2::Npx() const
{
+// 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 !!!
// return fSlatSegmentation->MaxPadIndexX()+1;
Int_t
AliMUONTriggerSegmentationV2::Npy() const
{
+// Maximum number of Pads in y
+// hard coded for the time being
+
return 64;
// return fSlatSegmentation->MaxPadIndexY()+1;
}
//_____________________________________________________________________________
void
AliMUONTriggerSegmentationV2::PC2LA(Int_t ixPC, Int_t iyPC,
- Int_t& ixLA, Int_t& iyLA)
+ Int_t& ixLA, Int_t& iyLA) const
{
//
// From PC to LA conventions for integers indices.
void
AliMUONTriggerSegmentationV2::Print(Option_t* opt) const
{
+// Printing
+
TString sopt(opt);
cout << "DetElemId=" << fDetElemId << " PlaneType="
}
}
-//_____________________________________________________________________________
-void
-AliMUONTriggerSegmentationV2::ReadMappingData()
-{
- fSlatSegmentation = dynamic_cast<AliMpTriggerSegmentation*>
- (AliMUONSegmentationManager::Segmentation(fDetElemId,fPlaneType));
-
- if (!fSlatSegmentation)
- {
- AliFatal("Wrong segmentation type encountered");
- }
- fSlat = fSlatSegmentation->Slat();
- TString id(fSlat->GetID());
- Ssiz_t pos = id.Last('L');
- if ( pos <= 0 )
- {
- AliFatal(Form("Cannot infer line number for slat %s",id.Data()));
- }
- fLineNumber = TString(id(pos+1),1).Atoi();
-}
-
//_____________________________________________________________________________
Int_t
AliMUONTriggerSegmentationV2::Sector(Int_t ix, Int_t iy)
{
+// Calculate sector from pad coordinates
+
Int_t ixLA, iyLA;
IGlo2ILoc(ix,iy,ixLA,iyLA);
AliMpPad pad = fSlatSegmentation->PadByIndices(AliMpIntPair(ixLA,iyLA),kFALSE);
Int_t
AliMUONTriggerSegmentationV2::Sector(Float_t, Float_t)
{
+// Not implemented
+
AliFatal("Not implemented");
return 0;
}
void
AliMUONTriggerSegmentationV2::SetCorrFunc(Int_t,TF1*)
{
+// Not implemented
+
AliFatal("Not Implemented");
}
//_____________________________________________________________________________
void
-AliMUONTriggerSegmentationV2::SetDAnod(float)
+AliMUONTriggerSegmentationV2::SetDAnod(Float_t)
{
+// 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
+
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
+
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.
+
Int_t ixLA, iyLA;
IGlo2ILoc(ix,iy,ixLA,iyLA);
fCurrentPad = fSlatSegmentation->PadByIndices(AliMpIntPair(ixLA,iyLA),kTRUE);
//_____________________________________________________________________________
void
-AliMUONTriggerSegmentationV2::SetPadSize(float,float)
+AliMUONTriggerSegmentationV2::SetPadSize(Float_t,Float_t)
{
+// Not implemented
+
AliFatal("Not Implemented");
}
Int_t
AliMUONTriggerSegmentationV2::SigGenCond(Float_t,Float_t,Float_t)
{
+// Not implemented
+
AliFatal("Not Implemented");
return 0;
}
void
AliMUONTriggerSegmentationV2::SigGenInit(Float_t,Float_t,Float_t)
{
- AliFatal("Not Implemented");
-}
+// Not implemented
-//_____________________________________________________________________________
-void
-AliMUONTriggerSegmentationV2::Streamer(TBuffer &R__b)
-{
- if (R__b.IsReading())
- {
- AliMUONTriggerSegmentationV2::Class()->ReadBuffer(R__b, this);
- ReadMappingData();
- }
- else
- {
- AliMUONTriggerSegmentationV2::Class()->WriteBuffer(R__b, this);
- }
+ AliFatal("Not Implemented");
}
-
-
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff