ecosemantic-engine 0.1.8__py3-none-any.whl

ecosemantic/engine/background.py

@@ -0,0 +1,345 @@
+"""A database compiled for calculation: its matrices as labelled arrays, its exchange rows with
+their distributions, and the directory of numpy files it is saved as."""
+
+from __future__ import annotations
+
+import hashlib
+import json
+from collections.abc import Sequence
+from dataclasses import dataclass, fields
+from pathlib import Path
+
+import nimblend as nb
+import numpy as np
+
+from ecosemantic.errors import Conflict, Invalid, NotFound
+from ecosemantic.model.entities import DISTRIBUTION_IDS, Method, Uncertainty
+from ecosemantic.model.refs import Database
+
+FORMAT = 1
+_PARAMETERS = ("loc", "scale", "minimum", "maximum")
+
+
+@dataclass(frozen=True)
+class Rows:
+    """Exchange rows by label, as a source states them: each row's row and column label, its
+    amount, whether it enters the matrix negated, and its distribution."""
+
+    rows: Sequence[str]
+    columns: Sequence[str]
+    amounts: Sequence[float]
+    flipped: Sequence[bool]
+    uncertainties: Sequence[Uncertainty | None]
+
+
+@dataclass(frozen=True)
+class Factors:
+    """Characterisation factors by label: each one's category, its flow and its value."""
+
+    categories: Sequence[str]
+    flows: Sequence[str]
+    values: Sequence[float]
+
+
+@dataclass(frozen=True)
+class Exchanges:
+    """Exchange rows unsummed, at the positions of a background's coordinates: each row's row and
+    column, its amount as stated, whether it enters the matrix negated, and its distribution:
+    the type as `DISTRIBUTION_IDS` numbers it, 0 for none, and NaN for a parameter the type has
+    not."""
+
+    row: np.ndarray
+    column: np.ndarray
+    amount: np.ndarray
+    flip: np.ndarray
+    uncertainty_type: np.ndarray
+    loc: np.ndarray
+    scale: np.ndarray
+    minimum: np.ndarray
+    maximum: np.ndarray
+    negative: np.ndarray
+
+    @classmethod
+    def of(
+        cls,
+        row: np.ndarray,
+        column: np.ndarray,
+        amounts: Sequence[float],
+        flipped: Sequence[bool],
+        uncertainties: Sequence[Uncertainty | None],
+    ) -> Exchanges:
+        """Rows at positions, with their distributions as columns."""
+        n = len(amounts)
+        kind = np.zeros(n, dtype=np.int8)
+        parameters = {name: np.full(n, np.nan) for name in _PARAMETERS}
+        negative = np.zeros(n, dtype=bool)
+        for at, uncertainty in enumerate(uncertainties):
+            if uncertainty is None:
+                continue
+            kind[at] = DISTRIBUTION_IDS[uncertainty.type]
+            for name, value in uncertainty.params.items():
+                if name == "negative":
+                    negative[at] = bool(value)
+                else:
+                    parameters[name][at] = float(value)
+        return cls(
+            row=np.asarray(row, dtype=np.int32),
+            column=np.asarray(column, dtype=np.int32),
+            amount=np.asarray(amounts, dtype=np.float64),
+            flip=np.asarray(flipped, dtype=bool),
+            uncertainty_type=kind,
+            negative=negative,
+            **parameters,
+        )
+
+
+def _known(what: str, labels: np.ndarray, coordinate: np.ndarray) -> None:
+    """Invalid when a row names a label the coordinate does not hold."""
+    unknown = labels[~np.isin(labels, coordinate)]
+    if unknown.size:
+        raise Invalid(
+            f"{unknown.size} {what} name a label the background does not hold, "
+            f"the first {str(unknown[0])!r}"
+        )
+
+
+def _exchanges(rows: Rows, row: nb.StoredCoord, column: nb.StoredCoord) -> Exchanges:
+    """The rows at the positions of two coordinates, their distributions as columns."""
+    return Exchanges.of(
+        row=row.to_position(np.asarray(rows.rows)),
+        column=column.to_position(np.asarray(rows.columns)),
+        amounts=rows.amounts,
+        flipped=rows.flipped,
+        uncertainties=rows.uncertainties,
+    )
+
+
+def _signed(rows: Rows) -> np.ndarray:
+    """Each row's amount as it enters the matrix."""
+    return np.where(np.asarray(rows.flipped, dtype=bool), -1.0, 1.0) * np.asarray(
+        rows.amounts, dtype=np.float64
+    )
+
+
+class Background:
+    """A database compiled for calculation. `technosphere` is over ("product", "activity"),
+    `biosphere` over ("flow", "activity") and `characterization` over ("category", "flow").
+    "product" and "activity" share one coordinate: one label per dataset, its native id."""
+
+    def __init__(
+        self,
+        database: Database,
+        methods: Sequence[Method],
+        coords: dict[str, nb.StoredCoord],
+        technosphere: nb.SparseArray,
+        biosphere: nb.SparseArray,
+        characterization: nb.SparseArray,
+        exchanges: dict[str, Exchanges],
+    ) -> None:
+        self.database = database
+        self.methods = tuple(methods)
+        self.coords = coords
+        self.technosphere = technosphere
+        self.biosphere = biosphere
+        self.characterization = characterization
+        self.exchanges = exchanges
+        self._category = {method.id: at for at, method in enumerate(self.methods)}
+
+    @classmethod
+    def compile(
+        cls,
+        database: Database,
+        activities: Sequence[str],
+        flows: Sequence[str],
+        methods: Sequence[Method],
+        technosphere: Rows,
+        biosphere: Rows,
+        factors: Factors,
+    ) -> Background:
+        """The background of these datasets, flows and methods. A dataset's rows at one
+        coordinate, its production and its use of its own product, are added. Invalid for a row
+        naming a label outside its coordinate."""
+        activity_labels = np.array(sorted(activities))
+        flow_labels = np.array(sorted(flows))
+        category_labels = np.array([method.id for method in methods])
+        _known("technosphere rows", np.asarray(technosphere.rows), activity_labels)
+        _known("technosphere columns", np.asarray(technosphere.columns), activity_labels)
+        _known("biosphere rows", np.asarray(biosphere.rows), flow_labels)
+        _known("biosphere columns", np.asarray(biosphere.columns), activity_labels)
+        _known("factor categories", np.asarray(factors.categories), category_labels)
+        _known("factor flows", np.asarray(factors.flows), flow_labels)
+        activity = nb.StoredCoord(activity_labels)
+        coords = {
+            "product": activity,
+            "activity": activity,
+            "flow": nb.StoredCoord(flow_labels),
+            "category": nb.StoredCoord(category_labels),
+        }
+        return cls(
+            database,
+            methods,
+            coords,
+            nb.from_long(
+                ("product", "activity"),
+                coords,
+                {
+                    "product": np.asarray(technosphere.rows),
+                    "activity": np.asarray(technosphere.columns),
+                },
+                _signed(technosphere),
+                on_duplicate="sum",
+            ),
+            nb.from_long(
+                ("flow", "activity"),
+                coords,
+                {"flow": np.asarray(biosphere.rows), "activity": np.asarray(biosphere.columns)},
+                _signed(biosphere),
+                on_duplicate="sum",
+            ),
+            nb.from_long(
+                ("category", "flow"),
+                coords,
+                {"category": np.asarray(factors.categories), "flow": np.asarray(factors.flows)},
+                np.asarray(factors.values, dtype=np.float64),
+                on_duplicate="sum",
+            ),
+            {
+                "technosphere": _exchanges(technosphere, activity, activity),
+                "biosphere": _exchanges(biosphere, coords["flow"], activity),
+            },
+        )
+
+    def treating(self) -> frozenset[str]:
+        """The datasets whose production, net of their use of their own product, enters the
+        matrix negative: the treatments, each taking in the waste its reference names, so a
+        consumer sends it a negative amount. ecoinvent states such a reference as a negative
+        output and openLCA as an input; both compile to a negative production."""
+        rows = self.exchanges["technosphere"]
+        own = np.asarray(rows.row) == np.asarray(rows.column)
+        signed = np.where(np.asarray(rows.flip)[own], -1.0, 1.0) * np.asarray(rows.amount)[own]
+        labels = self.coords["activity"].labels
+        net = np.bincount(np.asarray(rows.column)[own], weights=signed, minlength=labels.size)
+        return frozenset(str(label) for label in labels[net < 0])
+
+    def position(self, dim: str, label: str) -> int | None:
+        """The position of a label along "activity" or "flow", whose labels are sorted, or
+        None."""
+        labels = self.coords[dim].labels
+        at = int(np.searchsorted(labels, label))
+        return at if at < labels.size and labels[at] == label else None
+
+    def positions(self, methods: Sequence[Method]) -> list[int]:
+        """The position of each method's category, in the order given; NotFound naming every
+        method the background does not hold."""
+        missing = [method.spec for method in methods if method.id not in self._category]
+        if missing:
+            raise NotFound(f"{self.database.name!r} lacks methods {missing}")
+        return [self._category[method.id] for method in methods]
+
+    def arrays(self) -> dict[str, np.ndarray]:
+        """Every array the background is saved as, by the name of its file: the label columns,
+        each matrix's index and data, and each exchange column."""
+        arrays: dict[str, np.ndarray] = {
+            "activities": np.asarray(self.coords["activity"].labels),
+            "flows": np.asarray(self.coords["flow"].labels),
+            "categories": np.asarray(self.coords["category"].labels),
+        }
+        for name in ("technosphere", "biosphere", "characterization"):
+            array: nb.SparseArray = getattr(self, name)
+            arrays[f"{name}.index"] = np.asarray(array.index)
+            arrays[f"{name}.data"] = np.asarray(array.data)
+        for matrix, exchanges in self.exchanges.items():
+            for field in fields(Exchanges):
+                arrays[f"{matrix}.exchanges.{field.name}"] = np.asarray(
+                    getattr(exchanges, field.name)
+                )
+        return arrays
+
+    def fingerprint(self) -> str:
+        """SHA-256 of the arrays in the order of their names, each as its name, its dtype, its
+        shape and its bytes in C order, the category labels taken as each category's key less
+        the database name, since a method id carries the name its database is installed under:
+        what a calculation reads, apart from that name, background.json's other fields and the
+        files' headers, so one build installed under any name, and every build holding the same
+        numbers, shares it."""
+        arrays = self.arrays()
+        arrays["categories"] = np.asarray(
+            [" > ".join(method.tuple[1:]) for method in self.methods], dtype=np.str_
+        )
+        digest = hashlib.sha256()
+        for name, array in sorted(arrays.items()):
+            values = np.ascontiguousarray(array)
+            digest.update(f"{name}\0{values.dtype.str}\0{values.shape}\0".encode())
+            digest.update(values.tobytes())
+        return digest.hexdigest()
+
+    def save(self, directory: Path) -> None:
+        """Write the background into a new directory: one .npy file per array and label column,
+        and background.json, written last, with the format, the database, the methods and the
+        counts."""
+        if directory.exists():
+            raise Conflict(f"{directory} exists; save the background to a new directory")
+        directory.mkdir(parents=True)
+        arrays = self.arrays()
+        for name, values in arrays.items():
+            np.save(directory / f"{name}.npy", values, allow_pickle=False)
+        manifest = {
+            "format": FORMAT,
+            "database": self.database.model_dump(mode="json"),
+            "methods": [method.model_dump(mode="json") for method in self.methods],
+            "counts": {name: int(values.shape[-1]) for name, values in arrays.items()},
+        }
+        (directory / "background.json").write_text(
+            json.dumps(manifest, indent=1) + "\n", encoding="utf-8"
+        )
+
+    @classmethod
+    def load(cls, directory: Path) -> Background:
+        """The background saved in a directory, its arrays memory-mapped. NotFound for a
+        directory holding none, Invalid for a format this engine does not read."""
+        manifest_path = directory / "background.json"
+        if not manifest_path.is_file():
+            raise NotFound(f"{directory} holds no saved background")
+        manifest = json.loads(manifest_path.read_text(encoding="utf-8"))
+        if manifest.get("format") != FORMAT:
+            raise Invalid(
+                f"{directory} holds background format {manifest.get('format')!r}; "
+                f"this engine reads format {FORMAT}"
+            )
+
+        def read(name: str) -> np.ndarray:
+            return np.load(directory / f"{name}.npy", mmap_mode="r", allow_pickle=False)
+
+        activity = nb.StoredCoord(read("activities"))
+        coords = {
+            "product": activity,
+            "activity": activity,
+            "flow": nb.StoredCoord(read("flows")),
+            "category": nb.StoredCoord(read("categories")),
+        }
+        dims = {
+            "technosphere": ("product", "activity"),
+            "biosphere": ("flow", "activity"),
+            "characterization": ("category", "flow"),
+        }
+        arrays = {
+            name: nb.SparseArray.from_canonical(
+                read(f"{name}.index"), read(f"{name}.data"), coords, frame
+            )
+            for name, frame in dims.items()
+        }
+        exchanges = {
+            matrix: Exchanges(
+                **{f.name: read(f"{matrix}.exchanges.{f.name}") for f in fields(Exchanges)}
+            )
+            for matrix in ("technosphere", "biosphere")
+        }
+        return cls(
+            Database.model_validate(manifest["database"]),
+            [Method.model_validate(method) for method in manifest["methods"]],
+            coords,
+            arrays["technosphere"],
+            arrays["biosphere"],
+            arrays["characterization"],
+            exchanges,
+        )

ecosemantic/engine/calculation.py

@@ -0,0 +1,293 @@
+"""Exact results over a compiled background: one solve, and the scores, contributions,
+intensities, supply, inventory and paths read from it."""
+
+from __future__ import annotations
+
+import uuid
+from collections.abc import Mapping, Sequence
+from dataclasses import dataclass
+
+import nimblend as nb
+import numpy as np
+import scipy.sparse as sp
+
+from ecosemantic.engine.background import Background
+from ecosemantic.engine.foreground import Foreground
+from ecosemantic.engine.loops import Loops, loops_of
+from ecosemantic.engine.paths import PathTree, Walked, walk
+from ecosemantic.engine.solver import Solver, SolverName
+from ecosemantic.errors import Invalid, NotFound
+from ecosemantic.model.entities import DemandItem, Method, ProductSystem
+from ecosemantic.model.refs import ForegroundRef
+
+NOISE_FLOOR = 1e-34
+
+
+def _csr(array: nb.SparseArray) -> sp.csr_matrix:
+    """A two-dimensional array as a scipy CSR matrix over its buffers."""
+    indices, values, indptr = array.to_csr()
+    return sp.csr_matrix((values, indices, indptr), shape=array.shape)
+
+
+def _over(dim: str, coord: nb.StoredCoord, values: np.ndarray) -> nb.SparseArray:
+    """A value at every label of one coordinate."""
+    return nb.Domain.full((dim,), {dim: coord}).array(np.asarray(values, dtype=np.float64))
+
+
+@dataclass(frozen=True)
+class Solution:
+    """One solve: the foreground it solved, the supply of each foreground process over
+    "process" and of each background activity over "activity", the inventory over "flow", the
+    demand placed on background activities, and the solver that ran."""
+
+    foreground: Foreground | None
+    process_supply: nb.SparseArray
+    activity_supply: nb.SparseArray
+    inventory: nb.SparseArray
+    background_demand: np.ndarray
+    solver: SolverName
+
+
+@dataclass(frozen=True)
+class Contributions:
+    """A score split over the processes that emit, each one's direct emissions characterised
+    times its supply: the foreground's over "process", the background's over "activity"."""
+
+    foreground: nb.SparseArray
+    background: nb.SparseArray
+
+
+@dataclass(frozen=True)
+class Inventory:
+    """The amount of every elementary flow over "flow", and for each flow with an amount the
+    label of the foreground process whose own and upstream emissions of it are largest, None
+    where a demanded background activity's are or where there is no foreground. An amount at or
+    below `floor`, NOISE_FLOOR of the largest, is float64 residue: it is set to zero, and
+    `dropped` counts it."""
+
+    amounts: nb.SparseArray
+    sources: dict[str, str | None]
+    floor: float
+    dropped: int
+
+
+class Calculation:
+    """Exact results over one background: its technosphere factorised once by the named solver,
+    and per category the direct impact of each activity and the cradle-to-gate intensities, each
+    built on first use."""
+
+    def __init__(self, background: Background, solver: SolverName = "superlu") -> None:
+        self.background = background
+        self.technosphere = _csr(background.technosphere)
+        self.biosphere = _csr(background.biosphere)
+        self.characterization = _csr(background.characterization)
+        self.solver = Solver(solver, self.technosphere)
+        self._direct: dict[int, np.ndarray] = {}
+        self._intensities: dict[int, np.ndarray] = {}
+        self._loops: Loops | None = None
+
+    def foreground(
+        self, product_system: ProductSystem, linked: Mapping[uuid.UUID, ProductSystem]
+    ) -> Foreground:
+        """The foreground of a product system and the systems it links."""
+        return Foreground.of(self.background, product_system, linked)
+
+    def loops(self) -> Loops:
+        """The background's loops a sampled draw is checked on, found on first use."""
+        if self._loops is None:
+            self._loops = loops_of(self.technosphere)
+        return self._loops
+
+    def _factors(self, position: int) -> np.ndarray:
+        """The characterisation factor of every flow under one category."""
+        return np.asarray(self.characterization[[position]].toarray()).ravel()
+
+    def _direct_impacts(self, position: int) -> np.ndarray:
+        """Each activity's direct emissions characterised under one category, per unit of its
+        operation."""
+        if position not in self._direct:
+            self._direct[position] = (
+                (self.characterization[[position]] @ self.biosphere).toarray().ravel()
+            )
+        return self._direct[position]
+
+    def _intensity_rows(self, positions: Sequence[int]) -> np.ndarray:
+        """The cradle-to-gate intensity of every activity under each category, one row each; the
+        categories not yet held are solved together, one right-hand side each."""
+        missing = sorted({p for p in positions if p not in self._intensities})
+        if missing:
+            direct = np.column_stack([self._direct_impacts(p) for p in missing])
+            solved = self.solver.adjoint(direct)
+            for at, p in enumerate(missing):
+                self._intensities[p] = solved[:, at]
+        return np.vstack([self._intensities[p] for p in positions])
+
+    def placed(
+        self, foreground: Foreground | None, demand: Sequence[DemandItem]
+    ) -> tuple[np.ndarray, np.ndarray]:
+        """The demand on foreground processes and on background activities."""
+        background = self.background
+        d_fg = np.zeros(len(foreground.columns) if foreground is not None else 0)
+        d_bg = np.zeros(len(background.coords["activity"]))
+        for item in demand:
+            if isinstance(item.ref, ForegroundRef):
+                if foreground is None:
+                    raise Invalid(
+                        f"the demand names foreground process {item.ref.code!r} "
+                        "and the calculation has no product system"
+                    )
+                host = foreground.product_system.id
+                d_fg[foreground.column_of(host, item.ref.code, "the demand")] += item.amount
+                continue
+            if item.ref.database != background.database.name:
+                raise Invalid(f"the demand names database {item.ref.database!r}")
+            at = background.position("activity", item.ref.id)
+            if at is None:
+                raise NotFound(
+                    f"the demand names background dataset {item.ref.id!r}, "
+                    f"which {background.database.name!r} does not hold"
+                )
+            d_bg[at] += item.amount
+        return d_fg, d_bg
+
+    def _process_coord(self, foreground: Foreground | None) -> nb.StoredCoord:
+        labels = foreground.labels if foreground is not None else np.array([], dtype=str)
+        return nb.StoredCoord(labels)
+
+    def solve(self, foreground: Foreground | None, demand: Sequence[DemandItem]) -> Solution:
+        """The supply and the inventory that meet a demand: the foreground first, then the
+        background with the foreground's uses added to its demand."""
+        background = self.background
+        d_fg, d_bg = self.placed(foreground, demand)
+        rhs = d_bg.copy()
+        s_fg = np.zeros(0)
+        if foreground is not None:
+            s_fg = foreground.solve(d_fg)
+            rhs = rhs + foreground.uses @ s_fg
+        s_bg = self.solver.forward(rhs) if rhs.any() else np.zeros_like(rhs)
+        g = np.asarray(self.biosphere @ s_bg).ravel()
+        if foreground is not None:
+            g = g + np.asarray(foreground.direct @ s_fg).ravel()
+        return Solution(
+            foreground=foreground,
+            process_supply=_over("process", self._process_coord(foreground), s_fg),
+            activity_supply=_over("activity", background.coords["activity"], s_bg),
+            inventory=_over("flow", background.coords["flow"], g),
+            background_demand=d_bg,
+            solver=self.solver.name,
+        )
+
+    def scores(self, solution: Solution, methods: Sequence[Method]) -> nb.SparseArray:
+        """One score per method over "category", in the order given; NotFound naming every
+        method the background does not hold."""
+        positions = self.background.positions(methods)
+        values = np.asarray(self.characterization[positions] @ solution.inventory.data).ravel()
+        coord = nb.StoredCoord(np.array([method.id for method in methods]))
+        return _over("category", coord, values)
+
+    def by_process(self, solution: Solution, method: Method) -> Contributions:
+        """The score of each foreground process and each background activity: its direct
+        emissions characterised, times its supply."""
+        [position] = self.background.positions([method])
+        factors = self._factors(position)
+        background = self._direct_impacts(position) * solution.activity_supply.data
+        fg = solution.foreground
+        own = np.zeros(0) if fg is None else np.asarray(factors @ fg.direct).ravel()
+        return Contributions(
+            foreground=_over(
+                "process", self._process_coord(fg), own * solution.process_supply.data
+            ),
+            background=_over("activity", self.background.coords["activity"], background),
+        )
+
+    def by_flow(self, solution: Solution, method: Method) -> nb.SparseArray:
+        """Each flow's characterised amount over "flow"."""
+        [position] = self.background.positions([method])
+        values = self._factors(position) * solution.inventory.data
+        return _over("flow", self.background.coords["flow"], values)
+
+    def intensities(self, methods: Sequence[Method]) -> nb.SparseArray:
+        """The cradle-to-gate score of one unit of every activity's product under each method,
+        over ("category", "activity")."""
+        rows = self._intensity_rows(self.background.positions(methods))
+        coords = {
+            "category": nb.StoredCoord(np.array([method.id for method in methods])),
+            "activity": self.background.coords["activity"],
+        }
+        return nb.Domain.full(("category", "activity"), coords).array(rows.ravel())
+
+    def supply(self, foreground: Foreground, demand: Sequence[DemandItem]) -> nb.SparseArray:
+        """The level of each foreground process that meets the demand, over "process", with no
+        background solve."""
+        d_fg, _ = self.placed(foreground, demand)
+        return _over("process", self._process_coord(foreground), foreground.solve(d_fg))
+
+    def inventory(self, solution: Solution) -> Inventory:
+        """The inventory, and each flow's dominant source: per foreground process its own
+        emissions plus those of the background it uses, one background solve each, and the
+        demanded background activities together."""
+        found = solution.inventory.data
+        floor = NOISE_FLOOR * float(np.abs(found).max(initial=0.0))
+        residue = (found != 0.0) & (np.abs(found) <= floor)
+        g = np.where(residue, 0.0, found)
+        amounts = _over("flow", self.background.coords["flow"], g)
+        dropped = int(residue.sum())
+        flows = self.background.coords["flow"].labels
+        nonzero = np.flatnonzero(g)
+        fg = solution.foreground
+        if fg is None:
+            sourced = {str(flows[row]): None for row in nonzero}
+            return Inventory(amounts, sourced, floor, dropped)
+        s_fg = solution.process_supply.data
+        k = len(fg.columns)
+        shares = np.zeros((k + 1, g.size))
+        for j in range(k):
+            own = np.asarray(fg.direct[:, [j]].toarray()).ravel() * s_fg[j]
+            used = np.asarray(fg.uses[:, [j]].toarray()).ravel() * s_fg[j]
+            upstream = self.biosphere @ self.solver.forward(used) if used.any() else 0.0
+            shares[j] = own + upstream
+        if solution.background_demand.any():
+            shares[k] = self.biosphere @ self.solver.forward(solution.background_demand)
+        labels = fg.labels
+        sources: dict[str, str | None] = {}
+        for row in nonzero:
+            winner = int(np.argmax(np.abs(shares[:, row])))
+            sources[str(flows[row])] = None if winner == k else str(labels[winner])
+        return Inventory(amounts, sources, floor, dropped)
+
+    def paths(
+        self,
+        foreground: Foreground,
+        item: DemandItem,
+        method: Method,
+        max_level: int,
+        max_nodes: int,
+        cutoff: float,
+    ) -> PathTree:
+        """The paths under the one foreground process an item demands, walked best first."""
+        if not isinstance(item.ref, ForegroundRef):
+            raise Invalid("paths start at one foreground process")
+        [position] = self.background.positions([method])
+        factors = self._factors(position)
+        background_intensity = self._intensity_rows([position])[0]
+        foreground_intensity = foreground.solve_transposed(
+            np.asarray(factors @ foreground.direct).ravel()
+            + np.asarray(foreground.uses.T @ background_intensity).ravel()
+        )
+        solution = self.solve(foreground, [item])
+        total = float(factors @ solution.inventory.data)
+        root = foreground.column_of(foreground.product_system.id, item.ref.code, "the paths")
+        walked = Walked(
+            foreground_intensity=foreground_intensity,
+            background_intensity=background_intensity,
+            factors=factors,
+            foreground=foreground.technosphere.tocsc(),
+            uses=foreground.uses.tocsc(),
+            direct=foreground.direct.tocsc(),
+            technosphere=self.technosphere.tocsc(),
+            biosphere=self.biosphere.tocsc(),
+            process_labels=foreground.labels,
+            activity_labels=self.background.coords["activity"].labels,
+            flow_labels=self.background.coords["flow"].labels,
+        )
+        return walk(walked, root, item.amount, total, max_level, max_nodes, cutoff)