Removing circular dependences, work in progress (Ch. Finck)
authorcussonno <cussonno@f7af4fe6-9843-0410-8265-dc069ae4e863>
Mon, 20 Dec 2004 10:44:05 +0000 (10:44 +0000)
committercussonno <cussonno@f7af4fe6-9843-0410-8265-dc069ae4e863>
Mon, 20 Dec 2004 10:44:05 +0000 (10:44 +0000)
27 files changed:
MUON/AliMUON.h
MUON/AliMUONChamber.cxx
MUON/AliMUONChamber.h
MUON/AliMUONClusterFinderVS.cxx
MUON/AliMUONClusterInput.cxx
MUON/AliMUONClusterInput.h
MUON/AliMUONClusterReconstructor.cxx
MUON/AliMUONClusterReconstructor.h
MUON/AliMUONConstants.cxx
MUON/AliMUONConstants.h
MUON/AliMUONDisplay.cxx
MUON/AliMUONEventReconstructor.cxx
MUON/AliMUONMathieson.cxx [new file with mode: 0644]
MUON/AliMUONMathieson.h [new file with mode: 0644]
MUON/AliMUONReconstructor.cxx
MUON/AliMUONResponse.h
MUON/AliMUONResponseTrigger.cxx
MUON/AliMUONResponseTrigger.h
MUON/AliMUONTriggerDecision.cxx
MUON/AliMUONTriggerDecision.h
MUON/MUONbaseLinkDef.h
MUON/MUONrecLinkDef.h
MUON/MUONsimLinkDef.h
MUON/libMUONbase.pkg
MUON/libMUONrec.pkg
MUON/libMUONsim.pkg
MUON/loadlibs.C [new file with mode: 0644]

index acbd025..024e3d6 100644 (file)
@@ -152,7 +152,7 @@ class AliMUON : public  AliDetector
     // Background eent for event mixing
     AliMUONMerger *fMerger;   // ! pointer to merger
     
-    ClassDef(AliMUON,5)  // MUON Detector base class
+    ClassDef(AliMUON,7)  // MUON Detector base class
 };
 #endif
 
index a934819..31e48dc 100644 (file)
@@ -37,7 +37,6 @@ AliMUONChamber::AliMUONChamber()
     frMax(0.),
     fCurrentCorrel(1), // to avoid mistakes if ChargeCorrelInit is not called
     fSegmentation(0),
-    fReconstruction(0),
     fResponse(0),
     fGeometry(0)
 {
@@ -55,7 +54,6 @@ AliMUONChamber::AliMUONChamber(Int_t id)
     frMax(0.),
     fCurrentCorrel(1), // to avoid mistakes if ChargeCorrelInit is not called
     fSegmentation(0),
-    fReconstruction(0),
     fResponse(0),
     fGeometry(0)
 {
index a8e5627..95ed3e9 100644 (file)
@@ -53,10 +53,6 @@ class AliMUONChamber : public TObject
   virtual void    SetSegmentationModel(Int_t i, AliSegmentation* thisSegmentation) {
       fSegmentation->AddAt(thisSegmentation,i-1);
   }
-// Set Cluster reconstruction model  
-  virtual void    SetReconstructionModel(AliMUONClusterFinderVS *thisReconstruction) {
-      fReconstruction = thisReconstruction;
-  }
 //  
 //  Get pointer to response model
   virtual AliMUONResponse* &ResponseModel(){return fResponse;}
@@ -66,8 +62,7 @@ class AliMUONChamber : public TObject
       return (AliSegmentation *) (*fSegmentation)[isec-1];
   }
   virtual TObjArray* ChamberSegmentation() {return fSegmentation;}
-//  Get pointer to cluster reconstruction model
-  virtual AliMUONClusterFinderVS* &ReconstructionModel(){return fReconstruction;}
+
 // Get number of segmentation sectors  
   virtual Int_t Nsec() const        {return fnsec;}
 // Set number of segmented cathodes (1 or 2)  
@@ -136,7 +131,6 @@ class AliMUONChamber : public TObject
   Float_t fCurrentCorrel; //! charge correlation for current hit.
 
   TObjArray              *fSegmentation;    // pointer to segmentation
-  AliMUONClusterFinderVS *fReconstruction;  // pointer to reconstruction
   AliMUONResponse        *fResponse;        // pointer to response
   AliMUONGeometryModule  *fGeometry;        // pointer to geometry
   ClassDef(AliMUONChamber,3) // Muon tracking chamber class
index a2c713a..b196c3d 100644 (file)
@@ -22,7 +22,7 @@
 #include "AliMUONDigit.h"
 #include "AliMUONRawCluster.h"
 #include "AliSegmentation.h"
-#include "AliMUONResponse.h"
+#include "AliMUONMathieson.h"
 #include "AliMUONClusterInput.h"
 #include "AliMUONHitMapA1.h"
 #include "AliLog.h"
@@ -558,20 +558,20 @@ void AliMUONClusterFinderVS::SplitByLocalMaxima(AliMUONRawCluster *c)
 
            chi2f = (TMath::Log(fInput->TotalCharge(0)*fQrFit[0]
                  /  (fInput->TotalCharge(1)*fQrFit[1]) )
-                 / fInput->Response()->ChargeCorrel() );
+                 / fInput->ChargeCorrel() );
            chi2f *=chi2f;
            chi2fi = (TMath::Log(fInput->TotalCharge(0)*(1-fQrFit[0])
                  /  (fInput->TotalCharge(1)*(1-fQrFit[1])) )
-                 / fInput->Response()->ChargeCorrel() );
+                 / fInput->ChargeCorrel() );
            chi2f += chi2fi*chi2fi;
 
            chi2s = (TMath::Log(fInput->TotalCharge(0)*sQrFit[0]
                  /  (fInput->TotalCharge(1)*sQrFit[1]) )
-                 / fInput->Response()->ChargeCorrel() );
+                 / fInput->ChargeCorrel() );
            chi2s *=chi2s;
            chi2si = (TMath::Log(fInput->TotalCharge(0)*(1-sQrFit[0])
                  /  (fInput->TotalCharge(1)*(1-sQrFit[1])) )
-                 / fInput->Response()->ChargeCorrel() );
+                 / fInput->ChargeCorrel() );
            chi2s += chi2si*chi2si;
 
            // usefull to store the charge matching chi2 in the cluster
@@ -1963,7 +1963,7 @@ void AliMUONClusterFinderVS::Split(AliMUONRawCluster* c)
            for (i=0; i<fMul[cath]; i++) {
                cnew.SetIndex(cnew.GetMultiplicity(cath), cath, c->GetIndex(i,cath));
                fSeg[cath]->SetPad(fIx[i][cath], fIy[i][cath]);
-               Float_t q1=fInput->Response()->IntXY(fSeg[cath]);
+               Float_t q1 = fInput->Mathieson()->IntXY(fSeg[cath]);
                cnew.SetContrib(i, cath, q1*Float_t(cnew.GetCharge(cath))/Float_t(fQ[i][cath]));
                cnew.SetMultiplicity(cath, cnew.GetMultiplicity(cath)+1 );
            }
index 60bbf5c..f68d3c4 100644 (file)
@@ -21,8 +21,9 @@
 #include "AliRun.h"
 #include "AliMUON.h"
 #include "AliMUONChamber.h"
+#include "AliMUONConstants.h"
 #include "AliMUONClusterInput.h"
-#include "AliMUONResponse.h"
+#include "AliMUONMathieson.h"
 #include "AliMUONRawCluster.h"
 #include "AliMUONDigit.h"
 #include "AliLog.h"
@@ -31,18 +32,18 @@ ClassImp(AliMUONClusterInput)
 
 AliMUONClusterInput* AliMUONClusterInput::fgClusterInput = 0; 
 TMinuit* AliMUONClusterInput::fgMinuit = 0; 
+AliMUONMathieson* AliMUONClusterInput::fgMathieson = 0; 
 
 AliMUONClusterInput::AliMUONClusterInput()
-  : TObject()
+  : TObject(),
+    fCluster(0),
+    fChargeCorrel(1.) // in case not defined
+
 {
-  fgClusterInput = 0; 
-  fgMinuit = 0; 
   fDigits[0]=0;
   fDigits[1]=0;
   fSegmentation[0]=0;
   fSegmentation[1]=0;
-  fResponse=0;
-  fCluster=0;
 }
 
 AliMUONClusterInput* AliMUONClusterInput::Instance()
@@ -60,6 +61,7 @@ AliMUONClusterInput::~AliMUONClusterInput()
 {
 // Destructor
     delete fgMinuit;
+    delete fgMathieson;
 }
 
 AliMUONClusterInput::AliMUONClusterInput(const AliMUONClusterInput& clusterInput):TObject(clusterInput)
@@ -84,10 +86,23 @@ void AliMUONClusterInput::SetDigits(Int_t chamber, TClonesArray* dig1, TClonesAr
     pMUON = (AliMUON*) gAlice->GetModule("MUON");
     iChamber =  &(pMUON->Chamber(chamber));
 
+    fgMathieson = new AliMUONMathieson();
     fSegmentation[0]=iChamber->SegmentationModel(1);
     fSegmentation[1]=iChamber->SegmentationModel(2);
-    fResponse=iChamber->ResponseModel();
     fNseg = 2;
+    if (chamber < AliMUONConstants::NTrackingCh()) {
+      if (chamber > 3 ) {
+       fgMathieson->SetPitch(AliMUONConstants::PitchSlat());
+       fgMathieson->SetSqrtKx3AndDeriveKx2Kx4(AliMUONConstants::SqrtKx3Slat());
+       fgMathieson->SetSqrtKy3AndDeriveKy2Ky4(AliMUONConstants::SqrtKy3Slat());
+       fChargeCorrel = AliMUONConstants::ChargeCorrelSlat();
+      } else {
+       fgMathieson->SetPitch(AliMUONConstants::PitchSt12());
+       fgMathieson->SetSqrtKx3AndDeriveKx2Kx4(AliMUONConstants::SqrtKx3St12());
+       fgMathieson->SetSqrtKy3AndDeriveKy2Ky4(AliMUONConstants::SqrtKy3St12());
+       fChargeCorrel = AliMUONConstants::ChargeCorrelSt12();
+      }
+    }
 }
 
 void AliMUONClusterInput::SetDigits(Int_t chamber, TClonesArray* dig)
@@ -101,7 +116,6 @@ void AliMUONClusterInput::SetDigits(Int_t chamber, TClonesArray* dig)
     iChamber =  &(pMUON->Chamber(chamber));
 
     fSegmentation[0]=iChamber->SegmentationModel(1);
-    fResponse=iChamber->ResponseModel();
     fNseg=1;
 }
 
@@ -160,7 +174,7 @@ Float_t AliMUONClusterInput::DiscrChargeCombiS1(Int_t i,Double_t *par, Int_t cat
    fSegmentation[cath]->SetPad(fix[i][cath], fiy[i][cath]);
 //  First Cluster
    fSegmentation[cath]->SetHit(par[0],par[1],fZ);
-   Float_t q1=fResponse->IntXY(fSegmentation[cath]);
+   Float_t q1=fgMathieson->IntXY(fSegmentation[cath]);
     
    Float_t value = fQtot[cath]*q1;
    return value;
@@ -179,11 +193,11 @@ Float_t AliMUONClusterInput::DiscrChargeS2(Int_t i,Double_t *par)
    fSegmentation[0]->SetPad(fix[i][0], fiy[i][0]);
 //  First Cluster
    fSegmentation[0]->SetHit(par[0],par[1],fZ);
-   Float_t q1=fResponse->IntXY(fSegmentation[0]);
+   Float_t q1=fgMathieson->IntXY(fSegmentation[0]);
     
 //  Second Cluster
    fSegmentation[0]->SetHit(par[2],par[3],fZ);
-   Float_t q2=fResponse->IntXY(fSegmentation[0]);
+   Float_t q2=fgMathieson->IntXY(fSegmentation[0]);
     
    Float_t value = fQtot[0]*(par[4]*q1+(1.-par[4])*q2);
    return value;
@@ -202,11 +216,11 @@ Float_t AliMUONClusterInput::DiscrChargeCombiS2(Int_t i,Double_t *par, Int_t cat
    fSegmentation[cath]->SetPad(fix[i][cath], fiy[i][cath]);
 //  First Cluster
    fSegmentation[cath]->SetHit(par[0],par[1],fZ);
-   Float_t q1=fResponse->IntXY(fSegmentation[cath]);
+   Float_t q1=fgMathieson->IntXY(fSegmentation[cath]);
     
 //  Second Cluster
    fSegmentation[cath]->SetHit(par[2],par[3],fZ);
-   Float_t q2=fResponse->IntXY(fSegmentation[cath]);
+   Float_t q2=fgMathieson->IntXY(fSegmentation[cath]);
    Float_t value;
    if (cath==0) {
        value = fQtot[0]*(par[4]*q1+(1.-par[4])*q2);
index b17e11c..dddfdb8 100644 (file)
@@ -14,7 +14,7 @@ class TMinuit;
 class AliMUONDigit;
 class AliMUONRawCluster;
 class AliSegmentation;
-class AliMUONResponse;
+class AliMUONMathieson;
 
 class AliMUONClusterInput : public TObject 
 {
@@ -31,7 +31,9 @@ class AliMUONClusterInput : public TObject
     TClonesArray* Digits(Int_t cath) const {return fDigits[cath];}
     Int_t NDigits(Int_t cath) const {return fNDigits[cath];}
     AliSegmentation* Segmentation(Int_t cath) const {return fSegmentation[cath];}
-    AliMUONResponse* Response() const {return fResponse;}    
+    AliMUONMathieson* Mathieson() const {return fgMathieson;}    
+    Float_t ChargeCorrel() const {return fChargeCorrel;}    
+
 // Fitting    
     TMinuit*      Fitter() const {return fgMinuit;}
 // Current cluster information    
@@ -52,11 +54,12 @@ class AliMUONClusterInput : public TObject
     AliMUONClusterInput & operator = (const AliMUONClusterInput& rhs);
  private:
     static AliMUONClusterInput* fgClusterInput; // ! singleton instance
+    static AliMUONMathieson*    fgMathieson;     // ! Mathieson
+
     // Digits
     TClonesArray*        fDigits[2];       // ! Array of pointers to digits
     Int_t                fNDigits[2];      // ! Number of digits
     AliSegmentation*     fSegmentation[2]; // ! Segmentation per cathode
-    AliMUONResponse*     fResponse;        // ! Response
     Int_t                fNseg;            // ! number of cathode planes
     Int_t                fChamber;         // ! Current chamber number
     
@@ -70,6 +73,8 @@ class AliMUONClusterInput : public TObject
     Int_t                fChargeTot[2];    // ! Total charge
     Float_t              fQtot[2];         // ! Total charge
     Float_t              fZ;               // ! Current z-position
+    Float_t              fChargeCorrel;    // ! charge correlation 
+
     // Fitter
     static TMinuit*      fgMinuit;          // ! Fitter
     ClassDef(AliMUONClusterInput, 0)        // Global data service for hit reconstruction
index 9abd297..71c17ec 100644 (file)
@@ -27,7 +27,6 @@
 #include "AliRunLoader.h"
 #include "AliLoader.h"
 
-#include "AliMUON.h"
 #include "AliMUONDigit.h"
 #include "AliMUONConstants.h"
 #include "AliMUONData.h"
@@ -44,18 +43,12 @@ ClassImp(AliMUONClusterReconstructor) // Class implementation in ROOT context
 
 //__________________________________________________________________________
 AliMUONClusterReconstructor::AliMUONClusterReconstructor(AliLoader* loader)
-  : TObject()
+  : TObject(),
+    fMUONData(0),
+    fPrintLevel(fgkDefaultPrintLevel),
+    fDebug(0)
 {
   // Standard Constructor
-  fDebug           = 0;
-  fNCh             = 0;
-  fNTrackingCh     = 0;
-  fChambers        = 0;
-  fMUONData        = 0;
-  fChambers = new TObjArray(AliMUONConstants::NCh());
-
-  fPrintLevel = fgkDefaultPrintLevel;
 
   // initialize loader's
   fLoader = loader;
@@ -63,23 +56,16 @@ AliMUONClusterReconstructor::AliMUONClusterReconstructor(AliLoader* loader)
   // initialize container
   fMUONData  = new AliMUONData(fLoader,"MUON","MUON");
 
-  // Loading AliRun master
-  AliRunLoader* runloader = fLoader->GetRunLoader();
-  if (runloader->GetAliRun() == 0x0) runloader->LoadgAlice();
-  gAlice = runloader->GetAliRun();
+  // reconstruction model
+  fRecModel = new AliMUONClusterFinderVS();
+  //fRecModel = new AliMUONClusterFinderAZ();
 
-  // getting MUON
-  fMUON = (AliMUON*) gAlice->GetDetector("MUON");
 }
 
 //__________________________________________________________________________
 AliMUONClusterReconstructor::AliMUONClusterReconstructor()
   : TObject(),
-    fNCh(0),
-    fNTrackingCh(0),
     fMUONData(0),
-    fMUON(0),
-    fChambers(0),
     fPrintLevel(fgkDefaultPrintLevel),
     fDebug(0),
     fLoader(0)
@@ -87,18 +73,6 @@ AliMUONClusterReconstructor::AliMUONClusterReconstructor()
   // Default Constructor
 }
 
-//____________________________________________________________________
-void AliMUONClusterReconstructor::SetReconstructionModel(Int_t id, AliMUONClusterFinderVS *reconst)
-{
-  // take infos chambers from AliMUON
-  AliMUONChamber* pCh = 0;
-  pCh = &(fMUON->Chamber(id));
-
-  fChambers->AddAt(pCh, id);
-
-  // Set ClusterFinder for chamber id
-  ((AliMUONChamber*) fChambers->At(id))->SetReconstructionModel(reconst);
-}
 //_______________________________________________________________________
 AliMUONClusterReconstructor::AliMUONClusterReconstructor (const AliMUONClusterReconstructor& rhs)
   : TObject(rhs)
@@ -124,10 +98,7 @@ AliMUONClusterReconstructor::operator=(const AliMUONClusterReconstructor& rhs)
 //__________________________________________________________________________
 AliMUONClusterReconstructor::~AliMUONClusterReconstructor(void)
 {
-  if (fChambers){
-    fChambers->Clear(); // Sets pointers to 0 sinche it is not the owner
-    delete fChambers;
-  } 
+
   if (fMUONData)
     delete fMUONData;
 
@@ -144,15 +115,11 @@ void AliMUONClusterReconstructor::Digits2Clusters()
     dig1 = new TClonesArray("AliMUONDigit",1000);
     dig2 = new TClonesArray("AliMUONDigit",1000);
     AliMUONDigit *digit;
-// Loop on chambers and on cathode planes
-//
-//    fMUONData->ResetRawClusters();        
+
+// Loop on chambers and on cathode planes     
     TClonesArray * muonDigits;
 
     for (Int_t ich = 0; ich < 10; ich++) {
-       AliMUONChamber* iChamber = (AliMUONChamber*) fChambers->At(ich);
-       AliMUONClusterFinderVS* rec = iChamber->ReconstructionModel();
-       //AliMUONClusterFinderAZ* rec = (AliMUONClusterFinderAZ*)iChamber->ReconstructionModel();
 
        fMUONData->ResetDigits();
        fMUONData->GetCathode(0);
@@ -164,7 +131,7 @@ void AliMUONClusterReconstructor::Digits2Clusters()
        Int_t n = 0;
        for (k = 0; k < ndig; k++) {
            digit = (AliMUONDigit*) muonDigits->UncheckedAt(k);
-           if (rec->TestTrack(digit->Track(0)))
+           if (fRecModel->TestTrack(digit->Track(0)))
              new(lhits1[n++]) AliMUONDigit(*digit);
        }
        fMUONData->ResetDigits();
@@ -177,16 +144,16 @@ void AliMUONClusterReconstructor::Digits2Clusters()
        
        for (k=0; k<ndig; k++) {
            digit= (AliMUONDigit*) muonDigits->UncheckedAt(k);
-           if (rec->TestTrack(digit->Track(0)))
+           if (fRecModel->TestTrack(digit->Track(0)))
              new(lhits2[n++]) AliMUONDigit(*digit);
        }
 
-       if (rec) {       
+       if (fRecModel) {         
            AliMUONClusterInput::Instance()->SetDigits(ich, dig1, dig2);
-           rec->FindRawClusters();
+           fRecModel->FindRawClusters();
        }
        // copy into the container
-       TClonesArray* tmp = rec->GetRawClusters();
+       TClonesArray* tmp = fRecModel->GetRawClusters();
        for (Int_t id = 0; id < tmp->GetEntriesFast(); id++) {
          AliMUONRawCluster* pClus = (AliMUONRawCluster*) tmp->At(id);
          fMUONData->AddRawCluster(ich, *pClus);
@@ -206,3 +173,19 @@ void AliMUONClusterReconstructor::Digits2Clusters(AliRawReader* /*rawReader*/)
 
    AliFatal("clusterization not implemented for raw data input");
 }
+//_______________________________________________________________________
+void AliMUONClusterReconstructor::Trigger2Trigger() 
+{
+// copy trigger from TreeD to TreeR
+
+  fMUONData->SetTreeAddress("GLT");
+  fMUONData->GetTriggerD();
+}
+//_______________________________________________________________________
+void AliMUONClusterReconstructor::Trigger2Trigger(AliRawReader* /*rawReader*/) 
+{
+// call the Trigger Algorithm from raw data and fill TreeR 
+
+   AliFatal("Trigger not implemented for raw data input");
+
+}
index 08818a3..cd93836 100644 (file)
@@ -14,7 +14,6 @@
 
 class AliLoader;
 class AliMUON;
-class AliMUONChamber;
 class AliMUONRawCluster;
 class AliMUONClusterFinderVS;
 class AliMUONData;
@@ -32,15 +31,19 @@ class AliMUONClusterReconstructor : public TObject
   // Cluster Finding & Trigger
   virtual void   Digits2Clusters();
   virtual void   Digits2Clusters(AliRawReader* rawReader);
+  virtual void   Trigger2Trigger() ;
+  virtual void   Trigger2Trigger(AliRawReader* rawReader);
 
-
-  // void EventDump(void);  // dump reconstructed event
-  
-  // Set Reconstruction Model
-  virtual void   SetReconstructionModel(Int_t id, AliMUONClusterFinderVS* reconst);
+  // pointer to data container
   AliMUONData*   GetMUONData() {return fMUONData;}
 
+  // Reco Model
+  AliMUONClusterFinderVS* GetRecoModel() {return fRecModel;}
+  //  AliMUONClusterFinderAZ* GetRecoModel() {return fRecModel;}
+  void   SetRecoModel(AliMUONClusterFinderVS* rec) {fRecModel = rec;}
+  //  void   SetRecoModel(AliMUONClusterFinderAZ* rec) {fRecModel = rec;}
+
+  // print level
   Int_t GetPrintLevel(void) const {return fPrintLevel;}
   void SetPrintLevel(Int_t printLevel) {fPrintLevel = printLevel;}
 
@@ -52,11 +55,9 @@ class AliMUONClusterReconstructor : public TObject
  private:
   static const Int_t fgkDefaultPrintLevel;     // Default print level
 
-  Int_t                   fNCh;                // Number of chambers   
-  Int_t                   fNTrackingCh;        // Number of tracking chambers*
   AliMUONData*            fMUONData;           //! Data container for MUON subsystem 
-  AliMUON*                fMUON;               //! pointer to MUON  
-  TObjArray*              fChambers;           //! List of Tracking Chambers
+  AliMUONClusterFinderVS* fRecModel;           //! cluster recontruction model
+  //AliMUONClusterFinderAZ* fRecModel;           //! cluster recontruction model
 
  // print level
   Int_t fPrintLevel;
index 991ff14..888901c 100644 (file)
@@ -33,6 +33,17 @@ Float_t AliMUONConstants::fgDefaultChamberZ[14] =
 Float_t  AliMUONConstants::fgDzCh   = 15.5/2.;
 Float_t  AliMUONConstants::fgDzSlat = 8.5/2.;
 
+Float_t  AliMUONConstants::fgSqrtKx3Slat = 0.7131;
+Float_t  AliMUONConstants::fgSqrtKy3Slat = 0.7642;
+
+Float_t  AliMUONConstants::fgSqrtKx3St12 = 0.7000;
+Float_t  AliMUONConstants::fgSqrtKy3St12 = 0.7550;
+
+Float_t  AliMUONConstants::fgChargeCorrelSlat = 0.11;
+Float_t  AliMUONConstants::fgChargeCorrelSt12 = 0.0; //???
+
+Float_t  AliMUONConstants::fgPitchSlat = 0.25;
+Float_t  AliMUONConstants::fgPitchSt12 = 0.20; 
 
 Float_t  AliMUONConstants::fgDmin[7] = {  36.4,  46.2,  66.0,   80.,   80., 100., 100.};    
 Float_t  AliMUONConstants::fgDmax[7]  = {183., 245., 395.,  560.,  563., 850., 900.};  
index 602a672..15f771f 100644 (file)
@@ -33,6 +33,18 @@ class AliMUONConstants : public TObject {
     // return half-distance between two slats
     static Float_t    DzSlat() {return fgDzSlat;}
     static  Int_t ChamberNumber(Float_t z); 
+    // return SqrtKx3 and SqrtKy3 for Slat
+    static Float_t SqrtKx3Slat() {return fgSqrtKx3Slat;}
+    static Float_t SqrtKy3Slat() {return fgSqrtKy3Slat;}
+    // return SqrtKx3 and SqrtKy3 for Station 1 & 2
+    static Float_t SqrtKx3St12() {return fgSqrtKx3St12;}
+    static Float_t SqrtKy3St12() {return fgSqrtKy3St12;}
+       // return charge correlation (needed for response and for cluster finder !?)
+    static Float_t ChargeCorrelSlat() {return fgChargeCorrelSlat;}
+    static Float_t ChargeCorrelSt12() {return fgChargeCorrelSt12;}
+     // return wire pitch
+    static Float_t PitchSlat() {return fgPitchSlat;}
+    static Float_t PitchSt12() {return fgPitchSt12;}
 
  protected:
     AliMUONConstants() : TObject() {}
@@ -50,6 +62,16 @@ class AliMUONConstants : public TObject {
 
     static Float_t  fgDzCh;             // half-distance between two half-chambers 
     static Float_t  fgDzSlat;           // half-distance between two slat on the same chamber
+    static Float_t  fgSqrtKx3Slat;      // SqrtKx3 for Slat
+    static Float_t  fgSqrtKy3Slat;      // SqrtKy3 for Slat
+    static Float_t  fgSqrtKx3St12;      // SqrtKx3 for Station 1 & 2
+    static Float_t  fgSqrtKy3St12;      // SqrtKy3 for Station 1 & 2
+    static Float_t  fgChargeCorrelSlat;      // charge correlation for Slats
+    static Float_t  fgChargeCorrelSt12;      // charge correlation for Station 1 & 2
+
+    static Float_t  fgPitchSlat;      // wire pitch for Slats
+    static Float_t  fgPitchSt12;      // wire pitch for Station 1 & 2
 
 //
     static Int_t    fgMaxZoom;                // Maximum Zoom for event display
index 00d26bd..df8f7a1 100644 (file)
@@ -55,7 +55,6 @@
 #include "AliMUONTrackParam.h"
 
 #include "AliSegmentation.h"
-#include "AliMUONResponse.h"
 #include "AliMUONChamber.h"
 #include "AliMUONConstants.h"
 #include "AliMC.h"
@@ -424,11 +423,9 @@ void AliMUONDisplay::DisplayColorScale()
     text->SetTextSize(0.2);
     text->SetTextAlign(22);
     
-    AliMUON *pMUON  = (AliMUON*)gAlice->GetModule("MUON");
-    AliMUONChamber *iChamber = &(pMUON->Chamber(fChamber-1));
-    AliMUONResponse * response=iChamber->ResponseModel();
-    Int_t adcmax=1024;
-    if (response) adcmax = (Int_t) response->MaxAdc();
+
+    Int_t adcmax=4096; // default 12 bits ADC
+
     
 
     TBox *box;
@@ -923,7 +920,6 @@ void AliMUONDisplay::LoadDigits(Int_t chamber, Int_t cathode)
     AliMUON *pMUON  =     (AliMUON*)gAlice->GetModule("MUON");
     AliMUONChamber*       iChamber;
     AliSegmentation*      segmentation;
-    AliMUONResponse*      response;
    
     GetMUONData()->SetTreeAddress("D");
 
@@ -946,7 +942,6 @@ void AliMUONDisplay::LoadDigits(Int_t chamber, Int_t cathode)
     iChamber = &(pMUON->Chamber(chamber-1));
 
     segmentation = iChamber->SegmentationModel(cathode);
-    response     = iChamber->ResponseModel();
     Float_t zpos = iChamber->Z();
 
     AliMUONDigit  *mdig;
@@ -956,8 +951,8 @@ void AliMUONDisplay::LoadDigits(Int_t chamber, Int_t cathode)
     //loop over all digits and store their position
     
     Int_t npoints  = 1;
-    Float_t adcmax = 1024;
-    if (response&&chamber<11) adcmax = response->MaxAdc();
+    Float_t adcmax = 1024; // default
+    if (chamber<11) adcmax = 4096;
 
     for (Int_t digit = 0; digit < ndigits; digit++) {
         mdig    = (AliMUONDigit*)muonDigits->UncheckedAt(digit);
index 8ecd49a..64eb0af 100644 (file)
@@ -149,11 +149,6 @@ AliMUONEventReconstructor::AliMUONEventReconstructor(AliLoader* loader)
   // initialize container
   fMUONData  = new AliMUONData(fLoader,"MUON","MUON");
 
-   // Loading AliRun master
-  AliRunLoader* runloader = fLoader->GetRunLoader();
-  if (runloader->GetAliRun() == 0x0) runloader->LoadgAlice();
-  gAlice = runloader->GetAliRun();
-
   return;
 }
   //__________________________________________________________________________
diff --git a/MUON/AliMUONMathieson.cxx b/MUON/AliMUONMathieson.cxx
new file mode 100644 (file)
index 0000000..bbd2639
--- /dev/null
@@ -0,0 +1,97 @@
+/**************************************************************************
+ * 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$ */
+
+#include <TMath.h>
+#include <TRandom.h>
+
+#include "AliMUONMathieson.h"
+#include "AliSegmentation.h"
+
+
+ClassImp(AliMUONMathieson)
+       
+//__________________________________________________________________________
+AliMUONMathieson::AliMUONMathieson() 
+{
+// Default constructor
+
+}
+
+  //__________________________________________________________________________
+void AliMUONMathieson::SetSqrtKx3AndDeriveKx2Kx4(Float_t SqrtKx3)
+{
+  // Set to "SqrtKx3" the Mathieson parameter K3 ("fSqrtKx3")
+  // in the X direction, perpendicular to the wires,
+  // and derive the Mathieson parameters K2 ("fKx2") and K4 ("fKx4")
+  // in the same direction
+  fSqrtKx3 = SqrtKx3;
+  fKx2 = TMath::Pi() / 2. * (1. - 0.5 * fSqrtKx3);
+  Float_t cx1 = fKx2 * fSqrtKx3 / 4. / TMath::ATan(Double_t(fSqrtKx3));
+  fKx4 = cx1 / fKx2 / fSqrtKx3;
+}
+       
+  //__________________________________________________________________________
+void AliMUONMathieson::SetSqrtKy3AndDeriveKy2Ky4(Float_t SqrtKy3)
+{
+  // Set to "SqrtKy3" the Mathieson parameter K3 ("fSqrtKy3")
+  // in the Y direction, along the wires,
+  // and derive the Mathieson parameters K2 ("fKy2") and K4 ("fKy4")
+  // in the same direction
+  fSqrtKy3 = SqrtKy3;
+  fKy2 = TMath::Pi() / 2. * (1. - 0.5 * fSqrtKy3);
+  Float_t cy1 = fKy2 * fSqrtKy3 / 4. / TMath::ATan(Double_t(fSqrtKy3));
+  fKy4 = cy1 / fKy2 / fSqrtKy3;
+}
+
+// -------------------------------------------
+
+Float_t AliMUONMathieson::IntXY(AliSegmentation * segmentation)
+{
+// Calculate charge on current pad according to Mathieson distribution
+// 
+    const Float_t kInversePitch = 1/fPitch;
+//
+//  Integration limits defined by segmentation model
+//  
+    Float_t xi1, xi2, yi1, yi2;
+    segmentation->IntegrationLimits(xi1,xi2,yi1,yi2);
+    xi1=xi1*kInversePitch;
+    xi2=xi2*kInversePitch;
+    yi1=yi1*kInversePitch;
+    yi2=yi2*kInversePitch;
+//
+// The Mathieson function 
+    Double_t ux1=fSqrtKx3*TMath::TanH(fKx2*xi1);
+    Double_t ux2=fSqrtKx3*TMath::TanH(fKx2*xi2);
+
+    Double_t uy1=fSqrtKy3*TMath::TanH(fKy2*yi1);
+    Double_t uy2=fSqrtKy3*TMath::TanH(fKy2*yi2);
+
+    
+    return Float_t(4.*fKx4*(TMath::ATan(ux2)-TMath::ATan(ux1))*
+                     fKy4*(TMath::ATan(uy2)-TMath::ATan(uy1)));
+}
+
+
+
+
+
+
+
+
+
+
diff --git a/MUON/AliMUONMathieson.h b/MUON/AliMUONMathieson.h
new file mode 100644 (file)
index 0000000..044782b
--- /dev/null
@@ -0,0 +1,64 @@
+#ifndef ALIMUONMATHIESON_H
+#define ALIMUONMATHIESON_H
+/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ * See cxx source for full Copyright notice                               */
+
+/* $Id$ */
+// Revision of includes 07/05/2004
+
+class AliSegmentation;
+
+class AliMUONMathieson 
+{
+ public:
+    AliMUONMathieson();
+    virtual ~AliMUONMathieson(){}
+    // Get anode cathode Pitch
+    Float_t Pitch() const        {return fPitch;}
+    // Set anode cathode Pitch
+    void    SetPitch(Float_t p1) {fPitch = p1;};
+
+    // Set Mathieson parameters
+    // Mathieson \sqrt{Kx3} and derived Kx2 and Kx4
+    void SetSqrtKx3AndDeriveKx2Kx4(Float_t SqrtKx3);
+    // Mathieson \sqrt{Kx3}
+    void    SetSqrtKx3(Float_t p1) {fSqrtKx3 = p1;};
+    // Mathieson Kx2
+    void    SetKx2(Float_t p1)      {fKx2 = p1;};
+    // Mathieson Kx4
+    void    SetKx4(Float_t p1)      {fKx4 = p1;};
+    // Mathieson \sqrt{Ky3} and derived Ky2 and Ky4
+    void SetSqrtKy3AndDeriveKy2Ky4(Float_t SqrtKy3);
+    // Mathieson \sqrt{Ky3}
+    void    SetSqrtKy3(Float_t p1)   {fSqrtKy3 = p1;};
+    // Mathieson Ky2
+    void    SetKy2(Float_t p1) {fKy2 = p1;};
+    // Mathieson Ky4
+    void    SetKy4(Float_t p1) {fKy4 = p1;};
+    // Charge disintegration
+    Float_t  IntXY(AliSegmentation * segmentation);
+
+    ClassDef(AliMUONMathieson,1) // Implementation of Mathieson response
+ protected:
+  
+    Float_t fSqrtKx3;                  // Mathieson Sqrt(Kx3)
+    Float_t fKx2;                      // Mathieson Kx2
+    Float_t fKx4;                      // Mathieson Kx4 = Kx1/Kx2/Sqrt(Kx3)  
+    Float_t fSqrtKy3;                  // Mathieson Sqrt(Ky3)
+    Float_t fKy2;                      // Mathieson Ky2
+    Float_t fKy4;                      // Mathieson Ky4 = Ky1/Ky2/Sqrt(Ky3)
+    Float_t fPitch;                    // anode-cathode pitch
+};
+#endif
+
+
+
+
+
+
+
+
+
+
+
index a3018b0..bebc989 100644 (file)
@@ -31,7 +31,6 @@
 #include "AliMUONData.h"
 #include "AliMUONEventReconstructor.h"
 #include "AliMUONClusterReconstructor.h"
-#include "AliMUONTriggerDecision.h"
 #include "AliMUONClusterFinderVS.h"
 #include "AliMUONTrack.h"
 #include "AliMUONTrackParam.h"
@@ -63,16 +62,8 @@ void AliMUONReconstructor::Reconstruct(AliRunLoader* runLoader) const
 
   AliMUONClusterReconstructor* recoCluster = new AliMUONClusterReconstructor(loader);
   AliMUONData* dataCluster = recoCluster->GetMUONData();
-
-  AliMUONTriggerDecision* trigDec = new AliMUONTriggerDecision(loader,0,dataCluster);
-  //  AliMUONData* dataTrig = trigDec->GetMUONData();
-
-
-  for (Int_t i = 0; i < 10; i++) {
-    AliMUONClusterFinderVS *recModel = new AliMUONClusterFinderVS();
-    recModel->SetGhostChi2Cut(10);
-    recoCluster->SetReconstructionModel(i,recModel);
-  } 
+  AliMUONClusterFinderVS *recModel = recoCluster->GetRecoModel();
+  recModel->SetGhostChi2Cut(10);
 
   loader->LoadDigits("READ");
   loader->LoadRecPoints("RECREATE");
@@ -95,7 +86,7 @@ void AliMUONReconstructor::Reconstruct(AliRunLoader* runLoader) const
     // trigger branch
     dataCluster->MakeBranch("TC");
     dataCluster->SetTreeAddress("TC");
-    trigDec->Trigger2Trigger(); 
+    recoCluster->Trigger2Trigger(); 
     dataCluster->Fill("TC");
 
     loader->WriteRecPoints("OVERWRITE");
@@ -134,7 +125,6 @@ void AliMUONReconstructor::Reconstruct(AliRunLoader* runLoader) const
 
   delete recoCluster;
   delete recoEvent;
-  delete trigDec;
 }
 
 //_____________________________________________________________________________
@@ -150,14 +140,8 @@ void AliMUONReconstructor::Reconstruct(AliRunLoader* runLoader, AliRawReader* ra
 
   AliMUONClusterReconstructor* recoCluster = new AliMUONClusterReconstructor(loader);
   AliMUONData* dataCluster = recoCluster->GetMUONData();
-
-  AliMUONTriggerDecision* trigDec = new AliMUONTriggerDecision(loader,0,dataCluster);
-  for (Int_t i = 0; i < 10; i++) {
-    AliMUONClusterFinderVS *recModel = new AliMUONClusterFinderVS();
-    recModel->SetGhostChi2Cut(10);
-    recoCluster->SetReconstructionModel(i,recModel);
-  } 
+  AliMUONClusterFinderVS *recModel = recoCluster->GetRecoModel();
+  recModel->SetGhostChi2Cut(10);
 
   loader->LoadRecPoints("RECREATE");
   loader->LoadTracks("RECREATE");
@@ -181,7 +165,7 @@ void AliMUONReconstructor::Reconstruct(AliRunLoader* runLoader, AliRawReader* ra
     // trigger branch
     dataCluster->MakeBranch("TC");
     dataCluster->SetTreeAddress("TC");
-    trigDec->Trigger2Trigger(rawReader); 
+    recoCluster->Trigger2Trigger(rawReader); 
     dataCluster->Fill("TC");
 
     loader->WriteRecPoints("OVERWRITE");
@@ -219,7 +203,6 @@ void AliMUONReconstructor::Reconstruct(AliRunLoader* runLoader, AliRawReader* ra
 
   delete recoCluster;
   delete recoEvent;
-  delete trigDec;
 }
 
 //_____________________________________________________________________________
index a7ed4a9..4bd92b0 100644 (file)
@@ -16,55 +16,55 @@ class AliMUONResponse : public TObject
 {
  public:
     AliMUONResponse();
-    virtual ~AliMUONResponse();
+    ~AliMUONResponse();
  
     //
     // Configuration methods
     //
     // Set number of sigmas over which cluster disintegration is performed
-    virtual void    SetSigmaIntegration(Float_t p1)           =0;
+    virtual void    SetSigmaIntegration(Float_t)           {return;}
     // Get number of sigmas over which cluster disintegration is performed
-    virtual Float_t SigmaIntegration() const                  =0;
+    virtual Float_t SigmaIntegration() const                  {return 1.;}
     // Set single electron pulse height (ADCcounts/e)
-    virtual void    SetChargeSlope(Float_t p1)                =0;
+    virtual void    SetChargeSlope(Float_t )                {return;}
     // Get single electron pulse height (ADCcounts/e)
-    virtual Float_t ChargeSlope() const                       =0;
+    virtual Float_t ChargeSlope() const                       {return 1.;}
     // Set sigmas of the charge spread function
-    virtual void    SetChargeSpread(Float_t p1, Float_t p2)   =0;
+    virtual void    SetChargeSpread(Float_t , Float_t )   {return;}
     // Get sigma_X of the charge spread function
-    virtual Float_t ChargeSpreadX() const                     =0;
+    virtual Float_t ChargeSpreadX() const                     {return 1.;}
     // Get sigma_Y of the charge spread function
-    virtual Float_t ChargeSpreadY() const                     =0;
+    virtual Float_t ChargeSpreadY() const                     {return 1.;}
     // Set maximum Adc-count value
-    virtual void    SetMaxAdc(Int_t p1)                       =0;
+    virtual void    SetMaxAdc(Int_t )                       {return;}
     // Set saturation value
-    virtual void    SetSaturation(Int_t p1)                   =0;
+    virtual void    SetSaturation(Int_t )                   {return;}
     // Set zero suppression threshold
-    virtual void    SetZeroSuppression(Int_t val)             =0;
+    virtual void    SetZeroSuppression(Int_t )             {return;}
     // Get maximum Adc-count value
-    virtual Int_t MaxAdc() const                              =0;
+    virtual Int_t MaxAdc() const                              {return kTRUE;}
     // Get saturation value
-    virtual Int_t Saturation() const                          =0;
+    virtual Int_t Saturation() const                          {return kTRUE;}
     // Get maximum zero suppression threshold
-    virtual Int_t ZeroSuppression() const                     =0;
+    virtual Int_t ZeroSuppression() const                     {return kTRUE;}
     // Set anode cathode Pitch
-    virtual void    SetPitch(Float_t)                         =0;
+    virtual void    SetPitch(Float_t)                         {return;}
     // Get anode cathode Pitch
-    virtual Float_t Pitch() const                             =0;
+    virtual Float_t Pitch() const                             {return 1.;}
     // Set the charge correlation
-    virtual void SetChargeCorrel(Float_t correl)              =0;
+    virtual void SetChargeCorrel(Float_t)              {return;}
     // Get the charge correlation
-    virtual Float_t ChargeCorrel() const                      =0;
+    virtual Float_t ChargeCorrel() const                      {return 1.;}
     //  
     // Chamber response methods
     // Pulse height from scored quantity (eloss)
-    virtual Float_t IntPH(Float_t eloss)                      =0;
+    virtual Float_t IntPH(Float_t)                      {return 1.;}
     // Charge disintegration 
-    virtual Float_t IntXY(AliSegmentation *)                  =0;
+    virtual Float_t IntXY(AliSegmentation *)                  {return 1.;}
     // Noise, zero-suppression, adc saturation
-    //virtual Int_t DigitResponse(Int_t digit)                =0;
-    virtual Int_t DigitResponse(Int_t digit, 
-                                AliMUONTransientDigit* where) =0;
+    //virtual Int_t DigitResponse(Int_t )                {return kTRUE;}
+    virtual Int_t DigitResponse(Int_t , 
+                                AliMUONTransientDigit* ) {return kTRUE;}
     // 
     ClassDef(AliMUONResponse,1) // Chamber response virtual base class 
 };
index ccb542e..b4931f4 100644 (file)
@@ -26,7 +26,7 @@ ClassImp(AliMUONResponseTrigger)
 
 //------------------------------------------------------------------   
 AliMUONResponseTrigger::AliMUONResponseTrigger()
-  : AliMUONResponseV0()
+  : AliMUONResponse()
 {
 // Default constructor
 }
index e7a17c0..6cb344f 100644 (file)
@@ -6,9 +6,9 @@
 /* $Id$ */
 // Revision of includes 07/05/2004
 
-#include "AliMUONResponseV0.h"
+#include "AliMUONResponse.h"
 
-class AliMUONResponseTrigger : public AliMUONResponseV0 
+class AliMUONResponseTrigger : public AliMUONResponse
 {
  public:
   AliMUONResponseTrigger();
index 5d221a3..86e93e1 100644 (file)
@@ -96,10 +96,6 @@ AliMUONTriggerDecision::AliMUONTriggerDecision(AliLoader* loader, Int_t iprint,
   }else{
     fMUONData = data;
   }
-  // Loading AliRun master
-  AliRunLoader* runloader = fLoader->GetRunLoader();
-  if (runloader->GetAliRun() == 0x0) runloader->LoadgAlice();
-  gAlice = runloader->GetAliRun();
 
   // getting MUON
   fMUON = (AliMUON*) gAlice->GetDetector("MUON");
@@ -1438,21 +1434,3 @@ void AliMUONTriggerDecision::Digits2Trigger(){
     }
   }
 }
-
-//_______________________________________________________________________
-void AliMUONTriggerDecision::Trigger2Trigger() 
-{
-// copy trigger from TreeD to TreeR
-
-  fMUONData->SetTreeAddress("GLT");
-  fMUONData->GetTriggerD();
-}
-
-//_______________________________________________________________________
-void AliMUONTriggerDecision::Trigger2Trigger(AliRawReader* /*rawReader*/) 
-{
-// call the Trigger Algorithm from raw data and fill TreeR 
-
-   AliFatal("Trigger not implemented for raw data input");
-
-}
index 4335840..2628dd3 100644 (file)
@@ -49,10 +49,6 @@ class AliMUONTriggerDecision : public TObject
 
   void Digits2Trigger(); // main function for digitizer
 
-  void Trigger2Trigger();// main function for reconstructor
-
-  void Trigger2Trigger(AliRawReader* rawReader); // for raw data reader purpose
-
   void ClearDigits();
   TClonesArray* Digits(Int_t DetectionPlane);
   void AddDigit(Int_t id, Int_t* tracks, Int_t* charges, Int_t* digits);
index d38937e..10f4d9f 100644 (file)
@@ -4,20 +4,58 @@
 #pragma link off all functions;
 
 #pragma link C++ class AliMUON+; 
-#pragma link C++ class AliMUONConstants+; 
-#pragma link C++ class AliMUONTriggerConstants+; 
-#pragma link C++ class AliMUONData+; 
-#pragma link C++ class AliMUONDataInterface+; 
-#pragma link C++ class AliMUONLoader+; 
+#pragma link C++ class AliMUONv1+; 
+
+// mapping & segmentation (change in progress)
+#pragma link C++ class AliMUONSegmentationV0+;
+#pragma link C++ class AliMUONSegmentationV01+; 
+#pragma link C++ class AliMUONSegmentationV02+; 
+#pragma link C++ class AliMUONSegmentationTrigger+;  
+#pragma link C++ class AliMUONSegmentationTriggerX+; 
+#pragma link C++ class AliMUONSegmentationTriggerY+; 
+#pragma link C++ class AliMUONSegmentationSlatModule+; 
+#pragma link C++ class AliMUONSegmentationSlatModuleN+; 
+#pragma link C++ class AliMUONSegmentationSlat+; 
+#pragma link C++ class AliMUONSegmentationSlatN+; 
 #pragma link C++ class AliMUONSegmentationDetectionElement+;
 #pragma link C++ class AliMUONSegmentIndex+;
 #pragma link C++ class AliMUONSegmentManuIndex+;
 #pragma link C++ class AliMUONSegmentPosition+;
+// geometry & response
+#pragma link C++ class AliMUONResponse+; 
+#pragma link C++ class AliMUONResponseV0+;
+#pragma link C++ class AliMUONResponseTrigger+; 
+#pragma link C++ class AliMUONResponseTriggerV1+;
+#pragma link C++ class AliMUONGeometryDEIndexing+;
+#pragma link C++ class AliMUONCommonGeometryBuilder+;
+#pragma link C++ class AliMUONSt1GeometryBuilder+; 
+#pragma link C++ class AliMUONSt1GeometryBuilderV2+; 
+#pragma link C++ class AliMUONSt2GeometryBuilder+; 
+#pragma link C++ class AliMUONSlatGeometryBuilder+; 
+#pragma link C++ class AliMUONTriggerGeometryBuilder+; 
+// info classes 
+#pragma link C++ class AliMUONConstants+; 
+#pragma link C++ class AliMUONTriggerConstants+; 
+#pragma link C++ class AliMUONDataInterface+; 
+#pragma link C++ class AliMUONLoader+; 
 #pragma link C++ class AliMUONChamber+; 
 #pragma link C++ class AliMUONChamberTrigger+; 
 #pragma link C++ class AliMUONTriggerCircuit+; 
-#pragma link C++ class AliMUONDisplay+; 
+
+// containers
+#pragma link C++ class AliMUONData+; 
 #pragma link C++ class AliMUONPoints+; 
+#pragma link C++ class AliMUONHit+; 
+#pragma link C++ class AliMUONHitMapA1+; 
+#pragma link C++ class AliMUONRawCluster+;
+#pragma link C++ class AliMUONDigit+; 
+#pragma link C++ class AliMUONTransientDigit+;
+#pragma link C++ class AliMUONGlobalTrigger+; 
+#pragma link C++ class AliMUONLocalTrigger+; 
+#pragma link C++ class AliMUONTriggerLut+; 
+
+// display
+#pragma link C++ class AliMUONDisplay+; 
 #pragma link C++ class AliMUONRecoDisplay+; 
 #pragma link C++ class AliMUONRecoCheck+; 
 #endif
index 8df7e91..ce1ff1c 100644 (file)
@@ -6,9 +6,9 @@
 #pragma link C++ class AliMUONClusterReconstructor+; 
 #pragma link C++ class AliMUONClusterFinderVS+; 
 #pragma link C++ class AliMUONClusterFinderAZ+; 
+#pragma link C++ class AliMUONMathieson+; 
 #pragma link C++ class AliMUONPixel+; 
 #pragma link C++ class AliMUONClusterInput+; 
-#pragma link C++ class AliMUONRawCluster+; 
 #pragma link C++ class AliMUONReconstructor+;
 #pragma link C++ class AliMUONEventReconstructor+; 
 #pragma link C++ class AliMUONTrack+; 
 #pragma link C++ class AliMUONSegment+;
 #pragma link C++ class AliMUONReconstHit+; 
 
-#pragma link C++ class AliMUONDigit+; 
-#pragma link C++ class AliMUONTransientDigit+; 
-
-
-#pragma link C++ class AliMUONTriggerDecision+; 
-#pragma link C++ class AliMUONGlobalTrigger+; 
-#pragma link C++ class AliMUONLocalTrigger+; 
-#pragma link C++ class AliMUONTriggerLut+; 
-
 #pragma link C++ class AliMUONDDLTrigger+;
 #pragma link C++ class AliMUONSubEventTrigger+;
 #pragma link C++ class AliMUONScalerEventTrigger+;
index a34b1e5..83ce9b2 100644 (file)
@@ -3,45 +3,23 @@
 #pragma link off all classes;
 #pragma link off all functions;
 
+#pragma link C++ class AliMUON+; 
 #pragma link C++ class AliMUONv0+; 
-#pragma link C++ class AliMUONv1+; 
 #pragma link C++ class AliMUONv3+; 
 
-#pragma link C++ class AliMUONGeometryDEIndexing+;
-#pragma link C++ class AliMUONCommonGeometryBuilder+;
-#pragma link C++ class AliMUONSt1GeometryBuilder+; 
-#pragma link C++ class AliMUONSt1GeometryBuilderV2+; 
-#pragma link C++ class AliMUONSt2GeometryBuilder+; 
-#pragma link C++ class AliMUONSlatGeometryBuilder+; 
-#pragma link C++ class AliMUONTriggerGeometryBuilder+; 
+
 #pragma link C++ class AliMUONFactory+; 
 
-#pragma link C++ class AliMUONSegmentationV0+;
-#pragma link C++ class AliMUONSegmentationV01+; 
-#pragma link C++ class AliMUONSegmentationV02+; 
-#pragma link C++ class AliMUONSegmentationTrigger+;  
-#pragma link C++ class AliMUONSegmentationTriggerX+; 
-#pragma link C++ class AliMUONSegmentationTriggerY+; 
-#pragma link C++ class AliMUONSegmentationSlatModule+; 
-#pragma link C++ class AliMUONSegmentationSlatModuleN+; 
-#pragma link C++ class AliMUONSegmentationSlat+; 
-#pragma link C++ class AliMUONSegmentationSlatN+; 
 #pragma link C++ class AliMUONSt1Segmentation+; 
 #pragma link C++ class AliMUONSt12QuadrantSegmentation+; 
 
-#pragma link C++ class AliMUONResponse+; 
-#pragma link C++ class AliMUONResponseV0+; 
 #pragma link C++ class AliMUONSt1Response+;
-#pragma link C++ class AliMUONResponseTrigger+; 
-#pragma link C++ class AliMUONResponseTriggerV1+;
 
 #pragma link C++ class AliMUONSt1ElectronicElement+; 
 #pragma link C++ class AliMUONSt1SpecialMotif+; 
 #pragma link C++ class AliMUONSt1ResponseParameter+; 
 #pragma link C++ class AliMUONSt1ResponseRule+; 
 
-#pragma link C++ class AliMUONHit+; 
-#pragma link C++ class AliMUONHitMapA1+; 
 #pragma link C++ class AliMUONPadHit+; 
 
 #pragma link C++ class AliMUONDigitizer+; 
@@ -49,6 +27,7 @@
 #pragma link C++ class AliMUONDigitizerv2+; 
 #pragma link C++ class AliMUONSDigitizerv1+; 
 #pragma link C++ class AliMUONMerger+; 
+#pragma link C++ class AliMUONTriggerDecision+; 
 
 #pragma link C++ class AliMUONTest+; 
 #endif
index 5bfbefb..cb11d5c 100644 (file)
@@ -1,20 +1,49 @@
 # $Id$
 
-SRCS:=  AliMUON.cxx \
-        AliMUONConstants.cxx \
-        AliMUONTriggerConstants.cxx \
-        AliMUONData.cxx \
-        AliMUONDataInterface.cxx \
-        AliMUONLoader.cxx \
+SRCS:=  AliMUON.cxx AliMUONv1.cxx \
+        AliMUONSegmentationV0.cxx \
+        AliMUONSegmentationV01.cxx \
+        AliMUONSegmentationV02.cxx \
+        AliMUONSegmentationTrigger.cxx  \
+        AliMUONSegmentationTriggerX.cxx \
+        AliMUONSegmentationTriggerY.cxx \
+        AliMUONSegmentationSlatModule.cxx \
+        AliMUONSegmentationSlatModuleN.cxx \
+        AliMUONSegmentationSlat.cxx \
+        AliMUONSegmentationSlatN.cxx \
         AliMUONSegmentationDetectionElement.cxx \
         AliMUONSegmentIndex.cxx \
         AliMUONSegmentManuIndex.cxx \
         AliMUONSegmentPosition.cxx\
+        AliMUONResponse.cxx \
+        AliMUONResponseV0.cxx \
+        AliMUONResponseTrigger.cxx \
+        AliMUONResponseTriggerV1.cxx\
+        AliMUONGeometryDEIndexing.cxx \
+        AliMUONCommonGeometryBuilder.cxx \
+        AliMUONSt1GeometryBuilder.cxx \
+        AliMUONSt1GeometryBuilderV2.cxx \
+        AliMUONSt2GeometryBuilder.cxx \
+        AliMUONSlatGeometryBuilder.cxx \
+        AliMUONTriggerGeometryBuilder.cxx \
+        AliMUONConstants.cxx \
+        AliMUONTriggerConstants.cxx \
+        AliMUONDataInterface.cxx \
+        AliMUONLoader.cxx \
         AliMUONChamber.cxx \
         AliMUONChamberTrigger.cxx \
         AliMUONTriggerCircuit.cxx \
-        AliMUONDisplay.cxx \
+        AliMUONData.cxx \
         AliMUONPoints.cxx \
+        AliMUONHit.cxx \
+        AliMUONHitMapA1.cxx \
+        AliMUONDigit.cxx \
+        AliMUONTransientDigit.cxx \
+        AliMUONRawCluster.cxx \
+        AliMUONGlobalTrigger.cxx  \
+        AliMUONLocalTrigger.cxx \
+        AliMUONTriggerLut.cxx \
+        AliMUONDisplay.cxx \
         AliMUONRecoDisplay.cxx \
         AliMUONRecoCheck.cxx
 
index 92fa4df..9c384ee 100644 (file)
@@ -5,9 +5,9 @@ FSRCS= extrap.F
 SRCS:= AliMUONClusterReconstructor.cxx \
        AliMUONClusterFinderVS.cxx \
        AliMUONClusterFinderAZ.cxx \
+       AliMUONMathieson.cxx \
        AliMUONPixel.cxx \
        AliMUONClusterInput.cxx \
-       AliMUONRawCluster.cxx \
        AliMUONReconstructor.cxx \
        AliMUONEventReconstructor.cxx \
        AliMUONTrack.cxx \
@@ -20,12 +20,6 @@ SRCS:= AliMUONClusterReconstructor.cxx \
        AliMUONTrackHit.cxx \
        AliMUONSegment.cxx \
        AliMUONReconstHit.cxx \
-       AliMUONDigit.cxx \
-       AliMUONTransientDigit.cxx \
-       AliMUONTriggerDecision.cxx \
-       AliMUONGlobalTrigger.cxx  \
-       AliMUONLocalTrigger.cxx \
-       AliMUONTriggerLut.cxx \
        AliMUONDDLTrigger.cxx \
        AliMUONSubEventTrigger.cxx \
        AliMUONScalerEventTrigger.cxx \
index 24d13b4..3a78b51 100644 (file)
@@ -1,38 +1,15 @@
 # $Id$
 
-SRCS:= AliMUONv0.cxx AliMUONv1.cxx AliMUONv3.cxx \
-       AliMUONGeometryDEIndexing.cxx \
-       AliMUONCommonGeometryBuilder.cxx \
-       AliMUONSt1GeometryBuilder.cxx \
-       AliMUONSt1GeometryBuilderV2.cxx \
-       AliMUONSt2GeometryBuilder.cxx \
-       AliMUONSlatGeometryBuilder.cxx \
-       AliMUONTriggerGeometryBuilder.cxx \
+SRCS:= AliMUONv0.cxx  AliMUONv3.cxx \
        AliMUONFactory.cxx \
-       AliMUONSegmentationV0.cxx \
-       AliMUONSegmentationV01.cxx \
-       AliMUONSegmentationV02.cxx \
-       AliMUONSegmentationTrigger.cxx  \
-       AliMUONSegmentationTriggerX.cxx \
-       AliMUONSegmentationTriggerY.cxx \
-       AliMUONSegmentationSlatModule.cxx \
-       AliMUONSegmentationSlatModuleN.cxx \
-       AliMUONSegmentationSlat.cxx \
-       AliMUONSegmentationSlatN.cxx \
        AliMUONSt1Segmentation.cxx \
        AliMUONSt12QuadrantSegmentation.cxx \
-       AliMUONResponse.cxx \
-       AliMUONResponseV0.cxx \
        AliMUONSt1Response.cxx \
-       AliMUONResponseTrigger.cxx \
-       AliMUONResponseTriggerV1.cxx\
        AliMUONSt1ElectronicElement.cxx \
        AliMUONSt1SpecialMotif.cxx \
        AliMUONSt1ResponseParameter.cxx \
        AliMUONSt1ResponseRule.cxx \
        AliMUONSt1IniReader.cxx \
-       AliMUONHit.cxx \
-       AliMUONHitMapA1.cxx \
        AliMUONPadHit.cxx \
        AliMUONSt1Decoder.cxx \
        AliMUONDigitizer.cxx \
@@ -40,6 +17,7 @@ SRCS:= AliMUONv0.cxx AliMUONv1.cxx AliMUONv3.cxx \
        AliMUONDigitizerv2.cxx \
        AliMUONSDigitizerv1.cxx \
        AliMUONMerger.cxx \
+       AliMUONTriggerDecision.cxx \
        AliMUONTest.cxx
 
 HDRS:= $(SRCS:.cxx=.h)
diff --git a/MUON/loadlibs.C b/MUON/loadlibs.C
new file mode 100644 (file)
index 0000000..8941739
--- /dev/null
@@ -0,0 +1,29 @@
+void loadlibs () 
+{
+  gSystem->Load("libPhysics");
+  gSystem->Load("libMinuit");
+  gSystem->Load("libmicrocern");
+  gSystem->Load("libpdf");
+  gSystem->Load("libpythia6");
+  gSystem->Load("libEG");
+  gSystem->Load("libGeom");
+  gSystem->Load("libVMC");
+  gSystem->Load("libEGPythia6");
+
+  gSystem->Load("libRAW");
+  gSystem->Load("libESD");
+  gSystem->Load("libSTEER");
+  gSystem->Load("libEVGEN");
+  gSystem->Load("libFASTSIM");
+  gSystem->Load("libAliPythia6");
+  gSystem->Load("libSTRUCT");
+  gSystem->Load("libMUONmapping");
+  gSystem->Load("libMUONgeometry");
+  gSystem->Load("libMUONbase");
+
+  gSystem->Load("libMUONsim");
+  new AliRun("gAlice","The ALICE Off-line Simulation Framework");
+
+  gSystem->Load("libMUONrec");
+  
+}