Module olca.schema
Expand source code
# DO NOT CHANGE THIS CODE AS THIS IS GENERATED AUTOMATICALLY
# This module contains a Python API of the JSON-LD based
# openLCA data exchange model.package schema.
# For more information see http://greendelta.github.io/olca-schema/
from __future__ import annotations
import json as jsonlib
from dataclasses import dataclass
from enum import Enum
from typing import List, Optional
class AllocationType(Enum):
"""
An enumeration type for allocation methods. This type is used to define the
type of an [AllocationFactor], the default allocation method of a
multi-functional [Process], or the allocation method in a
[CalculationSetup].
"""
PHYSICAL_ALLOCATION = 'PHYSICAL_ALLOCATION'
ECONOMIC_ALLOCATION = 'ECONOMIC_ALLOCATION'
CAUSAL_ALLOCATION = 'CAUSAL_ALLOCATION'
USE_DEFAULT_ALLOCATION = 'USE_DEFAULT_ALLOCATION'
NO_ALLOCATION = 'NO_ALLOCATION'
class CalculationType(Enum):
"""
An enumeration of the different calculation methods supported by openLCA.
"""
SIMPLE_CALCULATION = 'SIMPLE_CALCULATION'
"""
Calculates the total results for elementary flows, LCIA indicators, costs,
etc. of a product system.
"""
CONTRIBUTION_ANALYSIS = 'CONTRIBUTION_ANALYSIS'
"""
Includes the total result vectors of a simple calculation but calculates
also the direct contributions of each process (or better process product in
case of multi-output processes) to these total results.
"""
UPSTREAM_ANALYSIS = 'UPSTREAM_ANALYSIS'
"""
Extends the contribution analysis by providing also the upstream results of
each process (process product) in the product system. The upstream result
contains the direct contributions of the respective process but also the
result of the supply chain up to this process scaled to the demand of the
process in the product system.
"""
REGIONALIZED_CALCULATION = 'REGIONALIZED_CALCULATION'
"""
A regionalized calculation is a contribution analysis but with an LCIA
method that supports regionalized characterization factors (via region
specific parameters in formulas) and a product system with processes that
have geographic information assigned (point, line, or polygon shapes).
"""
MONTE_CARLO_SIMULATION = 'MONTE_CARLO_SIMULATION'
"""
A Monte Carlo simulation generates for each run, of a given number of a
given number of iterations, random values according to the uncertainty
distributions of process inputs/outputs, parameters, characterization
factors, etc. of a product system and then performs a simple calculation
for that specific run.
"""
class FlowPropertyType(Enum):
"""
An enumeration of flow property types.
"""
ECONOMIC_QUANTITY = 'ECONOMIC_QUANTITY'
PHYSICAL_QUANTITY = 'PHYSICAL_QUANTITY'
class FlowType(Enum):
"""
The basic flow types.
"""
ELEMENTARY_FLOW = 'ELEMENTARY_FLOW'
PRODUCT_FLOW = 'PRODUCT_FLOW'
WASTE_FLOW = 'WASTE_FLOW'
class ModelType(Enum):
"""
An enumeration of the root entity types.
"""
ACTOR = 'ACTOR'
CATEGORY = 'CATEGORY'
CURRENCY = 'CURRENCY'
DQ_SYSTEM = 'DQ_SYSTEM'
FLOW = 'FLOW'
FLOW_PROPERTY = 'FLOW_PROPERTY'
IMPACT_CATEGORY = 'IMPACT_CATEGORY'
IMPACT_METHOD = 'IMPACT_METHOD'
LOCATION = 'LOCATION'
NW_SET = 'NW_SET'
PARAMETER = 'PARAMETER'
PROCESS = 'PROCESS'
PRODUCT_SYSTEM = 'PRODUCT_SYSTEM'
PROJECT = 'PROJECT'
SOCIAL_INDICATOR = 'SOCIAL_INDICATOR'
SOURCE = 'SOURCE'
UNIT = 'UNIT'
UNIT_GROUP = 'UNIT_GROUP'
class ParameterScope(Enum):
"""
The possible scopes of parameters. Parameters can be defined globally, in
processes, or impact categories. They can be redefined in calculation
setups on the project and product system level, but the initial definition
is always only global, in a process, or an LCIA category.
"""
PROCESS_SCOPE = 'PROCESS_SCOPE'
"""
Indicates that the evaluation scope of a parameter is the process where it
is defined.
"""
IMPACT_SCOPE = 'IMPACT_SCOPE'
"""
Indicates that the evaluation scope of a parameter is the impact category
where it is defined.
"""
GLOBAL_SCOPE = 'GLOBAL_SCOPE'
"""
Indicates that the evaluation scope of a parameter is the global scope.
"""
class ProcessType(Enum):
LCI_RESULT = 'LCI_RESULT'
UNIT_PROCESS = 'UNIT_PROCESS'
class RiskLevel(Enum):
"""
"""
NO_OPPORTUNITY = 'NO_OPPORTUNITY'
HIGH_OPPORTUNITY = 'HIGH_OPPORTUNITY'
MEDIUM_OPPORTUNITY = 'MEDIUM_OPPORTUNITY'
LOW_OPPORTUNITY = 'LOW_OPPORTUNITY'
NO_RISK = 'NO_RISK'
VERY_LOW_RISK = 'VERY_LOW_RISK'
LOW_RISK = 'LOW_RISK'
MEDIUM_RISK = 'MEDIUM_RISK'
HIGH_RISK = 'HIGH_RISK'
VERY_HIGH_RISK = 'VERY_HIGH_RISK'
NO_DATA = 'NO_DATA'
NOT_APPLICABLE = 'NOT_APPLICABLE'
class UncertaintyType(Enum):
"""
Enumeration of uncertainty distribution types that can be used in
exchanges, parameters, LCIA factors, etc.
"""
LOG_NORMAL_DISTRIBUTION = 'LOG_NORMAL_DISTRIBUTION'
NORMAL_DISTRIBUTION = 'NORMAL_DISTRIBUTION'
TRIANGLE_DISTRIBUTION = 'TRIANGLE_DISTRIBUTION'
UNIFORM_DISTRIBUTION = 'UNIFORM_DISTRIBUTION'
@dataclass
class Entity(object):
"""
The most generic type of the openLCA data model.
"""
id: str = ''
olca_type: str = ''
def _repr_html_(self):
code = jsonlib.dumps(self.to_json(), indent=2, sort_keys=True)
if len(code) > 10000:
code = code[0:10000] + '...'
return f'<pre><code class="language-json">{code}</code></pre>'
def to_json(self) -> dict:
o_type = self.olca_type
if o_type is None:
o_type = type(self).__name__
json = {'@type': o_type}
if self.id is not None:
json['@id'] = self.id
return json
def read_json(self, json: dict):
self.id = json.get('@id')
self.olca_type = json.get('@type')
@staticmethod
def from_json(json: dict):
instance = Entity()
instance.read_json(json)
return instance
@dataclass
class AllocationFactor(Entity):
"""
A single allocation factor in a process.
Attributes
----------
allocation_type: AllocationType
The type of allocation.
product: Ref
The output product (or waste input) to which this allocation factor is
related. The must be an exchange with this product output (or waste
input) in this process.
value: float
The value of the allocation factor.
formula: str
An optional formula from which the value of the allocation factor is
calculated.
exchange: ExchangeRef
A product input, waste output, or elementary flow exchange which is
allocated by this factor. This is only valid for causal allocation
where allocation factors can be assigned to single exchanges.
"""
olca_type: str = 'AllocationFactor'
allocation_type: Optional[AllocationType] = None
product: Optional[Ref] = None
value: Optional[float] = None
formula: Optional[str] = None
exchange: Optional[ExchangeRef] = None
def to_json(self) -> dict:
json: dict = super(AllocationFactor, self).to_json()
if self.allocation_type is not None:
json['allocationType'] = self.allocation_type.value
if self.product is not None:
json['product'] = self.product.to_json()
if self.value is not None:
json['value'] = self.value
if self.formula is not None:
json['formula'] = self.formula
if self.exchange is not None:
json['exchange'] = self.exchange.to_json()
return json
def read_json(self, json: dict):
super(AllocationFactor, self).read_json(json)
val = json.get('allocationType')
if val is not None:
self.allocation_type = AllocationType(val)
val = json.get('product')
if val is not None:
self.product = Ref()
self.product.read_json(val)
val = json.get('value')
if val is not None:
self.value = val
val = json.get('formula')
if val is not None:
self.formula = val
val = json.get('exchange')
if val is not None:
self.exchange = ExchangeRef()
self.exchange.read_json(val)
@staticmethod
def from_json(json: dict):
instance = AllocationFactor()
instance.read_json(json)
return instance
@dataclass
class CalculationSetup(Entity):
"""
A setup for a product system calculation.
Attributes
----------
calculation_type: CalculationType
The type of calculation that should be performed.
product_system: Ref
The product system that should be calculated (required).
impact_method: Ref
The LCIA method for the calculation (optional).
with_costs: bool
Indicates whether life cycle costs should be also calculated
(optional).
with_regionalization: bool
Indicates whether a regionalized result should be calculated or not. If
this is set to true, the intervention matrix is indexed by (elementary
flow, location) - pairs instead of just elementary flows. The LCI
result then contains results for these pairs which can be then used in
regionalized impact assessments.
nw_set: Ref
The normalisation and weighting set for the calculation (optional).
allocation_method: AllocationType
The calculation type to be used in the calculation (optional).
parameter_redefs: List[ParameterRedef]
A list of parameter redefinitions to be used in the calculation
(optional).
amount: float
(optional)
unit: Ref
(optional)
flow_property: Ref
(optional)
"""
olca_type: str = 'CalculationSetup'
calculation_type: Optional[CalculationType] = None
product_system: Optional[Ref] = None
impact_method: Optional[Ref] = None
with_costs: Optional[bool] = None
with_regionalization: Optional[bool] = None
nw_set: Optional[Ref] = None
allocation_method: Optional[AllocationType] = None
parameter_redefs: Optional[List[ParameterRedef]] = None
amount: Optional[float] = None
unit: Optional[Ref] = None
flow_property: Optional[Ref] = None
def to_json(self) -> dict:
json: dict = super(CalculationSetup, self).to_json()
if self.calculation_type is not None:
json['calculationType'] = self.calculation_type.value
if self.product_system is not None:
json['productSystem'] = self.product_system.to_json()
if self.impact_method is not None:
json['impactMethod'] = self.impact_method.to_json()
if self.with_costs is not None:
json['withCosts'] = self.with_costs
if self.with_regionalization is not None:
json['withRegionalization'] = self.with_regionalization
if self.nw_set is not None:
json['nwSet'] = self.nw_set.to_json()
if self.allocation_method is not None:
json['allocationMethod'] = self.allocation_method.value
if self.parameter_redefs is not None:
json['parameterRedefs'] = []
for e in self.parameter_redefs:
json['parameterRedefs'].append(e.to_json())
if self.amount is not None:
json['amount'] = self.amount
if self.unit is not None:
json['unit'] = self.unit.to_json()
if self.flow_property is not None:
json['flowProperty'] = self.flow_property.to_json()
return json
def read_json(self, json: dict):
super(CalculationSetup, self).read_json(json)
val = json.get('calculationType')
if val is not None:
self.calculation_type = CalculationType(val)
val = json.get('productSystem')
if val is not None:
self.product_system = Ref()
self.product_system.read_json(val)
val = json.get('impactMethod')
if val is not None:
self.impact_method = Ref()
self.impact_method.read_json(val)
val = json.get('withCosts')
if val is not None:
self.with_costs = val
val = json.get('withRegionalization')
if val is not None:
self.with_regionalization = val
val = json.get('nwSet')
if val is not None:
self.nw_set = Ref()
self.nw_set.read_json(val)
val = json.get('allocationMethod')
if val is not None:
self.allocation_method = AllocationType(val)
val = json.get('parameterRedefs')
if val is not None:
self.parameter_redefs = []
for d in val:
e = ParameterRedef()
e.read_json(d)
self.parameter_redefs.append(e)
val = json.get('amount')
if val is not None:
self.amount = val
val = json.get('unit')
if val is not None:
self.unit = Ref()
self.unit.read_json(val)
val = json.get('flowProperty')
if val is not None:
self.flow_property = Ref()
self.flow_property.read_json(val)
@staticmethod
def from_json(json: dict):
instance = CalculationSetup()
instance.read_json(json)
return instance
@dataclass
class DQIndicator(Entity):
"""
An indicator of a data quality system ([DQSystem]).
Attributes
----------
name: str
position: int
scores: List[DQScore]
"""
olca_type: str = 'DQIndicator'
name: Optional[str] = None
position: Optional[int] = None
scores: Optional[List[DQScore]] = None
def to_json(self) -> dict:
json: dict = super(DQIndicator, self).to_json()
if self.name is not None:
json['name'] = self.name
if self.position is not None:
json['position'] = self.position
if self.scores is not None:
json['scores'] = []
for e in self.scores:
json['scores'].append(e.to_json())
return json
def read_json(self, json: dict):
super(DQIndicator, self).read_json(json)
val = json.get('name')
if val is not None:
self.name = val
val = json.get('position')
if val is not None:
self.position = val
val = json.get('scores')
if val is not None:
self.scores = []
for d in val:
e = DQScore()
e.read_json(d)
self.scores.append(e)
@staticmethod
def from_json(json: dict):
instance = DQIndicator()
instance.read_json(json)
return instance
@dataclass
class DQScore(Entity):
"""
An score value of an indicator ([DQIndicator]) in a data quality system
([DQSystem]).
Attributes
----------
position: int
label: str
description: str
uncertainty: float
"""
olca_type: str = 'DQScore'
position: Optional[int] = None
label: Optional[str] = None
description: Optional[str] = None
uncertainty: Optional[float] = None
def to_json(self) -> dict:
json: dict = super(DQScore, self).to_json()
if self.position is not None:
json['position'] = self.position
if self.label is not None:
json['label'] = self.label
if self.description is not None:
json['description'] = self.description
if self.uncertainty is not None:
json['uncertainty'] = self.uncertainty
return json
def read_json(self, json: dict):
super(DQScore, self).read_json(json)
val = json.get('position')
if val is not None:
self.position = val
val = json.get('label')
if val is not None:
self.label = val
val = json.get('description')
if val is not None:
self.description = val
val = json.get('uncertainty')
if val is not None:
self.uncertainty = val
@staticmethod
def from_json(json: dict):
instance = DQScore()
instance.read_json(json)
return instance
@dataclass
class Exchange(Entity):
"""
An Exchange is an input or output of a [Flow] in a [Process]. The amount of
an exchange is given in a specific unit of a quantity ([FlowProperty]) of
the flow. The allowed units and flow properties that can be used for a flow
in an exchange are defined by the flow property information in that flow
(see also the [FlowPropertyFactor] type).
Attributes
----------
avoided_product: bool
Indicates whether this exchange is an avoided product.
cost_formula: str
A formula for calculating the costs of this exchange.
cost_value: float
The costs of this exchange.
currency: Ref
The currency in which the costs of this exchange are given.
internal_id: int
The process internal ID of the exchange. This is used to identify
exchanges unambiguously within a process (e.g. when linking exchanges
in a product system where multiple exchanges with the same flow are
allowed). The value should be >= 1.
flow: Ref
The reference to the flow of the exchange.
flow_property: Ref
The quantity in which the amount is given.
input: bool
quantitative_reference: bool
Indicates whether the exchange is the quantitative reference of the
process.
base_uncertainty: float
default_provider: Ref
A default provider is a [Process] that is linked as the provider of a
product input or the waste treatment provider of a waste output. It is
just an optional default setting which can be also ignored when
building product systems in openLCA. The user is always free to link
processes in product systems ignoring these defaults (but the flows and
flow directions have to match of course).
amount: float
amount_formula: str
unit: Ref
dq_entry: str
A data quality entry like `(1;3;2;5;1)`. The entry is a vector of data
quality values that need to match the data quality scheme for flow
inputs and outputs that is assigned to the [Process]. In such a scheme
the data quality indicators have fixed positions and the respective
values in the `dqEntry` vector map to these positions.
uncertainty: Uncertainty
description: str
A general comment about the input or output.
"""
olca_type: str = 'Exchange'
avoided_product: Optional[bool] = None
cost_formula: Optional[str] = None
cost_value: Optional[float] = None
currency: Optional[Ref] = None
internal_id: Optional[int] = None
flow: Optional[Ref] = None
flow_property: Optional[Ref] = None
input: Optional[bool] = None
quantitative_reference: Optional[bool] = None
base_uncertainty: Optional[float] = None
default_provider: Optional[Ref] = None
amount: Optional[float] = None
amount_formula: Optional[str] = None
unit: Optional[Ref] = None
dq_entry: Optional[str] = None
uncertainty: Optional[Uncertainty] = None
description: Optional[str] = None
def to_json(self) -> dict:
json: dict = super(Exchange, self).to_json()
if self.avoided_product is not None:
json['avoidedProduct'] = self.avoided_product
if self.cost_formula is not None:
json['costFormula'] = self.cost_formula
if self.cost_value is not None:
json['costValue'] = self.cost_value
if self.currency is not None:
json['currency'] = self.currency.to_json()
if self.internal_id is not None:
json['internalId'] = self.internal_id
if self.flow is not None:
json['flow'] = self.flow.to_json()
if self.flow_property is not None:
json['flowProperty'] = self.flow_property.to_json()
if self.input is not None:
json['input'] = self.input
if self.quantitative_reference is not None:
json['quantitativeReference'] = self.quantitative_reference
if self.base_uncertainty is not None:
json['baseUncertainty'] = self.base_uncertainty
if self.default_provider is not None:
json['defaultProvider'] = self.default_provider.to_json()
if self.amount is not None:
json['amount'] = self.amount
if self.amount_formula is not None:
json['amountFormula'] = self.amount_formula
if self.unit is not None:
json['unit'] = self.unit.to_json()
if self.dq_entry is not None:
json['dqEntry'] = self.dq_entry
if self.uncertainty is not None:
json['uncertainty'] = self.uncertainty.to_json()
if self.description is not None:
json['description'] = self.description
return json
def read_json(self, json: dict):
super(Exchange, self).read_json(json)
val = json.get('avoidedProduct')
if val is not None:
self.avoided_product = val
val = json.get('costFormula')
if val is not None:
self.cost_formula = val
val = json.get('costValue')
if val is not None:
self.cost_value = val
val = json.get('currency')
if val is not None:
self.currency = Ref()
self.currency.read_json(val)
val = json.get('internalId')
if val is not None:
self.internal_id = val
val = json.get('flow')
if val is not None:
self.flow = Ref()
self.flow.read_json(val)
val = json.get('flowProperty')
if val is not None:
self.flow_property = Ref()
self.flow_property.read_json(val)
val = json.get('input')
if val is not None:
self.input = val
val = json.get('quantitativeReference')
if val is not None:
self.quantitative_reference = val
val = json.get('baseUncertainty')
if val is not None:
self.base_uncertainty = val
val = json.get('defaultProvider')
if val is not None:
self.default_provider = Ref()
self.default_provider.read_json(val)
val = json.get('amount')
if val is not None:
self.amount = val
val = json.get('amountFormula')
if val is not None:
self.amount_formula = val
val = json.get('unit')
if val is not None:
self.unit = Ref()
self.unit.read_json(val)
val = json.get('dqEntry')
if val is not None:
self.dq_entry = val
val = json.get('uncertainty')
if val is not None:
self.uncertainty = Uncertainty()
self.uncertainty.read_json(val)
val = json.get('description')
if val is not None:
self.description = val
@staticmethod
def from_json(json: dict):
instance = Exchange()
instance.read_json(json)
return instance
@dataclass
class ExchangeRef(Entity):
"""
An instance of this class describes a reference to an exchange in a
process. When we reference such an exchange we only need the information to
indentify that exchange unambiguously in a process.
Attributes
----------
internal_id: int
The internal ID of the exchange.
"""
olca_type: str = 'ExchangeRef'
internal_id: Optional[int] = None
def to_json(self) -> dict:
json: dict = super(ExchangeRef, self).to_json()
if self.internal_id is not None:
json['internalId'] = self.internal_id
return json
def read_json(self, json: dict):
super(ExchangeRef, self).read_json(json)
val = json.get('internalId')
if val is not None:
self.internal_id = val
@staticmethod
def from_json(json: dict):
instance = ExchangeRef()
instance.read_json(json)
return instance
@dataclass
class FlowMapEntry(Entity):
"""
A mapping from a source flow to a target flow.
Attributes
----------
from_: FlowMapRef
Describes the source flow of the mapping.
to: FlowMapRef
Describes the target of the mapping.
conversion_factor: float
The conversion factor to convert the amount of 1 unit of the source
flow into the corresponding quantity of the target flow.
"""
olca_type: str = 'FlowMapEntry'
from_: Optional[FlowMapRef] = None
to: Optional[FlowMapRef] = None
conversion_factor: Optional[float] = None
def to_json(self) -> dict:
json: dict = super(FlowMapEntry, self).to_json()
if self.from_ is not None:
json['from'] = self.from_.to_json()
if self.to is not None:
json['to'] = self.to.to_json()
if self.conversion_factor is not None:
json['conversionFactor'] = self.conversion_factor
return json
def read_json(self, json: dict):
super(FlowMapEntry, self).read_json(json)
val = json.get('from')
if val is not None:
self.from_ = FlowMapRef()
self.from_.read_json(val)
val = json.get('to')
if val is not None:
self.to = FlowMapRef()
self.to.read_json(val)
val = json.get('conversionFactor')
if val is not None:
self.conversion_factor = val
@staticmethod
def from_json(json: dict):
instance = FlowMapEntry()
instance.read_json(json)
return instance
@dataclass
class FlowMapRef(Entity):
"""
Describes a source or target flow in a `FlowMappingEntry` of a `FlowMap`.
Such a flow reference can also optionally specify the unit and flow
property (quantity) for which the mapping is valid. If the unit or quantity
is not given, the mapping is based on the respective reference unit and
reference flow property of the flow.
Attributes
----------
flow: Ref
The reference to the flow data set.
flow_property: Ref
An optional reference to a flow property of the flow for which the
mapping is valid.
unit: Ref
An optional reference to a unit of the flow for which the mapping is
valid
provider: Ref
In case of a product or waste flow a flow mapping can contain a
provider which is the process that produces the product or a waste
treatment process that consumes the waste flow. This is useful when we
want to apply mappings of product and waste flows on databases and link
them in the corresponding processes and product systems.
"""
olca_type: str = 'FlowMapRef'
flow: Optional[Ref] = None
flow_property: Optional[Ref] = None
unit: Optional[Ref] = None
provider: Optional[Ref] = None
def to_json(self) -> dict:
json: dict = super(FlowMapRef, self).to_json()
if self.flow is not None:
json['flow'] = self.flow.to_json()
if self.flow_property is not None:
json['flowProperty'] = self.flow_property.to_json()
if self.unit is not None:
json['unit'] = self.unit.to_json()
if self.provider is not None:
json['provider'] = self.provider.to_json()
return json
def read_json(self, json: dict):
super(FlowMapRef, self).read_json(json)
val = json.get('flow')
if val is not None:
self.flow = Ref()
self.flow.read_json(val)
val = json.get('flowProperty')
if val is not None:
self.flow_property = Ref()
self.flow_property.read_json(val)
val = json.get('unit')
if val is not None:
self.unit = Ref()
self.unit.read_json(val)
val = json.get('provider')
if val is not None:
self.provider = Ref()
self.provider.read_json(val)
@staticmethod
def from_json(json: dict):
instance = FlowMapRef()
instance.read_json(json)
return instance
@dataclass
class FlowPropertyFactor(Entity):
"""
A FlowPropertyFactor is a conversion factor between <a
href="./FlowProperty.html">flow properties (quantities)</a> of a <a
href="./Flow.html">flow</a>. As an example the amount of the flow 'water'
in a process could be expressed in 'kg' mass or 'm3' volume. In this case
the flow water would have two flow property factors: one for the flow
property 'mass' and one for 'volume'. Each of these flow properties has a
reference to a <a href="./UnitGroup.html">unit group</a> which again has a
reference unit. In the example the flow property 'mass' could reference the
unit group 'units of mass' with 'kg' as reference unit and volume could
reference the unit group 'units of volume' with 'm3' as reference unit. The
flow property factor is now the conversion factor between these two
reference units where the factor of the reference flow property of the flow
is 1. If the reference flow property of 'water' in the example would be
'mass' the respective flow property factor would be 1 and the factor for
'volume' would be 0.001 (as 1 kg water is 0.001 m3). The amount of water in
a process can now be also given in liter, tons, grams etc. For this, the
unit conversion factor of the respective unit group can be used to convert
into the reference unit (which then can be used to convert to the reference
unit of another flow property). Another thing to note is that different
flow properties can refer to the same unit group (e.g. MJ upper calorific
value and MJ lower calorific value.)
Attributes
----------
flow_property: Ref
The flow property (quantity) of the factor.
conversion_factor: float
The value of the conversion factor.
reference_flow_property: bool
Indicates whether the flow property of the factor is the reference flow
property of the flow. The reference flow property must have a
conversion factor of 1.0 and there should be only one reference flow
property.
"""
olca_type: str = 'FlowPropertyFactor'
flow_property: Optional[Ref] = None
conversion_factor: Optional[float] = None
reference_flow_property: Optional[bool] = None
def to_json(self) -> dict:
json: dict = super(FlowPropertyFactor, self).to_json()
if self.flow_property is not None:
json['flowProperty'] = self.flow_property.to_json()
if self.conversion_factor is not None:
json['conversionFactor'] = self.conversion_factor
if self.reference_flow_property is not None:
json['referenceFlowProperty'] = self.reference_flow_property
return json
def read_json(self, json: dict):
super(FlowPropertyFactor, self).read_json(json)
val = json.get('flowProperty')
if val is not None:
self.flow_property = Ref()
self.flow_property.read_json(val)
val = json.get('conversionFactor')
if val is not None:
self.conversion_factor = val
val = json.get('referenceFlowProperty')
if val is not None:
self.reference_flow_property = val
@staticmethod
def from_json(json: dict):
instance = FlowPropertyFactor()
instance.read_json(json)
return instance
@dataclass
class FlowResult(Entity):
"""
A result value for a flow; given in the reference unit of the flow.
Attributes
----------
flow: Ref
The flow reference.
input: bool
Indicates whether the flow is an input or not.
value: float
The value of the flow amount.
location: Ref
The (reference to the) location of this flow result in case of a
regionalized result.
"""
olca_type: str = 'FlowResult'
flow: Optional[Ref] = None
input: Optional[bool] = None
value: Optional[float] = None
location: Optional[Ref] = None
def to_json(self) -> dict:
json: dict = super(FlowResult, self).to_json()
if self.flow is not None:
json['flow'] = self.flow.to_json()
if self.input is not None:
json['input'] = self.input
if self.value is not None:
json['value'] = self.value
if self.location is not None:
json['location'] = self.location.to_json()
return json
def read_json(self, json: dict):
super(FlowResult, self).read_json(json)
val = json.get('flow')
if val is not None:
self.flow = Ref()
self.flow.read_json(val)
val = json.get('input')
if val is not None:
self.input = val
val = json.get('value')
if val is not None:
self.value = val
val = json.get('location')
if val is not None:
self.location = Ref()
self.location.read_json(val)
@staticmethod
def from_json(json: dict):
instance = FlowResult()
instance.read_json(json)
return instance
@dataclass
class ImpactFactor(Entity):
"""
A single characterisation factor of a LCIA category for a flow.
Attributes
----------
flow: Ref
The [Flow] of the impact assessment factor.
location: Ref
In case of a regionalized impact category, this field can contain the
location for which this factor is valid.
flow_property: Ref
The quantity of the flow to which the LCIA factor is related (e.g.
Mass).
unit: Ref
The flow unit to which the LCIA factor is related (e.g. kg).
value: float
The value of the impact assessment factor.
formula: str
A mathematical formula for calculating the value of the LCIA factor.
uncertainty: Uncertainty
The uncertainty distribution of the factors' value.
"""
olca_type: str = 'ImpactFactor'
flow: Optional[Ref] = None
location: Optional[Ref] = None
flow_property: Optional[Ref] = None
unit: Optional[Ref] = None
value: Optional[float] = None
formula: Optional[str] = None
uncertainty: Optional[Uncertainty] = None
def to_json(self) -> dict:
json: dict = super(ImpactFactor, self).to_json()
if self.flow is not None:
json['flow'] = self.flow.to_json()
if self.location is not None:
json['location'] = self.location.to_json()
if self.flow_property is not None:
json['flowProperty'] = self.flow_property.to_json()
if self.unit is not None:
json['unit'] = self.unit.to_json()
if self.value is not None:
json['value'] = self.value
if self.formula is not None:
json['formula'] = self.formula
if self.uncertainty is not None:
json['uncertainty'] = self.uncertainty.to_json()
return json
def read_json(self, json: dict):
super(ImpactFactor, self).read_json(json)
val = json.get('flow')
if val is not None:
self.flow = Ref()
self.flow.read_json(val)
val = json.get('location')
if val is not None:
self.location = Ref()
self.location.read_json(val)
val = json.get('flowProperty')
if val is not None:
self.flow_property = Ref()
self.flow_property.read_json(val)
val = json.get('unit')
if val is not None:
self.unit = Ref()
self.unit.read_json(val)
val = json.get('value')
if val is not None:
self.value = val
val = json.get('formula')
if val is not None:
self.formula = val
val = json.get('uncertainty')
if val is not None:
self.uncertainty = Uncertainty()
self.uncertainty.read_json(val)
@staticmethod
def from_json(json: dict):
instance = ImpactFactor()
instance.read_json(json)
return instance
@dataclass
class ImpactResult(Entity):
"""
A result value for an impact assessment category.
Attributes
----------
impact_category: Ref
The reference to the impact assessment category.
value: float
The value of the flow amount.
"""
olca_type: str = 'ImpactResult'
impact_category: Optional[Ref] = None
value: Optional[float] = None
def to_json(self) -> dict:
json: dict = super(ImpactResult, self).to_json()
if self.impact_category is not None:
json['impactCategory'] = self.impact_category.to_json()
if self.value is not None:
json['value'] = self.value
return json
def read_json(self, json: dict):
super(ImpactResult, self).read_json(json)
val = json.get('impactCategory')
if val is not None:
self.impact_category = Ref()
self.impact_category.read_json(val)
val = json.get('value')
if val is not None:
self.value = val
@staticmethod
def from_json(json: dict):
instance = ImpactResult()
instance.read_json(json)
return instance
@dataclass
class NwFactor(Entity):
"""
A normalization and weighting factor of a [NwSet] related to an impact
category. Depending on the purpose of the [NwSet] (normalization,
weighting, or both) the normalization and weighting factor can be present
or not.
Attributes
----------
impact_category: Ref
normalisation_factor: float
weighting_factor: float
"""
olca_type: str = 'NwFactor'
impact_category: Optional[Ref] = None
normalisation_factor: Optional[float] = None
weighting_factor: Optional[float] = None
def to_json(self) -> dict:
json: dict = super(NwFactor, self).to_json()
if self.impact_category is not None:
json['impactCategory'] = self.impact_category.to_json()
if self.normalisation_factor is not None:
json['normalisationFactor'] = self.normalisation_factor
if self.weighting_factor is not None:
json['weightingFactor'] = self.weighting_factor
return json
def read_json(self, json: dict):
super(NwFactor, self).read_json(json)
val = json.get('impactCategory')
if val is not None:
self.impact_category = Ref()
self.impact_category.read_json(val)
val = json.get('normalisationFactor')
if val is not None:
self.normalisation_factor = val
val = json.get('weightingFactor')
if val is not None:
self.weighting_factor = val
@staticmethod
def from_json(json: dict):
instance = NwFactor()
instance.read_json(json)
return instance
@dataclass
class ParameterRedef(Entity):
"""
A redefinition of a parameter in a product system.
Attributes
----------
context: Ref
The context of the paramater (a process or LCIA method). If no context
is provided it is assumed that this is a redefinition of a global
parameter.
description: str
A description of this parameter redefinition.
name: str
The name of the redefined parameter. Note that parameter names are used
in formulas so they need to follow specific syntax rules. A
redefinition replaces a bound parameter in a specific context and thus
has to exactly match the respective name.
uncertainty: Uncertainty
An uncertainty distribution for the redefined parameter value.
value: float
The value of the redefined parameter.
"""
olca_type: str = 'ParameterRedef'
context: Optional[Ref] = None
description: Optional[str] = None
name: Optional[str] = None
uncertainty: Optional[Uncertainty] = None
value: Optional[float] = None
def to_json(self) -> dict:
json: dict = super(ParameterRedef, self).to_json()
if self.context is not None:
json['context'] = self.context.to_json()
if self.description is not None:
json['description'] = self.description
if self.name is not None:
json['name'] = self.name
if self.uncertainty is not None:
json['uncertainty'] = self.uncertainty.to_json()
if self.value is not None:
json['value'] = self.value
return json
def read_json(self, json: dict):
super(ParameterRedef, self).read_json(json)
val = json.get('context')
if val is not None:
self.context = Ref()
self.context.read_json(val)
val = json.get('description')
if val is not None:
self.description = val
val = json.get('name')
if val is not None:
self.name = val
val = json.get('uncertainty')
if val is not None:
self.uncertainty = Uncertainty()
self.uncertainty.read_json(val)
val = json.get('value')
if val is not None:
self.value = val
@staticmethod
def from_json(json: dict):
instance = ParameterRedef()
instance.read_json(json)
return instance
@dataclass
class ParameterRedefSet(Entity):
"""
An instance of this class is just a set of parameter redefinitions attached
to a product system. It can have a name and a description. One of the
parameter sets can be defined as the baseline of the product system. In the
calculation the baseline set is then taken by default.
Attributes
----------
name: str
The name of the parameter set.
description: str
A description of the parameter set.
is_baseline: bool
Indicates if this set of parameter redefinitions is the baseline for a
product system.
parameters: List[ParameterRedef]
The parameter redefinitions of this redefinition set.
"""
olca_type: str = 'ParameterRedefSet'
name: Optional[str] = None
description: Optional[str] = None
is_baseline: Optional[bool] = None
parameters: Optional[List[ParameterRedef]] = None
def to_json(self) -> dict:
json: dict = super(ParameterRedefSet, self).to_json()
if self.name is not None:
json['name'] = self.name
if self.description is not None:
json['description'] = self.description
if self.is_baseline is not None:
json['isBaseline'] = self.is_baseline
if self.parameters is not None:
json['parameters'] = []
for e in self.parameters:
json['parameters'].append(e.to_json())
return json
def read_json(self, json: dict):
super(ParameterRedefSet, self).read_json(json)
val = json.get('name')
if val is not None:
self.name = val
val = json.get('description')
if val is not None:
self.description = val
val = json.get('isBaseline')
if val is not None:
self.is_baseline = val
val = json.get('parameters')
if val is not None:
self.parameters = []
for d in val:
e = ParameterRedef()
e.read_json(d)
self.parameters.append(e)
@staticmethod
def from_json(json: dict):
instance = ParameterRedefSet()
instance.read_json(json)
return instance
@dataclass
class ProcessDocumentation(Entity):
"""
Attributes
----------
time_description: str
valid_until: str
valid_from: str
technology_description: str
data_collection_description: str
completeness_description: str
data_selection_description: str
review_details: str
data_treatment_description: str
inventory_method_description: str
modeling_constants_description: str
reviewer: Ref
sampling_description: str
sources: List[Ref]
restrictions_description: str
copyright: bool
creation_date: str
data_documentor: Ref
data_generator: Ref
data_set_owner: Ref
intended_application: str
project_description: str
publication: Ref
geography_description: str
"""
olca_type: str = 'ProcessDocumentation'
time_description: Optional[str] = None
valid_until: Optional[str] = None
valid_from: Optional[str] = None
technology_description: Optional[str] = None
data_collection_description: Optional[str] = None
completeness_description: Optional[str] = None
data_selection_description: Optional[str] = None
review_details: Optional[str] = None
data_treatment_description: Optional[str] = None
inventory_method_description: Optional[str] = None
modeling_constants_description: Optional[str] = None
reviewer: Optional[Ref] = None
sampling_description: Optional[str] = None
sources: Optional[List[Ref]] = None
restrictions_description: Optional[str] = None
copyright: Optional[bool] = None
creation_date: Optional[str] = None
data_documentor: Optional[Ref] = None
data_generator: Optional[Ref] = None
data_set_owner: Optional[Ref] = None
intended_application: Optional[str] = None
project_description: Optional[str] = None
publication: Optional[Ref] = None
geography_description: Optional[str] = None
def to_json(self) -> dict:
json: dict = super(ProcessDocumentation, self).to_json()
if self.time_description is not None:
json['timeDescription'] = self.time_description
if self.valid_until is not None:
json['validUntil'] = self.valid_until
if self.valid_from is not None:
json['validFrom'] = self.valid_from
if self.technology_description is not None:
json['technologyDescription'] = self.technology_description
if self.data_collection_description is not None:
json['dataCollectionDescription'] = self.data_collection_description
if self.completeness_description is not None:
json['completenessDescription'] = self.completeness_description
if self.data_selection_description is not None:
json['dataSelectionDescription'] = self.data_selection_description
if self.review_details is not None:
json['reviewDetails'] = self.review_details
if self.data_treatment_description is not None:
json['dataTreatmentDescription'] = self.data_treatment_description
if self.inventory_method_description is not None:
json['inventoryMethodDescription'] = self.inventory_method_description
if self.modeling_constants_description is not None:
json['modelingConstantsDescription'] = self.modeling_constants_description
if self.reviewer is not None:
json['reviewer'] = self.reviewer.to_json()
if self.sampling_description is not None:
json['samplingDescription'] = self.sampling_description
if self.sources is not None:
json['sources'] = []
for e in self.sources:
json['sources'].append(e.to_json())
if self.restrictions_description is not None:
json['restrictionsDescription'] = self.restrictions_description
if self.copyright is not None:
json['copyright'] = self.copyright
if self.creation_date is not None:
json['creationDate'] = self.creation_date
if self.data_documentor is not None:
json['dataDocumentor'] = self.data_documentor.to_json()
if self.data_generator is not None:
json['dataGenerator'] = self.data_generator.to_json()
if self.data_set_owner is not None:
json['dataSetOwner'] = self.data_set_owner.to_json()
if self.intended_application is not None:
json['intendedApplication'] = self.intended_application
if self.project_description is not None:
json['projectDescription'] = self.project_description
if self.publication is not None:
json['publication'] = self.publication.to_json()
if self.geography_description is not None:
json['geographyDescription'] = self.geography_description
return json
def read_json(self, json: dict):
super(ProcessDocumentation, self).read_json(json)
val = json.get('timeDescription')
if val is not None:
self.time_description = val
val = json.get('validUntil')
if val is not None:
self.valid_until = val
val = json.get('validFrom')
if val is not None:
self.valid_from = val
val = json.get('technologyDescription')
if val is not None:
self.technology_description = val
val = json.get('dataCollectionDescription')
if val is not None:
self.data_collection_description = val
val = json.get('completenessDescription')
if val is not None:
self.completeness_description = val
val = json.get('dataSelectionDescription')
if val is not None:
self.data_selection_description = val
val = json.get('reviewDetails')
if val is not None:
self.review_details = val
val = json.get('dataTreatmentDescription')
if val is not None:
self.data_treatment_description = val
val = json.get('inventoryMethodDescription')
if val is not None:
self.inventory_method_description = val
val = json.get('modelingConstantsDescription')
if val is not None:
self.modeling_constants_description = val
val = json.get('reviewer')
if val is not None:
self.reviewer = Ref()
self.reviewer.read_json(val)
val = json.get('samplingDescription')
if val is not None:
self.sampling_description = val
val = json.get('sources')
if val is not None:
self.sources = []
for d in val:
e = Ref()
e.read_json(d)
self.sources.append(e)
val = json.get('restrictionsDescription')
if val is not None:
self.restrictions_description = val
val = json.get('copyright')
if val is not None:
self.copyright = val
val = json.get('creationDate')
if val is not None:
self.creation_date = val
val = json.get('dataDocumentor')
if val is not None:
self.data_documentor = Ref()
self.data_documentor.read_json(val)
val = json.get('dataGenerator')
if val is not None:
self.data_generator = Ref()
self.data_generator.read_json(val)
val = json.get('dataSetOwner')
if val is not None:
self.data_set_owner = Ref()
self.data_set_owner.read_json(val)
val = json.get('intendedApplication')
if val is not None:
self.intended_application = val
val = json.get('projectDescription')
if val is not None:
self.project_description = val
val = json.get('publication')
if val is not None:
self.publication = Ref()
self.publication.read_json(val)
val = json.get('geographyDescription')
if val is not None:
self.geography_description = val
@staticmethod
def from_json(json: dict):
instance = ProcessDocumentation()
instance.read_json(json)
return instance
@dataclass
class ProcessLink(Entity):
"""
A process link is a connection between two processes in a product system.
Attributes
----------
provider: Ref
The descriptor of the process or product system that provides a product
or a waste treatment.
flow: Ref
The descriptor of the flow that is exchanged between the two processes.
process: Ref
The descriptor of the process that is linked to the provider.
exchange: ExchangeRef
The exchange of the linked process (this is useful if the linked
process has multiple exchanges with the same flow that are linked to
different provides, e.g. in an electricity mix).
"""
olca_type: str = 'ProcessLink'
provider: Optional[Ref] = None
flow: Optional[Ref] = None
process: Optional[Ref] = None
exchange: Optional[ExchangeRef] = None
def to_json(self) -> dict:
json: dict = super(ProcessLink, self).to_json()
if self.provider is not None:
json['provider'] = self.provider.to_json()
if self.flow is not None:
json['flow'] = self.flow.to_json()
if self.process is not None:
json['process'] = self.process.to_json()
if self.exchange is not None:
json['exchange'] = self.exchange.to_json()
return json
def read_json(self, json: dict):
super(ProcessLink, self).read_json(json)
val = json.get('provider')
if val is not None:
self.provider = Ref()
self.provider.read_json(val)
val = json.get('flow')
if val is not None:
self.flow = Ref()
self.flow.read_json(val)
val = json.get('process')
if val is not None:
self.process = Ref()
self.process.read_json(val)
val = json.get('exchange')
if val is not None:
self.exchange = ExchangeRef()
self.exchange.read_json(val)
@staticmethod
def from_json(json: dict):
instance = ProcessLink()
instance.read_json(json)
return instance
@dataclass
class RootEntity(Entity):
"""
A standalone item in a database like a location, unit group, flow, or
process. A root entity can be unambiguously identified by its id (the
JSON-LD @id field), version, and lastChange fields.
Attributes
----------
name: str
The name of the entity.
description: str
The description of the entity.
version: str
A version number in MAJOR.MINOR.PATCH format where the MINOR and PATCH
fields are optional and the fields may have leading zeros (so 01.00.00
is the same as 1.0.0 or 1).
last_change: str
The timestamp when the entity was changed the last time.
"""
name: Optional[str] = None
description: Optional[str] = None
version: Optional[str] = None
last_change: Optional[str] = None
def to_json(self) -> dict:
json: dict = super(RootEntity, self).to_json()
if self.name is not None:
json['name'] = self.name
if self.description is not None:
json['description'] = self.description
if self.version is not None:
json['version'] = self.version
if self.last_change is not None:
json['lastChange'] = self.last_change
return json
def read_json(self, json: dict):
super(RootEntity, self).read_json(json)
val = json.get('name')
if val is not None:
self.name = val
val = json.get('description')
if val is not None:
self.description = val
val = json.get('version')
if val is not None:
self.version = val
val = json.get('lastChange')
if val is not None:
self.last_change = val
@staticmethod
def from_json(json: dict):
instance = RootEntity()
instance.read_json(json)
return instance
@dataclass
class SimpleResult(Entity):
"""
Attributes
----------
flow_results: List[FlowResult]
impact_results: List[ImpactResult]
"""
olca_type: str = 'SimpleResult'
flow_results: Optional[List[FlowResult]] = None
impact_results: Optional[List[ImpactResult]] = None
def to_json(self) -> dict:
json: dict = super(SimpleResult, self).to_json()
if self.flow_results is not None:
json['flowResults'] = []
for e in self.flow_results:
json['flowResults'].append(e.to_json())
if self.impact_results is not None:
json['impactResults'] = []
for e in self.impact_results:
json['impactResults'].append(e.to_json())
return json
def read_json(self, json: dict):
super(SimpleResult, self).read_json(json)
val = json.get('flowResults')
if val is not None:
self.flow_results = []
for d in val:
e = FlowResult()
e.read_json(d)
self.flow_results.append(e)
val = json.get('impactResults')
if val is not None:
self.impact_results = []
for d in val:
e = ImpactResult()
e.read_json(d)
self.impact_results.append(e)
@staticmethod
def from_json(json: dict):
instance = SimpleResult()
instance.read_json(json)
return instance
@dataclass
class SocialAspect(Entity):
"""
An instance of this class describes a social aspect related to a social
indicator in a process.
Attributes
----------
activity_value: float
The value of the activity variable of the related indicator.
comment: str
quality: str
A data quality entry, e.g. `(3,1,2,4,1)`.
raw_amount: str
The raw amount of the indicator's unit of measurement (not required to
be numeric currently)
risk_level: RiskLevel
social_indicator: Ref
source: Ref
"""
olca_type: str = 'SocialAspect'
activity_value: Optional[float] = None
comment: Optional[str] = None
quality: Optional[str] = None
raw_amount: Optional[str] = None
risk_level: Optional[RiskLevel] = None
social_indicator: Optional[Ref] = None
source: Optional[Ref] = None
def to_json(self) -> dict:
json: dict = super(SocialAspect, self).to_json()
if self.activity_value is not None:
json['activityValue'] = self.activity_value
if self.comment is not None:
json['comment'] = self.comment
if self.quality is not None:
json['quality'] = self.quality
if self.raw_amount is not None:
json['rawAmount'] = self.raw_amount
if self.risk_level is not None:
json['riskLevel'] = self.risk_level.value
if self.social_indicator is not None:
json['socialIndicator'] = self.social_indicator.to_json()
if self.source is not None:
json['source'] = self.source.to_json()
return json
def read_json(self, json: dict):
super(SocialAspect, self).read_json(json)
val = json.get('activityValue')
if val is not None:
self.activity_value = val
val = json.get('comment')
if val is not None:
self.comment = val
val = json.get('quality')
if val is not None:
self.quality = val
val = json.get('rawAmount')
if val is not None:
self.raw_amount = val
val = json.get('riskLevel')
if val is not None:
self.risk_level = RiskLevel(val)
val = json.get('socialIndicator')
if val is not None:
self.social_indicator = Ref()
self.social_indicator.read_json(val)
val = json.get('source')
if val is not None:
self.source = Ref()
self.source.read_json(val)
@staticmethod
def from_json(json: dict):
instance = SocialAspect()
instance.read_json(json)
return instance
@dataclass
class Uncertainty(Entity):
"""
Defines the parameter values of an uncertainty distribution. Depending on
the uncertainty distribution type different parameters could be used.
Attributes
----------
distribution_type: UncertaintyType
The uncertainty distribution type
mean: float
The arithmetic mean (used for normal distributions).
mean_formula: str
A mathematical formula for the arithmetic mean.
geom_mean: float
The geometric mean value (used for log-normal distributions).
geom_mean_formula: str
A mathematical formula for the geometric mean.
minimum: float
The minimum value (used for uniform and triangle distributions).
minimum_formula: str
A mathematical formula for the minimum value.
sd: float
The arithmetic standard deviation (used for normal distributions).
sd_formula: str
A mathematical formula for the arithmetic standard deviation.
geom_sd: float
The geometric standard deviation (used for log-normal distributions).
geom_sd_formula: str
A mathematical formula for the geometric standard deviation.
mode: float
The most likely value (used for triangle distributions).
mode_formula: str
A mathematical formula for the most likely value.
maximum: float
The maximum value (used for uniform and triangle distributions).
maximum_formula: str
A mathematical formula for the maximum value.
"""
olca_type: str = 'Uncertainty'
distribution_type: Optional[UncertaintyType] = None
mean: Optional[float] = None
mean_formula: Optional[str] = None
geom_mean: Optional[float] = None
geom_mean_formula: Optional[str] = None
minimum: Optional[float] = None
minimum_formula: Optional[str] = None
sd: Optional[float] = None
sd_formula: Optional[str] = None
geom_sd: Optional[float] = None
geom_sd_formula: Optional[str] = None
mode: Optional[float] = None
mode_formula: Optional[str] = None
maximum: Optional[float] = None
maximum_formula: Optional[str] = None
def to_json(self) -> dict:
json: dict = super(Uncertainty, self).to_json()
if self.distribution_type is not None:
json['distributionType'] = self.distribution_type.value
if self.mean is not None:
json['mean'] = self.mean
if self.mean_formula is not None:
json['meanFormula'] = self.mean_formula
if self.geom_mean is not None:
json['geomMean'] = self.geom_mean
if self.geom_mean_formula is not None:
json['geomMeanFormula'] = self.geom_mean_formula
if self.minimum is not None:
json['minimum'] = self.minimum
if self.minimum_formula is not None:
json['minimumFormula'] = self.minimum_formula
if self.sd is not None:
json['sd'] = self.sd
if self.sd_formula is not None:
json['sdFormula'] = self.sd_formula
if self.geom_sd is not None:
json['geomSd'] = self.geom_sd
if self.geom_sd_formula is not None:
json['geomSdFormula'] = self.geom_sd_formula
if self.mode is not None:
json['mode'] = self.mode
if self.mode_formula is not None:
json['modeFormula'] = self.mode_formula
if self.maximum is not None:
json['maximum'] = self.maximum
if self.maximum_formula is not None:
json['maximumFormula'] = self.maximum_formula
return json
def read_json(self, json: dict):
super(Uncertainty, self).read_json(json)
val = json.get('distributionType')
if val is not None:
self.distribution_type = UncertaintyType(val)
val = json.get('mean')
if val is not None:
self.mean = val
val = json.get('meanFormula')
if val is not None:
self.mean_formula = val
val = json.get('geomMean')
if val is not None:
self.geom_mean = val
val = json.get('geomMeanFormula')
if val is not None:
self.geom_mean_formula = val
val = json.get('minimum')
if val is not None:
self.minimum = val
val = json.get('minimumFormula')
if val is not None:
self.minimum_formula = val
val = json.get('sd')
if val is not None:
self.sd = val
val = json.get('sdFormula')
if val is not None:
self.sd_formula = val
val = json.get('geomSd')
if val is not None:
self.geom_sd = val
val = json.get('geomSdFormula')
if val is not None:
self.geom_sd_formula = val
val = json.get('mode')
if val is not None:
self.mode = val
val = json.get('modeFormula')
if val is not None:
self.mode_formula = val
val = json.get('maximum')
if val is not None:
self.maximum = val
val = json.get('maximumFormula')
if val is not None:
self.maximum_formula = val
@staticmethod
def from_json(json: dict):
instance = Uncertainty()
instance.read_json(json)
return instance
@dataclass
class CategorizedEntity(RootEntity):
"""
A root entity which can have a category.
Attributes
----------
category: Ref
The category of the entity.
tags: List[str]
A list of optional tags. A tag is just a string which should not
contain commas (and other special characters).
library: str
If this entity is part of a library, this field contains the identifier
of that library. The identifier is typically just the combination of
the library name and version.
"""
category: Optional[Ref] = None
tags: Optional[List[str]] = None
library: Optional[str] = None
def to_json(self) -> dict:
json: dict = super(CategorizedEntity, self).to_json()
if self.category is not None:
json['category'] = self.category.to_json()
if self.tags is not None:
json['tags'] = []
for e in self.tags:
json['tags'].append(e)
if self.library is not None:
json['library'] = self.library
return json
def read_json(self, json: dict):
super(CategorizedEntity, self).read_json(json)
val = json.get('category')
if val is not None:
self.category = Ref()
self.category.read_json(val)
val = json.get('tags')
if val is not None:
self.tags = []
for d in val:
e = d
self.tags.append(e)
val = json.get('library')
if val is not None:
self.library = val
@staticmethod
def from_json(json: dict):
instance = CategorizedEntity()
instance.read_json(json)
return instance
@dataclass
class FlowMap(RootEntity):
"""
A crosswalk of flows from a source flow list to a target flow list.
Attributes
----------
source: Ref
The reference (id, name, description) of the source flow list.
target: Ref
The reference (id, name, description) of the target flow list.
mappings: List[FlowMapEntry]
A list of flow mappings from flows in a source flow list to flows in a
target flow list.
"""
olca_type: str = 'FlowMap'
source: Optional[Ref] = None
target: Optional[Ref] = None
mappings: Optional[List[FlowMapEntry]] = None
def to_json(self) -> dict:
json: dict = super(FlowMap, self).to_json()
if self.source is not None:
json['source'] = self.source.to_json()
if self.target is not None:
json['target'] = self.target.to_json()
if self.mappings is not None:
json['mappings'] = []
for e in self.mappings:
json['mappings'].append(e.to_json())
return json
def read_json(self, json: dict):
super(FlowMap, self).read_json(json)
val = json.get('source')
if val is not None:
self.source = Ref()
self.source.read_json(val)
val = json.get('target')
if val is not None:
self.target = Ref()
self.target.read_json(val)
val = json.get('mappings')
if val is not None:
self.mappings = []
for d in val:
e = FlowMapEntry()
e.read_json(d)
self.mappings.append(e)
@staticmethod
def from_json(json: dict):
instance = FlowMap()
instance.read_json(json)
return instance
@dataclass
class NwSet(RootEntity):
"""
A normalization and weighting set.
Attributes
----------
weighted_score_unit: str
This is the optional unit of the (normalized and) weighted score when
this normalization and weighting set was applied on a LCIA result.
factors: List[NwFactor]
The list of normalization and weighting factors of this set.
"""
olca_type: str = 'NwSet'
weighted_score_unit: Optional[str] = None
factors: Optional[List[NwFactor]] = None
def to_json(self) -> dict:
json: dict = super(NwSet, self).to_json()
if self.weighted_score_unit is not None:
json['weightedScoreUnit'] = self.weighted_score_unit
if self.factors is not None:
json['factors'] = []
for e in self.factors:
json['factors'].append(e.to_json())
return json
def read_json(self, json: dict):
super(NwSet, self).read_json(json)
val = json.get('weightedScoreUnit')
if val is not None:
self.weighted_score_unit = val
val = json.get('factors')
if val is not None:
self.factors = []
for d in val:
e = NwFactor()
e.read_json(d)
self.factors.append(e)
@staticmethod
def from_json(json: dict):
instance = NwSet()
instance.read_json(json)
return instance
@dataclass
class Ref(RootEntity):
"""
A Ref is a reference to a [RootEntity]. When serializing an entity (e.g. a
[Process]) that references another standalone entity (e.g. a [Flow] in an
[Exchange]) we do not want to write the complete referenced entity into the
serialized JSON object but just a reference. However, the reference
contains some meta-data like name, category path etc. that are useful to
display.
Attributes
----------
category_path: List[str]
The full path of the category of the referenced entity from top to
bottom, e.g. `"Elementary flows", "Emissions to air", "unspecified"`.
library: str
If the entity that is described by this reference is part of a library,
this field contains the identifier of that library. The identifier is
typically just the combination of the library name and version.
ref_unit: str
This field is only valid for references of flows or impact categories
and contains the name (symbol) of the reference unit of that respective
flow or impact category.
location: str
This field is only valid for references of processes or flows and
contains the location name or code of that respective process or flow.
flow_type: FlowType
In case of a reference to a flow, this field can contain the type of
flow that is referenced.
process_type: ProcessType
In case of a reference to a process, this fiel can contain the type of
process that is referenced.
"""
olca_type: str = 'Ref'
category_path: Optional[List[str]] = None
library: Optional[str] = None
ref_unit: Optional[str] = None
location: Optional[str] = None
flow_type: Optional[FlowType] = None
process_type: Optional[ProcessType] = None
def to_json(self) -> dict:
json: dict = super(Ref, self).to_json()
if self.category_path is not None:
json['categoryPath'] = []
for e in self.category_path:
json['categoryPath'].append(e)
if self.library is not None:
json['library'] = self.library
if self.ref_unit is not None:
json['refUnit'] = self.ref_unit
if self.location is not None:
json['location'] = self.location
if self.flow_type is not None:
json['flowType'] = self.flow_type.value
if self.process_type is not None:
json['processType'] = self.process_type.value
return json
def read_json(self, json: dict):
super(Ref, self).read_json(json)
val = json.get('categoryPath')
if val is not None:
self.category_path = []
for d in val:
e = d
self.category_path.append(e)
val = json.get('library')
if val is not None:
self.library = val
val = json.get('refUnit')
if val is not None:
self.ref_unit = val
val = json.get('location')
if val is not None:
self.location = val
val = json.get('flowType')
if val is not None:
self.flow_type = FlowType(val)
val = json.get('processType')
if val is not None:
self.process_type = ProcessType(val)
@staticmethod
def from_json(json: dict):
instance = Ref()
instance.read_json(json)
return instance
@dataclass
class Unit(RootEntity):
"""
An unit of measure
Attributes
----------
conversion_factor: float
The conversion factor to the reference unit of the unit group to which
this unit belongs.
reference_unit: bool
Indicates whether the unit is the reference unit of the unit group to
which this unit belongs. If it is the reference unit the conversion
factor must be 1.0. There should be always only one reference unit in a
unit group. The reference unit is used to convert amounts given in one
unit to amounts given in another unit of the respective unit group.
synonyms: List[str]
A list of synonyms for the unit.
"""
olca_type: str = 'Unit'
conversion_factor: Optional[float] = None
reference_unit: Optional[bool] = None
synonyms: Optional[List[str]] = None
def to_json(self) -> dict:
json: dict = super(Unit, self).to_json()
if self.conversion_factor is not None:
json['conversionFactor'] = self.conversion_factor
if self.reference_unit is not None:
json['referenceUnit'] = self.reference_unit
if self.synonyms is not None:
json['synonyms'] = []
for e in self.synonyms:
json['synonyms'].append(e)
return json
def read_json(self, json: dict):
super(Unit, self).read_json(json)
val = json.get('conversionFactor')
if val is not None:
self.conversion_factor = val
val = json.get('referenceUnit')
if val is not None:
self.reference_unit = val
val = json.get('synonyms')
if val is not None:
self.synonyms = []
for d in val:
e = d
self.synonyms.append(e)
@staticmethod
def from_json(json: dict):
instance = Unit()
instance.read_json(json)
return instance
@dataclass
class Actor(CategorizedEntity):
"""
An actor is a person or organisation.
Attributes
----------
address: str
city: str
country: str
email: str
telefax: str
telephone: str
website: str
zip_code: str
"""
olca_type: str = 'Actor'
address: Optional[str] = None
city: Optional[str] = None
country: Optional[str] = None
email: Optional[str] = None
telefax: Optional[str] = None
telephone: Optional[str] = None
website: Optional[str] = None
zip_code: Optional[str] = None
def to_json(self) -> dict:
json: dict = super(Actor, self).to_json()
if self.address is not None:
json['address'] = self.address
if self.city is not None:
json['city'] = self.city
if self.country is not None:
json['country'] = self.country
if self.email is not None:
json['email'] = self.email
if self.telefax is not None:
json['telefax'] = self.telefax
if self.telephone is not None:
json['telephone'] = self.telephone
if self.website is not None:
json['website'] = self.website
if self.zip_code is not None:
json['zipCode'] = self.zip_code
return json
def read_json(self, json: dict):
super(Actor, self).read_json(json)
val = json.get('address')
if val is not None:
self.address = val
val = json.get('city')
if val is not None:
self.city = val
val = json.get('country')
if val is not None:
self.country = val
val = json.get('email')
if val is not None:
self.email = val
val = json.get('telefax')
if val is not None:
self.telefax = val
val = json.get('telephone')
if val is not None:
self.telephone = val
val = json.get('website')
if val is not None:
self.website = val
val = json.get('zipCode')
if val is not None:
self.zip_code = val
@staticmethod
def from_json(json: dict):
instance = Actor()
instance.read_json(json)
return instance
@dataclass
class Category(CategorizedEntity):
"""
A category is used for the categorisation of types like processes, flows,
etc. The tricky thing is that the `Category` class inherits also from the
[CategorizedEntity] type so that a category can have a category attribute
which is then the parent category of this category (uff).
Attributes
----------
model_type: ModelType
The type of models that can be linked to the category.
"""
olca_type: str = 'Category'
model_type: Optional[ModelType] = None
def to_json(self) -> dict:
json: dict = super(Category, self).to_json()
if self.model_type is not None:
json['modelType'] = self.model_type.value
return json
def read_json(self, json: dict):
super(Category, self).read_json(json)
val = json.get('modelType')
if val is not None:
self.model_type = ModelType(val)
@staticmethod
def from_json(json: dict):
instance = Category()
instance.read_json(json)
return instance
@dataclass
class Currency(CategorizedEntity):
"""
Attributes
----------
code: str
conversion_factor: float
reference_currency: Ref
"""
olca_type: str = 'Currency'
code: Optional[str] = None
conversion_factor: Optional[float] = None
reference_currency: Optional[Ref] = None
def to_json(self) -> dict:
json: dict = super(Currency, self).to_json()
if self.code is not None:
json['code'] = self.code
if self.conversion_factor is not None:
json['conversionFactor'] = self.conversion_factor
if self.reference_currency is not None:
json['referenceCurrency'] = self.reference_currency.to_json()
return json
def read_json(self, json: dict):
super(Currency, self).read_json(json)
val = json.get('code')
if val is not None:
self.code = val
val = json.get('conversionFactor')
if val is not None:
self.conversion_factor = val
val = json.get('referenceCurrency')
if val is not None:
self.reference_currency = Ref()
self.reference_currency.read_json(val)
@staticmethod
def from_json(json: dict):
instance = Currency()
instance.read_json(json)
return instance
@dataclass
class DQSystem(CategorizedEntity):
"""
A data quality system (DQS) in openLCA describes a pedigree matrix of $m$
data quality indicators (DQIs) and $n$ data quality scores (DQ scores).
Such a system can then be used to assess the data quality of processes and
exchanges by tagging them with an instance of the system $D$ where $D$ is a
$m * n$ matrix with an entry $d_{ij}$ containing the value of the data
quality score $j$ for indicator $i$. As each indicator in $D$ can only have
a single score value, $D$ can be stored in a vector $d$ where $d_i$
contains the data quality score for indicator $i$. The possible values of
the data quality scores are defined as a linear order $1 \dots n$. In
openLCA, the data quality entry $d$ of a process or exchange is stored as a
string like `(3;2;4;n.a.;2)` which means the data quality score for the
first indicator is `3`, for the second `2` etc. A specific value is `n.a.`
which stands for _not applicable_. In calculations, these data quality
entries can be aggregated in different ways. For example, the data quality
entry of a flow $f$ with a contribution of `0.5 kg` and a data quality
entry of `(3;2;4;n.a.;2)` in a process $p$ and a contribution of `1.5 kg`
and a data quality entry of `(2;3;1;n.a.;5)` in a process $q$ could be
aggregated to `(2;3;2;n.a.;4)` by applying an weighted average and
rounding. Finally, custom labels like `A, B, C, ...` or `Very good, Good,
Fair, ...` for the DQ scores can be assigned by the user. These labels are
then displayed instead of `1, 2, 3 ...` in the user interface or result
exports. However, internally the numeric values are used in the data model
and calculations.
Attributes
----------
has_uncertainties: bool
source: Ref
indicators: List[DQIndicator]
"""
olca_type: str = 'DQSystem'
has_uncertainties: Optional[bool] = None
source: Optional[Ref] = None
indicators: Optional[List[DQIndicator]] = None
def to_json(self) -> dict:
json: dict = super(DQSystem, self).to_json()
if self.has_uncertainties is not None:
json['hasUncertainties'] = self.has_uncertainties
if self.source is not None:
json['source'] = self.source.to_json()
if self.indicators is not None:
json['indicators'] = []
for e in self.indicators:
json['indicators'].append(e.to_json())
return json
def read_json(self, json: dict):
super(DQSystem, self).read_json(json)
val = json.get('hasUncertainties')
if val is not None:
self.has_uncertainties = val
val = json.get('source')
if val is not None:
self.source = Ref()
self.source.read_json(val)
val = json.get('indicators')
if val is not None:
self.indicators = []
for d in val:
e = DQIndicator()
e.read_json(d)
self.indicators.append(e)
@staticmethod
def from_json(json: dict):
instance = DQSystem()
instance.read_json(json)
return instance
@dataclass
class Flow(CategorizedEntity):
"""
Everything that can be an input or output of a process (e.g. a substance, a
product, a waste, a service etc.)
Attributes
----------
flow_type: FlowType
The type of the flow. Note that this type is more a descriptor of how
the flow is handled in calculations.
cas: str
A CAS number of the flow.
formula: str
A chemical formula of the flow.
flow_properties: List[FlowPropertyFactor]
The flow properties (quantities) in which amounts of the flow can be
expressed together with conversion factors between these flow flow
properties.
location: Ref
The location of the flow. Normally the location of a flow is defined by
the process location where the flow is an input or output. However,
some data formats define a location as a property of a flow.
synonyms: str
A list of synonyms but packed into a single field. Best is to use
semicolons as separator as commas are sometimes used in names of
chemicals.
infrastructure_flow: bool
Indicates whether this flow describes an infrastructure product. This
field is part of the openLCA schema because of backward compatibility
with EcoSpold 1. It does not really have a meaning in openLCA and
should not be used anymore.
"""
olca_type: str = 'Flow'
flow_type: Optional[FlowType] = None
cas: Optional[str] = None
formula: Optional[str] = None
flow_properties: Optional[List[FlowPropertyFactor]] = None
location: Optional[Ref] = None
synonyms: Optional[str] = None
infrastructure_flow: Optional[bool] = None
def to_json(self) -> dict:
json: dict = super(Flow, self).to_json()
if self.flow_type is not None:
json['flowType'] = self.flow_type.value
if self.cas is not None:
json['cas'] = self.cas
if self.formula is not None:
json['formula'] = self.formula
if self.flow_properties is not None:
json['flowProperties'] = []
for e in self.flow_properties:
json['flowProperties'].append(e.to_json())
if self.location is not None:
json['location'] = self.location.to_json()
if self.synonyms is not None:
json['synonyms'] = self.synonyms
if self.infrastructure_flow is not None:
json['infrastructureFlow'] = self.infrastructure_flow
return json
def read_json(self, json: dict):
super(Flow, self).read_json(json)
val = json.get('flowType')
if val is not None:
self.flow_type = FlowType(val)
val = json.get('cas')
if val is not None:
self.cas = val
val = json.get('formula')
if val is not None:
self.formula = val
val = json.get('flowProperties')
if val is not None:
self.flow_properties = []
for d in val:
e = FlowPropertyFactor()
e.read_json(d)
self.flow_properties.append(e)
val = json.get('location')
if val is not None:
self.location = Ref()
self.location.read_json(val)
val = json.get('synonyms')
if val is not None:
self.synonyms = val
val = json.get('infrastructureFlow')
if val is not None:
self.infrastructure_flow = val
@staticmethod
def from_json(json: dict):
instance = Flow()
instance.read_json(json)
return instance
@dataclass
class FlowProperty(CategorizedEntity):
"""
A flow property is a quantity that can be used to express amounts of a
flow.
Attributes
----------
flow_property_type: FlowPropertyType
The type of the flow property
unit_group: Ref
The units of measure that can be used to express quantities of the flow
property.
"""
olca_type: str = 'FlowProperty'
flow_property_type: Optional[FlowPropertyType] = None
unit_group: Optional[Ref] = None
def to_json(self) -> dict:
json: dict = super(FlowProperty, self).to_json()
if self.flow_property_type is not None:
json['flowPropertyType'] = self.flow_property_type.value
if self.unit_group is not None:
json['unitGroup'] = self.unit_group.to_json()
return json
def read_json(self, json: dict):
super(FlowProperty, self).read_json(json)
val = json.get('flowPropertyType')
if val is not None:
self.flow_property_type = FlowPropertyType(val)
val = json.get('unitGroup')
if val is not None:
self.unit_group = Ref()
self.unit_group.read_json(val)
@staticmethod
def from_json(json: dict):
instance = FlowProperty()
instance.read_json(json)
return instance
@dataclass
class ImpactCategory(CategorizedEntity):
"""
Attributes
----------
reference_unit_name: str
The name of the reference unit of the LCIA category (e.g. kg CO2-eq.).
parameters: List[Parameter]
A set of parameters which can be used in formulas of the
characterisation factors in this impact category.
impact_factors: List[ImpactFactor]
The characterisation factors of the LCIA category.
"""
olca_type: str = 'ImpactCategory'
reference_unit_name: Optional[str] = None
parameters: Optional[List[Parameter]] = None
impact_factors: Optional[List[ImpactFactor]] = None
def to_json(self) -> dict:
json: dict = super(ImpactCategory, self).to_json()
if self.reference_unit_name is not None:
json['referenceUnitName'] = self.reference_unit_name
if self.parameters is not None:
json['parameters'] = []
for e in self.parameters:
json['parameters'].append(e.to_json())
if self.impact_factors is not None:
json['impactFactors'] = []
for e in self.impact_factors:
json['impactFactors'].append(e.to_json())
return json
def read_json(self, json: dict):
super(ImpactCategory, self).read_json(json)
val = json.get('referenceUnitName')
if val is not None:
self.reference_unit_name = val
val = json.get('parameters')
if val is not None:
self.parameters = []
for d in val:
e = Parameter()
e.read_json(d)
self.parameters.append(e)
val = json.get('impactFactors')
if val is not None:
self.impact_factors = []
for d in val:
e = ImpactFactor()
e.read_json(d)
self.impact_factors.append(e)
@staticmethod
def from_json(json: dict):
instance = ImpactCategory()
instance.read_json(json)
return instance
@dataclass
class ImpactMethod(CategorizedEntity):
"""
An impact assessment method.
Attributes
----------
impact_categories: List[Ref]
The impact categories of the method.
nw_sets: List[NwSet]
The normalization and weighting sets of the method.
"""
olca_type: str = 'ImpactMethod'
impact_categories: Optional[List[Ref]] = None
nw_sets: Optional[List[NwSet]] = None
def to_json(self) -> dict:
json: dict = super(ImpactMethod, self).to_json()
if self.impact_categories is not None:
json['impactCategories'] = []
for e in self.impact_categories:
json['impactCategories'].append(e.to_json())
if self.nw_sets is not None:
json['nwSets'] = []
for e in self.nw_sets:
json['nwSets'].append(e.to_json())
return json
def read_json(self, json: dict):
super(ImpactMethod, self).read_json(json)
val = json.get('impactCategories')
if val is not None:
self.impact_categories = []
for d in val:
e = Ref()
e.read_json(d)
self.impact_categories.append(e)
val = json.get('nwSets')
if val is not None:
self.nw_sets = []
for d in val:
e = NwSet()
e.read_json(d)
self.nw_sets.append(e)
@staticmethod
def from_json(json: dict):
instance = ImpactMethod()
instance.read_json(json)
return instance
@dataclass
class Location(CategorizedEntity):
"""
A location like a country, state, city, etc.
Attributes
----------
code: str
The code of the location (e.g. an ISO 2-letter country code).
latitude: float
The average latitude of the location.
longitude: float
The average longitude of the location.
geometry: dict
A GeoJSON object.
"""
olca_type: str = 'Location'
code: Optional[str] = None
latitude: Optional[float] = None
longitude: Optional[float] = None
geometry: Optional[dict] = None
def to_json(self) -> dict:
json: dict = super(Location, self).to_json()
if self.code is not None:
json['code'] = self.code
if self.latitude is not None:
json['latitude'] = self.latitude
if self.longitude is not None:
json['longitude'] = self.longitude
if self.geometry is not None:
json['geometry'] = self.geometry
return json
def read_json(self, json: dict):
super(Location, self).read_json(json)
val = json.get('code')
if val is not None:
self.code = val
val = json.get('latitude')
if val is not None:
self.latitude = val
val = json.get('longitude')
if val is not None:
self.longitude = val
val = json.get('geometry')
if val is not None:
self.geometry = val
@staticmethod
def from_json(json: dict):
instance = Location()
instance.read_json(json)
return instance
@dataclass
class Parameter(CategorizedEntity):
"""
In openLCA, parameters can be defined in different scopes: global, process,
or LCIA method. The parameter name can be used in formulas and, thus, need
to conform to a specific syntax. Within a scope the parameter name should
be unique (otherwise the evaluation is not deterministic). There are two
types of parameters in openLCA: input parameters and dependent parameters.
An input parameter can have an optional uncertainty distribution but not a
formula. A dependent parameter can (should) have a formula (where also
other parameters can be used) but no uncertainty distribution.
Attributes
----------
parameter_scope: ParameterScope
The scope where the parameter is valid.
input_parameter: bool
Indicates whether the parameter is an input parameter (true) or a
dependent/calculated parameter (false). A parameter can have a formula
if it is not an input parameter.
value: float
The parameter value.
formula: str
A mathematical expression to calculate the parameter value.
uncertainty: Uncertainty
An uncertainty distribution of the parameter value. This is only valid
for input parameters.
"""
olca_type: str = 'Parameter'
parameter_scope: Optional[ParameterScope] = None
input_parameter: Optional[bool] = None
value: Optional[float] = None
formula: Optional[str] = None
uncertainty: Optional[Uncertainty] = None
def to_json(self) -> dict:
json: dict = super(Parameter, self).to_json()
if self.parameter_scope is not None:
json['parameterScope'] = self.parameter_scope.value
if self.input_parameter is not None:
json['inputParameter'] = self.input_parameter
if self.value is not None:
json['value'] = self.value
if self.formula is not None:
json['formula'] = self.formula
if self.uncertainty is not None:
json['uncertainty'] = self.uncertainty.to_json()
return json
def read_json(self, json: dict):
super(Parameter, self).read_json(json)
val = json.get('parameterScope')
if val is not None:
self.parameter_scope = ParameterScope(val)
val = json.get('inputParameter')
if val is not None:
self.input_parameter = val
val = json.get('value')
if val is not None:
self.value = val
val = json.get('formula')
if val is not None:
self.formula = val
val = json.get('uncertainty')
if val is not None:
self.uncertainty = Uncertainty()
self.uncertainty.read_json(val)
@staticmethod
def from_json(json: dict):
instance = Parameter()
instance.read_json(json)
return instance
@dataclass
class Process(CategorizedEntity):
"""
Attributes
----------
allocation_factors: List[AllocationFactor]
default_allocation_method: AllocationType
exchanges: List[Exchange]
The inputs and outputs of the process.
last_internal_id: int
This field holds the last internal ID that was used in an exchange
(which may have been deleted, so it can be larger than the largest
internal ID of the exchanges of the process.) The internal ID of an
exchange is used to identify exchanges within a process (for updates,
data exchanges (see process links), etc.). When you add an exchange to
a process, you should increment this field in the process and set the
resulting value as the internal ID of that exchange. The sequence of
internal IDs should start with `1`.
location: Ref
The location of the process.
parameters: List[Parameter]
process_documentation: ProcessDocumentation
process_type: ProcessType
dq_system: Ref
A reference to a data quality system ([DQSystem]) with which the
overall quality of the process can be assessed.
exchange_dq_system: Ref
A reference to a data quality system ([DQSystem]) with which the
quality of individual inputs and outputs ([Exchange]s) of the process
can be assessed.
social_dq_system: Ref
A reference to a data quality system ([DQSystem]) with which the
quality of individual social aspects of the process can be assessed.
dq_entry: str
A data quality entry like `(1;3;2;5;1)`. The entry is a vector of data
quality values that need to match the overall data quality system of
the process (the system that is stored in the `dqSystem` property). In
such a system the data quality indicators have fixed positions and the
respective values in the `dqEntry` vector map to these positions.
infrastructure_process: bool
Indicates whether this process describes an infrastructure process.
This field is part of the openLCA schema because of backward
compatibility with EcoSpold 1. It does not really have a meaning in
openLCA and should not be used anymore.
social_aspects: List[SocialAspect]
A set of social aspects related to this process.
"""
olca_type: str = 'Process'
allocation_factors: Optional[List[AllocationFactor]] = None
default_allocation_method: Optional[AllocationType] = None
exchanges: Optional[List[Exchange]] = None
last_internal_id: Optional[int] = None
location: Optional[Ref] = None
parameters: Optional[List[Parameter]] = None
process_documentation: Optional[ProcessDocumentation] = None
process_type: Optional[ProcessType] = None
dq_system: Optional[Ref] = None
exchange_dq_system: Optional[Ref] = None
social_dq_system: Optional[Ref] = None
dq_entry: Optional[str] = None
infrastructure_process: Optional[bool] = None
social_aspects: Optional[List[SocialAspect]] = None
def to_json(self) -> dict:
json: dict = super(Process, self).to_json()
if self.allocation_factors is not None:
json['allocationFactors'] = []
for e in self.allocation_factors:
json['allocationFactors'].append(e.to_json())
if self.default_allocation_method is not None:
json['defaultAllocationMethod'] = self.default_allocation_method.value
if self.exchanges is not None:
json['exchanges'] = []
for e in self.exchanges:
json['exchanges'].append(e.to_json())
if self.last_internal_id is not None:
json['lastInternalId'] = self.last_internal_id
if self.location is not None:
json['location'] = self.location.to_json()
if self.parameters is not None:
json['parameters'] = []
for e in self.parameters:
json['parameters'].append(e.to_json())
if self.process_documentation is not None:
json['processDocumentation'] = self.process_documentation.to_json()
if self.process_type is not None:
json['processType'] = self.process_type.value
if self.dq_system is not None:
json['dqSystem'] = self.dq_system.to_json()
if self.exchange_dq_system is not None:
json['exchangeDqSystem'] = self.exchange_dq_system.to_json()
if self.social_dq_system is not None:
json['socialDqSystem'] = self.social_dq_system.to_json()
if self.dq_entry is not None:
json['dqEntry'] = self.dq_entry
if self.infrastructure_process is not None:
json['infrastructureProcess'] = self.infrastructure_process
if self.social_aspects is not None:
json['socialAspects'] = []
for e in self.social_aspects:
json['socialAspects'].append(e.to_json())
return json
def read_json(self, json: dict):
super(Process, self).read_json(json)
val = json.get('allocationFactors')
if val is not None:
self.allocation_factors = []
for d in val:
e = AllocationFactor()
e.read_json(d)
self.allocation_factors.append(e)
val = json.get('defaultAllocationMethod')
if val is not None:
self.default_allocation_method = AllocationType(val)
val = json.get('exchanges')
if val is not None:
self.exchanges = []
for d in val:
e = Exchange()
e.read_json(d)
self.exchanges.append(e)
val = json.get('lastInternalId')
if val is not None:
self.last_internal_id = val
val = json.get('location')
if val is not None:
self.location = Ref()
self.location.read_json(val)
val = json.get('parameters')
if val is not None:
self.parameters = []
for d in val:
e = Parameter()
e.read_json(d)
self.parameters.append(e)
val = json.get('processDocumentation')
if val is not None:
self.process_documentation = ProcessDocumentation()
self.process_documentation.read_json(val)
val = json.get('processType')
if val is not None:
self.process_type = ProcessType(val)
val = json.get('dqSystem')
if val is not None:
self.dq_system = Ref()
self.dq_system.read_json(val)
val = json.get('exchangeDqSystem')
if val is not None:
self.exchange_dq_system = Ref()
self.exchange_dq_system.read_json(val)
val = json.get('socialDqSystem')
if val is not None:
self.social_dq_system = Ref()
self.social_dq_system.read_json(val)
val = json.get('dqEntry')
if val is not None:
self.dq_entry = val
val = json.get('infrastructureProcess')
if val is not None:
self.infrastructure_process = val
val = json.get('socialAspects')
if val is not None:
self.social_aspects = []
for d in val:
e = SocialAspect()
e.read_json(d)
self.social_aspects.append(e)
@staticmethod
def from_json(json: dict):
instance = Process()
instance.read_json(json)
return instance
@dataclass
class ProductSystem(CategorizedEntity):
"""
A product system describes the supply chain of a product (the functional
unit) ...
Attributes
----------
processes: List[Ref]
The descriptors of all processes and sub-systems that are contained in
the product system.
reference_process: Ref
The descriptor of the process that provides the flow of the functional
unit of the product system.
reference_exchange: ExchangeRef
The exchange of the reference processes (typically the product output)
that provides the flow of the functional unit of the product system.
target_amount: float
The flow amount of the functional unit of the product system.
target_unit: Ref
The unit in which the flow amount of the functional unit is given.
target_flow_property: Ref
The flow property in which the flow amount of the functional unit is
given.
process_links: List[ProcessLink]
The process links of the product system.
parameter_sets: List[ParameterRedefSet]
A list of possible sets of parameter redefinitions for this product
system.
"""
olca_type: str = 'ProductSystem'
processes: Optional[List[Ref]] = None
reference_process: Optional[Ref] = None
reference_exchange: Optional[ExchangeRef] = None
target_amount: Optional[float] = None
target_unit: Optional[Ref] = None
target_flow_property: Optional[Ref] = None
process_links: Optional[List[ProcessLink]] = None
parameter_sets: Optional[List[ParameterRedefSet]] = None
def to_json(self) -> dict:
json: dict = super(ProductSystem, self).to_json()
if self.processes is not None:
json['processes'] = []
for e in self.processes:
json['processes'].append(e.to_json())
if self.reference_process is not None:
json['referenceProcess'] = self.reference_process.to_json()
if self.reference_exchange is not None:
json['referenceExchange'] = self.reference_exchange.to_json()
if self.target_amount is not None:
json['targetAmount'] = self.target_amount
if self.target_unit is not None:
json['targetUnit'] = self.target_unit.to_json()
if self.target_flow_property is not None:
json['targetFlowProperty'] = self.target_flow_property.to_json()
if self.process_links is not None:
json['processLinks'] = []
for e in self.process_links:
json['processLinks'].append(e.to_json())
if self.parameter_sets is not None:
json['parameterSets'] = []
for e in self.parameter_sets:
json['parameterSets'].append(e.to_json())
return json
def read_json(self, json: dict):
super(ProductSystem, self).read_json(json)
val = json.get('processes')
if val is not None:
self.processes = []
for d in val:
e = Ref()
e.read_json(d)
self.processes.append(e)
val = json.get('referenceProcess')
if val is not None:
self.reference_process = Ref()
self.reference_process.read_json(val)
val = json.get('referenceExchange')
if val is not None:
self.reference_exchange = ExchangeRef()
self.reference_exchange.read_json(val)
val = json.get('targetAmount')
if val is not None:
self.target_amount = val
val = json.get('targetUnit')
if val is not None:
self.target_unit = Ref()
self.target_unit.read_json(val)
val = json.get('targetFlowProperty')
if val is not None:
self.target_flow_property = Ref()
self.target_flow_property.read_json(val)
val = json.get('processLinks')
if val is not None:
self.process_links = []
for d in val:
e = ProcessLink()
e.read_json(d)
self.process_links.append(e)
val = json.get('parameterSets')
if val is not None:
self.parameter_sets = []
for d in val:
e = ParameterRedefSet()
e.read_json(d)
self.parameter_sets.append(e)
@staticmethod
def from_json(json: dict):
instance = ProductSystem()
instance.read_json(json)
return instance
@dataclass
class Project(CategorizedEntity):
"""
Attributes
----------
impact_method: Ref
nw_set: NwSet
"""
olca_type: str = 'Project'
impact_method: Optional[Ref] = None
nw_set: Optional[NwSet] = None
def to_json(self) -> dict:
json: dict = super(Project, self).to_json()
if self.impact_method is not None:
json['impactMethod'] = self.impact_method.to_json()
if self.nw_set is not None:
json['nwSet'] = self.nw_set.to_json()
return json
def read_json(self, json: dict):
super(Project, self).read_json(json)
val = json.get('impactMethod')
if val is not None:
self.impact_method = Ref()
self.impact_method.read_json(val)
val = json.get('nwSet')
if val is not None:
self.nw_set = NwSet()
self.nw_set.read_json(val)
@staticmethod
def from_json(json: dict):
instance = Project()
instance.read_json(json)
return instance
@dataclass
class SocialIndicator(CategorizedEntity):
"""
Attributes
----------
activity_variable: str
The name of the activity variable of the indicator.
activity_quantity: Ref
The quantity of the activity variable.
activity_unit: Ref
The unit of the activity variable.
unit_of_measurement: str
The unit in which the indicator is measured.
evaluation_scheme: str
Documentation of the evaluation scheme of the indicator.
"""
olca_type: str = 'SocialIndicator'
activity_variable: Optional[str] = None
activity_quantity: Optional[Ref] = None
activity_unit: Optional[Ref] = None
unit_of_measurement: Optional[str] = None
evaluation_scheme: Optional[str] = None
def to_json(self) -> dict:
json: dict = super(SocialIndicator, self).to_json()
if self.activity_variable is not None:
json['activityVariable'] = self.activity_variable
if self.activity_quantity is not None:
json['activityQuantity'] = self.activity_quantity.to_json()
if self.activity_unit is not None:
json['activityUnit'] = self.activity_unit.to_json()
if self.unit_of_measurement is not None:
json['unitOfMeasurement'] = self.unit_of_measurement
if self.evaluation_scheme is not None:
json['evaluationScheme'] = self.evaluation_scheme
return json
def read_json(self, json: dict):
super(SocialIndicator, self).read_json(json)
val = json.get('activityVariable')
if val is not None:
self.activity_variable = val
val = json.get('activityQuantity')
if val is not None:
self.activity_quantity = Ref()
self.activity_quantity.read_json(val)
val = json.get('activityUnit')
if val is not None:
self.activity_unit = Ref()
self.activity_unit.read_json(val)
val = json.get('unitOfMeasurement')
if val is not None:
self.unit_of_measurement = val
val = json.get('evaluationScheme')
if val is not None:
self.evaluation_scheme = val
@staticmethod
def from_json(json: dict):
instance = SocialIndicator()
instance.read_json(json)
return instance
@dataclass
class Source(CategorizedEntity):
"""
A source is a literature reference.
Attributes
----------
url: str
A URL that points to the source.
text_reference: str
The full text reference of the source.
year: int
The publication year of the source.
external_file: str
A direct link (relative or absolute URL) to the source file.
"""
olca_type: str = 'Source'
url: Optional[str] = None
text_reference: Optional[str] = None
year: Optional[int] = None
external_file: Optional[str] = None
def to_json(self) -> dict:
json: dict = super(Source, self).to_json()
if self.url is not None:
json['url'] = self.url
if self.text_reference is not None:
json['textReference'] = self.text_reference
if self.year is not None:
json['year'] = self.year
if self.external_file is not None:
json['externalFile'] = self.external_file
return json
def read_json(self, json: dict):
super(Source, self).read_json(json)
val = json.get('url')
if val is not None:
self.url = val
val = json.get('textReference')
if val is not None:
self.text_reference = val
val = json.get('year')
if val is not None:
self.year = val
val = json.get('externalFile')
if val is not None:
self.external_file = val
@staticmethod
def from_json(json: dict):
instance = Source()
instance.read_json(json)
return instance
@dataclass
class UnitGroup(CategorizedEntity):
"""
A group of units that can be converted into each other.
Attributes
----------
default_flow_property: Ref
Some LCA data formats do not have the concept of flow properties or
quantities. This field provides a default link to a flow property for
units that are contained in this group.
units: List[Unit]
The units of the unit group.
"""
olca_type: str = 'UnitGroup'
default_flow_property: Optional[Ref] = None
units: Optional[List[Unit]] = None
def to_json(self) -> dict:
json: dict = super(UnitGroup, self).to_json()
if self.default_flow_property is not None:
json['defaultFlowProperty'] = self.default_flow_property.to_json()
if self.units is not None:
json['units'] = []
for e in self.units:
json['units'].append(e.to_json())
return json
def read_json(self, json: dict):
super(UnitGroup, self).read_json(json)
val = json.get('defaultFlowProperty')
if val is not None:
self.default_flow_property = Ref()
self.default_flow_property.read_json(val)
val = json.get('units')
if val is not None:
self.units = []
for d in val:
e = Unit()
e.read_json(d)
self.units.append(e)
@staticmethod
def from_json(json: dict):
instance = UnitGroup()
instance.read_json(json)
return instanceClasses
class Actor (id: str = '', olca_type: str = 'Actor', name: Optional[str] = None, description: Optional[str] = None, version: Optional[str] = None, last_change: Optional[str] = None, category: Optional[Ref] = None, tags: Optional[List[str]] = None, library: Optional[str] = None, address: Optional[str] = None, city: Optional[str] = None, country: Optional[str] = None, email: Optional[str] = None, telefax: Optional[str] = None, telephone: Optional[str] = None, website: Optional[str] = None, zip_code: Optional[str] = None)-
An actor is a person or organisation.
Attributes
address:strcity:strcountry:stremail:strtelefax:strtelephone:strwebsite:strzip_code:str
Expand source code
@dataclass class Actor(CategorizedEntity): """ An actor is a person or organisation. Attributes ---------- address: str city: str country: str email: str telefax: str telephone: str website: str zip_code: str """ olca_type: str = 'Actor' address: Optional[str] = None city: Optional[str] = None country: Optional[str] = None email: Optional[str] = None telefax: Optional[str] = None telephone: Optional[str] = None website: Optional[str] = None zip_code: Optional[str] = None def to_json(self) -> dict: json: dict = super(Actor, self).to_json() if self.address is not None: json['address'] = self.address if self.city is not None: json['city'] = self.city if self.country is not None: json['country'] = self.country if self.email is not None: json['email'] = self.email if self.telefax is not None: json['telefax'] = self.telefax if self.telephone is not None: json['telephone'] = self.telephone if self.website is not None: json['website'] = self.website if self.zip_code is not None: json['zipCode'] = self.zip_code return json def read_json(self, json: dict): super(Actor, self).read_json(json) val = json.get('address') if val is not None: self.address = val val = json.get('city') if val is not None: self.city = val val = json.get('country') if val is not None: self.country = val val = json.get('email') if val is not None: self.email = val val = json.get('telefax') if val is not None: self.telefax = val val = json.get('telephone') if val is not None: self.telephone = val val = json.get('website') if val is not None: self.website = val val = json.get('zipCode') if val is not None: self.zip_code = val @staticmethod def from_json(json: dict): instance = Actor() instance.read_json(json) return instanceAncestors
Class variables
var address : Optional[str]var city : Optional[str]var country : Optional[str]var email : Optional[str]var olca_type : strvar telefax : Optional[str]var telephone : Optional[str]var website : Optional[str]var zip_code : Optional[str]
Static methods
def from_json(json: dict)-
Expand source code
@staticmethod def from_json(json: dict): instance = Actor() instance.read_json(json) return instance
Methods
def read_json(self, json: dict)-
Expand source code
def read_json(self, json: dict): super(Actor, self).read_json(json) val = json.get('address') if val is not None: self.address = val val = json.get('city') if val is not None: self.city = val val = json.get('country') if val is not None: self.country = val val = json.get('email') if val is not None: self.email = val val = json.get('telefax') if val is not None: self.telefax = val val = json.get('telephone') if val is not None: self.telephone = val val = json.get('website') if val is not None: self.website = val val = json.get('zipCode') if val is not None: self.zip_code = val def to_json(self) ‑> dict-
Expand source code
def to_json(self) -> dict: json: dict = super(Actor, self).to_json() if self.address is not None: json['address'] = self.address if self.city is not None: json['city'] = self.city if self.country is not None: json['country'] = self.country if self.email is not None: json['email'] = self.email if self.telefax is not None: json['telefax'] = self.telefax if self.telephone is not None: json['telephone'] = self.telephone if self.website is not None: json['website'] = self.website if self.zip_code is not None: json['zipCode'] = self.zip_code return json
class AllocationFactor (id: str = '', olca_type: str = 'AllocationFactor', allocation_type: Optional[AllocationType] = None, product: Optional[Ref] = None, value: Optional[float] = None, formula: Optional[str] = None, exchange: Optional[ExchangeRef] = None)-
A single allocation factor in a process.
Attributes
allocation_type:AllocationType- The type of allocation.
product:Ref- The output product (or waste input) to which this allocation factor is related. The must be an exchange with this product output (or waste input) in this process.
value:float- The value of the allocation factor.
formula:str- An optional formula from which the value of the allocation factor is calculated.
exchange:ExchangeRef- A product input, waste output, or elementary flow exchange which is allocated by this factor. This is only valid for causal allocation where allocation factors can be assigned to single exchanges.
Expand source code
@dataclass class AllocationFactor(Entity): """ A single allocation factor in a process. Attributes ---------- allocation_type: AllocationType The type of allocation. product: Ref The output product (or waste input) to which this allocation factor is related. The must be an exchange with this product output (or waste input) in this process. value: float The value of the allocation factor. formula: str An optional formula from which the value of the allocation factor is calculated. exchange: ExchangeRef A product input, waste output, or elementary flow exchange which is allocated by this factor. This is only valid for causal allocation where allocation factors can be assigned to single exchanges. """ olca_type: str = 'AllocationFactor' allocation_type: Optional[AllocationType] = None product: Optional[Ref] = None value: Optional[float] = None formula: Optional[str] = None exchange: Optional[ExchangeRef] = None def to_json(self) -> dict: json: dict = super(AllocationFactor, self).to_json() if self.allocation_type is not None: json['allocationType'] = self.allocation_type.value if self.product is not None: json['product'] = self.product.to_json() if self.value is not None: json['value'] = self.value if self.formula is not None: json['formula'] = self.formula if self.exchange is not None: json['exchange'] = self.exchange.to_json() return json def read_json(self, json: dict): super(AllocationFactor, self).read_json(json) val = json.get('allocationType') if val is not None: self.allocation_type = AllocationType(val) val = json.get('product') if val is not None: self.product = Ref() self.product.read_json(val) val = json.get('value') if val is not None: self.value = val val = json.get('formula') if val is not None: self.formula = val val = json.get('exchange') if val is not None: self.exchange = ExchangeRef() self.exchange.read_json(val) @staticmethod def from_json(json: dict): instance = AllocationFactor() instance.read_json(json) return instanceAncestors
Class variables
var allocation_type : Optional[AllocationType]var exchange : Optional[ExchangeRef]var formula : Optional[str]var olca_type : strvar product : Optional[Ref]var value : Optional[float]
Static methods
def from_json(json: dict)-
Expand source code
@staticmethod def from_json(json: dict): instance = AllocationFactor() instance.read_json(json) return instance
Methods
def read_json(self, json: dict)-
Expand source code
def read_json(self, json: dict): super(AllocationFactor, self).read_json(json) val = json.get('allocationType') if val is not None: self.allocation_type = AllocationType(val) val = json.get('product') if val is not None: self.product = Ref() self.product.read_json(val) val = json.get('value') if val is not None: self.value = val val = json.get('formula') if val is not None: self.formula = val val = json.get('exchange') if val is not None: self.exchange = ExchangeRef() self.exchange.read_json(val) def to_json(self) ‑> dict-
Expand source code
def to_json(self) -> dict: json: dict = super(AllocationFactor, self).to_json() if self.allocation_type is not None: json['allocationType'] = self.allocation_type.value if self.product is not None: json['product'] = self.product.to_json() if self.value is not None: json['value'] = self.value if self.formula is not None: json['formula'] = self.formula if self.exchange is not None: json['exchange'] = self.exchange.to_json() return json
class AllocationType (value, names=None, *, module=None, qualname=None, type=None, start=1)-
An enumeration type for allocation methods. This type is used to define the type of an [AllocationFactor], the default allocation method of a multi-functional [Process], or the allocation method in a [CalculationSetup].
Expand source code
class AllocationType(Enum): """ An enumeration type for allocation methods. This type is used to define the type of an [AllocationFactor], the default allocation method of a multi-functional [Process], or the allocation method in a [CalculationSetup]. """ PHYSICAL_ALLOCATION = 'PHYSICAL_ALLOCATION' ECONOMIC_ALLOCATION = 'ECONOMIC_ALLOCATION' CAUSAL_ALLOCATION = 'CAUSAL_ALLOCATION' USE_DEFAULT_ALLOCATION = 'USE_DEFAULT_ALLOCATION' NO_ALLOCATION = 'NO_ALLOCATION'Ancestors
- enum.Enum
Class variables
var CAUSAL_ALLOCATIONvar ECONOMIC_ALLOCATIONvar NO_ALLOCATIONvar PHYSICAL_ALLOCATIONvar USE_DEFAULT_ALLOCATION
class CalculationSetup (id: str = '', olca_type: str = 'CalculationSetup', calculation_type: Optional[CalculationType] = None, product_system: Optional[Ref] = None, impact_method: Optional[Ref] = None, with_costs: Optional[bool] = None, with_regionalization: Optional[bool] = None, nw_set: Optional[Ref] = None, allocation_method: Optional[AllocationType] = None, parameter_redefs: Optional[List[ParameterRedef]] = None, amount: Optional[float] = None, unit: Optional[Ref] = None, flow_property: Optional[Ref] = None)-
A setup for a product system calculation.
Attributes
calculation_type:CalculationType- The type of calculation that should be performed.
product_system:Ref- The product system that should be calculated (required).
impact_method:Ref- The LCIA method for the calculation (optional).
with_costs:bool- Indicates whether life cycle costs should be also calculated (optional).
with_regionalization:bool- Indicates whether a regionalized result should be calculated or not. If this is set to true, the intervention matrix is indexed by (elementary flow, location) - pairs instead of just elementary flows. The LCI result then contains results for these pairs which can be then used in regionalized impact assessments.
nw_set:Ref- The normalisation and weighting set for the calculation (optional).
allocation_method:AllocationType- The calculation type to be used in the calculation (optional).
parameter_redefs:List[ParameterRedef]- A list of parameter redefinitions to be used in the calculation (optional).
amount:float- (optional)
unit:Ref- (optional)
flow_property:Ref- (optional)
Expand source code
@dataclass class CalculationSetup(Entity): """ A setup for a product system calculation. Attributes ---------- calculation_type: CalculationType The type of calculation that should be performed. product_system: Ref The product system that should be calculated (required). impact_method: Ref The LCIA method for the calculation (optional). with_costs: bool Indicates whether life cycle costs should be also calculated (optional). with_regionalization: bool Indicates whether a regionalized result should be calculated or not. If this is set to true, the intervention matrix is indexed by (elementary flow, location) - pairs instead of just elementary flows. The LCI result then contains results for these pairs which can be then used in regionalized impact assessments. nw_set: Ref The normalisation and weighting set for the calculation (optional). allocation_method: AllocationType The calculation type to be used in the calculation (optional). parameter_redefs: List[ParameterRedef] A list of parameter redefinitions to be used in the calculation (optional). amount: float (optional) unit: Ref (optional) flow_property: Ref (optional) """ olca_type: str = 'CalculationSetup' calculation_type: Optional[CalculationType] = None product_system: Optional[Ref] = None impact_method: Optional[Ref] = None with_costs: Optional[bool] = None with_regionalization: Optional[bool] = None nw_set: Optional[Ref] = None allocation_method: Optional[AllocationType] = None parameter_redefs: Optional[List[ParameterRedef]] = None amount: Optional[float] = None unit: Optional[Ref] = None flow_property: Optional[Ref] = None def to_json(self) -> dict: json: dict = super(CalculationSetup, self).to_json() if self.calculation_type is not None: json['calculationType'] = self.calculation_type.value if self.product_system is not None: json['productSystem'] = self.product_system.to_json() if self.impact_method is not None: json['impactMethod'] = self.impact_method.to_json() if self.with_costs is not None: json['withCosts'] = self.with_costs if self.with_regionalization is not None: json['withRegionalization'] = self.with_regionalization if self.nw_set is not None: json['nwSet'] = self.nw_set.to_json() if self.allocation_method is not None: json['allocationMethod'] = self.allocation_method.value if self.parameter_redefs is not None: json['parameterRedefs'] = [] for e in self.parameter_redefs: json['parameterRedefs'].append(e.to_json()) if self.amount is not None: json['amount'] = self.amount if self.unit is not None: json['unit'] = self.unit.to_json() if self.flow_property is not None: json['flowProperty'] = self.flow_property.to_json() return json def read_json(self, json: dict): super(CalculationSetup, self).read_json(json) val = json.get('calculationType') if val is not None: self.calculation_type = CalculationType(val) val = json.get('productSystem') if val is not None: self.product_system = Ref() self.product_system.read_json(val) val = json.get('impactMethod') if val is not None: self.impact_method = Ref() self.impact_method.read_json(val) val = json.get('withCosts') if val is not None: self.with_costs = val val = json.get('withRegionalization') if val is not None: self.with_regionalization = val val = json.get('nwSet') if val is not None: self.nw_set = Ref() self.nw_set.read_json(val) val = json.get('allocationMethod') if val is not None: self.allocation_method = AllocationType(val) val = json.get('parameterRedefs') if val is not None: self.parameter_redefs = [] for d in val: e = ParameterRedef() e.read_json(d) self.parameter_redefs.append(e) val = json.get('amount') if val is not None: self.amount = val val = json.get('unit') if val is not None: self.unit = Ref() self.unit.read_json(val) val = json.get('flowProperty') if val is not None: self.flow_property = Ref() self.flow_property.read_json(val) @staticmethod def from_json(json: dict): instance = CalculationSetup() instance.read_json(json) return instanceAncestors
Class variables
var allocation_method : Optional[AllocationType]var amount : Optional[float]var calculation_type : Optional[CalculationType]var flow_property : Optional[Ref]var impact_method : Optional[Ref]var nw_set : Optional[Ref]var olca_type : strvar parameter_redefs : Optional[List[ParameterRedef]]var product_system : Optional[Ref]var unit : Optional[Ref]var with_costs : Optional[bool]var with_regionalization : Optional[bool]
Static methods
def from_json(json: dict)-
Expand source code
@staticmethod def from_json(json: dict): instance = CalculationSetup() instance.read_json(json) return instance
Methods
def read_json(self, json: dict)-
Expand source code
def read_json(self, json: dict): super(CalculationSetup, self).read_json(json) val = json.get('calculationType') if val is not None: self.calculation_type = CalculationType(val) val = json.get('productSystem') if val is not None: self.product_system = Ref() self.product_system.read_json(val) val = json.get('impactMethod') if val is not None: self.impact_method = Ref() self.impact_method.read_json(val) val = json.get('withCosts') if val is not None: self.with_costs = val val = json.get('withRegionalization') if val is not None: self.with_regionalization = val val = json.get('nwSet') if val is not None: self.nw_set = Ref() self.nw_set.read_json(val) val = json.get('allocationMethod') if val is not None: self.allocation_method = AllocationType(val) val = json.get('parameterRedefs') if val is not None: self.parameter_redefs = [] for d in val: e = ParameterRedef() e.read_json(d) self.parameter_redefs.append(e) val = json.get('amount') if val is not None: self.amount = val val = json.get('unit') if val is not None: self.unit = Ref() self.unit.read_json(val) val = json.get('flowProperty') if val is not None: self.flow_property = Ref() self.flow_property.read_json(val) def to_json(self) ‑> dict-
Expand source code
def to_json(self) -> dict: json: dict = super(CalculationSetup, self).to_json() if self.calculation_type is not None: json['calculationType'] = self.calculation_type.value if self.product_system is not None: json['productSystem'] = self.product_system.to_json() if self.impact_method is not None: json['impactMethod'] = self.impact_method.to_json() if self.with_costs is not None: json['withCosts'] = self.with_costs if self.with_regionalization is not None: json['withRegionalization'] = self.with_regionalization if self.nw_set is not None: json['nwSet'] = self.nw_set.to_json() if self.allocation_method is not None: json['allocationMethod'] = self.allocation_method.value if self.parameter_redefs is not None: json['parameterRedefs'] = [] for e in self.parameter_redefs: json['parameterRedefs'].append(e.to_json()) if self.amount is not None: json['amount'] = self.amount if self.unit is not None: json['unit'] = self.unit.to_json() if self.flow_property is not None: json['flowProperty'] = self.flow_property.to_json() return json
class CalculationType (value, names=None, *, module=None, qualname=None, type=None, start=1)-
An enumeration of the different calculation methods supported by openLCA.
Expand source code
class CalculationType(Enum): """ An enumeration of the different calculation methods supported by openLCA. """ SIMPLE_CALCULATION = 'SIMPLE_CALCULATION' """ Calculates the total results for elementary flows, LCIA indicators, costs, etc. of a product system. """ CONTRIBUTION_ANALYSIS = 'CONTRIBUTION_ANALYSIS' """ Includes the total result vectors of a simple calculation but calculates also the direct contributions of each process (or better process product in case of multi-output processes) to these total results. """ UPSTREAM_ANALYSIS = 'UPSTREAM_ANALYSIS' """ Extends the contribution analysis by providing also the upstream results of each process (process product) in the product system. The upstream result contains the direct contributions of the respective process but also the result of the supply chain up to this process scaled to the demand of the process in the product system. """ REGIONALIZED_CALCULATION = 'REGIONALIZED_CALCULATION' """ A regionalized calculation is a contribution analysis but with an LCIA method that supports regionalized characterization factors (via region specific parameters in formulas) and a product system with processes that have geographic information assigned (point, line, or polygon shapes). """ MONTE_CARLO_SIMULATION = 'MONTE_CARLO_SIMULATION' """ A Monte Carlo simulation generates for each run, of a given number of a given number of iterations, random values according to the uncertainty distributions of process inputs/outputs, parameters, characterization factors, etc. of a product system and then performs a simple calculation for that specific run. """Ancestors
- enum.Enum
Class variables
var CONTRIBUTION_ANALYSIS-
Includes the total result vectors of a simple calculation but calculates also the direct contributions of each process (or better process product in case of multi-output processes) to these total results.
var MONTE_CARLO_SIMULATION-
A Monte Carlo simulation generates for each run, of a given number of a given number of iterations, random values according to the uncertainty distributions of process inputs/outputs, parameters, characterization factors, etc. of a product system and then performs a simple calculation for that specific run.
var REGIONALIZED_CALCULATION-
A regionalized calculation is a contribution analysis but with an LCIA method that supports regionalized characterization factors (via region specific parameters in formulas) and a product system with processes that have geographic information assigned (point, line, or polygon shapes).
var SIMPLE_CALCULATION-
Calculates the total results for elementary flows, LCIA indicators, costs, etc. of a product system.
var UPSTREAM_ANALYSIS-
Extends the contribution analysis by providing also the upstream results of each process (process product) in the product system. The upstream result contains the direct contributions of the respective process but also the result of the supply chain up to this process scaled to the demand of the process in the product system.
class CategorizedEntity (id: str = '', olca_type: str = '', name: Optional[str] = None, description: Optional[str] = None, version: Optional[str] = None, last_change: Optional[str] = None, category: Optional[Ref] = None, tags: Optional[List[str]] = None, library: Optional[str] = None)-
A root entity which can have a category.
Attributes
category:Ref- The category of the entity.
tags:List[str]- A list of optional tags. A tag is just a string which should not contain commas (and other special characters).
library:str- If this entity is part of a library, this field contains the identifier of that library. The identifier is typically just the combination of the library name and version.
Expand source code
@dataclass class CategorizedEntity(RootEntity): """ A root entity which can have a category. Attributes ---------- category: Ref The category of the entity. tags: List[str] A list of optional tags. A tag is just a string which should not contain commas (and other special characters). library: str If this entity is part of a library, this field contains the identifier of that library. The identifier is typically just the combination of the library name and version. """ category: Optional[Ref] = None tags: Optional[List[str]] = None library: Optional[str] = None def to_json(self) -> dict: json: dict = super(CategorizedEntity, self).to_json() if self.category is not None: json['category'] = self.category.to_json() if self.tags is not None: json['tags'] = [] for e in self.tags: json['tags'].append(e) if self.library is not None: json['library'] = self.library return json def read_json(self, json: dict): super(CategorizedEntity, self).read_json(json) val = json.get('category') if val is not None: self.category = Ref() self.category.read_json(val) val = json.get('tags') if val is not None: self.tags = [] for d in val: e = d self.tags.append(e) val = json.get('library') if val is not None: self.library = val @staticmethod def from_json(json: dict): instance = CategorizedEntity() instance.read_json(json) return instanceAncestors
Subclasses
- Actor
- Category
- Currency
- DQSystem
- Flow
- FlowProperty
- ImpactCategory
- ImpactMethod
- Location
- Parameter
- Process
- ProductSystem
- Project
- SocialIndicator
- Source
- UnitGroup
Class variables
var category : Optional[Ref]var library : Optional[str]
Static methods
def from_json(json: dict)-
Expand source code
@staticmethod def from_json(json: dict): instance = CategorizedEntity() instance.read_json(json) return instance
Methods
def read_json(self, json: dict)-
Expand source code
def read_json(self, json: dict): super(CategorizedEntity, self).read_json(json) val = json.get('category') if val is not None: self.category = Ref() self.category.read_json(val) val = json.get('tags') if val is not None: self.tags = [] for d in val: e = d self.tags.append(e) val = json.get('library') if val is not None: self.library = val def to_json(self) ‑> dict-
Expand source code
def to_json(self) -> dict: json: dict = super(CategorizedEntity, self).to_json() if self.category is not None: json['category'] = self.category.to_json() if self.tags is not None: json['tags'] = [] for e in self.tags: json['tags'].append(e) if self.library is not None: json['library'] = self.library return json
class Category (id: str = '', olca_type: str = 'Category', name: Optional[str] = None, description: Optional[str] = None, version: Optional[str] = None, last_change: Optional[str] = None, category: Optional[Ref] = None, tags: Optional[List[str]] = None, library: Optional[str] = None, model_type: Optional[ModelType] = None)-
A category is used for the categorisation of types like processes, flows, etc. The tricky thing is that the
Categoryclass inherits also from the [CategorizedEntity] type so that a category can have a category attribute which is then the parent category of this category (uff).Attributes
model_type:ModelType- The type of models that can be linked to the category.
Expand source code
@dataclass class Category(CategorizedEntity): """ A category is used for the categorisation of types like processes, flows, etc. The tricky thing is that the `Category` class inherits also from the [CategorizedEntity] type so that a category can have a category attribute which is then the parent category of this category (uff). Attributes ---------- model_type: ModelType The type of models that can be linked to the category. """ olca_type: str = 'Category' model_type: Optional[ModelType] = None def to_json(self) -> dict: json: dict = super(Category, self).to_json() if self.model_type is not None: json['modelType'] = self.model_type.value return json def read_json(self, json: dict): super(Category, self).read_json(json) val = json.get('modelType') if val is not None: self.model_type = ModelType(val) @staticmethod def from_json(json: dict): instance = Category() instance.read_json(json) return instanceAncestors
Class variables
var model_type : Optional[ModelType]var olca_type : str
Static methods
def from_json(json: dict)-
Expand source code
@staticmethod def from_json(json: dict): instance = Category() instance.read_json(json) return instance
Methods
def read_json(self, json: dict)-
Expand source code
def read_json(self, json: dict): super(Category, self).read_json(json) val = json.get('modelType') if val is not None: self.model_type = ModelType(val) def to_json(self) ‑> dict-
Expand source code
def to_json(self) -> dict: json: dict = super(Category, self).to_json() if self.model_type is not None: json['modelType'] = self.model_type.value return json
class Currency (id: str = '', olca_type: str = 'Currency', name: Optional[str] = None, description: Optional[str] = None, version: Optional[str] = None, last_change: Optional[str] = None, category: Optional[Ref] = None, tags: Optional[List[str]] = None, library: Optional[str] = None, code: Optional[str] = None, conversion_factor: Optional[float] = None, reference_currency: Optional[Ref] = None)-
Attributes
code:strconversion_factor:floatreference_currency:Ref
Expand source code
@dataclass class Currency(CategorizedEntity): """ Attributes ---------- code: str conversion_factor: float reference_currency: Ref """ olca_type: str = 'Currency' code: Optional[str] = None conversion_factor: Optional[float] = None reference_currency: Optional[Ref] = None def to_json(self) -> dict: json: dict = super(Currency, self).to_json() if self.code is not None: json['code'] = self.code if self.conversion_factor is not None: json['conversionFactor'] = self.conversion_factor if self.reference_currency is not None: json['referenceCurrency'] = self.reference_currency.to_json() return json def read_json(self, json: dict): super(Currency, self).read_json(json) val = json.get('code') if val is not None: self.code = val val = json.get('conversionFactor') if val is not None: self.conversion_factor = val val = json.get('referenceCurrency') if val is not None: self.reference_currency = Ref() self.reference_currency.read_json(val) @staticmethod def from_json(json: dict): instance = Currency() instance.read_json(json) return instanceAncestors
Class variables
var code : Optional[str]var conversion_factor : Optional[float]var olca_type : strvar reference_currency : Optional[Ref]
Static methods
def from_json(json: dict)-
Expand source code
@staticmethod def from_json(json: dict): instance = Currency() instance.read_json(json) return instance
Methods
def read_json(self, json: dict)-
Expand source code
def read_json(self, json: dict): super(Currency, self).read_json(json) val = json.get('code') if val is not None: self.code = val val = json.get('conversionFactor') if val is not None: self.conversion_factor = val val = json.get('referenceCurrency') if val is not None: self.reference_currency = Ref() self.reference_currency.read_json(val) def to_json(self) ‑> dict-
Expand source code
def to_json(self) -> dict: json: dict = super(Currency, self).to_json() if self.code is not None: json['code'] = self.code if self.conversion_factor is not None: json['conversionFactor'] = self.conversion_factor if self.reference_currency is not None: json['referenceCurrency'] = self.reference_currency.to_json() return json
class DQIndicator (id: str = '', olca_type: str = 'DQIndicator', name: Optional[str] = None, position: Optional[int] = None, scores: Optional[List[DQScore]] = None)-
An indicator of a data quality system ([DQSystem]).
Attributes
name:strposition:intscores:List[DQScore]
Expand source code
@dataclass class DQIndicator(Entity): """ An indicator of a data quality system ([DQSystem]). Attributes ---------- name: str position: int scores: List[DQScore] """ olca_type: str = 'DQIndicator' name: Optional[str] = None position: Optional[int] = None scores: Optional[List[DQScore]] = None def to_json(self) -> dict: json: dict = super(DQIndicator, self).to_json() if self.name is not None: json['name'] = self.name if self.position is not None: json['position'] = self.position if self.scores is not None: json['scores'] = [] for e in self.scores: json['scores'].append(e.to_json()) return json def read_json(self, json: dict): super(DQIndicator, self).read_json(json) val = json.get('name') if val is not None: self.name = val val = json.get('position') if val is not None: self.position = val val = json.get('scores') if val is not None: self.scores = [] for d in val: e = DQScore() e.read_json(d) self.scores.append(e) @staticmethod def from_json(json: dict): instance = DQIndicator() instance.read_json(json) return instanceAncestors
Class variables
var name : Optional[str]var olca_type : strvar position : Optional[int]var scores : Optional[List[DQScore]]
Static methods
def from_json(json: dict)-
Expand source code
@staticmethod def from_json(json: dict): instance = DQIndicator() instance.read_json(json) return instance
Methods
def read_json(self, json: dict)-
Expand source code
def read_json(self, json: dict): super(DQIndicator, self).read_json(json) val = json.get('name') if val is not None: self.name = val val = json.get('position') if val is not None: self.position = val val = json.get('scores') if val is not None: self.scores = [] for d in val: e = DQScore() e.read_json(d) self.scores.append(e) def to_json(self) ‑> dict-
Expand source code
def to_json(self) -> dict: json: dict = super(DQIndicator, self).to_json() if self.name is not None: json['name'] = self.name if self.position is not None: json['position'] = self.position if self.scores is not None: json['scores'] = [] for e in self.scores: json['scores'].append(e.to_json()) return json
class DQScore (id: str = '', olca_type: str = 'DQScore', position: Optional[int] = None, label: Optional[str] = None, description: Optional[str] = None, uncertainty: Optional[float] = None)-
An score value of an indicator ([DQIndicator]) in a data quality system ([DQSystem]).
Attributes
position:intlabel:strdescription:struncertainty:float
Expand source code
@dataclass class DQScore(Entity): """ An score value of an indicator ([DQIndicator]) in a data quality system ([DQSystem]). Attributes ---------- position: int label: str description: str uncertainty: float """ olca_type: str = 'DQScore' position: Optional[int] = None label: Optional[str] = None description: Optional[str] = None uncertainty: Optional[float] = None def to_json(self) -> dict: json: dict = super(DQScore, self).to_json() if self.position is not None: json['position'] = self.position if self.label is not None: json['label'] = self.label if self.description is not None: json['description'] = self.description if self.uncertainty is not None: json['uncertainty'] = self.uncertainty return json def read_json(self, json: dict): super(DQScore, self).read_json(json) val = json.get('position') if val is not None: self.position = val val = json.get('label') if val is not None: self.label = val val = json.get('description') if val is not None: self.description = val val = json.get('uncertainty') if val is not None: self.uncertainty = val @staticmethod def from_json(json: dict): instance = DQScore() instance.read_json(json) return instanceAncestors
Class variables
var description : Optional[str]var label : Optional[str]var olca_type : strvar position : Optional[int]var uncertainty : Optional[float]
Static methods
def from_json(json: dict)-
Expand source code
@staticmethod def from_json(json: dict): instance = DQScore() instance.read_json(json) return instance
Methods
def read_json(self, json: dict)-
Expand source code
def read_json(self, json: dict): super(DQScore, self).read_json(json) val = json.get('position') if val is not None: self.position = val val = json.get('label') if val is not None: self.label = val val = json.get('description') if val is not None: self.description = val val = json.get('uncertainty') if val is not None: self.uncertainty = val def to_json(self) ‑> dict-
Expand source code
def to_json(self) -> dict: json: dict = super(DQScore, self).to_json() if self.position is not None: json['position'] = self.position if self.label is not None: json['label'] = self.label if self.description is not None: json['description'] = self.description if self.uncertainty is not None: json['uncertainty'] = self.uncertainty return json
class DQSystem (id: str = '', olca_type: str = 'DQSystem', name: Optional[str] = None, description: Optional[str] = None, version: Optional[str] = None, last_change: Optional[str] = None, category: Optional[Ref] = None, tags: Optional[List[str]] = None, library: Optional[str] = None, has_uncertainties: Optional[bool] = None, source: Optional[Ref] = None, indicators: Optional[List[DQIndicator]] = None)-
A data quality system (DQS) in openLCA describes a pedigree matrix of $m$ data quality indicators (DQIs) and $n$ data quality scores (DQ scores). Such a system can then be used to assess the data quality of processes and exchanges by tagging them with an instance of the system $D$ where $D$ is a $m * n$ matrix with an entry $d_{ij}$ containing the value of the data quality score $j$ for indicator $i$. As each indicator in $D$ can only have a single score value, $D$ can be stored in a vector $d$ where $d_i$ contains the data quality score for indicator $i$. The possible values of the data quality scores are defined as a linear order $1 \dots n$. In openLCA, the data quality entry $d$ of a process or exchange is stored as a string like
(3;2;4;n.a.;2)which means the data quality score for the first indicator is3, for the second2etc. A specific value isn.a.which stands for not applicable. In calculations, these data quality entries can be aggregated in different ways. For example, the data quality entry of a flow $f$ with a contribution of0.5 kgand a data quality entry of(3;2;4;n.a.;2)in a process $p$ and a contribution of1.5 kgand a data quality entry of(2;3;1;n.a.;5)in a process $q$ could be aggregated to(2;3;2;n.a.;4)by applying an weighted average and rounding. Finally, custom labels likeA, B, C, …orVery good, Good, Fair, ...for the DQ scores can be assigned by the user. These labels are then displayed instead of1, 2, 3 …in the user interface or result exports. However, internally the numeric values are used in the data model and calculations.Attributes
has_uncertainties:boolsource:Refindicators:List[DQIndicator]
Expand source code
@dataclass class DQSystem(CategorizedEntity): """ A data quality system (DQS) in openLCA describes a pedigree matrix of $m$ data quality indicators (DQIs) and $n$ data quality scores (DQ scores). Such a system can then be used to assess the data quality of processes and exchanges by tagging them with an instance of the system $D$ where $D$ is a $m * n$ matrix with an entry $d_{ij}$ containing the value of the data quality score $j$ for indicator $i$. As each indicator in $D$ can only have a single score value, $D$ can be stored in a vector $d$ where $d_i$ contains the data quality score for indicator $i$. The possible values of the data quality scores are defined as a linear order $1 \dots n$. In openLCA, the data quality entry $d$ of a process or exchange is stored as a string like `(3;2;4;n.a.;2)` which means the data quality score for the first indicator is `3`, for the second `2` etc. A specific value is `n.a.` which stands for _not applicable_. In calculations, these data quality entries can be aggregated in different ways. For example, the data quality entry of a flow $f$ with a contribution of `0.5 kg` and a data quality entry of `(3;2;4;n.a.;2)` in a process $p$ and a contribution of `1.5 kg` and a data quality entry of `(2;3;1;n.a.;5)` in a process $q$ could be aggregated to `(2;3;2;n.a.;4)` by applying an weighted average and rounding. Finally, custom labels like `A, B, C, ...` or `Very good, Good, Fair, ...` for the DQ scores can be assigned by the user. These labels are then displayed instead of `1, 2, 3 ...` in the user interface or result exports. However, internally the numeric values are used in the data model and calculations. Attributes ---------- has_uncertainties: bool source: Ref indicators: List[DQIndicator] """ olca_type: str = 'DQSystem' has_uncertainties: Optional[bool] = None source: Optional[Ref] = None indicators: Optional[List[DQIndicator]] = None def to_json(self) -> dict: json: dict = super(DQSystem, self).to_json() if self.has_uncertainties is not None: json['hasUncertainties'] = self.has_uncertainties if self.source is not None: json['source'] = self.source.to_json() if self.indicators is not None: json['indicators'] = [] for e in self.indicators: json['indicators'].append(e.to_json()) return json def read_json(self, json: dict): super(DQSystem, self).read_json(json) val = json.get('hasUncertainties') if val is not None: self.has_uncertainties = val val = json.get('source') if val is not None: self.source = Ref() self.source.read_json(val) val = json.get('indicators') if val is not None: self.indicators = [] for d in val: e = DQIndicator() e.read_json(d) self.indicators.append(e) @staticmethod def from_json(json: dict): instance = DQSystem() instance.read_json(json) return instanceAncestors
Class variables
var has_uncertainties : Optional[bool]var indicators : Optional[List[DQIndicator]]var olca_type : strvar source : Optional[Ref]
Static methods
def from_json(json: dict)-
Expand source code
@staticmethod def from_json(json: dict): instance = DQSystem() instance.read_json(json) return instance
Methods
def read_json(self, json: dict)-
Expand source code
def read_json(self, json: dict): super(DQSystem, self).read_json(json) val = json.get('hasUncertainties') if val is not None: self.has_uncertainties = val val = json.get('source') if val is not None: self.source = Ref() self.source.read_json(val) val = json.get('indicators') if val is not None: self.indicators = [] for d in val: e = DQIndicator() e.read_json(d) self.indicators.append(e) def to_json(self) ‑> dict-
Expand source code
def to_json(self) -> dict: json: dict = super(DQSystem, self).to_json() if self.has_uncertainties is not None: json['hasUncertainties'] = self.has_uncertainties if self.source is not None: json['source'] = self.source.to_json() if self.indicators is not None: json['indicators'] = [] for e in self.indicators: json['indicators'].append(e.to_json()) return json
class Entity (id: str = '', olca_type: str = '')-
The most generic type of the openLCA data model.
Expand source code
@dataclass class Entity(object): """ The most generic type of the openLCA data model. """ id: str = '' olca_type: str = '' def _repr_html_(self): code = jsonlib.dumps(self.to_json(), indent=2, sort_keys=True) if len(code) > 10000: code = code[0:10000] + '...' return f'<pre><code class="language-json">{code}</code></pre>' def to_json(self) -> dict: o_type = self.olca_type if o_type is None: o_type = type(self).__name__ json = {'@type': o_type} if self.id is not None: json['@id'] = self.id return json def read_json(self, json: dict): self.id = json.get('@id') self.olca_type = json.get('@type') @staticmethod def from_json(json: dict): instance = Entity() instance.read_json(json) return instanceSubclasses
- ContributionItem
- ProductResult
- AllocationFactor
- CalculationSetup
- DQIndicator
- DQScore
- Exchange
- ExchangeRef
- FlowMapEntry
- FlowMapRef
- FlowPropertyFactor
- FlowResult
- ImpactFactor
- ImpactResult
- NwFactor
- ParameterRedef
- ParameterRedefSet
- ProcessDocumentation
- ProcessLink
- RootEntity
- SimpleResult
- SocialAspect
- Uncertainty
Class variables
var id : strvar olca_type : str
Static methods
def from_json(json: dict)-
Expand source code
@staticmethod def from_json(json: dict): instance = Entity() instance.read_json(json) return instance
Methods
def read_json(self, json: dict)-
Expand source code
def read_json(self, json: dict): self.id = json.get('@id') self.olca_type = json.get('@type') def to_json(self) ‑> dict-
Expand source code
def to_json(self) -> dict: o_type = self.olca_type if o_type is None: o_type = type(self).__name__ json = {'@type': o_type} if self.id is not None: json['@id'] = self.id return json
class Exchange (id: str = '', olca_type: str = 'Exchange', avoided_product: Optional[bool] = None, cost_formula: Optional[str] = None, cost_value: Optional[float] = None, currency: Optional[Ref] = None, internal_id: Optional[int] = None, flow: Optional[Ref] = None, flow_property: Optional[Ref] = None, input: Optional[bool] = None, quantitative_reference: Optional[bool] = None, base_uncertainty: Optional[float] = None, default_provider: Optional[Ref] = None, amount: Optional[float] = None, amount_formula: Optional[str] = None, unit: Optional[Ref] = None, dq_entry: Optional[str] = None, uncertainty: Optional[Uncertainty] = None, description: Optional[str] = None)-
An Exchange is an input or output of a [Flow] in a [Process]. The amount of an exchange is given in a specific unit of a quantity ([FlowProperty]) of the flow. The allowed units and flow properties that can be used for a flow in an exchange are defined by the flow property information in that flow (see also the [FlowPropertyFactor] type).
Attributes
avoided_product:bool- Indicates whether this exchange is an avoided product.
cost_formula:str- A formula for calculating the costs of this exchange.
cost_value:float- The costs of this exchange.
currency:Ref- The currency in which the costs of this exchange are given.
internal_id:int- The process internal ID of the exchange. This is used to identify exchanges unambiguously within a process (e.g. when linking exchanges in a product system where multiple exchanges with the same flow are allowed). The value should be >= 1.
flow:Ref- The reference to the flow of the exchange.
flow_property:Ref- The quantity in which the amount is given.
input:boolquantitative_reference:bool- Indicates whether the exchange is the quantitative reference of the process.
base_uncertainty:floatdefault_provider:Ref- A default provider is a [Process] that is linked as the provider of a product input or the waste treatment provider of a waste output. It is just an optional default setting which can be also ignored when building product systems in openLCA. The user is always free to link processes in product systems ignoring these defaults (but the flows and flow directions have to match of course).
amount:floatamount_formula:strunit:Refdq_entry:str- A data quality entry like
(1;3;2;5;1). The entry is a vector of data quality values that need to match the data quality scheme for flow inputs and outputs that is assigned to the [Process]. In such a scheme the data quality indicators have fixed positions and the respective values in thedqEntryvector map to these positions. uncertainty:Uncertaintydescription:str- A general comment about the input or output.
Expand source code
@dataclass class Exchange(Entity): """ An Exchange is an input or output of a [Flow] in a [Process]. The amount of an exchange is given in a specific unit of a quantity ([FlowProperty]) of the flow. The allowed units and flow properties that can be used for a flow in an exchange are defined by the flow property information in that flow (see also the [FlowPropertyFactor] type). Attributes ---------- avoided_product: bool Indicates whether this exchange is an avoided product. cost_formula: str A formula for calculating the costs of this exchange. cost_value: float The costs of this exchange. currency: Ref The currency in which the costs of this exchange are given. internal_id: int The process internal ID of the exchange. This is used to identify exchanges unambiguously within a process (e.g. when linking exchanges in a product system where multiple exchanges with the same flow are allowed). The value should be >= 1. flow: Ref The reference to the flow of the exchange. flow_property: Ref The quantity in which the amount is given. input: bool quantitative_reference: bool Indicates whether the exchange is the quantitative reference of the process. base_uncertainty: float default_provider: Ref A default provider is a [Process] that is linked as the provider of a product input or the waste treatment provider of a waste output. It is just an optional default setting which can be also ignored when building product systems in openLCA. The user is always free to link processes in product systems ignoring these defaults (but the flows and flow directions have to match of course). amount: float amount_formula: str unit: Ref dq_entry: str A data quality entry like `(1;3;2;5;1)`. The entry is a vector of data quality values that need to match the data quality scheme for flow inputs and outputs that is assigned to the [Process]. In such a scheme the data quality indicators have fixed positions and the respective values in the `dqEntry` vector map to these positions. uncertainty: Uncertainty description: str A general comment about the input or output. """ olca_type: str = 'Exchange' avoided_product: Optional[bool] = None cost_formula: Optional[str] = None cost_value: Optional[float] = None currency: Optional[Ref] = None internal_id: Optional[int] = None flow: Optional[Ref] = None flow_property: Optional[Ref] = None input: Optional[bool] = None quantitative_reference: Optional[bool] = None base_uncertainty: Optional[float] = None default_provider: Optional[Ref] = None amount: Optional[float] = None amount_formula: Optional[str] = None unit: Optional[Ref] = None dq_entry: Optional[str] = None uncertainty: Optional[Uncertainty] = None description: Optional[str] = None def to_json(self) -> dict: json: dict = super(Exchange, self).to_json() if self.avoided_product is not None: json['avoidedProduct'] = self.avoided_product if self.cost_formula is not None: json['costFormula'] = self.cost_formula if self.cost_value is not None: json['costValue'] = self.cost_value if self.currency is not None: json['currency'] = self.currency.to_json() if self.internal_id is not None: json['internalId'] = self.internal_id if self.flow is not None: json['flow'] = self.flow.to_json() if self.flow_property is not None: json['flowProperty'] = self.flow_property.to_json() if self.input is not None: json['input'] = self.input if self.quantitative_reference is not None: json['quantitativeReference'] = self.quantitative_reference if self.base_uncertainty is not None: json['baseUncertainty'] = self.base_uncertainty if self.default_provider is not None: json['defaultProvider'] = self.default_provider.to_json() if self.amount is not None: json['amount'] = self.amount if self.amount_formula is not None: json['amountFormula'] = self.amount_formula if self.unit is not None: json['unit'] = self.unit.to_json() if self.dq_entry is not None: json['dqEntry'] = self.dq_entry if self.uncertainty is not None: json['uncertainty'] = self.uncertainty.to_json() if self.description is not None: json['description'] = self.description return json def read_json(self, json: dict): super(Exchange, self).read_json(json) val = json.get('avoidedProduct') if val is not None: self.avoided_product = val val = json.get('costFormula') if val is not None: self.cost_formula = val val = json.get('costValue') if val is not None: self.cost_value = val val = json.get('currency') if val is not None: self.currency = Ref() self.currency.read_json(val) val = json.get('internalId') if val is not None: self.internal_id = val val = json.get('flow') if val is not None: self.flow = Ref() self.flow.read_json(val) val = json.get('flowProperty') if val is not None: self.flow_property = Ref() self.flow_property.read_json(val) val = json.get('input') if val is not None: self.input = val val = json.get('quantitativeReference') if val is not None: self.quantitative_reference = val val = json.get('baseUncertainty') if val is not None: self.base_uncertainty = val val = json.get('defaultProvider') if val is not None: self.default_provider = Ref() self.default_provider.read_json(val) val = json.get('amount') if val is not None: self.amount = val val = json.get('amountFormula') if val is not None: self.amount_formula = val val = json.get('unit') if val is not None: self.unit = Ref() self.unit.read_json(val) val = json.get('dqEntry') if val is not None: self.dq_entry = val val = json.get('uncertainty') if val is not None: self.uncertainty = Uncertainty() self.uncertainty.read_json(val) val = json.get('description') if val is not None: self.description = val @staticmethod def from_json(json: dict): instance = Exchange() instance.read_json(json) return instanceAncestors
Class variables
var amount : Optional[float]var amount_formula : Optional[str]var avoided_product : Optional[bool]var base_uncertainty : Optional[float]var cost_formula : Optional[str]var cost_value : Optional[float]var currency : Optional[Ref]var default_provider : Optional[Ref]var description : Optional[str]var dq_entry : Optional[str]var flow : Optional[Ref]var flow_property : Optional[Ref]var input : Optional[bool]var internal_id : Optional[int]var olca_type : strvar quantitative_reference : Optional[bool]var uncertainty : Optional[Uncertainty]var unit : Optional[Ref]
Static methods
def from_json(json: dict)-
Expand source code
@staticmethod def from_json(json: dict): instance = Exchange() instance.read_json(json) return instance
Methods
def read_json(self, json: dict)-
Expand source code
def read_json(self, json: dict): super(Exchange, self).read_json(json) val = json.get('avoidedProduct') if val is not None: self.avoided_product = val val = json.get('costFormula') if val is not None: self.cost_formula = val val = json.get('costValue') if val is not None: self.cost_value = val val = json.get('currency') if val is not None: self.currency = Ref() self.currency.read_json(val) val = json.get('internalId') if val is not None: self.internal_id = val val = json.get('flow') if val is not None: self.flow = Ref() self.flow.read_json(val) val = json.get('flowProperty') if val is not None: self.flow_property = Ref() self.flow_property.read_json(val) val = json.get('input') if val is not None: self.input = val val = json.get('quantitativeReference') if val is not None: self.quantitative_reference = val val = json.get('baseUncertainty') if val is not None: self.base_uncertainty = val val = json.get('defaultProvider') if val is not None: self.default_provider = Ref() self.default_provider.read_json(val) val = json.get('amount') if val is not None: self.amount = val val = json.get('amountFormula') if val is not None: self.amount_formula = val val = json.get('unit') if val is not None: self.unit = Ref() self.unit.read_json(val) val = json.get('dqEntry') if val is not None: self.dq_entry = val val = json.get('uncertainty') if val is not None: self.uncertainty = Uncertainty() self.uncertainty.read_json(val) val = json.get('description') if val is not None: self.description = val def to_json(self) ‑> dict-
Expand source code
def to_json(self) -> dict: json: dict = super(Exchange, self).to_json() if self.avoided_product is not None: json['avoidedProduct'] = self.avoided_product if self.cost_formula is not None: json['costFormula'] = self.cost_formula if self.cost_value is not None: json['costValue'] = self.cost_value if self.currency is not None: json['currency'] = self.currency.to_json() if self.internal_id is not None: json['internalId'] = self.internal_id if self.flow is not None: json['flow'] = self.flow.to_json() if self.flow_property is not None: json['flowProperty'] = self.flow_property.to_json() if self.input is not None: json['input'] = self.input if self.quantitative_reference is not None: json['quantitativeReference'] = self.quantitative_reference if self.base_uncertainty is not None: json['baseUncertainty'] = self.base_uncertainty if self.default_provider is not None: json['defaultProvider'] = self.default_provider.to_json() if self.amount is not None: json['amount'] = self.amount if self.amount_formula is not None: json['amountFormula'] = self.amount_formula if self.unit is not None: json['unit'] = self.unit.to_json() if self.dq_entry is not None: json['dqEntry'] = self.dq_entry if self.uncertainty is not None: json['uncertainty'] = self.uncertainty.to_json() if self.description is not None: json['description'] = self.description return json
class ExchangeRef (id: str = '', olca_type: str = 'ExchangeRef', internal_id: Optional[int] = None)-
An instance of this class describes a reference to an exchange in a process. When we reference such an exchange we only need the information to indentify that exchange unambiguously in a process.
Attributes
internal_id:int- The internal ID of the exchange.
Expand source code
@dataclass class ExchangeRef(Entity): """ An instance of this class describes a reference to an exchange in a process. When we reference such an exchange we only need the information to indentify that exchange unambiguously in a process. Attributes ---------- internal_id: int The internal ID of the exchange. """ olca_type: str = 'ExchangeRef' internal_id: Optional[int] = None def to_json(self) -> dict: json: dict = super(ExchangeRef, self).to_json() if self.internal_id is not None: json['internalId'] = self.internal_id return json def read_json(self, json: dict): super(ExchangeRef, self).read_json(json) val = json.get('internalId') if val is not None: self.internal_id = val @staticmethod def from_json(json: dict): instance = ExchangeRef() instance.read_json(json) return instanceAncestors
Class variables
var internal_id : Optional[int]var olca_type : str
Static methods
def from_json(json: dict)-
Expand source code
@staticmethod def from_json(json: dict): instance = ExchangeRef() instance.read_json(json) return instance
Methods
def read_json(self, json: dict)-
Expand source code
def read_json(self, json: dict): super(ExchangeRef, self).read_json(json) val = json.get('internalId') if val is not None: self.internal_id = val def to_json(self) ‑> dict-
Expand source code
def to_json(self) -> dict: json: dict = super(ExchangeRef, self).to_json() if self.internal_id is not None: json['internalId'] = self.internal_id return json
class Flow (id: str = '', olca_type: str = 'Flow', name: Optional[str] = None, description: Optional[str] = None, version: Optional[str] = None, last_change: Optional[str] = None, category: Optional[Ref] = None, tags: Optional[List[str]] = None, library: Optional[str] = None, flow_type: Optional[FlowType] = None, cas: Optional[str] = None, formula: Optional[str] = None, flow_properties: Optional[List[FlowPropertyFactor]] = None, location: Optional[Ref] = None, synonyms: Optional[str] = None, infrastructure_flow: Optional[bool] = None)-
Everything that can be an input or output of a process (e.g. a substance, a product, a waste, a service etc.)
Attributes
flow_type:FlowType- The type of the flow. Note that this type is more a descriptor of how the flow is handled in calculations.
cas:str- A CAS number of the flow.
formula:str- A chemical formula of the flow.
flow_properties:List[FlowPropertyFactor]- The flow properties (quantities) in which amounts of the flow can be expressed together with conversion factors between these flow flow properties.
location:Ref- The location of the flow. Normally the location of a flow is defined by the process location where the flow is an input or output. However, some data formats define a location as a property of a flow.
synonyms:str- A list of synonyms but packed into a single field. Best is to use semicolons as separator as commas are sometimes used in names of chemicals.
infrastructure_flow:bool- Indicates whether this flow describes an infrastructure product. This field is part of the openLCA schema because of backward compatibility with EcoSpold 1. It does not really have a meaning in openLCA and should not be used anymore.
Expand source code
@dataclass class Flow(CategorizedEntity): """ Everything that can be an input or output of a process (e.g. a substance, a product, a waste, a service etc.) Attributes ---------- flow_type: FlowType The type of the flow. Note that this type is more a descriptor of how the flow is handled in calculations. cas: str A CAS number of the flow. formula: str A chemical formula of the flow. flow_properties: List[FlowPropertyFactor] The flow properties (quantities) in which amounts of the flow can be expressed together with conversion factors between these flow flow properties. location: Ref The location of the flow. Normally the location of a flow is defined by the process location where the flow is an input or output. However, some data formats define a location as a property of a flow. synonyms: str A list of synonyms but packed into a single field. Best is to use semicolons as separator as commas are sometimes used in names of chemicals. infrastructure_flow: bool Indicates whether this flow describes an infrastructure product. This field is part of the openLCA schema because of backward compatibility with EcoSpold 1. It does not really have a meaning in openLCA and should not be used anymore. """ olca_type: str = 'Flow' flow_type: Optional[FlowType] = None cas: Optional[str] = None formula: Optional[str] = None flow_properties: Optional[List[FlowPropertyFactor]] = None location: Optional[Ref] = None synonyms: Optional[str] = None infrastructure_flow: Optional[bool] = None def to_json(self) -> dict: json: dict = super(Flow, self).to_json() if self.flow_type is not None: json['flowType'] = self.flow_type.value if self.cas is not None: json['cas'] = self.cas if self.formula is not None: json['formula'] = self.formula if self.flow_properties is not None: json['flowProperties'] = [] for e in self.flow_properties: json['flowProperties'].append(e.to_json()) if self.location is not None: json['location'] = self.location.to_json() if self.synonyms is not None: json['synonyms'] = self.synonyms if self.infrastructure_flow is not None: json['infrastructureFlow'] = self.infrastructure_flow return json def read_json(self, json: dict): super(Flow, self).read_json(json) val = json.get('flowType') if val is not None: self.flow_type = FlowType(val) val = json.get('cas') if val is not None: self.cas = val val = json.get('formula') if val is not None: self.formula = val val = json.get('flowProperties') if val is not None: self.flow_properties = [] for d in val: e = FlowPropertyFactor() e.read_json(d) self.flow_properties.append(e) val = json.get('location') if val is not None: self.location = Ref() self.location.read_json(val) val = json.get('synonyms') if val is not None: self.synonyms = val val = json.get('infrastructureFlow') if val is not None: self.infrastructure_flow = val @staticmethod def from_json(json: dict): instance = Flow() instance.read_json(json) return instanceAncestors
Class variables
var cas : Optional[str]var flow_properties : Optional[List[FlowPropertyFactor]]var flow_type : Optional[FlowType]var formula : Optional[str]var infrastructure_flow : Optional[bool]var location : Optional[Ref]var olca_type : strvar synonyms : Optional[str]
Static methods
def from_json(json: dict)-
Expand source code
@staticmethod def from_json(json: dict): instance = Flow() instance.read_json(json) return instance
Methods
def read_json(self, json: dict)-
Expand source code
def read_json(self, json: dict): super(Flow, self).read_json(json) val = json.get('flowType') if val is not None: self.flow_type = FlowType(val) val = json.get('cas') if val is not None: self.cas = val val = json.get('formula') if val is not None: self.formula = val val = json.get('flowProperties') if val is not None: self.flow_properties = [] for d in val: e = FlowPropertyFactor() e.read_json(d) self.flow_properties.append(e) val = json.get('location') if val is not None: self.location = Ref() self.location.read_json(val) val = json.get('synonyms') if val is not None: self.synonyms = val val = json.get('infrastructureFlow') if val is not None: self.infrastructure_flow = val def to_json(self) ‑> dict-
Expand source code
def to_json(self) -> dict: json: dict = super(Flow, self).to_json() if self.flow_type is not None: json['flowType'] = self.flow_type.value if self.cas is not None: json['cas'] = self.cas if self.formula is not None: json['formula'] = self.formula if self.flow_properties is not None: json['flowProperties'] = [] for e in self.flow_properties: json['flowProperties'].append(e.to_json()) if self.location is not None: json['location'] = self.location.to_json() if self.synonyms is not None: json['synonyms'] = self.synonyms if self.infrastructure_flow is not None: json['infrastructureFlow'] = self.infrastructure_flow return json
class FlowMap (id: str = '', olca_type: str = 'FlowMap', name: Optional[str] = None, description: Optional[str] = None, version: Optional[str] = None, last_change: Optional[str] = None, source: Optional[Ref] = None, target: Optional[Ref] = None, mappings: Optional[List[FlowMapEntry]] = None)-
A crosswalk of flows from a source flow list to a target flow list.
Attributes
source:Ref- The reference (id, name, description) of the source flow list.
target:Ref- The reference (id, name, description) of the target flow list.
mappings:List[FlowMapEntry]- A list of flow mappings from flows in a source flow list to flows in a target flow list.
Expand source code
@dataclass class FlowMap(RootEntity): """ A crosswalk of flows from a source flow list to a target flow list. Attributes ---------- source: Ref The reference (id, name, description) of the source flow list. target: Ref The reference (id, name, description) of the target flow list. mappings: List[FlowMapEntry] A list of flow mappings from flows in a source flow list to flows in a target flow list. """ olca_type: str = 'FlowMap' source: Optional[Ref] = None target: Optional[Ref] = None mappings: Optional[List[FlowMapEntry]] = None def to_json(self) -> dict: json: dict = super(FlowMap, self).to_json() if self.source is not None: json['source'] = self.source.to_json() if self.target is not None: json['target'] = self.target.to_json() if self.mappings is not None: json['mappings'] = [] for e in self.mappings: json['mappings'].append(e.to_json()) return json def read_json(self, json: dict): super(FlowMap, self).read_json(json) val = json.get('source') if val is not None: self.source = Ref() self.source.read_json(val) val = json.get('target') if val is not None: self.target = Ref() self.target.read_json(val) val = json.get('mappings') if val is not None: self.mappings = [] for d in val: e = FlowMapEntry() e.read_json(d) self.mappings.append(e) @staticmethod def from_json(json: dict): instance = FlowMap() instance.read_json(json) return instanceAncestors
Class variables
var mappings : Optional[List[FlowMapEntry]]var olca_type : strvar source : Optional[Ref]var target : Optional[Ref]
Static methods
def from_json(json: dict)-
Expand source code
@staticmethod def from_json(json: dict): instance = FlowMap() instance.read_json(json) return instance
Methods
def read_json(self, json: dict)-
Expand source code
def read_json(self, json: dict): super(FlowMap, self).read_json(json) val = json.get('source') if val is not None: self.source = Ref() self.source.read_json(val) val = json.get('target') if val is not None: self.target = Ref() self.target.read_json(val) val = json.get('mappings') if val is not None: self.mappings = [] for d in val: e = FlowMapEntry() e.read_json(d) self.mappings.append(e) def to_json(self) ‑> dict-
Expand source code
def to_json(self) -> dict: json: dict = super(FlowMap, self).to_json() if self.source is not None: json['source'] = self.source.to_json() if self.target is not None: json['target'] = self.target.to_json() if self.mappings is not None: json['mappings'] = [] for e in self.mappings: json['mappings'].append(e.to_json()) return json
class FlowMapEntry (id: str = '', olca_type: str = 'FlowMapEntry', from_: Optional[FlowMapRef] = None, to: Optional[FlowMapRef] = None, conversion_factor: Optional[float] = None)-
A mapping from a source flow to a target flow.
Attributes
from_:FlowMapRef- Describes the source flow of the mapping.
to:FlowMapRef- Describes the target of the mapping.
conversion_factor:float- The conversion factor to convert the amount of 1 unit of the source flow into the corresponding quantity of the target flow.
Expand source code
@dataclass class FlowMapEntry(Entity): """ A mapping from a source flow to a target flow. Attributes ---------- from_: FlowMapRef Describes the source flow of the mapping. to: FlowMapRef Describes the target of the mapping. conversion_factor: float The conversion factor to convert the amount of 1 unit of the source flow into the corresponding quantity of the target flow. """ olca_type: str = 'FlowMapEntry' from_: Optional[FlowMapRef] = None to: Optional[FlowMapRef] = None conversion_factor: Optional[float] = None def to_json(self) -> dict: json: dict = super(FlowMapEntry, self).to_json() if self.from_ is not None: json['from'] = self.from_.to_json() if self.to is not None: json['to'] = self.to.to_json() if self.conversion_factor is not None: json['conversionFactor'] = self.conversion_factor return json def read_json(self, json: dict): super(FlowMapEntry, self).read_json(json) val = json.get('from') if val is not None: self.from_ = FlowMapRef() self.from_.read_json(val) val = json.get('to') if val is not None: self.to = FlowMapRef() self.to.read_json(val) val = json.get('conversionFactor') if val is not None: self.conversion_factor = val @staticmethod def from_json(json: dict): instance = FlowMapEntry() instance.read_json(json) return instanceAncestors
Class variables
var conversion_factor : Optional[float]var from_ : Optional[FlowMapRef]var olca_type : strvar to : Optional[FlowMapRef]
Static methods
def from_json(json: dict)-
Expand source code
@staticmethod def from_json(json: dict): instance = FlowMapEntry() instance.read_json(json) return instance
Methods
def read_json(self, json: dict)-
Expand source code
def read_json(self, json: dict): super(FlowMapEntry, self).read_json(json) val = json.get('from') if val is not None: self.from_ = FlowMapRef() self.from_.read_json(val) val = json.get('to') if val is not None: self.to = FlowMapRef() self.to.read_json(val) val = json.get('conversionFactor') if val is not None: self.conversion_factor = val def to_json(self) ‑> dict-
Expand source code
def to_json(self) -> dict: json: dict = super(FlowMapEntry, self).to_json() if self.from_ is not None: json['from'] = self.from_.to_json() if self.to is not None: json['to'] = self.to.to_json() if self.conversion_factor is not None: json['conversionFactor'] = self.conversion_factor return json
class FlowMapRef (id: str = '', olca_type: str = 'FlowMapRef', flow: Optional[Ref] = None, flow_property: Optional[Ref] = None, unit: Optional[Ref] = None, provider: Optional[Ref] = None)-
Describes a source or target flow in a
FlowMappingEntryof aFlowMap. Such a flow reference can also optionally specify the unit and flow property (quantity) for which the mapping is valid. If the unit or quantity is not given, the mapping is based on the respective reference unit and reference flow property of the flow.Attributes
flow:Ref- The reference to the flow data set.
flow_property:Ref- An optional reference to a flow property of the flow for which the mapping is valid.
unit:Ref- An optional reference to a unit of the flow for which the mapping is valid
provider:Ref- In case of a product or waste flow a flow mapping can contain a provider which is the process that produces the product or a waste treatment process that consumes the waste flow. This is useful when we want to apply mappings of product and waste flows on databases and link them in the corresponding processes and product systems.
Expand source code
@dataclass class FlowMapRef(Entity): """ Describes a source or target flow in a `FlowMappingEntry` of a `FlowMap`. Such a flow reference can also optionally specify the unit and flow property (quantity) for which the mapping is valid. If the unit or quantity is not given, the mapping is based on the respective reference unit and reference flow property of the flow. Attributes ---------- flow: Ref The reference to the flow data set. flow_property: Ref An optional reference to a flow property of the flow for which the mapping is valid. unit: Ref An optional reference to a unit of the flow for which the mapping is valid provider: Ref In case of a product or waste flow a flow mapping can contain a provider which is the process that produces the product or a waste treatment process that consumes the waste flow. This is useful when we want to apply mappings of product and waste flows on databases and link them in the corresponding processes and product systems. """ olca_type: str = 'FlowMapRef' flow: Optional[Ref] = None flow_property: Optional[Ref] = None unit: Optional[Ref] = None provider: Optional[Ref] = None def to_json(self) -> dict: json: dict = super(FlowMapRef, self).to_json() if self.flow is not None: json['flow'] = self.flow.to_json() if self.flow_property is not None: json['flowProperty'] = self.flow_property.to_json() if self.unit is not None: json['unit'] = self.unit.to_json() if self.provider is not None: json['provider'] = self.provider.to_json() return json def read_json(self, json: dict): super(FlowMapRef, self).read_json(json) val = json.get('flow') if val is not None: self.flow = Ref() self.flow.read_json(val) val = json.get('flowProperty') if val is not None: self.flow_property = Ref() self.flow_property.read_json(val) val = json.get('unit') if val is not None: self.unit = Ref() self.unit.read_json(val) val = json.get('provider') if val is not None: self.provider = Ref() self.provider.read_json(val) @staticmethod def from_json(json: dict): instance = FlowMapRef() instance.read_json(json) return instanceAncestors
Class variables
var flow : Optional[Ref]var flow_property : Optional[Ref]var olca_type : strvar provider : Optional[Ref]var unit : Optional[Ref]
Static methods
def from_json(json: dict)-
Expand source code
@staticmethod def from_json(json: dict): instance = FlowMapRef() instance.read_json(json) return instance
Methods
def read_json(self, json: dict)-
Expand source code
def read_json(self, json: dict): super(FlowMapRef, self).read_json(json) val = json.get('flow') if val is not None: self.flow = Ref() self.flow.read_json(val) val = json.get('flowProperty') if val is not None: self.flow_property = Ref() self.flow_property.read_json(val) val = json.get('unit') if val is not None: self.unit = Ref() self.unit.read_json(val) val = json.get('provider') if val is not None: self.provider = Ref() self.provider.read_json(val) def to_json(self) ‑> dict-
Expand source code
def to_json(self) -> dict: json: dict = super(FlowMapRef, self).to_json() if self.flow is not None: json['flow'] = self.flow.to_json() if self.flow_property is not None: json['flowProperty'] = self.flow_property.to_json() if self.unit is not None: json['unit'] = self.unit.to_json() if self.provider is not None: json['provider'] = self.provider.to_json() return json
class FlowProperty (id: str = '', olca_type: str = 'FlowProperty', name: Optional[str] = None, description: Optional[str] = None, version: Optional[str] = None, last_change: Optional[str] = None, category: Optional[Ref] = None, tags: Optional[List[str]] = None, library: Optional[str] = None, flow_property_type: Optional[FlowPropertyType] = None, unit_group: Optional[Ref] = None)-
A flow property is a quantity that can be used to express amounts of a flow.
Attributes
flow_property_type:FlowPropertyType- The type of the flow property
unit_group:Ref- The units of measure that can be used to express quantities of the flow property.
Expand source code
@dataclass class FlowProperty(CategorizedEntity): """ A flow property is a quantity that can be used to express amounts of a flow. Attributes ---------- flow_property_type: FlowPropertyType The type of the flow property unit_group: Ref The units of measure that can be used to express quantities of the flow property. """ olca_type: str = 'FlowProperty' flow_property_type: Optional[FlowPropertyType] = None unit_group: Optional[Ref] = None def to_json(self) -> dict: json: dict = super(FlowProperty, self).to_json() if self.flow_property_type is not None: json['flowPropertyType'] = self.flow_property_type.value if self.unit_group is not None: json['unitGroup'] = self.unit_group.to_json() return json def read_json(self, json: dict): super(FlowProperty, self).read_json(json) val = json.get('flowPropertyType') if val is not None: self.flow_property_type = FlowPropertyType(val) val = json.get('unitGroup') if val is not None: self.unit_group = Ref() self.unit_group.read_json(val) @staticmethod def from_json(json: dict): instance = FlowProperty() instance.read_json(json) return instanceAncestors
Class variables
var flow_property_type : Optional[FlowPropertyType]var olca_type : strvar unit_group : Optional[Ref]
Static methods
def from_json(json: dict)-
Expand source code
@staticmethod def from_json(json: dict): instance = FlowProperty() instance.read_json(json) return instance
Methods
def read_json(self, json: dict)-
Expand source code
def read_json(self, json: dict): super(FlowProperty, self).read_json(json) val = json.get('flowPropertyType') if val is not None: self.flow_property_type = FlowPropertyType(val) val = json.get('unitGroup') if val is not None: self.unit_group = Ref() self.unit_group.read_json(val) def to_json(self) ‑> dict-
Expand source code
def to_json(self) -> dict: json: dict = super(FlowProperty, self).to_json() if self.flow_property_type is not None: json['flowPropertyType'] = self.flow_property_type.value if self.unit_group is not None: json['unitGroup'] = self.unit_group.to_json() return json
class FlowPropertyFactor (id: str = '', olca_type: str = 'FlowPropertyFactor', flow_property: Optional[Ref] = None, conversion_factor: Optional[float] = None, reference_flow_property: Optional[bool] = None)-
A FlowPropertyFactor is a conversion factor between flow properties (quantities) of a flow. As an example the amount of the flow 'water' in a process could be expressed in 'kg' mass or 'm3' volume. In this case the flow water would have two flow property factors: one for the flow property 'mass' and one for 'volume'. Each of these flow properties has a reference to a unit group which again has a reference unit. In the example the flow property 'mass' could reference the unit group 'units of mass' with 'kg' as reference unit and volume could reference the unit group 'units of volume' with 'm3' as reference unit. The flow property factor is now the conversion factor between these two reference units where the factor of the reference flow property of the flow is 1. If the reference flow property of 'water' in the example would be 'mass' the respective flow property factor would be 1 and the factor for 'volume' would be 0.001 (as 1 kg water is 0.001 m3). The amount of water in a process can now be also given in liter, tons, grams etc. For this, the unit conversion factor of the respective unit group can be used to convert into the reference unit (which then can be used to convert to the reference unit of another flow property). Another thing to note is that different flow properties can refer to the same unit group (e.g. MJ upper calorific value and MJ lower calorific value.)
Attributes
flow_property:Ref- The flow property (quantity) of the factor.
conversion_factor:float- The value of the conversion factor.
reference_flow_property:bool- Indicates whether the flow property of the factor is the reference flow property of the flow. The reference flow property must have a conversion factor of 1.0 and there should be only one reference flow property.
Expand source code
@dataclass class FlowPropertyFactor(Entity): """ A FlowPropertyFactor is a conversion factor between <a href="./FlowProperty.html">flow properties (quantities)</a> of a <a href="./Flow.html">flow</a>. As an example the amount of the flow 'water' in a process could be expressed in 'kg' mass or 'm3' volume. In this case the flow water would have two flow property factors: one for the flow property 'mass' and one for 'volume'. Each of these flow properties has a reference to a <a href="./UnitGroup.html">unit group</a> which again has a reference unit. In the example the flow property 'mass' could reference the unit group 'units of mass' with 'kg' as reference unit and volume could reference the unit group 'units of volume' with 'm3' as reference unit. The flow property factor is now the conversion factor between these two reference units where the factor of the reference flow property of the flow is 1. If the reference flow property of 'water' in the example would be 'mass' the respective flow property factor would be 1 and the factor for 'volume' would be 0.001 (as 1 kg water is 0.001 m3). The amount of water in a process can now be also given in liter, tons, grams etc. For this, the unit conversion factor of the respective unit group can be used to convert into the reference unit (which then can be used to convert to the reference unit of another flow property). Another thing to note is that different flow properties can refer to the same unit group (e.g. MJ upper calorific value and MJ lower calorific value.) Attributes ---------- flow_property: Ref The flow property (quantity) of the factor. conversion_factor: float The value of the conversion factor. reference_flow_property: bool Indicates whether the flow property of the factor is the reference flow property of the flow. The reference flow property must have a conversion factor of 1.0 and there should be only one reference flow property. """ olca_type: str = 'FlowPropertyFactor' flow_property: Optional[Ref] = None conversion_factor: Optional[float] = None reference_flow_property: Optional[bool] = None def to_json(self) -> dict: json: dict = super(FlowPropertyFactor, self).to_json() if self.flow_property is not None: json['flowProperty'] = self.flow_property.to_json() if self.conversion_factor is not None: json['conversionFactor'] = self.conversion_factor if self.reference_flow_property is not None: json['referenceFlowProperty'] = self.reference_flow_property return json def read_json(self, json: dict): super(FlowPropertyFactor, self).read_json(json) val = json.get('flowProperty') if val is not None: self.flow_property = Ref() self.flow_property.read_json(val) val = json.get('conversionFactor') if val is not None: self.conversion_factor = val val = json.get('referenceFlowProperty') if val is not None: self.reference_flow_property = val @staticmethod def from_json(json: dict): instance = FlowPropertyFactor() instance.read_json(json) return instanceAncestors
Class variables
var conversion_factor : Optional[float]var flow_property : Optional[Ref]var olca_type : strvar reference_flow_property : Optional[bool]
Static methods
def from_json(json: dict)-
Expand source code
@staticmethod def from_json(json: dict): instance = FlowPropertyFactor() instance.read_json(json) return instance
Methods
def read_json(self, json: dict)-
Expand source code
def read_json(self, json: dict): super(FlowPropertyFactor, self).read_json(json) val = json.get('flowProperty') if val is not None: self.flow_property = Ref() self.flow_property.read_json(val) val = json.get('conversionFactor') if val is not None: self.conversion_factor = val val = json.get('referenceFlowProperty') if val is not None: self.reference_flow_property = val def to_json(self) ‑> dict-
Expand source code
def to_json(self) -> dict: json: dict = super(FlowPropertyFactor, self).to_json() if self.flow_property is not None: json['flowProperty'] = self.flow_property.to_json() if self.conversion_factor is not None: json['conversionFactor'] = self.conversion_factor if self.reference_flow_property is not None: json['referenceFlowProperty'] = self.reference_flow_property return json
class FlowPropertyType (value, names=None, *, module=None, qualname=None, type=None, start=1)-
An enumeration of flow property types.
Expand source code
class FlowPropertyType(Enum): """ An enumeration of flow property types. """ ECONOMIC_QUANTITY = 'ECONOMIC_QUANTITY' PHYSICAL_QUANTITY = 'PHYSICAL_QUANTITY'Ancestors
- enum.Enum
Class variables
var ECONOMIC_QUANTITYvar PHYSICAL_QUANTITY
class FlowResult (id: str = '', olca_type: str = 'FlowResult', flow: Optional[Ref] = None, input: Optional[bool] = None, value: Optional[float] = None, location: Optional[Ref] = None)-
A result value for a flow; given in the reference unit of the flow.
Attributes
Expand source code
@dataclass class FlowResult(Entity): """ A result value for a flow; given in the reference unit of the flow. Attributes ---------- flow: Ref The flow reference. input: bool Indicates whether the flow is an input or not. value: float The value of the flow amount. location: Ref The (reference to the) location of this flow result in case of a regionalized result. """ olca_type: str = 'FlowResult' flow: Optional[Ref] = None input: Optional[bool] = None value: Optional[float] = None location: Optional[Ref] = None def to_json(self) -> dict: json: dict = super(FlowResult, self).to_json() if self.flow is not None: json['flow'] = self.flow.to_json() if self.input is not None: json['input'] = self.input if self.value is not None: json['value'] = self.value if self.location is not None: json['location'] = self.location.to_json() return json def read_json(self, json: dict): super(FlowResult, self).read_json(json) val = json.get('flow') if val is not None: self.flow = Ref() self.flow.read_json(val) val = json.get('input') if val is not None: self.input = val val = json.get('value') if val is not None: self.value = val val = json.get('location') if val is not None: self.location = Ref() self.location.read_json(val) @staticmethod def from_json(json: dict): instance = FlowResult() instance.read_json(json) return instanceAncestors
Class variables
var flow : Optional[Ref]var input : Optional[bool]var location : Optional[Ref]var olca_type : strvar value : Optional[float]
Static methods
def from_json(json: dict)-
Expand source code
@staticmethod def from_json(json: dict): instance = FlowResult() instance.read_json(json) return instance
Methods
def read_json(self, json: dict)-
Expand source code
def read_json(self, json: dict): super(FlowResult, self).read_json(json) val = json.get('flow') if val is not None: self.flow = Ref() self.flow.read_json(val) val = json.get('input') if val is not None: self.input = val val = json.get('value') if val is not None: self.value = val val = json.get('location') if val is not None: self.location = Ref() self.location.read_json(val) def to_json(self) ‑> dict-
Expand source code
def to_json(self) -> dict: json: dict = super(FlowResult, self).to_json() if self.flow is not None: json['flow'] = self.flow.to_json() if self.input is not None: json['input'] = self.input if self.value is not None: json['value'] = self.value if self.location is not None: json['location'] = self.location.to_json() return json
class FlowType (value, names=None, *, module=None, qualname=None, type=None, start=1)-
The basic flow types.
Expand source code
class FlowType(Enum): """ The basic flow types. """ ELEMENTARY_FLOW = 'ELEMENTARY_FLOW' PRODUCT_FLOW = 'PRODUCT_FLOW' WASTE_FLOW = 'WASTE_FLOW'Ancestors
- enum.Enum
Class variables
var ELEMENTARY_FLOWvar PRODUCT_FLOWvar WASTE_FLOW
class ImpactCategory (id: str = '', olca_type: str = 'ImpactCategory', name: Optional[str] = None, description: Optional[str] = None, version: Optional[str] = None, last_change: Optional[str] = None, category: Optional[Ref] = None, tags: Optional[List[str]] = None, library: Optional[str] = None, reference_unit_name: Optional[str] = None, parameters: Optional[List[Parameter]] = None, impact_factors: Optional[List[ImpactFactor]] = None)-
Attributes
reference_unit_name:str- The name of the reference unit of the LCIA category (e.g. kg CO2-eq.).
parameters:List[Parameter]- A set of parameters which can be used in formulas of the characterisation factors in this impact category.
impact_factors:List[ImpactFactor]- The characterisation factors of the LCIA category.
Expand source code
@dataclass class ImpactCategory(CategorizedEntity): """ Attributes ---------- reference_unit_name: str The name of the reference unit of the LCIA category (e.g. kg CO2-eq.). parameters: List[Parameter] A set of parameters which can be used in formulas of the characterisation factors in this impact category. impact_factors: List[ImpactFactor] The characterisation factors of the LCIA category. """ olca_type: str = 'ImpactCategory' reference_unit_name: Optional[str] = None parameters: Optional[List[Parameter]] = None impact_factors: Optional[List[ImpactFactor]] = None def to_json(self) -> dict: json: dict = super(ImpactCategory, self).to_json() if self.reference_unit_name is not None: json['referenceUnitName'] = self.reference_unit_name if self.parameters is not None: json['parameters'] = [] for e in self.parameters: json['parameters'].append(e.to_json()) if self.impact_factors is not None: json['impactFactors'] = [] for e in self.impact_factors: json['impactFactors'].append(e.to_json()) return json def read_json(self, json: dict): super(ImpactCategory, self).read_json(json) val = json.get('referenceUnitName') if val is not None: self.reference_unit_name = val val = json.get('parameters') if val is not None: self.parameters = [] for d in val: e = Parameter() e.read_json(d) self.parameters.append(e) val = json.get('impactFactors') if val is not None: self.impact_factors = [] for d in val: e = ImpactFactor() e.read_json(d) self.impact_factors.append(e) @staticmethod def from_json(json: dict): instance = ImpactCategory() instance.read_json(json) return instanceAncestors
Class variables
var impact_factors : Optional[List[ImpactFactor]]var olca_type : strvar parameters : Optional[List[Parameter]]var reference_unit_name : Optional[str]
Static methods
def from_json(json: dict)-
Expand source code
@staticmethod def from_json(json: dict): instance = ImpactCategory() instance.read_json(json) return instance
Methods
def read_json(self, json: dict)-
Expand source code
def read_json(self, json: dict): super(ImpactCategory, self).read_json(json) val = json.get('referenceUnitName') if val is not None: self.reference_unit_name = val val = json.get('parameters') if val is not None: self.parameters = [] for d in val: e = Parameter() e.read_json(d) self.parameters.append(e) val = json.get('impactFactors') if val is not None: self.impact_factors = [] for d in val: e = ImpactFactor() e.read_json(d) self.impact_factors.append(e) def to_json(self) ‑> dict-
Expand source code
def to_json(self) -> dict: json: dict = super(ImpactCategory, self).to_json() if self.reference_unit_name is not None: json['referenceUnitName'] = self.reference_unit_name if self.parameters is not None: json['parameters'] = [] for e in self.parameters: json['parameters'].append(e.to_json()) if self.impact_factors is not None: json['impactFactors'] = [] for e in self.impact_factors: json['impactFactors'].append(e.to_json()) return json
class ImpactFactor (id: str = '', olca_type: str = 'ImpactFactor', flow: Optional[Ref] = None, location: Optional[Ref] = None, flow_property: Optional[Ref] = None, unit: Optional[Ref] = None, value: Optional[float] = None, formula: Optional[str] = None, uncertainty: Optional[Uncertainty] = None)-
A single characterisation factor of a LCIA category for a flow.
Attributes
flow:Ref- The [Flow] of the impact assessment factor.
location:Ref- In case of a regionalized impact category, this field can contain the location for which this factor is valid.
flow_property:Ref- The quantity of the flow to which the LCIA factor is related (e.g. Mass).
unit:Ref- The flow unit to which the LCIA factor is related (e.g. kg).
value:float- The value of the impact assessment factor.
formula:str- A mathematical formula for calculating the value of the LCIA factor.
uncertainty:Uncertainty- The uncertainty distribution of the factors' value.
Expand source code
@dataclass class ImpactFactor(Entity): """ A single characterisation factor of a LCIA category for a flow. Attributes ---------- flow: Ref The [Flow] of the impact assessment factor. location: Ref In case of a regionalized impact category, this field can contain the location for which this factor is valid. flow_property: Ref The quantity of the flow to which the LCIA factor is related (e.g. Mass). unit: Ref The flow unit to which the LCIA factor is related (e.g. kg). value: float The value of the impact assessment factor. formula: str A mathematical formula for calculating the value of the LCIA factor. uncertainty: Uncertainty The uncertainty distribution of the factors' value. """ olca_type: str = 'ImpactFactor' flow: Optional[Ref] = None location: Optional[Ref] = None flow_property: Optional[Ref] = None unit: Optional[Ref] = None value: Optional[float] = None formula: Optional[str] = None uncertainty: Optional[Uncertainty] = None def to_json(self) -> dict: json: dict = super(ImpactFactor, self).to_json() if self.flow is not None: json['flow'] = self.flow.to_json() if self.location is not None: json['location'] = self.location.to_json() if self.flow_property is not None: json['flowProperty'] = self.flow_property.to_json() if self.unit is not None: json['unit'] = self.unit.to_json() if self.value is not None: json['value'] = self.value if self.formula is not None: json['formula'] = self.formula if self.uncertainty is not None: json['uncertainty'] = self.uncertainty.to_json() return json def read_json(self, json: dict): super(ImpactFactor, self).read_json(json) val = json.get('flow') if val is not None: self.flow = Ref() self.flow.read_json(val) val = json.get('location') if val is not None: self.location = Ref() self.location.read_json(val) val = json.get('flowProperty') if val is not None: self.flow_property = Ref() self.flow_property.read_json(val) val = json.get('unit') if val is not None: self.unit = Ref() self.unit.read_json(val) val = json.get('value') if val is not None: self.value = val val = json.get('formula') if val is not None: self.formula = val val = json.get('uncertainty') if val is not None: self.uncertainty = Uncertainty() self.uncertainty.read_json(val) @staticmethod def from_json(json: dict): instance = ImpactFactor() instance.read_json(json) return instanceAncestors
Class variables
var flow : Optional[Ref]var flow_property : Optional[Ref]var formula : Optional[str]var location : Optional[Ref]var olca_type : strvar uncertainty : Optional[Uncertainty]var unit : Optional[Ref]var value : Optional[float]
Static methods
def from_json(json: dict)-
Expand source code
@staticmethod def from_json(json: dict): instance = ImpactFactor() instance.read_json(json) return instance
Methods
def read_json(self, json: dict)-
Expand source code
def read_json(self, json: dict): super(ImpactFactor, self).read_json(json) val = json.get('flow') if val is not None: self.flow = Ref() self.flow.read_json(val) val = json.get('location') if val is not None: self.location = Ref() self.location.read_json(val) val = json.get('flowProperty') if val is not None: self.flow_property = Ref() self.flow_property.read_json(val) val = json.get('unit') if val is not None: self.unit = Ref() self.unit.read_json(val) val = json.get('value') if val is not None: self.value = val val = json.get('formula') if val is not None: self.formula = val val = json.get('uncertainty') if val is not None: self.uncertainty = Uncertainty() self.uncertainty.read_json(val) def to_json(self) ‑> dict-
Expand source code
def to_json(self) -> dict: json: dict = super(ImpactFactor, self).to_json() if self.flow is not None: json['flow'] = self.flow.to_json() if self.location is not None: json['location'] = self.location.to_json() if self.flow_property is not None: json['flowProperty'] = self.flow_property.to_json() if self.unit is not None: json['unit'] = self.unit.to_json() if self.value is not None: json['value'] = self.value if self.formula is not None: json['formula'] = self.formula if self.uncertainty is not None: json['uncertainty'] = self.uncertainty.to_json() return json
class ImpactMethod (id: str = '', olca_type: str = 'ImpactMethod', name: Optional[str] = None, description: Optional[str] = None, version: Optional[str] = None, last_change: Optional[str] = None, category: Optional[Ref] = None, tags: Optional[List[str]] = None, library: Optional[str] = None, impact_categories: Optional[List[Ref]] = None, nw_sets: Optional[List[NwSet]] = None)-
An impact assessment method.
Attributes
Expand source code
@dataclass class ImpactMethod(CategorizedEntity): """ An impact assessment method. Attributes ---------- impact_categories: List[Ref] The impact categories of the method. nw_sets: List[NwSet] The normalization and weighting sets of the method. """ olca_type: str = 'ImpactMethod' impact_categories: Optional[List[Ref]] = None nw_sets: Optional[List[NwSet]] = None def to_json(self) -> dict: json: dict = super(ImpactMethod, self).to_json() if self.impact_categories is not None: json['impactCategories'] = [] for e in self.impact_categories: json['impactCategories'].append(e.to_json()) if self.nw_sets is not None: json['nwSets'] = [] for e in self.nw_sets: json['nwSets'].append(e.to_json()) return json def read_json(self, json: dict): super(ImpactMethod, self).read_json(json) val = json.get('impactCategories') if val is not None: self.impact_categories = [] for d in val: e = Ref() e.read_json(d) self.impact_categories.append(e) val = json.get('nwSets') if val is not None: self.nw_sets = [] for d in val: e = NwSet() e.read_json(d) self.nw_sets.append(e) @staticmethod def from_json(json: dict): instance = ImpactMethod() instance.read_json(json) return instanceAncestors
Class variables
var impact_categories : Optional[List[Ref]]var nw_sets : Optional[List[NwSet]]var olca_type : str
Static methods
def from_json(json: dict)-
Expand source code
@staticmethod def from_json(json: dict): instance = ImpactMethod() instance.read_json(json) return instance
Methods
def read_json(self, json: dict)-
Expand source code
def read_json(self, json: dict): super(ImpactMethod, self).read_json(json) val = json.get('impactCategories') if val is not None: self.impact_categories = [] for d in val: e = Ref() e.read_json(d) self.impact_categories.append(e) val = json.get('nwSets') if val is not None: self.nw_sets = [] for d in val: e = NwSet() e.read_json(d) self.nw_sets.append(e) def to_json(self) ‑> dict-
Expand source code
def to_json(self) -> dict: json: dict = super(ImpactMethod, self).to_json() if self.impact_categories is not None: json['impactCategories'] = [] for e in self.impact_categories: json['impactCategories'].append(e.to_json()) if self.nw_sets is not None: json['nwSets'] = [] for e in self.nw_sets: json['nwSets'].append(e.to_json()) return json
class ImpactResult (id: str = '', olca_type: str = 'ImpactResult', impact_category: Optional[Ref] = None, value: Optional[float] = None)-
A result value for an impact assessment category.
Attributes
impact_category:Ref- The reference to the impact assessment category.
value:float- The value of the flow amount.
Expand source code
@dataclass class ImpactResult(Entity): """ A result value for an impact assessment category. Attributes ---------- impact_category: Ref The reference to the impact assessment category. value: float The value of the flow amount. """ olca_type: str = 'ImpactResult' impact_category: Optional[Ref] = None value: Optional[float] = None def to_json(self) -> dict: json: dict = super(ImpactResult, self).to_json() if self.impact_category is not None: json['impactCategory'] = self.impact_category.to_json() if self.value is not None: json['value'] = self.value return json def read_json(self, json: dict): super(ImpactResult, self).read_json(json) val = json.get('impactCategory') if val is not None: self.impact_category = Ref() self.impact_category.read_json(val) val = json.get('value') if val is not None: self.value = val @staticmethod def from_json(json: dict): instance = ImpactResult() instance.read_json(json) return instanceAncestors
Class variables
var impact_category : Optional[Ref]var olca_type : strvar value : Optional[float]
Static methods
def from_json(json: dict)-
Expand source code
@staticmethod def from_json(json: dict): instance = ImpactResult() instance.read_json(json) return instance
Methods
def read_json(self, json: dict)-
Expand source code
def read_json(self, json: dict): super(ImpactResult, self).read_json(json) val = json.get('impactCategory') if val is not None: self.impact_category = Ref() self.impact_category.read_json(val) val = json.get('value') if val is not None: self.value = val def to_json(self) ‑> dict-
Expand source code
def to_json(self) -> dict: json: dict = super(ImpactResult, self).to_json() if self.impact_category is not None: json['impactCategory'] = self.impact_category.to_json() if self.value is not None: json['value'] = self.value return json
class Location (id: str = '', olca_type: str = 'Location', name: Optional[str] = None, description: Optional[str] = None, version: Optional[str] = None, last_change: Optional[str] = None, category: Optional[Ref] = None, tags: Optional[List[str]] = None, library: Optional[str] = None, code: Optional[str] = None, latitude: Optional[float] = None, longitude: Optional[float] = None, geometry: Optional[dict] = None)-
A location like a country, state, city, etc.
Attributes
code:str- The code of the location (e.g. an ISO 2-letter country code).
latitude:float- The average latitude of the location.
longitude:float- The average longitude of the location.
geometry:dict- A GeoJSON object.
Expand source code
@dataclass class Location(CategorizedEntity): """ A location like a country, state, city, etc. Attributes ---------- code: str The code of the location (e.g. an ISO 2-letter country code). latitude: float The average latitude of the location. longitude: float The average longitude of the location. geometry: dict A GeoJSON object. """ olca_type: str = 'Location' code: Optional[str] = None latitude: Optional[float] = None longitude: Optional[float] = None geometry: Optional[dict] = None def to_json(self) -> dict: json: dict = super(Location, self).to_json() if self.code is not None: json['code'] = self.code if self.latitude is not None: json['latitude'] = self.latitude if self.longitude is not None: json['longitude'] = self.longitude if self.geometry is not None: json['geometry'] = self.geometry return json def read_json(self, json: dict): super(Location, self).read_json(json) val = json.get('code') if val is not None: self.code = val val = json.get('latitude') if val is not None: self.latitude = val val = json.get('longitude') if val is not None: self.longitude = val val = json.get('geometry') if val is not None: self.geometry = val @staticmethod def from_json(json: dict): instance = Location() instance.read_json(json) return instanceAncestors
Class variables
var code : Optional[str]var geometry : Optional[dict]var latitude : Optional[float]var longitude : Optional[float]var olca_type : str
Static methods
def from_json(json: dict)-
Expand source code
@staticmethod def from_json(json: dict): instance = Location() instance.read_json(json) return instance
Methods
def read_json(self, json: dict)-
Expand source code
def read_json(self, json: dict): super(Location, self).read_json(json) val = json.get('code') if val is not None: self.code = val val = json.get('latitude') if val is not None: self.latitude = val val = json.get('longitude') if val is not None: self.longitude = val val = json.get('geometry') if val is not None: self.geometry = val def to_json(self) ‑> dict-
Expand source code
def to_json(self) -> dict: json: dict = super(Location, self).to_json() if self.code is not None: json['code'] = self.code if self.latitude is not None: json['latitude'] = self.latitude if self.longitude is not None: json['longitude'] = self.longitude if self.geometry is not None: json['geometry'] = self.geometry return json
class ModelType (value, names=None, *, module=None, qualname=None, type=None, start=1)-
An enumeration of the root entity types.
Expand source code
class ModelType(Enum): """ An enumeration of the root entity types. """ ACTOR = 'ACTOR' CATEGORY = 'CATEGORY' CURRENCY = 'CURRENCY' DQ_SYSTEM = 'DQ_SYSTEM' FLOW = 'FLOW' FLOW_PROPERTY = 'FLOW_PROPERTY' IMPACT_CATEGORY = 'IMPACT_CATEGORY' IMPACT_METHOD = 'IMPACT_METHOD' LOCATION = 'LOCATION' NW_SET = 'NW_SET' PARAMETER = 'PARAMETER' PROCESS = 'PROCESS' PRODUCT_SYSTEM = 'PRODUCT_SYSTEM' PROJECT = 'PROJECT' SOCIAL_INDICATOR = 'SOCIAL_INDICATOR' SOURCE = 'SOURCE' UNIT = 'UNIT' UNIT_GROUP = 'UNIT_GROUP'Ancestors
- enum.Enum
Class variables
var ACTORvar CATEGORYvar CURRENCYvar DQ_SYSTEMvar FLOWvar FLOW_PROPERTYvar IMPACT_CATEGORYvar IMPACT_METHODvar LOCATIONvar NW_SETvar PARAMETERvar PROCESSvar PRODUCT_SYSTEMvar PROJECTvar SOCIAL_INDICATORvar SOURCEvar UNITvar UNIT_GROUP
class NwFactor (id: str = '', olca_type: str = 'NwFactor', impact_category: Optional[Ref] = None, normalisation_factor: Optional[float] = None, weighting_factor: Optional[float] = None)-
A normalization and weighting factor of a [NwSet] related to an impact category. Depending on the purpose of the [NwSet] (normalization, weighting, or both) the normalization and weighting factor can be present or not.
Attributes
impact_category:Refnormalisation_factor:floatweighting_factor:float
Expand source code
@dataclass class NwFactor(Entity): """ A normalization and weighting factor of a [NwSet] related to an impact category. Depending on the purpose of the [NwSet] (normalization, weighting, or both) the normalization and weighting factor can be present or not. Attributes ---------- impact_category: Ref normalisation_factor: float weighting_factor: float """ olca_type: str = 'NwFactor' impact_category: Optional[Ref] = None normalisation_factor: Optional[float] = None weighting_factor: Optional[float] = None def to_json(self) -> dict: json: dict = super(NwFactor, self).to_json() if self.impact_category is not None: json['impactCategory'] = self.impact_category.to_json() if self.normalisation_factor is not None: json['normalisationFactor'] = self.normalisation_factor if self.weighting_factor is not None: json['weightingFactor'] = self.weighting_factor return json def read_json(self, json: dict): super(NwFactor, self).read_json(json) val = json.get('impactCategory') if val is not None: self.impact_category = Ref() self.impact_category.read_json(val) val = json.get('normalisationFactor') if val is not None: self.normalisation_factor = val val = json.get('weightingFactor') if val is not None: self.weighting_factor = val @staticmethod def from_json(json: dict): instance = NwFactor() instance.read_json(json) return instanceAncestors
Class variables
var impact_category : Optional[Ref]var normalisation_factor : Optional[float]var olca_type : strvar weighting_factor : Optional[float]
Static methods
def from_json(json: dict)-
Expand source code
@staticmethod def from_json(json: dict): instance = NwFactor() instance.read_json(json) return instance
Methods
def read_json(self, json: dict)-
Expand source code
def read_json(self, json: dict): super(NwFactor, self).read_json(json) val = json.get('impactCategory') if val is not None: self.impact_category = Ref() self.impact_category.read_json(val) val = json.get('normalisationFactor') if val is not None: self.normalisation_factor = val val = json.get('weightingFactor') if val is not None: self.weighting_factor = val def to_json(self) ‑> dict-
Expand source code
def to_json(self) -> dict: json: dict = super(NwFactor, self).to_json() if self.impact_category is not None: json['impactCategory'] = self.impact_category.to_json() if self.normalisation_factor is not None: json['normalisationFactor'] = self.normalisation_factor if self.weighting_factor is not None: json['weightingFactor'] = self.weighting_factor return json
class NwSet (id: str = '', olca_type: str = 'NwSet', name: Optional[str] = None, description: Optional[str] = None, version: Optional[str] = None, last_change: Optional[str] = None, weighted_score_unit: Optional[str] = None, factors: Optional[List[NwFactor]] = None)-
A normalization and weighting set.
Attributes
weighted_score_unit:str- This is the optional unit of the (normalized and) weighted score when this normalization and weighting set was applied on a LCIA result.
factors:List[NwFactor]- The list of normalization and weighting factors of this set.
Expand source code
@dataclass class NwSet(RootEntity): """ A normalization and weighting set. Attributes ---------- weighted_score_unit: str This is the optional unit of the (normalized and) weighted score when this normalization and weighting set was applied on a LCIA result. factors: List[NwFactor] The list of normalization and weighting factors of this set. """ olca_type: str = 'NwSet' weighted_score_unit: Optional[str] = None factors: Optional[List[NwFactor]] = None def to_json(self) -> dict: json: dict = super(NwSet, self).to_json() if self.weighted_score_unit is not None: json['weightedScoreUnit'] = self.weighted_score_unit if self.factors is not None: json['factors'] = [] for e in self.factors: json['factors'].append(e.to_json()) return json def read_json(self, json: dict): super(NwSet, self).read_json(json) val = json.get('weightedScoreUnit') if val is not None: self.weighted_score_unit = val val = json.get('factors') if val is not None: self.factors = [] for d in val: e = NwFactor() e.read_json(d) self.factors.append(e) @staticmethod def from_json(json: dict): instance = NwSet() instance.read_json(json) return instanceAncestors
Class variables
var factors : Optional[List[NwFactor]]var olca_type : strvar weighted_score_unit : Optional[str]
Static methods
def from_json(json: dict)-
Expand source code
@staticmethod def from_json(json: dict): instance = NwSet() instance.read_json(json) return instance
Methods
def read_json(self, json: dict)-
Expand source code
def read_json(self, json: dict): super(NwSet, self).read_json(json) val = json.get('weightedScoreUnit') if val is not None: self.weighted_score_unit = val val = json.get('factors') if val is not None: self.factors = [] for d in val: e = NwFactor() e.read_json(d) self.factors.append(e) def to_json(self) ‑> dict-
Expand source code
def to_json(self) -> dict: json: dict = super(NwSet, self).to_json() if self.weighted_score_unit is not None: json['weightedScoreUnit'] = self.weighted_score_unit if self.factors is not None: json['factors'] = [] for e in self.factors: json['factors'].append(e.to_json()) return json
class Parameter (id: str = '', olca_type: str = 'Parameter', name: Optional[str] = None, description: Optional[str] = None, version: Optional[str] = None, last_change: Optional[str] = None, category: Optional[Ref] = None, tags: Optional[List[str]] = None, library: Optional[str] = None, parameter_scope: Optional[ParameterScope] = None, input_parameter: Optional[bool] = None, value: Optional[float] = None, formula: Optional[str] = None, uncertainty: Optional[Uncertainty] = None)-
In openLCA, parameters can be defined in different scopes: global, process, or LCIA method. The parameter name can be used in formulas and, thus, need to conform to a specific syntax. Within a scope the parameter name should be unique (otherwise the evaluation is not deterministic). There are two types of parameters in openLCA: input parameters and dependent parameters. An input parameter can have an optional uncertainty distribution but not a formula. A dependent parameter can (should) have a formula (where also other parameters can be used) but no uncertainty distribution.
Attributes
parameter_scope:ParameterScope- The scope where the parameter is valid.
input_parameter:bool- Indicates whether the parameter is an input parameter (true) or a dependent/calculated parameter (false). A parameter can have a formula if it is not an input parameter.
value:float- The parameter value.
formula:str- A mathematical expression to calculate the parameter value.
uncertainty:Uncertainty- An uncertainty distribution of the parameter value. This is only valid for input parameters.
Expand source code
@dataclass class Parameter(CategorizedEntity): """ In openLCA, parameters can be defined in different scopes: global, process, or LCIA method. The parameter name can be used in formulas and, thus, need to conform to a specific syntax. Within a scope the parameter name should be unique (otherwise the evaluation is not deterministic). There are two types of parameters in openLCA: input parameters and dependent parameters. An input parameter can have an optional uncertainty distribution but not a formula. A dependent parameter can (should) have a formula (where also other parameters can be used) but no uncertainty distribution. Attributes ---------- parameter_scope: ParameterScope The scope where the parameter is valid. input_parameter: bool Indicates whether the parameter is an input parameter (true) or a dependent/calculated parameter (false). A parameter can have a formula if it is not an input parameter. value: float The parameter value. formula: str A mathematical expression to calculate the parameter value. uncertainty: Uncertainty An uncertainty distribution of the parameter value. This is only valid for input parameters. """ olca_type: str = 'Parameter' parameter_scope: Optional[ParameterScope] = None input_parameter: Optional[bool] = None value: Optional[float] = None formula: Optional[str] = None uncertainty: Optional[Uncertainty] = None def to_json(self) -> dict: json: dict = super(Parameter, self).to_json() if self.parameter_scope is not None: json['parameterScope'] = self.parameter_scope.value if self.input_parameter is not None: json['inputParameter'] = self.input_parameter if self.value is not None: json['value'] = self.value if self.formula is not None: json['formula'] = self.formula if self.uncertainty is not None: json['uncertainty'] = self.uncertainty.to_json() return json def read_json(self, json: dict): super(Parameter, self).read_json(json) val = json.get('parameterScope') if val is not None: self.parameter_scope = ParameterScope(val) val = json.get('inputParameter') if val is not None: self.input_parameter = val val = json.get('value') if val is not None: self.value = val val = json.get('formula') if val is not None: self.formula = val val = json.get('uncertainty') if val is not None: self.uncertainty = Uncertainty() self.uncertainty.read_json(val) @staticmethod def from_json(json: dict): instance = Parameter() instance.read_json(json) return instanceAncestors
Class variables
var formula : Optional[str]var input_parameter : Optional[bool]var olca_type : strvar parameter_scope : Optional[ParameterScope]var uncertainty : Optional[Uncertainty]var value : Optional[float]
Static methods
def from_json(json: dict)-
Expand source code
@staticmethod def from_json(json: dict): instance = Parameter() instance.read_json(json) return instance
Methods
def read_json(self, json: dict)-
Expand source code
def read_json(self, json: dict): super(Parameter, self).read_json(json) val = json.get('parameterScope') if val is not None: self.parameter_scope = ParameterScope(val) val = json.get('inputParameter') if val is not None: self.input_parameter = val val = json.get('value') if val is not None: self.value = val val = json.get('formula') if val is not None: self.formula = val val = json.get('uncertainty') if val is not None: self.uncertainty = Uncertainty() self.uncertainty.read_json(val) def to_json(self) ‑> dict-
Expand source code
def to_json(self) -> dict: json: dict = super(Parameter, self).to_json() if self.parameter_scope is not None: json['parameterScope'] = self.parameter_scope.value if self.input_parameter is not None: json['inputParameter'] = self.input_parameter if self.value is not None: json['value'] = self.value if self.formula is not None: json['formula'] = self.formula if self.uncertainty is not None: json['uncertainty'] = self.uncertainty.to_json() return json
class ParameterRedef (id: str = '', olca_type: str = 'ParameterRedef', context: Optional[Ref] = None, description: Optional[str] = None, name: Optional[str] = None, uncertainty: Optional[Uncertainty] = None, value: Optional[float] = None)-
A redefinition of a parameter in a product system.
Attributes
context:Ref- The context of the paramater (a process or LCIA method). If no context is provided it is assumed that this is a redefinition of a global parameter.
description:str- A description of this parameter redefinition.
name:str- The name of the redefined parameter. Note that parameter names are used in formulas so they need to follow specific syntax rules. A redefinition replaces a bound parameter in a specific context and thus has to exactly match the respective name.
uncertainty:Uncertainty- An uncertainty distribution for the redefined parameter value.
value:float- The value of the redefined parameter.
Expand source code
@dataclass class ParameterRedef(Entity): """ A redefinition of a parameter in a product system. Attributes ---------- context: Ref The context of the paramater (a process or LCIA method). If no context is provided it is assumed that this is a redefinition of a global parameter. description: str A description of this parameter redefinition. name: str The name of the redefined parameter. Note that parameter names are used in formulas so they need to follow specific syntax rules. A redefinition replaces a bound parameter in a specific context and thus has to exactly match the respective name. uncertainty: Uncertainty An uncertainty distribution for the redefined parameter value. value: float The value of the redefined parameter. """ olca_type: str = 'ParameterRedef' context: Optional[Ref] = None description: Optional[str] = None name: Optional[str] = None uncertainty: Optional[Uncertainty] = None value: Optional[float] = None def to_json(self) -> dict: json: dict = super(ParameterRedef, self).to_json() if self.context is not None: json['context'] = self.context.to_json() if self.description is not None: json['description'] = self.description if self.name is not None: json['name'] = self.name if self.uncertainty is not None: json['uncertainty'] = self.uncertainty.to_json() if self.value is not None: json['value'] = self.value return json def read_json(self, json: dict): super(ParameterRedef, self).read_json(json) val = json.get('context') if val is not None: self.context = Ref() self.context.read_json(val) val = json.get('description') if val is not None: self.description = val val = json.get('name') if val is not None: self.name = val val = json.get('uncertainty') if val is not None: self.uncertainty = Uncertainty() self.uncertainty.read_json(val) val = json.get('value') if val is not None: self.value = val @staticmethod def from_json(json: dict): instance = ParameterRedef() instance.read_json(json) return instanceAncestors
Class variables
var context : Optional[Ref]var description : Optional[str]var name : Optional[str]var olca_type : strvar uncertainty : Optional[Uncertainty]var value : Optional[float]
Static methods
def from_json(json: dict)-
Expand source code
@staticmethod def from_json(json: dict): instance = ParameterRedef() instance.read_json(json) return instance
Methods
def read_json(self, json: dict)-
Expand source code
def read_json(self, json: dict): super(ParameterRedef, self).read_json(json) val = json.get('context') if val is not None: self.context = Ref() self.context.read_json(val) val = json.get('description') if val is not None: self.description = val val = json.get('name') if val is not None: self.name = val val = json.get('uncertainty') if val is not None: self.uncertainty = Uncertainty() self.uncertainty.read_json(val) val = json.get('value') if val is not None: self.value = val def to_json(self) ‑> dict-
Expand source code
def to_json(self) -> dict: json: dict = super(ParameterRedef, self).to_json() if self.context is not None: json['context'] = self.context.to_json() if self.description is not None: json['description'] = self.description if self.name is not None: json['name'] = self.name if self.uncertainty is not None: json['uncertainty'] = self.uncertainty.to_json() if self.value is not None: json['value'] = self.value return json
class ParameterRedefSet (id: str = '', olca_type: str = 'ParameterRedefSet', name: Optional[str] = None, description: Optional[str] = None, is_baseline: Optional[bool] = None, parameters: Optional[List[ParameterRedef]] = None)-
An instance of this class is just a set of parameter redefinitions attached to a product system. It can have a name and a description. One of the parameter sets can be defined as the baseline of the product system. In the calculation the baseline set is then taken by default.
Attributes
name:str- The name of the parameter set.
description:str- A description of the parameter set.
is_baseline:bool- Indicates if this set of parameter redefinitions is the baseline for a product system.
parameters:List[ParameterRedef]- The parameter redefinitions of this redefinition set.
Expand source code
@dataclass class ParameterRedefSet(Entity): """ An instance of this class is just a set of parameter redefinitions attached to a product system. It can have a name and a description. One of the parameter sets can be defined as the baseline of the product system. In the calculation the baseline set is then taken by default. Attributes ---------- name: str The name of the parameter set. description: str A description of the parameter set. is_baseline: bool Indicates if this set of parameter redefinitions is the baseline for a product system. parameters: List[ParameterRedef] The parameter redefinitions of this redefinition set. """ olca_type: str = 'ParameterRedefSet' name: Optional[str] = None description: Optional[str] = None is_baseline: Optional[bool] = None parameters: Optional[List[ParameterRedef]] = None def to_json(self) -> dict: json: dict = super(ParameterRedefSet, self).to_json() if self.name is not None: json['name'] = self.name if self.description is not None: json['description'] = self.description if self.is_baseline is not None: json['isBaseline'] = self.is_baseline if self.parameters is not None: json['parameters'] = [] for e in self.parameters: json['parameters'].append(e.to_json()) return json def read_json(self, json: dict): super(ParameterRedefSet, self).read_json(json) val = json.get('name') if val is not None: self.name = val val = json.get('description') if val is not None: self.description = val val = json.get('isBaseline') if val is not None: self.is_baseline = val val = json.get('parameters') if val is not None: self.parameters = [] for d in val: e = ParameterRedef() e.read_json(d) self.parameters.append(e) @staticmethod def from_json(json: dict): instance = ParameterRedefSet() instance.read_json(json) return instanceAncestors
Class variables
var description : Optional[str]var is_baseline : Optional[bool]var name : Optional[str]var olca_type : strvar parameters : Optional[List[ParameterRedef]]
Static methods
def from_json(json: dict)-
Expand source code
@staticmethod def from_json(json: dict): instance = ParameterRedefSet() instance.read_json(json) return instance
Methods
def read_json(self, json: dict)-
Expand source code
def read_json(self, json: dict): super(ParameterRedefSet, self).read_json(json) val = json.get('name') if val is not None: self.name = val val = json.get('description') if val is not None: self.description = val val = json.get('isBaseline') if val is not None: self.is_baseline = val val = json.get('parameters') if val is not None: self.parameters = [] for d in val: e = ParameterRedef() e.read_json(d) self.parameters.append(e) def to_json(self) ‑> dict-
Expand source code
def to_json(self) -> dict: json: dict = super(ParameterRedefSet, self).to_json() if self.name is not None: json['name'] = self.name if self.description is not None: json['description'] = self.description if self.is_baseline is not None: json['isBaseline'] = self.is_baseline if self.parameters is not None: json['parameters'] = [] for e in self.parameters: json['parameters'].append(e.to_json()) return json
class ParameterScope (value, names=None, *, module=None, qualname=None, type=None, start=1)-
The possible scopes of parameters. Parameters can be defined globally, in processes, or impact categories. They can be redefined in calculation setups on the project and product system level, but the initial definition is always only global, in a process, or an LCIA category.
Expand source code
class ParameterScope(Enum): """ The possible scopes of parameters. Parameters can be defined globally, in processes, or impact categories. They can be redefined in calculation setups on the project and product system level, but the initial definition is always only global, in a process, or an LCIA category. """ PROCESS_SCOPE = 'PROCESS_SCOPE' """ Indicates that the evaluation scope of a parameter is the process where it is defined. """ IMPACT_SCOPE = 'IMPACT_SCOPE' """ Indicates that the evaluation scope of a parameter is the impact category where it is defined. """ GLOBAL_SCOPE = 'GLOBAL_SCOPE' """ Indicates that the evaluation scope of a parameter is the global scope. """Ancestors
- enum.Enum
Class variables
var GLOBAL_SCOPE-
Indicates that the evaluation scope of a parameter is the global scope.
var IMPACT_SCOPE-
Indicates that the evaluation scope of a parameter is the impact category where it is defined.
var PROCESS_SCOPE-
Indicates that the evaluation scope of a parameter is the process where it is defined.
class Process (id: str = '', olca_type: str = 'Process', name: Optional[str] = None, description: Optional[str] = None, version: Optional[str] = None, last_change: Optional[str] = None, category: Optional[Ref] = None, tags: Optional[List[str]] = None, library: Optional[str] = None, allocation_factors: Optional[List[AllocationFactor]] = None, default_allocation_method: Optional[AllocationType] = None, exchanges: Optional[List[Exchange]] = None, last_internal_id: Optional[int] = None, location: Optional[Ref] = None, parameters: Optional[List[Parameter]] = None, process_documentation: Optional[ProcessDocumentation] = None, process_type: Optional[ProcessType] = None, dq_system: Optional[Ref] = None, exchange_dq_system: Optional[Ref] = None, social_dq_system: Optional[Ref] = None, dq_entry: Optional[str] = None, infrastructure_process: Optional[bool] = None, social_aspects: Optional[List[SocialAspect]] = None)-
Attributes
allocation_factors:List[AllocationFactor]default_allocation_method:AllocationTypeexchanges:List[Exchange]- The inputs and outputs of the process.
last_internal_id:int- This field holds the last internal ID that was used in an exchange
(which may have been deleted, so it can be larger than the largest
internal ID of the exchanges of the process.) The internal ID of an
exchange is used to identify exchanges within a process (for updates,
data exchanges (see process links), etc.). When you add an exchange to
a process, you should increment this field in the process and set the
resulting value as the internal ID of that exchange. The sequence of
internal IDs should start with
1. location:Ref- The location of the process.
parameters:List[Parameter]process_documentation:ProcessDocumentationprocess_type:ProcessTypedq_system:Ref- A reference to a data quality system ([DQSystem]) with which the overall quality of the process can be assessed.
exchange_dq_system:Ref- A reference to a data quality system ([DQSystem]) with which the quality of individual inputs and outputs ([Exchange]s) of the process can be assessed.
social_dq_system:Ref- A reference to a data quality system ([DQSystem]) with which the quality of individual social aspects of the process can be assessed.
dq_entry:str- A data quality entry like
(1;3;2;5;1). The entry is a vector of data quality values that need to match the overall data quality system of the process (the system that is stored in thedqSystemproperty). In such a system the data quality indicators have fixed positions and the respective values in thedqEntryvector map to these positions. infrastructure_process:bool- Indicates whether this process describes an infrastructure process. This field is part of the openLCA schema because of backward compatibility with EcoSpold 1. It does not really have a meaning in openLCA and should not be used anymore.
social_aspects:List[SocialAspect]- A set of social aspects related to this process.
Expand source code
@dataclass class Process(CategorizedEntity): """ Attributes ---------- allocation_factors: List[AllocationFactor] default_allocation_method: AllocationType exchanges: List[Exchange] The inputs and outputs of the process. last_internal_id: int This field holds the last internal ID that was used in an exchange (which may have been deleted, so it can be larger than the largest internal ID of the exchanges of the process.) The internal ID of an exchange is used to identify exchanges within a process (for updates, data exchanges (see process links), etc.). When you add an exchange to a process, you should increment this field in the process and set the resulting value as the internal ID of that exchange. The sequence of internal IDs should start with `1`. location: Ref The location of the process. parameters: List[Parameter] process_documentation: ProcessDocumentation process_type: ProcessType dq_system: Ref A reference to a data quality system ([DQSystem]) with which the overall quality of the process can be assessed. exchange_dq_system: Ref A reference to a data quality system ([DQSystem]) with which the quality of individual inputs and outputs ([Exchange]s) of the process can be assessed. social_dq_system: Ref A reference to a data quality system ([DQSystem]) with which the quality of individual social aspects of the process can be assessed. dq_entry: str A data quality entry like `(1;3;2;5;1)`. The entry is a vector of data quality values that need to match the overall data quality system of the process (the system that is stored in the `dqSystem` property). In such a system the data quality indicators have fixed positions and the respective values in the `dqEntry` vector map to these positions. infrastructure_process: bool Indicates whether this process describes an infrastructure process. This field is part of the openLCA schema because of backward compatibility with EcoSpold 1. It does not really have a meaning in openLCA and should not be used anymore. social_aspects: List[SocialAspect] A set of social aspects related to this process. """ olca_type: str = 'Process' allocation_factors: Optional[List[AllocationFactor]] = None default_allocation_method: Optional[AllocationType] = None exchanges: Optional[List[Exchange]] = None last_internal_id: Optional[int] = None location: Optional[Ref] = None parameters: Optional[List[Parameter]] = None process_documentation: Optional[ProcessDocumentation] = None process_type: Optional[ProcessType] = None dq_system: Optional[Ref] = None exchange_dq_system: Optional[Ref] = None social_dq_system: Optional[Ref] = None dq_entry: Optional[str] = None infrastructure_process: Optional[bool] = None social_aspects: Optional[List[SocialAspect]] = None def to_json(self) -> dict: json: dict = super(Process, self).to_json() if self.allocation_factors is not None: json['allocationFactors'] = [] for e in self.allocation_factors: json['allocationFactors'].append(e.to_json()) if self.default_allocation_method is not None: json['defaultAllocationMethod'] = self.default_allocation_method.value if self.exchanges is not None: json['exchanges'] = [] for e in self.exchanges: json['exchanges'].append(e.to_json()) if self.last_internal_id is not None: json['lastInternalId'] = self.last_internal_id if self.location is not None: json['location'] = self.location.to_json() if self.parameters is not None: json['parameters'] = [] for e in self.parameters: json['parameters'].append(e.to_json()) if self.process_documentation is not None: json['processDocumentation'] = self.process_documentation.to_json() if self.process_type is not None: json['processType'] = self.process_type.value if self.dq_system is not None: json['dqSystem'] = self.dq_system.to_json() if self.exchange_dq_system is not None: json['exchangeDqSystem'] = self.exchange_dq_system.to_json() if self.social_dq_system is not None: json['socialDqSystem'] = self.social_dq_system.to_json() if self.dq_entry is not None: json['dqEntry'] = self.dq_entry if self.infrastructure_process is not None: json['infrastructureProcess'] = self.infrastructure_process if self.social_aspects is not None: json['socialAspects'] = [] for e in self.social_aspects: json['socialAspects'].append(e.to_json()) return json def read_json(self, json: dict): super(Process, self).read_json(json) val = json.get('allocationFactors') if val is not None: self.allocation_factors = [] for d in val: e = AllocationFactor() e.read_json(d) self.allocation_factors.append(e) val = json.get('defaultAllocationMethod') if val is not None: self.default_allocation_method = AllocationType(val) val = json.get('exchanges') if val is not None: self.exchanges = [] for d in val: e = Exchange() e.read_json(d) self.exchanges.append(e) val = json.get('lastInternalId') if val is not None: self.last_internal_id = val val = json.get('location') if val is not None: self.location = Ref() self.location.read_json(val) val = json.get('parameters') if val is not None: self.parameters = [] for d in val: e = Parameter() e.read_json(d) self.parameters.append(e) val = json.get('processDocumentation') if val is not None: self.process_documentation = ProcessDocumentation() self.process_documentation.read_json(val) val = json.get('processType') if val is not None: self.process_type = ProcessType(val) val = json.get('dqSystem') if val is not None: self.dq_system = Ref() self.dq_system.read_json(val) val = json.get('exchangeDqSystem') if val is not None: self.exchange_dq_system = Ref() self.exchange_dq_system.read_json(val) val = json.get('socialDqSystem') if val is not None: self.social_dq_system = Ref() self.social_dq_system.read_json(val) val = json.get('dqEntry') if val is not None: self.dq_entry = val val = json.get('infrastructureProcess') if val is not None: self.infrastructure_process = val val = json.get('socialAspects') if val is not None: self.social_aspects = [] for d in val: e = SocialAspect() e.read_json(d) self.social_aspects.append(e) @staticmethod def from_json(json: dict): instance = Process() instance.read_json(json) return instanceAncestors
Class variables
var allocation_factors : Optional[List[AllocationFactor]]var default_allocation_method : Optional[AllocationType]var dq_entry : Optional[str]var dq_system : Optional[Ref]var exchange_dq_system : Optional[Ref]var exchanges : Optional[List[Exchange]]var infrastructure_process : Optional[bool]var last_internal_id : Optional[int]var location : Optional[Ref]var olca_type : strvar parameters : Optional[List[Parameter]]var process_documentation : Optional[ProcessDocumentation]var process_type : Optional[ProcessType]
Static methods
def from_json(json: dict)-
Expand source code
@staticmethod def from_json(json: dict): instance = Process() instance.read_json(json) return instance
Methods
def read_json(self, json: dict)-
Expand source code
def read_json(self, json: dict): super(Process, self).read_json(json) val = json.get('allocationFactors') if val is not None: self.allocation_factors = [] for d in val: e = AllocationFactor() e.read_json(d) self.allocation_factors.append(e) val = json.get('defaultAllocationMethod') if val is not None: self.default_allocation_method = AllocationType(val) val = json.get('exchanges') if val is not None: self.exchanges = [] for d in val: e = Exchange() e.read_json(d) self.exchanges.append(e) val = json.get('lastInternalId') if val is not None: self.last_internal_id = val val = json.get('location') if val is not None: self.location = Ref() self.location.read_json(val) val = json.get('parameters') if val is not None: self.parameters = [] for d in val: e = Parameter() e.read_json(d) self.parameters.append(e) val = json.get('processDocumentation') if val is not None: self.process_documentation = ProcessDocumentation() self.process_documentation.read_json(val) val = json.get('processType') if val is not None: self.process_type = ProcessType(val) val = json.get('dqSystem') if val is not None: self.dq_system = Ref() self.dq_system.read_json(val) val = json.get('exchangeDqSystem') if val is not None: self.exchange_dq_system = Ref() self.exchange_dq_system.read_json(val) val = json.get('socialDqSystem') if val is not None: self.social_dq_system = Ref() self.social_dq_system.read_json(val) val = json.get('dqEntry') if val is not None: self.dq_entry = val val = json.get('infrastructureProcess') if val is not None: self.infrastructure_process = val val = json.get('socialAspects') if val is not None: self.social_aspects = [] for d in val: e = SocialAspect() e.read_json(d) self.social_aspects.append(e) def to_json(self) ‑> dict-
Expand source code
def to_json(self) -> dict: json: dict = super(Process, self).to_json() if self.allocation_factors is not None: json['allocationFactors'] = [] for e in self.allocation_factors: json['allocationFactors'].append(e.to_json()) if self.default_allocation_method is not None: json['defaultAllocationMethod'] = self.default_allocation_method.value if self.exchanges is not None: json['exchanges'] = [] for e in self.exchanges: json['exchanges'].append(e.to_json()) if self.last_internal_id is not None: json['lastInternalId'] = self.last_internal_id if self.location is not None: json['location'] = self.location.to_json() if self.parameters is not None: json['parameters'] = [] for e in self.parameters: json['parameters'].append(e.to_json()) if self.process_documentation is not None: json['processDocumentation'] = self.process_documentation.to_json() if self.process_type is not None: json['processType'] = self.process_type.value if self.dq_system is not None: json['dqSystem'] = self.dq_system.to_json() if self.exchange_dq_system is not None: json['exchangeDqSystem'] = self.exchange_dq_system.to_json() if self.social_dq_system is not None: json['socialDqSystem'] = self.social_dq_system.to_json() if self.dq_entry is not None: json['dqEntry'] = self.dq_entry if self.infrastructure_process is not None: json['infrastructureProcess'] = self.infrastructure_process if self.social_aspects is not None: json['socialAspects'] = [] for e in self.social_aspects: json['socialAspects'].append(e.to_json()) return json
class ProcessDocumentation (id: str = '', olca_type: str = 'ProcessDocumentation', time_description: Optional[str] = None, valid_until: Optional[str] = None, valid_from: Optional[str] = None, technology_description: Optional[str] = None, data_collection_description: Optional[str] = None, completeness_description: Optional[str] = None, data_selection_description: Optional[str] = None, review_details: Optional[str] = None, data_treatment_description: Optional[str] = None, inventory_method_description: Optional[str] = None, modeling_constants_description: Optional[str] = None, reviewer: Optional[Ref] = None, sampling_description: Optional[str] = None, sources: Optional[List[Ref]] = None, restrictions_description: Optional[str] = None, copyright: Optional[bool] = None, creation_date: Optional[str] = None, data_documentor: Optional[Ref] = None, data_generator: Optional[Ref] = None, data_set_owner: Optional[Ref] = None, intended_application: Optional[str] = None, project_description: Optional[str] = None, publication: Optional[Ref] = None, geography_description: Optional[str] = None)-
Attributes
time_description:strvalid_until:strvalid_from:strtechnology_description:strdata_collection_description:strcompleteness_description:strdata_selection_description:strreview_details:strdata_treatment_description:strinventory_method_description:strmodeling_constants_description:strreviewer:Refsampling_description:strsources:List[Ref]restrictions_description:strcopyright:boolcreation_date:strdata_documentor:Refdata_generator:Refdata_set_owner:Refintended_application:strproject_description:strpublication:Refgeography_description:str
Expand source code
@dataclass class ProcessDocumentation(Entity): """ Attributes ---------- time_description: str valid_until: str valid_from: str technology_description: str data_collection_description: str completeness_description: str data_selection_description: str review_details: str data_treatment_description: str inventory_method_description: str modeling_constants_description: str reviewer: Ref sampling_description: str sources: List[Ref] restrictions_description: str copyright: bool creation_date: str data_documentor: Ref data_generator: Ref data_set_owner: Ref intended_application: str project_description: str publication: Ref geography_description: str """ olca_type: str = 'ProcessDocumentation' time_description: Optional[str] = None valid_until: Optional[str] = None valid_from: Optional[str] = None technology_description: Optional[str] = None data_collection_description: Optional[str] = None completeness_description: Optional[str] = None data_selection_description: Optional[str] = None review_details: Optional[str] = None data_treatment_description: Optional[str] = None inventory_method_description: Optional[str] = None modeling_constants_description: Optional[str] = None reviewer: Optional[Ref] = None sampling_description: Optional[str] = None sources: Optional[List[Ref]] = None restrictions_description: Optional[str] = None copyright: Optional[bool] = None creation_date: Optional[str] = None data_documentor: Optional[Ref] = None data_generator: Optional[Ref] = None data_set_owner: Optional[Ref] = None intended_application: Optional[str] = None project_description: Optional[str] = None publication: Optional[Ref] = None geography_description: Optional[str] = None def to_json(self) -> dict: json: dict = super(ProcessDocumentation, self).to_json() if self.time_description is not None: json['timeDescription'] = self.time_description if self.valid_until is not None: json['validUntil'] = self.valid_until if self.valid_from is not None: json['validFrom'] = self.valid_from if self.technology_description is not None: json['technologyDescription'] = self.technology_description if self.data_collection_description is not None: json['dataCollectionDescription'] = self.data_collection_description if self.completeness_description is not None: json['completenessDescription'] = self.completeness_description if self.data_selection_description is not None: json['dataSelectionDescription'] = self.data_selection_description if self.review_details is not None: json['reviewDetails'] = self.review_details if self.data_treatment_description is not None: json['dataTreatmentDescription'] = self.data_treatment_description if self.inventory_method_description is not None: json['inventoryMethodDescription'] = self.inventory_method_description if self.modeling_constants_description is not None: json['modelingConstantsDescription'] = self.modeling_constants_description if self.reviewer is not None: json['reviewer'] = self.reviewer.to_json() if self.sampling_description is not None: json['samplingDescription'] = self.sampling_description if self.sources is not None: json['sources'] = [] for e in self.sources: json['sources'].append(e.to_json()) if self.restrictions_description is not None: json['restrictionsDescription'] = self.restrictions_description if self.copyright is not None: json['copyright'] = self.copyright if self.creation_date is not None: json['creationDate'] = self.creation_date if self.data_documentor is not None: json['dataDocumentor'] = self.data_documentor.to_json() if self.data_generator is not None: json['dataGenerator'] = self.data_generator.to_json() if self.data_set_owner is not None: json['dataSetOwner'] = self.data_set_owner.to_json() if self.intended_application is not None: json['intendedApplication'] = self.intended_application if self.project_description is not None: json['projectDescription'] = self.project_description if self.publication is not None: json['publication'] = self.publication.to_json() if self.geography_description is not None: json['geographyDescription'] = self.geography_description return json def read_json(self, json: dict): super(ProcessDocumentation, self).read_json(json) val = json.get('timeDescription') if val is not None: self.time_description = val val = json.get('validUntil') if val is not None: self.valid_until = val val = json.get('validFrom') if val is not None: self.valid_from = val val = json.get('technologyDescription') if val is not None: self.technology_description = val val = json.get('dataCollectionDescription') if val is not None: self.data_collection_description = val val = json.get('completenessDescription') if val is not None: self.completeness_description = val val = json.get('dataSelectionDescription') if val is not None: self.data_selection_description = val val = json.get('reviewDetails') if val is not None: self.review_details = val val = json.get('dataTreatmentDescription') if val is not None: self.data_treatment_description = val val = json.get('inventoryMethodDescription') if val is not None: self.inventory_method_description = val val = json.get('modelingConstantsDescription') if val is not None: self.modeling_constants_description = val val = json.get('reviewer') if val is not None: self.reviewer = Ref() self.reviewer.read_json(val) val = json.get('samplingDescription') if val is not None: self.sampling_description = val val = json.get('sources') if val is not None: self.sources = [] for d in val: e = Ref() e.read_json(d) self.sources.append(e) val = json.get('restrictionsDescription') if val is not None: self.restrictions_description = val val = json.get('copyright') if val is not None: self.copyright = val val = json.get('creationDate') if val is not None: self.creation_date = val val = json.get('dataDocumentor') if val is not None: self.data_documentor = Ref() self.data_documentor.read_json(val) val = json.get('dataGenerator') if val is not None: self.data_generator = Ref() self.data_generator.read_json(val) val = json.get('dataSetOwner') if val is not None: self.data_set_owner = Ref() self.data_set_owner.read_json(val) val = json.get('intendedApplication') if val is not None: self.intended_application = val val = json.get('projectDescription') if val is not None: self.project_description = val val = json.get('publication') if val is not None: self.publication = Ref() self.publication.read_json(val) val = json.get('geographyDescription') if val is not None: self.geography_description = val @staticmethod def from_json(json: dict): instance = ProcessDocumentation() instance.read_json(json) return instanceAncestors
Class variables
var completeness_description : Optional[str]var copyright : Optional[bool]var creation_date : Optional[str]var data_collection_description : Optional[str]var data_documentor : Optional[Ref]var data_generator : Optional[Ref]var data_selection_description : Optional[str]var data_set_owner : Optional[Ref]var data_treatment_description : Optional[str]var geography_description : Optional[str]var intended_application : Optional[str]var inventory_method_description : Optional[str]var modeling_constants_description : Optional[str]var olca_type : strvar project_description : Optional[str]var publication : Optional[Ref]var restrictions_description : Optional[str]var review_details : Optional[str]var reviewer : Optional[Ref]var sampling_description : Optional[str]var sources : Optional[List[Ref]]var technology_description : Optional[str]var time_description : Optional[str]var valid_from : Optional[str]var valid_until : Optional[str]
Static methods
def from_json(json: dict)-
Expand source code
@staticmethod def from_json(json: dict): instance = ProcessDocumentation() instance.read_json(json) return instance
Methods
def read_json(self, json: dict)-
Expand source code
def read_json(self, json: dict): super(ProcessDocumentation, self).read_json(json) val = json.get('timeDescription') if val is not None: self.time_description = val val = json.get('validUntil') if val is not None: self.valid_until = val val = json.get('validFrom') if val is not None: self.valid_from = val val = json.get('technologyDescription') if val is not None: self.technology_description = val val = json.get('dataCollectionDescription') if val is not None: self.data_collection_description = val val = json.get('completenessDescription') if val is not None: self.completeness_description = val val = json.get('dataSelectionDescription') if val is not None: self.data_selection_description = val val = json.get('reviewDetails') if val is not None: self.review_details = val val = json.get('dataTreatmentDescription') if val is not None: self.data_treatment_description = val val = json.get('inventoryMethodDescription') if val is not None: self.inventory_method_description = val val = json.get('modelingConstantsDescription') if val is not None: self.modeling_constants_description = val val = json.get('reviewer') if val is not None: self.reviewer = Ref() self.reviewer.read_json(val) val = json.get('samplingDescription') if val is not None: self.sampling_description = val val = json.get('sources') if val is not None: self.sources = [] for d in val: e = Ref() e.read_json(d) self.sources.append(e) val = json.get('restrictionsDescription') if val is not None: self.restrictions_description = val val = json.get('copyright') if val is not None: self.copyright = val val = json.get('creationDate') if val is not None: self.creation_date = val val = json.get('dataDocumentor') if val is not None: self.data_documentor = Ref() self.data_documentor.read_json(val) val = json.get('dataGenerator') if val is not None: self.data_generator = Ref() self.data_generator.read_json(val) val = json.get('dataSetOwner') if val is not None: self.data_set_owner = Ref() self.data_set_owner.read_json(val) val = json.get('intendedApplication') if val is not None: self.intended_application = val val = json.get('projectDescription') if val is not None: self.project_description = val val = json.get('publication') if val is not None: self.publication = Ref() self.publication.read_json(val) val = json.get('geographyDescription') if val is not None: self.geography_description = val def to_json(self) ‑> dict-
Expand source code
def to_json(self) -> dict: json: dict = super(ProcessDocumentation, self).to_json() if self.time_description is not None: json['timeDescription'] = self.time_description if self.valid_until is not None: json['validUntil'] = self.valid_until if self.valid_from is not None: json['validFrom'] = self.valid_from if self.technology_description is not None: json['technologyDescription'] = self.technology_description if self.data_collection_description is not None: json['dataCollectionDescription'] = self.data_collection_description if self.completeness_description is not None: json['completenessDescription'] = self.completeness_description if self.data_selection_description is not None: json['dataSelectionDescription'] = self.data_selection_description if self.review_details is not None: json['reviewDetails'] = self.review_details if self.data_treatment_description is not None: json['dataTreatmentDescription'] = self.data_treatment_description if self.inventory_method_description is not None: json['inventoryMethodDescription'] = self.inventory_method_description if self.modeling_constants_description is not None: json['modelingConstantsDescription'] = self.modeling_constants_description if self.reviewer is not None: json['reviewer'] = self.reviewer.to_json() if self.sampling_description is not None: json['samplingDescription'] = self.sampling_description if self.sources is not None: json['sources'] = [] for e in self.sources: json['sources'].append(e.to_json()) if self.restrictions_description is not None: json['restrictionsDescription'] = self.restrictions_description if self.copyright is not None: json['copyright'] = self.copyright if self.creation_date is not None: json['creationDate'] = self.creation_date if self.data_documentor is not None: json['dataDocumentor'] = self.data_documentor.to_json() if self.data_generator is not None: json['dataGenerator'] = self.data_generator.to_json() if self.data_set_owner is not None: json['dataSetOwner'] = self.data_set_owner.to_json() if self.intended_application is not None: json['intendedApplication'] = self.intended_application if self.project_description is not None: json['projectDescription'] = self.project_description if self.publication is not None: json['publication'] = self.publication.to_json() if self.geography_description is not None: json['geographyDescription'] = self.geography_description return json
class ProcessLink (id: str = '', olca_type: str = 'ProcessLink', provider: Optional[Ref] = None, flow: Optional[Ref] = None, process: Optional[Ref] = None, exchange: Optional[ExchangeRef] = None)-
A process link is a connection between two processes in a product system.
Attributes
provider:Ref- The descriptor of the process or product system that provides a product or a waste treatment.
flow:Ref- The descriptor of the flow that is exchanged between the two processes.
process:Ref- The descriptor of the process that is linked to the provider.
exchange:ExchangeRef- The exchange of the linked process (this is useful if the linked process has multiple exchanges with the same flow that are linked to different provides, e.g. in an electricity mix).
Expand source code
@dataclass class ProcessLink(Entity): """ A process link is a connection between two processes in a product system. Attributes ---------- provider: Ref The descriptor of the process or product system that provides a product or a waste treatment. flow: Ref The descriptor of the flow that is exchanged between the two processes. process: Ref The descriptor of the process that is linked to the provider. exchange: ExchangeRef The exchange of the linked process (this is useful if the linked process has multiple exchanges with the same flow that are linked to different provides, e.g. in an electricity mix). """ olca_type: str = 'ProcessLink' provider: Optional[Ref] = None flow: Optional[Ref] = None process: Optional[Ref] = None exchange: Optional[ExchangeRef] = None def to_json(self) -> dict: json: dict = super(ProcessLink, self).to_json() if self.provider is not None: json['provider'] = self.provider.to_json() if self.flow is not None: json['flow'] = self.flow.to_json() if self.process is not None: json['process'] = self.process.to_json() if self.exchange is not None: json['exchange'] = self.exchange.to_json() return json def read_json(self, json: dict): super(ProcessLink, self).read_json(json) val = json.get('provider') if val is not None: self.provider = Ref() self.provider.read_json(val) val = json.get('flow') if val is not None: self.flow = Ref() self.flow.read_json(val) val = json.get('process') if val is not None: self.process = Ref() self.process.read_json(val) val = json.get('exchange') if val is not None: self.exchange = ExchangeRef() self.exchange.read_json(val) @staticmethod def from_json(json: dict): instance = ProcessLink() instance.read_json(json) return instanceAncestors
Class variables
var exchange : Optional[ExchangeRef]var flow : Optional[Ref]var olca_type : strvar process : Optional[Ref]var provider : Optional[Ref]
Static methods
def from_json(json: dict)-
Expand source code
@staticmethod def from_json(json: dict): instance = ProcessLink() instance.read_json(json) return instance
Methods
def read_json(self, json: dict)-
Expand source code
def read_json(self, json: dict): super(ProcessLink, self).read_json(json) val = json.get('provider') if val is not None: self.provider = Ref() self.provider.read_json(val) val = json.get('flow') if val is not None: self.flow = Ref() self.flow.read_json(val) val = json.get('process') if val is not None: self.process = Ref() self.process.read_json(val) val = json.get('exchange') if val is not None: self.exchange = ExchangeRef() self.exchange.read_json(val) def to_json(self) ‑> dict-
Expand source code
def to_json(self) -> dict: json: dict = super(ProcessLink, self).to_json() if self.provider is not None: json['provider'] = self.provider.to_json() if self.flow is not None: json['flow'] = self.flow.to_json() if self.process is not None: json['process'] = self.process.to_json() if self.exchange is not None: json['exchange'] = self.exchange.to_json() return json
class ProcessType (value, names=None, *, module=None, qualname=None, type=None, start=1)-
An enumeration.
Expand source code
class ProcessType(Enum): LCI_RESULT = 'LCI_RESULT' UNIT_PROCESS = 'UNIT_PROCESS'Ancestors
- enum.Enum
Class variables
var LCI_RESULTvar UNIT_PROCESS
class ProductSystem (id: str = '', olca_type: str = 'ProductSystem', name: Optional[str] = None, description: Optional[str] = None, version: Optional[str] = None, last_change: Optional[str] = None, category: Optional[Ref] = None, tags: Optional[List[str]] = None, library: Optional[str] = None, processes: Optional[List[Ref]] = None, reference_process: Optional[Ref] = None, reference_exchange: Optional[ExchangeRef] = None, target_amount: Optional[float] = None, target_unit: Optional[Ref] = None, target_flow_property: Optional[Ref] = None, process_links: Optional[List[ProcessLink]] = None, parameter_sets: Optional[List[ParameterRedefSet]] = None)-
A product system describes the supply chain of a product (the functional unit) …
Attributes
processes:List[Ref]- The descriptors of all processes and sub-systems that are contained in the product system.
reference_process:Ref- The descriptor of the process that provides the flow of the functional unit of the product system.
reference_exchange:ExchangeRef- The exchange of the reference processes (typically the product output) that provides the flow of the functional unit of the product system.
target_amount:float- The flow amount of the functional unit of the product system.
target_unit:Ref- The unit in which the flow amount of the functional unit is given.
target_flow_property:Ref- The flow property in which the flow amount of the functional unit is given.
process_links:List[ProcessLink]- The process links of the product system.
parameter_sets:List[ParameterRedefSet]- A list of possible sets of parameter redefinitions for this product system.
Expand source code
@dataclass class ProductSystem(CategorizedEntity): """ A product system describes the supply chain of a product (the functional unit) ... Attributes ---------- processes: List[Ref] The descriptors of all processes and sub-systems that are contained in the product system. reference_process: Ref The descriptor of the process that provides the flow of the functional unit of the product system. reference_exchange: ExchangeRef The exchange of the reference processes (typically the product output) that provides the flow of the functional unit of the product system. target_amount: float The flow amount of the functional unit of the product system. target_unit: Ref The unit in which the flow amount of the functional unit is given. target_flow_property: Ref The flow property in which the flow amount of the functional unit is given. process_links: List[ProcessLink] The process links of the product system. parameter_sets: List[ParameterRedefSet] A list of possible sets of parameter redefinitions for this product system. """ olca_type: str = 'ProductSystem' processes: Optional[List[Ref]] = None reference_process: Optional[Ref] = None reference_exchange: Optional[ExchangeRef] = None target_amount: Optional[float] = None target_unit: Optional[Ref] = None target_flow_property: Optional[Ref] = None process_links: Optional[List[ProcessLink]] = None parameter_sets: Optional[List[ParameterRedefSet]] = None def to_json(self) -> dict: json: dict = super(ProductSystem, self).to_json() if self.processes is not None: json['processes'] = [] for e in self.processes: json['processes'].append(e.to_json()) if self.reference_process is not None: json['referenceProcess'] = self.reference_process.to_json() if self.reference_exchange is not None: json['referenceExchange'] = self.reference_exchange.to_json() if self.target_amount is not None: json['targetAmount'] = self.target_amount if self.target_unit is not None: json['targetUnit'] = self.target_unit.to_json() if self.target_flow_property is not None: json['targetFlowProperty'] = self.target_flow_property.to_json() if self.process_links is not None: json['processLinks'] = [] for e in self.process_links: json['processLinks'].append(e.to_json()) if self.parameter_sets is not None: json['parameterSets'] = [] for e in self.parameter_sets: json['parameterSets'].append(e.to_json()) return json def read_json(self, json: dict): super(ProductSystem, self).read_json(json) val = json.get('processes') if val is not None: self.processes = [] for d in val: e = Ref() e.read_json(d) self.processes.append(e) val = json.get('referenceProcess') if val is not None: self.reference_process = Ref() self.reference_process.read_json(val) val = json.get('referenceExchange') if val is not None: self.reference_exchange = ExchangeRef() self.reference_exchange.read_json(val) val = json.get('targetAmount') if val is not None: self.target_amount = val val = json.get('targetUnit') if val is not None: self.target_unit = Ref() self.target_unit.read_json(val) val = json.get('targetFlowProperty') if val is not None: self.target_flow_property = Ref() self.target_flow_property.read_json(val) val = json.get('processLinks') if val is not None: self.process_links = [] for d in val: e = ProcessLink() e.read_json(d) self.process_links.append(e) val = json.get('parameterSets') if val is not None: self.parameter_sets = [] for d in val: e = ParameterRedefSet() e.read_json(d) self.parameter_sets.append(e) @staticmethod def from_json(json: dict): instance = ProductSystem() instance.read_json(json) return instanceAncestors
Class variables
var olca_type : strvar parameter_sets : Optional[List[ParameterRedefSet]]var process_links : Optional[List[ProcessLink]]var processes : Optional[List[Ref]]var reference_exchange : Optional[ExchangeRef]var reference_process : Optional[Ref]var target_amount : Optional[float]var target_flow_property : Optional[Ref]var target_unit : Optional[Ref]
Static methods
def from_json(json: dict)-
Expand source code
@staticmethod def from_json(json: dict): instance = ProductSystem() instance.read_json(json) return instance
Methods
def read_json(self, json: dict)-
Expand source code
def read_json(self, json: dict): super(ProductSystem, self).read_json(json) val = json.get('processes') if val is not None: self.processes = [] for d in val: e = Ref() e.read_json(d) self.processes.append(e) val = json.get('referenceProcess') if val is not None: self.reference_process = Ref() self.reference_process.read_json(val) val = json.get('referenceExchange') if val is not None: self.reference_exchange = ExchangeRef() self.reference_exchange.read_json(val) val = json.get('targetAmount') if val is not None: self.target_amount = val val = json.get('targetUnit') if val is not None: self.target_unit = Ref() self.target_unit.read_json(val) val = json.get('targetFlowProperty') if val is not None: self.target_flow_property = Ref() self.target_flow_property.read_json(val) val = json.get('processLinks') if val is not None: self.process_links = [] for d in val: e = ProcessLink() e.read_json(d) self.process_links.append(e) val = json.get('parameterSets') if val is not None: self.parameter_sets = [] for d in val: e = ParameterRedefSet() e.read_json(d) self.parameter_sets.append(e) def to_json(self) ‑> dict-
Expand source code
def to_json(self) -> dict: json: dict = super(ProductSystem, self).to_json() if self.processes is not None: json['processes'] = [] for e in self.processes: json['processes'].append(e.to_json()) if self.reference_process is not None: json['referenceProcess'] = self.reference_process.to_json() if self.reference_exchange is not None: json['referenceExchange'] = self.reference_exchange.to_json() if self.target_amount is not None: json['targetAmount'] = self.target_amount if self.target_unit is not None: json['targetUnit'] = self.target_unit.to_json() if self.target_flow_property is not None: json['targetFlowProperty'] = self.target_flow_property.to_json() if self.process_links is not None: json['processLinks'] = [] for e in self.process_links: json['processLinks'].append(e.to_json()) if self.parameter_sets is not None: json['parameterSets'] = [] for e in self.parameter_sets: json['parameterSets'].append(e.to_json()) return json
class Project (id: str = '', olca_type: str = 'Project', name: Optional[str] = None, description: Optional[str] = None, version: Optional[str] = None, last_change: Optional[str] = None, category: Optional[Ref] = None, tags: Optional[List[str]] = None, library: Optional[str] = None, impact_method: Optional[Ref] = None, nw_set: Optional[NwSet] = None)-
Expand source code
@dataclass class Project(CategorizedEntity): """ Attributes ---------- impact_method: Ref nw_set: NwSet """ olca_type: str = 'Project' impact_method: Optional[Ref] = None nw_set: Optional[NwSet] = None def to_json(self) -> dict: json: dict = super(Project, self).to_json() if self.impact_method is not None: json['impactMethod'] = self.impact_method.to_json() if self.nw_set is not None: json['nwSet'] = self.nw_set.to_json() return json def read_json(self, json: dict): super(Project, self).read_json(json) val = json.get('impactMethod') if val is not None: self.impact_method = Ref() self.impact_method.read_json(val) val = json.get('nwSet') if val is not None: self.nw_set = NwSet() self.nw_set.read_json(val) @staticmethod def from_json(json: dict): instance = Project() instance.read_json(json) return instanceAncestors
Class variables
var impact_method : Optional[Ref]var nw_set : Optional[NwSet]var olca_type : str
Static methods
def from_json(json: dict)-
Expand source code
@staticmethod def from_json(json: dict): instance = Project() instance.read_json(json) return instance
Methods
def read_json(self, json: dict)-
Expand source code
def read_json(self, json: dict): super(Project, self).read_json(json) val = json.get('impactMethod') if val is not None: self.impact_method = Ref() self.impact_method.read_json(val) val = json.get('nwSet') if val is not None: self.nw_set = NwSet() self.nw_set.read_json(val) def to_json(self) ‑> dict-
Expand source code
def to_json(self) -> dict: json: dict = super(Project, self).to_json() if self.impact_method is not None: json['impactMethod'] = self.impact_method.to_json() if self.nw_set is not None: json['nwSet'] = self.nw_set.to_json() return json
class Ref (id: str = '', olca_type: str = 'Ref', name: Optional[str] = None, description: Optional[str] = None, version: Optional[str] = None, last_change: Optional[str] = None, category_path: Optional[List[str]] = None, library: Optional[str] = None, ref_unit: Optional[str] = None, location: Optional[str] = None, flow_type: Optional[FlowType] = None, process_type: Optional[ProcessType] = None)-
A Ref is a reference to a [RootEntity]. When serializing an entity (e.g. a [Process]) that references another standalone entity (e.g. a [Flow] in an [Exchange]) we do not want to write the complete referenced entity into the serialized JSON object but just a reference. However, the reference contains some meta-data like name, category path etc. that are useful to display.
Attributes
category_path:List[str]- The full path of the category of the referenced entity from top to
bottom, e.g.
"Elementary flows", "Emissions to air", "unspecified". library:str- If the entity that is described by this reference is part of a library, this field contains the identifier of that library. The identifier is typically just the combination of the library name and version.
ref_unit:str- This field is only valid for references of flows or impact categories and contains the name (symbol) of the reference unit of that respective flow or impact category.
location:str- This field is only valid for references of processes or flows and contains the location name or code of that respective process or flow.
flow_type:FlowType- In case of a reference to a flow, this field can contain the type of flow that is referenced.
process_type:ProcessType- In case of a reference to a process, this fiel can contain the type of process that is referenced.
Expand source code
@dataclass class Ref(RootEntity): """ A Ref is a reference to a [RootEntity]. When serializing an entity (e.g. a [Process]) that references another standalone entity (e.g. a [Flow] in an [Exchange]) we do not want to write the complete referenced entity into the serialized JSON object but just a reference. However, the reference contains some meta-data like name, category path etc. that are useful to display. Attributes ---------- category_path: List[str] The full path of the category of the referenced entity from top to bottom, e.g. `"Elementary flows", "Emissions to air", "unspecified"`. library: str If the entity that is described by this reference is part of a library, this field contains the identifier of that library. The identifier is typically just the combination of the library name and version. ref_unit: str This field is only valid for references of flows or impact categories and contains the name (symbol) of the reference unit of that respective flow or impact category. location: str This field is only valid for references of processes or flows and contains the location name or code of that respective process or flow. flow_type: FlowType In case of a reference to a flow, this field can contain the type of flow that is referenced. process_type: ProcessType In case of a reference to a process, this fiel can contain the type of process that is referenced. """ olca_type: str = 'Ref' category_path: Optional[List[str]] = None library: Optional[str] = None ref_unit: Optional[str] = None location: Optional[str] = None flow_type: Optional[FlowType] = None process_type: Optional[ProcessType] = None def to_json(self) -> dict: json: dict = super(Ref, self).to_json() if self.category_path is not None: json['categoryPath'] = [] for e in self.category_path: json['categoryPath'].append(e) if self.library is not None: json['library'] = self.library if self.ref_unit is not None: json['refUnit'] = self.ref_unit if self.location is not None: json['location'] = self.location if self.flow_type is not None: json['flowType'] = self.flow_type.value if self.process_type is not None: json['processType'] = self.process_type.value return json def read_json(self, json: dict): super(Ref, self).read_json(json) val = json.get('categoryPath') if val is not None: self.category_path = [] for d in val: e = d self.category_path.append(e) val = json.get('library') if val is not None: self.library = val val = json.get('refUnit') if val is not None: self.ref_unit = val val = json.get('location') if val is not None: self.location = val val = json.get('flowType') if val is not None: self.flow_type = FlowType(val) val = json.get('processType') if val is not None: self.process_type = ProcessType(val) @staticmethod def from_json(json: dict): instance = Ref() instance.read_json(json) return instanceAncestors
Class variables
var category_path : Optional[List[str]]var flow_type : Optional[FlowType]var library : Optional[str]var location : Optional[str]var olca_type : strvar process_type : Optional[ProcessType]var ref_unit : Optional[str]
Static methods
def from_json(json: dict)-
Expand source code
@staticmethod def from_json(json: dict): instance = Ref() instance.read_json(json) return instance
Methods
def read_json(self, json: dict)-
Expand source code
def read_json(self, json: dict): super(Ref, self).read_json(json) val = json.get('categoryPath') if val is not None: self.category_path = [] for d in val: e = d self.category_path.append(e) val = json.get('library') if val is not None: self.library = val val = json.get('refUnit') if val is not None: self.ref_unit = val val = json.get('location') if val is not None: self.location = val val = json.get('flowType') if val is not None: self.flow_type = FlowType(val) val = json.get('processType') if val is not None: self.process_type = ProcessType(val) def to_json(self) ‑> dict-
Expand source code
def to_json(self) -> dict: json: dict = super(Ref, self).to_json() if self.category_path is not None: json['categoryPath'] = [] for e in self.category_path: json['categoryPath'].append(e) if self.library is not None: json['library'] = self.library if self.ref_unit is not None: json['refUnit'] = self.ref_unit if self.location is not None: json['location'] = self.location if self.flow_type is not None: json['flowType'] = self.flow_type.value if self.process_type is not None: json['processType'] = self.process_type.value return json
class RiskLevel (value, names=None, *, module=None, qualname=None, type=None, start=1)-
Expand source code
class RiskLevel(Enum): """ """ NO_OPPORTUNITY = 'NO_OPPORTUNITY' HIGH_OPPORTUNITY = 'HIGH_OPPORTUNITY' MEDIUM_OPPORTUNITY = 'MEDIUM_OPPORTUNITY' LOW_OPPORTUNITY = 'LOW_OPPORTUNITY' NO_RISK = 'NO_RISK' VERY_LOW_RISK = 'VERY_LOW_RISK' LOW_RISK = 'LOW_RISK' MEDIUM_RISK = 'MEDIUM_RISK' HIGH_RISK = 'HIGH_RISK' VERY_HIGH_RISK = 'VERY_HIGH_RISK' NO_DATA = 'NO_DATA' NOT_APPLICABLE = 'NOT_APPLICABLE'Ancestors
- enum.Enum
Class variables
var HIGH_OPPORTUNITYvar HIGH_RISKvar LOW_OPPORTUNITYvar LOW_RISKvar MEDIUM_OPPORTUNITYvar MEDIUM_RISKvar NOT_APPLICABLEvar NO_DATAvar NO_OPPORTUNITYvar NO_RISKvar VERY_HIGH_RISKvar VERY_LOW_RISK
class RootEntity (id: str = '', olca_type: str = '', name: Optional[str] = None, description: Optional[str] = None, version: Optional[str] = None, last_change: Optional[str] = None)-
A standalone item in a database like a location, unit group, flow, or process. A root entity can be unambiguously identified by its id (the JSON-LD @id field), version, and lastChange fields.
Attributes
name:str- The name of the entity.
description:str- The description of the entity.
version:str- A version number in MAJOR.MINOR.PATCH format where the MINOR and PATCH fields are optional and the fields may have leading zeros (so 01.00.00 is the same as 1.0.0 or 1).
last_change:str- The timestamp when the entity was changed the last time.
Expand source code
@dataclass class RootEntity(Entity): """ A standalone item in a database like a location, unit group, flow, or process. A root entity can be unambiguously identified by its id (the JSON-LD @id field), version, and lastChange fields. Attributes ---------- name: str The name of the entity. description: str The description of the entity. version: str A version number in MAJOR.MINOR.PATCH format where the MINOR and PATCH fields are optional and the fields may have leading zeros (so 01.00.00 is the same as 1.0.0 or 1). last_change: str The timestamp when the entity was changed the last time. """ name: Optional[str] = None description: Optional[str] = None version: Optional[str] = None last_change: Optional[str] = None def to_json(self) -> dict: json: dict = super(RootEntity, self).to_json() if self.name is not None: json['name'] = self.name if self.description is not None: json['description'] = self.description if self.version is not None: json['version'] = self.version if self.last_change is not None: json['lastChange'] = self.last_change return json def read_json(self, json: dict): super(RootEntity, self).read_json(json) val = json.get('name') if val is not None: self.name = val val = json.get('description') if val is not None: self.description = val val = json.get('version') if val is not None: self.version = val val = json.get('lastChange') if val is not None: self.last_change = val @staticmethod def from_json(json: dict): instance = RootEntity() instance.read_json(json) return instanceAncestors
Subclasses
Class variables
var description : Optional[str]var last_change : Optional[str]var name : Optional[str]var version : Optional[str]
Static methods
def from_json(json: dict)-
Expand source code
@staticmethod def from_json(json: dict): instance = RootEntity() instance.read_json(json) return instance
Methods
def read_json(self, json: dict)-
Expand source code
def read_json(self, json: dict): super(RootEntity, self).read_json(json) val = json.get('name') if val is not None: self.name = val val = json.get('description') if val is not None: self.description = val val = json.get('version') if val is not None: self.version = val val = json.get('lastChange') if val is not None: self.last_change = val def to_json(self) ‑> dict-
Expand source code
def to_json(self) -> dict: json: dict = super(RootEntity, self).to_json() if self.name is not None: json['name'] = self.name if self.description is not None: json['description'] = self.description if self.version is not None: json['version'] = self.version if self.last_change is not None: json['lastChange'] = self.last_change return json
class SimpleResult (id: str = '', olca_type: str = 'SimpleResult', flow_results: Optional[List[FlowResult]] = None, impact_results: Optional[List[ImpactResult]] = None)-
Attributes
flow_results:List[FlowResult]impact_results:List[ImpactResult]
Expand source code
@dataclass class SimpleResult(Entity): """ Attributes ---------- flow_results: List[FlowResult] impact_results: List[ImpactResult] """ olca_type: str = 'SimpleResult' flow_results: Optional[List[FlowResult]] = None impact_results: Optional[List[ImpactResult]] = None def to_json(self) -> dict: json: dict = super(SimpleResult, self).to_json() if self.flow_results is not None: json['flowResults'] = [] for e in self.flow_results: json['flowResults'].append(e.to_json()) if self.impact_results is not None: json['impactResults'] = [] for e in self.impact_results: json['impactResults'].append(e.to_json()) return json def read_json(self, json: dict): super(SimpleResult, self).read_json(json) val = json.get('flowResults') if val is not None: self.flow_results = [] for d in val: e = FlowResult() e.read_json(d) self.flow_results.append(e) val = json.get('impactResults') if val is not None: self.impact_results = [] for d in val: e = ImpactResult() e.read_json(d) self.impact_results.append(e) @staticmethod def from_json(json: dict): instance = SimpleResult() instance.read_json(json) return instanceAncestors
Class variables
var flow_results : Optional[List[FlowResult]]var impact_results : Optional[List[ImpactResult]]var olca_type : str
Static methods
def from_json(json: dict)-
Expand source code
@staticmethod def from_json(json: dict): instance = SimpleResult() instance.read_json(json) return instance
Methods
def read_json(self, json: dict)-
Expand source code
def read_json(self, json: dict): super(SimpleResult, self).read_json(json) val = json.get('flowResults') if val is not None: self.flow_results = [] for d in val: e = FlowResult() e.read_json(d) self.flow_results.append(e) val = json.get('impactResults') if val is not None: self.impact_results = [] for d in val: e = ImpactResult() e.read_json(d) self.impact_results.append(e) def to_json(self) ‑> dict-
Expand source code
def to_json(self) -> dict: json: dict = super(SimpleResult, self).to_json() if self.flow_results is not None: json['flowResults'] = [] for e in self.flow_results: json['flowResults'].append(e.to_json()) if self.impact_results is not None: json['impactResults'] = [] for e in self.impact_results: json['impactResults'].append(e.to_json()) return json
class SocialAspect (id: str = '', olca_type: str = 'SocialAspect', activity_value: Optional[float] = None, comment: Optional[str] = None, quality: Optional[str] = None, raw_amount: Optional[str] = None, risk_level: Optional[RiskLevel] = None, social_indicator: Optional[Ref] = None, source: Optional[Ref] = None)-
An instance of this class describes a social aspect related to a social indicator in a process.
Attributes
activity_value:float- The value of the activity variable of the related indicator.
comment:strquality:str- A data quality entry, e.g.
(3,1,2,4,1). raw_amount:str- The raw amount of the indicator's unit of measurement (not required to be numeric currently)
risk_level:RiskLevelsocial_indicator:Refsource:Ref
Expand source code
@dataclass class SocialAspect(Entity): """ An instance of this class describes a social aspect related to a social indicator in a process. Attributes ---------- activity_value: float The value of the activity variable of the related indicator. comment: str quality: str A data quality entry, e.g. `(3,1,2,4,1)`. raw_amount: str The raw amount of the indicator's unit of measurement (not required to be numeric currently) risk_level: RiskLevel social_indicator: Ref source: Ref """ olca_type: str = 'SocialAspect' activity_value: Optional[float] = None comment: Optional[str] = None quality: Optional[str] = None raw_amount: Optional[str] = None risk_level: Optional[RiskLevel] = None social_indicator: Optional[Ref] = None source: Optional[Ref] = None def to_json(self) -> dict: json: dict = super(SocialAspect, self).to_json() if self.activity_value is not None: json['activityValue'] = self.activity_value if self.comment is not None: json['comment'] = self.comment if self.quality is not None: json['quality'] = self.quality if self.raw_amount is not None: json['rawAmount'] = self.raw_amount if self.risk_level is not None: json['riskLevel'] = self.risk_level.value if self.social_indicator is not None: json['socialIndicator'] = self.social_indicator.to_json() if self.source is not None: json['source'] = self.source.to_json() return json def read_json(self, json: dict): super(SocialAspect, self).read_json(json) val = json.get('activityValue') if val is not None: self.activity_value = val val = json.get('comment') if val is not None: self.comment = val val = json.get('quality') if val is not None: self.quality = val val = json.get('rawAmount') if val is not None: self.raw_amount = val val = json.get('riskLevel') if val is not None: self.risk_level = RiskLevel(val) val = json.get('socialIndicator') if val is not None: self.social_indicator = Ref() self.social_indicator.read_json(val) val = json.get('source') if val is not None: self.source = Ref() self.source.read_json(val) @staticmethod def from_json(json: dict): instance = SocialAspect() instance.read_json(json) return instanceAncestors
Class variables
var activity_value : Optional[float]var comment : Optional[str]var olca_type : strvar quality : Optional[str]var raw_amount : Optional[str]var risk_level : Optional[RiskLevel]var source : Optional[Ref]
Static methods
def from_json(json: dict)-
Expand source code
@staticmethod def from_json(json: dict): instance = SocialAspect() instance.read_json(json) return instance
Methods
def read_json(self, json: dict)-
Expand source code
def read_json(self, json: dict): super(SocialAspect, self).read_json(json) val = json.get('activityValue') if val is not None: self.activity_value = val val = json.get('comment') if val is not None: self.comment = val val = json.get('quality') if val is not None: self.quality = val val = json.get('rawAmount') if val is not None: self.raw_amount = val val = json.get('riskLevel') if val is not None: self.risk_level = RiskLevel(val) val = json.get('socialIndicator') if val is not None: self.social_indicator = Ref() self.social_indicator.read_json(val) val = json.get('source') if val is not None: self.source = Ref() self.source.read_json(val) def to_json(self) ‑> dict-
Expand source code
def to_json(self) -> dict: json: dict = super(SocialAspect, self).to_json() if self.activity_value is not None: json['activityValue'] = self.activity_value if self.comment is not None: json['comment'] = self.comment if self.quality is not None: json['quality'] = self.quality if self.raw_amount is not None: json['rawAmount'] = self.raw_amount if self.risk_level is not None: json['riskLevel'] = self.risk_level.value if self.social_indicator is not None: json['socialIndicator'] = self.social_indicator.to_json() if self.source is not None: json['source'] = self.source.to_json() return json
class SocialIndicator (id: str = '', olca_type: str = 'SocialIndicator', name: Optional[str] = None, description: Optional[str] = None, version: Optional[str] = None, last_change: Optional[str] = None, category: Optional[Ref] = None, tags: Optional[List[str]] = None, library: Optional[str] = None, activity_variable: Optional[str] = None, activity_quantity: Optional[Ref] = None, activity_unit: Optional[Ref] = None, unit_of_measurement: Optional[str] = None, evaluation_scheme: Optional[str] = None)-
Attributes
activity_variable:str- The name of the activity variable of the indicator.
activity_quantity:Ref- The quantity of the activity variable.
activity_unit:Ref- The unit of the activity variable.
unit_of_measurement:str- The unit in which the indicator is measured.
evaluation_scheme:str- Documentation of the evaluation scheme of the indicator.
Expand source code
@dataclass class SocialIndicator(CategorizedEntity): """ Attributes ---------- activity_variable: str The name of the activity variable of the indicator. activity_quantity: Ref The quantity of the activity variable. activity_unit: Ref The unit of the activity variable. unit_of_measurement: str The unit in which the indicator is measured. evaluation_scheme: str Documentation of the evaluation scheme of the indicator. """ olca_type: str = 'SocialIndicator' activity_variable: Optional[str] = None activity_quantity: Optional[Ref] = None activity_unit: Optional[Ref] = None unit_of_measurement: Optional[str] = None evaluation_scheme: Optional[str] = None def to_json(self) -> dict: json: dict = super(SocialIndicator, self).to_json() if self.activity_variable is not None: json['activityVariable'] = self.activity_variable if self.activity_quantity is not None: json['activityQuantity'] = self.activity_quantity.to_json() if self.activity_unit is not None: json['activityUnit'] = self.activity_unit.to_json() if self.unit_of_measurement is not None: json['unitOfMeasurement'] = self.unit_of_measurement if self.evaluation_scheme is not None: json['evaluationScheme'] = self.evaluation_scheme return json def read_json(self, json: dict): super(SocialIndicator, self).read_json(json) val = json.get('activityVariable') if val is not None: self.activity_variable = val val = json.get('activityQuantity') if val is not None: self.activity_quantity = Ref() self.activity_quantity.read_json(val) val = json.get('activityUnit') if val is not None: self.activity_unit = Ref() self.activity_unit.read_json(val) val = json.get('unitOfMeasurement') if val is not None: self.unit_of_measurement = val val = json.get('evaluationScheme') if val is not None: self.evaluation_scheme = val @staticmethod def from_json(json: dict): instance = SocialIndicator() instance.read_json(json) return instanceAncestors
Class variables
var activity_quantity : Optional[Ref]var activity_unit : Optional[Ref]var activity_variable : Optional[str]var evaluation_scheme : Optional[str]var olca_type : strvar unit_of_measurement : Optional[str]
Static methods
def from_json(json: dict)-
Expand source code
@staticmethod def from_json(json: dict): instance = SocialIndicator() instance.read_json(json) return instance
Methods
def read_json(self, json: dict)-
Expand source code
def read_json(self, json: dict): super(SocialIndicator, self).read_json(json) val = json.get('activityVariable') if val is not None: self.activity_variable = val val = json.get('activityQuantity') if val is not None: self.activity_quantity = Ref() self.activity_quantity.read_json(val) val = json.get('activityUnit') if val is not None: self.activity_unit = Ref() self.activity_unit.read_json(val) val = json.get('unitOfMeasurement') if val is not None: self.unit_of_measurement = val val = json.get('evaluationScheme') if val is not None: self.evaluation_scheme = val def to_json(self) ‑> dict-
Expand source code
def to_json(self) -> dict: json: dict = super(SocialIndicator, self).to_json() if self.activity_variable is not None: json['activityVariable'] = self.activity_variable if self.activity_quantity is not None: json['activityQuantity'] = self.activity_quantity.to_json() if self.activity_unit is not None: json['activityUnit'] = self.activity_unit.to_json() if self.unit_of_measurement is not None: json['unitOfMeasurement'] = self.unit_of_measurement if self.evaluation_scheme is not None: json['evaluationScheme'] = self.evaluation_scheme return json
class Source (id: str = '', olca_type: str = 'Source', name: Optional[str] = None, description: Optional[str] = None, version: Optional[str] = None, last_change: Optional[str] = None, category: Optional[Ref] = None, tags: Optional[List[str]] = None, library: Optional[str] = None, url: Optional[str] = None, text_reference: Optional[str] = None, year: Optional[int] = None, external_file: Optional[str] = None)-
A source is a literature reference.
Attributes
url:str- A URL that points to the source.
text_reference:str- The full text reference of the source.
year:int- The publication year of the source.
external_file:str- A direct link (relative or absolute URL) to the source file.
Expand source code
@dataclass class Source(CategorizedEntity): """ A source is a literature reference. Attributes ---------- url: str A URL that points to the source. text_reference: str The full text reference of the source. year: int The publication year of the source. external_file: str A direct link (relative or absolute URL) to the source file. """ olca_type: str = 'Source' url: Optional[str] = None text_reference: Optional[str] = None year: Optional[int] = None external_file: Optional[str] = None def to_json(self) -> dict: json: dict = super(Source, self).to_json() if self.url is not None: json['url'] = self.url if self.text_reference is not None: json['textReference'] = self.text_reference if self.year is not None: json['year'] = self.year if self.external_file is not None: json['externalFile'] = self.external_file return json def read_json(self, json: dict): super(Source, self).read_json(json) val = json.get('url') if val is not None: self.url = val val = json.get('textReference') if val is not None: self.text_reference = val val = json.get('year') if val is not None: self.year = val val = json.get('externalFile') if val is not None: self.external_file = val @staticmethod def from_json(json: dict): instance = Source() instance.read_json(json) return instanceAncestors
Class variables
var external_file : Optional[str]var olca_type : strvar text_reference : Optional[str]var url : Optional[str]var year : Optional[int]
Static methods
def from_json(json: dict)-
Expand source code
@staticmethod def from_json(json: dict): instance = Source() instance.read_json(json) return instance
Methods
def read_json(self, json: dict)-
Expand source code
def read_json(self, json: dict): super(Source, self).read_json(json) val = json.get('url') if val is not None: self.url = val val = json.get('textReference') if val is not None: self.text_reference = val val = json.get('year') if val is not None: self.year = val val = json.get('externalFile') if val is not None: self.external_file = val def to_json(self) ‑> dict-
Expand source code
def to_json(self) -> dict: json: dict = super(Source, self).to_json() if self.url is not None: json['url'] = self.url if self.text_reference is not None: json['textReference'] = self.text_reference if self.year is not None: json['year'] = self.year if self.external_file is not None: json['externalFile'] = self.external_file return json
class Uncertainty (id: str = '', olca_type: str = 'Uncertainty', distribution_type: Optional[UncertaintyType] = None, mean: Optional[float] = None, mean_formula: Optional[str] = None, geom_mean: Optional[float] = None, geom_mean_formula: Optional[str] = None, minimum: Optional[float] = None, minimum_formula: Optional[str] = None, sd: Optional[float] = None, sd_formula: Optional[str] = None, geom_sd: Optional[float] = None, geom_sd_formula: Optional[str] = None, mode: Optional[float] = None, mode_formula: Optional[str] = None, maximum: Optional[float] = None, maximum_formula: Optional[str] = None)-
Defines the parameter values of an uncertainty distribution. Depending on the uncertainty distribution type different parameters could be used.
Attributes
distribution_type:UncertaintyType- The uncertainty distribution type
mean:float- The arithmetic mean (used for normal distributions).
mean_formula:str- A mathematical formula for the arithmetic mean.
geom_mean:float- The geometric mean value (used for log-normal distributions).
geom_mean_formula:str- A mathematical formula for the geometric mean.
minimum:float- The minimum value (used for uniform and triangle distributions).
minimum_formula:str- A mathematical formula for the minimum value.
sd:float- The arithmetic standard deviation (used for normal distributions).
sd_formula:str- A mathematical formula for the arithmetic standard deviation.
geom_sd:float- The geometric standard deviation (used for log-normal distributions).
geom_sd_formula:str- A mathematical formula for the geometric standard deviation.
mode:float- The most likely value (used for triangle distributions).
mode_formula:str- A mathematical formula for the most likely value.
maximum:float- The maximum value (used for uniform and triangle distributions).
maximum_formula:str- A mathematical formula for the maximum value.
Expand source code
@dataclass class Uncertainty(Entity): """ Defines the parameter values of an uncertainty distribution. Depending on the uncertainty distribution type different parameters could be used. Attributes ---------- distribution_type: UncertaintyType The uncertainty distribution type mean: float The arithmetic mean (used for normal distributions). mean_formula: str A mathematical formula for the arithmetic mean. geom_mean: float The geometric mean value (used for log-normal distributions). geom_mean_formula: str A mathematical formula for the geometric mean. minimum: float The minimum value (used for uniform and triangle distributions). minimum_formula: str A mathematical formula for the minimum value. sd: float The arithmetic standard deviation (used for normal distributions). sd_formula: str A mathematical formula for the arithmetic standard deviation. geom_sd: float The geometric standard deviation (used for log-normal distributions). geom_sd_formula: str A mathematical formula for the geometric standard deviation. mode: float The most likely value (used for triangle distributions). mode_formula: str A mathematical formula for the most likely value. maximum: float The maximum value (used for uniform and triangle distributions). maximum_formula: str A mathematical formula for the maximum value. """ olca_type: str = 'Uncertainty' distribution_type: Optional[UncertaintyType] = None mean: Optional[float] = None mean_formula: Optional[str] = None geom_mean: Optional[float] = None geom_mean_formula: Optional[str] = None minimum: Optional[float] = None minimum_formula: Optional[str] = None sd: Optional[float] = None sd_formula: Optional[str] = None geom_sd: Optional[float] = None geom_sd_formula: Optional[str] = None mode: Optional[float] = None mode_formula: Optional[str] = None maximum: Optional[float] = None maximum_formula: Optional[str] = None def to_json(self) -> dict: json: dict = super(Uncertainty, self).to_json() if self.distribution_type is not None: json['distributionType'] = self.distribution_type.value if self.mean is not None: json['mean'] = self.mean if self.mean_formula is not None: json['meanFormula'] = self.mean_formula if self.geom_mean is not None: json['geomMean'] = self.geom_mean if self.geom_mean_formula is not None: json['geomMeanFormula'] = self.geom_mean_formula if self.minimum is not None: json['minimum'] = self.minimum if self.minimum_formula is not None: json['minimumFormula'] = self.minimum_formula if self.sd is not None: json['sd'] = self.sd if self.sd_formula is not None: json['sdFormula'] = self.sd_formula if self.geom_sd is not None: json['geomSd'] = self.geom_sd if self.geom_sd_formula is not None: json['geomSdFormula'] = self.geom_sd_formula if self.mode is not None: json['mode'] = self.mode if self.mode_formula is not None: json['modeFormula'] = self.mode_formula if self.maximum is not None: json['maximum'] = self.maximum if self.maximum_formula is not None: json['maximumFormula'] = self.maximum_formula return json def read_json(self, json: dict): super(Uncertainty, self).read_json(json) val = json.get('distributionType') if val is not None: self.distribution_type = UncertaintyType(val) val = json.get('mean') if val is not None: self.mean = val val = json.get('meanFormula') if val is not None: self.mean_formula = val val = json.get('geomMean') if val is not None: self.geom_mean = val val = json.get('geomMeanFormula') if val is not None: self.geom_mean_formula = val val = json.get('minimum') if val is not None: self.minimum = val val = json.get('minimumFormula') if val is not None: self.minimum_formula = val val = json.get('sd') if val is not None: self.sd = val val = json.get('sdFormula') if val is not None: self.sd_formula = val val = json.get('geomSd') if val is not None: self.geom_sd = val val = json.get('geomSdFormula') if val is not None: self.geom_sd_formula = val val = json.get('mode') if val is not None: self.mode = val val = json.get('modeFormula') if val is not None: self.mode_formula = val val = json.get('maximum') if val is not None: self.maximum = val val = json.get('maximumFormula') if val is not None: self.maximum_formula = val @staticmethod def from_json(json: dict): instance = Uncertainty() instance.read_json(json) return instanceAncestors
Class variables
var distribution_type : Optional[UncertaintyType]var geom_mean : Optional[float]var geom_mean_formula : Optional[str]var geom_sd : Optional[float]var geom_sd_formula : Optional[str]var maximum : Optional[float]var maximum_formula : Optional[str]var mean : Optional[float]var mean_formula : Optional[str]var minimum : Optional[float]var minimum_formula : Optional[str]var mode : Optional[float]var mode_formula : Optional[str]var olca_type : strvar sd : Optional[float]var sd_formula : Optional[str]
Static methods
def from_json(json: dict)-
Expand source code
@staticmethod def from_json(json: dict): instance = Uncertainty() instance.read_json(json) return instance
Methods
def read_json(self, json: dict)-
Expand source code
def read_json(self, json: dict): super(Uncertainty, self).read_json(json) val = json.get('distributionType') if val is not None: self.distribution_type = UncertaintyType(val) val = json.get('mean') if val is not None: self.mean = val val = json.get('meanFormula') if val is not None: self.mean_formula = val val = json.get('geomMean') if val is not None: self.geom_mean = val val = json.get('geomMeanFormula') if val is not None: self.geom_mean_formula = val val = json.get('minimum') if val is not None: self.minimum = val val = json.get('minimumFormula') if val is not None: self.minimum_formula = val val = json.get('sd') if val is not None: self.sd = val val = json.get('sdFormula') if val is not None: self.sd_formula = val val = json.get('geomSd') if val is not None: self.geom_sd = val val = json.get('geomSdFormula') if val is not None: self.geom_sd_formula = val val = json.get('mode') if val is not None: self.mode = val val = json.get('modeFormula') if val is not None: self.mode_formula = val val = json.get('maximum') if val is not None: self.maximum = val val = json.get('maximumFormula') if val is not None: self.maximum_formula = val def to_json(self) ‑> dict-
Expand source code
def to_json(self) -> dict: json: dict = super(Uncertainty, self).to_json() if self.distribution_type is not None: json['distributionType'] = self.distribution_type.value if self.mean is not None: json['mean'] = self.mean if self.mean_formula is not None: json['meanFormula'] = self.mean_formula if self.geom_mean is not None: json['geomMean'] = self.geom_mean if self.geom_mean_formula is not None: json['geomMeanFormula'] = self.geom_mean_formula if self.minimum is not None: json['minimum'] = self.minimum if self.minimum_formula is not None: json['minimumFormula'] = self.minimum_formula if self.sd is not None: json['sd'] = self.sd if self.sd_formula is not None: json['sdFormula'] = self.sd_formula if self.geom_sd is not None: json['geomSd'] = self.geom_sd if self.geom_sd_formula is not None: json['geomSdFormula'] = self.geom_sd_formula if self.mode is not None: json['mode'] = self.mode if self.mode_formula is not None: json['modeFormula'] = self.mode_formula if self.maximum is not None: json['maximum'] = self.maximum if self.maximum_formula is not None: json['maximumFormula'] = self.maximum_formula return json
class UncertaintyType (value, names=None, *, module=None, qualname=None, type=None, start=1)-
Enumeration of uncertainty distribution types that can be used in exchanges, parameters, LCIA factors, etc.
Expand source code
class UncertaintyType(Enum): """ Enumeration of uncertainty distribution types that can be used in exchanges, parameters, LCIA factors, etc. """ LOG_NORMAL_DISTRIBUTION = 'LOG_NORMAL_DISTRIBUTION' NORMAL_DISTRIBUTION = 'NORMAL_DISTRIBUTION' TRIANGLE_DISTRIBUTION = 'TRIANGLE_DISTRIBUTION' UNIFORM_DISTRIBUTION = 'UNIFORM_DISTRIBUTION'Ancestors
- enum.Enum
Class variables
var LOG_NORMAL_DISTRIBUTIONvar NORMAL_DISTRIBUTIONvar TRIANGLE_DISTRIBUTIONvar UNIFORM_DISTRIBUTION
class Unit (id: str = '', olca_type: str = 'Unit', name: Optional[str] = None, description: Optional[str] = None, version: Optional[str] = None, last_change: Optional[str] = None, conversion_factor: Optional[float] = None, reference_unit: Optional[bool] = None, synonyms: Optional[List[str]] = None)-
An unit of measure
Attributes
conversion_factor:float- The conversion factor to the reference unit of the unit group to which this unit belongs.
reference_unit:bool- Indicates whether the unit is the reference unit of the unit group to which this unit belongs. If it is the reference unit the conversion factor must be 1.0. There should be always only one reference unit in a unit group. The reference unit is used to convert amounts given in one unit to amounts given in another unit of the respective unit group.
synonyms:List[str]- A list of synonyms for the unit.
Expand source code
@dataclass class Unit(RootEntity): """ An unit of measure Attributes ---------- conversion_factor: float The conversion factor to the reference unit of the unit group to which this unit belongs. reference_unit: bool Indicates whether the unit is the reference unit of the unit group to which this unit belongs. If it is the reference unit the conversion factor must be 1.0. There should be always only one reference unit in a unit group. The reference unit is used to convert amounts given in one unit to amounts given in another unit of the respective unit group. synonyms: List[str] A list of synonyms for the unit. """ olca_type: str = 'Unit' conversion_factor: Optional[float] = None reference_unit: Optional[bool] = None synonyms: Optional[List[str]] = None def to_json(self) -> dict: json: dict = super(Unit, self).to_json() if self.conversion_factor is not None: json['conversionFactor'] = self.conversion_factor if self.reference_unit is not None: json['referenceUnit'] = self.reference_unit if self.synonyms is not None: json['synonyms'] = [] for e in self.synonyms: json['synonyms'].append(e) return json def read_json(self, json: dict): super(Unit, self).read_json(json) val = json.get('conversionFactor') if val is not None: self.conversion_factor = val val = json.get('referenceUnit') if val is not None: self.reference_unit = val val = json.get('synonyms') if val is not None: self.synonyms = [] for d in val: e = d self.synonyms.append(e) @staticmethod def from_json(json: dict): instance = Unit() instance.read_json(json) return instanceAncestors
Class variables
var conversion_factor : Optional[float]var olca_type : strvar reference_unit : Optional[bool]var synonyms : Optional[List[str]]
Static methods
def from_json(json: dict)-
Expand source code
@staticmethod def from_json(json: dict): instance = Unit() instance.read_json(json) return instance
Methods
def read_json(self, json: dict)-
Expand source code
def read_json(self, json: dict): super(Unit, self).read_json(json) val = json.get('conversionFactor') if val is not None: self.conversion_factor = val val = json.get('referenceUnit') if val is not None: self.reference_unit = val val = json.get('synonyms') if val is not None: self.synonyms = [] for d in val: e = d self.synonyms.append(e) def to_json(self) ‑> dict-
Expand source code
def to_json(self) -> dict: json: dict = super(Unit, self).to_json() if self.conversion_factor is not None: json['conversionFactor'] = self.conversion_factor if self.reference_unit is not None: json['referenceUnit'] = self.reference_unit if self.synonyms is not None: json['synonyms'] = [] for e in self.synonyms: json['synonyms'].append(e) return json
class UnitGroup (id: str = '', olca_type: str = 'UnitGroup', name: Optional[str] = None, description: Optional[str] = None, version: Optional[str] = None, last_change: Optional[str] = None, category: Optional[Ref] = None, tags: Optional[List[str]] = None, library: Optional[str] = None, default_flow_property: Optional[Ref] = None, units: Optional[List[Unit]] = None)-
A group of units that can be converted into each other.
Attributes
Expand source code
@dataclass class UnitGroup(CategorizedEntity): """ A group of units that can be converted into each other. Attributes ---------- default_flow_property: Ref Some LCA data formats do not have the concept of flow properties or quantities. This field provides a default link to a flow property for units that are contained in this group. units: List[Unit] The units of the unit group. """ olca_type: str = 'UnitGroup' default_flow_property: Optional[Ref] = None units: Optional[List[Unit]] = None def to_json(self) -> dict: json: dict = super(UnitGroup, self).to_json() if self.default_flow_property is not None: json['defaultFlowProperty'] = self.default_flow_property.to_json() if self.units is not None: json['units'] = [] for e in self.units: json['units'].append(e.to_json()) return json def read_json(self, json: dict): super(UnitGroup, self).read_json(json) val = json.get('defaultFlowProperty') if val is not None: self.default_flow_property = Ref() self.default_flow_property.read_json(val) val = json.get('units') if val is not None: self.units = [] for d in val: e = Unit() e.read_json(d) self.units.append(e) @staticmethod def from_json(json: dict): instance = UnitGroup() instance.read_json(json) return instanceAncestors
Class variables
var default_flow_property : Optional[Ref]var olca_type : strvar units : Optional[List[Unit]]
Static methods
def from_json(json: dict)-
Expand source code
@staticmethod def from_json(json: dict): instance = UnitGroup() instance.read_json(json) return instance
Methods
def read_json(self, json: dict)-
Expand source code
def read_json(self, json: dict): super(UnitGroup, self).read_json(json) val = json.get('defaultFlowProperty') if val is not None: self.default_flow_property = Ref() self.default_flow_property.read_json(val) val = json.get('units') if val is not None: self.units = [] for d in val: e = Unit() e.read_json(d) self.units.append(e) def to_json(self) ‑> dict-
Expand source code
def to_json(self) -> dict: json: dict = super(UnitGroup, self).to_json() if self.default_flow_property is not None: json['defaultFlowProperty'] = self.default_flow_property.to_json() if self.units is not None: json['units'] = [] for e in self.units: json['units'].append(e.to_json()) return json