* provided "as is" without express or implied warranty. *
**************************************************************************/
-/*
-$Log$
-Revision 1.3 2000/06/29 12:34:09 morsch
-AliMUONSegmentation class has been made independent of AliMUONChamber. This makes
-it usable with any other geometry class. The link to the object to which it belongs is
-established via an index. This assumes that there exists a global geometry manager
-from which the pointer to the parent object can be obtained (in our case gAlice).
-
-Revision 1.2 2000/06/15 07:58:48 morsch
-Code from MUON-dev joined
-
-Revision 1.1.2.2 2000/06/12 07:57:43 morsch
-include TMath.cxx
-
-Revision 1.1.2.1 2000/06/09 21:41:29 morsch
-AliMUONSegmentationV1 code from AliMUONSegResV1.cxx
-
-*/
-
+/* $Id$ */
/////////////////////////////////////////////////////////
// Manager and hits classes for set:MUON version LYON //
/////////////////////////////////////////////////////////
#include <TMath.h>
+
#include "AliMUONChamber.h"
#include "AliMUONSegmentationV1.h"
#include "AliRun.h"
#include "AliMUON.h"
+#include "AliMUONChamber.h"
//___________________________________________
ClassImp(AliMUONSegmentationV1)
AliMUONSegmentationV1::AliMUONSegmentationV1(const AliMUONSegmentationV1& segmentation)
+ : AliSegmentation(segmentation)
{
-// Dummy copy constructor
+// Protected copy constructor
+
+ Fatal("AliMUONSegmentationV1", "Not implemented.");
}
AliMUONSegmentationV1::AliMUONSegmentationV1()
-
+ : AliSegmentation()
{
// initizalize the class with default settings
fNzone=1;
fDpx=0.0; // forces crash if not initialized by user
fNZoneCut[0]=0;
fSensOffset=0;
+ fCorr = 0;
}
// fNwire=3;
DefaultCut();
fCorr=0;
+
+ fZ = iChamber->Z();
+
}
void AliMUONSegmentationV1::DefaultCut(void)
return (xhit>0) ? kwire : -kwire ;
}
-Float_t AliMUONSegmentationV1::GetAnod(Float_t xhit)
+Float_t AliMUONSegmentationV1::GetAnod(Float_t xhit) const
{
// Get anode position
Int_t kwire=Int_t((TMath::Abs(xhit)-fSensOffset)/fDAnod)+1; // to be compatible ...
SetHit(Float_t xhit, Float_t yhit)
{
// Find the wire position (center of charge distribution)
- fxhit=xhit;
- fyhit=yhit;
+ fXhit=xhit;
+ fYhit=yhit;
}
void AliMUONSegmentationV1::
SetPad(Int_t ix, Int_t iy)
{
// Set current pad position
- GetPadC(ix,iy,fx,fy);
+ GetPadC(ix,iy,fX,fY);
}
void AliMUONSegmentationV1::SetPadCoord(Int_t iX, Int_t iY)
{
// Set current pad coordinates
-GetPadC(iX,iY,fx,fy);
+GetPadC(iX,iY,fX,fY);
Float_t radius2;
- if ( ( (radius2=fx*fx+fy*fy) > frSensMax2 || radius2 < frSensMin2 )
+ if ( ( (radius2=fX*fX+fY*fY) > frSensMax2 || radius2 < frSensMin2 )
&& MorePads() )
NextPad();
}
//
// Find the wire position (center of charge distribution)
Float_t x0a=GetAnod(xhit);
- fxhit=x0a;
- fyhit=yhit;
+ fXhit=x0a;
+ fYhit=yhit;
//
// and take fNsigma*sigma around this center
Float_t x01=x0a - dx;
y02 = TMath::Sign(fSensOffset, yhit);
//
// find the pads over which the charge distributes
- GetPadI(x01,y01,fixmin,fiymin);
- GetPadI(x02,y02,fixmax,fiymax);
+ GetPadI(x01,y01,fIxmin,fIymin);
+ GetPadI(x02,y02,fIxmax,fIymax);
//
// Set current pad to lower left corner
- fix=fixmin;
- fiy=fiymin;
- SetPadCoord(fix,fiy);
+ fIx=fIxmin;
+ fIy=fIymin;
+ SetPadCoord(fIx,fIy);
}
void AliMUONSegmentationV1::NextPad()
{
//
// Step to next pad in integration region
- if (fix != fixmax) {
- fix++;
- } else if (fiy != fiymax) {
- fix=fixmin;
- fiy++;
+ if (fIx != fIxmax) {
+ fIx++;
+ } else if (fIy != fIymax) {
+ fIx=fIxmin;
+ fIy++;
} else
printf("\n Error: Stepping outside integration region\n ");
- SetPadCoord(fix,fiy);
+ SetPadCoord(fIx,fIy);
}
Int_t AliMUONSegmentationV1::MorePads()
//
// Are there more pads in the integration region
- if (fix == fixmax && fiy == fiymax) {
+ if (fIx == fIxmax && fIy == fIymax) {
return 0;
} else {
return 1;
}
}
-Int_t AliMUONSegmentationV1::IsParallel2(Int_t iX, Int_t iY)
+Int_t AliMUONSegmentationV1::IsParallel2(Int_t iX, Int_t iY) const
{
// test if the pad is read in parallel for zone 2
// iX and iY are assumed to be positive and starting at 0 numbering (cF. iX)
return (iX%6)/3+1;
}
-Int_t AliMUONSegmentationV1::IsParallel3(Int_t iX, Int_t iY)
+Int_t AliMUONSegmentationV1::IsParallel3(Int_t iX, Int_t iY) const
{
// test if the pad is read in parallel for zone 3
// iX and iY are assumed to be positive and starting at 0 numbering (cF. iX)
return (iX%9)/3+1 - (iY%3==2 && iX%3==0);
}
-Int_t AliMUONSegmentationV1::NParallel2(Int_t iX, Int_t iY)
+Int_t AliMUONSegmentationV1::NParallel2(Int_t /*iX*/, Int_t iY) const
{
// returns the number of pads connected in parallel for zone 2
// iX and iY are assumed to be positive and starting at 0 numbering (cF. iX)
return 2;
}
-Int_t AliMUONSegmentationV1::NParallel3(Int_t iX, Int_t iY)
+Int_t AliMUONSegmentationV1::NParallel3(Int_t iX, Int_t iY) const
{
// test if the pad is read in parallel for zone 3
// iX and iY are assumed to be positive and starting at 0 numbering (cF. iX)
return -1;
}
-Int_t AliMUONSegmentationV1::Ix()
+Int_t AliMUONSegmentationV1::Ix()
{
// returns the X number of pad which has to increment charge
// due to parallel read-out
-return Ix(fix,fiy);
+ return Ix(fIx,fIy);
}
-Int_t AliMUONSegmentationV1::ISector()
+Int_t AliMUONSegmentationV1::ISector()
{
// This function is of no use for this kind of segmentation.
- return GetZone(fix,fiy);
+ return GetZone(fIx,fIy);
}
-void AliMUONSegmentationV1::SigGenInit(Float_t x,Float_t y,Float_t z)
+void AliMUONSegmentationV1::SigGenInit(Float_t x,Float_t y,Float_t /*z*/)
{
//
// Initialises pad and wire position during stepping
- fxt =x;
- fyt =y;
- GetPadI(x,y,fixt,fiyt);
- fiwt= GetiAnod(x);
+ fXt =x;
+ fYt =y;
+ GetPadI(x,y,fIxt,fIyt);
+ fIwt= GetiAnod(x);
}
-Int_t AliMUONSegmentationV1::SigGenCond(Float_t x,Float_t y,Float_t z)
+Int_t AliMUONSegmentationV1::SigGenCond(Float_t x,Float_t y,Float_t /*z*/)
{
//
// Signal will be generated if particle crosses pad boundary or
GetPadI(x,y,ixt,iyt);
Int_t iwt= GetiAnod(x);
- if ((ixt != fixt) || (iyt !=fiyt) || (iwt != fiwt)) {
+ if ((ixt != fIxt) || (iyt !=fIyt) || (iwt != fIwt)) {
return 1;
} else {
return 0;
IntegrationLimits(Float_t& x1,Float_t& x2,Float_t& y1, Float_t& y2)
{
// Get integration limits
- x1=fxhit-fx-fDpx/2.;
+ x1=fXhit-fX-fDpx/2.;
x2=x1+fDpx;
- y1=fyhit-fy-fDpy/2.;
+ y1=fYhit-fY-fDpy/2.;
y2=y1+fDpy;
}
}
-void AliMUONSegmentationV1::GiveTestPoints(Int_t &n, Float_t *x, Float_t *y)
+void AliMUONSegmentationV1::GiveTestPoints(Int_t &n, Float_t *x, Float_t *y) const
{
// Return a test point
n=1;
y[0]=x[0];
}
-AliMUONSegmentationV1& AliMUONSegmentationV1::operator =(const AliMUONSegmentationV1 & rhs)
+AliMUONSegmentationV1&
+AliMUONSegmentationV1::operator =(const AliMUONSegmentationV1 & rhs)
{
-// Dummy assignment operator
- return *this;
+// Protected assignement operator
+
+ if (this == &rhs) return *this;
+
+ Fatal("operator=", "Not implemented.");
+
+ return *this;
}
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff