Renamed _script_ (not macro) to end in .macro (sigh)

Author: cholmcc

run/SimExamples/HepMC/README.md

@@ -5,36 +5,33 @@
 Here are pointers on how to use `GeneratorHepMC` selected by the
 option `-g hepmc` for `o2-sim`. 
 
-## Reading HepMC files 
+## Reading HepMC files
 
 The generator `GeneratorHepMC` can read events from a
-[HepMC(3)](http://hepmc.web.cern.ch/hepmc/) formatted file.  These files
-can be produced by a standalone event generator program (EG).
-Examples of such programs are 
+[HepMC(3)](http://hepmc.web.cern.ch/hepmc/) formatted file.  These
+files can be produced by a standalone event generator program (EG).
+Examples of such programs are
 
 - [Pythia8](https://pythia.org)
-- The [CRMC](https://gitlab.iap.kit.edu/AirShowerPhysics/crmc) suite 
+- The [CRMC](https://gitlab.iap.kit.edu/AirShowerPhysics/crmc) suite
 - [Herwig](https://herwig.hepforge.org/)
 - [SMASH](https://smash-transport.github.io/)
-- ... and many others 
+- ... and many others
 
 Please refer to the documentation of these for more on how to make
 event files in the HepMC format. 
 
-To make a simulation reading from the file `events.hepmc`, do 
-
+To make a simulation reading from the file `events.hepmc`, do
     o2-sim -g hepmc --configKeyValues "HepMC.fileName=events.hepmc"	...
 
 See also [`read.sh`](read.sh) 
 
-## Reading HepMC events from child process 
-
+## Reading HepMC events from child process
 `GeneratorHepMC` can not only read HepMC events from a file, but can
 also spawn an child EG to produce events.  Suppose we have a program
 named `eg` which is some EG that writes HepMC event records to the
 standard output.  Then we can execute a simulation using this external
-EG by 
-
+EG by
     o2-sim -g hepmc --configKeyValues "HepMC.progCmd=eg" 
 
 See also [`child.sh`](child.sh) 
@@ -50,10 +47,9 @@ There are some requirements on the program `eg`:
 If a program does not adhere to these requirements, it will often be
 simple enough to make a small wrapper script that enforce this.  For
 example, `crmc` will write a lot of information to standard output.
-We can filter that out via a shell script ([`crmc.sh`](crmc.sh)) like 
+We can filter that out via a shell script ([`crmc.sh`](crmc.sh)) like
 
-    #!/bin/sh 
-	
+    #!/bin/sh
 	crmc $@ -o hepmc3 -f /dev/stdout | sed -n 's/^\(HepMC::\|[EAUWVP] \)/\1/p'
 
 The `sed` command selects lines that begin with `HepMC::`, or one
@@ -65,12 +61,12 @@ standard output.
 The script above also passes any additional command line options on to
 `crmc` via `$@`.  We can utilise this with `o2-sim` to set options to
 the CRMC suite.  For example, if we want to simulate p-Pb collisions
-using DpmJET, we can do 
+using DpmJET, we can do
 
     o2-sim -g hepmc --configKeyValues "HepMC.progCmd=crmc.sh -m 12 -i2212 -I 1002080820"
 
 
-### Implementation details 
+### Implementation details
 
 Internally `GeneratorHepMC` 
 
@@ -81,14 +77,14 @@ Internally `GeneratorHepMC`
 
       eg options > fifo-name & 
 
-4. and executes that command line 
+4. and executes that command line
 
-## The future 
+## The future
 
 The `GeneratorHepMC` (and sister generator `GeneratorTParticle`) will
 in the not so distant future be upgraded with new functionality to
 more easily customise reading files and executing a child process.  In
-particular 
+particular
 
 - HepMC event structures can be read from any file format supported by
   HepMC it self (see
@@ -101,8 +97,7 @@ particular
     beginning of each file read. 
 
   - `FileOrCmd.fileNames=list` a comma separated list of HepMC files
-    to read 
-	
+    to read
   - `FileOrCmd.cmd=command line` a command line to execute as a
     background child process.  If this is set (not the empty string),
     then `FileOrCmd.fileNames` is ignored. 
@@ -132,19 +127,18 @@ particular
       the program is put in the background.  Typically this should be
       `&`, but a program may itself fork to the background.
 
-- Some options are no longer available 
-
+- Some options are no longer available
   - `HepMC.fileName` - use `FileOrCmd.fileNames`
   - `HepMC.progCmd` - use `FileOrCmd.cmd` 
 
-The command line build will now be 
+The command line build will now be
 
 > _commandLine_ _nEventsSwitch_ _nEvents_ _seedSwitch_ _seed_
 > _bMaxSwitch_ _bMax_ _outputSwitch_ _output_ _backgroundSwitch_
 
 If any of the `Switch` keys are empty, then the corresponding option
 is not propagated to the command line.  For example, if _bMaxSwitch_
-is empty, then the build command line will be 
+is empty, then the build command line will be
 
 > _commandLine_ _nEventsSwitch_ _nEvents_ _seedSwitch_ _seed_
 > _outputSwitch_ _output_ _backgroundSwitch_

run/SimExamples/TParticle/MyEG.macro

@@ -0,0 +1,128 @@
+#include <TGenerator.h>
+#include <TFile.h>
+#include <TTree.h>
+#include <TClonesArray.h>
+#include <TRandom.h>
+#include <TParticle.h>
+
+//--------------------------------------------------------------------
+// Our generator class.  Really simple.
+class MyGenerator : public TGenerator
+{
+ public:
+  Long_t projectilePDG;
+  Long_t targetPDG;
+  Double_t sqrts;
+  MyGenerator() {}
+  void Initialize(Long_t projectile,
+                  Long_t target,
+                  Double_t sqrts)
+  {
+    this->projectilePDG = projectile;
+    this->targetPDG = target;
+    this->sqrts = sqrts;
+  }
+  void GenerateEvent()
+  { /* Do something */
+  }
+  TObjArray* ImportParticles(Option_t* option = "") { return 0; }
+  Int_t ImportParticles(TClonesArray* particles, Option_t* option = "")
+  {
+    Int_t nParticles = 10;
+    Int_t iParticle = 0;
+    // Make beam particles
+    new ((*particles)[iParticle++]) TParticle(projectilePDG, 4, -1, -1,
+                                              2, nParticles - 1,
+                                              0, 0, sqrts / 2,
+                                              TMath::Sqrt(1 + sqrts * sqrts),
+                                              0, 0, 0, 0);
+    new ((*particles)[iParticle++]) TParticle(projectilePDG, 4, -1, -1,
+                                              2, nParticles - 1,
+                                              0, 0, -sqrts / 2,
+                                              TMath::Sqrt(1 + sqrts * sqrts),
+                                              0, 0, 0, 0);
+    for (; iParticle < nParticles; iParticle++)
+      new ((*particles)[iParticle])
+        TParticle(211, 1, 0, 1,
+                  -1, -1,
+                  0.1 * iParticle,
+                  0.1 * iParticle,
+                  0.1 * iParticle,
+                  TMath::Sqrt(0.03 * iParticle * iParticle + 0.14 * 0.14),
+                  0, 0, 0, 0);
+
+    return nParticles;
+  }
+};
+//--------------------------------------------------------------------
+// Our steering class
+struct MySteer {
+  TGenerator* generator;
+  TFile* file;
+  TTree* tree;
+  TClonesArray* particles;
+  Int_t every;
+  MySteer(TGenerator* generator, const TString& output, Int_t every)
+    : generator(generator),
+      file(TFile::Open(output, "RECREATE")),
+      tree(new TTree("T", "T")),
+      particles(new TClonesArray("TParticle")),
+      every(every)
+  {
+    tree->SetDirectory(file);
+    tree->Branch("Particles", &particles);
+  }
+  ~MySteer()
+  {
+    close();
+  }
+  void event()
+  {
+    particles->Clear();
+    generator->GenerateEvent();
+    generator->ImportParticles(particles);
+    tree->Fill();
+  }
+  void sync()
+  {
+    // Important so that GeneratorTParticle picks up the events as
+    // they come.
+    tree->AutoSave("SaveSelf FlushBaskets Overwrite");
+  }
+  void run(Int_t nev)
+  {
+    for (Int_t iev = 0; iev < nev; iev++) {
+      event();
+
+      if (every > 0 and (iev % every == 0) and iev != 0)
+        sync();
+    }
+  }
+  void close()
+  {
+    if (not file)
+      return;
+    file->Write();
+    file->Close();
+    file = nullptr;
+  }
+};
+
+//--------------------------------------------------------------------
+// Our steering function
+void MyEG(Int_t nev, const TString& out, Int_t seed, Int_t every = 1)
+{
+  gRandom->SetSeed(seed);
+
+  MyGenerator* eg = new MyGenerator();
+  eg->Initialize(2212, 2212, 5200);
+
+  MySteer steer(eg, out, every);
+  steer.run(nev);
+}
+// Local Variables:
+//  mode: C++
+// End:
+//
+// EOF
+//

run/SimExamples/TParticle/myeg.sh

@@ -18,5 +18,5 @@ while test $# -gt 0 ; do
     shift
 done
 
-root -q -l MyEG.cc${opt} -- $nev \"$out\" $seed
+root -q -l MyEG.macro${opt} -- $nev \"$out\" $seed