extend material loss/path_split logic to allow for a three-way path split (electrical steel)

[rjhanes]

We'll need to implement that for the electrical steel case study

[rjhanes]

Yes, this logic is already implemented. Some additional coding will be required if there are facilities that have losses being sent to landfill and a fixed split between two downstream facility types, as in "contamination removal 1" for the electrical steel baseline scenario. (Scrap is decontaminated with some material lost, then the remainder is split 80/20 between next use/exporting and carbon steel manufacturing.)

In the scenario YAML files, this information is specified in the path_split dictionary, which looks like this in the glass case study baseline:

    path_split:
        fine grinding:
            fraction: 0.3
            facility_1: landfilling
        window installation:
            fraction: 0.03
            facility_1: landfilling
        window glass recovery:
            fraction: 0.006
            facility_1: landfilling
        window glass cullet manufacturing:
            fraction: 0.1
            facility_1: landfilling
        module disassembly:
            fraction: 0.09
            facility_1: landfilling
        solar glass cullet manufacturing:
            fraction: 0.028
            facility_1: landfilling

Specifying a different facility_1 value will direct the lost fraction to the nearest (least-cost) facility of type facility_1.

The code that implements this logic is in component.eol_process, lines 398-455 ish:

# If the next step for the component involves material losses,
                if factype in [key for key in self.split_dict]:
                    # Pull in the mass fraction lost in this step
                    _loss = apply_array_uncertainty(self.split_dict[factype]["fraction"],self.context.model_run)

                    # Move the component to the facility that involves material losses
                    # Note the amt parameter is the FRACTION of this component being moved
                    # amt multiplies component actual count and actual material masses within
                    # the move_component_to and move_component_from methods
                    self.move_component_to(
                        env, loc=location, dist=distance, route_id=route_id, amt = 1.0
                    )
                    # Update the component's location
                    self.current_location = location
                    
                    # Wait until the component has spent 'lifespan' timesteps here
                    # Generally this is only 1 timestep
                    yield env.timeout(lifespan)

                    # Move the entire component OUT of the facility that involves material losses,
                    # IF the component has a next step in its pathway
                    # (both the lost fraction and recovered fraction have to leave the facility)
                    if len(self.pathway) > 0:
                        self.move_component_from(env, loc=location, amt = 1.0)
                    # If there's no next step, then only move the lost component fraction
                    # out of this facility. The recovered fraction remains in the current facility.
                    else:
                        self.move_component_from(env, loc=location, amt = _loss)

                    # Locate the closest facility that receives material losses
                    _split_facility_1 = self.context.cost_graph.find_nearest_factype(
                        source_node = location,
                        target_factype = self.split_dict[factype]["facility_1"],
                        crit = 'dist',
                    )

                    # Move component fractions to [landfill] facility that receives material losses
                    self.move_component_to(
                        env,
                        loc = _split_facility_1[0],
                        amt = _loss,
                        dist = _split_facility_1[1],
                        route_id = _split_facility_1[2],
                    )
                    
                    # Move the rest of the component to the next facility along pathway
                    if len(self.pathway) > 0:

                        location, lifespan, distance, route_id = self.pathway.popleft()
                        factype = location.split("_")[0]

                        self.move_component_to(
                            env,
                            loc = location,
                            dist = distance,
                            route_id = route_id,
                            amt= 1 - _loss
                        )

To implement a fixed path_split between three facilities, the relevant entry in the path_split dict would look like:

    path_split:
        origin_facility:
            fraction_1: 0.1
            facility_1: destination_facility_1
            fraction_2: 0.2
            facility_2: destination_facility_2

The code logic would need to be extended accordingly by adding the following, adjusted to refer to the second destination facility information:

                    # Locate the closest facility that receives material losses
                    _split_facility_1 = self.context.cost_graph.find_nearest_factype(
                        source_node = location,
                        target_factype = self.split_dict[factype]["facility_1"],
                        crit = 'dist',
                    )

                    # Move component fractions to [landfill] facility that receives material losses
                    self.move_component_to(
                        env,
                        loc = _split_facility_1[0],
                        amt = _loss,
                        dist = _split_facility_1[1],
                        route_id = _split_facility_1[2],
                    )