void rec_UrQMD() { 
 
  TStopwatch timer; 
  timer.Start(); 
 
  
    // ----  Load libraries   ------------------------------------------------- 
  gROOT->LoadMacro("$VMCWORKDIR/gconfig/basiclibs.C"); 
  basiclibs(); 
  gSystem->Load("libGeoBase"); 
  gSystem->Load("libParBase"); 
  gSystem->Load("libBase"); 
  gSystem->Load("libCbmBase"); 
  gSystem->Load("libCbmData"); 
  gSystem->Load("libField"); 
  gSystem->Load("libGen"); 
  gSystem->Load("libPassive"); 
  gSystem->Load("libMvd"); 
  gSystem->Load("libSts"); 
  gSystem->Load("libRich"); 
  gSystem->Load("libTrd"); 
  gSystem->Load("libTof"); 
  gSystem->Load("libEcal"); 
  gSystem->Load("libGlobal"); 
  gSystem->Load("libKF"); 
  gSystem->Load("libL1"); 
  gSystem->Load("libMinuit2"); // Needs for rich ellipse fitter 
  // ------------------------------------------------------------------------ 
 
 
  const int L1iVerbose = 1; 
  const int nEvents = 2; // from sim file
  const int nEventsToRun =nEvents; 
  const int firstEventToRun = 0; 
  const int lastEventToRun = firstEventToRun+nEventsToRun-1; 
  const bool useMvd = 0; // no maps 
  const bool idealResponse = 0; // real  hits 
  const bool usePipe = 1; 
  TString name; 
  name ="_auau.25gev.centr.v11b4";
 
  TString inFile  = name + ".mc.root"; 
  TString parFile = name + ".params.root"; 
  TString outFile = name + ".rec.root"; 
  TString stsDigiFile; 
  stsDigiFile = "sts_v11b.digi.par"; 
 
  // -----   Reconstruction run   ------------------------------------------- 
  FairRunAna *run= new FairRunAna(); 
  run->SetInputFile(inFile); 
  run->SetOutputFile(outFile); 
  // ------------------------------------------------------------------------ 
 
 //          Adjust this part according to your requirements 
 
  // Verbosity level (0=quiet, 1=event level, 2=track level, 3=debug) 
  Int_t iVerbose = 0; 
 
 
  // ========================================================================= 
  // ===                      STS local reconstruction                     === 
  // ========================================================================= 
 
  // ------- REAL RESPONSE --------- 
 
  // -----   STS digitizer   ------------------------------------------------- 
//  FairTask* stsDigitize = new CbmStsDigitize(iVerbose); 
  Double_t threshold  =  4; 
  Double_t noiseWidth =  0.1; 
  Int_t    nofBits    = 20; 
  Double_t minStep    =  0.01; 
  Double_t StripDeadTime = 10.;//0.3% inefficiency 

      // -------   MVD Digitiser   (simplified version) ----------------------------------------------
    CbmMvdDigitizeL* digi = new CbmMvdDigitizeL("MVDDigitiser", 0, iVerbose);
    cout << "Adding Task:  CbmMvdDigitiser... " << endl;
    run->AddTask(digi);

   
    
    //--- Pile Up -------
    
    Int_t pileUpInMVD=1; // use 1 or higher
    // if no pile-up, no bg-file is needed

    //digi->SetBgFileName(bgFile);
    //digi->SetBgBufferSize(5); //for simulation this buffer should contain > 2 * pileUpInMVD mBias events.
			      //default = few 100 (increase for high pile-up, reduce to limit memory consumption)
    digi->SetPileUp(pileUpInMVD-1);


    //--- Delta electrons -------
    //digi->SetDeltaName(deltaFile);
    //digi->SetDeltaBufferSize(50); //for simulation, this buffer must contain at least pileUpInMVD*200 delta electrons
    digi->SetDeltaEvents(0); //valid for QA-purposes only, use next line for simulations
    //digi->SetDeltaEvents(pileUpInMVD*100); // for simulation assumes 1% target

    //digi->ShowDebugHistograms();
    

    //----------------------------------------------------------------------------
    // -----   MVD Cluster Finder   ----------------------------------------------

    
    CbmMvdFindHits* mvd_hit   = new CbmMvdFindHits("MVDFindHits", 0, iVerbose);
   // mvd_hit->SetSigmaNoise(15,kTRUE);  // kTRUE = add noise to digis, kFALSE = ideal detector
   // mvd_hit->SetSeedThreshold(50); //in electrons!
   // mvd_hit->SetNeighbourThreshold(30);
   // mvd_hit->SetAdcBits(12);
    mvd_hit->SetHitPosErrX(0.0005);
    mvd_hit->SetHitPosErrY(0.0005);
    //mvd_hit->ShowDebugHistograms();
    run->AddTask(mvd_hit);




  CbmStsDigitize* stsDigitize = new CbmStsDigitize("STSDigitize", iVerbose); 
  stsDigitize->SetRealisticResponse(); 
  stsDigitize->SetFrontThreshold (threshold); 
  stsDigitize->SetBackThreshold  (threshold); 
  stsDigitize->SetFrontNoiseWidth(noiseWidth); 
  stsDigitize->SetBackNoiseWidth (noiseWidth); 
 
  stsDigitize->SetFrontNofBits   (nofBits); 
  stsDigitize->SetBackNofBits    (nofBits); 
  stsDigitize->SetFrontMinStep   (minStep); 
  stsDigitize->SetBackMinStep    (minStep); 
 
  stsDigitize->SetStripDeadTime  (StripDeadTime); 
   
 
  if (!idealResponse) run->AddTask(stsDigitize); 
  // ------------------------------------------------------------------------- 
 
 
  // -----   STS Cluster Finder   -------------------------------------------- 
  FairTask* stsClusterFinder = new CbmStsClusterFinder("STS Cluster Finder", 
      iVerbose); 
  if (!idealResponse) run->AddTask(stsClusterFinder); 
  // ------------------------------------------------------------------------- 
 
 
  // -----  STS hit finding   ------------------------------------------------ 
  FairTask* stsFindHits = new CbmStsFindHits(iVerbose); 
  if (!idealResponse) run->AddTask(stsFindHits); 
  // ------------------------------------------------------------------------- 
 
  // -----  STS hit matching   ----------------------------------------------- 
  CbmStsMatchHits* stsMatchHits = new CbmStsMatchHits(iVerbose); 
  if (!idealResponse) run->AddTask(stsMatchHits); 
  // ------------------------------------------------------------------------- 
   
//   ------- IDEAL RESPONSE --------- 
   
  // -----   STS digitizer   ------------------------------------------------- 
  FairTask* stsIdealDigitize = new CbmStsIdealDigitize(iVerbose); 
  if (idealResponse) run->AddTask(stsIdealDigitize); 
  // ------------------------------------------------------------------------- 
 
  // -----  STS hit finding   ------------------------------------------------ 
  FairTask* stsIdealFindHits = new CbmStsIdealFindHits(iVerbose); 
  if (idealResponse) run->AddTask(stsIdealFindHits); 
  // ------------------------------------------------------------------------- 
 
  // -----  STS hit matching   ----------------------------------------------- 
  FairTask* stsIdealMatchHits = new CbmStsIdealMatchHits(iVerbose); 
  if (idealResponse) run->AddTask(stsIdealMatchHits); 
  // ------------------------------------------------------------------------- 
 
 
  // ---  STS track finding   ------------------------------------------------ 
  CbmKF* kalman = new CbmKF();
  run->AddTask(kalman); 
  CbmL1* l1 = new CbmL1("CbmL1",L1iVerbose,3); //new eff 4 consecutive mc points 
  run->AddTask(l1); 
   CbmStsTrackFinder* stsTrackFinder    = new CbmL1StsTrackFinder(); 
//  
    FairTask* stsFindTracks = new CbmStsFindTracks(iVerbose, stsTrackFinder, useMvd); 
//  
   run->AddTask(stsFindTracks); 
  // ------------------------------------------------------------------------- 
   
   
  // ---   STS track matching   ---------------------------------------------- 
   FairTask* stsMatchTracks = new CbmStsMatchTracks(iVerbose); 
   run->AddTask(stsMatchTracks); 
  // ------------------------------------------------------------------------- 
 
 
  // ---   STS track fitting   ----------------------------------------------- 
   CbmStsTrackFitter* stsTrackFitter = new CbmStsKFTrackFitter(); 
   FairTask* stsFitTracks = new CbmStsFitTracks(stsTrackFitter, iVerbose); 
   run->AddTask(stsFitTracks); 
  // ------------------------------------------------------------------------- 
 
  // ===                 End of STS local reconstruction                   === 
 
 
  // -----   Primary vertex finding   --------------------------------------- 
   CbmPrimaryVertexFinder* pvFinder = new CbmPVFinderKF(); 
   CbmFindPrimaryVertex* findVertex = new CbmFindPrimaryVertex(pvFinder); 
   run->AddTask(findVertex); 
  // ------------------------------------------------------------------------ 

 
  // -----  Parameter database   -------------------------------------------- 
  TString stsDigi = gSystem->Getenv("VMCWORKDIR"); 
  stsDigi += "/parameters/sts/"; 
  stsDigi += stsDigiFile; 
  FairRuntimeDb* rtdb = run->GetRuntimeDb(); 
  FairParRootFileIo* parIo1 = new FairParRootFileIo(); 
  FairParAsciiFileIo* parIo2 = new FairParAsciiFileIo(); 
  parIo1->open(parFile.Data()); 
  parIo2->open(stsDigi.Data(),"in"); 
  rtdb->setFirstInput(parIo1); 
  rtdb->setSecondInput(parIo2); 
  rtdb->setOutput(parIo1); 
  rtdb->saveOutput(); 
  
 // -----   Intialise and run   -------------------------------------------- 
//  run->LoadGeometry(); 
  run->Init(); 
  cout << "Starting run" << endl; 
  run->Run(firstEventToRun,lastEventToRun+1); 
  // ------------------------------------------------------------------------ 
 
  //****************** 
  timer.Stop(); 
  Double_t rtime = timer.RealTime(); 
  Double_t ctime = timer.CpuTime(); 
  cout << "Macro finished succesfully." << endl; 
  cout << "Output file is "    << outFile << endl; 
  cout << "Parameter file is " << parFile << endl; 
  printf("RealTime=%f seconds, CpuTime=%f seconds\n",rtime,ctime); 
}