Support code for the community code interfaces

class amuse.rfi.core.CodeFunction(interface, owner, specification)

Implementation of the runtime call to the remote process.

Performs the encoding of python arguments into lists of values, sends a message over an MPI channel and waits for a result message, decodes this message and returns.

class amuse.rfi.core.CodeInterface(name_of_the_worker='worker_code', **options)

Abstract base class for all interfaces to legacy codes.

When a subclass is instantiated, a number of subprocesses will be started. These subprocesses are called workers as they implement the interface and do the actual work of the instantiated object.

before_get_parameter()

Called everytime just before a parameter is retrieved in using:: instance.parameter.name

before_set_parameter()

Called everytime just before a parameter is updated in using:: instance.parameter.name = newvalue

get_data_directory()

Returns the root name of the directory for the application data files

get_output_directory()

Returns the root name of the directory to use by the application to store it’s output / temporary files in.

internal__get_message_polling_interval

Gets the message polling interval for MPI header messages, in microseconds

int32 internal__get_message_polling_interval(int32 * polling_interval);
FUNCTION internal__get_message_polling_interval(polling_interval)
  INTEGER :: polling_interval
  INTEGER :: internal__get_message_polling_interval
END FUNCTION
Parameters:polling_interval (int32, OUT) –
Returns:
internal__set_message_polling_interval
int32 internal__set_message_polling_interval(int32 polling_interval);
FUNCTION internal__set_message_polling_interval(polling_interval)
  INTEGER :: polling_interval
  INTEGER :: internal__set_message_polling_interval
END FUNCTION
Parameters:polling_interval (int32, IN) –
Returns:
redirection

Redirect the output of the code to null, standard streams or file

class amuse.rfi.core.LegacyFunctionSpecification

Specification of a legacy function. Describes the name, result type and parameters of a legacy function.

The legacy functions are implemented by legacy codes. The implementation of legacy functions is in C/C++ or Fortran. To interact with these functions a specification of the legacy function is needed. This specification is used to determine how to encode and decode the parameters and results of the function. Objects of this class describe the specification of one function.

>>> specification = LegacyFunctionSpecification()
>>> specification.name = "test"
>>> specification.addParameter("one", dtype="int32", direction = specification.IN)
>>> specification.addParameter("two", dtype="float64", direction = specification.OUT)
>>> specification.result_type = "int32"
>>> print specification
function: int test(int one)
output: double two, int __result
IN = <object object at 0x1cb1240>

Used to specify that a parameter is used as an input parameter, passed by value

INOUT = <object object at 0x1cb1260>

Used to specify that a parameter is used as an input and an outpur parameter, passed by reference

LENGTH = <object object at 0x1cb1270>

Used to specify that a parameter is used as the length parameter for the other parameters

OUT = <object object at 0x1cb1250>

Used to specify that a parameter is used as an output parameter, passed by reference

addParameter(name, dtype='i', direction=<object object at 0x1cb1240>, description='', default=None, unit=None)

Extend the specification with a new parameter.

The sequence of calls to addParameter is important. The first call will be interpreted as the first argument, the second call as the second argument etc.

Parameters:
  • name – Name of the parameter, used in documentation and function generation
  • dtype – Datatype specification string
  • direction – Direction of the argument, can be IN, OUT or INOUT
  • description – Description of the argument, for documenting purposes
  • default – An optional default value for the parameter
class amuse.rfi.core.PythonCodeInterface(implementation_factory=None, name_of_the_worker=None, **options)

Base class for codes having a python implementation

Parameters:implementation_factory – Class of the python implementation
amuse.rfi.core.legacy_function

Decorator for legacy functions.

The decorated function cannot have any arguments. This means the decorated function must not have a self argument.

The decorated function must return a LegacyFunctionSpecification.

>>> class LegacyExample(object):
...     @legacy_function
...     def evolve():
...          specification = LegacyFunctionSpecification()
...          return specification
...
>>> x = LegacyExample()
>>> x.evolve.specification 
<amuse.rfi.core.LegacyFunctionSpecification object at 0x...>
>>> LegacyExample.evolve 
<amuse.rfi.core.legacy_function object at 0x...>
>>> x.evolve 
<amuse.rfi.core.CodeFunction object at 0x...>
Parameters:specification_function – The function to be decorated
amuse.rfi.core.stop_interfaces()

Stop the workers of all instantiated interfaces.

All instantiated interfaces will become unstable after this call!

Previous topic

Support code for AMUSE framework

Next topic

Supported File Formats

This Page