psyclone.domain.lfric.kern_call_arg_list.KernCallArgList Class Reference

Inheritance diagram for psyclone.domain.lfric.kern_call_arg_list.KernCallArgList:

Collaboration diagram for psyclone.domain.lfric.kern_call_arg_list.KernCallArgList:

Public Member Functions
def	__init__ (self, kern)
def	get_user_type (self, module_name, user_type, name, tag=None)
def	append_structure_reference (self, module_name, user_type, member_list, name, tag=None, overwrite_datatype=None)
def	cell_position (self, var_accesses=None)
def	cell_map (self, var_accesses=None)
def	mesh_height (self, var_accesses=None)
def	scalar (self, scalar_arg, var_accesses=None)
def	cma_operator (self, arg, 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_2d_unknown_extent (self, arg, var_accesses=None)
def	stencil_2d_max_extent (self, arg, var_accesses=None)
def	stencil_unknown_direction (self, arg, var_accesses=None)
def	stencil (self, arg, var_accesses=None)
def	stencil_2d (self, arg, var_accesses=None)
def	operator (self, arg, var_accesses=None)
def	fs_common (self, function_space, var_accesses=None)
def	fs_compulsory_field (self, function_space, var_accesses=None)
def	fs_intergrid (self, function_space, 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	mesh_properties (self, var_accesses=None)
def	quad_rule (self, var_accesses=None)
def	nlayers_positions (self)
def	nqp_positions (self)
def	ndf_positions (self)
def	cell_ref_name (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	generate (self, var_accesses=None)
def	banded_dofmap (self, function_space, var_accesses=None)
def	indirection_dofmap (self, function_space, operator=None, var_accesses=None)
def	ref_element_properties (self, var_accesses=None)

Static Public Attributes
	NdfInfo = namedtuple("NdfInfo", ["position", "function_space"])

Detailed Description

Creates the argument list required to call kernel "kern" from the
PSy-layer and captures the positions of the following arguments in
the argument list: nlayers, number of quadrature points and number
of degrees of freedom. The ordering and type of arguments is
captured by the base class.

:param kern: The kernel that is being called.
:type kern: :py:class:`psyclone.domain.lfric.LFRicKern`

Definition at line 63 of file kern_call_arg_list.py.

Member Function Documentation

append_structure_reference()

def psyclone.domain.lfric.kern_call_arg_list.KernCallArgList.append_structure_reference	(		self,
			module_name,
			user_type,
			member_list,
			name,
			tag = None,
			overwrite_datatype = None
	)

Creates a reference to a variable of a user-defined type. If
required, the required import statements will all be generated.

:param str module_name: the name of the module from which the
    user-defined type must be imported.
:param str user_type: the name of the user-defined type.
:param member_list: the members used hierarchically.
:type member_list: List[str]
:param str name: the name of the variable to be used in the Reference.
:param Optional[str] tag: tag to use for the variable, defaults to
    the name
:param overwrite_datatype: the datatype for the reference, which will
    overwrite the value determined by analysing the corresponding
    user defined type. This is useful when e.g. the module that
    declares the structure cannot be accessed.
:type overwrite_datatype:
    Optional[:py:class:`psyclone.psyir.symbols.DataType`]

:return: the symbol that is used in the reference
:rtype: :py:class:`psyclone.psyir.symbols.Symbol`

Definition at line 135 of file kern_call_arg_list.py.

                                   name, tag=None, overwrite_datatype=None):
        # pylint: disable=too-many-arguments
        '''Creates a reference to a variable of a user-defined type. If
        required, the required import statements will all be generated.
 
        :param str module_name: the name of the module from which the
            user-defined type must be imported.
        :param str user_type: the name of the user-defined type.
        :param member_list: the members used hierarchically.
        :type member_list: List[str]
        :param str name: the name of the variable to be used in the Reference.
        :param Optional[str] tag: tag to use for the variable, defaults to
            the name
        :param overwrite_datatype: the datatype for the reference, which will
            overwrite the value determined by analysing the corresponding
            user defined type. This is useful when e.g. the module that
            declares the structure cannot be accessed.
        :type overwrite_datatype:
            Optional[:py:class:`psyclone.psyir.symbols.DataType`]
 
        :return: the symbol that is used in the reference
        :rtype: :py:class:`psyclone.psyir.symbols.Symbol`
 
        '''
        sym = self.get_user_type(module_name, user_type, name, tag)
        self.psyir_append(StructureReference.
                          create(sym, member_list,
                                 overwrite_datatype=overwrite_datatype))
        return sym
 

References psyclone.domain.lfric.kern_call_arg_list.KernCallArgList.get_user_type(), and psyclone.domain.lfric.arg_ordering.ArgOrdering.psyir_append().

Here is the call graph for this function:

Here is the caller graph for this function:

basis()

def psyclone.domain.lfric.kern_call_arg_list.KernCallArgList.basis	(		self,
			function_space,
			var_accesses = None
	)

Add basis function information for this function space to the
argument list and optionally to the variable access information.

:param function_space: the function space for which the basis \
                       function is required.
:type function_space: :py:class:`psyclone.domain.lfric.FunctionSpace`
:param var_accesses: optional VariablesAccessInfo instance to store \
    the 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 kern_call_arg_list.py.

    def basis(self, function_space, var_accesses=None):
        '''Add basis function information for this function space to the
        argument list and optionally to the variable access information.
 
        :param function_space: the function space for which the basis \
                               function is required.
        :type function_space: :py:class:`psyclone.domain.lfric.FunctionSpace`
        :param var_accesses: optional VariablesAccessInfo instance to store \
            the information about variable accesses.
        :type var_accesses: \
            :py:class:`psyclone.core.VariablesAccessInfo`
 
        '''
        for rule in self._kern.qr_rules.values():
            basis_name = function_space.get_basis_name(qr_var=rule.psy_name)
            sym = self.append_array_reference(basis_name, [":", ":", ":", ":"],
                                              ScalarType.Intrinsic.REAL)
            self.append(sym.name, var_accesses)
 
        if "gh_evaluator" in self._kern.eval_shapes:
            # We are dealing with an evaluator and therefore need as many
            # basis functions as there are target function spaces.
            for fs_name in self._kern.eval_targets:
                # The associated FunctionSpace object is the first item in
                # the tuple dict entry associated with the name of the target
                # function space
                fspace = self._kern.eval_targets[fs_name][0]
                basis_name = function_space.get_basis_name(on_space=fspace)
                sym = self.append_array_reference(basis_name, [":", ":", ":"],
                                                  ScalarType.Intrinsic.REAL)
                self.append(sym.name, var_accesses)
 

References psyclone.domain.common.psylayer.psyloop.PSyLoop._kern, psyclone.domain.lfric.arg_ordering.ArgOrdering._kern, psyclone.domain.lfric.lfric_loop.LFRicLoop._kern, psyclone.psyir.nodes.node.ChildrenList.append(), psyclone.gocean1p0.GOKernelArguments.append(), psyclone.psyGen.Arguments.append(), psyclone.domain.lfric.arg_ordering.ArgOrdering.append(), and psyclone.domain.lfric.arg_ordering.ArgOrdering.append_array_reference().

Here is the call graph for this function:

Here is the caller graph for this function:

cell_map()

def psyclone.domain.lfric.kern_call_arg_list.KernCallArgList.cell_map	(		self,
			var_accesses = None
	)

Add cell-map and related cell counts (for inter-grid kernels)
to the argument list. If supplied it also stores these accesses to the
var_access object.

:param var_accesses: optional VariablesAccessInfo instance to store \
    the information about variable accesses.
:type var_accesses: \
    :py:class:`psyclone.core.VariablesAccessInfo`

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

Reimplemented in psyclone.domain.lfric.kern_call_acc_arg_list.KernCallAccArgList.

Definition at line 180 of file kern_call_arg_list.py.

    def cell_map(self, var_accesses=None):
        '''Add cell-map and related cell counts (for inter-grid kernels)
        to the argument list. If supplied it also stores these accesses to the
        var_access object.
 
        :param var_accesses: optional VariablesAccessInfo instance to store \
            the information about variable accesses.
        :type var_accesses: \
            :py:class:`psyclone.core.VariablesAccessInfo`
 
        '''
        cargs = psyGen.args_filter(self._kern.args, arg_meshes=["gh_coarse"])
        carg = cargs[0]
        fargs = psyGen.args_filter(self._kern.args, arg_meshes=["gh_fine"])
        farg = fargs[0]
        base_name = "cell_map_" + carg.name
 
        # Add the cell map to our argument list
        cell_ref_name, cell_ref = self.cell_ref_name(var_accesses)
        sym = self.append_array_reference(base_name, [":", ":", cell_ref],
                                          ScalarType.Intrinsic.INTEGER)
        self.append(f"{sym.name}(:,:,{cell_ref_name})",
                    var_accesses=var_accesses, var_access_name=sym.name)
 
        # No. of fine cells per coarse cell in x
        base_name = f"ncpc_{farg.name}_{carg.name}_x"
        sym = self.append_integer_reference(base_name)
        self.append(sym.name, var_accesses)
        # No. of fine cells per coarse cell in y
        base_name = f"ncpc_{farg.name}_{carg.name}_y"
        sym = self.append_integer_reference(base_name)
        self.append(sym.name, var_accesses)
        # No. of columns in the fine mesh
        base_name = f"ncell_{farg.name}"
        sym = self.append_integer_reference(base_name)
        self.append(sym.name, var_accesses)
 

References psyclone.domain.common.psylayer.psyloop.PSyLoop._kern, psyclone.domain.lfric.arg_ordering.ArgOrdering._kern, psyclone.domain.lfric.lfric_loop.LFRicLoop._kern, psyclone.psyir.nodes.node.ChildrenList.append(), psyclone.gocean1p0.GOKernelArguments.append(), psyclone.psyGen.Arguments.append(), psyclone.domain.lfric.arg_ordering.ArgOrdering.append(), psyclone.domain.lfric.arg_ordering.ArgOrdering.append_array_reference(), psyclone.domain.lfric.arg_ordering.ArgOrdering.append_integer_reference(), and psyclone.domain.lfric.kern_call_arg_list.KernCallArgList.cell_ref_name().

Here is the call graph for this function:

Here is the caller graph for this function:

cell_position()

def psyclone.domain.lfric.kern_call_arg_list.KernCallArgList.cell_position	(		self,
			var_accesses = None
	)

Adds a cell argument to the argument list and if supplied stores
this access in var_accesses.

:param var_accesses: optional VariablesAccessInfo instance to store \
    the information about variable accesses.
:type var_accesses: \
    :py:class:`psyclone.core.VariablesAccessInfo`

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

Reimplemented in psyclone.domain.lfric.kern_call_acc_arg_list.KernCallAccArgList.

Definition at line 166 of file kern_call_arg_list.py.

    def cell_position(self, var_accesses=None):
        '''Adds a cell argument to the argument list and if supplied stores
        this access in var_accesses.
 
        :param var_accesses: optional VariablesAccessInfo instance to store \
            the information about variable accesses.
        :type var_accesses: \
            :py:class:`psyclone.core.VariablesAccessInfo`
 
        '''
        cell_ref_name, ref = self.cell_ref_name(var_accesses)
        self.psyir_append(ref)
        self.append(cell_ref_name)
 

References psyclone.psyir.nodes.node.ChildrenList.append(), psyclone.gocean1p0.GOKernelArguments.append(), psyclone.psyGen.Arguments.append(), psyclone.domain.lfric.arg_ordering.ArgOrdering.append(), psyclone.domain.lfric.kern_call_arg_list.KernCallArgList.cell_ref_name(), and psyclone.domain.lfric.arg_ordering.ArgOrdering.psyir_append().

Here is the call graph for this function:

Here is the caller graph for this function:

cell_ref_name()

def psyclone.domain.lfric.kern_call_arg_list.KernCallArgList.cell_ref_name	(		self,
			var_accesses = None
	)

Utility routine which determines whether to return the cell value
or the colourmap lookup value. If supplied it also stores this access
in var_accesses.

:param var_accesses: optional VariablesAccessInfo instance to store \
    the information about variable accesses.
:type var_accesses: \
    :py:class:`psyclone.core.VariablesAccessInfo`

:returns: the Fortran code needed to access the current cell index.
:rtype: Tuple[str, py:class:`psyclone.psyir.nodes.Reference`]

Definition at line 923 of file kern_call_arg_list.py.

    def cell_ref_name(self, var_accesses=None):
        '''Utility routine which determines whether to return the cell value
        or the colourmap lookup value. If supplied it also stores this access
        in var_accesses.
 
        :param var_accesses: optional VariablesAccessInfo instance to store \
            the information about variable accesses.
        :type var_accesses: \
            :py:class:`psyclone.core.VariablesAccessInfo`
 
        :returns: the Fortran code needed to access the current cell index.
        :rtype: Tuple[str, py:class:`psyclone.psyir.nodes.Reference`]
 
        '''
        cell_sym = self._symtab.find_or_create_integer_symbol(
            "cell", tag="cell_loop_idx")
        if self._kern.is_coloured():
            colour_sym = self._symtab.find_or_create_integer_symbol(
                "colour", tag="colours_loop_idx")
            if self._kern.is_intergrid:
                tag = None
            else:
                # If there is only one colourmap we need to specify the tag
                # to make sure we get the right symbol.
                tag = "cmap"
            array_ref = self.get_array_reference(self._kern.colourmap,
                                                 [Reference(colour_sym),
                                                  Reference(cell_sym)],
                                                 ScalarType.Intrinsic.INTEGER,
                                                 tag=tag)
            if var_accesses is not None:
                var_accesses.add_access(Signature(colour_sym.name),
                                        AccessType.READ, self._kern)
                var_accesses.add_access(Signature(cell_sym.name),
                                        AccessType.READ, self._kern)
                var_accesses.add_access(Signature(array_ref.name),
                                        AccessType.READ,
                                        self._kern, ["colour", "cell"])
 
            return (self._kern.colourmap + "(colour,cell)",
                    array_ref)
 
        if var_accesses is not None:
            var_accesses.add_access(Signature("cell"), AccessType.READ,
                                    self._kern)
 
        return (cell_sym.name, Reference(cell_sym))
 
 
# ============================================================================
# For automatic documentation creation:

References psyclone.domain.common.psylayer.psyloop.PSyLoop._kern, psyclone.domain.lfric.arg_ordering.ArgOrdering._kern, psyclone.domain.lfric.lfric_loop.LFRicLoop._kern, psyclone.domain.lfric.arg_ordering.ArgOrdering._symtab(), and psyclone.domain.lfric.arg_ordering.ArgOrdering.get_array_reference().

Here is the call graph for this function:

Here is the caller graph for this function:

cma_operator()

def psyclone.domain.lfric.kern_call_arg_list.KernCallArgList.cma_operator	(		self,
			arg,
			var_accesses = None
	)

Add the CMA operator and associated scalars to the argument
list and optionally add them to the variable access
information.

:param arg: the CMA operator argument.
:type arg: :py:class:`psyclone.dynamo0p3.DynKernelArgument`
:param var_accesses: optional VariablesAccessInfo instance to store \
    the information about variable accesses.
:type var_accesses: \
    :py:class:`psyclone.core.VariablesAccessInfo`

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

Definition at line 289 of file kern_call_arg_list.py.

    def cma_operator(self, arg, var_accesses=None):
        '''Add the CMA operator and associated scalars to the argument
        list and optionally add them to the variable access
        information.
 
        :param arg: the CMA operator argument.
        :type arg: :py:class:`psyclone.dynamo0p3.DynKernelArgument`
        :param var_accesses: optional VariablesAccessInfo instance to store \
            the information about variable accesses.
        :type var_accesses: \
            :py:class:`psyclone.core.VariablesAccessInfo`
 
        '''
        components = ["matrix"]
        # Avoid circular import:
        # pylint: disable=import-outside-toplevel
        from psyclone.dynamo0p3 import DynCMAOperators
        if arg.function_space_to.orig_name != (arg.function_space_from.
                                               orig_name):
            components += DynCMAOperators.cma_diff_fs_params
        else:
            components += DynCMAOperators.cma_same_fs_params
 
        const = LFRicConstants()
        suffix = const.ARG_TYPE_SUFFIX_MAPPING["gh_columnwise_operator"]
 
        for component in components:
            # Matrix takes the access from the declaration of the argument
            # (i.e. read, write, ...), the rest are always read-only parameters
            if component == "matrix":
                # Matrix is a pointer to a 3d array
                # REAL(KIND=r_solver), pointer:: cma_op1_matrix(:,:,:)
                #    = > null()
                mode = arg.access
                sym = self._symtab.lookup_with_tag(f"{arg.name}:{suffix}")
                self.psyir_append(ArrayReference.create(sym, [":", ":", ":"]))
            else:
                # All other variables are scalar integers
                name = self._symtab.lookup_with_tag(
                    f"{arg.name}:{component}:{suffix}").name
                mode = AccessType.READ
                sym = self.append_integer_reference(
                    name, tag=f"{arg.name}:{component}:{suffix}")
 
            self.append(sym.name, var_accesses, mode=mode,
                        metadata_posn=arg.metadata_index)
 

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

Here is the call graph for this function:

Here is the caller graph for this function:

diff_basis()

def psyclone.domain.lfric.kern_call_arg_list.KernCallArgList.diff_basis	(		self,
			function_space,
			var_accesses = None
	)

Add differential basis information for the function space to the
argument list. If supplied it also stores this access in
var_accesses.

:param function_space: the function space for which the differential \
    basis functions are required.
:type function_space: :py:class:`psyclone.domain.lfric.FunctionSpace`
:param var_accesses: optional VariablesAccessInfo instance to store \
    the information about variable accesses.
:type var_accesses: \
    :py:class:`psyclone.core.VariablesAccessInfo`

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

Definition at line 694 of file kern_call_arg_list.py.

    def diff_basis(self, function_space, var_accesses=None):
        '''Add differential basis information for the function space to the
        argument list. If supplied it also stores this access in
        var_accesses.
 
        :param function_space: the function space for which the differential \
            basis functions are required.
        :type function_space: :py:class:`psyclone.domain.lfric.FunctionSpace`
        :param var_accesses: optional VariablesAccessInfo instance to store \
            the information about variable accesses.
        :type var_accesses: \
            :py:class:`psyclone.core.VariablesAccessInfo`
 
        '''
        for rule in self._kern.qr_rules.values():
            diff_basis_name = function_space.get_diff_basis_name(
                qr_var=rule.psy_name)
            sym = self.append_array_reference(diff_basis_name,
                                              [":", ":", ":", ":"],
                                              ScalarType.Intrinsic.REAL)
            self.append(sym.name, var_accesses)
 
        if "gh_evaluator" in self._kern.eval_shapes:
            # We are dealing with an evaluator and therefore need as many
            # basis functions as there are target function spaces.
            for fs_name in self._kern.eval_targets:
                # The associated FunctionSpace object is the first item in
                # the tuple dict entry associated with the name of the target
                # function space
                fspace = self._kern.eval_targets[fs_name][0]
                diff_basis_name = function_space.get_diff_basis_name(
                    on_space=fspace)
                sym = self.append_array_reference(diff_basis_name,
                                                  [":", ":", ":"],
                                                  ScalarType.Intrinsic.REAL)
                self.append(sym.name, var_accesses)
 

References psyclone.domain.common.psylayer.psyloop.PSyLoop._kern, psyclone.domain.lfric.arg_ordering.ArgOrdering._kern, psyclone.domain.lfric.lfric_loop.LFRicLoop._kern, psyclone.psyir.nodes.node.ChildrenList.append(), psyclone.gocean1p0.GOKernelArguments.append(), psyclone.psyGen.Arguments.append(), psyclone.domain.lfric.arg_ordering.ArgOrdering.append(), and psyclone.domain.lfric.arg_ordering.ArgOrdering.append_array_reference().

Here is the call graph for this function:

Here is the caller graph for this function:

field()

def psyclone.domain.lfric.kern_call_arg_list.KernCallArgList.field	(		self,
			arg,
			var_accesses = None
	)

Add the field array associated with the argument 'arg' to the
argument list. If supplied it also stores this access in var_accesses.

:param arg: the field to be added.
:type arg: :py:class:`psyclone.dynamo0p3.DynKernelArgument`
:param var_accesses: optional VariablesAccessInfo instance to store
    the information about variable accesses.
:type var_accesses: :py:class:`psyclone.core.VariablesAccessInfo`

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

Definition at line 366 of file kern_call_arg_list.py.

    def field(self, arg, var_accesses=None):
        '''Add the field array associated with the argument 'arg' to the
        argument list. If supplied it also stores this access in var_accesses.
 
        :param arg: the field to be added.
        :type arg: :py:class:`psyclone.dynamo0p3.DynKernelArgument`
        :param var_accesses: optional VariablesAccessInfo instance to store
            the information about variable accesses.
        :type var_accesses: :py:class:`psyclone.core.VariablesAccessInfo`
 
        '''
        const = LFRicConstants()
        suffix = const.ARG_TYPE_SUFFIX_MAPPING[arg.argument_type]
        # Look-up the name of the variable that stores the reference to
        # the data in this field.
        sym = self._symtab.lookup_with_tag(f"{arg.name}:{suffix}")
        # Add the field data array as being read.
        self.append(sym.name, var_accesses, var_access_name=sym.name,
                    mode=arg.access, metadata_posn=arg.metadata_index)
 
        self.psyir_append(Reference(sym))
 

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

Here is the call graph for this function:

Here is the caller graph for this function:

field_bcs_kernel()

def psyclone.domain.lfric.kern_call_arg_list.KernCallArgList.field_bcs_kernel	(		self,
			function_space,
			var_accesses = None
	)

Implement the boundary_dofs array fix for a field. If supplied it
also stores this access in var_accesses.

:param function_space: the function space for which boundary dofs \
    are required.
:type function_space: :py:class:`psyclone.domain.lfric.FunctionSpace`
:param var_accesses: optional VariablesAccessInfo instance to store \
    the information about variable accesses.
:type var_accesses: \
    :py:class:`psyclone.core.VariablesAccessInfo`

:raises GenerationError: if the bcs kernel does not contain \
    a field as argument (but e.g. an operator).

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

Definition at line 731 of file kern_call_arg_list.py.

    def field_bcs_kernel(self, function_space, var_accesses=None):
        '''Implement the boundary_dofs array fix for a field. If supplied it
        also stores this access in var_accesses.
 
        :param function_space: the function space for which boundary dofs \
            are required.
        :type function_space: :py:class:`psyclone.domain.lfric.FunctionSpace`
        :param var_accesses: optional VariablesAccessInfo instance to store \
            the information about variable accesses.
        :type var_accesses: \
            :py:class:`psyclone.core.VariablesAccessInfo`
 
        :raises GenerationError: if the bcs kernel does not contain \
            a field as argument (but e.g. an operator).
 
        '''
        fspace = None
        for fspace in self._kern.arguments.unique_fss:
            if fspace.orig_name == "any_space_1":
                break
        farg = self._kern.arguments.get_arg_on_space(fspace)
        # Sanity check - expect the enforce_bc_code kernel to only have
        # a field argument.
        if not farg.is_field:
            const = LFRicConstants()
            raise GenerationError(
                f"Expected an argument of {const.VALID_FIELD_NAMES} type "
                f"from which to look-up boundary dofs for kernel "
                f"{self._kern.name} but got '{farg.argument_type}'")
 
        base_name = "boundary_dofs_" + farg.name
        sym = self.append_array_reference(base_name, [":", ":"],
                                          ScalarType.Intrinsic.INTEGER)
        self.append(sym.name, var_accesses)
 

References psyclone.domain.common.psylayer.psyloop.PSyLoop._kern, psyclone.domain.lfric.arg_ordering.ArgOrdering._kern, psyclone.domain.lfric.lfric_loop.LFRicLoop._kern, psyclone.psyir.nodes.node.ChildrenList.append(), psyclone.gocean1p0.GOKernelArguments.append(), psyclone.psyGen.Arguments.append(), psyclone.domain.lfric.arg_ordering.ArgOrdering.append(), and psyclone.domain.lfric.arg_ordering.ArgOrdering.append_array_reference().

Here is the call graph for this function:

Here is the caller graph for this function:

field_vector()

def psyclone.domain.lfric.kern_call_arg_list.KernCallArgList.field_vector	(		self,
			argvect,
			var_accesses = None
	)

Add the field vector associated with the argument 'argvect' to the
argument list. If supplied it also stores these accesses to the
var_access object.

:param argvect: the field vector to add.
:type argvect: :py:class:`psyclone.dynamo0p3.DynKernelArgument`
:param var_accesses: optional VariablesAccessInfo instance to store \
    the information about variable accesses.
:type var_accesses: \
    :py:class:`psyclone.core.VariablesAccessInfo`

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

Definition at line 336 of file kern_call_arg_list.py.

    def field_vector(self, argvect, var_accesses=None):
        '''Add the field vector associated with the argument 'argvect' to the
        argument list. If supplied it also stores these accesses to the
        var_access object.
 
        :param argvect: the field vector to add.
        :type argvect: :py:class:`psyclone.dynamo0p3.DynKernelArgument`
        :param var_accesses: optional VariablesAccessInfo instance to store \
            the information about variable accesses.
        :type var_accesses: \
            :py:class:`psyclone.core.VariablesAccessInfo`
 
        '''
        suffix = LFRicConstants().ARG_TYPE_SUFFIX_MAPPING[
            argvect.argument_type]
        # The range function below returns values from
        # 1 to the vector size which is what we
        # require in our Fortran code
        for idx in range(1, argvect.vector_size + 1):
            cmpt_sym = self._symtab.lookup_with_tag(
                f"{argvect.name}_{idx}:{suffix}")
            self.psyir_append(Reference(cmpt_sym))
            text = cmpt_sym.name
            self.append(text, metadata_posn=argvect.metadata_index)
 
        if var_accesses is not None:
            # We add the whole field-vector, not the individual accesses.
            var_accesses.add_access(Signature(argvect.name), argvect.access,
                                    self._kern)
 

References psyclone.domain.common.psylayer.psyloop.PSyLoop._kern, psyclone.domain.lfric.arg_ordering.ArgOrdering._kern, psyclone.domain.lfric.lfric_loop.LFRicLoop._kern, psyclone.domain.lfric.arg_ordering.ArgOrdering._symtab(), psyclone.psyir.nodes.node.ChildrenList.append(), psyclone.gocean1p0.GOKernelArguments.append(), psyclone.psyGen.Arguments.append(), psyclone.domain.lfric.arg_ordering.ArgOrdering.append(), and psyclone.domain.lfric.arg_ordering.ArgOrdering.psyir_append().

Here is the call graph for this function:

Here is the caller graph for this function:

fs_common()

def psyclone.domain.lfric.kern_call_arg_list.KernCallArgList.fs_common	(		self,
			function_space,
			var_accesses = None
	)

Add function-space related arguments common to LMA operators and
fields. If supplied it also stores this access in var_accesses.

:param function_space: the function space for which the related \
    arguments common to LMA operators and fields are added.
:type function_space: :py:class:`psyclone.domain.lfric.FunctionSpace`
:param var_accesses: optional VariablesAccessInfo instance to store \
    the information about variable accesses.
:type var_accesses: \
    :py:class:`psyclone.core.VariablesAccessInfo`

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

Definition at line 580 of file kern_call_arg_list.py.

    def fs_common(self, function_space, var_accesses=None):
        '''Add function-space related arguments common to LMA operators and
        fields. If supplied it also stores this access in var_accesses.
 
        :param function_space: the function space for which the related \
            arguments common to LMA operators and fields are added.
        :type function_space: :py:class:`psyclone.domain.lfric.FunctionSpace`
        :param var_accesses: optional VariablesAccessInfo instance to store \
            the information about variable accesses.
        :type var_accesses: \
            :py:class:`psyclone.core.VariablesAccessInfo`
 
        '''
        if self._kern.iterates_over not in ["cell_column", "domain"]:
            return
        super().fs_common(function_space, var_accesses)
        self._ndf_positions.append(
            KernCallArgList.NdfInfo(position=self.num_args,
                                    function_space=function_space.orig_name))
 

References psyclone.domain.common.psylayer.psyloop.PSyLoop._kern, psyclone.domain.lfric.arg_ordering.ArgOrdering._kern, psyclone.domain.lfric.lfric_loop.LFRicLoop._kern, psyclone.domain.lfric.kern_call_arg_list.KernCallArgList._ndf_positions, psyclone.domain.lfric.arg_ordering.ArgOrdering.append(), and psyclone.domain.lfric.arg_ordering.ArgOrdering.num_args().

Here is the call graph for this function:

Here is the caller graph for this function:

fs_compulsory_field()

def psyclone.domain.lfric.kern_call_arg_list.KernCallArgList.fs_compulsory_field	(		self,
			function_space,
			var_accesses = None
	)

Add compulsory arguments associated with this function space to
the list. If supplied it also stores this access in var_accesses.

:param function_space: the function space for which the compulsory \
    arguments are added.
:type function_space: :py:class:`psyclone.domain.lfric.FunctionSpace`
:param var_accesses: optional VariablesAccessInfo instance to store \
    the information about variable accesses.
:type var_accesses: \
    :py:class:`psyclone.core.VariablesAccessInfo`

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

Reimplemented in psyclone.domain.lfric.kern_call_acc_arg_list.KernCallAccArgList.

Definition at line 600 of file kern_call_arg_list.py.

    def fs_compulsory_field(self, function_space, var_accesses=None):
        '''Add compulsory arguments associated with this function space to
        the list. If supplied it also stores this access in var_accesses.
 
        :param function_space: the function space for which the compulsory \
            arguments are added.
        :type function_space: :py:class:`psyclone.domain.lfric.FunctionSpace`
        :param var_accesses: optional VariablesAccessInfo instance to store \
            the information about variable accesses.
        :type var_accesses: \
            :py:class:`psyclone.core.VariablesAccessInfo`
 
        '''
        sym = self.append_integer_reference(function_space.undf_name)
        self.append(sym.name, var_accesses)
 
        map_name = function_space.map_name
        if self._kern.iterates_over == 'domain':
            # This kernel takes responsibility for iterating over cells so
            # pass the whole dofmap.
            sym = self.append_array_reference(map_name, [":", ":"],
                                              ScalarType.Intrinsic.INTEGER)
            self.append(sym.name, var_accesses, var_access_name=sym.name)
        else:
            # Pass the dofmap for the cell column
            cell_name, cell_ref = self.cell_ref_name(var_accesses)
            sym = self.append_array_reference(map_name, [":", cell_ref],
                                              ScalarType.Intrinsic.INTEGER)
            self.append(f"{sym.name}(:,{cell_name})",
                        var_accesses, var_access_name=sym.name)
 

References psyclone.domain.common.psylayer.psyloop.PSyLoop._kern, psyclone.domain.lfric.arg_ordering.ArgOrdering._kern, psyclone.domain.lfric.lfric_loop.LFRicLoop._kern, psyclone.psyir.nodes.node.ChildrenList.append(), psyclone.gocean1p0.GOKernelArguments.append(), psyclone.psyGen.Arguments.append(), psyclone.domain.lfric.arg_ordering.ArgOrdering.append(), psyclone.domain.lfric.arg_ordering.ArgOrdering.append_array_reference(), psyclone.domain.lfric.arg_ordering.ArgOrdering.append_integer_reference(), and psyclone.domain.lfric.kern_call_arg_list.KernCallArgList.cell_ref_name().

Here is the call graph for this function:

Here is the caller graph for this function:

fs_intergrid()

def psyclone.domain.lfric.kern_call_arg_list.KernCallArgList.fs_intergrid	(		self,
			function_space,
			var_accesses = None
	)

Add function-space related arguments for an intergrid kernel.
If supplied it also stores this access in var_accesses.

:param function_space: the function space for which to add arguments
:type function_space: :py:class:`psyclone.domain.lfric.FunctionSpace`
:param var_accesses: optional VariablesAccessInfo instance to store \
    the information about variable accesses.
:type var_accesses: \
    :py:class:`psyclone.core.VariablesAccessInfo`

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

Reimplemented in psyclone.domain.lfric.kern_call_acc_arg_list.KernCallAccArgList.

Definition at line 631 of file kern_call_arg_list.py.

    def fs_intergrid(self, function_space, var_accesses=None):
        '''Add function-space related arguments for an intergrid kernel.
        If supplied it also stores this access in var_accesses.
 
        :param function_space: the function space for which to add arguments
        :type function_space: :py:class:`psyclone.domain.lfric.FunctionSpace`
        :param var_accesses: optional VariablesAccessInfo instance to store \
            the information about variable accesses.
        :type var_accesses: \
            :py:class:`psyclone.core.VariablesAccessInfo`
 
        '''
        # Is this FS associated with the coarse or fine mesh? (All fields
        # on a given mesh must be on the same FS.)
        arg = self._kern.arguments.get_arg_on_space(function_space)
        if arg.mesh == "gh_fine":
            # For the fine mesh, we need ndf, undf and the *whole*
            # dofmap
            self.fs_common(function_space, var_accesses=var_accesses)
            sym = self.append_integer_reference(function_space.undf_name)
            self.append(sym.name, var_accesses)
            map_name = function_space.map_name
            sym = self.append_array_reference(map_name, [":", ":"],
                                              ScalarType.Intrinsic.INTEGER)
            self.append(sym.name, var_accesses)
        else:
            # For the coarse mesh we only need undf and the dofmap for
            # the current column
            self.fs_compulsory_field(function_space,
                                     var_accesses=var_accesses)
 

References psyclone.domain.common.psylayer.psyloop.PSyLoop._kern, psyclone.domain.lfric.arg_ordering.ArgOrdering._kern, psyclone.domain.lfric.lfric_loop.LFRicLoop._kern, psyclone.psyir.nodes.node.ChildrenList.append(), psyclone.gocean1p0.GOKernelArguments.append(), psyclone.psyGen.Arguments.append(), psyclone.domain.lfric.arg_ordering.ArgOrdering.append(), psyclone.domain.lfric.arg_ordering.ArgOrdering.append_array_reference(), psyclone.domain.lfric.arg_ordering.ArgOrdering.append_integer_reference(), psyclone.domain.lfric.arg_ordering.ArgOrdering.fs_common(), psyclone.domain.lfric.kern_call_arg_list.KernCallArgList.fs_common(), psyclone.domain.lfric.kern_call_invoke_arg_list.KernCallInvokeArgList.fs_common(), psyclone.domain.lfric.kernel_interface.KernelInterface.fs_common(), psyclone.domain.lfric.arg_ordering.ArgOrdering.fs_compulsory_field(), psyclone.domain.lfric.kern_call_acc_arg_list.KernCallAccArgList.fs_compulsory_field(), psyclone.domain.lfric.kern_call_arg_list.KernCallArgList.fs_compulsory_field(), psyclone.domain.lfric.kern_stub_arg_list.KernStubArgList.fs_compulsory_field(), and psyclone.domain.lfric.kernel_interface.KernelInterface.fs_compulsory_field().

Here is the call graph for this function:

Here is the caller graph for this function:

get_user_type()

def psyclone.domain.lfric.kern_call_arg_list.KernCallArgList.get_user_type	(		self,
			module_name,
			user_type,
			name,
			tag = None
	)

Returns the symbol for a user-defined type. If required, the
required import statements will all be generated.

:param str module_name: the name of the module from which the \
    user-defined type must be imported.
:param str user_type: the name of the user-defined type.
:param str name: the name of the variable to be used in the Reference.
:param Optional[str] tag: tag to use for the variable, defaults to \
    the name

:return: the symbol that is used in the reference
:rtype: :py:class:`psyclone.psyir.symbols.Symbol`

Definition at line 84 of file kern_call_arg_list.py.

    def get_user_type(self, module_name, user_type, name, tag=None):
        # pylint: disable=too-many-arguments
        '''Returns the symbol for a user-defined type. If required, the
        required import statements will all be generated.
 
        :param str module_name: the name of the module from which the \
            user-defined type must be imported.
        :param str user_type: the name of the user-defined type.
        :param str name: the name of the variable to be used in the Reference.
        :param Optional[str] tag: tag to use for the variable, defaults to \
            the name
 
        :return: the symbol that is used in the reference
        :rtype: :py:class:`psyclone.psyir.symbols.Symbol`
 
        '''
        if not tag:
            tag = name
 
        try:
            sym = self._symtab.lookup_with_tag(tag)
            return sym
        except KeyError:
            pass
 
        # The symbol does not exist already. So we potentially need to
        # create the import statement for the type:
        try:
            # Check if the module is already declared:
            module = self._symtab.lookup(module_name)
        except KeyError:
            module = self._symtab.new_symbol(module_name,
                                             symbol_type=ContainerSymbol)
 
        # Get the symbol table in which the module is declared:
        mod_sym_tab = module.find_symbol_table(self._kern)
 
        # The user-defined type must be declared in the same symbol
        # table as the container (otherwise errors will happen later):
        user_type_symbol = mod_sym_tab.find_or_create(
            user_type,
            symbol_type=DataTypeSymbol,
            datatype=UnresolvedType(),
            interface=ImportInterface(module))
        # Declare the actual user symbol in the local symbol table, using
        # the datatype from the root table:
        sym = self._symtab.new_symbol(name, tag=tag,
                                      symbol_type=DataSymbol,
                                      datatype=user_type_symbol)
        return sym
 

References psyclone.domain.common.psylayer.psyloop.PSyLoop._kern, psyclone.domain.lfric.arg_ordering.ArgOrdering._kern, psyclone.domain.lfric.lfric_loop.LFRicLoop._kern, and psyclone.domain.lfric.arg_ordering.ArgOrdering._symtab().

Here is the call graph for this function:

Here is the caller graph for this function:

mesh_height()

def psyclone.domain.lfric.kern_call_arg_list.KernCallArgList.mesh_height	(		self,
			var_accesses = None
	)

Add mesh height (nlayers) to the argument list and if supplied
stores this access in var_accesses.

:param var_accesses: optional VariablesAccessInfo instance to store \
    the information about variable accesses.
:type var_accesses: \
    :py:class:`psyclone.core.VariablesAccessInfo`

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

Definition at line 217 of file kern_call_arg_list.py.

    def mesh_height(self, var_accesses=None):
        '''Add mesh height (nlayers) to the argument list and if supplied
        stores this access in var_accesses.
 
        :param var_accesses: optional VariablesAccessInfo instance to store \
            the information about variable accesses.
        :type var_accesses: \
            :py:class:`psyclone.core.VariablesAccessInfo`
 
        '''
        if self._kern.iterates_over not in ["cell_column", "domain"]:
            return
        nlayers_symbol = self.append_integer_reference("nlayers")
        self.append(nlayers_symbol.name, var_accesses)
        self._nlayers_positions.append(self.num_args)
 

References psyclone.domain.common.psylayer.psyloop.PSyLoop._kern, psyclone.domain.lfric.arg_ordering.ArgOrdering._kern, psyclone.domain.lfric.lfric_loop.LFRicLoop._kern, psyclone.domain.lfric.kern_call_arg_list.KernCallArgList._nlayers_positions, psyclone.psyir.nodes.node.ChildrenList.append(), psyclone.gocean1p0.GOKernelArguments.append(), psyclone.psyGen.Arguments.append(), psyclone.domain.lfric.arg_ordering.ArgOrdering.append(), psyclone.domain.lfric.arg_ordering.ArgOrdering.append_integer_reference(), and psyclone.domain.lfric.arg_ordering.ArgOrdering.num_args().

Here is the call graph for this function:

Here is the caller graph for this function:

mesh_properties()

def psyclone.domain.lfric.kern_call_arg_list.KernCallArgList.mesh_properties	(		self,
			var_accesses = None
	)

Provide the kernel arguments required for the mesh properties
specified in the kernel metadata. If supplied it also stores this
access in var_accesses.

:param var_accesses: optional VariablesAccessInfo instance to store \
    the information about variable accesses.
:type var_accesses: \
    :py:class:`psyclone.core.VariablesAccessInfo`

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

Definition at line 787 of file kern_call_arg_list.py.

    def mesh_properties(self, var_accesses=None):
        '''Provide the kernel arguments required for the mesh properties
        specified in the kernel metadata. If supplied it also stores this
        access in var_accesses.
 
        :param var_accesses: optional VariablesAccessInfo instance to store \
            the information about variable accesses.
        :type var_accesses: \
            :py:class:`psyclone.core.VariablesAccessInfo`
 
        '''
        if self._kern.mesh.properties:
            # Avoid circular import:
            # pylint: disable=import-outside-toplevel
            from psyclone.dynamo0p3 import LFRicMeshProperties
            self.extend(LFRicMeshProperties(self._kern).
                        kern_args(stub=False, var_accesses=var_accesses,
                                  kern_call_arg_list=self))
 

References psyclone.domain.common.psylayer.psyloop.PSyLoop._kern, psyclone.domain.lfric.arg_ordering.ArgOrdering._kern, psyclone.domain.lfric.lfric_loop.LFRicLoop._kern, psyclone.psyir.nodes.node.ChildrenList.extend(), and psyclone.domain.lfric.arg_ordering.ArgOrdering.extend().

Here is the call graph for this function:

Here is the caller graph for this function:

ndf_positions()

def psyclone.domain.lfric.kern_call_arg_list.KernCallArgList.ndf_positions

(

self

)

:return: the position(s) in the argument list and the function \
    space(s) associated with the variable(s) that pass(es) the \
    number of degrees of freedom for the function space. The \
    generate method must be called first.
:rtype: list of namedtuple (position=int, function_space=str).

:raises InternalError: if the generate() method has not been \
    called.

Definition at line 906 of file kern_call_arg_list.py.

    def ndf_positions(self):
        ''':return: the position(s) in the argument list and the function \
            space(s) associated with the variable(s) that pass(es) the \
            number of degrees of freedom for the function space. The \
            generate method must be called first.
        :rtype: list of namedtuple (position=int, function_space=str).
 
        :raises InternalError: if the generate() method has not been \
            called.
 
        '''
        if not self._generate_called:
            raise InternalError(
                "KernCallArgList: the generate() method should be called "
                "before the ndf_positions() method")
        return self._ndf_positions
 

References psyclone.domain.lfric.arg_ordering.ArgOrdering._generate_called, and psyclone.domain.lfric.kern_call_arg_list.KernCallArgList._ndf_positions.

nlayers_positions()

def psyclone.domain.lfric.kern_call_arg_list.KernCallArgList.nlayers_positions

(

self

)

:returns: the position(s) in the argument list of the \
    variable(s) that passes the number of layers. The generate \
    method must be called first.
:rtype: list of int.

:raises InternalError: if the generate() method has not been called.

Definition at line 868 of file kern_call_arg_list.py.

    def nlayers_positions(self):
        ''':returns: the position(s) in the argument list of the \
            variable(s) that passes the number of layers. The generate \
            method must be called first.
        :rtype: list of int.
 
        :raises InternalError: if the generate() method has not been called.
 
        '''
        if not self._generate_called:
            raise InternalError(
                "KernCallArgList: the generate() method should be called "
                "before the nlayers_positions() method")
        return self._nlayers_positions
 

References psyclone.domain.lfric.arg_ordering.ArgOrdering._generate_called, and psyclone.domain.lfric.kern_call_arg_list.KernCallArgList._nlayers_positions.

nqp_positions()

def psyclone.domain.lfric.kern_call_arg_list.KernCallArgList.nqp_positions

(

self

)

:return: the positions in the argument list of the variables that \
    pass the number of quadrature points. The number and type of \
    these will change depending on the type of quadrature. A list \
    of dictionaries is returned with the quadrature types \
    being the keys to the dictionaries and their position in the \
    argument list being the values. At the moment only XYoZ is \
    supported (which has horizontal and vertical quadrature \
    points). The generate method must be called first.
:rtype: [{str: int, ...}]

:raises InternalError: if the generate() method has not been \
called.

Definition at line 884 of file kern_call_arg_list.py.

    def nqp_positions(self):
        ''':return: the positions in the argument list of the variables that \
            pass the number of quadrature points. The number and type of \
            these will change depending on the type of quadrature. A list \
            of dictionaries is returned with the quadrature types \
            being the keys to the dictionaries and their position in the \
            argument list being the values. At the moment only XYoZ is \
            supported (which has horizontal and vertical quadrature \
            points). The generate method must be called first.
        :rtype: [{str: int, ...}]
 
        :raises InternalError: if the generate() method has not been \
        called.
 
        '''
        if not self._generate_called:
            raise InternalError(
                "KernCallArgList: the generate() method should be called "
                "before the nqp_positions() method")
        return self._nqp_positions
 

References psyclone.domain.lfric.arg_ordering.ArgOrdering._generate_called, and psyclone.domain.lfric.kern_call_arg_list.KernCallArgList._nqp_positions.

operator()

def psyclone.domain.lfric.kern_call_arg_list.KernCallArgList.operator	(		self,
			arg,
			var_accesses = None
	)

Add the operator arguments to the argument list. If supplied it
also stores this access in var_accesses.

:param arg: the meta-data description of the operator.
:type arg: :py:class:`psyclone.dynamo0p3.DynKernelArgument`
:param var_accesses: optional VariablesAccessInfo instance to store \
    the information about variable accesses.
:type var_accesses: \
    :py:class:`psyclone.core.VariablesAccessInfo`

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

Reimplemented in psyclone.domain.lfric.kern_call_acc_arg_list.KernCallAccArgList.

Definition at line 543 of file kern_call_arg_list.py.

    def operator(self, arg, var_accesses=None):
        '''Add the operator arguments to the argument list. If supplied it
        also stores this access in var_accesses.
 
        :param arg: the meta-data description of the operator.
        :type arg: :py:class:`psyclone.dynamo0p3.DynKernelArgument`
        :param var_accesses: optional VariablesAccessInfo instance to store \
            the information about variable accesses.
        :type var_accesses: \
            :py:class:`psyclone.core.VariablesAccessInfo`
 
        '''
        # TODO we should only be including ncell_3d once in the argument
        # list but this adds it for every operator
        # This argument is always read only:
        if arg.data_type == "r_solver_operator_type":
            op_name = "r_solver_operator"
        elif arg.data_type == "r_tran_operator_type":
            op_name = "r_tran_operator"
        else:
            op_name = "operator"
        const = LFRicConstants()
        operator = const.DATA_TYPE_MAP[op_name]
        self.append_structure_reference(
            operator["module"], operator["proxy_type"], ["ncell_3d"],
            arg.proxy_name_indexed,
            overwrite_datatype=LFRicTypes("LFRicIntegerScalarDataType")())
        self.append(arg.proxy_name_indexed + "%ncell_3d", var_accesses,
                    mode=AccessType.READ)
 
        sym = self._symtab.lookup_with_tag(
            f"{arg.name}:{const.ARG_TYPE_SUFFIX_MAPPING[arg.argument_type]}")
        self.psyir_append(Reference(sym))
        # The access mode of `local_stencil` is taken from the meta-data:
        self.append(sym.name, var_accesses,
                    mode=arg.access, metadata_posn=arg.metadata_index)
 

References psyclone.domain.lfric.arg_ordering.ArgOrdering._symtab(), psyclone.psyir.nodes.node.ChildrenList.append(), psyclone.gocean1p0.GOKernelArguments.append(), psyclone.psyGen.Arguments.append(), psyclone.domain.lfric.arg_ordering.ArgOrdering.append(), psyclone.domain.lfric.kern_call_arg_list.KernCallArgList.append_structure_reference(), and psyclone.domain.lfric.arg_ordering.ArgOrdering.psyir_append().

Here is the call graph for this function:

Here is the caller graph for this function:

operator_bcs_kernel()

def psyclone.domain.lfric.kern_call_arg_list.KernCallArgList.operator_bcs_kernel	(		self,
			function_space,
			var_accesses = None
	)

Supply necessary additional arguments for the kernel that
applies boundary conditions to a LMA operator. If supplied it
also stores this access in var_accesses.

:param function_space: unused, only for consistency with base class.
:type function_space: :py:class:`psyclone.dynamo3.FunctionSpace`
:param var_accesses: optional VariablesAccessInfo instance to store \
    the information about variable accesses.
:type var_accesses: \
    :py:class:`psyclone.core.VariablesAccessInfo`

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

Definition at line 766 of file kern_call_arg_list.py.

    def operator_bcs_kernel(self, function_space, var_accesses=None):
        '''Supply necessary additional arguments for the kernel that
        applies boundary conditions to a LMA operator. If supplied it
        also stores this access in var_accesses.
 
        :param function_space: unused, only for consistency with base class.
        :type function_space: :py:class:`psyclone.dynamo3.FunctionSpace`
        :param var_accesses: optional VariablesAccessInfo instance to store \
            the information about variable accesses.
        :type var_accesses: \
            :py:class:`psyclone.core.VariablesAccessInfo`
 
        '''
        # This kernel has only a single LMA operator as argument.
        # Checks for this are performed in ArgOrdering.generate()
        op_arg = self._kern.arguments.args[0]
        base_name = "boundary_dofs_" + op_arg.name
        sym = self.append_array_reference(base_name, [":", ":"],
                                          ScalarType.Intrinsic.INTEGER)
        self.append(sym.name, var_accesses)
 

References psyclone.domain.common.psylayer.psyloop.PSyLoop._kern, psyclone.domain.lfric.arg_ordering.ArgOrdering._kern, psyclone.domain.lfric.lfric_loop.LFRicLoop._kern, psyclone.psyir.nodes.node.ChildrenList.append(), psyclone.gocean1p0.GOKernelArguments.append(), psyclone.psyGen.Arguments.append(), psyclone.domain.lfric.arg_ordering.ArgOrdering.append(), and psyclone.domain.lfric.arg_ordering.ArgOrdering.append_array_reference().

Here is the call graph for this function:

Here is the caller graph for this function:

quad_rule()

def psyclone.domain.lfric.kern_call_arg_list.KernCallArgList.quad_rule	(		self,
			var_accesses = None
	)

Add quadrature-related information to the kernel argument list.
Adds the necessary arguments to the argument list, and optionally
adds variable access information to the var_accesses object.

:param var_accesses: optional VariablesAccessInfo instance to store \
    the information about variable accesses.
:type var_accesses: \
    :py:class:`psyclone.core.VariablesAccessInfo`

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

Definition at line 806 of file kern_call_arg_list.py.

    def quad_rule(self, var_accesses=None):
        '''Add quadrature-related information to the kernel argument list.
        Adds the necessary arguments to the argument list, and optionally
        adds variable access information to the var_accesses object.
 
        :param var_accesses: optional VariablesAccessInfo instance to store \
            the information about variable accesses.
        :type var_accesses: \
            :py:class:`psyclone.core.VariablesAccessInfo`
 
        '''
        # The QR shapes that this routine supports
        supported_qr_shapes = ["gh_quadrature_xyoz", "gh_quadrature_edge",
                               "gh_quadrature_face"]
 
        for shape, rule in self._kern.qr_rules.items():
            if shape == "gh_quadrature_xyoz":
                # XYoZ quadrature requires the number of quadrature points in
                # the horizontal and in the vertical.
                self._nqp_positions.append(
                    {"horizontal": self.num_args + 1,
                     "vertical": self.num_args + 2})
                self.extend(rule.kernel_args, var_accesses)
            elif shape == "gh_quadrature_edge":
                # TODO #705 support transformations supplying the number of
                # quadrature points for edge quadrature.
                self.extend(rule.kernel_args, var_accesses)
            elif shape == "gh_quadrature_face":
                # TODO #705 support transformations supplying the number of
                # quadrature points for face quadrature.
                self.extend(rule.kernel_args, var_accesses)
            else:
                raise NotImplementedError(
                    f"quad_rule: no support implemented for quadrature with a "
                    f"shape of '{shape}'. Supported shapes are: "
                    f"{supported_qr_shapes}.")
            # Now define the arguments using PSyIR:
            for arg in rule.kernel_args:
                # Each rule has a `psy_name` (e.g. qr_xyoz), which is appended
                # to all variable names (e.g. np_xy_qr_xyoz). Remove this
                # suffix to get the 'generic' name, from which we derive
                # the correct type:
                generic_name = arg[:-len(rule.psy_name)-1]
                if generic_name in ["np_xy", "np_z", "nfaces", "np_xyz",
                                    "nedges"]:
                    # np_xy, np_z, nfaces, np_xyz, nedges are all integers:
                    self.append_integer_reference(arg)
                elif generic_name in ["weights_xy", "weights_z"]:
                    # 1d arrays:
                    # TODO # 1910: These should be pointers
                    self.append_array_reference(arg, [":"],
                                                ScalarType.Intrinsic.REAL)
                elif generic_name in ["weights_xyz"]:
                    # 2d arrays:
                    # TODO #1910: These should be pointers
                    self.append_array_reference(arg, [":", ":"],
                                                ScalarType.Intrinsic.REAL)
                else:
                    raise InternalError(f"Found invalid kernel argument "
                                        f"'{arg}'.")
 

References psyclone.domain.common.psylayer.psyloop.PSyLoop._kern, psyclone.domain.lfric.arg_ordering.ArgOrdering._kern, psyclone.domain.lfric.lfric_loop.LFRicLoop._kern, psyclone.domain.lfric.kern_call_arg_list.KernCallArgList._nqp_positions, psyclone.domain.lfric.arg_ordering.ArgOrdering.append(), psyclone.domain.lfric.arg_ordering.ArgOrdering.append_array_reference(), psyclone.domain.lfric.arg_ordering.ArgOrdering.append_integer_reference(), psyclone.psyir.nodes.node.ChildrenList.extend(), psyclone.domain.lfric.arg_ordering.ArgOrdering.extend(), and psyclone.domain.lfric.arg_ordering.ArgOrdering.num_args().

Here is the call graph for this function:

Here is the caller graph for this function:

scalar()

def psyclone.domain.lfric.kern_call_arg_list.KernCallArgList.scalar	(		self,
			scalar_arg,
			var_accesses = None
	)

Add the necessary argument for a scalar quantity as well as an
appropriate Symbol to the SymbolTable.

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

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

Reimplemented in psyclone.domain.lfric.kern_call_acc_arg_list.KernCallAccArgList.

Definition at line 233 of file kern_call_arg_list.py.

    def scalar(self, scalar_arg, var_accesses=None):
        '''
        Add the necessary argument for a scalar quantity as well as an
        appropriate Symbol to the SymbolTable.
 
        :param scalar_arg: the scalar kernel argument.
        :type scalar_arg: :py:class:`psyclone.dynamo0p3.DynKernelArgument`
        :param var_accesses: optional VariablesAccessInfo instance that \
            stores information about variable accesses.
        :type var_accesses: \
            :py:class:`psyclone.core.VariablesAccessInfo`
 
        '''
        super().scalar(scalar_arg, var_accesses)
        if scalar_arg.is_literal:
            self.psyir_append(scalar_arg.psyir_expression())
        else:
            sym = self._symtab.lookup(scalar_arg.name)
            self.psyir_append(Reference(sym))
 

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

Here is the call graph for this function:

Here is the caller graph for this function:

stencil()

def psyclone.domain.lfric.kern_call_arg_list.KernCallArgList.stencil	(		self,
			arg,
			var_accesses = None
	)

Add general stencil information associated with the argument 'arg'
to the argument list. If supplied it also stores this access in
var_accesses.

:param arg: the meta-data description of the kernel \
    argument with which the stencil is associated.
:type arg: :py:class:`psyclone.dynamo0p3.DynKernelArgument`
:param var_accesses: optional VariablesAccessInfo instance to store \
    the information about variable accesses.
:type var_accesses: \
    :py:class:`psyclone.core.VariablesAccessInfo`

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

Reimplemented in psyclone.domain.lfric.kern_call_acc_arg_list.KernCallAccArgList.

Definition at line 484 of file kern_call_arg_list.py.

    def stencil(self, arg, var_accesses=None):
        '''Add general stencil information associated with the argument 'arg'
        to the argument list. If supplied it also stores this access in
        var_accesses.
 
        :param arg: the meta-data description of the kernel \
            argument with which the stencil is associated.
        :type arg: :py:class:`psyclone.dynamo0p3.DynKernelArgument`
        :param var_accesses: optional VariablesAccessInfo instance to store \
            the information about variable accesses.
        :type var_accesses: \
            :py:class:`psyclone.core.VariablesAccessInfo`
 
        '''
        # add in stencil dofmap
        # Import here to avoid circular dependency
        # pylint: disable=import-outside-toplevel
        from psyclone.domain.lfric.lfric_stencils import LFRicStencils
        var_sym = LFRicStencils.dofmap_symbol(self._symtab, arg)
        cell_name, cell_ref = self.cell_ref_name(var_accesses)
        self.append_array_reference(var_sym.name, [":", ":", cell_ref],
                                    ScalarType.Intrinsic.INTEGER,
                                    symbol=var_sym)
        self.append(f"{var_sym.name}(:,:,{cell_name})", var_accesses,
                    var_access_name=var_sym.name)
 

References psyclone.domain.lfric.arg_ordering.ArgOrdering._symtab(), psyclone.psyir.nodes.node.ChildrenList.append(), psyclone.gocean1p0.GOKernelArguments.append(), psyclone.psyGen.Arguments.append(), psyclone.domain.lfric.arg_ordering.ArgOrdering.append(), psyclone.domain.lfric.arg_ordering.ArgOrdering.append_array_reference(), and psyclone.domain.lfric.kern_call_arg_list.KernCallArgList.cell_ref_name().

Here is the call graph for this function:

Here is the caller graph for this function:

stencil_2d()

def psyclone.domain.lfric.kern_call_arg_list.KernCallArgList.stencil_2d	(		self,
			arg,
			var_accesses = None
	)

Add general 2D stencil information associated with the argument
'arg' to the argument list. If supplied it also stores this access in
var_accesses.

:param arg: the meta-data description of the kernel \
    argument with which the stencil is associated.
:type arg: :py:class:`psyclone.dynamo0p3.DynKernelArgument`
:param var_accesses: optional VariablesAccessInfo instance to store \
    the information about variable accesses.
:type var_accesses: \
    :py:class:`psyclone.core.VariablesAccessInfo`

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

Reimplemented in psyclone.domain.lfric.kern_call_acc_arg_list.KernCallAccArgList.

Definition at line 510 of file kern_call_arg_list.py.

    def stencil_2d(self, arg, var_accesses=None):
        '''Add general 2D stencil information associated with the argument
        'arg' to the argument list. If supplied it also stores this access in
        var_accesses.
 
        :param arg: the meta-data description of the kernel \
            argument with which the stencil is associated.
        :type arg: :py:class:`psyclone.dynamo0p3.DynKernelArgument`
        :param var_accesses: optional VariablesAccessInfo instance to store \
            the information about variable accesses.
        :type var_accesses: \
            :py:class:`psyclone.core.VariablesAccessInfo`
 
        '''
        # The stencil_2D differs from the stencil in that the direction
        # of the branch is baked into the stencil_dofmap array.
        # The array dimensions are thus (dof_in_cell, cell_in_branch,
        # branch_in_stencil) where the branch_in_stencil is always ordered
        # West, South, East, North which is standard in LFRic. This allows
        # for knowledge of what direction a stencil cell is in relation
        # to the center even when the stencil is truncated at boundaries.
        # Import here to avoid circular dependency
        # pylint: disable=import-outside-toplevel
        from psyclone.domain.lfric.lfric_stencils import LFRicStencils
        var_sym = LFRicStencils.dofmap_symbol(self._symtab, arg)
        cell_name, cell_ref = self.cell_ref_name(var_accesses)
        self.append_array_reference(var_sym.name,
                                    [":", ":", ":", cell_ref],
                                    ScalarType.Intrinsic.INTEGER,
                                    symbol=var_sym)
        name = f"{var_sym.name}(:,:,:,{cell_name})"
        self.append(name, var_accesses, var_access_name=var_sym.name)
 

References psyclone.domain.lfric.arg_ordering.ArgOrdering._symtab(), psyclone.psyir.nodes.node.ChildrenList.append(), psyclone.gocean1p0.GOKernelArguments.append(), psyclone.psyGen.Arguments.append(), psyclone.domain.lfric.arg_ordering.ArgOrdering.append(), psyclone.domain.lfric.arg_ordering.ArgOrdering.append_array_reference(), and psyclone.domain.lfric.kern_call_arg_list.KernCallArgList.cell_ref_name().

Here is the call graph for this function:

Here is the caller graph for this function:

stencil_2d_max_extent()

def psyclone.domain.lfric.kern_call_arg_list.KernCallArgList.stencil_2d_max_extent	(		self,
			arg,
			var_accesses = None
	)

Add the maximum branch extent for a 2D stencil associated with the
argument 'arg' to the argument list. If supplied it also stores this
in var_accesses.

:param arg: the kernel argument with which the stencil is associated.
:type arg: :py:class:`pclone.dynamo0p3.DynKernelArgument`
:param var_accesses: optional SingleVariableAccessInfo instance \
    to store the information about variable accesses.
:type var_accesses: \
    :py:class:`psyclone.core.SingleVariableAccessInfo`

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

Definition at line 438 of file kern_call_arg_list.py.

    def stencil_2d_max_extent(self, arg, var_accesses=None):
        '''Add the maximum branch extent for a 2D stencil associated with the
        argument 'arg' to the argument list. If supplied it also stores this
        in var_accesses.
 
        :param arg: the kernel argument with which the stencil is associated.
        :type arg: :py:class:`pclone.dynamo0p3.DynKernelArgument`
        :param var_accesses: optional SingleVariableAccessInfo instance \
            to store the information about variable accesses.
        :type var_accesses: \
            :py:class:`psyclone.core.SingleVariableAccessInfo`
 
        '''
        # The maximum branch extent is not specified in the metadata so pass
        # the value in.
        # Import here to avoid circular dependency
        # pylint: disable=import-outside-toplevel
        from psyclone.domain.lfric.lfric_stencils import LFRicStencils
        # TODO #1915, this duplicates code in
        # LFRicStencils.max_branch_length_name
        unique_tag = LFRicStencils.stencil_unique_str(arg, "length")
        root_name = arg.name + "_max_branch_length"
 
        sym = self.append_integer_reference(root_name, tag=unique_tag)
        self.append(sym.name, var_accesses)
 

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

Here is the call graph for this function:

Here is the caller graph for this function:

stencil_2d_unknown_extent()

def psyclone.domain.lfric.kern_call_arg_list.KernCallArgList.stencil_2d_unknown_extent	(		self,
			arg,
			var_accesses = None
	)

Add 2D stencil information to the argument list associated with the
argument 'arg' if the extent is unknown. If supplied it also stores
this access in var_accesses.

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

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

Reimplemented in psyclone.domain.lfric.kern_call_acc_arg_list.KernCallAccArgList.

Definition at line 413 of file kern_call_arg_list.py.

    def stencil_2d_unknown_extent(self, arg, var_accesses=None):
        '''Add 2D stencil information to the argument list associated with the
        argument 'arg' if the extent is unknown. If supplied it also stores
        this access in var_accesses.
 
        :param arg: the kernel argument with which the stencil is associated.
        :type arg: :py:class:`psyclone.dynamo0p3.DynKernelArgument`
        :param var_accesses: optional VariablesAccessInfo instance to store \
            the information about variable accesses.
        :type var_accesses: \
            :py:class:`psyclone.core.VariablesAccessInfo`
 
        '''
        # The extent is not specified in the metadata so pass the value in
        # Import here to avoid circular dependency
        # pylint: disable=import-outside-toplevel
        from psyclone.domain.lfric.lfric_stencils import LFRicStencils
        var_sym = LFRicStencils.dofmap_size_symbol(self._symtab, arg)
        cell_name, cell_ref = self.cell_ref_name(var_accesses)
        self.append_array_reference(var_sym.name, [":", cell_ref],
                                    ScalarType.Intrinsic.INTEGER,
                                    symbol=var_sym)
        name = f"{var_sym.name}(:,{cell_name})"
        self.append(name, var_accesses, var_access_name=var_sym.name)
 

References psyclone.domain.lfric.arg_ordering.ArgOrdering._symtab(), psyclone.psyir.nodes.node.ChildrenList.append(), psyclone.gocean1p0.GOKernelArguments.append(), psyclone.psyGen.Arguments.append(), psyclone.domain.lfric.arg_ordering.ArgOrdering.append(), psyclone.domain.lfric.arg_ordering.ArgOrdering.append_array_reference(), and psyclone.domain.lfric.kern_call_arg_list.KernCallArgList.cell_ref_name().

Here is the call graph for this function:

Here is the caller graph for this function:

stencil_unknown_direction()

def psyclone.domain.lfric.kern_call_arg_list.KernCallArgList.stencil_unknown_direction	(		self,
			arg,
			var_accesses = None
	)

Add stencil information to the argument list associated with the
argument 'arg' if the direction is unknown (i.e. it's being supplied
in a variable). If supplied it also stores this access in
var_accesses.

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

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

Definition at line 464 of file kern_call_arg_list.py.

    def stencil_unknown_direction(self, arg, var_accesses=None):
        '''Add stencil information to the argument list associated with the
        argument 'arg' if the direction is unknown (i.e. it's being supplied
        in a variable). If supplied it also stores this access in
        var_accesses.
 
        :param arg: the kernel argument with which the stencil is associated.
        :type arg: :py:class:`psyclone.dynamo0p3.DynKernelArgument`
        :param var_accesses: optional VariablesAccessInfo instance to store \
            the information about variable accesses.
        :type var_accesses: \
            :py:class:`psyclone.core.VariablesAccessInfo`
 
        '''
        # the direction of the stencil is not known so pass the value in
        name = arg.stencil.direction_arg.varname
        tag = arg.stencil.direction_arg.text
        self.append_integer_reference(name, f"AlgArgs_{tag}")
        self.append(name, var_accesses)
 

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

Here is the call graph for this function:

Here is the caller graph for this function:

stencil_unknown_extent()

def psyclone.domain.lfric.kern_call_arg_list.KernCallArgList.stencil_unknown_extent	(		self,
			arg,
			var_accesses = None
	)

Add stencil information to the argument list associated with the
argument 'arg' if the extent is unknown. If supplied it also stores
this access in var_accesses.

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

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

Reimplemented in psyclone.domain.lfric.kern_call_acc_arg_list.KernCallAccArgList.

Definition at line 388 of file kern_call_arg_list.py.

    def stencil_unknown_extent(self, arg, var_accesses=None):
        '''Add stencil information to the argument list associated with the
        argument 'arg' if the extent is unknown. If supplied it also stores
        this access in var_accesses.
 
        :param arg: the kernel argument with which the stencil is associated.
        :type arg: :py:class:`psyclone.dynamo0p3.DynKernelArgument`
        :param var_accesses: optional VariablesAccessInfo instance to store \
            the information about variable accesses.
        :type var_accesses: \
            :py:class:`psyclone.core.VariablesAccessInfo`
 
        '''
        # The extent is not specified in the metadata so pass the value in
        # Import here to avoid circular dependency
        # pylint: disable=import-outside-toplevel
        from psyclone.domain.lfric.lfric_stencils import LFRicStencils
        var_sym = LFRicStencils.dofmap_size_symbol(self._symtab, arg)
        cell_name, cell_ref = self.cell_ref_name(var_accesses)
        self.append_array_reference(var_sym.name, [cell_ref],
                                    ScalarType.Intrinsic.INTEGER,
                                    symbol=var_sym)
        self.append(f"{var_sym.name}({cell_name})", var_accesses,
                    var_access_name=var_sym.name)
 

References psyclone.domain.lfric.arg_ordering.ArgOrdering._symtab(), psyclone.psyir.nodes.node.ChildrenList.append(), psyclone.gocean1p0.GOKernelArguments.append(), psyclone.psyGen.Arguments.append(), psyclone.domain.lfric.arg_ordering.ArgOrdering.append(), psyclone.domain.lfric.arg_ordering.ArgOrdering.append_array_reference(), and psyclone.domain.lfric.kern_call_arg_list.KernCallArgList.cell_ref_name().

Here is the call graph for this function:

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/domain/lfric/kern_call_arg_list.py