Merge branch 'dynamicChargePerStep' into 'master'

    config_.setDefault<double>("timestep_max", Units::get(0.5, "ns"));

    config_.setDefault<double>("integration_time", Units::get(25, "ns"));

    config_.setDefault<unsigned int>("charge_per_step", 10);

    config_.setDefault<unsigned int>("max_charge_groups", 1000);

    config_.setDefault<double>("temperature", 293.15);

    // Models:

    propagate_electrons_ = config_.get<bool>("propagate_electrons");

    propagate_holes_ = config_.get<bool>("propagate_holes");

    charge_per_step_ = config_.get<unsigned int>("charge_per_step");

    max_charge_groups_ = config_.get<unsigned int>("max_charge_groups");

    // Enable multithreading of this module if multithreading is enabled and no per-event output plots are requested:

    // FIXME: Review if this is really the case or we can still use multithreading

        group_size_histo_ = CreateHistogram<TH1D>("group_size_histo",

                                                  "Charge carrier group size;group size;number of groups transported",

                                                  static_cast<int>(charge_per_step_ - 1),

                                                  1,

                                                  static_cast<double>(charge_per_step_));

                                                  static_cast<int>(100 * charge_per_step_),

                                                  0,

                                                  static_cast<int>(100 * charge_per_step_));

        recombine_histo_ =

            CreateHistogram<TH1D>("recombination_histo",

            continue;

        }

        total_deposits_++;

        // Loop over all charges in the deposit

        unsigned int charges_remaining = deposit.getCharge();

                   << Units::display(deposit.getLocalPosition(), {"mm", "um"});

        auto charge_per_step = charge_per_step_;

        if(max_charge_groups_ > 0 && deposit.getCharge() / charge_per_step > max_charge_groups_) {

            charge_per_step = static_cast<unsigned int>(ceil(static_cast<double>(deposit.getCharge()) / max_charge_groups_));

            deposits_exceeding_max_groups_++;

            LOG(INFO) << "Deposited charge: " << deposit.getCharge()

                      << ", which exceeds the maximum number of charge groups allowed. Increasing charge_per_step to "

                      << charge_per_step << " for this deposit.";

        }

        while(charges_remaining > 0) {

            // Define number of charges to be propagated and remove charges of this step from the total

            if(charge_per_step > charges_remaining) {

void GenericPropagationModule::finalize() {

    if(output_plots_) {

        group_size_histo_->Get()->GetXaxis()->SetRange(1, group_size_histo_->Get()->GetNbinsX() + 1);

        step_length_histo_->Write();

        drift_time_histo_->Write();

        uncertainty_histo_->Write();

                               std::max(1u, static_cast<unsigned int>(total_propagated_charges_));

    LOG(INFO) << "Propagated total of " << total_propagated_charges_ << " charges in " << total_steps_

              << " steps in average time of " << Units::display(average_time, "ns");

    LOG(INFO) << deposits_exceeding_max_groups_ * 100.0 / total_deposits_ << "% of deposits have charge exceeding the "

              << max_charge_groups_ << " charge groups allowed, with a charge_per_step value of " << charge_per_step_ << ".";

}

            output_linegraphs_trapped_{}, output_animations_{};

        bool propagate_electrons_{}, propagate_holes_{};

        unsigned int charge_per_step_{};

        unsigned int max_charge_groups_{};

        // Models for electron and hole mobility and lifetime

        Mobility mobility_;

        std::atomic<unsigned int> total_propagated_charges_{};

        std::atomic<unsigned int> total_steps_{};

        std::atomic<long unsigned int> total_time_picoseconds_{};

        std::atomic<unsigned int> total_deposits_{}, deposits_exceeding_max_groups_{};

        Histogram<TH1D> step_length_histo_;

        Histogram<TH1D> drift_time_histo_;

        Histogram<TH1D> uncertainty_histo_;

---

## Description

Simulates the propagation of electrons and/or holes through the sensitive sensor volume of the detector. It allows to propagate sets of charge carriers together in order to speed up the simulation while maintaining the required accuracy. The propagation process for these sets is fully independent and no interaction is simulated. The maximum size of the set of propagated charges and thus the accuracy of the propagation can be controlled.

Simulates the propagation of electrons and/or holes through the sensitive sensor volume of the detector. It allows to propagate sets of charge carriers together in order to speed up the simulation while maintaining the required accuracy. The propagation process for these sets is fully independent and no interaction is simulated. The maximum size of the set of propagated charges and thus the accuracy of the propagation can be controlled via the `charge_per_step` parameter. The maximum number of charge groups to be propagated for a single deposit position can be controlled via the `max_charge_groups` parameter.

The propagation consists of a combination of drift and diffusion simulation. The drift is calculated using the charge carrier velocity derived from the charge carrier mobility and the magnetic field via a calculation of the Lorentz drift. The correct mobility for either electrons or holes is automatically chosen, based on the type of the charge carrier under consideration. Thus, also input with both electrons and holes is treated properly. The mobility model can be chosen using the `mobility_model` parameter, and a list of available models can be found in the user manual.

* `trapping_model`: Model for simulating charge carrier trapping from radiation-induced damage. Defaults to `none`, a list of available models can be found in the documentation. All models require explicitly setting a fluence parameter.

* `fluence`: 1MeV-neutron equivalent fluence the sensor has been exposed to.

* `charge_per_step` : Maximum number of charge carriers to propagate together. Divides the total number of deposited charge carriers at a specific point into sets of this number of charge carriers and a set with the remaining charge carriers. A value of 10 charges per step is used by default if this value is not specified.

* `max_charge_groups`: Maximum number of charge groups to propagate from a single deposit point. Temporarily increases the value of `charge_per_step` to reduce the number of propagated groups if the deposit is larger than the value `max_charge_groups`*`charge_per_step`, thus reducing the negative performance impact of unexpectedly large deposits. The default value is 1000 charge groups. If it is set to 0, there is no upper limit on the number of charge groups propagated.

* `spatial_precision` : Spatial precision to aim for. The timestep of the Runge-Kutta propagation is adjusted to reach this spatial precision after calculating the uncertainty from the fifth-order error method. Defaults to 0.25nm.

* `timestep_start` : Timestep to initialize the Runge-Kutta integration with. Appropriate initialization of this parameter reduces the time to optimize the timestep to the *spatial_precision* parameter. Default value is 0.01ns.

* `timestep_min` : Minimum step in time to use for the Runge-Kutta integration regardless of the spatial precision. Defaults to 1ps.

log_level = INFO

temperature = 293K

charge_per_step = 1

max_charge_groups = 0

propagate_electrons = false

propagate_holes = true

recombination_model = "srh_auger"

log_level = INFO

temperature = 293K

charge_per_step = 1

max_charge_groups = 0

propagate_electrons = false

propagate_holes = true

trapping_model = "custom"