grid.h++

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

*/

#ifndef GRID_HXX__
#define GRID_HXX__

#include <glib.h>
#include <libmodelxx/shapes.h++>
#include <libmodelxx/material.h++>
#include <libmodelxx/key_values.h++>
#include <libmodelxx/cartesian_grid.h++>
#include <libmodelxx/function_specification.h++>

#define GERROR_DOMAIN_LIBMODELXX_GRID 56932

namespace kdotp {
  namespace libmodelxx {
    namespace grid {

      enum grid_type {
  CARTESIAN
      };
      
      struct grid {
  enum grid_type t;
  /*GList containing pointers to GLists of floats (i.e. is a set of vectors
   *Is used to map out the extent of the grid to be used*/
  /*Pointer to a list of pointers to ints; size of box in gridsites*/
  GList *box_size;
  /*Pointer to a list of doubles; size of a gridsite in nm*/
  GList *site_length;
  int dimensions;
  /*Storage for raw key/value information from the input file*/
  GList *key_values;
      };

      struct point {
  /*Grid used to deal with this point*/
  struct grid *g;
  /*Array used to store the point data*/
  double *x;
      };

      /**
       *Sets up a grid that has been read in from a file
       *\param g grid structure from the input file
       *\return int error code:
       * 0: success
       */

      /**
       *Creates the grid on which we're going to hang the semiconductor.
       *\arg g pointer to the raw grid structure from the structspec
       *\arg err pointer to a GError containing the error.
       *\return pointer to the new grid class
       *\note the default material is NULL; this will help us find
       *        any unassigned places.
       *\note Error values;
       *        NULL if successful
       *        1 if there were too many/few dimensions specified
       *        2 if the grid type is unsupported.
       */
      template<typename T, unsigned Nc=1>
      void* set_up_grid(struct grid* g, T defvalue, GError **err) {
  switch(g->t) {
  case CARTESIAN:
    switch(g->dimensions){
    case 1:
      return new cartesian_grid<T, 1, Nc>(g->box_size, g->site_length, defvalue);
      break;
    case 2:
      return new cartesian_grid<T, 2, Nc>(g->box_size, g->site_length, defvalue);
      break;
    case 3:
      return new cartesian_grid<T, 3, Nc>(g->box_size, g->site_length, defvalue);
      break;
    default:
      *err = g_error_new(GERROR_DOMAIN_LIBMODELXX_GRID, 1, "kdotp::libmodelxx::continuous_structure::set_up_grid: ERROR setting up cartesian grid: bad number of dimensions (%d); must be in range (1, 3).", g->dimensions);
      return NULL;
    }
    break;
  default:
    *err = g_error_new(GERROR_DOMAIN_LIBMODELXX_GRID, 2, "kdotp::libmodelxx::continuous_structure::set_up_grid: ERROR no such grid (numeric equivalent is %d)\n\tThis is almost certainly a programming error and/or an input error (shouldn't have let the bad input through)", g->t);
  }
  return NULL;
      }

      template<typename T, unsigned Nc=1>
      GError* free_grid_class(enum grid_type t, int dims, void* grid_class) {
  switch(t) {
  case CARTESIAN:
    switch(dims){
    case 1:
      delete (cartesian_grid<T, 1, Nc>*)grid_class;
      return NULL;
    case 2:
      delete (cartesian_grid<T, 2, Nc>*)grid_class;
      return NULL;
    case 3:
      delete (cartesian_grid<T, 3, Nc>*)grid_class;
      return NULL;
    default:
      return g_error_new(GERROR_DOMAIN_LIBMODELXX_GRID, 1, "kdotp::libmodelxx::continuous_structure::free_grid: ERROR freeing cartesian grid: bad number of dimensions (%d); must be in range (1, 3).", dims);
    }
    break;
  default:
    return g_error_new(GERROR_DOMAIN_LIBMODELXX_GRID, 2, "kdotp::libmodelxx::continuous_structure::free_grid: ERROR no such grid (numeric equivalent is %d)\n\tThis is almost certainly a programming error and/or an input error (shouldn't have let the bad input through)", t);
  }
  return NULL;
      }



      /**
       ** Generic set_region
       *\param s shape_tree
       *\param m material
       *\return 0 if success
       */
      template<typename T, unsigned Nc=1>
      GError* set_value_in_grid(enum grid_type t, int dims, void* grid_class, const struct shape_tree* st, T value, GHashTable* global_symbol_table) {
  int err = 0;
  switch(t){
  case CARTESIAN:
    switch(dims){
    case 1:
      if((err=static_cast<cartesian_grid<T, 1, Nc>*>(grid_class)->set_points(st, &value, global_symbol_table)) != 0) {
        return g_error_new(GERROR_DOMAIN_LIBMODELXX_GRID, 10+err, "kdotp::libmodelxx::grid::set_value_in_grid: failed to execute set_points in 1D cartesian grid; err %d", err);
      }
      return NULL;
    case 2:
      if((err=static_cast<cartesian_grid<T, 2, Nc>*>(grid_class)->set_points(st, &value, global_symbol_table)) != 0) {
        return g_error_new(GERROR_DOMAIN_LIBMODELXX_GRID, 10+err, "kdotp::libmodelxx::grid::set_value_in_grid: failed to execute set_points in 2D cartesian grid; err %d", err);
      }
      return NULL;
    case 3:
      if((err=static_cast<cartesian_grid<T, 3, Nc>*>(grid_class)->set_points(st, &value, global_symbol_table)) != 0) {
        return g_error_new(GERROR_DOMAIN_LIBMODELXX_GRID, 10+err, "kdotp::libmodelxx::grid::set_value_in_grid: failed to execute set_points in 3D cartesian grid; err %d", err);
      }
      return NULL;
    default:
      return g_error_new(GERROR_DOMAIN_LIBMODELXX_GRID, 1, "kdotp::libmodelxx::grid::set_value_in_grid: ERROR setting up cartesian grid: bad number of dimensions (%d); must be in range (1, 3).\n", dims);
    }
    break;
  default:
    return g_error_new(GERROR_DOMAIN_LIBMODELXX_GRID, 2, "kdotp::libmodelxx::grid::set_value_in_grid: ERROR no such grid (numeric equivalent is %d)\n\tThis is almost certainly a programming error and/or an input error (shouldn't have let the bad input through)\n", t);
  }
  return NULL;
      }

      /**
       **set_region from an expression and a conversion from a double
       *\param s shape_tree
       *\param m material
       *\return 0 if success
       */
      template<typename T, unsigned Nc=1>
      GError* set_value_in_grid(enum grid_type t, int dims, void* grid_class, const struct shape_tree* st, struct ::kdotp::libmodelxx::postprocessing::function_exp *exp, GHashTable* global_symbol_table, GError*(*set_location_from_double)(T*, double*, int, void*), void* privdat) {
  GError *err=NULL, *e=NULL;
  switch(t){
  case CARTESIAN:
    switch(dims){
    case 1:
      if((err=static_cast<cartesian_grid<T, 1, Nc>*>(grid_class)->set_points(st, exp, global_symbol_table, set_location_from_double, privdat)) != NULL) {
        g_propagate_prefixed_error(&e, err, "kdotp::libmodelxx::grid::set_value_in_grid(expression): failed to execute set_points in 1D cartesian grid: ");
        return err;
      }
      return NULL;
    case 2:
      if((err=static_cast<cartesian_grid<T, 2, Nc>*>(grid_class)->set_points(st, exp, global_symbol_table, set_location_from_double, privdat)) != NULL) {
        g_propagate_prefixed_error(&e, err, "kdotp::libmodelxx::grid::set_value_in_grid(expression): failed to execute set_points in 2D cartesian grid: ");
        return err;
      }
      return NULL;
    case 3:
      if((err=static_cast<cartesian_grid<T, 3, Nc>*>(grid_class)->set_points(st, exp, global_symbol_table, set_location_from_double, privdat)) != NULL) {
        g_propagate_prefixed_error(&e, err, "kdotp::libmodelxx::grid::set_value_in_grid(expression): failed to execute set_points in 3D cartesian grid: ");
        return err;
      }
      return NULL;
    default:
      return g_error_new(GERROR_DOMAIN_LIBMODELXX_GRID, 1, "kdotp::libmodelxx::grid::set_value_in_grid(expression): ERROR setting up cartesian grid: bad number of dimensions (%d); must be in range (1, 3).\n", dims);
    }
    break;
  default:
    return g_error_new(GERROR_DOMAIN_LIBMODELXX_GRID, 2, "kdotp::libmodelxx::grid::set_value_in_grid(expression): ERROR no such grid (numeric equivalent is %d)\n\tThis is almost certainly a programming error and/or an input error (shouldn't have let the bad input through)\n", t);
  }
  return NULL;
      }


      template<typename T, unsigned Nc=1>
      GError* dump_grid(GOutputStream* gos, enum grid_type t, int dims, void* grid_class, char* (*t_to_str)(T*)) {
  GError *err=NULL, *e=NULL;
      switch(t){
  case CARTESIAN:
    switch(dims){
    case 1:
      if((err=static_cast<cartesian_grid<T, 1, Nc>*>(grid_class)->dump(gos, t_to_str))) {
        g_propagate_prefixed_error(&e, err, "kdotp::libmodelxx::grid::dump_grid(expression): failed to dump 1D cartesian grid: ");
        return err;
      }
      return NULL;
    case 2:
      if((err=static_cast<cartesian_grid<T, 2, Nc>*>(grid_class)->dump(gos, t_to_str))) {
        g_propagate_prefixed_error(&e, err, "kdotp::libmodelxx::grid::dump_grid(expression): failed to dump 2D cartesian grid: ");
        return err;
      }
      return NULL;
    case 3:
      if((err=static_cast<cartesian_grid<T, 3, Nc>*>(grid_class)->dump(gos, t_to_str))) {
        g_propagate_prefixed_error(&e, err, "kdotp::libmodelxx::grid::dump_grid(expression): failed to dump 3D cartesian grid: ");
        return err;
      }
      return NULL;
    default:
      return g_error_new(GERROR_DOMAIN_LIBMODELXX_GRID, 1, "kdotp::libmodelxx::grid::dump_grid(expression): ERROR setting up cartesian grid: bad number of dimensions (%d); must be in range (1, 3).\n", dims);
    }
    break;
  default:
    return g_error_new(GERROR_DOMAIN_LIBMODELXX_GRID, 2, "kdotp::libmodelxx::grid::dump_grid(expression): ERROR no such grid (numeric equivalent is %d)\n\tThis is almost certainly a programming error and/or an input error (shouldn't have let the bad input through)\n", t);
  }
  return NULL;
      }

      template<typename T, unsigned Nc=1>
      GError* dump_indexed_grid(GOutputStream* gos, enum grid_type t, int dims, void* grid_class, bool is_same(T*, T*), char* (*t_to_str)(T*)) {
  GError *err=NULL, *e=NULL;
  switch(t){
  case CARTESIAN:
    switch(dims){
    case 1:
      if((err=static_cast<cartesian_grid<T, 1, Nc>*>(grid_class)->dump_indexed(gos, is_same, t_to_str))) {
        g_propagate_prefixed_error(&e, err, "kdotp::libmodelxx::grid::dump_indexed_grid(expression): failed to dump indexed 1D cartesian grid: ");
        return err;
      }
      return NULL;
    case 2:
      if((err=static_cast<cartesian_grid<T, 2, Nc>*>(grid_class)->dump_indexed(gos, is_same, t_to_str))) {
        g_propagate_prefixed_error(&e, err, "kdotp::libmodelxx::grid::dump_indexed_grid(expression): failed to dump indexed 2D cartesian grid: ");
        return err;
      }
      return NULL;
    case 3:
      if((err=static_cast<cartesian_grid<T, 3, Nc>*>(grid_class)->dump_indexed(gos, is_same, t_to_str))) {
        g_propagate_prefixed_error(&e, err, "kdotp::libmodelxx::grid::dump_indexed_grid(expression): failed to dump indexed 3D cartesian grid: ");
        return err;
      }
      return NULL;
    default:
      return g_error_new(GERROR_DOMAIN_LIBMODELXX_GRID, 1, "kdotp::libmodelxx::grid::dump_indexed_grid(expression): ERROR setting up cartesian grid: bad number of dimensions (%d); must be in range (1, 3).\n", dims);
    }
    break;
  default:
    return g_error_new(GERROR_DOMAIN_LIBMODELXX_GRID, 2, "kdotp::libmodelxx::grid::dump_indexed_grid(expression): ERROR no such grid (numeric equivalent is %d)\n\tThis is almost certainly a programming error and/or an input error (shouldn't have let the bad input through)\n", t);
  }
  return NULL;
      }
  

    }
  }
}


#endif