get_vhartree_slice.c

Go to the documentation of this file.

/*
** get_vhartree_slice.c
** 
** Made by (Johnny Q. Hacker)
** Login   <solarion@borkborkbork>
** 
    Copyright (C) 2010 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/>.

** Started on  Wed Feb 24 17:04:30 2010 Johnny Q. Hacker
** Last update Sun May 12 01:17:25 2002 Speed Blue
*/

#include <glib-2.0/glib.h>
#include <gio/gio.h>
#include <stdio.h>
#include <stdlib.h>
#include <libdotcode/displ.h>
#include <libdotcode/read_binary_data.h>
#include <libdotcode/binary_data_common.h>
#include <libpostproc/postproc_generic.h>
#include <libpostproc/write_ascii_slice.h>
#include "get_vhartree_slice_args.h"

int main(int argc, char** argv) {
  g_type_init();
  GError *e = NULL;
  struct args *args = process_args(argc, argv, &e);
  if(e != NULL) {
    fprintf(stderr, "ERROR processing args: %s\n", e->message);
    return 2;
  }
  if(args == NULL) return 1;
  for(GList *file = args->struct_list; file != NULL; file=file->next ) {
    GFile* f = (GFile*)file->data;
    GError *e = NULL;
    enum dotcode_type t;
    void* structure = read_dotcode_generic_file(&t, f, &e);
    if(e != NULL) {
      fprintf(stderr, "ERROR: unable to find file %s: %s\n", (char*)file->data, e->message);
      g_error_free(e);
      return 3;
    }
    if(structure == NULL) {
      fprintf(stderr, "ERROR: structure from file (%s) was NULL\n", (char*)file->data);
      g_error_free(e);
      return 4;
    }
    if(t != DOTCODE_GRID) {
      fprintf(stderr, "ERROR: file (%s) was type %s, not Grid!\n", (char*)file->data, dotcode_string_from_type2(t));
      g_error_free(e);
      return 5;
    }
    struct dotcode_grid* g = (struct dotcode_grid*)structure;
    for(int i=0; i<3; i++) {
      printf("dim %d imin=%d imax=%d Ng=%d\n", i, (g->gridsites)[i]->imin, (g->gridsites)[i]->imax, g->Ng[i]);
      for(int j=0; j<((g->gridsites)[i]->imax - (g->gridsites)[i]->imin + 1); j++) {
  printf("\t%d=%g\n", j, ((double*)((g->gridsites)[i]->storage))[j]);
      }
    }

    if(g->data->t != DOTCODE_FLOAT8) {
      fprintf(stderr, "ERROR: tensor in grid is not a double (is a %d (%s))\n", g->data->t, dotcode_string_from_type(g->data->t));
      return 7;
    }
    
    int Nz =((g->data->indices)[5] - (g->data->indices)[4] + 1);
    int Ny =((g->data->indices)[3] - (g->data->indices)[2] + 1);
    int Nx =((g->data->indices)[1] - (g->data->indices)[0] + 1);
    for(int k=0; k<Nz; k++) {
      for(int j=0; j<Ny; j++) {
  for(int i=0; i<Nx; i++) {
    printf("%d/%d/%d=%g\n", i, j, k, ((double*)(g->data->data))[i + Nx*(j + Ny*k)]);
  }
      }
    }
    return 0;


    /*Now write the results out.*/
    GList *ll;
    int *adjusted_indices = (int*)malloc((g->data->Nd)*sizeof(int));
    if(adjusted_indices == NULL) {
      fprintf(stderr, "ERROR: failed to allocate memory for adjusted_indices!\n");
      return 6;
    }
    for(int i=0; i<(g->data->Nd); i++) adjusted_indices[i] = ((g->data->indices)[2*i+1] - (g->data->indices)[2*i]);
    GFile *base = g_file_new_for_path(".");

    for(ll = args->xslices; ll != NULL; ll=ll->next) {
      GError *err = postproc_write_ascii_slice(g->data->Nd, adjusted_indices, dotcode_type_to_postproc_type(g->data->t), g->data->data, POSTPROC_X, *(int*)(ll->data), base);
      if(err != NULL) {
  fprintf(stderr, "ERROR writing X slice at %d: %s\n", *(int*)(ll->data), err->message);
  g_error_free(err);
      }
    }
    for(ll = args->yslices; ll != NULL; ll=ll->next) {
      GError *err = postproc_write_ascii_slice(g->data->Nd, adjusted_indices, dotcode_type_to_postproc_type(g->data->t), g->data->data, POSTPROC_Y, *(int*)(ll->data), base);
      if(err != NULL) {
  fprintf(stderr, "ERROR writing Y slice at %d: %s\n", *(int*)(ll->data), err->message);
  g_error_free(err);
      }
    }
    for(ll = args->zslices; ll != NULL; ll=ll->next) {
      GError *err = postproc_write_ascii_slice(g->data->Nd, adjusted_indices, dotcode_type_to_postproc_type(g->data->t), g->data->data, POSTPROC_Z, *(int*)(ll->data), base);
      if(err != NULL) {
  fprintf(stderr, "ERROR writing Z slice at %d: %s\n", *(int*)(ll->data), err->message);
  g_error_free(err);
      }
    }
    GError *err = NULL;
    dotcode_free_type(t, structure, 1, &err, TRUE);
    if(err != NULL) {
      fprintf(stderr, "Error freeing structure from file (%s) after use: %s\n", (char*)(file->data), e->message);
      return 7;
    }
  }
  return 0;
}