Public Member Functions
def	__init__ (self, invoke, unique_psy_vars)

def	declarations (self, parent)

def	initialise (self, parent)

def	intergrid_kernels (self)

Detailed Description

Holds all mesh-related information (including colour maps if
required).  If there are no inter-grid kernels then there is only
one mesh object required (when calling kernels with operates_on==domain,
colouring, doing distributed memory or querying the reference element).
However, kernels performing inter-grid operations require multiple mesh
objects as well as mesh maps and other quantities.

There are two types of inter-grid operation; the first is "prolongation"
where a field on a coarse mesh is mapped onto a fine mesh. The second
is "restriction" where a field on a fine mesh is mapped onto a coarse
mesh.

:param invoke: the Invoke for which to extract information on all \
               required inter-grid operations.
:type invoke: :py:class:`psyclone.dynamo0p3.LFRicInvoke`
:param unique_psy_vars: list of arguments to the PSy-layer routine.
:type unique_psy_vars: list of \
                  :py:class:`psyclone.dynamo0p3.DynKernelArgument` objects.

Definition at line 2028 of file dynamo0p3.py.

Member Function Documentation

◆ declarations()

def psyclone.dynamo0p3.DynMeshes.declarations	(	self,
		parent
	)

Declare variables specific to mesh objects.

:param parent: the parent node to which to add the declarations
:type parent: :py:class:`psyclone.f2pygen.BaseGen`

Definition at line 2243 of file dynamo0p3.py.

     def declarations(self, parent):
         '''
         Declare variables specific to mesh objects.
  
         :param parent: the parent node to which to add the declarations
         :type parent: :py:class:`psyclone.f2pygen.BaseGen`
  
         '''
         # pylint: disable=too-many-locals, too-many-statements
         api_config = Config.get().api_conf("dynamo0.3")
         const = LFRicConstants()
  
         # Since we're now generating code, any transformations must
         # have been applied so we can set-up colourmap information
         self._colourmap_init()
  
         # We'll need various typedefs from the mesh module
         mtype = const.MESH_TYPE_MAP["mesh"]["type"]
         mmod = const.MESH_TYPE_MAP["mesh"]["module"]
         mmap_type = const.MESH_TYPE_MAP["mesh_map"]["type"]
         mmap_mod = const.MESH_TYPE_MAP["mesh_map"]["module"]
         if self._mesh_tag_names:
             name = self._symbol_table.lookup_with_tag(mtype).name
             parent.add(UseGen(parent, name=mmod, only=True,
                               funcnames=[name]))
         if self.intergrid_kernels:
             parent.add(UseGen(parent, name=mmap_mod, only=True,
                               funcnames=[mmap_type]))
         # Declare the mesh object(s) and associated halo depths
         for tag_name in self._mesh_tag_names:
             name = self._symbol_table.lookup_with_tag(tag_name).name
             parent.add(TypeDeclGen(parent, pointer=True, datatype=mtype,
                                    entity_decls=[name + " => null()"]))
             # For each mesh we also need the maximum halo depth.
             if Config.get().distributed_memory:
                 name = self._symbol_table.lookup_with_tag(
                     f"max_halo_depth_{tag_name}").name
                 parent.add(DeclGen(parent, datatype="integer",
                                    kind=api_config.default_kind["integer"],
                                    entity_decls=[name]))
  
         # Declare the inter-mesh map(s) and cell map(s)
         for kern in self.intergrid_kernels:
             parent.add(TypeDeclGen(parent, pointer=True,
                                    datatype=mmap_type,
                                    entity_decls=[kern.mmap + " => null()"]))
             parent.add(
                 DeclGen(parent, pointer=True, datatype="integer",
                         kind=api_config.default_kind["integer"],
                         entity_decls=[kern.cell_map + "(:,:,:) => null()"]))
  
             # Declare the number of cells in the fine mesh and how many fine
             # cells there are per coarse cell
             parent.add(DeclGen(parent, datatype="integer",
                                kind=api_config.default_kind["integer"],
                                entity_decls=[kern.ncell_fine,
                                              kern.ncellpercellx,
                                              kern.ncellpercelly]))
             # Declare variables to hold the colourmap information if required
             if kern.colourmap_symbol:
                 parent.add(
                     DeclGen(parent, datatype="integer",
                             kind=api_config.default_kind["integer"],
                             pointer=True,
                             entity_decls=[kern.colourmap_symbol.name+"(:,:)"]))
                 parent.add(
                     DeclGen(parent, datatype="integer",
                             kind=api_config.default_kind["integer"],
                             entity_decls=[kern.ncolours_var_symbol.name]))
                 # The cell-count array is 2D if we go into the halo and 1D
                 # otherwise (i.e. no DM or this kernel is GH_WRITE only and
                 # does not access the halo).
                 dim_list = len(kern.last_cell_var_symbol.datatype.shape)*":"
                 decln = (f"{kern.last_cell_var_symbol.name}("
                          f"{','.join(dim_list)})")
                 parent.add(
                     DeclGen(parent, datatype="integer", allocatable=True,
                             kind=api_config.default_kind["integer"],
                             entity_decls=[decln]))
  
         if not self.intergrid_kernels and (self._needs_colourmap or
                                            self._needs_colourmap_halo):
             # There aren't any inter-grid kernels but we do need
             # colourmap information
             base_name = "cmap"
             csym = self._schedule.symbol_table.lookup_with_tag("cmap")
             colour_map = csym.name
             # No. of colours
             base_name = "ncolour"
             ncolours = \
                 self._schedule.symbol_table.find_or_create_tag(base_name).name
             # Add declarations for these variables
             parent.add(DeclGen(parent, datatype="integer",
                                kind=api_config.default_kind["integer"],
                                pointer=True,
                                entity_decls=[colour_map+"(:,:)"]))
             parent.add(DeclGen(parent, datatype="integer",
                                kind=api_config.default_kind["integer"],
                                entity_decls=[ncolours]))
             if self._needs_colourmap_halo:
                 last_cell = self._symbol_table.find_or_create_tag(
                     "last_halo_cell_all_colours")
                 parent.add(DeclGen(parent, datatype="integer",
                                    kind=api_config.default_kind["integer"],
                                    allocatable=True,
                                    entity_decls=[last_cell.name+"(:,:)"]))
             if self._needs_colourmap:
                 last_cell = self._symbol_table.find_or_create_tag(
                     "last_edge_cell_all_colours")
                 parent.add(DeclGen(parent, datatype="integer",
                                    kind=api_config.default_kind["integer"],
                                    allocatable=True,
                                    entity_decls=[last_cell.name+"(:)"]))
  

References psyclone.dynamo0p3.DynMeshes._colourmap_init(), psyclone.dynamo0p3.DynMeshes._mesh_tag_names, psyclone.dynamo0p3.DynMeshes._needs_colourmap, psyclone.dynamo0p3.DynMeshes._needs_colourmap_halo, psyclone.domain.lfric.lfric_invoke.LFRicInvoke._schedule, psyclone.dynamo0p3.DynMeshes._schedule, psyclone.gocean1p0.GOInvoke._schedule, psyclone.nemo.NemoInvoke._schedule, psyclone.psyGen.Invoke._schedule, psyclone.psyir.nodes.omp_clauses.OMPScheduleClause._schedule, psyclone.domain.lfric.lfric_collection.LFRicCollection._symbol_table, psyclone.dynamo0p3.DynMeshes._symbol_table, psyclone.dynamo0p3.HaloDepth._symbol_table, psyclone.psyGen.HaloExchange._symbol_table, psyclone.psyir.backend.sympy_writer.SymPyWriter._symbol_table, psyclone.psyir.nodes.scoping_node.ScopingNode._symbol_table, and psyclone.dynamo0p3.DynMeshes.intergrid_kernels().

Here is the call graph for this function:

◆ initialise()

def psyclone.dynamo0p3.DynMeshes.initialise	(	self,
		parent
	)

Initialise parameters specific to inter-grid kernels.

:param parent: the parent node to which to add the initialisations.
:type parent: :py:class:`psyclone.f2pygen.BaseGen`

Definition at line 2357 of file dynamo0p3.py.

     def initialise(self, parent):
         '''
         Initialise parameters specific to inter-grid kernels.
  
         :param parent: the parent node to which to add the initialisations.
         :type parent: :py:class:`psyclone.f2pygen.BaseGen`
  
         '''
         # pylint: disable=too-many-branches
         # If we haven't got any need for a mesh in this invoke then we
         # don't do anything
         if not self._mesh_tag_names:
             return
  
         parent.add(CommentGen(parent, ""))
  
         if len(self._mesh_tag_names) == 1:
             # We only require one mesh object which means that this invoke
             # contains no inter-grid kernels (which would require at least 2)
             parent.add(CommentGen(parent, " Create a mesh object"))
             parent.add(CommentGen(parent, ""))
             rhs = "%".join([self._first_var.proxy_name_indexed,
                             self._first_var.ref_name(), "get_mesh()"])
             mesh_name = self._symbol_table.lookup_with_tag(
                 self._mesh_tag_names[0]).name
             parent.add(AssignGen(parent, pointer=True, lhs=mesh_name, rhs=rhs))
             if Config.get().distributed_memory:
                 # If distributed memory is enabled then we need the maximum
                 # halo depth.
                 depth_name = self._symbol_table.lookup_with_tag(
                     f"max_halo_depth_{self._mesh_tag_names[0]}").name
                 parent.add(AssignGen(parent, lhs=depth_name,
                                      rhs=f"{mesh_name}%get_halo_depth()"))
             if self._needs_colourmap or self._needs_colourmap_halo:
                 parent.add(CommentGen(parent, ""))
                 parent.add(CommentGen(parent, " Get the colourmap"))
                 parent.add(CommentGen(parent, ""))
                 # Look-up variable names for colourmap and number of colours
                 colour_map = self._schedule.symbol_table.find_or_create_tag(
                     "cmap").name
                 ncolour = \
                     self._schedule.symbol_table.find_or_create_tag("ncolour")\
                                                .name
                 # Get the number of colours
                 parent.add(AssignGen(
                     parent, lhs=ncolour, rhs=f"{mesh_name}%get_ncolours()"))
                 # Get the colour map
                 parent.add(AssignGen(parent, pointer=True, lhs=colour_map,
                                      rhs=f"{mesh_name}%get_colour_map()"))
             return
  
         parent.add(CommentGen(
             parent,
             " Look-up mesh objects and loop limits for inter-grid kernels"))
         parent.add(CommentGen(parent, ""))
  
         # Keep a list of quantities that we've already initialised so
         # that we don't generate duplicate assignments
         initialised = []
  
         # Loop over the DynInterGrid objects
         for dig in self.intergrid_kernels:
             # We need pointers to both the coarse and the fine mesh as well
             # as the maximum halo depth for each.
             fine_mesh = self._schedule.symbol_table.find_or_create_tag(
                 f"mesh_{dig.fine.name}").name
             coarse_mesh = self._schedule.symbol_table.find_or_create_tag(
                 f"mesh_{dig.coarse.name}").name
             if fine_mesh not in initialised:
                 initialised.append(fine_mesh)
                 parent.add(
                     AssignGen(parent, pointer=True,
                               lhs=fine_mesh,
                               rhs="%".join([dig.fine.proxy_name_indexed,
                                             dig.fine.ref_name(),
                                             "get_mesh()"])))
                 if Config.get().distributed_memory:
                     max_halo_f_mesh = (
                         self._schedule.symbol_table.find_or_create_tag(
                             f"max_halo_depth_mesh_{dig.fine.name}").name)
  
                     parent.add(AssignGen(parent, lhs=max_halo_f_mesh,
                                          rhs=f"{fine_mesh}%get_halo_depth()"))
             if coarse_mesh not in initialised:
                 initialised.append(coarse_mesh)
                 parent.add(
                     AssignGen(parent, pointer=True,
                               lhs=coarse_mesh,
                               rhs="%".join([dig.coarse.proxy_name_indexed,
                                             dig.coarse.ref_name(),
                                             "get_mesh()"])))
                 if Config.get().distributed_memory:
                     max_halo_c_mesh = (
                         self._schedule.symbol_table.find_or_create_tag(
                             f"max_halo_depth_mesh_{dig.coarse.name}").name)
                     parent.add(AssignGen(
                         parent, lhs=max_halo_c_mesh,
                         rhs=f"{coarse_mesh}%get_halo_depth()"))
             # We also need a pointer to the mesh map which we get from
             # the coarse mesh
             if dig.mmap not in initialised:
                 initialised.append(dig.mmap)
                 parent.add(
                     AssignGen(parent, pointer=True,
                               lhs=dig.mmap,
                               rhs=f"{coarse_mesh}%get_mesh_map({fine_mesh})"))
  
             # Cell map. This is obtained from the mesh map.
             if dig.cell_map not in initialised:
                 initialised.append(dig.cell_map)
                 parent.add(
                     AssignGen(parent, pointer=True, lhs=dig.cell_map,
                               rhs=dig.mmap+"%get_whole_cell_map()"))
  
             # Number of cells in the fine mesh
             if dig.ncell_fine not in initialised:
                 initialised.append(dig.ncell_fine)
                 if Config.get().distributed_memory:
                     # TODO this hardwired depth of 2 will need changing in
                     # order to support redundant computation
                     parent.add(
                         AssignGen(parent, lhs=dig.ncell_fine,
                                   rhs=(fine_mesh+"%get_last_halo_cell"
                                        "(depth=2)")))
                 else:
                     parent.add(
                         AssignGen(parent, lhs=dig.ncell_fine,
                                   rhs="%".join([dig.fine.proxy_name,
                                                 dig.fine.ref_name(),
                                                 "get_ncell()"])))
  
             # Number of fine cells per coarse cell in x.
             if dig.ncellpercellx not in initialised:
                 initialised.append(dig.ncellpercellx)
                 parent.add(
                     AssignGen(parent, lhs=dig.ncellpercellx,
                               rhs=dig.mmap +
                               "%get_ntarget_cells_per_source_x()"))
  
             # Number of fine cells per coarse cell in y.
             if dig.ncellpercelly not in initialised:
                 initialised.append(dig.ncellpercelly)
                 parent.add(
                     AssignGen(parent, lhs=dig.ncellpercelly,
                               rhs=dig.mmap +
                               "%get_ntarget_cells_per_source_y()"))
  
             # Colour map for the coarse mesh (if required)
             if dig.colourmap_symbol:
                 # Number of colours
                 parent.add(AssignGen(parent, lhs=dig.ncolours_var_symbol.name,
                                      rhs=coarse_mesh + "%get_ncolours()"))
                 # Colour map itself
                 parent.add(AssignGen(parent, lhs=dig.colourmap_symbol.name,
                                      pointer=True,
                                      rhs=coarse_mesh + "%get_colour_map()"))
                 # Last halo/edge cell per colour.
                 sym = dig.last_cell_var_symbol
                 if len(sym.datatype.shape) == 2:
                     # Array is 2D so is a halo access.
                     name = "%get_last_halo_cell_all_colours()"
                 else:
                     # Array is just 1D so go to the last edge cell.
                     name = "%get_last_edge_cell_all_colours()"
                 parent.add(AssignGen(parent, lhs=sym.name,
                                      rhs=coarse_mesh + name))
  

References psyclone.dynamo0p3.DynCellIterators._first_var, psyclone.dynamo0p3.DynMeshes._first_var, psyclone.dynamo0p3.DynMeshes._mesh_tag_names, psyclone.dynamo0p3.DynMeshes._needs_colourmap, psyclone.dynamo0p3.DynMeshes._needs_colourmap_halo, psyclone.domain.lfric.lfric_invoke.LFRicInvoke._schedule, psyclone.dynamo0p3.DynMeshes._schedule, psyclone.gocean1p0.GOInvoke._schedule, psyclone.nemo.NemoInvoke._schedule, psyclone.psyGen.Invoke._schedule, psyclone.psyir.nodes.omp_clauses.OMPScheduleClause._schedule, psyclone.domain.lfric.lfric_collection.LFRicCollection._symbol_table, psyclone.dynamo0p3.DynMeshes._symbol_table, psyclone.dynamo0p3.HaloDepth._symbol_table, psyclone.psyGen.HaloExchange._symbol_table, psyclone.psyir.backend.sympy_writer.SymPyWriter._symbol_table, psyclone.psyir.nodes.scoping_node.ScopingNode._symbol_table, and psyclone.dynamo0p3.DynMeshes.intergrid_kernels().

Here is the call graph for this function:

◆ intergrid_kernels()

def psyclone.dynamo0p3.DynMeshes.intergrid_kernels ( self )

:returns: A list of objects describing the intergrid kernels used in
    this invoke.
:rtype: list[:py:class:`psyclone.dynamo3p0.DynInterGrid`]

Definition at line 2525 of file dynamo0p3.py.

     def intergrid_kernels(self):
         '''
         :returns: A list of objects describing the intergrid kernels used in
             this invoke.
         :rtype: list[:py:class:`psyclone.dynamo3p0.DynInterGrid`]
         '''
         intergrids = []
         for call in self._schedule.coded_kernels():
             if call.is_intergrid:
                 intergrids.append(call._intergrid_ref)
         return intergrids
  
  

References psyclone.domain.lfric.lfric_invoke.LFRicInvoke._schedule, psyclone.dynamo0p3.DynMeshes._schedule, psyclone.gocean1p0.GOInvoke._schedule, psyclone.nemo.NemoInvoke._schedule, psyclone.psyGen.Invoke._schedule, and psyclone.psyir.nodes.omp_clauses.OMPScheduleClause._schedule.

Here is the caller graph for this function:

The documentation for this class was generated from the following file:

/home/docs/checkouts/readthedocs.org/user_builds/psyclone-ref/checkouts/latest/src/psyclone/dynamo0p3.py

Public Member Functions

Detailed Description

Member Function Documentation

◆ declarations()

◆ initialise()

◆ intergrid_kernels()