// Detailed information in Alice Technical Note xxxxxxxx (2004)
//====================================================================
+#include <TString.h>
+
#include "AliMUONSegmentIndex.h"
//___________________________________________
//___________________________________________
AliMUONSegmentIndex::AliMUONSegmentIndex() : TNamed()
{
+ // Constructor by default
fChannelId = 0;
fPadX = 0;
fPadY = 0;
//___________________________________________
AliMUONSegmentIndex::AliMUONSegmentIndex(const Int_t channelId, const Int_t padX, const Int_t padY, const Int_t cathode) : TNamed()
{
- char name[10];
- sprintf(name,"%d-%d",padX,padY);
- fName = name;
- fTitle = name;
+ // Constructor to be used
+ fName = Name(padX, padY, cathode).Data();
+ fTitle = Name(padX, padY, cathode).Data();
fChannelId = channelId;
fPadX = padX;
fPadY = padY;
//_______________________________________________
AliMUONSegmentIndex::~AliMUONSegmentIndex()
{
-
+ // Destructor
}
//___________________________________________
Int_t AliMUONSegmentIndex::Compare(const TObject *obj) const
{
+ // Comparison of two AliMUONSegmentIndex objects
AliMUONSegmentIndex * myobj = ( AliMUONSegmentIndex *) obj;
return (fChannelId > myobj->GetChannelId()) ? 1 : -1;
}
+//___________________________________________
+TString AliMUONSegmentIndex::Name(Int_t padx, Int_t pady, Int_t cathode)
+{
+ // Definition of the name of the object
+ char name[15];
+ sprintf(name,"%d-%d-%d",padx,pady,cathode);
+ return TString(name);
+}
+
//___________________________________________
void AliMUONSegmentIndex::Print() const
{
- printf("%s id=%d ix=%d iy=%d cathode=%d\n",fName.Data(),fChannelId,fPadX,fPadY,fCathode);
+ // Printing information of AliMUONSegmentIndex
+ Info("Print", "Name=%s Id=%d PadX=%d PadY=%d Cathode=%d\n",fName.Data(),fChannelId,fPadX,fPadY,fCathode);
}
//====================================================================
#include <TNamed.h>
+#include <TString.h>
class AliMUONSegmentIndex : public TNamed {
public:
Int_t GetPadY() const {return fPadX;}
Int_t GetCathode() const {return fCathode;}
+ static TString Name(Int_t padx, Int_t pady, Int_t cathode) ;
void Print() const;
private:
Int_t fChannelId; // Id of the channel within the detection element
- Int_t fPadX;
- Int_t fPadY;
- Int_t fCathode;
+ Int_t fPadX; // pad index in the X direction
+ Int_t fPadY; // pad index in the y direction
+ Int_t fCathode; // cathode plane 0 bending 1 non bending
ClassDef(AliMUONSegmentIndex,1) // Segmenation for MUON detection elements
};
// Detailed information in Alice Technical Note xxxxxxxx (2004)
//====================================================================
+#include <TString.h>
#include "AliMUONSegmentManuIndex.h"
//___________________________________________
AliMUONSegmentManuIndex::AliMUONSegmentManuIndex()
{
+ //Default constructor
fChannelId= 0;; // Id of the channel within the detection element
fManuId= 0;; // Manu id in the detection element
fBusPatchId= 0;; // BusPatchId in the detection element up to 4 for slats
//___________________________________________
AliMUONSegmentManuIndex::AliMUONSegmentManuIndex(const Int_t channelId, const Int_t manuId, const Int_t busPatchId, Int_t manuChannelId) : TNamed()
{
- char name[10];
- sprintf(name,"%d-%d",manuId,manuChannelId);
- fName=name;
- fTitle=name;
+ // Constructor to be used
+ fName = Name(manuId, manuChannelId).Data();
+ fTitle= Name(manuId, manuChannelId).Data();
fChannelId = channelId;
fManuId = manuId;
fBusPatchId = busPatchId;
//_______________________________________________
AliMUONSegmentManuIndex::~AliMUONSegmentManuIndex()
{
-
+ // Destructor
}
//___________________________________________
Int_t AliMUONSegmentManuIndex::Compare(const TObject *obj) const
{
+ // Comparison of two AliMUONSegmentManuIndex objects
AliMUONSegmentManuIndex * myobj = ( AliMUONSegmentManuIndex *) obj;
return (fChannelId > myobj->GetChannelId()) ? 1 : -1;
}
//___________________________________________
+TString AliMUONSegmentManuIndex::Name(Int_t manuid, Int_t manuchannel)
+{
+ // Definition of the name for TMap indexing
+ char name[15];
+ Int_t absid = manuid*64 + manuchannel;
+ sprintf(name,"%d",absid);
+ return TString(name);
+}
+//___________________________________________
void AliMUONSegmentManuIndex::Print() const
{
- printf("%s id=%d ManuId=%d BusPatch=%d ManuChannelId=%d\n",fName.Data(),fChannelId,fManuId,fBusPatchId,fManuChannelId);
+ // Printing AliMUONSegmentManuIndex information
+ Info("Print","Name=%s Id=%d BusPatch=%d ManuId=%d ManuChannelId=%d\n",fName.Data(),fChannelId,fBusPatchId,fManuId,fManuChannelId);
}
#include <TNamed.h>
+class TString;
class AliMUONSegmentManuIndex : public TNamed {
public:
Int_t GetManuId() const{return fManuId;}
Int_t GetBusPatchId() const{return fBusPatchId;}
Int_t GetManuChannelId() const{return fManuChannelId;}
+
+ static TString Name(Int_t manuId, Int_t manuchannel);
- void Print() const;
+ void Print() const;
private:
Int_t fChannelId; // Id of the channel within the detection element
// Detailed information in Alice Technical Note xxxxxxxx (2004)
//====================================================================
+#include <TMath.h>
+
#include "AliMUONSegmentPosition.h"
//___________________________________________
//___________________________________________
AliMUONSegmentPosition::AliMUONSegmentPosition() : TNamed()
{
+//Default constructor
fChannelId = 0;
fX = 0.;
fY = 0.;
//___________________________________________
AliMUONSegmentPosition::AliMUONSegmentPosition(const Int_t channelId, const Float_t x, const Float_t y, const Int_t cathode) : TNamed()
{
- char name[10];
- sprintf(name,"%5.2f-%5.2f",x,y);
- fName = name;
- fTitle= name;
+ // Constructor to be used
+ fName = Name(x,y,cathode);
+ fTitle= Name(x,y,cathode);
fChannelId = channelId;
fX = x;
fY = y;
//_______________________________________________
AliMUONSegmentPosition::~AliMUONSegmentPosition()
{
-
+ // Destructor
}
//___________________________________________
Int_t AliMUONSegmentPosition::Compare(const TObject *obj) const
{
+ // Comparison of two AliMUONSegmentPosition objects
AliMUONSegmentPosition * myobj = ( AliMUONSegmentPosition *) obj;
return (fChannelId > myobj->GetChannelId()) ? 1 : -1;
}
//___________________________________________
+TString AliMUONSegmentPosition::Name(Float_t x, Float_t y, Int_t cathode)
+{
+ // Definition of the name of AliMUONSegmentPosition
+ // Our convention since the smaller pad pich is 5 mm is to choice a 3mm unit:
+ // So for a position pair x,y and cathode plane icathode the name will be:
+ // xp = TMath::Nint(x*10./3.);
+ // yp = TMath::Nint(y+10./3.);
+ // sprintf(name,"%d-%d-%d",xp,yp,cathode);
+ Int_t xp = TMath::Nint(x*10./3.);
+ Int_t yp = TMath::Nint(y*10./3.);
+ char name[15];
+ sprintf(name,"%d-%d-%d",xp,yp,cathode);
+ return TString(name);
+}
+//___________________________________________
void AliMUONSegmentPosition::Print() const
{
- printf("%s id=%d x=%f y=%f cathode=%d\n",fName.Data(),fChannelId, fX, fY,fCathode);
+ // Printing AliMUONSegmentManuIndex information
+ Info("Print","Name=%s Id=%d X=%f Y=%f Cathode=%d\n",fName.Data(),fChannelId, fX, fY,fCathode);
}
// Detailed information in Alice Technical Note xxxxxxxx (2004)
//====================================================================
+
#include <TNamed.h>
+#include <TString.h>
class AliMUONSegmentPosition : public TNamed
{
Float_t GetYlocal() const {return fY;}
Int_t GetCathode() const {return fCathode;}
- void Print() const;
+
+ static TString Name(Float_t x, Float_t y, Int_t cathode) ;
+ void Print() const;
+
private:
- Int_t fChannelId; // Id of the channel within the detection element
- Float_t fX;
- Float_t fY;
- Int_t fCathode;
+ Int_t fChannelId; // Id of the channel within the detection element
+ Float_t fX; // Position X of the center of the segment (pad, strip, etc...)
+ Float_t fY; // Position Y of the center of the segment (pad, strip, etc...)
+ Int_t fCathode; // Cathode Side Bending 1 or non bending 0
ClassDef(AliMUONSegmentPosition,1) // Loal positions of segments
#include "AliMUONSegmentPosition.h"
#include "AliMUONSegmentIndex.h"
-
//___________________________________________
ClassImp(AliMUONSegmentationDetectionElement)
AliMUONSegmentationDetectionElement::AliMUONSegmentationDetectionElement() : TObject()
{
+ //Default constructor
fMapManuIndexIndex= 0x0;
fMapIndexManuIndex= 0x0;
fMapIndexPosition= 0x0;
- fXlocalSegmentPositions= 0x0;
- fYlocalSegmentPositions= 0x0;
+ fMapPositionIndex=0X0;
}
// fMapManuIndexIndex= 0x0;
// fMapIndexManuIndex= 0x0;
// fMapIndexPosition= 0x0;
-// fXlocalSegmentPositions= 0x0;
-// fYlocalSegmentPositions= 0x0;
// }
//________________________________________________
}
//_________________________________________________
AliMUONSegmentationDetectionElement::~AliMUONSegmentationDetectionElement(){
+ //Class destructor
fListOfIndexes->Delete();
fListOfManuIndexes->Delete();
fListOfPositions->Delete();
fMapManuIndexIndex->Clear();
fMapIndexManuIndex->Clear();
fMapIndexPosition->Clear();
+ fMapPositionIndex->Clear();
+}
+
+//_________________________________________________
+AliMUONSegmentIndex * AliMUONSegmentationDetectionElement::GetIndex(Int_t manu, Int_t channel) const
+{
+ // Getting AliMUONSegmentIndex from ManuIndex
+ return GetIndex( AliMUONSegmentManuIndex::Name(manu, channel).Data() ) ;
}
//_________________________________________________
-AliMUONSegmentIndex * AliMUONSegmentationDetectionElement::GetIndex( const char * SegmentManuIndexName)
+AliMUONSegmentIndex * AliMUONSegmentationDetectionElement::GetIndex( const char * SegmentManuIndexName) const
{
+ // Getting AliMUONSegmentIndex from name of AliMUONSegmentManuIndex
if (fMapManuIndexIndex) return (AliMUONSegmentIndex*) fMapManuIndexIndex->GetValue(SegmentManuIndexName);
else {
Warning("GetIndex","SegmentManuIndex %s out of DetectionElement Mapping %s",
return 0x0;
}
}
-
//_________________________________________________
-AliMUONSegmentManuIndex * AliMUONSegmentationDetectionElement::GetManuIndex( const char * SegmentIndexName)
+AliMUONSegmentManuIndex * AliMUONSegmentationDetectionElement::GetManuIndex(Int_t padx, Int_t pady, Int_t cathode ) const
+{
+ // Getting ManuIndex from Index
+ return GetManuIndex( AliMUONSegmentIndex::Name(padx, pady, cathode).Data() );
+}
+//_________________________________________________
+AliMUONSegmentManuIndex * AliMUONSegmentationDetectionElement::GetManuIndex( const char * SegmentIndexName) const
{
+ // Getting ManuIndex from manuname
if (fMapIndexManuIndex) return (AliMUONSegmentManuIndex*) fMapIndexManuIndex->GetValue(SegmentIndexName);
else {
Warning("GetManuIndex","SegmentIndex %s out of Detection Element mapping %s",
return 0x0;
}
}
-
//_________________________________________________
-AliMUONSegmentPosition * AliMUONSegmentationDetectionElement::GetPosition( const char * SegmentIndexName)
+AliMUONSegmentPosition * AliMUONSegmentationDetectionElement::GetPosition(Int_t padx, Int_t pady, Int_t cathode ) const
+{
+ //Getting position from index
+ return GetPosition( AliMUONSegmentIndex::Name(padx, pady, cathode).Data() );
+}
+//_________________________________________________
+AliMUONSegmentPosition * AliMUONSegmentationDetectionElement::GetPosition( const char * SegmentIndexName) const
{
+ // Getting position from indexname
if (fMapIndexPosition) return (AliMUONSegmentPosition*) fMapIndexPosition->GetValue(SegmentIndexName);
else {
Warning("GetPosition","SegmentIndex %s out of DetectionElement mapping %s",
return 0x0;
}
}
+//_________________________________________________
+AliMUONSegmentIndex * AliMUONSegmentationDetectionElement::GetIndexFromPosition(Float_t x, Float_t y, Int_t cathode) const
+{
+ // Getting Index from position if position is a center pad position
+ return GetIndexFromPosition( AliMUONSegmentPosition::Name(x,y, cathode).Data() );
+}
+//_________________________________________________
+AliMUONSegmentIndex * AliMUONSegmentationDetectionElement::GetIndexFromPosition( const char * PositionName) const
+{
+ // Getting index form positionname
+ if (fMapPositionIndex) return (AliMUONSegmentIndex*) fMapPositionIndex->GetValue(PositionName);
+ else {
+ Warning("GetIndexFromPosition","SegmentPosition %s out of DetectionElement Mapping %s",
+ PositionName,fDetectionElementType.Data());
+ return 0x0;
+ }
+}
//_________________________________________________
-AliMUONSegmentManuIndex * AliMUONSegmentationDetectionElement::FindManuIndex(const char* ManuIndexName)
+AliMUONSegmentManuIndex * AliMUONSegmentationDetectionElement::FindManuIndex( const char* ManuIndexName)const
{
+ // Getting AliMUONSegmentManuIndex objecto from manu index
if (fMapManuIndexIndex) return (AliMUONSegmentManuIndex*) fMapManuIndexIndex->FindObject(ManuIndexName);
else {
Warning("FindManuIndex","SegmentManuIndex %s out of DetectionElement mapping %s",
}
//_________________________________________________
-AliMUONSegmentManuIndex * AliMUONSegmentationDetectionElement::FindIndex(const char* IndexName)
+AliMUONSegmentIndex * AliMUONSegmentationDetectionElement::FindIndex(const char* IndexName) const
{
- if (fMapIndexPosition) return (AliMUONSegmentManuIndex *) fMapIndexPosition->FindObject(IndexName);
+ // Getting
+ if (fMapIndexPosition) return (AliMUONSegmentIndex *) fMapIndexPosition->FindObject(IndexName);
else {
Warning("FindIndex","SegmentIndex %s out of DetectionElement mapping %s",
IndexName,fDetectionElementType.Data());
return 0x0;
}
}
+//_________________________________________________
+AliMUONSegmentIndex * AliMUONSegmentationDetectionElement::FindIndexFromPosition(Float_t /*x*/, Float_t /*y*/, Int_t /*cathode*/ ) const
+{
+ // char * name = AliMUONSegmentPosition::Name(x,y);
+
+// if (GetIndexFromPosition( AliMUONSegmentPosition::Name(x,y)) )
+// return GetIndexFromPosition( AliMUONSegmentPosition::Name(x,y) );
+
+// Float_t xl= ((Int_t) x*10 )/10.;
+// Float_t yl= ((Int_t) y*10 )/10.;
+// Int_t ix,iy, ixp;
+
+// for(ix=1; ix<4; ix++) {
+// xl = ((Int_t) 0.5+10.*(x + ((Float_t) ix )*0.1))/10.;
+// for(iy=-ix; iy<ix+1; iy++) {
+// printf("A %d and %d and %f and %f \n",ix,iy,xl,yl);
+// yl = ((Int_t) 10.*(y + ((Float_t) iy )*0.1))/10. ;
+// sprintf(name,"%5.1f-%5.1f",xl, yl);
+// if (GetIndexFromPosition(name)) break;
+// }
+// if (GetIndexFromPosition(name)) break;
+
+
+// for(ixp=ix-1; ixp>-ix-1; ixp--) {
+// xl = ((Int_t) 0.5+10.*(x + ((Float_t) ixp )*0.1))/10. ;
+// printf("B %d and %d and %f and %f \n",ixp,ix, xl, yl);
+// sprintf(name,"%5.1f-%5.1f",xl, yl);
+// if (GetIndexFromPosition(name)) break;
+// }
+// if (GetIndexFromPosition(name)) break;
+
+// for(iy=ix-1; iy>-ix-1; iy--) {
+// yl = ((Int_t) 0.5+10.*(y + ((Float_t) iy )*0.1))/10. ;
+// printf("C %d and %d and %f and %f \n",-ix,iy,xl,yl);
+// sprintf(name,"%5.1f-%5.1f",xl, yl);
+// if (GetIndexFromPosition(name)) break;
+// }
+// if (GetIndexFromPosition(name)) break;
+
+// for(ixp=-ix+1; ixp<ix+1; ixp++) {
+// xl = ((Int_t) 0.5+10.*(x + ((Float_t) ixp )*0.1))/10. ;
+// printf("D %d and %d and %f and %f \n",ixp,-ix,xl,yl);
+// sprintf(name,"%5.1f-%5.1f",xl, yl);
+// if (GetIndexFromPosition(name)) break;
+// }
+// if (GetIndexFromPosition(name)) break;
+// }
+// return GetIndexFromPosition(name);
+ return 0x0;
+}
//_________________________________________________
void AliMUONSegmentationDetectionElement::Init(const char * DetectionElementType)
{
- TString ElementType(DetectionElementType);
- fSegmentationMappingFile_Bending = fgkDefaultTop+fgkStationDir+"345"
- +fgkBendingDir+"/"+ElementType+fgkBendingExt+fgkFileExt;
- printf("file is %s\n", fSegmentationMappingFile_Bending.Data());
- fSegmentationMappingFile_NonBending = fgkDefaultTop+fgkStationDir+"345"
- +fgkNonBendingDir+"/"+ElementType+fgkNonBendingExt+fgkFileExt;
+ TString elementType(DetectionElementType);
+ fSegmentationMappingFileBending = fgkDefaultTop+fgkStationDir+"345"
+ +fgkBendingDir+"/"+elementType+fgkBendingExt+fgkFileExt;
+ printf("file is %s\n", fSegmentationMappingFileBending.Data());
+ fSegmentationMappingFileNonBending = fgkDefaultTop+fgkStationDir+"345"
+ +fgkNonBendingDir+"/"+elementType+fgkNonBendingExt+fgkFileExt;
if (fMapManuIndexIndex==0x0) {
- fListOfIndexes = new TObjArray(10000);
- fListOfManuIndexes =new TObjArray(10000);
- fListOfPositions =new TObjArray(10000);
+ fListOfIndexes = new TObjArray(15000);
+ fListOfManuIndexes =new TObjArray(15000);
+ fListOfPositions =new TObjArray(15000);
fMapManuIndexIndex= new TMap();
fMapIndexManuIndex = new TMap();
fMapIndexPosition = new TMap();
+ fMapPositionIndex = new TMap();
}
else {
fListOfIndexes->Delete();
fMapManuIndexIndex->Clear();
fMapIndexManuIndex->Clear();
fMapIndexPosition->Clear();
+ fMapPositionIndex->Clear();
}
-
-
-
Int_t icathode;
//Bendingplane
icathode=0;
- ReadingSegmentationMappingFile(fSegmentationMappingFile_Bending ,icathode);
+ ReadingSegmentationMappingFile(fSegmentationMappingFileBending ,icathode);
//NonBendingplane
icathode=1;
- ReadingSegmentationMappingFile(fSegmentationMappingFile_NonBending,icathode);
+ ReadingSegmentationMappingFile(fSegmentationMappingFileNonBending,icathode);
}
//_______________________________________________________________
Float_t x, y;
while ( !in.eof()) {
in >> id >> ix >> iy >> x >> y >> idmanu >> idchannel;
- char name[10];
- sprintf(name,"%d%d",ix,iy);
- printf("%s id=%d ix=%d iy=%d x=%f y=%f idmanu=%d and idchannel=%d\n",name,id, ix, iy, x, y,idmanu, idchannel);
+ printf("id=%d ix=%d iy=%d x=%f y=%f idmanu=%d and idchannel=%d\n",id, ix, iy, x, y,idmanu, idchannel);
fListOfIndexes->AddAt( new AliMUONSegmentIndex(id,ix,iy,cathode), id);
fListOfManuIndexes->AddAt( new AliMUONSegmentManuIndex(id,idmanu,0,idchannel), id);;
fMapManuIndexIndex->Add( fListOfManuIndexes->At(id), fListOfIndexes->At(id));
fMapIndexManuIndex->Add( fListOfIndexes->At(id), fListOfManuIndexes->At(id));
fMapIndexPosition->Add( fListOfIndexes->At(id), fListOfPositions->At(id));
+ fMapPositionIndex->Add( fListOfPositions->At(id), fListOfIndexes->At(id) );
}
}
in.close();
AliMUONSegmentationDetectionElement();
//AliMUONSegmentationDetectionElement(const char* ElementType="");
virtual ~AliMUONSegmentationDetectionElement();
+
+ // User functions
+ AliMUONSegmentIndex * GetIndex(Int_t manu, Int_t channel) const;
+ AliMUONSegmentIndex * GetIndexFromPosition(Float_t x, Float_t y, Int_t icathode) const;
+ AliMUONSegmentManuIndex * GetManuIndex( Int_t padx, Int_t pady, Int_t cathode) const ;
+ AliMUONSegmentPosition * GetPosition(Int_t padx, Int_t pady, Int_t cathode) const ;
+
- AliMUONSegmentIndex * GetIndex( const char * SegmentManuIndexName);
- AliMUONSegmentManuIndex * GetManuIndex( const char * SegmentIndexName);
- AliMUONSegmentPosition * GetPosition( const char * SegmentIndexName);
+ AliMUONSegmentIndex * GetIndex( const char * SegmentManuIndexName)const;
+ AliMUONSegmentIndex * GetIndexFromPosition( const char * PositionName)const;
+ AliMUONSegmentManuIndex * GetManuIndex( const char * SegmentIndexName) const;
+ AliMUONSegmentPosition * GetPosition( const char * SegmentIndexName) const;
TObjArray * ListOfIndexes() {return fListOfIndexes;}
TObjArray * ListOfManuIndexes() {return fListOfIndexes;}
TObjArray * ListOfPositions() {return fListOfIndexes;}
- AliMUONSegmentManuIndex * FindManuIndex(const char* ManuIndexName="");
- AliMUONSegmentManuIndex * FindIndex(const char* IndexName="");
+ AliMUONSegmentManuIndex * FindManuIndex(const char* ManuIndexName="") const;
+ AliMUONSegmentIndex * FindIndex(const char* IndexName="") const;
+
+ AliMUONSegmentIndex * FindIndexFromPosition(Float_t x, Float_t y, Int_t cathode) const;
void Init(const char * DetectionElementType="slat220000N");
private:
// static data members
- static const TString fgkDefaultTop; //
- static const TString fgkStationDir; //
+ static const TString fgkDefaultTop; // Top directory of $Alice_ROOT/MUON/mapping
+ static const TString fgkStationDir; // Directory for station station1, station2, station345
static const TString fgkBendingDir; //bending plane directory
static const TString fgkNonBendingDir; //non-bending plane directory
static const TString fgkFileExt; // File extention
// data members
TString fDetectionElementType; // Type of detection element St1Sector, slat220000N, etc ....
- TString fSegmentationMappingFile_Bending; // Segmentation & mapping file for bending plane
- TString fSegmentationMappingFile_NonBending; // Segmentation & mapping file for non bending plane
- TObjArray * fListOfIndexes;
- TObjArray * fListOfManuIndexes;
- TObjArray * fListOfPositions;
+ TString fSegmentationMappingFileBending; // Segmentation & mapping file for bending plane
+ TString fSegmentationMappingFileNonBending; // Segmentation & mapping file for non bending plane
+ TObjArray * fListOfIndexes; // TObject Array fo AliMUONSegmentIndex
+ TObjArray * fListOfManuIndexes; // TObject Array fo AliMUONSegmentManuIndex
+ TObjArray * fListOfPositions; // TObject Array fo AliMUONSegmentPositions
TMap * fMapManuIndexIndex; // Map with key ManuIndex and value = Index
TMap * fMapIndexManuIndex;// Map with key ManuIndexIndex and value = ManuIndex
TMap * fMapIndexPosition;// Map with key Index and value = Position
- TArrayF * fXlocalSegmentPositions; // Array of posible values of Xlocal
- TArrayF * fYlocalSegmentPositions;// Array of posible values of Ylocal
+ TMap * fMapPositionIndex;// Map with key Index and value = Position
ClassDef(AliMUONSegmentationDetectionElement,1) // Segmentation for MUON detection elements
git://git.uio.no / u / mrichter / AliRoot.git / commitdiff