matdb.c

Go to the documentation of this file.

/*
 * matdb: generic materials database information.



    Copyright (C) 2008 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 <string.h>
#include <libmodeling/matdb.h>

#define ALLOY_PERCENT_MAX_FIELD_LENGTH 9

static guint g_string_hash2(gconstpointer p) {
  return g_str_hash(((GString*)p)->str);
}

static gboolean g_string_equal2(gconstpointer a, gconstpointer b) {
  return g_str_equal(((GString*)a)->str, ((GString*)b)->str);
}

static void destroy_double(gpointer data){
  free((double*)data);
}
static void destroy_gstring(gpointer data){
  g_string_free((GString*)data, TRUE);
}
static void destroy_hashtable(gpointer data){
  g_hash_table_destroy((GHashTable*)data);
}

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) {
  fprintf(stderr, "\t%s/%s:\n", ((GString*) key)->str, ((GString*)user_data)->str);
  g_hash_table_foreach((GHashTable*)value, &print_property, NULL);
}

static void print_material(gpointer key, gpointer value, gpointer user_data) {
  fprintf(stderr, "\tmaterial %s:\n", ((GString*)key)->str);
  g_hash_table_foreach((GHashTable*)value, &print_property, NULL);
}

static void print_bowing(gpointer key, gpointer value, gpointer user_data) {
  g_hash_table_foreach((GHashTable*)value, &print_inner_bowing, key);
}

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

/*ERROR CODES:
   0: success
   1: (not defined)
   2: mat1 doesn't exist.
   3: mat1 param doesn't exist.
   4: mat2 doesn't exist.
   5: mat2 param doesn't exist.
 */
double get_alloy_param(const struct matdb *mdb, const char* mat1, const char* mat2, double x, const char* param, int *err) {
  //fprintf(stderr, "get_alloy_param(%s, %s, %g, %s):", mat1, mat2, x, param);
  GString* m1 = g_string_new(mat1);
  GString* m2 = g_string_new(mat2);
  GString* p = g_string_new(param);
  GHashTable *ppts;
  GHashTable *ppts1;
  GHashTable *ppts2;
  double *v1;
  double *v2;
  double *bow = NULL;
  /*is a hash indexed by the first material, containing a hash indexed
   * by the second material.*/
  if((ppts = g_hash_table_lookup(mdb->bowings, m1)) == NULL) {
    /*If there's no bowing param, we just use a linear interpolation.*/
    if((ppts = g_hash_table_lookup(mdb->bowings, m2)) != NULL) {
      ppts = g_hash_table_lookup(ppts, m1);
    }
  }else{
    ppts = g_hash_table_lookup(ppts, m2);
  }
  if(ppts != NULL) {
    bow = g_hash_table_lookup(ppts, p);
  }
  if(unlikely((ppts1 = g_hash_table_lookup(mdb->materials, m1)) == NULL)) {
    *err = 2;
    g_string_free(m1, TRUE);
    g_string_free(m2, TRUE);
    g_string_free(p, TRUE);
    return 0;
  }else{
    if(unlikely((v1 = g_hash_table_lookup(ppts1, p)) == NULL)) {
      *err = 3;
      g_string_free(m1, TRUE);
      g_string_free(m2, TRUE);
      g_string_free(p, TRUE);
      return 0;
    }
  }
  if(unlikely((ppts2 = g_hash_table_lookup(mdb->materials, m2)) == NULL)) {
    *err = 4;
    g_string_free(m1, TRUE);
    g_string_free(m2, TRUE);
    g_string_free(p, TRUE);
    return 0;
  }else{
    if(unlikely((v2 = g_hash_table_lookup(ppts2, p)) == NULL)) {
      *err = 5;
      g_string_free(m1, TRUE);
      g_string_free(m2, TRUE);
      g_string_free(p, TRUE);
      return 0;
    }
  }
  *err = 0;
  if(bow != NULL) {
    //fprintf(stderr, "bow=%g alloy=%g\n", *bow, alloy_bowed(*v1, *v2, *bow, x));
    g_string_free(m1, TRUE);
    g_string_free(m2, TRUE);
    g_string_free(p, TRUE);
    return alloy_bowed(*v1, *v2, *bow, x);
  }else{
    //fprintf(stderr, "bow=[none] alloy=%g\n", alloy_linear(*v1, *v2, x));
    g_string_free(m1, TRUE);
    g_string_free(m2, TRUE);
    g_string_free(p, TRUE);
    return alloy_linear(*v1, *v2, x);
  }
}

/*ERROR CODES:
 *  0: success
 *  1: no such material
 *  2: material doesn't have param.
 */
double get_material_param(const struct matdb *mdb, const char* mat, const char* param, int *err) {
  GString* m = g_string_new(mat);
  GString* p = g_string_new(param);
  GHashTable *ppts;
  double* v;
  //fprintf(stderr, "get_material_param: m=%s p=%s\n", m->str, p->str);
  ppts = g_hash_table_lookup(mdb->materials, m);
  if(likely(ppts != NULL)) {
    if(unlikely((v = g_hash_table_lookup(ppts, p)) == NULL)) {
      *err = 2;
      g_string_free(m, TRUE);
      g_string_free(p, TRUE);
      return 0;
    }
  }else{
    *err = 1;
    g_string_free(m, TRUE);
    g_string_free(p, TRUE);
    return 0;
  }
  *err = 0;
  g_string_free(m, TRUE);
  g_string_free(p, TRUE);
  return *v;
}

/*ERROR CODES:
 * 0: success
 * 1: couldn't allocate space for storing the value
 * 3: (debug only) property already exists
 */
void set_material_param(struct matdb *mdb, const char* mat, const char* param, double value, int *err) {
  GString *p = g_string_new(param);
  GString *m = g_string_new(mat);
  GHashTable *ppts;
  //fprintf(stderr, "set_material_param: m=%s p=%s, value=%g\n", m->str, p->str, value);
  if((ppts = g_hash_table_lookup(mdb->materials, m)) == NULL) {
    /*Make a new structure.*/
    ppts = g_hash_table_new_full(g_string_hash2, g_string_equal2, destroy_gstring, destroy_double);
    g_hash_table_insert(mdb->materials, m, ppts);
  }else{
    g_string_free(m, TRUE);
  }
  double *v = (double*)malloc(sizeof(double));
  if(v == NULL) {
    *err = 1;
    g_string_free(m, TRUE);
    g_string_free(p, TRUE);
    return;
  }
  #ifdef DEBUG
  if(unlikely(g_hash_table_lookup(ppts, p) != NULL)) {
    *err = 3;
  }else{
  #endif
    *err = 0;
  #ifdef DEBUG
  }
  #endif
  *v = value;
  g_hash_table_insert(ppts, p, v);
}

/*ERROR CODES:
 *  0: success
 *  1: mat1 doesn't (yet?) exist
 *  2: mat1 param doesn't (yet?) exist
 *  3: mat2 doesn't (yet?) exist
 *  4: mat2 param doesn't (yet?) exist
 */
void set_bowing_param(struct matdb *mdb, const char* mat1, const char* mat2, const char* param, double value, int *err) {
  //fprintf(stderr, "set_bowing_param(%s, %s, %s, %g) ", mat1, mat2, param, value);
  GString *p = g_string_new(param);
  GString *p2 = g_string_new(param);
  GString *m1 = g_string_new(mat1);
  GString *m2 = g_string_new(mat2);
  /*for the 2nd-level table*/
  GString *m1_2 = g_string_new(mat1);
  GString *m2_2 = g_string_new(mat2);
  GHashTable *ppts;
  GHashTable *ppts2;
  double *v;
  /*First, ensure that the property has been set for both m1 and mat2.*/
  if(unlikely((ppts = g_hash_table_lookup(mdb->materials, m1)) == NULL)){
    //fprintf(stderr, "!mat1 (err1)\n");
    *err = 1;
    return;
  }
  if(unlikely((v = g_hash_table_lookup(ppts, p)) == NULL)){
    //fprintf(stderr, "!mat1/param (err2)\n");
    *err = 2;
    return;
  }
  if(unlikely((ppts2 = g_hash_table_lookup(mdb->materials, m2)) == NULL)){
    //fprintf(stderr, "!mat2 (err3)\n");
    *err = 3;
    return;
  }
  if(unlikely((v = g_hash_table_lookup(ppts2, p)) == NULL)){
    //fprintf(stderr, "!mat2/param (err4)\n");
    *err = 4;
    return;
  }
  GHashTable *l2_table;
  GHashTable *l2_table2;
  /*We ensure that the bowings are set for both m1->m2 and m2->m1*/
  if((l2_table = g_hash_table_lookup(mdb->bowings, m1)) == NULL) {
    /*Make a new structure.*/
    l2_table = g_hash_table_new_full(g_string_hash2, g_string_equal2, destroy_gstring, destroy_hashtable);
    g_hash_table_insert(mdb->bowings, m1, l2_table);
  }else{
    g_string_free(m1, TRUE);
  }
  /*Make sure that, if need be, there's a struct for the other way.*/
  if((l2_table2 = g_hash_table_lookup(mdb->bowings, m2)) == NULL) {
    /*Make a new structure.*/
    l2_table2 = g_hash_table_new_full(g_string_hash2, g_string_equal2, destroy_gstring, destroy_hashtable);
    g_hash_table_insert(mdb->bowings, m2, l2_table2);
  }else{
    g_string_free(m2, TRUE);
  }
  /*We can't just have m1,m2 and m2,m1 point to the same hash
   * table; Otherwise, on deletion (and therefore on inserting
   * duplicate data), the structure will be freed/destroyed twice!
   */
  if((ppts = g_hash_table_lookup(l2_table, m2_2)) == NULL) {
    /*Need to make a hash for the properties.*/
    ppts = g_hash_table_new_full(g_string_hash2, g_string_equal2, destroy_gstring, destroy_double);
    g_hash_table_insert(l2_table, m2_2, ppts);
  }else{
    g_string_free(m2_2, TRUE);
  }
  if((ppts2 = g_hash_table_lookup(l2_table2, m1_2)) == NULL) {
    /*Need to make a hash for the properties.*/
    ppts2 = g_hash_table_new_full(g_string_hash2, g_string_equal2, destroy_gstring, destroy_double);
    g_hash_table_insert(l2_table2, m1_2, ppts2);
  }else{
    g_string_free(m1_2, TRUE);
  }
  /*Now we can insert the value into the ppts.*/
  double *v1 = (double*)malloc(sizeof(double));
  double *v2 = (double*)malloc(sizeof(double));
  *v1 = *v2 = value;
  g_hash_table_insert(ppts, p, v1);
  g_hash_table_insert(ppts2, p2, v2);
  *err = 0;
  //fprintf(stderr, "\n");
}

double get_param(const struct matdb *mdb, const char* mat1, const char* mat2, double x, const char* param, int *err) {
  if(mat2 == NULL) return get_material_param(mdb, mat1, param, err);
  else return get_alloy_param(mdb, mat1, mat2, x, param, err);
}

struct matdb* matdb_new() {
  struct matdb* mdb = (struct matdb*)malloc(sizeof(struct matdb));
  if(mdb == NULL) return NULL;
  mdb->materials = g_hash_table_new_full(g_string_hash2, g_string_equal2, destroy_gstring, destroy_hashtable);
  if(mdb->materials == NULL) {
    free(mdb);
    return NULL;
  }
  mdb->bowings = g_hash_table_new_full(g_string_hash2, g_string_equal2, destroy_gstring, destroy_hashtable);
  if(mdb->bowings == NULL) {
    g_hash_table_destroy(mdb->materials);
    free(mdb);
    return NULL;
  }
  return mdb;
}

void canonicalize_alloy_args(char **mat1, char **mat2, double *x) {
  if(((*x) < 0) || ((*x) > 1)) return;
  char* t;
  if(strcmp(*mat1, *mat2) >= 0) {
    t = *mat1;
    *mat1 = *mat2;
    *mat2 = t;
    *x = 1.0-(*x);
  }
}
GString* canonicalize_alloy(char **mat1, char **mat2, double *x) {
  if(((*x) < 0) || ((*x) > 1)) return NULL;
  GString *name;
  char x1[ALLOY_PERCENT_MAX_FIELD_LENGTH];
  char x2[ALLOY_PERCENT_MAX_FIELD_LENGTH];
  canonicalize_alloy_args(mat1, mat2, x);
  snprintf(x1, ALLOY_PERCENT_MAX_FIELD_LENGTH, "%.5f", *x);
  snprintf(x2, ALLOY_PERCENT_MAX_FIELD_LENGTH, "%.5f", (1.0-(*x)));
  x1[ALLOY_PERCENT_MAX_FIELD_LENGTH-1]='\0';
  x2[ALLOY_PERCENT_MAX_FIELD_LENGTH-1]='\0';
  name = g_string_new(*mat1);
  name = g_string_append(name, "_");
  name = g_string_append(name, x1);
  name = g_string_append(name, "/");
  name = g_string_append(name, *mat2);
  name = g_string_append(name, "_");
  name = g_string_append(name, x2);
  return name;
}

struct property_passthru {
  GHashTable *ppts2;
  GHashTable *bowings;
  GHashTable *final_ppts;
  double x;
};

static void assemble_properties_foreach(gpointer key, gpointer data, gpointer private) {
  struct property_passthru *pt = (struct property_passthru*)private;
  double *v;
  double *v2;
  double *bow = NULL;
  /*Make sure the property is set for material 2.*/
  if((v2 = g_hash_table_lookup(pt->ppts2, (GString*)key)) == NULL) return;
  if(pt->bowings != NULL) bow = g_hash_table_lookup(pt->bowings, (GString*)key);
  v = (double*)malloc(sizeof(double));
  if(bow != NULL) {
    *v = alloy_bowed(*(double*)key, *v2, *bow, pt->x);
  }else{
    *v = alloy_linear(*(double*)key, *v2, pt->x);
  }
}

struct material* get_alloy(const struct matdb *mdb, const char* mat1, const char* mat2, double x) {
  struct material* m;
  if((m= (struct material*)malloc(sizeof(struct material))) == NULL) return NULL;
  if((m->storage = (struct alloy_storage*)malloc(sizeof(struct alloy_storage))) == NULL) {
    free(m);
    return NULL;
  }
  char *mt1 = (char*)mat1;
  char *mt2 = (char*)mat2;
  double ex = x;
  m->name = canonicalize_alloy(&mt1, &mt2, &ex);
  
  if(m->name == NULL) {
    free((struct material*)(m->storage));
    free(m);
    return NULL;
  }
  GString *m1 = g_string_new(mat1);
  GString *m2 = g_string_new(mat2);
  GHashTable *ppts1 = g_hash_table_lookup(mdb->materials, m1);
  GHashTable *ppts2 = g_hash_table_lookup(mdb->materials, m2);
  GHashTable *bowings = g_hash_table_lookup(mdb->bowings, m1);
  if(bowings != NULL) bowings = g_hash_table_lookup(bowings, m2);
  GHashTable *final_ppts = g_hash_table_new_full(g_string_hash2, g_string_equal2, destroy_gstring, destroy_double);
  if((m->name == NULL) || (final_ppts == NULL) || (ppts1 == NULL) || (ppts2 == NULL)) {
    g_string_free(m1, TRUE);
    g_string_free(m2, TRUE);
    if(final_ppts != NULL) g_hash_table_destroy(final_ppts);
    free((struct material*)(m->storage));
    free(m);
    return NULL;
  }
  struct property_passthru pt;
  pt.ppts2 = ppts2;
  pt.bowings = bowings;
  pt.final_ppts = final_ppts;
  pt.x = ex;
  g_hash_table_foreach(ppts1, assemble_properties_foreach, &pt);
  g_string_free(m1, TRUE);
  g_string_free(m2, TRUE);
  ((struct alloy_storage*)m->storage)->ppts = final_ppts;
  ((struct alloy_storage*)m->storage)->mat1 = m1;
  ((struct alloy_storage*)m->storage)->mat2 = m2;
  ((struct alloy_storage*)m->storage)->x = ex;
  return m;
}

void matdb_destroy(struct matdb* mdb) {
  g_hash_table_destroy(mdb->materials);
  g_hash_table_destroy(mdb->materials);
}