Source code for fiabilipy.component

#!/usr/bin/env python2
# -*- coding: utf-8 -*-

#Copyright (C) 2013 Chabot Simon, Sadaoui Akim

#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 2 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, write to the Free Software Foundation, Inc.,
#51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.

r""" Component design module

This modude gives tools to design basic components and compute some metrics,
such as the reliability, the availability, the Mean-Time-To-Failure, and so on.

"""

from sympy import exp, Symbol, oo

__all__ = ['Component']

[docs]class Component(object): r""" Describe a component with a constant failure rate. This class is used to create all the components of a system. Attributes ---------- name : str the name of the component. (It has to be a unique name for the whole system) lambda_ : float the constant failure rate of the component mu : float, optional the constant maintainability rate of the component initialy_avaible : boolean, optional whether the component is avaible at t=0 or not Examples -------- >>> motor = Component('M', 1e-4, 3e-2) >>> motor.lambda_ 0.0001 """ def __init__(self, name, lambda_, mu=0, initialy_avaible=True): self.__dict__["_systems"] = set() self.lambda_ = lambda_ self.mu = mu self.name = name self.initialy_avaible = initialy_avaible def __setattr__(self, name, value): for system in self._systems: system._cache = {} self.__dict__[name] = value def __repr__(self): return u'Component(%s)' % self.name
[docs] def reliability(self, t): r""" Compute the reliability of the component at `t` This method compute the reliability of the component at `t`. Parameters ---------- t : float or Symbol Returns ------- out : float or symbolic expression The reliability calculated for the given `t` Examples -------- >>> motor = Component('M', 1e-4, 3e-2) >>> t = Symbol('t', positive=True) >>> motor.reliability(t) exp(-0.0001*t) >>> motor.reliability(1000) 0.904837418035960 """ return exp(-self.lambda_ * t)
[docs] def maintainability(self, t): r""" Compute the maintainability of the component at `t` This method compute the maintainability of the component at `t`. Parameters ---------- t : int or Symbol Returns ------- out : float or symbolic expression The maintainability calculated for the given `t` Examples -------- >>> motor = Component('M', 1e-4, 3e-2) >>> t = Symbol('t', positive=True) >>> motor.maintainability(t) -exp(-0.03*t) + 1.0 >>> motor.maintainability(1000) 0.999999999999906 """ return 1.0 - exp(-self.mu * t)
[docs] def availability(self, t): r""" Compute the availability of the component at `t` This method compute the availability of the component at `t`. Parameters ---------- t : int or Symbol Returns ------- out : float or symbolic expression The availability calculated for the given `t` Examples -------- >>> motor = Component('M', 1e-4, 3e-2) >>> t = Symbol('t', positive=True) >>> motor.availability(t) 0.00332225913621263*exp(-0.0301*t) + 0.996677740863787 >>> motor.availability(1000) 0.996677740863788 """ if self.mu == self.lambda_ == 0: return 1 a = self.mu / (self.mu + self.lambda_) if self.initialy_avaible: b = self.lambda_ / (self.mu + self.lambda_) else: b = - self.mu / (self.mu + self.lambda_) return a + b*exp(-(self.lambda_ + self.mu) * t)
@property def mttf(self): r""" Compute the Mean-Time-To-Failure of the component The MTTF is defined as : :math:`MTTF = \int_{0}^{\infty} R(t)dt = \frac{1}{\lambda}` when the failure rate (:math:`\lambda` is constant) Returns ------- out : float The component MTTF Examples -------- >>> motor = Component('M', 1e-4, 3e-2) >>> motor.mttf 10000.0 """ return 1.0/self.lambda_ @property def mttr(self): r""" Compute the Mean-Time-To-Repair of the component The MTTR is defined as : :math:`MTTR = \int_{0}^{\infty} 1 - M(t)dt = \frac{1}{\mu}` when the failure rate (:math:`\mu` is constant) Returns ------- out : float The component MTTR Examples -------- >>> motor = Component('M', 1e-4, 3e-2) >>> motor.mttr 33.333333333333336 """ return 1.0/self.mu