Some fixes and updates for the embedding :
authorlaphecet <laphecet@f7af4fe6-9843-0410-8265-dc069ae4e863>
Fri, 3 Dec 2010 13:52:28 +0000 (13:52 +0000)
committerlaphecet <laphecet@f7af4fe6-9843-0410-8265-dc069ae4e863>
Fri, 3 Dec 2010 13:52:28 +0000 (13:52 +0000)
  - added a raw2sdigits.sh script to convert a (real) raw data file to SDigits file(s) suitable for embedding
  - added a "-e" option to the AlirootRun_MUONtest.sh test script for embedding real data into the test simulation
  - added an option to runSimulation.C and runReconstruction.C to allow embedding (in particular switch for which OCDB is used)
  - added an option to AliMUONDigitMaker::Raw2Digits to fill SDigits instead of Digits (otherwise the ADC value was filled instead of the required charge)
  - added an option to Config.C to indicate whether or not this will be used for embedding (in which case we switch OFF the noise generation, as the noise
  will naturally come from the real data embedded). Made it compilable to ease debugging (this required mods in rootlogon.C and loadlibs.C)
  - added the possibility to convert real digits into simulated ones in AliMUONDigitStoreV2S::AddConcreteDigit
  (the reverse, converting sim digit into real one, e.g. in AliMUONDigitStoreV2R::AddConcreteDigit, is still forbidden).
  - added a (Is)Converted method to AliMUON(V)Digit to keep track of the digits that were converted from another class

  - fixed AliMUON::Raw2SDigits in order to use the specified sdigit classname, and to fill the correct part (charge instead of ADC) of the digit
  - fixed AliMUONDigitizerV3 to allow merging of digit stores of different classes

(Laurent)

17 files changed:
MUON/AliMUON.cxx
MUON/AliMUONDigit.cxx
MUON/AliMUONDigit.h
MUON/AliMUONDigitMaker.cxx
MUON/AliMUONDigitMaker.h
MUON/AliMUONDigitStoreV2S.cxx
MUON/AliMUONDigitizerV3.cxx
MUON/AliMUONDigitizerV3.h
MUON/AliMUONVDigit.h
MUON/AlirootRun_MUONtest.sh
MUON/Config.C
MUON/MUONefficiency.C
MUON/loadlibs.C
MUON/raw2sdigits.sh [new file with mode: 0755]
MUON/rootlogon.C
MUON/runReconstruction.C
MUON/runSimulation.C

index 10a60f0..5bce7df 100644 (file)
@@ -508,21 +508,23 @@ void AliMUON::Digits2Raw()
 //_____________________________________________________________________
 Bool_t AliMUON::Raw2SDigits(AliRawReader* rawReader)
 {
-/// Convert  raw data to SDigit
-
+  /// Convert  raw data to SDigit
+  
   if (!fLoader->TreeS()) fLoader->MakeSDigitsContainer();
-
+  
   TTree* treeS = fLoader->TreeS();
   
-  AliMUONVDigitStore* sDigitStore = new AliMUONDigitStoreV1;
+  AliMUONVDigitStore* sDigitStore = AliMUONVDigitStore::Create(DigitStoreClassName());
+  
   sDigitStore->Connect(*treeS);
   
-  fDigitMaker->Raw2Digits(rawReader,sDigitStore,0x0);
+  if (!fDigitMaker) fDigitMaker = new AliMUONDigitMaker;
+  fDigitMaker->Raw2Digits(rawReader,sDigitStore,0x0,kTRUE);
   treeS->Fill();
   fLoader->WriteSDigits("OVERWRITE");
-
+  
   fLoader->UnloadSDigits();
-
+  
   delete sDigitStore;
   
   return kTRUE;
index 793d3ad..f8c5882 100644 (file)
@@ -239,6 +239,15 @@ AliMUONDigit::IsCalibrated() const
   return (fFlags & fgkCalibratedMask );
 }
 
+//_____________________________________________________________________________
+Bool_t
+AliMUONDigit::IsConverted() const
+{
+  /// Whether this digit is converted or not
+  
+  return (fFlags & fgkConverted);
+}
+
 
 //_____________________________________________________________________________
 Bool_t
@@ -387,6 +396,22 @@ AliMUONDigit::Saturated(Bool_t value)
 }
 
 //_____________________________________________________________________________
+void
+AliMUONDigit::Converted(Bool_t value)
+{
+  /// Set the convertion status of this digit.
+  
+  if ( value )
+  {
+    fFlags |= fgkConverted;
+  }
+  else
+  {
+    fFlags &= ~fgkConverted;
+  }
+}
+
+//_____________________________________________________________________________
 Int_t
 AliMUONDigit::Track(Int_t i) const
 {
index f895d25..b748c32 100644 (file)
@@ -52,12 +52,14 @@ class AliMUONDigit : public AliMUONVDigit
     virtual Bool_t IsSaturated() const;
     virtual Bool_t IsNoiseOnly() const;
     virtual Bool_t IsEfficiencyApplied() const;
+    virtual Bool_t IsConverted() const;
     virtual UInt_t StatusMap() const { return fStatusMap; }    ///< Return Neighbouring pad status
     
     virtual void NoiseOnly(Bool_t value=kTRUE);
     virtual void Saturated(Bool_t saturated=kTRUE);
     virtual void EfficiencyApplied(Bool_t value=kTRUE);
-    
+    virtual void Converted(Bool_t value=kTRUE);
+  
     virtual void SetADC(Int_t adc)         {fADC=adc; }        ///< Set ADC value
     virtual void SetPadXY(Int_t padx, Int_t pady)        {fPadX = padx; fPadY=pady; }      ///< Set pad number along x
     virtual void SetCharge(Float_t q)        {fSignal = q;}    ///< Set charge
@@ -116,8 +118,9 @@ private:
     static const UInt_t fgkCalibratedMask = 0x100; ///< whether this digits has been calibrated
     static const UInt_t fgkNoiseOnlyMask = 0x1000; ///< indicate a simulated digit due to noise only
     static const UInt_t fgkEfficiencyMask = 0x2000; ///< indicate chamber efficiency has been applied to a simulated digit
-    
-    ClassDef(AliMUONDigit,10)  //Digits for MUON
+    static const UInt_t fgkConverted       = 0x4000; ///< has been converted from a real digit
+  
+    ClassDef(AliMUONDigit,11)  //Digits for MUON
 };
 
 #endif
index 159b99b..19806ac 100644 (file)
@@ -173,8 +173,9 @@ AliMUONDigitMaker::Print(Option_t*) const
 //____________________________________________________________________
 Int_t
 AliMUONDigitMaker::Raw2Digits(AliRawReader* rawReader, 
-                                        AliMUONVDigitStore* digitStore,
-                                        AliMUONVTriggerStore* triggerStore)
+                              AliMUONVDigitStore* digitStore,
+                              AliMUONVTriggerStore* triggerStore,
+                              Bool_t sdigit)
 {
   /// Main method to creates digit
   /// for tracker 
@@ -198,7 +199,7 @@ AliMUONDigitMaker::Raw2Digits(AliRawReader* rawReader,
   if ( fDigitStore ) 
   {
     fDigitStore->Clear(); // insure we start with an empty container
-    tracker = ReadTrackerDDL(rawReader);
+    tracker = ReadTrackerDDL(rawReader,sdigit);
   }
   
   if ( fTriggerStore || fMakeTriggerDigits ) 
@@ -219,7 +220,7 @@ AliMUONDigitMaker::Raw2Digits(AliRawReader* rawReader,
 
 //____________________________________________________________________
 Int_t
-AliMUONDigitMaker::ReadTrackerDDL(AliRawReader* rawReader)
+AliMUONDigitMaker::ReadTrackerDDL(AliRawReader* rawReader, Bool_t sdigit)
 {
   /// Reading tracker DDL
   /// filling the fDigitStore container, which must not be null
@@ -289,8 +290,14 @@ AliMUONDigitMaker::ReadTrackerDDL(AliRawReader* rawReader)
     
     digit->SetPadXY(pad.GetIx(),pad.GetIy());
     
-    digit->SetADC(charge);
-
+    if ( sdigit ) 
+    {
+      digit->SetCharge(charge);
+    }
+    else
+    {
+      digit->SetADC(charge);
+    }
   }
   
   if ( fRawStreamTracker->IsErrorMessage() ) 
index 0db6117..d321589 100644 (file)
@@ -46,9 +46,10 @@ class AliMUONDigitMaker : public TObject
   // write raw data
   Int_t  Raw2Digits(AliRawReader* rawReader, 
                     AliMUONVDigitStore* digitContainer=0,
-                    AliMUONVTriggerStore* triggerStore=0);
+                    AliMUONVTriggerStore* triggerStore=0,
+                    Bool_t sdigit=kFALSE);
 
-  Int_t  ReadTrackerDDL(AliRawReader* rawReader);
+  Int_t  ReadTrackerDDL(AliRawReader* rawReader, Bool_t sdigit);
   Int_t  ReadTriggerDDL(AliRawReader* rawReader);
   
   Int_t TriggerDigits(Int_t nBoard, const TArrayS* xyPattern, 
index 3bdd6c6..c0368b2 100644 (file)
@@ -53,12 +53,18 @@ AliMUONDigitStoreV2S::AddConcreteDigit(TClonesArray& a,
                                        const AliMUONVDigit& digit,
                                        Int_t index)
 {
-  /// add a digit to this store
-  const AliMUONDigit* d = dynamic_cast<const AliMUONDigit*>(&digit);
+  /// add a digit to this store  
   
-  if ( !d ) return 0x0;
-  
-  return new(a[index]) AliMUONDigit(*d);
+  if ( digit.IsA() != AliMUONDigit::Class() ) 
+  {
+    AliMUONDigit d(digit.DetElemId(),digit.ManuId(),digit.ManuChannel(),digit.Cathode());
+    d.SetCharge(digit.Charge());
+    d.SetADC(digit.ADC());
+    d.Converted();
+    return new(a[index]) AliMUONDigit(d);
+  }
+
+  return new(a[index]) AliMUONDigit(static_cast<const AliMUONDigit&>(digit));
 }
 
 //_____________________________________________________________________________
index 4c86d96..5482128 100644 (file)
@@ -104,7 +104,7 @@ fLogger(new AliMUONLogger(1000)),
 fTriggerStore(new AliMUONTriggerStoreV1),
 fDigitStore(0x0),
 fOutputDigitStore(0x0),
-fInputDigitStore(0x0)
+fInputDigitStores(0x0)
 {
   /// Ctor.
 
@@ -125,7 +125,7 @@ AliMUONDigitizerV3::~AliMUONDigitizerV3()
   delete fTriggerStore;
   delete fDigitStore;
   delete fOutputDigitStore;
-  delete fInputDigitStore;
+  delete fInputDigitStores;
   
   AliInfo("Summary of messages");
   fLogger->Print();
@@ -338,12 +338,19 @@ AliMUONDigitizerV3::DecalibrateTrackerDigit(const AliMUONVCalibParam& pedestals,
 
 //_____________________________________________________________________________
 void
-AliMUONDigitizerV3::CreateInputDigitStore()
+AliMUONDigitizerV3::CreateInputDigitStores()
 {
-  /// Create an input digit store, and check that all input files
-  /// actually contains the same type of AliMUONVDigitStore
+  /// Create input digit stores
+  /// 
   
-  fInputDigitStore = 0x0;
+  if (fInputDigitStores)
+  {
+    AliFatal("Should be called only once !");
+  }
+  
+  fInputDigitStores = new TObjArray;
+  
+  fInputDigitStores->SetOwner(kTRUE);
   
   for ( Int_t iFile = 0; iFile < fManager->GetNinputs(); ++iFile )
   {    
@@ -357,19 +364,7 @@ AliMUONDigitizerV3::CreateInputDigitStore()
       AliFatal(Form("Could not get access to input file #%d",iFile));
     }
     
-    AliMUONVDigitStore* inputStore = AliMUONVDigitStore::Create(*iTreeS);
-    
-    if (!fInputDigitStore)
-    {
-      fInputDigitStore = inputStore;
-    }
-    else
-    {
-      if ( inputStore->IsA() != fInputDigitStore->IsA() )
-      {
-        AliFatal("Got different types of AliMUONVDigitStore here. Please implement me.");
-      }
-    }
+    fInputDigitStores->AddAt(AliMUONVDigitStore::Create(*iTreeS),iFile);
   }
 }
 
@@ -385,8 +380,6 @@ AliMUONDigitizerV3::Exec(Option_t*)
     
   AliCodeTimerAuto("",0)
   
-  AliDebug(1, "Running digitizer.");
-  
   if ( fManager->GetNinputs() == 0 )
   {
     AliWarning("No input set. Nothing to do.");
@@ -427,19 +420,22 @@ AliMUONDigitizerV3::Exec(Option_t*)
       AliFatal(Form("Could not get access to input file #%d",iFile));
     }
 
-    if (!fInputDigitStore)
+    if (!fInputDigitStores)
     {
-      CreateInputDigitStore();
+      CreateInputDigitStores();      
     }
-    fInputDigitStore->Connect(*iTreeS);
     
-    iTreeS->GetEvent(0);
+    AliMUONVDigitStore* dstore = static_cast<AliMUONVDigitStore*>(fInputDigitStores->At(iFile));
+    
+    dstore->Connect(*iTreeS);
     
-    MergeWithSDigits(fDigitStore,*fInputDigitStore,fManager->GetMask(iFile));
+    iTreeS->GetEvent(0);
+
+    MergeWithSDigits(fDigitStore,*dstore,fManager->GetMask(iFile));
 
     inputLoader->UnloadSDigits();
     
-    fInputDigitStore->Clear();
+    dstore->Clear();
   }
   
   // At this point, we do have digit arrays (one per chamber) which contains 
index ca1c6df..5c8a9c9 100644 (file)
@@ -79,7 +79,7 @@ private:
   
   static TF1* NoiseFunction();
   
-  void CreateInputDigitStore();
+  void CreateInputDigitStores();
 
 private:
   Bool_t fIsInitialized; ///< are we initialized ?
@@ -93,9 +93,9 @@ private:
   AliMUONVTriggerStore* fTriggerStore; //!< trigger objects
   AliMUONVDigitStore* fDigitStore; //!< temporary digits
   AliMUONVDigitStore* fOutputDigitStore; //!< digits we'll output to disk
-  AliMUONVDigitStore* fInputDigitStore; //!< input digit store
+  TObjArray* fInputDigitStores; //!< input digit stores (one per input file
   
-  ClassDef(AliMUONDigitizerV3,9) // MUON Digitizer V3-9
+  ClassDef(AliMUONDigitizerV3,10) // MUON Digitizer V3-9
 };
 
 #endif
index 0bcbd93..b0d66e3 100644 (file)
@@ -69,6 +69,9 @@ public:
   /// Set the calibrated status
   virtual void Calibrated(Bool_t value)=0;
   
+  /// Whether or not this digit was obtained from a conversion (e.g. real to simulated)
+  virtual Bool_t IsConverted() const { return kFALSE; }
+
   /// Whether this digit is used somewhere (typically in a cluster)
   virtual Bool_t IsUsed() const = 0;
   /// Set the used status
index 6ececed..9aa2cc7 100755 (executable)
@@ -15,7 +15,7 @@ RECOPTIONS="SAVEDIGITS" # default reconstruction options
 MC=""    # G3 Simulation with old Config.C 
 #MC="g3"  # G3 Simulation (with new config macros)
 #MC="g4"  # G4 Simulation (with new config macros)
-SIMCONFIG="$ALICE_ROOT/MUON/"$MC"Config.C"   # default simulation configuration file
+
 OUTDIR=""
 CURDIR=`pwd`
 
@@ -24,12 +24,15 @@ SEED=1234567 # random number generator seed
 SIMDIR="generated" # sub-directory where to move simulated files prior to reco
 DUMPEVENT=5 # event to be dump on files
 
+SIMCONFIG="$ALICE_ROOT/MUON/"$MC"Config.C"
+EMBEDWITH="" # no embedding by default
+
 # next try to see if there are options of this script that want to change the
 # defaults
  
 EXIT=0
 
-while getopts "SRZX:srxzn:tg:p:d:c:" option
+while getopts "SRZX:srxzn:tg:p:d:c:e:" option
 do
   case $option in
     R ) RECONSTRUCTION=1;;
@@ -49,6 +52,7 @@ do
     n ) NEVENTS=$OPTARG;;
     g ) SEED=$OPTARG;;
     p ) RECOPTIONS=$OPTARG;; 
+    e ) EMBEDWITH=$OPTARG;;
     *     ) echo "Unimplemented option chosen."
     EXIT=1
     ;;
@@ -79,14 +83,19 @@ if [ $# -gt 0 ] || [ "$EXIT" -eq 1 ]; then
   echo "       -p recoptions (quotified string) reconstruction options to use (default \"$RECOPTIONS\")"
   echo "       -d full path to output directory (default $OUTDIR)"
   echo "       -c full path to configuration file for simulation (default $SIMCONFIG)"
+  echo "       -e full path to a galice.root file relating to SDigits to be merged (embedding)"
   exit 4;
 fi
 
+
 # printout the options
 echo "sim $SIMULATION rec $RECONSTRUCTION check $CHECKS"
 if [ "$SIMULATION" -eq 1 ]; then
   echo "$NEVENTS events will be simulated, using the config found at $SIMCONFIG"
 fi
+if [ -n "$EMBEDWITH" ]; then
+  echo "Will embed simulation with $EMBEDWITH"
+fi
 if [ "$RECONSTRUCTION" -eq 1 ]; then
 echo "Reconstruction options to be used : $RECOPTIONS"
 if [ "$RAW" -eq 0 ]; then
@@ -142,7 +151,7 @@ if [ ! -f $ALICE_ROOT/OCDB/GRP/CTP/Config/Run0_999999999_v0_s1.root ]; then
   echo "Updating GRP CTP config  ..."
 
   aliroot -b > $OUTDIR/updateCDBCTPConfig.out 2>&1 << EOF
-  .L UpdateCDBCTPConfig.C+
+  .L UpdateCDBCTPConfig.C++g
   UpdateCDBCTPConfig();
   .q
 EOF
@@ -160,7 +169,7 @@ if [ "$SIMULATION" -eq 1 ]; then
 
   echo "Running simulation  ..."
 
-  aliroot -l -b -q runSimulation.C\($SEED,$NEVENTS,\""$SIMCONFIG"\"\) > $OUTDIR/testSim.out 2>&1
+  aliroot -l -b -q runSimulation.C\($SEED,$NEVENTS,\""$SIMCONFIG"\"\,\""$EMBEDWITH"\"\) > $OUTDIR/testSim.out 2>&1
 
   mkdir $OUTDIR/$SIMDIR
 
@@ -205,13 +214,19 @@ if [ "$RECONSTRUCTION" -eq 1 ]; then
 
   cd $OUTDIR
   
+  BOOLEMBED=kFALSE
+  
+  if [ -n "$EMBEDWITH" ]; then
+    BOOLEMBED=kTRUE
+  fi
+  
   if [ "$RAW" -eq 1 ]; then
   
-    aliroot -l -b -q runReconstruction\.C\($SEED,\""$OUTDIR/raw.root"\",\""$RECOPTIONS"\"\) > $OUTDIR/testReco.out 2>&1
+    aliroot -l -b -q runReconstruction\.C\($SEED,\""$OUTDIR/raw.root"\",\""$RECOPTIONS"\",$BOOLEMBED\) > $OUTDIR/testReco.out 2>&1
 
   else
 
-    aliroot -l -b -q runReconstruction\.C\($SEED,\"""\",\""$RECOPTIONS"\"\) > $OUTDIR/testReco.out  2>&1
+    aliroot -l -b -q runReconstruction\.C\($SEED,\"""\",\""$RECOPTIONS"\",$BOOLEMBED\) > $OUTDIR/testReco.out  2>&1
   
   fi
   
@@ -230,7 +245,7 @@ if [ "$CHECKS" -eq 1 ]; then
     echo "Running efficiency  ..."
 
     aliroot -b > $OUTDIR/testResults.out 2>&1 << EOF
-    .L MUONefficiency.C+
+    .L MUONefficiency.C++g
     // no argument assumes Upsilon but MUONefficiency(443) works on Jpsi
     MUONefficiency("$OUTDIR/$SIMDIR/galice.root");
     .q
@@ -240,7 +255,7 @@ EOF
 
       echo "Running Trigger efficiency  ..."
       aliroot -b > $OUTDIR/testTriggerResults.out 2>&1 << EOF
-      .L MUONTriggerEfficiency.C+
+      .L MUONTriggerEfficiency.C++g
       MUONTriggerEfficiency("$OUTDIR/$SIMDIR/galice.root", "$OUTDIR/galice.root", 1);
       .q
 EOF
@@ -250,7 +265,7 @@ EOF
         echo "Running check ..."
         aliroot -b > $OUTDIR/testCheck.out 2>&1 << EOF
         gSystem->Load("libMUONevaluation");
-        .L MUONCheck.C+
+        .L MUONCheck.C++g
         MUONCheck(0, $NEVENTS-1, "$OUTDIR/$SIMDIR/galice.root", "$OUTDIR/galice.root", "$OUTDIR/AliESDs.root"); 
         .q
 EOF
@@ -262,7 +277,7 @@ EOF
 
   if [ -f "$OUTDIR/$SIMDIR/galice.root" ]; then
     aliroot -l -b  << EOF
-    AliCDBManager* man = AliCDBManager::Instance();
+    AliCDBManager* man = AliCDBManager::Instance();    
     man->SetDefaultStorage("local://$ALICE_ROOT/OCDB");
     AliMUONMCDataInterface mcdSim("$OUTDIR/$SIMDIR/galice.root");
     mcdSim.DumpKine($DUMPEVENT);       > $OUTDIR/dump.$DUMPEVENT.kine
index cbf3b22..18f4a6f 100644 (file)
 /// Remember to define the directory and event generator option:
 ///
 /// gAlice->SetConfigFunction("Config('$HOME','box');");
+///
+/// Can be compiled by :
+/// .L Config.C+
+/// (depends on the correct rootlogon.C though...)
+
+#if !defined(__CINT__) || defined(__MAKECINT__)
+
+#include "AliABSOv3.h"
+#include "AliBODY.h"
+#include "AliConfig.h"
+#include "AliDIPOv3.h"
+#include "AliDecayerPythia.h"
+#include "AliFRAMEv2.h"
+#include "AliGenBox.h"
+#include "AliGenFixed.h"
+#include "AliGenHijing.h"
+#include "AliGenMUONCocktail.h"
+#include "AliGenMUONlib.h"
+#include "AliGenParam.h"
+#include "AliGenScan.h"
+#include "AliHALLv3.h"
+#include "AliITSv11Hybrid.h"
+#include "AliMAG.h"
+#include "AliMagF.h"
+#include "AliMUONv1.h"
+#include "AliPIPEv3.h"
+#include "AliRun.h"
+#include "AliRunLoader.h"
+#include "AliSHILv3.h"
+#include <Riostream.h>
+#include <TDatime.h>
+#include <TGeant3TGeo.h>
+#include <TGeoGlobalMagField.h>
+#include <TPDGCode.h>
+#include <TRandom.h>
+#include <TSystem.h>
+#include <TVirtualMC.h>
+
+//#include "AliZDCv3.h"
+//#include "AliFMDv1.h"
+//#include "AliPMDv1.h"
+//#include "AliVZEROv7.h"
+
+#endif
 
-void Config(char directory[100]="", char option[6]="param", const char* digitstore="AliMUONDigitStoreV2S")
+void Config(const char* directory="", 
+            const char* option="param", 
+            const char* digitstore="AliMUONDigitStoreV2S",
+            bool forEmbedding=kFALSE)
 {
   //=====================================================================
   // Config file for MUON test
   //=====================================================================
   //  Libraries required by geant321
+  
   gSystem->Load("liblhapdf.so");      // Parton density functions
   gSystem->Load("libpythia6.so");     // Pythia
   gSystem->Load("libgeant321.so");
@@ -190,17 +238,17 @@ void Config(char directory[100]="", char option[6]="param", const char* digitsto
   TGeoGlobalMagField::Instance()->SetField(new AliMagF("Maps","Maps", -1., -1, AliMagF::k5kG));
   //============================================================= 
   //=================== Alice BODY parameters =============================
-  AliBODY *BODY = new AliBODY("BODY","Alice envelop");
+  new AliBODY("BODY","Alice envelop");
   //=================== ABSO parameters ============================
-  AliABSO *ABSO = new AliABSOv3("ABSO", "Muon Absorber");
+  new AliABSOv3("ABSO", "Muon Absorber");
   //=================== DIPO parameters ============================
-  AliDIPO *DIPO = new AliDIPOv3("DIPO", "Dipole version 2");
+  new AliDIPOv3("DIPO", "Dipole version 2");
   //================== HALL parameters ============================
-  AliHALL *HALL = new AliHALLv3("HALL", "Alice Hall");
+  new AliHALLv3("HALL", "Alice Hall");
   //=================== PIPE parameters ============================
-  AliPIPE *PIPE = new AliPIPEv3("PIPE", "Beam Pipe");
+  new AliPIPEv3("PIPE", "Beam Pipe");
   //=================== SHIL parameters ============================
-  AliSHIL *SHIL = new AliSHILv3("SHIL", "Shielding Version 2");
+  new AliSHILv3("SHIL", "Shielding Version 2");
 
   //=================== MUON Subsystem ===========================
   AliMUON *MUON = new AliMUONv1("MUON", "default");
@@ -219,12 +267,17 @@ void Config(char directory[100]="", char option[6]="param", const char* digitsto
 
   // Use SetDigitStoreClassName() to change the digitStore implementation used by (s)digitizer
   MUON->SetDigitStoreClassName(digitstore);
-  
-  cout << "MUON DigitStore is " << MUON->DigitStoreClassName().Data() << endl;
-  
-  // Noise-only digits in tracker/trigger (0=no noise, 1=default (noise in tracker), 2=noise in tracker and trigger):
-  //MUON->SetDigitizerWithNoise(kFALSE);
 
+  if ( forEmbedding ) 
+  {
+    // Noise-only digits in tracker/trigger (0=no noise, 1=default (noise in tracker), 2=noise in tracker and trigger):
+    cout << "****** DISABLING NOISE GENERATION AS WE DO EMBEDDING ******" << endl;
+    MUON->SetDigitizerWithNoise(0);
+    
+    new AliITSv11Hybrid("ITS","ITS v11Hybrid");
+    
+  }
+  
   // Use non-high performance raw data decoder 
   //MUON->SetFastTrackerDecoder(kFALSE);  
   //MUON->SetFastTriggerDecoder(kFALSE);  
index 1e7313d..565b0db 100644 (file)
@@ -66,8 +66,8 @@
 
 #endif
 
-Bool_t MUONefficiency(char* filename = "generated/galice.root", char* esdFileName = "AliESDs.root",
-                     char* geoFilename = "geometry.root", char* ocdbPath = "local://$ALICE_ROOT/OCDB",
+Bool_t MUONefficiency(const char* filename = "generated/galice.root", const char* esdFileName = "AliESDs.root",
+                     const char* geoFilename = "geometry.root", const char* ocdbPath = "local://$ALICE_ROOT/OCDB",
                      Int_t ExtrapToVertex = -1, Int_t ResType = 553, Int_t FirstEvent = 0, Int_t LastEvent = 1000000 )
 { 
 /// \param ExtrapToVertex (default -1) 
index e8a2532..101c9c2 100644 (file)
@@ -66,4 +66,14 @@ void loadlibs ()
   gSystem->Load("libMUONcalign");
   
   gSystem->Load("libMUONgraphics");
+
+  gSystem->Load("libEVGEN");
+  gSystem->Load("libgeant321");
+  gSystem->Load("libhijing");
+  gSystem->Load("libFASTSIM");
+  gSystem->Load("libThijing");
+  gSystem->Load("libEGPythia6");
+  gSystem->Load("libPythia6");
+  gSystem->Load("libAliPythia6");
+  
 }
diff --git a/MUON/raw2sdigits.sh b/MUON/raw2sdigits.sh
new file mode 100755 (executable)
index 0000000..651a532
--- /dev/null
@@ -0,0 +1,35 @@
+#!/bin/sh
+
+# raw2sdigits.sh rawfile [esdfile]
+#
+# convert a (real) raw data file into SDigits suitable for embedding.
+# if esdfile is present (should correspond to the raw data file ;-) )
+# then zvertex is taken from it
+
+rawfile=$1
+esdfile=""
+
+if [ $# -ge 2 ]; then
+ esdfile=$2
+fi
+
+echo "rawfile=$rawfile esdfile=$esdfile"
+
+aliroot -l -b << EOF
+
+    AliSimulation sim("$ALICE_ROOT/MUON/Config.C");
+    gAlice->SetConfigFunction("Config(\"\", \"param\", \"AliMUONDigitStoreV2R\",kTRUE);");
+    AliCDBManager *cdbm = AliCDBManager::Instance();
+    AliRawReader* reader = AliRawReader::Create(gSystem->ExpandPathName("$rawfile"));
+    reader->NextEvent();
+    Int_t runNumber = reader->GetRunNumber();
+    delete reader;
+    cout << "SETTING RUN NUMBER TO " << runNumber << endl;
+    cdbm->SetRun(runNumber);
+    cdbm->SetDefaultStorage("local://$ALICE_ROOT/OCDB");     
+    cdbm->SetSpecificStorage("GRP/GRP/Data",Form("local://%s",gSystem->pwd()));
+    sim.SetMakeSDigits("MUON");  
+
+    sim.ConvertRaw2SDigits("$rawfile","$esdfile");
+
+EOF
index 7ad5271..f9c13f8 100644 (file)
   includePath        += "-I${ALICE_ROOT}/MUON ";
   includePath        += "-I${ALICE_ROOT}/MUON/mapping ";
   includePath        += "-I${ALICE_ROOT}/RAW ";
-  includePath        += "-I${ALICE_ROOT}/include";
+  includePath        += "-I${ALICE_ROOT}/include ";
+  includePath        += "-I${ALICE_ROOT}/STRUCT ";
+  includePath        += "-I${GEANT3}/TGeant3 ";
+  includePath        += "-I${ALICE_ROOT}/THijing ";
+
   gSystem->SetIncludePath(includePath.Data());
 }
index 5f497e2..8331f15 100644 (file)
 //#include <TObjectTable.h>
 #endif
 
-void runReconstruction(int seed, const char* input, const char* recoptions)
+void runReconstruction(int seed, const char* input, const char* recoptions, bool embedding)
 { 
   AliCDBManager* man = AliCDBManager::Instance();
-  man->SetDefaultStorage("local://$ALICE_ROOT/OCDB");
-  man->SetSpecificStorage("GRP/GRP/Data",
-                         Form("local://%s",gSystem->pwd()));
+  
+  if ( embedding ) 
+  {
+    cout << "**** WILL USE RAW OCDB AS WE'RE RECONSTRUCTING EMBEDDED DATA" << endl;
+    man->SetDefaultStorage("raw://");
+  }
+  else
+  {
+    man->SetDefaultStorage("local://$ALICE_ROOT/OCDB");
+
+    man->SetSpecificStorage("GRP/GRP/Data",
+                            Form("local://%s",gSystem->pwd()));
+  }
   
   gRandom->SetSeed(seed);
   
   AliReconstruction* MuonRec = new AliReconstruction("galice.root");
-  MuonRec->SetInput(input);
-  MuonRec->SetRunVertexFinder(kFALSE);
-  MuonRec->SetRunLocalReconstruction("MUON");
-  MuonRec->SetRunTracking("MUON");
+  MuonRec->SetInput(gSystem->ExpandPathName(input));
+  MuonRec->SetRunReconstruction("MUON");
   MuonRec->SetFillESD("HLT");
   MuonRec->SetOption("HLT", "libAliHLTMUON.so");
-  MuonRec->SetLoadAlignData("MUON");
   MuonRec->SetNumberOfEventsPerFile(1000);
   MuonRec->SetOption("MUON",recoptions);
   MuonRec->SetRunQA("MUON:ALL");
   MuonRec->SetQAWriteExpert(AliQAv1::kMUON);
+  MuonRec->SetQARefDefaultStorage("local://$ALICE_ROOT/QAref") ;
+  MuonRec->SetWriteESDfriend(kFALSE);
+  MuonRec->SetCleanESD(kFALSE);  
+  MuonRec->SetStopOnError(kFALSE);
+  
   // uncomment the following lines if you want to set custom RecoParam
   // instead of getting them from the OCDB
   //  AliMUONRecoParam *muonRecoParam = AliMUONRecoParam::GetLowFluxParam();
index 0456990..db8ecd9 100644 (file)
 #include <TRandom.h>
 #endif
 
-void runSimulation(int seed, int nevents, const char* config)
+void runSimulation(int seed, 
+                   int nevents, 
+                   const char* config,
+                   const char* embedwith)
 { 
 // Uncoment following lines to run simulation with local residual mis-alignment
 // (generated via MUONGenerateGeometryData.C macro)
@@ -38,6 +41,47 @@ void runSimulation(int seed, int nevents, const char* config)
 // man->SetSpecificStorage("MUON/Align/Data","local://$ALICE_ROOT/OCDB/MUON/ResMisAlignCDB");
 
   AliSimulation MuonSim(config);
+  
+  if ( strlen(embedwith) > 0 )
+  {
+    // setups specific to embedding
+    
+    gAlice->SetConfigFunction("Config(\"\", \"param\", \"AliMUONDigitStoreV2S\",kTRUE);");
+    
+    // get the run number from real data
+    
+    AliRunLoader* runLoader = AliRunLoader::Open(embedwith,"titi");
+    if (runLoader == 0x0) 
+    {
+      AliError(Form("Cannot open file %s",filename));    
+      return;
+    }
+    
+    runLoader->LoadHeader();
+    
+    if ( ! runLoader->GetHeader() ) {
+      AliError("Cannot load header.");    
+      return;
+    }
+    else {
+      Int_t runNumber = runLoader->GetHeader()->GetRun();
+      MuonSim.SetRunNumber(runNumber);
+      cout << Form("***** RUN NUMBER SET TO %09d ACCORDING TO %s ",runNumber,embedwith) << endl;
+    }  
+    runLoader->UnloadHeader(); 
+    delete runLoader;
+    
+    cout << "***** EMBEDDING MODE : USING RAW OCDB" << endl;
+    AliCDBManager::Instance()->SetDefaultStorage("raw://");
+    AliCDBManager::Instance()->SetSpecificStorage("local://$ALICE_ROOT/OCDB","MUON/Calib/Gains");
+    AliCDBManager::Instance()->SetSpecificStorage("local://$ALICE_ROOT/OCDB","MUON/Align/Data");
+    
+  }
+  else
+  {
+    gAlice->SetConfigFunction("Config(\"\", \"param\", \"AliMUONDigitStoreV2S\",kFALSE);");    
+  }
+  
   MuonSim.SetSeed(seed);
   MuonSim.SetTriggerConfig("MUON");
   MuonSim.SetWriteRawData("MUON HLT","raw.root",kTRUE);
@@ -50,6 +94,11 @@ void runSimulation(int seed, int nevents, const char* config)
 
   MuonSim.SetRunQA("MUON:ALL");
   
+  if ( strlen(embedwith) > 0 ) 
+  {
+    MuonSim.MergeWith(embedwith);
+  }
+  
   MuonSim.Run(nevents);
   //gObjectTable->Print();