Scenario
Pole Resilience vs Wind Speed
Given that poles have some ability to withstand wind loading, it is possible to gain a degree of information about that ability from the qualities of the pole.
However, there is still an element of uncertainty.
This analysis will determine how likely it is that a pole is damaged by the wind it endures, and if so how badly, by performing a Monte Carlo simulation in Neara.
Prerequisites
This example assumes a working knowledge of:
The Schema Editor
Creating and editing fields in a project's schema
The Neara Formula Language to create formulas in Schema fields and Report columns
To see the final solution or follow along in a Neara project, download the sample project on the Introduction page.
Model the distribution of resilience of a pole
First, create a distribution to represent the resilience of a pole.
Add a new field in the project's schema under Pole called u_resilience with this formula:
weibull_distribution(
shape: not_null(u_height_dimensionless),
scale: 1
)
Tips
To access the skewness of that distribution use:
u_resilience.skewness
For the 90% confidence interval on that distribution use:
evaluate_quantile(u_resilience, 0.9)
For the 5% confidence interval on that distribution use:
evaluate_quantile(u_resilience, 0.05)
Model the distribution of wind speeds
Next, model the distribution of the wind speeds.
The distribution of the wind speeds is not well known in this case; a new field under Pole called u_wind_speed_distribution with the following formula will ensure the results are close:
normal_distribution(
mean: u_resilience.mean,
standard_deviation: sqrt(u_resilience.variance)
)
This createe a normal distribution for the wind speeds with the same mean and standard deviation as the distribution of the resilience. Note that this means the wind speed each pole is subject to, is a function of the pole itself.
Perform the Monte Carlo simulation
The simulation will need samples from the distributions. This example will use 1000 samples from each.
Create a new field under Model in the schema called u_n_samples and set its formula to this number:
1000
This field is added under Model to make it easier to access and set later using model().u_n_samples
You can create an use value-type fields in the schema to hold Integer, Real, and Boolean values. However their values can only be set using other formulas or interactive controls like Parameters.
Using a Formula field in this case provides a shortcut to establish a static/constant value that will be used in other formulas.
Sample the resilience distribution
Create a new field under Pole in the schema called u_resilience_samples with this formula:
sample_distribution(
u_resilience,
model().u_n_samples,
seed: u_digest
)
sample_distribution accepts 3 arguments:
distribution, a ContinuousDistribution object representing the distribution we want to sample;n, an integer representing the number of samples we would like to draw; andseed: an integer that is used to lock down the random behaviour of the function.
About the seed
Neara is philosophically a deterministic platform. Running the same report with the same inputs should always return the same outputs. This conflicts with random sampling.
A straight forward approach of fixing a seed is problematic - it's possible to produce correlated random samples that would severely skew a model. To provide fine grained control, the function requires a custom seed.
The random behaviour of sample_distribution is controlled only by the parameters of the distribution and the specified seed. The same inputs here will produce highly correlated samples. Otherwise, expect that samples have no correlation, even if the distribution and seed are 'similar'.
In many cases it should be possible to easily generate a unique integer for each object you want to sample on, for example using the asset id of a pole.
In this example, create a new field under Pole in the schema called u_digest with the following formula that will always produce a random integer based on a unique attribute of that object:
round(
parse_num(
digest(
self.local_id,
digits: 10
)
)
)
The inner function digest takes in an object and a specified number of digits and produces a random integer with that many digits. The wrappers around it ensures the output is recognised as an integer.
Tip
Check the accuracy of the skewness attribute by evaluating the sample skewness of the samples:
estimate_skewness(u_resilience_samples)
At this point, u_resilience_samples is a field on Pole which contains a list with 1000 samples from the u_resilience distribution. Each pole's list is uncorrelated with any others. (This does not mean that the correlation coefficient will be 0).
Sample the wind speeds distribution
Now, obtain a matching set of samples from the distribution of wind speeds. Create a field under Pole in the schema called u_wind_speed_samples:
sample_distribution(
u_wind_speed_distribution,
model().u_n_samples,
seed: u_digest
)
Generate a new random variable of the difference of the resilience and wind speed samples
In this step, generate a new random variable that is the difference of the resilience sample and wind speed sample.
First, create an index on the pole in a new field under Pole in the schema called u_sample_index:
range(
model().u_n_samples
)
The length should match the number of samples.
Next, create fields on the index to get the samples. In the Schema Editor, navigate to Pole_c_sample_index and create a new field under it called u_resilience_sample:
index(
self.pole.u_resilience_samples,
sample_index_item
)
Create a second field under Pole_c_sample_index called u_wind_sample:
index(
self.pole.u_wind_speed_samples,
sample_index_item
)
Perform functions on the samples
At this point its possible to perform functions on the samples.
Create a new field under Pole_c_sample_index called u_composite_random_variable:
u_resilience_sample - u_wind_sample
This produces a list of 1000 samples of the difference between resilience and observed wind speed.