suzanne.soy/FreeCAD
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Implemented initialization stage

Browse Source
This commit is contained in:
Jose Luis Cercos Pita 2012-07-30 14:30:13 +02:00 committed by Yorik van Havre
parent 94c8489d0f
commit c5ec34318b
13 changed files with 747 additions and 98 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
src/Mod/Ship/CMakeLists.txt
View File

@ -56,6 +56,7 @@ SET(ShipExamples_SRCS
Examples/s60_katamaran.fcstd Examples/s60_katamaran.fcstd
Examples/wigley.fcstd Examples/wigley.fcstd
Examples/wigley_katamaran.fcstd Examples/wigley_katamaran.fcstd
OpenCL/simInit.cl
) )
SOURCE_GROUP("shipexamples" FILES ${ShipExamples_SRCS}) SOURCE_GROUP("shipexamples" FILES ${ShipExamples_SRCS})
@ -144,6 +145,9 @@ SET(SimRun_SRCS
simRun/Simulation.py simRun/Simulation.py
simRun/TaskPanel.py simRun/TaskPanel.py
simRun/TaskPanel.ui simRun/TaskPanel.ui
simRun/Sim/__init__.py
simRun/Sim/initialization.py
simRun/Sim/Utils.py
) )
SOURCE_GROUP("simrun" FILES ${SimRun_SRCS}) SOURCE_GROUP("simrun" FILES ${SimRun_SRCS})

7
src/Mod/Ship/Makefile.am
View File

@ -53,6 +53,7 @@ nobase_data_DATA = \
Examples/s60_katamaran.fcstd \ Examples/s60_katamaran.fcstd \
Examples/wigley.fcstd \ Examples/wigley.fcstd \
Examples/wigley_katamaran.fcstd \ Examples/wigley_katamaran.fcstd \
OpenCL/simInit.cl \
shipLoadExample/__init__.py \ shipLoadExample/__init__.py \
shipLoadExample/TaskPanel.py \ shipLoadExample/TaskPanel.py \
shipLoadExample/TaskPanel.ui \ shipLoadExample/TaskPanel.ui \
@ -96,7 +97,11 @@ nobase_data_DATA = \
simRun/__init__.py \ simRun/__init__.py \
simRun/Simulation.py \ simRun/Simulation.py \
simRun/TaskPanel.py \ simRun/TaskPanel.py \
simRun/TaskPanel.ui simRun/TaskPanel.ui \
simRun/Sim/__init__.py \
simRun/Sim/initialization.py
simRun/Sim/Utils.py
CLEANFILES = $(BUILT_SOURCES) CLEANFILES = $(BUILT_SOURCES)

99
src/Mod/Ship/OpenCL/simInit.cl Normal file
View File

@ -0,0 +1,99 @@
/*
* -----------------------------------------------------------------------
*
* This source file is part of AQUA-gpusph.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Library General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor Boston, MA 02110-1301, USA
*
*
* Authors:
* - Cercos Pita, Jose Luis
* - Miguel Gonzalez, Leo
* - Saelices, Jaime
* - Souto Iglesias, Antonio
*
* -----------------------------------------------------------------------
*/
#ifndef M_PI
#define M_PI 3,14159265359
#endif
#ifdef _g
#error '_g' is already defined.
#endif
#define _g __global
#ifdef _l
#error '_l' is already defined.
#endif
#define _l __local
#ifdef _c
#error '_c' is already defined.
#endif
#define _c __constant
#ifndef _grav
#define _grav 9.81
#endif
/** Setup velocity and acceleration potential for initial time step.
* @param pos Cell position.
* @param v Cell velocity.
* @param f Cell acceleration.
* @param waves Waves (A,T,phase,heading)
* @param phi Velocity potential.
* @param Phi Acceleration potential
* @param N Number of cell elements at each direction.
* @param n Number of waves.
*/
__kernel void FS(_g float4* pos, _g float4* v, _g float4* f,
_g float4* waves, _g float* phi, _g float* Phi,
uint2 N, uint n)
{
// find position in global arrays
unsigned int i = get_global_id(0);
unsigned int j = get_global_id(1);
if( (i >= N.x) || (j >= N.y) )
return;
unsigned int id = i*N.y + j;
// ---- | ------------------------ | ----
// ---- V ---- Your code here ---- V ----
unsigned int w;
for(w=0;w<n;w++){
float A = waves[w].x;
float T = waves[w].y;
float phase = waves[w].z;
float heading = M_PI*waves[w].w/180.f;
float lambda = 0.5f*_grav/M_PI * T*T;
float k = 2.f*M_PI/lambda;
float frec = 2.f*M_PI/T;
float l = pos[id].x*cos(heading) + pos[id].y*sin(heading);
// Position, velocity and acceleration
float amp = A*sin(k*l + phase);
pos[id].z = amp;
v[id].z = -frec*amp;
f[id].z = frec*frec*amp;
// Potentials
phi[id] = _grav/frec*amp;
Phi[id] = -_grav*amp;
}
// ---- A ---- Your code here ---- A ----
// ---- | ------------------------ | ----
}

BIN
src/Mod/Ship/shipUtils/Paths.pyc Normal file
View File

Binary file not shown.

BIN
src/Mod/Ship/shipUtils/__init__.pyc Normal file
View File

Binary file not shown.

57
src/Mod/Ship/simRun/Sim/Utils.py Normal file
View File

@ -0,0 +1,57 @@
#***************************************************************************
#* *
#* Copyright (c) 2011, 2012 *
#* Jose Luis Cercos Pita <jlcercos@gmail.com> *
#* *
#* This program is free software; you can redistribute it and/or modify *
#* it under the terms of the GNU Lesser General Public License (LGPL) *
#* as published by the Free Software Foundation; either version 2 of *
#* the License, or (at your option) any later version. *
#* for detail see the LICENCE text file. *
#* *
#* This program is distributed in the hope that it will be useful, *
#* but WITHOUT ANY WARRANTY; without even the implied warranty of *
#* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
#* GNU Library General Public License for more details. *
#* *
#* You should have received a copy of the GNU Library General Public *
#* License along with this program; if not, write to the Free Software *
#* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 *
#* USA *
#* *
#***************************************************************************
# FreeCAD
from shipUtils import Paths
# pyOpenCL
import pyopencl as cl
import numpy as np
# Standard
import math
def loadProgram(context, file):
""" Loads a file and comnpile it.
@param context OpenCL context where apply.
@param file File to load and compile.
@return Ready to use OpenCL program.
"""
f = open(file, 'r')
str = "".join(f.readlines())
return cl.Program(context, str).build()
def clPath():
""" Gets the OpenCL kernels path
@return OpenCL kernels path
"""
path = Paths.modulePath() + "/OpenCL"
return path
def globalSize(n):
""" Compute global size from amount of data.
@param n Amount of data.
@return global size.
"""
localSize = 256.0
return int(math.ceil(n/localSize)*localSize)

58
src/Mod/Ship/simRun/Sim/Utils.py~ Normal file
View File

@ -0,0 +1,58 @@
#***************************************************************************
#* *
#* Copyright (c) 2011, 2012 *
#* Jose Luis Cercos Pita <jlcercos@gmail.com> *
#* *
#* This program is free software; you can redistribute it and/or modify *
#* it under the terms of the GNU Lesser General Public License (LGPL) *
#* as published by the Free Software Foundation; either version 2 of *
#* the License, or (at your option) any later version. *
#* for detail see the LICENCE text file. *
#* *
#* This program is distributed in the hope that it will be useful, *
#* but WITHOUT ANY WARRANTY; without even the implied warranty of *
#* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
#* GNU Library General Public License for more details. *
#* *
#* You should have received a copy of the GNU Library General Public *
#* License along with this program; if not, write to the Free Software *
#* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 *
#* USA *
#* *
#***************************************************************************
# FreeCAD
from shipUtils import Paths
# pyOpenCL
import pyopencl as cl
import numpy as np
# Standard
import math
def loadProgram(context, file):
""" Loads a file and comnpile it.
@param context OpenCL context where apply.
@param file File to load and compile.
@return Ready to use OpenCL program.
"""
f = open(file, 'r')
str = "".join(f.readlines())
print(str)
return cl.Program(context, str).build()
def clPath():
""" Gets the OpenCL kernels path
@return OpenCL kernels path
"""
path = Paths.modulePath() + "/OpenCL"
return path
def globalSize(n):
""" Compute global size from amount of data.
@param n Amount of data.
@return global size.
"""
localSize = 256.0
return int(math.ceil(n/localSize)*localSize)

24
src/Mod/Ship/simRun/Sim/__init__.py Normal file
View File

@ -0,0 +1,24 @@
#***************************************************************************
#* *
#* Copyright (c) 2011, 2012 *
#* Jose Luis Cercos Pita <jlcercos@gmail.com> *
#* *
#* This program is free software; you can redistribute it and/or modify *
#* it under the terms of the GNU Lesser General Public License (LGPL) *
#* as published by the Free Software Foundation; either version 2 of *
#* the License, or (at your option) any later version. *
#* for detail see the LICENCE text file. *
#* *
#* This program is distributed in the hope that it will be useful, *
#* but WITHOUT ANY WARRANTY; without even the implied warranty of *
#* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
#* GNU Library General Public License for more details. *
#* *
#* You should have received a copy of the GNU Library General Public *
#* License along with this program; if not, write to the Free Software *
#* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 *
#* USA *
#* *
#***************************************************************************
import initialization, Utils

57
src/Mod/Ship/simRun/Sim/__init__.py~ Normal file
View File

@ -0,0 +1,57 @@
#***************************************************************************
#* *
#* Copyright (c) 2011, 2012 *
#* Jose Luis Cercos Pita <jlcercos@gmail.com> *
#* *
#* This program is free software; you can redistribute it and/or modify *
#* it under the terms of the GNU Lesser General Public License (LGPL) *
#* as published by the Free Software Foundation; either version 2 of *
#* the License, or (at your option) any later version. *
#* for detail see the LICENCE text file. *
#* *
#* This program is distributed in the hope that it will be useful, *
#* but WITHOUT ANY WARRANTY; without even the implied warranty of *
#* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
#* GNU Library General Public License for more details. *
#* *
#* You should have received a copy of the GNU Library General Public *
#* License along with this program; if not, write to the Free Software *
#* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 *
#* USA *
#* *
#***************************************************************************
# FreeCAD
from shipUtils import Paths
# pyOpenCL
import pyopencl as cl
import numpy as np
# Standard
import math
def loadProgram(context, file):
""" Loads a file and comnpile it.
@param context OpenCL context where apply.
@param file File to load and compile.
@return Ready to use OpenCL program.
"""
f = open(file, 'r')
str = "".join(f.readlines())
return cl.Program(context, str).build()
def clPath():
""" Gets the OpenCL kernels path
@return OpenCL kernels path
"""
path = Paths.modulePath() + "/OpenCL"
return path
def globalSize(n):
""" Compute global size from amount of data.
@param n Amount of data.
@return global size.
"""
localSize = 256
return int(math.ceil(n/localSize))

113
src/Mod/Ship/simRun/Sim/initialization.py Normal file
View File

@ -0,0 +1,113 @@
#***************************************************************************
#* *
#* Copyright (c) 2011, 2012 *
#* Jose Luis Cercos Pita <jlcercos@gmail.com> *
#* *
#* This program is free software; you can redistribute it and/or modify *
#* it under the terms of the GNU Lesser General Public License (LGPL) *
#* as published by the Free Software Foundation; either version 2 of *
#* the License, or (at your option) any later version. *
#* for detail see the LICENCE text file. *
#* *
#* This program is distributed in the hope that it will be useful, *
#* but WITHOUT ANY WARRANTY; without even the implied warranty of *
#* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
#* GNU Library General Public License for more details. *
#* *
#* You should have received a copy of the GNU Library General Public *
#* License along with this program; if not, write to the Free Software *
#* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 *
#* USA *
#* *
#***************************************************************************
# Simulation stuff
from Utils import *
# pyOpenCL
import pyopencl as cl
import numpy as np
class perform:
def __init__(self, context, queue, FSmesh, waves):
""" Constructor, includes program loading.
@param context OpenCL context where apply.
@param queue OpenCL command queue.
@param FSmesh Initial free surface mesh.
@param waves Considered simulation waves (A,T,phi,heading).
"""
self.context = context
self.queue = queue
self.program = loadProgram(context, clPath() + "/simInit.cl")
self.loadData(FSmesh, waves)
self.execute()
def loadData(self, FSmesh, waves):
""" Convert data to numpy format, and create OpenCL
buffers.
@param FSmesh Initial free surface mesh.
@param waves Considered simulation waves (A,T,phi,heading).
"""
mf = cl.mem_flags
nx = len(FSmesh)
ny = len(FSmesh[0])
nW = len(waves)
# Mesh data
p = np.ndarray((nx*ny, 4), dtype=np.float32)
n = np.ndarray((nx*ny, 4), dtype=np.float32)
a = np.ndarray((nx*ny, 1), dtype=np.float32)
for i in range(0, nx):
for j in range(0, ny):
id = i*ny + j
pos = FSmesh[i][j].pos
normal = FSmesh[i][j].normal
area = FSmesh[i][j].area
p[id,0] = pos.x
p[id,1] = pos.y
p[id,2] = pos.z
p[id,3] = 1.
n[id,0] = normal.x
n[id,1] = normal.y
n[id,2] = normal.z
n[id,3] = 0.
a[id,0] = area
p_cl = cl.Buffer(self.context, mf.READ_WRITE | mf.COPY_HOST_PTR, hostbuf=p)
n_cl = cl.Buffer(self.context, mf.READ_WRITE | mf.COPY_HOST_PTR, hostbuf=n)
a_cl = cl.Buffer(self.context, mf.READ_WRITE | mf.COPY_HOST_PTR, hostbuf=a)
v_cl = cl.Buffer(self.context, mf.READ_WRITE, size = nx*ny*4 * np.dtype('float32').itemsize)
f_cl = cl.Buffer(self.context, mf.READ_WRITE, size = nx*ny*4 * np.dtype('float32').itemsize)
phi = cl.Buffer(self.context, mf.READ_WRITE, size = nx*ny * np.dtype('float32').itemsize)
Phi = cl.Buffer(self.context, mf.READ_WRITE, size = nx*ny * np.dtype('float32').itemsize)
self.fs = {'Nx':nx, 'Ny':ny, 'pos':p_cl, 'vel':v_cl, 'acc':f_cl, \
'normal':n_cl, 'area':a_cl, 'velPot':phi, 'accPot':Phi}
# Waves data
w = np.ndarray((nW, 4), dtype=np.float32)
for i in range(0,nW):
w[i,0] = waves[i][0]
w[i,1] = waves[i][1]
w[i,2] = waves[i][2]
w[i,3] = waves[i][3]
w_cl = cl.Buffer(self.context, mf.READ_WRITE | mf.COPY_HOST_PTR, hostbuf=w)
self.waves = {'N':nW, 'data':w_cl}
# Ensure that all data has been written
self.queue.finish()
def execute(self):
""" Compute initial conditions. """
# Global size computation
N = np.ndarray((2, 1), dtype=np.uint32)
N[0] = self.fs['Nx']
N[1] = self.fs['Ny']
n = np.uint32(self.waves['N'])
gSize = (globalSize(N[0]),globalSize(N[1]),)
# Kernel arguments
kernelargs = (self.fs['pos'],
self.fs['vel'],
self.fs['acc'],
self.waves['data'],
self.fs['velPot'],
self.fs['accPot'],
N, n)
# Kernel launch
self.program.FS(self.queue, gSize, None, *(kernelargs))
self.queue.finish()

117
src/Mod/Ship/simRun/Sim/initialization.py~ Normal file
View File

@ -0,0 +1,117 @@
#***************************************************************************
#* *
#* Copyright (c) 2011, 2012 *
#* Jose Luis Cercos Pita <jlcercos@gmail.com> *
#* *
#* This program is free software; you can redistribute it and/or modify *
#* it under the terms of the GNU Lesser General Public License (LGPL) *
#* as published by the Free Software Foundation; either version 2 of *
#* the License, or (at your option) any later version. *
#* for detail see the LICENCE text file. *
#* *
#* This program is distributed in the hope that it will be useful, *
#* but WITHOUT ANY WARRANTY; without even the implied warranty of *
#* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
#* GNU Library General Public License for more details. *
#* *
#* You should have received a copy of the GNU Library General Public *
#* License along with this program; if not, write to the Free Software *
#* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 *
#* USA *
#* *
#***************************************************************************
# Simulation stuff
from Utils import *
# pyOpenCL
import pyopencl as cl
import numpy as np
class perform:
def __init__(self, context, queue, FSmesh, waves):
""" Constructor, includes program loading.
@param context OpenCL context where apply.
@param queue OpenCL command queue.
@param FSmesh Initial free surface mesh.
@param waves Considered simulation waves (A,T,phi,heading).
"""
self.context = context
self.queue = queue
self.program = loadProgram(context, clPath() + "/simInit.cl")
self.loadData(FSmesh, waves)
self.execute()
def loadData(self, FSmesh, waves):
""" Convert data to numpy format, and create OpenCL
buffers.
@param FSmesh Initial free surface mesh.
@param waves Considered simulation waves (A,T,phi,heading).
"""
mf = cl.mem_flags
nx = len(FSmesh)
ny = len(FSmesh[0])
nW = len(waves)
# Mesh data
p = np.ndarray((nx*ny, 4), dtype=np.float32)
n = np.ndarray((nx*ny, 4), dtype=np.float32)
a = np.ndarray((nx*ny, 1), dtype=np.float32)
for i in range(0, nx):
for j in range(0, ny):
id = i*ny + j
pos = FSmesh[i][j].pos
normal = FSmesh[i][j].normal
area = FSmesh[i][j].area
p[id,0] = pos.x
p[id,1] = pos.y
p[id,2] = pos.z
p[id,3] = 1.
n[id,0] = normal.x
n[id,1] = normal.y
n[id,2] = normal.z
n[id,3] = 0.
a[id,0] = area
p_cl = cl.Buffer(self.context, mf.READ_WRITE | mf.COPY_HOST_PTR, hostbuf=p)
n_cl = cl.Buffer(self.context, mf.READ_WRITE | mf.COPY_HOST_PTR, hostbuf=n)
a_cl = cl.Buffer(self.context, mf.READ_WRITE | mf.COPY_HOST_PTR, hostbuf=a)
v_cl = cl.Buffer(self.context, mf.READ_WRITE, size = nx*ny*4 * np.dtype('float32').itemsize)
f_cl = cl.Buffer(self.context, mf.READ_WRITE, size = nx*ny*4 * np.dtype('float32').itemsize)
phi = cl.Buffer(self.context, mf.READ_WRITE, size = nx*ny * np.dtype('float32').itemsize)
Phi = cl.Buffer(self.context, mf.READ_WRITE, size = nx*ny * np.dtype('float32').itemsize)
self.fs = {'Nx':nx, 'Ny':ny, 'pos':p_cl, 'vel':v_cl, 'acc':f_cl, \
'normal':n_cl, 'area':a_cl, 'velPot':phi, 'accPot':Phi}
# Waves data
w = np.ndarray((nW, 4), dtype=np.float32)
for i in range(0,nW):
w[i,0] = waves[i][0]
w[i,1] = waves[i][1]
w[i,2] = waves[i][2]
w[i,3] = waves[i][3]
w_cl = cl.Buffer(self.context, mf.READ_WRITE | mf.COPY_HOST_PTR, hostbuf=w)
self.waves = {'N':nW, 'data':w_cl}
# Ensure that all data has been written
self.queue.finish()
def execute(self):
""" Compute initial conditions. """
# Global size computation
N = np.ndarray((2, 1), dtype=np.uint32)
N[0] = self.fs['Nx']
N[1] = self.fs['Ny']
n = np.uint32(self.waves['N'])
gSize = (globalSize(N[0]),globalSize(N[1]),)
print(gSize)
# Kernel arguments
kernelargs = (self.fs['pos'],
self.fs['vel'],
self.fs['acc'],
self.waves['data'],
self.fs['velPot'],
self.fs['accPot'],
N, n)
print('Launching...')
# Kernel launch
self.program.FS(self.queue, gSize, None, *(kernelargs))
print('Waiting...')
self.queue.finish()
print('OK!')

202
src/Mod/Ship/simRun/Simulation.py
View File

@ -1,97 +1,105 @@
#*************************************************************************** #***************************************************************************
#* * #* *
#* Copyright (c) 2011, 2012 * #* Copyright (c) 2011, 2012 *
#* Jose Luis Cercos Pita <jlcercos@gmail.com> * #* Jose Luis Cercos Pita <jlcercos@gmail.com> *
#* * #* *
#* This program is free software; you can redistribute it and/or modify * #* This program is free software; you can redistribute it and/or modify *
#* it under the terms of the GNU Lesser General Public License (LGPL) * #* it under the terms of the GNU Lesser General Public License (LGPL) *
#* as published by the Free Software Foundation; either version 2 of * #* as published by the Free Software Foundation; either version 2 of *
#* the License, or (at your option) any later version. * #* the License, or (at your option) any later version. *
#* for detail see the LICENCE text file. * #* for detail see the LICENCE text file. *
#* * #* *
#* This program is distributed in the hope that it will be useful, * #* This program is distributed in the hope that it will be useful, *
#* but WITHOUT ANY WARRANTY; without even the implied warranty of * #* but WITHOUT ANY WARRANTY; without even the implied warranty of *
#* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * #* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
#* GNU Library General Public License for more details. * #* GNU Library General Public License for more details. *
#* * #* *
#* You should have received a copy of the GNU Library General Public * #* You should have received a copy of the GNU Library General Public *
#* License along with this program; if not, write to the Free Software * #* License along with this program; if not, write to the Free Software *
#* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 * #* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 *
#* USA * #* USA *
#* * #* *
#*************************************************************************** #***************************************************************************
import time import time
from math import * from math import *
import threading import threading
# pyOpenCL # pyOpenCL
import pyopencl as cl import pyopencl as cl
import numpy as np import numpy as np
# FreeCAD # FreeCAD
import FreeCAD,FreeCADGui import FreeCAD,FreeCADGui
from FreeCAD import Base, Vector from FreeCAD import Base, Vector
import Part import Part
# Ship design module # Simulation stuff
from shipUtils import Paths, Translator, Math from Sim import initialization
class Singleton(type): # Ship design module
def __init__(cls, name, bases, dct): from shipUtils import Paths, Translator, Math
cls.__instance = None
type.__init__(cls, name, bases, dct) class Singleton(type):
def __init__(cls, name, bases, dct):
def __call__(cls, *args, **kw): cls.__instance = None
if cls.__instance is None: type.__init__(cls, name, bases, dct)
cls.__instance = type.__call__(cls, *args,**kw)
return cls.__instance def __call__(cls, *args, **kw):
if cls.__instance is None:
class FreeCADShipSimulation(threading.Thread): cls.__instance = type.__call__(cls, *args,**kw)
__metaclass__ = Singleton return cls.__instance
def __init__ (self, device, endTime, output, FSmesh, waves):
""" Thread constructor. class FreeCADShipSimulation(threading.Thread):
@param device Device to use. __metaclass__ = Singleton
@param endTime Maximum simulation time. def __init__ (self, device, endTime, output, FSmesh, waves):
@param output [Rate,Type] Output rate, Type=0 if FPS, 1 if IPF. """ Thread constructor.
@param FSmesh Free surface mesh faces. @param device Device to use.
@param waves Waves parameters (A,T,phi,heading) @param endTime Maximum simulation time.
""" @param output [Rate,Type] Output rate, Type=0 if FPS, 1 if IPF.
threading.Thread.__init__(self) @param FSmesh Free surface mesh faces.
# Setup as stopped @param waves Waves parameters (A,T,phi,heading)
self.active = False """
# Build OpenCL context and command queue threading.Thread.__init__(self)
self.device = device # Setup as stopped
self.context = cl.Context(devices=[self.device]) self.active = False
self.queue = cl.CommandQueue(self.context) # Build OpenCL context and command queue
# Storage data self.device = device
self.endTime = endTime self.context = cl.Context(devices=[self.device])
self.output = output self.queue = cl.CommandQueue(self.context)
self.FSmesh = FSmesh # Storage data
self.waves = waves self.endTime = endTime
self.output = output
def run(self): self.FSmesh = FSmesh
""" Runs the simulation. self.waves = waves
"""
self.active = True def run(self):
# Perform work here """ Runs the simulation.
while self.active: """
print("Im thread, Im running...") self.active = True
time.sleep(1) # Perform work here
# ... msg = Translator.translate("\t[Sim]: Initializating OpenCL...\n")
print("Im thread, step done!") FreeCAD.Console.PrintMessage(msg)
# Set thread as stopped (and prepare it to restarting) init = initialization.perform(self.context,self.queue,self.FSmesh,self.waves)
self.active = False msg = Translator.translate("\t[Sim]: Iterating (outputs will be noticed)...\n")
threading.Event().set() FreeCAD.Console.PrintMessage(msg)
threading.Thread.__init__(self) while self.active:
print("Im thread, Im running...")
def stop(self): time.sleep(1)
""" Call to stop execution. # ...
""" print("Im thread, step done!")
self.active = False # Set thread as stopped (and prepare it to restarting)
self.active = False
def isRunning(self): threading.Event().set()
""" Report thread state threading.Thread.__init__(self)
@return True if thread is running, False otherwise.
""" def stop(self):
return self.active """ Call to stop execution.
"""
self.active = False
def isRunning(self):
""" Report thread state
@return True if thread is running, False otherwise.
"""
return self.active

107
src/Mod/Ship/simRun/Simulation.py~ Normal file
View File

@ -0,0 +1,107 @@
#***************************************************************************
#* *
#* Copyright (c) 2011, 2012 *
#* Jose Luis Cercos Pita <jlcercos@gmail.com> *
#* *
#* This program is free software; you can redistribute it and/or modify *
#* it under the terms of the GNU Lesser General Public License (LGPL) *
#* as published by the Free Software Foundation; either version 2 of *
#* the License, or (at your option) any later version. *
#* for detail see the LICENCE text file. *
#* *
#* This program is distributed in the hope that it will be useful, *
#* but WITHOUT ANY WARRANTY; without even the implied warranty of *
#* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
#* GNU Library General Public License for more details. *
#* *
#* You should have received a copy of the GNU Library General Public *
#* License along with this program; if not, write to the Free Software *
#* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 *
#* USA *
#* *
#***************************************************************************
import time
from math import *
import threading
# pyOpenCL
import pyopencl as cl
import numpy as np
# FreeCAD
import FreeCAD,FreeCADGui
from FreeCAD import Base, Vector
import Part
# Simulation stuff
from Sim import initialization
# Ship design module
from shipUtils import Paths, Translator, Math
class Singleton(type):
def __init__(cls, name, bases, dct):
cls.__instance = None
type.__init__(cls, name, bases, dct)
def __call__(cls, *args, **kw):
if cls.__instance is None:
cls.__instance = type.__call__(cls, *args,**kw)
return cls.__instance
class FreeCADShipSimulation(threading.Thread):
__metaclass__ = Singleton
def __init__ (self, device, endTime, output, FSmesh, waves):
""" Thread constructor.
@param device Device to use.
@param endTime Maximum simulation time.
@param output [Rate,Type] Output rate, Type=0 if FPS, 1 if IPF.
@param FSmesh Free surface mesh faces.
@param waves Waves parameters (A,T,phi,heading)
"""
threading.Thread.__init__(self)
# Setup as stopped
self.active = False
# Build OpenCL context and command queue
self.device = device
self.context = cl.Context(devices=[self.device])
self.queue = cl.CommandQueue(self.context)
# Storage data
self.endTime = endTime
self.output = output
self.FSmesh = FSmesh
self.waves = waves
def run(self):
""" Runs the simulation.
"""
self.active = True
# Perform work here
msg = Translator.translate("\t[Sim]: Initializating OpenCL...\n")
FreeCAD.Console.PrintMessage(msg)
init = initialization.perform(self.context,self.queue,self.FSmesh,self.waves)
msg = Translator.translate("\t[Sim]: Iterating (outputs will be noticed)...\n")
FreeCAD.Console.PrintMessage(msg)
while self.active:
print("Im thread, Im running...")
time.sleep(1)
# ...
print("Im thread, step done!")
msg = Translator.translate("\t[Sim]: Output performed!\n")
FreeCAD.Console.PrintMessage(msg)
# Set thread as stopped (and prepare it to restarting)
self.active = False
threading.Event().set()
threading.Thread.__init__(self)
def stop(self):
""" Call to stop execution.
"""
self.active = False
def isRunning(self):
""" Report thread state
@return True if thread is running, False otherwise.
"""
return self.active