Comparing freezes 12.29 and 12.30.

diff --git a/.gitignore b/.gitignore

index 7f0e1eb..970bd8f 100644

--- a/.gitignore

+++ b/.gitignore

@@ -2,4 +2,3 @@

 .*

 !/.gitignore

 *_history.txt

-*.old~

diff --git a/README.md b/README.md

index fafddf5..a08c4d7 100644

--- a/README.md

+++ b/README.md

@@ -1,28 +1,15 @@

-# The ND280 Energy Deposition Simulation

+This page was created from the documentation at [nd280.lancs.ac.uk](http://nd280.lancs.ac.uk)

-The energy deposition simulation is a wrapper around the GEANT4 particle

-propagation simulation and is intended as a tool to simulate all of the

-particle propagation and geometry related issues.  Be aware that the

-sequence of random numbers depends on the floating point accuracy of the

-machine, so given runs are machine dependent and may not be reproducible.

-This documentation assumes that you have a passing familiarity with how to

-write GEANT4 macro control files.

-Input file translators are provided for several standard input file

-formats.  In particular, this support input from both NEUT and GENIE.  The

-GENIE input is read using the RooTracker format.

+### Introduction

-## Introduction

-

-The ND280 off-axis detector simulation was formerly known as ND280MC,

-and any documentation that refers to ND280MC is applicable.  The

-simulation uses GEANT4, and NEUT to simulate particle propagation and

-geometry in the ND280 detector complex.  This MC is intended to be

-detailed and general enough to become part of the final T2K physics

+The ND280 off-axis detector simulation is intended to simulate all of the

+particle propagation and geometry related issues.  This MC is intended to

+be detailed and general enough to become part of the final T2K physics

 analysis.  Be aware that the sequence of random numbers depends on the

-floating point accuracy of the machine, so given runs are machine

-dependent and may not be reproducible.

+floating point accuracy of the machine, so given runs are machine dependent

+and may not be reproducible.

 This uses the oaEvent library to save events.  The Geant 4 macro

 language can be used to control the program execution and the reference

@@ -34,13 +21,13 @@ General Particle Source (GPS).  Since the main documentation for GPS is a

 bit sparse, there is information specific to our code at nd280Geant4SimGPS

 which covers many of the cases we need to simulate.  

-See Related pages for the release history, command

-list, bug list and to do list.  The related pages also provides

-information about adjusting the "alignment" of the MC geometry.

+See Related pages for the release history, nd280Geant4Sim command list, bug list and

+to do list.  The related pages also provides information about adjusting

+the "alignment" of the MC geometry.

 ### Running the ND280 Detector Simulation

-The detector simulation is run using the ND280GEANT4SIM.exe program which

+The ND280 detector simulation is run using the ND280GEANT4SIM.exe program which

 is a standard GEANT main program with minimal customization for T2K.  This

 can be run in any directory.  You will need to provide some sort of event

 kinematics generator (NEUT, NUANCE, NEUGEN, GPS, &c).  The preferred input

@@ -49,79 +36,10 @@ input format (NUANCE may be the only program in the world still using this

 format.  It was developed as a standard kinematics format for the IMB III

 experiment in about 1990)

-## Running the Detector Simulation

-

-The detector simulation is run using the ND280GEANT4SIM.exe program which

-is a standard GEANT main program with minimal customization.  This

-can be run in any directory.  You will need to provide some sort of event

-kinematics generator (NEUT, NUANCE, NEUGEN, GPS, &c).  The preferred input

-format is a rooTracker tree, but you can also use the text based tracker

-input format (NUANCE may be the only program in the world still using this

-format.  It was developed as a standard kinematics format for the IMB3

-experiment in about 1990)

-

-The program is generally run from the command line:

-```bash

-ND280GEANT4SIM.exe [options] macro-file.mac [macro-file.mac] ...

-```

-

-with one or more macro files.  The output file will be in the oaEvent

-format with a TGeoManager object summarizing the simulated geometry.

-

-Some important options:

-

-* -o <output-file> : Write the output to the root file.  This is equivalent

-        to the `/db/open` macro command.

-* -e <n>  : Add a `/run/beamOn <n>` command after the last macro is

-        processed so that `n` events are generated.

-* -u      : Add a `/t2k/update` command before the first macro is

-        processed.

-* -s      : Set the random seed based on the clock.  The seed can also

-        be set in the macro file.

-* -p <physics-list> : Set the physics list (see G4 documentation for the

-        available lists).

-* -C      : Toggle checking for overlaps in the geometry.

-

-If simulation is run with the `-h` option, it will print a help message.

-There are example macro files in the "inputs" subdirectory.

-

-The simulation uses some GEANT4 macro files to control how it is run.

-These are installed in the system dependent directory,

-

-An example of a command line is

-

-```bash

-ND280GEANT4SIM.exe -o my-output.root -u -e 100 muon-500.mac

-```

-

-There are example macro files in the "inputs" subdirectory, but the

-muon-500.mac might contain: 

-```

-####################################################################

-#

-# Generate a 10000 MeV muon beamed in the down stream direction.

-#

-

-# Define the particle and it's energy.

-/gps/particle mu+

-/gps/energy 10000 MeV

-

-# Set the position of the particle gun.

-/gps/position 0.0 0.0 -10.0 m

-

-# This generates the direction of the muon.  This aims

-# the particle downstream with the directions uniformly distributed in

-# a 5 deg cone around the Z axis.

-/gps/ang/type iso

-/gps/ang/maxtheta 5 deg

-/gps/ang/rot1 1 0 0

-/gps/ang/rot2 0 -1 0

-```

 ### Controlling the ND280 Detector Geometry.

-The coordinate system for the simulation is relative to the

-center of the unloaded (and undeflected) basket as defined in

-T2K-TN-10.

+The coordinate system for the ND280GEANT4SIM is centered around the center of the

+unloaded (and undeflected) basket as defined in T2K-TN-10.

 The nd280Geant4SimCommandList documents how to get low level control over the

 detector geometry, but most standard geometries can be simulated using

@@ -146,340 +64,11 @@ set.

 /t2k/control p0d-with-air 1.0

 ```

+

+

 GEANT 4 defines a simple macro language that is used to control the

 execution of the detector simulation.  All of the commands defined in the 

 ND280GEANT4SIM.exe executable are defined below.

-### Using GPS (The General Particle Source)

-

-This describes how to use the GPS particle source provided by GEANT.

-It is part of GEANT, so deviates from the normal way that the

-simulation accepts kinemtics.

-

-This particle source is incredibly useful, but extremely is idiosyncratic.

-It's also has relatively little documentation, and the documentation that

-exists is often misleading.  This page attempts to cover the basics of

-using GPS to write GEANT macros that produce samples of events to be used

-for testing ND280 software (meaning I got annoyed enough at the GPS

-documentation make notes).

-

-The general particle source as developed for the ESA, so it tends to use

-astronomical conventions.  This is particularly relevant with describing

-angles and directions.  Astronomers (and apparently space scientists) tend

-to speak about where the particle is coming from, not where it is going.

-This makes for an odd match when dealing with a particle simulation which

-is concerned with tracking the particles, and not determining the position

-of the source.  Once you get beyond the idiosyncratic definitions (which

-are at odds with the rest of GEANT), the GPS can be used to create almost

-any sort of particle distribution for testing programs.

-

-#### Controlling the Simulated Particle

-

-The particle being simulated is set using the `/gps/particle` command.  The

-particles are set by name, and can be any of the ones simulated by GEANT.

-The most common particles are `mu-`, `mu+`, `pi+`, `pi-, `e-`,

-`e+`, `gamma`, and `proton`.  For example

-

-```

-/gps/particle mu-

-/gps/particle pi+

-/gps/particle gamma

-/gps/particle proton

-```

-

-#### Controlling the Position Distribution

-

-The vertex position is controlled using the commands in the /gps/pos/

-subdirectory.  The most useful distributions are the Point, Plane, and

-Volume.  To generate a point source the following commands are used

-

-##### Making a point source

-

-```

-/gps/position 0 0 -50 cm

-/gps/pos/type Point

-```

-

-where the first line specifies that this is a point and the second line

-specifies the position.  Notice that all three coordinates must have the

-same units.  For a point source, it's not necessary to specify the type.

-GEANT is very inconsistent about the spelling of `centre` vs `center` with

-19 classes using `centre` and 33 using `center`.  You just have to check

-which version is being used by which class.  For consistency, avoid the

-problem by prefering `/gps/position` and avoiding `/gps/pos/centre`.

-

-##### Making a rectangular or circular source

-

-Since a point source can bias tests, vertices should usually be spread over

-a plane or a volume.  The vertices can be distributed over a flat surface

-by setting

-

-```

-/gps/position 0 0 -50 cm

-/gps/pos/type Plane

-/gps/pos/shape Rectangle

-/gps/pos/halfx 1 cm

-/gps/pos/halfy 1 cm

-/gps/pos/rot1 0 0 -1

-/gps/pos/rot2 0 1 0

-```

-

-##### Making a volume source

-

-To distribute the vertices over a volume the type is changed to Volume, and

-a volumetric shape must be chosen.  The following commands will generate a

-box

-

-```

-/gps/position 0 0 -50 cm

-/gps/pos/type Volume

-/gps/pos/shape Para

-/gps/pos/halfx 1 cm

-/gps/pos/halfy 1 cm

-/gps/pos/halfz 1 cm

-```

-

-that is 100 by 100 by 10 cm.  It's important that the /gps/position command

-comes first.  The other shapes that might be useful are Sphere and Cylinder

-which are specified as

-

-```

-/gps/position 0 0 -50 cm

-/gps/pos/type Volume

-/gps/pos/shape Sphere

-/gps/pos/radius 1 cm

-```

-

-and

-

-```

-/gps/position 0 0 -50 cm

-/gps/pos/type Volume

-/gps/pos/shape Cylinder

-/gps/pos/radius 1 cm

-/gps/pos/halfz 1 cm

-```

-

-#### Controlling the Direction Distribution

-

-The direction distribution is set using the commands in the /gps/ang/

-subdirectory.  When specifying the direction, be aware that the code was

-written under contract to the ESA, and no effort was made to be consistent

-with the rest of the GEANT code base.  As a result, the directions use a

-different angle convention when compared to the rest of GEANT.  In fact,

-while the documentation says that the /gps/ang/ commands control the

-angular distribution of the source, they actually control the direction

-from a point along an initial particle direction ray back to where the

-source is found [note that the mathematics are very poorly defined].  To be

-honest, it's an odd and poorly thought out mix of definitions used by

-physicists and astronomers.  Specifically, to get a particle traveling in

-the positive Z direction, you specify a theta of 180 degree.

-

-The coordinate system used to generate the direction can be changed by

-using the /gps/ang/rot1 and /gps/ang/rot2 commands.  The X axis of the

-direction coordinate system is defined by the /gps/ang/rot1 command, and

-the XY plane is determined by the /gps/ang/rot2 command.  Neither of the

-axes need to be unit vectors, and the rot2 vector doesn't need to be

-perpendicular to rot1 (the normal will be determined by rot1 cross rot2).

-The directions will then be distributed around the negative Z axis in the

-rotated coordinate system.  This means that

-

-```

-/gps/ang/rot1 0 0 1

-/gps/ang/rot2 0 1 0

-```

-

-will rotate the direction coordinate system so that the local Z axis points

-along to global negative X axis.  This will cause the generated particles

-to travel along the positive X axis (i.e. along the local negative Z axis).

-Note: The default for /gps/ang/rot2 is [0 1 0], so it doesn't need to be

-specified.

-

-##### Setting a fixed particle direction

-

-A fixed particle direction can be specified using

-

-```

-/gps/direction 0 0 1

-```

-

-where this specifies the direction that the particle is traveling.  In this

-case, the particle is traveling along the positive Z axis.  Notice unlike

-the rest of the gps direction commands, this uses the same convention as

-the rest of GEANT.

-

-##### Making directions with a Gaussian spread

-

-The problem with specifying a fixed direction is that it may bias a test.

-A Gaussian direction spread can be created using a one dimensional beam

-traveling along the local negative Z axis (yes, it is a bizarre choice).

-For instance, to create a beam traveling along the Z axis with a 10 degree

-divergence (sigma) the following commands would be used.

-

-```

-/gps/ang/type beam1d

-/gps/ang/sigma_r 10 deg

-/gps/ang/rot1 0 0 1

-/gps/ang/rot2 0 1 0

-```

-

-The first line specifies that a 1D beam should be generated where this

-means that the generated directions have a spread around the negative Z

-axis.  The second line specifies a 10 degree spread around the negative Z

-axis.  The third line fixes the screwball convention that the beam travels

-along the negative Z axis by reversing the coordinate system (this aligns

-the direction coordinate system so that it's negative Z axis points along

-the global Z axis).  You should be aware that (for reasons completely

-beyond me, but I've verified it in the source code) the /gps/ang/maxtheta

-and /gps/ang/mintheta commands have no effect on the beam distributions.

-

-##### Generating directions in a cone

-

-To spread the directions isotropically over all direction, the following

-command is used

-

-```

-/gps/ang/type iso

-```

-

-The directions can then be limited to a cone using the max and min

-commands.  By default, the maximum angle is 180 degree and the minimum is 0

-degree.  Bear in mind that 180 degrees points along the positive Z axis and

-0 degrees points along the negative Z axis (these guys failed high school

-geometry).  To create a 10 degree cone of directions along the Z axis use

-

-```

-/gps/ang/type iso

-/gps/ang/mintheta 170 deg

-```

-

-or alternatively

-

-```

-/gps/ang/type iso

-/gps/ang/maxtheta 10 deg

-/gps/ang/rot1 0 0 1

-/gps/ang/rot2 0 1 0

-```

-

-where the final line deals with the wacky angle convention.

-

-#### Controlling the Energy Distribution

-

-The energy distribution is set using the commands in the /gps/ene/

-subdirectory.  There are many options available, but for testing programs

-the most useful ones are to create a mono-energetic, Gaussian, or uniform

-energy source.  By default the energy is specified as the kinetic energy of

-the created particle.

-

-##### Making a monoenergetic source

-

-To create a monoenergetic source, the energy is specified

-like this:

-

-```

-/gps/ene/mono 100 MeV

-```

-

-where you must specify both the energy value and the unit.  This create a

-monoenergetic source with 100 MeV of kinetic energy.

-

-##### Making a uniform energy distribution.

-

-A uniform energy distribution can be created using:

-

-```

-/gps/ene/type Lin

-/gps/ene/gradient 0

-/gps/ene/intercept 1

-/gps/ene/min 100 MeV

-/gps/ene/max 500 MeV

-```

-

-where this creates a source with a uniform kinetic energy distribution

-between 100 MeV and 500 MeV of kinetic energy.  The gradient is specified

-in MeV^{-1}.  The intercept is a pure number, and the final distribution

-does not need to be normalized.

-

-##### Making a Gaussian energy distribution

-

-A Gaussian energy distribution can be created using

-

-```

-/gps/ene/type Gauss

-/gps/ene/mono 400 MeV

-/gps/ene/sigmae 30 MeV

-```

-

-where this create a source with a Gaussian spread of 30 MeV around 400 MeV.

-

-#### Creating Multiple Particle Events

-

-The GPS is very inflexible when it comes to handling multiple particles in

-a single event, so it's not possible to handle the general case with

-multiple particles coming from the same vertex.  This is overcome in detSim by implementing the `/generator/combine` command which is discussed below.

-

-For the simple case of generating multiple particles

-drawn from the same angle and energy distributions, but with the same position, use `/gps/number` command.  For instance

-

-```

-/gps/number 2

-```

-

-would create two particles at the vertex.  Note that both particles have

-the same energy and position distributions.

-

-If you need control over the individual particles, then you have to

-use the /gps/source commands in combination with the /generator/combine

-command.  For instance, to create an event with a mu- and a proton from the

-same vertex position (notice there will be two "primary vertexes" with the

-same position coordinates), you could create a macro:

-

-```

-# Clear the source and tell GPS to make multiple vertices

-/gps/source/clear

-/gps/source/multiplevertex true

-

-# Create the first particle.  This can be done using any of the GPS macro

-# commands.

-/gps/source/add 1

-/gps/particle mu-

-/gps/energy 500 MeV

-/gps/direction 0 1 1

-/gps/position 0.0 0.0 -50 cm

-/gps/pos/type Volume

-/gps/pos/shape Para

-/gps/pos/halfx 1 cm

-/gps/pos/halfy 1 cm

-/gps/pos/halfz 1 cm

-

-# Create the second particle.  This can be done using any of the GPS macro

-# commands.  The position will be overridden below.

-/gps/source/add 2

-/gps/particle proton

-/gps/energy 300 MeV

-/gps/direction 0 0 1

-/gps/position 0 0 0

-

-# Add the GPS generator.  It will create two primary vertices

-# (G4PrimaryVertex objects).

-/generator/add

-

-# Copy the vertex position from the first G4PrimaryVertex object to the

-# second.  Notice that the vertices in GPS are numbered from one, but that

-# the G4PrimaryVertex objects are numbered from zero.

-

-/generator/combine 0 1

-```

+\verbinclude nd280Geant4Sim-command.list

-The `/generator/combine` command copies the vertex position from the first

-vertex to the second, and takes three arguments.  The first argument is the

-vertex number to copy the position, the second argument is the vertex

-number to copy the position into, and the optional third argument is a

-boolean flag specifying if the position of the second vertex should be

-relative to the first.  If the argument is true, then the position is of

-the second particle is adjusted to be relative to the position of the first

-(default: false).  This can be used to simulate displaced vertices.  As an

-example, if the optional third argument is true, the first vertex position

-is [1,1,1], and the second vertex position is [0,1,0], then the simulated

-vertex positions will be [1,1,1] and [1,2,1].

diff --git a/app/nd280Geant4Sim.cc b/app/nd280Geant4Sim.cc

index 4315119..b42f4b3 100644

--- a/app/nd280Geant4Sim.cc

+++ b/app/nd280Geant4Sim.cc

@@ -1,93 +1,47 @@

+

+#include <iostream>

+#include <fstream>

+

 #include <csignal>

 #include <cstdlib>

-#include <iostream>

-#include <map>

-#include <string>

 #include "TND280Log.hxx"

 #include "globals.hh"

 #include "G4RunManager.hh"

 #include "G4UImanager.hh"

-#include "G4UIExecutive.hh"

+#include "G4UIterminal.hh"

+#include "G4UItcsh.hh"

 #include "ND280CreateRunManager.hh"

 #include "ND280PersistencyManager.hh"

 #include "ND280RootPersistencyManager.hh"

+// The physics lists that can be used.

+#include "ND280PhysicsList.hh"

+

 #ifdef G4VIS_USE

 #include <G4VisExecutive.hh>

 #endif

-void usage (std::string message) {

-    std::cout << "Usage: edep-sim [options] [macros]" << std::endl;

-    std::cout << "    -C      -- Toggle geometry validation [Default: false]"

-              << std::endl;

-    std::cout << "    -d      -- Increase the debug level" << std::endl;

-    std::cout << "    -D <name>=[error,severe,warn,debug,trace]"

-              << std::endl

-              << "            -- Change the named debug level"

-              << std::endl;

-    std::cout << "    -e <n>  -- Add /run/beamOn <n> after last macro."

-              << std::endl;

-    std::cout << "    -o      -- Set the output file" << std::endl;

-    std::cout << "    -p <l>  -- Select the physics list" << std::endl;

-    std::cout << "    -q      -- Decrease the verbosity level" << std::endl;

-    std::cout << "    -s      -- Set the seed from the time" << std::endl;

-    std::cout << "    -t      -- No tcsh-style interface" << std::endl;

-    std::cout << "    -u      -- Do update before running the macros"

-              << std::endl;

-    std::cout << "    -U      -- Start an interactive run after the macros"

-              << std::endl

-              << "               are processed."

-              << std::endl;

-    std::cout << "    -v      -- Increase the verbosity" << std::endl;

-    std::cout << "    -V <name>=[quiet,log,info,verbose]" << std::endl

-              << "            -- Change the named log level"

-              << std::endl;

-    std::cout << "    -h      -- This help message." << std::endl;

-

-    if (message.length() > 0) {

-        std::cout << "ERROR: " << message << std::endl;

-    }

-    std::exit(1);

-}

-

 int main(int argc,char** argv) {

-

     G4String outputFilename;

     G4String physicsList = "";

+    G4int errflg = 0;

     G4int c = 0;

-    G4bool useUI = false;

-    bool setSeed=false;

-    bool doUpdate=false;

-    bool validateGeometry=false;

-

+    G4bool useUItcsh = true;

     int debugLevel = 0;

     std::map<std::string, ND::TND280Log::ErrorPriority> namedDebugLevel;

-

     int logLevel = -1; // Will choose default logging level...

     std::map<std::string, ND::TND280Log::LogPriority> namedLogLevel;

-

-    // If filled, run this many events.  The command line argument must be an

-    // integer or G4 will give an error.  There could be error checking here,

-    // but assume the user is "intelligent", and won't try to run "-e ten"

-    // instead of "-e 10".

-    std::string beamOnCount = "";

-

-    while ((c=getopt(argc,argv,"CdD:e:o:p:qstuUvV:h")) != -1) {

+    while (!errflg && ((c=getopt(argc,argv,"dD:o:p:qtvV:")) != -1)) {

         switch (c) {

-        case 'C': {

-            // Toggle the validateGeometry flag.  The default value is set

-            // above.

-            validateGeometry = !validateGeometry;

-            break;

-        }

         case 'd':

             ++debugLevel;

             break;

-        case 'D': {

+        case 'D':

+        {

             // Set the debug level for a named trace.

             std::string arg(optarg);

             std::size_t sep = arg.find("=");

@@ -111,15 +65,10 @@ int main(int argc,char** argv) {

                     namedDebugLevel[name.c_str()] = ND::TND280Log::TraceLevel;

                     break;

                 default:

-                    usage("Unknown debug level for -D");

-                }

+                    ++errflg;

+                    G4cout << "Option not implemented" << G4endl;

                 }

-            break;

             }

-        case 'e': {

-            // Add a /run/beamOn command after the last macro has been

-            // processed.

-            beamOnCount = optarg;

             break;

         }

         case 'o':

@@ -133,26 +82,16 @@ int main(int argc,char** argv) {

             if (logLevel>0) --logLevel;

             else logLevel = 0;

             break;

-        case 's': {

-            // Force a '/t2k/random/timeRandomSeed'

-            setSeed = true;

-            break;

-        }

-        case 'u': {

-            // Force a '/t2k/update' before running the first macro.

-            doUpdate = true;

-            break;

-        }

-        case 'U':

-            // Fall back to the user command line interface.

-            useUI = true;

+        case 't': // Don't use a tcsh-style command line interface

+            useUItcsh = false;

             break;

         case 'v':

             // increase the verbosity level.

             if (logLevel>0) ++logLevel;

             else logLevel = 2;

             break;

-        case 'V': {

+        case 'V':

+        {

             // Set the debug level for a named trace.

             std::string arg(optarg);

             std::size_t sep = arg.find("=");

@@ -173,21 +112,20 @@ int main(int argc,char** argv) {

                     namedLogLevel[name.c_str()] = ND::TND280Log::VerboseLevel;

                     break;

                 default:

-                    usage("Unknown log level for -V");

+                    errflg++;

+                    G4cout << "Option not implemented" << G4endl;

                 }

             }

             break;

         }

-        case 'h':

-            usage("");

         default:

-            usage("Unknown option");

+            errflg++;

+            G4cout << "Option not implemented" << G4endl;

         }

     }

     ND::TND280Log::Configure();

-    // Set the global log level.

     if (logLevel == 0) {

         ND::TND280Log::SetLogLevel(ND::TND280Log::QuietLevel);

     }

@@ -204,7 +142,6 @@ int main(int argc,char** argv) {

         ND280Verbose("Set log level to VerboseLevel");

     }

-    // Set the name log levels.

     for (std::map<std::string,ND::TND280Log::LogPriority>::iterator i 

              = namedLogLevel.begin();

          i != namedLogLevel.end();

@@ -212,7 +149,6 @@ int main(int argc,char** argv) {

         ND::TND280Log::SetLogLevel(i->first.c_str(), i->second);

     }

-    // Set the global debug level.

     if (debugLevel == 1) {

         ND::TND280Log::SetDebugLevel(ND::TND280Log::WarnLevel);

         ND280Warn("Set debug level to WarnLevel");

@@ -226,7 +162,6 @@ int main(int argc,char** argv) {

         ND280Trace("Set debug level to TraceLevel");

     }

-    // Set the named debug levels.

     for (std::map<std::string,ND::TND280Log::ErrorPriority>::iterator i 

              = namedDebugLevel.begin();

          i != namedDebugLevel.end();

@@ -234,6 +169,7 @@ int main(int argc,char** argv) {

         ND::TND280Log::SetDebugLevel(i->first.c_str(), i->second);

     }

+    // Set the mandatory initialization classes

     // Construct the default run manager

     G4RunManager* runManager = ND280CreateRunManager(physicsList);

@@ -253,52 +189,34 @@ int main(int argc,char** argv) {

     // Set the defaults for the simulation.

     UI->ApplyCommand("/t2k/control nd280Geant4Sim-defaults 1.0");

-    // Open the output file.

     if (persistencyManager && outputFilename != "") {

         G4String command = "/db/open ";

         UI->ApplyCommand(command+outputFilename);

     }

-    // Make sure that signals use the default handling.  This makes sure that

-    // other libraries (ROOT, I'm looking at you) aren't trapping errors.

     std::signal(SIGILL,  SIG_DFL);

     std::signal(SIGBUS,  SIG_DFL);

     std::signal(SIGSEGV, SIG_DFL);

-    // Set the random seed from the time.

-    if (setSeed) UI->ApplyCommand("/t2k/random/timeRandomSeed");

-

-    // Signal that the geometry should be validated for overlaps before

-    // generating the first event.  This causes the executable to throw an

-    // exception if the geometry has overlaps.

-    if (validateGeometry) UI->ApplyCommand("/t2k/validateGeometry");

-

-    // Set the defaults for the simulation and get ready to run.  This needs

-    // to be done before the first event is generated, but can also be done in

-    // the users macro file.  It's executed here if the "-u" option was

-    // provided on the command line.

-    if (doUpdate) UI->ApplyCommand("/t2k/update");

-

-    // Run the macros from the command line.

+    if (optind < argc) {

+        G4String command = "/control/execute ";

         for (int i=optind; i<argc; ++i) {

-        std::string macroFilename = argv[i];

-        UI->ApplyCommand("/control/execute " +macroFilename);

+            G4String macroFilename = argv[i];

+            UI->ApplyCommand(command+macroFilename);

         }

-

-    // If a event count was provided with the -e format, then add a beamOn

-    // command.  The beamOn command can also be in the users macro, but

-    // this makes it a little more convenient to write generic macros and

-    // then specify the number of interactions to simulate from the

-    // command line.

-    if (!beamOnCount.empty()) {

-        UI->ApplyCommand("/run/beamOn " + beamOnCount);

     }

-

-    // Make a command line available if one was requested.

-    if (useUI) {

-        G4UIExecutive* ui = new G4UIExecutive(argc, argv);

-        ui->SessionStart();

-        delete ui;

+    else {

+        // G4UIterminal is a (dumb) terminal.

+        G4UIsession * session;

+        if(useUItcsh) {

+            // G4UIterminal is a terminal with tcsh-like control.

+            session = new G4UIterminal(new G4UItcsh);

+        }

+        else {

+            session = new G4UIterminal();

+        }

+        session->SessionStart();

+        delete session;

     }

     // job termination

diff --git a/cmake/CMakeLists.txt b/cmake/CMakeLists.txt

index 8c677b9..4dc2f81 100644

--- a/cmake/CMakeLists.txt

+++ b/cmake/CMakeLists.txt

@@ -1,7 +1,7 @@

 # CMakeLists.txt for nd280Geant4Sim package. It creates a library with dictionary and a main program

 cmake_minimum_required(VERSION 3.9 FATAL_ERROR)

-find_package(nd280SoftwarePolicy 3)

+find_package(nd280SoftwarePolicy 3.0)

 if( NOT nd280SoftwarePolicy_FOUND) 

   message(FATAL_ERROR " nd280SoftwarePolicy not found - abort ")

 endif()

diff --git a/cmake/nd280Geant4SimPackageVersion.cmake b/cmake/nd280Geant4SimPackageVersion.cmake

index e7e49f1..6aeb705 100644

--- a/cmake/nd280Geant4SimPackageVersion.cmake

+++ b/cmake/nd280Geant4SimPackageVersion.cmake

@@ -1 +1 @@

-set(PACKAGE_VERSION "6.10" )

+set(PACKAGE_VERSION "6.11" )

diff --git a/doc/nd280Geant4SimHistory.dox b/doc/nd280Geant4SimHistory.dox

index 362f5ab..f72a67a 100644

--- a/doc/nd280Geant4SimHistory.dox

+++ b/doc/nd280Geant4SimHistory.dox

@@ -951,7 +951,7 @@ Remove an unneccesary line of output left over from earlier debugging.

-\section nd280Geant4Sim_6.9_history Version 6.9

+\section nd280Geant4Sim_6_9_history Version 6_9

 Freeze information:

    - Freeze Date: Sun Sep  1 19:30:48 2019

@@ -973,36 +973,25 @@ git.t2k.org/nd280/renaming.

 The name of this package was changed from nd280mc to nd280Geant4Sim.

-\section nd280Geant4Sim_6.10_history Version 6.10

+\section nd280Geant4Sim_6_11_history Version 6_11

 Freeze information:

-   - Freeze Date: Fri Oct 11 14:30:40 2019

+   - Freeze Date: Wed Feb 12 12:53:58 2020

    - Freeze User: Clark McGrew

    - Freeze Host: boxer

-FEATURES

+MAINTENANCE FREEZE

-** Deprecate ND280CombinationGenerator: The suggested replacement

-   is the ND280CopyVertexGenerator. This generator uses "iffy" C++

-   coding techniques that are explicitly deprecated starting in C++11.

+This is a freeze of the 6.9.x branch to create a new 6.11.x branch.

+This is being done so that going forward all of the 6.x.x branchs will

+be exactly what should be run for production 7 (pre upgrade work).

+All of the upgrade work will be done in version 7, or later.

-** ND280CopyVertexGenerator: Add a generator to copy the vertex

-   position and time from one primary vertex to another.  This works

-   with newer C++ standards.  It has slightly different sematics than

-   the combination generator that it replaces.  The combination

-   generator copied the particles from one vertex to another and then

-   removed the source vertex, the copy generator simply changes the

-   position of one of the vertices.

-

-** ND280Scintillation: Add a new process to implement scintillation.

-   This adds Birks constant definitions for all of the current

-   scintillator materials.

-

-** Track the amount of energy going into non-ionizing energy

-   deposition.  This is used to track the amount of energy that gets

-   changed into optical photons inside of a scintillator.  If this is

-   used with a later version of oaEvent (8.16 or later), the amount of

-   secondary energy deposition is saved in the output file.

+Notice that this has orphaned the 6.10 release.  That release contains

+changes for the upgrade, which have all been imported into master, and

+will be included in all later versions.

+It includes all changes needed to simulate the 2019 geometry which

+have been cherry picked from the master branch.

 */

diff --git a/inc/ND280FGDConstructor.hh b/inc/ND280FGDConstructor.hh

index d703ee6..1f477ed 100644

--- a/inc/ND280FGDConstructor.hh

+++ b/inc/ND280FGDConstructor.hh

@@ -9,6 +9,8 @@ class G4LogicalVolume;

 #include "ND280ModuleConstructor.hh"

+#include <vector>

+

 /// Create a bounding box to contain the FGD Detector.  The method

 /// GetPiece() constructs a new unplaced FGD that is facing along the Z

 /// axis.  The calling code should and place the object into a large mother

@@ -58,6 +60,10 @@ public:

         return G4ThreeVector();

     }

+    void AddMissingWaterLayer(int layer) {

+        fMissingWaterLayers.push_back(layer);

+    }

+

 private:

     void Init(void);

@@ -87,5 +93,7 @@ private:

     /// Only the first 2 components (dx, dy) can be modified by the command.

     G4ThreeVector fFGDModuleTrans[15];

+    /// A vector of missing water layers

+    std::vector<int> fMissingWaterLayers;

 };

 #endif

diff --git a/inc/ND280HitSegment.hh b/inc/ND280HitSegment.hh

index 99a0be3..dd251bb 100644

--- a/inc/ND280HitSegment.hh

+++ b/inc/ND280HitSegment.hh

@@ -22,10 +22,10 @@ using namespace CLHEP;

 /// This is a base class used to save G4Hit objects into a root output file.

 /// It contains the global position of the starting point and stopping point

 /// of the track segment that created the hit, plus the any fields provided by

-/// ND::TG4VHit.  The ND280GEANT4SIM expects the electronics response to be

-/// simulated off-line, and to assign the sensor identifiers to each hit.

-/// This class is used with the ND280SegmentSD sensitive detector class, and

-/// can be requested using the "segment" name from

+/// ND::TG4VHit.  The ND280GEANT4SIM expects the electronics response to be simulated

+/// off-line, and to assign the sensor identifiers to each hit.  This class is

+/// used with the ND280SegmentSD sensitive detector class, and can be

+/// requested using the "segment" name from

 /// ND280SensitiveDetectorFactor::MakeSD().

 class ND280HitSegment : public ND::TG4HitSegment, public G4VHit {

 public:

diff --git a/inc/ND280Scintillation.hh b/inc/ND280Scintillation.hh

deleted file mode 100644

index f9c44df..0000000

--- a/src/kinem/ND280CopyVertexGenerator.cc

+++ /dev/null

@@ -1,40 +0,0 @@

-#include <G4PrimaryVertex.hh>

-#include <G4Event.hh>

-

-#include <TND280Log.hxx>

-#include "kinem/ND280CopyVertexGenerator.hh"

-

-ND280CopyVertexGenerator::ND280CopyVertexGenerator(int src, int dest,

-                                                       bool relative)

-    : fSource(src), fDestination(dest), fRelative(relative) { }

-

-ND280CopyVertexGenerator::~ND280CopyVertexGenerator(void) {}

-

-void ND280CopyVertexGenerator::GeneratePrimaryVertex(G4Event* evt) {

-

-    if (fSource < 0 || fSource >= evt->GetNumberOfPrimaryVertex()) {

-        abort();

-    }

-

-    if (fDestination < 0 || fDestination >= evt->GetNumberOfPrimaryVertex()) {

-        abort();

-    }

-

-    G4ThreeVector src = evt->GetPrimaryVertex(fSource)->GetPosition();

-    double srcTime = evt->GetPrimaryVertex(fSource)->GetT0();

-

-    if (fRelative) {

-        G4ThreeVector dest = evt->GetPrimaryVertex(fDestination)->GetPosition();

-        double destTime = evt->GetPrimaryVertex(fDestination)->GetT0();

-        src = src + dest;

-        srcTime = srcTime + destTime;

-    }

-

-    evt->GetPrimaryVertex(fDestination)->SetPosition(src.x(),src.y(),src.z());

-    evt->GetPrimaryVertex(fDestination)->SetT0(srcTime);

-

-}

-

-G4String ND280CopyVertexGenerator::GetName() {

-    return "copyVertex";

-}

diff --git a/inc/ND280UserPrimaryGeneratorMessenger.hh b/inc/ND280UserPrimaryGeneratorMessenger.hh

index 252f67d..789b559 100644

--- a/inc/ND280UserPrimaryGeneratorMessenger.hh

+++ b/inc/ND280UserPrimaryGeneratorMessenger.hh

@@ -105,7 +105,6 @@ private:

     G4UIcmdWithoutParameter* fClearCMD;

     G4UIcmdWithoutParameter* fAddCMD;

-    G4UIcommand* fCopyVertexCMD;

     G4UIcmdWithoutParameter* fCombineCMD;

     G4UIcmdWithAString* fSetKinematicsCMD;

     G4UIcmdWithAString* fSetCountCMD;

diff --git a/inc/kinem/ND280CopyVertexGenerator.hh b/inc/kinem/ND280CopyVertexGenerator.hh

diff --git a/inputs/nd280Geant4Sim-command-html.sh b/inputs/nd280Geant4Sim-command-html.sh

index a75945a..de0727b 100755

--- a/inputs/nd280Geant4Sim-command-html.sh

+++ b/inputs/nd280Geant4Sim-command-html.sh

@@ -1,6 +1,6 @@

 #!/bin/sh

-source ${ND280GEANT4SIMROOT}/cmt/setup.sh

+source ${ND280GEANT4SIMROOT}/bin/setup.sh

 DIR=`pwd`/html

diff --git a/inputs/nd280Geant4Sim-command-list.sh b/inputs/nd280Geant4Sim-command-list.sh

index f58a312..164cdf4 100755

--- a/inputs/nd280Geant4Sim-command-list.sh

+++ b/inputs/nd280Geant4Sim-command-list.sh

@@ -1,6 +1,6 @@

 #!/bin/bash

-source ${ND280GEANT4SIMROOT}/cmt/setup.sh

+source ${ND280GEANT4SIMROOT}/bin/setup.sh

 MACRO=`mktemp -t nd280Geant4Sim.XXXXXXXXXX` || exit 1

 cat >> $MACRO <<EOF

diff --git a/inputs/nd280Geant4Sim-cosmics-gun.sh b/inputs/nd280Geant4Sim-cosmics-gun.sh

index 62379dd..1e5d250 100755

--- a/inputs/nd280Geant4Sim-cosmics-gun.sh

+++ b/inputs/nd280Geant4Sim-cosmics-gun.sh

@@ -40,7 +40,7 @@ if [ "x$1" != "x" ]; then

     shift

 fi

-source ${ND280GEANT4SIMROOT}/cmt/setup.sh

+source ${ND280GEANT4SIMROOT}/bin/setup.sh

 MACRO=`mktemp` || exit 1

 cat >> $MACRO <<EOF

diff --git a/inputs/nd280Geant4Sim-double-particle-gun.sh b/inputs/nd280Geant4Sim-double-particle-gun.sh

index eb95944..4118dc7 100755

--- a/inputs/nd280Geant4Sim-double-particle-gun.sh

+++ b/inputs/nd280Geant4Sim-double-particle-gun.sh

@@ -4,7 +4,7 @@

 # per event. 

 COUNT="10"

-source ${ND280GEANT4SIMROOT}/cmt/setup.sh

+source ${ND280GEANT4SIMROOT}/bin/setup.sh

 MACRO=`mktemp -t nd280Geant4Sim.XXXXXXXXXX` || exit 1

 cat >> $MACRO <<EOF

diff --git a/inputs/nd280Geant4Sim-export-geometry.sh b/inputs/nd280Geant4Sim-export-geometry.sh

index cbc827c..322afd4 100755

--- a/inputs/nd280Geant4Sim-export-geometry.sh

+++ b/inputs/nd280Geant4Sim-export-geometry.sh

@@ -50,6 +50,6 @@ ND280GEANT4SIM.exe $MACRO

 rm $MACRO

-VERS=`(cd $ND280GEANT4SIMROOT/cmt ; cmt show version)`

+VERS=`(cat $ND280GEANT4SIMROOT/cmake/nd280Geant4SimPackageVersion.cmake |awk '{print $2}' | sed s/\"//g)`

 strip-geom.exe -p ${VERS}${haveControl} $OUTPUT

diff --git a/inputs/nd280Geant4Sim-fg-fgd-bunch.sh b/inputs/nd280Geant4Sim-fg-fgd-bunch.sh

index 61d2ca5..52d46ae 100755

--- a/inputs/nd280Geant4Sim-fg-fgd-bunch.sh

+++ b/inputs/nd280Geant4Sim-fg-fgd-bunch.sh

@@ -32,7 +32,7 @@ else

     COUNT=10

 fi

-source ${ND280GEANT4SIMROOT}/cmt/setup.sh

+source ${ND280GEANT4SIMROOT}/bin/setup.sh

 MACRO=`mktemp -t nd280Geant4Sim.XXXXXXXXXX` || exit 1

 cat >> $MACRO <<EOF

diff --git a/inputs/nd280Geant4Sim-fg-p0d-bunch.sh b/inputs/nd280Geant4Sim-fg-p0d-bunch.sh

index 621df6e..d7c6758 100755

--- a/inputs/nd280Geant4Sim-fg-p0d-bunch.sh

+++ b/inputs/nd280Geant4Sim-fg-p0d-bunch.sh

@@ -32,7 +32,7 @@ else

     COUNT=10

 fi

-source ${ND280GEANT4SIMROOT}/cmt/setup.sh

+source ${ND280GEANT4SIMROOT}/bin/setup.sh

 MACRO=`mktemp -t nd280Geant4Sim.XXXXXXXXXX` || exit 1

 cat >> $MACRO <<EOF

diff --git a/inputs/nd280Geant4Sim-fg-test-neut.sh b/inputs/nd280Geant4Sim-fg-test-neut.sh

index 1b08cd7..4a8f439 100755

--- a/inputs/nd280Geant4Sim-fg-test-neut.sh

+++ b/inputs/nd280Geant4Sim-fg-test-neut.sh

@@ -21,7 +21,7 @@ else

     COUNT=10

 fi

-source ${ND280GEANT4SIMROOT}/cmt/setup.sh

+source ${ND280GEANT4SIMROOT}/bin/setup.sh

 MACRO=`mktemp -t nd280Geant4Sim.XXXXXXXXXX` || exit 1

 cat >> $MACRO <<EOF

diff --git a/inputs/nd280Geant4Sim-fg-test-sample.sh b/inputs/nd280Geant4Sim-fg-test-sample.sh

index 6a64be3..705f8d4 100755

--- a/inputs/nd280Geant4Sim-fg-test-sample.sh

+++ b/inputs/nd280Geant4Sim-fg-test-sample.sh

@@ -6,7 +6,7 @@

 # exhaustive. 

 COUNT="10"

-source ${ND280GEANT4SIMROOT}/cmt/setup.sh

+source ${ND280GEANT4SIMROOT}/bin/setup.sh

 MACRO=`mktemp -t nd280Geant4Sim.XXXXXXXXXX` || exit 1

 cat >> $MACRO <<EOF

diff --git a/inputs/nd280Geant4Sim-fg-test-source.sh b/inputs/nd280Geant4Sim-fg-test-source.sh

index e25be2e..37d235a 100755

--- a/inputs/nd280Geant4Sim-fg-test-source.sh

+++ b/inputs/nd280Geant4Sim-fg-test-source.sh

@@ -6,7 +6,7 @@

 COUNT="10"

 SPOT="-50"

-source ${ND280GEANT4SIMROOT}/cmt/setup.sh

+source ${ND280GEANT4SIMROOT}/bin/setup.sh

 MACRO=`mktemp -t nd280Geant4Sim.XXXXXXXXXX` || exit 1

 cat >> $MACRO <<EOF

diff --git a/inputs/nd280Geant4Sim-fg-test-spill.sh b/inputs/nd280Geant4Sim-fg-test-spill.sh

index 59704e8..8b72fca 100755

--- a/inputs/nd280Geant4Sim-fg-test-spill.sh

+++ b/inputs/nd280Geant4Sim-fg-test-spill.sh

@@ -6,7 +6,7 @@

 # exhaustive. 

 COUNT="10"

-source ${ND280GEANT4SIMROOT}/cmt/setup.sh

+source ${ND280GEANT4SIMROOT}/bin/setup.sh

 MACRO=`mktemp -t nd280Geant4Sim.XXXXXXXXXX` || exit 1

 cat >> $MACRO <<EOF

diff --git a/inputs/nd280Geant4Sim-fg-test-tracker.sh b/inputs/nd280Geant4Sim-fg-test-tracker.sh

index 984c047..52e2c62 100755

--- a/inputs/nd280Geant4Sim-fg-test-tracker.sh

+++ b/inputs/nd280Geant4Sim-fg-test-tracker.sh

@@ -21,7 +21,7 @@ else

     COUNT=10

 fi

-source ${ND280GEANT4SIMROOT}/cmt/setup.sh

+source ${ND280GEANT4SIMROOT}/bin/setup.sh

 MACRO=`mktemp -t nd280Geant4Sim.XXXXXXXXXX` || exit 1

 cat >> $MACRO <<EOF

diff --git a/inputs/nd280Geant4Sim-fg-test-tracking.sh b/inputs/nd280Geant4Sim-fg-test-tracking.sh

index ed9b6c8..bebec9c 100755

--- a/inputs/nd280Geant4Sim-fg-test-tracking.sh

+++ b/inputs/nd280Geant4Sim-fg-test-tracking.sh

@@ -6,7 +6,7 @@

 # exhaustive. 

 COUNT="500"

-source ${ND280GEANT4SIMROOT}/cmt/setup.sh

+source ${ND280GEANT4SIMROOT}/bin/setup.sh

 MACRO=`mktemp -t nd280Geant4Sim.XXXXXXXXXX` || exit 1

 cat >> $MACRO <<EOF

diff --git a/inputs/nd280Geant4Sim-particle.sh b/inputs/nd280Geant4Sim-particle.sh

new file mode 100755

index 0000000..00c62a3

--- /dev/null

+++ b/inputs/nd280Geant4Sim-particle.sh

@@ -0,0 +1,48 @@

+#!/bin/sh

+

+COUNT=$1

+shift

+if [ "${COUNT}"x = x ] ; then

+    COUNT=10;

+fi

+

+PARTICLE=$1

+shift

+if [ "${PARTICLE}"x = x ] ; then

+    PARTICLE="mu+";

+fi

+

+KE=$1

+shift

+if [ "${KE}"x = x ] ; then

+    KE=500;

+fi

+

+source ${ND280GEANT4SIMROOT}/bin/setup.sh

+

+MACRO=`mktemp -t nd280Geant4Sim.XXXXXXXXXX` || exit 1

+cat >> $MACRO <<EOF

+/t2k/control baseline 1.0

+/t2k/update

+

+/gps/verbose 2

+/gps/particle ${PARTICLE}

+/gps/ene/mono ${KE} MeV

+/gps/ang/type iso

+

+/generator/position/density/sample Basket

+/generator/position/set density

+

+/run/beamOn ${COUNT}

+

+EOF

+

+OUTPUT=nd280Geant4Sim-${PARTICLE}-${KE}MeV

+

+if [ -f $OUTPUT ]; then

+    rm $OUTPUT

+fi

+

+ND280GEANT4SIM.exe -o $OUTPUT $MACRO 

+

+rm $MACRO

diff --git a/inputs/nd280Geant4Sim-randomseed.sh b/inputs/nd280Geant4Sim-randomseed.sh

index 143e6dc..a3fd1ec 100644

--- a/inputs/nd280Geant4Sim-randomseed.sh

+++ b/inputs/nd280Geant4Sim-randomseed.sh

@@ -4,7 +4,7 @@

 # correctly tracked by the MC.  This is intended as a quick sanity

 # check, and is not exhaustive.

-source ${ND280GEANT4SIMROOT}/cmt/setup.sh

+source ${ND280GEANT4SIMROOT}/bin/setup.sh

 MACRO=`mktemp -t nd280Geant4Sim.XXXXXXXXXX` || exit 1

 cat >> $MACRO <<EOF

diff --git a/inputs/nd280Geant4Sim-single-particle-gun.sh b/inputs/nd280Geant4Sim-single-particle-gun.sh

index 34ec5c2..b883fb2 100755

--- a/inputs/nd280Geant4Sim-single-particle-gun.sh

+++ b/inputs/nd280Geant4Sim-single-particle-gun.sh

@@ -1,7 +1,7 @@

 # Macro that use G4 particle gun to create a single particle

 COUNT="10"

-source ${ND280GEANT4SIMROOT}/cmt/setup.sh

+source ${ND280GEANT4SIMROOT}/bin/setup.sh

 MACRO=`mktemp -t nd280Geant4Sim.XXXXXXXXXX` || exit 1

 cat >> $MACRO <<EOF

diff --git a/inputs/nd280Geant4Sim-standard-geometries.sh b/inputs/nd280Geant4Sim-standard-geometries.sh

index 4dc1bd3..9099018 100755

--- a/inputs/nd280Geant4Sim-standard-geometries.sh

+++ b/inputs/nd280Geant4Sim-standard-geometries.sh

@@ -17,3 +17,8 @@ ${ND280GEANT4SIMROOT}/inputs/nd280Geant4Sim-export-geometry.sh baseline-2010-11

 ${ND280GEANT4SIMROOT}/inputs/nd280Geant4Sim-export-geometry.sh baseline-2015-08 1.0

 ${ND280GEANT4SIMROOT}/inputs/nd280Geant4Sim-export-geometry.sh baseline-2015-08 1.0 p0d-with-air 1.0

+${ND280GEANT4SIMROOT}/inputs/nd280Geant4Sim-export-geometry.sh baseline-2019-08 1.0

+${ND280GEANT4SIMROOT}/inputs/nd280Geant4Sim-export-geometry.sh baseline-2019-08 1.0 p0d-with-air 1.0

+ 

+${ND280GEANT4SIMROOT}/inputs/nd280Geant4Sim-export-geometry.sh baseline-2019-11 1.0

+${ND280GEANT4SIMROOT}/inputs/nd280Geant4Sim-export-geometry.sh baseline-2019-11 1.0 p0d-with-air 1.0

diff --git a/inputs/nd280Geant4Sim-test-empty.sh b/inputs/nd280Geant4Sim-test-empty.sh

index 3e83bed..da47a5c 100755

--- a/inputs/nd280Geant4Sim-test-empty.sh

+++ b/inputs/nd280Geant4Sim-test-empty.sh

@@ -1,7 +1,7 @@

 # Macro that use G4 particle gun to create a single particle

 COUNT="10"

-source ${ND280GEANT4SIMROOT}/cmt/setup.sh

+source ${ND280GEANT4SIMROOT}/bin/setup.sh

 MACRO=`mktemp -t nd280Geant4Sim.XXXXXXXXXX` || exit 1

 cat >> $MACRO <<EOF

diff --git a/inputs/nd280Geant4Sim-test-rootracker.sh b/inputs/nd280Geant4Sim-test-rootracker.sh

index b1c90c6..0237c04 100755

--- a/inputs/nd280Geant4Sim-test-rootracker.sh

+++ b/inputs/nd280Geant4Sim-test-rootracker.sh

@@ -21,7 +21,7 @@ else

     COUNT=3

 fi

-source ${ND280GEANT4SIMROOT}/cmt/setup.sh

+source ${ND280GEANT4SIMROOT}/bin/setup.sh

 MACRO=`mktemp -p . -t nd280Geant4Sim.XXXXXXXXXX` || exit 1

 cat >> $MACRO <<EOF

diff --git a/inputs/nd280Geant4Sim-test-thresholds.sh b/inputs/nd280Geant4Sim-test-thresholds.sh

index 71ff53e..c20575f 100755

--- a/inputs/nd280Geant4Sim-test-thresholds.sh

+++ b/inputs/nd280Geant4Sim-test-thresholds.sh

@@ -39,7 +39,7 @@ else

     usage

 fi

-source ${ND280GEANT4SIMROOT}/cmt/setup.sh

+source ${ND280GEANT4SIMROOT}/bin/setup.sh

 MACRO=`mktemp` || exit 1

 cat >> $MACRO <<EOF

diff --git a/inputs/nd280Geant4Sim-test-trajectory.sh b/inputs/nd280Geant4Sim-test-trajectory.sh

index e6f410f..ed1f9af 100755

--- a/inputs/nd280Geant4Sim-test-trajectory.sh

+++ b/inputs/nd280Geant4Sim-test-trajectory.sh

@@ -6,7 +6,7 @@

 # exhaustive. 

 COUNT="10"

-source ${ND280GEANT4SIMROOT}/cmt/setup.sh

+source ${ND280GEANT4SIMROOT}/bin/setup.sh

 MACRO=`mktemp -t nd280Geant4Sim.XXXXXXXXXX` || exit 1

 cat >> $MACRO <<EOF

diff --git a/inputs/nd280Geant4Sim-tracker.sh b/inputs/nd280Geant4Sim-tracker.sh

index f1d0e75..20a2c0b 100755

--- a/inputs/nd280Geant4Sim-tracker.sh

+++ b/inputs/nd280Geant4Sim-tracker.sh

@@ -40,7 +40,7 @@ EOF

 cat $MACRO

-source ${ND280GEANT4SIMROOT}/cmt/setup.sh

+source ${ND280GEANT4SIMROOT}/bin/setup.sh

 ND280GEANT4SIM.exe -o $OUTPUT $MACRO 

 rm $MACRO

diff --git a/inputs/nd280Geant4Sim-triple-particle-gun.sh b/inputs/nd280Geant4Sim-triple-particle-gun.sh

new file mode 100755

index 0000000..d67ee57

--- /dev/null

+++ b/inputs/nd280Geant4Sim-triple-particle-gun.sh

@@ -0,0 +1,108 @@

+#!/bin/bash

+# 

+# Macro that use G4 particle gun to create two particles 

+# per event.  In particular creates 500 MeV/c muon and 

+# 200 MeV/c proton, with common vertex point

+# near the start of FGD1. The muon is initially pointing

+# in +z direction and proton is initially pointing 

+# at 45 degrees to +z direction.

+

+COUNT="10"

+source ${ND280GEANT4SIMROOT}/bin/setup.sh

+

+MACRO=`mktemp -t nd280Geant4Sim.XXXXXXXXXX` || exit 1

+cat >> $MACRO <<EOF

+/t2k/control baseline 1.0

+/t2k/update

+

+# Make sure that the GPS generator is it's default state.

+/gps/source/clear

+

+# Enable generating multiple particle guns per event.

+/gps/source/multiplevertex true

+

+#######################################

+# Create the first particle source

+#######################################

+/gps/source/add 1

+

+# This source will be used to specify the position of the vertex.  The

+# any of the GPS direction and energy commands can be used.

+/gps/particle mu+

+/gps/energy 600 MeV

+

+# This generates the position of the first particle gun.  It will be

+# used for the other particle guns.  The /gps/position command must

+# come first.

+/gps/position 0.0 0.0 -280.0 cm

+/gps/pos/type Volume

+/gps/pos/shape Para

+/gps/pos/halfx 50 cm

+/gps/pos/halfy 50 cm

+/gps/pos/halfz 10 cm

+

+# This generates the direction of the first particle gun.  This aims

+# the particle downstream with the directions uniformly distributed in

+# a 45 deg cone.

+/gps/ang/type iso

+/gps/ang/maxtheta 45 deg

+/gps/ang/rot1 -1 0 0 

+/gps/ang/rot2  0 1 0

+

+#########################################

+# Create the second particle source.

+#########################################

+/gps/source/add 2

+/gps/particle mu-

+/gps/energy 500 MeV

+

+# This generates the direction of the second particle gun.  This aims

+# the particle downstream with the directions uniformly distributed in

+# a 45 deg cone.

+/gps/ang/type iso

+/gps/ang/maxtheta 45 deg

+/gps/ang/rot1 -1 0 0 

+/gps/ang/rot2  0 1 0

+

+#########################################

+# Create the third particle source.

+#########################################

+/gps/source/add 3

+/gps/particle mu-

+/gps/energy 1000 MeV

+

+# This generates the direction of the second particle gun.  This aims

+# the particle downstream with the directions uniformly distributed in

+# a 20 deg cone.

+/gps/ang/type iso

+/gps/ang/maxtheta 20 deg

+/gps/ang/rot1 -1 0 0 

+/gps/ang/rot2  0 1 0

+

+# Create the GPS particle generator so it exists.  This isn't necessary for a

+# single particle generator since ND280GEANT4SIM will create it by default,

+# but it must be done explicitly when generating multiple GPS

+# particles

+/generator/add

+

+

+# The GPS particles will be created like a "stack".  The combine

+# command takes the last two particles and combines them into a single

+# vertex.  If you have more than two particles, you can use multiple

+# combine commands until you get a single vertex.

+/generator/combine

+/generator/combine

+

+/run/beamOn ${COUNT}

+

+EOF

+

+OUTPUT=nd280Geant4Sim-triple-particle-gun

+

+if [ -f $OUTPUT ]; then

+    rm $OUTPUT

+fi

+

+ND280GEANT4SIM.exe -o $OUTPUT $MACRO 

+

+rm $MACRO

diff --git a/inputs/neut-event.sh b/inputs/neut-event.sh

index 898efe5..ec2601e 100755

--- a/inputs/neut-event.sh

+++ b/inputs/neut-event.sh

@@ -29,7 +29,7 @@ else

     usage

 fi

-source ${ND280GEANT4SIMROOT}/cmt/setup.sh

+source ${ND280GEANT4SIMROOT}/bin/setup.sh

 MACRO=`mktemp -t nd280Geant4Sim.XXXXXXXXXX` || exit 1

 cat >> $MACRO <<EOF

diff --git a/inputs/sim-particle.sh b/inputs/sim-particle.sh

deleted file mode 100755

index 65a0018..0000000

--- a/inputs/sim-triple-particle.sh

+++ /dev/null

@@ -1,106 +0,0 @@

-#!/bin/bash

-#

-# Macro that use G4 particle gun to create two particles

-# per event.  In particular creates 500 MeV/c muon and

-# 200 MeV/c proton, with common vertex point

-# near the start of FGD1. The muon is initially pointing

-# in +z direction and proton is initially pointing

-# at 45 degrees to +z direction.

-

-COUNT="10"

-

-MACRO=`mktemp -t nd280Geant4Sim.XXXXXXXXXX` || exit 1

-cat >> $MACRO <<EOF

-/t2k/control baseline 1.0

-/t2k/update

-

-# Make sure that the GPS generator is it's default state.

-/gps/source/clear

-

-# Enable generating multiple particle guns per event.

-/gps/source/multiplevertex true

-

-#######################################

-# Create the first particle source

-#######################################

-/gps/source/add 1

-

-# This source will be used to specify the position of the vertex.  The

-# any of the GPS direction and energy commands can be used.

-/gps/particle mu+

-/gps/energy 600 MeV

-

-# This generates the position of the first particle gun.  It will be

-# used for the other particle guns.  The /gps/position command must

-# come first.

-/gps/position 0.0 0.0 -280.0 cm

-/gps/pos/type Volume

-/gps/pos/shape Para

-/gps/pos/halfx 50 cm

-/gps/pos/halfy 50 cm

-/gps/pos/halfz 10 cm

-

-# This generates the direction of the first particle gun.  This aims

-# the particle downstream with the direction uniformly distributed in

-# a 45 deg cone.

-/gps/ang/type iso

-/gps/ang/maxtheta 45 deg

-/gps/ang/rot1 -1 0 0

-/gps/ang/rot2  0 1 0

-

-#########################################

-# Create the second particle source.

-#########################################

-/gps/source/add 2

-/gps/particle mu-

-/gps/energy 500 MeV

-

-# This generates the direction of the second particle gun.  This aims

-# the particle downstream with the directions uniformly distributed in

-# a 45 deg cone.

-/gps/ang/type iso

-/gps/ang/maxtheta 45 deg

-/gps/ang/rot1 -1 0 0

-/gps/ang/rot2  0 1 0

-

-#########################################

-# Create the third particle source.

-#########################################

-/gps/source/add 3

-/gps/particle e+

-/gps/energy 1000 MeV

-

-# This generates the direction of the third particle gun.  This aims

-# the particle downstream with the directions uniformly distributed in

-# a 20 deg cone.

-/gps/ang/type iso

-/gps/ang/maxtheta 20 deg

-/gps/ang/rot1 -1 0 0

-/gps/ang/rot2  0 1 0

-

-# Create the GPS particle generator so it exists.  This isn't necessary for a

-# single particle generator since ND280GEANT4SIM will create it by default,

-# but it must be done explicitly when generating multiple GPS

-# particles

-/generator/add

-

-# Copy the vertex position and time of the first particle into the

-# second.  The sources are numbered from 0.

-/generator/copy 0 1

-

-# Copy the vertex position and time of the first particle in to the third.

-/generator/copy 0 2

-

-/run/beamOn ${COUNT}

-

-EOF

-

-OUTPUT=sim-triple-particle-gun

-

-if [ -f $OUTPUT ]; then

-    rm $OUTPUT

-fi

-

-ND280GEANT4SIM.exe -o $OUTPUT $MACRO

-

-rm $MACRO

diff --git a/inputs/sim-triple-particle.sh b/inputs/sim-triple-particle.sh

diff --git a/src/ND280ExtraPhysics.cc b/src/ND280ExtraPhysics.cc

index e9150a2..8b7f6f3 100644

--- a/src/ND280ExtraPhysics.cc

+++ b/src/ND280ExtraPhysics.cc

@@ -3,7 +3,6 @@

 #include <G4ParticleDefinition.hh>

 #include <G4ParticleWithCuts.hh>

 #include <G4ProcessManager.hh>

-#include <G4LossTableManager.hh>

 #include <G4ProcessVector.hh>

 #include <G4ParticleTypes.hh>

 #include <G4ParticleTable.hh>

@@ -14,7 +13,6 @@

 #include "TND280Log.hxx"

 #include "ND280ExtraPhysics.hh"

-#include "ND280Scintillation.hh"

 #include <stdexcept>

@@ -28,16 +26,6 @@ void ND280ExtraPhysics::ConstructParticle() { }

 void ND280ExtraPhysics::ConstructProcess() {

     ND280Log("ND280ExtraPhysics:: Add Extra Physics Processes");

-    // Construct the scintillation process that will be applied to particles.

-    // This uses G4EmSaturation to calculate the Birks saturation correction.

-    // See ND280Scintillation for details.  The Birks constant is set for each

-    // material using "mat->GetIonisation()->SetBirksConstant()".

-    // Scintillation is applied if the Birks constant is defined (greater than

-    // zero).

-    ND280Scintillation* scintillationProcess = new ND280Scintillation();

-    scintillationProcess->AddSaturation(

-        G4LossTableManager::Instance()->EmSaturation());

-

     G4ParticleTable::G4PTblDicIterator* particleIterator

         = theParticleTable->GetIterator();

     particleIterator->reset();

@@ -55,19 +43,10 @@ void ND280ExtraPhysics::ConstructProcess() {

             throw std::runtime_error("Particle without a Process Manager.");

         }

-        if (std::abs(charge) < 0.1) continue;

-

         // All charged particles should have a step limiter to make sure that

         // the steps do not get too long.

+        if (std::abs(charge) > 0.1) {

             pman->AddDiscreteProcess(new G4StepLimiter("Step Limit"));

-

-        // All charged particles should have scintillation.  It's checked for

-        // applicability, but that *SHOULD* just be a formality.

-        if (scintillationProcess->IsApplicable(*particle)) {

-            pman->AddProcess(scintillationProcess,

-                             ordDefault,

-                             ordInActive,

-                             ordDefault);

         }

     }

 }

diff --git a/src/ND280FGDConstructor.cc b/src/ND280FGDConstructor.cc

index e13aea3..0f51a61 100644

--- a/src/ND280FGDConstructor.cc

+++ b/src/ND280FGDConstructor.cc

@@ -15,6 +15,8 @@

 #include "ND280BeamConstructor.hh"

 #include "ND280IBeamConstructor.hh"

+#include <algorithm>

+

 class ND280FGDMessenger : public ND280ModuleConstructorMessenger {

 private:

@@ -23,6 +25,7 @@ private:

     G4UIcmdWithADoubleAndUnit* fTargetLengthCMD;

     G4UIcmdWithABool*       fHasWaterTargetCMD;

     G4UIcmdWithABool*       fHasFirstWaterLayerCMD;

+    G4UIcmdWithAnInteger*   fAddMissingWaterLayerCMD;

     // Array of commands to translate FGD scintillator modules.

     G4UIcmdWith3VectorAndUnit* fFGDModuleTransCMD[15];

@@ -52,6 +55,11 @@ public:

         fHasFirstWaterLayerCMD->SetGuidance("Set false if FGD has no water in the first layer.");

         fHasFirstWaterLayerCMD->SetParameterName("FirstWaterLayer",true);

+        fAddMissingWaterLayerCMD

+            = new G4UIcmdWithAnInteger(CommandName("addMissingWaterLayer"),this);

+        fAddMissingWaterLayerCMD->SetGuidance("Set the index of a missing water layer (number from zero).");

+        fAddMissingWaterLayerCMD->SetParameterName("layer",true);

+

     // Construct new commands to translate FGD modules.

     // There are 15 modules in FGD1, 7 modules in FGD2.

     char moduleNum[100];

@@ -108,7 +116,14 @@ public:

         }

         else if (cmd == fHasFirstWaterLayerCMD) {

             bool water = fHasFirstWaterLayerCMD->GetNewBoolValue(val);

-            if (!water) fConstructor->SetNoWaterFirstLayer();

+            if (!water) {

+                fConstructor->AddMissingWaterLayer(0);

+                fConstructor->SetNoWaterFirstLayer();

+            }

+        }

+        else if (cmd == fAddMissingWaterLayerCMD) {

+            int missing = fAddMissingWaterLayerCMD->GetNewIntValue(val);

+            fConstructor->AddMissingWaterLayer(missing);

         }

         else {

             ND280ModuleConstructorMessenger::SetNewValue(cmd,val);

@@ -297,7 +312,7 @@ void ND280FGDConstructor::BuildWaterTarget(void) {

     //  = 0.232mm + 0.188mm + 9.61mm + 0.190mm + 9.61mm + 0.188mm + 0.232mm +

     //      2.0mm = 22.25mm

-    if (fNoWaterFirstLayer) {

+    for (int i=0; i<6; ++i) {

         AddComponent("G10Gap");

         AddComponent("GlueGap1");

         AddComponent("ScintX");

@@ -308,47 +323,19 @@ void ND280FGDConstructor::BuildWaterTarget(void) {

         AddComponent("AirGap1");

         AddComponent("PropyleneGap");

         AddComponent("GlueGap3");

+        if (std::find(fMissingWaterLayers.begin(),fMissingWaterLayers.end(),i)

+            != fMissingWaterLayers.end()) {

+            ND280Log("Add EMPTY FGD water target in layer " << i );

             AddComponent("ActiveAirGap");

-       AddComponent("GlueGap3");

-       AddComponent("PropyleneGap");

-       AddComponent("AirGap2");

-

-       AddComponent("G10Gap");

-       AddComponent("GlueGap1");

-       AddComponent("ScintX");

-       AddComponent("GlueGap2");

-       AddComponent("ScintY");

-       AddComponent("GlueGap1");

-       AddComponent("G10Gap");

-       AddComponent("AirGap1");

-       AddComponent("PropyleneGap");

-       AddComponent("GlueGap3");

-       AddComponent("WaterGap");

-       AddComponent("GlueGap3");

-       AddComponent("PropyleneGap");

-       AddComponent("AirGap2");

-

-       SetRepetitions(5,14);

-    }else{

-       AddComponent("G10Gap");

-       AddComponent("GlueGap1");

-       AddComponent("ScintX");

-       AddComponent("GlueGap2");

-       AddComponent("ScintY");

-       AddComponent("GlueGap1");

-       AddComponent("G10Gap");

-       AddComponent("AirGap1");

-       AddComponent("PropyleneGap");

-       AddComponent("GlueGap3");

+        }

+        else {

             AddComponent("WaterGap");

+        }

         AddComponent("GlueGap3");

         AddComponent("PropyleneGap");

         AddComponent("AirGap2");

-

-       SetRepetitions(6,14);

     }

- 

     AddComponent("G10Gap");

     AddComponent("GlueGap1");

     AddComponent("ScintX");

@@ -399,7 +386,6 @@ void ND280FGDConstructor::BuildNoWaterTarget(void) {

     AddComponent("GlueGap1");

     AddComponent("G10Gap");

- 

     int compPerModule = 8;

     int compToTranslate = 7;

     // Check all 15 modules in FGD1 for translation parameters.

@@ -414,7 +400,6 @@ void ND280FGDConstructor::BuildNoWaterTarget(void) {

 }

 G4LogicalVolume *ND280FGDConstructor::GetPiece(void) {

-

     if (HasWaterTarget()) BuildWaterTarget();

     else BuildNoWaterTarget();

diff --git a/src/ND280HitSegment.cc b/src/ND280HitSegment.cc

index bfbc1a9..d361e15 100644

--- a/src/ND280HitSegment.cc

+++ b/src/ND280HitSegment.cc

@@ -87,7 +87,6 @@ void ND280HitSegment::AddStep(G4Step* theStep, double start, double end) {

     double energyDeposit = theStep->GetTotalEnergyDeposit();

     double stepLength = (prePos-postPos).mag();

     double trackLength = theStep->GetStepLength();

-    double nonIonizingDeposit = theStep->GetNonIonizingEnergyDeposit();

     if (trackLength < 0.75*stepLength || trackLength < stepLength - 1*mm) {

         ND280Warn("Track length shorter than step: " 

@@ -187,11 +186,6 @@ void ND280HitSegment::AddStep(G4Step* theStep, double start, double end) {

     }

     fEnergyDeposit += energyDeposit;

-#ifdef TG4HitSegment_HasSecondaryDeposit

-    fSecondaryDeposit += nonIonizingDeposit;

-#else

-#warning Secondary energy deposit value will not be saved.

-#endif

     fTrackLength += trackLength;

 }

diff --git a/src/ND280RootPersistencyManager.cc b/src/ND280RootPersistencyManager.cc

index 7e00447..a4d93eb 100644

--- a/src/ND280RootPersistencyManager.cc

+++ b/src/ND280RootPersistencyManager.cc

@@ -598,6 +598,7 @@ void ND280RootPersistencyManager::MakeMCHeader(ND::TND280Event& dest,

 #endif

 #if not BEFORE_oaEvent(8,12,0)

+    if(field){

     int ND280GEANT4SIMFieldModelType=field->GetBasketFieldModel();

     if(ND280GEANT4SIMFieldModelType==0)mcHeader->SetBasketFieldModel(ND::TOAMagneticField::kMCSimple);

     if(ND280GEANT4SIMFieldModelType==3)mcHeader->SetBasketFieldModel(ND::TOAMagneticField::kCOMSOL_MC);

@@ -610,6 +611,16 @@ void ND280RootPersistencyManager::MakeMCHeader(ND::TND280Event& dest,

     if(ND280GEANT4SIMFieldModelType==0) mcHeader->SetYokeFieldModel(ND::TOAMagneticField::kZeroField);

     if(ND280GEANT4SIMFieldModelType==1) mcHeader->SetYokeFieldModel(ND::TOAMagneticField::kMCSimple);

     if(ND280GEANT4SIMFieldModelType==3) mcHeader->SetYokeFieldModel(ND::TOAMagneticField::kCOMSOL_MC);

+    }

+    else

+    {

+        // Set a default value in case there is no field set, which happens if

+        // strength is 0

+        mcHeader->SetBasketFieldModel(ND::TOAMagneticField::kMCSimple);

+        mcHeader->SetCoilFieldModel(ND::TOAMagneticField::kMCSimple);

+        mcHeader->SetYokeFieldModel(ND::TOAMagneticField::kMCSimple);

+

+    }

     #else

 #warning Not saving Field Model Type in MC Header.

 #endif

diff --git a/src/ND280Scintillation.cc b/src/ND280Scintillation.cc

diff --git a/src/ND280UserDetectorConstruction.cc b/src/ND280UserDetectorConstruction.cc

index f07d8e6..585e341 100644

--- a/src/ND280UserDetectorConstruction.cc

+++ b/src/ND280UserDetectorConstruction.cc

@@ -327,33 +327,6 @@ void ND280UserDetectorConstruction::DefineMaterials() {

     polystyrene->AddElement(elH, 8);

     gMan->SetDrawAtt(polystyrene,kGray+3);

-    // Default Scintillator Properties -- This defines the baseline properties

-    // for all of the scintillator objects.

-    //

-    // The default value for Birks constant of polystyrene is from:

-    //

-    // M.Hirschberg et al., IEEE Trans. Nuc. Sci. 39 (1992) 511

-    // SCSN-38: kB = (0.806 +/- 0.012)E-2 g/cm^2/MeV

-    // SCSN-28: kB = (0.877 +/- 0.03)E-2 g/cm^2/MeV

-    // GS 2003: kB = (0.844 +/- 0.015)E-2 g/cm^2/MeV

-    // NE 102A: kB = (0.882 +/- 0.012)E-2 g/cm^2/MeV

-    // NE 102A: kB = (0.888 +/- 0.025)E-2 g/cm^2/MeV

-    // KSTI 390: kB = (1.09 +/- 0.015)E-2 g/cm^2/MeV

-    // Simple average: (0.898 +/- 0.099)E-2 g/cm^2/MeV

-    // Average excluding KSTI 390: (0.859 +/- 0.034)E-2 g/cm^2/MeV

-    //

-    // Also: M. Bongrand AIP Conf. Proc. 807 (2007) 14: kB = 9E-2 g/cm^2/MeV

-    //

-    // Wikipedia give a value of 0.126 mm/MeV for polystyrene based

-    // scintillator, and this value seems to pop up in various places.  It

-    // comes from a measurement of 1 mm scintillating fibers

-    //

-    // Leverington, Anelli, Campana, and Rosellini, arxiv:1106.5649 (2011))

-    //

-    // As best I can tell, the value was not fit to data, and is simply what

-    // was used in their simulation.  I don't find any supporting

-    // information in the paper.

-

     // Scintillator -- This is the average polystyrene plastic scintillator as

     // defined in the PDG C6H5CH=CH2 (this is a net C8H8).  The SMRD and ECal

     // geometries have been tuned to this value.  The 1.05 value represents a

@@ -363,8 +336,6 @@ void ND280UserDetectorConstruction::DefineMaterials() {

         = new G4Material(name="Scintillator", density, nel=2);

     scintillator->AddElement(elC, 8);

     scintillator->AddElement(elH, 8);

-    scintillator->GetIonisation()->SetBirksConstant(

-        (0.898E-2)*g/cm2/MeV/density);

     gMan->SetDrawAtt(scintillator,kGreen);

     // P0D Scintillator -- This has the average polystyrene plastic

@@ -380,8 +351,6 @@ void ND280UserDetectorConstruction::DefineMaterials() {

         = new G4Material(name="P0DScintillator", density, nel=2);

     p0dScintillator->AddElement(elC, 8);

     p0dScintillator->AddElement(elH, 8);

-    p0dScintillator->GetIonisation()->SetBirksConstant(

-        (0.898E-2)*g/cm2/MeV/density);

     gMan->SetDrawAtt(p0dScintillator,kGreen);

     // FGD Scintillator -- This is the average polystyrene scintillator for

@@ -393,8 +362,6 @@ void ND280UserDetectorConstruction::DefineMaterials() {

         = new G4Material(name="FGDScintillator", density, nel=2);

     fgdScintillator->AddElement(elC, 8);

     fgdScintillator->AddElement(elH, 8);

-    fgdScintillator->GetIonisation()->SetBirksConstant(

-        (0.898E-2)*g/cm2/MeV/density);

     gMan->SetDrawAtt(fgdScintillator,kGreen);

     // Scintillator coating.  This is the coating that goes around the average

@@ -407,7 +374,6 @@ void ND280UserDetectorConstruction::DefineMaterials() {

         = new G4Material(name="ScintillatorCoating", density, ncomponents=2);

     scintillatorCoating->AddMaterial(TIO2        ,fractionmass = 15*perCent);

     scintillatorCoating->AddMaterial(scintillator,fractionmass = 85*perCent);

-    scintillatorCoating->GetIonisation()->SetBirksConstant(0.0);

     gMan->SetDrawAtt(scintillatorCoating,kGreen);

     // PVC -- Polyvinyl Chloride CH2=CHCl = C3H3Cl

diff --git a/src/ND280UserPrimaryGeneratorMessenger.cc b/src/ND280UserPrimaryGeneratorMessenger.cc

index 98f83c6..ee37871 100644

--- a/src/ND280UserPrimaryGeneratorMessenger.cc

+++ b/src/ND280UserPrimaryGeneratorMessenger.cc

@@ -1,12 +1,15 @@

-#include <G4UIdirectory.hh>

-#include <G4UIcmdWithoutParameter.hh>

-#include <G4UIcmdWithADoubleAndUnit.hh>

-#include <G4UIcmdWith3VectorAndUnit.hh>

-#include <G4UIcmdWith3Vector.hh>

-#include <G4UIcmdWithABool.hh>

-#include <G4UIcmdWithAString.hh>

-#include <G4UIcmdWithAnInteger.hh>

-#include <G4UIcommand.hh>

+////////////////////////////////////////////////////////////

+// $Id$

+//

+

+#include "G4UIdirectory.hh"

+#include "G4UIcmdWithoutParameter.hh"

+#include "G4UIcmdWithADoubleAndUnit.hh"

+#include "G4UIcmdWith3VectorAndUnit.hh"

+#include "G4UIcmdWith3Vector.hh"

+#include "G4UIcmdWithABool.hh"

+#include "G4UIcmdWithAString.hh"

+#include "G4UIcmdWithAnInteger.hh"

 #include <TND280Log.hxx>

@@ -15,7 +18,6 @@

 #include "kinem/ND280PrimaryGenerator.hh"

 #include "kinem/ND280CombinationGenerator.hh"

-#include "kinem/ND280CopyVertexGenerator.hh"

 #include "kinem/ND280VKinematicsFactory.hh"

 #include "kinem/ND280GPSKinematicsFactory.hh"

 #include "kinem/ND280NeutKinematicsFactory.hh"

@@ -91,13 +93,6 @@ ND280UserPrimaryGeneratorMessenger::ND280UserPrimaryGeneratorMessenger(

     fAddCMD = new G4UIcmdWithoutParameter("/generator/add",this);

     fAddCMD->SetGuidance("Add a generator using the current factories.");

-    fCopyVertexCMD = new G4UIcommand("/generator/copy",this);

-    fCopyVertexCMD->SetGuidance("Copy the src position and time to dest.");

-    fCopyVertexCMD->SetParameter(new G4UIparameter("src",'i',false));

-    fCopyVertexCMD->SetParameter(new G4UIparameter("dest",'i',false));

-    fCopyVertexCMD->SetParameter(new G4UIparameter("relative",'b',true));

-    fCopyVertexCMD->GetParameter(2)->SetDefaultValue("false");

-

     fCombineCMD = new G4UIcmdWithoutParameter("/generator/combine",this);

     fCombineCMD->SetGuidance("Combine the previous two vertices into one.");

@@ -152,7 +147,6 @@ ND280UserPrimaryGeneratorMessenger::~ND280UserPrimaryGeneratorMessenger() {

     delete fTimeDir;

     delete fClearCMD;

     delete fAddCMD;

-    delete fCopyVertexCMD;

     delete fCombineCMD;

     delete fSetKinematicsCMD;

     delete fSetCountCMD;

@@ -171,16 +165,6 @@ void ND280UserPrimaryGeneratorMessenger::SetNewValue(G4UIcommand* command,

         ND280PrimaryGenerator* generator = CreateGenerator();

         fAction->AddGenerator(generator);

     }

-    else if (command == fCopyVertexCMD) {

-        int src, dest;

-        std::string relative;

-        std::istringstream is(newValue);

-        is >> src >> dest >> relative;

-        ND280CopyVertexGenerator* generator

-            = new ND280CopyVertexGenerator(

-                src,dest,G4UIcommand::ConvertToBool(relative.c_str()));

-        fAction->AddGenerator(generator);

-    }

     else if (command == fCombineCMD) {

         ND280CombinationGenerator* generator = new ND280CombinationGenerator();

         fAction->AddGenerator(generator);

diff --git a/src/ND280UserRunAction.cc b/src/ND280UserRunAction.cc

index bb3c73c..74f26b8 100644

--- a/src/ND280UserRunAction.cc

+++ b/src/ND280UserRunAction.cc

@@ -65,10 +65,9 @@ void ND280UserRunAction::EndOfRunAction(const G4Run* aRun) {

 void ND280UserRunAction::SetSeed(long seed) {

     if (seed<0) seed = -seed;

-    ND280Log("### Random seed set to: " << seed);

+    ND280Log("### Random seed number set to: " << seed);

     CLHEP::HepRandom::setTheSeed(seed);

-    // Condition the seed.

-    for (int i=0; i<10000000; ++i) G4UniformRand();

+    for (int i=0; i<100000; ++i) G4UniformRand();

 }

 long ND280UserRunAction::GetSeed(void) const {

@@ -86,8 +85,6 @@ void ND280UserRunAction::SetTimeSeed() {

 #else

 #warning Using seconds since epoch to seed the random generator.

     seed = time(NULL);

-    ND280Log("### Set seed from local time in seconds: " << seed);

-    ND280Error("Crude seed being used.  Multiple jobs may share this seed.")

 #endif

     // Make sure the seed is positive;

     if (seed<0) seed = -seed;

diff --git a/src/baseline-2019-08-1.0.mac b/src/baseline-2019-08-1.0.mac

new file mode 100644

index 0000000..82cf12a

--- /dev/null

+++ b/src/baseline-2019-08-1.0.mac

@@ -0,0 +1,23 @@

+############################################################

+# Baseline conditions for the nd280 detectors.

+#

+# This describes the detectors as of the start of run in

+#  October/November 2019.

+#

+# Changes from default geometry.

+#

+#   * LOTS!!!!

+#

+# This is loaded using the /t2k/control directive.

+#

+

+# Set the nominal field (The current is 0A).

+/t2k/field 0.0 tesla

+

+# No water in the first FGD2 plane.

+/t2k/OA/Magnet/Basket/Tracker/FGD2/addMissingWaterLayer 0

+/t2k/OA/Magnet/Basket/Tracker/FGD2/addMissingWaterLayer 4

+

+# Move the magnet to the correct position relative to the basket.

+/t2k/OA/Magnet/leftSplit -1.0 centimeter

+/t2k/OA/Magnet/rightSplit +1.0 centimeter

diff --git a/src/baseline-2019-11-1.0.mac b/src/baseline-2019-11-1.0.mac

new file mode 100644

index 0000000..1b77835

--- /dev/null

+++ b/src/baseline-2019-11-1.0.mac

@@ -0,0 +1,22 @@

+############################################################

+# Baseline conditions for the nd280 detectors.

+#

+# This describes the detectors as of middle of November 2019.  

+#

+# Changes from default geometry.

+#

+#   * LOTS!!!!

+#

+# This is loaded using the /t2k/control directive.

+#

+

+# Set the nominal field (The current is 0A).

+/t2k/field 0.0 tesla

+

+# No water in the first FGD2 plane.

+/t2k/OA/Magnet/Basket/Tracker/FGD2/addMissingWaterLayer 0

+/t2k/OA/Magnet/Basket/Tracker/FGD2/addMissingWaterLayer 4

+

+# Move the magnet to the correct position relative to the basket.

+/t2k/OA/Magnet/leftSplit -1.0 centimeter

+/t2k/OA/Magnet/rightSplit 400.0 centimeter

diff --git a/src/kinem/ND280CombinationGenerator.cc b/src/kinem/ND280CombinationGenerator.cc

index 2044a5e..11b3d14 100644

--- a/src/kinem/ND280CombinationGenerator.cc

+++ b/src/kinem/ND280CombinationGenerator.cc

@@ -1,34 +1,21 @@

-#include <TND280Log.hxx>

-

-#include "ND280CombinationGenerator.hh"

-

 // There isn't any standard interface to remove particles from the vertex,

 // or vertices from the event.  This has to grunge around in the G4

 // internals.  This depends on an evil hack.

-

 #define private public

 #include <G4PrimaryParticle.hh>

 #include <G4PrimaryVertex.hh>

 #include <G4Event.hh>

 #undef private

+#include <TND280Log.hxx>

+

+#include "ND280CombinationGenerator.hh"

+

 ND280CombinationGenerator::ND280CombinationGenerator() {}

 ND280CombinationGenerator::~ND280CombinationGenerator(void) {}

 void ND280CombinationGenerator::GeneratePrimaryVertex(G4Event* evt) {

-#if __cplusplus > 201103L

-#warning Add deprecation warning for the ND280CombinationGenerator

-    std::cout << std::endl

-              << "#################################################"

-              << std::endl

-              << "# WARNING: the ND280CombinationGenerator is deprecated."

-              << std::endl

-              << "#   use /generator/copy (i.e. ND280CopyVertexGenerator)"

-              << std::endl

-              << "#################################################"

-              << std::endl;

-#else

     ND280Info("# Combine previous two vertices");

     // Find the second to last vertex.

@@ -70,7 +57,7 @@ void ND280CombinationGenerator::GeneratePrimaryVertex(G4Event* evt) {

     lastVtx->tailVertex = NULL;

     delete lastVtx;

     --evt->numberOfPrimaryVertex;

-#endif

+

 }

 G4String ND280CombinationGenerator::GetName() {

diff --git a/src/kinem/ND280CopyVertexGenerator.cc b/src/kinem/ND280CopyVertexGenerator.cc