continuous_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 <stdio.h>
#include <string.h>
#include <math.h>
#include <glib.h>
#include <libmodelxx/continuous_structure.h++>
#include <libmodelxx/matdb.h++>
#include <libmodelxx/material.h++>
#include <libmodelxx/generic_structure.h++>
#include <libmodelxx/function_specification.h++>

namespace kdotp {
  namespace libmodelxx {
    namespace continuous_structure {
      #define CONTINUOUS_STRUCTURE_GERROR_DOMAIN 321

      static GError* callback_convert_type(double* location, double* values, int t, void* privdat) {
  for(int i=0; i<t; i++) {
    location[i] = values[i];
  }
  if(t == 0) {
    location[0] = values[0];
    return g_error_new(CONTINUOUS_STRUCTURE_GERROR_DOMAIN, 1, "::kdotp::libmodelxx::continuous_structure.c++::callback_convert_type:: warning: function data type boolean is invalid!");
  }
  if(t < 0) {
    return g_error_new(CONTINUOUS_STRUCTURE_GERROR_DOMAIN, 2, "::kdotp::libmodelxx::continuous_structure.c++::callback_convert_type:: warning: function data type is INVALID!");
  }
  return NULL;
      }

      struct callback_get_material_privdat {
  char* mat1;
  char* mat2;
  const struct structure::matdb* mdb;
      };

      static GError* callback_get_material(structure::material** location, double* values, int t, void* privdat) {
  struct callback_get_material_privdat* p = (struct callback_get_material_privdat*)privdat;
  if(t != 1) {
    return g_error_new(CONTINUOUS_STRUCTURE_GERROR_DOMAIN, 1, "::kdotp::libmodelxx::continuous_structure.c++::callback_get_material: ERROR: I have no idea how to convert a vector to a material composed of (%s) and (%s)!", p->mat1, p->mat2);
  }
  fprintf(stderr, "Got material from function: %s(%g)%s\n", p->mat1, values[0], p->mat2);
  if((values[0] < 0) || (values[0] > 1)) return g_error_new(CONTINUOUS_STRUCTURE_GERROR_DOMAIN, 2, "::kdotp::libmodelxx::continuous_structure.c++::callback_get_material: ERROR: invalid percentage from function (material would be (%s)(%g)(%s))!", p->mat1, values[0], p->mat2);
  location[0] = new structure::material(p->mdb, p->mat1, p->mat2, values[0]);
  if(location[0] == NULL) return g_error_new(CONTINUOUS_STRUCTURE_GERROR_DOMAIN, 3, "::kdotp::libmodelxx::continuous_structure.c++::callback_get_material: ERROR: Error getting material from function: (material would be (%s)(%g)(%s))!", p->mat1, values[0], p->mat2);
  return NULL;
      }

      struct structure::generic_structure* postprocess_structure(struct continuous_structure *s, const struct structure::matdb* mdb, GHashTable* global_symbol_table, GError **gerr) {
  struct structure::generic_structure* ngs;
  if((ngs = structure::generic_structure_new(s->g)) == NULL) {
    *gerr = g_error_new(CONTINUOUS_STRUCTURE_DOMAIN, 1, "kdotp::libmodelxx::continouous_structure::postprocess_structure: failed to set up new generic structure (got NULL)");
    return NULL;
  }
  int err=0;
  GList* l;
  GError *e = NULL;
  struct region* r;
  int i=0;
  for(l=s->regions; l!=NULL; l=l->next) {
    fprintf(stderr, "region %d:", i);
    r = (struct region*)(l->data);
    if(((r->st)=postprocess_shape_tree(r->st, s->g->dimensions)) == NULL) {
      *gerr = g_error_new(CONTINUOUS_STRUCTURE_DOMAIN, 100+err, "kdotp::libmodelxx::continuous_structure::postprocess_structure failed to set up a region shape tree (error in postprocess_shape_tree (error %d))", err);
      structure::generic_structure_free(ngs);
      return NULL;
    }
    /*Set up the specified material.*/
    if(r->f == NULL) {
      (r->m) = new structure::material(mdb, r->mat1, r->mat2, r->x);
      if((r->m) == NULL) {
        *gerr = g_error_new(CONTINUOUS_STRUCTURE_DOMAIN, 2, "kdotp::libmodelxx::continuous_structure::postprocess_structure failed to set up constat material (%s(%f)%s)", r->mat1, r->x, r->mat2);
        structure::generic_structure_free(ngs);
        return NULL;
      }
      /*Set the material*/
      e = set_value_in_grid(ngs->g->t, ngs->g->dimensions, ngs->material_grid, r->st, r->m, global_symbol_table);
      if(e != NULL) {
        g_propagate_prefixed_error(gerr, e, "kdotp::libmodelxx::continuous_structure.c++::postprocess_structure: got error setting material in grid (mat1=%s mat2=%s x=%f): ", r->mat1, r->mat2, r->x);
      }
    }else{
      GString *s = g_string_new("");
      function_print_tree(r->f, &s, 0);
      fprintf(stderr, "Got r->f tree:%s\n", s->str);
      g_string_free(s, TRUE);
      struct callback_get_material_privdat pd;
      pd.mat1 = r->mat1;
      pd.mat2 = r->mat2;
      pd.mdb = mdb;
      e = set_value_in_grid(ngs->g->t, ngs->g->dimensions, ngs->material_grid, r->st, r->f, global_symbol_table, callback_get_material, &pd);
      if(e != NULL) {
        g_propagate_prefixed_error(gerr, e, "kdotp::libmodelxx::continuous_structure.c++::postprocess_structure: got error setting material in grid with function: ");
      }
    }
    fprintf(stderr, " (set material in grid)");
    i++;
    fprintf(stderr, "\n");
  }
  struct doping *d;
  for(l=s->dopings; l!=NULL; l=l->next) {
    d=(struct doping*)(l->data);
    if(((d->st)=postprocess_shape_tree(d->st, s->g->dimensions)) == NULL) {
      *gerr = g_error_new(CONTINUOUS_STRUCTURE_DOMAIN, 100+err, "kdotp::libmodelxx::continuous_structure::postprocess_structure failed to set up a doping shape tree (error in postprocess_shape_tree (error %d))", err);
      structure::generic_structure_free(ngs);
      return NULL;
    }
    GString *s = g_string_new("");
    function_print_tree(d->f, &s, 0);
    fprintf(stderr, "Got d->f tree:%s\n", s->str);
    g_string_free(s, TRUE);
    e = set_value_in_grid(ngs->g->t, ngs->g->dimensions, ngs->doping_grid, d->st, d->f, global_symbol_table, callback_convert_type, NULL);
    if(e != NULL) {
      g_propagate_prefixed_error(gerr, e, "kdotp::libmodelxx::continuous_structure.c++::postprocess_structure: got error setting doping in grid: ");
    }
  }
  struct potential *p;
  for(l=s->potential; l != NULL; l=l->next) {
    //TODO!!
  }
        return ngs;
      }

      void print_structure(const struct continuous_structure *s) {
  fprintf(stderr, "================================================================\n");
  fprintf(stderr, "Grid data:\n");
  fprintf(stderr, "Regions:\n");
      }

      enum length length_from_str(const char* str) {
  if(!strcmp(str, "nm")) return NANOMETER;
  else if(!strcmp(str, "A")) return ANGSTROM;
  else if(!strcmp(str, "um")) return MICROMETER;
  else if(!strcmp(str, "mm")) return MILLIMETER;
  else if(!strcmp(str, "cm")) return CENTIMETER;
  else if(!strcmp(str, "m")) return METER;
  return UNKNOWN_LENGTH;
      }

      const char* str_from_length(enum length l) {
  switch(l) {
  case NANOMETER:
    return "nm";
  case ANGSTROM:
    return "A";
  case MICROMETER:
    return "um";
  case MILLIMETER:
    return "mm";
  case CENTIMETER:
    return "cm";
  case METER:
    return "m";
  default:
    return "<unknown unit of length>";
  }
      }

      enum energy energy_from_str(const char* str) {
  if(!strcmp(str, "eV")) return EVOLT;
  else if(!strcmp(str, "J")) return JOULE;
  else if(!strcmp(str, "erg")) return ERG;
  else if(!strcmp(str, "Eh")) return HARTREE;
  return UNKNOWN_ENERGY;
      }

      const char* str_from_energy(enum energy e) {
  switch(e) {
  case EVOLT:
    return "eV";
  case JOULE:
    return "J";
  case ERG:
    return "erg";
  case HARTREE:
    return "Eh";
  default:
    return "<unknown unit of energy>";
  }
      }

      double convert_length_to_nm(double len, enum length unit) {
  switch(unit) {
  case NANOMETER:
    return len;
  case ANGSTROM:
    return len/10.0;
  case MICROMETER:
    return len*1.0e3;
  case MILLIMETER:
    return len*1.0e6;
  case CENTIMETER:
    return len*1.0e7;
  case METER:
    return len*1.0e9;
  default:
    fprintf(stderr, "kdotp::libmodelxx::continuous_structure::convert_length_to_nm: ERROR while converting units: unknown unit of length (%s)\n", str_from_length(unit));
    return nan("NaN");
  }
      }

      /*From NIST*/
      double convert_energy_to_hartree(double en, enum energy unit) {
  switch(unit) {
  case HARTREE:
    return en;
  case EVOLT:
    return en*3.674932540e-2;
  case JOULE:
    return en*2.29371269e17;
  case ERG:
    /*From wikipedia: 1 erg = 1e-7 J */
    return en*2.29371269e10;
  default:
    fprintf(stderr, "kdotp::libmodelxx::continuous_structure::convert_energy_to_hartree: ERROR while converting units: unknown unit of energy (%s)\n", str_from_energy(unit));
    return nan("NaN");
  }
      }

    }
  }
}