Added new library libFMDutil. This library contains utility classes that
authorcholm <cholm@f7af4fe6-9843-0410-8265-dc069ae4e863>
Tue, 6 Dec 2005 20:56:06 +0000 (20:56 +0000)
committercholm <cholm@f7af4fe6-9843-0410-8265-dc069ae4e863>
Tue, 6 Dec 2005 20:56:06 +0000 (20:56 +0000)
are mainly used for FMD specific tasks, such as reading in FMD data, and so
forth.   Therefor, it's  put in a separate library to not crowd the normal
libraries and binaries with extra code.   See the file AliFMDInput.cxx
for more info.   Updated some of the scripts to use this interface.

Added some docs to some scripts.

Added script to get X-sections, energy loss, and ranges for a given
medium for a given particle type from TGeant3TGeo.

Added a script that compiles and loads other scripts :-)

Fixed some errors reported by Federico

30 files changed:
FMD/AliFMDDigitizer.cxx
FMD/AliFMDGeometry.cxx
FMD/AliFMDInput.cxx [new file with mode: 0644]
FMD/AliFMDInput.h [new file with mode: 0644]
FMD/AliFMDRing.cxx
FMD/FMDutilLinkDef.h [new file with mode: 0644]
FMD/libFMDutil.pkg [new file with mode: 0644]
FMD/scripts/Compile.C [new file with mode: 0644]
FMD/scripts/DrawDetail.C
FMD/scripts/DrawFMD2.C
FMD/scripts/DrawFMD3.C
FMD/scripts/DrawHits.C [new file with mode: 0644]
FMD/scripts/DrawXsection.C [new file with mode: 0644]
FMD/scripts/GetXsection.C [new file with mode: 0644]
FMD/scripts/MakeLego.C
FMD/scripts/MakeMap.C
FMD/scripts/MakeXsection.C [new file with mode: 0644]
FMD/scripts/RawTest.C
FMD/scripts/ShowDigits.C
FMD/scripts/ShowHits.C
FMD/scripts/ShowMult.C
FMD/scripts/ShowRaw.C
FMD/scripts/SimpleGeometry.C
FMD/scripts/VA1Response.C
FMD/scripts/VA1Train.C
FMD/scripts/ViewPIPE.C
FMD/scripts/Wafer.C
FMD/scripts/makelego.sh
FMD/scripts/runflukageo.sh
FMD/scripts/rungeant3geo.sh

index bfb9a27..46851ec 100644 (file)
@@ -306,10 +306,11 @@ AliFMDBaseDigitizer::SumContributions(AliFMD* fmd)
   // Get number of entries in the tree 
   Int_t ntracks  = Int_t(hitsTree->GetEntries());
   
+  Int_t read = 0;
   // Loop over the tracks in the 
   for (Int_t track = 0; track < ntracks; track++)  {
     // Read in entry number `track' 
-    hitsBranch->GetEntry(track);
+    read += hitsBranch->GetEntry(track);
     
     // Get the number of hits 
     Int_t nhits = fmdHits->GetEntries ();
@@ -325,7 +326,7 @@ AliFMDBaseDigitizer::SumContributions(AliFMD* fmd)
       UShort_t strip    = fmdHit->Strip();
       Float_t  edep     = fmdHit->Edep();
       if (fEdep(detector, ring, sector, strip).fEdep != 0)
-       AliDebug(1, Form("Double hit in %d%c(%d,%d)", 
+       AliDebug(5, Form("Double hit in %d%c(%d,%d)", 
                         detector, ring, sector, strip));
       
       fEdep(detector, ring, sector, strip).fEdep  += edep;
@@ -333,6 +334,8 @@ AliFMDBaseDigitizer::SumContributions(AliFMD* fmd)
       // Add this to the energy deposited for this strip
     }  // hit loop
   } // track loop
+  AliDebug(1, Form("Size of cache: %d bytes, read %d bytes", 
+                  sizeof(fEdep), read));
 }
 
 //____________________________________________________________________
@@ -537,7 +540,9 @@ AliFMDDigitizer::Exec(Option_t*)
   fmd->MakeBranchInTree(digitTree, fmd->GetName(), &(digits), 4000, 0);
   // TBranch* digitBranch = digitTree->GetBranch(fmd->GetName());
   // Fill the tree 
-  digitTree->Fill();
+  Int_t write = 0;
+  write = digitTree->Fill();
+  AliDebug(1, Form("Wrote %d bytes to digit tree", write));
   
   // Write the digits to disk 
   outFMD->WriteDigits("OVERWRITE");
index 16b4c84..8743159 100644 (file)
@@ -98,7 +98,8 @@ AliFMDGeometry::Instance()
 
 //____________________________________________________________________
 AliFMDGeometry::AliFMDGeometry() 
-  : AliGeometry("FMD", "Forward multiplicity")
+  : AliGeometry("FMD", "Forward multiplicity"), 
+    fBuilder(0)
 {
   // PROTECTED
   // Default constructor 
diff --git a/FMD/AliFMDInput.cxx b/FMD/AliFMDInput.cxx
new file mode 100644 (file)
index 0000000..3b30fb3
--- /dev/null
@@ -0,0 +1,412 @@
+/**************************************************************************
+ * Copyright(c) 2004, 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$ */
+
+//___________________________________________________________________
+//
+// The classes defined here, are utility classes for reading in data
+// for the FMD.  They are  put in a seperate library to not polute the
+// normal libraries.  The classes are intended to be used as base
+// classes for customized class that do some sort of analysis on the
+// various types of data produced by the FMD. 
+//
+// Latest changes by Christian Holm Christensen
+//
+#include "AliFMDInput.h"       // ALIFMDHIT_H
+#include "AliLog.h"            // ALILOG_H
+#include "Riostream.h"         // ROOT_Riostream
+#include <TDatabasePDG.h>
+#include <TMath.h>
+#include <TString.h>
+#include <TParticle.h>
+#include "AliFMDHit.h"         // ALIFMDHIT_H
+#include "AliFMDDigit.h"               // ALIFMDDigit_H
+#include "AliFMDMultStrip.h"           // ALIFMDMultStrip_H
+#include "AliFMDMultRegion.h"          // ALIFMDMultRegion_H
+
+//____________________________________________________________________
+ClassImp(AliFMDInput)
+#if 0
+  ; // This is here to keep Emacs for indenting the next line
+#endif
+
+
+//____________________________________________________________________
+AliFMDInput::AliFMDInput()
+  : fGAliceFile(""), 
+    fLoader(0),
+    fRun(0), 
+    fStack(0),
+    fFMDLoader(0), 
+    fFMD(0),
+    fTreeE(0),
+    fTreeH(0),
+    fTreeD(0),
+    fTreeS(0),
+    fTreeR(0), 
+    fArrayE(0),
+    fArrayH(0),
+    fArrayD(0),
+    fArrayS(0), 
+    fArrayN(0), 
+    fArrayP(0), 
+    fTreeMask(0), 
+    fIsInit(kFALSE)
+{
+  // Constructor of an FMD input object.  Specify what data to read in
+  // using the AddLoad member function.   Sub-classes should at a
+  // minimum overload the member function Event.   A full job can be
+  // executed using the member function Run. 
+}
+
+  
+
+//____________________________________________________________________
+AliFMDInput::AliFMDInput(const char* gAliceFile)
+  : fGAliceFile(gAliceFile),
+    fLoader(0),
+    fRun(0), 
+    fStack(0),
+    fFMDLoader(0), 
+    fFMD(0),
+    fTreeE(0),
+    fTreeH(0),
+    fTreeD(0),
+    fTreeS(0),
+    fTreeR(0), 
+    fArrayE(0),
+    fArrayH(0),
+    fArrayD(0),
+    fArrayS(0), 
+    fArrayN(0), 
+    fArrayP(0), 
+    fTreeMask(0), 
+    fIsInit(kFALSE)
+{
+  // Constructor of an FMD input object.  Specify what data to read in
+  // using the AddLoad member function.   Sub-classes should at a
+  // minimum overload the member function Event.   A full job can be
+  // executed using the member function Run. 
+}
+
+//____________________________________________________________________
+Int_t
+AliFMDInput::NEvents() const 
+{
+  // Get number of events
+  if (fTreeE) return fTreeE->GetEntries();
+  return -1;
+}
+
+//____________________________________________________________________
+Bool_t
+AliFMDInput::Init()
+{
+  // Initialize the object.  Get the needed loaders, and such. 
+
+  // Check if we have been initialized
+  if (fIsInit) { 
+    AliWarning("Already initialized");
+    return fIsInit;
+  }
+  if (fGAliceFile.IsNull()) fGAliceFile = "galice.root";
+  // Get the loader
+  fLoader = AliRunLoader::Open(fGAliceFile.Data(), "Alice", "read");
+  if (!fLoader) {
+    AliError(Form("Coulnd't read the file %s", fGAliceFile.Data()));
+    return kFALSE;
+  }
+  
+  // Get the run 
+  if  (fLoader->LoadgAlice()) return kFALSE;
+  fRun = fLoader->GetAliRun();
+  
+  // Get the FMD 
+  fFMD = static_cast<AliFMD*>(fRun->GetDetector("FMD"));
+  if (!fFMD) {
+    AliError("Failed to get detector FMD from loader");
+    return kFALSE;
+  }
+  
+  // Get the FMD loader
+  fFMDLoader = fLoader->GetLoader("FMDLoader");
+  if (!fFMDLoader) {
+    AliError("Failed to get detector FMD loader from loader");
+    return kFALSE;
+  }
+  if (fLoader->LoadHeader()) { 
+    AliError("Failed to get event header information from loader");
+    return kFALSE;
+  }
+  fTreeE = fLoader->TreeE();
+  
+  fIsInit = kTRUE;
+  return fIsInit;
+}
+
+//____________________________________________________________________
+Bool_t
+AliFMDInput::Begin(Int_t event)
+{
+  // Called at the begining of each event.  Per default, it gets the
+  // data trees and gets pointers to the output arrays.   Users can
+  // overload this, but should call this member function in the
+  // overloaded member function of the derived class. 
+
+  // Check if we have been initialized
+  if (!fIsInit) { 
+    AliError("Not initialized");
+    return fIsInit;
+  }
+  // Get the event 
+  if (fLoader->GetEvent(event)) return kFALSE;
+  AliInfo(Form("Now in event %d/%d", event, NEvents()));
+
+  // Possibly load global kinematics information 
+  if (TESTBIT(fTreeMask, kKinematics)) {
+    AliInfo("Getting kinematics");
+    if (fLoader->LoadKinematics()) return kFALSE;
+    fStack = fLoader->Stack();
+  }
+  // Possibly load FMD Hit information 
+  if (TESTBIT(fTreeMask, kHits)) {
+    AliInfo("Getting FMD hits");
+    if (fFMDLoader->LoadHits()) return kFALSE;
+    fTreeH = fFMDLoader->TreeH();
+    if (!fArrayH) fArrayH = fFMD->Hits(); 
+  }
+  // Possibly load FMD Digit information 
+  if (TESTBIT(fTreeMask, kDigits)) {
+    AliInfo("Getting FMD digits");
+    if (fFMDLoader->LoadDigits()) return kFALSE;
+    fTreeD = fFMDLoader->TreeD();
+    if (!fArrayD) fArrayD = fFMD->Digits();
+  }
+  // Possibly load FMD Sdigit information 
+  if (TESTBIT(fTreeMask, kSDigits)) {
+    AliInfo("Getting FMD summable digits");
+    if (fFMDLoader->LoadSDigits()) return kFALSE;
+    fTreeS = fFMDLoader->TreeS();
+    if (!fArrayS) fArrayS = fFMD->SDigits();
+  }
+  // Possibly load FMD RecPoints information 
+  if (TESTBIT(fTreeMask, kRecPoints)) {
+    AliInfo("Getting FMD reconstructed points");
+    if (fFMDLoader->LoadRecPoints()) return kFALSE;
+    fTreeR = fFMDLoader->TreeR();
+    if (!fArrayN) fArrayN = new TClonesArray("AliFMDMultStrip");
+    if (!fArrayP) fArrayP = new TClonesArray("AliFMDMultRegion");
+    fTreeR->SetBranchAddress("FMDNaiive",  &fArrayN);
+    fTreeR->SetBranchAddress("FMDPoisson", &fArrayP);
+  }
+  return kTRUE;
+}
+
+//____________________________________________________________________
+Bool_t
+AliFMDInput::End()
+{
+  // Called at the end of each event.  Per default, it unloads the
+  // data trees and resets the pointers to the output arrays.   Users
+  // can overload this, but should call this member function in the
+  // overloaded member function of the derived class. 
+
+  // Check if we have been initialized
+  if (!fIsInit) { 
+    AliError("Not initialized");
+    return fIsInit;
+  }
+  // Possibly unload global kinematics information 
+  if (TESTBIT(fTreeMask, kKinematics)) {
+    fLoader->UnloadKinematics();
+    // fTreeK = 0;
+    fStack = 0;
+  }
+  // Possibly unload FMD Hit information 
+  if (TESTBIT(fTreeMask, kHits)) {
+    fFMDLoader->UnloadHits();
+    fTreeH = 0;
+  }
+  // Possibly unload FMD Digit information 
+  if (TESTBIT(fTreeMask, kDigits)) {
+    fFMDLoader->UnloadDigits();
+    fTreeD = 0;
+  }
+  // Possibly unload FMD Sdigit information 
+  if (TESTBIT(fTreeMask, kSDigits)) {
+    fFMDLoader->UnloadSDigits();
+    fTreeS = 0;
+  }
+  // Possibly unload FMD RecPoints information 
+  if (TESTBIT(fTreeMask, kRecPoints)) {
+    fFMDLoader->UnloadRecPoints();
+    fTreeR = 0;
+  }
+  AliInfo("Now out event");
+  return kTRUE;
+}
+
+//____________________________________________________________________
+Bool_t
+AliFMDInput::Run()
+{
+  // Run over all events and files references in galice.root 
+
+  Bool_t retval;
+  if (!(retval = Init())) return retval;
+
+  Int_t nEvents = NEvents();
+  for (Int_t event = 0; event < nEvents; event++) {
+    if (!(retval = Begin(event))) break;
+    if (!(retval = Event())) break;
+    if (!(retval = End())) break;
+  }
+  if (!retval) return retval;
+  retval = Finish();
+  return retval;
+}
+
+//====================================================================
+ClassImp(AliFMDInputHits)
+#if 0
+  ;
+#endif
+
+Bool_t
+AliFMDInputHits::Event()
+{
+  // Read the hit tree, and pass each hit to the member function
+  // ProcessHit.  Optionally, if the user said `AddLoad(kKinematics)'
+  // the track corresponding to the hit will also be passed to the
+  // ProcessHit member function of the derived class.
+  if (!fTreeH) {
+    AliError("No hit tree defined");
+    return kFALSE;
+  }
+  Int_t nTracks = fTreeH->GetEntries();
+  for (Int_t i = 0; i < nTracks; i++) {
+    Int_t hitRead  = fTreeH->GetEntry(i);
+    if (hitRead <= 0) continue;
+    if (!fArrayH) {
+      AliError("No hit array defined");
+      return kFALSE;
+    }
+    Int_t nHit = fArrayH->GetEntries();
+    if (nHit <= 0) continue;
+    for (Int_t j = 0; j < nHit; j++) {
+      AliFMDHit* hit = static_cast<AliFMDHit*>(fArrayH->At(j));
+      if (!hit) continue;
+      TParticle* track = 0;
+      if (TESTBIT(fTreeMask, kKinematics) && fStack) {
+       Int_t trackno = hit->Track();
+       track = fStack->Particle(trackno);
+      }
+      if (!ProcessHit(hit, track)) return kFALSE;
+    }    
+  }
+  return kTRUE;
+}
+
+//====================================================================
+ClassImp(AliFMDInputDigits)
+#if 0
+  ;
+#endif
+
+Bool_t
+AliFMDInputDigits::Event()
+{
+  // Read the digit tree, and pass each digit to the member function
+  // ProcessDigit.
+  Int_t nEv = fTreeD->GetEntries();
+  for (Int_t i = 0; i < nEv; i++) {
+    Int_t digitRead  = fTreeD->GetEntry(i);
+    if (digitRead <= 0) continue;
+    Int_t nDigit = fArrayD->GetEntries();
+    if (nDigit <= 0) continue;
+    for (Int_t j = 0; j < nDigit; j++) {
+      AliFMDDigit* digit = static_cast<AliFMDDigit*>(fArrayD->At(j));
+      if (!digit) continue;
+      if (!ProcessDigit(digit)) return kFALSE;
+    }    
+  }
+  return kTRUE;
+}
+
+//====================================================================
+ClassImp(AliFMDInputSDigits)
+#if 0
+  ;
+#endif
+
+Bool_t
+AliFMDInputSDigits::Event()
+{
+  // Read the summable digit tree, and pass each sumable digit to the
+  // member function ProcessSdigit.
+  Int_t nEv = fTreeD->GetEntries();
+  for (Int_t i = 0; i < nEv; i++) {
+    Int_t sdigitRead  = fTreeS->GetEntry(i);
+    if (sdigitRead <= 0) continue;
+    Int_t nSdigit = fArrayS->GetEntries();
+    if (nSdigit <= 0) continue;
+    for (Int_t j = 0; j < nSdigit; j++) {
+      AliFMDSDigit* sdigit = static_cast<AliFMDSDigit*>(fArrayS->At(j));
+      if (!sdigit) continue;
+      if (!ProcessSDigit(sdigit)) return kFALSE;
+    }    
+  }
+  return kTRUE;
+}
+
+//====================================================================
+ClassImp(AliFMDInputRecPoints)
+#if 0
+  ;
+#endif
+
+Bool_t
+AliFMDInputRecPoints::Event()
+{
+  // Read the reconstrcted points tree, and pass each reconstruction
+  // object to either ProcessStrip (for AliFMDMultStrip objects), or 
+  // ProcessRegion (for AliFMDMultRegion objects).
+  Int_t nEv = fTreeR->GetEntries();
+  for (Int_t i = 0; i < nEv; i++) {
+    Int_t recRead  = fTreeR->GetEntry(i);
+    if (recRead <= 0) continue;
+    Int_t nRecStrip = fArrayN->GetEntries();
+    for (Int_t j = 0; j < nRecStrip; j++) {
+      AliFMDMultStrip* strip = static_cast<AliFMDMultStrip*>(fArrayN->At(j));
+      if (!strip) continue;
+      if (!ProcessStrip(strip)) return kFALSE;
+    }    
+    Int_t nRecRegion = fArrayP->GetEntries();
+    for (Int_t j = 0; j < nRecRegion; j++) {
+      AliFMDMultRegion* region =static_cast<AliFMDMultRegion*>(fArrayP->At(j));
+      if (!region) continue;
+      if (!ProcessRegion(region)) return kFALSE;
+    }    
+  }
+  return kTRUE;
+}
+
+    
+
+//____________________________________________________________________
+//
+// EOF
+//
diff --git a/FMD/AliFMDInput.h b/FMD/AliFMDInput.h
new file mode 100644 (file)
index 0000000..95681bf
--- /dev/null
@@ -0,0 +1,149 @@
+#ifndef AliFMDInput_H
+#define AliFMDInput_H
+/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights
+ * reserved. 
+ *
+ * See cxx source for full Copyright notice                               
+ */
+//___________________________________________________________________
+//
+// The classes defined here, are utility classes for reading in data
+// for the FMD.  They are  put in a seperate library to not polute the
+// normal libraries.  The classes are intended to be used as base
+// classes for customized class that do some sort of analysis on the
+// various types of data produced by the FMD. 
+//
+#ifndef ALILOADER_H
+# include <AliLoader.h>
+#endif
+#ifndef ALIRUNLOADER_H
+# include <AliRunLoader.h>
+#endif
+#ifndef ALIRUN_H
+# include <AliRun.h>
+#endif
+#ifndef ALISTACK_H
+# include <AliStack.h>
+#endif
+#ifndef ALIFMD_H
+# include <AliFMD.h>
+#endif
+#ifndef ROOT_TTree
+# include <TTree.h>
+#endif
+#ifndef ROOT_TParticle
+# include <TParticle.h>
+#endif
+#ifndef ROOT_TString
+# include <TString.h>
+#endif
+
+//___________________________________________________________________
+class AliFMDInput : public TObject
+{
+public:
+  enum ETrees {
+    kHits       = 1, 
+    kKinematics, 
+    kDigits, 
+    kSDigits, 
+    kHeader, 
+    kRecPoints
+  };
+  AliFMDInput();
+  AliFMDInput(const char* gAliceFile);
+  virtual ~AliFMDInput() {}
+
+  virtual void   AddLoad(ETrees tree)     { SETBIT(fTreeMask, tree); }
+  virtual void   RemoveLoad(ETrees tree)  { CLRBIT(fTreeMask, tree); }
+  virtual Int_t  NEvents() const;
+
+  virtual Bool_t Init();
+  virtual Bool_t Begin(Int_t event);
+  virtual Bool_t Event() = 0;
+  virtual Bool_t End();
+  virtual Bool_t Finish() { return kTRUE; }
+  virtual Bool_t Run();
+protected:
+  TString       fGAliceFile; // File name of gAlice file
+  AliRunLoader* fLoader;     // Loader of FMD data 
+  AliRun*       fRun;        // Run information
+  AliStack*     fStack;      // Stack of particles 
+  AliLoader*    fFMDLoader;  // Loader of FMD data 
+  AliFMD*       fFMD;        // FMD object
+  TTree*        fTreeE;      // Header tree 
+  TTree*        fTreeH;      // Hits tree
+  TTree*        fTreeD;      // Digit tree 
+  TTree*        fTreeS;      // SDigit tree 
+  TTree*        fTreeR;      // RecPoint tree
+  TClonesArray* fArrayE;     // Event info array
+  TClonesArray* fArrayH;     // Hit info array
+  TClonesArray* fArrayD;     // Digit info array
+  TClonesArray* fArrayS;     // SDigit info array
+  TClonesArray* fArrayN;     // Mult (single) info array
+  TClonesArray* fArrayP;     // Mult (region) info array
+  Int_t         fTreeMask;   // Which tree's to load
+  Bool_t        fIsInit;
+  ClassDef(AliFMDInput,0)  //Hits for detector FMD
+};
+
+
+//____________________________________________________________________
+class AliFMDHit;
+class AliFMDInputHits : public AliFMDInput 
+{
+public:
+  AliFMDInputHits(const char* file="galice.root") 
+    : AliFMDInput(file) { AddLoad(kHits); }
+  virtual Bool_t Event();
+  virtual Bool_t ProcessHit(AliFMDHit* hit, TParticle* track) = 0;
+  ClassDef(AliFMDInputHits, 0);
+};
+
+//____________________________________________________________________
+class AliFMDDigit;
+class AliFMDInputDigits : public AliFMDInput 
+{
+public:
+  AliFMDInputDigits(const char* file="galice.root")
+    : AliFMDInput(file) { AddLoad(kDigits); }
+  virtual Bool_t Event();
+  virtual Bool_t ProcessDigit(AliFMDDigit* digit) = 0;
+  ClassDef(AliFMDInputDigits, 0);
+};
+
+//____________________________________________________________________
+class AliFMDSDigit;
+class AliFMDInputSDigits : public AliFMDInput 
+{
+public:
+  AliFMDInputSDigits(const char* file="galice.root") 
+    : AliFMDInput(file) { AddLoad(kSDigits); }
+  virtual Bool_t Event();
+  virtual Bool_t ProcessSDigit(AliFMDSDigit* sdigit) = 0;
+  ClassDef(AliFMDInputSDigits, 0);
+};
+
+//____________________________________________________________________
+class AliFMDMultStrip;
+class AliFMDMultRegion;
+class AliFMDInputRecPoints : public AliFMDInput 
+{
+public:
+  AliFMDInputRecPoints(const char* file="galice.root") 
+    : AliFMDInput(file) { AddLoad(kRecPoints); }
+  virtual Bool_t Event();
+  virtual Bool_t ProcessStrip(AliFMDMultStrip* mult) = 0;
+  virtual Bool_t ProcessRegion(AliFMDMultRegion* mult) = 0;
+  ClassDef(AliFMDInputRecPoints, 0);
+};
+
+#endif
+//____________________________________________________________________
+//
+// Local Variables:
+//   mode: C++
+// End:
+//
+// EOF
+//
index 93a9323..c2b0ae8 100644 (file)
@@ -54,6 +54,7 @@ AliFMDRing::AliFMDRing(Char_t id)
   SetPrintboardThickness();
   SetCopperThickness();
   SetChipThickness();
+  SetSpacing();
   
   if (fId == 'I' || fId == 'i') {
     SetLowR(4.3);
diff --git a/FMD/FMDutilLinkDef.h b/FMD/FMDutilLinkDef.h
new file mode 100644 (file)
index 0000000..789e4e3
--- /dev/null
@@ -0,0 +1,28 @@
+// -*- mode: c++ -*- 
+/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights
+ * reserved. 
+ *
+ * See cxx source for full Copyright notice                               
+ */
+
+/* $Id$ */
+#ifdef __CINT__
+
+#pragma link off all globals;
+#pragma link off all classes;
+#pragma link off all functions;
+
+// #pragma link C++ class  std::pair<Float_t,UShort_t>;
+// #pragma link C++ class  AliFMDMap<std::pair<Float_t,UShort_t> >;
+// #pragma link C++ typedef  AliFMDEdepMap;
+#pragma link C++ class  AliFMDInput;
+#pragma link C++ class  AliFMDInputHits;
+#pragma link C++ class  AliFMDInputDigits;
+#pragma link C++ class  AliFMDInputSDigits;
+
+#else
+# error Not for compilation 
+#endif
+//
+// EOF
+//
diff --git a/FMD/libFMDutil.pkg b/FMD/libFMDutil.pkg
new file mode 100644 (file)
index 0000000..9804874
--- /dev/null
@@ -0,0 +1,11 @@
+#-*- Mode: Makefile -*-
+#
+# $Id$
+
+SRCS           =  AliFMDInput.cxx                              
+HDRS           =  $(SRCS:.cxx=.h) 
+DHDR           := FMDutilLinkDef.h
+
+#
+# EOF
+#
\ No newline at end of file
diff --git a/FMD/scripts/Compile.C b/FMD/scripts/Compile.C
new file mode 100644 (file)
index 0000000..8e83cc7
--- /dev/null
@@ -0,0 +1,21 @@
+//
+// $Id$
+//
+// Script to compile (using ACLic) and load a script.  It sets the
+// include path to contain the relevant directories. 
+//
+void
+Compile(const char* script)
+{
+  gSystem->Load("libFMDutil.so");
+  gSystem->SetIncludePath("-I`root-config --incdir` "
+                         "-I${ALICE_ROOT}/include " 
+                         "-I${ALICE_ROOT}/FMD "
+                         "-I${ALICE_ROOT}/geant3/TGeant3");
+  gROOT->ProcessLine(Form(".L %s++g", script));
+}
+
+//____________________________________________________________________
+//
+// EOF
+// 
index d0bb38d..9c0a39b 100644 (file)
@@ -1,4 +1,6 @@
 //
+//  $Id$
+// 
 // Script to draw detail of the FMD
 //
 void DrawDetail()
@@ -60,3 +62,7 @@ void DrawDetail()
   gPad->cd();
   gPad->Print("FMD3_detail.png");
 }
+//____________________________________________________________________
+//
+// EOF
+//
index 81c1374..05c9515 100644 (file)
@@ -1,4 +1,6 @@
 //
+// $Id$
+// 
 // Script to draw detail of the FMD
 //
 void DrawFMD2()
@@ -59,3 +61,7 @@ void DrawFMD2()
   gPad->cd();
   gPad->Print("FMD2.png");
 }
+//____________________________________________________________________
+//
+// EOF
+//
index 7414f4d..f752fd8 100644 (file)
@@ -1,4 +1,6 @@
 //
+// $Id$
+//
 // Script to draw detail of the FMD
 //
 void DrawFMD3()
@@ -53,3 +55,7 @@ void DrawFMD3()
   gPad->cd();
   gPad->Print("FMD3.png");
 }
+//____________________________________________________________________
+//
+// EOF
+//
diff --git a/FMD/scripts/DrawHits.C b/FMD/scripts/DrawHits.C
new file mode 100644 (file)
index 0000000..130e878
--- /dev/null
@@ -0,0 +1,55 @@
+//
+// $Id$
+//
+// Script that contains a class to draw hits, using the
+// AliFMDInputHits class in the util library. 
+//
+// It draws the energy loss versus the p/(mq^2).  It can be overlayed
+// with the Bethe-Bloc curve to show how the simulation behaves
+// relative to the expected. 
+//
+// Use the script `Compile.C' to compile this class using ACLic. 
+//
+#include <TH2D.h>
+#include <AliFMDHit.h>
+#include <AliFMDInput.h>
+#include <iostream>
+#include <TStyle.h>
+
+class DrawHits : public AliFMDInputHits
+{
+private:
+  TH2D* fElossVsPMQ; // Histogram 
+public:
+  DrawHits() 
+  { 
+    fElossVsPMQ = new TH2D("bad", "#Delta E vs. p/(mq^{2})>1GeV", 
+                    1000, 1, 100, 50, 0.00001, 10);
+    fElossVsPMQ->SetXTitle("p/(mq^{2}) [GeV/GeV]");
+    fElossVsPMQ->SetYTitle("#Delta E [MeV]");
+  }
+  Bool_t ProcessHit(AliFMDHit* hit, TParticle*) 
+  {
+    if (!hit) {
+      std::cout << "No hit" << std::endl;
+      return kFALSE;
+    }
+    Float_t pmq = 0;
+    if (hit->M() != 0 && hit->Q() != 0) 
+      pmq = hit->P() / hit->M() / TMath::Power(hit->Q()/3, 2);
+    fElossVsPMQ->Fill(pmq, hit->Edep());
+    return kTRUE;
+  }
+  Bool_t Finish()
+  {
+    gStyle->SetPalette(1);
+    fElossVsPMQ->SetStats(kFALSE);
+    fElossVsPMQ->Draw("COLZ");
+    return kTRUE;
+  }
+};
+
+//____________________________________________________________________
+//
+// EOF
+//
diff --git a/FMD/scripts/DrawXsection.C b/FMD/scripts/DrawXsection.C
new file mode 100644 (file)
index 0000000..fb53a3a
--- /dev/null
@@ -0,0 +1,46 @@
+void
+DrawXsection(const char* file="xsec.root", 
+            const char* var="LOSS", 
+            const char* medName="FMD_Si$", 
+            Double_t thick=.03,
+            const char* pdgName="pi+")
+{
+  TFile*   file = TFile::Open("xsec.root", "READ");
+  TTree*   tree = static_cast<TTree*>(file->Get(Form("%s_%s",medName,
+                                                    pdgName)));
+  TLeaf* tb   = tree->GetLeaf("T");
+  TLeaf* vb   = tree->GetLeaf(var);
+  if (!vb) {
+    std::cerr << "Leaf " << var << " not found" << std::endl;
+    return;
+  }
+  Float_t tkine, value;
+  tb->SetAddress(&tkine);
+  vb->SetAddress(&value);
+  Int_t n = tree->GetEntries();
+
+  TDatabasePDG* pdgDb = TDatabasePDG::Instance();
+  TParticlePDG* pdgP  = pdgDb->GetParticle(pdgName);
+  if (!pdgP) {
+    std::cerr << "Couldn't find particle " << pdgName << std::endl;
+    return;
+  }
+  Double_t m = pdgP->Mass();
+  Double_t q = pdgP->Charge() / 3;
+  if (m == 0) {
+    std::cerr  << "Mass is 0" << std::endl;
+    return;
+  }
+  
+  TGraph* graph = new TGraph(n);
+  for (Int_t i = 0; i < n; i++) {
+    tree->GetEntry(i);
+    graph->SetPoint(i, tkine/m/q/q, value*thick);
+  }
+  graph->Draw("ALP");
+}
+
+//____________________________________________________________________
+//
+// EOF
+//
diff --git a/FMD/scripts/GetXsection.C b/FMD/scripts/GetXsection.C
new file mode 100644 (file)
index 0000000..09db263
--- /dev/null
@@ -0,0 +1,141 @@
+//____________________________________________________________________
+//
+// $Id$
+//
+// Script to get the various cross sections, energy loss, and ranges
+// of a particular particle type in a particular medium. 
+//
+// This script should be compiled to speed it up.  
+// 
+// It creates a tree on the current output file, with the relevant
+// information. 
+//
+// Note, that VMC _must_ be the TGeant3TGeo VMC. 
+//
+#include <TArrayF.h>
+#include <TTree.h>
+#include <TMath.h>
+#include <iostream>
+#include <TVirtualMC.h>
+#include <TDatabasePDG.h>
+#include <TString.h>
+#include <TGeoManager.h>
+#include <TGeoMedium.h>
+#include <TGeant3.h>
+
+struct Mech 
+{
+  char*    name;
+  char*    title;
+  char*    unit;
+  TArrayF  values;
+  int      status;
+};
+
+
+void
+GetXsection(const char* medName, const char* pdgName,
+           Int_t n=91, Float_t emin=1e-5, Float_t emax=1e4)
+{
+  TArrayF tkine(n);
+  Float_t dp   = 1/TMath::Log10(emax/emin);
+  Float_t pmin = TMath::Log10(emin);
+  tkine[0]     = emin;
+  for (Int_t i=1; i < tkine.fN; i++) {
+    Float_t el = pmin + i * dp;
+    tkine[i]   = TMath::Power(10, el);
+  }
+  TArrayF cuts(5);
+  cuts.Reset(1e-4);
+
+  Mech mechs[] = 
+    {{ "HADF","total hadronic x-section according to FLUKA","cm^{1}",n,0},
+     { "INEF","hadronic inelastic x-section according to FLUKA","cm^{1}",n,0},
+     { "ELAF","hadronic elastic x-section according to FLUKA","cm^{1}",n,0},
+     { "HADG","total hadronic x-section according to GHEISHA","cm^{1}",n,0},
+     { "INEG","hadronic inelastic x-section according to GHEISHA","cm^{1}",n,0},
+     { "ELAG","hadronic elastic x-section according to GHEISHA","cm^{1}",n,0},
+     { "FISG","nuclear fission x-section according to GHEISHA","cm^{1}",n,0},
+     { "CAPG","neutron capture x-section according to GHEISHA","cm^{1}",n,0},
+     { "LOSS","stopping power","cm^{1}",n,0},
+     { "PHOT","photoelectric x-section","MeV/cm",n,0},
+     { "ANNI","positron annihilation x-section","cm^{1}",n,0},
+     { "COMP","Compton effect x-section","cm^{1}",n,0},
+     { "BREM","bremsstrahlung x-section","cm^{1}",n,0},
+     { "PAIR","photon and muon direct- pair x-section","cm^{1}",n,0},
+     { "DRAY","delta-rays x-section","cm^{1}",n,0},
+     { "PFIS","photo-fission x-section","cm^{1}",n,0},
+     { "RAYL","Rayleigh scattering x-section","cm^{1}",n,0},
+     { "MUNU","muon-nuclear interaction x-section","cm^{1}",n,0},
+     { "RANG","range","cm",n,0},
+     { "STEP","maximum step","cm",n,0},
+     { 0, 0, 0, 0, 0}};
+  TGeant3* mc = (TGeant3*)gMC;
+  if (!mc) {
+    std::cerr << "Couldn't get VMC" << std::endl;
+    return;
+  }
+  TGeoMedium* medium = gGeoManager->GetMedium(medName);
+  if (!medium) {
+    std::cerr << "Couldn't find medium " << medName << std::endl;
+    return;
+  }
+  Int_t medNo = medium->GetMaterial()->GetUniqueID();
+  TDatabasePDG* pdgDb = TDatabasePDG::Instance();
+  TParticlePDG* pdgP  = pdgDb->GetParticle(pdgName);
+  if (!pdgP) {
+    std::cerr << "Couldn't find particle " << pdgName << std::endl;
+    return;
+  }
+  Int_t pdgNo = pdgP->PdgCode();
+  Int_t pidNo = mc->IdFromPDG(pdgNo);
+    
+  Mech* mech = &(mechs[0]);
+  Int_t nMech = 0;
+  Int_t nOk = 0;
+  TString vars("T/F");
+  while (mech->name) {
+    cout << mech->name << ": " << mech->title << " ... " << std::flush;
+    nMech++;
+    Int_t ixst;
+    mc->Gftmat(medNo, pidNo, mech->name, n, 
+              tkine.fArray, mech->values.fArray, cuts.fArray, ixst);
+    mech->status = ixst;
+    if (ixst) {
+      nOk++;
+      vars.Append(Form(":%s", mech->name));
+      if (!strcmp("LOSS", mech->name)) {
+       for (Int_t i = 0; i < n; i++) 
+         std::cout << i << "\t" << tkine[i] << "\t" 
+                   << mech->values[i] << std::endl;
+      }
+    }
+    std::cout << (ixst ? "ok" : "failed") << std::endl;
+    mech++;
+  }
+  // TFile* file = TFile::Open(Form("xsec-%d.root", pdgNo),
+  // "RECREATE");
+  TArrayF cache(nOk+1);
+  TTree* tree = new TTree(Form("%s_%s", medName, pdgName), 
+                         Form("%s_%s", medName, pdgName));
+  tree->Branch("xsec", cache.fArray, vars.Data());
+  for (Int_t i = 0; i < n; i++) {
+    cache[0] = tkine[i];
+    Int_t k = 0;
+    for (Int_t j = 0; j < nMech; j++) {
+      if (mechs[j].status) {
+       if (!strcmp(mechs[j].name, "LOSS")) 
+         std::cout << tkine[i] << "\t" << mechs[j].values[i] << std::endl;
+       cache[k+1] = mechs[j].values[i];
+       k++;
+      }
+    }
+    std::cout << k << "\t" << (k == nOk) << std::endl;
+    tree->Fill();
+  }
+  tree->Write();
+}
+//____________________________________________________________________
+//
+// EOF
+//
index 3550641..1001fed 100644 (file)
@@ -1,4 +1,6 @@
 //
+// $Id$
+//
 // Script to make ROOT files with LEGO information histograms
 //
 TH1*
@@ -52,3 +54,7 @@ MakeLego(const Char_t* what)
   output->Close();
   galice->Close();  
 }
+//____________________________________________________________________
+//
+// EOF
+//
index bde85ab..c239bf5 100644 (file)
@@ -238,3 +238,8 @@ int main()
   return 0;
 }
 #endif
+
+//____________________________________________________________________
+//
+// EOF
+//
diff --git a/FMD/scripts/MakeXsection.C b/FMD/scripts/MakeXsection.C
new file mode 100644 (file)
index 0000000..8c3184f
--- /dev/null
@@ -0,0 +1,25 @@
+//
+// $Id$
+//
+// Script to generate cross-section tables for some particles in some
+// mediums.   The output is put in xsec.root. 
+// 
+// It uses the script GetXsection.C and Compile.C to compile the
+// aforementioned script. 
+//
+// Note, that VMC _must_ be the TGeant3TGeo VMC. 
+//
+void
+MakeXsection()
+{
+  gROOT->ProcessLine(".x Compile.C(\"$ALICE_ROOT/FMD/scripts/GetSection.C\"");
+  gAlice->InitMC("$(ALICE_ROOT)/FMD/Config.C");
+  TFile* file = TFile::Open("xsec.root", "RECREATE");
+  GetXsection("FMD_Si$", "pi+");
+  file->Close();
+}
+//____________________________________________________________________
+//
+// EOF
+// 
+
index d9d4417..63fb470 100644 (file)
@@ -1,4 +1,6 @@
 //
+// $Id$
+//
 // Small script to test consistency of writing and reading raw data.
 //
 void
@@ -93,6 +95,10 @@ RawTest()
 #endif
 }
 
+//____________________________________________________________________
+//
+// EOF
+//
   
     
        
index 570ce2b..27d1fcb 100644 (file)
@@ -1,51 +1,32 @@
 //
 // Script to digit multiplicity information to std::cout. 
 //
-void
-ShowDigits(Int_t det=2)
-{
-  AliRunLoader* runLoader = AliRunLoader::Open("galice.root");
-  runLoader->LoadgAlice();
-  runLoader->LoadHeader();
-  gAlice                   = runLoader->GetAliRun();
-  AliFMD*       fmd        = static_cast<AliFMD*>(gAlice->GetDetector("FMD"));
-  AliLoader*    fmdLoader  = runLoader->GetLoader("FMDLoader");
-  fmdLoader->LoadDigits("READ");
-  
-  TH1* h = new TH1F("digitData", "Digit Data", 128, 0, 1024);
-  Int_t nEvents = runLoader->TreeE()->GetEntries();
-  for (Int_t event = 0; event < nEvents; event++) {
-    cout << "Event # " << event << endl;
-    runLoader->GetEvent(event);
-    TClonesArray* digits   = 0;
-    TTree*        treeD  = fmdLoader->TreeD();
-    TBranch*      branch = treeD->GetBranch("FMD");
-    branch->SetAddress(&digits);
-
-    Int_t total = 0;
-    Int_t nEntries  = treeD->GetEntries();
-    for (Int_t entry = 0; entry < nEntries; entry++) {
-      cout << " Entry # " << entry << endl;
-      treeD->GetEntry(entry);
+#include <TH1F.h>
+#include <AliFMDDigit.h>
+#include <AliFMDInput.h>
 
-      Int_t nDigits = digits->GetLast();
-      for (Int_t i = 0; i < nDigits; i++) {
-       // cout << "  Digit # " << i << endl;
-       AliFMDDigit* digit = static_cast<AliFMDDigit*>(digits->UncheckedAt(i));
-       if (digit->Counts() > 12) { 
-         digit->Print();
-         total++;
-       }
-       if (digit->Detector() == det) 
-         h->Fill(digit->Counts());
-      }
-    }
-    cout << "Total number of digits: " << total << endl;
+class ShowDigits : public AliFMDInputDigits
+{
+  TH1F* fHist;
+  Int_t det
+  ShowDigits(Int_t det, const char* file="galice.root") 
+    : AliFMDInputDigits(file), fDet(det)
+  {
+    fHist = new TH1F("digitData", "Digit Data", 128, 0, 1024);
+  }
+  Bool_t ProcessDigit(AliFMDDigit* digit) 
+  {
+    if (digit->Counts() > 12) digit->Print();
+    if (digit->Detector() == det) fHist->Fill(digit->Counts());
+    return kTRUE;
+  }
+  Bool_t Finish() 
+  {
+    fHist->Draw();
+    return kTRUE;
   }
-
-  TCanvas* c = new TCanvas("digit", "Digit Data");
-  c->SetFillColor(0);
-  c->SetLogy();
-  c->SetBorderMode(0);
-  h->Draw();
 }
+//____________________________________________________________________
+//
+// EOF
+//
index beac62c..290d4e7 100644 (file)
@@ -1,39 +1,31 @@
 //
+// $Id$
+//
 // Script to dump hit information to std::cout. 
 //
-ShowHits()
-{
-  AliRunLoader* runLoader = AliRunLoader::Open("galice.root");
-  runLoader->LoadgAlice();
-  runLoader->LoadHeader();
-  gAlice                   = runLoader->GetAliRun();
-  AliFMD*       fmd        = static_cast<AliFMD*>(gAlice->GetDetector("FMD"));
-  AliLoader*    fmdLoader  = runLoader->GetLoader("FMDLoader");
-  fmdLoader->LoadHits("READ");
-  
-  Int_t nEvents = runLoader->TreeE()->GetEntries();
-  for (Int_t event = 0; event < nEvents; event++) {
-    cout << "Event # " << event << endl;
-    runLoader->GetEvent(event);
-    TClonesArray* hits   = 0;
-    TTree*        treeH  = fmdLoader->TreeH();
-    TBranch*      branch = treeH->GetBranch("FMD");
-    branch->SetAddress(&hits);
-
-    Int_t total = 0;
-    Int_t nEntries  = treeH->GetEntries();
-    for (Int_t entry = 0; entry < nEntries; entry++) {
-      // cout << " Entry # " << entry << endl;
-      treeH->GetEntry(entry);
+// Use the script `Compile.C' to compile this class using ACLic. 
+//
+#include <TH2D.h>
+#include <AliFMDHit.h>
+#include <AliFMDInput.h>
 
-      Int_t nHits = hits->GetEntries();
-      for (Int_t i = 0; i < nHits; i++) {
-       cout << "  Hit # " << i << "/" << nHits << "\t" << flush;
-       AliFMDHit* hit = static_cast<AliFMDHit*>(hits->UncheckedAt(i));
-       hit->Print();
-       total++;
-      }
+class ShowHits : public AliFMDInputHits
+{
+public:
+  ShowHits() {}
+  Bool_t ProcessHit(AliFMDHit* hit, TParticle* part) 
+  {
+    if (!hit) {
+      std::cout << "No hit" << std::endl;
+      return kFALSE;
     }
-    cout << "Total number of hits: " << total << endl;
+    hit->Print();
+    if (part) part->Print();
+    return kTRUE;
   }
-}
+};
+
+//____________________________________________________________________
+//
+// EOF
+//
index 70d799f..3a41f85 100644 (file)
@@ -1,50 +1,31 @@
 //
+// $Id$
+//
 // Script to dump multiplicity information to std::cout. 
 //
-void
-ShowMult()
-{
-  AliRunLoader* runLoader = AliRunLoader::Open("galice.root");
-  runLoader->LoadgAlice();
-  runLoader->LoadHeader();
-  gAlice                   = runLoader->GetAliRun();
-  AliFMD*       fmd        = static_cast<AliFMD*>(gAlice->GetDetector("FMD"));
-  AliLoader*    fmdLoader  = runLoader->GetLoader("FMDLoader");
-  fmdLoader->LoadRecPoints("READ");
-  
-  Int_t nEvents = runLoader->TreeE()->GetEntries();
-  for (Int_t event = 0; event < nEvents; event++) {
-    cout << "Event # " << event << endl;
-    runLoader->GetEvent(event);
-    TClonesArray* multStrips  = 0;
-    TClonesArray* multRegions = 0;
-    TTree*        treeR  = fmdLoader->TreeR();
-    TBranch*      branchRegions = treeR->GetBranch("FMDPoisson");
-    TBranch*      branchStrips  = treeR->GetBranch("FMDNaiive");
-    branchRegions->SetAddress(&multRegions);
-    branchStrips->SetAddress(&multStrips);
-
-    Int_t total = 0;
-    Int_t nEntries  = treeR->GetEntries();
-    for (Int_t entry = 0; entry < nEntries; entry++) {
-      cout << " Entry # " << entry << endl;
-      treeR->GetEntry(entry);
-
-      Int_t nMults = multStrips->GetLast();
-      for (Int_t i = 0; i < nMults; i++) {
-       // cout << "  Digit # " << i << endl;
-       AliFMDMultStrip* mult = 
-         static_cast<AliFMDMultStrip*>(multStrips->UncheckedAt(i));
-       if (mult->Particles() > 0) mult->Print();
-      }
+// Use the script `Compile.C' to compile this class using ACLic. 
+//
+#include <AliFMDMultStrip.h>
+#include <AliFMDMultRegion.h>
+#include <AliFMDInput.h>
 
-      nMults = multRegions->GetLast();
-      for (Int_t i = 0; i < nMults; i++) {
-       // cout << "  Digit # " << i << endl;
-       AliFMDMultStrip* mult = 
-         static_cast<AliFMDMultStrip*>(multRegions->UncheckedAt(i));
-       if (mult->Particles() > 0) mult->Print();
-      }
-    }
+class ShowMult : public AliFMDInputRecPoints
+{
+public:
+  ShowMult() {}
+  Bool_t ProcessStrip(AliFMDMultStrip* mult) 
+  {
+    mult->Print();
+    return kTRUE;
+  }
+  Bool_t ProcessRegion(AliFMDMultRegion* mult) 
+  {
+    mult->Print();
+    return kTRUE;
   }
-}
+};
+
+//____________________________________________________________________
+//
+// EOF
+//
index f416968..d610cb0 100644 (file)
@@ -1,4 +1,6 @@
 //
+// $Id$
+//
 // Script to read a raw data file, and dump it to std::cout 
 //
 #include <iomanip>
@@ -66,3 +68,7 @@ ShowRaw(Int_t det=2,  bool verbose=false, Int_t event=0)
   h->Draw();
   return;
 }
+//____________________________________________________________________
+//
+// EOF
+//
index 4e89236..db9bafd 100644 (file)
@@ -1,5 +1,8 @@
 //____________________________________________________________________
 //
+//
+// $Id$
+//
 // Script I used for rapid prototyping of the FMD3 geometry - in
 // particular the support cone 
 //
@@ -270,3 +273,7 @@ SimpleGeometry()
   geometry->Draw();
   // c->x3d("ogl");
 }
+//____________________________________________________________________
+//
+// EOF
+//
index 623203e..8bf8ba7 100644 (file)
@@ -1,4 +1,6 @@
 // 
+// $Id$
+//
 // Script to try to fit the reponse function of the VA1 signals, based
 // on a finite number of ALTRO samples. 
 //
@@ -47,3 +49,7 @@ VA1Response(Int_t n=2, Float_t B=5, Float_t dc=.01, Bool_t errors=kFALSE)
            << fit->GetParameter(1) << "+/-" << fit->GetParError(1) 
            << " * t))" << std::endl;
 }
+//____________________________________________________________________
+//
+// EOF
+//
index aa4b169..d406b2d 100644 (file)
@@ -1,4 +1,6 @@
 //
+// $Id$
+//
 // Small script that shows a signal train from a VA1 pre-amp. 
 // 
 void 
@@ -51,6 +53,7 @@ VA1Train()
     last = measurements[i]; 
   }
 }
-
-      
-  
+//____________________________________________________________________
+//
+// EOF
+//
index 947a8a0..41d3c5b 100644 (file)
@@ -1,3 +1,7 @@
+//____________________________________________________________________
+//
+// $Id$
+//
 void ViewPIPE()
 {
   gMC->Gsatt("QBPM","seen",0);
@@ -65,3 +69,7 @@ void ViewPIPE()
 
   gMC->Gsatt("QBVA","seen",1);
 }
+//____________________________________________________________________
+//
+// EOF
+//
index 40293f7..b4581fc 100644 (file)
@@ -1,4 +1,6 @@
 //
+// $Id$
+//
 // Small script that I used to make some intial testing of the wafer
 // layout and geometry. 
 //
@@ -134,6 +136,10 @@ Wafer()
   can->Print("fmd_module2.gif");
   
 }
+//____________________________________________________________________
+//
+// EOF
+//
 
 
 
index 3314bab..f1a56b3 100755 (executable)
@@ -7,3 +7,7 @@ for i in Inner ITS PIPE FMD Nothing ; do
 done 
 
 root -l -q FMD/scripts/DrawLego.C
+# ____________________________________________________________________
+#
+# EOF
+#
index d3bcabf..cf079a4 100755 (executable)
@@ -41,3 +41,7 @@ cp $ALICE_ROOT/.rootrc .
 aliroot -l  # -b -q ../runIt.C > run.log 2>&1 
 
 cd $CURDIR
+# ____________________________________________________________________
+#
+# EOF
+#
index 44d9597..5a3dc79 100755 (executable)
@@ -19,3 +19,7 @@ cp $ALICE_ROOT/.rootrc .
 aliroot -l -b -q ../runIt.C > run.log 2>&1 
 
 cd $CURDIR
+# ____________________________________________________________________
+#
+# EOF
+#