Program input/output file

Input schema

"input": {
  "schema_name": string,                     # Name of the input schema
  "schema_version": int,                     # Version of the input schema
  "molecule": {                              # Section for Molecule specification
    "charge": int,                           # Total molecular charge
    "multiplicity": int                      # Total spin multiplicity
    "coords": array[                         # Array of atoms
      {                                      # (one entry per atom)
        "atom": string,                      # Atomic symbol
        "xyz": array[float]                  # Nuclear Cartesian coordinate
      }                                      
    ],                                       
  },                                         
  "mpi": {                                   # Section for MPI specification
    "bank_size": int,                        # Number of MPI ranks in memory bank
    "numerically_exact": bool,               # Guarantee MPI invariant results
    "shared_memory_size": int                # Size (MB) of MPI shared memory blocks
  },                                         
  "mra": {                                   # Section for MultiResolution Analysis
    "basis_type": string,                    # Basis type (interpolating/legendre)
    "basis_order": int,                      # Polynomial order of basis
    "max_scale": int,                        # Maximum level of refinement
    "min_scale": int,                        # Minimum level of refinement (root scale)
    "boxes": array[int],                     # Number of root boxes
    "corner": array[int]                     # Translation of first root box
  },                                         
  "printer": {                               # Section for printed output
    "file_name": string,                     # Name of output file
    "print_level": int,                      # Amount of printed output
    "print_mpi": bool,                       # Use separate output file for each MPI
    "print_prec": int,                       # Number of digits for printed output
    "print_width": int                       # Line width of printed output
  },                                         
  "scf_calculation": {                       # Section for SCF specification
    "fock_operator": {                       # Contributions to Fock operator
      "kinetic_operator": {                  # Add Kinetic operator to Fock
        "derivative": string                 # Type of derivative operator
      },                                     
      "nuclear_operator": {                  # Add Nuclear operator to Fock
        "proj_prec": float,                  # Projection prec for potential
        "smooth_prec": float,                # Smoothing parameter for potential
        "shared_memory": bool                # Use shared memory for potential
      },                                     
      "coulomb_operator": {                  # Add Coulomb operator to Fock
        "poisson_prec": float,               # Build prec for Poisson operator
        "shared_memory": bool                # Use shared memory for potential
      },                                     
      "exchange_operator": {                 # Add Exchange operator to Fock
        "poisson_prec": float,               # Build prec for Poisson operator
        "screen": bool                       # Use screening in Exchange operator
      },                                     
      "xc_operator": {                       # Add XC operator to Fock
        "shared_memory": bool,               # Use shared memory for potential
        "xc_functional": {                   # XC functional specification
          "spin": bool,                      # Use spin separated functional
          "cutoff": float,                   # Cutoff value for small densities
          "functionals": array[              # Array of density functionals
            {                                
              "coef": float,                 # Numerical coefficient
              "name": string                 # Functional name
            }                                
          ]                                  
        }                                    
      },                                     
      "external_operator": {                 # Add external field operator to Fock
        "electric_field": array[float],      # Electric field vector
        "r_O": array[float]                  # Gauge orgigin for electric field
      }                                      
    },                                       
    "initial_guess": {                       # Initial guess specification
      "type": string,                        # Type of initial guess
      "prec": float,                         # Precision for initial guess
      "zeta": int,                           # Zeta quality for AO basis
      "method": string,                      # Name of method for initial energy
      "localize": bool,                      # Use localized orbitals
      "restricted": bool,                    # Use spin restricted orbitals
      "file_chk": string,                    # Path to checkpoint file
      "file_basis": string,                  # Path to GTO basis file
      "file_gto_a": string,                  # Path to GTO MO file (alpha)
      "file_gto_b": string,                  # Path to GTO MO file (beta)
      "file_gto_p": string,                  # Path to GTO MO file (paired)
      "file_phi_a": string,                  # Path to MW orbital file (alpha)
      "file_phi_b": string,                  # Path to MW orbital file (beta)
      "file_phi_p": string                   # Path to MW orbital file (paired)
    },                                       
    "scf_solver": {                          # SCF solver specification
      "kain": int,                           # Length of KAIN history
      "max_iter": int,                       # Maximum number of iterations
      "method": string,                      # Name of electronic structure method
      "rotation": int,                       # Iterations between localize/diagonalize
      "localize": bool,                      # Use localized orbitals
      "checkpoint": bool,                    # Save checkpoint file
      "file_chk": string,                    # Name of checkpoint file
      "start_prec": float,                   # Start precision for solver
      "final_prec": float,                   # Final precision for solver
      "helmholtz_prec": float,               # Precision for Helmholtz operators
      "orbital_thrs": float,                 # Convergence threshold orbitals
      "energy_thrs":float,                   # Convergence threshold energy
    },                                       
    "properties": {                          # Collection of properties to compute
      "dipole_moment": {                     # Collection of dipole moments
        id (string): {                       # Unique id: 'dip-${number}'
          "precision": float,                # Operator precision
          "operator": string,                # Operator used for property
          "r_O": array[float]                # Operator gauge origin
        }                                    
      },                                     
      "quadrupole_moment": {                 # Collection of quadrupole moments
        id (string): {                       # Unique id: 'quad-${number}'
          "precision": float,                # Operator precision
          "operator": string,                # Operator used for property
          "r_O": array[float]                # Operator gauge origin
        }                                    
      },
      "geometric_derivative": {              # Collection of geometric derivatives
        id (string): {                       # Unique id: 'geom-${number}'
          "precision": float,                # Operator precision
          "operator": string,                # Operator used for property
          "smooth_prec": float               # Smoothing parameter for potential
        }
      }
    },
    "plots": {                               # Collection of plots to perform
      "density": bool,                       # Plot converged densities
      "orbitals": array[int],                # List of orbitals to plot
      "plotter": {                           # Section specifying plotting parameters
        "path": string,                      # Path to output files
        "type": string,                      # Type of plot (line, surf or cube)
        "points": array[int],                # Number of points in each direction
        "O": array[float],                   # Plotting range origin
        "A": array[float],                   # Plotting range A vector
        "B": array[float],                   # Plotting range B vector
        "C": array[float]                    # Plotting range C vector
    }
  },                                         
  "rsp_calculations": {                      # Collection of response calculations
    id (string): {                           # Response id: e.g. 'ext_el-${frequency}'
      "dynamic": bool,                       # Use dynamic response solver
      "frequency": float,                    # Perturbation frequency
      "perturbation": {                      # Perturbation operator
        "operator": string                   # Operator used in response calculation
      },                                     
      "components": array[                   # Array of perturbation components
        {                                    # (one per Cartesian direction)
          "initial_guess": {                 # Initial guess specification
            "type": string,                  # Type of initial guess
            "prec": float,                   # Precision for initial guess
            "file_chk_x": string,            # Path to checkpoint file for X
            "file_chk_y": string,            # Path to checkpoint file for Y
            "file_x_a": string,              # Path to MW file for X (alpha)
            "file_x_b": string,              # Path to MW file for X (beta)
            "file_x_p": string,              # Path to MW file for X (paired)
            "file_y_a": string,              # Path to MW file for Y (alpha)
            "file_y_b": string,              # Path to MW file for Y (beta)
            "file_y_p": string               # Path to MW file for Y (paired)
          },                                 
          "rsp_solver": {                    # Response solver specification
            "kain": int,                     # Length of KAIN history
            "max_iter": int,                 # Maximum number of iterations
            "method": string,                # Name of electronic structure method
            "checkpoint": bool,              # Save checkpoint file
            "file_chk_x": string,            # Name of X checkpoint file
            "file_chk_y": string,            # Name of Y checkpoint file
            "orth_prec": float,              # Precision for orthogonalization
            "start_prec": float,             # Start precision for solver
            "final_prec": float,             # Final precision for solver
            "helmholtz_prec": float,         # Precision for Helmholtz operators
            "orbital_thrs": float,           # Convergence threshold orbitals
            "property_thrs": float           # Convergence threshold property
          }                                  
        }                                    
      ],                                     
      "properties": {                        # Collection of properties to compute
        "polarizability": {                  # Collection of polarizabilities
           id (string): {                    # Unique id: 'pol-${frequency}'
            "precision": float,              # Operator precision
            "operator": string,              # Operator used for property
            "r_O": array[float]              # Operator gauge origin
          }                                  
        },                                   
        "magnetizability": {                 # Collection of magnetizabilities
          id (string): {                     # Unique id: 'mag-${frequency}'
            "frequency": float,              # Perturbation frequency
            "precision": float,              # Operator precision
            "dia_operator": string,          # Operator used for diamagnetic property
            "para_operator": string,         # Operator used for paramagnetic property
            "derivative": string,            # Operator derivative type
            "r_O": array[float]              # Operator gauge origin
          }                                  
        },                                   
        "nmr_shielding": {                   # Collection of NMR shieldings
          id (string): {                     # Unique id: 'nmr-${nuc_idx}${atom_symbol}'
            "precision": float,              # Operator precision
            "dia_operator": string,          # Operator used for diamagnetic property
            "para_operator": string,         # Operator used for paramagnetic property
            "derivative": string,            # Operator derivative type
            "smoothing": float,              # Operator smoothing parameter
            "r_O": array[float],             # Operator gauge origin
            "r_K": array[float]              # Nuclear coordinate
          }                                  
        }                                    
      },                                     
      "fock_operator": {                     # Contributions to perturbed Fock operator
        "coulomb_operator": {                # Add Coulomb operator to Fock
          "poisson_prec": float,             # Build prec for Poisson operator
          "shared_memory": bool              # Use shared memory for potential
        },                                   
        "exchange_operator": {               # Add Exchange operator to Fock
          "poisson_prec": float,             # Build prec for Poisson operator
          "screen": bool                     # Use screening in Exchange operator
        },                                   
        "xc_operator": {                     # Add XC operator to Fock
          "shared_memory": bool,             # Use shared memory for potential
          "xc_functional": {                 # XC functional specification
            "spin": bool,                    # Use spin separated functional
            "cutoff": float,                 # Cutoff value for small densities
            "functionals": array[            # Array of density functionals
              {                              
                "coef": float,               # Numerical coefficient
                "name": string               # Functional name
              }
            ]
          }
        }
      },
      "unperturbed": {                       # Section for unperturbed part of response
        "prec": float,                       # Precision used for unperturbed system
        "localize": bool,                    # Use localized unperturbed orbitals
        "fock_operator": {                   # Contributions to unperturbed Fock operator
          "kinetic_operator": {              # Add Kinetic operator to Fock
            "derivative": string             # Type of derivative operator
          },
          "nuclear_operator": {              # Add Nuclear operator to Fock
            "proj_prec": float,              # Projection prec for potential
            "smooth_prec": float,            # Smoothing parameter for potential
            "shared_memory": bool            # Use shared memory for potential
          },
          "coulomb_operator": {              # Add Coulomb operator to Fock
            "poisson_prec": float,           # Build prec for Poisson operator
            "shared_memory": bool            # Use shared memory for potential
          },
          "exchange_operator": {             # Add Exchange operator to Fock
            "poisson_prec": float,           # Build prec for Poisson operator
            "screen": bool                   # Use screening in Exchange operator
          },
          "xc_operator": {                   # Add XC operator to Fock
            "shared_memory": bool,           # Use shared memory for potential
            "xc_functional": {               # XC functional specification
              "spin": bool,                  # Use spin separated functional
              "cutoff": float,               # Cutoff value for small densities
              "functionals": array[          # Array of density functionals
                {
                  "coef": float,             # Numerical coefficient
                  "name": string             # Functional name
                }
              ]
            }
          },
          "external_operator": {             # Add external field operator to Fock
            "electric_field": array[float],  # Electric field vector
            "r_O": array[float]              # Gauge orgigin for electric field
          }
        }
      }
    }
  }
}

Output schema

"output": {
  "success": bool,                           # Whether all requested calculations succeeded
  "schema_name": string,                     # Name of the output schema
  "schema_version": int,                     # Version of the output schema
  "provenance": {                            # Information on how the results were obtained
    "creator": string,                       # Program name
    "version": string,                       # Program version
    "nthreads": int,                         # Number of OpenMP threads used
    "mpi_processes": int,                    # Number of MPI processes used
    "total_cores": int,                      # Total number of cores used
    "routine": string                        # The function that generated the output
  },
  "properties": {                            # Collection of final properties
    "charge": int,                           # Total molecular charge
    "multiplicity": int,                     # Total spin multiplicity
    "center_of_mass": array[float],          # Center of mass coordinate
    "geometry": array[                       # Array of atoms
      {                                      # (one entry per atom)
        "symbol": string,                    # Atomic symbol
        "xyz": array[float]                  # Cartesian coordinate
      }
    ],
    "orbital_energies": {                    # Collection of orbital energies
      "spin": array[string],                 # Array of spins ('p', 'a' or 'b')
      "energy": array[float],                # Array of energies
      "occupation": array[int],              # Array of orbital occupations
      "sum_occupied": float                  # \sum_i occupation[i]*energy[i]
    },
    "scf_energy": {                          # Collection of energy contributions
      "E_kin": float,                        # Kinetic energy
      "E_nn": float,                         # Classical nuclear-nuclear interaction
      "E_en": float,                         # Classical electron-nuclear interaction
      "E_ee": float,                         # Classical electron-electron interaction
      "E_next": float,                       # Classical nuclear-external field interaction
      "E_eext": float,                       # Classical electron-external field interaction
      "E_x": float,                          # Hartree-Fock exact exchange energy
      "E_xc": float,                         # DFT exchange-correlation energy
      "E_el": float,                         # Sum of electronic contributions
      "E_nuc": float,                        # Sum of nuclear contributions
      "E_tot": float                         # Sum of all contributions
    },
    "dipole_moment": {                       # Collection of electric dipole moments
      id (string): {                         # Unique id: 'dip-${number}'
        "r_O": array[float],                 # Gauge origin vector
        "vector": array[float],              # Total dipole vector
        "vector_el": array[float],           # Electronic dipole vector
        "vector_nuc": array[float],          # Nuclear dipole vector
        "magnitude": float                   # Magnitude of total vector
      }
    },
    "quadrupole_moment": {                   # Collection of electric quadrupole moments
      id (string): {                         # Unique id: 'quad-${number}'
        "r_O": array[float],                 # Gauge origin vector
        "tensor": array[float],              # Total quadrupole tensor
        "tensor_el": array[float],           # Electronic quadrupole tensor
        "tensor_nuc": array[float]           # Nuclear quadrupole tensor
      }
    },
    "polarizability": {                      # Collection of polarizabilities
      id (string): {                         # Unique id: 'pol-${frequency}'
        "frequency": float,                  # Perturbation frequency
        "r_O": array[float],                 # Gauge origin vector
        "tensor": array[float],              # Full polarizability tensor
        "isotropic_average": float           # Diagonal average
      }
    },
    "magnetizability": {                     # Collection of magnetizability
      id (string): {                         # Unique id: 'mag-${frequency}'
        "frequency": float,                  # Perturbation frequency
        "r_O": array[float],                 # Gauge origin vector
        "tensor": array[float],              # Full magnetizability tensor
        "tensor_dia": array[float],          # Diamagnetic tensor
        "tensor_para": array[float],         # Paramagnetic tensor
        "isotropic_average": float           # Diagonal average
      }
    },
    "nmr_shielding": {                       # Collection of NMR shielding tensors
      id (string): {                         # Unique id: 'nmr-${nuc_idx}+${atom_symbol}'
        "r_O": array[float],                 # Gauge origin vector
        "r_K": array[float],                 # Nuclear coordinate vector
        "tensor": array[float],              # Full NMR shielding tensor
        "tensor_dia": array[float],          # Diamagnetic tensor
        "tensor_para": array[float],         # Paramagnetic tensor
        "diagonalized_tensor": array[float], # Diagonalized tensor used for (an)isotropy
        "isotropic_average": float,          # Diagonal average
        "anisotropy": float                  # Anisotropy of tensor
      }
    },
    "geometric_derivative": {                # Collection of geometric derivatives
      id (string): {                         # Unique id: 'geom-${number}'
        "electronic": array[float],          # Electronic component of the geometric derivative
        "electronic_norm": float,            # Norm of the electronic component of the geoemtric derivative
        "nuclear": array[float],             # Nuclear component of the geometric derivative
        "nuclear_norm": float,               # Norm of the nuclear component of the geometric derivative
        "total": array[float],               # Geometric derivative
        "total_norm": float                  # Norm of the geometric derivative
      }
    }
  },
  "scf_calculation": {                       # Ground state SCF calculation
    "success": bool,                         # SCF finished successfully
    "initial_energy": {                      # Energy computed from initial orbitals
      "E_kin": float,                        # Kinetic energy
      "E_nn": float,                         # Classical nuclear-nuclear interaction
      "E_en": float,                         # Classical electron-nuclear interaction
      "E_ee": float,                         # Classical electron-electron interaction
      "E_next": float,                       # Classical nuclear-external field interaction
      "E_eext": float,                       # Classical electron-external field interaction
      "E_x": float,                          # Hartree-Fock exact exchange energy
      "E_xc": float,                         # DFT exchange-correlation energy
      "E_el": float,                         # Sum of electronic contributions
      "E_nuc": float,                        # Sum of nuclear contributions
      "E_tot": float                         # Sum of all contributions
    },
    "scf_solver": {                          # Details from SCF optimization
      "converged": bool,                     # Optimization converged
      "wall_time": float,                    # Wall time (sec) for SCF optimization 
      "cycles": array[                       # Array of SCF cycles
        {                                    # (one entry per cycle)
          "energy_total": float,             # Current total energy
          "energy_update": float,            # Current energy update
          "mo_residual": float,              # Current orbital residual
          "wall_time": float,                # Wall time (sec) for SCF cycle
          "energy_terms": {                  # Energy contributions
            "E_kin": float,                  # Kinetic energy
            "E_nn": float,                   # Classical nuclear-nuclear interaction
            "E_en": float,                   # Classical electron-nuclear interaction
            "E_ee": float,                   # Classical electron-electron interaction
            "E_next": float,                 # Classical nuclear-external field interaction
            "E_eext": float,                 # Classical electron-external field interaction
            "E_x": float,                    # Hartree-Fock exact exchange energy
            "E_xc": float,                   # DFT exchange-correlation energy
            "E_el": float,                   # Sum of electronic contributions
            "E_nuc": float,                  # Sum of nuclear contributions
            "E_tot": float                   # Sum of all contributions
          }
        }
      ]
    }
  },
  "rsp_calculations": {                      # Collection of response calculations
    id (string): {                           # Response id: e.g. 'ext_el-${frequency}'
      "success": bool,                       # Response finished successfully
      "frequency": float,                    # Frequency of perturbation
      "perturbation": string,                # Name of perturbation operator
      "components": array[                   # Array of operator components
        {                                    # (one entry per Cartesian direction)
          "rsp_solver": {                    # Details from response optimization
            "wall_time": float,              # Wall time (sec) for response calculation
            "converged": bool,               # Optimization converged
            "cycles": array[                 # Array of response cycles
              {                              # (one entry per cycle)
                "symmetric_property": float, # Property computed from perturbation operator
                "property_update": float,    # Current symmetric property update
                "mo_residual": float,        # Current orbital residual
                "wall_time": float           # Wall time (sec) for response cycle
              }
            ]
          }
        }
      ]
    }
  }
}