def test_equation_scaling(self):
"""
test if user can set variable scaling.
"""
self.model.set('_residual_equation_scaling',1)
self.model.initialize()
extract_jmi_log('test_KINsolver_log.xml', self.log_file_name)
log = parse_jmi_log(self.log_file_name)
solves = gather_solves(log)
nose.tools.assert_false(N.array_equal(solves[0].block_solves[0].iterations[0].residual_scaling,
N.array([1., 1.])))
self.setUp()
self.model.set('_residual_equation_scaling',2)
self.model.initialize()
extract_jmi_log('test_KINsolver_log.xml', self.log_file_name)
log = parse_jmi_log(self.log_file_name)
solves = gather_solves(log)
nose.tools.assert_true(N.array_equal(solves[0].block_solves[0].iterations[0].residual_scaling,
N.array([1., 3.])))
self.setUp()
self.model.set('_residual_equation_scaling',0)
self.model.initialize()
extract_jmi_log('test_KINsolver_log.xml', self.log_file_name)
log = parse_jmi_log(self.log_file_name)
solves = gather_solves(log)
#residual scaling is not loged when turned off.
nose.tools.assert_false('residual_scaling' in solves[0].block_solves[0].iterations[0])
def test_equation_scaling(self):
"""
test if user can set variable scaling.
"""
self.setUp()
self.model.set('_residual_equation_scaling',1)
self.model.initialize()
log = parse_jmi_log(self.log_file_name)
solves = gather_solves(log)
result = solves[0].block_solves[0].iterations[0].residual_scaling
expected = N.array([1., 1.])
err_msg = "Arrays are supposed to be different but are actually equal. Result={}\nExpected={}".format(result, expected)
assert not N.allclose(result, expected), err_msg
# self.setUp()
# self.model.set('_residual_equation_scaling',2)
# self.model.initialize()
# extract_jmi_log('test_KINsolver_log.xml', self.log_file_name)
# log = parse_jmi_log(self.log_file_name)
# solves = gather_solves(log)
# nose.tools.assert_true(N.array_equal(solves[0].block_solves[0].iterations[0].residual_scaling,
# N.array([1., 3.])))
self.setUp('test_KINsolver_options_log_res0.txt')
self.model.set('_residual_equation_scaling',0)
self.model.initialize()
log = parse_jmi_log(self.log_file_name)
solves = gather_solves(log)
#residual scaling is not logged when turned off.
condition = 'residual_scaling' in solves[0].block_solves[0].iterations[0]
assert not condition, "Test failed because string residual_scaling was found in {}".format(solves[0].block_solves[0].iterations[0])
def test_equation_scaling(self):
"""
test if user can set variable scaling.
"""
self.model.set('_residual_equation_scaling', 1)
self.model.initialize()
extract_jmi_log('test_KINsolver_log.xml', self.log_file_name)
log = parse_jmi_log(self.log_file_name)
solves = gather_solves(log)
nose.tools.assert_false(
N.array_equal(
solves[0].block_solves[0].iterations[0].residual_scaling,
N.array([1., 1.])))
# self.setUp()
# self.model.set('_residual_equation_scaling',2)
# self.model.initialize()
# extract_jmi_log('test_KINsolver_log.xml', self.log_file_name)
# log = parse_jmi_log(self.log_file_name)
# solves = gather_solves(log)
# nose.tools.assert_true(N.array_equal(solves[0].block_solves[0].iterations[0].residual_scaling,
# N.array([1., 3.])))
self.setUp()
self.model.set('_residual_equation_scaling', 0)
self.model.initialize()
extract_jmi_log('test_KINsolver_log.xml', self.log_file_name)
log = parse_jmi_log(self.log_file_name)
solves = gather_solves(log)
#residual scaling is not logged when turned off.
nose.tools.assert_false(
'residual_scaling' in solves[0].block_solves[0].iterations[0])
def test_log_file(self):
"""
Test that the log file is parsable
"""
self.m.set('u1', 3)
self.m.get('u1')
self.m.set('y1', 0.)
self.m.initialize()
self.m.get('u1')
self.m.set('u1', 4)
self.m.get('u1')
self.m.get_derivatives()
self.m.set('y1', 0.5)
self.m.get('x1')
self.m.set('p', 0.5)
self.m.get('x1')
d = gather_solves(parse_jmi_log('LoggerTest_log.txt'))
assert len(d) == 7, "Unexpected number of solver invocations"
assert len(
d[0]['block_solves']
) == 4, "Unexpected number of block solves in first iteration"
def test_parse_log_file(self):
"""
Test that a pregenerated log file is parsable
"""
log = parse_jmi_log(
os.path.join(path_to_fmu_logs, 'LoggerTest_log.txt'))
assert log.find("EquationSolve")[0].t == 0.0
d = gather_solves(log)
assert len(d) == 8, "Unexpected number of solver invocations"
assert d[0].t == 0.0
assert len(
d[0].block_solves
) == 4, "Unexpected number of block solves in first iteration"
vars = d[0].block_solves[0].variables
assert len(vars) == 3
assert all(vars == N.asarray(['x1', 'z1', 'y1']))
assert N.array_equiv(
d[0].block_solves[0].min,
N.asarray([
-1.7976931348623157E+308, -1.7976931348623157E+308,
-1.7976931348623157E+308
]))
assert N.array_equiv(
d[0].block_solves[0].max,
N.asarray([
1.7976931348623157E+308, 1.7976931348623157E+308,
1.7976931348623157E+308
]))
assert N.array_equiv(d[0].block_solves[0].initial_residual_scaling,
N.asarray([4.0, 1.0, 1.0]))
assert len(d[0].block_solves[0].iterations) == 12
assert N.array_equiv(d[0].block_solves[0].iterations[0].ivs,
N.asarray([0.0, 0.0, 1.4901161193847656E-08]))
assert N.array_equiv(
d[0].block_solves[0].iterations[0].residuals,
N.asarray([-1.25, 1.1999999985098839E+01, 2.9999999850988388E+00]))
assert N.array_equiv(
d[0].block_solves[0].iterations[0].jacobian,
N.asarray([[-1.0, 4.0, 0.0], [-1.0, -1.0, -1.0], [-1.0, 1.0,
-1.0]]))
assert d[0].block_solves[0].iterations[0].jacobian_updated == True
assert N.array_equiv(
d[0].block_solves[0].iterations[0].residual_scaling,
N.asarray([4.0, 1.0, 1.0]))
assert d[0].block_solves[0].iterations[
0].residual_scaling_updated == False
nose.tools.assert_almost_equal(
d[0].block_solves[0].iterations[0].scaled_residual_norm,
1.2432316741177614E+01)
def test_debbug_solution(self):
"""
That the correct solution is stored in the debug file.
"""
self.model.initialize()
extract_jmi_log('test_KINsolver_log.xml', self.log_file_name)
log = parse_jmi_log(self.log_file_name)
solves = gather_solves(log)
N.testing.assert_array_almost_equal(solves[0].block_solves[0].iterations[-1].ivs, N.array([N.sqrt(11), 5. ]))
def test_variable_scaling(self):
"""
test if user can set variable scaling.
"""
self.model.set('_iteration_variable_scaling', 0)
self.model.initialize()
extract_jmi_log('test_KINsolver_log.xml', self.log_file_name)
log = parse_jmi_log(self.log_file_name)
solves = gather_solves(log)
nose.tools.assert_true(N.array_equal(solves[0].block_solves[0].nominal,
N.array([1.,1.])))
def test_debug_solution(self):
"""
That the correct solution is stored in the debug file.
"""
self.model.initialize()
extract_jmi_log('test_KINsolver_log.xml', self.log_file_name)
log = parse_jmi_log(self.log_file_name)
solves = gather_solves(log)
N.testing.assert_array_almost_equal(
solves[0].block_solves[0].iterations[-1].ivs,
N.array([N.sqrt(11), 5.]))
def test_variable_scaling(self):
"""
test if user can set variable scaling.
"""
self.model.set('_iteration_variable_scaling', 0)
self.model.initialize()
extract_jmi_log('test_KINsolver_log.xml', self.log_file_name)
log = parse_jmi_log(self.log_file_name)
solves = gather_solves(log)
nose.tools.assert_true(
N.array_equal(solves[0].block_solves[0].nominal, N.array([1.,
1.])))
def test_debug_solution(self):
"""
That the correct solution is stored in the debug file.
"""
self.setUp()
self.model.initialize()
extract_jmi_log('test_KINsolver_log.xml', self.log_file_name)
log = parse_jmi_log(self.log_file_name)
solves = gather_solves(log)
result = solves[0].block_solves[0].iterations[-1].ivs
expected = N.array([N.sqrt(11), 5. ])
err_msg = "Arrays are not almost equal:\nEXPECTED: {}\nACTUAL: {}".format(expected, result)
N.testing.assert_array_almost_equal(result, expected, err_msg=err_msg)
def test_debug_solution(self):
"""
That the correct solution is stored in the debug file.
"""
self.setUp()
self.model.initialize()
extract_jmi_log('test_KINsolver_log.xml', self.log_file_name)
log = parse_jmi_log(self.log_file_name)
solves = gather_solves(log)
result = solves[0].block_solves[0].iterations[-1].ivs
expected = N.array([N.sqrt(11), 5. ])
err_msg = "Arrays not equal, expected {} but got {}".format(expected, result)
assert N.allclose(result, expected), err_msg
def test_variable_scaling(self):
"""
test if user can set variable scaling.
"""
self.setUp()
self.model.set('_iteration_variable_scaling', 0)
self.model.initialize()
extract_jmi_log('test_KINsolver_log.xml', self.log_file_name)
log = parse_jmi_log(self.log_file_name)
solves = gather_solves(log)
result = solves[0].block_solves[0].nominal
expected = N.array([1.,1.])
err_msg = "Arrays not equal, expected {} but got {}".format(expected, result)
assert N.allclose(result, expected), err_msg
def test_debug_file(self):
"""
That the correct amount of debug info is created.
"""
self.setUp()
self.model.set_debug_logging(True)
self.model.set('_log_level',1)
self.model.initialize()
extract_jmi_log('test_KINsolver_log.xml', self.log_file_name)
log = parse_jmi_log(self.log_file_name)
solves = gather_solves(log)
assert not solves, "Failed in assert (1/6) because list is not empty, got solves={}".format(solves)
self.setUp()
self.model.set('_log_level',2)
self.model.initialize()
extract_jmi_log('test_KINsolver_log.xml', self.log_file_name)
log = parse_jmi_log(self.log_file_name)
solves = gather_solves(log)
assert not solves, "Failed in assert (2/6) because list is not empty, got solves={}".format(solves)
self.setUp()
self.model.set('_log_level',3)
self.model.initialize()
extract_jmi_log('test_KINsolver_log.xml', self.log_file_name)
log = parse_jmi_log(self.log_file_name)
solves = gather_solves(log)
assert not solves, "Failed in assert (3/6) because list is not empty, got solves={}".format(solves)
self.setUp()
self.model.set('_log_level',4)
self.model.initialize()
extract_jmi_log('test_KINsolver_log.xml', self.log_file_name)
log = parse_jmi_log(self.log_file_name)
solves = gather_solves(log)
assert not solves, "Failed in assert (4/6) because list is not empty, got solves={}".format(solves)
self.setUp()
self.model.set('_log_level',5)
self.model.initialize()
extract_jmi_log('test_KINsolver_log.xml', self.log_file_name)
log = parse_jmi_log(self.log_file_name)
solves = gather_solves(log)
assert len(solves) == 4, "Failed in assert (5/6) because result is not of length 4, got solves={}, with length {}".format(solves, len(solves))
self.setUp()
self.model.set('_log_level',6)
self.model.initialize()
extract_jmi_log('test_KINsolver_log.xml', self.log_file_name)
log = parse_jmi_log(self.log_file_name)
solves = gather_solves(log)
assert len(solves) == 4, "Failed in assert (6/6) because result is not of length 4, got solves={}, with length {}".format(solves, len(solves))
def test_debbug_file(self):
"""
That the correct amount of debug info is created.
"""
self.model.set_debug_logging(True)
self.model.set('_log_level',1)
self.model.initialize()
extract_jmi_log('test_KINsolver_log.xml', self.log_file_name)
log = parse_jmi_log(self.log_file_name)
solves = gather_solves(log)
nose.tools.assert_equals(solves, [])
self.setUp()
self.model.set('_log_level',2)
self.model.initialize()
extract_jmi_log('test_KINsolver_log.xml', self.log_file_name)
log = parse_jmi_log(self.log_file_name)
solves = gather_solves(log)
nose.tools.assert_equals(solves, [])
self.setUp()
self.model.set('_log_level',3)
self.model.initialize()
extract_jmi_log('test_KINsolver_log.xml', self.log_file_name)
log = parse_jmi_log(self.log_file_name)
solves = gather_solves(log)
nose.tools.assert_equals(solves, [])
self.setUp()
self.model.set('_log_level',4)
self.model.initialize()
extract_jmi_log('test_KINsolver_log.xml', self.log_file_name)
log = parse_jmi_log(self.log_file_name)
solves = gather_solves(log)
nose.tools.assert_equals(solves, [])
self.setUp()
self.model.set('_log_level',5)
self.model.initialize()
extract_jmi_log('test_KINsolver_log.xml', self.log_file_name)
log = parse_jmi_log(self.log_file_name)
solves = gather_solves(log)
nose.tools.assert_equals(len(solves), 3)
self.setUp()
self.model.set('_log_level',6)
self.model.initialize()
extract_jmi_log('test_KINsolver_log.xml', self.log_file_name)
log = parse_jmi_log(self.log_file_name)
solves = gather_solves(log)
nose.tools.assert_equals(len(solves), 3)
def test_debbug_file(self):
"""
That the correct amount of debug info is created.
"""
self.model.set_debug_logging(True)
self.model.set('_log_level', 1)
self.model.initialize()
extract_jmi_log('test_KINsolver_log.xml', self.log_file_name)
log = parse_jmi_log(self.log_file_name)
solves = gather_solves(log)
nose.tools.assert_equals(solves, [])
self.setUp()
self.model.set('_log_level', 2)
self.model.initialize()
extract_jmi_log('test_KINsolver_log.xml', self.log_file_name)
log = parse_jmi_log(self.log_file_name)
solves = gather_solves(log)
nose.tools.assert_equals(solves, [])
self.setUp()
self.model.set('_log_level', 3)
self.model.initialize()
extract_jmi_log('test_KINsolver_log.xml', self.log_file_name)
log = parse_jmi_log(self.log_file_name)
solves = gather_solves(log)
nose.tools.assert_equals(solves, [])
self.setUp()
self.model.set('_log_level', 4)
self.model.initialize()
extract_jmi_log('test_KINsolver_log.xml', self.log_file_name)
log = parse_jmi_log(self.log_file_name)
solves = gather_solves(log)
nose.tools.assert_equals(solves, [])
self.setUp()
self.model.set('_log_level', 5)
self.model.initialize()
extract_jmi_log('test_KINsolver_log.xml', self.log_file_name)
log = parse_jmi_log(self.log_file_name)
solves = gather_solves(log)
nose.tools.assert_equals(len(solves), 4)
self.setUp()
self.model.set('_log_level', 6)
self.model.initialize()
extract_jmi_log('test_KINsolver_log.xml', self.log_file_name)
log = parse_jmi_log(self.log_file_name)
solves = gather_solves(log)
nose.tools.assert_equals(len(solves), 4)
def test_parse_log_file(self):
"""
Test that a pregenerated log file is parsable
"""
log = parse_jmi_log(os.path.join(path_to_fmu_logs, 'LoggerTest_log.txt'))
assert log.find("EquationSolve")[0].t == 0.0
d = gather_solves(log)
assert len(d)==8, "Unexpected number of solver invocations"
assert d[0].t==0.0
assert len(d[0].block_solves)==4, "Unexpected number of block solves in first iteration"
vars = d[0].block_solves[0].variables
assert len(vars)==3
assert all(vars==N.asarray(['x1', 'z1', 'y1']))
assert N.array_equiv( d[0].block_solves[0].min,
N.asarray([-1.7976931348623157E+308, -1.7976931348623157E+308, -1.7976931348623157E+308]) )
assert N.array_equiv( d[0].block_solves[0].max,
N.asarray([ 1.7976931348623157E+308, 1.7976931348623157E+308, 1.7976931348623157E+308]) )
assert N.array_equiv( d[0].block_solves[0].initial_residual_scaling,
N.asarray([4.0, 1.0, 1.0]) )
assert len(d[0].block_solves[0].iterations)==12
assert N.array_equiv( d[0].block_solves[0].iterations[0].ivs,
N.asarray([0.0, 0.0, 1.4901161193847656E-08]) )
assert N.array_equiv( d[0].block_solves[0].iterations[0].residuals,
N.asarray([-1.25, 1.1999999985098839E+01, 2.9999999850988388E+00]) )
assert N.array_equiv( d[0].block_solves[0].iterations[0].jacobian,
N.asarray([[-1.0, 4.0, 0.0],
[-1.0, -1.0, -1.0],
[-1.0, 1.0, -1.0]]) )
assert d[0].block_solves[0].iterations[0].jacobian_updated==True
assert N.array_equiv( d[0].block_solves[0].iterations[0].residual_scaling,
N.asarray([ 4.0, 1.0, 1.0]) )
assert d[0].block_solves[0].iterations[0].residual_scaling_updated==False
nose.tools.assert_almost_equal( d[0].block_solves[0].iterations[0].scaled_residual_norm,
1.2432316741177614E+01 )
def test_debug_file(self):
"""
That the correct amount of debug info is created.
"""
self.model.set_debug_logging(True)
self.model.set('_log_level', 1)
self.model.initialize()
log = parse_jmi_log(self.log_file_name)
solves = gather_solves(log)
nose.tools.assert_equals(solves, [])
self.setUp('test_KINsolver_options_log_ll2.txt')
self.model.set('_log_level', 2)
self.model.initialize()
log = parse_jmi_log(self.log_file_name)
solves = gather_solves(log)
nose.tools.assert_equals(solves, [])
self.setUp('test_KINsolver_options_log_ll3.txt')
self.model.set('_log_level', 3)
self.model.initialize()
log = parse_jmi_log(self.log_file_name)
solves = gather_solves(log)
nose.tools.assert_equals(solves, [])
self.setUp('test_KINsolver_options_log_ll4.txt')
self.model.set('_log_level', 4)
self.model.initialize()
log = parse_jmi_log(self.log_file_name)
solves = gather_solves(log)
nose.tools.assert_equals(solves, [])
self.setUp('test_KINsolver_options_log_ll5.txt')
self.model.set('_log_level', 5)
self.model.initialize()
log = parse_jmi_log(self.log_file_name)
solves = gather_solves(log)
nose.tools.assert_equals(len(solves), 2)
self.setUp('test_KINsolver_options_log_ll6.txt')
self.model.set('_log_level', 6)
self.model.initialize()
log = parse_jmi_log(self.log_file_name)
solves = gather_solves(log)
print solves
nose.tools.assert_equals(len(solves), 2)
def test_log_file(self):
"""
Test that the log file is parsable
"""
self.m.set('u1',3)
self.m.get('u1')
self.m.set('y1',0.)
self.m.initialize()
self.m.get('u1')
self.m.set('u1',4)
self.m.get('u1')
self.m.get_derivatives()
self.m.set('y1',0.5)
self.m.get('x1')
self.m.set('p',0.5)
self.m.get('x1')
d = gather_solves(parse_jmi_log('LoggerTest_log.txt'))
assert len(d)==7, "Unexpected number of solver invocations"
assert len(d[0]['block_solves'])==4, "Unexpected number of block solves in first iteration"
def run_demo():
"""
Demonstrate how to parse a log file from a JModelica FMU.
"""
curr_dir = os.path.dirname(os.path.abspath(__file__));
file_name = os.path.join(curr_dir, 'files', 'LoggerTest.mo')
fmu_name = compile_fmu('LoggerTest', file_name, compiler_log_level='i',
compiler_options={'generate_only_initial_system':True})
log_file_name='LoggerTest_log.txt'
m = load_fmu(fmu_name, log_file_name=log_file_name)
m.set_debug_logging(True)
m.set('_log_level', 6)
m.set_fmil_log_level(5)
# Play around with the model
m.set('u1',3)
print 'u1' + str(m.get('u1'))
print 'x1' + str(m.get('x1'))
print 'y1' + str(m.get('y1'))
print 'z1' + str(m.get('z1'))
m.set('y1',0.)
m.initialize()
print "model initialized"
print 'u1' + str(m.get('u1'))
print 'x1' + str(m.get('x1'))
print 'y1' + str(m.get('y1'))
print 'z1' + str(m.get('z1'))
m.set('u1',4)
print "Input set"
print 'u1' + str(m.get('u1'))
print 'x1' + str(m.get('x1'))
print 'y1' + str(m.get('y1'))
print 'z1' + str(m.get('z1'))
m.get_derivatives()
m.set('y1',0.5)
print "Set initial value of y1"
print 'x1' + str(m.get('x1'))
print 'y1' + str(m.get('y1'))
print 'z1' + str(m.get('z1'))
m.set('p',0.5)
print "Set initial value of p"
print 'x1' + str(m.get('x1'))
print 'y1' + str(m.get('y1'))
print 'z1' + str(m.get('z1'))
# Parse the log file and print some of its contents
# Extract the log file XML contents into a pure XML file
dest_xml_file_name = 'LoggerTest_log.xml'
extract_jmi_log(dest_xml_file_name, log_file_name)
# Parse the entire XML log
log = parse_jmi_log(log_file_name)
print
print 'Top log node: log =', log
print 'Unnamed sub nodes: log.nodes = ['
for node in log.nodes:
print ' ', node, ','
print ']'
print 'Time of first solve: log.nodes[0].t =', log.nodes[0].t
# Gather information pertaining to equation solves
solves = gather_solves(log)
print
print 'Number of solver invocations:', len(solves)
print 'Time of first solve:', solves[0].t
print 'Number of block solves in first solver invocation:', len(solves[0].block_solves)
print 'Names of iteration variables in first block solve:', solves[0].block_solves[0].variables
print 'Min bounds in first block solve:', solves[0].block_solves[0].min
print 'Max bounds in first block solve:', solves[0].block_solves[0].max
print 'Initial residual scaling in first block solve:', solves[0].block_solves[0].initial_residual_scaling
print 'Number of iterations in first block solve:', len(solves[0].block_solves[0].iterations)
print
print 'First iteration in first block solve: '
print ' Iteration variables:', solves[0].block_solves[0].iterations[0].ivs
print ' Scaled residuals:', solves[0].block_solves[0].iterations[0].residuals
print ' Jacobian:\n', solves[0].block_solves[0].iterations[0].jacobian
print ' Jacobian updated in iteration:', solves[0].block_solves[0].iterations[0].jacobian_updated
print ' Residual scaling factors:', solves[0].block_solves[0].iterations[0].residual_scaling
print ' Residual scaling factors_updated:', solves[0].block_solves[0].iterations[0].residual_scaling_updated
print ' Scaled residual norm:', solves[0].block_solves[0].iterations[0].scaled_residual_norm
def run_demo():
"""
Demonstrate how to parse a log file from a JModelica FMU.
"""
curr_dir = os.path.dirname(os.path.abspath(__file__))
file_name = os.path.join(curr_dir, 'files', 'LoggerTest.mo')
fmu_name = compile_fmu(
'LoggerTest',
file_name,
compiler_log_level='i',
compiler_options={'generate_only_initial_system': True})
log_file_name = 'LoggerTest_log.txt'
m = load_fmu(fmu_name, log_file_name=log_file_name)
m.set_debug_logging(True)
m.set('_log_level', 6)
m.set_fmil_log_level(5)
# Play around with the model
m.set('u1', 3)
print('u1' + str(m.get('u1')))
print('x1' + str(m.get('x1')))
print('y1' + str(m.get('y1')))
print('z1' + str(m.get('z1')))
m.set('y1', 0.)
m.initialize()
print("model initialized")
print('u1' + str(m.get('u1')))
print('x1' + str(m.get('x1')))
print('y1' + str(m.get('y1')))
print('z1' + str(m.get('z1')))
m.set('u1', 4)
print("Input set")
print('u1' + str(m.get('u1')))
print('x1' + str(m.get('x1')))
print('y1' + str(m.get('y1')))
print('z1' + str(m.get('z1')))
m.get_derivatives()
m.set('y1', 0.5)
print("Set initial value of y1")
print('x1' + str(m.get('x1')))
print('y1' + str(m.get('y1')))
print('z1' + str(m.get('z1')))
m.set('p', 0.5)
print("Set initial value of p")
print('x1' + str(m.get('x1')))
print('y1' + str(m.get('y1')))
print('z1' + str(m.get('z1')))
# Parse the log file and print some of its contents
# Extract the log file XML contents into a pure XML file
dest_xml_file_name = 'LoggerTest_log.xml'
extract_jmi_log(dest_xml_file_name, log_file_name)
# Parse the entire XML log
log = parse_jmi_log(log_file_name)
print()
print('Top log node: log =', log)
print('Unnamed sub nodes: log.nodes = [')
for node in log.nodes:
print(' ', node, ',')
print(']')
# Gather information pertaining to equation solves
solves = gather_solves(log)
print()
print('Number of solver invocations:', len(solves))
print('Time of first solve:', solves[0].t)
print('Number of block solves in first solver invocation:',
len(solves[0].block_solves))
print('Names of iteration variables in first block solve:',
solves[0].block_solves[0].variables)
print('Min bounds in first block solve:', solves[0].block_solves[0].min)
print('Max bounds in first block solve:', solves[0].block_solves[0].max)
print('Initial residual scaling in first block solve:',
solves[0].block_solves[0].initial_residual_scaling)
print('Number of iterations in first block solve:',
len(solves[0].block_solves[0].iterations))
print()
print('First iteration in first block solve: ')
print(' Iteration variables:',
solves[0].block_solves[0].iterations[0].ivs)
print(' Scaled residuals:',
solves[0].block_solves[0].iterations[0].scaled_residuals)
print(' Jacobian:\n', solves[0].block_solves[0].iterations[0].jacobian)
print(' Jacobian updated in iteration:',
solves[0].block_solves[0].iterations[0].jacobian_updated)
print(' Residual scaling factors:',
solves[0].block_solves[0].iterations[0].residual_scaling)
print(' Residual scaling factors_updated:',
solves[0].block_solves[0].iterations[0].residual_scaling_updated)
print(' Scaled residual norm:',
solves[0].block_solves[0].iterations[0].scaled_residual_norm)
def run_demo(with_plots=True):
"""
This example demonstrates how to initialize with and without active
boundaries. The iterations are displaied graphically together with
the boundaries.
"""
curr_dir = os.path.dirname(os.path.abspath(__file__));
fpath = os.path.join(curr_dir, 'files', 'BoundsDemo.mo')
print(fpath)
compile_fmu('BoundsDemo', fpath)
log_file_name='files/bounds_kinsol.txt'
m = load_fmu('BoundsDemo.fmu', log_file_name=log_file_name)
m.set_debug_logging(True)
m.set_fmil_log_level(5)
m.set('_log_level',5)
m.set('_nle_solver_log_level',3)
m.set('_enforce_bounds',False)
try:
m.initialize()
print 'Initialized OK'
except:
print 'Error in initialize'
# Parse the entire XML log
log = parse_jmi_log(log_file_name)
# Gather information pertaining to equation solves
solves = gather_solves(log)
print 'Number of iterations in solver without bounds:',\
len(solves[0].block_solves[0].iterations), '+', len(solves[0].block_solves[1].iterations)
print 'Solution: x_1=', m.get('x_1'),' x_2=', m.get('x_2')
nbr_iterations = len(solves[0].block_solves[0].iterations)
iteration_points = numpy.zeros(shape=(nbr_iterations,2))
for i in xrange(nbr_iterations):
iteration_points[i] = solves[0].block_solves[0].iterations[i].ivs
if with_plots:
#Plot the iterations
iteration_points_dx = diff(iteration_points[:, 0])
iteration_points_dy = diff(iteration_points[:, 1])
Q = quiver(iteration_points[0:-1,0], iteration_points[0:-1,1],
iteration_points_dx, iteration_points_dy,scale_units='xy',
angles='xy', scale=1, width=0.005, color='k')
quiverkey(Q,4,8,1,"Iteration without active bounds",coordinates='data',color='k')
m = load_fmu('BoundsDemo.fmu', log_file_name=log_file_name)
m.set_debug_logging(True)
m.set_fmil_log_level(5)
m.set('_log_level',5)
m.set('_nle_solver_log_level',3)
m.set('_enforce_bounds',True)
try:
m.initialize()
print 'Initialized OK'
except:
print 'Error in initialize'
# Parse the entire XML log
log = parse_jmi_log(log_file_name)
# Gather information pertaining to equation solves
solves = gather_solves(log)
print 'Number of iterations in solver with bounds:',\
len(solves[0].block_solves[0].iterations), '+', len(solves[0].block_solves[1].iterations)
print 'Solution: x_1=', m.get('x_1'),' x_2=', m.get('x_2')
nbr_iterations = len(solves[0].block_solves[0].iterations)
iteration_points = numpy.zeros(shape=(nbr_iterations,2))
for i in xrange(nbr_iterations):
iteration_points[i] = solves[0].block_solves[0].iterations[i].ivs
if with_plots:
#Plot the iterations
iteration_points_dx = diff(iteration_points[:, 0])
iteration_points_dy = diff(iteration_points[:, 1])
Q = quiver(iteration_points[0:-1,0], iteration_points[0:-1,1],
iteration_points_dx, iteration_points_dy,scale_units='xy',
angles='xy', scale=1, width=0.005, color='red', label='test')
quiverkey(Q,4,7,1,"Iteration with active bounds",coordinates='data',color='r')
#Plot the boundaries
plot([-4, 4, 4, -4, -4], [-6, -6, 6, 6, -6], color='k')
xlim([-5,7])
ylim([-7,9])
#Plot the contours
x = arange(-5,7,0.1)
y = arange(-7,9,0.1)
X,Y = meshgrid(x, y)
Z = (X**2 + Y**2 - 25)**2 + ((X - 5)**2 + (Y - 2)**2 - 4)**2
contour_levels = [4**n for n in xrange(1,6)]
contour(X,Y,Z, contour_levels, colors='b')
show()
def run_demo(with_plots=True):
"""
This example demonstrates how to initialize with and without active
boundaries. The iterations are displaied graphically together with
the boundaries.
"""
curr_dir = os.path.dirname(os.path.abspath(__file__))
fpath = os.path.join(curr_dir, 'files', 'BoundsDemo.mo')
print(fpath)
compile_fmu('BoundsDemo', fpath)
log_file_name = 'files/bounds_kinsol.txt'
m = load_fmu('BoundsDemo.fmu', log_file_name=log_file_name)
m.set_debug_logging(True)
m.set_fmil_log_level(5)
m.set('_log_level', 5)
m.set('_nle_solver_log_level', 3)
m.set('_enforce_bounds', False)
try:
m.initialize()
print 'Initialized OK'
except:
print 'Error in initialize'
# Parse the entire XML log
log = parse_jmi_log(log_file_name)
# Gather information pertaining to equation solves
solves = gather_solves(log)
print 'Number of iterations in solver without bounds:',\
len(solves[0].block_solves[0].iterations), '+', len(solves[0].block_solves[1].iterations)
print 'Solution: x_1=', m.get('x_1'), ' x_2=', m.get('x_2')
nbr_iterations = len(solves[0].block_solves[0].iterations)
iteration_points = numpy.zeros(shape=(nbr_iterations, 2))
for i in xrange(nbr_iterations):
iteration_points[i] = solves[0].block_solves[0].iterations[i].ivs
if with_plots:
#Plot the iterations
iteration_points_dx = diff(iteration_points[:, 0])
iteration_points_dy = diff(iteration_points[:, 1])
Q = quiver(iteration_points[0:-1, 0],
iteration_points[0:-1, 1],
iteration_points_dx,
iteration_points_dy,
scale_units='xy',
angles='xy',
scale=1,
width=0.005,
color='k')
quiverkey(Q,
4,
8,
1,
"Iteration without active bounds",
coordinates='data',
color='k')
m = load_fmu('BoundsDemo.fmu', log_file_name=log_file_name)
m.set_debug_logging(True)
m.set_fmil_log_level(5)
m.set('_log_level', 5)
m.set('_nle_solver_log_level', 3)
m.set('_enforce_bounds', True)
try:
m.initialize()
print 'Initialized OK'
except:
print 'Error in initialize'
# Parse the entire XML log
log = parse_jmi_log(log_file_name)
# Gather information pertaining to equation solves
solves = gather_solves(log)
print 'Number of iterations in solver with bounds:',\
len(solves[0].block_solves[0].iterations), '+', len(solves[0].block_solves[1].iterations)
print 'Solution: x_1=', m.get('x_1'), ' x_2=', m.get('x_2')
nbr_iterations = len(solves[0].block_solves[0].iterations)
iteration_points = numpy.zeros(shape=(nbr_iterations, 2))
for i in xrange(nbr_iterations):
iteration_points[i] = solves[0].block_solves[0].iterations[i].ivs
if with_plots:
#Plot the iterations
iteration_points_dx = diff(iteration_points[:, 0])
iteration_points_dy = diff(iteration_points[:, 1])
Q = quiver(iteration_points[0:-1, 0],
iteration_points[0:-1, 1],
iteration_points_dx,
iteration_points_dy,
scale_units='xy',
angles='xy',
scale=1,
width=0.005,
color='red',
label='test')
quiverkey(Q,
4,
7,
1,
"Iteration with active bounds",
coordinates='data',
color='r')
#Plot the boundaries
plot([-4, 4, 4, -4, -4], [-6, -6, 6, 6, -6], color='k')
xlim([-5, 7])
ylim([-7, 9])
#Plot the contours
x = arange(-5, 7, 0.1)
y = arange(-7, 9, 0.1)
X, Y = meshgrid(x, y)
Z = (X**2 + Y**2 - 25)**2 + ((X - 5)**2 + (Y - 2)**2 - 4)**2
contour_levels = [4**n for n in xrange(1, 6)]
contour(X, Y, Z, contour_levels, colors='b')
show()
