diff --git a/data_dictionary/data_structures_extra/costing.json b/data_dictionary/data_structures_extra/costing.json index 1243f598..7ae63311 100644 --- a/data_dictionary/data_structures_extra/costing.json +++ b/data_dictionary/data_structures_extra/costing.json @@ -707,7 +707,7 @@ }, "costing.levelized_CoE": { "data_type": "FLT_0D", - "documentation": "Levelized cost of electiricity (total cost / total electricy generated)", + "documentation": "Levelized cost of electiricity (total cost / total electricity generated)", "type": "static", "units": "$/kWh" }, diff --git a/data_dictionary/data_structures_extra/risk.json b/data_dictionary/data_structures_extra/risk.json new file mode 100644 index 00000000..bb88b613 --- /dev/null +++ b/data_dictionary/data_structures_extra/risk.json @@ -0,0 +1,675 @@ +{ + "risk": { + "documentation": "Risk quantification of plasma and engineering components" + }, + "risk.code": { + "data_type": "STRUCTURE", + "documentation": "Generic decription of the code-specific parameters for the code that has produced this IDS", + "full_path": "risk/code", + "lifecycle_status": "active", + "structure_reference": "code" + }, + "risk.code.commit": { + "data_type": "STR_0D", + "documentation": "Unique commit reference of software", + "full_path": "risk/code/commit", + "lifecycle_status": "active", + "type": "constant" + }, + "risk.code.description": { + "data_type": "STR_0D", + "documentation": "Short description of the software (type, purpose)", + "full_path": "risk/code/description", + "introduced_after_version": "3.38.1", + "lifecycle_status": "active", + "type": "constant" + }, + "risk.code.library": { + "coordinates": [ + "1...N" + ], + "data_type": "STRUCT_ARRAY", + "documentation": "List of external libraries used by the code that has produced this IDS", + "full_path": "risk/code/library(i1)", + "lifecycle_status": "active", + "maxoccur": "10", + "structure_reference": "library" + }, + "risk.code.library[:].commit": { + "data_type": "STR_0D", + "documentation": "Unique commit reference of software", + "full_path": "risk/code/library(i1)/commit", + "lifecycle_status": "active", + "type": "constant" + }, + "risk.code.library[:].description": { + "data_type": "STR_0D", + "documentation": "Short description of the software (type, purpose)", + "full_path": "risk/code/library(i1)/description", + "introduced_after_version": "3.38.1", + "lifecycle_status": "active", + "type": "constant" + }, + "risk.code.library[:].name": { + "data_type": "STR_0D", + "documentation": "Name of software", + "full_path": "risk/code/library(i1)/name", + "lifecycle_status": "active", + "type": "constant" + }, + "risk.code.library[:].parameters": { + "data_type": "STR_0D", + "documentation": "List of the code specific parameters in XML format", + "full_path": "risk/code/library(i1)/parameters", + "lifecycle_status": "active", + "type": "constant" + }, + "risk.code.library[:].repository": { + "data_type": "STR_0D", + "documentation": "URL of software repository", + "full_path": "risk/code/library(i1)/repository", + "lifecycle_status": "active", + "type": "constant" + }, + "risk.code.library[:].version": { + "data_type": "STR_0D", + "documentation": "Unique version (tag) of software", + "full_path": "risk/code/library(i1)/version", + "lifecycle_status": "active", + "type": "constant" + }, + "risk.code.name": { + "data_type": "STR_0D", + "documentation": "Name of software generating IDS", + "full_path": "risk/code/name", + "lifecycle_status": "active", + "type": "constant" + }, + "risk.code.output_flag": { + "coordinates": [ + "equilibrium.time" + ], + "data_type": "INT_1D", + "documentation": "Output flag : 0 means the run is successful, other values mean some difficulty has been encountered, the exact meaning is then code specific. Negative values mean the result shall not be used.", + "full_path": "risk/code/output_flag(:)", + "lifecycle_status": "active", + "timebasepath": "/time", + "type": "dynamic" + }, + "risk.code.parameters": { + "data_type": "STR_0D", + "documentation": "List of the code specific parameters in XML format", + "full_path": "risk/code/parameters", + "lifecycle_status": "active", + "type": "constant" + }, + "risk.code.repository": { + "data_type": "STR_0D", + "documentation": "URL of software repository", + "full_path": "risk/code/repository", + "lifecycle_status": "active", + "type": "constant" + }, + "risk.code.version": { + "data_type": "STR_0D", + "documentation": "Unique version (tag) of software", + "full_path": "risk/code/version", + "lifecycle_status": "active", + "type": "constant" + }, + "risk.engineering.loss": { + "coordinates": [ + "1...N" + ], + "data_type": "STRUCT_ARRAY", + "documentation": "List of engineering-related losses", + "type": "static" + }, + "risk.engineering.loss[:].description": { + "data_type": "STR_0D", + "documentation": "Description of loss channel", + "type": "static" + }, + "risk.engineering.loss[:].failure_mode": { + "coordinates": [ + "1...N" + ], + "data_type": "STRUCT_ARRAY", + "documentation": "List of failure modes associated to a particular loss", + "type": "static" + }, + "risk.engineering.loss[:].failure_mode[:].description": { + "data_type": "STR_0D", + "documentation": "Description of failure mode", + "type": "static" + }, + "risk.engineering.loss[:].failure_mode[:].probability": { + "data_type": "FLT_0D", + "documentation": "Probability of failure mode", + "type": "static" + }, + "risk.engineering.loss[:].failure_mode[:].weight": { + "data_type": "FLT_0D", + "documentation": "Weight associated to failure mode", + "type": "static" + }, + "risk.engineering.loss[:].probability": { + "data_type": "FLT_0D", + "documentation": "Probability of failure", + "type": "static" + }, + "risk.engineering.loss[:].risk": { + "data_type": "FLT_0D", + "documentation": "Product of loss probability and severity", + "type": "static" + }, + "risk.engineering.loss[:].severity": { + "data_type": "FLT_0D", + "documentation": "Severity of failure", + "type": "static", + "units": "M$" + }, + "risk.engineering.risk": { + "data_type": "FLT_0D", + "documentation": "Total engineering risk", + "type": "static", + "units": "M$" + }, + "risk.ids_properties": { + "data_type": "STRUCTURE", + "documentation": "Interface Data Structure properties. This element identifies the node above as an IDS", + "full_path": "risk/ids_properties", + "lifecycle_status": "active", + "structure_reference": "ids_properties" + }, + "risk.ids_properties.comment": { + "data_type": "STR_0D", + "documentation": "Any comment describing the content of this IDS", + "full_path": "risk/ids_properties/comment", + "lifecycle_status": "active", + "type": "constant" + }, + "risk.ids_properties.creation_date": { + "data_type": "STR_0D", + "documentation": "Date at which this data has been produced", + "full_path": "risk/ids_properties/creation_date", + "lifecycle_status": "active", + "type": "constant" + }, + "risk.ids_properties.homogeneous_time": { + "data_type": "INT_0D", + "documentation": "This node must be filled (with 0, 1, or 2) for the IDS to be valid. If 1, the time of this IDS is homogeneous, i.e. the time values for this IDS are stored in the time node just below the root of this IDS. If 0, the time values are stored in the various time fields at lower levels in the tree. In the case only constant or static nodes are filled within the IDS, homogeneous_time must be set to 2", + "full_path": "risk/ids_properties/homogeneous_time", + "lifecycle_status": "active", + "type": "constant" + }, + "risk.ids_properties.name": { + "data_type": "STR_0D", + "documentation": "User-defined name for this IDS occurrence", + "full_path": "risk/ids_properties/name", + "introduced_after_version": "3.39.0", + "lifecycle_status": "active", + "type": "constant" + }, + "risk.ids_properties.occurrence": { + "data_type": "INT_0D", + "description": "occurrence number [NOTE: this field only exists in OMAS and is not part of the ITER PDM]", + "full_path": "risk.ids_properties.occurrence" + }, + "risk.ids_properties.occurrence_type": { + "data_type": "STRUCTURE", + "doc_identifier": "utilities/occurrence_type_identifier.xml", + "documentation": "Type of data contained in this occurrence\n1) reconstruction : Equilibrium reconstruction\n2) prediction_fixed : Equilibrium prediction, fixed boundary\n3) prediction_free : Equilibrium prediction, free boundary\n4) mapping : Used for mapping risk results from one grid type / resolution to another, or for including variables not present in the first set such as the calculation of magnetic field of other derived parameters", + "full_path": "risk/ids_properties/occurrence_type", + "introduced_after_version": "3.39.0", + "lifecycle_status": "active", + "structure_reference": "identifier" + }, + "risk.ids_properties.occurrence_type.description": { + "data_type": "STR_0D", + "documentation": "Verbose description", + "full_path": "risk/ids_properties/occurrence_type/description", + "lifecycle_status": "active", + "type": "constant" + }, + "risk.ids_properties.occurrence_type.index": { + "data_type": "INT_0D", + "documentation": "Integer identifier (enumeration index within a list). Private identifier values must be indicated by a negative index.", + "full_path": "risk/ids_properties/occurrence_type/index", + "lifecycle_status": "active", + "type": "constant" + }, + "risk.ids_properties.occurrence_type.name": { + "data_type": "STR_0D", + "documentation": "Short string identifier", + "full_path": "risk/ids_properties/occurrence_type/name", + "lifecycle_status": "active", + "type": "constant" + }, + "risk.ids_properties.plugins": { + "data_type": "STRUCTURE", + "documentation": "Information about the plugins used to write/read this IDS. This structure is filled automatically by the Access Layer at GET/PUT time, no need to fill it via a user program.", + "full_path": "risk/ids_properties/plugins", + "introduced_after_version": "3.38.1", + "lifecycle_status": "alpha", + "lifecycle_version": "3.39.0", + "structure_reference": "ids_plugins" + }, + "risk.ids_properties.plugins.infrastructure_get": { + "data_type": "STRUCTURE", + "documentation": "Plugin infrastructure used to GET the data", + "full_path": "risk/ids_properties/plugins/infrastructure_get", + "lifecycle_status": "alpha", + "structure_reference": "code_constant_noparam" + }, + "risk.ids_properties.plugins.infrastructure_get.commit": { + "data_type": "STR_0D", + "documentation": "Unique commit reference of software", + "full_path": "risk/ids_properties/plugins/infrastructure_get/commit", + "lifecycle_status": "alpha", + "type": "constant" + }, + "risk.ids_properties.plugins.infrastructure_get.description": { + "data_type": "STR_0D", + "documentation": "Short description of the software (type, purpose)", + "full_path": "risk/ids_properties/plugins/infrastructure_get/description", + "introduced_after_version": "3.38.1", + "lifecycle_status": "alpha", + "type": "constant" + }, + "risk.ids_properties.plugins.infrastructure_get.name": { + "data_type": "STR_0D", + "documentation": "Name of software used", + "full_path": "risk/ids_properties/plugins/infrastructure_get/name", + "lifecycle_status": "alpha", + "type": "constant" + }, + "risk.ids_properties.plugins.infrastructure_get.repository": { + "data_type": "STR_0D", + "documentation": "URL of software repository", + "full_path": "risk/ids_properties/plugins/infrastructure_get/repository", + "lifecycle_status": "alpha", + "type": "constant" + }, + "risk.ids_properties.plugins.infrastructure_get.version": { + "data_type": "STR_0D", + "documentation": "Unique version (tag) of software", + "full_path": "risk/ids_properties/plugins/infrastructure_get/version", + "lifecycle_status": "alpha", + "type": "constant" + }, + "risk.ids_properties.plugins.infrastructure_put": { + "data_type": "STRUCTURE", + "documentation": "Plugin infrastructure used to PUT the data", + "full_path": "risk/ids_properties/plugins/infrastructure_put", + "lifecycle_status": "alpha", + "structure_reference": "code_constant_noparam" + }, + "risk.ids_properties.plugins.infrastructure_put.commit": { + "data_type": "STR_0D", + "documentation": "Unique commit reference of software", + "full_path": "risk/ids_properties/plugins/infrastructure_put/commit", + "lifecycle_status": "alpha", + "type": "constant" + }, + "risk.ids_properties.plugins.infrastructure_put.description": { + "data_type": "STR_0D", + "documentation": "Short description of the software (type, purpose)", + "full_path": "risk/ids_properties/plugins/infrastructure_put/description", + "introduced_after_version": "3.38.1", + "lifecycle_status": "alpha", + "type": "constant" + }, + "risk.ids_properties.plugins.infrastructure_put.name": { + "data_type": "STR_0D", + "documentation": "Name of software used", + "full_path": "risk/ids_properties/plugins/infrastructure_put/name", + "lifecycle_status": "alpha", + "type": "constant" + }, + "risk.ids_properties.plugins.infrastructure_put.repository": { + "data_type": "STR_0D", + "documentation": "URL of software repository", + "full_path": "risk/ids_properties/plugins/infrastructure_put/repository", + "lifecycle_status": "alpha", + "type": "constant" + }, + "risk.ids_properties.plugins.infrastructure_put.version": { + "data_type": "STR_0D", + "documentation": "Unique version (tag) of software", + "full_path": "risk/ids_properties/plugins/infrastructure_put/version", + "lifecycle_status": "alpha", + "type": "constant" + }, + "risk.ids_properties.plugins.node": { + "coordinates": [ + "1...N" + ], + "data_type": "STRUCT_ARRAY", + "documentation": "Set of IDS nodes for which a plugin has been applied", + "full_path": "risk/ids_properties/plugins/node(i1)", + "lifecycle_status": "alpha", + "maxoccur": "20", + "structure_reference": "ids_plugins_node", + "type": "constant" + }, + "risk.ids_properties.plugins.node[:].get_operation": { + "coordinates": [ + "1...N" + ], + "data_type": "STRUCT_ARRAY", + "documentation": "Plugins actually used to read back a node (potentially, multiple plugins can be applied, listed in reverse order of application). This information is filled by the plugin infrastructure during the GET operation.", + "full_path": "risk/ids_properties/plugins/node(i1)/get_operation(i2)", + "lifecycle_status": "alpha", + "maxoccur": "10", + "structure_reference": "code_constant" + }, + "risk.ids_properties.plugins.node[:].get_operation[:].commit": { + "data_type": "STR_0D", + "documentation": "Unique commit reference of software", + "full_path": "risk/ids_properties/plugins/node(i1)/get_operation(i2)/commit", + "lifecycle_status": "alpha", + "type": "constant" + }, + "risk.ids_properties.plugins.node[:].get_operation[:].description": { + "data_type": "STR_0D", + "documentation": "Short description of the software (type, purpose)", + "full_path": "risk/ids_properties/plugins/node(i1)/get_operation(i2)/description", + "introduced_after_version": "3.38.1", + "lifecycle_status": "alpha", + "type": "constant" + }, + "risk.ids_properties.plugins.node[:].get_operation[:].name": { + "data_type": "STR_0D", + "documentation": "Name of software used", + "full_path": "risk/ids_properties/plugins/node(i1)/get_operation(i2)/name", + "lifecycle_status": "alpha", + "type": "constant" + }, + "risk.ids_properties.plugins.node[:].get_operation[:].parameters": { + "data_type": "STR_0D", + "documentation": "List of the code specific parameters in XML format", + "full_path": "risk/ids_properties/plugins/node(i1)/get_operation(i2)/parameters", + "lifecycle_status": "alpha", + "type": "constant" + }, + "risk.ids_properties.plugins.node[:].get_operation[:].repository": { + "data_type": "STR_0D", + "documentation": "URL of software repository", + "full_path": "risk/ids_properties/plugins/node(i1)/get_operation(i2)/repository", + "lifecycle_status": "alpha", + "type": "constant" + }, + "risk.ids_properties.plugins.node[:].get_operation[:].version": { + "data_type": "STR_0D", + "documentation": "Unique version (tag) of software", + "full_path": "risk/ids_properties/plugins/node(i1)/get_operation(i2)/version", + "lifecycle_status": "alpha", + "type": "constant" + }, + "risk.ids_properties.plugins.node[:].path": { + "data_type": "STR_0D", + "documentation": "Path of the node within the IDS, following the syntax given in the link below. If empty, means the plugin applies to the whole IDS.", + "full_path": "risk/ids_properties/plugins/node(i1)/path", + "lifecycle_status": "alpha", + "type": "constant", + "url": "utilities/IDS-path-syntax.md" + }, + "risk.ids_properties.plugins.node[:].put_operation": { + "coordinates": [ + "1...N" + ], + "data_type": "STRUCT_ARRAY", + "documentation": "Plugins used to PUT a node (potentially, multiple plugins can be applied, if so they are listed by order of application)", + "full_path": "risk/ids_properties/plugins/node(i1)/put_operation(i2)", + "lifecycle_status": "alpha", + "maxoccur": "10", + "structure_reference": "code_constant" + }, + "risk.ids_properties.plugins.node[:].put_operation[:].commit": { + "data_type": "STR_0D", + "documentation": "Unique commit reference of software", + "full_path": "risk/ids_properties/plugins/node(i1)/put_operation(i2)/commit", + "lifecycle_status": "alpha", + "type": "constant" + }, + "risk.ids_properties.plugins.node[:].put_operation[:].description": { + "data_type": "STR_0D", + "documentation": "Short description of the software (type, purpose)", + "full_path": "risk/ids_properties/plugins/node(i1)/put_operation(i2)/description", + "introduced_after_version": "3.38.1", + "lifecycle_status": "alpha", + "type": "constant" + }, + "risk.ids_properties.plugins.node[:].put_operation[:].name": { + "data_type": "STR_0D", + "documentation": "Name of software used", + "full_path": "risk/ids_properties/plugins/node(i1)/put_operation(i2)/name", + "lifecycle_status": "alpha", + "type": "constant" + }, + "risk.ids_properties.plugins.node[:].put_operation[:].parameters": { + "data_type": "STR_0D", + "documentation": "List of the code specific parameters in XML format", + "full_path": "risk/ids_properties/plugins/node(i1)/put_operation(i2)/parameters", + "lifecycle_status": "alpha", + "type": "constant" + }, + "risk.ids_properties.plugins.node[:].put_operation[:].repository": { + "data_type": "STR_0D", + "documentation": "URL of software repository", + "full_path": "risk/ids_properties/plugins/node(i1)/put_operation(i2)/repository", + "lifecycle_status": "alpha", + "type": "constant" + }, + "risk.ids_properties.plugins.node[:].put_operation[:].version": { + "data_type": "STR_0D", + "documentation": "Unique version (tag) of software", + "full_path": "risk/ids_properties/plugins/node(i1)/put_operation(i2)/version", + "lifecycle_status": "alpha", + "type": "constant" + }, + "risk.ids_properties.plugins.node[:].readback": { + "coordinates": [ + "1...N" + ], + "data_type": "STRUCT_ARRAY", + "documentation": "Plugins to be used to read back a node (potentially, multiple plugins can be applied, listed in reverse order of application) ", + "full_path": "risk/ids_properties/plugins/node(i1)/readback(i2)", + "lifecycle_status": "alpha", + "maxoccur": "10", + "structure_reference": "code_constant" + }, + "risk.ids_properties.plugins.node[:].readback[:].commit": { + "data_type": "STR_0D", + "documentation": "Unique commit reference of software", + "full_path": "risk/ids_properties/plugins/node(i1)/readback(i2)/commit", + "lifecycle_status": "alpha", + "type": "constant" + }, + "risk.ids_properties.plugins.node[:].readback[:].description": { + "data_type": "STR_0D", + "documentation": "Short description of the software (type, purpose)", + "full_path": "risk/ids_properties/plugins/node(i1)/readback(i2)/description", + "introduced_after_version": "3.38.1", + "lifecycle_status": "alpha", + "type": "constant" + }, + "risk.ids_properties.plugins.node[:].readback[:].name": { + "data_type": "STR_0D", + "documentation": "Name of software used", + "full_path": "risk/ids_properties/plugins/node(i1)/readback(i2)/name", + "lifecycle_status": "alpha", + "type": "constant" + }, + "risk.ids_properties.plugins.node[:].readback[:].parameters": { + "data_type": "STR_0D", + "documentation": "List of the code specific parameters in XML format", + "full_path": "risk/ids_properties/plugins/node(i1)/readback(i2)/parameters", + "lifecycle_status": "alpha", + "type": "constant" + }, + "risk.ids_properties.plugins.node[:].readback[:].repository": { + "data_type": "STR_0D", + "documentation": "URL of software repository", + "full_path": "risk/ids_properties/plugins/node(i1)/readback(i2)/repository", + "lifecycle_status": "alpha", + "type": "constant" + }, + "risk.ids_properties.plugins.node[:].readback[:].version": { + "data_type": "STR_0D", + "documentation": "Unique version (tag) of software", + "full_path": "risk/ids_properties/plugins/node(i1)/readback(i2)/version", + "lifecycle_status": "alpha", + "type": "constant" + }, + "risk.ids_properties.provenance": { + "data_type": "STRUCTURE", + "documentation": "Provenance information about this IDS", + "full_path": "risk/ids_properties/provenance", + "lifecycle_status": "alpha", + "lifecycle_version": "3.34.0", + "structure_reference": "ids_provenance" + }, + "risk.ids_properties.provenance.node": { + "coordinates": [ + "1...N" + ], + "data_type": "STRUCT_ARRAY", + "documentation": "Set of IDS nodes for which the provenance is given. The provenance information applies to the whole structure below the IDS node. For documenting provenance information for the whole IDS, set the size of this array of structure to 1 and leave the child \"path\" node empty", + "full_path": "risk/ids_properties/provenance/node(i1)", + "lifecycle_status": "alpha", + "maxoccur": "20", + "structure_reference": "ids_provenance_node", + "type": "constant" + }, + "risk.ids_properties.provenance.node[:].path": { + "data_type": "STR_0D", + "documentation": "Path of the node within the IDS, following the syntax given in the link below. If empty, means the provenance information applies to the whole IDS.", + "full_path": "risk/ids_properties/provenance/node(i1)/path", + "lifecycle_status": "alpha", + "type": "constant", + "url": "utilities/IDS-path-syntax.md" + }, + "risk.ids_properties.provenance.node[:].sources": { + "coordinates": [ + "1...N" + ], + "data_type": "STR_1D", + "documentation": "List of sources used to import or calculate this node, identified as explained below. In case the node is the result of of a calculation / data processing, the source is an input to the process described in the \"code\" structure at the root of the IDS. The source can be an IDS (identified by a URI or a persitent identifier, see syntax in the link below) or non-IDS data imported directly from an non-IMAS database (identified by the command used to import the source, or the persistent identifier of the data source). Often data are obtained by a chain of processes, however only the last process input are recorded here. The full chain of provenance has then to be reconstructed recursively from the provenance information contained in the data sources.", + "full_path": "risk/ids_properties/provenance/node(i1)/sources(:)", + "lifecycle_status": "alpha", + "type": "constant", + "url": "utilities/IMAS-URI-scheme.md" + }, + "risk.ids_properties.provider": { + "data_type": "STR_0D", + "documentation": "Name of the person in charge of producing this data", + "full_path": "risk/ids_properties/provider", + "lifecycle_status": "active", + "type": "constant" + }, + "risk.ids_properties.source": { + "data_type": "STR_0D", + "documentation": "Source of the data (any comment describing the origin of the data : code, path to diagnostic signals, processing method, ...). Superseeded by the new provenance structure.", + "full_path": "risk/ids_properties/source", + "lifecycle_status": "obsolescent", + "lifecycle_version": "3.34.0", + "type": "constant" + }, + "risk.ids_properties.version_put": { + "data_type": "STRUCTURE", + "documentation": "Version of the access layer package used to PUT this IDS", + "full_path": "risk/ids_properties/version_put", + "lifecycle_status": "active", + "structure_reference": "version_dd_al" + }, + "risk.ids_properties.version_put.access_layer": { + "data_type": "STR_0D", + "documentation": "Version of Access Layer used to PUT this IDS", + "full_path": "risk/ids_properties/version_put/access_layer", + "lifecycle_status": "active", + "type": "constant" + }, + "risk.ids_properties.version_put.access_layer_language": { + "data_type": "STR_0D", + "documentation": "Programming language of the Access Layer high level API used to PUT this IDS", + "full_path": "risk/ids_properties/version_put/access_layer_language", + "lifecycle_status": "active", + "type": "constant" + }, + "risk.ids_properties.version_put.data_dictionary": { + "data_type": "STR_0D", + "documentation": "Version of Data Dictionary used to PUT this IDS", + "full_path": "risk/ids_properties/version_put/data_dictionary", + "lifecycle_status": "active", + "type": "constant" + }, + "risk.plasma.loss": { + "coordinates": [ + "1...N" + ], + "data_type": "STRUCT_ARRAY", + "documentation": "List of plasma-related losses", + "type": "static" + }, + "risk.plasma.loss[:].description": { + "data_type": "STR_0D", + "documentation": "Description of loss channel", + "type": "static" + }, + "risk.plasma.loss[:].probability": { + "data_type": "FLT_0D", + "documentation": "Probability of failure", + "type": "static" + }, + "risk.plasma.loss[:].risk": { + "data_type": "FLT_0D", + "documentation": "Product of loss probability and severity", + "type": "static", + "units": "$/kWh" + }, + "risk.plasma.risk": { + "data_type": "FLT_0D", + "documentation": "Total plasma risk", + "type": "static", + "units": "$/kWh" + }, + "risk.plasma.severity.average_severity": { + "data_type": "FLT_0D", + "documentation": "Average severity of disruption-induced events", + "type": "static" + }, + "risk.plasma.severity.current_quench": { + "data_type": "FLT_0D", + "documentation": "Severity of disruption-induced current quench", + "type": "static" + }, + "risk.plasma.severity.thermal_quench": { + "data_type": "FLT_0D", + "documentation": "Severity of disruption-induced thermal quench", + "type": "static" + }, + "risk.plasma.severity.vertical_forces": { + "data_type": "FLT_0D", + "documentation": "Severity of disruption-induced vertical forces", + "type": "static" + }, + "risk.time": { + "units": "s", + "coordinates": [ + "1...N" + ], + "lifecycle_status": "active", + "data_type": "FLT_1D_TYPE", + "full_path": "risk/time(:)", + "timebasepath": "time", + "documentation": "Generic time", + "type": "dynamic" + }, + "risk.total_risk": { + "data_type": "FLT_0D", + "documentation": "Sum of risks", + "type": "static" + } +} diff --git a/src/dd.jl b/src/dd.jl index ab3bc00b..a85f7cb7 100644 --- a/src/dd.jl +++ b/src/dd.jl @@ -50305,6 +50305,620 @@ end runaway_electrons() = runaway_electrons{Float64}() +mutable struct FilledFields____risk__plasma__severity + var"average_severity"::Bool + var"average_severity_σ"::Bool + var"current_quench"::Bool + var"current_quench_σ"::Bool + var"thermal_quench"::Bool + var"thermal_quench_σ"::Bool + var"vertical_forces"::Bool + var"vertical_forces_σ"::Bool +end + +mutable struct risk__plasma__severity{T} <: IDS{T} + var"average_severity" :: T + var"average_severity_σ" :: T + var"current_quench" :: T + var"current_quench_σ" :: T + var"thermal_quench" :: T + var"thermal_quench_σ" :: T + var"vertical_forces" :: T + var"vertical_forces_σ" :: T + _filled::FilledFields____risk__plasma__severity + _frozen::Bool + _threads_lock::ReentrantLock + _in_expression::Dict{Int,Vector{Symbol}} + _parent::WeakRef +end + +function risk__plasma__severity{T}() where T + ids = risk__plasma__severity{T}(0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, FilledFields____risk__plasma__severity(false, false, false, false, false, false, false, false), false, ReentrantLock(), Dict{Int,Vector{Symbol}}(), WeakRef(nothing)) + return ids +end + +risk__plasma__severity() = risk__plasma__severity{Float64}() + +mutable struct FilledFields____risk__plasma__loss + var"description"::Bool + var"probability"::Bool + var"probability_σ"::Bool + var"risk"::Bool + var"risk_σ"::Bool +end + +mutable struct risk__plasma__loss{T} <: IDSvectorStaticElement{T} + var"description" :: String + var"probability" :: T + var"probability_σ" :: T + var"risk" :: T + var"risk_σ" :: T + _filled::FilledFields____risk__plasma__loss + _frozen::Bool + _threads_lock::ReentrantLock + _in_expression::Dict{Int,Vector{Symbol}} + _parent::WeakRef +end + +function risk__plasma__loss{T}() where T + ids = risk__plasma__loss{T}("", 0.0, 0.0, 0.0, 0.0, FilledFields____risk__plasma__loss(false, false, false, false, false), false, ReentrantLock(), Dict{Int,Vector{Symbol}}(), WeakRef(nothing)) + return ids +end + +risk__plasma__loss() = risk__plasma__loss{Float64}() + +mutable struct FilledFields____risk__plasma + var"loss"::Bool + var"risk"::Bool + var"risk_σ"::Bool + var"severity"::Bool +end + +mutable struct risk__plasma{T} <: IDS{T} + var"loss"::IDSvector{risk__plasma__loss{T}} + var"risk" :: T + var"risk_σ" :: T + var"severity"::risk__plasma__severity{T} + _filled::FilledFields____risk__plasma + _frozen::Bool + _threads_lock::ReentrantLock + _in_expression::Dict{Int,Vector{Symbol}} + _parent::WeakRef +end + +function risk__plasma{T}() where T + ids = risk__plasma{T}(IDSvector{risk__plasma__loss{T}}(), 0.0, 0.0, risk__plasma__severity{T}(), FilledFields____risk__plasma(false, false, false, false), false, ReentrantLock(), Dict{Int,Vector{Symbol}}(), WeakRef(nothing)) + setfield!(ids.loss, :_parent, WeakRef(ids)) + setfield!(ids.severity, :_parent, WeakRef(ids)) + return ids +end + +risk__plasma() = risk__plasma{Float64}() + +mutable struct FilledFields____risk__ids_properties__version_put + var"access_layer"::Bool + var"access_layer_language"::Bool + var"data_dictionary"::Bool +end + +mutable struct risk__ids_properties__version_put{T} <: IDS{T} + var"access_layer" :: String + var"access_layer_language" :: String + var"data_dictionary" :: String + _filled::FilledFields____risk__ids_properties__version_put + _frozen::Bool + _threads_lock::ReentrantLock + _in_expression::Dict{Int,Vector{Symbol}} + _parent::WeakRef +end + +function risk__ids_properties__version_put{T}() where T + ids = risk__ids_properties__version_put{T}("", "", "", FilledFields____risk__ids_properties__version_put(false, false, false), false, ReentrantLock(), Dict{Int,Vector{Symbol}}(), WeakRef(nothing)) + return ids +end + +risk__ids_properties__version_put() = risk__ids_properties__version_put{Float64}() + +mutable struct FilledFields____risk__ids_properties__provenance__node + var"path"::Bool + var"sources"::Bool +end + +mutable struct risk__ids_properties__provenance__node{T} <: IDSvectorStaticElement{T} + var"path" :: String + var"sources" :: Vector{String} + _filled::FilledFields____risk__ids_properties__provenance__node + _frozen::Bool + _threads_lock::ReentrantLock + _in_expression::Dict{Int,Vector{Symbol}} + _parent::WeakRef +end + +function risk__ids_properties__provenance__node{T}() where T + ids = risk__ids_properties__provenance__node{T}("", String[], FilledFields____risk__ids_properties__provenance__node(false, false), false, ReentrantLock(), Dict{Int,Vector{Symbol}}(), WeakRef(nothing)) + return ids +end + +risk__ids_properties__provenance__node() = risk__ids_properties__provenance__node{Float64}() + +mutable struct FilledFields____risk__ids_properties__provenance + var"node"::Bool +end + +mutable struct risk__ids_properties__provenance{T} <: IDS{T} + var"node"::IDSvector{risk__ids_properties__provenance__node{T}} + _filled::FilledFields____risk__ids_properties__provenance + _frozen::Bool + _threads_lock::ReentrantLock + _in_expression::Dict{Int,Vector{Symbol}} + _parent::WeakRef +end + +function risk__ids_properties__provenance{T}() where T + ids = risk__ids_properties__provenance{T}(IDSvector{risk__ids_properties__provenance__node{T}}(), FilledFields____risk__ids_properties__provenance(false), false, ReentrantLock(), Dict{Int,Vector{Symbol}}(), WeakRef(nothing)) + setfield!(ids.node, :_parent, WeakRef(ids)) + return ids +end + +risk__ids_properties__provenance() = risk__ids_properties__provenance{Float64}() + +mutable struct FilledFields____risk__ids_properties__plugins__node___readback + var"commit"::Bool + var"description"::Bool + var"name"::Bool + var"parameters"::Bool + var"repository"::Bool + var"version"::Bool +end + +mutable struct risk__ids_properties__plugins__node___readback{T} <: IDSvectorStaticElement{T} + var"commit" :: String + var"description" :: String + var"name" :: String + var"parameters" :: String + var"repository" :: String + var"version" :: String + _filled::FilledFields____risk__ids_properties__plugins__node___readback + _frozen::Bool + _threads_lock::ReentrantLock + _in_expression::Dict{Int,Vector{Symbol}} + _parent::WeakRef +end + +function risk__ids_properties__plugins__node___readback{T}() where T + ids = risk__ids_properties__plugins__node___readback{T}("", "", "", "", "", "", FilledFields____risk__ids_properties__plugins__node___readback(false, false, false, false, false, false), false, ReentrantLock(), Dict{Int,Vector{Symbol}}(), WeakRef(nothing)) + return ids +end + +risk__ids_properties__plugins__node___readback() = risk__ids_properties__plugins__node___readback{Float64}() + +mutable struct FilledFields____risk__ids_properties__plugins__node___put_operation + var"commit"::Bool + var"description"::Bool + var"name"::Bool + var"parameters"::Bool + var"repository"::Bool + var"version"::Bool +end + +mutable struct risk__ids_properties__plugins__node___put_operation{T} <: IDSvectorStaticElement{T} + var"commit" :: String + var"description" :: String + var"name" :: String + var"parameters" :: String + var"repository" :: String + var"version" :: String + _filled::FilledFields____risk__ids_properties__plugins__node___put_operation + _frozen::Bool + _threads_lock::ReentrantLock + _in_expression::Dict{Int,Vector{Symbol}} + _parent::WeakRef +end + +function risk__ids_properties__plugins__node___put_operation{T}() where T + ids = risk__ids_properties__plugins__node___put_operation{T}("", "", "", "", "", "", FilledFields____risk__ids_properties__plugins__node___put_operation(false, false, false, false, false, false), false, ReentrantLock(), Dict{Int,Vector{Symbol}}(), WeakRef(nothing)) + return ids +end + +risk__ids_properties__plugins__node___put_operation() = risk__ids_properties__plugins__node___put_operation{Float64}() + +mutable struct FilledFields____risk__ids_properties__plugins__node___get_operation + var"commit"::Bool + var"description"::Bool + var"name"::Bool + var"parameters"::Bool + var"repository"::Bool + var"version"::Bool +end + +mutable struct risk__ids_properties__plugins__node___get_operation{T} <: IDSvectorStaticElement{T} + var"commit" :: String + var"description" :: String + var"name" :: String + var"parameters" :: String + var"repository" :: String + var"version" :: String + _filled::FilledFields____risk__ids_properties__plugins__node___get_operation + _frozen::Bool + _threads_lock::ReentrantLock + _in_expression::Dict{Int,Vector{Symbol}} + _parent::WeakRef +end + +function risk__ids_properties__plugins__node___get_operation{T}() where T + ids = risk__ids_properties__plugins__node___get_operation{T}("", "", "", "", "", "", FilledFields____risk__ids_properties__plugins__node___get_operation(false, false, false, false, false, false), false, ReentrantLock(), Dict{Int,Vector{Symbol}}(), WeakRef(nothing)) + return ids +end + +risk__ids_properties__plugins__node___get_operation() = risk__ids_properties__plugins__node___get_operation{Float64}() + +mutable struct FilledFields____risk__ids_properties__plugins__node + var"get_operation"::Bool + var"path"::Bool + var"put_operation"::Bool + var"readback"::Bool +end + +mutable struct risk__ids_properties__plugins__node{T} <: IDSvectorStaticElement{T} + var"get_operation"::IDSvector{risk__ids_properties__plugins__node___get_operation{T}} + var"path" :: String + var"put_operation"::IDSvector{risk__ids_properties__plugins__node___put_operation{T}} + var"readback"::IDSvector{risk__ids_properties__plugins__node___readback{T}} + _filled::FilledFields____risk__ids_properties__plugins__node + _frozen::Bool + _threads_lock::ReentrantLock + _in_expression::Dict{Int,Vector{Symbol}} + _parent::WeakRef +end + +function risk__ids_properties__plugins__node{T}() where T + ids = risk__ids_properties__plugins__node{T}(IDSvector{risk__ids_properties__plugins__node___get_operation{T}}(), "", IDSvector{risk__ids_properties__plugins__node___put_operation{T}}(), IDSvector{risk__ids_properties__plugins__node___readback{T}}(), FilledFields____risk__ids_properties__plugins__node(false, false, false, false), false, ReentrantLock(), Dict{Int,Vector{Symbol}}(), WeakRef(nothing)) + setfield!(ids.get_operation, :_parent, WeakRef(ids)) + setfield!(ids.put_operation, :_parent, WeakRef(ids)) + setfield!(ids.readback, :_parent, WeakRef(ids)) + return ids +end + +risk__ids_properties__plugins__node() = risk__ids_properties__plugins__node{Float64}() + +mutable struct FilledFields____risk__ids_properties__plugins__infrastructure_put + var"commit"::Bool + var"description"::Bool + var"name"::Bool + var"repository"::Bool + var"version"::Bool +end + +mutable struct risk__ids_properties__plugins__infrastructure_put{T} <: IDS{T} + var"commit" :: String + var"description" :: String + var"name" :: String + var"repository" :: String + var"version" :: String + _filled::FilledFields____risk__ids_properties__plugins__infrastructure_put + _frozen::Bool + _threads_lock::ReentrantLock + _in_expression::Dict{Int,Vector{Symbol}} + _parent::WeakRef +end + +function risk__ids_properties__plugins__infrastructure_put{T}() where T + ids = risk__ids_properties__plugins__infrastructure_put{T}("", "", "", "", "", FilledFields____risk__ids_properties__plugins__infrastructure_put(false, false, false, false, false), false, ReentrantLock(), Dict{Int,Vector{Symbol}}(), WeakRef(nothing)) + return ids +end + +risk__ids_properties__plugins__infrastructure_put() = risk__ids_properties__plugins__infrastructure_put{Float64}() + +mutable struct FilledFields____risk__ids_properties__plugins__infrastructure_get + var"commit"::Bool + var"description"::Bool + var"name"::Bool + var"repository"::Bool + var"version"::Bool +end + +mutable struct risk__ids_properties__plugins__infrastructure_get{T} <: IDS{T} + var"commit" :: String + var"description" :: String + var"name" :: String + var"repository" :: String + var"version" :: String + _filled::FilledFields____risk__ids_properties__plugins__infrastructure_get + _frozen::Bool + _threads_lock::ReentrantLock + _in_expression::Dict{Int,Vector{Symbol}} + _parent::WeakRef +end + +function risk__ids_properties__plugins__infrastructure_get{T}() where T + ids = risk__ids_properties__plugins__infrastructure_get{T}("", "", "", "", "", FilledFields____risk__ids_properties__plugins__infrastructure_get(false, false, false, false, false), false, ReentrantLock(), Dict{Int,Vector{Symbol}}(), WeakRef(nothing)) + return ids +end + +risk__ids_properties__plugins__infrastructure_get() = risk__ids_properties__plugins__infrastructure_get{Float64}() + +mutable struct FilledFields____risk__ids_properties__plugins + var"infrastructure_get"::Bool + var"infrastructure_put"::Bool + var"node"::Bool +end + +mutable struct risk__ids_properties__plugins{T} <: IDS{T} + var"infrastructure_get"::risk__ids_properties__plugins__infrastructure_get{T} + var"infrastructure_put"::risk__ids_properties__plugins__infrastructure_put{T} + var"node"::IDSvector{risk__ids_properties__plugins__node{T}} + _filled::FilledFields____risk__ids_properties__plugins + _frozen::Bool + _threads_lock::ReentrantLock + _in_expression::Dict{Int,Vector{Symbol}} + _parent::WeakRef +end + +function risk__ids_properties__plugins{T}() where T + ids = risk__ids_properties__plugins{T}(risk__ids_properties__plugins__infrastructure_get{T}(), risk__ids_properties__plugins__infrastructure_put{T}(), IDSvector{risk__ids_properties__plugins__node{T}}(), FilledFields____risk__ids_properties__plugins(false, false, false), false, ReentrantLock(), Dict{Int,Vector{Symbol}}(), WeakRef(nothing)) + setfield!(ids.infrastructure_get, :_parent, WeakRef(ids)) + setfield!(ids.infrastructure_put, :_parent, WeakRef(ids)) + setfield!(ids.node, :_parent, WeakRef(ids)) + return ids +end + +risk__ids_properties__plugins() = risk__ids_properties__plugins{Float64}() + +mutable struct FilledFields____risk__ids_properties__occurrence_type + var"description"::Bool + var"index"::Bool + var"name"::Bool +end + +mutable struct risk__ids_properties__occurrence_type{T} <: IDS{T} + var"description" :: String + var"index" :: Int + var"name" :: String + _filled::FilledFields____risk__ids_properties__occurrence_type + _frozen::Bool + _threads_lock::ReentrantLock + _in_expression::Dict{Int,Vector{Symbol}} + _parent::WeakRef +end + +function risk__ids_properties__occurrence_type{T}() where T + ids = risk__ids_properties__occurrence_type{T}("", 0, "", FilledFields____risk__ids_properties__occurrence_type(false, false, false), false, ReentrantLock(), Dict{Int,Vector{Symbol}}(), WeakRef(nothing)) + return ids +end + +risk__ids_properties__occurrence_type() = risk__ids_properties__occurrence_type{Float64}() + +mutable struct FilledFields____risk__ids_properties + var"comment"::Bool + var"creation_date"::Bool + var"homogeneous_time"::Bool + var"name"::Bool + var"occurrence"::Bool + var"occurrence_type"::Bool + var"plugins"::Bool + var"provenance"::Bool + var"provider"::Bool + var"version_put"::Bool +end + +mutable struct risk__ids_properties{T} <: IDS{T} + var"comment" :: String + var"creation_date" :: String + var"homogeneous_time" :: Int + var"name" :: String + var"occurrence" :: Int + var"occurrence_type"::risk__ids_properties__occurrence_type{T} + var"plugins"::risk__ids_properties__plugins{T} + var"provenance"::risk__ids_properties__provenance{T} + var"provider" :: String + var"version_put"::risk__ids_properties__version_put{T} + _filled::FilledFields____risk__ids_properties + _frozen::Bool + _threads_lock::ReentrantLock + _in_expression::Dict{Int,Vector{Symbol}} + _parent::WeakRef +end + +function risk__ids_properties{T}() where T + ids = risk__ids_properties{T}("", "", 0, "", 0, risk__ids_properties__occurrence_type{T}(), risk__ids_properties__plugins{T}(), risk__ids_properties__provenance{T}(), "", risk__ids_properties__version_put{T}(), FilledFields____risk__ids_properties(false, false, false, false, false, false, false, false, false, false), false, ReentrantLock(), Dict{Int,Vector{Symbol}}(), WeakRef(nothing)) + setfield!(ids.occurrence_type, :_parent, WeakRef(ids)) + setfield!(ids.plugins, :_parent, WeakRef(ids)) + setfield!(ids.provenance, :_parent, WeakRef(ids)) + setfield!(ids.version_put, :_parent, WeakRef(ids)) + return ids +end + +risk__ids_properties() = risk__ids_properties{Float64}() + +mutable struct FilledFields____risk__engineering__loss___failure_mode + var"description"::Bool + var"probability"::Bool + var"probability_σ"::Bool + var"weight"::Bool + var"weight_σ"::Bool +end + +mutable struct risk__engineering__loss___failure_mode{T} <: IDSvectorStaticElement{T} + var"description" :: String + var"probability" :: T + var"probability_σ" :: T + var"weight" :: T + var"weight_σ" :: T + _filled::FilledFields____risk__engineering__loss___failure_mode + _frozen::Bool + _threads_lock::ReentrantLock + _in_expression::Dict{Int,Vector{Symbol}} + _parent::WeakRef +end + +function risk__engineering__loss___failure_mode{T}() where T + ids = risk__engineering__loss___failure_mode{T}("", 0.0, 0.0, 0.0, 0.0, FilledFields____risk__engineering__loss___failure_mode(false, false, false, false, false), false, ReentrantLock(), Dict{Int,Vector{Symbol}}(), WeakRef(nothing)) + return ids +end + +risk__engineering__loss___failure_mode() = risk__engineering__loss___failure_mode{Float64}() + +mutable struct FilledFields____risk__engineering__loss + var"description"::Bool + var"failure_mode"::Bool + var"probability"::Bool + var"probability_σ"::Bool + var"risk"::Bool + var"risk_σ"::Bool + var"severity"::Bool + var"severity_σ"::Bool +end + +mutable struct risk__engineering__loss{T} <: IDSvectorStaticElement{T} + var"description" :: String + var"failure_mode"::IDSvector{risk__engineering__loss___failure_mode{T}} + var"probability" :: T + var"probability_σ" :: T + var"risk" :: T + var"risk_σ" :: T + var"severity" :: T + var"severity_σ" :: T + _filled::FilledFields____risk__engineering__loss + _frozen::Bool + _threads_lock::ReentrantLock + _in_expression::Dict{Int,Vector{Symbol}} + _parent::WeakRef +end + +function risk__engineering__loss{T}() where T + ids = risk__engineering__loss{T}("", IDSvector{risk__engineering__loss___failure_mode{T}}(), 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, FilledFields____risk__engineering__loss(false, false, false, false, false, false, false, false), false, ReentrantLock(), Dict{Int,Vector{Symbol}}(), WeakRef(nothing)) + setfield!(ids.failure_mode, :_parent, WeakRef(ids)) + return ids +end + +risk__engineering__loss() = risk__engineering__loss{Float64}() + +mutable struct FilledFields____risk__engineering + var"loss"::Bool + var"risk"::Bool + var"risk_σ"::Bool +end + +mutable struct risk__engineering{T} <: IDS{T} + var"loss"::IDSvector{risk__engineering__loss{T}} + var"risk" :: T + var"risk_σ" :: T + _filled::FilledFields____risk__engineering + _frozen::Bool + _threads_lock::ReentrantLock + _in_expression::Dict{Int,Vector{Symbol}} + _parent::WeakRef +end + +function risk__engineering{T}() where T + ids = risk__engineering{T}(IDSvector{risk__engineering__loss{T}}(), 0.0, 0.0, FilledFields____risk__engineering(false, false, false), false, ReentrantLock(), Dict{Int,Vector{Symbol}}(), WeakRef(nothing)) + setfield!(ids.loss, :_parent, WeakRef(ids)) + return ids +end + +risk__engineering() = risk__engineering{Float64}() + +mutable struct FilledFields____risk__code__library + var"commit"::Bool + var"description"::Bool + var"name"::Bool + var"parameters"::Bool + var"repository"::Bool + var"version"::Bool +end + +mutable struct risk__code__library{T} <: IDSvectorStaticElement{T} + var"commit" :: String + var"description" :: String + var"name" :: String + var"parameters" :: String + var"repository" :: String + var"version" :: String + _filled::FilledFields____risk__code__library + _frozen::Bool + _threads_lock::ReentrantLock + _in_expression::Dict{Int,Vector{Symbol}} + _parent::WeakRef +end + +function risk__code__library{T}() where T + ids = risk__code__library{T}("", "", "", "", "", "", FilledFields____risk__code__library(false, false, false, false, false, false), false, ReentrantLock(), Dict{Int,Vector{Symbol}}(), WeakRef(nothing)) + return ids +end + +risk__code__library() = risk__code__library{Float64}() + +mutable struct FilledFields____risk__code + var"commit"::Bool + var"description"::Bool + var"library"::Bool + var"name"::Bool + var"output_flag"::Bool + var"parameters"::Bool + var"repository"::Bool + var"version"::Bool +end + +mutable struct risk__code{T} <: IDS{T} + var"commit" :: String + var"description" :: String + var"library"::IDSvector{risk__code__library{T}} + var"name" :: String + var"output_flag" :: Vector{Int} + var"parameters" :: String + var"repository" :: String + var"version" :: String + _filled::FilledFields____risk__code + _frozen::Bool + _threads_lock::ReentrantLock + _in_expression::Dict{Int,Vector{Symbol}} + _parent::WeakRef +end + +function risk__code{T}() where T + ids = risk__code{T}("", "", IDSvector{risk__code__library{T}}(), "", Int[], "", "", "", FilledFields____risk__code(false, false, false, false, false, false, false, false), false, ReentrantLock(), Dict{Int,Vector{Symbol}}(), WeakRef(nothing)) + setfield!(ids.library, :_parent, WeakRef(ids)) + return ids +end + +risk__code() = risk__code{Float64}() + +mutable struct FilledFields____risk + var"code"::Bool + var"engineering"::Bool + var"ids_properties"::Bool + var"plasma"::Bool + var"time"::Bool + var"total_risk"::Bool + var"total_risk_σ"::Bool +end + +mutable struct risk{T} <: IDStop{T} + var"code"::risk__code{T} + var"engineering"::risk__engineering{T} + var"ids_properties"::risk__ids_properties{T} + var"plasma"::risk__plasma{T} + var"time" :: Vector{Float64} + var"total_risk" :: T + var"total_risk_σ" :: T + _filled::FilledFields____risk + _frozen::Bool + _threads_lock::ReentrantLock + _in_expression::Dict{Int,Vector{Symbol}} + _parent::WeakRef +end + +function risk{T}() where T + ids = risk{T}(risk__code{T}(), risk__engineering{T}(), risk__ids_properties{T}(), risk__plasma{T}(), T[], 0.0, 0.0, FilledFields____risk(false, false, false, false, false, false, false), false, ReentrantLock(), Dict{Int,Vector{Symbol}}(), WeakRef(nothing)) + setfield!(ids.code, :_parent, WeakRef(ids)) + setfield!(ids.engineering, :_parent, WeakRef(ids)) + setfield!(ids.ids_properties, :_parent, WeakRef(ids)) + setfield!(ids.plasma, :_parent, WeakRef(ids)) + return ids +end + +risk() = risk{Float64}() + mutable struct FilledFields____requirements__ids_properties__version_put var"access_layer"::Bool var"access_layer_language"::Bool @@ -147763,6 +148377,7 @@ mutable struct FilledFields____dd var"reflectometer_profile"::Bool var"refractometer"::Bool var"requirements"::Bool + var"risk"::Bool var"runaway_electrons"::Bool var"sawteeth"::Bool var"soft_x_rays"::Bool @@ -147852,6 +148467,7 @@ mutable struct dd{T} <: DD{T} var"reflectometer_profile"::reflectometer_profile{T} var"refractometer"::refractometer{T} var"requirements"::requirements{T} + var"risk"::risk{T} var"runaway_electrons"::runaway_electrons{T} var"sawteeth"::sawteeth{T} var"soft_x_rays"::soft_x_rays{T} @@ -147880,7 +148496,7 @@ mutable struct dd{T} <: DD{T} end function dd{T}() where T - ids = dd{T}(amns_data{T}(), b_field_non_axisymmetric{T}(), balance_of_plant{T}(), barometry{T}(), blanket{T}(), bolometer{T}(), bremsstrahlung_visible{T}(), build{T}(), calorimetry{T}(), camera_ir{T}(), camera_visible{T}(), camera_x_rays{T}(), charge_exchange{T}(), coils_non_axisymmetric{T}(), controllers{T}(), core_instant_changes{T}(), core_profiles{T}(), core_sources{T}(), core_transport{T}(), costing{T}(), cryostat{T}(), dataset_description{T}(), dataset_fair{T}(), disruption{T}(), distribution_sources{T}(), distributions{T}(), divertors{T}(), ec_launchers{T}(), ece{T}(), edge_profiles{T}(), edge_sources{T}(), edge_transport{T}(), em_coupling{T}(), equilibrium{T}(), ferritic{T}(), focs{T}(), gas_injection{T}(), gas_pumping{T}(), gyrokinetics_local{T}(), hard_x_rays{T}(), ic_antennas{T}(), interferometer{T}(), iron_core{T}(), langmuir_probes{T}(), lh_antennas{T}(), limits{T}(), magnetics{T}(), mhd{T}(), mhd_linear{T}(), mse{T}(), nbi{T}(), neutron_diagnostic{T}(), neutronics{T}(), ntms{T}(), operational_instrumentation{T}(), pellets{T}(), pf_active{T}(), pf_passive{T}(), pf_plasma{T}(), plasma_initiation{T}(), polarimeter{T}(), pulse_schedule{T}(), radiation{T}(), real_time_data{T}(), reflectometer_fluctuation{T}(), reflectometer_profile{T}(), refractometer{T}(), requirements{T}(), runaway_electrons{T}(), sawteeth{T}(), soft_x_rays{T}(), solid_mechanics{T}(), spectrometer_mass{T}(), spectrometer_uv{T}(), spectrometer_visible{T}(), spectrometer_x_ray_crystal{T}(), spi{T}(), summary{T}(), temporary{T}(), tf{T}(), thomson_scattering{T}(), transport_solver_numerics{T}(), turbulence{T}(), wall{T}(), waves{T}(), workflow{T}(), 0.0, Dict(), FilledFields____dd(false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false), false, ReentrantLock(), Dict{Int,Vector{Symbol}}(), WeakRef(nothing)) + ids = dd{T}(amns_data{T}(), b_field_non_axisymmetric{T}(), balance_of_plant{T}(), barometry{T}(), blanket{T}(), bolometer{T}(), bremsstrahlung_visible{T}(), build{T}(), calorimetry{T}(), camera_ir{T}(), camera_visible{T}(), camera_x_rays{T}(), charge_exchange{T}(), coils_non_axisymmetric{T}(), controllers{T}(), core_instant_changes{T}(), core_profiles{T}(), core_sources{T}(), core_transport{T}(), costing{T}(), cryostat{T}(), dataset_description{T}(), dataset_fair{T}(), disruption{T}(), distribution_sources{T}(), distributions{T}(), divertors{T}(), ec_launchers{T}(), ece{T}(), edge_profiles{T}(), edge_sources{T}(), edge_transport{T}(), em_coupling{T}(), equilibrium{T}(), ferritic{T}(), focs{T}(), gas_injection{T}(), gas_pumping{T}(), gyrokinetics_local{T}(), hard_x_rays{T}(), ic_antennas{T}(), interferometer{T}(), iron_core{T}(), langmuir_probes{T}(), lh_antennas{T}(), limits{T}(), magnetics{T}(), mhd{T}(), mhd_linear{T}(), mse{T}(), nbi{T}(), neutron_diagnostic{T}(), neutronics{T}(), ntms{T}(), operational_instrumentation{T}(), pellets{T}(), pf_active{T}(), pf_passive{T}(), pf_plasma{T}(), plasma_initiation{T}(), polarimeter{T}(), pulse_schedule{T}(), radiation{T}(), real_time_data{T}(), reflectometer_fluctuation{T}(), reflectometer_profile{T}(), refractometer{T}(), requirements{T}(), risk{T}(), runaway_electrons{T}(), sawteeth{T}(), soft_x_rays{T}(), solid_mechanics{T}(), spectrometer_mass{T}(), spectrometer_uv{T}(), spectrometer_visible{T}(), spectrometer_x_ray_crystal{T}(), spi{T}(), summary{T}(), temporary{T}(), tf{T}(), thomson_scattering{T}(), transport_solver_numerics{T}(), turbulence{T}(), wall{T}(), waves{T}(), workflow{T}(), 0.0, Dict(), FilledFields____dd(false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false), false, ReentrantLock(), Dict{Int,Vector{Symbol}}(), WeakRef(nothing)) setfield!(ids.amns_data, :_parent, WeakRef(ids)) setfield!(ids.b_field_non_axisymmetric, :_parent, WeakRef(ids)) setfield!(ids.balance_of_plant, :_parent, WeakRef(ids)) @@ -147949,6 +148565,7 @@ function dd{T}() where T setfield!(ids.reflectometer_profile, :_parent, WeakRef(ids)) setfield!(ids.refractometer, :_parent, WeakRef(ids)) setfield!(ids.requirements, :_parent, WeakRef(ids)) + setfield!(ids.risk, :_parent, WeakRef(ids)) setfield!(ids.runaway_electrons, :_parent, WeakRef(ids)) setfield!(ids.sawteeth, :_parent, WeakRef(ids)) setfield!(ids.soft_x_rays, :_parent, WeakRef(ids)) @@ -152589,7 +153206,7 @@ const _all_info = Dict{String,Info}( "costing.ids_properties.version_put.access_layer" => Info{Tuple{}}((), "-", "STR_0D", "Version of Access Layer used to PUT this IDS", true, String[]), "costing.ids_properties.version_put.access_layer_language" => Info{Tuple{}}((), "-", "STR_0D", "Programming language of the Access Layer high level API used to PUT this IDS", true, String[]), "costing.ids_properties.version_put.data_dictionary" => Info{Tuple{}}((), "-", "STR_0D", "Version of Data Dictionary used to PUT this IDS", true, String[]), -"costing.levelized_CoE" => Info{Tuple{}}((), "\$/kWh", "FLT_0D", "Levelized cost of electiricity (total cost / total electricy generated)", true, String[]), +"costing.levelized_CoE" => Info{Tuple{}}((), "\$/kWh", "FLT_0D", "Levelized cost of electiricity (total cost / total electricity generated)", true, String[]), "costing.levelized_CoE_σ" => Info{Tuple{}}((), "\$/kWh", "FLT_0D", "error of costing.levelized_CoE", true, String[]), "costing.plant_lifetime" => Info{Tuple{}}((), "year", "FLT_0D", "Lifetime of the plant", true, String[]), "costing.plant_lifetime_σ" => Info{Tuple{}}((), "year", "FLT_0D", "error of costing.plant_lifetime", true, String[]), @@ -167635,6 +168252,115 @@ const _all_info = Dict{String,Info}( "requirements.time" => Info{Tuple{String}}(("1...N",), "s", "FLT_1D", "Generic time", true, String[]), "requirements.tritium_breeding_ratio" => Info{Tuple{}}((), "-", "FLT_0D", "Tritium breeding ratio of the whole plant", true, String[]), "requirements.tritium_breeding_ratio_σ" => Info{Tuple{}}((), "-", "FLT_0D", "error of requirements.tritium_breeding_ratio", true, String[]), +"risk" => Info{Tuple{}}((), "-", "STRUCTURE", "Risk quantification of plasma and engineering components", true, String[]), +"risk.code" => Info{Tuple{}}((), "-", "STRUCTURE", "Generic decription of the code-specific parameters for the code that has produced this IDS", true, String[]), +"risk.code.commit" => Info{Tuple{}}((), "-", "STR_0D", "Unique commit reference of software", true, String[]), +"risk.code.description" => Info{Tuple{}}((), "-", "STR_0D", "Short description of the software (type, purpose)", true, String[]), +"risk.code.library[:]" => Info{Tuple{String}}(("1...N",), "-", "STRUCT_ARRAY", "List of external libraries used by the code that has produced this IDS", true, String[]), +"risk.code.library[:].commit" => Info{Tuple{}}((), "-", "STR_0D", "Unique commit reference of software", true, String[]), +"risk.code.library[:].description" => Info{Tuple{}}((), "-", "STR_0D", "Short description of the software (type, purpose)", true, String[]), +"risk.code.library[:].name" => Info{Tuple{}}((), "-", "STR_0D", "Name of software", true, String[]), +"risk.code.library[:].parameters" => Info{Tuple{}}((), "-", "STR_0D", "List of the code specific parameters in XML format", true, String[]), +"risk.code.library[:].repository" => Info{Tuple{}}((), "-", "STR_0D", "URL of software repository", true, String[]), +"risk.code.library[:].version" => Info{Tuple{}}((), "-", "STR_0D", "Unique version (tag) of software", true, String[]), +"risk.code.name" => Info{Tuple{}}((), "-", "STR_0D", "Name of software generating IDS", true, String[]), +"risk.code.output_flag" => Info{Tuple{String}}(("equilibrium.time",), "-", "INT_1D", "Output flag : 0 means the run is successful, other values mean some difficulty has been encountered, the exact meaning is then code specific. Negative values mean the result shall not be used.", true, String[]), +"risk.code.parameters" => Info{Tuple{}}((), "-", "STR_0D", "List of the code specific parameters in XML format", true, String[]), +"risk.code.repository" => Info{Tuple{}}((), "-", "STR_0D", "URL of software repository", true, String[]), +"risk.code.version" => Info{Tuple{}}((), "-", "STR_0D", "Unique version (tag) of software", true, String[]), +"risk.engineering" => Info{Tuple{}}((), "-", "STRUCTURE", "", true, String[]), +"risk.engineering.loss[:]" => Info{Tuple{String}}(("1...N",), "-", "STRUCT_ARRAY", "List of engineering-related losses", true, String[]), +"risk.engineering.loss[:].description" => Info{Tuple{}}((), "-", "STR_0D", "Description of loss channel", true, String[]), +"risk.engineering.loss[:].failure_mode[:]" => Info{Tuple{String}}(("1...N",), "-", "STRUCT_ARRAY", "List of failure modes associated to a particular loss", true, String[]), +"risk.engineering.loss[:].failure_mode[:].description" => Info{Tuple{}}((), "-", "STR_0D", "Description of failure mode", true, String[]), +"risk.engineering.loss[:].failure_mode[:].probability" => Info{Tuple{}}((), "-", "FLT_0D", "Probability of failure mode", true, String[]), +"risk.engineering.loss[:].failure_mode[:].probability_σ" => Info{Tuple{}}((), "-", "FLT_0D", "error of risk.engineering.loss[:].failure_mode[:].probability", true, String[]), +"risk.engineering.loss[:].failure_mode[:].weight" => Info{Tuple{}}((), "-", "FLT_0D", "Weight associated to failure mode", true, String[]), +"risk.engineering.loss[:].failure_mode[:].weight_σ" => Info{Tuple{}}((), "-", "FLT_0D", "error of risk.engineering.loss[:].failure_mode[:].weight", true, String[]), +"risk.engineering.loss[:].probability" => Info{Tuple{}}((), "-", "FLT_0D", "Probability of failure", true, String[]), +"risk.engineering.loss[:].probability_σ" => Info{Tuple{}}((), "-", "FLT_0D", "error of risk.engineering.loss[:].probability", true, String[]), +"risk.engineering.loss[:].risk" => Info{Tuple{}}((), "-", "FLT_0D", "Product of loss probability and severity", true, String[]), +"risk.engineering.loss[:].risk_σ" => Info{Tuple{}}((), "-", "FLT_0D", "error of risk.engineering.loss[:].risk", true, String[]), +"risk.engineering.loss[:].severity" => Info{Tuple{}}((), "M\$", "FLT_0D", "Severity of failure", true, String[]), +"risk.engineering.loss[:].severity_σ" => Info{Tuple{}}((), "M\$", "FLT_0D", "error of risk.engineering.loss[:].severity", true, String[]), +"risk.engineering.risk" => Info{Tuple{}}((), "M\$", "FLT_0D", "Total engineering risk", true, String[]), +"risk.engineering.risk_σ" => Info{Tuple{}}((), "M\$", "FLT_0D", "error of risk.engineering.risk", true, String[]), +"risk.ids_properties" => Info{Tuple{}}((), "-", "STRUCTURE", "Interface Data Structure properties. This element identifies the node above as an IDS", true, String[]), +"risk.ids_properties.comment" => Info{Tuple{}}((), "-", "STR_0D", "Any comment describing the content of this IDS", true, String[]), +"risk.ids_properties.creation_date" => Info{Tuple{}}((), "-", "STR_0D", "Date at which this data has been produced", true, String[]), +"risk.ids_properties.homogeneous_time" => Info{Tuple{}}((), "-", "INT_0D", "This node must be filled (with 0, 1, or 2) for the IDS to be valid. If 1, the time of this IDS is homogeneous, i.e. the time values for this IDS are stored in the time node just below the root of this IDS. If 0, the time values are stored in the various time fields at lower levels in the tree. In the case only constant or static nodes are filled within the IDS, homogeneous_time must be set to 2", true, String[]), +"risk.ids_properties.name" => Info{Tuple{}}((), "-", "STR_0D", "User-defined name for this IDS occurrence", true, String[]), +"risk.ids_properties.occurrence" => Info{Tuple{}}((), "-", "INT_0D", "", true, String[]), +"risk.ids_properties.occurrence_type" => Info{Tuple{}}((), "-", "STRUCTURE", "Type of data contained in this occurrence\n1) reconstruction : Equilibrium reconstruction\n2) prediction_fixed : Equilibrium prediction, fixed boundary\n3) prediction_free : Equilibrium prediction, free boundary\n4) mapping : Used for mapping risk results from one grid type / resolution to another, or for including variables not present in the first set such as the calculation of magnetic field of other derived parameters", true, String[]), +"risk.ids_properties.occurrence_type.description" => Info{Tuple{}}((), "-", "STR_0D", "Verbose description", true, String[]), +"risk.ids_properties.occurrence_type.index" => Info{Tuple{}}((), "-", "INT_0D", "Integer identifier (enumeration index within a list). Private identifier values must be indicated by a negative index.", true, String[]), +"risk.ids_properties.occurrence_type.name" => Info{Tuple{}}((), "-", "STR_0D", "Short string identifier", true, String[]), +"risk.ids_properties.plugins" => Info{Tuple{}}((), "-", "STRUCTURE", "Information about the plugins used to write/read this IDS. This structure is filled automatically by the Access Layer at GET/PUT time, no need to fill it via a user program.", true, String[]), +"risk.ids_properties.plugins.infrastructure_get" => Info{Tuple{}}((), "-", "STRUCTURE", "Plugin infrastructure used to GET the data", true, String[]), +"risk.ids_properties.plugins.infrastructure_get.commit" => Info{Tuple{}}((), "-", "STR_0D", "Unique commit reference of software", true, String[]), +"risk.ids_properties.plugins.infrastructure_get.description" => Info{Tuple{}}((), "-", "STR_0D", "Short description of the software (type, purpose)", true, String[]), +"risk.ids_properties.plugins.infrastructure_get.name" => Info{Tuple{}}((), "-", "STR_0D", "Name of software used", true, String[]), +"risk.ids_properties.plugins.infrastructure_get.repository" => Info{Tuple{}}((), "-", "STR_0D", "URL of software repository", true, String[]), +"risk.ids_properties.plugins.infrastructure_get.version" => Info{Tuple{}}((), "-", "STR_0D", "Unique version (tag) of software", true, String[]), +"risk.ids_properties.plugins.infrastructure_put" => Info{Tuple{}}((), "-", "STRUCTURE", "Plugin infrastructure used to PUT the data", true, String[]), +"risk.ids_properties.plugins.infrastructure_put.commit" => Info{Tuple{}}((), "-", "STR_0D", "Unique commit reference of software", true, String[]), +"risk.ids_properties.plugins.infrastructure_put.description" => Info{Tuple{}}((), "-", "STR_0D", "Short description of the software (type, purpose)", true, String[]), +"risk.ids_properties.plugins.infrastructure_put.name" => Info{Tuple{}}((), "-", "STR_0D", "Name of software used", true, String[]), +"risk.ids_properties.plugins.infrastructure_put.repository" => Info{Tuple{}}((), "-", "STR_0D", "URL of software repository", true, String[]), +"risk.ids_properties.plugins.infrastructure_put.version" => Info{Tuple{}}((), "-", "STR_0D", "Unique version (tag) of software", true, String[]), +"risk.ids_properties.plugins.node[:]" => Info{Tuple{String}}(("1...N",), "-", "STRUCT_ARRAY", "Set of IDS nodes for which a plugin has been applied", true, String[]), +"risk.ids_properties.plugins.node[:].get_operation[:]" => Info{Tuple{String}}(("1...N",), "-", "STRUCT_ARRAY", "Plugins actually used to read back a node (potentially, multiple plugins can be applied, listed in reverse order of application). This information is filled by the plugin infrastructure during the GET operation.", true, String[]), +"risk.ids_properties.plugins.node[:].get_operation[:].commit" => Info{Tuple{}}((), "-", "STR_0D", "Unique commit reference of software", true, String[]), +"risk.ids_properties.plugins.node[:].get_operation[:].description" => Info{Tuple{}}((), "-", "STR_0D", "Short description of the software (type, purpose)", true, String[]), +"risk.ids_properties.plugins.node[:].get_operation[:].name" => Info{Tuple{}}((), "-", "STR_0D", "Name of software used", true, String[]), +"risk.ids_properties.plugins.node[:].get_operation[:].parameters" => Info{Tuple{}}((), "-", "STR_0D", "List of the code specific parameters in XML format", true, String[]), +"risk.ids_properties.plugins.node[:].get_operation[:].repository" => Info{Tuple{}}((), "-", "STR_0D", "URL of software repository", true, String[]), +"risk.ids_properties.plugins.node[:].get_operation[:].version" => Info{Tuple{}}((), "-", "STR_0D", "Unique version (tag) of software", true, String[]), +"risk.ids_properties.plugins.node[:].path" => Info{Tuple{}}((), "-", "STR_0D", "Path of the node within the IDS, following the syntax given in the link below. If empty, means the plugin applies to the whole IDS.", true, String[]), +"risk.ids_properties.plugins.node[:].put_operation[:]" => Info{Tuple{String}}(("1...N",), "-", "STRUCT_ARRAY", "Plugins used to PUT a node (potentially, multiple plugins can be applied, if so they are listed by order of application)", true, String[]), +"risk.ids_properties.plugins.node[:].put_operation[:].commit" => Info{Tuple{}}((), "-", "STR_0D", "Unique commit reference of software", true, String[]), +"risk.ids_properties.plugins.node[:].put_operation[:].description" => Info{Tuple{}}((), "-", "STR_0D", "Short description of the software (type, purpose)", true, String[]), +"risk.ids_properties.plugins.node[:].put_operation[:].name" => Info{Tuple{}}((), "-", "STR_0D", "Name of software used", true, String[]), +"risk.ids_properties.plugins.node[:].put_operation[:].parameters" => Info{Tuple{}}((), "-", "STR_0D", "List of the code specific parameters in XML format", true, String[]), +"risk.ids_properties.plugins.node[:].put_operation[:].repository" => Info{Tuple{}}((), "-", "STR_0D", "URL of software repository", true, String[]), +"risk.ids_properties.plugins.node[:].put_operation[:].version" => Info{Tuple{}}((), "-", "STR_0D", "Unique version (tag) of software", true, String[]), +"risk.ids_properties.plugins.node[:].readback[:]" => Info{Tuple{String}}(("1...N",), "-", "STRUCT_ARRAY", "Plugins to be used to read back a node (potentially, multiple plugins can be applied, listed in reverse order of application) ", true, String[]), +"risk.ids_properties.plugins.node[:].readback[:].commit" => Info{Tuple{}}((), "-", "STR_0D", "Unique commit reference of software", true, String[]), +"risk.ids_properties.plugins.node[:].readback[:].description" => Info{Tuple{}}((), "-", "STR_0D", "Short description of the software (type, purpose)", true, String[]), +"risk.ids_properties.plugins.node[:].readback[:].name" => Info{Tuple{}}((), "-", "STR_0D", "Name of software used", true, String[]), +"risk.ids_properties.plugins.node[:].readback[:].parameters" => Info{Tuple{}}((), "-", "STR_0D", "List of the code specific parameters in XML format", true, String[]), +"risk.ids_properties.plugins.node[:].readback[:].repository" => Info{Tuple{}}((), "-", "STR_0D", "URL of software repository", true, String[]), +"risk.ids_properties.plugins.node[:].readback[:].version" => Info{Tuple{}}((), "-", "STR_0D", "Unique version (tag) of software", true, String[]), +"risk.ids_properties.provenance" => Info{Tuple{}}((), "-", "STRUCTURE", "Provenance information about this IDS", true, String[]), +"risk.ids_properties.provenance.node[:]" => Info{Tuple{String}}(("1...N",), "-", "STRUCT_ARRAY", "Set of IDS nodes for which the provenance is given. The provenance information applies to the whole structure below the IDS node. For documenting provenance information for the whole IDS, set the size of this array of structure to 1 and leave the child \"path\" node empty", true, String[]), +"risk.ids_properties.provenance.node[:].path" => Info{Tuple{}}((), "-", "STR_0D", "Path of the node within the IDS, following the syntax given in the link below. If empty, means the provenance information applies to the whole IDS.", true, String[]), +"risk.ids_properties.provenance.node[:].sources" => Info{Tuple{String}}(("1...N",), "-", "STR_1D", "List of sources used to import or calculate this node, identified as explained below. In case the node is the result of of a calculation / data processing, the source is an input to the process described in the \"code\" structure at the root of the IDS. The source can be an IDS (identified by a URI or a persitent identifier, see syntax in the link below) or non-IDS data imported directly from an non-IMAS database (identified by the command used to import the source, or the persistent identifier of the data source). Often data are obtained by a chain of processes, however only the last process input are recorded here. The full chain of provenance has then to be reconstructed recursively from the provenance information contained in the data sources.", true, String[]), +"risk.ids_properties.provider" => Info{Tuple{}}((), "-", "STR_0D", "Name of the person in charge of producing this data", true, String[]), +"risk.ids_properties.version_put" => Info{Tuple{}}((), "-", "STRUCTURE", "Version of the access layer package used to PUT this IDS", true, String[]), +"risk.ids_properties.version_put.access_layer" => Info{Tuple{}}((), "-", "STR_0D", "Version of Access Layer used to PUT this IDS", true, String[]), +"risk.ids_properties.version_put.access_layer_language" => Info{Tuple{}}((), "-", "STR_0D", "Programming language of the Access Layer high level API used to PUT this IDS", true, String[]), +"risk.ids_properties.version_put.data_dictionary" => Info{Tuple{}}((), "-", "STR_0D", "Version of Data Dictionary used to PUT this IDS", true, String[]), +"risk.plasma" => Info{Tuple{}}((), "-", "STRUCTURE", "", true, String[]), +"risk.plasma.loss[:]" => Info{Tuple{String}}(("1...N",), "-", "STRUCT_ARRAY", "List of plasma-related losses", true, String[]), +"risk.plasma.loss[:].description" => Info{Tuple{}}((), "-", "STR_0D", "Description of loss channel", true, String[]), +"risk.plasma.loss[:].probability" => Info{Tuple{}}((), "-", "FLT_0D", "Probability of failure", true, String[]), +"risk.plasma.loss[:].probability_σ" => Info{Tuple{}}((), "-", "FLT_0D", "error of risk.plasma.loss[:].probability", true, String[]), +"risk.plasma.loss[:].risk" => Info{Tuple{}}((), "\$/kWh", "FLT_0D", "Product of loss probability and severity", true, String[]), +"risk.plasma.loss[:].risk_σ" => Info{Tuple{}}((), "\$/kWh", "FLT_0D", "error of risk.plasma.loss[:].risk", true, String[]), +"risk.plasma.risk" => Info{Tuple{}}((), "\$/kWh", "FLT_0D", "Total plasma risk", true, String[]), +"risk.plasma.risk_σ" => Info{Tuple{}}((), "\$/kWh", "FLT_0D", "error of risk.plasma.risk", true, String[]), +"risk.plasma.severity" => Info{Tuple{}}((), "-", "STRUCTURE", "", true, String[]), +"risk.plasma.severity.average_severity" => Info{Tuple{}}((), "-", "FLT_0D", "Average severity of disruption-induced events", true, String[]), +"risk.plasma.severity.average_severity_σ" => Info{Tuple{}}((), "-", "FLT_0D", "error of risk.plasma.severity.average_severity", true, String[]), +"risk.plasma.severity.current_quench" => Info{Tuple{}}((), "-", "FLT_0D", "Severity of disruption-induced current quench", true, String[]), +"risk.plasma.severity.current_quench_σ" => Info{Tuple{}}((), "-", "FLT_0D", "error of risk.plasma.severity.current_quench", true, String[]), +"risk.plasma.severity.thermal_quench" => Info{Tuple{}}((), "-", "FLT_0D", "Severity of disruption-induced thermal quench", true, String[]), +"risk.plasma.severity.thermal_quench_σ" => Info{Tuple{}}((), "-", "FLT_0D", "error of risk.plasma.severity.thermal_quench", true, String[]), +"risk.plasma.severity.vertical_forces" => Info{Tuple{}}((), "-", "FLT_0D", "Severity of disruption-induced vertical forces", true, String[]), +"risk.plasma.severity.vertical_forces_σ" => Info{Tuple{}}((), "-", "FLT_0D", "error of risk.plasma.severity.vertical_forces", true, String[]), +"risk.time" => Info{Tuple{String}}(("1...N",), "s", "FLT_1D", "Generic time", true, String[]), +"risk.total_risk" => Info{Tuple{}}((), "-", "FLT_0D", "Sum of risks", true, String[]), +"risk.total_risk_σ" => Info{Tuple{}}((), "-", "FLT_0D", "error of risk.total_risk", true, String[]), "runaway_electrons" => Info{Tuple{}}((), "-", "STRUCTURE", "Description of runaway electrons", false, String[]), "runaway_electrons.code" => Info{Tuple{}}((), "-", "STRUCTURE", "Generic decription of the code-specific parameters for the code that has produced this IDS", false, String[]), "runaway_electrons.code.commit" => Info{Tuple{}}((), "-", "STR_0D", "Unique commit reference of software", false, String[]),