src/physics/Detrapping.hpp

Definition of charge carrier detrapping models. More…

Namespaces

Name
allpix Helper class to hold support layers for a detector model.

Classes

	Name
class	allpix::DetrappingModel Charge carrier detrapping time models.
class	allpix::NoDetrapping No detrapping.
class	allpix::ConstantDetrapping Constant detrapping rate of charge carriers.
class	allpix::Detrapping Wrapper class and factory for detrapping models.

Detailed Description

Definition of charge carrier detrapping models.

Copyright: Copyright (c) 2022-2024 CERN and the Allpix Squared authors. This software is distributed under the terms of the MIT License, copied verbatim in the file “LICENSE.md”. In applying this license, CERN does not waive the privileges and immunities granted to it by virtue of its status as an Intergovernmental Organization or submit itself to any jurisdiction. SPDX-License-Identifier: MIT

Source code


#ifndef ALLPIX_DETRAPPING_MODELS_H
#define ALLPIX_DETRAPPING_MODELS_H

#include <TFormula.h>

#include "exceptions.h"

#include "core/config/Configuration.hpp"
#include "core/utils/log.h"
#include "core/utils/unit.h"
#include "objects/SensorCharge.hpp"

namespace allpix {

    class DetrappingModel {
    public:
        DetrappingModel() = default;

        virtual ~DetrappingModel() = default;

        virtual double operator()(const CarrierType& type, double probability, double efield_mag) const = 0;
    };

    class NoDetrapping : virtual public DetrappingModel {
    public:
        double operator()(const CarrierType&, double, double) const override { return std::numeric_limits<double>::max(); };
    };

    class ConstantDetrapping : virtual public DetrappingModel {
    public:
        ConstantDetrapping(double electron_lifetime, double hole_lifetime)
            : tau_eff_electron_(electron_lifetime), tau_eff_hole_(hole_lifetime){};

        double operator()(const CarrierType& type, double probability, double) const override {
            return -1 * log(1 - probability) * (type == CarrierType::ELECTRON ? tau_eff_electron_ : tau_eff_hole_);
        }

    protected:
        double tau_eff_electron_{std::numeric_limits<double>::max()};
        double tau_eff_hole_{std::numeric_limits<double>::max()};
    };

    class Detrapping {
    public:
        Detrapping() = default;

        explicit Detrapping(const Configuration& config) {
            try {
                auto model = config.get<std::string>("detrapping_model", "none");

                if(model == "constant") {
                    model_ = std::make_unique<ConstantDetrapping>(config.get<double>("detrapping_time_electron"),
                                                                  config.get<double>("detrapping_time_hole"));
                } else if(model == "none") {
                    LOG(INFO) << "No charge carrier detrapping model chosen, no detrapping simulated";
                    model_ = std::make_unique<NoDetrapping>();
                } else {
                    throw InvalidModelError(model);
                }
            } catch(const ModelError& e) {
                throw InvalidValueError(config, "detrapping_model", e.what());
            }
        }

        template <class... ARGS> double operator()(ARGS&&... args) const {
            return model_->operator()(std::forward<ARGS>(args)...);
        }

    private:
        std::unique_ptr<DetrappingModel> model_{};
    };

} // namespace allpix

#endif

Updated on 2025-02-27 at 14:14:46 +0000