istp/gray
2
0
Fork 0
Code Issues Pull Requests Packages Projects Releases 1 Wiki Activity
baf53b932b
gray/src/main.f90

546 lines
20 KiB
Fortran
Raw Normal View History

src: use derived type arguments (work in progress) This change structures the arguments of most functions, in particular gray_main, into well-defined categories using derived types. All types are defined in the gray_params.f90 (location subject to change) and are organised as follows: gray_parameters (statically allocated data) ├── antenna_parameters ├── ecrh_cd_parameters ├── equilibrium_parameters ├── misc_parameters ├── output_parameters ├── profiles_parameters └── raytracing_parameters gray_data - inputs of gray_main (dynamically-allocated arrays) ├── equilibrium_data └── profiles_data gray_results - outputs of gray_main (dynamically-allocated arrays)
2021-12-15 02:31:09 +01:00
program main
rework the analytical model This change modifies the analytical equilibrium in order to simplify the computation of the poloidal flux normalization and the derivatives. In the power law parametrisation of the safety factor, ρ_t is replaced with ρ_p and, similarly, the normalised poloidal radius is now identified with ρ_p, instead of ρ_t. With the same parameters (q₀,q₁,α...), this choice slightly changes the plasma current distribution, but enables us to obtain a closed form for ψ_a = ψ(r=a) and the relation ρ_t(ρ_p). In fact, both expressions are now obtained by integrating the q(ρ_p), instead of 1/q(ρ_t), which has no elementary antiderivative. As the normalisation is now computed exactly, the values of the normalised flux ψ_n = ψ/ψ_a and the gradient ∇ψ (entering the raytracing equations in X and ∇X, respectively) are computed to the same precision. Previously, ψ_n was computed to a lower precision due to the use of a simple trapezoid integration of 1/q(ρ_p) for ψ_a, while ∇ψ was computed up to machine precision using an exact formula. This error effectively caused a very slight decoupling between X=ω_p²/ω² and ∇X that introduced a systematic error in the numerical solution of the raytracing equations. The error manifests itself as a bias with a weak dependency on X in the values taken by the dispersion function Λ(r̅, n̅) on the phase-space points generated by the integrator. More specifically, lim h→0 Λ(r̅_i, n̅_i) = -kX(r̅_i) where h is the integrator step size; r̅_i is the position at the i-th step; k ≈ -3.258⋅10⁻⁵ and depends only on the number of points used to perform the trapedoid integral for ψ_a (as ~ 1/n²). After this change Λ behaves consistently with being a conserved quantity (zero) up to the cumulative integration error of the 4° order Runge-Kutta method. In fact we now have that: Λ(r̅_i, n̅_i) ∝ - h⁴ ‖∂⁴X(r̅_i)/∂r̅⁴‖ It must be said that within this model the relation ρ_p(ρ_t) can't be computed analytically (inverting ρ_t(ρ_p) produces a trascendental equation of the form b = x + c x^α). However, this relation is not necessary for raytracing and is easily solved, up to machine precision, using minpack. In addition, this change also makes the model consistetly use the cocos=3 and fully implements the ability to force the signs of I_p, B_φ (via equilibrium.sgni,sgnb) and rescaling the field (via equilibrium.factb).
2023-10-11 17:29:24 +02:00
use const_and_precisions, only : wp_, zero
src: use the logging system everywhere
2021-12-18 18:57:38 +01:00
use logger, only : INFO, ERROR, set_log_level, log_message
Close open units on exit to flush the buffer
2021-12-22 23:45:30 +01:00
use units, only : set_active_units, close_units
add INI configuration file This adds a new configuration file based on the INI format. The new format will allow adding GRAY parameters without breaking compatibility with existing configurations, unlike as of the old gray_params.data.
2022-05-09 21:11:51 +02:00
use utils, only : dirname
add option to set parameters from the command-line
2022-04-29 01:52:50 +02:00
use gray_cli, only : cli_options, parse_cli_options, &
deinit_cli_options, parse_param_overrides
src/graycore.f90 -> src/gray_core.f90 Rename for consistency with other modules.
2021-12-15 02:31:14 +01:00
use gray_core, only : gray_main
src: use derived type arguments (work in progress) This change structures the arguments of most functions, in particular gray_main, into well-defined categories using derived types. All types are defined in the gray_params.f90 (location subject to change) and are organised as follows: gray_parameters (statically allocated data) ├── antenna_parameters ├── ecrh_cd_parameters ├── equilibrium_parameters ├── misc_parameters ├── output_parameters ├── profiles_parameters └── raytracing_parameters gray_data - inputs of gray_main (dynamically-allocated arrays) ├── equilibrium_data └── profiles_data gray_results - outputs of gray_main (dynamically-allocated arrays)
2021-12-15 02:31:09 +01:00
use gray_params, only : gray_parameters, gray_data, gray_results, &
add INI configuration file This adds a new configuration file based on the INI format. The new format will allow adding GRAY parameters without breaking compatibility with existing configurations, unlike as of the old gray_params.data.
2022-05-09 21:11:51 +02:00
read_gray_params, read_gray_config, &
params_set_globals => set_globals
nocommon branch merged back into trunk
2015-11-18 17:34:33 +01:00
implicit none
merge graysum and gray Note that graysum, now as sum_mode, still doesn't support multipass.
2021-12-15 02:30:55 +01:00
initial gray CLI work This lays down the basis for the gray command-line interface. All options works but currently --units and -v/-q have no effect.
2021-12-15 02:31:16 +01:00
! CLI options
type(cli_options) :: opts
src: use derived type arguments (work in progress) This change structures the arguments of most functions, in particular gray_main, into well-defined categories using derived types. All types are defined in the gray_params.f90 (location subject to change) and are organised as follows: gray_parameters (statically allocated data) ├── antenna_parameters ├── ecrh_cd_parameters ├── equilibrium_parameters ├── misc_parameters ├── output_parameters ├── profiles_parameters └── raytracing_parameters gray_data - inputs of gray_main (dynamically-allocated arrays) ├── equilibrium_data └── profiles_data gray_results - outputs of gray_main (dynamically-allocated arrays)
2021-12-15 02:31:09 +01:00
! gray_main subroutine arguments
type(gray_parameters) :: params ! Inputs
type(gray_data) :: data !
type(gray_results) :: results ! Outputs
src: use the logging system everywhere
2021-12-18 18:57:38 +01:00
integer :: err ! Exit code
src: use derived type arguments (work in progress) This change structures the arguments of most functions, in particular gray_main, into well-defined categories using derived types. All types are defined in the gray_params.f90 (location subject to change) and are organised as follows: gray_parameters (statically allocated data) ├── antenna_parameters ├── ecrh_cd_parameters ├── equilibrium_parameters ├── misc_parameters ├── output_parameters ├── profiles_parameters └── raytracing_parameters gray_data - inputs of gray_main (dynamically-allocated arrays) ├── equilibrium_data └── profiles_data gray_results - outputs of gray_main (dynamically-allocated arrays)
2021-12-15 02:31:09 +01:00
add INI configuration file This adds a new configuration file based on the INI format. The new format will allow adding GRAY parameters without breaking compatibility with existing configurations, unlike as of the old gray_params.data.
2022-05-09 21:11:51 +02:00
! Store the original working directory
character(len=256) :: cwd
call getcwd(cwd)
initial gray CLI work This lays down the basis for the gray command-line interface. All options works but currently --units and -v/-q have no effect.
2021-12-15 02:31:16 +01:00
! Parse the command-line options
call parse_cli_options(opts)
src: use derived type arguments (work in progress) This change structures the arguments of most functions, in particular gray_main, into well-defined categories using derived types. All types are defined in the gray_params.f90 (location subject to change) and are organised as follows: gray_parameters (statically allocated data) ├── antenna_parameters ├── ecrh_cd_parameters ├── equilibrium_parameters ├── misc_parameters ├── output_parameters ├── profiles_parameters └── raytracing_parameters gray_data - inputs of gray_main (dynamically-allocated arrays) ├── equilibrium_data └── profiles_data gray_results - outputs of gray_main (dynamically-allocated arrays)
2021-12-15 02:31:09 +01:00
src: use the logging system everywhere
2021-12-18 18:57:38 +01:00
! Initialise logging
if (opts%quiet) opts%verbose = ERROR
call set_log_level(opts%verbose)
src: implement toggling of output units This actually implements the --units option
2021-12-19 16:39:19 +01:00
! Activate the given output units
call set_active_units(opts%units)
add INI configuration file This adds a new configuration file based on the INI format. The new format will allow adding GRAY parameters without breaking compatibility with existing configurations, unlike as of the old gray_params.data.
2022-05-09 21:11:51 +02:00
! Load the parameters from file and move to its directory
! (all other filepaths are assumed relative to it)
if (allocated(opts%config_file)) then
! Use the newer gray.ini configuration file
call log_message(level=INFO, mod='main', msg='using GRAY INI config')
call exit on errors only in main
2023-09-12 16:29:09 +02:00
call read_gray_config(opts%config_file, params, err)
if (err /= 0) call exit(1)
add INI configuration file This adds a new configuration file based on the INI format. The new format will allow adding GRAY parameters without breaking compatibility with existing configurations, unlike as of the old gray_params.data.
2022-05-09 21:11:51 +02:00
err = chdir(dirname(opts%config_file))
else
! Use the legacy gray_params.data file
call log_message(level=INFO, mod='main', msg='using GRAY params file')
call exit on errors only in main
2023-09-12 16:29:09 +02:00
call read_gray_params(opts%params_file, params, err)
if (err /= 0) call exit(1)
add INI configuration file This adds a new configuration file based on the INI format. The new format will allow adding GRAY parameters without breaking compatibility with existing configurations, unlike as of the old gray_params.data.
2022-05-09 21:11:51 +02:00
err = chdir(dirname(opts%params_file))
end if
if (err /= 0) then
call log_message(level=ERROR, mod='main', &
msg='chdir to configuration file directory failed!')
call exit(1)
end if
src/main.f90: give priority to cli over beamdata.txt
2023-04-02 16:18:43 +02:00
! Initialise antenna parameters before parsing the
! cli arguments, so antenna%pos can be overriden
call init_antenna(params%antenna, err)
if (err /= 0) call exit(err)
! Apply CLI overrides to the parameters
add option to set parameters from the command-line
2022-04-29 01:52:50 +02:00
call parse_param_overrides(params)
src/main.f90: give priority to cli over beamdata.txt
2023-04-02 16:18:43 +02:00
! Copy the parameters into global variables
! exported by the gray_params module
src: use derived type arguments (work in progress) This change structures the arguments of most functions, in particular gray_main, into well-defined categories using derived types. All types are defined in the gray_params.f90 (location subject to change) and are organised as follows: gray_parameters (statically allocated data) ├── antenna_parameters ├── ecrh_cd_parameters ├── equilibrium_parameters ├── misc_parameters ├── output_parameters ├── profiles_parameters └── raytracing_parameters gray_data - inputs of gray_main (dynamically-allocated arrays) ├── equilibrium_data └── profiles_data gray_results - outputs of gray_main (dynamically-allocated arrays)
2021-12-15 02:31:09 +01:00
call params_set_globals(params)
src: use hypot and norm2 when possible
2021-12-19 02:35:24 +01:00
! Read the input data and set the global variables
src: use derived type arguments (work in progress) This change structures the arguments of most functions, in particular gray_main, into well-defined categories using derived types. All types are defined in the gray_params.f90 (location subject to change) and are organised as follows: gray_parameters (statically allocated data) ├── antenna_parameters ├── ecrh_cd_parameters ├── equilibrium_parameters ├── misc_parameters ├── output_parameters ├── profiles_parameters └── raytracing_parameters gray_data - inputs of gray_main (dynamically-allocated arrays) ├── equilibrium_data └── profiles_data gray_results - outputs of gray_main (dynamically-allocated arrays)
2021-12-15 02:31:09 +01:00
! of the respective module. Note: order matters.
call exit on errors only in main
2023-09-12 16:29:09 +02:00
call init_equilibrium(params, data, err)
if (err /= 0) call exit(err)
src/coreprofiles: make psnbnd fully automatic 1. Fix the mismatch between the psnbnd in coreprofiles and gray_core. This happens whenever gray overrides the externally provided one (i.e. the density tail would become negative before psnbnd and is so rescaled to end exactly on the zero). 2. Make psnbnd no longer required by always computing it as in 1. It hasn't been removed, because gray_params.data is sacrosant, but it no longer has any effect. 3. Cleanup: mark public functions, restructure the global variables into three categories; add comments explaining the analytical profiles format, formulae and how the polynomial tail is computed.
2022-05-21 22:56:57 +02:00
call init_profiles(params%profiles, params%equilibrium%factb, &
call exit on errors only in main
2023-09-12 16:29:09 +02:00
params%antenna%pos, data%profiles, err)
if (err /= 0) call exit(err)
src: use derived type arguments (work in progress) This change structures the arguments of most functions, in particular gray_main, into well-defined categories using derived types. All types are defined in the gray_params.f90 (location subject to change) and are organised as follows: gray_parameters (statically allocated data) ├── antenna_parameters ├── ecrh_cd_parameters ├── equilibrium_parameters ├── misc_parameters ├── output_parameters ├── profiles_parameters └── raytracing_parameters gray_data - inputs of gray_main (dynamically-allocated arrays) ├── equilibrium_data └── profiles_data gray_results - outputs of gray_main (dynamically-allocated arrays)
2021-12-15 02:31:09 +01:00
call init_misc(params, data)
merge graysum and gray Note that graysum, now as sum_mode, still doesn't support multipass.
2021-12-15 02:30:55 +01:00
src/main.f90: fix chdir to absolute output path
2023-11-23 18:51:47 +01:00
! Get back to the initial directory
err = chdir(cwd)
add INI configuration file This adds a new configuration file based on the INI format. The new format will allow adding GRAY parameters without breaking compatibility with existing configurations, unlike as of the old gray_params.data.
2022-05-09 21:11:51 +02:00
! Change the current directory to output files there
initial gray CLI work This lays down the basis for the gray command-line interface. All options works but currently --units and -v/-q have no effect.
2021-12-15 02:31:16 +01:00
if (allocated(opts%output_dir)) then
src/main.f90: fix chdir to absolute output path
2023-11-23 18:51:47 +01:00
if (chdir(opts%output_dir) /= 0) then
src: use the logging system everywhere
2021-12-18 18:57:38 +01:00
call log_message(level=ERROR, mod='main', &
msg='chdir to output_dir ('//opts%output_dir//') failed!')
initial gray CLI work This lays down the basis for the gray command-line interface. All options works but currently --units and -v/-q have no effect.
2021-12-15 02:31:16 +01:00
call exit(1)
end if
end if
if (allocated(opts%sum_filelist)) then
src: use the logging system everywhere
2021-12-18 18:57:38 +01:00
call log_message(level=INFO, mod='main', msg='summing profiles')
src: use derived type arguments (work in progress) This change structures the arguments of most functions, in particular gray_main, into well-defined categories using derived types. All types are defined in the gray_params.f90 (location subject to change) and are organised as follows: gray_parameters (statically allocated data) ├── antenna_parameters ├── ecrh_cd_parameters ├── equilibrium_parameters ├── misc_parameters ├── output_parameters ├── profiles_parameters └── raytracing_parameters gray_data - inputs of gray_main (dynamically-allocated arrays) ├── equilibrium_data └── profiles_data gray_results - outputs of gray_main (dynamically-allocated arrays)
2021-12-15 02:31:09 +01:00
sum: block
Fix the summation mode + temporary fix for file unit numbers - Add missing array allocations - Add parameter for varying number of columns in input files - Change output unit numbers (dirty fix. Original units created an empty named file, but wrote in default named fort.* files)
2022-11-24 23:37:29 +01:00
real(wp_), dimension(:), allocatable :: jphi
src: use derived type arguments (work in progress) This change structures the arguments of most functions, in particular gray_main, into well-defined categories using derived types. All types are defined in the gray_params.f90 (location subject to change) and are organised as follows: gray_parameters (statically allocated data) ├── antenna_parameters ├── ecrh_cd_parameters ├── equilibrium_parameters ├── misc_parameters ├── output_parameters ├── profiles_parameters └── raytracing_parameters gray_data - inputs of gray_main (dynamically-allocated arrays) ├── equilibrium_data └── profiles_data gray_results - outputs of gray_main (dynamically-allocated arrays)
2021-12-15 02:31:09 +01:00
real(wp_), dimension(:), allocatable :: currins, pins, rtin, rpin
Fix the summation mode + temporary fix for file unit numbers - Add missing array allocations - Add parameter for varying number of columns in input files - Change output unit numbers (dirty fix. Original units created an empty named file, but wrote in default named fort.* files)
2022-11-24 23:37:29 +01:00
real(wp_), dimension(:), allocatable :: extracol
integer :: i, j, k, l, n, ngam, nextracol, irt
character(len=255) :: filename, headerline, fmtstr
src: use derived type arguments (work in progress) This change structures the arguments of most functions, in particular gray_main, into well-defined categories using derived types. All types are defined in the gray_params.f90 (location subject to change) and are organised as follows: gray_parameters (statically allocated data) ├── antenna_parameters ├── ecrh_cd_parameters ├── equilibrium_parameters ├── misc_parameters ├── output_parameters ├── profiles_parameters └── raytracing_parameters gray_data - inputs of gray_main (dynamically-allocated arrays) ├── equilibrium_data └── profiles_data gray_results - outputs of gray_main (dynamically-allocated arrays)
2021-12-15 02:31:09 +01:00
real(wp_), dimension(5) :: f48v
Fix the summation mode + temporary fix for file unit numbers - Add missing array allocations - Add parameter for varying number of columns in input files - Change output unit numbers (dirty fix. Original units created an empty named file, but wrote in default named fort.* files)
2022-11-24 23:37:29 +01:00
real(wp_) :: jphip,dpdvp, &
src: use derived type arguments (work in progress) This change structures the arguments of most functions, in particular gray_main, into well-defined categories using derived types. All types are defined in the gray_params.f90 (location subject to change) and are organised as follows: gray_parameters (statically allocated data) ├── antenna_parameters ├── ecrh_cd_parameters ├── equilibrium_parameters ├── misc_parameters ├── output_parameters ├── profiles_parameters └── raytracing_parameters gray_data - inputs of gray_main (dynamically-allocated arrays) ├── equilibrium_data └── profiles_data gray_results - outputs of gray_main (dynamically-allocated arrays)
2021-12-15 02:31:09 +01:00
rhotj,rhotjava,rhotp,rhotpav,drhotjava,drhotpav,ratjamx,ratjbmx
allocate(jphi(params%output%nrho), currins(params%output%nrho), &
pins(params%output%nrho), rtin(params%output%nrho), &
rpin(params%output%nrho))
src: use the logging system everywhere
2021-12-18 18:57:38 +01:00
open(100, file=opts%sum_filelist, action='read', status='old', iostat=err)
if (err /= 0) then
call log_message(level=ERROR, mod='main', &
msg='opening file list ('//opts%sum_filelist//') failed!')
call exit(1)
end if
Fix the summation mode + temporary fix for file unit numbers - Add missing array allocations - Add parameter for varying number of columns in input files - Change output unit numbers (dirty fix. Original units created an empty named file, but wrote in default named fort.* files)
2022-11-24 23:37:29 +01:00
open(unit=100 -1, file='f48sum.txt', action='write', status='unknown')
open(unit=100 -2, file='f7sum.txt', action='write', status='unknown')
read(100, *) n, ngam, nextracol
allocate(extracol(nextracol))
src: use derived type arguments (work in progress) This change structures the arguments of most functions, in particular gray_main, into well-defined categories using derived types. All types are defined in the gray_params.f90 (location subject to change) and are organised as follows: gray_parameters (statically allocated data) ├── antenna_parameters ├── ecrh_cd_parameters ├── equilibrium_parameters ├── misc_parameters ├── output_parameters ├── profiles_parameters └── raytracing_parameters gray_data - inputs of gray_main (dynamically-allocated arrays) ├── equilibrium_data └── profiles_data gray_results - outputs of gray_main (dynamically-allocated arrays)
2021-12-15 02:31:09 +01:00
do i=1,n
read(100, *) filename
src: use the logging system everywhere
2021-12-18 18:57:38 +01:00
open(100 + i, file=filename, action='read', status='old', iostat=err)
if (err /= 0) then
call log_message(level=ERROR, mod='main', &
msg='opening summand file ('//trim(filename)//') failed!')
call exit(1)
end if
src: use derived type arguments (work in progress) This change structures the arguments of most functions, in particular gray_main, into well-defined categories using derived types. All types are defined in the gray_params.f90 (location subject to change) and are organised as follows: gray_parameters (statically allocated data) ├── antenna_parameters ├── ecrh_cd_parameters ├── equilibrium_parameters ├── misc_parameters ├── output_parameters ├── profiles_parameters └── raytracing_parameters gray_data - inputs of gray_main (dynamically-allocated arrays) ├── equilibrium_data └── profiles_data gray_results - outputs of gray_main (dynamically-allocated arrays)
2021-12-15 02:31:09 +01:00
do j=1,22
Fix the summation mode + temporary fix for file unit numbers - Add missing array allocations - Add parameter for varying number of columns in input files - Change output unit numbers (dirty fix. Original units created an empty named file, but wrote in default named fort.* files)
2022-11-24 23:37:29 +01:00
read(100 + i, '(a255)') headerline
if (i == 1) then
write(100 -1, '(a)') trim(headerline)
write(100 -2, '(a)') trim(headerline)
end if
src: use derived type arguments (work in progress) This change structures the arguments of most functions, in particular gray_main, into well-defined categories using derived types. All types are defined in the gray_params.f90 (location subject to change) and are organised as follows: gray_parameters (statically allocated data) ├── antenna_parameters ├── ecrh_cd_parameters ├── equilibrium_parameters ├── misc_parameters ├── output_parameters ├── profiles_parameters └── raytracing_parameters gray_data - inputs of gray_main (dynamically-allocated arrays) ├── equilibrium_data └── profiles_data gray_results - outputs of gray_main (dynamically-allocated arrays)
2021-12-15 02:31:09 +01:00
end do
merge graysum and gray Note that graysum, now as sum_mode, still doesn't support multipass.
2021-12-15 02:30:55 +01:00
end do
src: use derived type arguments (work in progress) This change structures the arguments of most functions, in particular gray_main, into well-defined categories using derived types. All types are defined in the gray_params.f90 (location subject to change) and are organised as follows: gray_parameters (statically allocated data) ├── antenna_parameters ├── ecrh_cd_parameters ├── equilibrium_parameters ├── misc_parameters ├── output_parameters ├── profiles_parameters └── raytracing_parameters gray_data - inputs of gray_main (dynamically-allocated arrays) ├── equilibrium_data └── profiles_data gray_results - outputs of gray_main (dynamically-allocated arrays)
2021-12-15 02:31:09 +01:00
Fix the summation mode + temporary fix for file unit numbers - Add missing array allocations - Add parameter for varying number of columns in input files - Change output unit numbers (dirty fix. Original units created an empty named file, but wrote in default named fort.* files)
2022-11-24 23:37:29 +01:00
allocate(results%jcd(params%output%nrho), results%dpdv(params%output%nrho))
src: use derived type arguments (work in progress) This change structures the arguments of most functions, in particular gray_main, into well-defined categories using derived types. All types are defined in the gray_params.f90 (location subject to change) and are organised as follows: gray_parameters (statically allocated data) ├── antenna_parameters ├── ecrh_cd_parameters ├── equilibrium_parameters ├── misc_parameters ├── output_parameters ├── profiles_parameters └── raytracing_parameters gray_data - inputs of gray_main (dynamically-allocated arrays) ├── equilibrium_data └── profiles_data gray_results - outputs of gray_main (dynamically-allocated arrays)
2021-12-15 02:31:09 +01:00
do k=1,ngam
Fix the summation mode + temporary fix for file unit numbers - Add missing array allocations - Add parameter for varying number of columns in input files - Change output unit numbers (dirty fix. Original units created an empty named file, but wrote in default named fort.* files)
2022-11-24 23:37:29 +01:00
jphi = zero
results%jcd = zero
results%dpdv = zero
currins = zero
pins = zero
src: use derived type arguments (work in progress) This change structures the arguments of most functions, in particular gray_main, into well-defined categories using derived types. All types are defined in the gray_params.f90 (location subject to change) and are organised as follows: gray_parameters (statically allocated data) ├── antenna_parameters ├── ecrh_cd_parameters ├── equilibrium_parameters ├── misc_parameters ├── output_parameters ├── profiles_parameters └── raytracing_parameters gray_data - inputs of gray_main (dynamically-allocated arrays) ├── equilibrium_data └── profiles_data gray_results - outputs of gray_main (dynamically-allocated arrays)
2021-12-15 02:31:09 +01:00
do j=1,params%output%nrho
do i=1,n
Fix the summation mode + temporary fix for file unit numbers - Add missing array allocations - Add parameter for varying number of columns in input files - Change output unit numbers (dirty fix. Original units created an empty named file, but wrote in default named fort.* files)
2022-11-24 23:37:29 +01:00
read(100+i, *) (extracol(l), l=1,nextracol), &
rpin(j), rtin(j), f48v(1:5), irt
jphi(j) = f48v(1) + jphi(j)
results%jcd(j) = f48v(2) + results%jcd(j)
results%dpdv(j) = f48v(3) + results%dpdv(j)
currins(j) = f48v(4) + currins(j)
pins(j) = f48v(5) + pins(j)
src: use derived type arguments (work in progress) This change structures the arguments of most functions, in particular gray_main, into well-defined categories using derived types. All types are defined in the gray_params.f90 (location subject to change) and are organised as follows: gray_parameters (statically allocated data) ├── antenna_parameters ├── ecrh_cd_parameters ├── equilibrium_parameters ├── misc_parameters ├── output_parameters ├── profiles_parameters └── raytracing_parameters gray_data - inputs of gray_main (dynamically-allocated arrays) ├── equilibrium_data └── profiles_data gray_results - outputs of gray_main (dynamically-allocated arrays)
2021-12-15 02:31:09 +01:00
end do
Fix the summation mode + temporary fix for file unit numbers - Add missing array allocations - Add parameter for varying number of columns in input files - Change output unit numbers (dirty fix. Original units created an empty named file, but wrote in default named fort.* files)
2022-11-24 23:37:29 +01:00
write(fmtstr, '("(",i0,"(1x,e16.8e3),i5)")') nextracol+7
write(100 -1,trim(fmtstr)) &
(extracol(l), l=1,nextracol), rpin(j), rtin(j), &
jphi(j), results%jcd(j), results%dpdv(j), &
currins(j), pins(j), irt
merge graysum and gray Note that graysum, now as sum_mode, still doesn't support multipass.
2021-12-15 02:30:55 +01:00
end do
Fix the summation mode + temporary fix for file unit numbers - Add missing array allocations - Add parameter for varying number of columns in input files - Change output unit numbers (dirty fix. Original units created an empty named file, but wrote in default named fort.* files)
2022-11-24 23:37:29 +01:00
results%pabs = pins(params%output%nrho)
results%icd = currins(params%output%nrho)
write(100 -1, *)
call sum_profiles(params, jphi, results%jcd, results%dpdv, &
currins, pins, results%pabs, results%icd, &
jphip, dpdvp, rhotj, rhotjava, rhotp, rhotpav, &
drhotjava, drhotpav, ratjamx, ratjbmx)
write(fmtstr, '("(",i0,"(1x,e12.5),i5,7(1x,e12.5))")') nextracol+12
write(100 -2, trim(fmtstr)) &
(extracol(l), l=1,nextracol), results%icd, results%pabs, &
jphip, dpdvp, rhotj, rhotjava, rhotp, rhotpav, &
src: use derived type arguments (work in progress) This change structures the arguments of most functions, in particular gray_main, into well-defined categories using derived types. All types are defined in the gray_params.f90 (location subject to change) and are organised as follows: gray_parameters (statically allocated data) ├── antenna_parameters ├── ecrh_cd_parameters ├── equilibrium_parameters ├── misc_parameters ├── output_parameters ├── profiles_parameters └── raytracing_parameters gray_data - inputs of gray_main (dynamically-allocated arrays) ├── equilibrium_data └── profiles_data gray_results - outputs of gray_main (dynamically-allocated arrays)
2021-12-15 02:31:09 +01:00
drhotjava, drhotpav, ratjamx, ratjbmx
merge graysum and gray Note that graysum, now as sum_mode, still doesn't support multipass.
2021-12-15 02:30:55 +01:00
end do
Fix the summation mode + temporary fix for file unit numbers - Add missing array allocations - Add parameter for varying number of columns in input files - Change output unit numbers (dirty fix. Original units created an empty named file, but wrote in default named fort.* files)
2022-11-24 23:37:29 +01:00
do i=-2,n
src: use derived type arguments (work in progress) This change structures the arguments of most functions, in particular gray_main, into well-defined categories using derived types. All types are defined in the gray_params.f90 (location subject to change) and are organised as follows: gray_parameters (statically allocated data) ├── antenna_parameters ├── ecrh_cd_parameters ├── equilibrium_parameters ├── misc_parameters ├── output_parameters ├── profiles_parameters └── raytracing_parameters gray_data - inputs of gray_main (dynamically-allocated arrays) ├── equilibrium_data └── profiles_data gray_results - outputs of gray_main (dynamically-allocated arrays)
2021-12-15 02:31:09 +01:00
close(100 + i)
end do
Fix the summation mode + temporary fix for file unit numbers - Add missing array allocations - Add parameter for varying number of columns in input files - Change output unit numbers (dirty fix. Original units created an empty named file, but wrote in default named fort.* files)
2022-11-24 23:37:29 +01:00
deallocate(jphi, currins, pins, rtin, rpin)
deallocate(extracol)
add option to set parameters from the command-line
2022-04-29 01:52:50 +02:00
deallocate(opts%params_file)
src: use derived type arguments (work in progress) This change structures the arguments of most functions, in particular gray_main, into well-defined categories using derived types. All types are defined in the gray_params.f90 (location subject to change) and are organised as follows: gray_parameters (statically allocated data) ├── antenna_parameters ├── ecrh_cd_parameters ├── equilibrium_parameters ├── misc_parameters ├── output_parameters ├── profiles_parameters └── raytracing_parameters gray_data - inputs of gray_main (dynamically-allocated arrays) ├── equilibrium_data └── profiles_data gray_results - outputs of gray_main (dynamically-allocated arrays)
2021-12-15 02:31:09 +01:00
end block sum
merge graysum and gray Note that graysum, now as sum_mode, still doesn't support multipass.
2021-12-15 02:30:55 +01:00
else
src: use the logging system everywhere
2021-12-18 18:57:38 +01:00
call gray_main(params, data, results, err)
merge graysum and gray Note that graysum, now as sum_mode, still doesn't support multipass.
2021-12-15 02:30:55 +01:00
end if
src: use derived type arguments (work in progress) This change structures the arguments of most functions, in particular gray_main, into well-defined categories using derived types. All types are defined in the gray_params.f90 (location subject to change) and are organised as follows: gray_parameters (statically allocated data) ├── antenna_parameters ├── ecrh_cd_parameters ├── equilibrium_parameters ├── misc_parameters ├── output_parameters ├── profiles_parameters └── raytracing_parameters gray_data - inputs of gray_main (dynamically-allocated arrays) ├── equilibrium_data └── profiles_data gray_results - outputs of gray_main (dynamically-allocated arrays)
2021-12-15 02:31:09 +01:00
src: use the logging system everywhere
2021-12-18 18:57:38 +01:00
print_res: block
character(256) :: msg
write(msg, '(a,g0.3," MW")') 'total absoption: P=', results%pabs
call log_message(msg, level=INFO, mod='main')
write(msg, '(a,g0.3," kA")') 'total current drive: I=', results%icd * 1.0e3_wp_
call log_message(msg, level=INFO, mod='main')
end block print_res
src: use derived type arguments (work in progress) This change structures the arguments of most functions, in particular gray_main, into well-defined categories using derived types. All types are defined in the gray_params.f90 (location subject to change) and are organised as follows: gray_parameters (statically allocated data) ├── antenna_parameters ├── ecrh_cd_parameters ├── equilibrium_parameters ├── misc_parameters ├── output_parameters ├── profiles_parameters └── raytracing_parameters gray_data - inputs of gray_main (dynamically-allocated arrays) ├── equilibrium_data └── profiles_data gray_results - outputs of gray_main (dynamically-allocated arrays)
2021-12-15 02:31:09 +01:00
! Free memory
call deinit_equilibrium(data%equilibrium)
call deinit_profiles(data%profiles)
call deinit_misc
add option to set parameters from the command-line
2022-04-29 01:52:50 +02:00
call deinit_cli_options(opts)
src: use derived type arguments (work in progress) This change structures the arguments of most functions, in particular gray_main, into well-defined categories using derived types. All types are defined in the gray_params.f90 (location subject to change) and are organised as follows: gray_parameters (statically allocated data) ├── antenna_parameters ├── ecrh_cd_parameters ├── equilibrium_parameters ├── misc_parameters ├── output_parameters ├── profiles_parameters └── raytracing_parameters gray_data - inputs of gray_main (dynamically-allocated arrays) ├── equilibrium_data └── profiles_data gray_results - outputs of gray_main (dynamically-allocated arrays)
2021-12-15 02:31:09 +01:00
deallocate(results%dpdv, results%jcd)
Close open units on exit to flush the buffer
2021-12-22 23:45:30 +01:00
call close_units
src: use derived type arguments (work in progress) This change structures the arguments of most functions, in particular gray_main, into well-defined categories using derived types. All types are defined in the gray_params.f90 (location subject to change) and are organised as follows: gray_parameters (statically allocated data) ├── antenna_parameters ├── ecrh_cd_parameters ├── equilibrium_parameters ├── misc_parameters ├── output_parameters ├── profiles_parameters └── raytracing_parameters gray_data - inputs of gray_main (dynamically-allocated arrays) ├── equilibrium_data └── profiles_data gray_results - outputs of gray_main (dynamically-allocated arrays)
2021-12-15 02:31:09 +01:00
contains
call exit on errors only in main
2023-09-12 16:29:09 +02:00
subroutine init_equilibrium(params, data, err)
src: use derived type arguments (work in progress) This change structures the arguments of most functions, in particular gray_main, into well-defined categories using derived types. All types are defined in the gray_params.f90 (location subject to change) and are organised as follows: gray_parameters (statically allocated data) ├── antenna_parameters ├── ecrh_cd_parameters ├── equilibrium_parameters ├── misc_parameters ├── output_parameters ├── profiles_parameters └── raytracing_parameters gray_data - inputs of gray_main (dynamically-allocated arrays) ├── equilibrium_data └── profiles_data gray_results - outputs of gray_main (dynamically-allocated arrays)
2021-12-15 02:31:09 +01:00
! Reads the MHD equilibrium file (either in the G-EQDSK format
! or an analytical description) and initialises the respective
! GRAY parameters and data.
src/main.f90: use enums
2024-01-29 02:09:27 +01:00
use gray_params, only : EQ_VACUUM, EQ_ANALYTICAL, EQ_EQDSK_FULL, EQ_EQDSK_PARTIAL
src: use derived type arguments (work in progress) This change structures the arguments of most functions, in particular gray_main, into well-defined categories using derived types. All types are defined in the gray_params.f90 (location subject to change) and are organised as follows: gray_parameters (statically allocated data) ├── antenna_parameters ├── ecrh_cd_parameters ├── equilibrium_parameters ├── misc_parameters ├── output_parameters ├── profiles_parameters └── raytracing_parameters gray_data - inputs of gray_main (dynamically-allocated arrays) ├── equilibrium_data └── profiles_data gray_results - outputs of gray_main (dynamically-allocated arrays)
2021-12-15 02:31:09 +01:00
use equilibrium, only : read_equil_an, read_eqdsk, change_cocos, &
simplify handling of splines This adds a new `splines` module which implements a high-level interface for creating and evaluating splines and rewrite almost all modules to use it. Also, notably: 1. both `simplespline` and DIERCKX splines can now used with a uniform interface 2. most complexity due to handling working space arrays is gone 3. memory management has been significantly simplified too
2022-12-18 14:09:40 +01:00
set_equil_an, set_equil_spline, scale_equil
rework the analytical model This change modifies the analytical equilibrium in order to simplify the computation of the poloidal flux normalization and the derivatives. In the power law parametrisation of the safety factor, ρ_t is replaced with ρ_p and, similarly, the normalised poloidal radius is now identified with ρ_p, instead of ρ_t. With the same parameters (q₀,q₁,α...), this choice slightly changes the plasma current distribution, but enables us to obtain a closed form for ψ_a = ψ(r=a) and the relation ρ_t(ρ_p). In fact, both expressions are now obtained by integrating the q(ρ_p), instead of 1/q(ρ_t), which has no elementary antiderivative. As the normalisation is now computed exactly, the values of the normalised flux ψ_n = ψ/ψ_a and the gradient ∇ψ (entering the raytracing equations in X and ∇X, respectively) are computed to the same precision. Previously, ψ_n was computed to a lower precision due to the use of a simple trapezoid integration of 1/q(ρ_p) for ψ_a, while ∇ψ was computed up to machine precision using an exact formula. This error effectively caused a very slight decoupling between X=ω_p²/ω² and ∇X that introduced a systematic error in the numerical solution of the raytracing equations. The error manifests itself as a bias with a weak dependency on X in the values taken by the dispersion function Λ(r̅, n̅) on the phase-space points generated by the integrator. More specifically, lim h→0 Λ(r̅_i, n̅_i) = -kX(r̅_i) where h is the integrator step size; r̅_i is the position at the i-th step; k ≈ -3.258⋅10⁻⁵ and depends only on the number of points used to perform the trapedoid integral for ψ_a (as ~ 1/n²). After this change Λ behaves consistently with being a conserved quantity (zero) up to the cumulative integration error of the 4° order Runge-Kutta method. In fact we now have that: Λ(r̅_i, n̅_i) ∝ - h⁴ ‖∂⁴X(r̅_i)/∂r̅⁴‖ It must be said that within this model the relation ρ_p(ρ_t) can't be computed analytically (inverting ρ_t(ρ_p) produces a trascendental equation of the form b = x + c x^α). However, this relation is not necessary for raytracing and is easily solved, up to machine precision, using minpack. In addition, this change also makes the model consistetly use the cocos=3 and fully implements the ability to force the signs of I_p, B_φ (via equilibrium.sgni,sgnb) and rescaling the field (via equilibrium.factb).
2023-10-11 17:29:24 +02:00
use logger, only : log_debug
src: use derived type arguments (work in progress) This change structures the arguments of most functions, in particular gray_main, into well-defined categories using derived types. All types are defined in the gray_params.f90 (location subject to change) and are organised as follows: gray_parameters (statically allocated data) ├── antenna_parameters ├── ecrh_cd_parameters ├── equilibrium_parameters ├── misc_parameters ├── output_parameters ├── profiles_parameters └── raytracing_parameters gray_data - inputs of gray_main (dynamically-allocated arrays) ├── equilibrium_data └── profiles_data gray_results - outputs of gray_main (dynamically-allocated arrays)
2021-12-15 02:31:09 +01:00
! subroutine arguments
type(gray_parameters), intent(inout) :: params
type(gray_data), intent(out) :: data
call exit on errors only in main
2023-09-12 16:29:09 +02:00
integer, intent(out) :: err
src: use derived type arguments (work in progress) This change structures the arguments of most functions, in particular gray_main, into well-defined categories using derived types. All types are defined in the gray_params.f90 (location subject to change) and are organised as follows: gray_parameters (statically allocated data) ├── antenna_parameters ├── ecrh_cd_parameters ├── equilibrium_parameters ├── misc_parameters ├── output_parameters ├── profiles_parameters └── raytracing_parameters gray_data - inputs of gray_main (dynamically-allocated arrays) ├── equilibrium_data └── profiles_data gray_results - outputs of gray_main (dynamically-allocated arrays)
2021-12-15 02:31:09 +01:00
src/main.f90: use enums
2024-01-29 02:09:27 +01:00
select case (params%equilibrium%iequil)
case (EQ_VACUUM)
call log_debug('vacuum, no MHD equilibrium', &
mod='main', proc='init_equilibrium')
case (EQ_ANALYTICAL)
call log_debug('loading analytical file', &
mod='main', proc='init_equilibrium')
call read_equil_an(params%equilibrium%filenm, &
params%raytracing%ipass, &
data%equilibrium, err)
if (err /= 0) return
case (EQ_EQDSK_FULL, EQ_EQDSK_PARTIAL)
call log_debug('loading G-EQDK file', &
mod='main', proc='init_equilibrium')
call read_eqdsk(params%equilibrium, data%equilibrium, err)
if (err /= 0) return
call change_cocos(data%equilibrium, params%equilibrium%icocos, 3)
end select
src: use derived type arguments (work in progress) This change structures the arguments of most functions, in particular gray_main, into well-defined categories using derived types. All types are defined in the gray_params.f90 (location subject to change) and are organised as follows: gray_parameters (statically allocated data) ├── antenna_parameters ├── ecrh_cd_parameters ├── equilibrium_parameters ├── misc_parameters ├── output_parameters ├── profiles_parameters └── raytracing_parameters gray_data - inputs of gray_main (dynamically-allocated arrays) ├── equilibrium_data └── profiles_data gray_results - outputs of gray_main (dynamically-allocated arrays)
2021-12-15 02:31:09 +01:00
! Rescale B, I and/or force their signs
simplify handling of splines This adds a new `splines` module which implements a high-level interface for creating and evaluating splines and rewrite almost all modules to use it. Also, notably: 1. both `simplespline` and DIERCKX splines can now used with a uniform interface 2. most complexity due to handling working space arrays is gone 3. memory management has been significantly simplified too
2022-12-18 14:09:40 +01:00
call scale_equil(params%equilibrium, data%equilibrium)
src: use derived type arguments (work in progress) This change structures the arguments of most functions, in particular gray_main, into well-defined categories using derived types. All types are defined in the gray_params.f90 (location subject to change) and are organised as follows: gray_parameters (statically allocated data) ├── antenna_parameters ├── ecrh_cd_parameters ├── equilibrium_parameters ├── misc_parameters ├── output_parameters ├── profiles_parameters └── raytracing_parameters gray_data - inputs of gray_main (dynamically-allocated arrays) ├── equilibrium_data └── profiles_data gray_results - outputs of gray_main (dynamically-allocated arrays)
2021-12-15 02:31:09 +01:00
src/main.f90: use enums
2024-01-29 02:09:27 +01:00
! Set global variables
select case (params%equilibrium%iequil)
src/equilibrium.f90: use enums
2024-01-30 10:14:24 +01:00
case (EQ_ANALYTICAL)
src/main.f90: use enums
2024-01-29 02:09:27 +01:00
call set_equil_an
case (EQ_EQDSK_FULL, EQ_EQDSK_PARTIAL)
call log_debug('computing splines...', mod='main', proc='init_equilibrium')
call set_equil_spline(params%equilibrium, data%equilibrium, err)
if (err /= 0) return
call log_debug('splines computed', mod='main', proc='init_equilibrium')
end select
src: use derived type arguments (work in progress) This change structures the arguments of most functions, in particular gray_main, into well-defined categories using derived types. All types are defined in the gray_params.f90 (location subject to change) and are organised as follows: gray_parameters (statically allocated data) ├── antenna_parameters ├── ecrh_cd_parameters ├── equilibrium_parameters ├── misc_parameters ├── output_parameters ├── profiles_parameters └── raytracing_parameters gray_data - inputs of gray_main (dynamically-allocated arrays) ├── equilibrium_data └── profiles_data gray_results - outputs of gray_main (dynamically-allocated arrays)
2021-12-15 02:31:09 +01:00
end subroutine init_equilibrium
subroutine deinit_equilibrium(data)
! Free all memory allocated by the init_equilibrium subroutine.
use gray_params, only : equilibrium_data
simplify handling of splines This adds a new `splines` module which implements a high-level interface for creating and evaluating splines and rewrite almost all modules to use it. Also, notably: 1. both `simplespline` and DIERCKX splines can now used with a uniform interface 2. most complexity due to handling working space arrays is gone 3. memory management has been significantly simplified too
2022-12-18 14:09:40 +01:00
use equilibrium, only : unset_equil_spline
src: use derived type arguments (work in progress) This change structures the arguments of most functions, in particular gray_main, into well-defined categories using derived types. All types are defined in the gray_params.f90 (location subject to change) and are organised as follows: gray_parameters (statically allocated data) ├── antenna_parameters ├── ecrh_cd_parameters ├── equilibrium_parameters ├── misc_parameters ├── output_parameters ├── profiles_parameters └── raytracing_parameters gray_data - inputs of gray_main (dynamically-allocated arrays) ├── equilibrium_data └── profiles_data gray_results - outputs of gray_main (dynamically-allocated arrays)
2021-12-15 02:31:09 +01:00
! subroutine arguments
type(equilibrium_data), intent(inout) :: data
! Free the MHD equilibrium arrays
if (allocated(data%rv)) deallocate(data%rv, data%zv, data%fpol, data%qpsi)
if (allocated(data%psin)) deallocate(data%psin, data%psinr)
if (allocated(data%rbnd)) deallocate(data%rbnd, data%zbnd)
if (allocated(data%rlim)) deallocate(data%rlim, data%zlim)
! Unset global variables of the `equilibrium` module
convert remaining subroutines to derived types - converts analytical profiles/equilibrium subroutines to derived types - use less undecipherable and consistent names The subroutine names have changed as follows: set_prfspl → set_profiles_spline set_prfan → set_profiles_an unset_prfspl → unset_profiles_spline unset_prfan → unset_profiles_an set_equian → set_equil_an set_eqspl → set_equil_spline unset_equian → unset_equil_an unset_eqspl → unset_equil_spline unset_rhospl → unset_rho_spline
2022-05-11 00:30:34 +02:00
call unset_equil_spline
src: use derived type arguments (work in progress) This change structures the arguments of most functions, in particular gray_main, into well-defined categories using derived types. All types are defined in the gray_params.f90 (location subject to change) and are organised as follows: gray_parameters (statically allocated data) ├── antenna_parameters ├── ecrh_cd_parameters ├── equilibrium_parameters ├── misc_parameters ├── output_parameters ├── profiles_parameters └── raytracing_parameters gray_data - inputs of gray_main (dynamically-allocated arrays) ├── equilibrium_data └── profiles_data gray_results - outputs of gray_main (dynamically-allocated arrays)
2021-12-15 02:31:09 +01:00
end subroutine deinit_equilibrium
call exit on errors only in main
2023-09-12 16:29:09 +02:00
subroutine init_profiles(params, factb, launch_pos, data, err)
src: use derived type arguments (work in progress) This change structures the arguments of most functions, in particular gray_main, into well-defined categories using derived types. All types are defined in the gray_params.f90 (location subject to change) and are organised as follows: gray_parameters (statically allocated data) ├── antenna_parameters ├── ecrh_cd_parameters ├── equilibrium_parameters ├── misc_parameters ├── output_parameters ├── profiles_parameters └── raytracing_parameters gray_data - inputs of gray_main (dynamically-allocated arrays) ├── equilibrium_data └── profiles_data gray_results - outputs of gray_main (dynamically-allocated arrays)
2021-12-15 02:31:09 +01:00
! Reads the plasma kinetic profiles file (containing the elecron
! temperature, density and plasma effective charge) and initialises
! the respective GRAY data structure.
src/main.f90: use enums
2024-01-29 02:09:27 +01:00
use gray_params, only : profiles_parameters, profiles_data, &
RHO_TOR, RHO_POL, RHO_PSI, &
PROF_ANALYTIC, PROF_NUMERIC
rework the analytical model This change modifies the analytical equilibrium in order to simplify the computation of the poloidal flux normalization and the derivatives. In the power law parametrisation of the safety factor, ρ_t is replaced with ρ_p and, similarly, the normalised poloidal radius is now identified with ρ_p, instead of ρ_t. With the same parameters (q₀,q₁,α...), this choice slightly changes the plasma current distribution, but enables us to obtain a closed form for ψ_a = ψ(r=a) and the relation ρ_t(ρ_p). In fact, both expressions are now obtained by integrating the q(ρ_p), instead of 1/q(ρ_t), which has no elementary antiderivative. As the normalisation is now computed exactly, the values of the normalised flux ψ_n = ψ/ψ_a and the gradient ∇ψ (entering the raytracing equations in X and ∇X, respectively) are computed to the same precision. Previously, ψ_n was computed to a lower precision due to the use of a simple trapezoid integration of 1/q(ρ_p) for ψ_a, while ∇ψ was computed up to machine precision using an exact formula. This error effectively caused a very slight decoupling between X=ω_p²/ω² and ∇X that introduced a systematic error in the numerical solution of the raytracing equations. The error manifests itself as a bias with a weak dependency on X in the values taken by the dispersion function Λ(r̅, n̅) on the phase-space points generated by the integrator. More specifically, lim h→0 Λ(r̅_i, n̅_i) = -kX(r̅_i) where h is the integrator step size; r̅_i is the position at the i-th step; k ≈ -3.258⋅10⁻⁵ and depends only on the number of points used to perform the trapedoid integral for ψ_a (as ~ 1/n²). After this change Λ behaves consistently with being a conserved quantity (zero) up to the cumulative integration error of the 4° order Runge-Kutta method. In fact we now have that: Λ(r̅_i, n̅_i) ∝ - h⁴ ‖∂⁴X(r̅_i)/∂r̅⁴‖ It must be said that within this model the relation ρ_p(ρ_t) can't be computed analytically (inverting ρ_t(ρ_p) produces a trascendental equation of the form b = x + c x^α). However, this relation is not necessary for raytracing and is easily solved, up to machine precision, using minpack. In addition, this change also makes the model consistetly use the cocos=3 and fully implements the ability to force the signs of I_p, B_φ (via equilibrium.sgni,sgnb) and rescaling the field (via equilibrium.factb).
2023-10-11 17:29:24 +02:00
use equilibrium, only : frhopol
src/coreprofiles.f90: use derived types
2021-12-15 02:31:10 +01:00
use coreprofiles, only : read_profiles_an, read_profiles, &
convert remaining subroutines to derived types - converts analytical profiles/equilibrium subroutines to derived types - use less undecipherable and consistent names The subroutine names have changed as follows: set_prfspl → set_profiles_spline set_prfan → set_profiles_an unset_prfspl → unset_profiles_spline unset_prfan → unset_profiles_an set_equian → set_equil_an set_eqspl → set_equil_spline unset_equian → unset_equil_an unset_eqspl → unset_equil_spline unset_rhospl → unset_rho_spline
2022-05-11 00:30:34 +02:00
scale_profiles, set_profiles_an, &
set_profiles_spline
add some useful debug messages
2022-05-26 02:33:55 +02:00
use logger, only : log_debug
src: use derived type arguments (work in progress) This change structures the arguments of most functions, in particular gray_main, into well-defined categories using derived types. All types are defined in the gray_params.f90 (location subject to change) and are organised as follows: gray_parameters (statically allocated data) ├── antenna_parameters ├── ecrh_cd_parameters ├── equilibrium_parameters ├── misc_parameters ├── output_parameters ├── profiles_parameters └── raytracing_parameters gray_data - inputs of gray_main (dynamically-allocated arrays) ├── equilibrium_data └── profiles_data gray_results - outputs of gray_main (dynamically-allocated arrays)
2021-12-15 02:31:09 +01:00
! subroutine arguments
src/coreprofiles: make psnbnd fully automatic 1. Fix the mismatch between the psnbnd in coreprofiles and gray_core. This happens whenever gray overrides the externally provided one (i.e. the density tail would become negative before psnbnd and is so rescaled to end exactly on the zero). 2. Make psnbnd no longer required by always computing it as in 1. It hasn't been removed, because gray_params.data is sacrosant, but it no longer has any effect. 3. Cleanup: mark public functions, restructure the global variables into three categories; add comments explaining the analytical profiles format, formulae and how the polynomial tail is computed.
2022-05-21 22:56:57 +02:00
type(profiles_parameters), intent(inout) :: params
real(wp_), intent(in) :: factb
real(wp_), intent(in) :: launch_pos(3)
type(profiles_data), intent(out) :: data
call exit on errors only in main
2023-09-12 16:29:09 +02:00
integer, intent(out) :: err
src: use derived type arguments (work in progress) This change structures the arguments of most functions, in particular gray_main, into well-defined categories using derived types. All types are defined in the gray_params.f90 (location subject to change) and are organised as follows: gray_parameters (statically allocated data) ├── antenna_parameters ├── ecrh_cd_parameters ├── equilibrium_parameters ├── misc_parameters ├── output_parameters ├── profiles_parameters └── raytracing_parameters gray_data - inputs of gray_main (dynamically-allocated arrays) ├── equilibrium_data └── profiles_data gray_results - outputs of gray_main (dynamically-allocated arrays)
2021-12-15 02:31:09 +01:00
rework the analytical model This change modifies the analytical equilibrium in order to simplify the computation of the poloidal flux normalization and the derivatives. In the power law parametrisation of the safety factor, ρ_t is replaced with ρ_p and, similarly, the normalised poloidal radius is now identified with ρ_p, instead of ρ_t. With the same parameters (q₀,q₁,α...), this choice slightly changes the plasma current distribution, but enables us to obtain a closed form for ψ_a = ψ(r=a) and the relation ρ_t(ρ_p). In fact, both expressions are now obtained by integrating the q(ρ_p), instead of 1/q(ρ_t), which has no elementary antiderivative. As the normalisation is now computed exactly, the values of the normalised flux ψ_n = ψ/ψ_a and the gradient ∇ψ (entering the raytracing equations in X and ∇X, respectively) are computed to the same precision. Previously, ψ_n was computed to a lower precision due to the use of a simple trapezoid integration of 1/q(ρ_p) for ψ_a, while ∇ψ was computed up to machine precision using an exact formula. This error effectively caused a very slight decoupling between X=ω_p²/ω² and ∇X that introduced a systematic error in the numerical solution of the raytracing equations. The error manifests itself as a bias with a weak dependency on X in the values taken by the dispersion function Λ(r̅, n̅) on the phase-space points generated by the integrator. More specifically, lim h→0 Λ(r̅_i, n̅_i) = -kX(r̅_i) where h is the integrator step size; r̅_i is the position at the i-th step; k ≈ -3.258⋅10⁻⁵ and depends only on the number of points used to perform the trapedoid integral for ψ_a (as ~ 1/n²). After this change Λ behaves consistently with being a conserved quantity (zero) up to the cumulative integration error of the 4° order Runge-Kutta method. In fact we now have that: Λ(r̅_i, n̅_i) ∝ - h⁴ ‖∂⁴X(r̅_i)/∂r̅⁴‖ It must be said that within this model the relation ρ_p(ρ_t) can't be computed analytically (inverting ρ_t(ρ_p) produces a trascendental equation of the form b = x + c x^α). However, this relation is not necessary for raytracing and is easily solved, up to machine precision, using minpack. In addition, this change also makes the model consistetly use the cocos=3 and fully implements the ability to force the signs of I_p, B_φ (via equilibrium.sgni,sgnb) and rescaling the field (via equilibrium.factb).
2023-10-11 17:29:24 +02:00
! local variables
integer :: i
src/main.f90: use enums
2024-01-29 02:09:27 +01:00
select case (params%iprof)
case (PROF_ANALYTIC)
call log_debug('loading analytical file', &
mod='main', proc='init_profiles')
call read_profiles_an(params%filenm, data, err)
if (err /= 0) return
case (PROF_NUMERIC)
call log_debug('loading numerical file', &
mod='main', proc='init_profiles')
call read_profiles(params%filenm, data, err)
if (err /= 0) return
! Convert psrad to ψ
select case (params%irho)
case (RHO_TOR) ! psrad is ρ_t = √Φ (toroidal flux)
data%psrad = [(frhopol(data%psrad(i))**2, i=1,size(data%psrad))]
case (RHO_POL) ! psrad is ρ_p = √ψ (poloidal flux)
data%psrad = data%psrad**2
case (RHO_PSI) ! psrad is already ψ
end select
end select
src/coreprofiles.f90: use derived types
2021-12-15 02:31:10 +01:00
src: use derived type arguments (work in progress) This change structures the arguments of most functions, in particular gray_main, into well-defined categories using derived types. All types are defined in the gray_params.f90 (location subject to change) and are organised as follows: gray_parameters (statically allocated data) ├── antenna_parameters ├── ecrh_cd_parameters ├── equilibrium_parameters ├── misc_parameters ├── output_parameters ├── profiles_parameters └── raytracing_parameters gray_data - inputs of gray_main (dynamically-allocated arrays) ├── equilibrium_data └── profiles_data gray_results - outputs of gray_main (dynamically-allocated arrays)
2021-12-15 02:31:09 +01:00
! Rescale input data
src/coreprofiles.f90: use derived types
2021-12-15 02:31:10 +01:00
call scale_profiles(params, factb, data)
src: use derived type arguments (work in progress) This change structures the arguments of most functions, in particular gray_main, into well-defined categories using derived types. All types are defined in the gray_params.f90 (location subject to change) and are organised as follows: gray_parameters (statically allocated data) ├── antenna_parameters ├── ecrh_cd_parameters ├── equilibrium_parameters ├── misc_parameters ├── output_parameters ├── profiles_parameters └── raytracing_parameters gray_data - inputs of gray_main (dynamically-allocated arrays) ├── equilibrium_data └── profiles_data gray_results - outputs of gray_main (dynamically-allocated arrays)
2021-12-15 02:31:09 +01:00
! Set global variables
src/main.f90: use enums
2024-01-29 02:09:27 +01:00
select case (params%iprof)
case (PROF_ANALYTIC)
call set_profiles_an(params, data)
case (PROF_NUMERIC)
call log_debug('computing splines...', mod='main', proc='init_profiles')
call set_profiles_spline(params, data, err, launch_pos)
call log_debug('splines computed', mod='main', proc='init_profiles')
end select
src: use derived type arguments (work in progress) This change structures the arguments of most functions, in particular gray_main, into well-defined categories using derived types. All types are defined in the gray_params.f90 (location subject to change) and are organised as follows: gray_parameters (statically allocated data) ├── antenna_parameters ├── ecrh_cd_parameters ├── equilibrium_parameters ├── misc_parameters ├── output_parameters ├── profiles_parameters └── raytracing_parameters gray_data - inputs of gray_main (dynamically-allocated arrays) ├── equilibrium_data └── profiles_data gray_results - outputs of gray_main (dynamically-allocated arrays)
2021-12-15 02:31:09 +01:00
end subroutine init_profiles
subroutine deinit_profiles(data)
! Free all memory allocated by the init_profiles subroutine.
use gray_params, only : profiles_data
convert remaining subroutines to derived types - converts analytical profiles/equilibrium subroutines to derived types - use less undecipherable and consistent names The subroutine names have changed as follows: set_prfspl → set_profiles_spline set_prfan → set_profiles_an unset_prfspl → unset_profiles_spline unset_prfan → unset_profiles_an set_equian → set_equil_an set_eqspl → set_equil_spline unset_equian → unset_equil_an unset_eqspl → unset_equil_spline unset_rhospl → unset_rho_spline
2022-05-11 00:30:34 +02:00
use coreprofiles, only : unset_profiles_spline
src: use derived type arguments (work in progress) This change structures the arguments of most functions, in particular gray_main, into well-defined categories using derived types. All types are defined in the gray_params.f90 (location subject to change) and are organised as follows: gray_parameters (statically allocated data) ├── antenna_parameters ├── ecrh_cd_parameters ├── equilibrium_parameters ├── misc_parameters ├── output_parameters ├── profiles_parameters └── raytracing_parameters gray_data - inputs of gray_main (dynamically-allocated arrays) ├── equilibrium_data └── profiles_data gray_results - outputs of gray_main (dynamically-allocated arrays)
2021-12-15 02:31:09 +01:00
! subroutine arguments
type(profiles_data), intent(inout) :: data
! Free the plasma kinetic profiles arrays
if (allocated(data%psrad)) deallocate(data%psrad)
if (allocated(data%terad)) deallocate(data%terad, data%derad, data%zfc)
! Unset global variables of the `coreprofiles` module
convert remaining subroutines to derived types - converts analytical profiles/equilibrium subroutines to derived types - use less undecipherable and consistent names The subroutine names have changed as follows: set_prfspl → set_profiles_spline set_prfan → set_profiles_an unset_prfspl → unset_profiles_spline unset_prfan → unset_profiles_an set_equian → set_equil_an set_eqspl → set_equil_spline unset_equian → unset_equil_an unset_eqspl → unset_equil_spline unset_rhospl → unset_rho_spline
2022-05-11 00:30:34 +02:00
call unset_profiles_spline
src: use derived type arguments (work in progress) This change structures the arguments of most functions, in particular gray_main, into well-defined categories using derived types. All types are defined in the gray_params.f90 (location subject to change) and are organised as follows: gray_parameters (statically allocated data) ├── antenna_parameters ├── ecrh_cd_parameters ├── equilibrium_parameters ├── misc_parameters ├── output_parameters ├── profiles_parameters └── raytracing_parameters gray_data - inputs of gray_main (dynamically-allocated arrays) ├── equilibrium_data └── profiles_data gray_results - outputs of gray_main (dynamically-allocated arrays)
2021-12-15 02:31:09 +01:00
end subroutine deinit_profiles
call exit on errors only in main
2023-09-12 16:29:09 +02:00
subroutine init_antenna(params, err)
src: use derived type arguments (work in progress) This change structures the arguments of most functions, in particular gray_main, into well-defined categories using derived types. All types are defined in the gray_params.f90 (location subject to change) and are organised as follows: gray_parameters (statically allocated data) ├── antenna_parameters ├── ecrh_cd_parameters ├── equilibrium_parameters ├── misc_parameters ├── output_parameters ├── profiles_parameters └── raytracing_parameters gray_data - inputs of gray_main (dynamically-allocated arrays) ├── equilibrium_data └── profiles_data gray_results - outputs of gray_main (dynamically-allocated arrays)
2021-12-15 02:31:09 +01:00
! Reads the wave launcher file (containing the wave frequency, launcher
! position, direction and beam description) and initialises the respective
! GRAY parameters.
use beams, only : read_beam0, read_beam1, read_beam2
src/main.f90: use enums
2024-01-29 02:09:27 +01:00
use gray_params, only : antenna_parameters, BEAM_0D, BEAM_1D, BEAM_2D
src: use derived type arguments (work in progress) This change structures the arguments of most functions, in particular gray_main, into well-defined categories using derived types. All types are defined in the gray_params.f90 (location subject to change) and are organised as follows: gray_parameters (statically allocated data) ├── antenna_parameters ├── ecrh_cd_parameters ├── equilibrium_parameters ├── misc_parameters ├── output_parameters ├── profiles_parameters └── raytracing_parameters gray_data - inputs of gray_main (dynamically-allocated arrays) ├── equilibrium_data └── profiles_data gray_results - outputs of gray_main (dynamically-allocated arrays)
2021-12-15 02:31:09 +01:00
! subroutine arguments
type(antenna_parameters), intent(inout) :: params
call exit on errors only in main
2023-09-12 16:29:09 +02:00
integer, intent(out) :: err
src: use derived type arguments (work in progress) This change structures the arguments of most functions, in particular gray_main, into well-defined categories using derived types. All types are defined in the gray_params.f90 (location subject to change) and are organised as follows: gray_parameters (statically allocated data) ├── antenna_parameters ├── ecrh_cd_parameters ├── equilibrium_parameters ├── misc_parameters ├── output_parameters ├── profiles_parameters └── raytracing_parameters gray_data - inputs of gray_main (dynamically-allocated arrays) ├── equilibrium_data └── profiles_data gray_results - outputs of gray_main (dynamically-allocated arrays)
2021-12-15 02:31:09 +01:00
! Note: α, β are loaded from gray_params.data
select case (params%ibeam)
src/main.f90: use enums
2024-01-29 02:09:27 +01:00
case (BEAM_2D)
src: use derived type arguments (work in progress) This change structures the arguments of most functions, in particular gray_main, into well-defined categories using derived types. All types are defined in the gray_params.f90 (location subject to change) and are organised as follows: gray_parameters (statically allocated data) ├── antenna_parameters ├── ecrh_cd_parameters ├── equilibrium_parameters ├── misc_parameters ├── output_parameters ├── profiles_parameters └── raytracing_parameters gray_data - inputs of gray_main (dynamically-allocated arrays) ├── equilibrium_data └── profiles_data gray_results - outputs of gray_main (dynamically-allocated arrays)
2021-12-15 02:31:09 +01:00
! 2 degrees of freedom
! w(z, α, β), 1/R(z, α, β)
! FIXME: 1st beam is always selected, iox read from table
call exit on errors only in main
2023-09-12 16:29:09 +02:00
call read_beam2(params, beamid=1, err=err)
src/main.f90: use enums
2024-01-29 02:09:27 +01:00
case (BEAM_1D)
src: use derived type arguments (work in progress) This change structures the arguments of most functions, in particular gray_main, into well-defined categories using derived types. All types are defined in the gray_params.f90 (location subject to change) and are organised as follows: gray_parameters (statically allocated data) ├── antenna_parameters ├── ecrh_cd_parameters ├── equilibrium_parameters ├── misc_parameters ├── output_parameters ├── profiles_parameters └── raytracing_parameters gray_data - inputs of gray_main (dynamically-allocated arrays) ├── equilibrium_data └── profiles_data gray_results - outputs of gray_main (dynamically-allocated arrays)
2021-12-15 02:31:09 +01:00
! 1 degree of freedom
! w(z, α), 1/R(z, α)
call exit on errors only in main
2023-09-12 16:29:09 +02:00
call read_beam1(params, err)
src/main.f90: use enums
2024-01-29 02:09:27 +01:00
case (BEAM_0D)
src: use derived type arguments (work in progress) This change structures the arguments of most functions, in particular gray_main, into well-defined categories using derived types. All types are defined in the gray_params.f90 (location subject to change) and are organised as follows: gray_parameters (statically allocated data) ├── antenna_parameters ├── ecrh_cd_parameters ├── equilibrium_parameters ├── misc_parameters ├── output_parameters ├── profiles_parameters └── raytracing_parameters gray_data - inputs of gray_main (dynamically-allocated arrays) ├── equilibrium_data └── profiles_data gray_results - outputs of gray_main (dynamically-allocated arrays)
2021-12-15 02:31:09 +01:00
! fixed w(z), 1/R(z)
call exit on errors only in main
2023-09-12 16:29:09 +02:00
call read_beam0(params, err)
src: use derived type arguments (work in progress) This change structures the arguments of most functions, in particular gray_main, into well-defined categories using derived types. All types are defined in the gray_params.f90 (location subject to change) and are organised as follows: gray_parameters (statically allocated data) ├── antenna_parameters ├── ecrh_cd_parameters ├── equilibrium_parameters ├── misc_parameters ├── output_parameters ├── profiles_parameters └── raytracing_parameters gray_data - inputs of gray_main (dynamically-allocated arrays) ├── equilibrium_data └── profiles_data gray_results - outputs of gray_main (dynamically-allocated arrays)
2021-12-15 02:31:09 +01:00
end select
end subroutine init_antenna
subroutine init_misc(params, data)
! Performs miscellanous initial tasks, before the gray_main subroutine.
src/main.f90: use enums
2024-01-29 02:09:27 +01:00
use gray_params, only : EQ_VACUUM, EQ_ANALYTICAL, &
EQ_EQDSK_FULL, EQ_EQDSK_PARTIAL
improve inside and move it to utils.f90 This slightly improves the performance of inside. For a ~100 points contour the instructions cost is reduced by ~5%.
2023-10-04 17:00:45 +02:00
use utils, only : range2rect
fix simple limiter in analytic equilibrium In the case of analytic equilibrium without a limiter contour, the simple limiter was built incorrectly due to an unnecessary conversion from cm (the equilibrium data are already in metre).
2023-09-20 15:12:17 +02:00
use limiter, only : limiter_set_globals=>set_globals
src/equilibrium.f90: use enums
2024-01-30 10:14:24 +01:00
use const_and_precisions, only : cm, comp_huge
src: use derived type arguments (work in progress) This change structures the arguments of most functions, in particular gray_main, into well-defined categories using derived types. All types are defined in the gray_params.f90 (location subject to change) and are organised as follows: gray_parameters (statically allocated data) ├── antenna_parameters ├── ecrh_cd_parameters ├── equilibrium_parameters ├── misc_parameters ├── output_parameters ├── profiles_parameters └── raytracing_parameters gray_data - inputs of gray_main (dynamically-allocated arrays) ├── equilibrium_data └── profiles_data gray_results - outputs of gray_main (dynamically-allocated arrays)
2021-12-15 02:31:09 +01:00
! subroutine arguments
type(gray_parameters), intent(inout) :: params
type(gray_data), intent(inout) :: data
fix simple limiter in analytic equilibrium In the case of analytic equilibrium without a limiter contour, the simple limiter was built incorrectly due to an unnecessary conversion from cm (the equilibrium data are already in metre).
2023-09-20 15:12:17 +02:00
! Build a basic limiter if one is not provided by equilibrium.txt
src: use derived type arguments (work in progress) This change structures the arguments of most functions, in particular gray_main, into well-defined categories using derived types. All types are defined in the gray_params.f90 (location subject to change) and are organised as follows: gray_parameters (statically allocated data) ├── antenna_parameters ├── ecrh_cd_parameters ├── equilibrium_parameters ├── misc_parameters ├── output_parameters ├── profiles_parameters └── raytracing_parameters gray_data - inputs of gray_main (dynamically-allocated arrays) ├── equilibrium_data └── profiles_data gray_results - outputs of gray_main (dynamically-allocated arrays)
2021-12-15 02:31:09 +01:00
if (.not. allocated(data%equilibrium%rlim) &
.or. params%raytracing%ipass < 0) then
fix simple limiter in analytic equilibrium In the case of analytic equilibrium without a limiter contour, the simple limiter was built incorrectly due to an unnecessary conversion from cm (the equilibrium data are already in metre).
2023-09-20 15:12:17 +02:00
! Restore sign of ipass
params%raytracing%ipass = abs(params%raytracing%ipass)
allocate(data%equilibrium%rlim(5))
allocate(data%equilibrium%zlim(5))
src: use derived type arguments (work in progress) This change structures the arguments of most functions, in particular gray_main, into well-defined categories using derived types. All types are defined in the gray_params.f90 (location subject to change) and are organised as follows: gray_parameters (statically allocated data) ├── antenna_parameters ├── ecrh_cd_parameters ├── equilibrium_parameters ├── misc_parameters ├── output_parameters ├── profiles_parameters └── raytracing_parameters gray_data - inputs of gray_main (dynamically-allocated arrays) ├── equilibrium_data └── profiles_data gray_results - outputs of gray_main (dynamically-allocated arrays)
2021-12-15 02:31:09 +01:00
block
fix simple limiter in analytic equilibrium In the case of analytic equilibrium without a limiter contour, the simple limiter was built incorrectly due to an unnecessary conversion from cm (the equilibrium data are already in metre).
2023-09-20 15:12:17 +02:00
real(wp_) :: R_launch, z_launch, R_max, delta_z
! Launcher coordinates
R_launch = norm2(params%antenna%pos(1:2)) * cm
z_launch = params%antenna%pos(3) * cm
! Max vertical distance a ray can travel
delta_z = abs(params%raytracing%ipass) * &
params%raytracing%dst * params%raytracing%nstep * cm
! Max radius, either due to the plasma extent or equilibrium grid
src/main.f90: use enums
2024-01-29 02:09:27 +01:00
select case (params%equilibrium%iequil)
src/equilibrium.f90: use enums
2024-01-30 10:14:24 +01:00
case (EQ_VACUUM)
! Use a very large R, ~ unbounded
R_max = comp_huge
case (EQ_ANALYTICAL)
src/main.f90: use enums
2024-01-29 02:09:27 +01:00
! use R₀+a
block
use equilibrium, only : model
R_max = model%R0 + model%a
end block
case (EQ_EQDSK_FULL, EQ_EQDSK_PARTIAL)
! use max R of the grid
R_max = data%equilibrium%rv(size(data%equilibrium%rv))
end select
fix simple limiter in analytic equilibrium In the case of analytic equilibrium without a limiter contour, the simple limiter was built incorrectly due to an unnecessary conversion from cm (the equilibrium data are already in metre).
2023-09-20 15:12:17 +02:00
! Avoid clipping out the launcher
R_max = max(R_launch, R_max)
! Convert to a list of R,z:
!
! (R_wall, z_launch+Δz)╔═════╗(R_max, z_launch+Δz)
! ║4 3║
! ║ ║
! ║1 2║
! (R_wall, z_launch-Δz)╚═════╝(R_max, z_launch-Δz)
!
call range2rect(xmin=params%misc%rwall, xmax=R_max, &
ymin=z_launch - delta_z, ymax=z_launch + delta_z, &
improve inside and move it to utils.f90 This slightly improves the performance of inside. For a ~100 points contour the instructions cost is reduced by ~5%.
2023-10-04 17:00:45 +02:00
x=data%equilibrium%rlim, y=data%equilibrium%zlim)
src: use derived type arguments (work in progress) This change structures the arguments of most functions, in particular gray_main, into well-defined categories using derived types. All types are defined in the gray_params.f90 (location subject to change) and are organised as follows: gray_parameters (statically allocated data) ├── antenna_parameters ├── ecrh_cd_parameters ├── equilibrium_parameters ├── misc_parameters ├── output_parameters ├── profiles_parameters └── raytracing_parameters gray_data - inputs of gray_main (dynamically-allocated arrays) ├── equilibrium_data └── profiles_data gray_results - outputs of gray_main (dynamically-allocated arrays)
2021-12-15 02:31:09 +01:00
end block
end if
! Set the global variables of the `limiter` module
call limiter_set_globals(data%equilibrium)
end subroutine init_misc
src/main.f90: fix typo
2022-04-19 23:09:24 +02:00
src: use derived type arguments (work in progress) This change structures the arguments of most functions, in particular gray_main, into well-defined categories using derived types. All types are defined in the gray_params.f90 (location subject to change) and are organised as follows: gray_parameters (statically allocated data) ├── antenna_parameters ├── ecrh_cd_parameters ├── equilibrium_parameters ├── misc_parameters ├── output_parameters ├── profiles_parameters └── raytracing_parameters gray_data - inputs of gray_main (dynamically-allocated arrays) ├── equilibrium_data └── profiles_data gray_results - outputs of gray_main (dynamically-allocated arrays)
2021-12-15 02:31:09 +01:00
subroutine deinit_misc
! Free all memory allocated by the init_misc subroutine.
use limiter, only : limiter_unset_globals=>unset_globals
! Unset the global variables of the `limiter` module
call limiter_unset_globals
end subroutine deinit_misc
subroutine sum_profiles(params, jphi, jcd, dpdv, currins, pins, pabs, icd, &
jphip, dpdvp, rhotj, rhotjava, rhotp, rhotpav, &
drhotjava, drhotpav, ratjamx, ratjbmx)
use const_and_precisions, only : zero, degree
convert remaining subroutines to derived types - converts analytical profiles/equilibrium subroutines to derived types - use less undecipherable and consistent names The subroutine names have changed as follows: set_prfspl → set_profiles_spline set_prfan → set_profiles_an unset_prfspl → unset_profiles_spline unset_prfan → unset_profiles_an set_equian → set_equil_an set_eqspl → set_equil_spline unset_equian → unset_equil_an unset_eqspl → unset_equil_spline unset_rhospl → unset_rho_spline
2022-05-11 00:30:34 +02:00
use coreprofiles, only : set_profiles_an, set_profiles_spline, &
temp, fzeff
src: use derived type arguments (work in progress) This change structures the arguments of most functions, in particular gray_main, into well-defined categories using derived types. All types are defined in the gray_params.f90 (location subject to change) and are organised as follows: gray_parameters (statically allocated data) ├── antenna_parameters ├── ecrh_cd_parameters ├── equilibrium_parameters ├── misc_parameters ├── output_parameters ├── profiles_parameters └── raytracing_parameters gray_data - inputs of gray_main (dynamically-allocated arrays) ├── equilibrium_data └── profiles_data gray_results - outputs of gray_main (dynamically-allocated arrays)
2021-12-15 02:31:09 +01:00
use dispersion, only : expinit
src/gray_core.f90: cleanup - add some comments - annotate loops - indent comments - remove trailing whitespace - reduce usage of opaque global variables - use Fortran 90 logical operators - use Fortran 2003 array syntax
2022-05-10 12:36:37 +02:00
use gray_params, only : gray_parameters, print_parameters
src: use derived type arguments (work in progress) This change structures the arguments of most functions, in particular gray_main, into well-defined categories using derived types. All types are defined in the gray_params.f90 (location subject to change) and are organised as follows: gray_parameters (statically allocated data) ├── antenna_parameters ├── ecrh_cd_parameters ├── equilibrium_parameters ├── misc_parameters ├── output_parameters ├── profiles_parameters └── raytracing_parameters gray_data - inputs of gray_main (dynamically-allocated arrays) ├── equilibrium_data └── profiles_data gray_results - outputs of gray_main (dynamically-allocated arrays)
2021-12-15 02:31:09 +01:00
use beams, only : launchangles2n, xgygcoeff
use magsurf_data, only : flux_average, dealloc_surfvec
simplify memory management This change replaces pointers with automatic arrays to greatly simplify the memory management in the main subroutine: - All arrays are defined in a single location and with their final dimension explicitely shown. - The allocation/deallocation is performed automatically when entering/leaving the gray_main routine.
2024-04-23 17:00:40 +02:00
use beamdata, only : init_btr
src: use derived type arguments (work in progress) This change structures the arguments of most functions, in particular gray_main, into well-defined categories using derived types. All types are defined in the gray_params.f90 (location subject to change) and are organised as follows: gray_parameters (statically allocated data) ├── antenna_parameters ├── ecrh_cd_parameters ├── equilibrium_parameters ├── misc_parameters ├── output_parameters ├── profiles_parameters └── raytracing_parameters gray_data - inputs of gray_main (dynamically-allocated arrays) ├── equilibrium_data └── profiles_data gray_results - outputs of gray_main (dynamically-allocated arrays)
2021-12-15 02:31:09 +01:00
use pec, only : pec_init, postproc_profiles, dealloc_pec, &
rhop_tab, rhot_tab
src/graycore.f90 -> src/gray_core.f90 Rename for consistency with other modules.
2021-12-15 02:31:14 +01:00
use gray_core, only : print_headers, print_finals, print_pec, &
src: use derived type arguments (work in progress) This change structures the arguments of most functions, in particular gray_main, into well-defined categories using derived types. All types are defined in the gray_params.f90 (location subject to change) and are organised as follows: gray_parameters (statically allocated data) ├── antenna_parameters ├── ecrh_cd_parameters ├── equilibrium_parameters ├── misc_parameters ├── output_parameters ├── profiles_parameters └── raytracing_parameters gray_data - inputs of gray_main (dynamically-allocated arrays) ├── equilibrium_data └── profiles_data gray_results - outputs of gray_main (dynamically-allocated arrays)
2021-12-15 02:31:09 +01:00
print_bres, print_prof, print_maps, &
print_surfq
! subroutine arguments
src/gray_core.f90: cleanup - add some comments - annotate loops - indent comments - remove trailing whitespace - reduce usage of opaque global variables - use Fortran 90 logical operators - use Fortran 2003 array syntax
2022-05-10 12:36:37 +02:00
type(gray_parameters), intent(inout) :: params
real(wp_), intent(in) :: pabs, icd
real(wp_), dimension(:), intent(in) :: jphi, jcd, dpdv, currins, pins
src: use derived type arguments (work in progress) This change structures the arguments of most functions, in particular gray_main, into well-defined categories using derived types. All types are defined in the gray_params.f90 (location subject to change) and are organised as follows: gray_parameters (statically allocated data) ├── antenna_parameters ├── ecrh_cd_parameters ├── equilibrium_parameters ├── misc_parameters ├── output_parameters ├── profiles_parameters └── raytracing_parameters gray_data - inputs of gray_main (dynamically-allocated arrays) ├── equilibrium_data └── profiles_data gray_results - outputs of gray_main (dynamically-allocated arrays)
2021-12-15 02:31:09 +01:00
real(wp_), intent(out) :: jphip, dpdvp, rhotj, rhotjava, &
rhotp, rhotpav, drhotjava, drhotpav, &
src/gray_core.f90: cleanup - add some comments - annotate loops - indent comments - remove trailing whitespace - reduce usage of opaque global variables - use Fortran 90 logical operators - use Fortran 2003 array syntax
2022-05-10 12:36:37 +02:00
ratjamx, ratjbmx
src: use derived type arguments (work in progress) This change structures the arguments of most functions, in particular gray_main, into well-defined categories using derived types. All types are defined in the gray_params.f90 (location subject to change) and are organised as follows: gray_parameters (statically allocated data) ├── antenna_parameters ├── ecrh_cd_parameters ├── equilibrium_parameters ├── misc_parameters ├── output_parameters ├── profiles_parameters └── raytracing_parameters gray_data - inputs of gray_main (dynamically-allocated arrays) ├── equilibrium_data └── profiles_data gray_results - outputs of gray_main (dynamically-allocated arrays)
2021-12-15 02:31:09 +01:00
! local variables
real(wp_) :: ak0, bres, xgcn
real(wp_) :: chipol, psipol, st
real(wp_) :: drhotp, drhotj, dpdvmx, jphimx
! ======== set environment BEGIN ========
src/main.f90: fix typo
2022-04-19 23:09:24 +02:00
! Compute X=(ω_pe/ω)² and Y=ω_ce/ω (with B=1)
src: use derived type arguments (work in progress) This change structures the arguments of most functions, in particular gray_main, into well-defined categories using derived types. All types are defined in the gray_params.f90 (location subject to change) and are organised as follows: gray_parameters (statically allocated data) ├── antenna_parameters ├── ecrh_cd_parameters ├── equilibrium_parameters ├── misc_parameters ├── output_parameters ├── profiles_parameters └── raytracing_parameters gray_data - inputs of gray_main (dynamically-allocated arrays) ├── equilibrium_data └── profiles_data gray_results - outputs of gray_main (dynamically-allocated arrays)
2021-12-15 02:31:09 +01:00
call xgygcoeff(params%antenna%fghz, ak0, bres, xgcn)
! Initialise the ray variables (beamtracing)
simplify memory management This change replaces pointers with automatic arrays to greatly simplify the memory management in the main subroutine: - All arrays are defined in a single location and with their final dimension explicitely shown. - The allocation/deallocation is performed automatically when entering/leaving the gray_main routine.
2024-04-23 17:00:40 +02:00
call init_btr(params%raytracing)
src: use derived type arguments (work in progress) This change structures the arguments of most functions, in particular gray_main, into well-defined categories using derived types. All types are defined in the gray_params.f90 (location subject to change) and are organised as follows: gray_parameters (statically allocated data) ├── antenna_parameters ├── ecrh_cd_parameters ├── equilibrium_parameters ├── misc_parameters ├── output_parameters ├── profiles_parameters └── raytracing_parameters gray_data - inputs of gray_main (dynamically-allocated arrays) ├── equilibrium_data └── profiles_data gray_results - outputs of gray_main (dynamically-allocated arrays)
2021-12-15 02:31:09 +01:00
! Initialise the dispersion module
convert remaining subroutines to derived types - converts analytical profiles/equilibrium subroutines to derived types - use less undecipherable and consistent names The subroutine names have changed as follows: set_prfspl → set_profiles_spline set_prfan → set_profiles_an unset_prfspl → unset_profiles_spline unset_prfan → unset_profiles_an set_equian → set_equil_an set_eqspl → set_equil_spline unset_equian → unset_equil_an unset_eqspl → unset_equil_spline unset_rhospl → unset_rho_spline
2022-05-11 00:30:34 +02:00
if (params%ecrh_cd%iwarm > 1) call expinit
src: use derived type arguments (work in progress) This change structures the arguments of most functions, in particular gray_main, into well-defined categories using derived types. All types are defined in the gray_params.f90 (location subject to change) and are organised as follows: gray_parameters (statically allocated data) ├── antenna_parameters ├── ecrh_cd_parameters ├── equilibrium_parameters ├── misc_parameters ├── output_parameters ├── profiles_parameters └── raytracing_parameters gray_data - inputs of gray_main (dynamically-allocated arrays) ├── equilibrium_data └── profiles_data gray_results - outputs of gray_main (dynamically-allocated arrays)
2021-12-15 02:31:09 +01:00
! Initialise the magsurf_data module
call flux_average ! requires frhotor for dadrhot,dvdrhot
! Initialise the output profiles
call pec_init(params%output%ipec)
! ======= set environment END ======
! ======== pre-proc prints BEGIN ========
skip print_headers with no active units
2022-05-03 23:16:21 +02:00
call print_headers(params)
src: use derived type arguments (work in progress) This change structures the arguments of most functions, in particular gray_main, into well-defined categories using derived types. All types are defined in the gray_params.f90 (location subject to change) and are organised as follows: gray_parameters (statically allocated data) ├── antenna_parameters ├── ecrh_cd_parameters ├── equilibrium_parameters ├── misc_parameters ├── output_parameters ├── profiles_parameters └── raytracing_parameters gray_data - inputs of gray_main (dynamically-allocated arrays) ├── equilibrium_data └── profiles_data gray_results - outputs of gray_main (dynamically-allocated arrays)
2021-12-15 02:31:09 +01:00
! Print ψ surface for q=1.5 and q=2 on file and psi,rhot,rhop on stdout
call print_surfq([1.5_wp_, 2.0_wp_])
! Print ne, Te, q, Jphi versus psi, rhop, rhot
call print_bres(bres)
src/gray_core.f90: print profiles up to ψ_bnd
2023-05-23 17:49:51 +02:00
call print_prof(params%profiles)
src: use hypot and norm2 when possible
2021-12-19 02:35:24 +01:00
call print_maps(bres, xgcn, &
norm2(params%antenna%pos(1:2)) *0.01_wp_ , &
src: use derived type arguments (work in progress) This change structures the arguments of most functions, in particular gray_main, into well-defined categories using derived types. All types are defined in the gray_params.f90 (location subject to change) and are organised as follows: gray_parameters (statically allocated data) ├── antenna_parameters ├── ecrh_cd_parameters ├── equilibrium_parameters ├── misc_parameters ├── output_parameters ├── profiles_parameters └── raytracing_parameters gray_data - inputs of gray_main (dynamically-allocated arrays) ├── equilibrium_data └── profiles_data gray_results - outputs of gray_main (dynamically-allocated arrays)
2021-12-15 02:31:09 +01:00
sin(params%antenna%beta*degree))
! ========= pre-proc prints END =========
! Print power and current density profiles
call print_pec(rhop_tab, rhot_tab, jphi, jcd, &
dpdv, currins, pins, index_rt=1)
! Compute profiles width
call postproc_profiles(pabs, icd, rhot_tab, dpdv, jphi, &
rhotpav, drhotpav, rhotjava, drhotjava, &
dpdvp, jphip, rhotp, drhotp, rhotj, drhotj, &
dpdvmx, jphimx, ratjamx, ratjbmx)
! Print 0D results
call print_finals(pabs, icd, dpdvp, jphip, rhotpav, rhotjava, drhotpav, &
drhotjava, dpdvmx, jphimx, rhotp, rhotj, drhotp, &
drhotj, ratjamx, ratjbmx, st, psipol, chipol, &
1, params%antenna%power, cpl1=zero, cpl2=zero)
! Free memory
call dealloc_surfvec ! for fluxval
call dealloc_pec
end subroutine sum_profiles
end program main
Reference in New Issue Copy Permalink