def test_add_measurement_times(self):
builder = TemplateBuilder()
times = range(5)
builder.add_measurement_times(times)
for i in times:
self.assertIn(i, builder._meas_times)
self.assertIn(i, builder.measurement_times)
def test_set_algebraics_rule(self):
builder = TemplateBuilder()
def rule(x, y, z):
return x + y + z
self.assertRaises(RuntimeError, builder.set_algebraics_rule, rule)
def test_add_spectral_data(self):
builder = TemplateBuilder()
d_frame = pd.DataFrame()
self.assertFalse(builder.has_spectral_data())
builder.add_spectral_data(d_frame)
self.assertTrue(builder.has_spectral_data())
def test_construct(self):
mixture_components = {'A': 1, 'B': 0}
extra_states = {'T': 278.0}
parameters = {'k': 0.01}
algebraics = ['r1','r2']
builder = TemplateBuilder(concentrations=mixture_components,
parameters=parameters,
extra_states=extra_states,
algebraics=algebraics)
self.assertEqual(builder.num_mixture_components, 2)
self.assertTrue('A' in builder._init_conditions)
self.assertTrue('A' in builder._component_names)
self.assertEqual(builder._init_conditions['A'], 1)
self.assertTrue('B' in builder._init_conditions)
self.assertTrue('B' in builder._component_names)
self.assertEqual(builder._init_conditions['B'], 0)
self.assertEqual(builder.num_parameters, 1)
self.assertTrue('k' in builder._parameters)
self.assertEqual(builder._parameters['k'], 0.01)
self.assertFalse('k' in builder._parameters_bounds)
self.assertEqual(builder.num_complementary_states, 1)
self.assertTrue('T' in builder._init_conditions)
self.assertTrue('T' in builder._complementary_states)
self.assertEqual(builder._init_conditions['T'], 278.0)
self.assertEqual(builder.num_algebraics, 2)
self.assertTrue('r1' in builder._algebraics)
self.assertTrue('r2' in builder._algebraics)
parameters = ['k']
builder = TemplateBuilder(parameters=parameters)
self.assertEqual(builder.num_parameters, 1)
self.assertTrue('k' in builder._parameters)
def test_set_odes_rule(self):
builder = TemplateBuilder()
# define explicit system of ODEs
def rule_odes(m, t):
exprs = dict()
exprs['A'] = -m.P['k'] * m.Z[t, 'A']
exprs['B'] = m.P['k'] * m.Z[t, 'A']
return exprs
builder.set_odes_rule(rule_odes)
m = pe.ConcreteModel()
m.P = pe.Param(['k'], initialize=0.01)
m.t = dae.ContinuousSet(bounds=(0, 1))
m.Z = pe.Var(m.t, ['A', 'B'])
self.assertIsInstance(builder._odes(m, 0), dict)
def rule(x, y, z):
return x + y + z
self.assertRaises(RuntimeError, builder.set_odes_rule, rule)
def test_add_algebraic_variable(self):
builder = TemplateBuilder()
builder.add_algebraic_variable('r1')
self.assertEqual(builder.num_algebraics, 1)
self.assertTrue('r1' in builder._algebraics)
builder.add_algebraic_variable(['r2', 'r3'])
self.assertEqual(builder.num_algebraics, 3)
self.assertTrue('r2' in builder._algebraics)
self.assertTrue('r3' in builder._algebraics)
def test_add_complementary_state_variable(self):
builder = TemplateBuilder()
builder.add_complementary_state_variable('A', 1)
self.assertEqual(builder.num_complementary_states, 1)
self.assertTrue('A' in builder._init_conditions)
self.assertTrue('A' in builder._complementary_states)
self.assertEqual(builder._init_conditions['A'], 1)
builder.add_complementary_state_variable({'B': 0})
self.assertEqual(builder.num_complementary_states, 2)
self.assertTrue('B' in builder._init_conditions)
self.assertTrue('B' in builder._complementary_states)
self.assertEqual(builder._init_conditions['B'], 0)
def test_add_complementary_state(self):
builder = TemplateBuilder()
builder.add_complementary_state_variable('T', 278.0)
self.assertEqual(builder.num_complementary_states, 1)
self.assertTrue('T' in builder._init_conditions)
self.assertTrue('T' in builder._complementary_states)
self.assertEqual(builder._init_conditions['T'], 278.0)
builder.add_complementary_state_variable({'V': 10.0})
self.assertEqual(builder.num_complementary_states, 2)
self.assertTrue('V' in builder._init_conditions)
self.assertTrue('V' in builder._complementary_states)
self.assertEqual(builder._init_conditions['V'], 10.0)
def test_add_mixture_component(self):
builder = TemplateBuilder()
builder.add_mixture_component('A', 1)
self.assertEqual(builder.num_mixture_components, 1)
self.assertTrue('A' in builder._init_conditions)
self.assertTrue('A' in builder._component_names)
self.assertEqual(builder._init_conditions['A'], 1)
builder.add_mixture_component({'B': 0})
self.assertEqual(builder.num_mixture_components, 2)
self.assertTrue('B' in builder._init_conditions)
self.assertTrue('B' in builder._component_names)
self.assertEqual(builder._init_conditions['B'], 0)
#=========================================================================
# Load spectral data from the relevant file location. As described in section 4.3.1
#################################################################################
dataDirectory = os.path.abspath(
os.path.join(
os.path.dirname(
os.path.abspath(inspect.getfile(inspect.currentframe()))),
'data_sets'))
filename = os.path.join(dataDirectory, 'Dij_tv_G.txt')
D_frame = read_spectral_data_from_txt(filename)
print(D_frame)
# Then we build dae block for as described in the section 4.2.1. Note the addition
# of the data using .add_spectral_data
#################################################################################
builder = TemplateBuilder()
components = {'A': 0.01, 'B': 0.0, 'C': 0.0}
builder.add_mixture_component(components)
builder.add_parameter('k1', init=1.4, bounds=(0.0, 2.0)) #True k1 = 1.5
#There is also the option of providing initial values: Just add init=... as additional argument as above.
builder.add_parameter('k2', bounds=(0.0, 0.5)) #True k2 = 0.2
builder.add_spectral_data(D_frame)
# There are options of providing initial values and bounds
# for unwanted contribution variables, qr(t) and g(lambda).
builder.add_qr_bounds_init(bounds=(0, None), init=1.1)
builder.add_g_bounds_init(bounds=(0, None))
# define explicit system of ODEs
def rule_odes(m, t):
exprs = dict()
def test_add_parameter(self):
builder = TemplateBuilder()
builder.add_parameter('k', 0.01)
self.assertEqual(builder.num_parameters, 1)
self.assertTrue('k' in builder._parameters)
self.assertEqual(builder._parameters['k'], 0.01)
self.assertFalse('k' in builder._parameters_bounds)
builder.add_parameter('k1', 0.01, bounds=(0, 1))
self.assertEqual(builder.num_parameters, 2)
self.assertTrue('k1' in builder._parameters)
self.assertTrue('k1' in builder._parameters_bounds)
self.assertEqual(builder._parameters_bounds['k1'][0], 0)
self.assertEqual(builder._parameters_bounds['k1'][1], 1)
builder.add_parameter(['B', 'C'])
self.assertTrue('B' in builder._parameters)
self.assertTrue('C' in builder._parameters)
self.assertIsNone(builder._parameters['B'])
self.assertIsNone(builder._parameters['C'])
self.assertEqual(builder.num_parameters, 4)
builder.add_parameter(['D'], bounds=[(0.0, 1.0)])
self.assertEqual(builder.num_parameters, 5)
self.assertTrue('D' in builder._parameters_bounds)
self.assertEqual(builder._parameters_bounds['D'][0], 0)
self.assertEqual(builder._parameters_bounds['D'][1], 1)
builder.add_parameter({'E': 7.0})
self.assertEqual(builder.num_parameters, 6)
self.assertEqual(builder._parameters['E'], 7)
builder.add_parameter({'F': 7.0}, bounds={'F': (4, 5)})
self.assertEqual(builder.num_parameters, 7)
self.assertEqual(builder._parameters['F'], 7)
self.assertTrue('F' in builder._parameters_bounds)
self.assertEqual(builder._parameters_bounds['F'][0], 4)
self.assertEqual(builder._parameters_bounds['F'][1], 5)
def test_add_absorption_data(self):
builder = TemplateBuilder()
s_frame = pd.DataFrame()
self.assertFalse(builder.has_adsorption_data())
builder.add_absorption_data(s_frame)
self.assertTrue(builder.has_adsorption_data())
X_data = X_data.iloc[t, :]
Z_data.drop(index=0, inplace=True)
X_data.drop(index=0, inplace=True)
return Z_data, X_data, results_pyomo
if __name__ == "__main__":
with_plots = False
if len(sys.argv) == 2:
if int(sys.argv[1]):
with_plots = False
builder = TemplateBuilder()
components = [
Component('A', 1000, 0.1),
]
parameters = [
KineticParameter('Tf', (250, 400), 293.15, 0.09),
KineticParameter('Cfa', (0, 5000), 2500, 0.01),
KineticParameter('rho', (800, 2000), 1025, 0.01),
KineticParameter('delH', (0.0, 400), 160, 0.01),
KineticParameter('ER', (0.0, 500), 255, 0.01),
KineticParameter('k', (0.0, 10), 2.5, 0.01),
KineticParameter('Tfc', (250, 400), 283.15, 0.01),
KineticParameter('rhoc', (0.0, 2000), 1000, 0.01),
KineticParameter('h', (0.0, 5000), 3600, 0.01),
models = {}
# Declare all global variables used in simulation
d_init = {
'k1': (2.5, (0.0, 5.0)),
'k2': (0.8, (0.0, 1.0)),
}
# Declare all global variables as the initial guess
d_init_guess = {
'k1': (2.5, (0.0, 5.0)),
'k2': (0.5, (0.0, 1.0)),
}
# Scenario 1 #############################################################
builder = TemplateBuilder()
build = builder
components = {'A': 1e-3, 'B': 0, 'C': 0}
build.add_mixture_component(components)
for d, dv in d_init.items():
build.add_parameter(d, init=dv[0], bounds=dv[1])
build.set_odes_rule(rule_odes)
build.set_model_times(times)
# Simulate data for scenario 1
pyomo_model = build.create_pyomo_model()
simulator = PyomoSimulator(pyomo_model)
Z_data, X_data, results = run_simulation(simulator)
return Z_data, X_data, results_pyomo
if __name__ == "__main__":
with_plots = True
if len(sys.argv) == 2:
if int(sys.argv[1]):
with_plots = False
#=========================================================================
#USER INPUT SECTION - REQUIRED MODEL BUILDING ACTIONS
#=========================================================================
# Create Template model (Section 4.2.1 of documentation)
builder = TemplateBuilder()
components = [
Component('y1', 1.6497, 4.09e-4),
Component('y2', 8.2262, 1.04e-3),
Component('y3', 0.0, 4.69e-4),
Component('y4', 0, 3.28e-4),
]
kinetic_parameters = [
KineticParameter('k1', (0.1, 5), 1.8934, 0.09),
KineticParameter('k2', (0.0, 5), 2.7585, 0.01),
KineticParameter('k-1', (0.0, 3000), 1754.0, 0.01),
KineticParameter('B1', (0.0, 2), 6.1894e-3, 0.01),
KineticParameter('B2', (0.0, 2), 0.0048, 0.01),
]
filename3 = os.path.join(dataDirectory,'Dij_multexp_no_G.txt')
D_frame1 = read_spectral_data_from_txt(filename1)
D_frame2 = read_spectral_data_from_txt(filename2)
D_frame3 = read_spectral_data_from_txt(filename3)
#This function can be used to remove a certain number of wavelengths from data
# in this case only every 2nd wavelength is included
# D_frame1 = decrease_wavelengths(D_frame1,A_set = 2)
#Here we add noise to datasets in order to make our data differenct between experiments
# D_frame2 = add_noise_to_signal(D_frame2, 0.00001)
# D_frame2 = decrease_wavelengths(D_frame2,A_set = 2)
#################################################################################
builder = TemplateBuilder()
components = {'A':0.01,'B':0,'C':0}
builder.add_mixture_component(components)
builder.add_parameter('k1', init=1.3, bounds=(0.0,2.0))
#There is also the option of providing initial values: Just add init=... as additional argument as above.
builder.add_parameter('k2', bounds=(0.0,0.5))
builder.add_qr_bounds_init(bounds = (0,None),init = 1.0)
builder.add_g_bounds_init(bounds = (0,None))
# If you have multiple experiments, you need to add your experimental datasets to a dictionary:
datasets = {'Exp1': D_frame1, 'Exp2': D_frame2, 'Exp3': D_frame3}
# Additionally, we do not add the spectral data to the TemplateBuilder, rather supplying the
# TemplateBuilder before data is added as an argument into the function
# define explicit system of ODEs
