Fix scales launching

HySoP/hysop/operator/advection.py

@@ -3,7 +3,7 @@
 
 Advection operator representation.
 """
-from parmepy.constants import debug
+from parmepy.constants import debug, np, PARMES_INDEX
 from parmepy.operator.continuous import Operator
 from parmepy.mpi.topology import Cartesian
 
@@ -44,56 +44,77 @@ class Advection(Operator):
 
         """
         Operator.setUp(self)
-        #variables discretization
-        for v in self.variables:
-            topoId, topo = self.domain.addTopology(
-                Cartesian(domain=self.domain, dim=self.domain.dimension,
-                          globalMeshResolution=self.resolutions[v]))
-            df, dfId = v.discretize(topo)
-            self.discreteFieldId[v] = dfId
-        if self.discreteOperator is None:
-            if self.method.find('gpu_2k') >= 0:
-                if self.advectedFields.vector:
-                #if not isinstance(self.advectedFields.discreteField[
-                #        self.discreteFieldId[self.advectedFields]],
-                #        ScalarField):
-                    raise ValueError("Not implemented yet. GPU advection" +
-                                     " is only for scalar fields")
-                from parmepy.operator.gpu_particle_advection_2k \
-                    import GPUParticleAdvection2k
-                self.discreteOperator = \
-                    GPUParticleAdvection2k(self, method=self.method,
-                                           **self.config)
-            elif self.method.find('gpu_1k') >= 0:
-                if self.advectedFields.vector:
-                #if not isinstance(self.advectedFields.discreteField[
-                #        self.discreteFieldId[self.advectedFields]],
-                #        ScalarField):
-                    raise ValueError("Not implemented yet. GPU advection" +
-                                     " is only for scalar fields")
-                from parmepy.operator.gpu_particle_advection_1k \
-                    import GPUParticleAdvection1k
-                self.discreteOperator = \
-                    GPUParticleAdvection1k(self, method=self.method,
-                                           **self.config)
-            elif self.method.find('scales') >= 0:
-                if not self.advectedFields.dimension == 3:
+        if self.method.find('scales') >= 0:
+            if not self.advectedFields.dimension == 3:
                     raise ValueError("Scales Advection not implemented in 2D.")
-                from parmepy.operator.scales_advection \
-                    import ScalesAdvection
-                self.discreteOperator = \
-                    ScalesAdvection(self, method=self.method,
-                                    **self.config)
-            else:
-                print "Using default advection operator"
-                if self.advectedFields.vector:
-                    raise ValueError("Not implemented yet. default advection" +
-                                     " is only for scalar fields")
-                from parmepy.operator.particle_advection \
-                    import ParticleAdvection
-                self.discreteOperator = \
-                    ParticleAdvection(self, method=self.method,
-                                      **self.config)
+            ## Scales imports for topology creation
+            from parmepy.operator.scales_advection import ScalesAdvection
+            from parmepy.f2py import scales2py as scales
+            from parmepy.mpi.main_var import main_size
+
+            ## Extract order form self.method (default p_O2)
+            order = 'p_O2'
+            for o in ['p_O2', 'p_O4', 'p_M6']:
+                if self.method.find(o) >= 0:
+                    order = o
+            ## Scales nbcells equals resolutions - 1
+            ## resolutions is a number of points given by user
+            nbcells = np.asarray(self.resolutions[self.advectedFields],
+                                 dtype=PARMES_INDEX) - 1
+            topodims = [1, 1, main_size]
+            scalesres, scalesoffset, stab_coeff = \
+                scales.init_advection_solver(nbcells,
+                                             self.domain.length,
+                                             topodims, order=order)
+            ## Use same topodims as scales to create Cartesian topology
+            ## in order to discretize our fields
+            for v in self.variables:
+                topoId, topo = self.domain.addTopology(
+                    Cartesian.withResolution(
+                        domain=self.domain, topoResolution=topodims,
+                        globalMeshResolution=self.resolutions[v]))
+                df, dfId = v.discretize(topo)
+                self.discreteFieldId[v] = dfId
+            self.discreteOperator = ScalesAdvection(self, method=self.method,
+                                                    **self.config)
+        else:
+            #variables discretization
+            for v in self.variables:
+                topoId, topo = self.domain.addTopology(
+                    Cartesian(domain=self.domain, dim=self.domain.dimension,
+                              globalMeshResolution=self.resolutions[v]))
+                df, dfId = v.discretize(topo)
+                self.discreteFieldId[v] = dfId
+            if self.discreteOperator is None:
+                if self.method.find('gpu_2k') >= 0:
+                    if self.advectedFields.vector:
+                        raise ValueError("Not implemented yet. GPU advection" +
+                                         " is only for scalar fields")
+                    from parmepy.operator.gpu_particle_advection_2k \
+                        import GPUParticleAdvection2k
+                    self.discreteOperator = \
+                        GPUParticleAdvection2k(self, method=self.method,
+                                               **self.config)
+                elif self.method.find('gpu_1k') >= 0:
+                    if self.advectedFields.vector:
+                        raise ValueError("Not implemented yet. GPU advection" +
+                                         " is only for scalar fields")
+                    from parmepy.operator.gpu_particle_advection_1k \
+                        import GPUParticleAdvection1k
+                    self.discreteOperator = \
+                        GPUParticleAdvection1k(self, method=self.method,
+                                               **self.config)
+                else:
+                    print "Using default advection operator"
+                    if self.advectedFields.vector:
+                        raise ValueError("Not implemented yet. default" +
+                                         " advection is only for " +
+                                         "scalar fields")
+                    from parmepy.operator.particle_advection \
+                        import ParticleAdvection
+                    self.discreteOperator = \
+                        ParticleAdvection(self, method=self.method,
+                                          **self.config)
         self.discreteOperator.setUp()
 
     def __str__(self):

HySoP/hysop/operator/scales_advection.py

@@ -46,8 +46,6 @@ class ScalesAdvection(DiscreteOperator):
         self.ghosts = self.topology.ghosts
         self.resolution = self.topology.mesh.resolution
         self.dim = self.topology.dim
-        # TODO scales setup
-        #scales2py.setup('p_O2', True, 'strang')
 
     @debug
     def apply(self, t, dt, ite):
@@ -162,8 +160,8 @@ class ScalesAdvection(DiscreteOperator):
         return self.compute_time
 
     def printComputeTime(self):
-        self.timings_info[0] = "\"Advection calculation total\""
-        self.timings_info[1] = str(self.total_time)
+        self.time_info[0] = "\"Advection calculation total\""
+        self.time_info[1] = str(self.total_time)
         print "Time of the last advection calculation loop :", \
             self.compute_time