Fault Coverage-Aware Metrics for Evaluating the Reliability Factor of Solar Tracking Systems

Es ist mir soeben gelungen, unser Forschungsarbeit zu den fehlerabdeckungsbewussten Metriken für die Bewertung des Zuverlässigkeitsfaktors von solaren Nachführsystemen (Fault Coverage-Aware Metrics for Evaluating the Reliability Factor of Solar Tracking Systems) zu präsentieren. Die Forschungsarbeit wurde heute im Energies Journal veröffentlicht, das einen Impact Factor von 2.702 hat und auch im Web of Science aka ISI indexiert ist.

Kurz gefasst:

1) Die drei von uns vorgeschlagenen Metriken berücksichtigen die Hardware-, Software-, und In-Circuit-Test-Fehler, die bei der Prüfung der elektronischen Ausrüstung, die der Konstruktion der Solar-Nachführsysteme zugrunde liegt, festgestellt wurden.

2) Beim Vergleich unserer Ideen mit bestehenden metrischen Modellen (Weibull-normalisierte Verteilung) haben wir festgestellt, dass die Standardmetriken derzeit nur das Problem des zeitlichen Versagens von Industriegeräten (Sensoren, Motoren, integrierte Schaltkreise usw.) angehen, ohne die Ursache der Fehler selbst zu untersuchen. Darüber hinaus basieren die Standardmetriken auf einer großen Anzahl von Parametern: Mean Time to Failure (MTF), Mean Time Between Failures (MTBF), Mean Down Time (MDT), die bei der Berechnung der Gefährdungsrate und der Zuverlässigkeit von automatisierten Systemen beteiligt sind.

3) Die drei von uns vorgeschlagenen Metriken verwenden nur zwei Hauptparameter: einen solaren Testfaktor (STF) und einen solaren Zuverlässigkeitsfaktor (SRF), deren mathematische Ausdrücke für die Hard-, Software-, und In-Circuit-Testszenarien unterschiedlich sind. Um ihre Wirksamkeit bei der Berechnung der Zuverlässigkeit von solaren Nachführsystemen zu beweisen, sammelten wir die experimentellen Daten, die im Artikeln Online Built-In Self-Test , White-Box und In-Circuit Testing Methoden erhalten wurden, um die Graphen der Funktionen zu generieren, die mit den STF- und SRF-Parametern verbunden sind.

4) Wir haben einen Software-Algorithmus in der Python-Programmierumgebung implementiert, der die Weibull- und unsere Metrik-Gleichungssätze nutzt, um die Anzahl der Berechnungsschritte und die Berechnungszeit zu bestimmen. Nachdem wir 8 Zyklen für jedes der Modelle ausgeführt hatten, stellten wir fest, dass die vorgeschlagenen fehlerabdeckungsfähigen Metriken die Berechnungszeit um 85,91% und die Anzahl der Berechnungsschritte um 74,81% signifikant reduzieren, was zeigt, dass unsere Metriken im Vergleich zum Standard-Weibull-Verteilungsmodell wesentlich effizienter sind.

5) Die drei von uns vorgeschlagenen Metriken fördern das Testen von solaren Nachführsystemen, indem sie die Art der aufgetretenen Fehler und die Schäden spezifizieren, die sie an den getesteten Geräten verursachen können. Perspektivisch gesehen wird dieser Artikel wahrscheinlich unseren Artikel bezüglich der Rekonfigurationstechniken und der eingebauten Faltungscodes unterstützen, wodurch der Umfang der Fehler vergrößert und damit die von unseren 3 Metriken gegebene Bewertung verbessert wird.

Zusammenfassung: In diesem Artikel wird ein mathematischer Ansatz zur Bestimmung der Zuverlässigkeit von Solarnachführsystemen vorgestellt, der auf drei fehlerabdeckungsfähigen Metriken basiert, die Systemfehlerdaten von Hard- und Software sowie In-Circuit-Testing-Techniken (ICT) verwenden, um einen Solar-Test-Faktor (STF) zu berechnen. Unter Verwendung der genannten Eulerschen Konstante wird der Solar Reliability Factor (SRF) berechnet, um die Robustheit und Verfügbarkeit moderner, leistungsfähiger Solar-Nachführsysteme zu definieren. Die in der Mathcad-Softwaresuite und der Python-Programmierumgebung durchgeführten Experimentalfälle zeigen, dass die fehlerabdeckungsbewusste Metrik die Test- und Zuverlässigkeitsfaktorkurve von Solarnachführsystemen stark verändert und eine deutliche Reduzierung der Berechnungsschritte und der Rechenzeit erreicht.

Sie können den Forschungsartikel hier lesen.

Hier habe ich alle Projektdateien bezüglich unserer Forschungsartikel „Fault Coverage-Aware Metrics for Evaluating the Reliability Factor of Solar Tracking Systems“ veröffentlicht.

fault coverage-aware metrics_implementation.py

# Python Code created by Sorin Liviu Jurj for the research paper called „Fault Coverage-Aware Metrics for Evaluating the Reliability Factor of Solar Tracking Systems“.
#More information about the research paper can be found here: https://www.jurj.de/fault-coverage-aware-metrics-for-evaluating-the-reliability-factor-of-solar-tracking-systems/

„““We implemented a software algorithm in the Python programming environment which makes use of the Weibull and our metrics equation sets in order to determine the number of calculation steps and computation time. After running 8 cycles for each of the models, we established that the proposed fault coverage-aware metrics significantly reduce the computation time by 85,91% and the number of calculation steps by 74,81%, showing that our metrics are considerably more efficient when compared to the standard Weibull distribution model“““

import numpy as np
from time import time

# Section 1
Ts = np.array([
125,
170.83,
220.83,
283.3,
291.6,
341.6,
375,
512.5,
541.6,
583.3,
625,
666.6,
687.5,
741.6,
795.83
])

Td = np.array([
2,
4,
3,
2,
7,
4,
1,
6,
3,
2,
4,
3,
8,
6,
5,
5,
1,
5,
1,
5,
1,
1,
2,
1,
5,
1,
1,
4,
3,
2,
3,
2,
6,
7,
2,
1,
2,
1,
4,
3
])

N = 30
T = 90
eta = 625
beta = 1.5
t = 416.6
t0 = 0

def mean(L):
n = len(L)
ret = 0
steps = 1
for x in L:
ret += x/n
steps += 2
return ret, steps

def lmbda(Ts):
mTs, steps = mean(Ts)
return 1./mTs, steps+1

def MTF(Ts):
return mean(Ts)

def MDT(Td):
return mean(Td)

def OTtS(N, T, Td):
MDTd, steps = MDT(Td)
return (N*T – (len(Td)*MDTd)), steps + 4

def MTBF(N, T, Td):
otts, steps = OTtS(N, T, Td)
return otts/len(Td), steps + 2

def HazardRate(N, T, Td):
mtbf, steps = MTBF(N, T, Td)
return 1/mtbf, steps + 1

def Availability(N, T, Td):
mdt, steps = MDT(Td)
return ((N*T – len(Td)*mdt)/N*T), steps+6

# def Availability2(N, T, Td):
# interm = MTBF(N, T, Td)
# return interm/(interm+ MDT(N, T, Td))

def Unavailability(N, T, Td):
av, steps = Availability(N, T, Td)
return 1 – Availability(N, T, Td), steps+1

def LambdaWeibull(t, t0, eta, beta):
return (beta/eta)*((t-t0)/eta)**(beta-1), 6

def Reliability(t, t0, eta, beta):
return np.exp(-((t-t0)/eta)**beta), 5

def WeibullCycle(N, T, Ts, Td, t, t0, eta, beta):
startTime = time()
totalSteps = 0
mtbf, s = MTBF(N, T, Td)
totalSteps += s

hazard, s = HazardRate(N, T, Td)
totalSteps += s

A, s = Availability(N, T, Td)
totalSteps += s

U = 1 – A
totalSteps += 1

lambdaWeibull, s = LambdaWeibull(t, t0, eta, beta)
totalSteps += s

R, s = Reliability(t, t0, eta, beta)
totalSteps += s
return totalSteps, time()-startTime

print(„Weibull Execution Cycles: „)
for _ in range(8):
print(WeibullCycle(N, T, Ts, Td, t, t0, eta, beta))

# Section 2
controlFlowErrors=[
395,
175,
118,
78
]

CommunicationErrors = [
2,
1,
1,
0,]

CalculationErrors = [
568,
242,
166,
2
]
ErrorHandlingFaults = [
736,
299,
214,
42
]

totalTests = [
2277,
1087,
840,
130,
]

errorCov = [74.70,
65.96,
59.40,
93.84,]

B = 10

Tp = 4334

def WE(i):
a = controlFlowErrors[i] + CommunicationErrors[i] + CalculationErrors[i] +ErrorHandlingFaults[i]
return a*totalTests[i], 4

def WSTF(i, Tp, B):
e, steps = WE(i)
return e/(Tp*(2**B)), steps + 3

# def WSRF(i, Tp, B):
# stf, steps = WSTF(i, Tp, B)
# return 1/np.exp(stf), steps + 2

def WBST():
totalSteps = 0
for i in range(4):
wstf, s = WSTF(i, Tp, B)
totalSteps += s
wsrf = np.exp(-wstf)
totalSteps + 2
return totalSteps

OE = [61570, 61557, 61550, 61544, 61536]
D = 16

def OSTF(i, D):
return OE[i]/((2**16)*(2**16 – 1)), 5

def OBIST():
totalSteps = 0
for i in range(5):
ostf, s = OSTF(i, D)
totalSteps += s
osrf = np.exp(-ostf)
totalSteps + 2
return totalSteps

Tr = 250
FC = [88.7, 90, 91.4, 95.7]
Nr = 1000
P = 1

def ISTF(i, Nr, P):
return (Tr*FC[i])/(Nr*2**P), 4

def ICT():
totalSteps = 0
for i in range(4):
istf, s = ISTF(i, Nr, P)
totalSteps += s
isrf = np.exp(-istf)
totalSteps + 2
return totalSteps

def MetricsCycle():
startTime = time()
totalSteps = WBST() + OBIST() + ICT()
return totalSteps, time()-startTime

print()
print(„Metrics Execution Cycles: „)
for _ in range(8):
print(MetricsCycle())

 

 

Leave a Comment

Diese Website verwendet Akismet, um Spam zu reduzieren. Erfahren Sie mehr darüber, wie Ihre Kommentardaten verarbeitet werden .

Scroll Up