packages/engine/scram-node/src/expression/exponential.h

Expressions and distributions that are described with exponential formulas.

Namespaces

Name
scram
scram::mef

Classes

	Name
class	scram::mef::Exponential <br>Negative exponential distribution with hourly failure rate and time.
class	scram::mef::Glm <br>Exponential with probability of failure on demand, hourly failure rate, hourly repairing rate, and time.
class	scram::mef::Weibull <br>Weibull distribution with scale, shape, time shift, and time.
class	scram::mef::PeriodicTest <br>Periodic test with 3 phases: deploy, test, functioning.

Source code

/*
 * Copyright (C) 2014-2018 Olzhas Rakhimov
 * Copyright (C) 2023 OpenPRA ORG Inc.
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */


#pragma once

#include <memory>

#include "src/expression.h"

namespace scram::mef {

class Exponential : public ExpressionFormula<Exponential> {
 public:
  Exponential(Expression* lambda, Expression* t);

  void Validate() const override;
  Interval interval() noexcept override { return Interval::closed(0, 1); }

  template <typename T>
  double Compute(T&& eval) noexcept {
    return Compute(eval(&lambda_), eval(&time_));
  }
  double Compute(double lambda, double time) noexcept;

 private:
  Expression& lambda_;  
  Expression& time_;  
};

class Glm : public ExpressionFormula<Glm> {
 public:
  Glm(Expression* gamma, Expression* lambda, Expression* mu, Expression* t);

  void Validate() const override;
  Interval interval() noexcept override { return Interval::closed(0, 1); }

  template <typename T>
  double Compute(T&& eval) noexcept {
    return Compute(eval(&gamma_), eval(&lambda_), eval(&mu_), eval(&time_));
  }
  double Compute(double gamma, double lambda, double mu, double time) noexcept;

 private:
  Expression& gamma_;  
  Expression& lambda_;  
  Expression& mu_;  
  Expression& time_;  
};

class Weibull : public ExpressionFormula<Weibull> {
 public:
  Weibull(Expression* alpha, Expression* beta, Expression* t0,
          Expression* time);

  void Validate() const override;
  Interval interval() noexcept override { return Interval::closed(0, 1); }

  template <typename T>
  double Compute(T&& eval) noexcept {
    return Compute(eval(&alpha_), eval(&beta_), eval(&t0_), eval(&time_));
  }
  double Compute(double alpha, double beta, double t0, double time) noexcept;

 private:
  Expression& alpha_;  
  Expression& beta_;  
  Expression& t0_;  
  Expression& time_;  
};

class PeriodicTest : public Expression {
 public:
  PeriodicTest(Expression* lambda, Expression* tau, Expression* theta,
               Expression* time);

  PeriodicTest(Expression* lambda, Expression* mu, Expression* tau,
               Expression* theta, Expression* time);

  PeriodicTest(Expression* lambda, Expression* lambda_test, Expression* mu,
               Expression* tau, Expression* theta, Expression* gamma,
               Expression* test_duration, Expression* available_at_test,
               Expression* sigma, Expression* omega, Expression* time);

  void Validate() const override { flavor_->Validate(); }
  double value() noexcept override { return flavor_->value(); }
  Interval interval() noexcept override { return Interval::closed(0, 1); }

 private:
  double DoSample() noexcept override { return flavor_->Sample(); }

  struct Flavor {
    virtual ~Flavor() = default;
    virtual void Validate() const = 0;
    virtual double value() noexcept = 0;
    virtual double Sample() noexcept = 0;
  };

  class InstantRepair : public Flavor {
   public:
    InstantRepair(Expression* lambda, Expression* tau, Expression* theta,
                  Expression* time)
        : lambda_(*lambda), tau_(*tau), theta_(*theta), time_(*time) {}

    void Validate() const override;
    double value() noexcept override;
    double Sample() noexcept override;

   protected:
    Expression& lambda_;  
    Expression& tau_;  
    Expression& theta_;  
    Expression& time_;  

   private:
    double Compute(double lambda, double tau, double theta,
                   double time) noexcept;
  };

  class InstantTest : public InstantRepair {
   public:
    InstantTest(Expression* lambda, Expression* mu, Expression* tau,
                Expression* theta, Expression* time)
        : InstantRepair(lambda, tau, theta, time), mu_(*mu) {}

    void Validate() const override;
    double value() noexcept override;
    double Sample() noexcept override;

   protected:
    Expression& mu_;  

   private:
    double Compute(double lambda, double mu, double tau, double theta,
                   double time) noexcept;
  };

  class Complete : public InstantTest {
   public:
    Complete(Expression* lambda, Expression* lambda_test, Expression* mu,
             Expression* tau, Expression* theta, Expression* gamma,
             Expression* test_duration, Expression* available_at_test,
             Expression* sigma, Expression* omega, Expression* time)
        : InstantTest(lambda, mu, tau, theta, time),
          lambda_test_(*lambda_test),
          gamma_(*gamma),
          test_duration_(*test_duration),
          available_at_test_(*available_at_test),
          sigma_(*sigma),
          omega_(*omega) {}

    void Validate() const override;
    double value() noexcept override;
    double Sample() noexcept override;

   private:
    double Compute(double lambda, double lambda_test, double mu, double tau,
                   double theta, double gamma, double test_duration,
                   bool available_at_test, double sigma, double omega,
                   double time) noexcept;

    Expression& lambda_test_;  
    Expression& gamma_;  
    Expression& test_duration_;  
    Expression& available_at_test_;  
    Expression& sigma_;  
    Expression& omega_;  
  };

  std::unique_ptr<Flavor> flavor_;  
};

}  // namespace scram::mef

---

Updated on 2025-11-11 at 16:51:08 +0000