Protection against abnormal memory occupancy in the global tracking
authorauras <auras@f7af4fe6-9843-0410-8265-dc069ae4e863>
Mon, 9 Jul 2012 17:19:37 +0000 (17:19 +0000)
committerauras <auras@f7af4fe6-9843-0410-8265-dc069ae4e863>
Mon, 9 Jul 2012 17:19:37 +0000 (17:19 +0000)
MFT/AliMFT.cxx
MFT/AliMFT.h
MFT/AliMFTConstants.cxx
MFT/AliMFTConstants.h
MFT/AliMuonForwardTrackFinder.cxx
MFT/AliMuonForwardTrackFinder.h
MFT/AliMuonForwardTrackPair.cxx
MFT/AliMuonForwardTrackPair.h
MFT/Config.C
MFT/runReconstruction.C
MFT/runSimulation.C

index 691b7d8..cc95c33 100644 (file)
@@ -201,6 +201,23 @@ void AliMFT::CreateGeometry() {
 
 //====================================================================================================================================================
 
+void AliMFT::AddAlignableVolumes() {
+
+  // Create entries for alignable volumes associating the symbolic volume
+  // name with the corresponding volume path. Needs to be syncronized with
+  // eventual changes in the geometry.
+
+  TString sysName = "MFT";
+  TString volPath = "/ALIC_1/MFT_0";
+  
+  if (!gGeoManager->SetAlignableEntry(sysName.Data(),volPath.Data())) {
+    AliFatal(Form("Alignable entry %s not created. Volume path %s not valid", sysName.Data(), volPath.Data()));
+  }  
+
+}
+
+//====================================================================================================================================================
+
 void AliMFT::StepManager() {
 
   // Full Step Manager
index 884574c..af6a618 100644 (file)
@@ -51,7 +51,8 @@ public:
   
   // ------- framework part -----------------------------------------------------------------------------------
   void CreateMaterials();                       // from AliModule invoked from AliMC
-  void CreateGeometry();                        // from AliModule invoked from AliMC                     
+  void CreateGeometry();                        // from AliModule invoked from AliMC
+  void AddAlignableVolumes();                     
   void StepManager();                           // from AliModule invoked from AliMC::Stepping()
   void Hits2SDigits();
   void Hits2SDigitsLocal(TClonesArray *hits, const TObjArray *pSDig, Int_t track);
index 556ec00..23dfa51 100644 (file)
@@ -44,4 +44,6 @@ const Double_t AliMFTConstants::fRadLengthSi = 9.37;
 
 const Double_t AliMFTConstants::fWidthChip = 1.0;
 
+const Double_t AliMFTConstants::fPrecisionPointOfClosestApproach = 10.e-4;  // 10 micron
+
 //====================================================================================================================================================
index fe15ce7..5bbae2d 100644 (file)
@@ -47,6 +47,8 @@ public:
 
   static const Double_t fWidthChip;      ///< expressed in cm
 
+  static const Double_t fPrecisionPointOfClosestApproach;  ///< precision (along z) for the research of the point of closest approach for a dimuon
+
 protected:
 
   AliMFTConstants() : TObject() {}
index c01353f..f9bc1e7 100644 (file)
@@ -71,6 +71,8 @@ AliMuonForwardTrackFinder::AliMuonForwardTrackFinder():
   fRun(0),
   fNEventsToAnalyze(0),
   fSigmaClusterCut(0),
+  fScaleSigmaClusterCut(1.),
+  fGlobalTrackingDiverged(kFALSE),
   fChi2GlobalCut(0),
   fSigmaSpectrometerCut(0),
   fVertexErrorX(0.015),
@@ -462,22 +464,19 @@ Int_t AliMuonForwardTrackFinder::LoadNextTrack() {
 
   // load next muon track from the reconstructed event
 
-  if (fCountRealTracksAnalyzed>fMaxNTracksToBeAnalyzed) return kFALSE;
-
+  if (fCountRealTracksAnalyzed>=fMaxNTracksToBeAnalyzed) return kFALSE;
   if (!fCountRealTracksAnalyzed) if (!LoadNextEvent()) return kFALSE;
-  if (fCountRealTracksAnalyzed==fMaxNTracksToBeAnalyzed) {
+
+  if (!fGlobalTrackingDiverged) {
+    while ( !(fMuonTrackReco = static_cast<AliMUONTrack*>(fNextTrack->Next())) ) if (!LoadNextEvent()) return kFALSE;
     fCountRealTracksAnalyzed++;
-    if (!LoadNextEvent()) return kFALSE;
+    fCountRealTracksAnalyzedOfEvent++;
   }
 
-  while ( !(fMuonTrackReco = static_cast<AliMUONTrack*>(fNextTrack->Next())) ) if (!LoadNextEvent()) return kFALSE;
-
   AliDebug(1, "**************************************************************************************\n");
   AliDebug(1, Form("***************************   MUON TRACK %3d   ***************************************\n", fCountRealTracksAnalyzedOfEvent));
   AliDebug(1, "**************************************************************************************\n");
 
-  fCountRealTracksAnalyzed++;
-
   fCandidateTracks -> Delete();
 
   fLabelMC = -1;
@@ -507,7 +506,7 @@ Int_t AliMuonForwardTrackFinder::LoadNextTrack() {
 
   Int_t motherPdg=0;
   if (fLabelMC>=0) {
-    fCountRealTracksWithRefMC++;
+    if (!fGlobalTrackingDiverged) fCountRealTracksWithRefMC++;
     if (fStack->Particle(fLabelMC)->GetFirstMother() != -1) {
       motherPdg = fStack->Particle(fStack->Particle(fLabelMC)->GetFirstMother())->GetPdgCode();
     }
@@ -515,7 +514,7 @@ Int_t AliMuonForwardTrackFinder::LoadNextTrack() {
 
   CheckCurrentMuonTrackable();
 
-  if (fMuonTrackReco->GetMatchTrigger()) fCountRealTracksWithRefMC_andTrigger++;
+  if (!fGlobalTrackingDiverged) if (fMuonTrackReco->GetMatchTrigger()) fCountRealTracksWithRefMC_andTrigger++;
   
   // the track we are going to build, starting from fMuonTrackReco and adding the MFT clusters
   AliMuonForwardTrack *track = new ((*fCandidateTracks)[0]) AliMuonForwardTrack();
@@ -577,7 +576,11 @@ Int_t AliMuonForwardTrackFinder::LoadNextTrack() {
        fCurrentTrack = (AliMuonForwardTrack*) fCandidateTracks->UncheckedAt(iTrack);
        // if the old track is compatible with the new cluster, the track is updated and inserted as new track in the array 
        // (several new tracks can be created for one old track)
-       FindClusterInPlane(iPlane);   
+       if (FindClusterInPlane(iPlane) == 2) {
+         fGlobalTrackingDiverged = kTRUE;
+         if (fScaleSigmaClusterCut>0) fScaleSigmaClusterCut -= 0.1;
+         return 6;
+       }
        if ((fNPlanesMFTAnalyzed-fCurrentTrack->GetNMFTClusters())>fNMaxMissingMFTClusters || fIsPlaneMandatory[iPlane]) {
          fCandidateTracks->Remove(fCurrentTrack);     // the old track is removed after the check;
        }
@@ -600,6 +603,9 @@ Int_t AliMuonForwardTrackFinder::LoadNextTrack() {
   
   // -------------------------- END OF THE CYCLE OVER THE MFT PLANES --------------------------------------------
   
+  fGlobalTrackingDiverged = kFALSE;
+  fScaleSigmaClusterCut = 1.0;
+
   AliDebug(1, "Finished cycle over planes");
 
   Double_t momentum = pt * TMath::CosH(eta);
@@ -798,15 +804,13 @@ Int_t AliMuonForwardTrackFinder::LoadNextTrack() {
   fCandidateTracks->Delete();
   fFinalBestCandidate = NULL;
   
-  fCountRealTracksAnalyzedOfEvent++;
-
   return 5;
   
 }
 
 //===========================================================================================================================================
 
-void AliMuonForwardTrackFinder::FindClusterInPlane(Int_t planeId) { 
+Int_t AliMuonForwardTrackFinder::FindClusterInPlane(Int_t planeId) { 
   
   AliDebug(2, Form(">>>> executing AliMuonForwardTrackFinder::FindClusterInPlane(%d)\n", planeId));
 
@@ -888,7 +892,7 @@ void AliMuonForwardTrackFinder::FindClusterInPlane(Int_t planeId) {
 
   //---------------------------------------------------------------------------------------
 
-  Double_t chi2cut = 2.*fSigmaClusterCut*fSigmaClusterCut;     // depends on the number of variables (here, 2)
+  Double_t chi2cut = 2.*fScaleSigmaClusterCut*fScaleSigmaClusterCut*fSigmaClusterCut*fSigmaClusterCut;     // depends on the number of variables (here, 2)
   
   // Analyizing the clusters: FRONT ACTIVE ELEMENTS
   
@@ -923,6 +927,7 @@ void AliMuonForwardTrackFinder::FindClusterInPlane(Int_t planeId) {
     if (isGoodChi2) {
       AliDebug(3, Form("accepting cluster: chi2=%f (cut = %f)\n", chi2, chi2cut));
       AliMuonForwardTrack *newTrack = new ((*fCandidateTracks)[fCandidateTracks->GetEntriesFast()]) AliMuonForwardTrack(*fCurrentTrack);
+      if (fCandidateTracks->GetEntriesFast() > fMaxNCandidates) return 2;
       newTrack->AddTrackParamAtMFTCluster(currentParamFront, *cluster);    // creating new track param and attaching the cluster
       AliDebug(2, Form("After plane %02d: newTrack->GetNMFTClusters() = %d (fCurrentTrack->GetNMFTClusters() = %d)", 
                       planeId, newTrack->GetNMFTClusters(), fCurrentTrack->GetNMFTClusters()));
@@ -976,6 +981,7 @@ void AliMuonForwardTrackFinder::FindClusterInPlane(Int_t planeId) {
     if (isGoodChi2) {
       AliDebug(3,Form("accepting cluster: chi2=%f (cut = %f)\n", chi2, chi2cut));
       AliMuonForwardTrack *newTrack = new ((*fCandidateTracks)[fCandidateTracks->GetEntriesFast()]) AliMuonForwardTrack(*fCurrentTrack);
+      if (fCandidateTracks->GetEntriesFast() > fMaxNCandidates) return 2;
       newTrack->AddTrackParamAtMFTCluster(currentParamBack, *cluster);    // creating new track param and attaching the cluster
       AliDebug(2, Form("After plane %02d: newTrack->GetNMFTClusters() = %d (fCurrentTrack->GetNMFTClusters() = %d)", 
                       planeId, newTrack->GetNMFTClusters(), fCurrentTrack->GetNMFTClusters()));
@@ -1006,6 +1012,8 @@ void AliMuonForwardTrackFinder::FindClusterInPlane(Int_t planeId) {
       fHistDistanceGoodClusterFromTrackAtLastPlane -> Fill(fDistanceFromGoodClusterAndTrackAtLastPlane);
     }
   }
+
+  return 0;
   
 }
 
index e620f59..b69dfa7 100644 (file)
@@ -116,7 +116,7 @@ public:
   void SetNMaxMissingMFTClusters(Int_t nMaxMissingMFTClusters) { fNMaxMissingMFTClusters = nMaxMissingMFTClusters; }
   void SetMandatoryPlane(Int_t iPlane) { if (0<=iPlane && iPlane<AliMFTConstants::fNMaxPlanes) fIsPlaneMandatory[iPlane] = kTRUE; }
 
-  void FindClusterInPlane(Int_t planeId);
+  Int_t FindClusterInPlane(Int_t planeId);
   void AttachGoodClusterInPlane(Int_t planeId);
   void FillPlanesWithTrackHistory();
   Double_t TryOneCluster(const AliMUONTrackParam &trackParam, AliMFTCluster *cluster);
@@ -151,10 +151,13 @@ protected:
 
   static const Int_t fNMaxPlanes = AliMFTConstants::fNMaxPlanes;        // max number of MFT planes
   static const Double_t fRadLengthSi;
+  static const Int_t fMaxNCandidates = 1000;
 
   Int_t fRun; 
   Int_t fNEventsToAnalyze;           // events to analyze
   Double_t fSigmaClusterCut;         // to select the clusters in the MFT planes which are compatible with the extrapolated muon track
+  Double_t fScaleSigmaClusterCut;    // to tune the cut on the compatible clusters in case of too many candidates
+  Bool_t fGlobalTrackingDiverged;    // to keep memory of a possible divergence in the global tracking finding
   Double_t fChi2GlobalCut;           // cut on the final chi2 of the global muon track
   Double_t fSigmaSpectrometerCut;    // for the selection of the tracks in the muon spectrometer
   Double_t fVertexErrorX;            // uncertainty on the x position of the muon's origin
index 6f29403..03637be 100644 (file)
@@ -41,7 +41,10 @@ AliMuonForwardTrackPair::AliMuonForwardTrackPair():
   fMuonForwardTracks(0),
   fKinemMC(0,0,0,0),
   fKinem(0,0,0,0),
-  fIsKinemSet(kFALSE)
+  fIsKinemSet(kFALSE),
+  fXPointOfClosestApproach(9999),
+  fYPointOfClosestApproach(9999),
+  fZPointOfClosestApproach(9999)
 {
 
   // default constructor
@@ -57,7 +60,10 @@ AliMuonForwardTrackPair::AliMuonForwardTrackPair(AliMuonForwardTrack *track0, Al
   fMuonForwardTracks(0),
   fKinemMC(0,0,0,0),
   fKinem(0,0,0,0),
-  fIsKinemSet(kFALSE)
+  fIsKinemSet(kFALSE),
+  fXPointOfClosestApproach(9999),
+  fYPointOfClosestApproach(9999),
+  fZPointOfClosestApproach(9999)
 {
 
   fMuonForwardTracks = new TClonesArray("AliMuonForwardTrack", 2);
@@ -66,6 +72,7 @@ AliMuonForwardTrackPair::AliMuonForwardTrackPair(AliMuonForwardTrack *track0, Al
   new ((*fMuonForwardTracks)[1]) AliMuonForwardTrack(*track1);
 
   SetKinemMC();
+  SetPointOfClosestApproach();
 
 }
 
@@ -76,7 +83,10 @@ AliMuonForwardTrackPair::AliMuonForwardTrackPair(const AliMuonForwardTrackPair&
   fMuonForwardTracks(trackPair.fMuonForwardTracks),
   fKinemMC(trackPair.fKinemMC),
   fKinem(trackPair.fKinem),
-  fIsKinemSet(trackPair.fIsKinemSet)
+  fIsKinemSet(trackPair.fIsKinemSet),
+  fXPointOfClosestApproach(trackPair.fXPointOfClosestApproach),
+  fYPointOfClosestApproach(trackPair.fYPointOfClosestApproach),
+  fZPointOfClosestApproach(trackPair.fZPointOfClosestApproach)
 {
 
   // copy constructor
@@ -102,6 +112,9 @@ AliMuonForwardTrackPair& AliMuonForwardTrackPair::operator=(const AliMuonForward
   fKinemMC = trackPair.fKinemMC;
   fKinem = trackPair.fKinem;
   fIsKinemSet = trackPair.fIsKinemSet;
+  fXPointOfClosestApproach = trackPair.fXPointOfClosestApproach;
+  fYPointOfClosestApproach = trackPair.fYPointOfClosestApproach;
+  fZPointOfClosestApproach = trackPair.fZPointOfClosestApproach;
 
   return *this;
 
@@ -109,16 +122,6 @@ AliMuonForwardTrackPair& AliMuonForwardTrackPair::operator=(const AliMuonForward
 
 //====================================================================================================================================================
 
-void AliMuonForwardTrackPair::SetTrack(Int_t iTrack, AliMuonForwardTrack *track) {
-
-  if (iTrack==0 || iTrack==1) {
-    new ((*fMuonForwardTracks)[iTrack]) AliMuonForwardTrack(*track);
-  }
-
-}
-
-//====================================================================================================================================================
-
 Double_t AliMuonForwardTrackPair::GetWeightedOffset(Double_t x, Double_t y, Double_t z) {
 
   Double_t weightedOffset[2]={0};
@@ -255,8 +258,90 @@ void AliMuonForwardTrackPair::SetKinem(Double_t z, Int_t nClusters) {
 
   fIsKinemSet = kTRUE;
 
-  //  return fKinem.M();
+}
+
+//====================================================================================================================================================
+
+void AliMuonForwardTrackPair::SetPointOfClosestApproach() {
+  
+  AliMUONTrackParam *param0 = ((AliMuonForwardTrack*) fMuonForwardTracks->At(0))->GetTrackParamAtMFTCluster(0);
+  AliMUONTrackParam *param1 = ((AliMuonForwardTrack*) fMuonForwardTracks->At(1))->GetTrackParamAtMFTCluster(0);
+  
+  Double_t step = 1.;  // in cm
+  Double_t startPoint = 0.;
 
+  Double_t r[3]={0}, z[3]={startPoint, startPoint+step, startPoint+2*step};
+  
+  for (Int_t i=0; i<3; i++) {
+    AliMUONTrackExtrap::ExtrapToZCov(param0, z[i]);
+    AliMUONTrackExtrap::ExtrapToZCov(param1, z[i]);
+    Double_t dX = param0->GetNonBendingCoor() - param1->GetNonBendingCoor();
+    Double_t dY = param0->GetBendingCoor()    - param1->GetBendingCoor();
+    r[i] = TMath::Sqrt(dX*dX + dY*dY);
+  }
+  
+  Double_t researchDirection=0.;
+  
+  if      (r[0]>r[1] && r[1]>r[2]) researchDirection = +1.;   // towards z positive
+  else if (r[0]<r[1] && r[1]<r[2]) researchDirection = -1.;   // towards z negative
+  else if (r[0]<r[1] && r[1]>r[2]) { 
+    AliError("Point of closest approach cannot be found for dimuon (no minima)");
+    return;
+  }
+  
+  while (TMath::Abs(researchDirection)>0.5) {
+    if (researchDirection>0.) {
+      z[0] = z[1];
+      z[1] = z[2];
+      z[2] = z[1]+researchDirection*step;
+    }
+    else {
+      z[2] = z[1];
+      z[1] = z[0];
+      z[0] = z[1]+researchDirection*step;
+    }
+    if (TMath::Abs(z[0])>900.) {
+      AliError("Point of closest approach cannot be found for dimuon (no minima)");
+      return;
+    }
+    for (Int_t i=0; i<3; i++) {
+      AliMUONTrackExtrap::ExtrapToZCov(param0, z[i]);
+      AliMUONTrackExtrap::ExtrapToZCov(param1, z[i]);
+      Double_t dX = param0->GetNonBendingCoor() - param1->GetNonBendingCoor();
+      Double_t dY = param0->GetBendingCoor()    - param1->GetBendingCoor();
+      r[i] = TMath::Sqrt(dX*dX + dY*dY);
+    }
+    researchDirection=0.;
+    if      (r[0]>r[1] && r[1]>r[2]) researchDirection = +1.;   // towards z positive
+    else if (r[0]<r[1] && r[1]<r[2]) researchDirection = -1.;   // towards z negative
+  }
+  
+  AliDebug(2,"Minimum region has been found");
+  
+  step *= 0.5;
+  while (step>AliMFTConstants::fPrecisionPointOfClosestApproach) {
+    z[0] = z[1]-step;
+    z[2] = z[1]+step;
+    for (Int_t i=0; i<3; i++) {
+      AliMUONTrackExtrap::ExtrapToZCov(param0, z[i]);
+      AliMUONTrackExtrap::ExtrapToZCov(param1, z[i]);
+      Double_t dX = param0->GetNonBendingCoor() - param1->GetNonBendingCoor();
+      Double_t dY = param0->GetBendingCoor()    - param1->GetBendingCoor();
+      r[i] = TMath::Sqrt(dX*dX + dY*dY);
+    }
+    if      (r[0]<r[1]) z[1] = z[0];
+    else if (r[2]<r[1]) z[1] = z[2];
+    else step *= 0.5;
+  }
+  
+  fZPointOfClosestApproach = z[1];
+  AliMUONTrackExtrap::ExtrapToZCov(param0, fZPointOfClosestApproach);
+  AliMUONTrackExtrap::ExtrapToZCov(param1, fZPointOfClosestApproach);  
+  fXPointOfClosestApproach = 0.5*(param0->GetNonBendingCoor() + param1->GetNonBendingCoor());
+  fYPointOfClosestApproach = 0.5*(param0->GetBendingCoor()    + param1->GetBendingCoor());
+  
+  AliDebug(2,Form("Point of Closest Approach: (%f, %f, %f)",fXPointOfClosestApproach,fYPointOfClosestApproach,fZPointOfClosestApproach));
+  
 }
 
 //====================================================================================================================================================
index 7a69e63..20126cb 100644 (file)
@@ -35,7 +35,6 @@ public:
   
   virtual ~AliMuonForwardTrackPair() { fMuonForwardTracks->Delete(); delete fMuonForwardTracks; }
 
-  void SetTrack(Int_t iTrack, AliMuonForwardTrack *track);
   AliMuonForwardTrack* GetTrack(Int_t iTrack) { 
     if (iTrack==0 || iTrack==1) return (AliMuonForwardTrack*) fMuonForwardTracks->At(iTrack); 
     else return NULL; 
@@ -45,6 +44,13 @@ public:
   void SetKinem(Double_t z, Int_t nClusters=-1);
   Bool_t IsKinemSet() { return fIsKinemSet; }
 
+  void SetPointOfClosestApproach();
+  void GetPointOfClosestApproach(Double_t *xyz) { 
+    xyz[0] = fXPointOfClosestApproach; 
+    xyz[1] = fYPointOfClosestApproach; 
+    xyz[2] = fZPointOfClosestApproach; 
+  }
+
   Double_t GetWeightedOffset(Double_t x, Double_t y, Double_t z);
   Double_t GetMassWithoutMFT(Double_t x, Double_t y, Double_t z, Int_t nClusters=-1);
   Double_t GetMassMC()     { return fKinemMC.M(); }
@@ -62,6 +68,8 @@ protected:
   TLorentzVector fKinemMC, fKinem;
   Bool_t fIsKinemSet;
 
+  Double_t fXPointOfClosestApproach, fYPointOfClosestApproach, fZPointOfClosestApproach;
+
   ClassDef(AliMuonForwardTrackPair,1)
     
 };
index 1736762..b3999d4 100644 (file)
@@ -47,8 +47,8 @@ enum PDCProc_t {kGenBox,
                kGenCorrHF,
                 kPythia6,
                kPythiaPerugia0, 
-               kPythiaPerugia0Jpsi2e, 
-               kPythiaPerugia0BtoJpsi2e, 
+               kPythiaPerugia0Jpsi2mu, 
+               kPythiaPerugia0BtoJpsi2mu, 
                kHijing, 
                kHijing2500,
                kHijing2500Cocktail};
@@ -60,8 +60,8 @@ const Char_t* pprRunName[] = {"kGenBox",
                              "kGenCorrHF",
                              "kPythia6",
                              "kPythiaPerugia0", 
-                             "kPythiaPerugia0Jpsi2e", 
-                             "kPythiaPerugia0BtoJpsi2e", 
+                             "kPythiaPerugia0Jpsi2mu", 
+                             "kPythiaPerugia0BtoJpsi2mu", 
                              "kHijing", 
                              "kHijing2500", 
                              "kHijing2500Cocktail"};
@@ -76,7 +76,7 @@ void LoadLibs();
 static PDCProc_t     proc     = kGenBox;
 static PDCProc_t     signal   = kGenBox;    // only in case kHijing2500Cocktail is the proc
 static Mag_t         mag      = k5kG;
-static Float_t       energy   = 14000.; // energy in CMS
+static Float_t       energy   = 5500.; // energy in CMS
 static Float_t       bMin     = 0.;
 static Float_t       bMax =   = 5.; // 0-5 fm corresponds to around 0-10% (see https://twiki.cern.ch/twiki/bin/viewauth/ALICE/CentStudies#Tables_with_centrality_bins_for)
 static Double_t      JpsiPol  = 0; // Jpsi polarisation
@@ -150,16 +150,17 @@ void Config() {
   
   // Generator
   AliGenerator* gener = 0x0;
-  if (proc == kPythia6)                   gener = MbPythia(); 
-  else if (proc == kPythiaPerugia0)       gener = MbPythiaTunePerugia0();
-  else if (proc == kHijing)               gener = Hijing();    
-  else if (proc == kHijing2500)           gener = Hijing2500();        
-  else if (proc == kHijing2500Cocktail)   gener = Hijing2500Cocktail();
-  else if (proc == kGenBox)               gener = GenBox();
-  else if (proc == kGenMuonLMR)           gener = GenMuonLMR();
-  else if (proc == kGenParamJpsi)         gener = GenParamJpsi();
-  else if (proc == kGenCorrHF)            gener = GenCorrHF();
-  else if (proc == kGenPionKaon)          gener = GenParamPionKaon();
+  if (proc == kPythia6)                        gener = MbPythia(); 
+  else if (proc == kPythiaPerugia0)            gener = MbPythiaTunePerugia0();
+  else if (proc == kHijing)                    gener = Hijing();       
+  else if (proc == kHijing2500)                gener = Hijing2500();   
+  else if (proc == kHijing2500Cocktail)        gener = Hijing2500Cocktail();
+  else if (proc == kGenBox)                    gener = GenBox();
+  else if (proc == kGenMuonLMR)                gener = GenMuonLMR();
+  else if (proc == kGenParamJpsi)              gener = GenParamJpsi();
+  else if (proc == kGenCorrHF)                 gener = GenCorrHF();
+  else if (proc == kGenPionKaon)               gener = GenParamPionKaon();
+  else if (proc == kPythiaPerugia0BtoJpsi2mu)  gener = MbPythiaTunePerugia0BtoJpsi2mu();
 
   // Size of the interaction diamond
   Float_t sigmaz  = 5.4 / TMath::Sqrt(2.);     // [cm]
@@ -249,9 +250,6 @@ void Config() {
   }
   if (iMFT) {
     AliMFT *MFT = new AliMFT("MFT", "normal MFT");
-    MFT->SetNSlices(1);
-    MFT->SetChargeDispersion(20.e-4);
-    MFT->SetNStepForChargeDispersion(4);
   }
 
   TIter next(gAlice->Modules());
@@ -283,13 +281,13 @@ AliGenerator* GenMuonLMR() {
   AliGenMUONLMR *gener = new AliGenMUONLMR();
   gener->SetMomentumRange(0,999);
   gener->SetPtRange(0,100.);
-  gener->SetYRange(-4.0, -2.5);
-  gener->SetChildThetaRange(171.0,177.0);
-  gener->SetChildMomentumRange(5.0, 999.);
+  gener->SetYRange(-4.5, -2.0);
+  gener->SetChildThetaRange(171.0,178.0);
+  gener->SetChildMomentumRange(4.0, 999.);
   gener->SetOrigin(0.0, 0.0, 0.0);             // vertex position
   gener->SetSigma(0.0, 0.0, 0.0);              // vertex position smearing
   enum {kEta2Body, kEtaDalitz, kRho2Body, kOmega2Body, kOmegaDalitz, kPhi2Body, kEtaPrimeDalitz, kPionLMR, kKaonLMR}; 
-  gener->GenerateSingleProcess(kPhi2Body, 10);
+  gener->GenerateSingleProcess(kOmega2Body, 10);
   gener->SetCutOnChild(1);
 
   return gener;
@@ -337,12 +335,13 @@ AliGenerator* GenParamPionKaon() {
 
 AliGenerator* GenCorrHF() {
   
-  AliGenCorrHF *gener = new AliGenCorrHF(1, 4, 14);  // for charm, 1 pair per event
-  // AliGenCorrHF *gener = new AliGenCorrHF(1, 5, 14);  // for beauty, 1 pair per event
+  AliGenCorrHF *gener = new AliGenCorrHF(1, 4, 6);  // for charm, 1 pair per event
+  // AliGenCorrHF *gener = new AliGenCorrHF(1, 5, 6);  // for beauty, 1 pair per event
   
   gener->SetMomentumRange(0,9999);
   gener->SetCutOnChild(1);          // 1/0 means cuts on children enable/disable
-  gener->SetChildThetaRange(170.0,179.0);
+  gener->SetChildThetaRange(171.0,178.0);
+  gener->SetChildMomentumRange(4.0, 999.);
   gener->SetOrigin(0,0,0);          //vertex position    
   gener->SetForceDecay(kSemiMuonic);
   gener->SetTrackingFlag(1);
@@ -396,31 +395,31 @@ AliGenerator* MbPythiaTunePerugia0() {
 
 //====================================================================================================================================================
 
-AliGenerator* MbPythiaTunePerugia0Jpsi2e() {
+AliGenerator* MbPythiaTunePerugia0Jpsi2mu() {
   
-  comment = comment.Append("Jpsi forced to dielectrons");
+  comment = comment.Append("Jpsi forced to dimuons");
   AliGenParam *jpsi=0x0;
-  if(JpsiHarderPt) jpsi = new AliGenParam(1, AliGenMUONlib::kJpsi, "CDF pp 8.8", "Jpsi");  // 8.8 TeV
+  if (JpsiHarderPt) jpsi = new AliGenParam(1, AliGenMUONlib::kJpsi, "CDF pp 8.8", "Jpsi");  // 8.8 TeV
   else jpsi = new AliGenParam(1, AliGenMUONlib::kJpsi, "CDF pp 7", "Jpsi");  // 7 TeV
   jpsi->SetPtRange(0.,999.);
   jpsi->SetYRange(-1.0, 1.0);
   jpsi->SetPhiRange(0.,360.);
-  jpsi->SetForceDecay(kDiElectron);
+  jpsi->SetOrigin(0,0,0);
+  jpsi->SetForceDecay(kDiMuon);
   return jpsi;
 
 }
 
 //====================================================================================================================================================
 
-AliGenerator* MbPythiaTunePerugia0BtoJpsi2e() {
+AliGenerator* MbPythiaTunePerugia0BtoJpsi2mu() {
 
-  comment = comment.Append(" pp: Pythia (Perugia0) BtoJpsi (1 bbbar per event, 1 b-hadron in |y|<2, 1 J/psi in |y|<2");
+  comment = comment.Append(" pp: Pythia (Perugia0) BtoJpsi (1 bbbar per event, 1 b-hadron, 1 J/psi");
   
   //    Pythia
   AliGenPythia* pythia = new AliGenPythia(-1);
   pythia->SetMomentumRange(0, 999999.);
-  pythia->SetThetaRange(0., 180.);
-  pythia->SetYRange(-2.,2.);
+  pythia->SetYRange(-4.5, -2.0);
   pythia->SetPtRange(0,1000.);
   pythia->SetProcess(kPyBeautyppMNRwmi);
   pythia->SetEnergyCMS(energy);
@@ -432,13 +431,14 @@ AliGenerator* MbPythiaTunePerugia0BtoJpsi2e() {
   //    decays
   pythia->SetCutOnChild(1);
   pythia->SetPdgCodeParticleforAcceptanceCut(443);
-  pythia->SetChildYRange(-2,2);
+  pythia->SetChildYRange(-4.5, -2.0);
   pythia->SetChildPtRange(0,10000.);
   //
   //    decays
-  pythia->SetForceDecay(kBJpsiDiElectron);
+  pythia->SetForceDecay(kBJpsiDiMuon);
   
   return pythia;
+
 }
 
 //====================================================================================================================================================
index 3af1f7f..52105c3 100644 (file)
@@ -11,8 +11,23 @@ void runReconstruction(Int_t seed, const Char_t *recOptions) {
   reco->SetSpecificStorage("GRP/GRP/Data",Form("local://%s",gSystem->pwd()));\r
   \r
   // MUON Tracker -> local:///$OCDB should reflect the content of alien://folder=/alice\r
-  reco->SetSpecificStorage("MUON/Align/Data",      "alien://folder=/alice/simulation/2008/v4-15-Release/Residual");\r
-  //  reco->SetSpecificStorage("MUON/Calib/RecoParam", "alien://folder=/alice/data/2011/OCDB");\r
+  reco->SetDefaultStorage("alien://folder=/alice/simulation/2008/v4-15-Release/Ideal");\r
+  reco->SetSpecificStorage("MUON/Align/Data",     "alien://folder=/alice/simulation/2008/v4-15-Release/Residual");\r
+  reco->SetSpecificStorage("MFT/Align/Data",      "alien://folder=/alice/cern.ch/user/a/auras/OCDB/");\r
+  reco->SetSpecificStorage("MFT/Calib/RecoParam", "alien://folder=/alice/cern.ch/user/a/auras/OCDB/");\r
+\r
+  AliMUONRecoParam *param = AliMUONRecoParam::GetLowFluxParam();\r
+  param->SetPadGoodnessMask(0x8080);      \r
+  for (Int_t iCh=0; iCh<10; iCh++) {\r
+    param->SetDefaultNonBendingReso(iCh,0.2);\r
+    param->SetDefaultBendingReso(iCh,0.2);\r
+  }\r
+  param->SetSigmaCutForTracking(5.);\r
+  param->ImproveTracks(kTRUE, 4.);\r
+  param->SetStripCutForTrigger(1.5);\r
+  param->SetSigmaCutForTrigger(4.);\r
+  param->Print("FULL");\r
+  reco->SetRecoParam("MUON", param);\r
 \r
   reco->SetRunReconstruction("MUON MFT");\r
   reco->SetRunLocalReconstruction("MUON MFT");\r
index 51c0347..9960f2a 100644 (file)
@@ -14,7 +14,9 @@ void runSimulation(Int_t seed,
   simulator->SetRunHLT("");\r
 \r
   // MUON Tracker -> local:///$OCDB should reflect the content of alien://folder=/alice\r
+  simulator->SetDefaultStorage("alien://folder=/alice/simulation/2008/v4-15-Release/Ideal");\r
   simulator->SetSpecificStorage("MUON/Align/Data", "alien://folder=/alice/simulation/2008/v4-15-Release/Ideal");\r
+  simulator->SetSpecificStorage("MFT/Align/Data",  "alien://folder=/alice/cern.ch/user/a/auras/OCDB/");\r
 \r
   // The rest\r
   TStopwatch timer;\r