NuclearInteraction.cc

Go to the documentation of this file.

// system headers
#include <cmath>
#include <memory>
#include <vector>
#include <map>
#include <string>
#include <fstream>
#include <iostream>
#include <sys/stat.h>
#include <cmath>
#include <TFile.h>
#include <TTree.h>
#include <TROOT.h>
#include <Math/AxisAngle.h>
#include "Math/Boost.h"
#include "DataFormats/Math/interface/Vector3D.h"

// Framework Headers
#include "FWCore/MessageLogger/interface/MessageLogger.h"
#include "FWCore/ParameterSet/interface/ParameterSet.h"
#include "FWCore/Utilities/interface/Exception.h"
#include "FWCore/ParameterSet/interface/FileInPath.h"

// Fast Sim headers
#include "FastSimulation/SimplifiedGeometryPropagator/interface/Particle.h"
#include "FastSimulation/SimplifiedGeometryPropagator/interface/SimplifiedGeometry.h"
#include "FastSimulation/SimplifiedGeometryPropagator/interface/InteractionModelFactory.h"
#include "FastSimulation/SimplifiedGeometryPropagator/interface/InteractionModel.h"
#include "FastSimulation/SimplifiedGeometryPropagator/interface/Constants.h"
#include "FastSimulation/Utilities/interface/RandomEngineAndDistribution.h"
#include "FastSimDataFormats/NuclearInteractions/interface/NUEvent.h"

// Math
#include "DataFormats/Math/interface/LorentzVector.h"


// Author: Patrick Janot
// Date: 25-Jan-2007
//
// Revision: Class structure modified to match SimplifiedGeometryPropagator
//           Unified the way, the closest charged daughter is defined
//           S. Kurz, 29 May 2017


// TODO: save() function called in destructer. Does that actually make sense?

typedef math::XYZVector XYZVector;
typedef math::XYZTLorentzVector XYZTLorentzVector;

namespace fastsim
{

    class NuclearInteraction : public InteractionModel
    {
        public:
        NuclearInteraction(const std::string & name,const edm::ParameterSet & cfg);

        ~NuclearInteraction() override;


        void interact(fastsim::Particle & particle, const SimplifiedGeometry & layer,std::vector<std::unique_ptr<fastsim::Particle> > & secondaries,const RandomEngineAndDistribution & random) override;

        private:
        unsigned index(int thePid);

        XYZVector orthogonal(const XYZVector& aVector) const;

        void save();

        bool read(std::string inputFile);

        double theDistCut; 
        double theHadronEnergy; 
        std::string inputFile; 


        // Read/Save nuclear interactions from FullSim

        TFile* theFile = nullptr; 
        std::vector< std::vector<TTree*> > theTrees; 
        std::vector< std::vector<TBranch*> > theBranches; 
        std::vector< std::vector<NUEvent*> > theNUEvents; 
        std::vector< std::vector<unsigned> > theCurrentEntry; 
        std::vector< std::vector<unsigned> > theCurrentInteraction; 
        std::vector< std::vector<unsigned> > theNumberOfEntries; 
        std::vector< std::vector<unsigned> > theNumberOfInteractions; 
        std::vector< std::vector<std::string> > theFileNames; 
        std::vector< std::vector<double> > theHadronCM; 

        unsigned ien4; 

        std::ofstream myOutputFile; 
        unsigned myOutputBuffer; 

        bool currentValuesWereSet; 

        // Properties of the Hadrons

        static std::vector< std::vector<double> > theRatiosMap; 
        static std::map<int, int> theIDMap;

        const std::vector<double> theHadronEN = {1.0, 2.0, 3.0, 4.0, 5.0, 7.0, 9.0, 12.0, 15.0, 20.0, 30.0, 50.0, 100.0, 200.0, 300.0, 500.0, 700.0, 1000.0};

        // Use same order for all vectors below (Properties for "piplus", "piminus", "K0L", "Kplus", "Kminus", "p", "pbar", "n", "nbar")

        const std::vector<int> theHadronID = {211, -211, 130, 321, -321, 2212, -2212, 2112, -2112};
        const std::vector<std::string> theHadronNA = {"piplus", "piminus", "K0L", "Kplus", "Kminus", "p", "pbar", "n", "nbar"};
        const std::vector<double> theHadronMA = {0.13957, 0.13957, 0.497648, 0.493677, 0.493677, 0.93827, 0.93827, 0.939565, 0.939565};
        const std::vector<double> theHadronPMin = {0.7, 0.0, 1.0, 1.0, 0.0, 1.1, 0.0, 1.1, 0.0};
        const std::vector<double> theLengthRatio = 
            {
                //pi+      pi-    K0L      K+      K-      p      pbar     n      nbar
                0.2257, 0.2294, 0.3042, 0.2591, 0.2854, 0.3101, 0.5216, 0.3668, 0.4898
            };
        const std::vector<double> theRatios = 
            {   // pi+ (211)
                0.031390573,0.531842852,0.819614219,0.951251711,0.986382750,1.000000000,0.985087033,0.982996773,
                0.990832192,0.992237923,0.994841580,0.973816742,0.967264815,0.971714258,0.969122824,0.978681792,
                0.977312732,0.984255819,
                // pi- (-211)
                0.035326512,0.577356403,0.857118809,0.965683504,0.989659360,1.000000000,0.989599240,0.980665408,
                0.988384816,0.981038152,0.975002104,0.959996152,0.953310808,0.954705592,0.957615400,0.961150456,
                0.965022184,0.960573304,
                // K0L (130)
                0.000000000,0.370261189,0.649793096,0.734342408,0.749079499,0.753360057,0.755790543,0.755872164,
                0.751337674,0.746685288,0.747519634,0.739357554,0.735004444,0.803039922,0.832749896,0.890900187,
                0.936734805,1.000000000,
                // K+ (321)
                0.000000000,0.175571717,0.391683394,0.528946472,0.572818635,0.614210280,0.644125538,0.670304050,
                0.685144573,0.702870161,0.714708513,0.730805263,0.777711536,0.831090576,0.869267129,0.915747562,
                0.953370523,1.000000000,
                // K- (-321)
                0.000000000,0.365353210,0.611663677,0.715315908,0.733498956,0.738361302,0.745253654,0.751459671,
                0.750628335,0.746442657,0.750850669,0.744895986,0.735093960,0.791663444,0.828609543,0.889993040,
                0.940897842,1.000000000,
                // proton (2212)
                0.000000000,0.042849136,0.459103223,0.666165343,0.787930873,0.890397011,0.920999533,0.937832788,
                0.950920131,0.966595049,0.979542270,0.988061653,0.983260159,0.988958431,0.991723494,0.995273237,
                1.000000000,0.999962634,
                // anti-proton (-2212)
                1.000000000,0.849956907,0.775625988,0.802018230,0.816207485,0.785899785,0.754998487,0.728977244, 
                0.710010673,0.670890339,0.665627872,0.652682888,0.613334247,0.647534574,0.667910938,0.689919693, 
                0.709200185,0.724199928,
                // neutron (2112)
                0.000000000,0.059216484,0.437844536,0.610370629,0.702090648,0.780076890,0.802143073,0.819570432,
                0.825829666,0.840079750,0.838435509,0.837529986,0.835687165,0.885205014,0.912450156,0.951451221,
                0.973215562,1.000000000,
                // anti-neutron
                1.000000000,0.849573257,0.756479495,0.787147094,0.804572414,0.791806302,0.760234588,0.741109531,
                0.724118186,0.692829761,0.688465897,0.671806061,0.636461171,0.675314029,0.699134460,0.724305037,
                0.742556115,0.758504713
            };

        // Used to build the ID map 'theIDMap' (i.e., what is to be considered as a proton, etc...)

        const std::vector<int> protonsID = {2212, 3222, -101, -102, -103, -104}; 
        const std::vector<int> antiprotonsID = {-2212, -3222}; 
        const std::vector<int> neutronsID = {2112, 3122, 3112, 3312, 3322, 3334, -3334}; 
        const std::vector<int> antineutronsID = {-2112, -3122, -3112, -3312, -3322}; 
        const std::vector<int> K0LsID = {130, 310}; 
        const std::vector<int> KplussesID = {321}; 
        const std::vector<int> KminussesID = {-321}; 
        const std::vector<int> PiplussesID = {211}; 
        const std::vector<int> PiminussesID = {-211}; 
    };

    // TODO: Is this correct?
    // Thread safety
    static std::once_flag initializeOnce;
    [[cms::thread_guard("initializeOnce")]] std::vector< std::vector<double> > NuclearInteraction::theRatiosMap;
    [[cms::thread_guard("initializeOnce")]] std::map<int, int> NuclearInteraction::theIDMap;
}


fastsim::NuclearInteraction::NuclearInteraction(const std::string & name,const edm::ParameterSet & cfg)
    : fastsim::InteractionModel(name)
    , currentValuesWereSet(false)
{
    // Full path to FullSim root file
    std::string fullPath;

    // Read from config file
    theDistCut = cfg.getParameter<double>("distCut");
    theHadronEnergy = cfg.getParameter<double>("hadronEnergy");
    inputFile = cfg.getUntrackedParameter<std::string>("inputFile","");

    // The evolution of the interaction lengths with energy
    theRatiosMap.resize(theHadronID.size());
    for(unsigned i=0; i<theHadronID.size(); ++i){ 
        for(unsigned j=0; j<theHadronEN.size(); ++j){ 
            theRatiosMap[i].push_back(theRatios[i*theHadronEN.size() + j]);
        }
    }

    // Build the ID map (i.e., what is to be considered as a proton, etc...)
    // Protons
    for(const auto & id : protonsID)  theIDMap[id] = 2212;
    // Anti-Protons
    for(const auto & id : antiprotonsID)  theIDMap[id] = -2212;
    // Neutrons
    for(const auto & id : neutronsID)  theIDMap[id] = 2112;
    // Anti-Neutrons
    for(const auto & id : antineutronsID)  theIDMap[id] = -2112;
    // K0L's
    for(const auto & id : K0LsID)  theIDMap[id] = 130;
    // K+'s
    for(const auto & id : KplussesID)  theIDMap[id] = 321;
    // K-'s
    for(const auto & id : KminussesID)  theIDMap[id] = -321;
    // pi+'s
    for(const auto & id : PiplussesID)  theIDMap[id] = 211;
    // pi-'s
    for(const auto & id : PiminussesID)  theIDMap[id] = -211;

    // Prepare the map of files
    // Loop over the particle names
    TFile* aVFile=nullptr;
    std::vector<TTree*> aVTree(theHadronEN.size());
    std::vector<TBranch*> aVBranch(theHadronEN.size());
    std::vector<NUEvent*> aVNUEvents(theHadronEN.size());
    std::vector<unsigned> aVCurrentEntry(theHadronEN.size());
    std::vector<unsigned> aVCurrentInteraction(theHadronEN.size());
    std::vector<unsigned> aVNumberOfEntries(theHadronEN.size());
    std::vector<unsigned> aVNumberOfInteractions(theHadronEN.size());
    std::vector<std::string> aVFileName(theHadronEN.size());
    std::vector<double> aVHadronCM(theHadronEN.size());
    theTrees.resize(theHadronNA.size());
    theBranches.resize(theHadronNA.size());
    theNUEvents.resize(theHadronNA.size());
    theCurrentEntry.resize(theHadronNA.size());
    theCurrentInteraction.resize(theHadronNA.size());
    theNumberOfEntries.resize(theHadronNA.size());
    theNumberOfInteractions.resize(theHadronNA.size());
    theFileNames.resize(theHadronNA.size());
    theHadronCM.resize(theHadronNA.size());
    theFile = aVFile;
    for(unsigned iname=0; iname<theHadronNA.size(); ++iname){ 
        theTrees[iname] = aVTree;
        theBranches[iname] = aVBranch;
        theNUEvents[iname] = aVNUEvents;
        theCurrentEntry[iname] = aVCurrentEntry;
        theCurrentInteraction[iname] = aVCurrentInteraction;
        theNumberOfEntries[iname] = aVNumberOfEntries;
        theNumberOfInteractions[iname] = aVNumberOfInteractions;
        theFileNames[iname] = aVFileName;
        theHadronCM[iname] = aVHadronCM;
    } 

    // Read the information from a previous run (to keep reproducibility)
    currentValuesWereSet = this->read(inputFile);
    if(currentValuesWereSet)
    std::cout << "***WARNING*** You are reading nuclear-interaction information from the file "
        << inputFile << " created in an earlier run."
        << std::endl;

    // Open the file for saving the information of the current run
    myOutputFile.open("NuclearInteractionOutputFile.txt");
    myOutputBuffer = 0;

    // Open the root file
    edm::FileInPath myDataFile("FastSimulation/MaterialEffects/data/NuclearInteractions.root");
    fullPath = myDataFile.fullPath();
    theFile = TFile::Open(fullPath.c_str());

    // Open the trees
    unsigned fileNb = 0;
    for(unsigned iname=0; iname<theHadronNA.size(); ++iname){
        for(unsigned iene=0; iene<theHadronEN.size(); ++iene){
            std::ostringstream filename;
            double theEne = theHadronEN[iene];
            filename << "NuclearInteractionsVal_" << theHadronNA[iname] << "_E"<< theEne << ".root";
            theFileNames[iname][iene] = filename.str();

            ++fileNb;
            std::string treeName="NuclearInteractions_"+theHadronNA[iname]+"_E"+std::to_string(int(theEne));
            theTrees[iname][iene] = (TTree*) theFile->Get(treeName.c_str()); 

            if ( !theTrees[iname][iene] ) throw cms::Exception("FastSimulation/MaterialEffects") 
                << "Tree with name " << treeName << " not found ";
            theBranches[iname][iene] = theTrees[iname][iene]->GetBranch("nuEvent");
            if ( !theBranches[iname][iene] ) throw cms::Exception("FastSimulation/MaterialEffects") 
                << "Branch with name nuEvent not found in " << theFileNames[iname][iene];

            theNUEvents[iname][iene] = new NUEvent();
            theBranches[iname][iene]->SetAddress(&theNUEvents[iname][iene]);
            theNumberOfEntries[iname][iene] = theTrees[iname][iene]->GetEntries();

            if(currentValuesWereSet){
                theTrees[iname][iene]->GetEntry(theCurrentEntry[iname][iene]);
                unsigned NInteractions = theNUEvents[iname][iene]->nInteractions();
                theNumberOfInteractions[iname][iene] = NInteractions;
            }

            // Compute the corresponding cm energies of the nuclear interactions
            XYZTLorentzVector Proton(0.,0.,0.,0.986);
            XYZTLorentzVector Reference(0.,
                0.,
                std::sqrt(theHadronEN[iene]*theHadronEN[iene]-theHadronMA[iname]*theHadronMA[iname]),
                theHadronEN[iene]);
            theHadronCM[iname][iene] = (Reference+Proton).M();
        }
    }

    // Find the index for which EN = 4. (or thereabout)
    ien4 = 0;
    while(theHadronEN[ien4] < 4.0) ++ien4;

    gROOT->cd();
}

fastsim::NuclearInteraction::~NuclearInteraction() {
    // Close all local files
    // Among other things, this allows the TROOT destructor to end up 
    // without crashing, while trying to close these files from outside
    theFile->Close();
    delete theFile;

    for(auto& vEvents: theNUEvents){
        for(auto evtPtr: vEvents){
            delete evtPtr;
        }
    }

    // Save data
    save();
    // Close the output file
    myOutputFile.close();
}


void fastsim::NuclearInteraction::interact(fastsim::Particle & particle, const SimplifiedGeometry & layer,std::vector<std::unique_ptr<fastsim::Particle> > & secondaries,const RandomEngineAndDistribution & random)
{   
    int pdgId = particle.pdgId();
    //
    // no valid PDGid
    //
    if(abs(pdgId) <= 100 || abs(pdgId) >= 1000000)
    {
    return;
    }

    double radLengths = layer.getThickness(particle.position(),particle.momentum());
    // TEC layers have some fudge factor for nuclear interactions
    radLengths *= layer.getNuclearInteractionThicknessFactor();
    //
    // no material
    //
    if(radLengths < 1E-10)
    {
    return;
    }

    // In case the events are not read from (old) saved file, then pick a random event from FullSim file
    if(!currentValuesWereSet) {
        currentValuesWereSet = true;
        for ( unsigned iname=0; iname<theHadronNA.size(); ++iname ) {
            for ( unsigned iene=0; iene<theHadronEN.size(); ++iene ) {
                theCurrentEntry[iname][iene] = (unsigned) (theNumberOfEntries[iname][iene] * random.flatShoot());

                theTrees[iname][iene]->GetEntry(theCurrentEntry[iname][iene]);
                unsigned NInteractions = theNUEvents[iname][iene]->nInteractions();
                theNumberOfInteractions[iname][iene] = NInteractions;

                theCurrentInteraction[iname][iene] = (unsigned) (theNumberOfInteractions[iname][iene] * random.flatShoot());
            }
        }
    }

    // Momentum of interacting hadron
    double pHadron = std::sqrt(particle.momentum().Vect().Mag2()); 

    //
    // The hadron has not enough momentum to create some relevant final state
    //
    if(pHadron < theHadronEnergy){
    return;
    } 

    // The particle type
    std::map<int,int>::const_iterator thePit = theIDMap.find(pdgId);
    // Use map for unique ID (e.g. proton = {2212, 3222, -101, -102, -103, -104})
    int thePid = (thePit != theIDMap.end() ? thePit->second : pdgId); 

    // Is this particle type foreseen?
    unsigned fPid = abs(thePid);
    if(fPid != 211 && fPid != 130 && fPid != 321 && fPid != 2112 && fPid != 2212)
    { 
    return;
    }

    // The hashed ID
    unsigned thePidIndex = index(thePid);
    // The inelastic interaction length at p(Hadron) = 5 GeV/c
    double theInelasticLength = radLengths * theLengthRatio[thePidIndex];

    // The elastic interaction length
    // The baroque parameterization is a fit to Fig. 40.13 of the PDG
    double ee = pHadron > 0.6 ? exp(-std::sqrt((pHadron-0.6)/1.122)) : exp(std::sqrt((0.6-pHadron)/1.122));
    double theElasticLength = (0.8753 * ee + 0.15) * theInelasticLength;

    // The total interaction length
    double theTotalInteractionLength = theInelasticLength + theElasticLength;

    //
    // Probability to interact is dl/L0 (maximum for 4 GeV Hadron)
    //
    double aNuclInteraction = -std::log(random.flatShoot());
    if(aNuclInteraction > theTotalInteractionLength)
    {
    return;
    }

    // The elastic part
    double elastic = random.flatShoot();
    if(elastic < theElasticLength/theTotalInteractionLength){
        // Characteristic scattering angle for the elastic part
        // A of silicon
        double A = 28.0855;
        double theta0 = std::sqrt(3.)/ std::pow(A,1./3.) * particle.momentum().mass()/pHadron; 

        // Draw an angle with theta/theta0*exp[(-theta/2theta0)**2] shape 
        double theta = theta0 * std::sqrt(-2.*std::log(random.flatShoot()));
        double phi = 2. * M_PI * random.flatShoot();

        // Rotate the particle accordingly
        ROOT::Math::AxisAngle rotation1(orthogonal(particle.momentum().Vect()),theta);
        ROOT::Math::AxisAngle rotation2(particle.momentum().Vect(),phi);
        // Rotate!
        XYZVector rotated = rotation2((rotation1(particle.momentum().Vect())));

        // Create a daughter if the kink is large enough
        if (std::sin(theta) > theDistCut) { 
            secondaries.emplace_back(new fastsim::Particle(pdgId
                ,particle.position()
                ,XYZTLorentzVector(rotated.X(),
                                    rotated.Y(),
                                    rotated.Z(),
                                    particle.momentum().E())));
            
            // Set the ClosestCharged Daughter thing for tracking
            if(particle.charge() != 0){
                secondaries.back()->setMotherDeltaR(particle.momentum());
                secondaries.back()->setMotherPdgId(pdgId);
                secondaries.back()->setMotherSimTrackIndex(particle.simTrackIndex());
            }

            // The particle is destroyed
            particle.momentum().SetXYZT(0., 0., 0., 0.);
        }else{
            // If kink is small enough just rotate particle
            particle.momentum().SetXYZT(rotated.X(),
                                    rotated.Y(),
                                    rotated.Z(),
                                    particle.momentum().E());
        }
    // The inelastic part
    }else{
        // Avoid multiple map access
        const std::vector<double>& aHadronCM = theHadronCM[thePidIndex];
        const std::vector<double>& aRatios = theRatiosMap[thePidIndex];
        // Find the file with the closest c.m energy
        // The target nucleon
        XYZTLorentzVector Proton(0.,0.,0.,0.939);
        // The current particle
        const XYZTLorentzVector& Hadron = (const XYZTLorentzVector&)particle.momentum();
        // The smallest momentum for inelastic interactions
        double pMin = theHadronPMin[thePidIndex]; 
        // The corresponding smallest four vector
        XYZTLorentzVector Hadron0(0.,
                                0.,
                                pMin,
                                std::sqrt(pMin*pMin+particle.momentum().M2()));

        // The current centre-of-mass energy
        double ecm = (Proton+Hadron).M();

        // Get the files of interest (closest c.m. energies)
        unsigned ene1=0;
        unsigned ene2=0;
        // The smallest centre-of-mass energy
        double ecm1= (Proton+Hadron0).M();

        double ecm2=aHadronCM[0]; 
        double ratio1=0.;
        double ratio2=aRatios[0];
        if(ecm > aHadronCM[0] && ecm < aHadronCM[aHadronCM.size()-1]){
            for(unsigned ene=1; ene < aHadronCM.size() && ecm > aHadronCM[ene-1]; ++ene){
                if(ecm < aHadronCM[ene]){ 
                    ene2 = ene;
                    ene1 = ene2-1;
                    ecm1 = aHadronCM[ene1];
                    ecm2 = aHadronCM[ene2];
                    ratio1 = aRatios[ene1];
                    ratio2 = aRatios[ene2];
                } 
            }
        }else if(ecm > aHadronCM[aHadronCM.size()-1]){ 
            ene1 = aHadronCM.size()-1;
            ene2 = aHadronCM.size()-2;
            ecm1 = aHadronCM[ene1];
            ecm2 = aHadronCM[ene2];
            ratio1 = aRatios[ene2];
            ratio2 = aRatios[ene2];
        } 

        // The inelastic part of the cross section depends cm energy
        double slope = (std::log10(ecm) - std::log10(ecm1)) / (std::log10(ecm2) - std::log10(ecm1));
        double inelastic = ratio1 + (ratio2 - ratio1) * slope;
        double inelastic4 =  pHadron < 4. ? aRatios[ien4] : 1.;  

        // Simulate an inelastic interaction
        if(elastic > 1.- (inelastic*theInelasticLength) / theTotalInteractionLength){ 
            // Avoid mutliple map access
            std::vector<unsigned>& aCurrentInteraction = theCurrentInteraction[thePidIndex];
            std::vector<unsigned>& aNumberOfInteractions = theNumberOfInteractions[thePidIndex];
            std::vector<NUEvent*>& aNUEvents = theNUEvents[thePidIndex];

            // Choice of the file to read according the the log10(ecm) distance
            // and protection against low momentum proton and neutron that never interacts 
            // (i.e., empty files)
            unsigned ene;
            if(random.flatShoot() < slope || aNumberOfInteractions[ene1] == 0){
                ene = ene2; 
            }else{
                ene = ene1;
            }

            // The boost characteristics
            XYZTLorentzVector theBoost = Proton + Hadron;
            theBoost /= theBoost.e();

            // Check we are not either at the end of an interaction bunch 
            // or at the end of a file
            if(aCurrentInteraction[ene] == aNumberOfInteractions[ene]){
                std::vector<unsigned>& aCurrentEntry = theCurrentEntry[thePidIndex];
                std::vector<unsigned>& aNumberOfEntries = theNumberOfEntries[thePidIndex];
                std::vector<TTree*>& aTrees = theTrees[thePidIndex];
                ++aCurrentEntry[ene];

                aCurrentInteraction[ene] = 0;
                if(aCurrentEntry[ene] == aNumberOfEntries[ene]){ 
                    aCurrentEntry[ene] = 0;
                }

                unsigned myEntry = aCurrentEntry[ene]; 
                aTrees[ene]->GetEntry(myEntry);
                aNumberOfInteractions[ene] = aNUEvents[ene]->nInteractions();
            }

            // Read the interaction
            NUEvent::NUInteraction anInteraction = aNUEvents[ene]->theNUInteractions()[aCurrentInteraction[ene]];

            unsigned firstTrack = anInteraction.first; 
            unsigned lastTrack = anInteraction.last;

            // Some rotation around the boost axis, for more randomness
            XYZVector theAxis = theBoost.Vect().Unit();
            double theAngle = random.flatShoot() * 2. * M_PI;
            ROOT::Math::AxisAngle axisRotation(theAxis,theAngle);
            ROOT::Math::Boost axisBoost(theBoost.x(),theBoost.y(),theBoost.z());

            // A rotation to bring the particles back to the Hadron direction
            XYZVector zAxis(0.,0.,1.); 
            XYZVector orthAxis = (zAxis.Cross(theBoost.Vect())).Unit(); 
            double orthAngle = acos(theBoost.Vect().Unit().Z());
            ROOT::Math::AxisAngle orthRotation(orthAxis,orthAngle);

            // Loop on the nuclear interaction products
            for(unsigned iTrack=firstTrack; iTrack<=lastTrack; ++iTrack){
                NUEvent::NUParticle aParticle = aNUEvents[ene]->theNUParticles()[iTrack];

                // Add a RawParticle with the proper energy in the c.m. frame of 
                // the nuclear interaction
                double energy = std::sqrt(aParticle.px*aParticle.px
                                    + aParticle.py*aParticle.py
                                    + aParticle.pz*aParticle.pz
                                    + aParticle.mass*aParticle.mass / (ecm * ecm));

                XYZTLorentzVector daugtherMomentum(aParticle.px*ecm, aParticle.py*ecm, aParticle.pz*ecm, energy*ecm);

                // Rotate to the collision axis
                XYZVector rotated = orthRotation(daugtherMomentum.Vect());
                // Rotate around the boost axis for more randomness
                rotated = axisRotation(rotated);

                // Rotated the daughter
                daugtherMomentum.SetXYZT(rotated.X(), rotated.Y(), rotated.Z(), daugtherMomentum.E());

                // Boost it in the lab frame
                daugtherMomentum = axisBoost(daugtherMomentum);

                // Create secondary
                secondaries.emplace_back(new fastsim::Particle(aParticle.id, particle.position(), daugtherMomentum));

                // The closestCharged Daughter thing for tracking
                // BUT: 'aParticle' also has to be charged, only then the mother should be set
                // Unfortunately, NUEvent::NUParticle does not contain any info about the charge
                // Did some tests and effect is absolutely negligible!
                if(particle.charge() != 0){
                    secondaries.back()->setMotherDeltaR(particle.momentum());
                    secondaries.back()->setMotherPdgId(pdgId);
                    secondaries.back()->setMotherSimTrackIndex(particle.simTrackIndex());
                }
            }

            // The particle is destroyed
            particle.momentum().SetXYZT(0., 0., 0., 0.);

            // This is a note from previous version of code but I don't understand it:
            // ERROR The way this loops through the events breaks
            // replay. Which events are retrieved depends on
            // which previous events were processed.

            // Increment for next time
            ++aCurrentInteraction[ene];

        // Simulate a stopping hadron (low momentum)
        }else if(pHadron < 4. && elastic > 1.- (inelastic4*theInelasticLength) / theTotalInteractionLength){ 
            // The particle is destroyed
            particle.momentum().SetXYZT(0., 0., 0., 0.);
        }
    }
}

void
fastsim::NuclearInteraction::save()
{
    // Size of buffer
    ++myOutputBuffer;

    // Periodically close the current file and open a new one
    if(myOutputBuffer/1000*1000 == myOutputBuffer){ 
        myOutputFile.close();
        myOutputFile.open ("NuclearInteractionOutputFile.txt");
    }
    //
    unsigned size1 = theCurrentEntry.size() * theCurrentEntry.begin()->size();
    std::vector<unsigned> theCurrentEntries;
    theCurrentEntries.resize(size1);
    size1*=sizeof(unsigned);
    //
    unsigned size2 = theCurrentInteraction.size() * theCurrentInteraction.begin()->size();
    std::vector<unsigned> theCurrentInteractions;
    theCurrentInteractions.resize(size2);
    size2 *= sizeof(unsigned);

    // Save the current entries 
    std::vector< std::vector<unsigned> >::const_iterator aCurrentEntry = theCurrentEntry.begin();
    std::vector< std::vector<unsigned> >::const_iterator lastCurrentEntry = theCurrentEntry.end();
    unsigned allEntries=0;
    for(; aCurrentEntry!=lastCurrentEntry; ++aCurrentEntry){ 
        unsigned size = aCurrentEntry->size();
        for(unsigned iene=0; iene<size; ++iene)
            theCurrentEntries[allEntries++] = (*aCurrentEntry)[iene]; 
    }

    // Save the current interactions
    std::vector< std::vector<unsigned> >::const_iterator aCurrentInteraction = theCurrentInteraction.begin();
    std::vector< std::vector<unsigned> >::const_iterator lastCurrentInteraction = theCurrentInteraction.end();
    unsigned allInteractions=0;
    for (; aCurrentInteraction!=lastCurrentInteraction; ++aCurrentInteraction){ 
        unsigned size = aCurrentInteraction->size();
        for(unsigned iene=0; iene<size; ++iene)
            theCurrentInteractions[allInteractions++] = (*aCurrentInteraction)[iene]; 
    }
    // Write to file 
    myOutputFile.write((const char*)(&theCurrentEntries.front()), size1);
    myOutputFile.write((const char*)(&theCurrentInteractions.front()), size2);  
    myOutputFile.flush();
}

bool
fastsim::NuclearInteraction::read(std::string inputFile)
{
    std::ifstream myInputFile;
    struct stat results;
    //
    unsigned size1 = theCurrentEntry.size() * theCurrentEntry.begin()->size();
    std::vector<unsigned> theCurrentEntries;
    theCurrentEntries.resize(size1);
    size1*=sizeof(unsigned);
    //
    unsigned size2 = theCurrentInteraction.size() * theCurrentInteraction.begin()->size();
    std::vector<unsigned> theCurrentInteractions;
    theCurrentInteractions.resize(size2);
    size2 *= sizeof(unsigned);
    //
    unsigned size = 0;


    // Open the file (if any), otherwise return false
    myInputFile.open (inputFile.c_str());
    if(myInputFile.is_open()){ 

        // Get the size of the file
        if(stat(inputFile.c_str(), &results) == 0) size = results.st_size;
        else return false; // Something is wrong with that file !

        // Position the pointer just before the last record
        myInputFile.seekg(size-size1-size2);
        myInputFile.read((char*)(&theCurrentEntries.front()),size1);
        myInputFile.read((char*)(&theCurrentInteractions.front()),size2);
        myInputFile.close();

        // Read the current entries
        std::vector< std::vector<unsigned> >::iterator aCurrentEntry = theCurrentEntry.begin();
        std::vector< std::vector<unsigned> >::iterator lastCurrentEntry = theCurrentEntry.end();
        unsigned allEntries=0;
        for(; aCurrentEntry!=lastCurrentEntry; ++aCurrentEntry){ 
            unsigned size = aCurrentEntry->size();
            for(unsigned iene=0; iene<size; ++iene)
                (*aCurrentEntry)[iene] = theCurrentEntries[allEntries++]; 
        }

        // Read the current interactions
        std::vector< std::vector<unsigned> >::iterator aCurrentInteraction = theCurrentInteraction.begin();
        std::vector< std::vector<unsigned> >::iterator lastCurrentInteraction = theCurrentInteraction.end();
        unsigned allInteractions=0;
        for(; aCurrentInteraction!=lastCurrentInteraction; ++aCurrentInteraction){ 
            unsigned size = aCurrentInteraction->size();
            for(unsigned iene=0; iene<size; ++iene)
                (*aCurrentInteraction)[iene] =  theCurrentInteractions[allInteractions++];
        }

        return true;
    }

    return false;
}

unsigned 
fastsim::NuclearInteraction::index(int thePid)
{   
    // Find hashed particle ID
    unsigned myIndex=0;
    while(thePid != theHadronID[myIndex]) ++myIndex; 
    return myIndex;
}

XYZVector 
fastsim::NuclearInteraction::orthogonal(const XYZVector& aVector) const
{ 
    double x = fabs(aVector.X());
    double y = fabs(aVector.Y());
    double z = fabs(aVector.Z());

    if (x < y) 
    return x < z ? 
      XYZVector(0.,aVector.Z(),-aVector.Y()) :
      XYZVector(aVector.Y(),-aVector.X(),0.);
    else
    return y < z ? 
      XYZVector(-aVector.Z(),0.,aVector.X()) :
      XYZVector(aVector.Y(),-aVector.X(),0.);
}


DEFINE_EDM_PLUGIN(
    fastsim::InteractionModelFactory,
    fastsim::NuclearInteraction,
    "fastsim::NuclearInteraction"
    );