def lcia_process_contributions(self, result: schema.SimpleResult,
impact: schema.Ref) -> List[ContributionItem]:
"""
Get the contributions to the result of the given impact category by
processes.
Parameters
----------
result: olca.schema.SimpleResult
The result.
impact: olca.schema.Ref
The (reference to the) LCIA category.
Example
-------
```python
# ...
result = client.calculate(setup)
# select the first LCIA result
impact_result = client.lcia(result)[0]
# get the flow contributions to the LCIA category of that result
cons = client.lcia_process_contributions(
result, impact_result.impact_category)
# ...
client.dispose(result)
```
"""
raw = self.__post('get/impacts/contributions/processes', {
'resultId': result.id,
'impactCategory': impact.to_json(),
})
return [ContributionItem.from_json(it) for it in raw]
def next_simulation(self, simulator: schema.Ref) -> schema.SimpleResult:
"""
Runs the next Monte-Carlo simulation with the given simulator reference.
It returns the simulation result which is not cached on the openLCA
side as the simulator with the single results is cached.
"""
if simulator is None:
raise ValueError('No simulator given')
resp = self.__post('next/simulation', simulator.to_json())
result = schema.SimpleResult()
result.from_json(resp)
return result
def next_simulation(self, simulator: schema.Ref) -> schema.SimpleResult:
"""
Runs the next Monte-Carlo simulation with the given simulator reference.
It returns the result of the simulation. Note that this result is not
cached (the simulator is cached).
See [the simulator example](#olca.ipc.Client.simulator).
Parameters
----------
simulator: olca.schema.Ref
The reference to the simulator which is called to run the next
simulation step.
"""
if simulator is None:
raise ValueError('No simulator given')
resp = self.__post('next/simulation', simulator.to_json())
return schema.SimpleResult.from_json(resp)
def lci_location_contributions(self, result: schema.SimpleResult,
flow: schema.Ref) -> List[ContributionItem]:
"""
Get the contributions of the result of the given flow by location.
Parameters
----------
result: olca.schema.SimpleResult
The result which needs to be at least a contribution result.
flow: olca.schema.Ref
The (reference of the) flow for which the calculations should be
calculated.
Returns
-------
List[ContributionItem]
The contributions to the flow result by location.
Example
-------
```python
# ...
result = client.calculate(setup)
# select the first output of the LCI result
output = client.lci_outputs(result)[0]
# calculate the location contributions of the flow of that output
cons = client.lci_location_contributions(result, output.flow)
# ...
client.dispose(result)
```
"""
raw, err = self.__post('get/inventory/contributions/locations', {
'resultId': result.id,
'flow': flow.to_json(),
})
if err:
log.error('failed to ger contributions by location')
return []
return [ContributionItem.from_json(it) for it in raw]
def upstream_tree_of(
self,
result: schema.SimpleResult,
ref: schema.Ref,
max_depth=5,
min_contribution=0.1,
max_recursion_depth=3) -> Optional[utree.UpstreamTree]:
"""
Get an upstream tree for an impact category or flow.
This function is only available in openLCA 2.x.
Parameters
----------
result: olca.schema.SimpleResult
The previously calculated result. This needs to be an upstream
result.
ref: olca.schema.Ref
The result reference of the upstream tree: a flow or impact
category reference.
max_depth: int
The maximum number of levels of the tree. A value < 0 means
unlimited. In this case reasonable recursion limits are
required if the underlying product system has cycles.
min_contribution: float
In addition to the maximum tree depth, this parameter describes
the minimum upstream contribution of a node in the tree. A value
< 0 means that there is no minimum contribution.
max_recursion_depth: int
When the max. tree depth is unlimited and the underlying product
system has cycles, this parameter indicates how often a process
can occur in a tree path. It defines the maximum number of
expansions of a loop in a tree path.
Example
-------
```python
client = olca.Client()
# create the calculation setup and run the calculation
setup = olca.CalculationSetup()
setup.calculation_type = olca.CalculationType.UPSTREAM_ANALYSIS
setup.product_system = olca.ref(
olca.ProductSystem,
'7d1cbce0-b5b3-47ba-95b5-014ab3c7f569'
)
setup.impact_method = olca.ref(
olca.ImpactMethod,
'99b9d86b-ec6f-4610-ba9f-68ebfe5691dd'
)
setup.amount = 1.0
result = client.calculate(setup)
# calculate the upstream tree and traverse it
impact = olca.ref(
olca.ImpactCategory,
'2a26b243-23cb-4f90-baab-239d3d7397fa')
tree = client.upstream_tree_of(result, impact)
def traversal_handler(n: Tuple[UpstreamNode, int]):
(node, depth) = n
print('%s+ %s %.3f' % (
' ' * depth,
node.product.process.name,
node.result
))
tree.traverse(traversal_handler)
# dispose the result
client.dispose(result)
```
"""
raw, err = self.__post(
'get/upstream/tree', {
'resultId': result.id,
'ref': ref.to_json(),
'maxDepth': max_depth,
'minContribution': min_contribution,
'maxRecursionDepth': max_recursion_depth
})
if err:
log.error('Failed to get upstream tree: %s', err)
return None
return utree.UpstreamTree.from_json(raw)