Data of OpenQP - Open-Quantum-Platform/openqp GitHub Wiki

Combining high-performance compiled languages with the flexible Python environment provides an ideal framework but introduces challenges in data sharing across multiple languages. To address this, successful modularization relies on data abstraction—a fundamental concept that hides the complexities of data storage and processing, presenting only essential information in a simplified manner to the user.

To tackle this challenge, we first define a structured data type, information, which encompasses all the fundamental scalar data needed by OpenQP. The Fortran definition of information is shown below, where each element is also a structured data type. This information is initially allocated in the Python layer as mol, as depicted in Fig. below. Instead of passing individual data through arguments, its handler is passed to Fortran via the C API. By using a single structured data type, mol, the complexities of data exchange are minimized, thereby simplifying workflow extension. With this handler, the Fortran layer can directly read from and write to mol. Consequently, the calculation results from Fortran modules are saved in mol, making them immediately accessible from the Python environment without needing to pass data through a sequence of arguments.

The derived information type is defined in source/types.F90 as follows:

type, public :: information
    type(molecule) :: mol_prop
    type(energy_results) :: mol_energy
    type(dft_parameters) :: dft
    type(control_parameters) :: control
    type(atomic_structure) :: atoms
    type(functional_t) :: functional
    type(tddft_parameters) :: tddft
    type(container_t) :: dat
    type(basis_set) :: basis
contains
    generic :: set_atoms => set_atoms_arr, set_atoms_atm
    procedure, pass :: set_atoms_arr => info_set_atoms_arr
    procedure, pass :: set_atoms_atm => info_set_atoms_atm
end type information

Certain components of the derived information type are accessible through the C API under the name oqp_handle_t, which is defined in include/oqp.h as follows:

typedef struct oqp_handle_t {
    void *inf;
    xyz_t *xyz;
    double *qn;
    double *mass;
    xyz_t *grad;
    struct molecule *mol_prop;
    struct energy_results *mol_energy;
    struct dft_parameters *dft;
    struct tddft_parameters *tddft;
    struct control_parameters *control;
} oqp_handle_t;

While most of the data involved are relatively small and can be defined using static memory, certain critical intermediate quantities—such as the Fock matrix—require dynamic memory allocation. Moreover, it is essential that this dynamically allocated data be transparently accessible across all layers of OpenQP, ensuring bidirectional access between Python and Fortran environments.

To facilitate seamless data access and interoperability between Python and Fortran, a separate tool named tagarray has been developed. This tool allows for the efficient handling and exchange of dynamically allocated data between different layers and languages within OpenQP.

Going back to Developer Documentation