aiphoria 0.0.1__py3-none-any.whl → 0.8.0__py3-none-any.whl

aiphoria/lib/odym/modules/test/ODYM_Classes_test_known_results.py

@@ -0,0 +1,107 @@
+# -*- coding: utf-8 -*-
+"""
+Created on Mon Aug 11 16:19:39 2014
+
+@authors: Stefan Pauliuk, Uni Freiburg, Germany
+"""
+import os
+import sys
+# Put location of 
+sys.path.insert(0,  os.path.abspath(os.path.join(os.path.dirname(__file__), '..\\..')) + '\\modules') # add ODYM module directory to system path
+#NOTE: Hidden variable __file__ must be know to script for the directory structure to work.
+# Therefore: When first using the model, run the entire script with F5 so that the __file__ variable can be created.
+
+import ODYM_Classes as msc # import the ODYM class file
+import ODYM_Functions as msf # import the ODYM function file
+import numpy as np
+import unittest
+import pandas as pd
+
+
+###############################################################################
+# Test 1) A simple MFA system with 5 years and 1 chemical element
+###############################################################################
+# Define results
+MyMFA_Test1_Flowshape1 = (5,2) # shape of a flow in system defined below.
+F_0_1_Values1          = np.array([[1,1],[0,0],[2,2],[1,1],[4,4]]) # Define some arbitrary inflow data for each year and element
+F_1_2_Values1          = np.array([[1,1],[1,1],[32,32],[1,1],[4,4]]) # 
+F_2_1_Values1          = np.array([[0,0],[1,1],[30,30],[0,0],[0,0]]) # Define flow back to process 1, make sure mass balance holds.
+F_2_0_Values1          = F_0_1_Values1.copy()  # outflow equals inflow as no stocks are present
+Bal_Test1              = np.zeros((5,3,2))
+
+# Define dynamic MFA model and fill in values
+"""Create Dynamic MFA Models and hand over the pre-defined values."""
+# Define a basic classification with 5 years, 1 element, and unity. 'Time' and 'Element' must be present!
+ModelClassification_Test1 = {} 
+ModelClassification_Test1['Unity']    = msc.Classification(Name = 'Unity',         Dimension = 'Unity',   Items = [1])
+ModelClassification_Test1['Time']     = msc.Classification(Name = 'Time',          Dimension = 'Time',    Items = [2010,2011,2012,2013,2014])
+ModelClassification_Test1['Element'] = msc.Classification(Name = 'Chem_Elements', Dimension = 'Element', Items = ['All','Fe'])
+
+#extract start and end year
+Model_Time_Start = min(ModelClassification_Test1['Time'].Items)
+Model_Time_End   = max(ModelClassification_Test1['Time'].Items)
+
+#Define model aspects in right order
+Model_Aspects = ['Time','Element','Unity'] # aspects of the model to be considered. Must be the same as the items of the ModelClassification_Test1 dictionary
+# Define a simple index table with the three aspects time, element, and unity, using the modelclassification above.
+IndexTable = pd.DataFrame({'Aspect'        : Model_Aspects, # 'Time' and 'Element' must be present!
+                           'Description'   : ['Time','Element','Unity'],
+                           'Dimension'     : ['Time','Element','Unity'], # must be the same as 'Dimenstion' in the classification above
+                           'Classification': [ModelClassification_Test1[Aspect] for Aspect in Model_Aspects],
+                           'IndexLetter'   : ['t','e','i']}) # Unique one letter (upper or lower case) indices to be used later for calculations. t for time, e for element
+
+IndexTable.set_index('Aspect', inplace = True) # Default indexing of IndexTable, other indices are produced on the fly
+
+# Initialize MFA system
+MyMFA_Test1 = msc.MFAsystem(Name = 'TestSystem', 
+                      Geogr_Scope = 'World', 
+                      Unit = 'Mt', 
+                      ProcessList = [], 
+                      FlowDict = {}, 
+                      StockDict = {},
+                      ParameterDict = None, 
+                      Time_Start = Model_Time_Start, 
+                      Time_End = Model_Time_End, 
+                      IndexTable = IndexTable, 
+                      Elements = IndexTable.ix['Element'].Classification.Items) 
+                      
+# Add 2 processes to system
+PrL_Name   = ['Environment','Process_1','Process_2']
+PrL_Number = [0,1,2]
+for m in range(0, len(PrL_Name)):
+    MyMFA_Test1.ProcessList.append(msc.Process(Name = PrL_Name[m], ID   = PrL_Number[m]))
+    
+# Define 4 flows by symbol and names
+MyMFA_Test1.FlowDict['F_0_1'] = msc.Flow(Name = 'Input'             , P_Start = 0, P_End = 1, Indices = 't,e', Values=None, Uncert=None)
+MyMFA_Test1.FlowDict['F_1_2'] = msc.Flow(Name = 'Processed input'   , P_Start = 1, P_End = 2, Indices = 't,e', Values=None, Uncert=None)
+MyMFA_Test1.FlowDict['F_2_1'] = msc.Flow(Name = 'Sent back to 1'    , P_Start = 2, P_End = 1, Indices = 't,e', Values=None, Uncert=None)
+MyMFA_Test1.FlowDict['F_2_0'] = msc.Flow(Name = 'Output'            , P_Start = 2, P_End = 0, Indices = 't,e', Values=None, Uncert=None)
+
+MyMFA_Test1.Initialize_FlowValues() # Assign empty arrays to flows according to dimensions specified above
+
+# Assign values to flows, manually: This prodecure mimicks the calculation of results by solving the model equations
+MyMFA_Test1.FlowDict['F_0_1'].Values = F_0_1_Values1
+MyMFA_Test1.FlowDict['F_1_2'].Values = F_1_2_Values1
+MyMFA_Test1.FlowDict['F_2_1'].Values = F_2_1_Values1
+MyMFA_Test1.FlowDict['F_2_0'].Values = F_2_0_Values1
+
+Bal = MyMFA_Test1.MassBalance() # Determine Mass Balance    
+
+###############################################################################
+# Tests
+###############################################################################
+
+class KnownResultsTestCase(unittest.TestCase):
+
+    # For MyMFA_Test1:
+    def test_Dimensions_MyMFA_Test1(self):
+        """Test Inflow Driven Model with Fixed product lifetime."""
+        np.testing.assert_array_equal(MyMFA_Test1.FlowDict['F_1_2'].Values.shape[0],MyMFA_Test1_Flowshape1[0])
+        np.testing.assert_array_equal(MyMFA_Test1.FlowDict['F_1_2'].Values.shape[1],MyMFA_Test1_Flowshape1[1])
+        np.testing.assert_array_equal(MyMFA_Test1.MassBalance(),Bal_Test1)
+           
+
+
+
+    if __name__ == '__main__':
+        unittest.main()

aiphoria/lib/odym/modules/test/ODYM_Functions_test_known_results.py

@@ -0,0 +1,136 @@
+# -*- coding: utf-8 -*-
+"""
+Created on Mon Aug 11 16:19:39 2014
+
+@authors: Stefan Pauliuk, Uni Freiburg, Germany
+"""
+import os
+import sys
+# Put location of 
+sys.path.insert(0,  os.path.abspath(os.path.join(os.path.dirname(__file__), '..\\..')) + '\\modules') # add ODYM module directory to system path
+#NOTE: Hidden variable __file__ must be know to script for the directory structure to work.
+# Therefore: When first using the model, run the entire script with F5 so that the __file__ variable can be created.
+
+import ODYM_Classes as msc # import the ODYMM class file
+import ODYM_Functions as msf # import the ODYM function file
+import numpy as np
+import unittest
+import pandas as pd
+
+
+###############################################################################
+# Test 1) A simple MFA system with 5 years and 1 chemical element
+###############################################################################
+# Define results
+
+# For TableWithFlowsToShares(Table,axis):
+
+TSA = np.array([[1, 2, 1, 2, 4, 1],
+                [1, 3, 0, 2, 4, 3],
+                [0, 3, 4, 3, 1, 0],
+                [1, 4, 3, 2, 1, 0]])
+
+TSB = np.array([[0.333333,0.166667,0.125,0.222222,0.4,0.25],
+[0.333333,0.25,0,0.222222,0.4,0.75],
+[0,0.25,0.5,0.333333,0.1,0],
+[0.333333,0.333333,0.375,0.222222,0.1,0]])
+
+TSC = np.array([[0.0909091,0.181818,0.0909091,0.181818,0.363636,0.0909091],
+[0.0769231,0.230769,0,0.153846,0.307692,0.230769],
+[0,0.272727,0.363636,0.272727,0.0909091,0],
+[0.0909091,0.363636,0.272727,0.181818,0.0909091,0]])
+
+B = msf.TableWithFlowsToShares(TSA,axis=0)
+C = msf.TableWithFlowsToShares(TSA,axis=1)
+
+TSAx = np.array([[1, 2, 1, 0, 4, 1],
+                 [1, 3, 0, 0, 4, 3],
+                 [0, 3, 4, 0, 1, 0],
+                 [1, 4, 3, 0, 1, 0]])
+
+Bx = msf.TableWithFlowsToShares(TSAx,axis=0)
+Cx = msf.TableWithFlowsToShares(TSAx,axis=1)
+
+TSBx = np.array([[0.3333333333333333,0.1666666666666667,0.125,0,0.4,0.25],
+[0.3333333333333333,0.25,0,0,0.4,0.75],
+[0,0.25,0.5,0,0.1,0],
+[0.3333333333333333,0.3333333333333333,0.375,0,0.1,0]])
+
+TSCx = np.array([[0.1111111111111111,0.2222222222222222,0.1111111111111111,0,0.4444444444444444,0.1111111111111111],
+[0.09090909090909091,0.2727272727272727,0,0,0.3636363636363636,0.2727272727272727],
+[0,0.375,0.5,0,0.125,0],
+[0.1111111111111111,0.4444444444444444,0.3333333333333333,0,0.1111111111111111,0]])
+
+TSAy = np.array([[1, 2, 1, 2, 4, 1],
+                 [1, 3, 0, 2, 4, 3],
+                 [0, 3, 4, 3, 1, 0],
+                 [0, 0, 0, 0, 0, 0]])
+
+By = msf.TableWithFlowsToShares(TSAy,axis=0)
+Cy = msf.TableWithFlowsToShares(TSAy,axis=1)
+
+TSAzref = np.array([[0.5,0.25,0.2,0.2857142857142857,0.4444444444444444,0.25],
+[0.5,0.375,0,0.2857142857142857,0.4444444444444444,0.75],
+[0,0.375,0.8,0.4285714285714285,0.1111111111111111,0],
+[0,0,0,0,0,0]])
+
+TSBzref = np.array([[0.090909090909090911614143238,0.18181818181818182322828648,0.090909090909090911614143238,0.18181818181818182322828648,0.36363636363636364645657295,0.090909090909090911614143238],
+[0.076923076923076927347011633,0.2307692307692307820410349,0,0.15384615384615385469402327,0.30769230769230770938804653,0.2307692307692307820410349],
+[0,0.2727272727272727070868541,0.36363636363636364645657295,0.2727272727272727070868541,0.090909090909090911614143238,0],
+[0,0,0,0,0,0]])
+
+TSAz = np.zeros((4,6))
+Bz = msf.TableWithFlowsToShares(TSAz,axis=0)
+Cz = msf.TableWithFlowsToShares(TSAz,axis=1)
+
+
+ELCTest1 = np.array([[3.59212,0,0,0.00922665,3.58289,0,0,0],
+[0,0,0,0,0,0,0,0],
+[0,0,0,0,0,0,0,0],
+[0.173689,0,0.1719,0,0,0.00178926,0,0],
+[0.0574175,0,0,0,0,0.0574175,0,0],
+[0,0,0,0,0,0,0,0]])
+
+ELCTest1res = np.array([[1,0,0,0.002568583066476976,0.9974314169335231,0,0,0],
+[1,0,0,0,0,0,0,1],
+[1,0,0,0,0,0,0,1],
+[1,0,0.9896984994927148,0,0,0.01030150050728525,0,0],
+[1,0,0,0,0,1,0,0],
+[1,0,0,0,0,0,0,1]])
+
+#A= msf.DetermineElementComposition_All_Oth(ELCTest1)
+
+
+###############################################################################
+# Tests
+###############################################################################
+
+class KnownResultsTestCase(unittest.TestCase):
+
+    # For MyMFA_Test1:
+    def test_ListStringToListNumbers(self):
+        """Test the list string to list of numbers function."""
+        np.testing.assert_array_equal(msf.ListStringToListNumbers('[1,2,3]'),[1,2,3])
+           
+    def test_MI_Tuple(self):
+        """Test the MI_Tuple function."""
+        np.testing.assert_array_equal(msf.MI_Tuple(10, [3,4,2,6]),[0,0,1,4])
+
+    def test_TableWithFlowsToShares(self):
+        """Test the TableWithFlowsToShares function."""
+        np.testing.assert_array_almost_equal(msf.TableWithFlowsToShares(TSA,axis=0),TSB,6)
+        np.testing.assert_array_almost_equal(msf.TableWithFlowsToShares(TSA,axis=1),TSC,6)
+        np.testing.assert_array_almost_equal(msf.TableWithFlowsToShares(TSAx,axis=0),TSBx,16)
+        np.testing.assert_array_almost_equal(msf.TableWithFlowsToShares(TSAx,axis=1),TSCx,16)
+        np.testing.assert_array_almost_equal(msf.TableWithFlowsToShares(TSAy,axis=0),TSAzref,16)
+        np.testing.assert_array_almost_equal(msf.TableWithFlowsToShares(TSAy,axis=1),TSBzref,26)
+        np.testing.assert_array_equal(msf.TableWithFlowsToShares(TSAz,axis=0),np.zeros((4,6)))
+        np.testing.assert_array_equal(msf.TableWithFlowsToShares(TSAz,axis=1),np.zeros((4,6)))
+    
+    def test_DetermineElementComposition_All_Oth(self):
+        """Test the DetermineElementComposition_All_Oth function."""
+        np.testing.assert_array_almost_equal(msf.DetermineElementComposition_All_Oth(ELCTest1),ELCTest1res,16)
+        
+    
+    if __name__ == '__main__':
+        unittest.main()

aiphoria/lib/odym/modules/test/__init__.py

@@ -0,0 +1,2 @@
+# -*- coding: utf-8 -*-
+