Control Agent

Indicates the type of a flow within a path

Supported Graphs

It represents data structure for maintenance related info

Message with default reason: Forward

Message with no input port

Message with pair in data

Simulated Physical Network Element

Agent's state, including observed state of 
monitoring/controlling asset

"Real" state of the asset

add_edges_gids(g,lv,nbs_gids,gid)

Add edges between the local vertex lv and the list of gids (global ids passed) using property gid

It annotates the graph with the coordinates obtained from the passed file name and location (location/name.csv). Annotating the graph is just adding attributes to the MetaGraph object passed.

Progress control agents one step.

Progress SimNE one step.

Checks if a directory exists, otherwise create it.

Clears cache of control agent

TODO Opportunity to investigate ways to store relevant cache rather than clearing all

clear queries requested by sne to controller that have expired, so the same query can be requested after some time model.ofmsg_reattempt

config(bconfig)

It prepares a config object based on the plain configuration (bconfig) passed as parameter.

It simulates a NE-controller link down In reality this is the routine that checks heartbeats from controlled NEs.

Simplest create agents

Create control agents

Helper function to create a csv file template out of a given config object passed

Create a packet using arguments

Create simulated asset agents

create_subgraph(egs,eqv,gid_prop)

Creates a graph g (MetaGraph) for the given edge list egs, where g represents a subgraph of a global graph. In eqv, every pair has the form: (lv,gv) where lv is the local vertex id and gv is the global vertex id. gid_prop indicates the property of g used to reference gv.

create_subgraph(m,eqv)

Creates a graph g (MetaGraph) for the given adjacency matrix m, where g represents a subgraph of a global graph. The vector eqv, gives the tuples: (lv,gv) where lv is the local vertex id and gv is the global vertex id.

Delete all the flows that output to the given port

Function to deteriorate a network element

Check confindence of a path @Deprecated (for time being)

It processes scheduled events

Processing for MATCH_PATH msg

Prepare MATCH reply

It process a msg from a neighbor controller notifying a sne is down

Query by neighbour control agent after receiving AGMessage

Initial query by controller receiving OF message

Query local calculated paths and local graph

Receives inter-agent messages

Run RUL predictions for the assets controlled by agent $a$

It deals with prediction of unavailability (for a given time window) of a set of NEs under control.

Update flows of the snes controlled by the agent a and for the path given,

Removes asset node (sne) from the network

Add to the count of dropped packets for the given sne

Determines criteria for valid values to TTF for
the exponential function.

    t₀: unused, defined to keep uniformity of function
        (TODO: check if this can be removed)
    t: value to evaluate

Basic implementation of exponential deterioration function
according to:

* T. Wang, J. Yu, D. Siegel, and J. Lee, “2008 International Conference on Prognostics and Health Management, PHM2008,” 
  2008 Int. Conf. Progn. Heal. Manag. PHM 2008, 2008.

  * A. Salvador Palau, M. Dhada, and A. Parlikad, “Multi-Agent System architectures for collaborative prognostics,” 
  J. Intell. Manuf., 2019.

a: max expected value of condition/health indicator (i.e. 1 if normalised)
b: curvature parameter
t: remaining time-to-failure (generally calculated with exp_t function)

Calculates remaining ttf(time-to-failure) for a given expected ttf
and current t
ttf: expected time-to-failure
t: current time

Scales exponential function considering shifting for long term
behaviour.

ttf: expected time-to-failure
t: value to scale
d: units to shift to the right (near TTF)

Find agent in the model given the id

It forwards packet to a host

It forwards packet to another sne

It generates the sensor time series for a given asset ttf:time-to-failure ot: off-time

Traffic generation per tick #TODO Implement this function as per required

It illustrates how to use the other TTE functions

Given a SimNE id it returns its ntw node address.

Return total of control messages exchanged by agents

get_default_config()

It returns the default config for simulation.

return the times when random assets will fail according to total sim time (N), quantity (q) of assets and proportion. It receives also random

labels is a dictionary where keys are: :tpt for througput and :up for node alive.

Given a ntw node address it returns the corresponding SimNE id

get_end_points(seed,g::G,coverage::Float64)

Given a set of paths, return the start and end vertices

Get query exclusions for a given message
@Deprecated

get_graph(seed,size,topo;k=0,B=0,adj_m_csv=nothing,sep=';')

Helper function to get underlying graph, passing either the size and topo required or the name adj_m_csv of the csv file with the adjacency matrix and the separator.

Return SNEs that are up

Return SNEs controlled by Agent a that are up

Get a random number of packets to be processed by a sne on a given tick defined by the sequence passed (tick + sne_id)

get_run_label(config)

It obtains the label for a simulation run based on the configuration parameters: config. Label is based on the graph model of the underlying controlled network and the control network, plus the size, seed and maintenance policy.

get_subgraph(g,nodes,id_prop)

It generates subgraph for the vector of nodes passed. This is similar to egonet but it keeps custom indexes given in id_prop parameter.

• g: graph
• nodes: It receives vector of controlled assets (nodes)
• id_prop: could be either :eid (simNE) or :aid (agent)

Calculates throughput for the given trajectory
- packet/bytes trajectory 
- interval: time steps

It filters throughput only when the given sne is up

has_prop_vertex(value,g,prop)

Check if vertex of the given graph g has property prop with value value.

msg: SimNE.id, in_port, DPacket

Packet processing per tick per agent

Initialise control agents

Initialise sne agents

Initialize an array of dimensions d1 x d2 that contains vectors of type T

Initialise state of model for a given step

Basic initialization

Function that makes a control agent trigger a flow install in the sne

Install the given flow in the sne. I t does not check if the flow is valid (the port is available), as this flow could be installed for the future.

Helper function that checks if x value is in vector V

Check if path is invalid according to local knowledge. It does not mean is valid as this agent might not have all info to check validity. Only flags invalid if 100% sure. cnes:controlled nes by this agent (a)

isless_paths(a,b)

Used to compare and ordering tuples of paths where tuples is of the form (tick,score)

join_subgraphs(g1,g2)

It joins two subgraphs assuming they are both part of a global graph. The id in the global graph is given by property :eid.

Linear degradation m: degradation slope b: expected life t: current time

It simulates operations happening in a network asset when the link corresponding to the given dpnid goes down. sne is up and node went down is dpnid.

It simulates operations happening in a network asset when the link corresponding to the given rjnid rejoins. sne is up and node re-joining is rjnid.

load_base_cfgs

It loads the simulation config parameters from csv file which location and name is passed. I passes a list with delimiters (delims) used in the file from outer, to inner. Default=[';',',']

load_control_graph(graph::MetaGraph)

It Loads(initialises) the graph of the control system

loadgraphfrom_csv

This function loads a graph from csv file containing the adjacency matrix of the graph. The file location and name is passed as argument (location/name.csv) together with the separator used in the csv e.g. ';' or ','.

load_network_graph(graph::MetaGraph)

It loads (initialise) the graph of the network to control

It loads serialised data for all the runs in the passed directory

Determines criteria for valid values to TTF for
the logistics function.

    t₀: initial value for the cycle/phase
    t: value to evaluate

logs only for a given agent

logs an info msg for tick and agent_id passed

logs an info msg for tick passed

Log info msg

Maintenance cost at a given time step:

rul_mnt: rul of an asset (sne) of the network that is undergoing maintenance. If rul == 0., then it is corrective maintenance, if rul > 0, then it is preventive maintenance. Otherwise (-1) no maintenance ongoing.

is_start: indicates if maintenance has just started so time-independent costs are added

is_active: indicates if the asset was active in the network before maintenance started, i.e. was part of an active flow.

dt_cost: downtime cost, cost of service flow/production loss per time step, time-dependent. Added when corrective maintenance.

l_cost: labour cost per time step, time-dependent.

p_cost: parts costs for maintenance regardless of the time it takes, time-independent, only added when maintenance starts.

r_cost: cost of loss of remaining life. Added when preventive maintenance.

When a solution is received for a query it marks the pending msg so it can be reprocessed in the next tick

Return mnt jobs in a given range for the passed plan

It advance model one step. Agents are progressed here to ensure that one action is perform in
all agents before the next action is performed in all agents, instead of having one action
executed in some agents and then some start with second action.

Next agent message's id

It returns the next event time for a given random number and rate of events

Next Open Flow message id

Add random normally distributed noise to a given value. Ensures that always: 0 ⋜ v + ϵ ⋜ y, for a random noise ϵ.

v: original value without noise
ϵₛ: noise standard deviation
ϵ₀: noise μ
y:  max value the noised value can take

It handles msg from sne when a neighbor sne has rejoined the underlying network.

This function progresses one step each link of the sne network.

It enqueues packets that were not processed in 
previous time steps. It discard packets according to defined size of the queue.

Plots the underlying controlled network

Plots the bare base map using the shp file passed

Plots a single agent control network

Plots a multiagent control network

Plots message exchange among control agents

Plots an empty placeholder

Plot network on top of the given geo plot passed

Plot network on top of the given geo plot passed

It plots one step at a time, receiving all steps in a vector of vector of NetworkAssetState

It plots one step at a time, receiving all steps in a DataFrame with data coming from NetworkAssetState

Plots packet loss of the underlying controlled network

Plots a subgraph that is part of a greater one global ids in property :eid.

Plots throughput of the underlying controlled network

It plots throughput and reference for one step of an animation of t timesteps

It plots throughput for one step of an animation of t timesteps

Main plotting function calls others

It processes OF msg sent by controlled NE  to
remove a given port from its graph
This is done by the agent controlling the neighbour of a dropped node

Function that prepare serialised time series of control agents for plotting

Processes msgs to SimNE

It processes a route received from optimisation algorithm

Push a new port edge pair

push OF message to from simulated host to dst SimNE

push OF message to from src SimNE to dst SimNE

It records messages pending to process in a given tick

query_paths(lg,s,d)

A wrapper of the Julia Graph ecosystem shortest_paths functions. It searches for a path between nodes with global id (eid) s and d in the local graph lg. It assumes property :eid of each vertex is global id of vertex

query_paths(lg,t)

Path search in local graph lg, receiving source s and destination d in a tuple t, such as t:(s,d).

It records active flow for reporting active path

Records benchmark for a query

Rejoin node to network according to

• base_network
• current_network
• rejoining node id

It removes a dropped sne node from local paths and graph

It routes packets according to installed flow rules. There could be rules that are not valid in the current time step but will be valid later.

Simple run model function

run_sim(config)

Based on config parameters received it creates objects required to trigger simulation run.

Schedules an event of type $type$ on the given agent $a$ at time $time$, affecting the snes with ids: $snes$.

Schedules an event of type $type$ on the given agent $a$ at time $time$.

score_path(path)

Wrapper the path score function. It gives a score to the given path, initially only based on length of path

Set controller agent down

Set controller agent up

single_run(config) -> ctl_ags,ne_ags,model

It runs a single simulation with the passed configuration, returning simulation data in ctl_ags,ne_ags,model. Optionally logging to a file if parameter log_to_file set to true.

soft_remove_vertex(g::AbstractGraph,dpn_id::Int)

Given the graph g, this function creates a deep copy of g and removes all the edges of the vertex whose global id (eid) is dpn_id and returns the new graph. The vertex whose id is dpn_id is only disconnected from the graph.

start_mnt!(a::Agent,sne::SimNE,model::ABM)

It simulates start of maintenance.

stop_mnt!(a::Agent,sne::SimNE,model::ABM)

It simulates completion of maintenance, refilling RUL and rejoining asset to the network.

to_local_vertex(lg,gv,gid)

It obtains the local id of a vertex in graph lg given its global gv in property in gid

to_local_vertex(lg,eid)

It obtains id of vertex in a local graph lg given vertex's global eid set to property :eid

A controller agent is notified of an event happening in the controlled element

Triggers random failures on active nodes. This function is coupled to the model as it detects nodes that are active and make sure disruption happen to some of those nodes. If decoupled, cleaner, but then requires to know in advance what paths are used at every time, to make sure that dropping nodes are always active.

Update (ntw node) addresses of SimNE agents after removal of a given SimNE

update_maintenance_plan!(a::Agent,mnt_policy::Type{PreventiveM},model::ABM)

It schedules maintenance events (start/stop maintenance) for assets under control of a that are configured with preventive or predictive mnt_policy

update_maintenance_plan!(a::Agent,mnt_policy::Type{PreventiveM},model::ABM)

It schedules maintenance events (start/stop maintenance) for assets under control of a that are configured with predictive mnt_policy with maintenance planning running in python.

Generates the time series until failure of an asset, given 
the provided parameters:

ttf: expected time-to-failure
n: maximum number of cycles the asset can last
Δᵩ: Delta of number of time steps that are reduced as the asset
    reaches a new cycle/phase
ϵₛ: Standard deviation of the gaussian noise 
f: function to generate values until ttf
params: params required by the f
tsf: function to scale t for the given function
tse: extra parameter required by tsf
f_c: function that defines criteria for a valid value in the time series.

Weibull scaling function ttf: expected time-to-failure γ: factor to tune max y (yₙ) value, e.g. for max y=1, with ttf =100, λ=0.5, κ=05 => γ=8

TODO: check if γ might be calculated from ttf, λ and κ

Scales weibull input t value considering shifting 
for long term behaviour

ttf: expected time-to-failure
γ: factor to tune max y (yₙ) value, e.g. for max y=1, with ttf =100,
λ=0.5, κ=05 => γ=8
d: units to shift to the right (near TTF)

Basic implementation of Weibull function with 2-parameters
κ: shape parameter, κ > 0
λ: scale parameter, λ > 0
t: current time (generally calculated with wb_t function)

Introduces a variation on the x value according to the phase (ϕ) Used concretely for long-term TTF, we assume: * An asset has expected TTF (x) * After TTF the asset can be repaired or maintained and then will operate for a number of cycles/phases. * The current cycle/phase is given by ϕ * After every phase ϕ, the asset reduces its TTF by Δᵩ