--- /dev/null
+/**************************************************************************
+ * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ * *
+ * Author: The ALICE Off-line Project. *
+ * Contributors are mentioned in the code where appropriate. *
+ * *
+ * Permission to use, copy, modify and distribute this software and its *
+ * documentation strictly for non-commercial purposes is hereby granted *
+ * without fee, provided that the above copyright notice appears in all *
+ * copies and that both the copyright notice and this permission notice *
+ * appear in the supporting documentation. The authors make no claims *
+ * about the suitability of this software for any purpose. It is *
+ * provided "as is" without express or implied warranty. *
+ **************************************************************************/
+
+/* $Id$ */
+
+//===================================================================
+// Segment element indexing in a detection element
+// Gines MARTINEZ, SUBATECH July 04
+// This class is the basic component of
+// AliMUONSegmentationDetectionElement and contains al the
+// info about a segment (pad or strip):
+// Id-indetectionelement, ix ,iy
+// Detailed information in Alice Technical Note xxxxxxxx (2004)
+//====================================================================
+
+#include "AliMUONSegmentIndex.h"
+
+//___________________________________________
+ClassImp(AliMUONSegmentIndex)
+
+//
+//___________________________________________
+AliMUONSegmentIndex::AliMUONSegmentIndex() : TNamed()
+{
+ fChannelId = 0;
+ fPadX = 0;
+ fPadY = 0;
+ fCathode=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;
+ fChannelId = channelId;
+ fPadX = padX;
+ fPadY = padY;
+ fCathode=cathode;
+}
+//_______________________________________________
+AliMUONSegmentIndex::~AliMUONSegmentIndex()
+{
+
+}
+//___________________________________________
+Int_t AliMUONSegmentIndex::Compare(const TObject *obj) const
+{
+ AliMUONSegmentIndex * myobj = ( AliMUONSegmentIndex *) obj;
+ return (fChannelId > myobj->GetChannelId()) ? 1 : -1;
+}
+//___________________________________________
+void AliMUONSegmentIndex::Print() const
+{
+ printf("%s id=%d ix=%d iy=%d cathode=%d\n",fName.Data(),fChannelId,fPadX,fPadY,fCathode);
+}
--- /dev/null
+#ifndef ALIMUONSEGMENTINDEX_H
+#define ALIMUONSEGMENTINDEX_H
+/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ * See cxx source for full Copyright notice */
+
+/* $Id$ */
+
+//===================================================================
+// Segment element indexing in a detection element
+// Gines MARTINEZ, SUBATECH July 04
+// This class is the basic component of
+// AliMUONSegmentationDetectionElement and contains al the
+// info about a segment (pad or strip):
+// Id-indetectionelement, ix ,iy
+// Detailed information in Alice Technical Note xxxxxxxx (2004)
+//====================================================================
+
+#include <TNamed.h>
+
+class AliMUONSegmentIndex : public TNamed {
+ public:
+ AliMUONSegmentIndex();
+ AliMUONSegmentIndex(const Int_t channelId, const Int_t padX, const Int_t padY, const Int_t cathode);
+ virtual ~AliMUONSegmentIndex();
+
+
+ Int_t Compare(const TObject *obj) const;
+ Int_t GetChannelId() const {return fChannelId;}
+ Int_t GetPadX() const {return fPadX;}
+ Int_t GetPadY() const {return fPadX;}
+ Int_t GetCathode() const {return fCathode;}
+
+ void Print() const;
+
+ private:
+ Int_t fChannelId; // Id of the channel within the detection element
+ Int_t fPadX;
+ Int_t fPadY;
+ Int_t fCathode;
+
+ ClassDef(AliMUONSegmentIndex,1) // Segmenation for MUON detection elements
+};
+#endif
+
+
+
+
+
+
--- /dev/null
+/**************************************************************************
+ * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ * *
+ * Author: The ALICE Off-line Project. *
+ * Contributors are mentioned in the code where appropriate. *
+ * *
+ * Permission to use, copy, modify and distribute this software and its *
+ * documentation strictly for non-commercial purposes is hereby granted *
+ * without fee, provided that the above copyright notice appears in all *
+ * copies and that both the copyright notice and this permission notice *
+ * appear in the supporting documentation. The authors make no claims *
+ * about the suitability of this software for any purpose. It is *
+ * provided "as is" without express or implied warranty. *
+ **************************************************************************/
+
+/* $Id$ */
+
+//===================================================================
+// Segment element indexing in a detection element for electronics
+// Gines MARTINEZ, SUBATECH July 04
+// This class is the basic component of
+// AliMUONSegmentationDetectionElement and contains al the
+// info about a segment (pad or strip):
+// Id-indetectionelement, #manu, #manuchannel
+// Detailed information in Alice Technical Note xxxxxxxx (2004)
+//====================================================================
+
+
+#include "AliMUONSegmentManuIndex.h"
+
+//___________________________________________
+ClassImp(AliMUONSegmentManuIndex)
+
+//
+//___________________________________________
+AliMUONSegmentManuIndex::AliMUONSegmentManuIndex()
+{
+ 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
+ fManuChannelId= 0;;
+}
+//___________________________________________
+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;
+ fChannelId = channelId;
+ fManuId = manuId;
+ fBusPatchId = busPatchId;
+ fManuChannelId = manuChannelId;
+}
+//_______________________________________________
+AliMUONSegmentManuIndex::~AliMUONSegmentManuIndex()
+{
+
+}
+//___________________________________________
+Int_t AliMUONSegmentManuIndex::Compare(const TObject *obj) const
+{
+ AliMUONSegmentManuIndex * myobj = ( AliMUONSegmentManuIndex *) obj;
+ return (fChannelId > myobj->GetChannelId()) ? 1 : -1;
+}
+//___________________________________________
+void AliMUONSegmentManuIndex::Print() const
+{
+ printf("%s id=%d ManuId=%d BusPatch=%d ManuChannelId=%d\n",fName.Data(),fChannelId,fManuId,fBusPatchId,fManuChannelId);
+}
--- /dev/null
+#ifndef ALIMUONSEGMENTMANUINDEX_H
+#define ALIMUONSEGMENTMANUINDEX_H
+/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ * See cxx source for full Copyright notice */
+
+/* $Id$ */
+
+//===================================================================
+// Segment element indexing in a detection element for electronics
+// Gines MARTINEZ, SUBATECH July 04
+// This class is the basic component of
+// AliMUONSegmentationDetectionElement and contains al the
+// info about a segment (pad or strip):
+// Id-indetectionelement, #manu, #manuchannel
+// Detailed information in Alice Technical Note xxxxxxxx (2004)
+//====================================================================
+
+#include <TNamed.h>
+
+
+class AliMUONSegmentManuIndex : public TNamed {
+ public:
+ AliMUONSegmentManuIndex();
+ AliMUONSegmentManuIndex(const Int_t channelId, const Int_t manuId, const Int_t busPatchId, const Int_t manuChannelId);
+
+ virtual ~AliMUONSegmentManuIndex();
+
+ Int_t Compare(const TObject *obj) const;
+
+ Int_t GetChannelId() const{return fChannelId;}
+ Int_t GetManuId() const{return fManuId;}
+ Int_t GetBusPatchId() const{return fBusPatchId;}
+ Int_t GetManuChannelId() const{return fManuChannelId;}
+
+ void Print() const;
+
+ private:
+ Int_t fChannelId; // Id of the channel within the detection element
+ Int_t fManuId; // Manu id in the detection element
+ Int_t fBusPatchId; // BusPatchId in the detection element up to 4 for slats
+ Int_t fManuChannelId; // ChannelId in the manu card 1-64
+
+ ClassDef(AliMUONSegmentManuIndex,1) // Segmenation for MUON detection elements
+
+};
+
+#endif
+
+
+
+
+
+
--- /dev/null
+/**************************************************************************
+ * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ * *
+ * Author: The ALICE Off-line Project. *
+ * Contributors are mentioned in the code where appropriate. *
+ * *
+ * Permission to use, copy, modify and distribute this software and its *
+ * documentation strictly for non-commercial purposes is hereby granted *
+ * without fee, provided that the above copyright notice appears in all *
+ * copies and that both the copyright notice and this permission notice *
+ * appear in the supporting documentation. The authors make no claims *
+ * about the suitability of this software for any purpose. It is *
+ * provided "as is" without express or implied warranty. *
+ **************************************************************************/
+
+/* $Id$ */
+
+//===================================================================
+// Segment element position in local coordinates of the detection element
+// Gines MARTINEZ, SUBATECH July 04
+// This class is one of the basic component of
+// AliMUONSegmentationDetectionElement and contains al the
+// info about a segment (pad or strip):
+// Id-indetectionelement, x_local, y_local
+// Detailed information in Alice Technical Note xxxxxxxx (2004)
+//====================================================================
+
+#include "AliMUONSegmentPosition.h"
+
+//___________________________________________
+ClassImp(AliMUONSegmentPosition)
+
+//
+//___________________________________________
+AliMUONSegmentPosition::AliMUONSegmentPosition() : TNamed()
+{
+ 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;
+ fChannelId = channelId;
+ fX = x;
+ fY = y;
+ fCathode=cathode;
+}
+//_______________________________________________
+AliMUONSegmentPosition::~AliMUONSegmentPosition()
+{
+
+}
+//___________________________________________
+Int_t AliMUONSegmentPosition::Compare(const TObject *obj) const
+{
+ AliMUONSegmentPosition * myobj = ( AliMUONSegmentPosition *) obj;
+ return (fChannelId > myobj->GetChannelId()) ? 1 : -1;
+}
+//___________________________________________
+void AliMUONSegmentPosition::Print() const
+{
+ printf("%s id=%d x=%f y=%f cathode=%d\n",fName.Data(),fChannelId, fX, fY,fCathode);
+}
--- /dev/null
+#ifndef ALIMUONSEGMENTPOSITION_H
+#define ALIMUONSEGMENTPOSITION_H
+/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ * See cxx source for full Copyright notice */
+
+/* $Id$ */
+
+//===================================================================
+// Segment element position in local coordinates of the detection element
+// Gines MARTINEZ, SUBATECH July 04
+// This class is one of the basic component of
+// AliMUONSegmentationDetectionElement and contains al the
+// info about a segment (pad or strip):
+// Id-indetectionelement, x_local, y_local
+// Detailed information in Alice Technical Note xxxxxxxx (2004)
+//====================================================================
+
+#include <TNamed.h>
+
+class AliMUONSegmentPosition : public TNamed
+{
+ public:
+ AliMUONSegmentPosition();
+ AliMUONSegmentPosition(const Int_t channelId, const Float_t x, const Float_t y, const Int_t cathode);
+ virtual ~AliMUONSegmentPosition();
+
+ Int_t Compare(const TObject *obj) const;
+ Int_t GetChannelId()const {return fChannelId;}
+ Float_t GetXlocal() const {return fX;}
+ Float_t GetYlocal() const {return fY;}
+ Int_t GetCathode() const {return fCathode;}
+
+ void Print() const;
+ private:
+ Int_t fChannelId; // Id of the channel within the detection element
+ Float_t fX;
+ Float_t fY;
+ Int_t fCathode;
+
+ ClassDef(AliMUONSegmentPosition,1) // Loal positions of segments
+
+};
+#endif
+
+
+
+
+
+
--- /dev/null
+/**************************************************************************
+ * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ * *
+ * Author: The ALICE Off-line Project. *
+ * Contributors are mentioned in the code where appropriate. *
+ * *
+ * Permission to use, copy, modify and distribute this software and its *
+ * documentation strictly for non-commercial purposes is hereby granted *
+ * without fee, provided that the above copyright notice appears in all *
+ * copies and that both the copyright notice and this permission notice *
+ * appear in the supporting documentation. The authors make no claims *
+ * about the suitability of this software for any purpose. It is *
+ * provided "as is" without express or implied warranty. *
+ **************************************************************************/
+
+/* $Id$ */
+//===========================================================
+// Segmentation classes for MUON Detection Elements
+// Gines MARTINEZ, SUBATECH July 04
+// This class interfaces with the mapping and segmentation
+// files MUON.
+// This files are placed by default in
+// $ALICE_ROOT/MUON/mapping/data/Stationxxx/yyy_plane/
+// There are in tracking 23 types of detection elements
+// 8 SectorSt1, 8 SectorSt2, 2 122000SR1, 2 122000NR1, 4 112200SR2, 4 112200NR2
+// 4 122200S, 4 122200N, 8 222000N,8 220000N, 8 330000N, 4 122300N, 8 112230NR3
+// 8 112230N, 8 222330N, 8 223300N, 16 333000N, 4 122330N, 8 112233NR3, 8 112233N
+// 8 222333N, 8 223330N, 8 333300N
+// Detailed information in Alice Technical Note xxxxxxxx (2004)
+//===========================================================
+
+#include <Riostream.h>
+
+#include "TClonesArray.h"
+#include "TMap.h"
+
+#include "AliMUONSegmentationDetectionElement.h"
+#include "AliMUONSegmentManuIndex.h"
+#include "AliMUONSegmentPosition.h"
+#include "AliMUONSegmentIndex.h"
+
+
+//___________________________________________
+ClassImp(AliMUONSegmentationDetectionElement)
+
+//static data member
+const TString AliMUONSegmentationDetectionElement::fgkDefaultTop =getenv("ALICE_ROOT") ;
+const TString AliMUONSegmentationDetectionElement::fgkStationDir = "/MUON/mapping/data/station";
+const TString AliMUONSegmentationDetectionElement::fgkBendingDir= "/bending_plane";
+const TString AliMUONSegmentationDetectionElement::fgkNonBendingDir= "/non-bending_plane";
+const TString AliMUONSegmentationDetectionElement::fgkFileExt = ".map";
+const TString AliMUONSegmentationDetectionElement::fgkBendingExt = ".Bending";
+const TString AliMUONSegmentationDetectionElement::fgkNonBendingExt = ".NonBending";
+
+//___________________________________________
+
+AliMUONSegmentationDetectionElement::AliMUONSegmentationDetectionElement() : TObject()
+{
+ fMapManuIndexIndex= 0x0;
+ fMapIndexManuIndex= 0x0;
+ fMapIndexPosition= 0x0;
+ fXlocalSegmentPositions= 0x0;
+ fYlocalSegmentPositions= 0x0;
+}
+
+
+// AliMUONSegmentationDetectionElement::AliMUONSegmentationDetectionElement(const char* ElementType)
+// {
+
+// fMapManuIndexIndex= 0x0;
+// fMapIndexManuIndex= 0x0;
+// fMapIndexPosition= 0x0;
+// fXlocalSegmentPositions= 0x0;
+// fYlocalSegmentPositions= 0x0;
+// }
+
+//________________________________________________
+AliMUONSegmentationDetectionElement::AliMUONSegmentationDetectionElement(const AliMUONSegmentationDetectionElement& rhs): TObject(rhs)
+{
+// Protected copy constructor
+
+ Fatal("AliMUONSegmentationDetectionElementModule", "Not implemented.");
+}
+//_________________________________________________
+AliMUONSegmentationDetectionElement::~AliMUONSegmentationDetectionElement(){
+ fListOfIndexes->Delete();
+ fListOfManuIndexes->Delete();
+ fListOfPositions->Delete();
+ fMapManuIndexIndex->Clear();
+ fMapIndexManuIndex->Clear();
+ fMapIndexPosition->Clear();
+}
+//_________________________________________________
+AliMUONSegmentIndex * AliMUONSegmentationDetectionElement::GetIndex( const char * SegmentManuIndexName)
+{
+ if (fMapManuIndexIndex) return (AliMUONSegmentIndex*) fMapManuIndexIndex->GetValue(SegmentManuIndexName);
+ else {
+ Warning("GetIndex","SegmentManuIndex %s out of DetectionElement Mapping %s",
+ SegmentManuIndexName,fDetectionElementType.Data());
+ return 0x0;
+ }
+}
+
+//_________________________________________________
+AliMUONSegmentManuIndex * AliMUONSegmentationDetectionElement::GetManuIndex( const char * SegmentIndexName)
+{
+ if (fMapIndexManuIndex) return (AliMUONSegmentManuIndex*) fMapIndexManuIndex->GetValue(SegmentIndexName);
+ else {
+ Warning("GetManuIndex","SegmentIndex %s out of Detection Element mapping %s",
+ SegmentIndexName,fDetectionElementType.Data());
+ return 0x0;
+ }
+}
+
+//_________________________________________________
+AliMUONSegmentPosition * AliMUONSegmentationDetectionElement::GetPosition( const char * SegmentIndexName)
+{
+ if (fMapIndexPosition) return (AliMUONSegmentPosition*) fMapIndexPosition->GetValue(SegmentIndexName);
+ else {
+ Warning("GetPosition","SegmentIndex %s out of DetectionElement mapping %s",
+ SegmentIndexName, fDetectionElementType.Data());
+ return 0x0;
+ }
+}
+
+//_________________________________________________
+AliMUONSegmentManuIndex * AliMUONSegmentationDetectionElement::FindManuIndex(const char* ManuIndexName)
+{
+ if (fMapManuIndexIndex) return (AliMUONSegmentManuIndex*) fMapManuIndexIndex->FindObject(ManuIndexName);
+ else {
+ Warning("FindManuIndex","SegmentManuIndex %s out of DetectionElement mapping %s",
+ ManuIndexName,fDetectionElementType.Data());
+ return 0x0;
+ }
+}
+
+//_________________________________________________
+AliMUONSegmentManuIndex * AliMUONSegmentationDetectionElement::FindIndex(const char* IndexName)
+{
+ if (fMapIndexPosition) return (AliMUONSegmentManuIndex *) fMapIndexPosition->FindObject(IndexName);
+ else {
+ Warning("FindIndex","SegmentIndex %s out of DetectionElement mapping %s",
+ IndexName,fDetectionElementType.Data());
+ 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;
+
+ if (fMapManuIndexIndex==0x0) {
+ fListOfIndexes = new TObjArray(10000);
+ fListOfManuIndexes =new TObjArray(10000);
+ fListOfPositions =new TObjArray(10000);
+ fMapManuIndexIndex= new TMap();
+ fMapIndexManuIndex = new TMap();
+ fMapIndexPosition = new TMap();
+ }
+ else {
+ fListOfIndexes->Delete();
+ fListOfManuIndexes->Delete();
+ fListOfPositions->Delete();
+ fMapManuIndexIndex->Clear();
+ fMapIndexManuIndex->Clear();
+ fMapIndexPosition->Clear();
+ }
+
+
+
+ Int_t icathode;
+ //Bendingplane
+ icathode=0;
+ ReadingSegmentationMappingFile(fSegmentationMappingFile_Bending ,icathode);
+ //NonBendingplane
+ icathode=1;
+ ReadingSegmentationMappingFile(fSegmentationMappingFile_NonBending,icathode);
+
+}
+//_______________________________________________________________
+void AliMUONSegmentationDetectionElement::ReadingSegmentationMappingFile(TString infile, Int_t cathode)
+{
+ ifstream in( infile, ios::in);
+ if (!in) {
+ // Error("ReadingSegmentationMappingFile", "File not found.");
+ }
+ else {
+ Int_t id, ix, iy, idmanu, idchannel;
+ 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);
+
+ fListOfIndexes->AddAt( new AliMUONSegmentIndex(id,ix,iy,cathode), id);
+ fListOfManuIndexes->AddAt( new AliMUONSegmentManuIndex(id,idmanu,0,idchannel), id);;
+ fListOfPositions->AddAt( new AliMUONSegmentPosition(id, x, y,cathode), id);;
+
+ ( (AliMUONSegmentIndex* )fListOfIndexes->At(id))->Print();
+ ( (AliMUONSegmentManuIndex*)fListOfManuIndexes->At(id))->Print();
+ ( (AliMUONSegmentPosition*)fListOfPositions->At(id))->Print();
+
+ fMapManuIndexIndex->Add( fListOfManuIndexes->At(id), fListOfIndexes->At(id));
+ fMapIndexManuIndex->Add( fListOfIndexes->At(id), fListOfManuIndexes->At(id));
+ fMapIndexPosition->Add( fListOfIndexes->At(id), fListOfPositions->At(id));
+ }
+ }
+ in.close();
+}
--- /dev/null
+#ifndef ALIMUONSEGMENTATIONDETECTIONELEMENT_H
+#define ALIMUONSEGMENTATIONDETECTIONELEMENT_H
+/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ * See cxx source for full Copyright notice */
+
+/* $Id$ */
+
+//===========================================================
+// Segmentation classes for MUON Detection Elements
+// Gines MARTINEZ, SUBATECH July 04
+// This class interfaces with the mapping and segmentation
+// files MUON.
+// This files are placed by default in
+// $ALICE_ROOT/MUON/mapping/data/Stationxxx/yyy_plane/
+// There are in tracking 23 types of detection elements
+// 8 SectorSt1, 8 SectorSt2, 2 122000SR1, 2 122000NR1, 4 112200SR2, 4 112200NR2
+// 4 122200S, 4 122200N, 8 222000N,8 220000N, 8 330000N, 4 122300N, 8 112230NR3
+// 8 112230N, 8 222330N, 8 223300N, 16 333000N, 4 122330N, 8 112233NR3, 8 112233N
+// 8 222333N, 8 223330N, 8 333300N
+// Detailed information in Alice Technical Note xxxxxxxx (2004)
+//===========================================================
+#include <Riostream.h>
+
+
+#include <TObject.h>
+#include <TString.h>
+#include <TArrayF.h>
+
+class TClonesArray;
+class TMap;
+
+class AliMUONSegmentManuIndex;
+class AliMUONSegmentPosition;
+class AliMUONSegmentIndex;
+
+class AliMUONSegmentationDetectionElement : public TObject {
+ public:
+ AliMUONSegmentationDetectionElement();
+ //AliMUONSegmentationDetectionElement(const char* ElementType="");
+ virtual ~AliMUONSegmentationDetectionElement();
+
+ AliMUONSegmentIndex * GetIndex( const char * SegmentManuIndexName);
+ AliMUONSegmentManuIndex * GetManuIndex( const char * SegmentIndexName);
+ AliMUONSegmentPosition * GetPosition( const char * SegmentIndexName);
+ TObjArray * ListOfIndexes() {return fListOfIndexes;}
+ TObjArray * ListOfManuIndexes() {return fListOfIndexes;}
+ TObjArray * ListOfPositions() {return fListOfIndexes;}
+
+ AliMUONSegmentManuIndex * FindManuIndex(const char* ManuIndexName="");
+ AliMUONSegmentManuIndex * FindIndex(const char* IndexName="");
+
+ void Init(const char * DetectionElementType="slat220000N");
+
+ void ReadingSegmentationMappingFile(TString infile, Int_t cathode);
+
+ protected:
+ AliMUONSegmentationDetectionElement(const AliMUONSegmentationDetectionElement& rhs);
+
+ private:
+ // static data members
+ static const TString fgkDefaultTop; //
+ static const TString fgkStationDir; //
+ static const TString fgkBendingDir; //bending plane directory
+ static const TString fgkNonBendingDir; //non-bending plane directory
+ static const TString fgkFileExt; // File extention
+ static const TString fgkBendingExt; // bending file extention
+ static const TString fgkNonBendingExt; // bending 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;
+ 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
+
+
+ ClassDef(AliMUONSegmentationDetectionElement,1) // Segmentation for MUON detection elements
+
+ };
+#endif
+
+
+
+
+
+
#pragma link C++ class AliMUONResponseTriggerV1+;
#pragma link C++ class AliMUONSegmentationV01+;
#pragma link C++ class AliMUONSegmentationV02+;
-#pragma link C++ class AliMUONSegmentationV04+;
-#pragma link C++ class AliMUONSegmentationV05+;
-#pragma link C++ class AliMUONSegmentationV1+;
#pragma link C++ class AliMUONSegmentationTrigger+;
#pragma link C++ class AliMUONSegmentationTriggerX+;
#pragma link C++ class AliMUONSegmentationTriggerY+;
+#pragma link C++ class AliMUONSegmentationDetectionElement+;
+#pragma link C++ class AliMUONSegmentIndex+;
+#pragma link C++ class AliMUONSegmentManuIndex+;
+#pragma link C++ class AliMUONSegmentPosition+;
#pragma link C++ class AliMUONChamber+;
#pragma link C++ class AliMUONChamberTrigger+;
#pragma link C++ class AliMUONPoints+;
AliMUONSegmentationV0.cxx\
AliMUONResponse.cxx AliMUONResponseV0.cxx \
AliMUONSegmentationV01.cxx \
- AliMUONSegmentationV02.cxx AliMUONSegmentationV04.cxx \
- AliMUONSegmentationV05.cxx\
+ AliMUONSegmentationV02.cxx \
AliMUONSegmentationTrigger.cxx AliMUONResponseTrigger.cxx\
AliMUONResponseTriggerV1.cxx\
AliMUONSegmentationTriggerX.cxx AliMUONSegmentationTriggerY.cxx \
- AliMUONSegmentationV1.cxx AliMUON.cxx AliMUONv0.cxx AliMUONv1.cxx AliMUONv3.cxx \
+ AliMUONSegmentationDetectionElement.cxx AliMUONSegmentIndex.cxx AliMUONSegmentManuIndex.cxx AliMUONSegmentPosition.cxx\
+ AliMUON.cxx AliMUONv0.cxx AliMUONv1.cxx AliMUONv3.cxx \
AliMUONChamberGeometry.cxx AliMUONGeometryConstituent.cxx AliMUONGeometryEnvelope.cxx \
AliMUONVGeometryBuilder.cxx AliMUONSt1GeometryBuilder.cxx AliMUONSt1GeometryBuilderV2.cxx \
AliMUONSt2GeometryBuilder.cxx AliMUONSlatGeometryBuilder.cxx \
git://git.uio.no / u / mrichter / AliRoot.git / commitdiff