derived_types.f90

Go to the documentation of this file.

 
module derived_types
 
  use kinds
  use constants
  
  implicit none
 
  private
 
  public :: run_params, metropolis_params, ns_params, tmmc_params, wl_params
 
  type run_params
 
    ! Paramater defining the mode of operation
    integer :: mode
    ! Number of unit cells in each direction and
    ! number of atoms in the basis
    integer :: n_1, n_2, n_3, n_basis
    ! Number of chemical species
    integer :: n_species
    ! Number of atoms
    integer :: n_atoms
    ! Logical flag for fixed or time-based random seed
    logical :: static_seed=.false.
    ! Lattice type - name, e.g. fcc, bcc, hcp, ...
    character(len=20) :: lattice
    ! Lattice parameter (for writing xyz file)
    real(real64) :: lattice_parameter
    ! Lattice vectors (for writing xyz file)
    real(real64), dimension(3,3) :: lattice_vectors
    ! Vector to second basis atom (for writing xyz file)
    real(real64), dimension(3) :: basis_vectors
    ! Names of the chemical species
    character(len=2), dimension(:), allocatable :: species_names
    ! Concentrations of the chemical species
    real(real64), dimension(:), allocatable :: species_concentrations
    ! Number of atoms of each chemical species
    integer(int64), dimension(:), allocatable :: species_numbers
    ! Atom-atom interchange interaction file name
    character(len=50) :: interaction_file
    ! Interaction range (number of coordination shells)
    integer :: interaction_range
    ! Number of coordination shells for Warren-Cowley parameters
    integer :: wc_range
    ! Hamiltonian to use
    procedure(hamiltonian), pointer, pass :: full_energy => null()
    ! neighbour energy function to use
    procedure(neighbour), pointer, pass :: nbr_energy => null()
    ! Random site function to use
    procedure(rand_site), pointer, pass :: rdm_site => null()
    ! Random neighbour function to use
    procedure(rand_neighbour), pointer, pass :: rdm_nbr => null()
    ! Monte Carlo step to call. (Neighbour swap or whole lattice swap)
    procedure(monte_carlo), pointer, pass :: mc_step => null()
 
  end type run_params
 
  type metropolis_params
 
    ! Paramater defining the mode of Metropolis operation
    ! Current options are:
    !  - 'equilibrate'
    !    - This option runs the Metropolis algorithm at a given
    !      temperature and tracks the simulation energy and atomic
    !      order parameters as a function of number of trial moves.
    !      Optionally, you can dump a 'trajectory' showing how the
    !      alloy configuration evolves.
    !  - 'simulated_annealing'
    !    - This option uses simulated annealing to examine atomic
    !      short- and long-range order parameters, simulation energy,
    !      and specific heat capacity as a function of temperature for a
    !      given system. Optionally, you can dump the simulation
    !      configuration at the end of each temperature.
    !  - 'decorrelated_samples'
    !    - This option draws grid configurations a set number of steps
    !      apart (for producing indicative equilibrated atomic configs
    !      at a given temperature.
    character(len=30) :: mode
    ! Number of monte carlo steps (at each temperature if annealing)
    integer :: n_mc_steps
    ! Burn in at FIRST temperature if doing simulated annealing?
    logical :: burn_in_start
    ! Burn in at ALL temperatures if doing simulated annealing?
    logical :: burn_in
    ! Number of burn-in steps (at each temperature if annealing)
    integer :: n_burn_in_steps
    ! Number of Monte Carlo trial moves between drawing samples
    ! of ANY quantity
    integer :: n_sample_steps
    ! Do we want to total simulation energy and store it?
    logical :: calculate_energies
    ! Do we want to write the trajectory's energy to file
    logical :: write_trajectory_energy
    ! Do we want to calculate atomic short-range order parameters?
    logical :: calculate_asro
    ! Do we want to write the trajectory's energy to file
    logical :: write_trajectory_asro
    ! Number of monte carlo steps between drawing ASRO parameters
    ! (MUST be an integer multiple of n_sample_steps)
    integer :: n_sample_steps_asro
    ! Do we want to store atomic long-range order parameters
    logical :: calculate_alro
    ! Number of monte carlo steps between drawing ALRO parameters
    ! (MUST be an integer multiple of n_sample_steps)
    integer :: n_sample_steps_alro
    ! Do we want to write the trajectory as an xyz file
    ! (for visualisation)
    logical :: write_trajectory_xyz
    ! Number of monte carlo steps between drawing ALRO parameters
    ! (MUST be an integer multiple of n_sample_steps)
    integer :: n_sample_steps_trajectory
    ! Do we want to write the initial config (at each temp if annealing)
    ! as an xyz file?
    logical :: write_initial_config_xyz
    ! Do we want to write the initial config (at each temp if annealing)
    ! as a NetCDF file? (For restart later.)
    logical :: write_initial_config_nc
    ! Do we want to write the final config (at each temp if annealing)
    ! as an xyz file?
    logical :: write_final_config_xyz
    ! Do we want to write the final config (at each temp if annealing)
    ! as a NetCDF file? (For restart later.)
    logical :: write_final_config_nc
    ! Do we want to read a starting config from file?
    ! (Useful if restarting an earlier run...)
    logical :: read_start_config_nc
    ! Name of file from which to read if so
    character(len=144) :: start_config_file
    ! Inverse temperature
    real(real64) :: beta
    ! Temperature of simulation (or start temperature if annealing)
    ! Should come in units of Kelvin
    real(real64) :: t
    ! Number of temperature steps (if annealing)
    integer :: t_steps
    ! Temperature step size if annealing
    real(real64) :: delta_t
    ! Atom swap flag
    ! If True then only swap neighbouring pairs of atoms
    ! If False then permit swaps across the lattice
    logical :: nbr_swap
 
  end type metropolis_params
 
  type ns_params
 
    ! Number of nested sampling walkers
    integer :: n_walkers
    ! Number of steps required for walk generating a new configuration
    integer :: n_steps
    ! Number of NS iterations before sampling is finished
    integer :: n_iter
    ! Frequency of writing configuration (every traj_freq-th NS iteration)
    integer :: traj_freq
    ! Output filenames
    character(len=100) :: outfile_ener, outfile_traj  
 
  end type ns_params
 
  type tmmc_params
 
    ! Number of sweeps (each sweep is n_atoms mc steps)
    integer :: mc_sweeps
    ! Number of bins across energy range
    integer :: bins
    ! Number of energy windows
    integer :: num_windows
    ! Number of bins in the overlap region
    real :: bin_overlap
    ! Number of bias weight updates
    integer :: weight_update
    ! Energy range minimum
    real :: energy_min
    ! Energy range maximum
    real :: energy_max
    ! Temperature of dynamics
    real :: t
 
  end type tmmc_params
 
  type wl_params
 
    ! Number of  sweeps (each sweep is n_atoms mc steps)
    integer :: mc_sweeps
    ! Number of bins across energy range
    integer :: bins
    ! Number of energy windows
    integer :: num_windows
    ! Percentage overlap between windows
    real :: bin_overlap
    ! Tolerance for wang landau
    real :: tolerance
    ! Flatness for wang landau histogram
    real :: flatness
    ! Wang Landau density of states histogram tuning parameter
    real :: wl_f
    ! Energy range minimum
    real :: energy_min
    ! Energy range maximum
    real :: energy_max
    ! Radial density samples per bin
    integer :: radial_samples
    ! Performance analysis
    integer :: performance
    ! Dynamics type
    logical :: nbr_swap
    ! Monte Carlo step to call. (Neighbour swap or whole lattice swap)
    procedure(), pointer, nopass :: mc_select => null()
  end type wl_params
 
  !--------------------------------------------------------------------!
  ! Interfaces for various Hamiltonian and dynamics implementations    !
  ! chosen at runtime.                                                 !
  !                                                                    !
  ! C. D. Woodgate,  Bristol                                      2025 !
  !--------------------------------------------------------------------!
  interface
 
    function hamiltonian(setup, config)
 
      use kinds, only : real64
      use constants, only : array_int
 
      import :: run_params
 
      integer(array_int), dimension(:,:,:,:), intent(in) :: config
      real(real64) :: hamiltonian
      class(run_params), intent(in) :: setup
 
    end function
 
    function neighbour(setup, config, site_b, site_i, site_j, site_k)
 
      use kinds, only : real64
      use constants, only : array_int
 
      import :: run_params
 
      integer(array_int), dimension(:,:,:,:), intent(in) :: config
      real(real64) :: neighbour
      class(run_params), intent(in) :: setup
      integer, intent(in) :: site_b, site_i, site_j, site_k
 
    end function
 
    function rand_site(setup)
 
      use kinds, only : real64
      use constants, only : array_int
 
      import :: run_params
 
      class(run_params), intent(in) :: setup
      integer, dimension(4) :: rand_site
 
    end function
 
    function rand_neighbour(setup, site)
 
      use kinds, only : real64
      use constants, only : array_int
 
      import :: run_params
 
      class(run_params), intent(in) :: setup
      integer, dimension(4), intent(in) :: site
      integer, dimension(4) :: rand_neighbour
 
    end function
 
    function monte_carlo(setup, config, beta) result(accept)
 
      use kinds, only : real64
      use constants, only : array_int
 
      import :: run_params
 
      integer(array_int), dimension(:,:,:,:) :: config
      class(run_params), intent(in) :: setup
      integer :: accept
      real(real64), intent(in) :: beta
 
    end function monte_carlo
 
  end interface
 
end module derived_types