最平凡日子 最卑微梦想

ADC效能分析模型

本文针对ADC模型,抛开推导过程,从算法实现角度进行阐述。

正文含少量MathJax公式,加载异常刷新即可。

前言

系统的效能是指某系统在规定的条件下达到规定使用目标的能力,是目标系统完成规定任务程度的度量,能从总体上描绘出一个对象在特定环境下完成规定任务的实际能力。

为更加清晰阐述算法实现,将以导弹武器系统为例进行描述。

可用性分析

表示可用性向量,表征系统在执行任务之前的状态。

假设系统有 $n$ 种不同的状态,且在任一时刻系统处于状态 $i$ 的概率为 $a_i$,则可用性向量 $A=(a_1, a_2, \cdots, a_n)$ 表示。

设 A、B、C 分别表示发射平台、飞航导弹和技术保障设备 3 个系统,这 3 个系统的平均故障间隔时间分别表示为 $T_1$、$T_2$、$T_3$,平均故障修复时间分别为 $M_1$、$M_2$、$M_3$。3 个组成部分在工作时有 8 种工作状态,从 $(ABC)$ 示三部分全部处于正常状态、$(AB\overline{C})$ 示发射平台和飞航导弹正常、技术保障设备故障,到 $(\overline{A}\overline{B}\overline{C})$ 表示三部分全部处于故障状态等八个。

可用度是该系统处于工作状态的概率,计算公式如下:

$$ \begin{cases} A_A=\frac{T_1}{T_1+M_1}\\ A_B=\frac{T_2}{T_2+M_2}\\ A_C=\frac{T_3}{T_3+M_3} \end{cases} $$

推算步骤省略,可计算得到系统可用性向量:

可信性分析

可信性是指系统在任务开始时可用性给定的情况下,规定的任务剖面中的任一随机时刻,能够使用且能完成规定任务的能力。

可信性在概念上与可靠性有相似之处。可信性参数矩阵:

$$D(t)=\begin{bmatrix}d_{11}&d_{12}&\cdots&d_{1n}\\d_{21}&d_{22}&\cdots&d_{2n}\\\cdots&\cdots&\cdots&\cdots\\d_{n1}&d_{n2}&\cdots&d_{nn}\end{bmatrix}$$

式中:$d_{ij}$表示若系统在开始执行任务时处于状态$i$,系统在执行任务过程中处于状态$j$的概率;$t$表示执行任务的时间。

系统运行过程中的可靠性函数为指数函数,并由下式给出:

因此,发射平台、飞航导弹和技术保障设备的可靠性如下:

$$ R_A=\exp\left(-\frac{t}{T_1}\right) $$

$$ R_B=\exp\left(-\frac{t}{T_2}\right) $$

$$ R_C=\exp\left(-\frac{t}{T_3}\right) $$

基本的转移概率为:

$$ \begin{aligned} &P(A\to A)=R_{A},\quad P(B\to B)=R_{B}, \\ &P(C\to C)=R_{C},\quad P(A\to\overline{A})=1-R_{A}, \\ &P(B\to\overline{B})=1-R_{B},\quad P(C\to\overline{C})=1-R_{C}, \\ &P(\overline{A}\to A)=0,\quad P(\overline{B}\to B)=0,\quad P(\overline{C}\to C)=0, \\ &P(\overline{A}\to\overline{A})=1,\quad P(\overline{B}\to\overline{B})=1,\quad P(\overline{C}\to\overline{C})=1 \end{aligned} $$

定义$d_{ij}=P\left\{t\text{ 时间内状态}i\text{ 转移到状态 }j\right\}$

可得到系统的可信性参数矩阵:

能⼒分析

能⼒矩阵$C$是描述系统处于$n$个状态时,完成规定任务的固有能⼒。$C$是⼀个具有$n$个元素的列向量。

$$C=(c_1,c_2\cdots c_j\cdots c_n)^\mathrm{T}$$

$p_1$表⽰发射平台状态良好,能顺利完成发射任务的概率;$p_2$表⽰导弹发射后,飞⾏过程中各部件⼯作状态良好,能够完成制导、突防以及有效打击对⽅⽬标的概率;$p_3$表⽰技术保障设备状态良好,能够成功保障顺利发射的概率。

$p_1^{\prime}$表示发射平台发⽣故障,但能顺利完成发射任务的概率;$p_2^{\prime}$表示导弹发射后,⻜⾏过程中某部件发⽣故障,但能够完成制导、突防以及有效打击对⽅⽬标的概率;$p_3^{\prime}$表示技术保障设备发⽣故障,能够保障顺利发射的概率。

故能力参数如下:

$$ \begin{aligned} &c_1=p_1p_2p_3, \\ &c_2=p_1p_2p_3^{\prime}, \\ &c_3=p_1p_2^{\prime}p_3, \\ &c_4=p_1p_2^{\prime}p_3^{\prime}, \\ &c_5=p_1^{\prime}p_2p_3, \\ &c_{6}=p_1^{\prime}p_2p_3^{\prime}, \\ &c_{7}=p_1^{\prime}p_2^{\prime}p_3, \\ &c_{8}=p_1^{\prime}p_2^{\prime}p_3^{\prime} \end{aligned} $$

能⼒参数矩阵应表⽰为:

$$ C=\begin{bmatrix}c_1\\c_2\\c_3\\c_4\\c_5\\c_6\\c_7\\c_8\end{bmatrix}=\begin{bmatrix}p_1p_2p_3\\p_1p_2p_3^{\prime}\\p_1p_2^{\prime}p_3\\p_1p_2^{\prime}p_3^{\prime}\\p_1^{\prime}p_2p_3\\p_1^{\prime}p_2p_3^{\prime}\\p_1^{\prime}p_2^{\prime}p_3\\p_1^{\prime}p_2^{\prime}p_3^{\prime}\end{bmatrix} $$

效能模型

令 $F=D\cdot C$、$F_i = \sum_{j=1}^{8} D_{ij} \cdot C_j$

$$ E = A\cdot D\cdot C= \sum_{k=1}^{8} A_k \cdot F_k $$

实现Demo

#include <iostream>
#include <vector>
#include <cmath>

class SystemAvailability {
public:
    // Constructors to initialize the time and maintenance arrays
    SystemAvailability(double t1, double m1, double t2, double m2, double t3, double m3) 
        : T1(t1), M1(m1), T2(t2), M2(m2), T3(t3), M3(m3) {}

    // Method to compute the availability vector
    std::vector<double> computeAvailability() {
        double A1 = T1 / (T1 + M1);
        double A2 = T2 / (T2 + M2);
        double A3 = T3 / (T3 + M3);

        return {
            A1 * A2 * A3,
            A1 * A2 * (1 - A3),
            A1 * (1 - A2) * A3,
            A1 * (1 - A2) * (1 - A3),
            (1 - A1) * A2 * A3,
            (1 - A1) * A2 * (1 - A3),
            (1 - A1) * (1 - A2) * A3,
            (1 - A1) * (1 - A2) * (1 - A3)
        };
    }

private:
    double T1, M1, T2, M2, T3, M3;
};

class SystemReliability {
public:
    SystemReliability(double t, double t1, double t2, double t3) 
        : time(t), T1(t1), T2(t2), T3(t3) {}

    std::vector<std::vector<double>> computeReliabilityMatrix() {
        double RA = std::exp(-time / T1);
        double RB = std::exp(-time / T2);
        double RC = std::exp(-time / T3);

        return {
            {RA*RB*RC, RA*RB*(1-RC), RA*(1-RB)*RC, RA*(1-RB)*(1-RC), (1-RA)*RB*RC, (1-RA)*RB*(1-RC), (1-RA)*(1-RB)*RC, (1-RA)*(1-RB)*(1-RC)},
            {0, RA*RB, 0, RA*(1-RB), 0, (1-RA)*RB, 0, (1-RA)*(1-RB)},
            {0, 0, RA*RC, RA*(1-RC), 0, 0, (1-RA)*RC, (1-RA)*(1-RC)},
            {0, 0, 0, RA, 0, 0, 0, 1-RA},
            {0, 0, 0, 0, RB*RC, RB*(1-RC), (1-RB)*RC, (1-RB)*(1-RC)},
            {0, 0, 0, 0, 0, RB, 0, 1-RB},
            {0, 0, 0, 0, 0, 0, RC, 1-RC},
            {0, 0, 0, 0, 0, 0, 0, 1}
        };
    }

private:
    double time, T1, T2, T3;
};

class SystemCapability {
public:
    SystemCapability(double p1, double p2, double p3, double p1_prime, double p2_prime, double p3_prime) 
        : P1(p1), P2(p2), P3(p3), P1_prime(p1_prime), P2_prime(p2_prime), P3_prime(p3_prime) {}

    // Method to compute the capability vector
    std::vector<double> computeCapability() {
        return {
            P1 * P2 * P3,
            P1 * P2 * P3_prime,
            P1 * P2_prime * P3,
            P1 * P2_prime * P3_prime,
            P1_prime * P2 * P3,
            P1_prime * P2 * P3_prime,
            P1_prime * P2_prime * P3,
            P1_prime * P2_prime * P3_prime
        };
    }

private:
    double P1, P2, P3, P1_prime, P2_prime, P3_prime;
};

int main() {
    // Availability calculations
    SystemAvailability availability(100, 20, 150, 25, 200, 30);
    std::vector<double> availabilityVector = availability.computeAvailability();

    // Reliability calculations
    SystemReliability reliability(50, 100, 150, 200);
    auto reliabilityMatrix = reliability.computeReliabilityMatrix();

    // Capability calculations
    SystemCapability capability(0.9, 0.85, 0.95, 0.8, 0.8, 0.9);
    std::vector<double> capabilityVector = capability.computeCapability();

    // Placeholder for performance calculation based on A, D, C
    double performanceMetric = 0;
    for (size_t i = 0; i < 8; ++i) {
        double Fi = 0;
        for (size_t j = 0; j < 8; ++j) {
            Fi += reliabilityMatrix[i][j] * capabilityVector[j];
        }
        performanceMetric += availabilityVector[i] * Fi;
    }

    std::cout << "Performance Metric: " << performanceMetric << std::endl;

    return 0;
}

SystemAvailabilitySystemReliabilitySystemCapability,用于分别计算可用性、可信性和能力矩阵。

碎碎念

  1. 之前看过一个知乎帖子,说是代码里std::出现次数和代码水平成反比,我觉得他说的对,因为我能写就写,且代码能力低下。
  2. 前两天把很久前(大概在2016年)在南锣鼓巷的一个音像店里买的一张专辑拿了出来,珍藏了很久很有感情的一张专辑。
  3. 深夜适配美食,想下楼吃碗烤冷面。