xcoll 0.3.3__py3-none-any.whl → 0.3.5__py3-none-any.whl

xcoll/scattering_routines/geant4/collimasim/src/collimasim/BDSXtrackInterface.cpp

@@ -1,662 +0,0 @@
-#include "BDSXtrackInterface.hh"
-#include <cstring>
-#include <cmath>
-#include <BDSSamplerCustom.hh>
-
-
-BDSParticleDefinition* PrepareBDSParticleDefition(long long int pdgIDIn, double momentumIn, double kineticEnergyIn)
-{
-    G4ParticleTable* particleTable = G4ParticleTable::GetParticleTable();
-    G4ParticleDefinition* particleDef = particleTable->FindParticle(pdgIDIn);
-    if (!particleDef)
-    {throw BDSException("BDSBunchUserFile> Particle \"" + std::to_string(pdgIDIn) + "\" not found");}
-
-    BDSIonDefinition* ionDef = nullptr;
-    if (BDS::IsIon(particleDef))
-    {
-        throw BDSException("BDSBunchUserFile> Particle \"" + std::to_string(pdgIDIn) + "\" is an ion and is not supported.");
-    }
-
-    // Wrap in our class that calculates momentum and kinetic energy.
-    // Requires that one of E, Ek, P be non-zero (only one).
-    BDSParticleDefinition* particleDefinition = nullptr;
-
-    // This should throw an error if both the kintetic energy and the momentum are set
-    particleDefinition = new BDSParticleDefinition(particleDef, 0, kineticEnergyIn, momentumIn, 1, ionDef);
-
-    return particleDefinition;
-}
-
-
-XtrackInterface::XtrackInterface(const  std::string& bdsimConfigFile,
-                                 int    referencePdgIdIn,
-                                 double referenceEkIn,
-                                 double relativeEnergyCutIn,
-                                 int    seedIn,
-                                 bool   batchMode):
-        relativeEnergyCut(relativeEnergyCutIn),
-        seed(seedIn)
-{
-    stp = new BDSBunchSixTrackLink();
-    bds = new BDSIMLink(stp);
-
-    std::string seedStr = std::to_string(seed);
-    std::vector<std::string> arguments = {"--file=" + bdsimConfigFile,
-                                          "--file=" + bdsimConfigFile,
-                                          //"--vis_debug",
-                                          "--output=none",
-                                          "--seed=" + seedStr,
-                                          "--outfile=output_" + seedStr};
-
-    for(auto & argument : arguments)
-    {
-        argv.push_back(strdup(argument.c_str()));
-    }
-    if (batchMode)
-    {
-        std::string batch_flag = "--batch";
-        argv.push_back(strdup(batch_flag.c_str()));
-    }
-    argv.push_back(nullptr);
-
-    double referenceEk = referenceEkIn * CLHEP::GeV;
-
-    double relEKCut = relativeEnergyCut;
-    if (relEKCut < 1e-6) // defaults to 0 which means 0eV cut which is bad
-    { relEKCut = 1.0; }
-
-    double minimumEK = relEKCut * (referenceEk);
-
-    G4cout << "Minimum kinetic energy " << minimumEK << " MeV" << G4endl;
-    auto data = argv.data();
-    try
-    { bds->Initialise(argv.size() - 1, &argv[0], true, minimumEK / CLHEP::GeV, false); } // minimumEk in GeV
-    catch (const std::exception &e)
-    {
-        std::cout << e.what() << std::endl;
-        exit(1);
-    }
-
-    refParticleDefinition = PrepareBDSParticleDefition(referencePdgIdIn, 0, referenceEk);
-}
-
-
-XtrackInterface::~XtrackInterface()
-{
-    delete bds;
-    delete stp;
-
-    delete refParticleDefinition;
-}
-
-
-void XtrackInterface::addCollimator(const std::string&   name,
-                                    const std::string&   material,
-                                    double lengthIn,
-                                    double apertureLeftIn,
-                                    double apertureRightIn,
-                                    double rotationIn,
-                                    double xOffsetIn,
-                                    double yOffsetIn,
-                                    double jawTiltLeft,
-                                    double jawTiltRight,
-                                    int    side)
-    {
-
-        bool buildLeft  = side == 0 || side == 1;
-        bool buildRight = side == 0 || side == 2;
-
-        bool isACrystal = false;
-
-        bds->AddLinkCollimatorJaw(name,
-                                  material,
-                                  lengthIn * CLHEP::m,
-                                  apertureLeftIn * CLHEP::m,
-                                  apertureRightIn * CLHEP::m,
-                                  rotationIn * CLHEP::rad,
-                                  xOffsetIn * CLHEP::m,
-                                  yOffsetIn * CLHEP::m,
-                                  jawTiltLeft * CLHEP::rad,
-                                  jawTiltRight * CLHEP::rad,
-                                  buildLeft,
-                                  buildRight,
-                                  isACrystal,
-                                  0);
-    }
-
-
-void XtrackInterface::addParticle(double xIn,
-                                  double yIn,
-                                  double pxIn,
-                                  double pyIn,
-                                  double ctIn,
-                                  double deltapIn,
-                                  double sIn,
-                                  int64_t trackidIn
-                                  )
-{
-
-    G4double p = refParticleDefinition->Momentum() * (G4double) deltapIn + refParticleDefinition->Momentum();
-
-    // For now, use the pdgID from the reference particle definition, which is stored as a data member
-    // In general, each particle can be of different species
-    auto partDef = PrepareBDSParticleDefition(refParticleDefinition->PDGID(), p, 0);
-
-    G4double t = - (G4double) ctIn * CLHEP::m / (refParticleDefinition->Beta() * CLHEP::c_light); // this is time difference in ns
-
-    auto x  = (G4double) xIn;
-    auto y  = (G4double) yIn;
-    auto px  = (G4double) pxIn;
-    auto py  = (G4double) pyIn;
-    auto s = (G4double) sIn;
-    auto trackid = (G4int) trackidIn;
-
-    G4double oneplusdelta = 1 + deltapIn;
-    // G4double pz = std::sqrt(oneplusdelta*oneplusdelta - px*px - py*py);
-    G4double xp = px / oneplusdelta;
-    G4double yp = py / oneplusdelta;
-
-    // Zp0 is 1 as here we assume no back-scatterd particles, e.g p>0
-    G4double zp = BDSBunch::CalculateZp(xp, yp, 1);
-
-    BDSParticleCoordsFull coords = BDSParticleCoordsFull(x * CLHEP::m,
-                                                         y * CLHEP::m,
-                                                         0,
-                                                         xp,
-                                                         yp,
-                                                         zp,
-                                                         t,
-                                                         0,
-                                                         partDef->TotalEnergy(),
-                                                         1);
-
-    stp->AddParticle(partDef, coords, trackid, trackid);
-}
-
-
-void XtrackInterface::addParticles(const py::list& coordinates)
-{
-    // Obtain the arrays from the list and cast them to the correct array type
-    py::array_t<double> x = py::cast<py::array>(coordinates[0]);
-    py::array_t<double> y = py::cast<py::array>(coordinates[1]);
-    py::array_t<double> px = py::cast<py::array>(coordinates[2]);
-    py::array_t<double> py = py::cast<py::array>(coordinates[3]);
-    py::array_t<double> zeta = py::cast<py::array>(coordinates[4]);
-    py::array_t<double> delta = py::cast<py::array>(coordinates[5]);
-    py::array_t<double> s = py::cast<py::array>(coordinates[6]);
-    py::array_t<int64_t> trackid = py::cast<py::array>(coordinates[7]);
-    py::array_t<int64_t> state = py::cast<py::array>(coordinates[8]);
-    py::array_t<int64_t> at_element = py::cast<py::array>(coordinates[9]);
-    py::array_t<int64_t> at_turn = py::cast<py::array>(coordinates[10]);
-
-
-    // Obtain the buffers
-    py::buffer_info x_buff = x.request();
-    py::buffer_info y_buff = y.request();
-    py::buffer_info px_buff = px.request();
-    py::buffer_info py_buff = py.request();
-    py::buffer_info zeta_buff = zeta.request();
-    py::buffer_info delta_buff = delta.request();
-    py::buffer_info s_buff = s.request();
-    py::buffer_info id_buff = trackid.request();
-    py::buffer_info state_buff = state.request();
-    py::buffer_info at_element_buff = at_element.request();
-    py::buffer_info at_turn_buff = at_turn.request();
-
-    // Get the pointers for iteration
-    auto x_ptr = static_cast<double *>(x_buff.ptr);
-    auto y_ptr = static_cast<double *>(y_buff.ptr);
-    auto px_ptr = static_cast<double *>(px_buff.ptr);
-    auto py_ptr = static_cast<double *>(py_buff.ptr);
-    auto zeta_ptr = static_cast<double *>(zeta_buff.ptr);
-    auto delta_ptr = static_cast<double *>(delta_buff.ptr);
-    auto s_ptr = static_cast<double *>(s_buff.ptr);
-    auto trackid_ptr = static_cast<int64_t *>(id_buff.ptr);
-    auto state_ptr = static_cast<int64_t *>(state_buff.ptr);
-    auto at_element_ptr = static_cast<int64_t *>(at_element_buff.ptr);
-    auto at_turn_ptr = static_cast<int64_t *>(at_turn_buff.ptr);
-
-    long n = 1; // Get the number of elements in the array, assume all arrays have the same number of elements
-    for (auto r: x_buff.shape) {
-        n *= r;
-    }
-
-    for(int i=0; i < n; i++)
-    {
-        auto x_part = x_ptr[i];
-        auto y_part = y_ptr[i];
-        auto px_part = px_ptr[i];
-        auto py_part = py_ptr[i];
-        auto zeta_part = zeta_ptr[i];
-        auto delta_part = delta_ptr[i];
-        auto s_part = s_ptr[i];
-        auto trackid_part = trackid_ptr[i];
-        auto state_part = state_ptr[i];
-        auto at_element_part = at_element_ptr[i];
-        auto at_turn_part = at_turn_ptr[i];
-
-        // The particles with state=0 are inactive and should not be processed at all, but need to keep track of them
-        // The internal processing in BDSIM does not feature an active state check, so this must be done at a higher
-        // level here
-
-        if (state_part == 1) // State == 1 means that the particle is active
-        {
-            particleActiveState.push_back(true);
-            addParticle(x_part, y_part, px_part, py_part, zeta_part, delta_part, s_part, trackid_part);
-            maxParticleID = std::max(maxParticleID, trackid_part);
-            bds->SetCurrentMaximumExternalParticleID(maxParticleID);
-        }
-        else
-        {
-            if (state_part == -999999999) // This is reserve memory for new particles, no need to process
-            {
-                break;
-            }
-            particleActiveState.push_back(false);
-        }
-
-        auto particle_coords = new XtrackCoordinates{x_part, y_part, px_part, py_part, zeta_part,
-                                                     delta_part, s_part, trackid_part, state_part,
-                                                     at_element_part, at_turn_part};
-        xtrackParticles.push_back(particle_coords);
-    }
-}
-
-
-void XtrackInterface::collimate()
-{
-    bds->BeamOn((G4int)stp->Size());
-}
-
-
-void XtrackInterface::selectCollimator(const std::string& collimatorName)
-{
-    currentCollimatorName = collimatorName;
-    // This doesn't throw an error if the element doesn't exist
-    bds->SelectLinkElement(collimatorName);
-
-    // Check if the element exists by querying the index: -1 means it doesn't exist
-    if (bds->GetLinkIndex(collimatorName) == -1)
-        {throw std::runtime_error("Element not found " + collimatorName);}
-}
-
-
-void XtrackInterface::clearData()
-{
-    bds->ClearSamplerHits();
-    // A malloc error about freeing a pointer not allocated is thrown if the run is terminated after
-    // the bunch is manually cleared. Consider using an alternative to vector.clear() in the BDSIM bunch class:
-    // vector<T>().swap(x);   // clear x reallocating  (https://www.cplusplus.com/reference/vector/vector/clear/)
-    // to ensure the pointer is still allocated after clearing
-    stp->ClearParticles();
-
-    for (auto part : xtrackParticles)
-    {
-       delete part;
-    }
-
-    std::vector<XtrackCoordinates*>().swap(xtrackParticles);
-    std::vector<bool>().swap(particleActiveState);
-    currentCollimatorName.clear();
-
-    maxParticleID = 0;
-
-}
-
-
-py::dict XtrackInterface::collimateReturn(const py::list& coordinates)
-{
-    // Prepare the buffers for modifying the primary particle coordinates in place
-
-    // Obtain the arrays from the list and cast them to the correct array type
-    py::array_t<double> x = py::cast<py::array>(coordinates[0]);
-    py::array_t<double> y = py::cast<py::array>(coordinates[1]);
-    py::array_t<double> px = py::cast<py::array>(coordinates[2]);
-    py::array_t<double> py = py::cast<py::array>(coordinates[3]);
-    py::array_t<double> zeta = py::cast<py::array>(coordinates[4]);
-    py::array_t<double> delta = py::cast<py::array>(coordinates[5]);
-    py::array_t<double> s = py::cast<py::array>(coordinates[6]);
-    py::array_t<int64_t> trackid = py::cast<py::array>(coordinates[7]);
-    py::array_t<int64_t> state = py::cast<py::array>(coordinates[8]);
-    py::array_t<int64_t> at_element = py::cast<py::array>(coordinates[9]);
-    py::array_t<int64_t> at_turn = py::cast<py::array>(coordinates[10]);
-
-    // Obtain the buffers
-    py::buffer_info x_buff = x.request();
-    py::buffer_info y_buff = y.request();
-    py::buffer_info px_buff = px.request();
-    py::buffer_info py_buff = py.request();
-    py::buffer_info zeta_buff = zeta.request();
-    py::buffer_info delta_buff = delta.request();
-    py::buffer_info s_buff = s.request();
-    py::buffer_info id_buff = trackid.request();
-    py::buffer_info state_buff = state.request();
-    py::buffer_info at_element_buff = at_element.request();
-    py::buffer_info at_turn_buff = at_turn.request();
-
-    // Get the pointers for iteration
-    auto x_ptr = static_cast<double *>(x_buff.ptr);
-    auto y_ptr = static_cast<double *>(y_buff.ptr);
-    auto px_ptr = static_cast<double *>(px_buff.ptr);
-    auto py_ptr = static_cast<double *>(py_buff.ptr);
-    auto zeta_ptr = static_cast<double *>(zeta_buff.ptr);
-    auto delta_ptr = static_cast<double *>(delta_buff.ptr);
-    auto s_ptr = static_cast<double *>(s_buff.ptr);
-    auto trackid_ptr = static_cast<int64_t *>(id_buff.ptr);
-    auto state_ptr = static_cast<int64_t *>(state_buff.ptr);
-    auto at_element_ptr = static_cast<int64_t *>(at_element_buff.ptr);
-    auto at_turn_ptr = static_cast<int64_t *>(at_turn_buff.ptr);
-
-    // N.B book keeping needed
-    // Note: Load and and transfer for surviving primaries
-    // Secondaries inherit the element and turn of parent particle
-    //auto at_element = static_cast<int64_t *>(at_element.ptr);
-    //auto turn = static_cast<int64_t *>(turn.ptr);
-
-
-    // Prepare the buffers for writing out the products
-    // New numpy arrays are allocated for writing the products
-
-    // Access the sampler hits - particles reaching the planes for transport back
-    const BDSHitsCollectionSamplerLink* hits = bds->SamplerHits();
-
-    //size_t hitsCount = hits ? hits->GetSize() : 0;
-
-    size_t hitsCount = 0;
-    if (hits)
-    {
-        hitsCount = hits->GetSize();
-    }
-    else
-    {
-        // There were no hits - check if there were any active particles at all coming in
-        if (!stp->Size())
-        {
-            // A particle needs to be added to the bunch and the GetNextParticleLocal method
-            // must be called to initialise the variables and ensure a safe deletion of the
-            // underlying BDSBunch object. This will not be needed in the next release of BDSIM
-            addParticle(0, 0, 0, 0, 0, 0, 0, 0);
-            // The dummy particle added is never used, as the collimateReturn method terminates
-            // the processing
-            stp->GetNextParticleLocal();
-        }
-    }
-
-
-    // Count the number of secondary particles
-    size_t secondaryCount = 0;
-    for (size_t i = 0; i < hitsCount; i++)
-    {
-        auto hit = (*hits)[i];
-        if (hit->externalParticleID != hit->externalParentID) { secondaryCount++; }
-    }
-
-    // The output arrays has slots for all primary particles, regardless if lost or not, and for secondary particles
-    size_t output_size = secondaryCount;
-
-    // TODO: this is mostly default buffers, so there are probably simpler constructors to use
-    // Prepare the numpy array that will be returned
-    auto x_out = py::array(py::buffer_info(
-            nullptr,            /* Pointer to data (nullptr -> ask NumPy to allocate!) */
-            sizeof(double),     /* Size of one item */
-            py::format_descriptor<double>::value, /* Buffer format */
-            1,          /* How many dimensions? */
-            { output_size },  /* Number of elements for each dimension */
-            { sizeof(double) }  /* Strides for each dimension */
-    ));
-
-    auto y_out = py::array(py::buffer_info(
-            nullptr,
-            sizeof(double),
-            py::format_descriptor<double>::value,
-            1,
-            { output_size },
-            { sizeof(double) }
-    ));
-
-    auto px_out = py::array(py::buffer_info(
-            nullptr,
-            sizeof(double),
-            py::format_descriptor<double>::value,
-            1,
-            { output_size },
-            { sizeof(double) }
-    ));
-
-    auto py_out = py::array(py::buffer_info(
-            nullptr,
-            sizeof(double),
-            py::format_descriptor<double>::value,
-            1,
-            { output_size },
-            { sizeof(double) }
-    ));
-
-    auto zeta_out = py::array(py::buffer_info(
-            nullptr,
-            sizeof(double),
-            py::format_descriptor<double>::value,
-            1,
-            { output_size },
-            { sizeof(double) }
-    ));
-
-    auto delta_out = py::array(py::buffer_info(
-            nullptr,
-            sizeof(double),
-            py::format_descriptor<double>::value,
-            1,
-            { output_size },
-            { sizeof(double) }
-    ));
-
-    auto s_out = py::array(py::buffer_info(
-            nullptr,
-            sizeof(double),
-            py::format_descriptor<double>::value,
-            1,
-            { output_size },
-            { sizeof(double) }
-    ));
-
-    auto trackid_out = py::array(py::buffer_info(
-            nullptr,
-            sizeof(int64_t),
-            py::format_descriptor<int64_t>::value,
-            1,
-            { output_size },
-            { sizeof(int64_t) }
-    ));
-
-    auto state_out = py::array(py::buffer_info(
-            nullptr,
-            sizeof(int64_t),
-            py::format_descriptor<int64_t>::value,
-            1,
-            { output_size },
-            { sizeof(int64_t) }
-    ));
-
-    auto at_element_out = py::array(py::buffer_info(
-            nullptr,
-            sizeof(int64_t),
-            py::format_descriptor<int64_t>::value,
-            1,
-            { output_size },
-            { sizeof(int64_t) }
-    ));
-
-    auto at_turn_out = py::array(py::buffer_info(
-            nullptr,
-            sizeof(int64_t),
-            py::format_descriptor<int64_t>::value,
-            1,
-            { output_size },
-            { sizeof(int64_t) }
-    ));
-
-    auto massratio_out = py::array(py::buffer_info(
-            nullptr,
-            sizeof(double),
-            py::format_descriptor<double>::value,
-            1,
-            { output_size },
-            { sizeof(double) }
-    ));
-
-    auto chargeratio_out = py::array(py::buffer_info(
-            nullptr,
-            sizeof(double),
-            py::format_descriptor<double>::value,
-            1,
-            { output_size },
-            { sizeof(double) }
-    ));
-
-    auto x_prod_buf = x_out.request();
-    auto y_prod_buf = y_out.request();
-    auto px_prod_buf = px_out.request();
-    auto py_prod_buf = py_out.request();
-    auto zeta_prod_buf = zeta_out.request();
-    auto delta_prod_buf = delta_out.request();
-    auto s_prod_buf = s_out.request();
-    auto trackid_prod_buf = trackid_out.request();
-    auto state_prod_buf = state_out.request();
-    auto at_element_prod_buf = at_element_out.request();
-    auto at_turn_prod_buf = at_turn_out.request();
-    auto massratio_prod_buf = massratio_out.request();
-    auto chargeratio_prod_buf = chargeratio_out.request();
-
-    auto *x_prod_ptr = (double *) x_prod_buf.ptr;
-    auto *y_prod_ptr = (double *) y_prod_buf.ptr;
-    auto *px_prod_ptr = (double *) px_prod_buf.ptr;
-    auto *py_prod_ptr = (double *) py_prod_buf.ptr;
-    auto *zeta_prod_ptr = (double *) zeta_prod_buf.ptr;
-    auto *delta_prod_ptr = (double *) delta_prod_buf.ptr;
-    auto *s_prod_ptr = (double *) s_prod_buf.ptr;
-    auto *trackid_prod_ptr = (int64_t *) trackid_prod_buf.ptr;
-    auto *state_prod_ptr = (int64_t *) state_prod_buf.ptr;
-    auto *at_element_prod_ptr = (int64_t *) at_element_prod_buf.ptr;
-    auto *at_turn_prod_ptr = (int64_t *) at_turn_prod_buf.ptr;
-    auto *massratio_prod_ptr = (double *) massratio_prod_buf.ptr;
-    auto *chargeratio_prod_ptr = (double *) chargeratio_prod_buf.ptr;
-
-    // Loop through the particles in the *original* bunch - the primaries
-    size_t hits_index = 0;
-    bool prim_survied = false;
-    double sum_deltaplusone_sec = 0.0;
-
-    size_t prod_write_index = 0;
-
-    for (size_t i=0; i < particleActiveState.size(); i++){
-        if (!particleActiveState.at(i)){
-            continue; // This was an inactive particle that hasn't been processed, do not change it
-        }
-
-        auto xtrack_part = xtrackParticles.at(i); // Get the cached coordinates of the original xtrack particle
-
-        auto part = stp->GetNextParticle(); // Advance through the bunch
-        auto prim_part_id = stp->CurrentExternalParticleID(); // Get the ID of the primary particle
-
-        // Now start looping over the hits - the particles to be returned to the tracker
-        // These can be primary or secondary particles. Each primary can produce 0, 1, or 2+ products
-        // The products need to be sorted to keep the array order - surviving primary particles are all
-        // filled in first. If a primary didn't survive, keep the original coordinates and make it inactive.
-        // The hits are ordered by primary event, so just need one loop.
-        while (hits_index < hitsCount)
-        {
-            BDSHitSamplerLink* hit = (*hits)[hits_index];
-
-            if (hit->externalParentID != prim_part_id) { // The hits corresponding to the current primary are exhausted
-                break;
-            }
-
-            const BDSParticleCoordsFull &coords = hit->coords;
-
-            double qratio = hit->charge / refParticleDefinition->Charge();
-            double mratio = hit->mass / refParticleDefinition->Mass();
-
-            double dp = (hit->momentum - refParticleDefinition->Momentum()) / refParticleDefinition->Momentum();
-
-            double collLength = bds->GetArcLengthOfLinkElement(currentCollimatorName);
-            /// Need to compensate for the geometry construction in BDSIM
-            /// There is a safety margin that is added to the collimator legnth
-            double collMargin = 2.5 * BDSSamplerCustom::ChordLength();
-
-            //double zt = (collLength + collMargin) / beta0 - CLHEP::c_light * coords.T;
-            double zt = refParticleDefinition->Beta() * CLHEP::c_light * ((collLength + collMargin) / (CLHEP::c_light * refParticleDefinition->Beta()) - coords.T);
-
-            double oneplusdelta = 1 + dp;
-
-            // double pz = (1 + dp) / std::sqrt(1 + std::pow(coords.xp, 2) + std::pow(coords.yp, 2));
-            //double ps = (E - E0) / (beta0 * P0);
-            //double sigma = coords.s - beta0* coords.T / CLHEP::s; // check this
-
-            auto track_id = hit->externalParticleID;
-            auto parent_id = hit->externalParentID;
-
-            if (track_id == parent_id){
-                // This is a primary particle as its parent is itself
-                prim_survied = true;
-
-                x_ptr[i] = coords.x / CLHEP::m;
-                y_ptr[i] = coords.y / CLHEP::m;
-                px_ptr[i] = coords.xp * oneplusdelta; // convert back to px proper
-                py_ptr[i] = coords.yp * oneplusdelta;
-                zeta_ptr[i] = zt / CLHEP::m;
-                delta_ptr[i] = dp;
-                s_ptr[i] = xtrack_part->s + collLength / CLHEP::m;
-                //trackid_ptr[i] = track_id; // Don't touch the primary particle id
-                state_ptr[i] = 1; // active
-            }
-            else
-            {
-                // Secondary particles are populated in newly allocated arrays
-                x_prod_ptr[prod_write_index] = coords.x / CLHEP::m;
-                y_prod_ptr[prod_write_index] = coords.y / CLHEP::m;
-                px_prod_ptr[prod_write_index] = coords.xp * oneplusdelta; // convert back to px proper
-                py_prod_ptr[prod_write_index] = coords.yp * oneplusdelta; // convert back to py proper;
-                zeta_prod_ptr[prod_write_index] = zt / CLHEP::m;
-                delta_prod_ptr[prod_write_index] = dp;
-                s_prod_ptr[prod_write_index] = xtrack_part->s + collLength / CLHEP::m;
-                trackid_prod_ptr[prod_write_index] = parent_id;
-                state_prod_ptr[prod_write_index] = 1; // active
-                at_element_prod_ptr[prod_write_index] = xtrack_part->at_element; // active
-                at_turn_prod_ptr[prod_write_index] = xtrack_part->at_turn; // active
-                massratio_prod_ptr[prod_write_index] = mratio;
-                chargeratio_prod_ptr[prod_write_index] = qratio;
-
-                sum_deltaplusone_sec += (dp + 1);
-                prod_write_index++;
-            }
-
-            hits_index++;
-        }
-
-        if (!prim_survied) // Primary didn't survive - set inactive
-        {
-            state_ptr[i] = -333; // inactive
-            // Correct the energy of the lost primary particle to account for the production of secondaries
-            delta_ptr[i] = delta_ptr[i] - sum_deltaplusone_sec;
-        }
-        prim_survied = false; // reset for next particle
-        sum_deltaplusone_sec = 0.0;
-    }
-
-    auto result = py::dict();
-
-    result["s"] = s_out;
-    result["x"] = x_out;
-    result["px"] = px_out;
-    result["y"] = y_out;
-    result["py"] = py_out;
-    result["zeta"] = zeta_out;
-    result["delta"] = delta_out;
-    result["at_element"] = at_element_out;
-    result["at_turn"] = at_turn_out;
-    result["mass_ratio"] = massratio_out;
-    result["charge_ratio"] = chargeratio_out;
-    result["parent_particle_id"] = trackid_out;
-
-    return result;
-}