Inheritance diagram for psyclone.domain.lfric.kernel_interface.KernelInterface:

Collaboration diagram for psyclone.domain.lfric.kernel_interface.KernelInterface:

Public Member Functions
def	__init__ (self, kern)

def	generate (self, var_accesses=None)

def	cell_position (self, var_accesses=None)

def	mesh_height (self, var_accesses=None)

def	cell_map (self, var_accesses=None)

def	field_vector (self, argvect, var_accesses=None)

def	field (self, arg, var_accesses=None)

def	stencil_unknown_extent (self, arg, var_accesses=None)

def	stencil_unknown_direction (self, arg, var_accesses=None)

def	stencil (self, arg, var_accesses=None)

def	operator (self, arg, var_accesses=None)

def	cma_operator (self, arg, var_accesses=None)

def	scalar (self, scalar_arg, var_accesses=None)

def	fs_common (self, function_space, var_accesses=None)

def	fs_intergrid (self, function_space, var_accesses=None)

def	fs_compulsory_field (self, function_space, var_accesses=None)

def	banded_dofmap (self, function_space, var_accesses=None)

def	indirection_dofmap (self, function_space, operator=None, var_accesses=None)

def	basis (self, function_space, var_accesses=None)

def	diff_basis (self, function_space, var_accesses=None)

def	field_bcs_kernel (self, function_space, var_accesses=None)

def	operator_bcs_kernel (self, function_space, var_accesses=None)

def	ref_element_properties (self, var_accesses=None)

def	mesh_properties (self, var_accesses=None)

def	quad_rule (self, var_accesses=None)

Public Member Functions inherited from psyclone.domain.lfric.arg_ordering.ArgOrdering
def	psyir_append (self, node)

def	append (self, var_name, var_accesses=None, var_access_name=None, mode=AccessType.READ, metadata_posn=None)

def	extend (self, list_var_name, var_accesses=None, mode=AccessType.READ, list_metadata_posn=None)

def	append_integer_reference (self, name, tag=None)

def	get_array_reference (self, array_name, indices, intrinsic_type, tag=None, symbol=None)

def	append_array_reference (self, array_name, indices, intrinsic_type, tag=None, symbol=None)

def	num_args (self)

def	arglist (self)

def	psyir_arglist (self)

def	metadata_index_from_actual_index (self, idx)

def	stencil_2d_unknown_extent (self, arg, var_accesses=None)

def	stencil_2d_max_extent (self, arg, var_accesses=None)

def	stencil_2d (self, arg, var_accesses=None)

Static Public Attributes
dictionary	field_mapping

dictionary	vector_field_mapping

dictionary	basis_mapping

dictionary	diff_basis_mapping

Detailed Description

Create the kernel arguments for the supplied kernel as specified by
the associated kernel metadata and the kernel ordering rules
encoded in the ArgOrdering base class as method callbacks.

A PSyIR symbol table is created containing appropriate LFRic PSyIR
symbols to specify the arguments. If an argument is an array with
one or more dimension sizes specified by another argument, then
the associated array symbol is created so that it references the
appropriate symbol.

Related arguments - e.g. a field has an associated dofmap - are
not directly connected, they must be inferred from the function
space names. It is not yet clear whether this would be useful or
not.

TODO #928: This class should replace the current kernel stub generation
code when all of its methods are implemented.

:param kern: the kernel for which to create arguments.
:type kern: :py:class:`psyclone.domain.lfric.LFRicKern`

Definition at line 54 of file kernel_interface.py.

Member Function Documentation

◆ banded_dofmap()

def psyclone.domain.lfric.kernel_interface.KernelInterface.banded_dofmap	(	self,
		function_space,
		var_accesses = `None`
	)

Not implemented.

:param function_space: the function space for this dofmap.
:type function_space: :py:class:`psyclone.domain.lfric.FunctionSpace`
:param var_accesses: an unused optional argument that stores \
    information about variable accesses.
:type var_accesses: :\
    py:class:`psyclone.core.VariablesAccessInfo`

:raises NotImplementedError: as this method is not implemented.

Reimplemented from psyclone.domain.lfric.arg_ordering.ArgOrdering.

Definition at line 510 of file kernel_interface.py.

     def banded_dofmap(self, function_space, var_accesses=None):
         '''Not implemented.
  
         :param function_space: the function space for this dofmap.
         :type function_space: :py:class:`psyclone.domain.lfric.FunctionSpace`
         :param var_accesses: an unused optional argument that stores \
             information about variable accesses.
         :type var_accesses: :\
             py:class:`psyclone.core.VariablesAccessInfo`
  
         :raises NotImplementedError: as this method is not implemented.
  
         '''
         raise NotImplementedError("TODO #928: banded_dofmap not implemented")
  

Here is the caller graph for this function:

◆ basis()

def psyclone.domain.lfric.kernel_interface.KernelInterface.basis	(	self,
		function_space,
		var_accesses = `None`
	)

Create an LFRic basis function argument and add it to the symbol
table and argument list.

:param function_space: the function space for this basis function.
:type function_space: :py:class:`psyclone.domain.lfric.FunctionSpace`
:param var_accesses: an unused optional argument that stores \
    information about variable accesses.
:type var_accesses: :\
    py:class:`psyclone.core.VariablesAccessInfo`

Reimplemented from psyclone.domain.lfric.arg_ordering.ArgOrdering.

Definition at line 544 of file kernel_interface.py.

     def basis(self, function_space, var_accesses=None):
         '''Create an LFRic basis function argument and add it to the symbol
         table and argument list.
  
         :param function_space: the function space for this basis function.
         :type function_space: :py:class:`psyclone.domain.lfric.FunctionSpace`
         :param var_accesses: an unused optional argument that stores \
             information about variable accesses.
         :type var_accesses: :\
             py:class:`psyclone.core.VariablesAccessInfo`
  
         '''
         basis_name_func = function_space.get_basis_name
         # This import must be placed here to avoid circular dependencies
         # pylint: disable=import-outside-toplevel
         from psyclone.dynamo0p3 import DynBasisFunctions
         first_dim_value_func = DynBasisFunctions.basis_first_dim_value
         self._create_basis(function_space, self.basis_mapping,
                            basis_name_func, first_dim_value_func)
  

References psyclone.domain.lfric.kernel_interface.KernelInterface._create_basis(), and psyclone.domain.lfric.kernel_interface.KernelInterface.basis_mapping.

Here is the call graph for this function:

Here is the caller graph for this function:

◆ cell_map()

def psyclone.domain.lfric.kernel_interface.KernelInterface.cell_map	(	self,
		var_accesses = `None`
	)

Not implemented.

:param var_accesses: an unused optional argument that stores \
    information about variable accesses.
:type var_accesses: :\
    py:class:`psyclone.core.VariablesAccessInfo`

:raises NotImplementedError: as this method is not implemented.

Reimplemented from psyclone.domain.lfric.arg_ordering.ArgOrdering.

Definition at line 202 of file kernel_interface.py.

     def cell_map(self, var_accesses=None):
         '''Not implemented.
  
         :param var_accesses: an unused optional argument that stores \
             information about variable accesses.
         :type var_accesses: :\
             py:class:`psyclone.core.VariablesAccessInfo`
  
         :raises NotImplementedError: as this method is not implemented.
  
         '''
         raise NotImplementedError("TODO #928: cell_map not implemented")
  

Here is the caller graph for this function:

◆ cell_position()

def psyclone.domain.lfric.kernel_interface.KernelInterface.cell_position	(	self,
		var_accesses = `None`
	)

Create an LFRic cell-position object and add it to the symbol table
and argument list.

:param var_accesses: an unused optional argument that stores \
    information about variable accesses.
:type var_accesses: :\
    py:class:`psyclone.core.VariablesAccessInfo`

Reimplemented from psyclone.domain.lfric.arg_ordering.ArgOrdering.

Definition at line 145 of file kernel_interface.py.

     def cell_position(self, var_accesses=None):
         '''Create an LFRic cell-position object and add it to the symbol table
         and argument list.
  
         :param var_accesses: an unused optional argument that stores \
             information about variable accesses.
         :type var_accesses: :\
             py:class:`psyclone.core.VariablesAccessInfo`
  
         '''
         symbol = self._symtab.find_or_create_tag(
             "cell", symbol_type=LFRicTypes("CellPositionDataSymbol"),
             interface=self._read_access)
         self._arglist.append(symbol)
  

References psyclone.domain.lfric.arg_ordering.ArgOrdering._arglist, psyclone.domain.lfric.kernel_interface.KernelInterface._arglist, psyclone.domain.lfric.kernel_interface.KernelInterface._read_access, psyclone.domain.lfric.arg_ordering.ArgOrdering._symtab(), and psyclone.domain.lfric.arg_ordering.ArgOrdering.append().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ cma_operator()

def psyclone.domain.lfric.kernel_interface.KernelInterface.cma_operator	(	self,
		arg,
		var_accesses = `None`
	)

Not implemented.

:param arg: the CMA operator argument.
:type arg: :py:class:`psyclone.dynamo0p3.DynKernelArgument`
:param var_accesses: an unused optional argument that stores \
    information about variable accesses.
:type var_accesses: :\
    py:class:`psyclone.core.VariablesAccessInfo`

:raises NotImplementedError: as this method is not implemented.

Reimplemented from psyclone.domain.lfric.arg_ordering.ArgOrdering.

Definition at line 390 of file kernel_interface.py.

     def cma_operator(self, arg, var_accesses=None):
         '''Not implemented.
  
         :param arg: the CMA operator argument.
         :type arg: :py:class:`psyclone.dynamo0p3.DynKernelArgument`
         :param var_accesses: an unused optional argument that stores \
             information about variable accesses.
         :type var_accesses: :\
             py:class:`psyclone.core.VariablesAccessInfo`
  
         :raises NotImplementedError: as this method is not implemented.
  
         '''
         raise NotImplementedError("TODO #928: cma_operator not implemented")
  

Here is the caller graph for this function:

◆ diff_basis()

def psyclone.domain.lfric.kernel_interface.KernelInterface.diff_basis	(	self,
		function_space,
		var_accesses = `None`
	)

Create an LFRic differential basis function argument and add it to
the symbol table and argument list.

:param function_space: the function space for this \
    differential basis function.
:type function_space: :py:class:`psyclone.domain.lfric.FunctionSpace`
:param var_accesses: an unused optional argument that stores \
    information about variable accesses.
:type var_accesses: :\
    py:class:`psyclone.core.VariablesAccessInfo`

Reimplemented from psyclone.domain.lfric.arg_ordering.ArgOrdering.

Definition at line 564 of file kernel_interface.py.

     def diff_basis(self, function_space, var_accesses=None):
         '''Create an LFRic differential basis function argument and add it to
         the symbol table and argument list.
  
         :param function_space: the function space for this \
             differential basis function.
         :type function_space: :py:class:`psyclone.domain.lfric.FunctionSpace`
         :param var_accesses: an unused optional argument that stores \
             information about variable accesses.
         :type var_accesses: :\
             py:class:`psyclone.core.VariablesAccessInfo`
  
         '''
         basis_name_func = function_space.get_diff_basis_name
         # This import must be placed here to avoid circular dependencies
         # pylint: disable=import-outside-toplevel
         from psyclone.dynamo0p3 import DynBasisFunctions
         first_dim_value_func = DynBasisFunctions.diff_basis_first_dim_value
         self._create_basis(function_space, self.diff_basis_mapping,
                            basis_name_func, first_dim_value_func)
  

References psyclone.domain.lfric.kernel_interface.KernelInterface._create_basis(), and psyclone.domain.lfric.kernel_interface.KernelInterface.diff_basis_mapping.

Here is the call graph for this function:

Here is the caller graph for this function:

◆ field()

def psyclone.domain.lfric.kernel_interface.KernelInterface.field	(	self,
		arg,
		var_accesses = `None`
	)

Create an LFRic field argument and add it to the symbol table and
argument list. Also declare the associated "undf" symbol if it
has not already been declared so that it can be used to
dimension the field argument.

:param arg: the field to add.
:type arg: :py:class:`psyclone.dynamo0p3.DynKernelArgument`
:param var_accesses: an unused optional argument that stores \
    information about variable accesses.
:type var_accesses: :\
    py:class:`psyclone.core.VariablesAccessInfo`

:raises NotImplementedError: if the datatype of the field is \
    not supported.

Reimplemented from psyclone.domain.lfric.arg_ordering.ArgOrdering.

Definition at line 256 of file kernel_interface.py.

     def field(self, arg, var_accesses=None):
         '''Create an LFRic field argument and add it to the symbol table and
         argument list. Also declare the associated "undf" symbol if it
         has not already been declared so that it can be used to
         dimension the field argument.
  
         :param arg: the field to add.
         :type arg: :py:class:`psyclone.dynamo0p3.DynKernelArgument`
         :param var_accesses: an unused optional argument that stores \
             information about variable accesses.
         :type var_accesses: :\
             py:class:`psyclone.core.VariablesAccessInfo`
  
         :raises NotImplementedError: if the datatype of the field is \
             not supported.
  
         '''
         fs_name = arg.function_space.orig_name
  
         undf_symbol = self._symtab.find_or_create_tag(
             f"undf_{fs_name}",
             symbol_type=LFRicTypes("NumberOfUniqueDofsDataSymbol"),
             fs=fs_name, interface=self._read_access)
  
         try:
             type_name = self.field_mapping[arg.intrinsic_type]
             field_class = LFRicTypes(type_name)
         except KeyError as info:
             message = (f"kernel interface does not support a field of type "
                        f"'{arg.intrinsic_type}'.")
             raise NotImplementedError(message) from info
         field_data_symbol = self._symtab.find_or_create_tag(
             arg.name, interface=ArgumentInterface(INTENT_MAPPING[arg.intent]),
             symbol_type=field_class, dims=[Reference(undf_symbol)], fs=fs_name)
  
         self._arg_index_to_metadata_index[len(self._arglist)] = (
             arg.metadata_index)
         self._arglist.append(field_data_symbol)
  

References psyclone.domain.lfric.arg_ordering.ArgOrdering._arg_index_to_metadata_index, psyclone.domain.lfric.arg_ordering.ArgOrdering._arglist, psyclone.domain.lfric.kernel_interface.KernelInterface._arglist, psyclone.domain.lfric.kernel_interface.KernelInterface._read_access, psyclone.domain.lfric.arg_ordering.ArgOrdering._symtab(), psyclone.domain.lfric.arg_ordering.ArgOrdering.append(), and psyclone.domain.lfric.kernel_interface.KernelInterface.field_mapping.

Here is the call graph for this function:

Here is the caller graph for this function:

◆ field_bcs_kernel()

def psyclone.domain.lfric.kernel_interface.KernelInterface.field_bcs_kernel	(	self,
		function_space,
		var_accesses = `None`
	)

Create the boundary-dofs mask argument required for the
enforce_bc_code kernel. Adds it to the symbol table and the argument
list.

:param function_space: the function space for this boundary condition.
:type function_space: :py:class:`psyclone.domain.lfric.FunctionSpace`
:param var_accesses: an unused optional argument that stores
    information about variable accesses.
:type var_accesses: :py:class:`psyclone.core.VariablesAccessInfo`

:raises InternalError: if the kernel does not have a single field as
                       argument.
:raises InternalError: if the field argument is not on the
                       'ANY_SPACE_1' function space.

Reimplemented from psyclone.domain.lfric.arg_ordering.ArgOrdering.

Definition at line 585 of file kernel_interface.py.

     def field_bcs_kernel(self, function_space, var_accesses=None):
         '''Create the boundary-dofs mask argument required for the
         enforce_bc_code kernel. Adds it to the symbol table and the argument
         list.
  
         :param function_space: the function space for this boundary condition.
         :type function_space: :py:class:`psyclone.domain.lfric.FunctionSpace`
         :param var_accesses: an unused optional argument that stores
             information about variable accesses.
         :type var_accesses: :py:class:`psyclone.core.VariablesAccessInfo`
  
         :raises InternalError: if the kernel does not have a single field as
                                argument.
         :raises InternalError: if the field argument is not on the
                                'ANY_SPACE_1' function space.
  
         '''
         # Sanity check - expect the enforce_bc_code to have a single argument
         # that is a field.
         if (len(self._kern.arguments.args) != 1 or
                 not self._kern.arguments.args[0].is_field):
             const = LFRicConstants()
             raise InternalError(
                 f"Kernel '{self._kern.name}' applies boundary conditions to a "
                 f"field and therefore should have a single, field argument "
                 f"(one of {const.VALID_FIELD_NAMES}) but got "
                 f"{[arg.argument_type for arg in self._kern.arguments.args]}")
         farg = self._kern.arguments.args[0]
         fspace = farg.function_space
         # Sanity check - expect the field argument to the enforce_bc_code
         # kernel to be on the ANY_SPACE_1 space.
         if fspace.orig_name != "any_space_1":
             raise InternalError(
                 f"Kernel '{self._kern.name}' applies boundary conditions to a "
                 f"field but the supplied argument, '{farg.name}', is on "
                 f"'{fspace.orig_name}' rather than the expected 'ANY_SPACE_1'")
  
         ndf_symbol = self._symtab.find_or_create_tag(
             f"ndf_{fspace.orig_name}", fs=fspace.orig_name,
             symbol_type=LFRicTypes("NumberOfDofsDataSymbol"),
             interface=self._read_access)
  
         # Add the boundary-dofs array argument.
         sym = self._symtab.find_or_create_tag(
             f"boundary_dofs_{farg.name}",
             interface=self._read_access,
             symbol_type=LFRicTypes("VerticalBoundaryDofMaskDataSymbol"),
             dims=[Reference(ndf_symbol), 2])
         self._arglist.append(sym)
  

References psyclone.domain.lfric.arg_ordering.ArgOrdering._arglist, psyclone.domain.lfric.kernel_interface.KernelInterface._arglist, psyclone.domain.common.psylayer.psyloop.PSyLoop._kern, psyclone.domain.lfric.arg_ordering.ArgOrdering._kern, psyclone.domain.lfric.lfric_loop.LFRicLoop._kern, psyclone.domain.lfric.kernel_interface.KernelInterface._read_access, psyclone.domain.lfric.arg_ordering.ArgOrdering._symtab(), and psyclone.domain.lfric.arg_ordering.ArgOrdering.append().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ field_vector()

def psyclone.domain.lfric.kernel_interface.KernelInterface.field_vector	(	self,
		argvect,
		var_accesses = `None`
	)

Create LFRic field vector arguments and add them to the symbol
table and argument list. Also declare the associated "undf"
symbol if it has not already been declared so that it can be
used to dimension the field vector arguments.

:param argvect: the field vector to add.
:type argvect: :py:class:`psyclone.dynamo0p3.DynKernelArgument`
:param var_accesses: an unused optional argument that stores \
    information about variable accesses.
:type var_accesses: :\
    py:class:`psyclone.core.VariablesAccessInfo`

:raises NotImplementedError: if the datatype of the vector \
    field is not supported.

Reimplemented from psyclone.domain.lfric.arg_ordering.ArgOrdering.

Definition at line 215 of file kernel_interface.py.

     def field_vector(self, argvect, var_accesses=None):
         '''Create LFRic field vector arguments and add them to the symbol
         table and argument list. Also declare the associated "undf"
         symbol if it has not already been declared so that it can be
         used to dimension the field vector arguments.
  
         :param argvect: the field vector to add.
         :type argvect: :py:class:`psyclone.dynamo0p3.DynKernelArgument`
         :param var_accesses: an unused optional argument that stores \
             information about variable accesses.
         :type var_accesses: :\
             py:class:`psyclone.core.VariablesAccessInfo`
  
         :raises NotImplementedError: if the datatype of the vector \
             field is not supported.
  
         '''
         fs_name = argvect.function_space.orig_name
         undf_symbol = self._symtab.find_or_create_tag(
             f"undf_{fs_name}", fs=fs_name,
             symbol_type=LFRicTypes("NumberOfUniqueDofsDataSymbol"),
             interface=self._read_access)
  
         interface = ArgumentInterface(INTENT_MAPPING[argvect.intent])
         try:
             type_name = self.vector_field_mapping[argvect.intrinsic_type]
             field_class = LFRicTypes(type_name)
         except KeyError as info:
             message = (f"kernel interface does not support a vector field of "
                        f"type '{argvect.intrinsic_type}'.")
             raise NotImplementedError(message) from info
         for idx in range(argvect.vector_size):
             tag = f"{argvect.name}_v{idx}"
             field_data_symbol = self._symtab.find_or_create_tag(
                 tag, symbol_type=field_class, dims=[Reference(undf_symbol)],
                 fs=fs_name, interface=interface)
  
             self._arg_index_to_metadata_index[len(self._arglist)] = (
                 argvect.metadata_index)
             self._arglist.append(field_data_symbol)
  

References psyclone.domain.lfric.arg_ordering.ArgOrdering._arg_index_to_metadata_index, psyclone.domain.lfric.arg_ordering.ArgOrdering._arglist, psyclone.domain.lfric.kernel_interface.KernelInterface._arglist, psyclone.domain.lfric.kernel_interface.KernelInterface._read_access, psyclone.domain.lfric.arg_ordering.ArgOrdering._symtab(), psyclone.domain.lfric.arg_ordering.ArgOrdering.append(), and psyclone.domain.lfric.kernel_interface.KernelInterface.vector_field_mapping.

Here is the call graph for this function:

Here is the caller graph for this function:

◆ fs_common()

def psyclone.domain.lfric.kernel_interface.KernelInterface.fs_common	(	self,
		function_space,
		var_accesses = `None`
	)

Create any arguments that are common to a particular function
space. At this time the only common argument is the number of
degrees of freedom. Create the associated LFRic symbol, and
add it to the symbol table and argument list.

:param function_space: the function space for any common arguments.
:type function_space: :py:class:`psyclone.domain.lfric.FunctionSpace`
:param var_accesses: an unused optional argument that stores \
    information about variable accesses.
:type var_accesses: :\
    py:class:`psyclone.core.VariablesAccessInfo`

Reimplemented from psyclone.domain.lfric.arg_ordering.ArgOrdering.

Definition at line 438 of file kernel_interface.py.

     def fs_common(self, function_space, var_accesses=None):
         '''Create any arguments that are common to a particular function
         space. At this time the only common argument is the number of
         degrees of freedom. Create the associated LFRic symbol, and
         add it to the symbol table and argument list.
  
         :param function_space: the function space for any common arguments.
         :type function_space: :py:class:`psyclone.domain.lfric.FunctionSpace`
         :param var_accesses: an unused optional argument that stores \
             information about variable accesses.
         :type var_accesses: :\
             py:class:`psyclone.core.VariablesAccessInfo`
  
         '''
         fs_name = function_space.orig_name
         ndf_symbol = self._symtab.find_or_create_tag(
             f"ndf_{fs_name}", fs=fs_name,
             symbol_type=LFRicTypes("NumberOfDofsDataSymbol"),
             interface=self._read_access)
         self._arglist.append(ndf_symbol)
  

References psyclone.domain.lfric.arg_ordering.ArgOrdering._arglist, psyclone.domain.lfric.kernel_interface.KernelInterface._arglist, psyclone.domain.lfric.kernel_interface.KernelInterface._read_access, psyclone.domain.lfric.arg_ordering.ArgOrdering._symtab(), and psyclone.domain.lfric.arg_ordering.ArgOrdering.append().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ fs_compulsory_field()

def psyclone.domain.lfric.kernel_interface.KernelInterface.fs_compulsory_field	(	self,
		function_space,
		var_accesses = `None`
	)

Create any arguments that are compulsory for a field on a
particular function space. At this time the compulsory
arguments are the unique number of degrees of freedom and the
dofmap. Create the associated LFRic symbol, and add it to the
symbol table and argument list. Also declare the number of
degrees of freedom and add to the symbol table if one has not
yet been added.

:param function_space: the function space for any compulsory arguments.
:type function_space: :py:class:`psyclone.domain.lfric.FunctionSpace`
:param var_accesses: an unused optional argument that stores \
    information about variable accesses.
:type var_accesses: :\
    py:class:`psyclone.core.VariablesAccessInfo`

Reimplemented from psyclone.domain.lfric.arg_ordering.ArgOrdering.

Definition at line 474 of file kernel_interface.py.

     def fs_compulsory_field(self, function_space, var_accesses=None):
         '''Create any arguments that are compulsory for a field on a
         particular function space. At this time the compulsory
         arguments are the unique number of degrees of freedom and the
         dofmap. Create the associated LFRic symbol, and add it to the
         symbol table and argument list. Also declare the number of
         degrees of freedom and add to the symbol table if one has not
         yet been added.
  
         :param function_space: the function space for any compulsory arguments.
         :type function_space: :py:class:`psyclone.domain.lfric.FunctionSpace`
         :param var_accesses: an unused optional argument that stores \
             information about variable accesses.
         :type var_accesses: :\
             py:class:`psyclone.core.VariablesAccessInfo`
  
         '''
         fs_name = function_space.orig_name
         undf_symbol = self._symtab.find_or_create_tag(
             f"undf_{fs_name}", fs=fs_name,
             symbol_type=LFRicTypes("NumberOfUniqueDofsDataSymbol"),
             interface=self._read_access)
         self._arglist.append(undf_symbol)
  
         fs_name = function_space.orig_name
         ndf_symbol = self._symtab.find_or_create_tag(
             f"ndf_{fs_name}", fs=fs_name,
             symbol_type=LFRicTypes("NumberOfDofsDataSymbol"),
             interface=self._read_access)
  
         dofmap_symbol = self._symtab.find_or_create_tag(
             f"dofmap_{fs_name}", fs=fs_name,
             symbol_type=LFRicTypes("DofMapDataSymbol"),
             dims=[Reference(ndf_symbol)], interface=self._read_access)
         self._arglist.append(dofmap_symbol)
  

References psyclone.domain.lfric.arg_ordering.ArgOrdering._arglist, psyclone.domain.lfric.kernel_interface.KernelInterface._arglist, psyclone.domain.lfric.kernel_interface.KernelInterface._read_access, psyclone.domain.lfric.arg_ordering.ArgOrdering._symtab(), and psyclone.domain.lfric.arg_ordering.ArgOrdering.append().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ fs_intergrid()

def psyclone.domain.lfric.kernel_interface.KernelInterface.fs_intergrid	(	self,
		function_space,
		var_accesses = `None`
	)

Not implemented.

:param arg: the CMA operator argument.
:type arg: :py:class:`psyclone.dynamo0p3.DynKernelArgument`
:param var_accesses: an unused optional argument that stores \
    information about variable accesses.
:type var_accesses: :\
    py:class:`psyclone.core.VariablesAccessInfo`

:raises NotImplementedError: as this method is not implemented.

Reimplemented from psyclone.domain.lfric.arg_ordering.ArgOrdering.

Definition at line 459 of file kernel_interface.py.

     def fs_intergrid(self, function_space, var_accesses=None):
         '''Not implemented.
  
         :param arg: the CMA operator argument.
         :type arg: :py:class:`psyclone.dynamo0p3.DynKernelArgument`
         :param var_accesses: an unused optional argument that stores \
             information about variable accesses.
         :type var_accesses: :\
             py:class:`psyclone.core.VariablesAccessInfo`
  
         :raises NotImplementedError: as this method is not implemented.
  
         '''
         raise NotImplementedError("TODO #928: fs_intergrid not implemented")
  

Here is the caller graph for this function:

◆ generate()

def psyclone.domain.lfric.kernel_interface.KernelInterface.generate	(	self,
		var_accesses = `None`
	)

Call the generate base class then add the argument list as it can't
be appended as we go along.

:param var_accesses: an unused optional argument that stores \
    information about variable accesses.
:type var_accesses: :\
    py:class:`psyclone.core.VariablesAccessInfo`

Reimplemented from psyclone.domain.lfric.arg_ordering.ArgOrdering.

Definition at line 112 of file kernel_interface.py.

     def generate(self, var_accesses=None):
         '''Call the generate base class then add the argument list as it can't
         be appended as we go along.
  
         :param var_accesses: an unused optional argument that stores \
             information about variable accesses.
         :type var_accesses: :\
             py:class:`psyclone.core.VariablesAccessInfo`
  
         '''
         super().generate(var_accesses=var_accesses)
         # Set the argument list for the symbol table. This is done at
         # the end after incrementally adding symbols to the _args
         # list, as it is not possible to incrementally add symbols to
         # the symbol table argument list.
         self._symtab.specify_argument_list(self._arglist)
         # While data dependence analysis does not use the symbol
         # table, see #845, we have to provide variable information
         # separately. This is done by using the base class append()
         # method. However, this method also adds the variable names to the
         # internal _arglist list which we do not want as we have
         # already added our symbols there. Therefore we need to remove
         # them afterwards.
         # Map from symbol table accesses to dependence analysis accesses.
         mapping = {ArgumentInterface.Access.READ: AccessType.READ,
                    ArgumentInterface.Access.READWRITE: AccessType.READWRITE,
                    ArgumentInterface.Access.WRITE: AccessType.WRITE}
         len_arglist = len(self._arglist)
         for symbol in self._symtab.symbols:
             self.append(symbol.name, var_accesses,
                         mode=mapping[symbol.interface.access])
         self._arglist = self._arglist[:len_arglist]
  

References psyclone.domain.lfric.arg_ordering.ArgOrdering._arglist, psyclone.domain.lfric.kernel_interface.KernelInterface._arglist, psyclone.domain.lfric.arg_ordering.ArgOrdering._symtab(), psyclone.psyir.nodes.node.ChildrenList.append(), psyclone.gocean1p0.GOKernelArguments.append(), psyclone.psyGen.Arguments.append(), and psyclone.domain.lfric.arg_ordering.ArgOrdering.append().

Here is the call graph for this function:

◆ indirection_dofmap()

def psyclone.domain.lfric.kernel_interface.KernelInterface.indirection_dofmap	(	self,
		function_space,
		operator = `None`,
		var_accesses = `None`
	)

Not implemented.

:param function_space: the function space for this dofmap.
:type function_space: :py:class:`psyclone.domain.lfric.FunctionSpace`
:param operator: the CMA operator.
:type operator: :py:class:`psyclone.dynamo0p3.DynKernelArgument`
:param var_accesses: an unused optional argument that stores \
    information about variable accesses.
:type var_accesses: :\
    py:class:`psyclone.core.VariablesAccessInfo`

:raises NotImplementedError: as this method is not implemented.

Reimplemented from psyclone.domain.lfric.arg_ordering.ArgOrdering.

Definition at line 525 of file kernel_interface.py.

                            var_accesses=None):
         '''Not implemented.
  
         :param function_space: the function space for this dofmap.
         :type function_space: :py:class:`psyclone.domain.lfric.FunctionSpace`
         :param operator: the CMA operator.
         :type operator: :py:class:`psyclone.dynamo0p3.DynKernelArgument`
         :param var_accesses: an unused optional argument that stores \
             information about variable accesses.
         :type var_accesses: :\
             py:class:`psyclone.core.VariablesAccessInfo`
  
         :raises NotImplementedError: as this method is not implemented.
  
         '''
         raise NotImplementedError(
             "TODO #928: indirection_dofmap not implemented")
  

Here is the caller graph for this function:

◆ mesh_height()

def psyclone.domain.lfric.kernel_interface.KernelInterface.mesh_height	(	self,
		var_accesses = `None`
	)

Create an LFRic mesh height object and add it to the symbol table
and argument list.

:param var_accesses: an unused optional argument that stores \
    information about variable accesses.
:type var_accesses: :\
    py:class:`psyclone.core.VariablesAccessInfo`

Reimplemented from psyclone.domain.lfric.arg_ordering.ArgOrdering.

Definition at line 160 of file kernel_interface.py.

     def mesh_height(self, var_accesses=None):
         '''Create an LFRic mesh height object and add it to the symbol table
         and argument list.
  
         :param var_accesses: an unused optional argument that stores \
             information about variable accesses.
         :type var_accesses: :\
             py:class:`psyclone.core.VariablesAccessInfo`
  
         '''
         symbol = self._symtab.find_or_create_tag(
             "nlayers", symbol_type=LFRicTypes("MeshHeightDataSymbol"),
             interface=self._read_access)
         self._arglist.append(symbol)
  

References psyclone.domain.lfric.arg_ordering.ArgOrdering._arglist, psyclone.domain.lfric.kernel_interface.KernelInterface._arglist, psyclone.domain.lfric.kernel_interface.KernelInterface._read_access, psyclone.domain.lfric.arg_ordering.ArgOrdering._symtab(), and psyclone.domain.lfric.arg_ordering.ArgOrdering.append().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ mesh_properties()

def psyclone.domain.lfric.kernel_interface.KernelInterface.mesh_properties	(	self,
		var_accesses = `None`
	)

 Properties associated with the mesh

:param var_accesses: an unused optional argument that stores \
    information about variable accesses.
:type var_accesses: :\
    py:class:`psyclone.core.VariablesAccessInfo`

Reimplemented from psyclone.domain.lfric.arg_ordering.ArgOrdering.

Definition at line 662 of file kernel_interface.py.

     def mesh_properties(self, var_accesses=None):
         ''' Properties associated with the mesh
  
         :param var_accesses: an unused optional argument that stores \
             information about variable accesses.
         :type var_accesses: :\
             py:class:`psyclone.core.VariablesAccessInfo`
  
         '''
         # This callback does not contribute any kernel arguments
  

Here is the caller graph for this function:

◆ operator()

def psyclone.domain.lfric.kernel_interface.KernelInterface.operator	(	self,
		arg,
		var_accesses = `None`
	)

Create an LFRic operator argument and an ncells argument and add
them to the symbol table and argument list. Also declare the
associated 'fs_from', 'fs_to' symbols if they have not already
been declared so that they can be used to dimension the
operator symbol (as well as ncells).

:param arg: the operator to add.
:type arg: :py:class:`psyclone.dynamo0p3.DynKernelArgument`
:param var_accesses: an unused optional argument that stores
    information about variable accesses.
:type var_accesses: :py:class:`psyclone.core.VariablesAccessInfo`

:raises NotImplementedError: if the datatype of the field is
    not supported.

Reimplemented from psyclone.domain.lfric.arg_ordering.ArgOrdering.

Definition at line 342 of file kernel_interface.py.

     def operator(self, arg, var_accesses=None):
         '''Create an LFRic operator argument and an ncells argument and add
         them to the symbol table and argument list. Also declare the
         associated 'fs_from', 'fs_to' symbols if they have not already
         been declared so that they can be used to dimension the
         operator symbol (as well as ncells).
  
         :param arg: the operator to add.
         :type arg: :py:class:`psyclone.dynamo0p3.DynKernelArgument`
         :param var_accesses: an unused optional argument that stores
             information about variable accesses.
         :type var_accesses: :py:class:`psyclone.core.VariablesAccessInfo`
  
         :raises NotImplementedError: if the datatype of the field is
             not supported.
  
         '''
         fs_from_name = arg.function_space_from.orig_name
  
         ndf_symbol_from = self._symtab.find_or_create_tag(
             f"ndf_{fs_from_name}", fs=fs_from_name,
             symbol_type=LFRicTypes("NumberOfDofsDataSymbol"),
             interface=self._read_access)
         fs_to_name = arg.function_space_to.orig_name
         ndf_symbol_to = self._symtab.find_or_create_tag(
             f"ndf_{fs_to_name}", fs=fs_to_name,
             symbol_type=LFRicTypes("NumberOfDofsDataSymbol"),
             interface=self._read_access)
  
         # We may already have a symbol for this argument as we add it for each
         # operator (TODO #2074).
         ncells = self._symtab.find_or_create(
             "ncell_3d",
             symbol_type=LFRicTypes("NumberOfCellsDataSymbol"),
             interface=self._read_access)
         self._arglist.append(ncells)
  
         op_arg_symbol = self._symtab.find_or_create_tag(
             arg.name, symbol_type=LFRicTypes("OperatorDataSymbol"),
             dims=[Reference(ndf_symbol_from), Reference(ndf_symbol_to),
                   Reference(ncells)],
             fs_from=fs_from_name, fs_to=fs_to_name,
             interface=ArgumentInterface(INTENT_MAPPING[arg.intent]))
  
         self._arg_index_to_metadata_index[len(self._arglist)] = (
             arg.metadata_index)
         self._arglist.append(op_arg_symbol)
  

References psyclone.domain.lfric.arg_ordering.ArgOrdering._arg_index_to_metadata_index, psyclone.domain.lfric.arg_ordering.ArgOrdering._arglist, psyclone.domain.lfric.kernel_interface.KernelInterface._arglist, psyclone.domain.lfric.kernel_interface.KernelInterface._read_access, psyclone.domain.lfric.arg_ordering.ArgOrdering._symtab(), and psyclone.domain.lfric.arg_ordering.ArgOrdering.append().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ operator_bcs_kernel()

def psyclone.domain.lfric.kernel_interface.KernelInterface.operator_bcs_kernel	(	self,
		function_space,
		var_accesses = `None`
	)

Not implemented.

:param function_space: the function space for this bcs kernel
:type function_space: :py:class:`psyclone.domain.lfric.FunctionSpace`
:param var_accesses: an unused optional argument that stores \
    information about variable accesses.
:type var_accesses: :\
    py:class:`psyclone.core.VariablesAccessInfo`

:raises NotImplementedError: as this method is not implemented.

Reimplemented from psyclone.domain.lfric.arg_ordering.ArgOrdering.

Definition at line 635 of file kernel_interface.py.

     def operator_bcs_kernel(self, function_space, var_accesses=None):
         '''Not implemented.
  
         :param function_space: the function space for this bcs kernel
         :type function_space: :py:class:`psyclone.domain.lfric.FunctionSpace`
         :param var_accesses: an unused optional argument that stores \
             information about variable accesses.
         :type var_accesses: :\
             py:class:`psyclone.core.VariablesAccessInfo`
  
         :raises NotImplementedError: as this method is not implemented.
  
         '''
         raise NotImplementedError(
             "TODO #928: operator_bcs_kernel not implemented")
  

Here is the caller graph for this function:

◆ quad_rule()

def psyclone.domain.lfric.kernel_interface.KernelInterface.quad_rule	(	self,
		var_accesses = `None`
	)

Create LFRic arguments associated with the required quadrature, if
they do not already exist, and add them to the symbol table
and argument list. The arguments depend on the type of
quadrature requested.

:param var_accesses: an unused optional argument that stores \
    information about variable accesses.
:type var_accesses: :\
    py:class:`psyclone.core.VariablesAccessInfo`

:raises InternalError: if an unsupported quadrature shape is \
    found.

Reimplemented from psyclone.domain.lfric.arg_ordering.ArgOrdering.

Definition at line 673 of file kernel_interface.py.

     def quad_rule(self, var_accesses=None):
         '''Create LFRic arguments associated with the required quadrature, if
         they do not already exist, and add them to the symbol table
         and argument list. The arguments depend on the type of
         quadrature requested.
  
         :param var_accesses: an unused optional argument that stores \
             information about variable accesses.
         :type var_accesses: :\
             py:class:`psyclone.core.VariablesAccessInfo`
  
         :raises InternalError: if an unsupported quadrature shape is \
             found.
  
         '''
         # The kernel captures all the required quadrature shapes
         for shape in self._kern.qr_rules:
             if shape == "gh_quadrature_xyoz":
                 nqp_xy = self._symtab.find_or_create_tag(
                     "nqp_xy",
                     symbol_type=LFRicTypes("NumberOfQrPointsInXyDataSymbol"),
                     interface=self._read_access)
                 nqp_z = self._symtab.find_or_create_tag(
                     "nqp_z",
                     symbol_type=LFRicTypes("NumberOfQrPointsInZDataSymbol"),
                     interface=self._read_access)
                 weights_xy = self._symtab.find_or_create_tag(
                     "weights_xy",
                     symbol_type=LFRicTypes("QrWeightsInXyDataSymbol"),
                     dims=[Reference(nqp_xy)], interface=self._read_access)
                 weights_z = self._symtab.find_or_create_tag(
                     "weights_z",
                     symbol_type=LFRicTypes("QrWeightsInZDataSymbol"),
                     dims=[Reference(nqp_z)], interface=self._read_access)
                 self._arglist.extend([nqp_xy, nqp_z, weights_xy, weights_z])
             elif shape == "gh_quadrature_face":
                 nfaces = self._symtab.find_or_create_tag(
                     "nfaces",
                     symbol_type=LFRicTypes("NumberOfFacesDataSymbol"),
                     interface=self._read_access)
                 nqp = self._symtab.find_or_create_tag(
                     "nqp_faces",
                     symbol_type=LFRicTypes(
                         "NumberOfQrPointsInFacesDataSymbol"),
                     interface=self._read_access)
                 weights = self._symtab.find_or_create_tag(
                     "weights_faces",
                     symbol_type=LFRicTypes("QrWeightsInFacesDataSymbol"),
                     dims=[Reference(nqp)], interface=self._read_access)
                 self._arglist.extend([nfaces, nqp, weights])
             elif shape == "gh_quadrature_edge":
                 nedges = self._symtab.find_or_create_tag(
                     "nedges",
                     symbol_type=LFRicTypes("NumberOfEdgesDataSymbol"),
                     interface=self._read_access)
                 nqp = self._symtab.find_or_create_tag(
                     "nqp_edges",
                     symbol_type=LFRicTypes(
                         "NumberOfQrPointsInEdgesDataSymbol"),
                     interface=self._read_access)
                 weights = self._symtab.find_or_create_tag(
                     "weights_edges",
                     symbol_type=LFRicTypes("QrWeightsInEdgesDataSymbol"),
                     dims=[Reference(nqp)], interface=self._read_access)
                 self._arglist.extend([nedges, nqp, weights])
             else:
                 raise InternalError(f"Unsupported quadrature shape '{shape}' "
                                     f"found in kernel_interface.")
  

Here is the caller graph for this function:

◆ ref_element_properties()

def psyclone.domain.lfric.kernel_interface.KernelInterface.ref_element_properties	(	self,
		var_accesses = `None`
	)

 Properties associated with the reference element

:param var_accesses: an unused optional argument that stores \
    information about variable accesses.
:type var_accesses: :\
    py:class:`psyclone.core.VariablesAccessInfo`

Reimplemented from psyclone.domain.lfric.arg_ordering.ArgOrdering.

Definition at line 651 of file kernel_interface.py.

     def ref_element_properties(self, var_accesses=None):
         ''' Properties associated with the reference element
  
         :param var_accesses: an unused optional argument that stores \
             information about variable accesses.
         :type var_accesses: :\
             py:class:`psyclone.core.VariablesAccessInfo`
  
         '''
         # This callback does not contribute any kernel arguments
  

Here is the caller graph for this function:

◆ scalar()

def psyclone.domain.lfric.kernel_interface.KernelInterface.scalar	(	self,
		scalar_arg,
		var_accesses = `None`
	)

Create an LFRic scalar argument and add it to the symbol table and
argument list.

:param scalar_arg: the scalar to add.
:type scalar_arg: :py:class:`psyclone.dynamo0p3.DynKernelArgument`
:param var_accesses: an unused optional argument that stores \
    information about variable accesses.
:type var_accesses: :\
    py:class:`psyclone.core.VariablesAccessInfo`

:raises NotImplementedError: if the datatype of the scalar is \
    not supported.

Reimplemented from psyclone.domain.lfric.arg_ordering.ArgOrdering.

Definition at line 405 of file kernel_interface.py.

     def scalar(self, scalar_arg, var_accesses=None):
         '''Create an LFRic scalar argument and add it to the symbol table and
         argument list.
  
         :param scalar_arg: the scalar to add.
         :type scalar_arg: :py:class:`psyclone.dynamo0p3.DynKernelArgument`
         :param var_accesses: an unused optional argument that stores \
             information about variable accesses.
         :type var_accesses: :\
             py:class:`psyclone.core.VariablesAccessInfo`
  
         :raises NotImplementedError: if the datatype of the scalar is \
             not supported.
  
         '''
         mapping = {
             "integer": LFRicTypes("LFRicIntegerScalarDataSymbol"),
             "real": LFRicTypes("LFRicRealScalarDataSymbol"),
             "logical": LFRicTypes("LFRicLogicalScalarDataSymbol")}
         try:
             symbol = self._symtab.find_or_create_tag(
                 scalar_arg.name,
                 symbol_type=mapping[scalar_arg.intrinsic_type],
                 interface=ArgumentInterface(INTENT_MAPPING[scalar_arg.intent]))
         except KeyError as info:
             message = (
                 f"scalar of type '{scalar_arg.intrinsic_type}' not implemented"
                 f" in KernelInterface class.")
             raise NotImplementedError(message) from info
         self._arg_index_to_metadata_index[len(self._arglist)] = (
             scalar_arg.metadata_index)
         self._arglist.append(symbol)
  

References psyclone.domain.lfric.arg_ordering.ArgOrdering._arg_index_to_metadata_index, psyclone.domain.lfric.arg_ordering.ArgOrdering._arglist, psyclone.domain.lfric.kernel_interface.KernelInterface._arglist, psyclone.domain.lfric.arg_ordering.ArgOrdering._symtab(), and psyclone.domain.lfric.arg_ordering.ArgOrdering.append().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ stencil()

def psyclone.domain.lfric.kernel_interface.KernelInterface.stencil	(	self,
		arg,
		var_accesses = `None`
	)

Not implemented.

:param arg: the kernel argument with which the stencil is associated.
:type arg: :py:class:`psyclone.dynamo0p3.DynKernelArgument`
:param var_accesses: an unused optional argument that stores \
    information about variable accesses.
:type var_accesses: :\
    py:class:`psyclone.core.VariablesAccessInfo`

:raises NotImplementedError: as this method is not implemented.

Reimplemented from psyclone.domain.lfric.arg_ordering.ArgOrdering.

Definition at line 327 of file kernel_interface.py.

     def stencil(self, arg, var_accesses=None):
         '''Not implemented.
  
         :param arg: the kernel argument with which the stencil is associated.
         :type arg: :py:class:`psyclone.dynamo0p3.DynKernelArgument`
         :param var_accesses: an unused optional argument that stores \
             information about variable accesses.
         :type var_accesses: :\
             py:class:`psyclone.core.VariablesAccessInfo`
  
         :raises NotImplementedError: as this method is not implemented.
  
         '''
         raise NotImplementedError("TODO #928: stencil not implemented")
  

Here is the caller graph for this function:

◆ stencil_unknown_direction()

def psyclone.domain.lfric.kernel_interface.KernelInterface.stencil_unknown_direction	(	self,
		arg,
		var_accesses = `None`
	)

Not implemented.

:param arg: the kernel argument with which the stencil is associated.
:type arg: :py:class:`psyclone.dynamo0p3.DynKernelArgument`
:param var_accesses: an unused optional argument that stores \
    information about variable accesses.
:type var_accesses: :\
    py:class:`psyclone.core.VariablesAccessInfo`

:raises NotImplementedError: as this method is not implemented.

Reimplemented from psyclone.domain.lfric.arg_ordering.ArgOrdering.

Definition at line 311 of file kernel_interface.py.

     def stencil_unknown_direction(self, arg, var_accesses=None):
         '''Not implemented.
  
         :param arg: the kernel argument with which the stencil is associated.
         :type arg: :py:class:`psyclone.dynamo0p3.DynKernelArgument`
         :param var_accesses: an unused optional argument that stores \
             information about variable accesses.
         :type var_accesses: :\
             py:class:`psyclone.core.VariablesAccessInfo`
  
         :raises NotImplementedError: as this method is not implemented.
  
         '''
         raise NotImplementedError(
             "TODO #928: stencil_unknown_direction not implemented")
  

Here is the caller graph for this function:

◆ stencil_unknown_extent()

def psyclone.domain.lfric.kernel_interface.KernelInterface.stencil_unknown_extent	(	self,
		arg,
		var_accesses = `None`
	)

Not implemented.

:param arg: the kernel argument with which the stencil is associated.
:type arg: :py:class:`psyclone.dynamo0p3.DynKernelArgument`
:param var_accesses: an unused optional argument that stores \
    information about variable accesses.
:type var_accesses: :\
    py:class:`psyclone.core.VariablesAccessInfo`

:raises NotImplementedError: as this method is not implemented.

Reimplemented from psyclone.domain.lfric.arg_ordering.ArgOrdering.

Definition at line 295 of file kernel_interface.py.

     def stencil_unknown_extent(self, arg, var_accesses=None):
         '''Not implemented.
  
         :param arg: the kernel argument with which the stencil is associated.
         :type arg: :py:class:`psyclone.dynamo0p3.DynKernelArgument`
         :param var_accesses: an unused optional argument that stores \
             information about variable accesses.
         :type var_accesses: :\
             py:class:`psyclone.core.VariablesAccessInfo`
  
         :raises NotImplementedError: as this method is not implemented.
  
         '''
         raise NotImplementedError(
             "TODO #928: stencil_unknown_extent not implemented")
  

Here is the caller graph for this function:

Member Data Documentation

◆ basis_mapping

dictionary psyclone.domain.lfric.kernel_interface.KernelInterface.basis_mapping

static

Initial value:

=  {
        "gh_quadrature_xyoz": "BasisFunctionQrXyozDataSymbol",
        "gh_quadrature_face": "BasisFunctionQrFaceDataSymbol",
        "gh_quadrature_edge": "BasisFunctionQrEdgeDataSymbol"}

Definition at line 91 of file kernel_interface.py.

◆ diff_basis_mapping

dictionary psyclone.domain.lfric.kernel_interface.KernelInterface.diff_basis_mapping

static

Initial value:

=  {
        "gh_quadrature_xyoz": "DiffBasisFunctionQrXyozDataSymbol",
        "gh_quadrature_face": "DiffBasisFunctionQrFaceDataSymbol",
        "gh_quadrature_edge": "DiffBasisFunctionQrEdgeDataSymbol"}

Definition at line 97 of file kernel_interface.py.

◆ field_mapping

dictionary psyclone.domain.lfric.kernel_interface.KernelInterface.field_mapping

static

Initial value:

=  {
        "integer": "IntegerFieldDataSymbol",
        "real": "RealFieldDataSymbol",
        "logical": "LogicalFieldDataSymbol"}

Definition at line 79 of file kernel_interface.py.

◆ vector_field_mapping

dictionary psyclone.domain.lfric.kernel_interface.KernelInterface.vector_field_mapping

static

Initial value:

=  {
        "integer": "IntegerVectorFieldDataSymbol",
        "real": "RealVectorFieldDataSymbol",
        "logical": "LogicalVectorFieldDataSymbol"}

Definition at line 85 of file kernel_interface.py.

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

/home/docs/checkouts/readthedocs.org/user_builds/psyclone-ref/checkouts/latest/src/psyclone/domain/lfric/kernel_interface.py

Public Member Functions

Static Public Attributes

Detailed Description

Member Function Documentation

◆ banded_dofmap()

◆ basis()

◆ cell_map()

◆ cell_position()

◆ cma_operator()

◆ diff_basis()

◆ field()

◆ field_bcs_kernel()

◆ field_vector()

◆ fs_common()

◆ fs_compulsory_field()

◆ fs_intergrid()

◆ generate()

◆ indirection_dofmap()

◆ mesh_height()

◆ mesh_properties()

◆ operator()

◆ operator_bcs_kernel()

◆ quad_rule()

◆ ref_element_properties()

◆ scalar()

◆ stencil()

◆ stencil_unknown_direction()

◆ stencil_unknown_extent()

Member Data Documentation

◆ basis_mapping

◆ diff_basis_mapping

◆ field_mapping

◆ vector_field_mapping