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)