Homec4science
Diffusion glups (master) Browse

glups/glups.py
61668ba8ebf3master

Last Change
Raw File

glups.py
View Options

#!/usr/bin/env python
import sys
import math
from PyQt4 import QtCore, QtGui, QtOpenGL
from PyQt4.QtCore import pyqtSignature
from OpenGL.GL import *
from OpenGL.GLU import *
from OpenGL.GLUT import *
from optparse import OptionParser
from pNbody import *
from pNbody.param import *
from pNbody import mpi
from pNbody import libutil
from NbodyGLWidget import *
from NbodyMapWidget import *
from ControllWidget import *
from code import InteractiveInterpreter as Interpreter
from shell import get_shell_class
from pycutext import *
import delaunay
import geometry
GLPARAMETERFILE = '/%s/.glups'%os.environ['HOME']
########################################
#
# parser
#
########################################
def parse_options():
usage = "usage: %prog [options] file"
parser = OptionParser(usage=usage)
parser.add_option("-t",
action="store",
dest="ftype",
type="string",
default = 'gadget',
help="type of the file",
metavar=" TYPE")
parser.add_option("-p",
action="store",
dest="parameterfile",
type="string",
default = GLPARAMETERFILE,
help="default parameter file",
metavar=" FILE")
parser.add_option("--width",
action="store",
dest="width",
type="int",
default = 1000,
help="window width",
metavar=" INT")
parser.add_option("--height",
action="store",
dest="height",
type="int",
default = 750,
help="window height",
metavar=" INT")
parser.add_option("--cmd",
action="store",
dest="cmd",
type="string",
default='None',
help="python command 'nb = nb.selectc((nb.T()>10))'")
parser.add_option("--plugin",
action="store",
dest="plugin",
type="string",
default='None',
help="plugin file")
parser.add_option("-m",
action="store",
dest="markersfile",
type="string",
default=None,
help="Markers File",
metavar=" FILE")
parser.add_option("-v",
action="store",
dest="vectorsfile",
type="string",
default=None,
help="Vectors File",
metavar=" FILE")
parser.add_option("--trk",
action="store",
dest="trkfiles",
type="string",
default=None,
help="Trk Files",
metavar=" FILES")
parser.add_option("--noshell",
action="store_false",
dest="shell",
default = 1,
help="invert into cgs units")
parser.add_option("--nogl",
action="store_true",
dest="nogl",
default = False,
help="do no use gl")
parser.add_option("--fullscreen",
action="store_true",
dest="fullscreen",
default = False,
help="run in fullscreen mode")
(options, args) = parser.parse_args()
if len(args) == 0:
#print "you must specify a filename"
#sys.exit(0)
files = None
else:
#file = args[0]
files = args
return files,options
###########################################
#
# MAIN BOARD
#
###########################################
class ParamsTableWidget(QtGui.QTableWidget):
def __init__(self, parent=None, parameters=None):
QtGui.QTableWidget.__init__(self, parent)
self.setFocusPolicy(QtCore.Qt.StrongFocus) # Widget accepts focus (tab and mouse)
self.parent = parent
font = QtGui.QFont()
font.setPointSize(6)
self.parameters = parameters
self.params = parameters.params
self.setRowCount(len(self.params))
self.setColumnCount(3)
self.label1 = []
self.label2 = []
self.lineEdit = []
i = 0
self.setHorizontalHeaderLabels([self.tr("Parameter"), self.tr("Type"), self.tr("Value")])
self.setColumnWidth(1, 45)
for param in self.params:
self.label1.append(QtGui.QTableWidgetItem(self.tr(param[1])))
self.label2.append(QtGui.QTableWidgetItem(self.tr(param[2])))
self.lineEdit.append(QtGui.QTableWidgetItem(self.tr(write_ascii_value(param[3], param[2], param[0]))))
self.label1[-1].setFlags(QtCore.Qt.ItemIsEnabled)
self.label2[-1].setFlags(QtCore.Qt.ItemIsEnabled)
self.label1[-1].setFont(font)
self.label2[-1].setFont(font)
self.lineEdit[-1].setFont(font)
self.setItem(i, 0, self.label1[-1])
self.setItem(i, 1, self.label2[-1])
self.setItem(i, 2, self.lineEdit[-1])
self.setRowHeight(i, 20)
i = i+1
def AutoSetParameters(self):
i=0
for param in self.params:
self.label1[i] = QtGui.QTableWidgetItem(self.tr(param[1]))
self.label2[i] = QtGui.QTableWidgetItem(self.tr(param[2]))
self.lineEdit[i] = QtGui.QTableWidgetItem(self.tr(write_ascii_value(param[3], param[2], param[0])))
self.setItem(i, 0, self.label1[i])
self.setItem(i, 1, self.label2[i])
self.setItem(i, 2, self.lineEdit[i])
i = i + 1
def SetParameters(self,parameters):
self.parameters = parameters
self.params = parameters.params
i=0
for param in self.params:
self.label1[i] = QtGui.QTableWidgetItem(self.tr(param[1]))
self.label2[i] = QtGui.QTableWidgetItem(self.tr(param[2]))
self.lineEdit[i] = QtGui.QTableWidgetItem(self.tr(write_ascii_value(param[3], param[2], param[0])))
self.setItem(i, 0, self.label1[i])
self.setItem(i, 1, self.label2[i])
self.setItem(i, 2, self.lineEdit[i])
i = i + 1
def UpdateParameters(self):
i = 0
for param in self.params:
valstring = self.lineEdit[i].text()
var = read_ascii_value(str(valstring), param[2], param[0])
self.parameters.set(param[0],var)
i=i+1
def GetParameters(self):
self.UpdateParameters()
return self.parameters
def keyPressEvent(self, event):
key = event.key()
if key==QtCore.Qt.Key_D:
i = 0
for param in self.params:
valstring = self.lineEdit[i].text()
var = read_ascii_value(str(valstring), param[2], param[0])
self.parameters.set(param[0],var)
i = i+1
self.parent.Display(updateFromGL=False)
class MainBoard(QtGui.QMainWindow):
def __init__(self, parent=None, argv=None, ParameterFile=None,MarkersFile=None,VectorsFile=None,TrkFiles=None,ModelFiles=None,cmd=None,plugin=None,shell=False,nogl=False,comm=None,ftype='gadget',fullscreen=False):
self.comm = comm
QtGui.QMainWindow.__init__(self, parent)
QtCore.QMetaObject.connectSlotsByName(self) # Automatic connexions -- for example menuAction <-> def on_menuAction_triggered() ...
self.glWidget = None
self.mpWidget = None
self.ftype = ftype
self.ModelFiles = ModelFiles
self.cmd = cmd
self.plugin = plugin
self.nogl = nogl
self.fullscreen = fullscreen
if self.ModelFiles:
self.CurrentFile = ModelFiles[0]
self.LoadFile(self.CurrentFile)
##############################
# some global var
##############################
self.ImageMat = None
self.ImageMatint = None
self.ImageMin = None
self.ImageMax = None
self.ImageCd = None
##############################
# add menu, widget and dock
##############################
if not self.fullscreen:
self.createMenu()
self.createDisplay()
# shortcut for gl
self.gl = self.glWidget
if shell and not self.fullscreen:
self.createInterpreter()
self.setWindowTitle(self.tr("glups"))
# if slave, WaitForACommand
if not self.comm.mpi_IsMaster():
self.WaitForACommand()
#################################################################
#################################################################
###########################
def WaitForACommand(self,*arg,**kw):
###########################
# wait for the command
if self.comm.NTask==1:
#name = self.comm[0].Bcast(None)
#arg = self.comm[0].Bcast(None)
#kw = self.comm[0].Bcast(None)
name = self.comm.mpi_Bcast(0,None)
arg = self.comm.mpi_Bcast(0,None)
kw = self.comm.mpi_Bcast(0,None)
else:
name = MPI.COMM_WORLD[0].Bcast(None)
arg = MPI.COMM_WORLD[0].Bcast(None)
kw = MPI.COMM_WORLD[0].Bcast(None)
# now, execute the command
#print "(%d)"%(ThisTask),name,arg,kw
apply(getattr(self,name),arg,kw)
#apply(self.allfct[name],arg,kw)
#print "(%d) done :"%(ThisTask),name,arg,kw
# recursive call
self.WaitForACommand() # !!! here, we have the rist to never quit !!!
#thread.start_new_thread(self.WaitForACommand,arg,kw)
###########################
def BroadcastCmd(self,name,arg,kw):
###########################
if self.comm.mpi_IsMaster():
if self.comm.ThisTask==0:
if self.comm.NTask==1:
#name = self.comm[0].Bcast(name)
#arg = self.comm[0].Bcast(arg)
#kw = self.comm[0].Bcast(kw)
name = self.comm.mpi_Bcast(0,None)
arg = self.comm.mpi_Bcast(0,None)
kw = self.comm.mpi_Bcast(0,None)
else:
name = MPI.COMM_WORLD[0].Bcast(name)
arg = MPI.COMM_WORLD[0].Bcast(arg)
kw = MPI.COMM_WORLD[0].Bcast(kw)
##################################################
def createDisplay(self):
##################################################
if not self.nogl:
self.glWidget = NbodyGLWidget(parent=self,argv=sys.argv,nb=self.nb,ParameterFile=ParameterFile,MarkersFile=MarkersFile,VectorsFile=VectorsFile,TrkFiles=TrkFiles)
if self.fullscreen:
self.setCentralWidget(self.glWidget)
return
self.mpWidget = NbodyMapWidget(parent=self)
self.TabWidget = QtGui.QTabWidget()
self.setCentralWidget(self.TabWidget)
if not self.nogl:
self.TabWidget.addTab(self.glWidget, self.tr("GL Display"))
self.TabWidget.addTab(self.mpWidget, self.tr("Map Display"))
self.connect(self.TabWidget, QtCore.SIGNAL("currentChanged(int)"), self.showDock)
# Creating Parameters dock widget
self.paramsDockWidget = QtGui.QDockWidget(self.tr("Parameters"), self)
self.paramsDockWidget.setAllowedAreas(QtCore.Qt.AllDockWidgetAreas)
self.paramsDockWidgetContents = ParamsTableWidget(self, self.nb.parameters)
self.paramsDockWidget.setWidget(self.paramsDockWidgetContents)
self.addDockWidget(QtCore.Qt.DockWidgetArea(QtCore.Qt.RightDockWidgetArea),self.paramsDockWidget)
self.paramsDockWidget.hide()
# Creating Controll dock widget
self.controllDockWidget = QtGui.QDockWidget(self.tr("Controll"), self)
self.controllDockWidget.setAllowedAreas(QtCore.Qt.AllDockWidgetAreas)
self.controllDockWidgetContents = ControllWidget(self)
self.controllDockWidget.setWidget(self.controllDockWidgetContents)
self.addDockWidget(QtCore.Qt.DockWidgetArea(QtCore.Qt.RightDockWidgetArea),self.controllDockWidget)
if not self.fullscreen:
self.controllDockWidget.show()
else:
self.controllDockWidget.hide()
##################################################
def createInterpreter(self):
##################################################
# Creating Interpreter dock widget
self.InterpreterDockWidget = QtGui.QDockWidget(self.tr("Shell"), self)
self.InterpreterDockWidget.setAllowedAreas(QtCore.Qt.AllDockWidgetAreas)
self.interpreter = Interpreter()
self.interpreter.locals['self'] = self
shellclass = get_shell_class()
self.InterpreterDockWidgetContents = shellclass(self.interpreter)
#self.shellDockWidgetContents = PyCutExt(interpreter)
#self.shellDockWidgetContents = interpreter.Interpreter(self.shellDockWidget)
self.InterpreterDockWidget.setWidget(self.InterpreterDockWidgetContents)
self.addDockWidget(QtCore.Qt.DockWidgetArea(QtCore.Qt.BottomDockWidgetArea), self.InterpreterDockWidget)
##################################################
def createMenu(self):
##################################################
self.myBar = self.menuBar()
##########################
### File Menu ###
##########################
self.action_OpenFile = QtGui.QAction(self)
self.action_OpenFile.setText(self.tr("&Open File"))
self.action_WriteFile = QtGui.QAction(self)
self.action_WriteFile.setText(self.tr("Write &File"))
self.action_Quit = QtGui.QAction(self)
self.action_Quit.setText(self.tr("&Quit"))
self.action_SaveGLImage = QtGui.QAction(self)
self.action_SaveGLImage.setText(self.tr("&Save GL Image"))
self.action_SaveMapImage = QtGui.QAction(self)
self.action_SaveMapImage.setText(self.tr("&Save Map Image"))
# Creating connexions
self.connect(self.action_OpenFile, QtCore.SIGNAL("triggered()"), self.OpenFile) # See SLOTS part below
self.connect(self.action_WriteFile, QtCore.SIGNAL("triggered()"), self.WriteFile)
self.connect(self.action_SaveGLImage, QtCore.SIGNAL("triggered()"), self.SaveGLImage)
self.connect(self.action_SaveMapImage, QtCore.SIGNAL("triggered()"), self.SaveMapImage)
self.connect(self.action_Quit, QtCore.SIGNAL("triggered()"), self.Quit)
#self.connect(self.action_Quit, QtCore.SIGNAL("triggered()"), self, QtCore.SLOT("close()"))
# Add Actions to menu
self.menu_File = QtGui.QMenu(self.tr("&File"), self)
self.menu_File.addAction(self.action_OpenFile)
self.menu_File.addAction(self.action_WriteFile)
self.menu_File.addSeparator()
self.menu_File.addAction(self.action_SaveGLImage)
self.menu_File.addAction(self.action_SaveMapImage)
self.menu_File.addSeparator()
self.menu_File.addAction(self.action_Quit)
##########################
### Operation Menu ###
##########################
self.action_Reset = QtGui.QAction(self)
self.action_Reset.setText(self.tr("&Reset"))
self.action_ModelInfo = QtGui.QAction(self)
self.action_ModelInfo.setText(self.tr("&Model Info"))
self.action_ObjectInfo = QtGui.QAction(self)
self.action_ObjectInfo.setText(self.tr("&Object Info"))
self.action_NodeInfo = QtGui.QAction(self)
self.action_NodeInfo.setText(self.tr("&Nodes Info"))
self.action_SelectFromNumFile = QtGui.QAction(self)
self.action_SelectFromNumFile.setText(self.tr("&Select from Num File"))
self.action_ComputeDelaunay = QtGui.QAction(self)
self.action_ComputeDelaunay.setText(self.tr("&Compute Delaunay"))
self.action_DrawDelaunayLines = QtGui.QAction(self)
self.action_DrawDelaunayLines.setText(self.tr("&Draw Delaunay Lines"))
self.action_DrawDelaunaySurface = QtGui.QAction(self)
self.action_DrawDelaunaySurface.setText(self.tr("&Draw Delaunay Surface"))
self.action_WriteNumFile = QtGui.QAction(self)
self.action_WriteNumFile.setText(self.tr("Write &Num"))
self.action_Plugin = QtGui.QAction(self)
self.action_Plugin.setText(self.tr("&Plugin"))
# Add Actions to menu
self.menu_Operations = QtGui.QMenu(self.tr("&Operations"), self)
self.menu_Operations.addAction(self.action_Reset)
self.menu_Operations.addSeparator()
self.menu_Operations.addAction(self.action_ModelInfo)
self.menu_Operations.addAction(self.action_ObjectInfo)
self.menu_Operations.addAction(self.action_NodeInfo)
self.menu_Operations.addSeparator()
self.menu_Operations.addAction(self.action_SelectFromNumFile)
self.menu_Operations.addAction(self.action_WriteNumFile)
self.menu_Operations.addSeparator()
self.menu_Operations.addAction(self.action_ComputeDelaunay)
self.menu_Operations.addAction(self.action_DrawDelaunayLines)
self.menu_Operations.addAction(self.action_DrawDelaunaySurface)
self.menu_Operations.addSeparator()
self.menu_Operations.addAction(self.action_Plugin)
# Creating connexions
self.connect(self.action_Reset, QtCore.SIGNAL("triggered()"), self.Reset)
self.connect(self.action_ModelInfo, QtCore.SIGNAL("triggered()"), self.Info)
self.connect(self.action_ObjectInfo, QtCore.SIGNAL("triggered()"), self.ObjectInfo)
self.connect(self.action_NodeInfo, QtCore.SIGNAL("triggered()"), self.NodeInfo)
self.connect(self.action_SelectFromNumFile, QtCore.SIGNAL("triggered()"), self.SelectFromNumFile)
self.connect(self.action_WriteNumFile, QtCore.SIGNAL("triggered()"), self.WriteNumFile)
self.connect(self.action_ComputeDelaunay, QtCore.SIGNAL("triggered()"), self.ComputeDelaunay)
self.connect(self.action_DrawDelaunayLines, QtCore.SIGNAL("triggered()"), self.DrawDelaunayLines)
self.connect(self.action_DrawDelaunaySurface, QtCore.SIGNAL("triggered()"), self.DrawDelaunaySurface)
self.connect(self.action_Plugin, QtCore.SIGNAL("triggered()"), self.OpenPlugin)
##########################
### GL Parameters Menu ###
##########################
self.action_ResetGLParameters = QtGui.QAction(self)
self.action_ResetGLParameters.setText(self.tr("&Reset"))
self.action_OpenGLParameters = QtGui.QAction(self)
self.action_OpenGLParameters.setText(self.tr("&Open"))
self.action_SaveGLParameters = QtGui.QAction(self)
self.action_SaveGLParameters.setText(self.tr("&Save"))
self.action_SaveAsGLParameters = QtGui.QAction(self)
self.action_SaveAsGLParameters.setText(self.tr("&Save As"))
### Add Actions to Menu Parameters###
self.menu_GLParameters= QtGui.QMenu(self.tr("&GL Parameters"), self)
self.menu_GLParameters.addAction(self.action_ResetGLParameters)
self.menu_GLParameters.addAction(self.action_OpenGLParameters)
self.menu_GLParameters.addSeparator()
self.menu_GLParameters.addAction(self.action_SaveGLParameters)
self.menu_GLParameters.addAction(self.action_SaveAsGLParameters)
# Creating connexions
self.connect(self.action_ResetGLParameters, QtCore.SIGNAL("triggered()"), self.ResetGLParameters)
self.connect(self.action_OpenGLParameters, QtCore.SIGNAL("triggered()"), self.OpenGLParameters)
self.connect(self.action_SaveGLParameters, QtCore.SIGNAL("triggered()"), self.SaveGLParameters)
self.connect(self.action_SaveAsGLParameters, QtCore.SIGNAL("triggered()"), self.SaveAsGLParameters)
##########################
### GL Object Menu ###
##########################
self.action_AddAxes = QtGui.QAction(self)
self.action_AddAxes.setText(self.tr("&Add Axes"))
self.action_AddGrid = QtGui.QAction(self)
self.action_AddGrid.setText(self.tr("&Add Grid"))
self.action_AddSphere = QtGui.QAction(self)
self.action_AddSphere.setText(self.tr("&Add Sphere"))
self.action_AddBox = QtGui.QAction(self)
self.action_AddBox.setText(self.tr("&Add Box"))
self.action_AddObjectsFromFile = QtGui.QAction(self)
self.action_AddObjectsFromFile.setText(self.tr("&Add Objects from file"))
self.action_RemoveObjects = QtGui.QAction(self)
self.action_RemoveObjects.setText(self.tr("&Remove all objects"))
# Add Actions to menu
self.menu_Objects = QtGui.QMenu(self.tr("&GL Objects"), self)
self.menu_Objects.addAction(self.action_AddAxes)
self.menu_Objects.addAction(self.action_AddGrid)
self.menu_Objects.addAction(self.action_AddSphere)
self.menu_Objects.addAction(self.action_AddBox)
self.menu_Objects.addAction(self.action_AddObjectsFromFile)
self.menu_Objects.addSeparator()
self.menu_Objects.addAction(self.action_RemoveObjects)
# Creating connexions
self.connect(self.action_AddAxes, QtCore.SIGNAL("triggered()"), self.AddAxes)
self.connect(self.action_AddGrid, QtCore.SIGNAL("triggered()"), self.AddGrid)
self.connect(self.action_AddSphere, QtCore.SIGNAL("triggered()"), self.AddSphere)
self.connect(self.action_AddBox, QtCore.SIGNAL("triggered()"), self.AddBox)
self.connect(self.action_AddObjectsFromFile, QtCore.SIGNAL("triggered()"), self.AddObjectsFromFile)
self.connect(self.action_RemoveObjects, QtCore.SIGNAL("triggered()"), self.RemoveObjects)
##########################
### GL Mode Menu ###
##########################
self.action_NormalMode = QtGui.QAction(self)
self.action_NormalMode.setText(self.tr("&Normal Mode"))
self.action_FlightMode = QtGui.QAction(self)
self.action_FlightMode.setText(self.tr("&Flight Mode"))
self.action_RotationMode = QtGui.QAction(self)
self.action_RotationMode.setText(self.tr("&Rotation Mode"))
self.action_RotationOnlyMode = QtGui.QAction(self)
self.action_RotationOnlyMode.setText(self.tr("&Rotation Only Mode"))
self.action_SetAutoMotionOn = QtGui.QAction(self)
self.action_SetAutoMotionOn.setText(self.tr("&Auto-motion on"))
self.action_SetAutoMotionOff = QtGui.QAction(self)
self.action_SetAutoMotionOff.setText(self.tr("&Auto-motion off"))
# Add Actions to menu
self.menu_GLMode = QtGui.QMenu(self.tr("&GL Mode"), self)
self.menu_GLMode.addAction(self.action_NormalMode)
self.menu_GLMode.addAction(self.action_FlightMode)
self.menu_GLMode.addAction(self.action_RotationMode)
self.menu_GLMode.addAction(self.action_RotationOnlyMode)
self.menu_GLMode.addSeparator()
self.menu_GLMode.addAction(self.action_SetAutoMotionOn)
self.menu_GLMode.addAction(self.action_SetAutoMotionOff)
# Creating connexions
self.connect(self.action_NormalMode, QtCore.SIGNAL("triggered()"), self.NormalMode)
self.connect(self.action_FlightMode, QtCore.SIGNAL("triggered()"), self.FlightMode)
self.connect(self.action_RotationMode, QtCore.SIGNAL("triggered()"), self.RotationMode)
self.connect(self.action_RotationOnlyMode, QtCore.SIGNAL("triggered()"), self.RotationOnlyMode)
self.connect(self.action_SetAutoMotionOn, QtCore.SIGNAL("triggered()"), self.AutoMotionOn)
self.connect(self.action_SetAutoMotionOff, QtCore.SIGNAL("triggered()"), self.AutoMotionOff)
##########################
### GL Palette Menu ###
##########################
self.menu_GLPalette = QtGui.QMenu(self.tr("&GL Palette"), self)
self.menu_GLPalette.setTearOffEnabled(True)
# look at the availables colormap tables
tables = glob.glob(os.path.join(parameters.PALETTEDIR,'*'))
tables.sort()
self.actionColormap = []
# generate Colormap menu (Palettes...)
for table in tables:
self.actionColormap.append(QtGui.QAction(self))
self.actionColormap[-1].setObjectName(os.path.basename(table))
self.actionColormap[-1].setText(os.path.basename(table))
self.menu_GLPalette.addAction(self.actionColormap[-1])
# Set Palette variable
QtCore.QObject.connect(self.actionColormap[-1], QtCore.SIGNAL("triggered()"), lambda x=os.path.basename(table): self.setGLPalette(x))
##########################
### Palette Menu ###
##########################
self.palette = "rainbow4"
self.menu_Palette = QtGui.QMenu(self.tr("&Palette"), self)
self.menu_Palette.setTearOffEnabled(True)
# look at the availables colormap tables
tables = glob.glob(os.path.join(parameters.PALETTEDIR,'*'))
tables.sort()
self.actionColormap = []
# generate Colormap menu (Palettes...)
for table in tables:
self.actionColormap.append(QtGui.QAction(self))
self.actionColormap[-1].setObjectName(os.path.basename(table))
self.actionColormap[-1].setText(os.path.basename(table))
self.menu_Palette.addAction(self.actionColormap[-1])
# Set Palette variable
QtCore.QObject.connect(self.actionColormap[-1], QtCore.SIGNAL("triggered()"), lambda x=os.path.basename(table): self.setPalette(x))
### Actions ###
self.action_pos = QtGui.QAction(self)
self.action_pos.setText("pos")
self.action_vel = QtGui.QAction(self)
self.action_vel.setText("vel")
self.action_m = QtGui.QAction(self)
self.action_m.setText("m")
self.action_u = QtGui.QAction(self)
self.action_u.setText("u")
self.action_rho = QtGui.QAction(self)
self.action_rho.setText("rho")
self.action_T = QtGui.QAction(self)
self.action_T.setText("T")
self.action_A = QtGui.QAction(self)
self.action_A.setText("A")
self.action_P = QtGui.QAction(self)
self.action_P.setText("P")
self.action_Tcool = QtGui.QAction(self)
self.action_Tcool.setText("Tcool")
self.action_Lum = QtGui.QAction(self)
self.action_Lum.setText("Lum")
self.action_Ne = QtGui.QAction(self)
self.action_Ne.setText("Ne")
self.action_x = QtGui.QAction(self)
self.action_x.setText("x")
self.action_y = QtGui.QAction(self)
self.action_y.setText("y")
self.action_z = QtGui.QAction(self)
self.action_z.setText("z")
self.action_x2 = QtGui.QAction(self)
self.action_x2.setText("x2")
self.action_y2 = QtGui.QAction(self)
self.action_y2.setText("y2")
self.action_z2 = QtGui.QAction(self)
self.action_z2.setText("z2")
self.action_vx = QtGui.QAction(self)
self.action_vx.setText("vx")
self.action_vy = QtGui.QAction(self)
self.action_vy.setText("vy")
self.action_vz = QtGui.QAction(self)
self.action_vz.setText("vz")
self.action_lx = QtGui.QAction(self)
self.action_lx.setText("lx")
self.action_ly = QtGui.QAction(self)
self.action_ly.setText("ly")
self.action_lz = QtGui.QAction(self)
self.action_lz.setText("lz")
self.action_Lx = QtGui.QAction(self)
self.action_Lx.setText("Lx")
self.action_Ly = QtGui.QAction(self)
self.action_Ly.setText("Ly")
self.action_Lz = QtGui.QAction(self)
self.action_Lz.setText("Lz")
self.action_vx2 = QtGui.QAction(self)
self.action_vx2.setText("vx2")
self.action_vy2 = QtGui.QAction(self)
self.action_vy2.setText("vy2")
self.action_vz2 = QtGui.QAction(self)
self.action_vz2.setText("vz2")
self.action_svr = QtGui.QAction(self)
self.action_svr.setText("svr")
self.action_vxyr = QtGui.QAction(self)
self.action_vxyr.setText("vxyr")
self.action_vxyr2 = QtGui.QAction(self)
self.action_vxyr2.setText("vxyr2")
self.action_svxyr = QtGui.QAction(self)
self.action_svxyr.setText("svxyr")
self.action_vtr = QtGui.QAction(self)
self.action_vtr.setText("vtr")
self.action_vtr2 = QtGui.QAction(self)
self.action_vtr2.setText("vtr2")
self.action_svtr = QtGui.QAction(self)
self.action_svtr.setText("svtr")
self.action_szr = QtGui.QAction(self)
self.action_szr.setText("szr")
### Add Actions to Menu ###
self.menu_Mode = QtGui.QMenu(self.tr("&Mode"), self)
self.menu_Mode.addAction(self.action_pos)
self.menu_Mode.addAction(self.action_vel)
self.menu_Mode.addSeparator()
self.menu_Mode.addAction(self.action_m)
self.menu_Mode.addAction(self.action_u)
self.menu_Mode.addAction(self.action_rho)
self.menu_Mode.addAction(self.action_T)
self.menu_Mode.addAction(self.action_A)
self.menu_Mode.addAction(self.action_P)
self.menu_Mode.addAction(self.action_Tcool)
self.menu_Mode.addAction(self.action_Lum)
self.menu_Mode.addAction(self.action_Ne)
self.menu_Mode.addSeparator()
self.menu_Mode.addAction(self.action_x)
self.menu_Mode.addAction(self.action_y)
self.menu_Mode.addAction(self.action_z)
self.menu_Mode.addAction(self.action_x2)
self.menu_Mode.addAction(self.action_y2)
self.menu_Mode.addAction(self.action_z2)
self.menu_Mode.addAction(self.action_vx)
self.menu_Mode.addAction(self.action_vy)
self.menu_Mode.addAction(self.action_vz)
self.menu_Mode.addSeparator()
self.menu_Mode.addAction(self.action_lx)
self.menu_Mode.addAction(self.action_ly)
self.menu_Mode.addAction(self.action_lz)
self.menu_Mode.addAction(self.action_Lx)
self.menu_Mode.addAction(self.action_Ly)
self.menu_Mode.addAction(self.action_Lz)
self.menu_Mode.addSeparator()
self.menu_Mode.addAction(self.action_vx2)
self.menu_Mode.addAction(self.action_vy2)
self.menu_Mode.addAction(self.action_vz2)
self.menu_Mode.addAction(self.action_svr)
self.menu_Mode.addAction(self.action_vxyr)
self.menu_Mode.addAction(self.action_vxyr2)
self.menu_Mode.addAction(self.action_svxyr)
self.menu_Mode.addAction(self.action_vtr)
self.menu_Mode.addAction(self.action_vtr2)
self.menu_Mode.addAction(self.action_svtr)
self.menu_Mode.addAction(self.action_szr)
############################
### MP Parameteters Menu ###
############################
self.action_ResetMPParameters = QtGui.QAction(self)
self.action_ResetMPParameters.setText(self.tr("&Reset"))
self.action_OpenMPParameters = QtGui.QAction(self)
self.action_OpenMPParameters.setText(self.tr("&Open"))
self.action_SaveMPParameters = QtGui.QAction(self)
self.action_SaveMPParameters.setText(self.tr("&Save"))
self.action_SaveAsMPParameters = QtGui.QAction(self)
self.action_SaveAsMPParameters.setText(self.tr("&Save As"))
### Add Actions to Menu Parameters###
self.menu_MPParameters= QtGui.QMenu(self.tr("&MP Parameters"), self)
self.menu_MPParameters.addAction(self.action_ResetMPParameters)
self.menu_MPParameters.addAction(self.action_OpenMPParameters)
self.menu_MPParameters.addSeparator()
self.menu_MPParameters.addAction(self.action_SaveMPParameters)
self.menu_MPParameters.addAction(self.action_SaveAsMPParameters)
# Creating connexions
self.connect(self.action_ResetMPParameters, QtCore.SIGNAL("triggered()"), self.ResetMPParameters)
self.connect(self.action_OpenMPParameters, QtCore.SIGNAL("triggered()"), self.OpenMPParameters)
self.connect(self.action_SaveMPParameters, QtCore.SIGNAL("triggered()"), self.SaveMPParameters)
self.connect(self.action_SaveAsMPParameters, QtCore.SIGNAL("triggered()"), self.SaveAsMPParameters)
#############################
### Menu Units Parameters ###
#############################
self.action_Set = QtGui.QAction(self)
self.action_Set.setText(self.tr("&Set"))
self.action_Reset = QtGui.QAction(self)
self.action_Reset.setText(self.tr("&Reset"))
self.action_Open = QtGui.QAction(self)
self.action_Open.setText(self.tr("&Open"))
self.action_Save = QtGui.QAction(self)
self.action_Save.setText(self.tr("&Save"))
self.action_SaveAs = QtGui.QAction(self)
self.action_SaveAs.setText(self.tr("&Save As"))
### Add Actions to Menu Unit_Parameters###
self.menu_Unit_Parameters= QtGui.QMenu(self.tr("&Unit_Parameters"), self)
self.menu_Unit_Parameters.addAction(self.action_Set)
self.menu_Unit_Parameters.addSeparator()
self.menu_Unit_Parameters.addAction(self.action_Reset)
self.menu_Unit_Parameters.addAction(self.action_Open)
self.menu_Unit_Parameters.addSeparator()
self.menu_Unit_Parameters.addAction(self.action_Save)
self.menu_Unit_Parameters.addAction(self.action_SaveAs)
# Adding menus to MenuBar
self.myBar.addMenu(self.menu_File)
self.myBar.addMenu(self.menu_Operations)
self.myBar.addMenu(self.menu_GLParameters)
self.myBar.addMenu(self.menu_Objects)
self.myBar.addMenu(self.menu_GLMode)
self.myBar.addMenu(self.menu_GLPalette)
def showDock(self, a): # Changes Dock and menus that must be displayed according to the current Tab (Map or GL view)
if a: # Map view selected
self.paramsDockWidget.show()
self.controllDockWidget.hide()
self.myBar.clear()
self.myBar.addMenu(self.menu_File)
self.myBar.addMenu(self.menu_Operations)
self.myBar.addMenu(self.menu_Palette)
self.myBar.addMenu(self.menu_Mode)
self.myBar.addMenu(self.menu_MPParameters)
self.myBar.addMenu(self.menu_Unit_Parameters)
else: # GL View selected
self.paramsDockWidget.hide()
self.controllDockWidget.show()
self.myBar.clear()
self.myBar.addMenu(self.menu_File)
self.myBar.addMenu(self.menu_Operations)
self.myBar.addMenu(self.menu_GLParameters)
self.myBar.addMenu(self.menu_Objects)
self.myBar.addMenu(self.menu_GLMode)
self.myBar.addMenu(self.menu_GLPalette)
################################################
#
# FILE MENU
#
################################################
###########################
def OpenFile(self):
###########################
filenames = QtGui.QFileDialog.getOpenFileNames(self, self.trUtf8("Open Model"), ".", self.trUtf8("Any Files (*)"))
if filenames:
firstfile = str(filenames[0])
for filename in filenames:
self.ModelFiles.append(str(filename))
self.CurrentFile = firstfile
self.LoadFile(self.CurrentFile)
###########################
def WriteFile(self):
###########################
filename = QtGui.QFileDialog.getSaveFileName(self, self.trUtf8("Save File"), "./untitled.dat", self.trUtf8("Dat Files (*.dat)"))
if filename:
self.nb.rename(filename)
self.nb.write()
###########################
def SaveGLImage(self):
###########################
filename = QtGui.QFileDialog.getSaveFileName(self, self.trUtf8("Save File"), "./image.gif", self.trUtf8("Dat Files (*)"))
if filename:
self.glWidget.SaveImage(str(filename))
###########################
def SaveMapImage(self):
###########################
filename = QtGui.QFileDialog.getSaveFileName(self, self.trUtf8("Save File"), "./image.jpg", self.trUtf8("Dat Files (*)"))
if filename:
filename = str(filename)
if os.path.splitext(filename)[1] == ".fits":
io.WriteFits(transpose(self.ImageMat).astype(float32),filename, None)
else:
self.mpWidget.SaveMap(filename,self.ImageMat,self.ImageMatint, self.palette)
###########################
def Quit(self,*arg,**kw):
###########################
self.BroadcastCmd("Quit",arg,kw)
#QtCore.SLOT("close()")
sys.exit()
################################################
#
# OPERATIONS MENU
#
################################################
###########################
def Info(self,*arg,**kw):
###########################
self.BroadcastCmd("Info",arg,kw)
'''
Display info on the current file
'''
self.nb.info()
###########################
def ObjectInfo(self,*arg,**kw):
###########################
self.BroadcastCmd("ObjectInfo",arg,kw)
'''
Display info on the current file
'''
self.nb.object_info()
###########################
def NodeInfo(self,*arg,**kw):
###########################
self.BroadcastCmd("NodeInfo",arg,kw)
'''
Display info on the current nodes
'''
self.nb.nodes_info()
###########################
def SelectFromNumFile(self):
###########################
filename = QtGui.QFileDialog.getOpenFileName(self, self.trUtf8("Open Numfile"), ".", self.trUtf8("Any Files (*)"))
if filename:
num = io.read_ascii(filename,[0])[0]
self.nb = self.nb.selectp(num)
self.update()
###########################
def WriteNumFile(self):
###########################
filename = QtGui.QFileDialog.getSaveFileName(self, self.trUtf8("Save File"), "./data.num", self.trUtf8("Dat Files (*)"))
if filename:
f = open(filename,'w')
for n in self.nb.num:
f.write('%8i\n'%(n))
f.close()
###########################
def ComputeDelaunay(self):
###########################
DelaunayFile='/tmp/delaunay.dat'
delaunay.ComputeDelaunay(self.nb.pos,DelaunayFile=DelaunayFile)
###########################
def DrawDelaunayLines(self):
###########################
self.gl.AddNewDelaunayLines(DelaunayFile='/tmp/delaunay.dat')
###########################
def DrawDelaunaySurface(self):
###########################
self.gl.AddNewDelaunaySurface(DelaunayFile='/tmp/delaunay.dat')
###########################
def AddAxes(self):
###########################
self.glWidget.AddNewAxes()
###########################
def AddGrid(self):
###########################
self.glWidget.AddNewGrid()
###########################
def AddBox(self):
###########################
self.glWidget.AddNewBox()
###########################
def AddSphere(self):
###########################
self.glWidget.AddNewSphere()
###########################
def AddObjectsFromFile(self):
###########################
filename = QtGui.QFileDialog.getOpenFileName(self, self.trUtf8("Open file"), ".", self.trUtf8("Any Files (*)"))
if filename:
self.glWidget.AddObjectsFromParameterFile(filename)
###########################
def RemoveObjects(self):
###########################
self.glWidget.RemoveAllObjects()
################################################
#
# GL PARAMETERS MENU
#
################################################
def ResetGLParameters(self):
self.glWidget.RemoveAllObjects()
self.glWidget.InitObjectsFromParameterFile()
self.glWidget.ReadParameters()
def OpenGLParameters(self):
filename = QtGui.QFileDialog.getOpenFileName(self, self.trUtf8("Open GL parameters"), ".", self.trUtf8("Any Files (*)"))
if filename:
self.glWidget.RemoveAllObjects()
self.glWidget.InitObjectsFromParameterFile(filename)
self.glWidget.ReadParameters(filename)
def SaveGLParameters(self):
self.glWidget.WriteParameters()
def SaveAsGLParameters(self):
filename = QtGui.QFileDialog.getSaveFileName(self, self.trUtf8("Save File"), "./glparameters", self.trUtf8("Dat Files (*)"))
if filename:
self.glWidget.WriteParameters(filename)
################################################
#
# MP PARAMETERS MENU
#
################################################
def ResetMPParameters(self):
paramname = PARAMETERFILE
if os.path.exists(paramname):
self.paramsDockWidgetContents.parameters.read(paramname)
self.paramsDockWidgetContents.AutoSetParameters() # ne met pas a jours...
def OpenMPParameters(self):
filename = QtGui.QFileDialog.getOpenFileName(self, self.trUtf8("Open GL parameters"), ".", self.trUtf8("Any Files (*)"))
if filename:
parameters = Params(filename,None)
self.paramsDockWidgetContents.SetParameters(parameters)
def SaveMPParameters(self):
self.paramsDockWidgetContents.parameters.save(PARAMETERFILE)
def SaveAsMPParameters(self):
filename = QtGui.QFileDialog.getSaveFileName(self, self.trUtf8("Save File"), "./params.nb", self.trUtf8("Dat Files (*)"))
if filename:
self.paramsDockWidgetContents.parameters.save(str(filename))
############################################
# Plugin
############################################
def OpenPlugin(self):
filename = QtGui.QFileDialog.getOpenFileName(self, self.trUtf8("Open plugin"), ".", self.trUtf8("Any Files (*)"))
if filename:
execfile(str(filename))
self.update()
############################################
# Mode
############################################
def NormalMode(self):
self.glWidget.SetMode('NORMAL')
def FlightMode(self):
self.glWidget.SetMode('FLIGHT')
def RotationMode(self):
self.glWidget.SetMode('ROTATION')
def RotationOnlyMode(self):
self.glWidget.SetMode('ROTATION_ONLY')
def AutoMotionOn(self):
self.glWidget.StartAutoMotion()
def AutoMotionOff(self):
self.glWidget.StopAutoMotion()
##################################################
def LoadFile(self,File):
##################################################
if self.comm.mpi_IsMaster():
self.setCursor(QtCore.Qt.WaitCursor)
self.nb = Nbody(File,ftype=self.ftype)
#apply cmd
if (self.cmd!= None) and (self.cmd!= 'None'):
print "exec : %s"%self.cmd
exec(self.cmd)
#apply plugin
if (self.plugin!= None) and (self.plugin!= 'None'):
if os.path.exists(self.plugin):
execfile(self.plugin)
if self.glWidget:
# send to gl
self.glWidget.nb = self.nb
self.glWidget.InitPoints()
self.glWidget.updateGL()
if self.comm.mpi_IsMaster():
self.setCursor(QtCore.Qt.ArrowCursor)
##################################################
def Reset(self):
##################################################
self.LoadFile(self.CurrentFile)
##################################################
def update(self):
##################################################
self.setCursor(QtCore.Qt.WaitCursor)
if self.glWidget:
# send to gl
self.glWidget.nb = self.nb
self.glWidget.InitPoints()
self.glWidget.updateGL()
self.setCursor(QtCore.Qt.ArrowCursor)
##################################################
Update = update # alias
##################################################
##################################################
def setGLPalette(self, palette_name='rainbow4'):
##################################################
self.glWidget.InitPalette(palette_name)
##################################################
def setPalette(self, palette='rainbow4'):
##################################################
self.palette = palette
self.mpWidget.DisplayMap(self.ImageMat,self.ImageMatint,self.ImageMin,self.ImageMax,self.ImageCd, self.palette)
##################################################
def Display(self, p = "rainbow4", updateFromGL = False):
##################################################
self.setCursor(QtCore.Qt.WaitCursor)
# Nbody parameters
new_nbparam = self.paramsDockWidgetContents.GetParameters()
if updateFromGL: # Only used when GL view selected.
# GL parameters
glparam = self.glWidget.getViewParameters()
# translate
self.nbparam = libutil.gl2pNbody(glparam,new_nbparam)
# send to Dock
self.paramsDockWidgetContents.SetParameters(self.nbparam)
else:
self.nbparam = new_nbparam
# make map
nbparam_dic = self.nbparam.get_dic()
self.ImageMat,self.ImageMatint,self.ImageMin,self.ImageMax,self.ImageCd = self.nb.Map(nbparam_dic)
self.ImageMin = self.ImageMin[0]
self.ImageMax = self.ImageMax[0]
self.ImageCd = self.ImageCd[0]
print "min=%10.3e max=%10.3e cd=%10.3e"%(self.ImageMin,self.ImageMax,self.ImageCd)
# display
self.mpWidget.DisplayMap(self.ImageMat,self.ImageMatint,self.ImageMin,self.ImageMax,self.ImageCd,self.palette)
self.setCursor(QtCore.Qt.ArrowCursor)
##################################################
def ReDisplay(self):
##################################################
self.setCursor(QtCore.Qt.WaitCursor)
# Nbody parameters
self.nbparam = self.paramsDockWidgetContents.GetParameters()
scale = self.nbparam.get('scale')
mn = self.nbparam.get('mn')
mx = self.nbparam.get('mx')
cd = self.nbparam.get('cd')
self.ImageMatint,self.ImageMin,self.ImageMax,self.ImageCd = libutil.set_ranges(self.ImageMat,scale,mn,mx,cd)
self.ImageMin = self.ImageMin
self.ImageMax = self.ImageMax
self.ImageCd = self.ImageCd
# add contour
l_color = self.nbparam.get('l_color')
l_n = self.nbparam.get('l_n')
l_min = self.nbparam.get('l_min')
l_max = self.nbparam.get('l_max')
l_kx = self.nbparam.get('l_kx')
l_ky = self.nbparam.get('l_ky')
l_color = self.nbparam.get('l_color')
l_crush = self.nbparam.get('l_crush')
if l_color != 0:
self.ImageMatint = contours(self.ImageMat,self.ImageMatint,l_n,l_min,l_max,l_kx,l_ky,l_color,l_crush)
# add box and ticks
b_weight = self.nbparam.get('b_weight')
shape = self.nbparam.get('shape')
size = self.nbparam.get('size')
b_weight = self.nbparam.get('b_weight')
b_xopts = self.nbparam.get('b_xopts')
b_yopts = self.nbparam.get('b_yopts')
b_color = self.nbparam.get('b_color')
if b_weight != 0:
self.ImageMatint = add_box(self.ImageMatint,shape=shape,size=size,center=None,box_opts=(b_weight,b_xopts,b_yopts,b_color))
self.mpWidget.DisplayMap(self.ImageMat,self.ImageMatint,self.ImageMin,self.ImageMax,self.ImageCd,self.palette)
self.setCursor(QtCore.Qt.ArrowCursor)
#################################################################
#
# special behavior
#
#################################################################
def CreateNbodyGridFromGLGrid(self,name):
if self.glWidget.Objects.has_key(name):
pos = self.glWidget.Objects[name].GetPos()
rot = self.glWidget.Objects[name].GetRot()
num = self.glWidget.Objects[name].GetNumber()
siz = self.glWidget.Objects[name].GetSize()
nx = num+1
ny = num+1
dx = 2*siz[0]/float((nx-1))
dy = 2*siz[1]/float((ny-1))
xmin = -siz[0]
ymin = -siz[0]
xmax = siz[1] +dx
ymax = siz[1] +dy
offx = -0.5
offy = -0.5
xpos = libgrid.get_Points_On_Carthesian_2d_Grid(nx,ny,xmin,xmax,ymin,ymax,offx,offy)
self.gr = Nbody(pos=xpos,status='new',ftype='gadget')
# apply rotation
if rot[2]!=0:
self.gr.rotate(axis='z',angle=rot[2]*pi/180)
if rot[1]!=0:
self.gr.rotate(axis='y',angle=rot[1]*pi/180)
if rot[0]!=0:
self.gr.rotate(axis='x',angle=rot[0]*pi/180)
# apply translation
self.gr.translate(pos)
self.gr.shape=(nx,ny)
self.gr.rename('gr.dat')
self.gr.write()
def ComputePotentialOnNbodyGrid(self,eps):
# compute potential
self.gr.pot = self.nb.TreePot(self.gr.pos,eps)
# make map
mat = self.gr.pot
mat.shape = self.gr.shape
#libutil.mplot(mat,save='map.fits') # ok, fonctionne
#nbparam_dic
scale = 'lin'
cd = 0.
mn = 0.
mx = 0.
self.ImageMatint,self.ImageMin,self.ImageMax,self.ImageCd = libutil.set_ranges(mat,scale,mn,mx,cd)
self.ImageMat = mat
self.ImageMin = self.ImageMin
self.ImageMax = self.ImageMax
self.ImageCd = self.ImageCd
#print "min=%10.3e max=%10.3e cd=%10.3e"%(self.ImageMin,self.ImageMax,self.ImageCd)
self.ImageMat = transpose(self.ImageMat)
self.ImageMatint = transpose(self.ImageMatint)
self.mpWidget.DisplayMap(self.ImageMat,self.ImageMatint,self.ImageMin,self.ImageMax,self.ImageCd, self.palette)
###########################################
#
# MAIN
#
###########################################
files,options = parse_options()
ParameterFile = options.parameterfile
ftype = options.ftype
width = options.width
height = options.height
cmd = options.cmd
plugin = options.plugin
MarkersFile = options.markersfile
VectorsFile = options.vectorsfile
TrkFiles = options.trkfiles
shell = options.shell
nogl = options.nogl
fullscreen = options.fullscreen
# init window
app = QtGui.QApplication(sys.argv)
board = MainBoard(argv=sys.argv,ParameterFile=ParameterFile,MarkersFile=MarkersFile,VectorsFile=VectorsFile,TrkFiles=TrkFiles,ModelFiles=files,cmd=cmd,plugin=plugin,shell=shell,nogl=nogl,comm=mpi,ftype=ftype,fullscreen=fullscreen)
board.setGeometry(0, 0, width, height)
# display board only if is master
if mpi.mpi_IsMaster():
board.show()
if fullscreen:
board.showFullScreen()
app.exec_()
c4science · Help