]> git.uio.no Git - u/mrichter/AliRoot.git/blobdiff - MUON/AliMUONTriggerCircuit.cxx
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
Transition to NewIO
[u/mrichter/AliRoot.git] / MUON / AliMUONTriggerCircuit.cxx
diff --git a/MUON/AliMUONTriggerCircuit.cxx b/MUON/AliMUONTriggerCircuit.cxx
index 8a2706d3b054c86d7e1668a6604e9d7bc077ec26..479981b0f2e2a3a71ff940219386d0b510b6973e 100644 (file)
--- a/MUON/AliMUONTriggerCircuit.cxx
+++ b/MUON/AliMUONTriggerCircuit.cxx
@@ -12,23 +12,18 @@
  * about the suitability of this software for any purpose. It is          *
  * provided "as is" without express or implied warranty.                  *
  **************************************************************************/
-/*
-$Log$
-Revision 1.3  2000/06/26 10:04:49  pcrochet
-problem with HP compiler solved (PH), static variables removed : now defined in AliMUONTriggerConstants
 
-*/
+/* $Id$ */
 
 #include "AliRun.h"
 #include "AliMUON.h"
-#include "AliMUONPoints.h"
 #include "AliMUONTriggerCircuit.h"
 #include "AliMUONTriggerConstants.h"
-#include "AliMUONSegmentation.h"
+#include "AliSegmentation.h"
 #include "AliMUONResponse.h"
 #include "AliMUONChamber.h"
 #include "TMath.h"
-#include "iostream.h"
+#include "Riostream.h"
 
 ClassImp(AliMUONTriggerCircuit)
 
@@ -36,9 +31,10 @@ ClassImp(AliMUONTriggerCircuit)
 AliMUONTriggerCircuit::AliMUONTriggerCircuit() 
 {
 // Constructor
-  fidCircuit=0;
-  fx2m=0;
-  fx2ud=0;
+  fSegmentation=0;
+  fIdCircuit=0;
+  fX2m=0;
+  fX2ud=0;
   fOrMud[0]=fOrMud[1]=0;
   Int_t i;  
   for (i=0; i<4; i++) {
@@ -68,7 +64,7 @@ AliMUONTriggerCircuit & AliMUONTriggerCircuit::operator=(const AliMUONTriggerCir
 //----------------------------------------------------------------------
 void AliMUONTriggerCircuit::Init(Int_t iCircuit) {
 // initialize circuit characteristics
-  fidCircuit=AliMUONTriggerConstants::CircuitId(iCircuit);
+  fIdCircuit=AliMUONTriggerConstants::CircuitId(iCircuit);
   LoadX2();
   LoadXCode();
   LoadYCode();
@@ -115,14 +111,14 @@ Int_t AliMUONTriggerCircuit::Position(Int_t idCircuit) {
 
 //----------------------------------------------------------------------
 void AliMUONTriggerCircuit::LoadX2() {
-// initialize fx2m, fx2ud and fOrMud
+// initialize fX2m, fX2ud and fOrMud
   
-  Int_t idModule=Module(fidCircuit);        // corresponding module Id.
+  Int_t idModule=Module(fIdCircuit);        // corresponding module Id.
 // and its number of X strips
   Int_t nStrX=AliMUONTriggerConstants::NstripX(ModuleNumber(idModule)); 
 // and its number of Y strips
   Int_t nStrY=AliMUONTriggerConstants::NstripY(ModuleNumber(idModule)); 
-  Int_t iPosCircuit=Position(fidCircuit); // position of circuit in module
+  Int_t iPosCircuit=Position(fIdCircuit); // position of circuit in module
   
 // first step : look at lower part 
   if (iPosCircuit==1) {               // need to scan lower module       
@@ -133,8 +129,8 @@ void AliMUONTriggerCircuit::LoadX2() {
       
       if (nStrY!=nStrD    
          &&TMath::Abs(idModule)!=42&&TMath::Abs(idModule)!=52) {   
-       if (nStrY==8) fx2m=1; 
-       if (nStrD==8) fx2ud=1; 
+       if (nStrY==8) fX2m=1; 
+       if (nStrD==8) fX2ud=1; 
       }      
     }      
 
@@ -152,8 +148,8 @@ void AliMUONTriggerCircuit::LoadX2() {
 
       if (nStrY!=nStrU    
          &&TMath::Abs(idModule)!=62&&TMath::Abs(idModule)!=52) {   
-       if (nStrY==8) fx2m=1; 
-       if (nStrU==8) fx2ud=1;
+       if (nStrY==8) fX2m=1; 
+       if (nStrU==8) fX2ud=1;
       }      
     }     
     
@@ -169,10 +165,10 @@ void AliMUONTriggerCircuit::LoadXCode(){
 
 // first part : fill XMC11 XMC12 and strips 8 to 24 (middle) XMC21 XMC22
   Int_t iStripCircMT1=0, iStripCircMT2=8;
-  Int_t idModule=Module(fidCircuit);        // corresponding module Id.
+  Int_t idModule=Module(fIdCircuit);        // corresponding module Id.
 // and its number of strips
   Int_t nStrX=AliMUONTriggerConstants::NstripX(ModuleNumber(idModule)); 
-  Int_t iPosCircuit=Position(fidCircuit);   // position of circuit in module  
+  Int_t iPosCircuit=Position(fIdCircuit);   // position of circuit in module  
   Int_t sign=TMath::Abs(idModule)/idModule; // left or right 
   Int_t istrip;
 
@@ -192,7 +188,7 @@ void AliMUONTriggerCircuit::LoadXCode(){
   Int_t idModuleD, idModuleU;
   Int_t nStrD, nStrU;
 
-  idModule=Module(fidCircuit); // corresponding module Id.
+  idModule=Module(fIdCircuit); // corresponding module Id.
 // number of X strips
   nStrX=AliMUONTriggerConstants::NstripX(ModuleNumber(idModule));  
   sign=TMath::Abs(idModule)/idModule;
@@ -259,7 +255,7 @@ void AliMUONTriggerCircuit::LoadYCode(){
 // note : for Y plane fill only "central part" of circuit
 // (upper and lower parts are filled in PreHandlingY of AliMUONTriggerDecision)
     
-  Int_t idModule=Module(fidCircuit);        // corresponding module Id.
+  Int_t idModule=Module(fIdCircuit);        // corresponding module Id.
 // and its number of Y strips
   Int_t nStrY=AliMUONTriggerConstants::NstripY(ModuleNumber(idModule)); 
   Int_t sign=TMath::Abs(idModule)/idModule; // left or right 
@@ -283,7 +279,7 @@ void AliMUONTriggerCircuit::LoadYPos(){
 
   AliMUON *pMUON  = (AliMUON*)gAlice->GetModule("MUON");  
   AliMUONChamber*  iChamber;
-  AliMUONSegmentation*  segmentation;    
+  AliSegmentation*  segmentation;    
 
 // first plane (11)
   chamber=11;
@@ -297,7 +293,7 @@ void AliMUONTriggerCircuit::LoadYPos(){
     idStrip=TMath::Abs(code-idModule*100); // corresp. strip number in module
     idSector=segmentation->Sector(idModule,idStrip); // corresponding sector
     width=segmentation->Dpy(idSector);      // corresponding strip width
-    segmentation->GetPadCxy(idModule,idStrip,x,y,z); // get strip real position
+    segmentation->GetPadC(idModule,idStrip,x,y,z); // get strip real position
     
     fYpos11[2*istrip]=y;
     if (istrip!=15) fYpos11[2*istrip+1]=y+width/2.;
@@ -315,7 +311,7 @@ void AliMUONTriggerCircuit::LoadYPos(){
     idStrip=TMath::Abs(code-idModule*100); // corresp. strip number in module
     idSector=segmentation->Sector(idModule,idStrip); // corresponding sector
     width=segmentation->Dpy(idSector);      // corresponding strip width
-    segmentation->GetPadCxy(idModule,idStrip,x,y,z); // get strip real position
+    segmentation->GetPadC(idModule,idStrip,x,y,z); // get strip real position
     
 // using idModule!=0 prevents to fill garbage in case of circuits 
 // in the first and last rows 
@@ -340,27 +336,27 @@ void AliMUONTriggerCircuit::LoadXPos(){
   Int_t cathode=2;
   AliMUON *pMUON  = (AliMUON*)gAlice->GetModule("MUON");  
   AliMUONChamber*  iChamber;
-  AliMUONSegmentation*  segmentation; 
+  AliSegmentation*  segmentation; 
   iChamber = &(pMUON->Chamber(chamber-1));
   segmentation=iChamber->SegmentationModel(cathode);
   
-  Int_t idModule=Module(fidCircuit);        // corresponding module Id.  
+  Int_t idModule=Module(fIdCircuit);        // corresponding module Id.  
 // number of Y strips
   Int_t nStrY=AliMUONTriggerConstants::NstripY(ModuleNumber(idModule)); 
   Int_t idSector=segmentation->Sector(idModule,0); // corresp. sector
   Float_t width=segmentation->Dpx(idSector);      // corresponding strip width
   
 // first case : up middle and down parts have all 8 or 16 strip 
-  if ((nStrY==16)||(nStrY==8&&fx2m==0&&fx2ud==0)) { 
+  if ((nStrY==16)||(nStrY==8&&fX2m==0&&fX2ud==0)) { 
     for (istrip=0; istrip<nStrY; istrip++) {
-      segmentation->GetPadCxy(idModule,istrip,x,y,z); 
+      segmentation->GetPadC(idModule,istrip,x,y,z); 
       fXpos11[istrip]=x;
     }
 // second case : mixing 8 and 16 strips within same circuit      
   } else {
     for (istrip=0; istrip<nStrY; istrip++) {
-      if (nStrY!=8) { cout << " bug in LoadXpos " << "\n";}
-      segmentation->GetPadCxy(idModule,istrip,x,y,z); 
+      if (nStrY!=8) { printf(" bug in LoadXpos \n");}
+      segmentation->GetPadC(idModule,istrip,x,y,z); 
       fXpos11[2*istrip]=x-width/4.;
       fXpos11[2*istrip+1]=fXpos11[2*istrip]+width/2.;
     }
@@ -391,39 +387,39 @@ Float_t AliMUONTriggerCircuit::PtCal(Int_t istripX, Int_t idev, Int_t istripY){
 //----------------------------------------------------------------------
 Int_t AliMUONTriggerCircuit::GetIdCircuit(){ 
 // returns circuit Id
-  return fidCircuit;
+  return fIdCircuit;
 }
 //----------------------------------------------------------------------
 Int_t AliMUONTriggerCircuit::GetIdModule(){ 
 // returns module Id
-  return Module(fidCircuit);
+  return Module(fIdCircuit);
 }
 //----------------------------------------------------------------------
 Int_t AliMUONTriggerCircuit::GetNstripX() { 
 // returns the number of X strips in the module where the circuit is sitting
-  return AliMUONTriggerConstants::NstripX(ModuleNumber(Module(fidCircuit)));
+  return AliMUONTriggerConstants::NstripX(ModuleNumber(Module(fIdCircuit)));
 }
 //----------------------------------------------------------------------
 Int_t AliMUONTriggerCircuit::GetNstripY() { 
 // returns the number of Y strips in the module where the circuit is sitting
-  return AliMUONTriggerConstants::NstripY(ModuleNumber(Module(fidCircuit)));
+  return AliMUONTriggerConstants::NstripY(ModuleNumber(Module(fIdCircuit)));
 }
 //----------------------------------------------------------------------
 Int_t AliMUONTriggerCircuit::GetPosCircuit() { 
 // returns the position of the circuit in its module
-  return Position(fidCircuit);
+  return Position(fIdCircuit);
 }
 //----------------------------------------------------------------------
 Int_t AliMUONTriggerCircuit::GetIdCircuitD(){
 // returns the Id of the circuit down 
-  Int_t idModule=Module(fidCircuit);
+  Int_t idModule=Module(fIdCircuit);
   Int_t idModuleD=(TMath::Abs(idModule)+10)*(TMath::Abs(idModule)/idModule); 
   return (TMath::Abs(idModuleD)*10+1)*(TMath::Abs(idModule)/idModule);
 }
 //----------------------------------------------------------------------
 Int_t AliMUONTriggerCircuit::GetICircuitD(){
 // returns the number of the circuit down 
-  Int_t idModule=Module(fidCircuit);
+  Int_t idModule=Module(fIdCircuit);
   Int_t idModuleD=(TMath::Abs(idModule)+10)*(TMath::Abs(idModule)/idModule); 
   Int_t idCircuitD=
     (TMath::Abs(idModuleD)*10+1)*(TMath::Abs(idModule)/idModule);
@@ -432,14 +428,14 @@ Int_t AliMUONTriggerCircuit::GetICircuitD(){
 //----------------------------------------------------------------------
 Int_t AliMUONTriggerCircuit::GetIdCircuitU(){
 // returns the Id of the circuit up 
-  Int_t idModule=Module(fidCircuit);
+  Int_t idModule=Module(fIdCircuit);
   Int_t idModuleU=(TMath::Abs(idModule)-10)*(TMath::Abs(idModule)/idModule); 
   return (TMath::Abs(idModuleU)*10+1)*(TMath::Abs(idModule)/idModule);
 }
 //----------------------------------------------------------------------
 Int_t AliMUONTriggerCircuit::GetICircuitU(){
 // returns the number of the circuit up 
-  Int_t idModule=Module(fidCircuit);
+  Int_t idModule=Module(fIdCircuit);
   Int_t idModuleU=(TMath::Abs(idModule)-10)*(TMath::Abs(idModule)/idModule); 
   Int_t idCircuitU=
     (TMath::Abs(idModuleU)*10+1)*(TMath::Abs(idModule)/idModule);
@@ -447,13 +443,13 @@ Int_t AliMUONTriggerCircuit::GetICircuitU(){
 }
 //----------------------------------------------------------------------
 Int_t AliMUONTriggerCircuit::GetX2m(){ 
-// returns fx2m
-  return fx2m;
+// returns fX2m
+  return fX2m;
 }
 //----------------------------------------------------------------------
 Int_t AliMUONTriggerCircuit::GetX2ud(){ 
-// returns fx2ud
-  return fx2ud;
+// returns fX2ud
+  return fX2ud;
 }
 //----------------------------------------------------------------------
 void AliMUONTriggerCircuit::GetOrMud(Int_t orMud[2]){