Implement pp6calculator Day 4 Homework

Add operation to Day 4 menu to call `pp6day4_muonanalysis` function for
implementing the homework solution.

Provide typedefs to build data structures useful in solution

- `Event` : Pair connecting int(EventId) to Particle
- `EventVector` : Vector of Events
- `RunMap` : map string(RunId) to `EventVector`
- `InvMassPair` : pair linking two Events
- `InvMassTable` : multimap double(InvariantMass) to InvMassPair

Factor problem into six main steps:

- Initialize `ParticleInfo` database from user supplied file
- Create a `RunMap` instance and read data from user supplied file
  into this structure
- Extract `EventVector` mapped from "run4.dat" RunId
- Copy mu- and mu+ Events from the run4.dat `EventVector` into
  dedicated `EventVector`s for each type
- Take Cartesian Product of mu-/mu+ `EventVectors`, operation being
  the invariant mass of the combinations and copy the resultant
  invariant mass and the `EventPair` into an `InvMassTable` instance
- Iterate over the `InvMassTable` presenting 10 largest invariant masses
  and the event pair that created it.

No sorting is needed as the multimap used to store invariant masses
sorts the keys (the invariant masses) for us.
Complete pp6calculator Homework Exercise for Day 4

Update News section of README to note completion of the homework
exercise.
Update Particle and ParticleInfo classes for Day 5

Make ParticleInfo a Singleton as the PDG database is a natural candidate
for this pattern. Refactor client code to use new Instance method for
accessing the single instance.

Add mass and charge data members to Particle class. Determine the values
for these using PDG code supplied to constructor to query ParticleInfo
database. NB: must have an initialized database before constructing any
Particles!

Add additional member functions:

- getName() : returns PDG name
- getCharge() : returns particle charge
- setPDGCode(int) : change particle PDG code, recalculating properties
- boost_v(double) : boost the particle four momentum along the z-axis

and free functions:

- operator<< : to stream a Particle instance to an ostream
- calculate_invariant_mass(vector<Particle>) : return invariant mass
  of a collection of particles
Implement pp6calculator Day 5 Exercise 1 solution

Add EventGenerator pure abstract class declaration. Add header to list
of sources of pp6lib library, as whilst it will not be built, CMake will
ensure it is visible to IDEs like Xcode.
Implement pp6calculator Day 5 Exercise 2 solution

Add top level menu for Day 5 with single operation for testing new
TwoBodyGenerator concrete class of EventGenerator.

Factor creation of ParticleInfo database into function, caching a static
boolen in function to mark database as initialized. User no longer needs
to enter PDG text file multiple times.

Implement TwoBodyGenerator concrete class as per design discussion from
Day 5 presentation. Construct the generator from names of mother and
daughter particles. Use ParticleInfo to determine particle properties,
checking that energy and charge are conserved by the requested decay (no
checking of spin is performed at this stage). If decay is valid, cache
the Q value of the decay for use in the generate method.

Implement generate method by isotropically generating daughter momenta
in rest frame, then boosting to lab frame given supplied beta.

Implement testing of TwoBodyGenerator by generating 50 B0->K+pi- decays
and outputing the resulting invariant mass of the products, comparing
this visually with the expected B0 mass from ParticleInfo.
Implement pp6calculator Day 5 Exercise 3 solution

Import header and implementation files supplied by course for
ThreeBodyGenerator and opaque ThreeBodyKinematics classes. Add to
build.

Add menu operation to Day 5 menu to test ThreeBodyGenerator. As per
instructions, generate 50 D-->K+pi-pi- decays and output decay products
and invariant mass of products to screen. "Test" via visual comparison
between invariant mass of decay products and D- mass as provided by the
ParticleInfo database.
Implement pp6calculator Day 5 Exercise 4 solution

Import supplied decay table to file to top of repository and copy it to
build directory for easy testing and usage.

Add operation to Day 5 menu to call function
pp6day5_test_dynamicgeneration. In this function, query user for decay
table file to load. If file is valid, read in lines and for two and
three body entries add a new (Two/Three)BodyGenerator instance to
colection of EventGenerator pointers.

Iterate over resulting collection, generating an event and printing
decay products and invariant mass of products to screen.

Use for_each algorithm and custom deleteGenerator function to iterate
over collection, deleting each element. Clear the collection after
deletions to ensure no dangling pointers.
Implement pp6calculator Day 5 Exercise 5 solution

Use Boost's shared_ptr to manage lifetime of EventGenerator instances
stored in a collection. Instrument destructors of EventGenerator pABC
and concrete instances to show that these are automatically deleted when
the collection goes out of scope.
Complete Day 5 Exercise Solutions

Update NEWS in README to note completion of the Day 5 exercises