You signed in with another tab or window. Reload to refresh your session.You signed out in another tab or window. Reload to refresh your session.You switched accounts on another tab or window. Reload to refresh your session.Dismiss alert
Copy file name to clipboardExpand all lines: inst/paper/paper.Rmd
+60-78Lines changed: 60 additions & 78 deletions
Original file line number
Diff line number
Diff line change
@@ -1,7 +1,7 @@
1
1
---
2
2
title: 'ReliaShiny: A FAIR Application for Reliability Analysis'
3
3
output:
4
-
pdf_document: default/
4
+
html_document
5
5
---
6
6
7
7
```{r setup, include=FALSE}
@@ -36,10 +36,10 @@ FAIR principles of Findability, Accessibility, Interoperability, and Reusability
36
36
have also been shown to improve the quality and impact of analysis software [3].
37
37
38
38
Despite these advances, reliability engineering is still not widely supported. Many
39
-
reliability tools are proprietary, which limits access for a broader audience. The
40
-
open-source options that do exist are tied to specific programming languages. While
39
+
reliability tools are proprietary, which both limits access for a broader audience
40
+
The open-source options that do exist are tied to specific programming languages. While
41
41
popular packages are available in R [4] and Python [5], they require programming
42
-
skills that may be a barrier for some users.
42
+
skills that may be a barrier for some users.
43
43
44
44
This article introduces ReliaShiny, a web-based application that makes reliability
45
45
analysis easier to use. Built on the Shiny framework [6], ReliaShiny offers an interactive
@@ -55,21 +55,21 @@ of future work and possible improvements.
55
55
56
56
This project started as a proof of concept for performing Life Data Analysis (LDA) in
57
57
a web application. The initial goal was to build an easy-to-use interface for popular
58
-
reliability software packages, making these tools more accessible to a wider audience.
58
+
reliability OSS, making these tools more accessible to a wider audience.
59
59
Although still under active development, the application has reached a stable stage
60
60
and is now available for public use. Over time, new features, such as support for
61
61
Reliability Growth Analysis (RGA), have been added based on user feedback. Moving
62
62
forward, development will focus on adding more functions to support a broader range
63
63
of reliability analyses.
64
64
65
-
The development process was guided by the FAIR principles for research software.
66
-
These principles shaped important decisions throughout the project, from selecting
67
-
the core features to designing the user interface. By following FAIR, the goal was
68
-
to build software that is not only useful but also easy to find, access, integrate,
69
-
and reuse. This approach helps ensure that the application can effectively meet the
70
-
needs of its user community.
65
+
To follow best practices in OSS development, the project adopted the FAIR principles
66
+
for research software as a guiding framework. The FAIR principles shaped important
67
+
decisions throughout the project, from selecting the core features to designing the
68
+
user interface. By following FAIR, the goal was to build software that is not only
69
+
useful but also easy to find, access, integrate, and reuse. This approach helps ensure
70
+
that the application can effectively meet the needs of its user community.
71
71
72
-
The following sections describe how the FAIR principles were applied during development.
72
+
The project documentation explains each FAIR principle and how it was applied. The sections below summarize the main ways the FAIR principles were implemented in the project.
73
73
74
74
***Findable**: The ReliaShiny software and metadata are available in public repositories,
75
75
including GitHub (https://github.com) and the Comprehensive R Archive Network (CRAN) (https://cran.r-project.org). These repositories provide documentation, installation
@@ -110,8 +110,9 @@ to help users understand fundamental reliability concepts and methods.
110
110
## Design
111
111
112
112
ReliaShiny is built with the Shiny framework, which is used to create web applications
113
-
in R. Shiny apps are reactive, meaning their outputs update automatically whenever
114
-
inputs change. This reactivity allows for highly interactive workflows, making it
113
+
in R. Shiny applications use reactive programming to build interactive user interfaces.
114
+
Reactive expressions help control how outputs respond to changes in inputs, which
115
+
prevents unnecessary recalculations that can slow down performance. This reactivity allows for highly interactive workflows, making it
115
116
easy to explore and visualize data quickly. Users can try different inputs and instantly
116
117
see the results without having to refresh or rerun any code.
117
118
@@ -123,8 +124,8 @@ Shiny offers several layout templates and also allows building interfaces with c
123
124
HTML. ReliaShiny uses the shinydashboard [9] package, a Shiny extension made for
124
125
dashboard-style applications. The user interface is organized into multiple menus
125
126
for key tasks like data input, model fitting, and visualization. The app also uses
126
-
the shinyWidgets [10] package to provide better input controls and make the app easier
127
-
to use.
127
+
the shinyWidgets [10] package to provide better control over visualizations, allowing
128
+
for custom layouts and styles.
128
129
129
130
On the server side, ReliaShiny is built on key R packages for reliability analysis
130
131
and visualization. The WeibullR [11] package provides tools to fit and analyze Weibull
@@ -133,6 +134,16 @@ package helps with reliability growth modeling, allowing users to track and impr
133
134
system reliability over time. The ReliaPlotR [14] package lets users create interactive
134
135
reliability plots, making it easier to understand results through dynamic visualizations.
135
136
137
+
The application follows a modular design, with separate components for different tasks.
138
+
This modularity makes it easier to maintain and expand the application. Each module
139
+
handles a specific function, such as data input or model fitting, and can be updated
140
+
independently. This design also allows for easy addition of new features in the future,
141
+
as new modules can be created and integrated without affecting existing functionality.
142
+
143
+
The application also follows best practices for error handling and user feedback. Input validation checks
144
+
are implemented to ensure that users provide data in the correct format. If errors
145
+
occur during analysis, informative messages guide users on how to fix the issues. Help text is provided throughout the interface to assist users in understanding various options and features.
146
+
136
147
## Usage
137
148
138
149
ReliaShiny is available in two primary ways: as a web application hosted online
@@ -143,7 +154,7 @@ the software package from CRAN or GitHub, and then launching the application usi
143
154
a simple command. This option is ideal for users who require offline access or wish
144
155
to customize the application for their specific needs.
145
156
146
-
### Web-based Example
157
+
### Life Data Analysis
147
158
148
159
To illustrate the functionality of the web-based application, the following example
149
160
provides an overview of performing LDA using a sample dataset.
@@ -175,17 +186,19 @@ application also includes several example datasets that can be loaded directly,
175
186
this example use the sample "Time-to-Failure" dataset.
176
187
177
188
At this stage, the application should resemble the figure below. This figure shows
178
-
the data upload and arrangement options, along with a preview of the dataset. The
179
-
menu has several options for customizing the data arrangement, such as specifying
180
-
censoring types and grouping variables, but this example uses the default settings.
189
+
the data upload and arrangement options, along with a preview of the dataset. For
190
+
this example, the data is already arranged in the required format, so no further adjustments
191
+
are needed. The Data sub-menu has several options for customizing the data arrangement,
192
+
such as specifying right-censored and interval-censored data types and grouping variables,
193
+
but this example uses the default settings. On the right side of the tab are value
194
+
boxes that summarize key information about the dataset, including the number of
195
+
observations, number of failures, and number of censored obervations.
Next, navigate to the Model sub-menu to fit a reliability model to the data. The Model
185
-
tab provides options for selecting the distribution type, estimation method, and
186
-
other model settings. For this example, the Weibull distribution is selected with
187
-
the Maximum Likelihood Estimation (MLE) method. Feel free to experiment with different
188
-
configurations to tailor the model to specific needs. The figure below shows the
200
+
tab provides options for selecting the distribution type, estimation method, plotting
201
+
method, confidence method, and confidence level. For this example, the Weibull distribution is selected with the default options. Feel free to experiment with different configurations to tailor the model to specific needs. The figure below shows the
For users who prefer programmatic access, ReliaShiny comes prepackaged with the
209
-
ReliaPlotR package. This package provides functions for generating interactive reliability
210
-
plots similar to those found in the web application. This option is ideal for users
211
-
who wish to integrate reliability plotting into their existing workflows or who prefer
212
-
coding over using a graphical interface.
221
+
To demonstrate RGA functionality, the following example provides an overview of performing
222
+
RGA using a sample dataset. First, navigate to the Reliability Growth menu and click on the Data sub-menu.
223
+
Similar to the LDA example, the Data tab provides options for uploading and arranging data for analysis. The application includes several example datasets that can be loaded directly, and this example uses the preloaded "Simple Data" dataset. The right side of the tab displays value boxes that summarize key information about the dataset, including the number of failures and cumulative time.
224
+
Next, under the Data Selection box, select "failures" as the Failure Column. At this stage, the app should resemble the following figure.
213
225
214
-
To illustrate programmatic analysis, the following example demonstrates basic
First, start by loading `ReliaGrowR` and `ReliaPlotR` in the R environment.
218
-
```{r warning=FALSE}
219
-
library(ReliaGrowR)
220
-
library(ReliaPlotR)
221
-
```
228
+
Next, navigate to the Model sub-menu to build the Reliability Growth model. The application will generate a Reliability Growth Plot using default settings. The model settings include options for selecting the model type and confidence level. The figure below shows the Model tab with the model settings, model plot, and model summary. Feel free to experiment with different configurations to tailor the model to your needs. Next to the plot are additional settings for further customization.
222
229
223
-
Next set up some example cumulative time and failure data. This data represents
224
-
the times at which failures occurred during testing and the corresponding number
Then run the RGA using the rga function from the ReliaGrowR package. This function
232
-
fits a reliability growth model to the provided data and returns the results.
232
+
Finally, visit the Duane Plot tab to create a Duane plot. Similar to the previous plot, the Duane plot visualizes the reliability growth over time. The figure below shows the Duane plot and model summary generated by the application. As with the previous plot, various customization options are also available.
233
233
234
-
Finally, use the plotly_rga function from the ReliaPlotR package to create an
235
-
interactive plot of the RGA results. This plot allows users to visualize the reliability
236
-
growth over time and explore the data interactively.
0 commit comments