generic_structure.c++

Go to the documentation of this file.

/*

    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/>.

*/

#include <stdlib.h>
#include <glib.h>
#include <hdf5.h>
#include <libmodelxx/grid.h++>
#include <libmodelxx/material.h++>
#include <libmodelxx/generic_structure.h++>

namespace kdotp {
  namespace libmodelxx {
    namespace structure {

      #define GERROR_DOMAIN_GENERIC_STRUCTURE 51

      static bool material_is_same(material** a, material** b) {
  return **a == **b;
      }
      
      char* material_to_string(libmodelxx::structure::material** value) {
  return (*value)->get_name();
      }

      char* double_to_string(double* value) {
  GString *s = g_string_new_len("", 1024);
  g_string_printf(s, "%g", *value);
  char* str = s->str;
  g_string_free(s, FALSE);
  return str;
      }

      GError* generic_structure_save(struct generic_structure *s, const char* filename) {
  /*
  hid_t file_id = H5Fcreate(filename, H5F_ACC_TRUNC, H5P_DEFAULT, H5P_DEFAULT);
  herr_t status;
  hsize_t one = 1;
  */
  /*Create a one-item space*/
  /*
  hid_t dspace_id_single = H5Create_simple(1, &one, NULL);
  hid_t dset_id_size;
  */
  return g_error_new(GERROR_DOMAIN_GENERIC_STRUCTURE, 0, "kdotp::libmodelxx::structure::generic_structure::generic_structure_save: this function is unimplemented.");
      }

      GError* generic_structure_restore(struct generic_structure **s, const char* filename) {
  return g_error_new(GERROR_DOMAIN_GENERIC_STRUCTURE, 0, "kdotp::libmodelxx::structure::generic_structure::generic_structure_restore: this function is unimplemented.");
      }

      GError* generic_structure_dump(struct generic_structure *s, GFile* file) {
  GError *e = NULL;
  GFileOutputStream* gfos = g_file_replace(file, NULL, FALSE, G_FILE_CREATE_NONE, NULL, &e);
  if(e != NULL) {
    GError *err = NULL;
    g_propagate_prefixed_error(&err, e, "kdotp::libmodelxx::structure::generic_structure.c++::generic_structure_dump: failed to open file.");
    return err;
  }

  e = grid::dump_indexed_grid<libmodelxx::structure::material*>((GOutputStream*)gfos, s->g->t, s->g->dimensions, s->material_grid, material_is_same, material_to_string);
  if(e != NULL) {
    GError *err = NULL;
    g_propagate_prefixed_error(&err, e, "kdotp::libmodelxx::structure::generic_structure.c++::generic_structure_dump: failed to dump indexed material grid to file");
    return err;
  }

  e = grid::dump_grid<double>((GOutputStream*)gfos, s->g->t, s->g->dimensions, s->potential_grid, double_to_string);
  if(e != NULL) {
    GError *err = NULL;
    g_propagate_prefixed_error(&err, e, "kdotp::libmodelxx::structure::generic_structure.c++::generic_structure_dump: failed to dump potential grid to file");
    return err;
  }

  e = grid::dump_grid<double>((GOutputStream*)gfos, s->g->t, s->g->dimensions, s->doping_grid, double_to_string);
  if(e != NULL) {
    GError *err = NULL;
    g_propagate_prefixed_error(&err, e, "kdotp::libmodelxx::structure::generic_structure.c++::generic_structure_dump: failed to dump doping grid to file");
    return err;
  }

  /*
  e = grid::dump_grid<double, 6>((GOutputStream*)gfos, s->g->t, s->g->dimensions, s->strain_grid, double_to_string);
  if(e != NULL) {
    GError *err = NULL;
    g_propagate_prefixed_error(&err, e, "kdotp::libmodelxx::structure::generic_structure.c++::generic_structure_dump: failed to dump strain grid to file");
    return err;
  }
  */

  g_object_unref(gfos);
  return NULL;
      }

      struct generic_structure* generic_structure_new(struct grid::grid *g) {
  struct generic_structure *s = (struct generic_structure*)malloc(sizeof(struct generic_structure));
  if(s == NULL) return NULL;
  s->g = g;
  GError *e = NULL;
  //s->material_grid = grid::set_up_grid<libmodelxx::structure::material>(g, NULL, &e);
  s->material_grid = grid::set_up_grid<libmodelxx::structure::material*>(g, NULL, &e);
  if(e != NULL) {
    GError *err = NULL;
    g_propagate_prefixed_error(&err, e, "kdotp::libmodelxx::structure::generic_structure.c++::generic_structure_new: failed to create new material grid");
    //return err;
  }
  s->potential_grid = grid::set_up_grid<double>(g, 0, &e);
  if(e != NULL) {
    GError *err = NULL;
    g_propagate_prefixed_error(&err, e, "kdotp::libmodelxx::structure::generic_structure.c++::generic_structure_new: failed to create new potential grid");
    //return err;
  }
  s->doping_grid = grid::set_up_grid<double>(g, 0, &e);
  if(e != NULL) {
    GError *err = NULL;
    g_propagate_prefixed_error(&err, e, "kdotp::libmodelxx::structure::generic_structure.c++::generic_structure_new: failed to create new doping grid");
    //return err;
  }
  /*
  s->strain_grid = grid::set_up_grid<double, 6>(g, 0, &e);
  if(e != NULL) {
    GError *err = NULL;
    g_propagate_prefixed_error(&err, e, "kdotp::libmodelxx::structure::generic_structure.c++::generic_structure_new: failed to create new strain grid");
    //return err;
  }
  */
  return s;
      }

      GError* generic_structure_free(struct generic_structure* s) {
  /*TODO: hash out how to free specific arrays.*/
  GError *e=NULL;
  e=grid::free_grid_class<libmodelxx::structure::material*>(s->g->t, s->g->dimensions, s->material_grid);
  if(e != NULL) return e;
  e=grid::free_grid_class<double>(s->g->t, s->g->dimensions, s->potential_grid);
  if(e != NULL) return e;
  e=grid::free_grid_class<double>(s->g->t, s->g->dimensions, s->doping_grid);
  if(e != NULL) return e;
  /*
  e=grid::free_grid_class<double, 6>(s->g->t, s->g->dimensions, s->strain_grid);
  if(e != NULL) return e;
  */
  free(s);
  return NULL;
      }

      void generic_structure_free_potential(struct generic_structure* s) {
  grid::free_grid_class<double>(s->g->t, s->g->dimensions, s->potential_grid);
  s->potential_grid = NULL;
      }

    
    }
  }
}