apparun 0.3.0__py3-none-any.whl

app/api/app.py

@@ -0,0 +1,43 @@
+from typing import Dict, List, Union
+
+from fastapi import FastAPI
+from pydantic import BaseModel
+
+import apparun.core
+
+app = FastAPI()
+
+
+class ComputeParams(BaseModel):
+    impact_model_name: str
+    params: Dict[str, Union[str, float, List[Union[str, float]]]]
+
+
+class GetModelParams(BaseModel):
+    impact_model_name: str
+
+
+@app.post("/compute/")
+def compute(params: ComputeParams):
+    scores = apparun.core.compute_impacts(params.impact_model_name, params.params)
+    return scores
+
+
+@app.post("/compute_nodes/")
+def compute_nodes(params: ComputeParams):
+    scores = apparun.core.compute_impacts(
+        params.impact_model_name, params.params, all_nodes=True
+    )
+    return scores
+
+
+@app.get("/get_models/")
+def get_models():
+    valid_impact_models = apparun.core.get_valid_models()
+    return valid_impact_models
+
+
+@app.post("/get_model_params/")
+def get_model_params(params: GetModelParams):
+    impact_models_params = apparun.core.get_model_params(params.impact_model_name)
+    return impact_models_params

app/cli/main.py

@@ -0,0 +1,62 @@
+import os
+from typing import Optional
+
+import typer
+import yaml
+
+import apparun.core
+
+cli_app = typer.Typer()
+
+
+@cli_app.command()
+def compute(
+    impact_model_name: str,
+    params_file_path: str,
+    output_file_path: Optional[str] = None,
+):
+    with open(params_file_path, "r") as stream:
+        params = yaml.safe_load(stream) or {}
+    scores = apparun.core.compute_impacts(impact_model_name, params)
+    print(scores)
+    if output_file_path is not None:
+        with open(output_file_path, "w") as stream:
+            yaml.dump(scores, stream, sort_keys=False)
+
+
+@cli_app.command()
+def compute_nodes(
+    impact_model_name: str,
+    params_file_path: str,
+    output_file_path: Optional[str] = None,
+):
+    with open(params_file_path, "r") as stream:
+        params = yaml.safe_load(stream) or {}
+    scores = apparun.core.compute_impacts(impact_model_name, params, all_nodes=True)
+    print(scores)
+    if output_file_path is not None:
+        with open(output_file_path, "w") as stream:
+            yaml.dump(scores, stream, sort_keys=False)
+
+
+@cli_app.command()
+def models():
+    valid_impact_models = apparun.core.get_valid_models()
+    print(valid_impact_models)
+
+
+@cli_app.command()
+def model_params(impact_model_name: str):
+    impact_model_params = apparun.core.get_model_params(impact_model_name)
+    print(impact_model_params)
+
+
+@cli_app.command()
+def results(results_config_file_path: str):
+    with open(results_config_file_path, "r") as stream:
+        results_config = yaml.safe_load(stream)
+    apparun.core.compute_results(results_config)
+
+
+if __name__ == "__main__":
+    cli_app()

apparun/core.py

@@ -0,0 +1,118 @@
+import logging
+import os
+import time
+from functools import wraps
+from typing import Dict, List, Union
+
+from apparun import results
+from apparun.impact_model import ImpactModel
+from apparun.results import get_result
+
+IMPACTS_MODEL_DIR = os.environ.get("APPARUN_IMPACT_MODELS_DIR")
+logging.basicConfig(
+    filename="apparun.log",
+    filemode="w",
+    format="%(name)s - %(levelname)s - %(message)s",
+    level=logging.INFO,
+)
+
+
+def execution_time_logging(func):
+    """
+    Decorator to log execution time as an info.
+    :param func: function to wrap.
+    :return: wrapped function.
+    """
+
+    @wraps(func)
+    def execution_time_logging_wrapper(*args, **kwargs):
+        start_time = time.perf_counter()
+        result = func(*args, **kwargs)
+        end_time = time.perf_counter()
+        total_time = end_time - start_time
+        logging.info(f"Function {func.__name__} executed in {total_time:.4f} seconds")
+        return result
+
+    return execution_time_logging_wrapper
+
+
+@execution_time_logging
+def compute_impacts(
+    impact_model_name: str, params: Dict, all_nodes: bool = False
+) -> Union[List, Dict[str, Union[float, List[float]]]]:
+    """
+    Load an impact model from disk from its name, and get impact scores of the root node
+    for each impact method, according to the parameters.
+    APPARUN_IMPACT_MODELS_DIR environment variable should be specified (see README.md).
+    :param impact_model_name: name of the impact model to load
+    :param params: value, or list of values of the impact model's parameters.
+    List of values must have the same length. If single values are provided
+    alongside a list of values, it will be duplicated to the appropriate length.
+    :param all_nodes: if True, scores will be computed for each node. Only root node
+    otherwise (default).
+    :return: a dict mapping impact names and corresponding score, or list of scores.
+    """
+    impact_model = ImpactModel.from_yaml(
+        os.path.join(IMPACTS_MODEL_DIR, f"{impact_model_name}.yaml")
+    )
+    if all_nodes:
+        return impact_model.get_nodes_scores(**params)
+    return dict(impact_model.get_scores(**params))
+
+
+@execution_time_logging
+def get_valid_models() -> List[str]:
+    """
+    Get a list of all valid impact models in the directory specified by
+    APPARUN_IMPACT_MODELS_DIR environment variable.
+    :return: a list of all valid impact models.
+    """
+    valid_impact_models = []
+    for file in os.listdir(IMPACTS_MODEL_DIR):
+        if file.endswith(".yaml"):
+            try:
+                ImpactModel.from_yaml(os.path.join(IMPACTS_MODEL_DIR, file))
+                valid_impact_models.append(file.replace(".yaml", ""))
+            except KeyError:
+                print(f"{file.replace('.yaml', '')} is not a valid impact model.")
+    return valid_impact_models
+
+
+@execution_time_logging
+def get_model_params(impact_model_name: str) -> List[Dict]:
+    """
+    Return the list of parameters required to execute an impact model.
+    APPARUN_IMPACT_MODELS_DIR environment variable should be specified (see README.md).
+    :param impact_model_name: name of the impact model to load.
+    :return: a list of parameters required by the model.
+    """
+    impact_model = ImpactModel.from_yaml(
+        os.path.join(IMPACTS_MODEL_DIR, f"{impact_model_name}.yaml")
+    )
+    return [parameter.to_dict() for parameter in impact_model.parameters]
+
+
+@execution_time_logging
+def compute_results(results_config: List[Dict]):
+    """
+    Generate results according to results_config.
+    :param results_config: list of results wanted. Each element of this list will be
+    used to construct an ImpactModelResult, using the elements in "args" argument.
+    Result subclass is determined by "class" argument.
+    """
+    for result_config in results_config:
+        result_name = result_config["result_name"]
+        result_constructor_args = result_config["args"]
+        if "parameters" in result_constructor_args["impact_model"]:
+            result_constructor_args["parameters"] = result_constructor_args[
+                "impact_model"
+            ]["parameters"]
+        result_constructor_args["impact_model"] = ImpactModel.from_yaml(
+            os.path.join(
+                IMPACTS_MODEL_DIR,
+                f"{result_constructor_args['impact_model']['name']}.yaml",
+            )
+        )
+        result_class = get_result(result_name)
+        result_objet = result_class(**result_constructor_args)
+        result_objet.run()

apparun/impact_methods.py

@@ -0,0 +1,129 @@
+from __future__ import annotations
+
+from aenum import Enum, NoAlias
+
+
+class MethodFullName(str, Enum):
+    """
+    Enumeration of impact methods supported by Brightway.
+    So far, only some ReCiPe methods, and all EF v3.0 impact methods are supported.
+    """
+
+    # EFV3
+    EFV3_ACIDIFICATION = "('EF v3.0', 'acidification', 'accumulated exceedance (AE)')"
+    EFV3_CLIMATE_CHANGE = (
+        "('EF v3.0', 'climate change', 'global warming potential (GWP100)')"
+    )
+    EFV3_CLIMATE_CHANGE_BIOGENIC = (
+        "('EF v3.0', 'climate change: biogenic', 'global warming potential (GWP100)')"
+    )
+    EFV3_CLIMATE_CHANGE_FOSSIL = (
+        "('EF v3.0', 'climate change: fossil', 'global warming potential (GWP100)')"
+    )
+    EFV3_CLIMATE_CHANGE_LAND_USE = "('EF v3.0', 'climate change: land use and land use change', 'global warming potential (GWP100)')"
+    EFV3_ECOTOXICITY_FRESHWATER = "('EF v3.0', 'ecotoxicity: freshwater', 'comparative toxic unit for ecosystems (CTUe)')"
+    EFV3_ECOTOXICITY_FRESHWATER_INORGANICS = "('EF v3.0', 'ecotoxicity: freshwater, inorganics', 'comparative toxic unit for ecosystems (CTUe)')"
+    EFV3_ECOTOXICITY_FRESHWATER_METALS = "('EF v3.0', 'ecotoxicity: freshwater, metals', 'comparative toxic unit for ecosystems (CTUe)')"
+    EFV3_ECOTOXICITY_FRESHWATER_ORGANICS = "('EF v3.0', 'ecotoxicity: freshwater, organics', 'comparative toxic unit for ecosystems (CTUe)')"
+    EFV3_EUTROPHICATION_FRESHWATER = "('EF v3.0', 'eutrophication: freshwater', 'fraction of nutrients reaching freshwater end compartment (P)')"
+    EFV3_EUTROPHICATION_MARINE = "('EF v3.0', 'eutrophication: marine', 'fraction of nutrients reaching marine end compartment (N)')"
+    EFV3_EUTROPHICATION_TERRESTRIAL = (
+        "('EF v3.0', 'eutrophication: terrestrial', 'accumulated exceedance (AE)')"
+    )
+    EFV3_HUMAN_TOXICITY_CARCINOGENIC = "('EF v3.0', 'human toxicity: carcinogenic', 'comparative toxic unit for human (CTUh)')"
+    EFV3_HUMAN_TOXICITY_CARCINOGENIC_INORGANICS = "('EF v3.0', 'human toxicity: carcinogenic, inorganics', 'comparative toxic unit for human (CTUh)')"
+    EFV3_HUMAN_TOXICITY_CARCINOGENIC_METALS = "('EF v3.0', 'human toxicity: carcinogenic, metals', 'comparative toxic unit for human (CTUh)')"
+    EFV3_HUMAN_TOXICITY_CARCINOGENIC_ORGANICS = "('EF v3.0', 'human toxicity: carcinogenic, organics', 'comparative toxic unit for human (CTUh)')"
+    EFV3_HUMAN_TOXICITY_NON_CARCINOGENIC = "('EF v3.0', 'human toxicity: non-carcinogenic', 'comparative toxic unit for human (CTUh)')"
+    EFV3_HUMAN_TOXICITY_NON_CARCINOGENIC_INORGANICS = "('EF v3.0', 'human toxicity: non-carcinogenic, inorganics', 'comparative toxic unit for human (CTUh)')"
+    EFV3_HUMAN_TOXICITY_NON_CARCINOGENIC_METALS = "('EF v3.0', 'human toxicity: non-carcinogenic, metals', 'comparative toxic unit for human (CTUh)')"
+    EFV3_HUMAN_TOXICITY_NON_CARCINOGENIC_ORGANICS = "('EF v3.0', 'human toxicity: non-carcinogenic, organics', 'comparative toxic unit for human (CTUh)')"
+    EFV3_IONISING_RADIATION = "('EF v3.0', 'ionising radiation: human health', 'human exposure efficiency relative to u235')"
+    EFV3_LAND_USE = "('EF v3.0', 'land use', 'soil quality index')"
+    EFV3_MATERIAL_RESOURCES = "('EF v3.0', 'material resources: metals/minerals', 'abiotic depletion potential (ADP): elements (ultimate reserves)')"
+    EFV3_ENERGY_RESOURCES = "('EF v3.0', 'energy resources: non-renewable', 'abiotic depletion potential (ADP): fossil fuels')"
+    EFV3_OZONE_DEPLETION = (
+        "('EF v3.0', 'ozone depletion', 'ozone depletion potential (ODP)')"
+    )
+    EFV3_PARTICULATE_MATTER_FORMATION = (
+        "('EF v3.0', 'particulate matter formation', 'impact on human health')"
+    )
+    EFV3_PHOTOCHEMICAL_OZONE_FORMATION = "('EF v3.0', 'photochemical oxidant formation: human health', 'tropospheric ozone concentration increase')"
+    EFV3_WATER_USE = "('EF v3.0', 'water use', 'user deprivation potential (deprivation-weighted water consumption)')"
+
+    def to_short_name(self) -> MethodShortName:
+        """
+        Convert a full impact name (as specified in Brightway) to its shorter version.
+        :return: short name version of full impact name.
+        """
+        return MethodShortName[self.name]
+
+
+class MethodShortName(str, Enum):
+    """
+    Short version of impact methods supported by Brightway, to ease readability of
+    figures.
+    So far, only some ReCiPe methods, and all EF v3.0 impact methods are supported.
+    """
+
+    _settings_ = NoAlias
+    # RECIPE
+    RECIPE_MIDPOINT_CLIMATE_CHANGE = "Climate change (GWP100)"
+    RECIPE_MIDPOINT_TERRESTRIAL_ECOTOXICITY = "Terrestrial ecotoxicity (TETPinf)"
+    RECIPE_ENDPOINT_ECOSYSTEM_QUALITY = "Damage to ecosystems"
+    RECIPE_ENDPOINT_RESOURCES = "Damage to resource availability"
+    RECIPE_ENDPOINT_HUMAN_HEALTH = "Damage to human health"
+    RECIPE_ENDPOINT_TOTAL = "Total damage"
+
+    # EFV3
+    EFV3_ACIDIFICATION = "Acification (AE)"
+    EFV3_CLIMATE_CHANGE = "Climate change (GWP100)"
+    EFV3_CLIMATE_CHANGE_BIOGENIC = "Climate change: biogenic (GWP100)"
+    EFV3_CLIMATE_CHANGE_FOSSIL = "Climate change: fossil (GWP100)"
+    EFV3_CLIMATE_CHANGE_LAND_USE = "Climate change: land use/land use change (GWP100)"
+    EFV3_ECOTOXICITY_FRESHWATER = "Ecotoxicity: freshwater (CTUe)"
+    EFV3_ECOTOXICITY_FRESHWATER_INORGANICS = (
+        "Ecotoxicity: freshwater, inorganics (CTUe)"
+    )
+    EFV3_ECOTOXICITY_FRESHWATER_METALS = "Ecotoxicity: freshwater, metals (CTUe)"
+    EFV3_ECOTOXICITY_FRESHWATER_ORGANICS = "Ecotoxicity: freshwater, organics (CTUe)"
+    EFV3_EUTROPHICATION_FRESHWATER = "Eutrophication: freshwater (kgPeq)"
+    EFV3_EUTROPHICATION_MARINE = "Eutrophication: marine (N)"
+    EFV3_EUTROPHICATION_TERRESTRIAL = "Eutrophication: terrestrial (AE)"
+    EFV3_HUMAN_TOXICITY_CARCINOGENIC = "Human toxicity: carcinogenic (CTUh)"
+    EFV3_HUMAN_TOXICITY_CARCINOGENIC_INORGANICS = (
+        "Human toxicity: carcinogenic, inorganics (CTUh)"
+    )
+    EFV3_HUMAN_TOXICITY_CARCINOGENIC_METALS = (
+        "Human toxicity: carcinogenic, metals (CTUh)"
+    )
+    EFV3_HUMAN_TOXICITY_CARCINOGENIC_ORGANICS = (
+        "Human toxicity: carcinogenic, organics (CTUh)"
+    )
+    EFV3_HUMAN_TOXICITY_NON_CARCINOGENIC = "Human toxicity: non-carcinogenic (CTUh)"
+    EFV3_HUMAN_TOXICITY_NON_CARCINOGENIC_INORGANICS = (
+        "Human toxicity: non-carcinogenic, inorganics (CTUh)"
+    )
+    EFV3_HUMAN_TOXICITY_NON_CARCINOGENIC_METALS = (
+        "Human toxicity: non-carcinogenic, metals (CTUh)"
+    )
+    EFV3_HUMAN_TOXICITY_NON_CARCINOGENIC_ORGANICS = (
+        "Human toxicity: non-carcinogenic, organics (CTUh)"
+    )
+    EFV3_IONISING_RADIATION = "Ionising radiation: human health (kBqU235)"
+    EFV3_LAND_USE = "Land use (soil quality index)"
+    EFV3_MATERIAL_RESOURCES = "Resource use, metals and minerals (kgSbeq)"
+    EFV3_ENERGY_RESOURCES = "Energy use, energy carriers (MJ)"
+    EFV3_OZONE_DEPLETION = "Ozone depletion (ODP)"
+    EFV3_PARTICULATE_MATTER_FORMATION = (
+        "Particulate matter formation: impact on human health (disease incidences)"
+    )
+    EFV3_PHOTOCHEMICAL_OZONE_FORMATION = "Photochemical ozone formation (kgNMVOCeq)"
+    EFV3_WATER_USE = "Depr.-weighted water cons. (kg world eq. deprived)"
+
+    def to_full_name(self) -> MethodFullName:
+        """
+        Convert a short impact name to its full version (as specified in Brightway).
+        :return: full name version of short impact name.
+        """
+        return MethodFullName[self.name]

apparun/impact_model.py

@@ -0,0 +1,318 @@
+from __future__ import annotations
+
+from typing import Callable, Dict, List, Optional, Union
+
+import numpy as np
+import yaml
+from pydantic import BaseModel
+from SALib.analyze import sobol
+
+from apparun.impact_tree import ImpactTreeNode
+from apparun.parameters import ImpactModelParams
+from apparun.score import LCIAScores
+from apparun.tree_node import NodeScores
+
+
+class LcaPractitioner(BaseModel):
+    """
+    Information about a LCA practitioner.
+    """
+
+    name: Optional[str] = None
+    organization: Optional[str] = None
+    mail: Optional[str] = None
+
+
+class LcaStudy(BaseModel):
+    """
+    Information about LCA study, in order to understand its scope and for
+    reproducibility.
+    """
+
+    link: Optional[str] = None
+    description: Optional[str] = None
+    date: Optional[str] = None
+    version: Optional[str] = None
+    license: Optional[str] = None
+    appabuild_version: Optional[str] = None
+
+
+class ModelMetadata(BaseModel):
+    """
+    Contain information various information about the context of production of the
+    impact model.
+    """
+
+    author: Optional[LcaPractitioner] = None
+    reviewer: Optional[LcaPractitioner] = None
+    report: Optional[LcaStudy] = None
+
+    def to_dict(self):
+        """
+        Convert self to dict.
+        :return: self as a dict
+        """
+        return self.model_dump()
+
+    @staticmethod
+    def from_dict(model_metadata: dict) -> ModelMetadata:
+        """
+        Convert dict to ModelMetadata object.
+        :param model_metadata: dict containing construction parameters of the model
+        metadata.
+        :return: constructed model metadata.
+        """
+        return ModelMetadata(
+            author=LcaPractitioner(**model_metadata["author"]),
+            reviewer=LcaPractitioner(**model_metadata["reviewer"]),
+            report=LcaStudy(**model_metadata["report"]),
+        )
+
+
+class ImpactModel(BaseModel):
+    """
+    Impact model contains all the information required to compute the impact of an
+    LCA built with Appa Build.
+    """
+
+    metadata: Optional[ModelMetadata] = None
+    parameters: Optional[ImpactModelParams] = None
+    tree: Optional[ImpactTreeNode] = None
+
+    @property
+    def name(self):
+        return self.tree.name
+
+    @property
+    def transformation_table(
+        self,
+    ) -> Dict[str, Callable[[Union[str, float]], Dict[str, float]]]:
+        """
+        Map each parameter to its transform method.
+        :return: a dict mapping impact model's parameters' name with their transform
+        method.
+        """
+        return {parameter.name: parameter.transform for parameter in self.parameters}
+
+    def transform_parameters(
+        self, parameters: Dict[str, Union[List[Union[str, float]], Union[str, float]]]
+    ) -> Dict[str, Union[List[Union[str, float]], Union[str, float]]]:
+        """
+        Transform all the parameters' values, so it can be fed into a node's compute
+        method. See ImpactModelParam's transform methods for more information.
+        :param parameters: a dict mapping parameters' name and parameters' value, or
+        list of values.
+        :return: a dict mapping parameters' name and parameters' transformed value, or
+        list of transformed values.
+        """
+        list_parameters = {
+            name: parameter
+            for name, parameter in parameters.items()
+            if isinstance(parameter, list)
+        }
+        single_parameters = {
+            name: parameter
+            for name, parameter in parameters.items()
+            if not isinstance(parameter, list)
+        }
+        if len(list_parameters) == 0:
+            return {
+                name: value
+                for table in [
+                    self.transformation_table[parameter_name](parameter_value)
+                    for parameter_name, parameter_value in parameters.items()
+                ]
+                for name, value in table.items()
+            }
+        assert min(
+            len(list_parameter) for list_parameter in list_parameters.values()
+        ) == max(len(list_parameter) for list_parameter in list_parameters.values())
+        full_list_parameters = {
+            **{
+                parameter_name: [parameter_value]
+                * len(list(list_parameters.values())[0])
+                for parameter_name, parameter_value in single_parameters.items()
+            },
+            **list_parameters,
+        }
+        return {
+            name: value
+            for table in [
+                self.transformation_table[parameter_name](parameter_value)
+                for parameter_name, parameter_value in full_list_parameters.items()
+            ]
+            for name, value in table.items()
+        }
+
+    def to_dict(self):
+        """
+        Convert self to dict.
+        :return: self as a dict
+        """
+        return {
+            "metadata": self.metadata.to_dict(),
+            "parameters": self.parameters.to_list(sorted_by_name=True),
+            "tree": self.tree.to_dict(),
+        }
+
+    def to_yaml(self, filepath: str, compile_models: bool = True):
+        """
+        Convert self to yaml file.
+        :param filepath: filepath of the yaml file to create.
+        :param compile_models: if True, all models in tree nodes will be compiled.
+        ImpactModel will be bigger, but its execution will be faster at first use.
+        """
+        if compile_models:
+            self.tree.compile_models()
+        with open(filepath, "w") as stream:
+            yaml.dump(self.to_dict(), stream, sort_keys=False)
+
+    @staticmethod
+    def from_dict(impact_model: dict) -> ImpactModel:
+        """
+        Convert dict to ImpactModel object.
+        :param impact_model: dict containing construction parameters of the impact
+        model.
+        :return: constructed impact model.
+        """
+        return ImpactModel(
+            metadata=ModelMetadata.from_dict(impact_model["metadata"]),
+            parameters=ImpactModelParams.from_list(impact_model["parameters"]),
+            tree=ImpactTreeNode.from_dict(impact_model["tree"]),
+        )
+
+    def from_tree_children(self) -> List[ImpactModel]:
+        """
+        Create a new impact model for each of Impact Model tree root node's children.
+        Parameters of the impact model are copied, so unused parameters can remain in
+        newly created impact models.
+        :return: a list of newly created impact models.
+        """
+        return [
+            ImpactModel(parameters=self.parameters, tree=child)
+            for child in self.tree.children
+        ]
+
+    @staticmethod
+    def from_yaml(filepath: str) -> ImpactModel:
+        """
+        Convert a yaml file to an ImpactModel object.
+        :param filepath: yaml file containing construction parameters of the impact
+        model.
+        :return: constructed impact model.
+        """
+        with open(filepath, "r") as stream:
+            impact_model = yaml.safe_load(stream)
+            return ImpactModel.from_dict(impact_model)
+
+    def get_scores(self, **params) -> LCIAScores:
+        """
+        Get impact scores of the root node for each impact method, according to the
+        parameters.
+        :param params: value, or list of values of the impact model's parameters.
+        List of values must have the same length. If single values are provided
+        alongside a list of values, it will be duplicated to the appropriate length.
+        :return: a dict mapping impact names and corresponding score, or list of scores.
+        """
+        missing_params = self.parameters.get_missing_parameter_names(params)
+        default_params = self.parameters.get_default_values(missing_params)
+        transformed_params = self.transform_parameters({**params, **default_params})
+        scores = self.tree.compute(transformed_params)
+        return scores
+
+    def get_nodes_scores(
+        self, by_property: Optional[str] = None, **params
+    ) -> List[NodeScores]:
+        """
+        Get impact scores of the each node for each impact method, according to the
+        parameters.
+        :param by_property: if different than None, results will be pooled by nodes
+        sharing the same property value. Property name is the value of by_property.
+        :param params: value, or list of values of the impact model's parameters.
+        List of values must have the same length. If single values are provided
+        alongside a list of values, it will be duplicated to the appropriate length.
+        :return: a list of dict mapping impact names and corresponding score, or list
+        of scores, for each node/property value.
+        """
+        missing_params = self.parameters.get_missing_parameter_names(params)
+        default_params = self.parameters.get_default_values(missing_params)
+        transformed_params = self.transform_parameters({**params, **default_params})
+        scores = [
+            NodeScores(
+                name=node.name,
+                properties=node.properties,
+                parent=node.parent.name if node.parent is not None else "",
+                lcia_scores=node.compute(
+                    transformed_params, direct_impacts=by_property is not None
+                ),
+            )
+            for node in self.tree.unnested_descendants
+        ]
+        if by_property is not None:
+            scores = NodeScores.combine_by_property(scores, by_property)
+        return scores
+
+    def get_uncertainty_nodes_scores(self, n) -> List[NodeScores]:
+        """ """
+        samples = self.parameters.uniform_draw(n)
+        samples = self.parameters.draw_to_distrib(samples)
+        nodes_scores = self.get_nodes_scores(**samples)
+        return nodes_scores
+
+    def get_uncertainty_scores(self, n) -> LCIAScores:
+        """ """
+        samples = self.parameters.uniform_draw(n)
+        samples = self.parameters.draw_to_distrib(samples)
+        lcia_scores = self.get_scores(**samples)
+        return lcia_scores
+
+    def get_sobol_s1_indices(
+        self, n, all_nodes: bool = False
+    ) -> List[Dict[str, Union[str, np.ndarray]]]:
+        """
+        Get sobol first indices, which corresponds to the contribution of each
+        parameter to total result variance.
+        :param n: number of samples to draw with monte carlo.
+        :param all_nodes: if True, sobol s1 indices will be computed for each node. Else,
+        only for root node (FU).
+        :return: unpivoted dataframe containing sobol first indices for each parameter,
+        impact method, and node name if all_nodes is True.
+        """
+        samples = self.parameters.sobol_draw(n)
+        samples = self.parameters.draw_to_distrib(samples)
+        if all_nodes:
+            lcia_scores = self.get_nodes_scores(**samples)
+            sobol_s1_indices = []
+            for node_scores in lcia_scores:
+                for method, scores in node_scores.lcia_scores.scores.items():
+                    s1 = sobol.analyze(
+                        self.parameters.sobol_problem,
+                        np.array(scores),
+                        calc_second_order=True,
+                    )["S1"]
+                    sobol_s1_indices += [
+                        {
+                            "node": node_scores.name,
+                            "method": method,
+                            "parameter": self.parameters.sobol_problem["names"][i],
+                            "sobol_s1": s1[i],
+                        }
+                        for i in range(len(s1))
+                    ]
+            return sobol_s1_indices
+        lcia_scores = self.get_scores(**samples)
+        sobol_s1_indices = []
+        for method, scores in lcia_scores.scores.items():
+            s1 = sobol.analyze(
+                self.parameters.sobol_problem, np.array(scores), calc_second_order=True
+            )["S1"]
+            sobol_s1_indices += [
+                {
+                    "node": self.tree.name,
+                    "method": method,
+                    "parameter": self.parameters.sobol_problem["names"][i],
+                    "sobol_s1": s1[i],
+                }
+                for i in range(len(s1))
+            ]
+        return sobol_s1_indices