Glossary

This glossary is organized into sections, so that you can see how a specific term fits into the bigger picture of how RiskScape operates. In particular, the sections cover:

Terms used to describe the model workflow in RiskScape.
RiskScape-specific terms that describe more generic functionality, such as what a RiskScape function actually is, or how RiskScape is configured.
Generic computing and GIS terms that might be helpful for understanding the domain in which RiskScape operates.

RiskScape terms

Risk assessment is ‘an assessment of the nature and extent of risk by analysing potential hazards and evaluating existing conditions of exposure and vulnerability to determine likely consequences‘ (NEMA definition).

RiskScape is a software application designed to model these likely consequences.

The software workflow is based around: Exposure + Hazard = Consequence. We define these terms as:

Consequence: The outcome of hazards interacting with exposed elements at risk. The consequence will vary depending on the intensity of the hazard and the vulnerability of the element impacted. For example, consequences might be building damage or monetary loss. The consequence is derived through applying a vulnerability or fragility function (called the Risk Function in RiskScape) that is defined by the modeller.
Exposure: The elements at risk. These may be people, infrastructure, buildings, land use or other tangible or intangible assets located in hazard-prone areas. Measures of exposure can include the number of people or types of assets in an area and their attributes (e.g. construction types, replacement values).
Hazard: A process, phenomenon or human activity that may cause loss of life, injury or other health impacts, property damage, social and economic disruption or environmental degradation. A hazard affects an Exposure to produce a Consequence.

RiskScape model workflow

The overall RiskScape modelling workflow can be conceptualized by the following processing phases (each phase is described in further detail below):

graph TD RD["Input Risk Data The layers used by the model (exposure, hazard, etc)"]; RD --> PRE["Geoprocessing Apply geometry operations (e.g. cutting) to the exposure layer elements before any risk analysis takes place"]; PRE --> SS["Spatial Sampling Match the exposure-layer elements against data values (e.g. hazard intensity) in the other layer(s)"]; SS --> CI["Consequence Analysis Apply a function to each exposure-layer element and hazard intensity to derive a consequence"]; CI --> POST["Post-Processing For example, calculate the AEP for probabilistic models or produce loss curves"]; POST --> REP["Reporting Collate and summarize the results, select which attributes (columns) to include, and then save to file"];

The term we use for this overall process is:

Model Pipeline: A data processing pipeline built around a pre-defined, customizable framework and represents the overall processing workflow in RiskScape. Executing (or ‘running’) the pipeline performs risk modelling analysis of the input risk data.

The following sections define the phases in the model pipeline, along with any associated terminology, in more detail.

Input risk data

This involves loading the input data files provided by the user into RiskScape. These input data layers are generally specified as RiskScape Bookmarks. (Imagine your file system is a book, your ‘bookmarks’ tell RiskScape what to use and how to use it)

Area Layer: An optional geographical dataset representing areas of interest. The area information gets associated with Exposure layer elements for use in the Model Pipeline or for reporting Consequence information. Example area layers might be suburb or district boundaries or census areas.
Attribute: If you think of your input data as a table in a spreadsheet, each column represents an attribute. Attributes give the input data its structure. They have a type associated with them, such as string, integer, or geometry.
Exposure layer: A geographical dataset representing the elements at risk being modelled and their attributes. This may be people, infrastructure, buildings, land use and other tangible or intangible human assets.
Hazard layer: A geographical dataset representing a Hazard footprint of varying intensity.
Resource layer: An optional geographical dataset representing information that is not represented as either a Hazard or Exposure. For example, supplementary soil type information might be supplied to the Consequence Function via a separate Resource layer.
Tuple: If you think of your input data as a table in a spreadsheet, each row represents a tuple. A tuple is an ordered, named, typed list of values. RiskScape goes through the Exposure layer input data and processes it one tuple at a time. The tuple is then transformed as it moves through the data processing pipeline - attributes from other input layers are added, values may be manipulated, and so on.

Geoprocessing

Optional processing that uses Geoprocessing Functions to transform the input data geometry in some way. This processing essentially produces a new Exposure layer, and is applied before any risk analysis takes place. For example, you could take roading data and cut the roads into 10-metre pieces before applying your risk analysis.

Geoprocessing Functions: Built-in functions that perform common geometry processing operations. For example, the segment function will cut a line or polygon so it is smaller in size, whereas buffer will add a defined area around a point, line or polygon. For more details on the functions available, refer to Geometry processing functions.

Spatial Sampling

The process of determining the intensity or intensities (if any) of the Hazard for each element at risk in the Exposure layer, based on its geospatial location.

Coverage: A coverage is part of the inner workings of how RiskScape matches an element at risk against another geospatial layer. RiskScape takes an underlying data source, such as the Hazard layer, and turns it into an index that it can lookup by any given geometry. Because the indexed layer could be Raster, Vector, or some other kind of geospatial data source, the underlying data may be stored in a number of different ways. Turning the layer into a coverage gives RiskScape a common way of accessing any spatial data.
Hazard Intensity Measure: A characteristic of a hazardous process, phenomenon or human activity. This is a value representing the intensity of a Hazard at a specific geospatial location. It may be a single value (e.g. ‘flood depth’) or a composite value (e.g. ‘flood depth’ and ‘flood velocity’).
Sampling: The geospatial process of determining the Hazard Intensity Measure(s) that correspond to the location of a given Exposure layer element. RiskScape builds what is called a Coverage around the Hazard layer, which allows RiskScape to evaluate the Hazard layer data against a given point (e.g. the centroid of the exposure feature), or against a given geometry (e.g. finding all intersecting geometry between the exposure and the hazard layer).

Consequence Analysis

To undertake consequence analysis, the user defines what Consequence Function needs to be applied for the analysis they are undertaking. The Consequence Function is applied to each Exposure layer element, along with any corresponding Hazard Intensity Measure and Resource. This produces a Consequence layer.

Consequence Function: A Function that allows consequences (such as severity of damage or monetary loss) to be estimated based on the magnitude of hazard which the element is exposed to, and the potential or lack thereof to resist impact. Vulnerability functions, damage functions, fragility curves and thresholds are all examples of consequence functions. The consequence function is generally user-defined and will be specific to what is being modelled. This function may use other Maths functions to calculate the consequence.
Consequence Layer: A combined layer that contains attributes of the Exposure, Hazard, Area, and Resource layers, as well as the resulting Consequences.
Maths Functions: Built-in functions that perform common statistical operations. For more details on the available functions, refer to Built-in maths functions.

Post-processing

Depending on what is being modelled, RiskScape may perform additional processing on the Consequence layer. For example, when the Hazard is a probabilistic dataset, RiskScape may also produce an Annual Exceedance Probability (AEP) table.

Reporting

The results in the Consequence layer can be specifically filtered, aggregated or sorted before the Output Risk Data file(s) are saved.

Aggregation: RiskScape allows the user to collate and summarize the results of the Consequence Analysis. Examples of aggregation might be total loss by suburb (Area layer), or maximum damage for different construction-types. The aggregation process groups together rows of data (Tuples) in the Consequence layer by a set of attributes or by a RiskScape Expression. An Aggregate Function, such as sum or max, is then applied across the grouped rows. If you have used SQL before, this is similar to the GROUP BY clause.
Aggregate Function: A special type of RiskScape Function that can be applied across Tuples (rows). Aggregate functions produce a summary result for a given attribute. Examples of aggregate functions are sum or count. Refer to Built-in aggregation functions: for a full list.
Filter: A filter can remove unwanted Tuples (rows) from the Consequence layer data. Only the tuples where a given boolean RiskScape Expression holds to be true will be retained.
Output Risk Data: The final data that gets saved to your file system. This is the Consequence layer data after any required filtering, sorting, and aggregation operations have been applied. The output risk data may be saved as a CSV file or in Shapefile format, depending on the data it contains and how the user wishes to view it (CSV loads easily into spreadsheet applications, whereas Shapefiles load easily into other GIS applications).
Sort: Orders the data in the Consequence layer based on a given set of attributes or by a RiskScape Expression.
Select: Manipulates the Attributes (columns) in the Consequence layer data. This can remove unwanted attributes from the final output, modify or rename existing attributes, or even add new attributes to the results.

General RiskScape terms

The following terms define generic functionality in RiskScape that are used to configure and run Model Pipelines.

Bookmark: Bookmarks tell RiskScape where your input data sources are located and how to use them. They can also be written to associate additional Metadata with the data. For example, a bookmark can specify the CRS for the underlying data, or describe how the data is structured (i.e. its Type). Bookmarks allow data sources to be easily used by RiskScape Model Pipelines. Note that the underlying data source is usually a file, but this is not always the case (the data could be hosted in the WFS web service, for example).
Built-in Function: RiskScape provides built-in functions for common tasks, such as geoprocessing and maths operations.
Function: A RiskScape function is a self-contained piece of code used to execute a small processing task as part of a larger Pipeline or Model Pipeline data processing workflow. RiskScape functions are user-facing: the user can list all possible functions available to use. A function can be applied to given data from any RiskScape Expression - in programming terms this is referred to as calling the function, and looks similar to using a spreadsheet formula, e.g. square_root(9).
Home directory: An alternative to Project files. Instead of specifying in a single INI file all the Project information that RiskScape should use, a home directory contains multiple different INI files with this information.
Project: A project is a collection of all the information RiskScape needs in order to perform the desired risk analysis. This may include:

Types that describe how the risk data is structured.
User-defined Functions that are used by the risk analysis.
Bookmarks for the available input data files.
Models that define a specific set of RiskScape model workflow operations.

Project file: A single INI file that contains all the RiskScape Project information.
Pipeline: A pipeline defines a set of data processing steps, where data (Tuples) are passed between the steps and transformed along the way. RiskScape pipelines are generic and can technically be used for any type of data processing, but are most commonly used as Model Pipelines.
Pipeline Step: An individual data-processing action within a Pipeline. Steps have a pre-defined action, such as Sort, and accept parameters that can customize their behaviour, such as the by expression to use. A step processes every Tuple that flows through the pipeline. The output tuples from one step become the input tuples for the next step. Note that each phase in the RiskScape model workflow can correspond to one or many pipeline steps.
RiskScape: A software application for multi-hazard impact and risk analysis. The RiskScape application consists of a core RiskScape Engine as well as additional RiskScape Plugins.
RiskScape Engine: The core RiskScape software component that performs Model Pipeline execution.
RiskScape Plugins: Java software components that can be incorporated into RiskScape at runtime to extend its modelling functionality. For example, plugins can add additional Functions or Pipeline Step actions suitable to a specific modelling domain. Plugins make RiskScape extensible, and allows users to customize its behaviour by writing their own Java components that ‘plug in’ to RiskScape.
RiskScape Expression Language: A custom language used as the ‘glue’ when building Model Pipelines, and Classifier Format. The RiskScape Expression Language is similar to the formulas that can be entered into spreadsheet cells or used in SQL statements. A RiskScape expression is a simple statement that can be used to:

perform a basic maths operation, e.g. (hazard_intensity / 4) * road.replacement_cost
call a RiskScape Function, e.g. log(512, base: 2)
declare a new Type, such as a Struct: { foo: 12.3, bar: 'xyz' }
evaluate a boolean condition, e.g. building.height_m > 10.0

Struct: A set of attributes or information that can represent an entity such as an Exposure, Hazard Intensity Measure, Consequence, or Resource.
Type: RiskScape types define how the underlying data should be interpreted as it passes between Pipeline Steps or Functions. Types define the attributes or information representing an Exposure, Hazard Intensity Measure, Consequence, or Resource. Types are used to define what arguments a Function expects. RiskScape provides built-in types, such as Integer or Text, that can be used to build up more complex types, such as Structs.
User-defined Function: RiskScape users can define their own Functions using either Jython or Classifier Format.

Comparison to general risk modelling terms

If you come from a risk-modelling background, this section maps the terms you are familiar with to the terms used in RiskScape Model Pipelines.

Deterministic Modelling: A model that determines the risk from a single hazard event or scenario where no randomness is involved.
Exposure Function: A Consequence Function that simply determines whether or a given Exposure was affected by the Hazard. A simple example is the is_exposed Built-in Function.
Fragility Function: A Consequence Function that estimates the probability (P) that a damage or impact state for an Exposure will be reached or exceeded for a given Hazard Intensity Measure.
Impact: In this context, can be thought of the same as Consequence. This is what is modelled for each event or scenario.
Probabilistic Model: A Model Pipeline that determines the risk from multiple Hazard events or scenarios where randomness is involved.
Stochastic Model: A Model Pipeline that determines the risk from a Hazard event or scenario where randomness is involved, i.e. a volcanic eruption of a single magnitude might be simulated for multiple environmental conditions.
Multi-Hazard Model: A Model Pipeline that determines risk when multiple Hazard layers are involved. A Hazard intensity measure is sampled from each Hazard layer and the combined set of values is passed to the Consequence Function or Functions.
Cascading Multi-Hazard Model: A Model Pipeline that determines Consequences when multiple Hazard layers are involved, each one representing a successive hazard event scenario. RiskScape treats this the same as a Multi-Hazard Model - how the successive hazards influence the Consequence is controlled by how you write your Consequence Functions and Pipeline.
Vulnerability: The conditions which increase the susceptibility of an Exposure to direct or indirect Impact from a Hazard can be encapsulated by your Consequence Function. How you model vulnerability is determined by how you write your Consequence Function.

General GIS and computing terms

These are general terms that don’t hold any special meaning within RiskScape, but may provide useful context for understanding how the RiskScape software operates.

CLI: Command Line Interface.
CI (Continuous Integration): A development practice where the RiskScape development team build and test code automatically in a continuous fashion.
CRS (Coordinate Reference System): A coordinate reference system (or spatial reference system) is a coordinate-based local, regional or global system used to locate geographical entities. A CRS defines a specific map projection, as well as transformations between different spatial reference systems.
CSV (Comma-Separated Values): A comma-separated values file (.csv) is a delimited text file that uses a comma to separate values.
GeoTools: An Open Source Java library used by RiskScape for geoprocessing operations.
GeoTIFF: A GeoTIFF (.tif) is OGC Implementation Standard GeoTIFF based on the TIFF format and is used as an interchange format for georeferenced raster imagery.
GIS (Geographic Information System): A framework that provides the ability to capture, manage and analyse spatial and geographic data.
GitLab: Platform/framework used for managing software projects, such as CI, code review, and issue-tracking.
INI file: An INI file is a text-based file format that is commonly used to store basic configuration information.
Java: An object-oriented, high-level, general-purpose programming language.
JSON: JavaScript Object Notation. A text-based file format commonly used to serialize data.
Jython: An Java implementation of the Python language. Jython allows seamless integration between Java and Python code.
Metadata: A set of data that describes and gives information about other data.
OGC: The Open Geospatial Consortium standards organization.
Python: An interpreted, high-level, general-purpose programming language.
Raster: A matrix of cells (or pixels) organized into rows and columns (or a grid) where each cell contains a value representing information.
Raster file: GIS file representing geographical data as a Raster.
Relation: A set of Tuples. Whereas a Tuple is a row in a database table, a Relation is the entire table.
Shapefile: The shapefile (.shp) format is a geospatial Vector data format for GIS software, including RiskScape.
SRS (Spatial Reference System): See CRS.
Swift: OpenStack Object Storage. A way of loading data files into RiskScape from an OpenStack Cloud.
Vector: A graphical representation of vertices and paths.
Vector file: GIS file representing geographical data as vertices and paths displayed as points, lines and polygons (areas) depicting real-world features.
WFS (Web Feature Service): The OGC Interface Standard that allow requests for geographical features across the web using platform-independent calls.
WCS (Web Coverage Service): The OGC Interface Standard for the retrieval of coverage files (e.g. raster) across the web using platform-independent calls.