trunk/pygtk/integratorreporter.py

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

from observer import *

# When writing this class, we assume that the integrator class has already had
# its "analyse" method called, so we know all that stuff like the number of
# observed variables, what our time samples are, what the independent variable 
# is, etc.

INTEGRATOR_NUM = 0

class IntegratorReporterPython(ascpy.IntegratorReporterCxx):
    def __init__(self,browser,integrator):
        self.browser=browser
        ascpy.IntegratorReporterCxx.__init__(self,integrator)
        
        # GUI elements
        _xml = gtk.glade.XML(browser.glade_file,"integratorstatusdialog")
        _xml.signal_autoconnect(self)
        self.window=_xml.get_widget("integratorstatusdialog")
        self.window.set_transient_for(self.browser.window)
        self.label=_xml.get_widget("integratorlabel")
        self.label.set_text("Solving with "+self.getIntegrator().getEngineName())
        self.progress=_xml.get_widget("integratorprogress")
        self.data = None

        self.cancelrequested=False

    def run(self):
        # run the dialog: start solution, monitor use events
        try:
            self.getIntegrator().solve()
        except RuntimeError,e:
            self.browser.reporter.reportError("Integrator failed: %s" % e)
        self.window.destroy()
        return

    def on_cancelbutton_clicked(self,*args):
        self.cancelrequested=True

    def initOutput(self):
        # empty out the data table
        self.data=[]
        self.nsteps = self.getIntegrator().getNumSteps()
        self.progress.set_text("Starting...")
        self.progress.set_fraction(0.0)
        #update the GUI
        while gtk.events_pending():
            gtk.main_iteration()
        return 1

    def closeOutput(self):
        global INTEGRATOR_NUM
        integrator = self.getIntegrator()
        # create an empty observer
        try:
            _xml = gtk.glade.XML(self.browser.glade_file,"observervbox")
            _label = gtk.Label();
            INTEGRATOR_NUM = INTEGRATOR_NUM + 1
            _name = "Integrator %d" % INTEGRATOR_NUM
            _tab = self.browser.maintabs.append_page(_xml.get_widget("observervbox"),_label)
            _obs = ObserverTab(xml=_xml, name=_name, browser=self.browser, tab=_tab, alive=False)
            _label.set_text(_obs.name)
            self.browser.observers.append(_obs)
            self.browser.tabs[_tab]=_obs
            
            # add the columns
            _obs.add_instance(integrator.getIndependentVariable().getInstance())
            for _v in [integrator.getObservedVariable(_i) for _i in range(0,integrator.getNumObservedVars())]:
                _obs.add_instance(_v.getInstance())

            for _time,_vals in self.data:
                _obs.do_add_row([_time]+[_v for _v in _vals])
        except Exception,e:
            sys.stderr.write("\n\n\nCAUGHT EXCEPTION: %s\n\n\n" % str(e))
        return 0

    def closeOutput1(self):
        # output the results (to the console, for now)
        for _t,_vals in self.data:
            print _t,_vals

        self.progress.set_fraction(1.0)
        self.progress.set_text("Finished.")
        return 1

    def updateStatus(self):
        # outdate the GUI
        try:
            # TODO: change so it's not updating every step!
            t = self.getIntegrator().getCurrentTime()
            _frac = float(self.getIntegrator().getCurrentStep())/self.nsteps
            self.progress.set_text("t = %f" % (self.getIntegrator().getCurrentTime()))
            self.progress.set_fraction(_frac)
            while gtk.events_pending():
                gtk.main_iteration()
            if self.cancelrequested:
                return 0    
            return 1
        except Exception,e:
            print "\n\nERROR IN UPDATESTATUS!",str(e)
            return 0

    def recordObservedValues(self):
        # just add to our in-memory data structure for now...
        try:
            i = self.getIntegrator()
            print str(i.getCurrentObservations())       
            self.data.append((i.getCurrentTime(),i.getCurrentObservations()))
        except Exception,e:
            print "\n\nERROR IN RECORDOBSERVEDVALUES!",str(e)
            return 0
        return 1


1	import ascpy
2	import time
3	import sys
4	import gtk
5	import gtk.glade
6	import time
7	from varentry import *
8	from preferences import *
9
10	from observer import *
11
12	# When writing this class, we assume that the integrator class has already had
13	# its "analyse" method called, so we know all that stuff like the number of
14	# observed variables, what our time samples are, what the independent variable
15	# is, etc.
16
17	INTEGRATOR_NUM = 0
18
19	class IntegratorReporterPython(ascpy.IntegratorReporterCxx):
20	def __init__(self,browser,integrator):
21	self.browser=browser
22	ascpy.IntegratorReporterCxx.__init__(self,integrator)
23
24	# GUI elements
25	_xml = gtk.glade.XML(browser.glade_file,"integratorstatusdialog")
26	_xml.signal_autoconnect(self)
27	self.window=_xml.get_widget("integratorstatusdialog")
28	self.window.set_transient_for(self.browser.window)
29	self.label=_xml.get_widget("integratorlabel")
30	self.label.set_text("Solving with "+self.getIntegrator().getEngineName())
31	self.progress=_xml.get_widget("integratorprogress")
32	self.data = None
33
34	self.cancelrequested=False
35
36	def run(self):
37	# run the dialog: start solution, monitor use events
38	try:
39	self.getIntegrator().solve()
40	except RuntimeError,e:
41	self.browser.reporter.reportError("Integrator failed: %s" % e)
42	self.window.destroy()
43	return
44
45	def on_cancelbutton_clicked(self,*args):
46	self.cancelrequested=True
47
48	def initOutput(self):
49	# empty out the data table
50	self.data=[]
51	self.nsteps = self.getIntegrator().getNumSteps()
52	self.progress.set_text("Starting...")
53	self.progress.set_fraction(0.0)
54	#update the GUI
55	while gtk.events_pending():
56	gtk.main_iteration()
57	return 1
58
59	def closeOutput(self):
60	global INTEGRATOR_NUM
61	integrator = self.getIntegrator()
62	# create an empty observer
63	try:
64	_xml = gtk.glade.XML(self.browser.glade_file,"observervbox")
65	_label = gtk.Label();
66	INTEGRATOR_NUM = INTEGRATOR_NUM + 1
67	_name = "Integrator %d" % INTEGRATOR_NUM
68	_tab = self.browser.maintabs.append_page(_xml.get_widget("observervbox"),_label)
69	_obs = ObserverTab(xml=_xml, name=_name, browser=self.browser, tab=_tab, alive=False)
70	_label.set_text(_obs.name)
71	self.browser.observers.append(_obs)
72	self.browser.tabs[_tab]=_obs
73
74	# add the columns
75	_obs.add_instance(integrator.getIndependentVariable().getInstance())
76	for _v in [integrator.getObservedVariable(_i) for _i in range(0,integrator.getNumObservedVars())]:
77	_obs.add_instance(_v.getInstance())
78
79	for _time,_vals in self.data:
80	_obs.do_add_row([_time]+[_v for _v in _vals])
81	except Exception,e:
82	sys.stderr.write("\n\n\nCAUGHT EXCEPTION: %s\n\n\n" % str(e))
83	return 0
84
85	def closeOutput1(self):
86	# output the results (to the console, for now)
87	for _t,_vals in self.data:
88	print _t,_vals
89
90	self.progress.set_fraction(1.0)
91	self.progress.set_text("Finished.")
92	return 1
93
94	def updateStatus(self):
95	# outdate the GUI
96	try:
97	# TODO: change so it's not updating every step!
98	t = self.getIntegrator().getCurrentTime()
99	_frac = float(self.getIntegrator().getCurrentStep())/self.nsteps
100	self.progress.set_text("t = %f" % (self.getIntegrator().getCurrentTime()))
101	self.progress.set_fraction(_frac)
102	while gtk.events_pending():
103	gtk.main_iteration()
104	if self.cancelrequested:
105	return 0
106	return 1
107	except Exception,e:
108	print "\n\nERROR IN UPDATESTATUS!",str(e)
109	return 0
110
111	def recordObservedValues(self):
112	# just add to our in-memory data structure for now...
113	try:
114	i = self.getIntegrator()
115	print str(i.getCurrentObservations())
116	self.data.append((i.getCurrentTime(),i.getCurrentObservations()))
117	except Exception,e:
118	print "\n\nERROR IN RECORDOBSERVEDVALUES!",str(e)
119	return 0
120	return 1
121
122
123