def test_append_to_foreground(self): a = pylcaio.LCAIO(1, verbose=False) b = pylcaio.LCAIO(1, verbose=False) a.extract_background(self.matdict) a.extract_foreground(self.matdict) B = {} B['PRO_f'] = np.array([['foo', 10, 'kg']], dtype=object) B['A_bf'] = scipy.sparse.csc_matrix([[1.0], [0.0], [0.0], [0.0]]) B['PRO_header'] = np.array([['FULL NAME', 'MATRIXID', 'UNIT']]) B['A_ff'] = scipy.sparse.csc_matrix([[11.0]]) # WITH THREE STRESSORS B['STR'] = np.array( [['stress01', 1614, 'kg'], ['stress02', 1615, 'kg'], ['stress03', 1616, 'kg']], dtype=object) B['F_f'] = scipy.sparse.csc_matrix([[0.0], [0.2], [0.0]]) B['y_f'] = scipy.sparse.csc_matrix([[2.0]]) b.extract_background(self.matdict) b.extract_foreground(B) a.append_to_foreground(b) y_f = pd.DataFrame({0: {10005: 1.0, 10002: 0.0, 10: 0.0}}) assert_frames_equivalent(a.y_f, y_f)
def test_append_to_foreground_w_ValueError(self): a = pylcaio.LCAIO(verbose=False) b = pylcaio.LCAIO(verbose=False) a.extract_foreground(self.matdict) b.extract_foreground(self.matdict) with self.assertRaises(ValueError): a.append_to_foreground(b)
def test_append_to_foreground_w_ValueError_w_multiindex(self): index = [0, 1, -1] a = pylcaio.LCAIO(index, verbose=False) b = pylcaio.LCAIO(index, verbose=False) a.extract_foreground(self.matdict) b.extract_foreground(self.matdict) with self.assertRaises(ValueError): a.append_to_foreground(b)
def test_append_to_foreground_multiindex(self): a = pylcaio.LCAIO([0, 1, -1], verbose=False) b = pylcaio.LCAIO([0, 1, -1], verbose=False) a.extract_foreground(self.matdict) B = {} B['PRO_f'] = np.array([['foo', 10, 'kg']], dtype=object) B['PRO_gen'] = np.array([['back01', 1, 'kg'], ['back02', 2, 'kg'], ['back03', 3, 'MJ'], ['back04', 4, 'MJ']], dtype=object) B['A_bf'] = scipy.sparse.csc_matrix([[1.0], [0.0], [0.0], [0.0]]) B['PRO_header'] = np.array([['FULL NAME', 'MATRIXID', 'UNIT']]) B['A_ff'] = scipy.sparse.csc_matrix([[11.0]]) # WITH THREE STRESSORS B['STR'] = np.array( [['stress01', 1614, 'kg'], ['stress02', 1615, 'kg'], ['stress03', 1616, 'kg']], dtype=object) B['F_f'] = scipy.sparse.csc_matrix([[0.0], [0.2], [0.0]]) B['y_f'] = scipy.sparse.csc_matrix([[0]]) b.extract_background(self.matdict) b.extract_foreground(B) a.append_to_foreground(b) A_bf = pd.DataFrame({ ('foo', 10, 'kg'): { ('back01', 1, 'kg'): 1.0, ('back03', 3, 'MJ'): 0.0, ('back04', 4, 'MJ'): 0.0, ('back02', 2, 'kg'): 0.0 }, ('Batt Packing', 10002, 'kg'): { ('back01', 1, 'kg'): 1.0, ('back03', 3, 'MJ'): 0.0, ('back04', 4, 'MJ'): 0.0, ('back02', 2, 'kg'): 0.0 }, ('s+orm', 10005, 'kg'): { ('back01', 1, 'kg'): 0.0, ('back03', 3, 'MJ'): 1.0, ('back04', 4, 'MJ'): 0.0, ('back02', 2, 'kg'): 1.0 } }) assert_frames_equivalent(a.A_bf, A_bf)
def test_match_foreground_background_trivial(self): a = pylcaio.LCAIO(verbose=False) a.extract_background(self.matdict) a.extract_foreground(self.matdict) b = pylcaio.LCAIO(verbose=False) b.extract_background(self.matdict) b.extract_foreground(self.matdict) a.match_foreground_to_background() assert (np.all(a.A_bf == b.A_bf)) assert (np.all(a.F_f == b.F_f))
def test_hybridization_detail(self): # define arda inventory object and populate a = pylcaio.LCAIO([0, 1], verbose=False) a.extract_background(self.matdict) a.extract_foreground(self.matdict) a.extract_io_background_from_pymrio(self.mrio) # Define two categories of IO flows a.io_categories['material'] = ['mining', 'food'] a.io_categories['energy'] = ['electricity'] # Hybridize, correcting for double counting in these two categories a.hybridize_process(('Batt Packing', 10002), ('reg2', 'transport'), 0.1, doublecounted_categories=('material', 'energy')) # assert that it got copied properly self.assertEqual( a.A.ix[('reg2', 'manufactoring'), ('Batt Packing', 10002)], a.A.ix[('reg2', 'manufactoring'), ('reg2', 'transport')] / 10) # assert that double counting from materiol inputs got corrected properly self.assertEqual(a.A.ix[('reg1', 'food'), ('Batt Packing', 10002)], 0) # assert that double counting from energy inputs got corrected properly self.assertEqual( a.A.ix[('reg1', 'electricity'), ('Batt Packing', 10002)], 0) # assert that intrasector flows were removed self.assertEqual( a.A.ix[('reg1', 'transport'), ('Batt Packing', 10002)], 0) # assert that direct emissions did not get copied self.assertEqual( a.F.ix[('emission_type1', 'air'), ('Batt Packing', 10002)], 0)
def test_hybridization_withOverwrite(self): # define arda inventory object and populate a = pylcaio.LCAIO([0, 1], verbose=False) a.extract_background(self.matdict) a.extract_foreground(self.matdict) a.extract_io_background_from_pymrio(self.mrio) # Define two categories of IO flows a.io_categories['material'] = ['mining', 'food'] a.io_categories['energy'] = ['electricity'] # Hybridize, correcting for double counting in these two categories a.hybridize_process(('Batt Packing', 10002), ('reg2', 'transport'), 0.1, doublecounted_categories=('material', 'energy'), overwrite=True, verbose=True) A_io_f_0 = a.A_io_f.copy() # Hybridize second time a.hybridize_process(('Batt Packing', 10002), ('reg2', 'transport'), 1E9, doublecounted_categories=('material', 'energy'), overwrite=True, verbose=True) # assert that second hybridization DID happen self.assertTrue(np.all(a.A_io_f >= A_io_f_0))
def test_identify_rows(random_LCA_system, random_IO_system, random_parameters): pylcaio_object = pylcaio.LCAIO( PRO_f=random_LCA_system['PRO_f'], A_ff=random_LCA_system['A_ff'], F_f=random_LCA_system['F_f'], C_f=random_LCA_system['C_f'], STR_f=random_LCA_system['STR_f'], y_f=random_LCA_system['y_f'], lca_database_name_and_version='ecoinvent3.5', A_io=random_IO_system['A_io'], F_io=random_IO_system['F_io'], C_io=random_IO_system['C_io'], STR_io=random_IO_system['STR_io'], y_io=random_IO_system['y_io'], io_database_name_and_version='exiobase3', listcountry=random_parameters['listcountry'], listregions=random_parameters['listregions'], countries_per_regions=random_parameters['countries_per_regions'], replacements1=random_parameters['replacements1'], reference_year_IO=random_parameters['reference_year_IO'], number_of_countries_IO=random_parameters['number_of_countries_IO'], number_of_products_IO=random_parameters['number_of_products_IO'], list_to_hyb=random_LCA_system['list_to_hyb'], list_not_hyb=random_LCA_system['list_not_to_hyb'], listmarket=random_LCA_system['listmarket']) pylcaio_object.identify_rows() sets = [] for RoW in pylcaio_object.dictRoW.values(): sets.append(set(RoW)) assert set(['FR', 'CH', 'ZA']) in sets assert set(['CA', 'ZA']) in sets assert len(pylcaio_object.dictRoW.values()) == 2 assert type(pylcaio_object.dictRoW) == dict assert 'RoW' not in pylcaio_object.PRO_f.io_geography.tolist()
def test_calc_lifecycle(self): a = pylcaio.LCAIO([0, 1], verbose=False) a.extract_background(self.matdict) a.extract_foreground(self.matdict) x = a.calc_lifecycle('production') x0 = pd.DataFrame.from_dict({ 0: { ('back03', 3): -0.25, ('back02', 2): -0.0, ('back04', 4): -0.0, ('back01', 1): -0.5, ('s+orm', 10005): 0.5, ('Batt Packing', 10002): -0.5 } }) assert_frames_equivalent(x, x0) e = a.calc_lifecycle('emissions') e0 = pd.DataFrame.from_dict({ 0: { ('stress02', 1615): -0.050000000000000003, ('stress01', 1614): 0.14999999999999999, ('stress03', 1616): 0.0 } }) assert_frames_equivalent(e, e0) d = a.calc_lifecycle('impacts') d0 = pylcaio.i2s( pd.DataFrame.from_dict({0: { ('GWP100', 1): 0.099999999999999992 }})) assert_frames_equivalent(d, d0)
def test_calc_proc(random_LCA_system, random_IO_system, random_parameters): pylcaio_object = pylcaio.LCAIO( PRO_f=random_LCA_system['PRO_f'], A_ff=random_LCA_system['A_ff'], F_f=random_LCA_system['F_f'], C_f=random_LCA_system['C_f'], STR_f=random_LCA_system['STR_f'], y_f=random_LCA_system['y_f'], lca_database_name_and_version='ecoinvent3.5', A_io=random_IO_system['A_io'], F_io=random_IO_system['F_io'], C_io=random_IO_system['C_io'], STR_io=random_IO_system['STR_io'], y_io=random_IO_system['y_io'], io_database_name_and_version='exiobase3', listcountry=random_parameters['listcountry'], listregions=random_parameters['listregions'], countries_per_regions=random_parameters['countries_per_regions'], replacements1=random_parameters['replacements1'], reference_year_IO=random_parameters['reference_year_IO'], number_of_countries_IO=random_parameters['number_of_countries_IO'], number_of_products_IO=random_parameters['number_of_products_IO'], list_to_hyb=random_LCA_system['list_to_hyb'], list_not_hyb=random_LCA_system['list_not_to_hyb'], listmarket=random_LCA_system['listmarket']) pylcaio_object.identify_rows() pylcaio_object.calc_productions() # check prod not empty assert len(pylcaio_object.total_prod_country) != 0 assert len(pylcaio_object.total_prod_region) != 0 assert len(pylcaio_object.total_prod_RoW) != 0 # check no string in prod assert type(pylcaio_object.total_prod_country.sum().sum()) == np.float64 assert type(pylcaio_object.total_prod_region.sum().sum()) == np.float64 assert type(pylcaio_object.total_prod_RoW.sum().sum()) == np.float64 # check non NaN in prod assert not pylcaio_object.total_prod_country.isnull().any()[0] assert not pylcaio_object.total_prod_region.isnull().any()[0] assert not pylcaio_object.total_prod_RoW.isnull().any()[0] # check if prods are in a dataframe format assert type(pylcaio_object.total_prod_country) == pd.core.frame.DataFrame assert type(pylcaio_object.total_prod_region) == pd.core.frame.DataFrame assert type(pylcaio_object.total_prod_RoW) == pd.core.frame.DataFrame # check no prod is negative assert pylcaio_object.total_prod_country[ pylcaio_object.total_prod_country < 0].sum()[0] == 0 assert pylcaio_object.total_prod_region[ pylcaio_object.total_prod_region < 0].sum().sum() == 0 assert pylcaio_object.total_prod_RoW[ pylcaio_object.total_prod_RoW < 0].sum().sum() == 0 # check that indexes are the same assert (pylcaio_object.A_io.index == pylcaio_object.total_prod_country.index).all() assert (pylcaio_object.A_io.index.levels[1] == pylcaio_object.total_prod_region.index).all() assert (pylcaio_object.A_io.index.levels[1] == pylcaio_object.total_prod_RoW.index).all()
def test_properties_multiindex(self): a = pylcaio.LCAIO([0, 1], verbose=False) a.extract_background(self.matdict) a.extract_foreground(self.matdict) a.extract_io_background_from_pymrio(self.mrio) a.A a.F a.PRO a.STR_all a.C_all
def test_match_foreground_background(self): a = pylcaio.LCAIO(verbose=False) a.extract_foreground(self.matdict) a.extract_background(self.bigdict) a.match_foreground_to_background() assert (np.all(a.A_bf.values == np.array([ [0, 1], [0, 0], # <--row5 insert here [1, 0], [1, 0], # <--row2 moved here [0, 0] ])))
def test_extract_io_background_from_pymrio(self): a = pylcaio.LCAIO(verbose=False) a.extract_background(self.matdict) a.extract_io_background_from_pymrio(self.mrio) # assertion1 assert (np.all(a.A_io.values == self.mrio.A.values)) # assertion2: stest extensions preserved self.assertAlmostEqual( a.F_io.values.sum(), self.mrio.emissions.S.values.sum() + self.mrio.factor_inputs.S.values.sum())
def test_delete_processes_foreground(self): a = pylcaio.LCAIO(1, verbose=False) a.extract_foreground(self.matdict) a.delete_processes_foreground([10005]) # A 2X2 FOREGROUND B = {} B['PRO_f'] = np.array([['Batt Packing', 10002, 'kg']], dtype=object) B['A_bf'] = scipy.sparse.csc_matrix([[1], [0], [0], [0]]) B['PRO_header'] = np.array([['FULL NAME', 'MATRIXID', 'UNIT']]) B['A_ff'] = scipy.sparse.csc_matrix([[11]]) # WITH THREE STRESSORS B['STR'] = np.array( [['stress01', 1614, 'kg'], ['stress02', 1615, 'kg'], ['stress03', 1616, 'kg']], dtype=object) B['F_f'] = scipy.sparse.csc_matrix([[0.0], [0.2], [0.0]]) B['y_f'] = scipy.sparse.csc_matrix([[0.0]]) b = pylcaio.LCAIO(1, verbose=False) b.extract_background(self.matdict) b.extract_foreground(B) pdt.assert_frame_equal(a.A_ff, b.A_ff) pdt.assert_frame_equal(a.F_f, b.F_f) pdt.assert_frame_equal(a.y_f, b.y_f) assert (np.all(a.A_bf.values == b.A_bf.values)) assert (np.all(a.PRO_f == b.PRO_f))
def test_import_and_export_matdict_keys_roundtrip(self): if os.name == 'nt': temporary = '/temp/' else: temporary = '/tmp/' a = pylcaio.LCAIO(verbose=False) a.extract_background(self.matdict) a.to_matfile(temporary + 'test_background.mat', foreground=False, background=True) a.extract_foreground(self.matdict) a.to_matfile(temporary + 'test_foreground.mat', foreground=True, background=False) fore = sio.loadmat(temporary + 'test_foreground.mat') back = sio.loadmat(temporary + 'test_background.mat') assert (len(self.matdict.keys() - fore.keys() - back.keys()) == 0)
def test_change_process_ids(self): a = pylcaio.LCAIO([1], verbose=False) a.extract_foreground(self.matdict) a.increase_foreground_process_ids(70000) A_ff = pd.DataFrame({ 80005: { 80005: 0, 80002: 10 }, 80002: { 80005: 1, 80002: 11 } }) assert_frames_equivalent(a.A_ff, A_ff) PRO_f = np.array( [['s+orm', 80005, 'kg'], ['Batt Packing', 80002, 'kg']], dtype=object) assert (np.all(a.PRO_f == PRO_f))
def test_hybridize(random_LCA_system, random_IO_system, random_parameters): pylcaio_object = pylcaio.LCAIO( PRO_f=random_LCA_system['PRO_f'], A_ff=random_LCA_system['A_ff'], F_f=random_LCA_system['F_f'], C_f=random_LCA_system['C_f'], STR_f=random_LCA_system['STR_f'], y_f=random_LCA_system['y_f'], lca_database_name_and_version='ecoinvent3.5', A_io=random_IO_system['A_io'], F_io=random_IO_system['F_io'], C_io=random_IO_system['C_io'], STR_io=random_IO_system['STR_io'], y_io=random_IO_system['y_io'], io_database_name_and_version='exiobase3', listcountry=random_parameters['listcountry'], listregions=random_parameters['listregions'], countries_per_regions=random_parameters['countries_per_regions'], replacements1=random_parameters['replacements1'], reference_year_IO=random_parameters['reference_year_IO'], number_of_countries_IO=random_parameters['number_of_countries_IO'], number_of_products_IO=random_parameters['number_of_products_IO'], list_to_hyb=random_LCA_system['list_to_hyb'], list_not_hyb=random_LCA_system['list_not_to_hyb'], listmarket=random_LCA_system['listmarket'], number_of_RoW_IO=random_parameters['number_of_RoW_IO'], io_categories=random_parameters['io_categories'], STAM_table=random_parameters['STAM_table'], categories_same_functionality=random_parameters[ 'categories_same_functionality']) pylcaio_object.hybridize('STAM') assert pylcaio_object.A_io_f.sum().sum() != 0 assert not pylcaio_object.A_io_f.empty assert (pylcaio_object.A_io_f.index == pylcaio_object.A_io.index).all() assert (pylcaio_object.A_io_f.columns == pylcaio_object.A_ff.columns).all() # all the sector2, 3 and 5 rows should be zero assert pylcaio_object.A_io_f.loc[[ i for i in pylcaio_object.A_io_f.index if i[1] == 'sector2' ]].sum().sum() == 0 assert pylcaio_object.A_io_f.loc[[ i for i in pylcaio_object.A_io_f.index if i[1] == 'sector3' ]].sum().sum() == 0 assert pylcaio_object.A_io_f.loc[[ i for i in pylcaio_object.A_io_f.index if i[1] == 'sector5' ]].sum().sum() == 0 # the sector4 row should not have ANY zero value assert pylcaio_object.A_io_f.loc[[ i for i in pylcaio_object.A_io_f.index if i[1] == 'sector4' ]][pylcaio_object.A_io_f.loc[ [i for i in pylcaio_object.A_io_f.index if i[1] == 'sector4']] == 0].isnull().all().all() # no zero in row sector1 columns 0, 2 and 4 assert pylcaio_object.A_io_f.loc[ [i for i in pylcaio_object.A_io_f.index if i[1] == 'sector1'], [ pylcaio_object.A_io_f.columns[0], pylcaio_object.A_io_f. columns[2], pylcaio_object.A_io_f.columns[4] ]][pylcaio_object.A_io_f.loc[ [i for i in pylcaio_object.A_io_f.index if i[1] == 'sector1'], [ pylcaio_object.A_io_f.columns[0], pylcaio_object.A_io_f. columns[2], pylcaio_object.A_io_f.columns[4] ]] == 0].isnull().all().all() # only zeros in row sector1 columns 1 and 3 assert pylcaio_object.A_io_f.loc[ [i for i in pylcaio_object.A_io_f.index if i[1] == 'sector1'], [pylcaio_object.A_io_f.columns[1], pylcaio_object.A_io_f. columns[3]]].sum().sum() == 0 # check that if uncorrected is different from corrected, then it is equal to zero (with STAM) assert pylcaio_object.A_io_f.loc[[ i for i in pylcaio_object.A_io_f_uncorrected.index if pylcaio_object.A_io_f_uncorrected.loc[ i, pylcaio_object.A_io_f_uncorrected.columns[0]] != pylcaio_object. A_io_f.loc[i, pylcaio_object.A_io_f_uncorrected.columns[0]] ]].sum().sum() == 0
def test_match_foreground_background_flowlosses(self): a = pylcaio.LCAIO(verbose=False) a.extract_foreground(self.matdict) a.extract_background(self.smalldict) with self.assertRaises(ValueError): a.match_foreground_to_background()
def test_append_to_foreground_with_final_demand(self): a = pylcaio.LCAIO(1, verbose=False) b = pylcaio.LCAIO(1, verbose=False) a.extract_background(self.matdict) b.extract_background(self.matdict) B = {} B['PRO_f'] = np.array([['foo', 10, 'kg']], dtype=object) B['A_bf'] = scipy.sparse.csc_matrix([[1.0], [0.0], [0.0], [0.0]]) B['PRO_header'] = np.array([['FULL NAME', 'MATRIXID', 'UNIT']]) B['A_ff'] = scipy.sparse.csc_matrix([[11]]) # WITH THREE STRESSORS B['STR'] = np.array( [['stress01', 1614, 'kg'], ['stress02', 1615, 'kg'], ['stress03', 1616, 'kg']], dtype=object) B['F_f'] = scipy.sparse.csc_matrix([[0.0], [0.2], [0.0]]) B['y_f'] = scipy.sparse.csc_matrix([[2.0]]) a.extract_foreground(self.matdict) b.extract_foreground(B) a.append_to_foreground(b, final_demand=True) A_ff = pd.DataFrame({ 10005: { 10005: 0.0, 10002: 10.0, 10: 0.0 }, 10: { 10005: 0.0, 10002: 0.0, 10: 11.0 }, 10002: { 10005: 1.0, 10002: 11.0, 10: 0.0 } }) assert_frames_equivalent(a.A_ff, A_ff) A_bf = pd.DataFrame({ 10005: { 1: 0.0, 2: 1.0, 3: 1.0, 4: 0.0 }, 10002: { 1: 1.0, 2: 0.0, 3: 0.0, 4: 0.0 }, 10: { 1: 1.0, 2: 0.0, 3: 0.0, 4: 0.0 } }) assert_frames_equivalent(a.A_bf, A_bf) F_f = pd.DataFrame({ 10005: { 1616: 0.0, 1614: 0.29999999999999999, 1615: 0.10000000000000001 }, 10002: { 1616: 0.0, 1614: 0.0, 1615: 0.20000000000000001 }, 10: { 1616: 0.0, 1614: 0.0, 1615: 0.20000000000000001 } }) assert_frames_equivalent(a.F_f, F_f) y_f = pd.DataFrame({0: {10005: 1.0, 10002: 0.0, 10: 2.0}}) assert_frames_equivalent(a.y_f, y_f) # check that order is right assert (np.all( a.PRO_f.ix[:, a._arda_default_labels] == a.A_ff.index.values))