def __init__(self, parent, plot_pp, plot_x, plot_y): assert isinstance(plot_pp, Canvas) assert isinstance(plot_x, Canvas) assert isinstance(plot_y, Canvas) # for deleting lineedits/etc. from parent class self.parent = parent self.plot_pp = plot_pp self.plot_x = plot_x self.plot_y = plot_y # register_graph plot_pp myEquilibria.register_graph(self.plot_pp) myNullclines.register_graph(self.plot_pp) myTrajectories.register_graph(self, self.plot_pp, self.plot_x, self.plot_y) myStreamlines.register_graph(self, self.plot_pp) myVectorfield.register_graph(self, self.plot_pp) # read initial values: vector field, streamlines, nullclines self.vf_toggle = myConfig.get_boolean("Vectorfield", "vf_onByDefault") self.nc_toggle = myConfig.get_boolean("Nullclines", "nc_onByDefault") self.sl_toggle = myConfig.get_boolean("Streamlines", "stream_onByDefault") myLogger.debug_message("Graph class initialized")
def __init__(self, parent, canvas): self.myWidget = parent Plot.__init__(self, self.myWidget, canvas) # read initial values: vector field, streamlines, nullclines self.vf_toggle = myConfig.get_boolean("Vectorfield", "vf_onByDefault") self.nc_toggle = myConfig.get_boolean("Nullclines", "nc_onByDefault") self.sl_toggle = myConfig.get_boolean("Streamlines", "stream_onByDefault")
def initialize_ui(self): # gets called after submitting a system (updae_ui() cannot be # used since the new system tab is not visible yet # values are taken from config file self.toggle_vectorfield_action.setChecked(myConfig.get_boolean("Vectorfield", "vf_onByDefault")) self.toggle_streamlines_action.setChecked(myConfig.get_boolean("Streamlines", "stream_onByDefault")) self.toggle_equilibrium_action.setChecked(False) self.toggle_nullclines_action.setChecked(myConfig.get_boolean("Nullclines", "nc_onByDefault"))
def clear(self): self.canvas.axes.clear() if myConfig.get_boolean(self._section, self._token + "showGrid"): self.canvas.axes.grid() if myConfig.get_boolean(self._section, self._token + "showMinorTicks"): self.canvas.axes.minorticks_on() else: self.canvas.axes.minorticks_off() if not myConfig.get_boolean(self._section, self._token + "showTTicks"): self.canvas.axes.zaxis.set_ticks([]) if not myConfig.get_boolean(self._section, self._token + "showXTicks"): self.canvas.axes.xaxis.set_ticks([]) if not myConfig.get_boolean(self._section, self._token + "showYTicks"): self.canvas.axes.yaxis.set_ticks([]) if myConfig.get_boolean(self._section, self._token + "showTitle"): title_x_dot = sp.latex( self.myWidget.mySystem.equation.what_is_my_system()[0]) title_y_dot = sp.latex( self.myWidget.mySystem.equation.what_is_my_system()[1]) self.canvas.axes.set_title("$\\dot{x} = " + title_x_dot + "$\n$\\dot{y} = " + title_y_dot + "$") else: self.canvas.fig.subplots_adjust(top=0.99) if myConfig.get_boolean(self._section, self._token + "showXLabel"): xlabel = "$x$" label_fontsize = myConfig.read(self._section, self._token + "labelFontSize") self.canvas.axes.set_xlabel(xlabel, fontsize=label_fontsize) if myConfig.get_boolean(self._section, self._token + "showYLabel"): label_fontsize = myConfig.read(self._section, self._token + "labelFontSize") ylabel = "$y$" self.canvas.axes.set_ylabel(ylabel, fontsize=label_fontsize) if myConfig.get_boolean(self._section, self._token + "showTLabel"): label_fontsize = myConfig.read(self._section, self._token + "labelFontSize") tlabel = "$t$" self.canvas.axes.set_zlabel(tlabel, fontsize=label_fontsize) if not myConfig.get_boolean(self._section, self._token + "showSpines"): for spine in self.canvas.axes.spines.itervalues(): spine.set_visible(False) self.update() myLogger.debug_message("3d graph cleared")
def plot_eigenvectors(self, equilibrium): if self.linear: # system is linear -> calculate jacobian x, y = sp.symbols("x, y") xdot = self.equation.x_dot_expr ydot = self.equation.y_dot_expr A11 = xdot.diff(x) A12 = xdot.diff(y) A21 = ydot.diff(x) A22 = ydot.diff(y) jac = np.array([[A11,A12],[A21,A22]], dtype=float) eigenvalues, eigenvectors = np.linalg.eig(jac) eigvec0 = eigenvectors[:,0] eigvec1 = eigenvectors[:,1] # calculating eigenvalues and eigenvectors: #~ eigenvalues, eigenvectors = self.Phaseplane.Equilibria.get_eigenval_eigenvec(equilibrium) myLogger.message("Eigenvectors: (" + str(eigvec0[0]) + ", " + str(eigvec0[1]) + ") and (" + str(eigvec1[0]) + ", " + str(eigvec1[1]) + ")") # scaling xmin, xmax, ymin, ymax = self.Phaseplane.Plot.get_limits() d1 = (xmax-xmin)/10 d2 = (ymax-ymin)/10 d_large = (xmax-xmin)*(ymax-ymin) EV0 = np.array([np.real(eigvec0[0]),np.real(eigvec0[1])]) EV0_norm = np.sqrt(EV0[0]**2+EV0[1]**2) EV0_scaled = np.array([d1*(1/EV0_norm)*EV0[0],d1*(1/EV0_norm)*EV0[1]]) EV1 = np.array([np.real(eigvec1[0]),np.real(eigvec1[1])]) EV1_norm = np.sqrt(EV1[0]**2+EV1[1]**2) EV1_scaled = np.array([d1*(1/EV1_norm)*EV1[0],d1*(1/EV1_norm)*EV1[1]]) # plot equilibrium: self.Phaseplane.Plot.canvas.axes.plot(equilibrium[0], equilibrium[1], 'ro', picker=2) # plot eigenvectors: color_eigenvec = myConfig.read("Linearization", "lin_eigenvector_color") color_eigenline = myConfig.read("Linearization", "lin_eigenvector_linecolor") if myConfig.get_boolean("Linearization","lin_show_eigenline"): self.Phaseplane.Plot.canvas.axes.arrow(equilibrium[0], equilibrium[1], d_large*EV0_scaled[0], d_large*EV0_scaled[1], head_width=0, head_length=0, color=color_eigenline) self.Phaseplane.Plot.canvas.axes.arrow(equilibrium[0], equilibrium[1], -d_large*EV0_scaled[0], -d_large*EV0_scaled[1], head_width=0, head_length=0, color=color_eigenline) if myConfig.get_boolean("Linearization","lin_show_eigenvector"): self.Phaseplane.Plot.canvas.axes.arrow(equilibrium[0], equilibrium[1], EV0_scaled[0], EV0_scaled[1], head_width=0, head_length=0, color=color_eigenvec) if myConfig.get_boolean("Linearization","lin_show_eigenline"): self.Phaseplane.Plot.canvas.axes.arrow(equilibrium[0], equilibrium[1], d_large*EV1_scaled[0], d_large*EV1_scaled[1], head_width=0, head_length=0, color=color_eigenline) self.Phaseplane.Plot.canvas.axes.arrow(equilibrium[0], equilibrium[1], -d_large*EV1_scaled[0], -d_large*EV1_scaled[1], head_width=0, head_length=0, color=color_eigenline) if myConfig.get_boolean("Linearization","lin_show_eigenvector"): self.Phaseplane.Plot.canvas.axes.arrow(equilibrium[0], equilibrium[1], EV1_scaled[0], EV1_scaled[1], head_width=0, head_length=0, color=color_eigenvec) self.Phaseplane.Plot.add_eigenvectors_to_title(eigvec0, eigvec1)
def initialize(self): """ this function gets called after myConfig instance has been created. logging before that is possible with hardcoded values. """ from core.ConfigHandler import myConfig self.show_error = myConfig.get_boolean("Logging", "log_showError") self.show_warning = myConfig.get_boolean("Logging", "log_showWarning") self.show_debug = myConfig.get_boolean("Logging", "log_showDbg") myLogger.debug_message("Logging class initialized.")
def initialize_ui(self): # gets called after submitting a system (updae_ui() cannot be # used since the new system tab is not visible yet # values are taken from config file self.toggle_vectorfield_action.setChecked( myConfig.get_boolean("Vectorfield", "vf_onByDefault")) self.toggle_streamlines_action.setChecked( myConfig.get_boolean("Streamlines", "stream_onByDefault")) self.toggle_equilibrium_action.setChecked(False) self.toggle_nullclines_action.setChecked( myConfig.get_boolean("Nullclines", "nc_onByDefault"))
def __init__(self, parent): self.mySystem = parent QtWidgets.QWidget.__init__(self) self.setupUi(self) self.latex_installed = self.mySystem.myPyplane.latex_installed self.Layout = QtWidgets.QVBoxLayout(self.frame) self.Canvas = Canvas(self, self.latex_installed) self.Layout.addWidget(self.Canvas) # Axis labels self.xlabel_str = "x" self.ylabel_str = "y" # set forward and backward integration true if myConfig.get_boolean("Trajectories", "traj_checkForwardByDefault"): self.forwardCheckbox.setChecked(True) if myConfig.get_boolean("Trajectories", "traj_checkBackwardByDefault"): self.backwardCheckbox.setChecked(True) self.xminLineEdit.setText(str(myConfig.read("Phaseplane", "pp_xmin"))) self.xmaxLineEdit.setText(str(myConfig.read("Phaseplane", "pp_xmax"))) self.yminLineEdit.setText(str(myConfig.read("Phaseplane", "pp_ymin"))) self.ymaxLineEdit.setText(str(myConfig.read("Phaseplane", "pp_ymax"))) self.Plot = PhasePlot(self, self.Canvas) self.Plot.set_window_range() self.VF = Vectorfield(self) self.SL = StreamlineHandler(self) self.Nullclines = NullclineHandler(self) self.Equilibria = EquilibriumHandler(self) # menu checkers self.mySystem.myPyplane.toggle_vectorfield_action.setChecked( self.VF.tgl) # connect buttons self.SetButton.clicked.connect(self.Plot.set_window_range) self.ZoomButton.clicked.connect(self.Canvas.toggle_zoom_mode) self.ZoomButton.setCheckable(True) self.RefreshButton.clicked.connect(self.Plot.refresh) self.CreateTrajectoryButton.clicked.connect( self.mySystem.Trajectories.create_trajectory) # linearize button and combo box # TODO: Fix next line! # self.connect(self.linBox, QtCore.SIGNAL('activated(QString)'), self.eq_chosen) self.linButton.clicked.connect(self.linearize_system) self.hide_linearization_objects()
def init(self): """ This function gets called only after program start. """ # load tmp file self.load_tmp_system() # set forward and backward integration true if myConfig.get_boolean("Trajectories", "traj_checkForwardByDefault"): self.forwardCheckbox.setChecked(True) if myConfig.get_boolean("Trajectories", "traj_checkBackwardByDefault"): self.backwardCheckbox.setChecked(True) self.initializing()
def __init__(self, parent): self.mySystem = parent QtWidgets.QWidget.__init__(self) self.setupUi(self) self.latex_installed = self.mySystem.myPyplane.latex_installed self.Layout = QtWidgets.QVBoxLayout(self.frame) self.Canvas = Canvas(self, self.latex_installed) self.Layout.addWidget(self.Canvas) # Axis labels self.xlabel_str = "x" self.ylabel_str = "y" # set forward and backward integration true if myConfig.get_boolean("Trajectories", "traj_checkForwardByDefault"): self.forwardCheckbox.setChecked(True) if myConfig.get_boolean("Trajectories", "traj_checkBackwardByDefault"): self.backwardCheckbox.setChecked(True) self.xminLineEdit.setText(str(myConfig.read("Phaseplane", "pp_xmin"))) self.xmaxLineEdit.setText(str(myConfig.read("Phaseplane", "pp_xmax"))) self.yminLineEdit.setText(str(myConfig.read("Phaseplane", "pp_ymin"))) self.ymaxLineEdit.setText(str(myConfig.read("Phaseplane", "pp_ymax"))) self.Plot = PhasePlot(self, self.Canvas) self.Plot.set_window_range() self.VF = Vectorfield(self) self.SL = StreamlineHandler(self) self.Nullclines = NullclineHandler(self) self.Equilibria = EquilibriumHandler(self) # menu checkers self.mySystem.myPyplane.toggle_vectorfield_action.setChecked(self.VF.tgl) # connect buttons self.SetButton.clicked.connect(self.Plot.set_window_range) self.ZoomButton.clicked.connect(self.Canvas.toggle_zoom_mode) self.ZoomButton.setCheckable(True) self.RefreshButton.clicked.connect(self.Plot.refresh) self.CreateTrajectoryButton.clicked.connect(self.mySystem.Trajectories.create_trajectory) # linearize button and combo box # TODO: Fix next line! # self.connect(self.linBox, QtCore.SIGNAL('activated(QString)'), self.eq_chosen) self.linButton.clicked.connect(self.linearize_system) self.hide_linearization_objects()
def clear(self): self.canvas.axes.clear() if myConfig.get_boolean(self._section, self._token + "showGrid"): self.canvas.axes.grid() if myConfig.get_boolean(self._section, self._token + "showMinorTicks"): self.canvas.axes.minorticks_on() else: self.canvas.axes.minorticks_off() if not myConfig.get_boolean(self._section, self._token + "showTTicks"): self.canvas.axes.zaxis.set_ticks([]) if not myConfig.get_boolean(self._section, self._token + "showXTicks"): self.canvas.axes.xaxis.set_ticks([]) if not myConfig.get_boolean(self._section, self._token + "showYTicks"): self.canvas.axes.yaxis.set_ticks([]) if myConfig.get_boolean(self._section, self._token + "showTitle"): title_x_dot = sp.latex(self.myWidget.mySystem.equation.what_is_my_system()[0]) title_y_dot = sp.latex(self.myWidget.mySystem.equation.what_is_my_system()[1]) self.canvas.axes.set_title("$\\dot{x} = " + title_x_dot + "$\n$\\dot{y} = " + title_y_dot + "$") else: self.canvas.fig.subplots_adjust(top=0.99) if myConfig.get_boolean(self._section, self._token + "showXLabel"): xlabel = "$x$" label_fontsize = myConfig.read(self._section, self._token + "labelFontSize") self.canvas.axes.set_xlabel(xlabel, fontsize=label_fontsize) if myConfig.get_boolean(self._section, self._token + "showYLabel"): label_fontsize = myConfig.read(self._section, self._token + "labelFontSize") ylabel = "$y$" self.canvas.axes.set_ylabel(ylabel, fontsize=label_fontsize) if myConfig.get_boolean(self._section, self._token + "showTLabel"): label_fontsize = myConfig.read(self._section, self._token + "labelFontSize") tlabel = "$t$" self.canvas.axes.set_zlabel(tlabel, fontsize=label_fontsize) if not myConfig.get_boolean(self._section, self._token + "showSpines"): for spine in self.canvas.axes.spines.itervalues(): spine.set_visible(False) self.update() myLogger.debug_message("3d graph cleared")
def __init__(self, parent, latex_installed): self.myWidget = parent plot_background = myConfig.read("Plotting", "plot_background") plot_CanvasBackground = str(myConfig.read("Plotting", "plot_CanvasBackground")) plot_fontSize = int(myConfig.read("Plotting", "plot_fontSize")) plot_topOfPlot = float(myConfig.read("Plotting", "plot_topOfPlot")) plot_leftOfPlot = 0.12#float(myConfig.read("Plotting", "plot_leftOfPlot")) plot_rightOfPlot = float(myConfig.read("Plotting", "plot_rightOfPlot")) plot_bottomOfPlot = 0.1#float(myConfig.read("Plotting", "plot_bottomOfPlot")) self.fig = pl.Figure(facecolor=plot_background) pl.matplotlib.rc('font', size=plot_fontSize) # Check if LaTeX and dvipng are installed on this system since this # is required by matplotlib for fine rendering. If it is not installed # only basic rendering will be done in the following rc('text', usetex=latex_installed) # ALIASING # TODO: read aliasing variables: # pl.matplotlib.rc('lines', antialiased=False) # pl.matplotlib.rc('text', antialiased=False) # pl.matplotlib.rc('patch', antialiased=False) self.axes = self.fig.add_subplot(111) # Matplotlib 2.0 vs. 1.5 behavior... try: self.axes.set_facecolor(plot_CanvasBackground) # Matplotlib >= 2 except AttributeError: self.axes.set_axis_bgcolor(plot_CanvasBackground) # Matplotlib < 2 # matplotlib background transparent (issues on old versions?) if myConfig.get_boolean("Plotting", "plot_backgroundTransparent"): self.fig.frameon = False self.adjust = self.fig.subplots_adjust(top=plot_topOfPlot, left=plot_leftOfPlot, right=plot_rightOfPlot, bottom=plot_bottomOfPlot) FigureCanvas.__init__(self, self.fig) self.setParent(parent) self.navigationToolbar = Toolbar(self) # TODO: rather as a real toolbar: # self.toolbar = NavigationToolbar(self, self.myWidget.mpl_layout, coordinates=True) # self.myWidget.mplvl.addWidget(self.toolbar) FigureCanvas.setSizePolicy(self, QtWidgets.QSizePolicy.Expanding, QtWidgets.QSizePolicy.Expanding) FigureCanvas.updateGeometry(self) # zoom mode on/off self.zoomMode = False myLogger.debug_message(str(self) + ": initialized")
def add_eigenvectors_to_title(self, vec0, vec1): if myConfig.get_boolean(self._section, self._token + "showTitle"): title_x_dot = sp.latex(self.myWidget.mySystem.equation.what_is_my_system()[0]) title_y_dot = sp.latex(self.myWidget.mySystem.equation.what_is_my_system()[1]) dec_place = 2 # TODO: read from config self.canvas.axes.set_title("$\\dot{x} = " + title_x_dot + "$\n$\\dot{y} = " + title_y_dot + "$\n$\mathbf{v}_1=("+str(round(vec0[0],dec_place)) + "," + str(round(vec0[1],dec_place)) + ")^T\qquad\mathbf{v}_2=(" + str(round(vec1[0],dec_place)) + "," + str(round(vec1[1],dec_place)) + ")^T$")
def __init__(self, parent, latex_installed): self.myWidget = parent plot_background = myConfig.read("Plotting", "plot_background") plot_CanvasBackground = str(myConfig.read("Plotting", "plot_CanvasBackground")) plot_fontSize = int(myConfig.read("Plotting", "plot_fontSize")) plot_topOfPlot = float(myConfig.read("Plotting", "plot_topOfPlot")) plot_leftOfPlot = float(myConfig.read("Plotting", "plot_leftOfPlot")) plot_rightOfPlot = float(myConfig.read("Plotting", "plot_rightOfPlot")) plot_bottomOfPlot = float(myConfig.read("Plotting", "plot_bottomOfPlot")) self.fig = pl.Figure(facecolor=plot_background) pl.matplotlib.rc('font', size=plot_fontSize) # Check if LaTeX and dvipng are installed on this system since this # is required by matplotlib for fine rendering. If it is not installed # only basic rendering will be done in the following rc('text', usetex=latex_installed) # ALIASING # TODO: read aliasing variables: # pl.matplotlib.rc('lines', antialiased=False) # pl.matplotlib.rc('text', antialiased=False) # pl.matplotlib.rc('patch', antialiased=False) self.axes = self.fig.add_subplot(111) self.axes.set_axis_bgcolor(plot_CanvasBackground) # matplotlib background transparent (issues on old versions?) if myConfig.get_boolean("Plotting", "plot_backgroundTransparent"): self.fig.frameon = False self.adjust = self.fig.subplots_adjust(top=plot_topOfPlot, left=plot_leftOfPlot, right=plot_rightOfPlot, bottom=plot_bottomOfPlot) FigureCanvas.__init__(self, self.fig) self.setParent(parent) self.navigationToolbar = Toolbar(self) # TODO: rather as a real toolbar: #~ self.toolbar = NavigationToolbar(self, self.myWidget.mpl_layout, coordinates=True) #~ self.myWidget.mplvl.addWidget(self.toolbar) FigureCanvas.setSizePolicy(self, QtGui.QSizePolicy.Expanding, QtGui.QSizePolicy.Expanding) FigureCanvas.updateGeometry(self) # zoom mode on/off self.zoomMode = False myLogger.debug_message(str(self) + ": initialized")
def __init__(self, parent=None): plot_background = myConfig.read("Plotting", "plot_background") plot_CanvasBackground = str(myConfig.read("Plotting", "plot_CanvasBackground")) plot_fontSize = int(myConfig.read("Plotting", "plot_fontSize")) plot_topOfPlot = float(myConfig.read("Plotting", "plot_topOfPlot")) plot_leftOfPlot = float(myConfig.read("Plotting", "plot_leftOfPlot")) plot_rightOfPlot = float(myConfig.read("Plotting", "plot_rightOfPlot")) plot_bottomOfPlot = float(myConfig.read("Plotting", "plot_bottomOfPlot")) self.fig = pl.Figure(facecolor=plot_background) pl.matplotlib.rc('font', size=plot_fontSize) # use latex rc('text', usetex=True) # ALIASING # TODO: read aliasing variables: # pl.matplotlib.rc('lines', antialiased=False) # pl.matplotlib.rc('text', antialiased=False) # pl.matplotlib.rc('patch', antialiased=False) self.axes = self.fig.add_subplot(111) self.axes.set_axis_bgcolor(plot_CanvasBackground) # matplotlib background transparent (issues on old versions?) if myConfig.get_boolean("Plotting", "plot_backgroundTransparent"): self.fig.frameon = False self.adjust = self.fig.subplots_adjust(top=plot_topOfPlot, left=plot_leftOfPlot, right=plot_rightOfPlot, bottom=plot_bottomOfPlot) FigureCanvas.__init__(self, self.fig) self.setParent(parent) self.navigationToolbar = Toolbar(self) FigureCanvas.setSizePolicy(self, QtGui.QSizePolicy.Expanding, QtGui.QSizePolicy.Expanding) FigureCanvas.updateGeometry(self) # zoom mode on/off self.zoomMode = False myLogger.debug_message(str(self) + ": initialized")
def clear(self): self.canvas.axes.clear() if myConfig.get_boolean(self._section, self._token + "showGrid"): self.canvas.axes.grid() if myConfig.get_boolean(self._section, self._token + "showMinorTicks"): self.canvas.axes.minorticks_on() else: self.canvas.axes.minorticks_off() if not myConfig.get_boolean(self._section, self._token + "showXTicks"): self.canvas.axes.xaxis.set_ticks([]) if not myConfig.get_boolean(self._section, self._token + "showYTicks"): self.canvas.axes.yaxis.set_ticks([]) if myConfig.get_boolean(self._section, self._token + "showXLabel"): pp_label_fontsize = myConfig.read(self._section, self._token + "labelFontSize") xlabel = "$%s$" % self.myWidget.xlabel_str self.canvas.axes.set_xlabel(xlabel, fontsize=pp_label_fontsize) if myConfig.get_boolean(self._section, self._token + "showTitle"): title_x_dot = sp.latex(self.myWidget.mySystem.equation.what_is_my_system()[0]) title_y_dot = sp.latex(self.myWidget.mySystem.equation.what_is_my_system()[1]) self.canvas.axes.set_title("$\\dot{x} = " + title_x_dot + "$\n$\\dot{y} = " + title_y_dot + "$") else: self.canvas.fig.subplots_adjust(top=0.99) if myConfig.get_boolean(self._section, self._token + "showYLabel"): pp_label_fontsize = myConfig.read(self._section, self._token + "labelFontSize") ylabel = "$%s$" % self.myWidget.ylabel_str self.canvas.axes.set_ylabel(ylabel, fontsize=pp_label_fontsize) # TODO (jcw): Check if this can be removed (together with Graph class) # if not myConfig.get_boolean(self._section, self._token + "showSpines"): # for spine in Graph.axes.spines.values(): # spine.set_visible(False) self.update() myLogger.debug_message("Graph cleared")
def __init__(self, parent): self.myWidget = parent self.stack = [] self.tgl = myConfig.get_boolean("Vectorfield", "vf_onByDefault") self.update()
def plot_trajectory(self, initial_condition, forward=None, backward=None): """ This function plots the solution of the differential equation depending on the initial condition. In general, the trajectory consists of three elements: the forward trajectory, the backward trajectory and the marker for the initial condition, while each element can be turned off in the config file / settings tab. The elements are stored in a list. A dictionary stores this data with the initalCondition as its key, and the list as the value. Input variables: - initialCondition (list with x and y coordinate) Return variables: - none """ if not forward and not backward: myLogger.warn_message("Please select forward and/or backward integration!") return False else: traj_stack = [] traj_integrationtime = float(myConfig.read("Trajectories", "traj_integrationtime")) traj_integrationstep = float(myConfig.read("Trajectories", "traj_integrationstep")) time = pl.arange(0, traj_integrationtime, traj_integrationstep) if forward: # while integrate.ode.successful(): # self.mySystem.jacobian(initialCondition) assert isinstance(initial_condition, list) self.x = integrate.odeint(self.mySystem.equation.rhs, initial_condition, time) #, full_output=1, printmessg=1, mxstep=20000) xvalue = self.x[:, 0] # extract the x vector yvalue = self.x[:, 1] # extract the dx/dt vector # masking xvalue (deleting invalid entries) # xvalue = np.ma.masked_outside(xvalue,-1*self.mySystem.max_norm, # self.mySystem.max_norm) # myMask = xvalue.mask # new_time = np.ma.array(self.t, mask=myMask).compressed() # yvalue = np.ma.array(yvalue, mask=myMask).compressed() # xvalue = xvalue.compressed() # QtCore.pyqtRemoveInputHook() # embed() # masking yvalue # yvalue = np.ma.masked_outside(yvalue,-1*self.mySystem.max_norm, # self.mySystem.max_norm) # myMask = yvalue.mask # new_time = np.ma.array(self.t, mask=myMask).compressed() # xvalue = np.ma.array(xvalue, mask=myMask) # yvalue = yvalue.compressed() # QtCore.pyqtRemoveInputHook() # embed() # plot solution in phase plane: traj_ppForwardColor = myConfig.read("Trajectories", "traj_ppForwardColor") plot1 = self.mySystem.Phaseplane.Plot.canvas.axes.plot(xvalue, yvalue, traj_ppForwardColor) plot3d_forward = self.mySystem.Txy.Plot.canvas.axes.plot(xvalue, yvalue, time, traj_ppForwardColor) zero_arrayx = np.array([10]*len(time)) zero_arrayy = np.array([-10]*len(time)) if myConfig.get_boolean("3d-plot", "3d_showXProjection"): plot3d_forward_projx = self.mySystem.Txy.Plot.canvas.axes.plot(xvalue, zero_arrayx, time, "0.75") traj_stack.append(plot3d_forward_projx) if myConfig.get_boolean("3d-plot", "3d_showYProjection"): plot3d_forward_projy = self.mySystem.Txy.Plot.canvas.axes.plot(zero_arrayy, yvalue, time, "0.75") traj_stack.append(plot3d_forward_projy) if myConfig.get_boolean("3d-plot", "3d_showYXProjection"): plot3d_forward_projxy = self.mySystem.Txy.Plot.canvas.axes.plot(xvalue, yvalue, 0, "0.75") traj_stack.append(plot3d_forward_projxy) # numpy array with both x and y values in pairs # TODO: might be faster if xvalues or yvalues greater than self.mySystem.max_norm # are masked before calculating the norm xvalue, yvalue = self.filter_values(xvalue, yvalue) # THIS HAS BEEN COMMENTED # z = np.column_stack((xvalue,yvalue)) # # # put norm of each pair in numpy array # normed_z = np.array([np.linalg.norm(v) for v in z]) # # # masking # max_norm = self.mySystem.max_norm # masked_normed_z = np.ma.masked_greater(normed_z, max_norm) # myMask = masked_normed_z.mask # # # new xvalue and yvalue # xvalue = np.ma.array(xvalue, mask=myMask) # yvalue = np.ma.array(yvalue, mask=myMask) # UNTIL HERE! # plot solution in x(t): traj_x_tColor = myConfig.read("Trajectories", "traj_x_tColor") plot2 = self.mySystem.Xt.Plot.canvas.axes.plot(time, xvalue, color=traj_x_tColor) # plot solution in y(t): traj_y_tColor = myConfig.read("Trajectories", "traj_y_tColor") plot3 = self.mySystem.Yt.Plot.canvas.axes.plot(time, yvalue, color=traj_y_tColor) # self.myLogger.message("forward trajectory done for initial condition "+str(initialCondition)) traj_stack.append(plot1) traj_stack.append(plot2) traj_stack.append(plot3) traj_stack.append(plot3d_forward) # backward in time -------------------------------------------- if backward: self.x_bw = integrate.odeint(self.mySystem.equation.n_rhs, initial_condition, time) #, full_output=1, printmessg=1)#, mxstep=5000) # self.x_bw, infodict2 = integrate.odeint(self.mySystem.n_rhs, # initialCondition, self.t)#, full_output=1, printmessg=1)#, mxstep=5000) xvalue_bw = self.x_bw[:, 0] yvalue_bw = self.x_bw[:, 1] # # masking xvalue_bw (deleting invalid entries) # xvalue_bw = np.ma.masked_outside(xvalue_bw,1*self.mySystem.max_norm, # self.mySystem.max_norm) # yvalue_bw = np.ma.array(yvalue_bw, mask=xvalue_bw.mask) # xvalue_bw = xvalue_bw.compressed() # # # masking yvalue_bw # yvalue_bw = np.ma.masked_outside(yvalue_bw,1*self.mySystem.max_norm, # self.mySystem.max_norm) # xvalue = np.ma.array(xvalue, mask=yvalue.mask) # yvalue_bw = yvalue_bw.compressed() # xvalue, yvalue = self.filter_values(xvalue,yvalue) # plot in phase plane: traj_ppBackwardColor = myConfig.read("Trajectories", "traj_ppBackwardColor") plot4 = self.mySystem.Phaseplane.Plot.canvas.axes.plot(xvalue_bw, yvalue_bw, color=traj_ppBackwardColor) plot3d_backward = self.mySystem.Txy.Plot.canvas.axes.plot(xvalue_bw, yvalue_bw, -time, traj_ppForwardColor) zero_arrayx = np.array([10]*len(time)) zero_arrayy = np.array([-10]*len(time)) if myConfig.get_boolean("3d-plot", "3d_showXProjection"): plot3d_backward_projx = self.mySystem.Txy.Plot.canvas.axes.plot(xvalue_bw, zero_arrayx, -time, "0.75") traj_stack.append(plot3d_backward_projx) if myConfig.get_boolean("3d-plot", "3d_showYProjection"): plot3d_backwardprojy = self.mySystem.Txy.Plot.canvas.axes.plot(zero_arrayy, yvalue_bw, -time, "0.75") traj_stack.append(plot3d_backwardprojy) if myConfig.get_boolean("3d-plot", "3d_showYXProjection"): plot3d_backward_projxy = self.mySystem.Txy.Plot.canvas.axes.plot(xvalue_bw, yvalue_bw, 0, "0.75") traj_stack.append(plot3d_backward_projxy) traj_stack.append(plot4) traj_stack.append(plot3d_backward) # self.myLogger.message("backward trajectory # done for initial condition "+str(initialCondition)) # mark init: if myConfig.get_boolean("Trajectories", "traj_plotInitPoint"): traj_initPointColor = myConfig.read("Trajectories", "traj_initPointColor") plot5 = self.mySystem.Phaseplane.Plot.canvas.axes.plot(initial_condition[0], initial_condition[1], '.', color=traj_initPointColor) plot3d_initpoint = self.mySystem.Txy.Plot.canvas.axes.plot([initial_condition[0]], [initial_condition[1]], [0], '.', color=traj_initPointColor) traj_stack.append(plot5) traj_stack.append(plot3d_initpoint) if len(traj_stack) != 0: # mark init: self.traj_dict[str(initial_condition)] = traj_stack self.mySystem.update()
def __init__(self): # superclass constructor PyplaneMainWindow.__init__(self) QtCore.pyqtRemoveInputHook() # check config file if shown by default self.terminal_toggle = myConfig.get_boolean("Logging", "showTerminal") self.update_terminal() # connect buttons ------------------------------------------------------ # connect buttons: system self.clearButton.clicked.connect(myTrajectories.remove_all) self.submitButton.clicked.connect(self.submit) # connect buttons: phase plane self.PP_SetButton.clicked.connect(lambda: self.myGraph.set_window_range(self.myGraph.plot_pp)) self.PP_ZoomButton.clicked.connect(self.myGraph.plot_pp.toggle_zoom_mode) self.PP_ZoomButton.setCheckable(True) self.PP_RefreshButton.clicked.connect(self.myGraph.refresh) self.PP_CreateTrajectoryButton.clicked.connect(myTrajectories.create_trajectory) # connect buttons: x(t) self.X_SetButton.clicked.connect(lambda: self.myGraph.set_window_range(self.myGraph.plot_x)) self.X_ZoomButton.clicked.connect(self.myGraph.plot_x.toggle_zoom_mode) self.X_ZoomButton.setCheckable(True) # self.X_ZoomButton.clicked.connect(self.plotCanvas2.zoomMode) # connect buttons: y(t) self.Y_SetButton.clicked.connect(lambda: self.myGraph.set_window_range(self.myGraph.plot_y)) self.Y_ZoomButton.clicked.connect(self.myGraph.plot_y.toggle_zoom_mode) self.Y_ZoomButton.setCheckable(True) # connect buttons: additional function self.FctPlotButton.clicked.connect(self.add_function_to_plot) self.FctClearButton.clicked.connect(self.remove_function_from_plot) # connect mouse events (left mouse button click) in phase plane self.myGraph.plot_pp.mpl_connect('button_press_event', self.myGraph.onclick) self.myGraph.plot_pp.mpl_connect('pick_event', self.myGraph.onpick) # file menu ------------------------------------------------------ # file self.file_menu = QtGui.QMenu('&File', self) self.load = QtGui.QMenu('&Open', self) self.file_menu.addMenu(self.load) self.load.addAction('&Recent', self.load_tmp_system) self.load.addAction('&From File', self.load_system_from_file, QtCore.Qt.CTRL + QtCore.Qt.Key_O) self.file_menu.addAction('&Save System As...', self.save_file, QtCore.Qt.CTRL + QtCore.Qt.Key_S) self.file_menu.addAction('&Export As...', self.export_as, QtCore.Qt.CTRL + QtCore.Qt.Key_E) self.file_menu.addAction('&Quit', self.file_quit, QtCore.Qt.CTRL + QtCore.Qt.Key_Q) self.menuBar().addMenu(self.file_menu) # show self.show_menu = QtGui.QMenu('&Show', self) self.menuBar().addMenu(self.show_menu) # terminal checkbox self.toggle_terminal_action = QtGui.QAction('Terminal', self.show_menu) self.toggle_terminal_action.setCheckable(True) #self.toggle_nullclines_action.setShortcuts( if myConfig.get_boolean("Logging", "showTerminal"): self.toggle_terminal_action.setChecked(True) # noinspection PyUnresolvedReferences self.toggle_terminal_action.triggered.connect(self.toggle_terminal) self.show_menu.addAction(self.toggle_terminal_action) # vector field checkbox self.toggle_vectorfield_action = QtGui.QAction('&Plot Vector Field', self.show_menu) self.toggle_vectorfield_action.setCheckable(True) if myConfig.get_boolean("Vectorfield", "vf_onByDefault"): self.toggle_vectorfield_action.setChecked(True) # noinspection PyUnresolvedReferences self.toggle_vectorfield_action.triggered.connect(self.vf_helper_function) self.show_menu.addAction(self.toggle_vectorfield_action) # streamlines checkbox self.toggle_streamlines_action = QtGui.QAction('&Plot Streamlines', self.show_menu) self.toggle_streamlines_action.setCheckable(True) if myConfig.get_boolean("Streamlines", "stream_onByDefault"): self.toggle_streamlines_action.setChecked(True) self.toggle_streamlines_action.triggered.connect(self.sl_helper_function) self.show_menu.addAction(self.toggle_streamlines_action) # equilibrium checkbox self.toggle_equilibrium_action = QtGui.QAction('&Find an Equilibrium Point / Linearize', self.show_menu) self.toggle_equilibrium_action.setCheckable(True) self.toggle_equilibrium_action.setChecked(False) self.toggle_equilibrium_action.triggered.connect(myEquilibria.toggle) self.show_menu.addAction(self.toggle_equilibrium_action) #self.show_menu.addAction('&Find an Equilibrium Point', self.myGraph.toggleEP) # nullclines checkbox self.toggle_nullclines_action = QtGui.QAction('Nullclines', self.show_menu) self.toggle_nullclines_action.setCheckable(True) if myConfig.get_boolean("Nullclines", "nc_onByDefault"): self.toggle_nullclines_action.setChecked(True) self.toggle_nullclines_action.triggered.connect(myNullclines.toggle) self.show_menu.addAction(self.toggle_nullclines_action) self.show_menu.addAction('&Calculate Nullclines (symbolic)', myNullclines.print_symbolic_nullclines) # help self.help_menu = QtGui.QMenu('&Help', self) self.menuBar().addMenu(self.help_menu) self.help_menu.addAction('&About', self.about) # initializing with default values ------------------------------------------------------ self.init() self.build_settings_tab() # from now on, plot only log messages as defined in config file. # for that, call initialize function in myLogger myLogger.initialize()
def plot_trajectory(self, initial_condition, forward=None, backward=None): """ This function plots the solution of the differential equation depending on the initial condition. In general, the trajectory consists of three elements: the forward trajectory, the backward trajectory and the marker for the initial condition, while each element can be turned off in the config file / settings tab. The elements are stored in a list. A dictionary stores this data with the initalCondition as its key, and the list as the value. Input variables: - initialCondition (list with x and y coordinate) Return variables: - none """ if not forward and not backward: myLogger.warn_message( "Please select forward and/or backward integration!") return False else: traj_stack = [] traj_integrationtime = float( myConfig.read("Trajectories", "traj_integrationtime")) traj_integrationstep = float( myConfig.read("Trajectories", "traj_integrationstep")) time = pl.arange(0, traj_integrationtime, traj_integrationstep) if forward: # while integrate.ode.successful(): # self.mySystem.jacobian(initialCondition) assert isinstance(initial_condition, list) self.x = integrate.odeint(self.mySystem.equation.rhs, initial_condition, time) #, full_output=1, printmessg=1, mxstep=20000) xvalue = self.x[:, 0] # extract the x vector yvalue = self.x[:, 1] # extract the dx/dt vector # masking xvalue (deleting invalid entries) # xvalue = np.ma.masked_outside(xvalue,-1*self.mySystem.max_norm, # self.mySystem.max_norm) # myMask = xvalue.mask # new_time = np.ma.array(self.t, mask=myMask).compressed() # yvalue = np.ma.array(yvalue, mask=myMask).compressed() # xvalue = xvalue.compressed() # QtCore.pyqtRemoveInputHook() # embed() # masking yvalue # yvalue = np.ma.masked_outside(yvalue,-1*self.mySystem.max_norm, # self.mySystem.max_norm) # myMask = yvalue.mask # new_time = np.ma.array(self.t, mask=myMask).compressed() # xvalue = np.ma.array(xvalue, mask=myMask) # yvalue = yvalue.compressed() # QtCore.pyqtRemoveInputHook() # embed() # plot solution in phase plane: traj_ppForwardColor = myConfig.read("Trajectories", "traj_ppForwardColor") plot1 = self.mySystem.Phaseplane.Plot.canvas.axes.plot( xvalue, yvalue, traj_ppForwardColor) plot3d_forward = self.mySystem.Txy.Plot.canvas.axes.plot( xvalue, yvalue, time, traj_ppForwardColor) zero_arrayx = np.array([10] * len(time)) zero_arrayy = np.array([-10] * len(time)) if myConfig.get_boolean("3d-plot", "3d_showXProjection"): plot3d_forward_projx = self.mySystem.Txy.Plot.canvas.axes.plot( xvalue, zero_arrayx, time, "0.75") traj_stack.append(plot3d_forward_projx) if myConfig.get_boolean("3d-plot", "3d_showYProjection"): plot3d_forward_projy = self.mySystem.Txy.Plot.canvas.axes.plot( zero_arrayy, yvalue, time, "0.75") traj_stack.append(plot3d_forward_projy) if myConfig.get_boolean("3d-plot", "3d_showYXProjection"): plot3d_forward_projxy = self.mySystem.Txy.Plot.canvas.axes.plot( xvalue, yvalue, 0, "0.75") traj_stack.append(plot3d_forward_projxy) # numpy array with both x and y values in pairs # TODO: might be faster if xvalues or yvalues greater than self.mySystem.max_norm # are masked before calculating the norm xvalue, yvalue = self.filter_values(xvalue, yvalue) # THIS HAS BEEN COMMENTED # z = np.column_stack((xvalue,yvalue)) # # # put norm of each pair in numpy array # normed_z = np.array([np.linalg.norm(v) for v in z]) # # # masking # max_norm = self.mySystem.max_norm # masked_normed_z = np.ma.masked_greater(normed_z, max_norm) # myMask = masked_normed_z.mask # # # new xvalue and yvalue # xvalue = np.ma.array(xvalue, mask=myMask) # yvalue = np.ma.array(yvalue, mask=myMask) # UNTIL HERE! # plot solution in x(t): traj_x_tColor = myConfig.read("Trajectories", "traj_x_tColor") plot2 = self.mySystem.Xt.Plot.canvas.axes.plot( time, xvalue, color=traj_x_tColor) # plot solution in y(t): traj_y_tColor = myConfig.read("Trajectories", "traj_y_tColor") plot3 = self.mySystem.Yt.Plot.canvas.axes.plot( time, yvalue, color=traj_y_tColor) # self.myLogger.message("forward trajectory done for initial condition "+str(initialCondition)) traj_stack.append(plot1) traj_stack.append(plot2) traj_stack.append(plot3) traj_stack.append(plot3d_forward) # backward in time -------------------------------------------- if backward: self.x_bw = integrate.odeint(self.mySystem.equation.n_rhs, initial_condition, time) #, full_output=1, printmessg=1)#, mxstep=5000) # self.x_bw, infodict2 = integrate.odeint(self.mySystem.n_rhs, # initialCondition, self.t)#, full_output=1, printmessg=1)#, mxstep=5000) xvalue_bw = self.x_bw[:, 0] yvalue_bw = self.x_bw[:, 1] # # masking xvalue_bw (deleting invalid entries) # xvalue_bw = np.ma.masked_outside(xvalue_bw,1*self.mySystem.max_norm, # self.mySystem.max_norm) # yvalue_bw = np.ma.array(yvalue_bw, mask=xvalue_bw.mask) # xvalue_bw = xvalue_bw.compressed() # # # masking yvalue_bw # yvalue_bw = np.ma.masked_outside(yvalue_bw,1*self.mySystem.max_norm, # self.mySystem.max_norm) # xvalue = np.ma.array(xvalue, mask=yvalue.mask) # yvalue_bw = yvalue_bw.compressed() # xvalue, yvalue = self.filter_values(xvalue,yvalue) # plot in phase plane: traj_ppBackwardColor = myConfig.read("Trajectories", "traj_ppBackwardColor") plot4 = self.mySystem.Phaseplane.Plot.canvas.axes.plot( xvalue_bw, yvalue_bw, color=traj_ppBackwardColor) plot3d_backward = self.mySystem.Txy.Plot.canvas.axes.plot( xvalue_bw, yvalue_bw, -time, traj_ppForwardColor) zero_arrayx = np.array([10] * len(time)) zero_arrayy = np.array([-10] * len(time)) if myConfig.get_boolean("3d-plot", "3d_showXProjection"): plot3d_backward_projx = self.mySystem.Txy.Plot.canvas.axes.plot( xvalue_bw, zero_arrayx, -time, "0.75") traj_stack.append(plot3d_backward_projx) if myConfig.get_boolean("3d-plot", "3d_showYProjection"): plot3d_backwardprojy = self.mySystem.Txy.Plot.canvas.axes.plot( zero_arrayy, yvalue_bw, -time, "0.75") traj_stack.append(plot3d_backwardprojy) if myConfig.get_boolean("3d-plot", "3d_showYXProjection"): plot3d_backward_projxy = self.mySystem.Txy.Plot.canvas.axes.plot( xvalue_bw, yvalue_bw, 0, "0.75") traj_stack.append(plot3d_backward_projxy) traj_stack.append(plot4) traj_stack.append(plot3d_backward) # self.myLogger.message("backward trajectory # done for initial condition "+str(initialCondition)) # mark init: if myConfig.get_boolean("Trajectories", "traj_plotInitPoint"): traj_initPointColor = myConfig.read("Trajectories", "traj_initPointColor") plot5 = self.mySystem.Phaseplane.Plot.canvas.axes.plot( initial_condition[0], initial_condition[1], '.', color=traj_initPointColor) plot3d_initpoint = self.mySystem.Txy.Plot.canvas.axes.plot( [initial_condition[0]], [initial_condition[1]], [0], '.', color=traj_initPointColor) traj_stack.append(plot5) traj_stack.append(plot3d_initpoint) if len(traj_stack) != 0: # mark init: self.traj_dict[str(initial_condition)] = traj_stack self.mySystem.update()
def clear_graph(self, Graph): """ This function resets a graph. Depending on the default values in the config file, the following is shown: - grid - minor ticks in x and y direction - labels on x and y axes - title """ Graph.axes.clear() if Graph == self.plot_pp: section = "Phaseplane" token = "pp_" elif Graph == self.plot_x: section = "x-t-plot" token = "x_" else: section = "y-t-plot" token = "y_" if myConfig.get_boolean(section, token + "showGrid"): Graph.axes.grid() if myConfig.get_boolean(section, token + "showMinorTicks"): Graph.axes.minorticks_on() else: Graph.axes.minorticks_off() if not myConfig.get_boolean(section, token + "showXTicks"): Graph.axes.xaxis.set_ticks([]) if not myConfig.get_boolean(section, token + "showYTicks"): Graph.axes.yaxis.set_ticks([]) if myConfig.get_boolean(section, token + "showXLabel"): pp_label_fontsize = myConfig.read(section, token + "labelFontSize") if Graph == self.plot_pp: xlabel = "$x$" else: xlabel = "$t$" Graph.axes.set_xlabel(xlabel, fontsize=pp_label_fontsize) if myConfig.get_boolean(section, token + "showTitle"): title_x_dot = sp.latex(mySystem.what_is_my_system()[0]) title_y_dot = sp.latex(mySystem.what_is_my_system()[1]) Graph.axes.set_title("$\\dot{x} = " + title_x_dot + "$\n$\\dot{y} = " + title_y_dot + "$") else: Graph.fig.subplots_adjust(top=0.99) if myConfig.get_boolean(section, token + "showYLabel"): pp_label_fontsize = myConfig.read(section, token + "labelFontSize") if Graph == self.plot_pp: ylabel = "$\\dot{x}$" elif Graph == self.plot_x: ylabel = "$x$" else: ylabel = "$y$" Graph.axes.set_ylabel(ylabel, fontsize=pp_label_fontsize) if not myConfig.get_boolean(section, token + "showSpines"): for spine in Graph.axes.spines.itervalues(): spine.set_visible(False) self.update_graph(Graph) myLogger.debug_message("Graph cleared")
def add_linearization_tab(self, equilibrium): # TODO: REFACTOR THIS FUNCTION!!! # if linearization has not been shown do so, otherwise ignore: if equilibrium not in self.linearization_stack: # Set up the user interface from Designer. myWidget = Ui_Form() contents = QtGui.QWidget(self.tabWidget) myWidget.setupUi(contents) # add content to linearization tab! self.myLayout_Lin = QtGui.QVBoxLayout(myWidget.frame_lin) self.plotCanvas_Lin = Canvas(myWidget.frame_lin) self.myLayout_Lin.addWidget(self.plotCanvas_Lin) # window range should be equal to window range of phase plane #limits = self.myGraph.get_limits(self.myGraph.plot_pp) #print(limits) #self.myGraph.set_window_range(self.plotCanvas_Lin) # TODO make set_window_range-funtion reusable for this case xmin = float(self.PP_xminLineEdit.text()) xmax = float(self.PP_xmaxLineEdit.text()) ymin = float(self.PP_yminLineEdit.text()) ymax = float(self.PP_ymaxLineEdit.text()) self.plotCanvas_Lin.axes.set_xlim(xmin, xmax) self.plotCanvas_Lin.axes.set_ylim(ymin, ymax) # window range init section = "Phaseplane" token = "pp_" if myConfig.get_boolean(section, token + "showGrid"): self.plotCanvas_Lin.axes.grid() if myConfig.get_boolean(section, token + "showMinorTicks"): self.plotCanvas_Lin.axes.minorticks_on() else: self.plotCanvas_Lin.axes.minorticks_off() if not myConfig.get_boolean(section, token + "showXTicks"): self.plotCanvas_Lin.axes.xaxis.set_ticks([]) if not myConfig.get_boolean(section, token + "showYTicks"): self.plotCanvas_Lin.axes.yaxis.set_ticks([]) if myConfig.get_boolean(section, token + "showXLabel"): pp_label_fontsize = 9 #myConfig.read(section, token + "labelFontSize") xlabel = "$x$" self.plotCanvas_Lin.axes.set_xlabel(xlabel, fontsize=pp_label_fontsize) if myConfig.get_boolean(section, token + "showYLabel"): pp_label_fontsize = 9 #myConfig.read(section, token + "labelFontSize") ylabel = "$\\dot{x}$" self.plotCanvas_Lin.axes.set_ylabel(ylabel, fontsize=pp_label_fontsize) if not myConfig.get_boolean(section, token + "showSpines"): for spine in self.plotCanvas_Lin.axes.spines.itervalues(): spine.set_visible(False) #self.myGraph.plot_pp.mpl_connect('button_press_event', self.myGraph.onclick) # plot linearized vectorfield linearized_vectorfield = VectorfieldHandler() linearized_vectorfield.register_graph(None, self.plotCanvas_Lin) # create linearized system linearized_system = System() # set system properties jac = myEquilibria.approx_ep_jacobian(equilibrium) xe = equilibrium[0] ye = equilibrium[1] x_dot_string = str(jac[0,0]) + "*(x-(" + str(xe) + ")) + (" + str(jac[0,1]) + ")*(y-(" + str(ye) + "))" y_dot_string = str(jac[1,0]) + "*(x-(" + str(xe) + ")) + (" + str(jac[1,1]) + ")*(y-(" + str(ye) + "))" linearized_system.set_rhs(x_dot_string, y_dot_string) # set system for vectorfield linearized_vectorfield.set_system(linearized_system) #title_matrix = r"$A=\begin{Bmatrix}"+str(jac[0,0])+r" & "+str(jac[0,1])+r" \\"+str(jac[1,0])+r" & "+str(jac[1,1])+r"\end{Bmatrix}$" # set title title_matrix = r'$\underline{A}_{' + str(len(self.linearization_stack)) + r'} = \left( \begin{array}{ll} ' + str(jac[0,0]) + r' & ' + str(jac[0,1]) + r'\\ ' + str(jac[1,0]) + r' & ' + str(jac[1,1]) + r' \end{array} \right)$' # characterize EP: # stable focus: SFOC # unstable focus: UFOC # focus: FOC # stable node: SNOD # unstable node: UNOD # saddle: SAD # calculating eigenvalues and eigenvectors: eigenvalues, eigenvectors = myEquilibria.get_eigenval_eigenvec(equilibrium) # len(eigenvalues) should be 2! # real_part_1 = np.real(eigenvalues[0]) # imag_part_1 = np.imag(eigenvalues[0]) # # real_part_2 = np.real(eigenvalues[1]) # imag_part_2 = np.real(eigenvalues[1]) determinant = jac[0,0]*jac[1,1] - jac[1,0]*jac[0,1] trace = jac[0,0] + jac[1,1] ep_character = "hm" if trace==0 and determinant==0: ep_character = "Unclassified" elif determinant < 0: ep_character = "Saddle" elif (determinant > 0) and (determinant < ((trace**2)/4)): if trace < 0: ep_character = "Nodal Sink" elif trace > 0: ep_character = "Nodal Source" elif determinant > ((trace**2)/4): if trace == 0: ep_character = "Center" elif trace < 0: ep_character = "Spiral Sink" elif trace > 0: ep_character = "Spiral Source" elif determinant == ((trace**2)/4): if trace < 0: ep_character = "Sink" elif trace > 0: ep_character = "Source" # plot eigenvectors: # eigenvalues = eigenvalues.tolist() # eigenvectors = eigenvectors.tolist() # # for i in xrange(0, len(eigenvectors)): # x, y = equilibrium[0], equilibrium[1] # dx, dy = eigenvectors[i][0], eigenvectors[i][1] # # vector = [x, y, dx, dy] # # self.myGraph.plot_vector(self.plotCanvas_Lin, vector) if myConfig.get_boolean(section, token + "showTitle"): title1 = str(ep_character) + r': (' + str(equilibrium[0]) + r', ' + str(equilibrium[1]) + r')' #self.plotCanvas_Lin.axes.set_title(str(title1)+"$\n$\\dot{x} = " + x_dot_string + "$\n$\\dot{y} = " + y_dot_string + "$", loc='center') self.plotCanvas_Lin.axes.set_title(r'$' + str(title1)+"$\n"+title_matrix, fontsize=11) else: self.plotCanvas_Lin.fig.subplots_adjust(top=0.99) # mark EP in linearized tab self.plotCanvas_Lin.axes.plot(equilibrium[0], equilibrium[1],'ro') # add annotation in phaseplane label = str(ep_character) self.plotCanvas1.axes.text(equilibrium[0], equilibrium[1], label, fontsize=10) self.plotCanvas1.draw() # plot vectorfield linearized_vectorfield.update() self.plotCanvas_Lin.draw() title = str(ep_character) self.index = self.tabWidget.addTab(contents, title) self.linearization_stack.append(equilibrium)
def __init__(self): # superclass constructor PyplaneMainWindow.__init__(self) QtCore.pyqtRemoveInputHook() # If set to True the app crashes under MS Windows if it is immediately closed after startup without any # further actions sip.setdestroyonexit(False) # Set Version-number self.setWindowTitle("PyPlane " + self.__PYPLANE_VERSION) # check config file if shown by default self.terminal_toggle = myConfig.get_boolean("Logging", "log_showTerminal") self.update_terminal() # # connect buttons ------------------------------------------------------ # # connect buttons: system self.clearButton.clicked.connect(self.clear_trajectories) self.submitButton.clicked.connect(self.submit) # # connect buttons: additional function self.FctPlotButton.clicked.connect(self.add_function) self.FctClearButton.clicked.connect(self.remove_functions) # file menu ------------------------------------------------------ # file self.file_menu = QtWidgets.QMenu('&System', self) self.load = QtWidgets.QMenu('&Open', self) self.file_menu.addMenu(self.load) self.load.addAction('&Recent', self.load_tmp_system) self.load.addAction('&From File', self.load_system_from_file, QtCore.Qt.CTRL + QtCore.Qt.Key_O) self.file_menu.addAction('&Save As...', self.save_file, QtCore.Qt.CTRL + QtCore.Qt.Key_S) self.file_menu.addAction('&Export As...', self.export_as, QtCore.Qt.CTRL + QtCore.Qt.Key_E) self.file_menu.addAction('&Close', self.close_current_tab, QtCore.Qt.CTRL + QtCore.Qt.Key_W) # self.file_menu.addAction('&Close All', self.close_all_tabs, QtCore.Qt.CTRL + QtCore.Qt.ShiftModifier + QtCore.Qt.Key_W) self.file_menu.addAction('&Quit', self.file_quit, QtCore.Qt.CTRL + QtCore.Qt.Key_Q) self.menuBar().addMenu(self.file_menu) # show self.show_menu = QtWidgets.QMenu('&Show', self) self.menuBar().addMenu(self.show_menu) # terminal checkbox self.toggle_terminal_action = QtWidgets.QAction( 'Terminal', self.show_menu) self.toggle_terminal_action.setShortcut(QtCore.Qt.CTRL + QtCore.Qt.Key_T) self.toggle_terminal_action.setCheckable(True) if myConfig.get_boolean("Logging", "log_showTerminal"): self.toggle_terminal_action.setChecked(True) self.toggle_terminal_action.triggered.connect(self.toggle_terminal) self.show_menu.addAction(self.toggle_terminal_action) # vector field checkbox self.toggle_vectorfield_action = QtWidgets.QAction( '&Plot Vector Field', self.show_menu) self.toggle_vectorfield_action.setShortcut(QtCore.Qt.CTRL + QtCore.Qt.Key_V) self.toggle_vectorfield_action.setCheckable(True) # if myConfig.get_boolean("Vectorfield", "vf_onByDefault"): # self.toggle_vectorfield_action.setChecked(True) self.toggle_vectorfield_action.triggered.connect( self.vf_helper_function) self.show_menu.addAction(self.toggle_vectorfield_action) # streamlines checkbox self.toggle_streamlines_action = QtWidgets.QAction( '&Plot Streamlines', self.show_menu) self.toggle_streamlines_action.setCheckable(True) # if myConfig.get_boolean("Streamlines", "stream_onByDefault"): # self.toggle_streamlines_action.setChecked(True) self.toggle_streamlines_action.triggered.connect( self.sl_helper_function) self.show_menu.addAction(self.toggle_streamlines_action) # equilibrium checkbox self.toggle_equilibrium_action = QtWidgets.QAction( '&Find an Equilibrium Point / Linearize', self.show_menu) self.toggle_equilibrium_action.setCheckable(True) # self.toggle_equilibrium_action.setChecked(False) self.toggle_equilibrium_action.triggered.connect( self.eq_helper_function) self.show_menu.addAction(self.toggle_equilibrium_action) #self.show_menu.addAction('&Find an Equilibrium Point', self.myGraph.toggleEP) # linearize checkbox # self.linearize_action = QtWidgets.QAction('&Linearize', self.show_menu) # self.linearize_action.triggered.connect(self.linearize_helper_function) # self.show_menu.addAction(self.linearize_action) # nullclines checkbox self.toggle_nullclines_action = QtWidgets.QAction( 'Nullclines', self.show_menu) self.toggle_nullclines_action.setShortcut(QtCore.Qt.CTRL + QtCore.Qt.Key_N) self.toggle_nullclines_action.setCheckable(True) # if system exists: read toggle-value # if not: read from config # TODO: new systems tab chosen -> check/uncheck toggle! # if self.systems == []: # read current systems tab: # if myConfig.get_boolean("Nullclines", "nc_onByDefault"): # self.toggle_nullclines_action.setChecked(True) self.toggle_nullclines_action.triggered.connect(self.toggle_nullclines) self.show_menu.addAction(self.toggle_nullclines_action) # self.show_menu.addAction('&Calculate Nullclines (symbolic)', myNullclines.print_symbolic_nullclines) # help self.help_menu = QtWidgets.QMenu('&Help', self) self.menuBar().addMenu(self.help_menu) self.help_menu.addAction('&About', self.about) # initializing with default values ------------------------------------------------------ self.init() # self.build_settings_tab() # from now on, plot only log messages as defined in config file. # for that, call initialize function in myLogger myLogger.initialize()
def __init__(self): # superclass constructor PyplaneMainWindow.__init__(self) QtCore.pyqtRemoveInputHook() # If set to True the app crashes under MS Windows if it is immediately closed after startup without any # further actions sip.setdestroyonexit(False) # Set Version-number self.setWindowTitle("PyPlane " + self.__PYPLANE_VERSION) # check config file if shown by default self.terminal_toggle = myConfig.get_boolean("Logging", "showTerminal") self.update_terminal() #~ # connect buttons ------------------------------------------------------ #~ # connect buttons: system self.clearButton.clicked.connect(self.clear_trajectories) self.submitButton.clicked.connect(self.submit) #~ # connect buttons: additional function self.FctPlotButton.clicked.connect(self.add_function) self.FctClearButton.clicked.connect(self.remove_functions) # file menu ------------------------------------------------------ # file self.file_menu = QtGui.QMenu('&System', self) self.load = QtGui.QMenu('&Open', self) self.file_menu.addMenu(self.load) self.load.addAction('&Recent', self.load_tmp_system) self.load.addAction('&From File', self.load_system_from_file, QtCore.Qt.CTRL + QtCore.Qt.Key_O) self.file_menu.addAction('&Save As...', self.save_file, QtCore.Qt.CTRL + QtCore.Qt.Key_S) self.file_menu.addAction('&Export As...', self.export_as, QtCore.Qt.CTRL + QtCore.Qt.Key_E) self.file_menu.addAction('&Close', self.close_current_tab, QtCore.Qt.CTRL + QtCore.Qt.Key_W) #~ self.file_menu.addAction('&Close All', self.close_all_tabs, QtCore.Qt.CTRL + QtCore.Qt.ShiftModifier + QtCore.Qt.Key_W) self.file_menu.addAction('&Quit', self.file_quit, QtCore.Qt.CTRL + QtCore.Qt.Key_Q) self.menuBar().addMenu(self.file_menu) # show self.show_menu = QtGui.QMenu('&Show', self) self.menuBar().addMenu(self.show_menu) # terminal checkbox self.toggle_terminal_action = QtGui.QAction('Terminal', self.show_menu) self.toggle_terminal_action.setShortcut(QtCore.Qt.CTRL + QtCore.Qt.Key_T) self.toggle_terminal_action.setCheckable(True) if myConfig.get_boolean("Logging", "showTerminal"): self.toggle_terminal_action.setChecked(True) self.toggle_terminal_action.triggered.connect(self.toggle_terminal) self.show_menu.addAction(self.toggle_terminal_action) # vector field checkbox self.toggle_vectorfield_action = QtGui.QAction('&Plot Vector Field', self.show_menu) self.toggle_vectorfield_action.setShortcut(QtCore.Qt.CTRL + QtCore.Qt.Key_V) self.toggle_vectorfield_action.setCheckable(True) #~ if myConfig.get_boolean("Vectorfield", "vf_onByDefault"): #~ self.toggle_vectorfield_action.setChecked(True) self.toggle_vectorfield_action.triggered.connect(self.vf_helper_function) self.show_menu.addAction(self.toggle_vectorfield_action) # streamlines checkbox self.toggle_streamlines_action = QtGui.QAction('&Plot Streamlines', self.show_menu) self.toggle_streamlines_action.setCheckable(True) #~ if myConfig.get_boolean("Streamlines", "stream_onByDefault"): #~ self.toggle_streamlines_action.setChecked(True) self.toggle_streamlines_action.triggered.connect(self.sl_helper_function) self.show_menu.addAction(self.toggle_streamlines_action) # equilibrium checkbox self.toggle_equilibrium_action = QtGui.QAction('&Find an Equilibrium Point / Linearize', self.show_menu) self.toggle_equilibrium_action.setCheckable(True) #~ self.toggle_equilibrium_action.setChecked(False) self.toggle_equilibrium_action.triggered.connect(self.eq_helper_function) self.show_menu.addAction(self.toggle_equilibrium_action) #self.show_menu.addAction('&Find an Equilibrium Point', self.myGraph.toggleEP) # linearize checkbox #~ self.linearize_action = QtGui.QAction('&Linearize', self.show_menu) #~ self.linearize_action.triggered.connect(self.linearize_helper_function) #~ self.show_menu.addAction(self.linearize_action) # nullclines checkbox self.toggle_nullclines_action = QtGui.QAction('Nullclines', self.show_menu) self.toggle_nullclines_action.setShortcut(QtCore.Qt.CTRL + QtCore.Qt.Key_N) self.toggle_nullclines_action.setCheckable(True) # if system exists: read toggle-value # if not: read from config # TODO: new systems tab chosen -> check/uncheck toggle! #~ if self.systems == []: # read current systems tab: #~ if myConfig.get_boolean("Nullclines", "nc_onByDefault"): #~ self.toggle_nullclines_action.setChecked(True) self.toggle_nullclines_action.triggered.connect(self.toggle_nullclines) self.show_menu.addAction(self.toggle_nullclines_action) #~ self.show_menu.addAction('&Calculate Nullclines (symbolic)', myNullclines.print_symbolic_nullclines) # help self.help_menu = QtGui.QMenu('&Help', self) self.menuBar().addMenu(self.help_menu) self.help_menu.addAction('&About', self.about) # initializing with default values ------------------------------------------------------ self.init() #~ self.build_settings_tab() # from now on, plot only log messages as defined in config file. # for that, call initialize function in myLogger myLogger.initialize()