getChainPotential_args.c

Go to the documentation of this file.

/*
** getChainPotential_args.c
**
Copyright (C) 2009 Joseph Pingenot

This program is free software: you can redistribute it and/or modify
it under the terms of the GNU Affero General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU Affero General Public License for more details.

You should have received a copy of the GNU Affero General Public License
along with this program.  If not, see <http://www.gnu.org/licenses/>.

** Made by (Johnny Q. Hacker)
** Login   <solarion@nathan>
**
** Started on  Sat Nov 14 19:00:09 2009 Johnny Q. Hacker
** Last update Sun May 12 01:17:25 2002 Speed Blue
*/

#include <errno.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <gio/gio.h>
#include <glib-2.0/glib.h>
#include "config.h"
#include "getChainPotential_args.h"

#define GET_CHAIN_POTENTIAL_ARGS_DOMAIN 1024

#define DEFAULT_OUTPUT_FILENAME "potential.grid"

extern void program_print_version(FILE* f);
extern void libdotcode_print_version(FILE* f);
extern void libpostproc_print_version(FILE* f);

void print_version_info() {
  program_print_version(stdout);
  libdotcode_print_version(stdout);
  libpostproc_print_version(stdout);
  printf("autotools info:\n\tProject: %s\n\tVersion: %s\n", PACKAGE_NAME, VERSION);
  printf("Platform information:\n\tSize of int=%d double=%d\n\tEndianness: %s\n", SIZEOF_INT, SIZEOF_DOUBLE,
#ifdef WORDS_BIGENDIAN
   "big"
#else
   "little"
#endif
   );
}

struct args args = {
  .wf_list = NULL,
  .center_wf_list = NULL,
  /*0->x 1->y 2->z*/
  .N_neighbors = {0, 0, 0},
  .xslices = NULL,
  .yslices = NULL,
  .zslices = NULL,
  .sweep_x = FALSE,
  .sweep_y = FALSE,
  .sweep_z = FALSE,
  .pixel_strategy = 0,
  .outfile = NULL,
  .invert_odd = 0,
  .expand_density_boxes = NULL,
  .save_ascii_values = FALSE,
  .sepchar = '\t',
  .povray= FALSE,
  .use_inhomogeneous_dielectric = FALSE,
  .extra_neighbor = {0, 0, 0},
  .neighbor_offset = {0, 0, 0},
  .save_inhomog_iterations = FALSE
};

void yyparse();
int yylex();

extern const char* version_info;

double* new_double_from_string(const char* s, GError **err) {
  double* d = (double*)malloc(sizeof(double));
  if(d == NULL) {
    *err = g_error_new(GET_CHAIN_POTENTIAL_ARGS_DOMAIN, 1, "getChainPotential_args.c::new_double_from_string: Error occurred converting string (%s) to double: out of memory/malloc failed", s);
    return NULL;
  }
  char *end;
  errno = 0;
  *d = strtod(s, &end);
  if(((end == s) && (*d == 0)) || (errno != 0)) {
    *err = g_error_new(GET_CHAIN_POTENTIAL_ARGS_DOMAIN, 2, "getChainPotential_args.c::new_double_from_string: Error occurred converting string (%s) to double: %s", s, strerror(errno));
    free(d);
    return NULL;
  }
  return d;
}

int* new_int_from_string(const char* s, GError **err) {
  int* d = (int*)malloc(sizeof(int));
  if(d == NULL) {
    *err = g_error_new(GET_CHAIN_POTENTIAL_ARGS_DOMAIN, 1, "getChainPotential_args.c::new_int_from_string: Error occurred converting string (%s) to int: out of memory/malloc failed", s);
    return NULL;
  }
  char *end;
  errno = 0;
  *d = strtod(s, &end);
  if(((end == s) && (*d == 0)) || (errno != 0)) {
    *err = g_error_new(GET_CHAIN_POTENTIAL_ARGS_DOMAIN, 2, "getChainPotential_args.c::new_int_from_string: Error occurred converting string (%s) to int: %s", s, strerror(errno));
    free(d);
    return NULL;
  }
  return d;
}

struct args* process_args(int argc, char **argv, GError **err) {
  fprintf(stderr, "Will I segfault too? %d %s\n", argc, argv[0]);
  gchar **file_names = NULL;
  gboolean print_version = FALSE;
  gchar** xslices = NULL;
  gchar** yslices = NULL;
  gchar** zslices = NULL;
  gboolean sweeps_exp_percent = FALSE;
  gboolean sweeps_log_percent = FALSE;
  char* invert_odd_coords = NULL;
  char* outfile = NULL;
  gboolean save_ascii_comma = FALSE;
  /*Static so that it doesn't disappear when we leave scope! This is the
   *array that will be used in the arg struct if expand_box[0] is non-zero.
   *The two negative numbers are flags for future code to let us know that
   *the other two numbers haven't been modified.
   */
  static int expand_box[3] = {-1, -1, -1};
  gchar* offsets=NULL;
  gchar* s_expand_box = NULL;
  GOptionEntry options[] = {
    { G_OPTION_REMAINING, '\0', 0, G_OPTION_ARG_FILENAME_ARRAY, &file_names,},
    { "version", 'v', G_OPTION_FLAG_OPTIONAL_ARG, G_OPTION_ARG_NONE, &print_version, "Print version information about this program", NULL },
    { "ascii-dump", 'a', G_OPTION_FLAG_OPTIONAL_ARG, G_OPTION_ARG_NONE, &(args.save_ascii_values), "Dump the entire array to a tab-separated file", NULL },
    { "povray", 'p', G_OPTION_FLAG_OPTIONAL_ARG, G_OPTION_ARG_NONE, &(args.povray), "Dump the entire array to a povray-rendered scene", NULL },
    { "ascii-dump-comma", 'c', G_OPTION_FLAG_OPTIONAL_ARG, G_OPTION_ARG_NONE, &(save_ascii_comma), "When dumping the entire array to a file, use commas instead of tabs to separate values.", NULL },
    { "expand-box", 'E', G_OPTION_FLAG_OPTIONAL_ARG, G_OPTION_ARG_FILENAME, &(s_expand_box), "Before calculating the potential, extend the box out in all directionsby this many grid sites.", NULL },
    { "invert-odd", 'i', G_OPTION_FLAG_OPTIONAL_ARG, G_OPTION_ARG_FILENAME, &invert_odd_coords, "3 characters representing the coordinates to invert on every odd site (one of each coordinate, in any order, no separators; used to make a chain of up-down-up-down-up potentials).", NULL },
    { "outfile", 'o', G_OPTION_FLAG_OPTIONAL_ARG, G_OPTION_ARG_FILENAME, &outfile, "File into which to put the resulting potential.", NULL},
    { "xneighbors", 'x', G_OPTION_FLAG_OPTIONAL_ARG, G_OPTION_ARG_INT, &(args.N_neighbors[0]), "Number of nearest neighbors along x", NULL},
    { "yneighbors", 'y', G_OPTION_FLAG_OPTIONAL_ARG, G_OPTION_ARG_INT, &(args.N_neighbors[1]), "Number of nearest neighbors along y", NULL},
    { "zneighbors", 'z', G_OPTION_FLAG_OPTIONAL_ARG, G_OPTION_ARG_INT, &(args.N_neighbors[2]), "Number of nearest neighbors along z", NULL},
    { "offset-distance", 'd', G_OPTION_FLAG_OPTIONAL_ARG, G_OPTION_ARG_STRING, &offsets, "Offset between neighbors in each direction, in gridsites. Is specified as x,y,z, e.g. 5,10,15 will have each each item in the chain setparted by x distance of 5, y of 10, and z of 15 gridsites.", NULL},
    { "xslice", 'X', G_OPTION_FLAG_OPTIONAL_ARG, G_OPTION_ARG_STRING_ARRAY, &(xslices), "x coordinate (in grid sites) along which to output a 2D slice of the total density and the resulting potential", NULL},
    { "yslice", 'Y', G_OPTION_FLAG_OPTIONAL_ARG, G_OPTION_ARG_STRING_ARRAY, &(yslices), "y coordinate (in grid sites) along which to output a 2D slice of the total density and the resulting potential", NULL},
    { "zslice", 'Z', G_OPTION_FLAG_OPTIONAL_ARG, G_OPTION_ARG_STRING_ARRAY, &(zslices), "z coordinate (in grid sites) along which to output a 2D slice of the total density and the resulting potential", NULL},
    { "sweepx", 0, G_OPTION_FLAG_OPTIONAL_ARG, G_OPTION_ARG_NONE, &args.sweep_x, "Output a sequence of PBMs to the sweep_x subdirectory showing a sweep along the x axis across the entire structure", NULL },
    { "sweepy", 0, G_OPTION_FLAG_OPTIONAL_ARG, G_OPTION_ARG_NONE, &args.sweep_y, "Output a sequence of PBMs to the sweep_y subdirectory showing a sweep along the y axis across the entire structure", NULL },
    { "sweepz", 0, G_OPTION_FLAG_OPTIONAL_ARG, G_OPTION_ARG_NONE, &args.sweep_z, "Output a sequence of PBMs to the sweep_z subdirectory showing a sweep along the z axis across the entire structure", NULL },
    { "sweep_exp", 'e', G_OPTION_FLAG_OPTIONAL_ARG, G_OPTION_ARG_NONE, &sweeps_exp_percent, "Set pixel values in the sweep images to the \"normalized exp\" of the percentage of the maximum value, instead of just the percentage =pixel_max_value*(1.0-exp(percent))/(1.0-e).", NULL},
    { "sweep_log", 'l', G_OPTION_FLAG_OPTIONAL_ARG, G_OPTION_ARG_NONE, &sweeps_log_percent, "Set pixel values in the sweep images to the \"normalized log\" of the percentage of the maximum value, instead of just the percentage =pixel_max_value*log(percent+1)/log(2).", NULL},
    { "inhomogeneous", 'H', G_OPTION_FLAG_OPTIONAL_ARG, G_OPTION_ARG_NONE, &args.use_inhomogeneous_dielectric, "Dielectric is inhomogeneous; use recursive multigrid calculation to find the potential (otherwise, will only divide rho by epsilon at each point)", NULL },
    { "save_inhomog_iterations", 's', G_OPTION_FLAG_OPTIONAL_ARG, G_OPTION_ARG_NONE, &args.save_inhomog_iterations, "Save a sweep along z of the potential and del_phi term at each iteration of the inhomogeneous solver and a dump.", NULL},
    {NULL}
  };
  GOptionContext *ctx;
  ctx = g_option_context_new("- create a dotcode potential for the specified grid of nearest neighbors");
  g_option_context_add_main_entries(ctx, options, "Options");

  g_option_context_parse(ctx, &argc, &argv, NULL);

  if(save_ascii_comma) args.sepchar = ',';

  /*Add an extra neighbor to each non-zero direction.*/
  for(int i=0; i<3; i++) if(args.N_neighbors[i]) args.extra_neighbor[i]=1;

  if(offsets != NULL) {
    gchar** specs=g_strsplit(offsets, ",", 3);
    for(int i=0; i<3; i++) {
      if(specs[i] == NULL) {
  *err = g_error_new(GET_CHAIN_POTENTIAL_ARGS_DOMAIN, 75, "getChainPotential_args.c: too few numbers in the neighbor offset list (got %d; should be exactly 3)\n", i);
  return NULL;
      }
      GError *e = NULL;
      int* val = new_int_from_string(specs[i], &e);
      if((val == NULL) || (e != NULL)) {
  if(e != NULL) {
    g_propagate_prefixed_error(err, e, "getChainPotential_args.c: Unable to convert specified offset (%s) (whole list was (%s)) or unable to allcoate an int!\n", specs[i], offsets);
  }else{
    *err = g_error_new(GET_CHAIN_POTENTIAL_ARGS_DOMAIN, 76, "getChainPotential_args.c: Unable to convert specified offset (%s) (whole list was (%s)) or unable to allcoate an int!\n", specs[i], offsets);
  }
  return NULL;
      }
      args.neighbor_offset[i] = *val;
      free(val);
    }
    g_strfreev(specs);
  }

  if(invert_odd_coords != NULL) {
    for(int i=0; i<3; i++) {
      if(invert_odd_coords[i] == '\0') break;
      switch(invert_odd_coords[i]){
      case 'X':
      case 'x':
  args.invert_odd |= 1;
      break;
      case 'Y':
      case 'y':
  args.invert_odd |= 2;
      break;
      case 'Z':
      case 'z':
  args.invert_odd |= 4;
      break;
      default:
  *err = g_error_new(GET_CHAIN_POTENTIAL_ARGS_DOMAIN, 15, "getChainPotential_args.c: character %c in invert-odd coordinate string (%s) is not x, y, or z!", invert_odd_coords[i], invert_odd_coords);
  return NULL;
      }
    }
  }

  args.xslices = NULL;
  int *d;
  GError *e = NULL;
  if(xslices != NULL) {
    for(int i=0; xslices[i] != NULL; i++) {
      if((d=new_int_from_string(xslices[i], &e)) != NULL) {
  args.xslices = g_list_append(args.xslices, d);
      }else{
  *err = e;
  return NULL;
      }
    }
  }
  args.yslices = NULL;
  e = NULL;
  if(yslices != NULL) {
    for(int i=0; yslices[i] != NULL; i++) {
      if((d=new_int_from_string(yslices[i], &e)) != NULL) {
  args.yslices = g_list_append(args.yslices, d);
      }else{
  *err = e;
  return NULL;
      }
    }
  }
  args.zslices = NULL;
  e = NULL;
  if(zslices != NULL) {
    for(int i=0; zslices[i] != NULL; i++) {
      if((d=new_int_from_string(zslices[i], &e)) != NULL) {
  args.zslices = g_list_append(args.zslices, d);
      }else{
  *err = e;
  return NULL;
      }
    }
  }
  if(sweeps_log_percent) {
    if(sweeps_exp_percent) {
      *err = g_error_new(GET_CHAIN_POTENTIAL_ARGS_DOMAIN, 24, "getChainPotential_args.c: you may give EITHER the normalized log OR exp strategy, not both!\n");
      return NULL;
    }else{
      args.pixel_strategy=1;
    }
  }else if(sweeps_exp_percent) {
    args.pixel_strategy=2;
  }

  if(s_expand_box != NULL) {
    fprintf(stderr, "Got s_expand_box=%s\n", s_expand_box);
    gchar** sb = g_strsplit(s_expand_box, ",", 0);
    int i;
    for(i=0; sb[i] != NULL; i++) {
      if(i>2) break;
      expand_box[i] = atoi(sb[i]);
      fprintf(stderr, "sb[%d]=%s->%d\n", i, sb[i], expand_box[i]);
    }
    g_strfreev(sb);
    if(i>3) {
      *err = g_error_new(GET_CHAIN_POTENTIAL_ARGS_DOMAIN, 24, "getChainPotential_args.c: ERROR: got more than 3 values for the expansion box (%s)\n", s_expand_box);
      return NULL;
    }
    /*Once the input has been processed, we check the values*/
    if((expand_box[0] == 0) && (expand_box[1] == 0) && (expand_box[2] == 0)) {
      /*Scenario three: all set to zero. Do nothing.*/
    } else if((expand_box[0] == 0) && (expand_box[1] == -1) && (expand_box[2] == -1)) {
      /*Scenario four: all set to zero by setting only the first. Do nothing.*/
    } else if((expand_box[0] >= 0) && (expand_box[1] == -1) && (expand_box[2] == -1)) {
      /*scenario one: just one coordinate set; expand in all directions.*/
      expand_box[1] = expand_box[0];
      expand_box[2] = expand_box[0];
      args.expand_density_boxes = expand_box;
    } else if((expand_box[0] >= 0) && (expand_box[1] >= 0) && (expand_box[2] >= 0)) {
      /*scenario two: User set all 3 values, so we need to save it to the struct*/
      args.expand_density_boxes = expand_box;
    } else {
      /*One or more invalid numbers.*/
      *err = g_error_new(GET_CHAIN_POTENTIAL_ARGS_DOMAIN, 14, "getChainPotential_args.c: ERROR: a specified calculation box expansion size was negative! (%d,%d,%d)", expand_box[0], expand_box[1], expand_box[2]);
      return NULL;
    }
    fprintf(stderr, "expand_box=%d,%d,%d expand_density_boxes=%p\n", expand_box[0], expand_box[1], expand_box[2], (void*)args.expand_density_boxes);
  }

  //gchar* htext = g_option_context_get_help(ctx, FALSE, NULL);
  g_option_context_free(ctx);

  args.wf_list = NULL;
  struct wavefunction *wf =NULL;
  gboolean center;
  if(file_names != NULL) {
    for(int i = 0; file_names[i] != NULL; i++) {
      if((wf = (struct wavefunction*)malloc(sizeof(struct wavefunction))) == NULL) {
  *err = g_error_new(GET_CHAIN_POTENTIAL_ARGS_DOMAIN, 3, "getChainPotential_args.c::new_double_from_string: Failed to allocate a struct wavefunction! Get more memory perhaps? (malloc returned NULL)");
  return NULL;
      }
      if(file_names[i][0] == '-') {
  wf->charge = -1.0;
      }else if(file_names[i][0] == '+') {
  wf->charge = 1.0;
      }else{
  *err = g_error_new(GET_CHAIN_POTENTIAL_ARGS_DOMAIN, 3, "getChainPotential_args.c::new_double_from_string: first character of the wavefunction argument was not a plus (+) or minus (-); we got \"%c\"; specification of \"%s\"! What is the sign of the charge here?", file_names[i][0], file_names[i]);
  free(wf);
  return NULL;
      }
      if(file_names[i][1] == '/') {
  center = FALSE;
      }else if(file_names[i][1] == '@') {
  center = TRUE;
      }else{
  *err = g_error_new(GET_CHAIN_POTENTIAL_ARGS_DOMAIN, 3, "getChainPotential_args.c::new_double_from_string: second character of the wavefunction argument was not a slash (/); we got \"%c\"; specification of \"%s\"! What is the sign of the charge here?", file_names[i][1], file_names[i]);
  free(wf);
  return NULL;
      }
      wf->storage =NULL;
      wf->file = g_file_new_for_commandline_arg(&file_names[i][2]);
      if(center) {
  fprintf(stderr, "center: %s\n", file_names[i]);
  args.center_wf_list = g_list_append(args.center_wf_list, wf);
      }else{
  fprintf(stderr, "not center: %s\n", file_names[i]);
  args.wf_list = g_list_append(args.wf_list, wf);
      }
    }
  }

  if(print_version){
    print_version_info();
    *err = g_error_new(GET_CHAIN_POTENTIAL_ARGS_DOMAIN, 7, "\n");
    return NULL;
  }

  if((args.wf_list == NULL) && (args.center_wf_list == NULL)) {
    *err = g_error_new(GET_CHAIN_POTENTIAL_ARGS_DOMAIN, 3, "getChainPotential_args.c::you MUST give at least one wave function to process!\n");
    return NULL;
  }

  if(outfile == NULL) {
    args.outfile = g_file_new_for_path(DEFAULT_OUTPUT_FILENAME);
  }else{
    args.outfile = g_file_new_for_commandline_arg(outfile);
  }

  return &args;
}