matdb.c++

Go to the documentation of this file.

/*
 * matdb: generic materials database information.



 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 <stdlib.h>
#include <math.h>
#include <glib.h>
#include <libmodelxx/matdb.h++>


namespace kdotp {
  namespace libmodelxx {
    namespace structure {

      static void print_property(gpointer key, gpointer value, gpointer user_data) {
  fprintf(stderr, "\t\t%s=%g:\n", (char*)key, *(double*)value);
      }
      static void print_inner_bowing(gpointer key, gpointer value, gpointer user_data) {
  struct matdb_bowing *bowing = (struct matdb_bowing*)value;
  fprintf(stderr, "\tbowing %s:%s[%s:%s]:\n", bowing->from->str, bowing->to->str, (char*)user_data, (char*)key);
  g_hash_table_foreach(bowing->properties, &print_property, NULL);
      }
      static void print_material(gpointer key, gpointer value, gpointer user_data) {
  struct matdb_material *mat = (struct matdb_material*)value;
  fprintf(stderr, "\tmaterial %s(%s):\n", mat->name->str, (char*)key);
  g_hash_table_foreach(mat->properties, &print_property, NULL);
      }
      static void print_bowing(gpointer key, gpointer value, gpointer user_data) {
  GHashTable *ht = (GHashTable*)value;
  g_hash_table_foreach(ht, &print_inner_bowing, key);
      }

      void print_matdb(const struct matdb *mdb) {
  fprintf(stderr, "matdb:\n");
  g_hash_table_foreach(mdb->materials, &print_material, NULL);
  g_hash_table_foreach(mdb->bowings, &print_bowing, NULL);
      }

      void destroy_material_gpointer(gpointer data) {
  destroy_material((struct matdb_material *)data);
      }
      void destroy_bowing_gpointer(gpointer data) {
  destroy_bowing((struct matdb_bowing *)data);
      }
      void destroy_material(struct matdb_material *mat) {
#ifdef DEBUG
  fprintf(stderr, "destroy_material\n");
#endif
  g_string_free(mat->name, TRUE);
  g_hash_table_unref(mat->properties);
  free(mat);
      }
      void destroy_bowing(struct matdb_bowing *bow) {
#ifdef DEBUG
  fprintf(stderr, "destroy_bowing\n");
#endif
  g_string_free(bow->from, TRUE);
  g_string_free(bow->to, TRUE);
  g_hash_table_unref(bow->properties);
  free(bow);
      }

      double* new_double(double d) {double* D = (double*)malloc(sizeof(double)); *D = d; return D;}

      struct foreach_datum {
  GHashTable *new_table;
  GHashTable *mat2_ppts;
  GHashTable *bowings;
  char* mat1;
  char* mat2;
  double x;
      };

      /*Bowing definition from Vurgaftman*/
      double interpolate_with_bowing(double mat1, double mat2, double bow, double x) {
  return x*mat1 + (1-x)*mat2 - x*(1-x)*bow;
      }

      double interpolate_without_bowing(double mat1, double mat2, double x) {
  return x*mat1 + (1-x)*mat2;
      }

      void clone_each_property(gpointer key, gpointer value, gpointer data) {
  char* ppt = (char*)key;
  double* val1 = (double*)value;
  struct foreach_datum* fd = (struct foreach_datum*)data;
  double* val2;
  double* bow;
  double result;
  if(fd->mat2_ppts != NULL) {
    if(fd->mat2_ppts == NULL) {
      fprintf(stderr, "matdb.c++::clone_each_property: fd->mat2_ppts is NULL\n");
    }
    val2 = (double*)g_hash_table_lookup(fd->mat2_ppts, ppt);
    if(val2 == NULL) {
      fprintf(stderr, "matdb.c::clone_each_property: WARNING material %s in material %s is not set in %s; skipping for their alloy.\n", ppt, fd->mat1, fd->mat2);
      return;
    }else{
      
      if((fd->bowings == NULL) || ((bow = (double*)g_hash_table_lookup(fd->bowings, ppt)) == NULL)) {
        result = interpolate_without_bowing(*val1, *val2, fd->x);
      }else{
        result = interpolate_with_bowing(*val1, *val2, *bow, fd->x);
      }
    }
  } else {
    val2=NULL;
    result = *val1;
  }
  g_hash_table_insert(fd->new_table, g_strdup(ppt), new_double(result));
      }

      GHashTable* get_material(const struct matdb* matdb, const char* mat1, const char* mat2, double x) {
  if((x < 0) || (x>1)) {
    fprintf(stderr, "matdb::get_material: material %s(%f)%s doesn't exist: x not in range [0, 1]\n", mat1, x, mat2);
    return NULL;
  }
  if(((!(fabs(x-1.0)) < 1e-8) && (mat2 == NULL))){
    fprintf(stderr, "matdb::get_material: material %s(%f)%s doesn't exist: x!=1 and mat2 is NULL\n", mat1, x, mat2);
    return NULL;
  }
  struct foreach_datum fd;
  void* rv;
  if(matdb->materials == NULL) {
    fprintf(stderr, "matdb.c++::get_material: matdb->materials is NULL\n");
  }
  rv = g_hash_table_lookup(matdb->materials, mat1);
  GHashTable *ppts1 = NULL;
  if(rv == NULL) {
    fprintf(stderr, "matdb::get_material: unable to find material %s in materials database!\n", mat1);
    return NULL;
  } else {
    ppts1 = ((struct matdb_material*)rv)->properties;
  }
  if(mat2 == NULL) {
    fd.mat2_ppts = NULL;
  } else {
    rv = g_hash_table_lookup(matdb->materials, mat2);
    if(rv == NULL) {
      fprintf(stderr, "matdb::get_material: unable to find material %s in materials database!\n", mat2);
      return NULL;
    }
    fd.mat2_ppts = ((struct matdb_material*)rv)->properties;
  }
  fd.new_table = g_hash_table_new_full(g_str_hash, g_str_equal, free, free);
  /*We cast away the const-ness; we need to store these in a struct.*/
  fd.mat1 = (char*)mat1;
  fd.mat2 = (char*)mat2;
  fd.x = x;
  rv = NULL;
  /*Look up and set bowings, if they exist.*/
  if(mat2 != NULL) {
    if(matdb->bowings == NULL) {
      fprintf(stderr, "matdb.c++::get_material: matdb->bowings is NULL\n");
    }
    GHashTable *ht = (GHashTable*)g_hash_table_lookup(matdb->bowings, mat1);
    if(ht != NULL) {
      rv = g_hash_table_lookup(ht, mat2);
      if(rv != NULL) {
        fd.bowings = ((struct matdb_bowing*)rv)->properties;
      }else{
        fd.bowings = NULL;
      }
    }else{
      fd.bowings = NULL;
    }
  }else{
    fd.bowings = NULL;
  }
  g_hash_table_foreach(ppts1, clone_each_property, &fd);
  /*Everything else is someone else's pointers, so we don't have to free anything.*/
  return fd.new_table;
      }

      double get_property1(const struct matdb* matdb, const char* ppt, const char* mat, int* err) {
  void* rv;
  GHashTable *ppts1;
  if(matdb->materials == NULL) {
    fprintf(stderr, "matdb.c++::get_property1: matdb->materials is NULL\n");
  }
  rv = g_hash_table_lookup(matdb->materials, mat);
  if(rv == NULL) {
    fprintf(stderr, "matdb::get_material: unable to find material %s in materials database!\n", mat);
    *err = 1;
    return nan("NaN");
  } else {
    ppts1 = ((struct matdb_material*)rv)->properties;
  }
  if(ppts1 == NULL) {
    fprintf(stderr, "matdb.c++::get_property1: ppts1 is NULL\n");
  }
  rv = g_hash_table_lookup(ppts1, ppt);
  if(rv == NULL) {
    fprintf(stderr, "matdb.c::get_property2: unable to find property %s in material %s\n", ppt, mat);
    *err = 4;
    return nan("NaN");
  }
  *err = 0;
  return *(double*)rv;
      }
      double get_property2(const struct matdb* matdb, const char* ppt, const char* mat1, const char* mat2, double x, int* err){
  if((x < 0) || (x>0) || ((x != 1.0) && (mat2 == NULL))){
    fprintf(stderr, "matdb::get_material: material %s(%e)%s doesn't exist: x not in range [0, 1], or x==1 and mat2 is NULL\n", mat1, x, mat2);
    *err = 1;
    return nan("NaN");
  }
  void* rv;
  if(matdb->materials == NULL) {
    fprintf(stderr, "matdb.c++::get_property2: matdb->materials is NULL\n");
  }
  rv = g_hash_table_lookup(matdb->materials, mat1);
  GHashTable *ppts1 = NULL;
  if(rv == NULL) {
    fprintf(stderr, "matdb::get_property2: unable to find material %s in materials database!\n", mat1);
    *err = 2;
    return nan("NaN");
  } else {
    ppts1 = ((struct matdb_material*)rv)->properties;
  }
  GHashTable *ppts2;
  if(mat2 == NULL) {
    ppts2 = NULL;
  } else {
    if(matdb->materials == NULL) {
      fprintf(stderr, "matdb.c++::get_property2: matdb->materials is NULL\n");
    }
    rv = g_hash_table_lookup(matdb->materials, mat2);
    if(rv == NULL) {
      fprintf(stderr, "matdb::get_property2: unable to find material %s in materials database!\n", mat2);
      *err = 3;
      return nan("NaN");
    }
    ppts2 = ((struct matdb_material*)rv)->properties;
  }
  rv = NULL;
  GHashTable *bowings;
  /*Look up and set bowings, if they exist.*/
  if(mat2 != NULL) {
    if(matdb->bowings == NULL) {
      fprintf(stderr, "matdb.c++::get_property2: matdb->bowings is NULL\n");
    }
    GHashTable *ht = (GHashTable*)g_hash_table_lookup(matdb->bowings, mat1);
    if(ht != NULL) {
      rv = g_hash_table_lookup(ht, mat2);
      if(rv != NULL) {
        bowings = ((struct matdb_bowing*)rv)->properties;
      }else{
        bowings = NULL;
      }
    }else{
      bowings = NULL;
    }
  }else{
    bowings=NULL;
  }
  if(ppts1 == NULL) {
    fprintf(stderr, "matdb.c++::get_property2: ppts1 is NULL\n");
  }
  rv = g_hash_table_lookup(ppts1, ppt);
  if(rv == NULL) {
    fprintf(stderr, "matdb.c::get_property2: unable to find property %s in material %s\n", ppt, mat1);
    *err = 4;
    return nan("NaN");
  }
  double* val1 = (double*)rv;
  double* val2;
  double* bow;
  double result;
  if(ppts2 != NULL) {
    val2 = (double*)g_hash_table_lookup(ppts2, ppt);
    if(val2 == NULL) {
      fprintf(stderr, "matdb.c::clone_each_property: WARNING material %s in material %s is not set in %s; skipping for their alloy.\n", ppt, mat1, mat2);
      *err = 5;
      return nan("NaN");
    }else{
      if(bowings == NULL) {
        fprintf(stderr, "matdb.c++::get_property2: bowings is NULL\n");
      }
      if((bow = (double*)g_hash_table_lookup(bowings, ppt)) == NULL) {
        result = interpolate_without_bowing(*val1, *val2, x);
      }else{
        result = interpolate_with_bowing(*val1, *val2, *bow, x);
      }
    }
  } else {
    val2=NULL;
    result = *val1;
  }
  /*Everything is someone else's pointers, so we don't have to free anything.*/
  *err = 0;
  return result;
      }
      double get_bowing(const struct matdb* matdb, const char* ppt, const char* mat1, const char* mat2, int* err) {
  void *rv;
  GHashTable *bowings;
  /*Look up and set bowings, if they exist.*/
  if(matdb->bowings == NULL) {
    fprintf(stderr, "matdb.c++::get_bowing: bowings is NULL\n");
  }
  GHashTable *ht = (GHashTable*)g_hash_table_lookup(matdb->bowings, mat1);
  if(ht != NULL) {
    rv = g_hash_table_lookup(ht, mat2);
    if(rv != NULL) {
      bowings = ((struct matdb_bowing*)rv)->properties;
    }else{
      *err = 1;
      return nan("NaN");
    }
  }else{
    *err = 2;
    return nan("NaN");
  }
  double* bow;
  if(bowings == NULL) {
    fprintf(stderr, "matdb.c++::get_bowing: bowings is NULL\n");
  }
  if((bow = (double*)g_hash_table_lookup(bowings, ppt)) == NULL) {
    *err = 3;
    return nan("NaN");
  }
  *err = 0;
  return *bow;
      }

      void insert_external_material(struct matdb* matdb, const char* matname) {
  struct matdb_material* mat = (struct matdb_material*)malloc(sizeof(struct matdb_material));
  /*Create an empty hash table for the fake material.*/
  mat->name = g_string_new(matname);
  GString* s = g_string_new(matname);
  mat->properties = g_hash_table_new_full(g_str_hash, g_str_equal, free, free);
  g_hash_table_insert(matdb->materials, s->str, mat);
  g_string_free(s, FALSE);
      }


    }
  }
}