Issue in results when using processes from several data bases

Question

Hello,

I have imported ELCD and EF data in one openLCA database because all the processes I need to use are not available in one or the other. So I crossed the data to build a more complete model.

The first results I got using ReCiPe method were very strange. For example, the road transport process gave no impact for the global warming category and globally the impacts of all categories were much lower than the ones of a water transport process I also used...

I analyzed in detail the results and noticed that the carbon dioxide flows used in both transport processes are not the same (different references).

I remember however having read that OpenLCA and especially Nexus were conceived to use standardized format in order for the user to be able to cross the databases and expand the possibilities when creating an ACV model.

My questions are:

Is it an isolate case or most of flows used in several databases have different references which are not always taken into account by the methods ?

Is there a process or a method to follow when building the model to avoid this kind of errors in the results ?

In my case, what can I do to correct my model with my two databases? Should I change manually all the flows which are not pointing to a reference taken into account in the method I used (processes contain hundreds of flows) ? Is there at least something easy to do to find the most impacted flows and just modify them ?

Thank you in advance for your answer,

Thibaut

Answer 1

One solution could be to combine the impact methods from the individual databases - so assuming ECLD and EF databases both have recipe, export the impact method from both databases into json-ld. In a new empty database, import both methods. And then if you're comfortable with python, you can use the IPC to create a combined method:

import olca

from uuid import uuid4

client = olca.Client(60000) #default here I believe is 8080

#use the IPC generator to get all impact categories from the database with combined methods

impact_cats_gen=client.get_all(olca.ImpactCategory)

impact_cats_list=[x for x in impact_cats_gen]

#If the impact categories have different names between the databases

#you'll have to change the names here. The dictionary key (e.g., Global warming potential)

#will be the name of your new combined category. Apologies for the seemingly

#non-sensical name franken_categories: frankenstein categories.

franken_categories={

    "Global warming potential":["IPCC GWP 100a - IPCC 2013 GWP 100a", "Global warming"],

    "Acidification potential":["Acidification - TRACI 2.1","Acidification"],

    "Eutrophication potential":["Eutrophication - TRACI 2.1","Eutrophication"],

    "Smog formation potential":["Smog - TRACI 2.1","Smog formation"],

    "Particulate matter formation potential":["Human health - particulate matter","Respiratory effects - TRACI 2.1"],

    "Ozone depletion potential":["Ozone depletion - TRACI 2.1","Ozone depletion"]

}

#this is where the magic happens. Creating a new impact categories that

#we'll later assign to an impact method

new_cats={}

new_cat_refs=[]

for franken_cat in franken_categories.keys():

    impact_factor_list = []

    if new_cats.get(franken_cat) is None:

        print(f"Creating ImpactCategory for {franken_cat}")

        new_cats[franken_cat]=olca.ImpactCategory()

        new_cats[franken_cat].olca_type=olca.schema.ImpactCategory.__name__

        new_cats[franken_cat].id=str(uuid4())

        new_cats[franken_cat].reference_unit_name=None

        new_cats[franken_cat].name=franken_cat

    for orig_cat in impact_cats_list:

        if orig_cat.name in franken_categories[franken_cat]:

            print(f"{orig_cat.name} is in {franken_cat}")

            if new_cats[franken_cat].reference_unit_name is None:

                print(f"Copying reference info from {orig_cat.name}")

                new_cats[franken_cat].reference_unit_name=orig_cat.reference_unit_name

                new_ref=olca.ImpactCategoryRef()

                new_ref.ref_unit=orig_cat.reference_unit_name

                new_ref.name=franken_cat

                new_ref.id=new_cats[franken_cat].id

            #print(f"{franken_categories[franken_cat]} - {orig_cat.name}")

            for impact_factor in orig_cat.impact_factors:

                #print(f"{impact_factor.flow.name}")

                impact_factor.olca_type=olca.schema.ImpactFactor.__name__

                impact_factor_list.append(impact_factor)

    new_cats[franken_cat].impact_factors=impact_factor_list

    #client.insert(new_cats[franken_cat])

    new_cat_refs.append(new_ref)

#creating a new impact method in openLCA.

impact_method=olca.ImpactMethod()

#change the name of your method to whatever you want

impact_method.name="Combined impacts"

impact_method.id=str(uuid4())

impact_method.impact_categories=new_cat_refs

impact_method.olca_type=olca.schema.ImpactMethod.__name__

client.insert(impact_method)

You'll probably need to close and re-open the database to see your new combined impact category. You can now export that to json-ld to use in the database with your combined datasets.

Good luck!