| ►Nallreduction_inter_io_mod | All reduction, which does a reduce and then broadcasts the data to all IO servers |
| Callreduce_type | |
| ►Narithmetic_operator_mod | The arithmetic operator which allows the user to define arithmetic formulas based on fields and constants which are then executed BDMAS style. This works by parsing the text forumula into an execution tree which is walked in order to perform the final result. Building the tree is the potentially expensive aspect of this, so built trees are cached as it is likely that the equation will be run many times. Currently this is expressed in terms of scalars, and it will operate on all elements of the data |
| Carithmetic_cache_item | |
| Carithmetic_execution_node | |
| ►Nbroadcast_inter_io_mod | Broadcast inter IO communication which sends a value from one IO server to all others. This tracks field name and timestep and only issues one call (and one results call to completion) for that combination |
| Cinter_io_broadcast | |
| Cthreaded_callback_parameters_type | |
| ►Ncasim_monc_dgs_space | |
| Ccasim_monc_dglist | |
| ►Ncollections_mod | Collection data structures |
| Cc_add_generic | Adds a generic element to the end of the list |
| Cc_add_integer | Adds an integer element to the end of the list |
| Cc_add_logical | Adds a logical element to the end of the list |
| Cc_add_real | Adds a double precision real element to the end of the list |
| Cc_add_string | Adds a string to the end of the list |
| Cc_contains | Determines whether or not a map contains a specific key |
| Cc_free | Frees up all the allocatable, heap, memory associated with a list, stack, queue or map |
| Cc_generic_at | Retrieves the generic value held at the specific map index or null if index > map elements |
| Cc_generic_entry_at | Retrieves a map entry at a specific index or null if index > map elements. This is more efficient than calling key at and then value at (or get with the key) as only requires one search for both the key and value |
| Cc_get_generic | Gets a specific generic element out of the list, stack, queue or map with the corresponding key |
| Cc_get_integer | Gets a specific integer element out of the list, stack, queue or map with the corresponding key |
| Cc_get_iterator | |
| Cc_get_logical | Gets a specific logical element out of the list, stack, queue or map with the corresponding key |
| Cc_get_real | Gets a specific double precision real element out of the list, stack, queue or map with the corresponding key |
| Cc_get_string | Gets a specific string element out of the list, stack, queue or map with the corresponding key |
| Cc_has_next | |
| Cc_insert_generic | Inserts a generic element into the list or places at the end if the index > list size |
| Cc_insert_integer | Inserts an integer element into the list or places at the end if the index > list size |
| Cc_insert_logical | Inserts a logical element into the list or places at the end if the index > list size |
| Cc_insert_real | Inserts a double precision real element into the list or places at the end if the index > list size |
| Cc_insert_string | Inserts a string into the list or places at the end if the index > list size |
| Cc_integer_at | Retrieves the integer value held at the specific map index or null if index > map elements |
| Cc_integer_entry_at | Retrieves a map entry at a specific index. This is more efficient than calling key at and then value at (or get with the key) as only requires one search for both the key and value |
| Cc_is_empty | Returns whether a collection is empty |
| Cc_key_at | Retrieves the key currently being held at a specific index in the map or "" if the index > map elements |
| Cc_logical_at | Retrieves the logical value held at the specific map index or null if index > map elements |
| Cc_logical_entry_at | Retrieves a map entry at a specific index. This is more efficient than calling key at and then value at (or get with the key) as only requires one search for both the key and value |
| Cc_next_generic | |
| Cc_next_integer | |
| Cc_next_logical | |
| Cc_next_mapentry | |
| Cc_next_real | |
| Cc_next_string | |
| Cc_pop_generic | Pops a generic element off the stack or queue |
| Cc_pop_integer | Pops an integer element off the stack or queue |
| Cc_pop_logical | Pops a logical element off the stack or queue |
| Cc_pop_real | Pops a double precision real element off the stack or queue |
| Cc_pop_string | Pops a string off the stack or queue |
| Cc_push_generic | Pushes a generic element onto the stack or queue |
| Cc_push_integer | Pushes an integer element onto the stack or queue |
| Cc_push_logical | Pushes a logical element onto the stack or queue |
| Cc_push_real | Pushes a double precision real element onto the stack or queue |
| Cc_push_string | Pushes a string element onto the stack or queue |
| Cc_put_generic | Puts a generic key-value pair into the map |
| Cc_put_integer | Puts an integer key-value pair into the map |
| Cc_put_logical | Puts a logical key-value pair into the map |
| Cc_put_real | Puts a double precision real key-value pair into the map |
| Cc_put_string | Puts a string key-value pair into the map |
| Cc_real_at | Retrieves the double precision real value held at the specific map index or null if index > map elements |
| Cc_real_entry_at | Retrieves a map entry at a specific index. This is more efficient than calling key at and then value at (or get with the key) as only requires one search for both the key and value |
| Cc_remove | Removes a specific element from the list or map |
| Cc_size | Returns the number of elements in the collection |
| Cc_string_at | Retrieves the string value held at the specific map index or null if index > map elements |
| Cc_string_entry_at | Retrieves a map entry at a specific index. This is more efficient than calling key at and then value at (or get with the key) as only requires one search for both the key and value |
| Chashmap_type | A hashmap structure, the same as a map but uses hashing for greatly improved performance when storing large numbers of entries, with the lookup complexisty being almost constant (assuming good hash distribution.) Note that this does require more storage than a map and unlike a map does not preserve ordering |
| Chashset_type | Hashset structure which will store unique strings. The hashing aspect means that lookup is very fast but it does add extra memory overhead and the order is non-deterministic |
| Citerator_type | |
| Clist_type | List data structure which implements a doubly linked list. This list will preserve its order |
| Clistnode_type | Private list node which holds the raw generic node data and pointers to next and previous list nodes |
| Cmap_type | Map data structure that holds string (length 20 maximum) key value pairs |
| Cmapentry_type | |
| Cmapnode_type | Private map key-value pair data structure |
| Cqueue_type | Queue (FIFO) data structure |
| Csetnode_type | Private set key structure |
| Cstack_type | Stack (FILO) data structure |
| ►Ncommunication_types_mod | Contains the types used for communication, holding the state of communications and supporting activities. These are held in a separate module to allow for dependencies from multiple areas of the code base which might otherwise result in circular dependencies if they lived in a specific module of functionality |
| Cfield_data_wrapper_type | |
| Chalo_communication_type | Maintains the state of a halo swap and contains buffers, neighbours etc |
| Cneighbour_description_type | Describes the neighbours of a process in a specific dimension and contains the communication buffers associated with these |
| ►Nconfiguration_parser_mod | Parses the XML configuration file to produce the io configuration description which contains the data layout specification and rules for handling received data |
| Cdata_values_type | |
| Cget_data_value_by_field_name | |
| Cio_configuration_data_definition_type | Configuration of a specific data definition |
| Cio_configuration_diagnostic_field_type | |
| Cio_configuration_field_type | Configuration associated with the representation of a specific data field |
| Cio_configuration_file_writer_facet_type | |
| Cio_configuration_file_writer_type | |
| Cio_configuration_group_type | |
| Cio_configuration_inter_communication_description | |
| Cio_configuration_misc_item_type | |
| Cio_configuration_registered_monc_type | Configuration that representes the state of a registered MONC process |
| Cio_configuration_type | Overall IO configuration |
| ►Nconversions_mod | Conversion between common inbuilt FORTRAN data types |
| Cconv_is_integer | Determines whether a data item can be represented as an integer or not |
| Cconv_is_logical | Determines whether a data item can be represented as a logical or not |
| Cconv_is_real | Determines whether a data item can be represented as a real or not |
| Cconv_to_generic | Converts a data type into the generic (class *) form |
| Cconv_to_integer | Converts data types to integers |
| Cconv_to_logical | Converts data types to logical |
| Cconv_to_real | Converts data types to real |
| Cconv_to_string | Converts data types to strings |
| ►Ndef_mcc_profiles | |
| Cstr_mcc_profiles | |
| ►Ndef_merge_atm | |
| Cstr_merge_atm | |
| ►Ndef_socrates_derived_fields | |
| Cstr_socrates_derived_fields | |
| ►Ndef_socrates_options | |
| Cstr_socrates_options | |
| ►Ndef_tvd_diagnostic_terms | |
| Cstr_tvd_diagnostic_terms | |
| ►Ndiagnostic_federator_mod | This diagnostics federator will take in data fields sent from a MONC, perform operators on these as required by the diagnostics definition to produce diagnostic instantaneous fields which are then sent along to anything interested in them |
| Call_diagnostics_at_timestep_type | |
| Cdiagnostics_activity_type | |
| Cdiagnostics_at_timestep_type | |
| Cdiagnostics_type | |
| ►Ndummy_netcdf_mod | |
| Cinteger_array_wrapper_type | |
| Cnf90_def_var | |
| Cnf90_get_var | |
| Cnf90_put_var | |
| ►Nforthread_ciface_mod | |
| Ci_start_routine | |
| Cthread_alloc | |
| Cthread_atfork | |
| Cthread_attr_destroy | |
| Cthread_attr_getdetachstate | |
| Cthread_attr_getguardsize | |
| Cthread_attr_getinheritsched | |
| Cthread_attr_getschedparam | |
| Cthread_attr_getschedpolicy | |
| Cthread_attr_getscope | |
| Cthread_attr_getstacksize | |
| Cthread_attr_init | |
| Cthread_attr_setdetachstate | |
| Cthread_attr_setguardsize | |
| Cthread_attr_setinheritsched | |
| Cthread_attr_setschedparam | |
| Cthread_attr_setschedpolicy | |
| Cthread_attr_setscope | |
| Cthread_attr_setstacksize | |
| Cthread_barrier_destroy | |
| Cthread_barrier_init | |
| Cthread_barrier_wait | |
| Cthread_barrierattr_destroy | |
| Cthread_barrierattr_getpshared | |
| Cthread_barrierattr_init | |
| Cthread_barrierattr_setpshared | |
| Cthread_cancel | |
| Cthread_cond_broadcast | |
| Cthread_cond_destroy | |
| Cthread_cond_init | |
| Cthread_cond_signal | |
| Cthread_cond_timedwait | |
| Cthread_cond_wait | |
| Cthread_condattr_destroy | |
| Cthread_condattr_getclock | |
| Cthread_condattr_getpshared | |
| Cthread_condattr_init | |
| Cthread_condattr_setclock | |
| Cthread_condattr_setpshared | |
| Cthread_create | |
| Cthread_destroy | |
| Cthread_detach | |
| Cthread_equal | |
| Cthread_exit | |
| Cthread_getconcurrency | |
| Cthread_getcpuclockid | |
| Cthread_getschedparam | |
| Cthread_getspecific | |
| Cthread_init | |
| Cthread_join | |
| Cthread_key_create | |
| Cthread_key_delete | |
| Cthread_kill | |
| Cthread_mutex_destroy | |
| Cthread_mutex_getprioceiling | |
| Cthread_mutex_init | |
| Cthread_mutex_lock | |
| Cthread_mutex_setprioceiling | |
| Cthread_mutex_timedlock | |
| Cthread_mutex_trylock | |
| Cthread_mutex_unlock | |
| Cthread_mutexattr_destroy | |
| Cthread_mutexattr_getprioceiling | |
| Cthread_mutexattr_getprotocol | |
| Cthread_mutexattr_getpshared | |
| Cthread_mutexattr_gettype | |
| Cthread_mutexattr_init | |
| Cthread_mutexattr_setprioceiling | |
| Cthread_mutexattr_setprotocol | |
| Cthread_mutexattr_setpshared | |
| Cthread_mutexattr_settype | |
| Cthread_once | |
| Cthread_once_init | |
| Cthread_rwlock_destroy | |
| Cthread_rwlock_init | |
| Cthread_rwlock_rdlock | |
| Cthread_rwlock_timedrdlock | |
| Cthread_rwlock_timedwrlock | |
| Cthread_rwlock_tryrdlock | |
| Cthread_rwlock_trywrlock | |
| Cthread_rwlock_unlock | |
| Cthread_rwlock_wrlock | |
| Cthread_rwlockattr_destroy | |
| Cthread_rwlockattr_getpshared | |
| Cthread_rwlockattr_init | |
| Cthread_rwlockattr_setpshared | |
| Cthread_setcancelstate | |
| Cthread_setcanceltype | |
| Cthread_setconcurrency | |
| Cthread_setschedparam | |
| Cthread_setschedprio | |
| Cthread_setspecific | |
| Cthread_spin_destroy | |
| Cthread_spin_init | |
| Cthread_spin_lock | |
| Cthread_spin_trylock | |
| Cthread_spin_unlock | |
| ►Nforthread_data | |
| Ci_destructor | |
| Ci_once | |
| Ci_run | |
| Cptr_t_run | |
| Ct_run | |
| ►Nforthread_types | |
| Csched_param | |
| Ctimespec | |
| ►Ngrids_mod | Functionality to support the different types of grid and abstraction between global grids and local ones after decomposition |
| Cglobal_grid_type | Defines the global grid |
| Cgrid_configuration_type | Wraps the dimensional configuration types |
| Chorizontal_grid_configuration_type | The configuration of the grid horizontally |
| Clocal_grid_type | Defined the local grid, i.e. the grid held on this process after decomposition |
| Cvertical_grid_configuration_type | The configuration of the grid vertically |
| ►Nhalo_communication_mod | Provides the mechanism for halo swapping. This module contains the functionality required to determine what messages get sent where, pack data up en mass, send and receive from neighbouring processes and unpack into the appropriate data locations. There is also some functionality to help local copying of data to corresponding locations. The idea is that the caller will determine the policy (i.e. exactly what fields are to be communicated) through procedure arguments and this mechanism can be used again and again. It implements bulk sending of all field data in one large message to reduce communication overhead |
| Ccopy_corners_to_halo_buffer_proc_interface | |
| Ccopy_fields_to_halo_buffer_proc_interface | |
| Ccopy_halo_buffer_to_corner_proc_interface | |
| Ccopy_halo_buffer_to_field_proc_interface | |
| Cget_fields_per_halo_cell_proc_interface | Procedure interfaces used to determine the policy (i.e. the fields) of halo swapping and |
| Cperform_local_data_copy_proc_interface | |
| ►Ninter_io_specifics_mod | Inter IO server communication specific functionality. This manages all of the communication that might happen between different IO servers |
| Chandle_completion | |
| ►Nio_server_client_mod | This defines some constants and procedures that are useful to the IO server and clients that call it. By using the contents then the client can guarantee consistency against what the server expects |
| Cdata_sizing_description_type | |
| Cdefinition_description_type | |
| Cfield_description_type | |
| ►Nio_server_state_reader_mod | Reads the IO server state that was stored in a NetCDF checkpoint file |
| Cnc_get_vara_long | ISO C binding for NetCDF get long scalar variable, required for retrieving long variables |
| Cnc_get_vars_text | ISO C binding for NetCDF get text vars, required for 64 bit start, count & stride |
| Cnc_inq_dim | ISO C binding for NetCDF inquire dimension, required for 64 bit dimension length |
| Cwriter_field_manager_unserialise_state | |
| ►Nio_server_state_writer_mod | The IO server state module which will write out the current state of the IO server to a NetCDF file |
| Cnc_def_dim | ISO C binding interface for NetCDF dimension definition, needed to support 64 bit lengths |
| Cnc_def_var | ISO C binding interface for NetCDF define variable, needed to support defining a long scalar variable |
| Cnc_put_var1_long | ISO C binding interface for NetCDF put long scalar, needed to support putting longs into file |
| Cnc_put_vars_text | ISO C binding interface for NetCDF put variable text, needed to support 64 bit starts, counts and strides |
| Cwrite_field_manager_determine_if_up_to_date | |
| Cwriter_field_manager_prepare_to_serialise_state | |
| Cwriter_field_manager_serialise_state | |
| ►Niobridge_mod | Bridge between MONC and the IO server, this registers the current MONC process, will issue data dumps and deregister MONCs when the model run is completed |
| Cio_configuration_data_definition_type | |
| Cio_configuration_field_type | |
| Cio_server_sendable_field_sizing | |
| ►Niterativesolver_mod | This is the iterative pressure solver and uses a Jacobi preconditioned BiCGStab which we implement here |
| Cmatrix_type | A helper type to abstract the concrete details of the matrix |
| ►Nmonc_component_mod | Interfaces and types that MONC components must specify |
| Ccomponent_descriptor_type | Description of a component |
| Ccomponent_field_information_type | |
| Ccomponent_field_value_type | Wrapper type for the value returned for a published field from a component |
| Ccomponent_finalisation | Component finalisation callback hook signature |
| Ccomponent_get_description | Interface defining the signature of each callback hook that a component may specify |
| Ccomponent_get_field_information | |
| Ccomponent_get_field_value | Retrieves a specific published field value from a component |
| Ccomponent_initialisation | Component initialisation callback hook signature |
| Ccomponent_timestep | Component timestep callback hook signature |
| ►Nmonc_mod | Main core entry point to the rest of the model, this is called by the program main |
| Cio_server_run_procedure | IO server entry procedure which may be passed to the core entry point (if IO server is enabled) |
| ►Nmpi_communication_mod | Abstraction layer around MPI, this issues and marshals the lower level communication details |
| Cusleep | |
| ►Noperator_mod | Operator federator which manages the different operators which are available. Operators take in any number of scalar reals and output a single scalar real |
| Cget_operator_required_fields_interface | |
| Cperform_activity | |
| ►Noptionsdatabase_mod | Manages the options database. Contains administration functions and deduce runtime options from the command line |
| Coptions_add | Generic add interface for adding different types of data to the databases |
| ►Npencil_fft_mod | This Pencil FFT performs 3D forward and backwards FFTs using pencil decomposition. It uses FFTW for the actual FFT kernel and this module contains all the data decomposition around this. There is no FFT required in Z, so this performs FFTs in Y and X (in that order forward and reversed backwards.) The data decomposition is the complex aspect, there is the concept of forward and backwards transformations. Forward transformations will go from pencil Z to Y to X and the backwards transformations undo these, so go from X to Y to Z. Note that we use quite a lot of buffer space here, this could be cut down if Y=X dimensions so some optimisation on memory could be done there in that case |
| Cpencil_transposition | Describes a specific pencil transposition, from one pencil decomposition to another |
| ►Nprognostics_mod | Contains prognostic field definitions and functions |
| Cprognostic_field_ptr_type | A pointer to the prognostic field. This is so we can wrap prognostics up in an array and still refer to the origonal field rather than a copy |
| Cprognostic_field_type | A prognostic field which is assumed to be 3D |
| ►Nq_indices_mod | This manages the Q variables and specifically the mapping between names and the index that they are stored at |
| Cq_metadata_type | |
| Cstandard_q_names_type | |
| ►Nreduction_inter_io_mod | Reduction inter IO action which will perform reductions between IO servers. This is not as trivial as calling the MPI function as it is nondeterministic when messages will arrive and hence when one reduction on a process and a reduction on another should be called |
| Creduction_progress_type | |
| ►Nregistry_mod | MONC component registry |
| Cgroup_descriptor_type | Descriptor of a group |
| Cpointer_wrapper_type | Private helper type which wraps a procedure pointer. This is needed for storage in our collections_mod and allows us to associate additional information, such as number of times called, performance etc in future if we wanted to |
| ►Nsax_xml_parser_mod | A SAX parser for XML files. This is used to parse the description of the data and rules. Being a SAX parser it works in a callback fashion, as these often do, and will call the start and end subroutines along with tag details. It still requires some additional stability work to handle ill formatted XML and error checking |
| Cend_element_callback_interface | The end element callback interface (on closing of XML tag, this is not called if an opening tag self closes) |
| Cstart_element_callback_interface | The start element callback interface (on opening of XML tag) |
| ►Nstate_mod | The model state which represents the current state of a run |
| Cmodel_state_type | The ModelState which represents the current state of a run |
| Cparallel_state_type | Information about the parallel aspects of the system |
| ►Nstencil_mod | Performs the interpolation between the primal and dual grids via a stencil approach. For performance reasons, for each field we store the entirety of the y dimension and the number of x slices required by the stencil. Therefore a new interpolation is simply the calculation of one point and reuse of existing computed points (unless this is the first x or y.) The applicable interpolation stenciled data is copied out, with :,1,1 being the central point, minus and plus in each y and x dimension as determined by the stencil size. This is done so that the stencil size can easily be different for each flow field and this is the case with u (where we need u-2 in the X.) |
| Cgrid_stencil_type | Configuration for a specific stencil interpolation to perform |
| ►Nthreadpool_mod | This is a thread pool and the single management "main" thread will spawn out free threads in the pool to perform specific work. If there are no free threads then it will block until one becomes available. It uses ForThreads, which is a wrapper around pthreads. The thread pool works by creating a number of threads and then passing the work to these threads, rather than creating a new thread for each piece of work |
| Cthread_procedure | The thread call procedure interface |
| Cthreaded_procedure_container_type | Wraps the thread procedure with the call itself and the data to pass to it |
| ►Ntimeaveraged_time_manipulation_mod | Performs time averaged, time manipulation and only returns a value if the output frequency determines one should be |
| Ctime_averaged_completed_type | The completed time averaged values |
| ►Nwriter_field_manager_mod | The writer field manager will manage aspects of the fields being provided to the writer federator. There are two major aspects to this, firstly extraction of fields from the data sent directly from MONC and then passed on if these fields are needed. Secondly, this will queue up the data to ensure that it is sent to the writer federator in strict order and that only one piece of a fields data is in the writer federator at any one time |
| Cfield_ordering_type | |
| Cfield_ordering_value_type | |
| Cprovide_field_to_writer_federator | |
| ►Nwriter_types_mod | Writer types which are shared across writing functionality. Also includes serialisation functionality for these types |
| Ccollective_q_field_representation_type | |
| Cnetcdf_diagnostics_timeseries_type | |
| Cnetcdf_diagnostics_type | |
| Cpending_write_type | |
| Cwrite_field_collective_descriptor_type | |
| Cwrite_field_collective_monc_info_type | |
| Cwrite_field_collective_values_type | |
| Cwriter_field_type | |
| Cwriter_type | |
