diff --git a/apps/transop-ewald/CMakeLists.txt b/apps/transop-ewald/CMakeLists.txt index 80a874e..c9dbb48 100644 --- a/apps/transop-ewald/CMakeLists.txt +++ b/apps/transop-ewald/CMakeLists.txt @@ -25,4 +25,4 @@ use_c99() # ) #target_include_directories (qpms PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}) -add_executable(EwaldTransOps transop-ewald.c transop_ewald_cmdline.c) +add_executable(EwaldTransOps transop_ewald.c transop_ewald_cmdline.c) diff --git a/apps/transop-ewald/translations_ewald.ggo b/apps/transop-ewald/translations_ewald.ggo index 024c1a6..4f85314 100644 --- a/apps/transop-ewald/translations_ewald.ggo +++ b/apps/transop-ewald/translations_ewald.ggo @@ -14,7 +14,11 @@ option "output" o "Output file" default="" optional -option "normalisation" n "VSWF normalisation convention" +option "error-estimate-output" E "Path to the output with error estimates" + string + optional + +option "normalisation" N "VSWF normalisation convention" values="Power","None","SH" enum default="Power" @@ -27,12 +31,47 @@ option "Ewald-parameter" e "The value of Ewald parameter η" double optional +option "frequency-unit" u "Specifies the frequency unit is used for inputs." + values="eV","scuff" + default="scuff" +option "lMax" L "Maximum spherical multipole order to which the translation operator elements are calculated" + int + required +option "eta" n "Medium refractive index" + double + required + +option "particle" p "Specify the x and y coordinates of a single particle; If not specified, one particle per unit cell is assumed." + optional + multiple defmode "k_omega_points" modedesc="Specifying each (ω, k) pair separately." defmode "k_omega_meshgrid" modedesc="Specifying lists of ω and k, from which all possible pairs are generated." +modeoption "pointfile" T "Path to a file containing frequency, k_x, k_y triples\ +(separated by white spaces). If not specified, read them from stdin." + mode="k_omega_points" multiple default="-" + +modeoption "point" t "Specifies a frequency, k_x, k_y triple, separated by commas." + mode="k_omega_points" multiple optional + +modeoption "omegafile" F "Path to a file containing a list of frequencies\ +separated by whitespaces." + mode="k_omega_meshgrid" multiple optional + +modeoption "omega" f "Specifies frequency (or multiple frequencies separated by semicolons) on the command line." + mode="k_omega_meshgrid" multiple optional + +modeoption "kfile" K "Path to a file containing a list of k_x, k_y pairs." + mode="k_omega_meshgrid" multiple optional + default="-" + +modeoption "k" k "Specifies pair(s) of k_x, k_y values" + mode="k_omega_meshgrid" multiple optional + + #option "" # {details=""} # {argtype} {typestr=""} diff --git a/apps/transop-ewald/transop_ewald.c b/apps/transop-ewald/transop_ewald.c new file mode 100644 index 0000000..cb93737 --- /dev/null +++ b/apps/transop-ewald/transop_ewald.c @@ -0,0 +1,160 @@ +// c99 -o ew_gen_kin -Wall -I ../.. -I ../../amos/ -O2 -ggdb -DQPMS_VECTORS_NICE_TRANSFORMATIONS -DLATTICESUMS32 2dlattice_ewald.c ../translations.c ../ewald.c ../ewaldsf.c ../gaunt.c ../lattices2d.c ../latticegens.c ../bessel.c -lgsl -lm -lblas ../../amos/libamos.a -lgfortran ../error.c + +#ifdef HAVE_CONFIG_H +#include +#endif + +#include "transop_ewald_cmdline.h" + +#include +#include +#include +#define LATTICESUMS32 +#include +#include +#include + +// Command line order: +// outfile b1.x b1.y b2.x b2.y lMax scuffomega refindex npart part0.x part0.y [part1.x part1.y [...]] +// +// Standard input (per line): +// k.x k.y +// +// Output data format (line): +// + + +#define MAXKCOUNT 200 // 200 // serves as klist default buffer size +//#define KMINCOEFF 0.783 //0.9783 // 0.783 // not used if KSTDIN defined +//#define KMAXCOEFF 1.217 //1.0217 // 1.217 // not used if KSTDIN defined +#define KLAYERS 20 +#define RLAYERS 20 + +const double s3 = 1.732050807568877293527446341505872366942805253810380628055; + +//const qpms_y_t lMax = 3; +//const double REFINDEX = 1.52; +static const double SCUFF_OMEGAUNIT = 3e14; +static const double hbar = GSL_CONST_MKSA_PLANCKS_CONSTANT_HBAR; +static const double eV = GSL_CONST_MKSA_ELECTRON_CHARGE; +static const double c0 = GSL_CONST_MKSA_SPEED_OF_LIGHT; + +int main (int argc, char **argv) { + struct gengetopt_args_info args_info; + + int retval = cmdline_parser(argc, argv, *argc_info); + if (retval) return retval; + + char *outfile = argv[1]; + char *errfile = NULL; // Filename for the error estimate output; NOT USED + cart2_t b1 = {strtod(argv[2], NULL), strtod(argv[3], NULL)}, + b2 = {strtod(argv[4], NULL), strtod(argv[5], NULL)}; + const qpms_l_t lMax = strtol(argv[6], NULL, 10); assert(lMax>0); + const double scuffomega = strtod(argv[7], NULL); + const double refindex = strtod(argv[8], NULL); + const int npart = strtol(argv[9], NULL, 10); assert(npart>0); + assert(argc >= 2*npart + 10); + assert(npart > 0); + cart2_t part_positions[npart]; + for(int p = 0; p < npart; ++p) { + part_positions[p].x = strtod(argv[10+2*p], NULL); + part_positions[p].y = strtod(argv[10+2*p+1], NULL); + } + +//#ifdef KSTDIN + size_t kcount = 0; + size_t klist_capacity = MAXKCOUNT; + cart2_t *klist = malloc(sizeof(cart2_t) * klist_capacity); + while (scanf("%lf %lf", &(klist[kcount].x), &(klist[kcount].y)) == 2) { + ++kcount; + if(kcount >= klist_capacity) { + klist_capacity *= 2; + klist = realloc(klist, sizeof(cart2_t) * klist_capacity); + if (klist == NULL) abort(); + } + } +//#else +#if 0 + cart2_t klist[MAXKCOUNT]; + int kcount = MAXKCOUNT; + for (int i = 0; i < kcount; ++i) { // TODO this should depend on orientation... + klist[i].x = 0; + klist[i].y = (4.* M_PI / 3. / LATTICE_A) * (KMINCOEFF + (KMAXCOEFF-KMINCOEFF)/kcount*i); + } +#endif + + const double unitcell_area = l2d_unitcell_area(b1, b2); + l2d_reduceBasis(b1, b2, &b1, &b2); + + // TODO more clever way of determining the cutoff + const double a = sqrt(unitcell_area); // N.B. different meaning than before + const double maxR = 25 * a; + const double maxK = 25 * 2*M_PI/a; + + qpms_trans_calculator *c = qpms_trans_calculator_init(lMax, QPMS_NORMALISATION_POWER_CS); // vai POWER_CS? + + FILE *out = fopen(outfile, "w"); + FILE *err = NULL; + if (errfile) + err = fopen(errfile, "w"); + + { + const double omega = scuffomega * SCUFF_OMEGAUNIT; + const double EeV = omega * hbar / eV; + const double k0_vac = omega / c0; + const double k0_eff = k0_vac * refindex; + const double eta = 5.224/a; // FIXME quite arbitrary, but this one should work + + // indices : destpart (A/B-particle), srcpart (A/B-particle), coeff type (A/B- type), desty, srcy + complex double W[npart][npart][2][c->nelem][c->nelem]; + double Werr[npart][npart][npart][c->nelem][c->nelem]; + + for (size_t ki = 0; ki < kcount; ++ki) { + cart2_t beta = klist[ki]; + memset(W, 0, sizeof(W)); + if(err) + memset(Werr, 0, sizeof(Werr)); + + const ptrdiff_t deststride = &(W[0][0][0][1][0]) - &(W[0][0][0][0][0]); + const ptrdiff_t srcstride = &(W[0][0][0][0][1]) - &(W[0][0][0][0][0]); + assert (srcstride == 1 && deststride == c->nelem); + + for (size_t ps = 0; ps < npart; ++ps) for (size_t pd = 0; pd < npart; ++pd) + // TODO optimize (calculate only once for each particle shift; especially if pd == ps) + qpms_trans_calculator_get_AB_arrays_e32(c, + &(W[pd][ps][0][0][0]), err ? &(Werr[pd][ps][0][0][0]) : NULL, // Adest, Aerr, + &(W[pd][ps][1][0][0]), err ? &(Werr[pd][ps][1][0][0]) : NULL, // Bdest, Berr, + deststride, srcstride, + eta, k0_eff, b1, b2, + beta, + cart2_substract(part_positions[pd], part_positions[ps]), // CHECKSIGN + maxR, maxK + ); + // TODO CHECK B<-A vs. A<-B relation + + fprintf(out, "%.16g\t%.16g\t%.16g\t%.16g\t%.16g\t", + scuffomega, EeV, k0_eff, beta.x, beta.y); + if(err) fprintf(err, "%.16g\t%.16g\t%16g\t%.16g\t%.16g\t", + scuffomega, EeV, k0_eff, beta.x, beta.y); + size_t totalelems = sizeof(W) / sizeof(complex double); + for (size_t i = 0; i < totalelems; ++i) { + complex double w = ((complex double *)W)[i]; + fprintf(out, "%.16g\t%.16g\t", creal(w), cimag(w)); + if (err) + fprintf(err, "%.3g\t", ((double *)Werr)[i]); + } + fputc('\n', out); + if(err) fputc('\n', err); + } + } + + fclose(out); + if(err) fclose(err); + +//#ifdef KSTDIN + free(klist); +//#endif + + qpms_trans_calculator_free(c); + +} diff --git a/apps/transop-ewald/transop_ewald_cmdline.c b/apps/transop-ewald/transop_ewald_cmdline.c new file mode 100644 index 0000000..7509a3e --- /dev/null +++ b/apps/transop-ewald/transop_ewald_cmdline.c @@ -0,0 +1,1068 @@ +/* + File autogenerated by gengetopt version 2.22.6 + generated with the following command: + gengetopt --file-name=transop_ewald_cmdline + + The developers of gengetopt consider the fixed text that goes in all + gengetopt output files to be in the public domain: + we make no copyright claims on it. +*/ + +/* If we use autoconf. */ +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif + +#include +#include +#include + +#ifndef FIX_UNUSED +#define FIX_UNUSED(X) (void) (X) /* avoid warnings for unused params */ +#endif + +#include + +#include "transop_ewald_cmdline.h" + +const char *gengetopt_args_info_purpose = "Computes Ewald-summed VSWF translation matrix elements in arbitrary 2D-periodic\ninfinite lattices."; + +const char *gengetopt_args_info_usage = "Usage: qpms-translations-ewald32 [OPTIONS]..."; + +const char *gengetopt_args_info_versiontext = ""; + +const char *gengetopt_args_info_description = ""; + +const char *gengetopt_args_info_detailed_help[] = { + " -h, --help Print help and exit", + " --detailed-help Print help, including all details and hidden\n options, and exit", + " -V, --version Print version and exit", + " -o, --output=STRING Output file (default=`')", + " Path to the output file. If not specified, print to the standard output.", + " -E, --error-estimate-output=STRING\n Path to the output with error estimates", + " -N, --normalisation=ENUM VSWF normalisation convention (possible\n values=\"Power\", \"None\", \"SH\"\n default=`Power')", + " -c, --csphase=INT Whether the Condon-Shortley phase is included\n in VSWF definition (-1) or not (+1)\n (possible values=\"+1\", \"-1\" default=`-1')", + " -e, --Ewald-parameter=DOUBLE The value of Ewald parameter η", + " -u, --frequency-unit=STRING Specifies the frequency unit is used for\n inputs. (possible values=\"eV\", \"scuff\"\n default=`scuff')", + " -L, --lMax=INT Maximum spherical multipole order to which the\n translation operator elements are calculated", + " -n, --eta=DOUBLE Medium refractive index", + " -p, --particle Specify the x and y coordinates of a single\n particle; If not specified, one particle per\n unit cell is assumed.", + "\n Mode: k_omega_points\n Specifying each (ω, k) pair separately.", + " -T, --pointfile Path to a file containing frequency, k_x, k_y\n triples(separated by white spaces). If not\n specified, read them from stdin.", + " -t, --point Specifies a frequency, k_x, k_y triple,\n separated by commas.", + "\n Mode: k_omega_meshgrid\n Specifying lists of ω and k, from which all possible pairs are generated.", + " -F, --omegafile Path to a file containing a list of\n frequenciesseparated by whitespaces.", + " -f, --omega Specifies frequency (or multiple frequencies\n separated by semicolons) on the command line.", + " -K, --kfile Path to a file containing a list of k_x, k_y\n pairs.", + " -k, --k Specifies pair(s) of k_x, k_y values", + 0 +}; + +static void +init_help_array(void) +{ + gengetopt_args_info_help[0] = gengetopt_args_info_detailed_help[0]; + gengetopt_args_info_help[1] = gengetopt_args_info_detailed_help[1]; + gengetopt_args_info_help[2] = gengetopt_args_info_detailed_help[2]; + gengetopt_args_info_help[3] = gengetopt_args_info_detailed_help[3]; + gengetopt_args_info_help[4] = gengetopt_args_info_detailed_help[5]; + gengetopt_args_info_help[5] = gengetopt_args_info_detailed_help[6]; + gengetopt_args_info_help[6] = gengetopt_args_info_detailed_help[7]; + gengetopt_args_info_help[7] = gengetopt_args_info_detailed_help[8]; + gengetopt_args_info_help[8] = gengetopt_args_info_detailed_help[9]; + gengetopt_args_info_help[9] = gengetopt_args_info_detailed_help[10]; + gengetopt_args_info_help[10] = gengetopt_args_info_detailed_help[11]; + gengetopt_args_info_help[11] = gengetopt_args_info_detailed_help[12]; + gengetopt_args_info_help[12] = gengetopt_args_info_detailed_help[13]; + gengetopt_args_info_help[13] = gengetopt_args_info_detailed_help[14]; + gengetopt_args_info_help[14] = gengetopt_args_info_detailed_help[15]; + gengetopt_args_info_help[15] = gengetopt_args_info_detailed_help[16]; + gengetopt_args_info_help[16] = gengetopt_args_info_detailed_help[17]; + gengetopt_args_info_help[17] = gengetopt_args_info_detailed_help[18]; + gengetopt_args_info_help[18] = gengetopt_args_info_detailed_help[19]; + gengetopt_args_info_help[19] = gengetopt_args_info_detailed_help[20]; + gengetopt_args_info_help[20] = 0; + +} + +const char *gengetopt_args_info_help[21]; + +typedef enum {ARG_NO + , ARG_STRING + , ARG_INT + , ARG_DOUBLE + , ARG_ENUM +} cmdline_parser_arg_type; + +static +void clear_given (struct gengetopt_args_info *args_info); +static +void clear_args (struct gengetopt_args_info *args_info); + +static int +cmdline_parser_internal (int argc, char **argv, struct gengetopt_args_info *args_info, + struct cmdline_parser_params *params, const char *additional_error); + +static int +cmdline_parser_required2 (struct gengetopt_args_info *args_info, const char *prog_name, const char *additional_error); + +const char *cmdline_parser_normalisation_values[] = {"Power", "None", "SH", 0}; /*< Possible values for normalisation. */ +const char *cmdline_parser_csphase_values[] = {"+1", "-1", 0}; /*< Possible values for csphase. */ +const char *cmdline_parser_frequency_unit_values[] = {"eV", "scuff", 0}; /*< Possible values for frequency-unit. */ + +static char * +gengetopt_strdup (const char *s); + +static +void clear_given (struct gengetopt_args_info *args_info) +{ + args_info->help_given = 0 ; + args_info->detailed_help_given = 0 ; + args_info->version_given = 0 ; + args_info->output_given = 0 ; + args_info->error_estimate_output_given = 0 ; + args_info->normalisation_given = 0 ; + args_info->csphase_given = 0 ; + args_info->Ewald_parameter_given = 0 ; + args_info->frequency_unit_given = 0 ; + args_info->lMax_given = 0 ; + args_info->eta_given = 0 ; + args_info->particle_given = 0 ; + args_info->pointfile_given = 0 ; + args_info->point_given = 0 ; + args_info->omegafile_given = 0 ; + args_info->omega_given = 0 ; + args_info->kfile_given = 0 ; + args_info->k_given = 0 ; + args_info->k_omega_meshgrid_mode_counter = 0 ; + args_info->k_omega_points_mode_counter = 0 ; +} + +static +void clear_args (struct gengetopt_args_info *args_info) +{ + FIX_UNUSED (args_info); + args_info->output_arg = gengetopt_strdup (""); + args_info->output_orig = NULL; + args_info->error_estimate_output_arg = NULL; + args_info->error_estimate_output_orig = NULL; + args_info->normalisation_arg = normalisation_arg_Power; + args_info->normalisation_orig = NULL; + args_info->csphase_arg = -1; + args_info->csphase_orig = NULL; + args_info->Ewald_parameter_orig = NULL; + args_info->frequency_unit_arg = gengetopt_strdup ("scuff"); + args_info->frequency_unit_orig = NULL; + args_info->lMax_orig = NULL; + args_info->eta_orig = NULL; + +} + +static +void init_args_info(struct gengetopt_args_info *args_info) +{ + + init_help_array(); + args_info->help_help = gengetopt_args_info_detailed_help[0] ; + args_info->detailed_help_help = gengetopt_args_info_detailed_help[1] ; + args_info->version_help = gengetopt_args_info_detailed_help[2] ; + args_info->output_help = gengetopt_args_info_detailed_help[3] ; + args_info->error_estimate_output_help = gengetopt_args_info_detailed_help[5] ; + args_info->normalisation_help = gengetopt_args_info_detailed_help[6] ; + args_info->csphase_help = gengetopt_args_info_detailed_help[7] ; + args_info->Ewald_parameter_help = gengetopt_args_info_detailed_help[8] ; + args_info->frequency_unit_help = gengetopt_args_info_detailed_help[9] ; + args_info->lMax_help = gengetopt_args_info_detailed_help[10] ; + args_info->eta_help = gengetopt_args_info_detailed_help[11] ; + args_info->particle_help = gengetopt_args_info_detailed_help[12] ; + args_info->particle_min = 0; + args_info->particle_max = 0; + args_info->pointfile_help = gengetopt_args_info_detailed_help[14] ; + args_info->pointfile_min = 0; + args_info->pointfile_max = 0; + args_info->point_help = gengetopt_args_info_detailed_help[15] ; + args_info->point_min = 0; + args_info->point_max = 0; + args_info->omegafile_help = gengetopt_args_info_detailed_help[17] ; + args_info->omegafile_min = 0; + args_info->omegafile_max = 0; + args_info->omega_help = gengetopt_args_info_detailed_help[18] ; + args_info->omega_min = 0; + args_info->omega_max = 0; + args_info->kfile_help = gengetopt_args_info_detailed_help[19] ; + args_info->kfile_min = 0; + args_info->kfile_max = 0; + args_info->k_help = gengetopt_args_info_detailed_help[20] ; + args_info->k_min = 0; + args_info->k_max = 0; + +} + +void +cmdline_parser_print_version (void) +{ + printf ("%s %s\n", + (strlen(CMDLINE_PARSER_PACKAGE_NAME) ? CMDLINE_PARSER_PACKAGE_NAME : CMDLINE_PARSER_PACKAGE), + CMDLINE_PARSER_VERSION); + + if (strlen(gengetopt_args_info_versiontext) > 0) + printf("\n%s\n", gengetopt_args_info_versiontext); +} + +static void print_help_common(void) { + cmdline_parser_print_version (); + + if (strlen(gengetopt_args_info_purpose) > 0) + printf("\n%s\n", gengetopt_args_info_purpose); + + if (strlen(gengetopt_args_info_usage) > 0) + printf("\n%s\n", gengetopt_args_info_usage); + + printf("\n"); + + if (strlen(gengetopt_args_info_description) > 0) + printf("%s\n\n", gengetopt_args_info_description); +} + +void +cmdline_parser_print_help (void) +{ + int i = 0; + print_help_common(); + while (gengetopt_args_info_help[i]) + printf("%s\n", gengetopt_args_info_help[i++]); +} + +void +cmdline_parser_print_detailed_help (void) +{ + int i = 0; + print_help_common(); + while (gengetopt_args_info_detailed_help[i]) + printf("%s\n", gengetopt_args_info_detailed_help[i++]); +} + +void +cmdline_parser_init (struct gengetopt_args_info *args_info) +{ + clear_given (args_info); + clear_args (args_info); + init_args_info (args_info); +} + +void +cmdline_parser_params_init(struct cmdline_parser_params *params) +{ + if (params) + { + params->override = 0; + params->initialize = 1; + params->check_required = 1; + params->check_ambiguity = 0; + params->print_errors = 1; + } +} + +struct cmdline_parser_params * +cmdline_parser_params_create(void) +{ + struct cmdline_parser_params *params = + (struct cmdline_parser_params *)malloc(sizeof(struct cmdline_parser_params)); + cmdline_parser_params_init(params); + return params; +} + +static void +free_string_field (char **s) +{ + if (*s) + { + free (*s); + *s = 0; + } +} + + +static void +cmdline_parser_release (struct gengetopt_args_info *args_info) +{ + + free_string_field (&(args_info->output_arg)); + free_string_field (&(args_info->output_orig)); + free_string_field (&(args_info->error_estimate_output_arg)); + free_string_field (&(args_info->error_estimate_output_orig)); + free_string_field (&(args_info->normalisation_orig)); + free_string_field (&(args_info->csphase_orig)); + free_string_field (&(args_info->Ewald_parameter_orig)); + free_string_field (&(args_info->frequency_unit_arg)); + free_string_field (&(args_info->frequency_unit_orig)); + free_string_field (&(args_info->lMax_orig)); + free_string_field (&(args_info->eta_orig)); + + + + clear_given (args_info); +} + +/** + * @param val the value to check + * @param values the possible values + * @return the index of the matched value: + * -1 if no value matched, + * -2 if more than one value has matched + */ +static int +check_possible_values(const char *val, const char *values[]) +{ + int i, found, last; + size_t len; + + if (!val) /* otherwise strlen() crashes below */ + return -1; /* -1 means no argument for the option */ + + found = last = 0; + + for (i = 0, len = strlen(val); values[i]; ++i) + { + if (strncmp(val, values[i], len) == 0) + { + ++found; + last = i; + if (strlen(values[i]) == len) + return i; /* exact macth no need to check more */ + } + } + + if (found == 1) /* one match: OK */ + return last; + + return (found ? -2 : -1); /* return many values or none matched */ +} + + +static void +write_into_file(FILE *outfile, const char *opt, const char *arg, const char *values[]) +{ + int found = -1; + if (arg) { + if (values) { + found = check_possible_values(arg, values); + } + if (found >= 0) + fprintf(outfile, "%s=\"%s\" # %s\n", opt, arg, values[found]); + else + fprintf(outfile, "%s=\"%s\"\n", opt, arg); + } else { + fprintf(outfile, "%s\n", opt); + } +} + +static void +write_multiple_into_file(FILE *outfile, int len, const char *opt, char **arg, const char *values[]) +{ + int i; + + for (i = 0; i < len; ++i) + write_into_file(outfile, opt, (arg ? arg[i] : 0), values); +} + +int +cmdline_parser_dump(FILE *outfile, struct gengetopt_args_info *args_info) +{ + int i = 0; + + if (!outfile) + { + fprintf (stderr, "%s: cannot dump options to stream\n", CMDLINE_PARSER_PACKAGE); + return EXIT_FAILURE; + } + + if (args_info->help_given) + write_into_file(outfile, "help", 0, 0 ); + if (args_info->detailed_help_given) + write_into_file(outfile, "detailed-help", 0, 0 ); + if (args_info->version_given) + write_into_file(outfile, "version", 0, 0 ); + if (args_info->output_given) + write_into_file(outfile, "output", args_info->output_orig, 0); + if (args_info->error_estimate_output_given) + write_into_file(outfile, "error-estimate-output", args_info->error_estimate_output_orig, 0); + if (args_info->normalisation_given) + write_into_file(outfile, "normalisation", args_info->normalisation_orig, cmdline_parser_normalisation_values); + if (args_info->csphase_given) + write_into_file(outfile, "csphase", args_info->csphase_orig, cmdline_parser_csphase_values); + if (args_info->Ewald_parameter_given) + write_into_file(outfile, "Ewald-parameter", args_info->Ewald_parameter_orig, 0); + if (args_info->frequency_unit_given) + write_into_file(outfile, "frequency-unit", args_info->frequency_unit_orig, cmdline_parser_frequency_unit_values); + if (args_info->lMax_given) + write_into_file(outfile, "lMax", args_info->lMax_orig, 0); + if (args_info->eta_given) + write_into_file(outfile, "eta", args_info->eta_orig, 0); + write_multiple_into_file(outfile, args_info->particle_given, "particle", 0, 0); + write_multiple_into_file(outfile, args_info->pointfile_given, "pointfile", 0, 0); + write_multiple_into_file(outfile, args_info->point_given, "point", 0, 0); + write_multiple_into_file(outfile, args_info->omegafile_given, "omegafile", 0, 0); + write_multiple_into_file(outfile, args_info->omega_given, "omega", 0, 0); + write_multiple_into_file(outfile, args_info->kfile_given, "kfile", 0, 0); + write_multiple_into_file(outfile, args_info->k_given, "k", 0, 0); + + + i = EXIT_SUCCESS; + return i; +} + +int +cmdline_parser_file_save(const char *filename, struct gengetopt_args_info *args_info) +{ + FILE *outfile; + int i = 0; + + outfile = fopen(filename, "w"); + + if (!outfile) + { + fprintf (stderr, "%s: cannot open file for writing: %s\n", CMDLINE_PARSER_PACKAGE, filename); + return EXIT_FAILURE; + } + + i = cmdline_parser_dump(outfile, args_info); + fclose (outfile); + + return i; +} + +void +cmdline_parser_free (struct gengetopt_args_info *args_info) +{ + cmdline_parser_release (args_info); +} + +/** @brief replacement of strdup, which is not standard */ +char * +gengetopt_strdup (const char *s) +{ + char *result = 0; + if (!s) + return result; + + result = (char*)malloc(strlen(s) + 1); + if (result == (char*)0) + return (char*)0; + strcpy(result, s); + return result; +} + +static int +check_multiple_option_occurrences(const char *prog_name, unsigned int option_given, unsigned int min, unsigned int max, const char *option_desc); + +int +check_multiple_option_occurrences(const char *prog_name, unsigned int option_given, unsigned int min, unsigned int max, const char *option_desc) +{ + int error_occurred = 0; + + if (option_given && (min > 0 || max > 0)) + { + if (min > 0 && max > 0) + { + if (min == max) + { + /* specific occurrences */ + if (option_given != (unsigned int) min) + { + fprintf (stderr, "%s: %s option occurrences must be %d\n", + prog_name, option_desc, min); + error_occurred = 1; + } + } + else if (option_given < (unsigned int) min + || option_given > (unsigned int) max) + { + /* range occurrences */ + fprintf (stderr, "%s: %s option occurrences must be between %d and %d\n", + prog_name, option_desc, min, max); + error_occurred = 1; + } + } + else if (min > 0) + { + /* at least check */ + if (option_given < min) + { + fprintf (stderr, "%s: %s option occurrences must be at least %d\n", + prog_name, option_desc, min); + error_occurred = 1; + } + } + else if (max > 0) + { + /* at most check */ + if (option_given > max) + { + fprintf (stderr, "%s: %s option occurrences must be at most %d\n", + prog_name, option_desc, max); + error_occurred = 1; + } + } + } + + return error_occurred; +} +int +cmdline_parser (int argc, char **argv, struct gengetopt_args_info *args_info) +{ + return cmdline_parser2 (argc, argv, args_info, 0, 1, 1); +} + +int +cmdline_parser_ext (int argc, char **argv, struct gengetopt_args_info *args_info, + struct cmdline_parser_params *params) +{ + int result; + result = cmdline_parser_internal (argc, argv, args_info, params, 0); + + if (result == EXIT_FAILURE) + { + cmdline_parser_free (args_info); + exit (EXIT_FAILURE); + } + + return result; +} + +int +cmdline_parser2 (int argc, char **argv, struct gengetopt_args_info *args_info, int override, int initialize, int check_required) +{ + int result; + struct cmdline_parser_params params; + + params.override = override; + params.initialize = initialize; + params.check_required = check_required; + params.check_ambiguity = 0; + params.print_errors = 1; + + result = cmdline_parser_internal (argc, argv, args_info, ¶ms, 0); + + if (result == EXIT_FAILURE) + { + cmdline_parser_free (args_info); + exit (EXIT_FAILURE); + } + + return result; +} + +int +cmdline_parser_required (struct gengetopt_args_info *args_info, const char *prog_name) +{ + int result = EXIT_SUCCESS; + + if (cmdline_parser_required2(args_info, prog_name, 0) > 0) + result = EXIT_FAILURE; + + if (result == EXIT_FAILURE) + { + cmdline_parser_free (args_info); + exit (EXIT_FAILURE); + } + + return result; +} + +int +cmdline_parser_required2 (struct gengetopt_args_info *args_info, const char *prog_name, const char *additional_error) +{ + int error_occurred = 0; + FIX_UNUSED (additional_error); + + /* checks for required options */ + if (! args_info->normalisation_given) + { + fprintf (stderr, "%s: '--normalisation' ('-N') option required%s\n", prog_name, (additional_error ? additional_error : "")); + error_occurred = 1; + } + + if (! args_info->csphase_given) + { + fprintf (stderr, "%s: '--csphase' ('-c') option required%s\n", prog_name, (additional_error ? additional_error : "")); + error_occurred = 1; + } + + if (! args_info->frequency_unit_given) + { + fprintf (stderr, "%s: '--frequency-unit' ('-u') option required%s\n", prog_name, (additional_error ? additional_error : "")); + error_occurred = 1; + } + + if (! args_info->lMax_given) + { + fprintf (stderr, "%s: '--lMax' ('-L') option required%s\n", prog_name, (additional_error ? additional_error : "")); + error_occurred = 1; + } + + if (! args_info->eta_given) + { + fprintf (stderr, "%s: '--eta' ('-n') option required%s\n", prog_name, (additional_error ? additional_error : "")); + error_occurred = 1; + } + + if (check_multiple_option_occurrences(prog_name, args_info->particle_given, args_info->particle_min, args_info->particle_max, "'--particle' ('-p')")) + error_occurred = 1; + + if (args_info->k_omega_points_mode_counter && ! args_info->pointfile_given) + { + fprintf (stderr, "%s: '--pointfile' ('-T') option required%s\n", prog_name, (additional_error ? additional_error : "")); + error_occurred = 1; + } + + if (args_info->k_omega_points_mode_counter && check_multiple_option_occurrences(prog_name, args_info->pointfile_given, args_info->pointfile_min, args_info->pointfile_max, "'--pointfile' ('-T')")) + error_occurred = 1; + + if (args_info->k_omega_points_mode_counter && check_multiple_option_occurrences(prog_name, args_info->point_given, args_info->point_min, args_info->point_max, "'--point' ('-t')")) + error_occurred = 1; + + if (args_info->k_omega_meshgrid_mode_counter && check_multiple_option_occurrences(prog_name, args_info->omegafile_given, args_info->omegafile_min, args_info->omegafile_max, "'--omegafile' ('-F')")) + error_occurred = 1; + + if (args_info->k_omega_meshgrid_mode_counter && check_multiple_option_occurrences(prog_name, args_info->omega_given, args_info->omega_min, args_info->omega_max, "'--omega' ('-f')")) + error_occurred = 1; + + if (args_info->k_omega_meshgrid_mode_counter && check_multiple_option_occurrences(prog_name, args_info->kfile_given, args_info->kfile_min, args_info->kfile_max, "'--kfile' ('-K')")) + error_occurred = 1; + + if (args_info->k_omega_meshgrid_mode_counter && check_multiple_option_occurrences(prog_name, args_info->k_given, args_info->k_min, args_info->k_max, "'--k' ('-k')")) + error_occurred = 1; + + + /* checks for dependences among options */ + + return error_occurred; +} + + +static char *package_name = 0; + +/** + * @brief updates an option + * @param field the generic pointer to the field to update + * @param orig_field the pointer to the orig field + * @param field_given the pointer to the number of occurrence of this option + * @param prev_given the pointer to the number of occurrence already seen + * @param value the argument for this option (if null no arg was specified) + * @param possible_values the possible values for this option (if specified) + * @param default_value the default value (in case the option only accepts fixed values) + * @param arg_type the type of this option + * @param check_ambiguity @see cmdline_parser_params.check_ambiguity + * @param override @see cmdline_parser_params.override + * @param no_free whether to free a possible previous value + * @param multiple_option whether this is a multiple option + * @param long_opt the corresponding long option + * @param short_opt the corresponding short option (or '-' if none) + * @param additional_error possible further error specification + */ +static +int update_arg(void *field, char **orig_field, + unsigned int *field_given, unsigned int *prev_given, + char *value, const char *possible_values[], + const char *default_value, + cmdline_parser_arg_type arg_type, + int check_ambiguity, int override, + int no_free, int multiple_option, + const char *long_opt, char short_opt, + const char *additional_error) +{ + char *stop_char = 0; + const char *val = value; + int found; + char **string_field; + FIX_UNUSED (field); + + stop_char = 0; + found = 0; + + if (!multiple_option && prev_given && (*prev_given || (check_ambiguity && *field_given))) + { + if (short_opt != '-') + fprintf (stderr, "%s: `--%s' (`-%c') option given more than once%s\n", + package_name, long_opt, short_opt, + (additional_error ? additional_error : "")); + else + fprintf (stderr, "%s: `--%s' option given more than once%s\n", + package_name, long_opt, + (additional_error ? additional_error : "")); + return 1; /* failure */ + } + + if (possible_values && (found = check_possible_values((value ? value : default_value), possible_values)) < 0) + { + if (short_opt != '-') + fprintf (stderr, "%s: %s argument, \"%s\", for option `--%s' (`-%c')%s\n", + package_name, (found == -2) ? "ambiguous" : "invalid", value, long_opt, short_opt, + (additional_error ? additional_error : "")); + else + fprintf (stderr, "%s: %s argument, \"%s\", for option `--%s'%s\n", + package_name, (found == -2) ? "ambiguous" : "invalid", value, long_opt, + (additional_error ? additional_error : "")); + return 1; /* failure */ + } + + if (field_given && *field_given && ! override) + return 0; + if (prev_given) + (*prev_given)++; + if (field_given) + (*field_given)++; + if (possible_values) + val = possible_values[found]; + + switch(arg_type) { + case ARG_INT: + if (val) *((int *)field) = strtol (val, &stop_char, 0); + break; + case ARG_DOUBLE: + if (val) *((double *)field) = strtod (val, &stop_char); + break; + case ARG_ENUM: + if (val) *((int *)field) = found; + break; + case ARG_STRING: + if (val) { + string_field = (char **)field; + if (!no_free && *string_field) + free (*string_field); /* free previous string */ + *string_field = gengetopt_strdup (val); + } + break; + default: + break; + }; + + /* check numeric conversion */ + switch(arg_type) { + case ARG_INT: + case ARG_DOUBLE: + if (val && !(stop_char && *stop_char == '\0')) { + fprintf(stderr, "%s: invalid numeric value: %s\n", package_name, val); + return 1; /* failure */ + } + break; + default: + ; + }; + + /* store the original value */ + switch(arg_type) { + case ARG_NO: + break; + default: + if (value && orig_field) { + if (no_free) { + *orig_field = value; + } else { + if (*orig_field) + free (*orig_field); /* free previous string */ + *orig_field = gengetopt_strdup (value); + } + } + }; + + return 0; /* OK */ +} + + +static int check_modes( + int given1[], const char *options1[], + int given2[], const char *options2[]) +{ + int i = 0, j = 0, errors = 0; + + while (given1[i] >= 0) { + if (given1[i]) { + while (given2[j] >= 0) { + if (given2[j]) { + ++errors; + fprintf(stderr, "%s: option %s conflicts with option %s\n", + package_name, options1[i], options2[j]); + } + ++j; + } + } + ++i; + } + + return errors; +} + +int +cmdline_parser_internal ( + int argc, char **argv, struct gengetopt_args_info *args_info, + struct cmdline_parser_params *params, const char *additional_error) +{ + int c; /* Character of the parsed option. */ + union generic_value multiple_default_value; + + int error_occurred = 0; + struct gengetopt_args_info local_args_info; + + int override; + int initialize; + int check_required; + int check_ambiguity; + + package_name = argv[0]; + + override = params->override; + initialize = params->initialize; + check_required = params->check_required; + check_ambiguity = params->check_ambiguity; + + if (initialize) + cmdline_parser_init (args_info); + + cmdline_parser_init (&local_args_info); + + optarg = 0; + optind = 0; + opterr = params->print_errors; + optopt = '?'; + + while (1) + { + int option_index = 0; + + static struct option long_options[] = { + { "help", 0, NULL, 'h' }, + { "detailed-help", 0, NULL, 0 }, + { "version", 0, NULL, 'V' }, + { "output", 1, NULL, 'o' }, + { "error-estimate-output", 1, NULL, 'E' }, + { "normalisation", 1, NULL, 'N' }, + { "csphase", 1, NULL, 'c' }, + { "Ewald-parameter", 1, NULL, 'e' }, + { "frequency-unit", 1, NULL, 'u' }, + { "lMax", 1, NULL, 'L' }, + { "eta", 1, NULL, 'n' }, + { "particle", 0, NULL, 'p' }, + { "pointfile", 0, NULL, 'T' }, + { "point", 0, NULL, 't' }, + { "omegafile", 0, NULL, 'F' }, + { "omega", 0, NULL, 'f' }, + { "kfile", 0, NULL, 'K' }, + { "k", 0, NULL, 'k' }, + { 0, 0, 0, 0 } + }; + + c = getopt_long (argc, argv, "hVo:E:N:c:e:u:L:n:pTtFfKk", long_options, &option_index); + + if (c == -1) break; /* Exit from `while (1)' loop. */ + + switch (c) + { + case 'h': /* Print help and exit. */ + cmdline_parser_print_help (); + cmdline_parser_free (&local_args_info); + exit (EXIT_SUCCESS); + + case 'V': /* Print version and exit. */ + cmdline_parser_print_version (); + cmdline_parser_free (&local_args_info); + exit (EXIT_SUCCESS); + + case 'o': /* Output file. */ + + + if (update_arg( (void *)&(args_info->output_arg), + &(args_info->output_orig), &(args_info->output_given), + &(local_args_info.output_given), optarg, 0, "", ARG_STRING, + check_ambiguity, override, 0, 0, + "output", 'o', + additional_error)) + goto failure; + + break; + case 'E': /* Path to the output with error estimates. */ + + + if (update_arg( (void *)&(args_info->error_estimate_output_arg), + &(args_info->error_estimate_output_orig), &(args_info->error_estimate_output_given), + &(local_args_info.error_estimate_output_given), optarg, 0, 0, ARG_STRING, + check_ambiguity, override, 0, 0, + "error-estimate-output", 'E', + additional_error)) + goto failure; + + break; + case 'N': /* VSWF normalisation convention. */ + + + if (update_arg( (void *)&(args_info->normalisation_arg), + &(args_info->normalisation_orig), &(args_info->normalisation_given), + &(local_args_info.normalisation_given), optarg, cmdline_parser_normalisation_values, "Power", ARG_ENUM, + check_ambiguity, override, 0, 0, + "normalisation", 'N', + additional_error)) + goto failure; + + break; + case 'c': /* Whether the Condon-Shortley phase is included in VSWF definition (-1) or not (+1). */ + + + if (update_arg( (void *)&(args_info->csphase_arg), + &(args_info->csphase_orig), &(args_info->csphase_given), + &(local_args_info.csphase_given), optarg, cmdline_parser_csphase_values, "-1", ARG_INT, + check_ambiguity, override, 0, 0, + "csphase", 'c', + additional_error)) + goto failure; + + break; + case 'e': /* The value of Ewald parameter η. */ + + + if (update_arg( (void *)&(args_info->Ewald_parameter_arg), + &(args_info->Ewald_parameter_orig), &(args_info->Ewald_parameter_given), + &(local_args_info.Ewald_parameter_given), optarg, 0, 0, ARG_DOUBLE, + check_ambiguity, override, 0, 0, + "Ewald-parameter", 'e', + additional_error)) + goto failure; + + break; + case 'u': /* Specifies the frequency unit is used for inputs.. */ + + + if (update_arg( (void *)&(args_info->frequency_unit_arg), + &(args_info->frequency_unit_orig), &(args_info->frequency_unit_given), + &(local_args_info.frequency_unit_given), optarg, cmdline_parser_frequency_unit_values, "scuff", ARG_STRING, + check_ambiguity, override, 0, 0, + "frequency-unit", 'u', + additional_error)) + goto failure; + + break; + case 'L': /* Maximum spherical multipole order to which the translation operator elements are calculated. */ + + + if (update_arg( (void *)&(args_info->lMax_arg), + &(args_info->lMax_orig), &(args_info->lMax_given), + &(local_args_info.lMax_given), optarg, 0, 0, ARG_INT, + check_ambiguity, override, 0, 0, + "lMax", 'L', + additional_error)) + goto failure; + + break; + case 'n': /* Medium refractive index. */ + + + if (update_arg( (void *)&(args_info->eta_arg), + &(args_info->eta_orig), &(args_info->eta_given), + &(local_args_info.eta_given), optarg, 0, 0, ARG_DOUBLE, + check_ambiguity, override, 0, 0, + "eta", 'n', + additional_error)) + goto failure; + + break; + case 'p': /* Specify the x and y coordinates of a single particle; If not specified, one particle per unit cell is assumed.. */ + + local_args_info.particle_given++; + + break; + case 'T': /* Path to a file containing frequency, k_x, k_y triples(separated by white spaces). If not specified, read them from stdin.. */ + args_info->k_omega_points_mode_counter += 1; + + local_args_info.pointfile_given++; + + break; + case 't': /* Specifies a frequency, k_x, k_y triple, separated by commas.. */ + args_info->k_omega_points_mode_counter += 1; + + local_args_info.point_given++; + + break; + case 'F': /* Path to a file containing a list of frequenciesseparated by whitespaces.. */ + args_info->k_omega_meshgrid_mode_counter += 1; + + local_args_info.omegafile_given++; + + break; + case 'f': /* Specifies frequency (or multiple frequencies separated by semicolons) on the command line.. */ + args_info->k_omega_meshgrid_mode_counter += 1; + + local_args_info.omega_given++; + + break; + case 'K': /* Path to a file containing a list of k_x, k_y pairs.. */ + args_info->k_omega_meshgrid_mode_counter += 1; + + local_args_info.kfile_given++; + + break; + case 'k': /* Specifies pair(s) of k_x, k_y values. */ + args_info->k_omega_meshgrid_mode_counter += 1; + + local_args_info.k_given++; + + break; + + case 0: /* Long option with no short option */ + if (strcmp (long_options[option_index].name, "detailed-help") == 0) { + cmdline_parser_print_detailed_help (); + cmdline_parser_free (&local_args_info); + exit (EXIT_SUCCESS); + } + + case '?': /* Invalid option. */ + /* `getopt_long' already printed an error message. */ + goto failure; + + default: /* bug: option not considered. */ + fprintf (stderr, "%s: option unknown: %c%s\n", CMDLINE_PARSER_PACKAGE, c, (additional_error ? additional_error : "")); + abort (); + } /* switch */ + } /* while */ + + + + args_info->particle_given += local_args_info.particle_given; + local_args_info.particle_given = 0; + args_info->pointfile_given += local_args_info.pointfile_given; + local_args_info.pointfile_given = 0; + args_info->point_given += local_args_info.point_given; + local_args_info.point_given = 0; + args_info->omegafile_given += local_args_info.omegafile_given; + local_args_info.omegafile_given = 0; + args_info->omega_given += local_args_info.omega_given; + local_args_info.omega_given = 0; + args_info->kfile_given += local_args_info.kfile_given; + local_args_info.kfile_given = 0; + args_info->k_given += local_args_info.k_given; + local_args_info.k_given = 0; + + if (args_info->k_omega_meshgrid_mode_counter && args_info->k_omega_points_mode_counter) { + int k_omega_meshgrid_given[] = {args_info->omegafile_given, args_info->omega_given, args_info->kfile_given, args_info->k_given, -1}; + const char *k_omega_meshgrid_desc[] = {"--omegafile", "--omega", "--kfile", "--k", 0}; + int k_omega_points_given[] = {args_info->pointfile_given, args_info->point_given, -1}; + const char *k_omega_points_desc[] = {"--pointfile", "--point", 0}; + error_occurred += check_modes(k_omega_meshgrid_given, k_omega_meshgrid_desc, k_omega_points_given, k_omega_points_desc); + } + + if (check_required) + { + error_occurred += cmdline_parser_required2 (args_info, argv[0], additional_error); + } + + cmdline_parser_release (&local_args_info); + + if ( error_occurred ) + return (EXIT_FAILURE); + + return 0; + +failure: + + cmdline_parser_release (&local_args_info); + return (EXIT_FAILURE); +} diff --git a/apps/transop-ewald/transop_ewald_cmdline.h b/apps/transop-ewald/transop_ewald_cmdline.h new file mode 100644 index 0000000..32ec26f --- /dev/null +++ b/apps/transop-ewald/transop_ewald_cmdline.h @@ -0,0 +1,249 @@ +/** @file transop_ewald_cmdline.h + * @brief The header file for the command line option parser + * generated by GNU Gengetopt version 2.22.6 + * http://www.gnu.org/software/gengetopt. + * DO NOT modify this file, since it can be overwritten + * @author GNU Gengetopt by Lorenzo Bettini */ + +#ifndef TRANSOP_EWALD_CMDLINE_H +#define TRANSOP_EWALD_CMDLINE_H + +/* If we use autoconf. */ +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif + +#include /* for FILE */ + +#ifdef __cplusplus +extern "C" { +#endif /* __cplusplus */ + +#ifndef CMDLINE_PARSER_PACKAGE +/** @brief the program name (used for printing errors) */ +#define CMDLINE_PARSER_PACKAGE "qpms-translations-ewald32" +#endif + +#ifndef CMDLINE_PARSER_PACKAGE_NAME +/** @brief the complete program name (used for help and version) */ +#define CMDLINE_PARSER_PACKAGE_NAME "qpms-translations-ewald32" +#endif + +#ifndef CMDLINE_PARSER_VERSION +/** @brief the program version */ +#define CMDLINE_PARSER_VERSION "dev" +#endif + +enum enum_normalisation { normalisation__NULL = -1, normalisation_arg_Power = 0, normalisation_arg_None, normalisation_arg_SH }; + +/** @brief Where the command line options are stored */ +struct gengetopt_args_info +{ + const char *help_help; /**< @brief Print help and exit help description. */ + const char *detailed_help_help; /**< @brief Print help, including all details and hidden options, and exit help description. */ + const char *version_help; /**< @brief Print version and exit help description. */ + char * output_arg; /**< @brief Output file (default=''). */ + char * output_orig; /**< @brief Output file original value given at command line. */ + const char *output_help; /**< @brief Output file help description. */ + char * error_estimate_output_arg; /**< @brief Path to the output with error estimates. */ + char * error_estimate_output_orig; /**< @brief Path to the output with error estimates original value given at command line. */ + const char *error_estimate_output_help; /**< @brief Path to the output with error estimates help description. */ + enum enum_normalisation normalisation_arg; /**< @brief VSWF normalisation convention (default='Power'). */ + char * normalisation_orig; /**< @brief VSWF normalisation convention original value given at command line. */ + const char *normalisation_help; /**< @brief VSWF normalisation convention help description. */ + int csphase_arg; /**< @brief Whether the Condon-Shortley phase is included in VSWF definition (-1) or not (+1) (default='-1'). */ + char * csphase_orig; /**< @brief Whether the Condon-Shortley phase is included in VSWF definition (-1) or not (+1) original value given at command line. */ + const char *csphase_help; /**< @brief Whether the Condon-Shortley phase is included in VSWF definition (-1) or not (+1) help description. */ + double Ewald_parameter_arg; /**< @brief The value of Ewald parameter η. */ + char * Ewald_parameter_orig; /**< @brief The value of Ewald parameter η original value given at command line. */ + const char *Ewald_parameter_help; /**< @brief The value of Ewald parameter η help description. */ + char * frequency_unit_arg; /**< @brief Specifies the frequency unit is used for inputs. (default='scuff'). */ + char * frequency_unit_orig; /**< @brief Specifies the frequency unit is used for inputs. original value given at command line. */ + const char *frequency_unit_help; /**< @brief Specifies the frequency unit is used for inputs. help description. */ + int lMax_arg; /**< @brief Maximum spherical multipole order to which the translation operator elements are calculated. */ + char * lMax_orig; /**< @brief Maximum spherical multipole order to which the translation operator elements are calculated original value given at command line. */ + const char *lMax_help; /**< @brief Maximum spherical multipole order to which the translation operator elements are calculated help description. */ + double eta_arg; /**< @brief Medium refractive index. */ + char * eta_orig; /**< @brief Medium refractive index original value given at command line. */ + const char *eta_help; /**< @brief Medium refractive index help description. */ + unsigned int particle_min; /**< @brief Specify the x and y coordinates of a single particle; If not specified, one particle per unit cell is assumed.'s minimum occurreces */ + unsigned int particle_max; /**< @brief Specify the x and y coordinates of a single particle; If not specified, one particle per unit cell is assumed.'s maximum occurreces */ + const char *particle_help; /**< @brief Specify the x and y coordinates of a single particle; If not specified, one particle per unit cell is assumed. help description. */ + unsigned int pointfile_min; /**< @brief Path to a file containing frequency, k_x, k_y triples(separated by white spaces). If not specified, read them from stdin.'s minimum occurreces */ + unsigned int pointfile_max; /**< @brief Path to a file containing frequency, k_x, k_y triples(separated by white spaces). If not specified, read them from stdin.'s maximum occurreces */ + const char *pointfile_help; /**< @brief Path to a file containing frequency, k_x, k_y triples(separated by white spaces). If not specified, read them from stdin. help description. */ + unsigned int point_min; /**< @brief Specifies a frequency, k_x, k_y triple, separated by commas.'s minimum occurreces */ + unsigned int point_max; /**< @brief Specifies a frequency, k_x, k_y triple, separated by commas.'s maximum occurreces */ + const char *point_help; /**< @brief Specifies a frequency, k_x, k_y triple, separated by commas. help description. */ + unsigned int omegafile_min; /**< @brief Path to a file containing a list of frequenciesseparated by whitespaces.'s minimum occurreces */ + unsigned int omegafile_max; /**< @brief Path to a file containing a list of frequenciesseparated by whitespaces.'s maximum occurreces */ + const char *omegafile_help; /**< @brief Path to a file containing a list of frequenciesseparated by whitespaces. help description. */ + unsigned int omega_min; /**< @brief Specifies frequency (or multiple frequencies separated by semicolons) on the command line.'s minimum occurreces */ + unsigned int omega_max; /**< @brief Specifies frequency (or multiple frequencies separated by semicolons) on the command line.'s maximum occurreces */ + const char *omega_help; /**< @brief Specifies frequency (or multiple frequencies separated by semicolons) on the command line. help description. */ + unsigned int kfile_min; /**< @brief Path to a file containing a list of k_x, k_y pairs.'s minimum occurreces */ + unsigned int kfile_max; /**< @brief Path to a file containing a list of k_x, k_y pairs.'s maximum occurreces */ + const char *kfile_help; /**< @brief Path to a file containing a list of k_x, k_y pairs. help description. */ + unsigned int k_min; /**< @brief Specifies pair(s) of k_x, k_y values's minimum occurreces */ + unsigned int k_max; /**< @brief Specifies pair(s) of k_x, k_y values's maximum occurreces */ + const char *k_help; /**< @brief Specifies pair(s) of k_x, k_y values help description. */ + + unsigned int help_given ; /**< @brief Whether help was given. */ + unsigned int detailed_help_given ; /**< @brief Whether detailed-help was given. */ + unsigned int version_given ; /**< @brief Whether version was given. */ + unsigned int output_given ; /**< @brief Whether output was given. */ + unsigned int error_estimate_output_given ; /**< @brief Whether error-estimate-output was given. */ + unsigned int normalisation_given ; /**< @brief Whether normalisation was given. */ + unsigned int csphase_given ; /**< @brief Whether csphase was given. */ + unsigned int Ewald_parameter_given ; /**< @brief Whether Ewald-parameter was given. */ + unsigned int frequency_unit_given ; /**< @brief Whether frequency-unit was given. */ + unsigned int lMax_given ; /**< @brief Whether lMax was given. */ + unsigned int eta_given ; /**< @brief Whether eta was given. */ + unsigned int particle_given ; /**< @brief Whether particle was given. */ + unsigned int pointfile_given ; /**< @brief Whether pointfile was given. */ + unsigned int point_given ; /**< @brief Whether point was given. */ + unsigned int omegafile_given ; /**< @brief Whether omegafile was given. */ + unsigned int omega_given ; /**< @brief Whether omega was given. */ + unsigned int kfile_given ; /**< @brief Whether kfile was given. */ + unsigned int k_given ; /**< @brief Whether k was given. */ + + int k_omega_meshgrid_mode_counter; /**< @brief Counter for mode k_omega_meshgrid */ + int k_omega_points_mode_counter; /**< @brief Counter for mode k_omega_points */ +} ; + +/** @brief The additional parameters to pass to parser functions */ +struct cmdline_parser_params +{ + int override; /**< @brief whether to override possibly already present options (default 0) */ + int initialize; /**< @brief whether to initialize the option structure gengetopt_args_info (default 1) */ + int check_required; /**< @brief whether to check that all required options were provided (default 1) */ + int check_ambiguity; /**< @brief whether to check for options already specified in the option structure gengetopt_args_info (default 0) */ + int print_errors; /**< @brief whether getopt_long should print an error message for a bad option (default 1) */ +} ; + +/** @brief the purpose string of the program */ +extern const char *gengetopt_args_info_purpose; +/** @brief the usage string of the program */ +extern const char *gengetopt_args_info_usage; +/** @brief the description string of the program */ +extern const char *gengetopt_args_info_description; +/** @brief all the lines making the help output */ +extern const char *gengetopt_args_info_help[]; +/** @brief all the lines making the detailed help output (including hidden options and details) */ +extern const char *gengetopt_args_info_detailed_help[]; + +/** + * The command line parser + * @param argc the number of command line options + * @param argv the command line options + * @param args_info the structure where option information will be stored + * @return 0 if everything went fine, NON 0 if an error took place + */ +int cmdline_parser (int argc, char **argv, + struct gengetopt_args_info *args_info); + +/** + * The command line parser (version with additional parameters - deprecated) + * @param argc the number of command line options + * @param argv the command line options + * @param args_info the structure where option information will be stored + * @param override whether to override possibly already present options + * @param initialize whether to initialize the option structure my_args_info + * @param check_required whether to check that all required options were provided + * @return 0 if everything went fine, NON 0 if an error took place + * @deprecated use cmdline_parser_ext() instead + */ +int cmdline_parser2 (int argc, char **argv, + struct gengetopt_args_info *args_info, + int override, int initialize, int check_required); + +/** + * The command line parser (version with additional parameters) + * @param argc the number of command line options + * @param argv the command line options + * @param args_info the structure where option information will be stored + * @param params additional parameters for the parser + * @return 0 if everything went fine, NON 0 if an error took place + */ +int cmdline_parser_ext (int argc, char **argv, + struct gengetopt_args_info *args_info, + struct cmdline_parser_params *params); + +/** + * Save the contents of the option struct into an already open FILE stream. + * @param outfile the stream where to dump options + * @param args_info the option struct to dump + * @return 0 if everything went fine, NON 0 if an error took place + */ +int cmdline_parser_dump(FILE *outfile, + struct gengetopt_args_info *args_info); + +/** + * Save the contents of the option struct into a (text) file. + * This file can be read by the config file parser (if generated by gengetopt) + * @param filename the file where to save + * @param args_info the option struct to save + * @return 0 if everything went fine, NON 0 if an error took place + */ +int cmdline_parser_file_save(const char *filename, + struct gengetopt_args_info *args_info); + +/** + * Print the help + */ +void cmdline_parser_print_help(void); +/** + * Print the detailed help (including hidden options and details) + */ +void cmdline_parser_print_detailed_help(void); +/** + * Print the version + */ +void cmdline_parser_print_version(void); + +/** + * Initializes all the fields a cmdline_parser_params structure + * to their default values + * @param params the structure to initialize + */ +void cmdline_parser_params_init(struct cmdline_parser_params *params); + +/** + * Allocates dynamically a cmdline_parser_params structure and initializes + * all its fields to their default values + * @return the created and initialized cmdline_parser_params structure + */ +struct cmdline_parser_params *cmdline_parser_params_create(void); + +/** + * Initializes the passed gengetopt_args_info structure's fields + * (also set default values for options that have a default) + * @param args_info the structure to initialize + */ +void cmdline_parser_init (struct gengetopt_args_info *args_info); +/** + * Deallocates the string fields of the gengetopt_args_info structure + * (but does not deallocate the structure itself) + * @param args_info the structure to deallocate + */ +void cmdline_parser_free (struct gengetopt_args_info *args_info); + +/** + * Checks that all the required options were specified + * @param args_info the structure to check + * @param prog_name the name of the program that will be used to print + * possible errors + * @return + */ +int cmdline_parser_required (struct gengetopt_args_info *args_info, + const char *prog_name); + +extern const char *cmdline_parser_normalisation_values[]; /**< @brief Possible values for normalisation. */ +extern const char *cmdline_parser_csphase_values[]; /**< @brief Possible values for csphase. */ +extern const char *cmdline_parser_frequency_unit_values[]; /**< @brief Possible values for frequency-unit. */ + + +#ifdef __cplusplus +} +#endif /* __cplusplus */ +#endif /* TRANSOP_EWALD_CMDLINE_H */