Allow for dynamically determining JSON schema of input (grimme-lab#96)

- all JSON formats are available with `json` extension, the `read_json`
  procedure dispatches to the format specific readers based on the schema
  information in the JSON file
- update README to list all formats supported in mctc-lib

Author: awvwgk

README.md

@@ -7,6 +7,47 @@
 [![codecov](https://codecov.io/gh/grimme-lab/mctc-lib/branch/main/graph/badge.svg)](https://codecov.io/gh/grimme-lab/mctc-lib)
 
 
+## Supported formats
+
+This library supports reading and writing in more than ten different geometry formats, including general ASCII formats, like xyz, JSON based formats, like QCSchema, and program specific formats, for example compatible with Turbomole or Vasp.
+
+*General geometry formats*
+
+- [xyz][xyz] file format with ``xyz`` extension
+- [Protein data base][pdb] file format with ``pdb`` extension
+- [mol][ctfile] and [structure data][ctfile] connection table file formats with ``mol`` and ``sdf`` extension, respectively
+
+[xyz]: http://www.ccl.net/chemistry/resources/messages/1996/10/21.005-dir/index.html
+[pdb]: http://www.wwpdb.org/documentation/file-format-content/format33/v3.3.html
+[ctfile]: https://www.daylight.com/meetings/mug05/Kappler/ctfile.pdf
+
+*JSON based formats*
+
+- [Pymatgen JSON][pmg] with ``pmgjson`` or ``json`` extension
+- [QCSchema JSON][qcsk] with ``qcjson`` or ``json`` extension
+- [Chemical JSON][cjson] with ``cjson`` or ``json`` extension
+
+[pmg]: https://pymatgen.org
+[qcsk]: https://molssi-qc-schema.readthedocs.io
+[cjson]: https://github.com/OpenChemistry/avogadrolibs/blob/master/avogadro/io/cjsonformat.cpp
+
+*Program specific formats*
+
+- [Q-Chem molecule][qchem] file format with ``qchem`` extension
+- [Turbomole coord][tmol] file format with ``tmol`` or ``coord`` extension
+- [VASP POSCAR and CONTCAR][vasp] files with ``vasp``, ``poscar``, or ``contcar`` extension
+- [DFTB+ gen][gen] format with ``gen`` extension
+- [Gaussian external][ein] format with ``ein`` extension
+- [FHI-aims][aims] ``geometry.in`` input files
+
+[aims]: https://fhi-aims.org
+[qchem]: https://manual.q-chem.com
+[tmol]: https://www.turbomole.org
+[gen]: https://dftbplus.org
+[ein]: https://gaussian.com/external/
+[vasp]: https://www.vasp.at/wiki/index.php
+
+
 ## Installation
 
 To build this project from the source code in this repository you need to have

doc/format-cjson.md

@@ -6,7 +6,7 @@ title: Chemical JSON
 
 @Note [Reference](https://github.com/OpenChemistry/avogadrolibs/blob/master/avogadro/io/cjsonformat.cpp)
 
-Chemical JSON files are identified by the extension ``cjson`` and parsed following the format implemented in Avogadro 2.
+Chemical JSON files are identified by the extension ``cjson`` or ``json`` and parsed following the format implemented in Avogadro 2.
 The entries *name*, *atoms.elements.number*, *atoms.coords.3d*, *atoms.coords.3d fractional*, *unit cell*, *atoms.formalCharges*, *bonds.connections.index*, and *bonds.order* are recognized by the reader.
 
 

doc/format-pymatgen.md

@@ -6,7 +6,7 @@ title: Pymatgen JSON
 
 @Note [Reference](https://pymatgen.org)
 
-Pymatgen formatted JSON files are identified by the extension ``pmgjson`` and parsed following the ``Molecule`` or ``Structure`` format.
+Pymatgen formatted JSON files are identified by the extension ``pmgjson`` or ``json`` and parsed following the ``Molecule`` or ``Structure`` format.
 
 
 ## Example

doc/format-qcschema.md

@@ -6,7 +6,7 @@ title: QCSchema JSON
 
 @Note [Reference](https://molssi-qc-schema.readthedocs.io)
 
-JSON files are identified by the extension ``json`` and parsed following the ``qcschema_molecule`` or ``qcschema_input`` format.
+JSON files are identified by the extension ``qcjson`` or ``json`` and parsed following the ``qcschema_molecule`` or ``qcschema_input`` format.
 The ``molecule`` entry from a ``qcschema_input`` will be extracted, but there is no guarantee that the input information will be used by the program.
 
 

man/mctc-convert.1.adoc

@@ -26,9 +26,9 @@ Supported formats:
 - Protein Database files, only single files (pdb)
 - Connection table files, molfile (mol) and structure data format (sdf)
 - Gaussian's external program input (ein)
-- JSON input with `qcschema_molecule` or `qcschema_input` structure (json)
-- Chemical JSON input (cjson)
-- Pymatgen JSON with `Molecule` or `Structure` schema (pmgjson)
+- JSON input with `qcschema_molecule` or `qcschema_input` structure (qcjson, json)
+- Chemical JSON input (cjson, json)
+- Pymatgen JSON with `Molecule` or `Structure` schema (pmgjson, json)
 - FHI-AIMS' input files (geometry.in)
 - Q-Chem molecule block inputs (qchem)
 

src/mctc/io/filetype.f90

@@ -66,6 +66,9 @@ module mctc_io_filetype
       !> Pymatgen JSON format
       integer :: pymatgen = 13
 
+      !> General JSON format
+      integer :: json = 14
+
    end type enum_filetype
 
    !> File type enumerator
@@ -107,14 +110,16 @@ elemental function get_filetype(file) result(ftype)
          ftype = filetype%gen
       case('ein')
          ftype = filetype%gaussian
-      case('json')
+      case('qcjson')
          ftype = filetype%qcschema
       case('cjson')
          ftype = filetype%cjson
       case('qchem')
          ftype = filetype%qchem
       case('pmgjson')
          ftype = filetype%pymatgen
+      case('json')
+         ftype = filetype%json
       end select
       if (ftype /= filetype%unknown) return
    else

src/mctc/io/read.f90

@@ -20,6 +20,7 @@ module mctc_io_read
    use mctc_io_read_ctfile, only : read_molfile, read_sdf
    use mctc_io_read_gaussian, only : read_gaussian_external
    use mctc_io_read_genformat, only : read_genformat
+   use mctc_io_read_json, only : read_json
    use mctc_io_read_qchem, only : read_qchem
    use mctc_io_read_qcschema, only : read_qcschema
    use mctc_io_read_pdb, only : read_pdb
@@ -181,6 +182,9 @@ subroutine get_structure_reader(reader, ftype)
    case(filetype%qchem)
       reader => read_qchem
 
+   case(filetype%json)
+      reader => read_json
+
    end select
 
 end subroutine get_structure_reader

src/mctc/io/read/CMakeLists.txt

@@ -21,6 +21,7 @@ list(
   "${dir}/ctfile.f90"
   "${dir}/gaussian.f90"
   "${dir}/genformat.f90"
+  "${dir}/json.F90"
   "${dir}/qchem.f90"
   "${dir}/qcschema.F90"
   "${dir}/pdb.f90"

src/mctc/io/read/cjson.F90

@@ -32,6 +32,13 @@ module mctc_io_read_cjson
 
    public :: read_cjson
 
+#if WITH_JSON
+   interface read_cjson
+      module procedure read_cjson
+      module procedure load_cjson
+   end interface read_cjson
+#endif
+
 
 contains
 
@@ -49,22 +56,10 @@ subroutine read_cjson(self, unit, error)
 
 #if WITH_JSON
    class(json_value), allocatable :: root
-   type(json_object), pointer :: object, child, child2
-   type(json_array), pointer :: array, child_array
-   type(json_keyval), pointer :: val
+   type(json_object), pointer :: object
    type(json_error), allocatable :: parse_error
    type(json_context) :: ctx
 
-   logical :: cartesian, found
-   integer :: stat, origin, schema_version, charge, multiplicity, ibond
-   integer :: origin_elements, origin_coords
-   character(len=:), allocatable :: input, line, message, comment
-   integer, allocatable :: num(:), bond(:, :), list(:), order(:)
-   real(wp) :: cellpar(6)
-   real(wp), allocatable :: lattice(:, :)
-   real(wp), allocatable, target :: geo(:)
-   real(wp), pointer :: xyz(:, :)
-
    call json_load(root, unit, config=json_parser_config(context_detail=1), &
       & context=ctx, error=parse_error)
    if (allocated(parse_error)) then
@@ -78,6 +73,42 @@ subroutine read_cjson(self, unit, error)
       return
    end if
 
+   call load_cjson(self, object, ctx, error)
+#else
+   call fatal_error(error, "JSON support not enabled")
+#endif
+end subroutine read_cjson
+
+
+#if WITH_JSON
+subroutine load_cjson(self, object, ctx, error)
+
+   !> Instance of the molecular structure data
+   type(structure_type), intent(out) :: self
+
+   !> JSON object representing the structure
+   type(json_object), intent(inout) :: object
+
+   !> JSON context for error reporting
+   type(json_context), intent(inout) :: ctx
+
+   !> Error handling
+   type(error_type), allocatable, intent(out) :: error
+
+   type(json_object), pointer :: child, child2
+   type(json_array), pointer :: array, child_array
+   type(json_keyval), pointer :: val
+
+   logical :: cartesian, found
+   integer :: stat, origin, schema_version, charge, multiplicity, ibond
+   integer :: origin_elements, origin_coords
+   character(len=:), allocatable :: input, line, message, comment
+   integer, allocatable :: num(:), bond(:, :), list(:), order(:)
+   real(wp) :: cellpar(6)
+   real(wp), allocatable :: lattice(:, :)
+   real(wp), allocatable, target :: geo(:)
+   real(wp), pointer :: xyz(:, :)
+
    call cjson_get_value(object, "chemicalJson", "chemical json", val, stat=stat, origin=origin)
    if (.not.associated(val) .or. stat /= json_stat%success) then
       call fatal_error(error, ctx%report("Could find chemical json", origin))
@@ -247,10 +278,8 @@ subroutine read_cjson(self, unit, error)
       call move_alloc(bond, self%bond)
    end if
 
-#else
-   call fatal_error(error, "JSON support not enabled")
+end subroutine load_cjson
 #endif
-end subroutine read_cjson
 
 #if WITH_JSON
 subroutine cjson_get_child(object, key1, key2, child, stat, origin)

src/mctc/io/read/json.F90

@@ -0,0 +1,96 @@
+! This file is part of mctc-lib.
+!
+! Licensed under the Apache License, Version 2.0 (the "License");
+! you may not use this file except in compliance with the License.
+! You may obtain a copy of the License at
+!
+!     http://www.apache.org/licenses/LICENSE-2.0
+!
+! Unless required by applicable law or agreed to in writing, software
+! distributed under the License is distributed on an "AS IS" BASIS,
+! WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+! See the License for the specific language governing permissions and
+! limitations under the License.
+
+#include "mctc/defs.h"
+
+module mctc_io_read_json
+   use mctc_env_accuracy, only : wp
+   use mctc_env_error, only : error_type, fatal_error
+   use mctc_io_structure, only : structure_type, new
+   use mctc_io_symbols, only : to_number, symbol_length
+   use mctc_io_utils, only : to_string
+   use mctc_io_read_cjson, only : read_cjson
+   use mctc_io_read_qcschema, only : read_qcschema
+   use mctc_io_read_pymatgen, only : read_pymatgen
+#if WITH_JSON
+   use jonquil, only : json_value, json_object, json_array, json_keyval, &
+      & json_load, json_error, json_context, json_stat, get_value, &
+      & json_parser_config, json_context, cast_to_object, len
+#endif
+   implicit none
+   private
+
+   public :: read_json
+
+
+contains
+
+
+subroutine read_json(self, unit, error)
+
+   !> Instance of the molecular structure data
+   type(structure_type), intent(out) :: self
+
+   !> File handle
+   integer, intent(in) :: unit
+
+   !> Error handling
+   type(error_type), allocatable, intent(out) :: error
+
+#if WITH_JSON
+   class(json_value), allocatable :: root
+   type(json_object), pointer :: object
+   type(json_error), allocatable :: parse_error
+   type(json_context) :: ctx
+
+   call json_load(root, unit, config=json_parser_config(context_detail=1), &
+      & context=ctx, error=parse_error)
+   if (allocated(parse_error)) then
+      allocate(error)
+      call move_alloc(parse_error%message, error%message)
+      return
+   end if
+   object => cast_to_object(root)
+   if (.not.associated(object)) then
+      call fatal_error(error, ctx%report("Invalid JSON object", root%origin, "Expected JSON object"))
+      return
+   end if
+
+   ! QCSchema JSON uses "schema_name" and "schema_version" keys
+   if (object%has_key("schema_name") .or. object%has_key("schema_version")) then
+      call read_qcschema(self, object, ctx, error)
+      return
+   end if
+
+   ! Pymatgen serialized via monty adds "@module" and "@class" keys
+   if (object%has_key("@module") .or. object%has_key("@class")) then
+      call read_pymatgen(self, object, ctx, error)
+      return
+   end if
+
+   ! Chemical JSON (cjson) tracks version via "chemical json" or "chemicalJson" keys
+   if (object%has_key("chemical json") .or. object%has_key("chemicalJson")) then
+      call read_cjson(self, object, ctx, error)
+      return
+   end if
+
+   ! Default to QCSchema if no specific schema is detected
+   call read_qcschema(self, object, ctx, error)
+#else
+   call fatal_error(error, "JSON support not enabled")
+#endif
+end subroutine read_json
+
+
+end module mctc_io_read_json