// 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
frMax(0.),
fCurrentCorrel(1), // to avoid mistakes if ChargeCorrelInit is not called
fSegmentation(0),
- fReconstruction(0),
fResponse(0),
fGeometry(0)
{
frMax(0.),
fCurrentCorrel(1), // to avoid mistakes if ChargeCorrelInit is not called
fSegmentation(0),
- fReconstruction(0),
fResponse(0),
fGeometry(0)
{
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;}
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)
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
#include "AliMUONDigit.h"
#include "AliMUONRawCluster.h"
#include "AliSegmentation.h"
-#include "AliMUONResponse.h"
+#include "AliMUONMathieson.h"
#include "AliMUONClusterInput.h"
#include "AliMUONHitMapA1.h"
#include "AliLog.h"
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
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 );
}
#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"
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()
{
// Destructor
delete fgMinuit;
+ delete fgMathieson;
}
AliMUONClusterInput::AliMUONClusterInput(const AliMUONClusterInput& clusterInput):TObject(clusterInput)
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)
iChamber = &(pMUON->Chamber(chamber));
fSegmentation[0]=iChamber->SegmentationModel(1);
- fResponse=iChamber->ResponseModel();
fNseg=1;
}
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;
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;
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);
class AliMUONDigit;
class AliMUONRawCluster;
class AliSegmentation;
-class AliMUONResponse;
+class AliMUONMathieson;
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
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
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
#include "AliRunLoader.h"
#include "AliLoader.h"
-#include "AliMUON.h"
#include "AliMUONDigit.h"
#include "AliMUONConstants.h"
#include "AliMUONData.h"
//__________________________________________________________________________
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;
// 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)
// 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)
//__________________________________________________________________________
AliMUONClusterReconstructor::~AliMUONClusterReconstructor(void)
{
- if (fChambers){
- fChambers->Clear(); // Sets pointers to 0 sinche it is not the owner
- delete fChambers;
- }
+
if (fMUONData)
delete fMUONData;
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);
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();
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);
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");
+
+}
class AliLoader;
class AliMUON;
-class AliMUONChamber;
class AliMUONRawCluster;
class AliMUONClusterFinderVS;
class AliMUONData;
// 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;}
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;
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.};
// 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() {}
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
#include "AliMUONTrackParam.h"
#include "AliSegmentation.h"
-#include "AliMUONResponse.h"
#include "AliMUONChamber.h"
#include "AliMUONConstants.h"
#include "AliMC.h"
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;
AliMUON *pMUON = (AliMUON*)gAlice->GetModule("MUON");
AliMUONChamber* iChamber;
AliSegmentation* segmentation;
- AliMUONResponse* response;
GetMUONData()->SetTreeAddress("D");
iChamber = &(pMUON->Chamber(chamber-1));
segmentation = iChamber->SegmentationModel(cathode);
- response = iChamber->ResponseModel();
Float_t zpos = iChamber->Z();
AliMUONDigit *mdig;
//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);
// 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;
}
//__________________________________________________________________________
--- /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$ */
+
+#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)));
+}
+
+
+
+
+
+
+
+
+
+
--- /dev/null
+#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
+
+
+
+
+
+
+
+
+
+
+
#include "AliMUONData.h"
#include "AliMUONEventReconstructor.h"
#include "AliMUONClusterReconstructor.h"
-#include "AliMUONTriggerDecision.h"
#include "AliMUONClusterFinderVS.h"
#include "AliMUONTrack.h"
#include "AliMUONTrackParam.h"
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");
// trigger branch
dataCluster->MakeBranch("TC");
dataCluster->SetTreeAddress("TC");
- trigDec->Trigger2Trigger();
+ recoCluster->Trigger2Trigger();
dataCluster->Fill("TC");
loader->WriteRecPoints("OVERWRITE");
delete recoCluster;
delete recoEvent;
- delete trigDec;
}
//_____________________________________________________________________________
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");
// trigger branch
dataCluster->MakeBranch("TC");
dataCluster->SetTreeAddress("TC");
- trigDec->Trigger2Trigger(rawReader);
+ recoCluster->Trigger2Trigger(rawReader);
dataCluster->Fill("TC");
loader->WriteRecPoints("OVERWRITE");
delete recoCluster;
delete recoEvent;
- delete trigDec;
}
//_____________________________________________________________________________
{
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
};
//------------------------------------------------------------------
AliMUONResponseTrigger::AliMUONResponseTrigger()
- : AliMUONResponseV0()
+ : AliMUONResponse()
{
// Default constructor
}
/* $Id$ */
// Revision of includes 07/05/2004
-#include "AliMUONResponseV0.h"
+#include "AliMUONResponse.h"
-class AliMUONResponseTrigger : public AliMUONResponseV0
+class AliMUONResponseTrigger : public AliMUONResponse
{
public:
AliMUONResponseTrigger();
}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");
}
}
}
-
-//_______________________________________________________________________
-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");
-
-}
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);
#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
#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+;
#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+;
#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
# $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
SRCS:= AliMUONClusterReconstructor.cxx \
AliMUONClusterFinderVS.cxx \
AliMUONClusterFinderAZ.cxx \
+ AliMUONMathieson.cxx \
AliMUONPixel.cxx \
AliMUONClusterInput.cxx \
- AliMUONRawCluster.cxx \
AliMUONReconstructor.cxx \
AliMUONEventReconstructor.cxx \
AliMUONTrack.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 \
# $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 \
AliMUONDigitizerv2.cxx \
AliMUONSDigitizerv1.cxx \
AliMUONMerger.cxx \
+ AliMUONTriggerDecision.cxx \
AliMUONTest.cxx
HDRS:= $(SRCS:.cxx=.h)
--- /dev/null
+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");
+
+}
git://git.uio.no / u / mrichter / AliRoot.git / commitdiff