diff --git a/HySoP/CMake/FindFFTW.cmake b/HySoP/CMake/FindFFTW.cmake
index ffcb3e4ab80501af1cb0ae4d3de4c3aec73476d2..a7a63d86764e4d274609c5cf8a03e57c278d5d3a 100644
--- a/HySoP/CMake/FindFFTW.cmake
+++ b/HySoP/CMake/FindFFTW.cmake
@@ -68,4 +68,4 @@ find_library(FFTWFloat_LIBRARY
set(FFTW_PROCESS_INCLUDES FFTW_INCLUDE_DIR)
set(FFTW_PROCESS_LIBS FFTW_LIBRARY FFTWFloat_LIBRARY FFTW_MPI_LIBRARY)
-libfind_process(FFTW)
+ libfind_process(FFTW)
diff --git a/HySoP/INSTALL b/HySoP/INSTALL
index 8caef903e5ed8d911943f77849019481b9c5c7b3..39c96164baed457dfc2eb25c1bef8805dbfe1eab 100644
--- a/HySoP/INSTALL
+++ b/HySoP/INSTALL
@@ -18,6 +18,7 @@ Requirements :
- fftw
- cmake > 2.8
- a python implementation including numpy and mpi4py.
+- pytest library (install with python-pip)
The install consists in 3 steps. First configuration of the package, makefile, setup.py and other files generation, then build of the underlying fortran libraries and of the python package and finally copy of the required files in the appropriate place.
diff --git a/HySoP/hysop/operator/synchronizeGhosts.py b/HySoP/hysop/operator/synchronizeGhosts.py
index fd00b2dd3be42b82719bcd753b09a133de4f9813..9973a26c7a8432bac5d30bc6daa8a59f7e73a515 100644
--- a/HySoP/hysop/operator/synchronizeGhosts.py
+++ b/HySoP/hysop/operator/synchronizeGhosts.py
@@ -1,10 +1,10 @@
"""
-@file synchronizeGhosts.py
+@package parmepy.operator.synchronizeGhosts
Update ghost points for some fields defined on a specific topology.
"""
-
-from parmepy.operator import Operator
+from parmepy.operator.continuous import Operator
+from parmepy.operator.synchronizeGhosts_d import SynchronizeGhosts_d
from parmepy.constants import debug
@@ -14,38 +14,45 @@ class SynchronizeGhosts(Operator):
"""
@debug
- def __init__(self, fieldslist, topology, transferMethod):
+ def __init__(self, fieldslist, resolution=None,
+ method='', **other_config):
"""
Defines a way to send/recv values at ghosts points for a list
of fields, discretized on a given topology.
@param fieldslist : a list of fields
- @param topology : the topology common to all fields.
- @param transferMethod : which type of exchange is used.
"""
+ if isinstance(fieldslist, list):
+ Operator.__init__(self, fieldslist, method)
+ else:
+ Operator.__init__(self, [fieldslist], method)
+ self.fieldslist = fieldslist
+ self.resolution = resolution
+ self.method = method
+ self.config = other_config
@debug
def setUp(self):
"""
- Transport operator discretization method.
- Create an discrete Transport operator from given specifications.
+ SynchroGhost operator discretization method.
+ Create an discrete SynchroGhost operator from given specifications.
"""
- # 1 - get discrete fields arrays
- # 2 - get list of ghosts area
- # 3 - get neighbours
- # 4 - find what is to be send/recv, the size of the arrays and
- # allocate buffers if required
- # 5 - set send/recv order
- self.discreteOperator.setUp()
+ for v in self.variables:
+ # the topology for v ...
+ topo = self.domain.getOrCreateTopology(self.domain.dimension,
+ self.resolution[v])
+ # ... and the corresponding discrete field
+ self.discreteFields[v] = v.discretize(topo)
+ self.discreteOperator = \
+ SynchronizeGhosts_d(self.discreteFields[v], topo,
+ transferMethod=self.method, **self.config)
- @debug
- def apply(self, *args):
+ self.discreteOperator.setUp()
+ self._isUpToDate = True
- # Do the send/recv as defined in setup.
- return self.discreteOperator.apply(*args)
-if __name__ == "__main__":
+if (__name__ == "__main__"):
print __doc__
print "- Provided class : SynchronizeGhosts"
print SynchronizeGhosts.__doc__
diff --git a/HySoP/hysop/operator/synchronizeGhosts_d.py b/HySoP/hysop/operator/synchronizeGhosts_d.py
new file mode 100644
index 0000000000000000000000000000000000000000..ae04b85174dd1be268a404028bf3f5aded7a3717
--- /dev/null
+++ b/HySoP/hysop/operator/synchronizeGhosts_d.py
@@ -0,0 +1,453 @@
+"""
+@package parmepy.operator.synchronizeGhosts_d
+
+Update ghost points for some fields defined on a specific topology.
+"""
+from parmepy.constants import debug, ORDER, PARMES_INTEGER, PARMES_REAL
+from parmepy.mpi.main_var import main_comm, main_size, main_rank, MPI
+from parmepy.operator.discrete import DiscreteOperator
+import time
+
+
+class SynchronizeGhosts_d(DiscreteOperator):
+ """
+ Ghost points synchronization.
+ """
+
+ @debug
+ def __init__(self, fieldslist, topology, transferMethod='greaterSend'):
+ """
+ Defines a way to send/recv values at ghosts points for a list
+ of fields, discretized on a given topology.
+
+ @param fieldslist : a list of fields
+ @param topology : the topology common to all fields.
+ @param transferMethod : which type of exchange is used.
+ """
+ DiscreteOperator.__init__(self, fieldslist, method=transferMethod)
+ self.input = fieldslist
+ self.output = fieldslist
+ self.compute_time = 0.
+ self.fieldslist = fieldslist
+ self.topology = topology
+ self.transferMethod = transferMethod
+
+ @debug
+ def setUp(self):
+ """
+ Transport operator discretization method.
+ Create an discrete Transport operator from given specifications.
+
+ """
+ Operator.setUp(self)
+ ghost = self.topology.ghosts
+ resolution = self.topology.resolution
+ if (self.transferMethod == 'SendRecv'):
+ topoMpi = self.topology
+ # Allocation of space for reciev data
+ self.dataRecvX = np.zeros((
+ ghosts[0], resolution[1], resolution[2]),
+ dtype=PARMES_REAL, order=ORDER)
+ self.dataRecvY = np.zeros((
+ resolution[0], ghosts[1], resolution[2]),
+ dtype=PARMES_REAL, order=ORDER)
+ self.dataRecvZ = np.zeros((
+ resolution[0], resolution[1], ghosts[2]),
+ dtype=PARMES_REAL, order=ORDER)
+ self.SendRecvList = np.zeros(
+ self.topology.dim * 2,
+ order=ORDER, dtype=PARMES_INTEGER)
+ self.SendRecvList[0], self.SendRecvList[1] = \
+ self.topology.Shift(0, 1)
+ self.SendRecvList[1], self.SendRecvList[1] = \
+ self.topology.Shift(1, 1)
+ if (self.topology.dim > 2):
+ self.SendRecvList[2], self.SendRecvList[1] = \
+ self.topology.Shift(2, 1)
+
+ if (self.transferMethod == 'greaterSend'):
+ self.tabSort = self.topology.neightbours
+ self.down, self.up = self.topo.Shift(XDIR, 1)
+ if(self.dim > 1):
+ self.west, self.east = self.topo.Shift(YDIR, 1)
+ if(self.dim > 2):
+ self.south, self.north = self.topo.Shift(ZDIR, 1)
+ self.tabSort = np.array(
+ [[self.up, 0], [self.down, 1], [self.east, 2], [self.west, 3],
+ [self.north, 4], [self.south, 5]])
+ tabSort1 = self.tabSort[self.tabSort[:, 0] <= main_rank]
+ tabSort2 = self.tabSort[self.tabSort[:, 0] > main_rank]
+ if (np.asarray(tabSort1[:, 0].shape) > 0):
+ tabSort1 = tabSort1[tabSort1[:, 0].argsort()]
+ if (np.asarray(tabSort2[:, 0].shape) > 0):
+ tabSort2 = tabSort2[np.invert(tabSort2[:, 0].argsort())]
+ tabSort2 = tabSort2[tabSort2[:, 0].argsort()]
+ self.tabSort = np.concatenate((tabSort1, tabSort2))
+ self.tabSort = self.tabSort[self.tabSort[:, 0].argsort()]
+
+ if ((self.transferMethod == 'greaterSend') or
+ (self.transferMethod == 'SendRecv')):
+ # Allocation of space for send and reciev data
+ self.dataSendX = np.zeros((
+ ghosts[0], resolution[1], resolution[2]),
+ dtype=PARMES_REAL, order=ORDER)
+ self.dataSendY = np.zeros((
+ resolution[0], ghosts[1], resolution[2]),
+ dtype=PARMES_REAL, order=ORDER)
+ self.dataSendZ = np.zeros((
+ resolution[0], resolution[1], ghosts[2]),
+ dtype=PARMES_REAL, order=ORDER)
+ # 1 - get discrete fields arrays
+ # 2 - get list of ghosts area
+ # 3 - get neighbours
+ # 4 - find what is to be send/recv, the size of the arrays and
+ # allocate buffers if required
+ # 5 - set send/recv order
+ self.discreteOperator.setUp()
+
+ @debug
+ def apply(self, *args):
+ resolution = self.topology.resolution
+ ghosts = self.topology.ghosts
+ dim = self.topology.dim
+ self.compute_time = time.time()
+ # Do the send/recv as defined in setup.
+ if args is None:
+ args = self.listFields
+
+ if (self.transferMethod == 'SendRecv'):
+ for f in listFields:
+ # DOWN
+ if (main_rank != self.SendRecvList[0]):
+ self.dataSendZ = f[j][:, :, ghosts[2]:2. * ghosts[2]]
+ main_comm.Sendrecv(
+ self.dataSendZ,
+ dest=self.SendRecvList[0],
+ sendtag=22,
+ recvbuf=self.dataRecvZ,
+ source=main_rank,
+ recvtag=11, status=None)
+ f[j][:, :, resolution[2] - ghosts[2]: resolution[2]] = \
+ self.dataRecvZ
+ else:
+ f[j][:, :, resolution[2] - ghosts[2]: resolution[2]
+ ] = f[j][:, :, ghosts[2]:2 * ghosts[2]]
+ # UP
+ if (main_rank != self.SendRecvList[1]):
+ self.dataSendZ = np.array(np.copy(f[j][
+ :, :,
+ resolution[2] - ghosts[2]:resolution[2]],
+ order=ORDER, dtype=PARMES_REAL))
+ print 'test main comm', dir(main_comm)
+ main_comm.Sendrecv(
+ self.dataSendZ,
+ dest=self.SendRecvList[1],
+ sendtag=11,
+ recvbuf=self.dataRecvZ,
+ source=main_rank,
+ recvtag=22, status=None)
+ else:
+ f[j][:, :, ghosts[2]:2 * ghosts[2]
+ ] = \
+ f[j][:, :, resolution[2] - ghosts[2]:resolution[2]]
+ # SOUTH
+ if (main_rank != self.SendRecvList[2]):
+ self.dataSendY = f[j][:, ghosts[1]:2. * ghosts[1], :]
+ main_comm.Sendrecv(
+ self.dataSendY,
+ dest=self.SendRecvList[2],
+ sendtag=44,
+ recvbuf=self.dataRecvY,
+ source=main_rank,
+ recvtag=33, status=None)
+ f[j][:, resolution[2] - ghosts[2]:resolution[2], :] \
+ = self.dataRecvY
+ else:
+ f[j][:, resolution[1] - ghosts[1]:resolution[1], :
+ ] = f[j][:, ghosts[1]:2 * ghosts[1], :]
+ # NORTH
+ if (main_rank != self.SendRecvList[3]):
+ self.dataSendY = np.array(np.copy(f[j][
+ :,
+ resolution[1] - ghosts[1]:resolution[1],
+ :],
+ order=ORDER, dtype=PARMES_REAL))
+ main_comm.Sendrecv(
+ self.dataSendY,
+ dest=self.SendRecvList[3],
+ sendtag=33,
+ recvbuf=self.dataRecvY,
+ source=main_rank,
+ recvtag=44, status=None)
+ else:
+ f[j][:, ghosts[1]:2 * ghosts[1], :
+ ] = f[j][:, resolution[1] - ghosts[1]:resolution[1],
+ :]
+ # EAST
+ if (main_rank != self.SendRecvList[4]):
+ self.dataSendX = f[j][ghosts[0]:2. * ghosts[0], :, :]
+ main_comm.Sendrecv(
+ self.dataSendX,
+ dest=self.SendRecvList[4],
+ sendtag=66,
+ recvbuf=self.dataRecvX,
+ source=main_rank,
+ recvtag=55, status=None)
+ f[j][resolution[0] - ghosts[0]:resolution[0], :, :] \
+ = self.dataRecvX
+ else:
+ f[j][resolution[0] - ghosts[0]:resolution[0], :, :
+ ] = f[j][:, :, ghosts[2]:2 * ghosts[2]]
+ # WEST
+ if (main_rank != self.SendRecvList[5]):
+ self.dataSendX = np.array(np.copy(f[j][
+ resolution[0] - ghosts[0]:resolution[0],
+ :, :],
+ order=ORDER, dtype=PARMES_REAL))
+ main_comm.Sendrecv(
+ self.dataSendX,
+ dest=self.SendRecvList[5],
+ sendtag=55,
+ recvbuf=self.dataRecvX,
+ source=main_rank,
+ recvtag=66, status=None)
+ else:
+ f[j][ghosts[0]:2 * ghosts[0], :, :
+ ] =\
+ f[j][resolution[0] - ghosts[0]:resolution[0], :, :]
+
+ if (self.transferMethod == 'greaterSend'):
+ for f in listFields:
+ for i in xrange(self.tabSort[:, 0].shape[0]):
+ if (main_rank == self.tabSort[i, 0]):
+ ## Without communication
+ # UP DOWN
+ if (self.tabSort[i, 1] == 0):
+ for j in xrange(dim):
+ f[j][
+ resolution[0] - ghosts[0]: resolution[0],
+ :, :] = f[j][ghosts[0]:2 * ghosts[0],
+ :, :]
+
+ if (self.tabSort[i, 1] == 1):
+ for j in xrange(dim):
+ f[j][0:ghosts[0], :, :] =\
+ f[j][resolution[0] - 2 *
+ ghosts[0]:resolution[0] - ghosts[0], :, :]
+
+ # WEST EAST
+ if (self.tabSort[i, 1] == 2):
+ for j in xrange(dim):
+ f[j][:, resolution[1] -
+ ghosts[1]:resolution[1], :] =\
+ f[j][:, ghosts[1]:2 *
+ ghosts[1], :]
+
+ if(self.tabSort[i, 1] == 3):
+ for j in xrange(dim):
+ f[j][:, 0:ghosts[1], :] =\
+ f[j][:, resolution[1] - 2 *
+ ghosts[1]:resolution[1] - ghosts[1], :]
+
+ # NORTH SOUTH
+ if(self.tabSort[i, 1] == 4):
+ for j in xrange(dim):
+ f[j][:, :, resolution[2] -
+ ghosts[2]:resolution[2]] =\
+ f[j][:, :, ghosts[2]:2 * ghosts[2]]
+
+ if(self.tabSort[i, 1] == 5):
+ for j in xrange(dim):
+ f[j][:, :, 0:ghosts[2]] =\
+ f[j][:, :, resolution[2] - 2 *
+ ghosts[2]:resolution[2] - ghosts[2]]
+ else:
+ ### PART COMMUNICATION
+ # UP
+ if(self.tabSort[i, 1] == 0):
+ if (main_rank < self.tabSort[i, 0]):
+ self.UPsend(self.tabSort[i, 0], f)
+ else:
+ self.UPrecv(self.tabSort[i, 0], f)
+ # DOWN
+ if (self.tabSort[i, 1] == 1):
+ if (main_rank < self.tabSort[i, 0]):
+ self.DOWNsend(self.tabSort[i, 0], f)
+ else:
+ self.DOWNrecv(self.tabSort[i, 0], f)
+ # NORTH
+ if (self.tabSort[i, 1] == 2):
+ if (main_rank < self.tabSort[i, 0]):
+ self.NORTHsend(self.tabSort[i, 0], f)
+ else:
+ self.NORTHrecv(self.tabSort[i, 0], f)
+ # SOUTH
+ if (self.tabSort[i, 1] == 3):
+ if (main_rank < self.tabSort[i, 0]):
+ self.SOUTHsend(self.tabSort[i, 0], f)
+ else:
+ self.SOUTHrecv(self.tabSort[i, 0], f)
+ # EAST
+ if(self.tabSort[i, 1] == 4):
+ if (main_rank < self.tabSort[i, 0]):
+ self.EASTsend(self.tabSort[i, 0], f)
+ else:
+ self.EASTrecv(self.tabSort[i, 0], f)
+ # WEST
+ if (self.tabSort[i, 1] == 5):
+ if (main_rank < self.tabSort[i, 0]):
+ self.WESTsend(self.tabSort[i, 0], f)
+ else:
+ self.WESTrecv(self.tabSort[i, 0], f)
+ self.compute_time = time.time() - self.compute_time
+ self.total_time += self.compute_time
+ return self.discreteOperator.apply(*args)
+
+ def UPsend(self, proc, listFields):
+ ghosts = self.topology.ghosts
+ resolution = self.topology.resolution
+ for i in xrange(self.topology.dim):
+ self.dataSendZ = np.array(np.copy(listFields[i][:, :,
+ resolution[2] - 2 * ghosts[2]:resolution[2] - ghosts[2],
+ ]), order=ORDER)
+ main_comm.Ssend(self.dataSendZ, dest=proc, tag=11)
+ main_comm.Recv(self.dataSendZ, source=proc, tag=11)
+ listFields[i][:, :,
+ resolution[2] - ghosts[2]:resolution[2]] =\
+ self.dataSendZ
+
+ def DOWNsend(self, proc, listFields):
+ ghosts = self.topology.ghosts
+ resolution = self.topology.resolution
+ for i in xrange(self.topology.dim):
+ self.dataSendZ = np.array(np.copy(listFields[i][
+ :, :, ghosts[2]:2 * ghosts[2]]), order=ORDER)
+ main_comm.Ssend(self.dataSendZ, dest=proc, tag=22)
+ main_comm.Recv(self.dataSendZ, source=proc, tag=22)
+ listFields[i][:, :, 0:ghosts[2]] = self.dataSendZ
+
+ def EASTsend(self, proc, listFields):
+ ghosts = self.topology.ghosts
+ resolution = self.topology.resolution
+ for i in xrange(self.topology.dim):
+ self.dataSendX = np.array(np.copy(listFields[i][
+ resolution[0] - 2 * ghosts[0]:resolution[0] - ghosts[0],
+ :, :]),
+ order=ORDER)
+ main_comm.Ssend(self.dataSendY, dest=proc, tag=33)
+ main_comm.Recv(self.dataSendY, source=proc, tag=33)
+ listFields[i][resolution[0] - ghosts[0]:resolution[0], :, :] =\
+ self.dataSendX
+
+ def WESTsend(self, proc, listFields):
+ ghosts = self.topology.ghosts
+ resolution = self.topology.resolution
+ for i in xrange(self.topology.dim):
+ self.dataSendX = np.array(np.copy(listFields[i][
+ ghosts[0]:ghosts[0] * 2, :, :]), order=ORDER)
+ main_comm.Ssend(self.dataSendX, dest=proc, tag=44)
+ main_comm.Recv(self.dataSendX, source=proc, tag=44)
+ listFields[i][0:ghosts[0], :, :] = self.dataSendX
+
+ def NORTHsend(self, proc, listFields):
+ ghosts = self.topology.ghosts
+ resolution = self.topology.resolution
+ for i in xrange(self.topology.dim):
+ self.dataSendY = np.array(np.copy(listFields[i][
+ :,
+ resolution[1] - 2 * ghosts[1]:resolution[1] - ghosts[1], :]),
+ order=ORDER)
+ main_comm.Ssend(self.dataSendY, dest=proc, tag=55)
+ main_comm.Recv(self.dataSendY, source=proc, tag=55)
+ listFields[i][:, resolution[1] - ghosts[1]:resolution[1], :] =\
+ self.dataSendY
+
+ def SOUTHsend(self, proc, listFields):
+ ghosts = self.topology.ghosts
+ resolution = self.topology.resolution
+ for i in xrange(self.topology.dim):
+ self.dataSendY = np.array(np.copy(listFields[i][
+ :, ghosts[1]:2 * ghosts[1], :]), order=ORDER)
+ main_comm.Ssend(self.dataSendY, dest=proc, tag=66)
+ main_comm.Recv(self.dataSendY, source=proc, tag=66)
+ listFields[i][:, 0:ghosts[1], :] = self.dataSendY
+
+ def UPrecv(self, proc, listFields):
+ ghosts = self.topology.ghosts
+ resolution = self.topology.resolution
+ for i in xrange(self.topology.dim):
+ main_comm.Recv(self.dataSendZ, source=proc, tag=22)
+ listFields[i][:, :, resolution[2] - ghosts[2]:resolution[2]] =\
+ self.dataSendZ
+ self.dataSendZ = np.array(np.copy(listFields[i][
+ :, :,
+ resolution[2] - 2 * ghosts[2]:resolution[2] - ghosts[2]
+ ]),
+ order=ORDER)
+ main_comm.Ssend(self.dataSendZ, dest=proc, tag=22)
+
+ def DOWNrecv(self, proc, listFields):
+ ghosts = self.topology.ghosts
+ resolution = self.topology.resolution
+ for i in xrange(self.topology.dim):
+ main_comm.Recv(self.dataSendZ, source=proc, tag=11)
+ listFields[i][:, :, 0:self.topo.ghosts[2]] = self.dataSendZ
+ data = np.array(np.copy(listFields[i][
+ :, :, ghosts[2]:ghosts[2] * 2]), order=ORDER)
+ main_comm.Ssend(self.dataSendZ, dest=proc, tag=11)
+
+ def EASTrecv(self, proc, listFields):
+ ghosts = self.topology.ghosts
+ resolution = self.topology.resolution
+ for i in xrange(self.topology.dim):
+ main_comm.Recv(self.dataSendX, source=proc, tag=44)
+ listFields[i][:, resolution[0] - ghosts[0]:resolution[0], :] =\
+ self.dataSendX
+ self.dataSendX = np.array(np.copy(listFields[i][
+ resolution[0] - 2 * ghosts[0]:resolution[0] - ghosts[0],
+ :, :]),
+ order=ORDER)
+ main_comm.Ssend(self.dataSendX, dest=proc, tag=44)
+
+ def WESTrecv(self, proc, listFields):
+ ghosts = self.topology.ghosts
+ resolution = self.topology.resolution
+ for i in xrange(self.topology.dim):
+ main_comm.Recv(self.dataSendX, source=proc, tag=33)
+ listFields[i][0:ghosts[0], :, :] = self.dataSendX
+ self.dataSendX = np.array(np.copy(listFields[i][
+ ghosts[0]:2 * ghosts[0], :, :]), order=ORDER)
+ main_comm.Ssend(self.dataSendX, dest=proc, tag=33)
+
+ def NORTHrecv(self, proc, listFields):
+ ghosts = self.topology.ghosts
+ resolution = self.topology.resolution
+ for i in xrange(self.topology.dim):
+ main_comm.Recv(self.dataSendY, source=proc, tag=66)
+ listFields[i][:, resolution[1] - ghosts[1]:resolution[1], :] =\
+ self.dataSendY
+ self.dataSendY = np.array(np.copy(listFields[i][
+ :, resolution[1] - 2 * ghosts[1]:resolution[1] -
+ ghosts[1], :]),
+ order=ORDER)
+ main_comm.Ssend(self.dataSendY, dest=proc, tag=66)
+
+ def SOUTHrecv(self, proc, listFields):
+ ghosts = self.topology.ghosts
+ resolution = self.topology.resolution
+ for i in xrange(self.topology.dim):
+ main_comm.Recv(self.dataSendY, source=proc, tag=55)
+ listFields[i][:, 0:ghosts[1], :] = self.dataSendY
+ self.dataSendY = np.array(np.copy(listFields[i][
+ :, ghosts[1]:2 * ghosts[1], :]), order=ORDER)
+ main_comm.Ssend(self.dataSendY, dest=proc, tag=55)
+
+ def __str__(self):
+ """ToString method"""
+ s = " Exchange operator"
+ return s + "\n"
+
+if (__name__ == "__main__"):
+ print __doc__
+ print "- Provided class : SynchronizeGhosts"
+ print SynchronizeGhosts.__doc__
diff --git a/HySoP/hysop/operator/tests/test_synchronizeGhosts.py b/HySoP/hysop/operator/tests/test_synchronizeGhosts.py
new file mode 100644
index 0000000000000000000000000000000000000000..5c4f29af4af62180234cd9801f420d52649adcda
--- /dev/null
+++ b/HySoP/hysop/operator/tests/test_synchronizeGhosts.py
@@ -0,0 +1,66 @@
+"""
+Testing parmepy.operator.synchronization
+"""
+import parmepy as pp
+import numpy as np
+from parmepy.operator.synchronizeGhosts import SynchronizeGhosts
+from parmepy.fields.continuous import Field
+from parmepy.mpi.topology import Cartesian
+from parmepy.fields.analytical import AnalyticalField
+from parmepy.mpi.main_var import main_comm, main_size, main_rank, MPI
+from parmepy.operator.analytic import Analytic
+
+
+def computeVel(x, y, z):
+ vx = x
+ vy = y
+ vz = z
+ return vx, vy, vz
+
+
+def test_Synchro():
+ nb = 65
+ dim = 3
+ boxLength = [1., 1., 1.]
+ boxMin = [0., 0., 0.]
+ nbElem = [nb, nb, nb]
+ nbGhosts = 2.
+ dom = pp.Box(dim, length=boxLength, origin=boxMin)
+ ## Fields
+
+ field = Field(domain=dom, name='velocity', isVector=True)
+# a = Analytic(field, formula=computeVel,
+# resolution={field: nbElem},
+# )
+# a.setUp()
+# velo = AnalyticalField(domain=dom, formula=computeVel,
+# name='Velocity', isVector=True)
+
+ Synchrotest = SynchronizeGhosts(field, resolution={field: nbElem, },
+ method='greaterSend')
+# Synchrotest = SynchronizeGhosts(velo, resolution={velo: nbElem},
+# method='greaterSend')
+# DiscreteOperator.__init__(velo)
+# Operator.setUp(self)
+# topoId, topo = dom.addTopology(
+# Cartesian(domain=dom, dim=3,
+# globalMeshResolution=[nb, nb, nb], # {velo: nbElem},
+# comm=main_comm, periods=np.asarray([True, True, True]),
+# ghosts=[nbGhosts, nbGhosts, nbGhosts]))
+# df, dfId = velo.discretize(topo)
+# self.discreteFieldId[v] = dfId
+# DiscreteOperator.__init__( velo)
+# synchro = SynchronizeGhosts(velo, topo, 'greaterSend')
+# synchro.discreteFieldId[velo] = dfId
+# self.discreteOperator = Stretching_d(self, method=self.method,
+# **self.config)
+# self.discreteOperator.setUp()
+
+ print "Setup Synchro"
+ Synchrotest.setUp()
+ print "Apply Synchro"
+ Synchrotest.apply()
+
+if __name__ == "__main__":
+ print "Rank", main_rank
+ test_Synchro()