driver.c File Reference

#include <stdlib.h>
#include <stdio.h>
#include <stdbool.h>
#include <inttypes.h>
#include <string.h>
#include <assert.h>
#include <ctype.h>
#include <dlfcn.h>
#include "hawaii.h"
#include "hep_hawaii.h"
#include "loess.hpp"
#include "flag.h"
#include <gsl/gsl_integration.h>
#include "cspline.h"

Include dependency graph for driver.c:

Classes
struct	InputBlock
struct	Loc
struct	Satellite_Temperatures
struct	Temperatures
struct	CF_Filenames
struct	Partial_Partition_Function_Ratios
struct	Lexer
struct	Funcall_Argument
struct	Funcall_Arguments
struct	Funcall
struct	Funcalls
struct	Processing_Params
union	Stack_Item
struct	Tagged_Stack_Item
struct	Processing_Stack
struct	Mn_Integrand_Params

Macros
#define	USE_MPI
#define	FLAG_IMPLEMENTATION
#define	CSPLINE_IMPLEMENTATION

Enumerations
enum	Token_Type {   TOKEN_EOF , TOKEN_BLOCK , TOKEN_KEYWORD , TOKEN_STRING ,   TOKEN_DQSTRING , TOKEN_INTEGER , TOKEN_FLOAT , TOKEN_BOOLEAN ,   TOKEN_OCURLY , TOKEN_CCURLY , TOKEN_OPAREN , TOKEN_CPAREN ,   TOKEN_COMMA , TOKEN_EQ , TOKEN_FUNCALL , TOKEN_COUNT }
enum	Keyword {   KEYWORD_CALCULATION_TYPE , KEYWORD_PAIR_STATE , KEYWORD_PAIR_REDUCED_MASS , KEYWORD_SO_POTENTIAL ,   KEYWORD_SO_DIPOLE , KEYWORD_SO_DIPOLE_1 , KEYWORD_SO_DIPOLE_2 , KEYWORD_TEMPERATURE ,   KEYWORD_TEMPERATURES , KEYWORD_SATELLITE_TEMPERATURES , KEYWORD_NITERATIONS , KEYWORD_TOTAL_TRAJECTORIES ,   KEYWORD_CVODE_TOLERANCE , KEYWORD_SAMPLING_TIME , KEYWORD_MAXTRAJECTORYLENGTH , KEYWORD_SAMPLER_RMIN ,   KEYWORD_SAMPLER_RMAX , KEYWORD_PESMIN , KEYWORD_INITIALM0_NPOINTS , KEYWORD_INITIALM2_NPOINTS ,   KEYWORD_HEP_M0_NITERATIONS , KEYWORD_HEP_M0_NPOINTS , KEYWORD_HEP_M2_NITERATIONS , KEYWORD_HEP_M2_NPOINTS ,   KEYWORD_HEP_PPF_NITERATIONS , KEYWORD_HEP_PPF_NPOINTS , KEYWORD_SF_FILENAME , KEYWORD_CF_FILENAME ,   KEYWORD_CF_FILENAMES , KEYWORD_R0 , KEYWORD_RCUT , KEYWORD_PARTIAL_PARTITION_FUNCTION_RATIO ,   KEYWORD_PARTIAL_PARTITION_FUNCTION_RATIOS , KEYWORD_APPROXIMATEFREQUENCYMAX , KEYWORD_ODD_J_SPIN_WEIGHT , KEYWORD_EVEN_J_SPIN_WEIGHT ,   KEYWORD_USE_ZIMMERMANN_TRICK , KEYWORD_AVERAGE_TIME_BETWEEN_COLLISIONS , KEYWORD_MONOMER_TYPE , KEYWORD_DJ ,   KEYWORD_II , KEYWORD_INITIAL_J , KEYWORD_TORQUE_CACHE_LEN , KEYWORD_TORQUE_LIMIT ,   KEYWORD_NSWITCH_HISTOGRAM_BINS , KEYWORD_NSWITCH_HISTOGRAM_MAX , KEYWORD_NSWITCH_HISTOGRAM_FILENAME , KEYWORD_JINI_HISTOGRAM_BINS ,   KEYWORD_JINI_HISTOGRAM_MAX , KEYWORD_JINI_HISTOGRAM_FILENAME , KEYWORD_JFIN_HISTOGRAM_BINS , KEYWORD_JFIN_HISTOGRAM_MAX ,   KEYWORD_JFIN_HISTOGRAM_FILENAME , KEYWORD_SPECTRUM_FREQUENCY_MAX , KEYWORD_COUNT }
enum	Funcall_Argument_Type { FUNCALL_ARGUMENT_STRING , FUNCALL_ARGUMENT_INTEGER , FUNCALL_ARGUMENT_FLOAT , FUNCALL_ARGUMENT_COUNT }
enum	Stack_Item_Type { STACK_ITEM_CF = 0 , STACK_ITEM_SF , STACK_ITEM_SPECTRUM , STACK_ITEM_FLOAT }

Functions
Lexer	lexer_new (const char *input_path, const char *input_stream, char *eof)
bool	is_eof (Lexer *l)
char	peek_char (Lexer *l)
void	skip_char (Lexer *l)
void	skip_whitespaces (Lexer *l)
bool	skip_prefix (Lexer *l, const char *prefix)
void	skip_until (Lexer *l, const char *prefix)
bool	is_identifier_begin (char c)
bool	is_identifier (char c)
bool	get_token (Lexer *l)
void	print_input_block (InputBlock *input_block)
void	print_monomer (Monomer *monomer)
void	print_params (CalcParams *params)
void	print_processing_params (Processing_Params *processing_params)
bool	read_entire_file (const char *path, String_Builder *sb)
void	print_lexeme (Lexer *l)
void	print_lexemes (Lexer *l)
void	expect_one_of_tokens (Lexer *l, int count,...)
void	expect_token (Lexer *l, Token_Type expected)
void	get_and_expect_token (Lexer *l, Token_Type token)
void	parse_input_block (Lexer *l, InputBlock *input_block, CalcParams *params)
void	parse_monomer_block (Lexer *l, Monomer *m)
void	stack_push_with_type (Processing_Stack *stack, void *item, Stack_Item_Type typ, Loc *loc)
void	parse_processing_block (Lexer *l, Processing_Params *processing_params)
void	parse_params (Lexer *l, CalcParams *calc_params, InputBlock *input_block, Monomer *m1, Monomer *m2, Processing_Params *processing_params)
void	stack_push (Processing_Stack *stack, Tagged_Stack_Item tagged_item)
Tagged_Stack_Item	stack_pop_with_type (Processing_Stack *stack, Loc loc)
Tagged_Stack_Item *	stack_peek_with_type (Processing_Stack *stack, size_t i, Loc loc)
Tagged_Stack_Item *	stack_peek_top_with_type (Processing_Stack *stack)
void	expect_item_on_stack (Loc *pc_loc, Tagged_Stack_Item *tagged_item, Stack_Item_Type expected_type)
bool	expect_one_of_items_on_stack (Loc *pc_loc, Tagged_Stack_Item *tagged_item, int count,...)
Funcall_Argument	shift_funcall_argument (Funcall *func)
void	expect_string_funcall_argument (Funcall *func, Funcall_Argument *arg)
void	expect_integer_funcall_argument (Funcall *func, Funcall_Argument *arg)
void	expect_float_funcall_argument (Funcall *func, Funcall_Argument *arg)
void	expect_integer_for_funcall_named_argument (Funcall *func, Funcall_Argument *arg)
void	expect_float_for_funcall_named_argument (Funcall *func, Funcall_Argument *arg)
void	expect_n_funcall_arguments (Funcall *func, size_t narguments)
bool	execute_read_cf (Funcall *func, Processing_Stack *stack)
	READ_CF reads a correlation function from a file specified by a string argument. Expects exactly one string argument (the file path). The correlation function is read into a CFnc structure and pushed onto the processing stack. The file may optionally contain a header with:
bool	execute_read_sf (Funcall *func, Processing_Stack *stack)
	READ_SF reads a spectral function from a file specified by a string argument. Expects exactly one string argument (the file path). The spectral function is read into a SFnc structure and pushed onto the processing stack. The file may optionally contain a header with:
bool	execute_read_spectrum (Funcall *func, Processing_Stack *stack)
	READ_SPECTRUM reads a spectrum from a file specified by a string argument. Expects exactly one string argument (the file path). The spectrum is read into a Spectrum structure and pushed onto the processing stack. The file may optionally contain a header with:
bool	execute_cf_to_sf (Funcall *func, Processing_Stack *stack)
	CF_TO_SF converts a correlation function (CFnc) to a spectral function (SFnc) using IDCT.
bool	execute_cmp (Funcall *func, Processing_Stack *stack)
	CMP compares two top stack elements (CFnc, SFnc, Spectrum or Floats) for equality.
bool	execute_drop2 (Funcall *func, Processing_Stack *stack)
	DROP2 removes the top two elements from the processing stack.
bool	execute_drop (Funcall *func, Processing_Stack *stack)
	DROP removes the top item from the processing stack. The operation will fail if the stack is empty.
bool	execute_fit_baseline (Funcall *func, Processing_Stack *stack)
	FIT_BASELINE fits the baseline model of the form C(t) = C + A/(1 + B^2 t^2) to the correlation function (CFnc) using Levenberg-Marquardt optimization.
bool	execute_average_cfs (Funcall *func, Processing_Stack *stack)
	AVERAGE_CFS averages all correlation functions (CFnc) on the stack.
bool	execute_dup2 (Funcall *func, Processing_Stack *stack)
	DUP2 duplicates the top two elements on the processing stack keeping their ordering.
bool	execute_dup (Funcall *func, Processing_Stack *stack)
	DUP duplicates the top element of the processing stack.
bool	execute_print (Funcall *func, Processing_Stack *stack)
	PRINT.
bool	execute_rot (Funcall *func, Processing_Stack *stack)
	ROT rotates the third item to top.
bool	execute_swap (Funcall *func, Processing_Stack *stack)
	SWAP swaps the top element with the one below in the processing stack.
double	m0_integrand (double nu, void *params)
double	m2_integrand (double nu, void *params)
bool	execute_compute_mn_classical_detailed_balance (Funcall *func, Processing_Stack *stack, Processing_Params *processing_params)
	COMPUTE_Mn_CLASSICAL_DETAILED_BALANCE computes n-th spectral moment using classical detailed balance.
bool	execute_compute_mn_quantum_detailed_balance (Funcall *func, Processing_Stack *stack, Processing_Params *processing_params)
	COMPUTE_Mn_QUANTUM_DETAILED_BALANCE computes n-th spectral moment using quantum detailed balance.
void	execute_int3 (Funcall *func, Processing_Stack *stack)
	INT3 triggers a debug breakpoint interrupt and displays comprehensive stack information.
bool	execute_add_spectra (Funcall *func, Processing_Stack *stack)
	ADD_SPECTRA performs element-wise addition of multiple spectra (Spectrum) from the stack.
bool	execute_alpha (Funcall *func, Processing_Stack *stack)
	ALPHA computes absorption coefficient from spectral function (SFnc).
bool	execute_D1 (Funcall *func, Processing_Stack *stack)
	Applies D1 desymmetrization to the spectral function (SFnc) on the top of the stack.
bool	execute_D2 (Funcall *func, Processing_Stack *stack)
	Applies D2 desymmetrization to the spectral function (SFnc) or spectrum (Spectrum) on the top of the stack.
bool	execute_D3 (Funcall *func, Processing_Stack *stack)
	Applies D3 desymmetrization to the spectral function (SFnc) or spectrum (Spectrum) on the top of the stack.
bool	execute_inv_D2 (Funcall *func, Processing_Stack *stack)
	Applies inverse of D2 desymmetrization to the spectrum (Spectrum) on the top of the stack.
bool	execute_inv_D3 (Funcall *func, Processing_Stack *stack)
	Applies inverse of D3 desymmetrization to the spectrum (Spectrum) on the top of the stack.
bool	execute_D4 (Funcall *func, Processing_Stack *stack)
	Applies D4 desymmetrization to the correlation function (CFnc) on the top of the stack producing spectral function (SFnc).
bool	execute_D4a (Funcall *func, Processing_Stack *stack)
	Applies D4a desymmetrization to the correlation function (CFnc) on the top of the stack producing spectral function (SFnc).
bool	execute_write_cf (Funcall *func, Processing_Stack *stack)
	Writes correlation function (CFnc) to output file.
bool	execute_write_sf (Funcall *func, Processing_Stack *stack)
	Writes spectral function (SFnc) to output file.
bool	execute_add (Funcall *func, Processing_Stack *stack)
bool	execute_write_float (Funcall *func, Processing_Stack *stack)
bool	execute_push_float (Funcall *func, Processing_Stack *stack)
bool	execute_write_spectrum (Funcall *func, Processing_Stack *stack, Processing_Params *processing_params)
	Writes spectrum (Spectrum) to output file.
bool	execute_smooth (Funcall *func, Processing_Stack *stack)
	Performs the smoothing of spectral function (SFnc) using LOESS algorithm.
int	run_processing (Processing_Params *processing_params)
void *	load_symbol (void *handle, const char *symbol_name, bool allow_undefined)
void	setup_dipole (const char *filepath, dipolePtr *dipole_func, dipoleFree *dipole_free)
void	setup_pes (InputBlock *input_block)
void	usage ()
int	main (int argc, char *argv[])

Variables
const char *	TOKEN_TYPES [TOKEN_COUNT]
const char *	PUNCTS [TOKEN_COUNT]
const char *	BLOCK_NAMES []
const char *	BOOLEAN_AS_STR []
const char *	KEYWORDS [KEYWORD_COUNT]
Token_Type	EXPECT_TOKEN_AFTER_KEYWORD [KEYWORD_COUNT]
const char *	FUNCALL_ARGUMENT_TYPES []

Macro Definition Documentation

CSPLINE_IMPLEMENTATION

#define CSPLINE_IMPLEMENTATION

FLAG_IMPLEMENTATION

#define FLAG_IMPLEMENTATION

USE_MPI

#define USE_MPI

Enumeration Type Documentation

Funcall_Argument_Type

enum Funcall_Argument_Type

Enumerator
FUNCALL_ARGUMENT_STRING
FUNCALL_ARGUMENT_INTEGER
FUNCALL_ARGUMENT_FLOAT
FUNCALL_ARGUMENT_COUNT

Keyword

enum Keyword

Enumerator
KEYWORD_CALCULATION_TYPE
KEYWORD_PAIR_STATE
KEYWORD_PAIR_REDUCED_MASS
KEYWORD_SO_POTENTIAL
KEYWORD_SO_DIPOLE
KEYWORD_SO_DIPOLE_1
KEYWORD_SO_DIPOLE_2
KEYWORD_TEMPERATURE
KEYWORD_TEMPERATURES
KEYWORD_SATELLITE_TEMPERATURES
KEYWORD_NITERATIONS
KEYWORD_TOTAL_TRAJECTORIES
KEYWORD_CVODE_TOLERANCE
KEYWORD_SAMPLING_TIME
KEYWORD_MAXTRAJECTORYLENGTH
KEYWORD_SAMPLER_RMIN
KEYWORD_SAMPLER_RMAX
KEYWORD_PESMIN
KEYWORD_INITIALM0_NPOINTS
KEYWORD_INITIALM2_NPOINTS
KEYWORD_HEP_M0_NITERATIONS
KEYWORD_HEP_M0_NPOINTS
KEYWORD_HEP_M2_NITERATIONS
KEYWORD_HEP_M2_NPOINTS
KEYWORD_HEP_PPF_NITERATIONS
KEYWORD_HEP_PPF_NPOINTS
KEYWORD_SF_FILENAME
KEYWORD_CF_FILENAME
KEYWORD_CF_FILENAMES
KEYWORD_R0
KEYWORD_RCUT
KEYWORD_PARTIAL_PARTITION_FUNCTION_RATIO
KEYWORD_PARTIAL_PARTITION_FUNCTION_RATIOS
KEYWORD_APPROXIMATEFREQUENCYMAX
KEYWORD_ODD_J_SPIN_WEIGHT
KEYWORD_EVEN_J_SPIN_WEIGHT
KEYWORD_USE_ZIMMERMANN_TRICK
KEYWORD_AVERAGE_TIME_BETWEEN_COLLISIONS
KEYWORD_MONOMER_TYPE
KEYWORD_DJ
KEYWORD_II
KEYWORD_INITIAL_J
KEYWORD_TORQUE_CACHE_LEN
KEYWORD_TORQUE_LIMIT
KEYWORD_NSWITCH_HISTOGRAM_BINS
KEYWORD_NSWITCH_HISTOGRAM_MAX
KEYWORD_NSWITCH_HISTOGRAM_FILENAME
KEYWORD_JINI_HISTOGRAM_BINS
KEYWORD_JINI_HISTOGRAM_MAX
KEYWORD_JINI_HISTOGRAM_FILENAME
KEYWORD_JFIN_HISTOGRAM_BINS
KEYWORD_JFIN_HISTOGRAM_MAX
KEYWORD_JFIN_HISTOGRAM_FILENAME
KEYWORD_SPECTRUM_FREQUENCY_MAX
KEYWORD_COUNT

Stack_Item_Type

enum Stack_Item_Type

Enumerator
STACK_ITEM_CF
STACK_ITEM_SF
STACK_ITEM_SPECTRUM
STACK_ITEM_FLOAT

Token_Type

enum Token_Type

Enumerator
TOKEN_EOF
TOKEN_BLOCK
TOKEN_KEYWORD
TOKEN_STRING
TOKEN_DQSTRING
TOKEN_INTEGER
TOKEN_FLOAT
TOKEN_BOOLEAN
TOKEN_OCURLY
TOKEN_CCURLY
TOKEN_OPAREN
TOKEN_CPAREN
TOKEN_COMMA
TOKEN_EQ
TOKEN_FUNCALL
TOKEN_COUNT

Function Documentation

execute_add()

bool execute_add	(	Funcall *	func,
		Processing_Stack *	stack )

execute_add_spectra()

bool execute_add_spectra	(	Funcall *	func,
		Processing_Stack *	stack )

ADD_SPECTRA performs element-wise addition of multiple spectra (Spectrum) from the stack.

Computes the sum of all spectra from the stack. All spectra must have consistent Temperature values. The resulting spectrum replaces all input spectra on the stack with the following properties:

• trajectory count: arithmetic sum of all input trajectory counts
• frequency range: [0, min(max_frequency)] of all input spectra
• data: element-wise sum of input spectra (using cubic spline interpolation if needed)

If input frequency ranges differ, performs cubic spline interpolation to the target frequency range defined by the smallest maximum frequency.

Parameters

wavenumber_step	Optional: output spectrum resolution. Defaults to the largest wavenumber step among input spectra
n	Optional: number of input spectra to process from stack top. Defaults to processing all available spectra from stack top. In this default case, all objects on stack are expected to be spectra (Spectrum).

execute_alpha()

bool execute_alpha	(	Funcall *	func,
		Processing_Stack *	stack )

ALPHA computes absorption coefficient from spectral function (SFnc).

Computes the absorption coefficient using the spectral function on stack top. The computation requires and consumes the input SFnc, using its Temperature field.

execute_average_cfs()

bool execute_average_cfs	(	Funcall *	func,
		Processing_Stack *	stack )

AVERAGE_CFS averages all correlation functions (CFnc) on the stack.

Computes the element-wise average of all correlation functions from the stack. All input CFncs must have identical dimensions, perfectly matching time arrays, and consistent Temperature values. The operation requires valid trajectory counts for every input CFnc.

The averaged CFnc replaces all input CFncs on the stack, with its trajectory count set to the arithmetic sum of all input trajectory counts.

The operation fails if the trajectory count for one of the CFncs is not set or the metadata is not compatible with the other ones.

execute_cf_to_sf()

bool execute_cf_to_sf	(	Funcall *	func,
		Processing_Stack *	stack )

CF_TO_SF converts a correlation function (CFnc) to a spectral function (SFnc) using IDCT.

Expects a correlation function on top of the stack and applies the inverse dicrete cosine transform (IDCT) to convert it to a spectral function.

If the FIT_BASELINE function was previously called on this CFnc, the function will account for the correlation function's wing parameters to add the corresponding Fourier image to the resulting spectral function.

execute_cmp()

bool execute_cmp	(	Funcall *	func,
		Processing_Stack *	stack )

CMP compares two top stack elements (CFnc, SFnc, Spectrum or Floats) for equality.

CMP performs a deep comparison of the two toptmost stack elements, checking:

• metadata: Temperature, length, trajectory count
• array contents: element-by-element comparison. For time and frequency values an absolute threshold is assume, for CF and SF values a relative threshold is assumed.

Parameters

reltol

Optional: relative tolerance for comparing floats (default: 1e-3)

On failure, an error message is printed detailing the differing fields. The processing_stack's (Processing_Stack) return_code is set to the result of CMP.

execute_compute_mn_classical_detailed_balance()

bool execute_compute_mn_classical_detailed_balance	(	Funcall *	func,
		Processing_Stack *	stack,
		Processing_Params *	processing_params )

COMPUTE_Mn_CLASSICAL_DETAILED_BALANCE computes n-th spectral moment using classical detailed balance.

Calculates the n-th order spectral moment from either a correlation function (CFnc) or spectral function (SFnc) on stack top assuming classical detailed balance. Pushes the obtained spectral moment on stack.

Parameters

n	Required: order of spectral moment (passed as integer argument)

The computation for spectral function uses Simpson's method for numerical integration. If SPECTRUM_FREQUENCY_MAX parameter is set, the spectral function is truncated at this frequency before conducting the integration.

execute_compute_mn_quantum_detailed_balance()

bool execute_compute_mn_quantum_detailed_balance	(	Funcall *	func,
		Processing_Stack *	stack,
		Processing_Params *	processing_params )

COMPUTE_Mn_QUANTUM_DETAILED_BALANCE computes n-th spectral moment using quantum detailed balance.

Calculates the n-th order spectral moment from a spectral function (SFnc) on stack assuming quantum detailed balance. Pushes the obtained spectral moment on stack.

Parameters

n	Required: order of spectral moment (passed as integer argument)

The computation for spectral function uses Simpson's method for numerical integration. If SPECTRUM_FREQUENCY_MAX parameter is set, the spectral function is truncated at this frequency before conducting the integration.

execute_D1()

bool execute_D1	(	Funcall *	func,
		Processing_Stack *	stack )

Applies D1 desymmetrization to the spectral function (SFnc) on the top of the stack.

execute_D2()

bool execute_D2	(	Funcall *	func,
		Processing_Stack *	stack )

Applies D2 desymmetrization to the spectral function (SFnc) or spectrum (Spectrum) on the top of the stack.

execute_D3()

bool execute_D3	(	Funcall *	func,
		Processing_Stack *	stack )

Applies D3 desymmetrization to the spectral function (SFnc) or spectrum (Spectrum) on the top of the stack.

execute_D4()

bool execute_D4	(	Funcall *	func,
		Processing_Stack *	stack )

Applies D4 desymmetrization to the correlation function (CFnc) on the top of the stack producing spectral function (SFnc).

execute_D4a()

bool execute_D4a	(	Funcall *	func,
		Processing_Stack *	stack )

Applies D4a desymmetrization to the correlation function (CFnc) on the top of the stack producing spectral function (SFnc).

execute_drop()

bool execute_drop	(	Funcall *	func,
		Processing_Stack *	stack )

DROP removes the top item from the processing stack. The operation will fail if the stack is empty.

execute_drop2()

bool execute_drop2	(	Funcall *	func,
		Processing_Stack *	stack )

DROP2 removes the top two elements from the processing stack.

It's equivalent to using DROP DROP. The operation will fail if there are not enough elements on the stack.

execute_dup()

bool execute_dup	(	Funcall *	func,
		Processing_Stack *	stack )

DUP duplicates the top element of the processing stack.

Creates an exact copy of the top stack element and pushes it onto the stack (valid for all supported types: CFnc, SFnc, and Spectrum).

Fails if the stack is empty.

execute_dup2()

bool execute_dup2	(	Funcall *	func,
		Processing_Stack *	stack )

DUP2 duplicates the top two elements on the processing stack keeping their ordering.

Schematically presenting the top stack elements: (before) ... a b – (after) ... a b a b

Fails if there are less than 2 elements on stack.

execute_fit_baseline()

bool execute_fit_baseline	(	Funcall *	func,
		Processing_Stack *	stack )

FIT_BASELINE fits the baseline model of the form C(t) = C + A/(1 + B^2 t^2) to the correlation function (CFnc) using Levenberg-Marquardt optimization.

The function fits the baseline model to the correlation function (CFnc) on stack top using GSL's Levenberg-Marquardt algorithm. Fitted parameters are saved as wing_params (WingParams) field of the processing stack (Processing_Stack) to be used by CF_TO_SF function.

Parameters

cf_extrapolation_begin_index

Optional: start time for fitting (default: DEFAULT_CF_EXTRAPOLATION_BEGIN_INDEX)

See the paper "Simulation of collision-induced absorption spectra based on classical trajectories and ab initio potential and induced dipole surfaces. II. CO2-Ar rototranslational band including true dimer contribution" for details.

We rely on the specific structure of the correlation function (see Fig. 7). Specifically, we expect it to have a secondary maximum from which it decays to some positive constant.

execute_int3()

void execute_int3	(	Funcall *	func,
		Processing_Stack *	stack )

INT3 triggers a debug breakpoint interrupt and displays comprehensive stack information.

When called it will halt the program execution and display current stack contents.

execute_inv_D2()

bool execute_inv_D2	(	Funcall *	func,
		Processing_Stack *	stack )

Applies inverse of D2 desymmetrization to the spectrum (Spectrum) on the top of the stack.

execute_inv_D3()

bool execute_inv_D3	(	Funcall *	func,
		Processing_Stack *	stack )

Applies inverse of D3 desymmetrization to the spectrum (Spectrum) on the top of the stack.

execute_print()

bool execute_print	(	Funcall *	func,
		Processing_Stack *	stack )

PRINT.

execute_push_float()

bool execute_push_float	(	Funcall *	func,
		Processing_Stack *	stack )

execute_read_cf()

bool execute_read_cf	(	Funcall *	func,
		Processing_Stack *	stack )

READ_CF reads a correlation function from a file specified by a string argument. Expects exactly one string argument (the file path). The correlation function is read into a CFnc structure and pushed onto the processing stack. The file may optionally contain a header with:

• a line "# TEMPERATURE: <value>" (floating-point value, K)
• a line "# AVERAGE OVER <value> TRAJECTORIES" (floating-point value).

The time values are expected to be in atomic time units, and correlation function values are expected in (m^3*atomic unit of dipole^2) units.

execute_read_sf()

bool execute_read_sf	(	Funcall *	func,
		Processing_Stack *	stack )

READ_SF reads a spectral function from a file specified by a string argument. Expects exactly one string argument (the file path). The spectral function is read into a SFnc structure and pushed onto the processing stack. The file may optionally contain a header with:

• a line "# TEMPERATURE: <value>" (floating-point value, K)
• a line "# AVERAGE OVER <value> TRAJECTORIES" (floating-point value).

The frequency values are expected to be in cm-1, and spectral function values are expected in (J * m^6 * s) units.

execute_read_spectrum()

bool execute_read_spectrum	(	Funcall *	func,
		Processing_Stack *	stack )

READ_SPECTRUM reads a spectrum from a file specified by a string argument. Expects exactly one string argument (the file path). The spectrum is read into a Spectrum structure and pushed onto the processing stack. The file may optionally contain a header with:

• a line "# TEMPERATURE: <value>" (floating-point value, K)
• a line "# AVERAGE OVER <value> TRAJECTORIES" (floating-point value).

The frequency values are expected to be in cm-1, and spectrum values are expected in (cm-1 Amagat-2) units.

execute_rot()

bool execute_rot	(	Funcall *	func,
		Processing_Stack *	stack )

ROT rotates the third item to top.

Schematically presenting the top stack elements: (before) ... a b c – (after) ... b c a

Fails if the stack size is less than 3.

execute_smooth()

bool execute_smooth	(	Funcall *	func,
		Processing_Stack *	stack )

Performs the smoothing of spectral function (SFnc) using LOESS algorithm.

Applies LOESS regression to smooth the spectral function (SFnc) on stack top. The algorithm performs local polynomial fitting across the provided frequency grid. The result replaces input spectral function on stack top.

The function uses thread parallelization.

Parameters

grid_npoints	Required: number of grid points for smooth function evaluation
grid_max	Required: upper frequency limit of the evaluation grid (in cm-1)
window_size_min	Optional: minimum number of points in smoothing window
window_size_step	Optional: window size growth rate (int cm-1/point). Determines how window expands with frequency.
window_size_delay	Optional: Delay before window size begins growing (in points). Maintains consistent window size at lower frequencies.
windows_size_cap	Optional: Cap on window size (in points) [though this option was not found useful in most cases]

execute_swap()

bool execute_swap	(	Funcall *	func,
		Processing_Stack *	stack )

SWAP swaps the top element with the one below in the processing stack.

Schematically presenting the top stack elements: (before) ... a b – (after) ... b a

Fails if the stack size is less than 2.

execute_write_cf()

bool execute_write_cf	(	Funcall *	func,
		Processing_Stack *	stack )

Writes correlation function (CFnc) to output file.

Serializes the correlation function from stack top to a file specified by a string argument. The correlation function is consumed from stack top during the operation. Its metadata (Temperature and trajectory count) is saved in a format expected by READ_CF.

The function handles the normlization: if correlation function's normalization flag is false, the data is divided by the trajectory count before writing to file.

Parameters

output_filename

Required: output filename provided as unnamed string argument

Fails if stack is empty or top element is not correlation function (CFnc)

execute_write_float()

bool execute_write_float	(	Funcall *	func,
		Processing_Stack *	stack )

execute_write_sf()

bool execute_write_sf	(	Funcall *	func,
		Processing_Stack *	stack )

Writes spectral function (SFnc) to output file.

Serializes the spectral function from stack top to a file specified by a string argument. The spectral function is consumed from stack top during the operation. Its metadata (Temperature and trajectory count) is saved in a format expected by READ_SF.

The function handles the normlization: if spectral function's normalization flag is false, the data is divided by the trajectory count before writing to file.

Parameters

output_filename

Required: output filename provided as unnamed string argument

Fails if stack is empty or top element is not spectral function (SFnc)

execute_write_spectrum()

bool execute_write_spectrum	(	Funcall *	func,
		Processing_Stack *	stack,
		Processing_Params *	processing_params )

Writes spectrum (Spectrum) to output file.

Serializes the spectrum from stack top to a file specified by a string argument. The spectrum is consumed from stack top during the operation. Its metadata (Temperature and trajectory count) is saved in a format expected by READ_SPECTRUM.

The function handles the normlization: if spectrum's normalization flag is false, the data is divided by the trajectory count before writing to file. If SPECTRUM_FREQUENCY_MAX parameter is set, spectrum is truncated at the specified frequency before saving to file.

Parameters

output_filename

Required: output filename provided as unnamed string argument

Fails if stack is empty or top element is not spectrum (Spectrum)

expect_float_for_funcall_named_argument()

void expect_float_for_funcall_named_argument	(	Funcall *	func,
		Funcall_Argument *	arg )

expect_float_funcall_argument()

void expect_float_funcall_argument	(	Funcall *	func,
		Funcall_Argument *	arg )

expect_integer_for_funcall_named_argument()

void expect_integer_for_funcall_named_argument	(	Funcall *	func,
		Funcall_Argument *	arg )

expect_integer_funcall_argument()

void expect_integer_funcall_argument	(	Funcall *	func,
		Funcall_Argument *	arg )

expect_item_on_stack()

void expect_item_on_stack	(	Loc *	pc_loc,
		Tagged_Stack_Item *	tagged_item,
		Stack_Item_Type	expected_type )

expect_n_funcall_arguments()

void expect_n_funcall_arguments	(	Funcall *	func,
		size_t	narguments )

expect_one_of_items_on_stack()

bool expect_one_of_items_on_stack	(	Loc *	pc_loc,
		Tagged_Stack_Item *	tagged_item,
		int	count,
			... )

expect_one_of_tokens()

void expect_one_of_tokens	(	Lexer *	l,
		int	count,
			... )

expect_string_funcall_argument()

void expect_string_funcall_argument	(	Funcall *	func,
		Funcall_Argument *	arg )

expect_token()

void expect_token	(	Lexer *	l,
		Token_Type	expected )

get_and_expect_token()

void get_and_expect_token	(	Lexer *	l,
		Token_Type	token )

get_token()

bool get_token

(

Lexer *

l

)

is_eof()

bool is_eof

(

Lexer *

l

)

is_identifier()

bool is_identifier

(

char

c

)

is_identifier_begin()

bool is_identifier_begin

(

char

c

)

lexer_new()

Lexer lexer_new	(	const char *	input_path,
		const char *	input_stream,
		char *	eof )

load_symbol()

void * load_symbol	(	void *	handle,
		const char *	symbol_name,
		bool	allow_undefined )

m0_integrand()

double m0_integrand	(	double	nu,
		void *	params )

m2_integrand()

double m2_integrand	(	double	nu,
		void *	params )

main()

int main	(	int	argc,
		char *	argv[] )

parse_input_block()

void parse_input_block	(	Lexer *	l,
		InputBlock *	input_block,
		CalcParams *	params )

parse_monomer_block()

void parse_monomer_block	(	Lexer *	l,
		Monomer *	m )

parse_params()

void parse_params	(	Lexer *	l,
		CalcParams *	calc_params,
		InputBlock *	input_block,
		Monomer *	m1,
		Monomer *	m2,
		Processing_Params *	processing_params )

parse_processing_block()

void parse_processing_block	(	Lexer *	l,
		Processing_Params *	processing_params )

peek_char()

char peek_char

(

Lexer *

l

)

print_input_block()

void print_input_block

(

InputBlock *

input_block

)

print_lexeme()

void print_lexeme

(

Lexer *

l

)

print_lexemes()

void print_lexemes

(

Lexer *

l

)

print_monomer()

void print_monomer

(

Monomer *

monomer

)

print_params()

void print_params

(

CalcParams *

params

)

print_processing_params()

void print_processing_params

(

Processing_Params *

processing_params

)

read_entire_file()

bool read_entire_file	(	const char *	path,
		String_Builder *	sb )

run_processing()

int run_processing

(

Processing_Params *

processing_params

)

setup_dipole()

void setup_dipole	(	const char *	filepath,
		dipolePtr *	dipole_func,
		dipoleFree *	dipole_free )

setup_pes()

void setup_pes

(

InputBlock *

input_block

)

shift_funcall_argument()

Funcall_Argument shift_funcall_argument

(

Funcall *

func

)

skip_char()

void skip_char

(

Lexer *

l

)

skip_prefix()

bool skip_prefix	(	Lexer *	l,
		const char *	prefix )

skip_until()

void skip_until	(	Lexer *	l,
		const char *	prefix )

skip_whitespaces()

void skip_whitespaces

(

Lexer *

l

)

stack_peek_top_with_type()

Tagged_Stack_Item * stack_peek_top_with_type

(

Processing_Stack *

stack

)

stack_peek_with_type()

Tagged_Stack_Item * stack_peek_with_type	(	Processing_Stack *	stack,
		size_t	i,
		Loc	loc )

stack_pop_with_type()

Tagged_Stack_Item stack_pop_with_type	(	Processing_Stack *	stack,
		Loc	loc )

stack_push()

void stack_push	(	Processing_Stack *	stack,
		Tagged_Stack_Item	tagged_item )

stack_push_with_type()

void stack_push_with_type	(	Processing_Stack *	stack,
		void *	item,
		Stack_Item_Type	typ,
		Loc *	loc )

usage()

void usage

(

void

)

Variable Documentation

BLOCK_NAMES

const char* BLOCK_NAMES[]

Initial value:

= {
    [0] = "&INPUT",
    [1] = "&MONOMER",
    [2] = "&PROCESSING",
    [3] = "&END",
}

BOOLEAN_AS_STR

const char* BOOLEAN_AS_STR[]

Initial value:

= {
    [0] = "FALSE",
    [1] = "TRUE",
}

EXPECT_TOKEN_AFTER_KEYWORD

Token_Type EXPECT_TOKEN_AFTER_KEYWORD[KEYWORD_COUNT]

FUNCALL_ARGUMENT_TYPES

const char* FUNCALL_ARGUMENT_TYPES[]

Initial value:

= {
    "ARGUMENT_STRING",
    "ARGUMENT_INTEGER",
    "ARGUMENT_FLOAT",
}

KEYWORDS

const char* KEYWORDS[KEYWORD_COUNT]

PUNCTS

const char* PUNCTS[TOKEN_COUNT]

Initial value:

= {
    [TOKEN_COMMA]  = ",",
    [TOKEN_OCURLY] = "{",
    [TOKEN_CCURLY] = "}",
    [TOKEN_OPAREN] = "(",
    [TOKEN_CPAREN] = ")",
    [TOKEN_EQ]     = "=",
}

TOKEN_TYPES

const char* TOKEN_TYPES[TOKEN_COUNT]

Initial value:

= {
      [TOKEN_EOF]          = "EOF",
      [TOKEN_BLOCK]        = "BLOCK",
      [TOKEN_KEYWORD]      = "KEYWORD",
      [TOKEN_STRING]       = "STRING",
      [TOKEN_DQSTRING]     = "DOUBLE-QUOTED STRING",
      [TOKEN_INTEGER]      = "INTEGER",
      [TOKEN_FLOAT]        = "FLOAT",
      [TOKEN_BOOLEAN]      = "BOOLEAN",
      [TOKEN_OCURLY]       = "{",
      [TOKEN_CCURLY]       = "}",
      [TOKEN_OPAREN]       = "(",
      [TOKEN_CPAREN]       = ")",
      [TOKEN_COMMA]        = ",",
      [TOKEN_EQ]           = "=",
      [TOKEN_FUNCALL]      = "FUNCTION CALL",
}