Inheritance diagram for psyclone.transformations.Dynamo0p3KernelConstTrans:

[legend]

Collaboration diagram for psyclone.transformations.Dynamo0p3KernelConstTrans:

[legend]

Public Member Functions
def	__str__ (self)

def	name (self)

def	apply (self, node, options=None)

def	validate (self, node, options=None)

Static Public Attributes
dictionary	space_to_dofs

Detailed Description

Modifies a kernel so that the number of dofs, number of layers and
number of quadrature points are fixed in the kernel rather than
being passed in by argument.

>>> from psyclone.parse.algorithm import parse
>>> from psyclone.psyGen import PSyFactory
>>> api = "dynamo0.3"
>>> ast, invokeInfo = parse("file.f90", api=api)
>>> psy=PSyFactory(api).create(invokeInfo)
>>> schedule = psy.invokes.get('invoke_0').schedule
>>> # Uncomment the following line to see a text view of the schedule
>>> # print(schedule.view())
>>>
>>> from psyclone.transformations import Dynamo0p3KernelConstTrans
>>> trans = Dynamo0p3KernelConstTrans()
>>> for kernel in schedule.coded_kernels():
>>>     trans.apply(kernel, number_of_layers=150)
>>>     kernel_schedule = kernel.get_kernel_schedule()
>>>     # Uncomment the following line to see a text view of the
>>>     # symbol table
>>>     # print(kernel_schedule.symbol_table.view())

Definition at line 2076 of file transformations.py.

Member Function Documentation

◆ apply()

def psyclone.transformations.Dynamo0p3KernelConstTrans.apply	(	self,
		node,
		options = `None`
	)

Transforms a kernel so that the values for the number of degrees of
freedom (if a valid value for the element_order arg is
provided), the number of quadrature points (if the quadrature
arg is set to True) and the number of layers (if a valid value
for the number_of_layers arg is provided) are constant in a
kernel rather than being passed in by argument.

The "cellshape", "element_order" and "number_of_layers"
arguments are provided to mirror the namelist values that are
input into an LFRic model when it is run.

Quadrature support is currently limited to XYoZ in ths
transformation. In the case of XYoZ the number of quadrature
points (for horizontal and vertical) are set to the
element_order + 3 in the LFRic infrastructure so their value
is derived.

:param node: a kernel node.
:type node: :py:obj:`psyclone.domain.lfric.LFRicKern`
:param options: a dictionary with options for transformations.
:type options: Optional[Dict[str, Any]]
:param str options["cellshape"]: the shape of the cells. This is\
    provided as it helps determine the number of dofs a field has\
    for a particular function space. Currently only "quadrilateral"\
    is supported which is also the default value.
:param int options["element_order"]: the order of the cell. In \
    combination with cellshape, this determines the number of \
    dofs a field has for a particular function space. If it is set \
    to None (the default) then the dofs values are not set as \
    constants in the kernel, otherwise they are.
:param int options["number_of_layers"]: the number of vertical \
    layers in the LFRic model mesh used for this particular run. If \
    this is set to None (the default) then the nlayers value is not \
    set as a constant in the kernel, otherwise it is.
:param bool options["quadrature"]: whether the number of quadrature \
    points values are set as constants in the kernel (True) or not \
    (False). The default is False.

Reimplemented from psyclone.psyGen.Transformation.

Definition at line 2138 of file transformations.py.

     def apply(self, node, options=None):
         # pylint: disable=too-many-statements, too-many-locals
         '''Transforms a kernel so that the values for the number of degrees of
         freedom (if a valid value for the element_order arg is
         provided), the number of quadrature points (if the quadrature
         arg is set to True) and the number of layers (if a valid value
         for the number_of_layers arg is provided) are constant in a
         kernel rather than being passed in by argument.
  
         The "cellshape", "element_order" and "number_of_layers"
         arguments are provided to mirror the namelist values that are
         input into an LFRic model when it is run.
  
         Quadrature support is currently limited to XYoZ in ths
         transformation. In the case of XYoZ the number of quadrature
         points (for horizontal and vertical) are set to the
         element_order + 3 in the LFRic infrastructure so their value
         is derived.
  
         :param node: a kernel node.
         :type node: :py:obj:`psyclone.domain.lfric.LFRicKern`
         :param options: a dictionary with options for transformations.
         :type options: Optional[Dict[str, Any]]
         :param str options["cellshape"]: the shape of the cells. This is\
             provided as it helps determine the number of dofs a field has\
             for a particular function space. Currently only "quadrilateral"\
             is supported which is also the default value.
         :param int options["element_order"]: the order of the cell. In \
             combination with cellshape, this determines the number of \
             dofs a field has for a particular function space. If it is set \
             to None (the default) then the dofs values are not set as \
             constants in the kernel, otherwise they are.
         :param int options["number_of_layers"]: the number of vertical \
             layers in the LFRic model mesh used for this particular run. If \
             this is set to None (the default) then the nlayers value is not \
             set as a constant in the kernel, otherwise it is.
         :param bool options["quadrature"]: whether the number of quadrature \
             points values are set as constants in the kernel (True) or not \
             (False). The default is False.
  
         '''
         # --------------------------------------------------------------------
         def make_constant(symbol_table, arg_position, value,
                           function_space=None):
             '''Utility function that modifies the argument at position
             'arg_position' into a compile-time constant with value
             'value'.
  
             :param symbol_table: the symbol table for the kernel holding
                 the argument that is going to be modified.
             :type symbol_table: :py:class:`psyclone.psyir.symbols.SymbolTable`
             :param int arg_position: the argument's position in the
                 argument list.
             :param value: the constant value that this argument is going to
                 be given. Its type depends on the type of the argument.
             :type value: int, str or bool
             :type str function_space: the name of the function space if there
                 is a function space associated with this argument. Defaults
                 to None.
  
             '''
             arg_index = arg_position - 1
             try:
                 symbol = symbol_table.argument_list[arg_index]
             except IndexError as err:
                 raise TransformationError(
                     f"The argument index '{arg_index}' is greater than the "
                     f"number of arguments "
                     f"'{len(symbol_table.argument_list)}'.") from err
             # Perform some basic checks on the argument to make sure
             # it is the expected type
             if not isinstance(symbol.datatype, ScalarType):
                 raise TransformationError(
                     f"Expected entry to be a scalar argument but found "
                     f"'{type(symbol.datatype).__name__}'.")
             if symbol.datatype.intrinsic != ScalarType.Intrinsic.INTEGER:
                 raise TransformationError(
                     f"Expected entry to be a scalar integer argument "
                     f"but found '{symbol.datatype}'.")
             if symbol.is_constant:
                 raise TransformationError(
                     "Expected entry to be a scalar integer argument "
                     "but found a constant.")
  
             # Create a new symbol with a known constant value then swap
             # it with the argument. The argument then becomes xxx_dummy
             # and is unused within the kernel body.
             orig_name = symbol.name
             new_name = symbol_table.next_available_name(f"{orig_name}_dummy")
             local_symbol = DataSymbol(new_name, INTEGER_TYPE,
                                       is_constant=True, initial_value=value)
             symbol_table.add(local_symbol)
             symbol_table.swap_symbol_properties(symbol, local_symbol)
  
             if function_space:
                 print(f"    Modified {orig_name}, arg position {arg_position},"
                       f" function space {function_space}, value {value}.")
             else:
                 print(f"    Modified {orig_name}, arg position {arg_position},"
                       f" value {value}.")
         # --------------------------------------------------------------------
  
         self.validate(node, options)
  
         if not options:
             options = {}
         number_of_layers = options.get("number_of_layers", None)
         quadrature = options.get("quadrature", False)
         element_order = options.get("element_order", None)
         kernel = node
  
         arg_list_info = KernCallArgList(kernel)
         arg_list_info.generate()
         try:
             kernel_schedule = kernel.get_kernel_schedule()
         except NotImplementedError as excinfo:
             raise TransformationError(
                 f"Failed to parse kernel '{kernel.name}'. Error reported was "
                 f"'{excinfo}'.") from excinfo
  
         symbol_table = kernel_schedule.symbol_table
         if number_of_layers:
             make_constant(symbol_table, arg_list_info.nlayers_positions[0],
                           number_of_layers)
  
         if quadrature and arg_list_info.nqp_positions:
             # TODO #705 - support the transformation of kernels requiring
             # other quadrature types (face/edge, multiple).
             if kernel.eval_shapes == ["gh_quadrature_xyoz"]:
                 make_constant(symbol_table,
                               arg_list_info.nqp_positions[0]["horizontal"],
                               element_order+3)
                 make_constant(symbol_table,
                               arg_list_info.nqp_positions[0]["vertical"],
                               element_order+3)
             else:
                 raise TransformationError(
                     f"Error in Dynamo0p3KernelConstTrans transformation. "
                     f"Support is currently limited to 'xyoz' quadrature but "
                     f"found {kernel.eval_shapes}.")
  
         const = LFRicConstants()
         if element_order is not None:
             # Modify the symbol table for degrees of freedom here.
             for info in arg_list_info.ndf_positions:
                 if (info.function_space.lower() in
                         (const.VALID_ANY_SPACE_NAMES +
                          const.VALID_ANY_DISCONTINUOUS_SPACE_NAMES +
                          ["any_w2"])):
                     # skip any_space_*, any_discontinuous_space_* and any_w2
                     print(f"    Skipped dofs, arg position {info.position}, "
                           f"function space {info.function_space}")
                 else:
                     try:
                         ndofs = Dynamo0p3KernelConstTrans. \
                                 space_to_dofs[
                                     info.function_space](element_order)
                     except KeyError as err:
                         raise InternalError(
                             f"Error in Dynamo0p3KernelConstTrans "
                             f"transformation. Unsupported function space "
                             f"'{info.function_space}' found. Expecting one of "
                             f"""{Dynamo0p3KernelConstTrans.
                                  space_to_dofs.keys()}.""") from err
                     make_constant(symbol_table, info.position, ndofs,
                                   function_space=info.function_space)
  
         # Flag that the kernel has been modified
         kernel.modified = True
  

Here is the call graph for this function:

◆ name()

def psyclone.transformations.Dynamo0p3KernelConstTrans.name ( self )

:returns: the name of this transformation as a string.
:rtype: str

Reimplemented from psyclone.psyGen.Transformation.

Definition at line 2131 of file transformations.py.

     def name(self):
         '''
         :returns: the name of this transformation as a string.
         :rtype: str
         '''
         return "Dynamo0p3KernelConstTrans"
  

Here is the caller graph for this function:

◆ validate()

def psyclone.transformations.Dynamo0p3KernelConstTrans.validate	(	self,
		node,
		options = `None`
	)

This method checks whether the input arguments are valid for
this transformation.

:param node: a dynamo 0.3 kernel node.
:type node: :py:obj:`psyclone.domain.lfric.LFRicKern`
:param options: a dictionary with options for transformations.
:type options: Optional[Dict[str, Any]]
:param str options["cellshape"]: the shape of the elements/cells.
:param int options["element_order"]: the order of the elements/cells.
:param int options["number_of_layers"]: the number of layers to use.
:param bool options["quadrature"]: whether quadrature dimension sizes \
    should or shouldn't be set as constants in a kernel.

:raises TransformationError: if the node argument is not a \
    dynamo 0.3 kernel, the cellshape argument is not set to \
    "quadrilateral", the element_order argument is not a 0 or a \
    positive integer, the number of layers argument is not a \
    positive integer, the quadrature argument is not a boolean, \
    neither element order nor number of layers arguments are set \
    (as the transformation would then do nothing), or the \
    quadrature argument is True but the element order is not \
    provided (as the former needs the latter).

Reimplemented from psyclone.psyGen.Transformation.

Definition at line 2308 of file transformations.py.

     def validate(self, node, options=None):
         '''This method checks whether the input arguments are valid for
         this transformation.
  
         :param node: a dynamo 0.3 kernel node.
         :type node: :py:obj:`psyclone.domain.lfric.LFRicKern`
         :param options: a dictionary with options for transformations.
         :type options: Optional[Dict[str, Any]]
         :param str options["cellshape"]: the shape of the elements/cells.
         :param int options["element_order"]: the order of the elements/cells.
         :param int options["number_of_layers"]: the number of layers to use.
         :param bool options["quadrature"]: whether quadrature dimension sizes \
             should or shouldn't be set as constants in a kernel.
  
         :raises TransformationError: if the node argument is not a \
             dynamo 0.3 kernel, the cellshape argument is not set to \
             "quadrilateral", the element_order argument is not a 0 or a \
             positive integer, the number of layers argument is not a \
             positive integer, the quadrature argument is not a boolean, \
             neither element order nor number of layers arguments are set \
             (as the transformation would then do nothing), or the \
             quadrature argument is True but the element order is not \
             provided (as the former needs the latter).
  
         '''
         if not isinstance(node, LFRicKern):
             raise TransformationError(
                 f"Error in Dynamo0p3KernelConstTrans transformation. Supplied "
                 f"node must be a dynamo kernel but found '{type(node)}'.")
  
         if not options:
             options = {}
         cellshape = options.get("cellshape", "quadrilateral")
         element_order = options.get("element_order", None)
         number_of_layers = options.get("number_of_layers", None)
         quadrature = options.get("quadrature", False)
         if cellshape.lower() != "quadrilateral":
             # Only quadrilaterals are currently supported
             raise TransformationError(
                 f"Error in Dynamo0p3KernelConstTrans transformation. Supplied "
                 f"cellshape must be set to 'quadrilateral' but found "
                 f"'{cellshape}'.")
  
         if element_order is not None and \
            (not isinstance(element_order, int) or element_order < 0):
             # element order must be 0 or a positive integer
             raise TransformationError(
                 f"Error in Dynamo0p3KernelConstTrans transformation. The "
                 f"element_order argument must be >= 0 but found "
                 f"'{element_order}'.")
  
         if number_of_layers is not None and \
            (not isinstance(number_of_layers, int) or number_of_layers < 1):
             # number of layers must be a positive integer
             raise TransformationError(
                 f"Error in Dynamo0p3KernelConstTrans transformation. The "
                 f"number_of_layers argument must be > 0 but found "
                 f"'{number_of_layers}'.")
  
         if quadrature not in [False, True]:
             # quadrature must be a boolean value
             raise TransformationError(
                 f"Error in Dynamo0p3KernelConstTrans transformation. The "
                 f"quadrature argument must be boolean but found "
                 f"'{quadrature}'.")
  
         if element_order is None and not number_of_layers:
             # As a minimum, element order or number of layers must have values.
             raise TransformationError(
                 "Error in Dynamo0p3KernelConstTrans transformation. At least "
                 "one of element_order or number_of_layers must be set "
                 "otherwise this transformation does nothing.")
  
         if quadrature and element_order is None:
             # if quadrature then element order
             raise TransformationError(
                 "Error in Dynamo0p3KernelConstTrans transformation. If "
                 "quadrature is set then element_order must also be set (as "
                 "the values of the former are derived from the latter.")
  
  

Here is the caller graph for this function:

Member Data Documentation

◆ space_to_dofs

dictionary psyclone.transformations.Dynamo0p3KernelConstTrans.space_to_dofs

static

Initial value:

=  {"w3":       (lambda n: (n+1)**3),
                     "w2":       (lambda n: 3*(n+2)*(n+1)**2),
                     "w1":       (lambda n: 3*(n+2)**2*(n+1)),
                     "w0":       (lambda n: (n+2)**3),
                     "wtheta":   (lambda n: (n+2)*(n+1)**2),
                     "w2h":      (lambda n: 2*(n+2)*(n+1)**2),
                     "w2v":      (lambda n: (n+2)*(n+1)**2),
                     "w2broken": (lambda n: 3*(n+1)**2*(n+2)),
                     "wchi":     (lambda n: (n+1)**3),
                     "w2trace":  (lambda n: 6*(n+1)**2),
                     "w2htrace": (lambda n: 4*(n+1)**2),
                     "w2vtrace": (lambda n: 2*(n+1)**2)}

Definition at line 2112 of file transformations.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/transformations.py

Public Member Functions

Static Public Attributes

Detailed Description

Member Function Documentation

◆ apply()

◆ name()

◆ validate()

Member Data Documentation

◆ space_to_dofs