trunk/pygtk/integrator.py

import ascpy
import time
import gtk
import gtk.glade
import time
from varentry import *
from preferences import *
from integratorreporter import *

class IntegratorError(RuntimeError):
    def __init__(self,msg):
        self.msg = msg
    def __str__(self):
        return "Input Error: %s" % self.msg;

class IntegratorWindow:
    def __init__(self,browser,sim):
        # create a new integrator straight away
        self.integrator = ascpy.Integrator(sim)
        self.engines = self.integrator.getEngines()

        self.browser=browser
        self.prefs = Preferences()

        # locate all the widgets
        _xml = gtk.glade.XML(browser.glade_file,"integratorwin")
        _xml.signal_autoconnect(self)

        self.window = _xml.get_widget("integratorwin")
        self.window.set_transient_for(self.browser.window)

        self.engineselect = _xml.get_widget("engineselect")
        self.beginentry = _xml.get_widget("beginentry")
        self.durationentry = _xml.get_widget("durationentry")
        self.nstepsentry = _xml.get_widget("nstepsentry")
        self.timedistributionselect = _xml.get_widget("timedistributionselect")

        self.settings = {
            # input field: [pref name, default value, export-to-integrator function]
            "initialstep": [1,lambda x:self.integrator.setInitialSubStep(float(x))]
            ,"minstep":[0.001,lambda x:self.integrator.setMinSubStep(float(x))]
            ,"maxstep":[1000,lambda x:self.integrator.setMaxSubStep(float(x))]
            ,"maxsteps":[100,lambda x:self.integrator.setMaxSubSteps(int(x))]
        }

        self.integratorentries={}
        for _k in self.settings.keys():
            _w = _xml.get_widget(_k+"entry")
            if not _w:
                raise RuntimeError("Couldn't find entry for"+_k)
            self.integratorentries[_k]=_w

        # fill values from user preferences, system values, etc
        self.fill_values()

    def fill_values(self):
        _enginestore = gtk.ListStore(str)
        self.engineselect.set_model(_enginestore)
        _cell = gtk.CellRendererText()
        self.engineselect.pack_start(_cell, True)
        self.engineselect.add_attribute(_cell, 'text', 1)
        
        _engpref = self.prefs.getStringPref("Integrator","engine","LSODE")
        _engindex = 0
        _i = 0
        if len(self.engines):
            for k in self.engines:
                _row = _enginestore.append()
                _enginestore.set(_row,0,self.engines[k])
                if self.engines[k]==_engpref:
                    _engindex=_i
                _i += 1

            # set preferred integrator  
            self.engineselect.set_active(_engindex)
            self.engineselect.set_sensitive(True)
        else:
            _row = _enginestore.append()
            _enginestore.set(_row,0,"No integrators available")
            self.engineselect.set_active(0)         
            self.engineselect.set_sensitive(False)


        # set preferred timesteps etc
        for _k,_v in self.settings.iteritems():
            self.integratorentries[_k].set_text(self.prefs.getStringPref("Integrator",_k,str(_v[0])))

        # get the current time value as the beginentry...
        print "SEARCHING FOR TIME VAR..."
        if self.integrator.findIndependentVar():
            print "FOUND time var..."   
            _t = self.integrator.getCurrentTime();
            print "Found time = %f" % _t
            self.beginentry.set_text(str(_t))
        else:
            self.browser.reporter.reportNote("No indep var found");
            self.beginentry.set_text("0")

        _dur = self.prefs.getStringPref("Integrator","duration","100")
        self.durationentry.set_text(_dur)
        self.nstepsentry.set_text("100")
        self.timedistributionselect.set_active(0)

    def on_integratorcancel_clicked(self,*args):
        self.browser.reporter.reportNote("CANCELLING");
        self.window.response(gtk.RESPONSE_CANCEL)

    def on_entry_key_press_event(self,widget,event):
        keyname = gtk.gdk.keyval_name(event.keyval)
        if keyname=="Return":
            self.window.response(gtk.RESPONSE_OK)
            return True
        elif keyname=="Escape":
            self.window.response(gtk.RESPONSE_CANCEL)
            return True;
        return False;

    def run(self):
        # focus the engine select box when we start...
        self.engineselect.grab_focus()

        # loop around unitil either cancelled or valid entries are input
        _ok = False
        while True:
            try:
                _res = self.window.run()
                if _res == gtk.RESPONSE_OK:
                    self.check_inputs()
                    _ok=True
                    break
                elif _res == gtk.RESPONSE_CANCEL or _res == gtk.RESPONSE_NONE:
                    self.browser.reporter.reportNote("CANCEL event received");
                    break
            except IntegratorError,e:
                self.browser.reporter.reportError(str(e))
                # continue

        if _ok:
            try:
                self.integrator.analyse()
            except RuntimeError,e:
                self.browser.reporter.reportError(str(e))
                return None                         
            # if we're all ok, create the reporter window and close this one
            _integratorreporter = IntegratorReporterPython(self.browser,self.integrator)
            self.integrator.setReporter(_integratorreporter)
            self.window.destroy()
            return _integratorreporter # means proceed to solve

        self.window.destroy()
        return None # can't solve

    def color_entry(self,entry,color):
        # colour an input box if it doesn't have acceptable contents
        # error messages would be reported by the 'errors panel' in the main win
        entry.modify_bg(gtk.STATE_NORMAL, gtk.gdk.color_parse(color))
        entry.modify_bg(gtk.STATE_ACTIVE, gtk.gdk.color_parse(color))
        entry.modify_base(gtk.STATE_NORMAL, gtk.gdk.color_parse(color))
        entry.modify_base(gtk.STATE_ACTIVE, gtk.gdk.color_parse(color))

    def check_inputs(self):
        # set the timesteps (samples)
        _val = {}
        for _k,_v in {
            self.beginentry:[lambda x:float(x),"begin"]
            , self.durationentry:[lambda x:float(x),"duration"]
            , self.nstepsentry:[lambda x:int(x),"num"]
        }.iteritems():
            _val[_v[1]]=_v[0](_k.get_text())
        
        self.integrator.setLinearTimesteps(ascpy.Units("s"), _val["begin"], (_val["begin"]+_val["duration"]), _val["num"]);
        self.begin=_val["begin"]
        self.duration=_val["duration"]

        self.prefs.setStringPref("Integrator","duration",str(self.duration))
        
        # set substep parameters (ie settings common to any integrator engine)
        _failed=False
        for _k,_v in self.settings.iteritems():
            try:
                _f = self.integratorentries[_k];
                # pass the substep setting to the integrator
                _v[1](_f.get_text())
                self.color_entry(_f,"white")
            except ValueError,e:
                self.color_entry(_f,"#FFBBBB")
                _failed=True
        
        if _failed:
            raise IntegratorError("Invalid step parameter(s)");

        for _k,_v in self.settings.iteritems():
            # store those inputs for next time
            _f = self.integratorentries[_k];
            self.prefs.setStringPref("Integrator",_k,str(_f.get_text()))

        # set engine (and check that it's OK with this system)
        engine=self.engineselect.get_active()
        if engine==-1:
            self.color_entry(self.engineselect,"#FFBBBB")
            raise IntegratorError("No engine selected")

        self.color_entry(self.engineselect,"white")

        self.prefs.setStringPref("Integrator","engine",self.engines.values()[engine])

        try:
            _res = self.integrator.setEngine(self.engines.keys()[engine])           
        except IndexError,e:
            raise IntegratorERror("Unable to set engine: %s",e) 
1	import ascpy
2	import time
3	import gtk
4	import gtk.glade
5	import time
6	from varentry import *
7	from preferences import *
8	from integratorreporter import *
9
10	class IntegratorError(RuntimeError):
11	def __init__(self,msg):
12	self.msg = msg
13	def __str__(self):
14	return "Input Error: %s" % self.msg;
15
16	class IntegratorWindow:
17	def __init__(self,browser,sim):
18	# create a new integrator straight away
19	self.integrator = ascpy.Integrator(sim)
20	self.engines = self.integrator.getEngines()
21
22	self.browser=browser
23	self.prefs = Preferences()
24
25	# locate all the widgets
26	_xml = gtk.glade.XML(browser.glade_file,"integratorwin")
27	_xml.signal_autoconnect(self)
28
29	self.window = _xml.get_widget("integratorwin")
30	self.window.set_transient_for(self.browser.window)
31
32	self.engineselect = _xml.get_widget("engineselect")
33	self.beginentry = _xml.get_widget("beginentry")
34	self.durationentry = _xml.get_widget("durationentry")
35	self.nstepsentry = _xml.get_widget("nstepsentry")
36	self.timedistributionselect = _xml.get_widget("timedistributionselect")
37
38	self.settings = {
39	# input field: [pref name, default value, export-to-integrator function]
40	"initialstep": [1,lambda x:self.integrator.setInitialSubStep(float(x))]
41	,"minstep":[0.001,lambda x:self.integrator.setMinSubStep(float(x))]
42	,"maxstep":[1000,lambda x:self.integrator.setMaxSubStep(float(x))]
43	,"maxsteps":[100,lambda x:self.integrator.setMaxSubSteps(int(x))]
44	}
45
46	self.integratorentries={}
47	for _k in self.settings.keys():
48	_w = _xml.get_widget(_k+"entry")
49	if not _w:
50	raise RuntimeError("Couldn't find entry for"+_k)
51	self.integratorentries[_k]=_w
52
53	# fill values from user preferences, system values, etc
54	self.fill_values()
55
56	def fill_values(self):
57	_enginestore = gtk.ListStore(str)
58	self.engineselect.set_model(_enginestore)
59	_cell = gtk.CellRendererText()
60	self.engineselect.pack_start(_cell, True)
61	self.engineselect.add_attribute(_cell, 'text', 1)
62
63	_engpref = self.prefs.getStringPref("Integrator","engine","LSODE")
64	_engindex = 0
65	_i = 0
66	if len(self.engines):
67	for k in self.engines:
68	_row = _enginestore.append()
69	_enginestore.set(_row,0,self.engines[k])
70	if self.engines[k]==_engpref:
71	_engindex=_i
72	_i += 1
73
74	# set preferred integrator
75	self.engineselect.set_active(_engindex)
76	self.engineselect.set_sensitive(True)
77	else:
78	_row = _enginestore.append()
79	_enginestore.set(_row,0,"No integrators available")
80	self.engineselect.set_active(0)
81	self.engineselect.set_sensitive(False)
82
83
84	# set preferred timesteps etc
85	for _k,_v in self.settings.iteritems():
86	self.integratorentries[_k].set_text(self.prefs.getStringPref("Integrator",_k,str(_v[0])))
87
88	# get the current time value as the beginentry...
89	print "SEARCHING FOR TIME VAR..."
90	if self.integrator.findIndependentVar():
91	print "FOUND time var..."
92	_t = self.integrator.getCurrentTime();
93	print "Found time = %f" % _t
94	self.beginentry.set_text(str(_t))
95	else:
96	self.browser.reporter.reportNote("No indep var found");
97	self.beginentry.set_text("0")
98
99	_dur = self.prefs.getStringPref("Integrator","duration","100")
100	self.durationentry.set_text(_dur)
101	self.nstepsentry.set_text("100")
102	self.timedistributionselect.set_active(0)
103
104	def on_integratorcancel_clicked(self,*args):
105	self.browser.reporter.reportNote("CANCELLING");
106	self.window.response(gtk.RESPONSE_CANCEL)
107
108	def on_entry_key_press_event(self,widget,event):
109	keyname = gtk.gdk.keyval_name(event.keyval)
110	if keyname=="Return":
111	self.window.response(gtk.RESPONSE_OK)
112	return True
113	elif keyname=="Escape":
114	self.window.response(gtk.RESPONSE_CANCEL)
115	return True;
116	return False;
117
118	def run(self):
119	# focus the engine select box when we start...
120	self.engineselect.grab_focus()
121
122	# loop around unitil either cancelled or valid entries are input
123	_ok = False
124	while True:
125	try:
126	_res = self.window.run()
127	if _res == gtk.RESPONSE_OK:
128	self.check_inputs()
129	_ok=True
130	break
131	elif _res == gtk.RESPONSE_CANCEL or _res == gtk.RESPONSE_NONE:
132	self.browser.reporter.reportNote("CANCEL event received");
133	break
134	except IntegratorError,e:
135	self.browser.reporter.reportError(str(e))
136	# continue
137
138	if _ok:
139	try:
140	self.integrator.analyse()
141	except RuntimeError,e:
142	self.browser.reporter.reportError(str(e))
143	return None
144	# if we're all ok, create the reporter window and close this one
145	_integratorreporter = IntegratorReporterPython(self.browser,self.integrator)
146	self.integrator.setReporter(_integratorreporter)
147	self.window.destroy()
148	return _integratorreporter # means proceed to solve
149
150	self.window.destroy()
151	return None # can't solve
152
153	def color_entry(self,entry,color):
154	# colour an input box if it doesn't have acceptable contents
155	# error messages would be reported by the 'errors panel' in the main win
156	entry.modify_bg(gtk.STATE_NORMAL, gtk.gdk.color_parse(color))
157	entry.modify_bg(gtk.STATE_ACTIVE, gtk.gdk.color_parse(color))
158	entry.modify_base(gtk.STATE_NORMAL, gtk.gdk.color_parse(color))
159	entry.modify_base(gtk.STATE_ACTIVE, gtk.gdk.color_parse(color))
160
161	def check_inputs(self):
162	# set the timesteps (samples)
163	_val = {}
164	for _k,_v in {
165	self.beginentry:[lambda x:float(x),"begin"]
166	, self.durationentry:[lambda x:float(x),"duration"]
167	, self.nstepsentry:[lambda x:int(x),"num"]
168	}.iteritems():
169	_val[_v[1]]=_v[0](_k.get_text())
170
171	self.integrator.setLinearTimesteps(ascpy.Units("s"), _val["begin"], (_val["begin"]+_val["duration"]), _val["num"]);
172	self.begin=_val["begin"]
173	self.duration=_val["duration"]
174
175	self.prefs.setStringPref("Integrator","duration",str(self.duration))
176
177	# set substep parameters (ie settings common to any integrator engine)
178	_failed=False
179	for _k,_v in self.settings.iteritems():
180	try:
181	_f = self.integratorentries[_k];
182	# pass the substep setting to the integrator
183	_v[1](_f.get_text())
184	self.color_entry(_f,"white")
185	except ValueError,e:
186	self.color_entry(_f,"#FFBBBB")
187	_failed=True
188
189	if _failed:
190	raise IntegratorError("Invalid step parameter(s)");
191
192	for _k,_v in self.settings.iteritems():
193	# store those inputs for next time
194	_f = self.integratorentries[_k];
195	self.prefs.setStringPref("Integrator",_k,str(_f.get_text()))
196
197	# set engine (and check that it's OK with this system)
198	engine=self.engineselect.get_active()
199	if engine==-1:
200	self.color_entry(self.engineselect,"#FFBBBB")
201	raise IntegratorError("No engine selected")
202
203	self.color_entry(self.engineselect,"white")
204
205	self.prefs.setStringPref("Integrator","engine",self.engines.values()[engine])
206
207	try:
208	_res = self.integrator.setEngine(self.engines.keys()[engine])
209	except IndexError,e:
210	raise IntegratorERror("Unable to set engine: %s",e)