material.c++

Go to the documentation of this file.

/*
 * materials.c++

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

namespace kdotp {
  namespace libmodelxx {
    namespace structure {

      struct index_struct {
  double *a;
  GHashTable *ht;
  int next;
      };

      static void print_property(gpointer key, gpointer value, gpointer data) {
  fprintf(stderr, "key=%s value=%g\n", (char*)key, *(double*)value);
      }

      int* alloc_set_int(int v) {int* ptr = (int*)malloc(sizeof(int)); *ptr = v; return ptr;}

      /**
       *Indexes the properties of a material (used as a callback in a
       *  g_hash_table_foreach call
       */
      static void index_properties(gpointer key, gpointer value, gpointer data) {
  struct index_struct* idxs = (struct index_struct*)data;
  idxs->a[idxs->next] = *(double*)value;
  g_hash_table_insert(idxs->ht, g_strdup((gchar*)key), alloc_set_int(idxs->next));
  (idxs->next)++;
      }

      material::material(const struct matdb* mdb, const char* mat1, const char* mat2, double x) {
  properties = get_material(mdb, mat1, mat2, x);
  /*Kick out if the material specified doesn't exist.*/
  if(properties == NULL) {
    fprintf(stderr, "ERROR in material consturctor: unable to get properties for material: %s/%g/%s\n", mat1, x, mat2); 
    return;
  }
  int ptsize = g_hash_table_size(properties);
  indexed_properties = (double*)malloc(ptsize*sizeof(double));
  property_indices = g_hash_table_new_full(g_str_hash, g_str_equal, free, free);
  struct index_struct idxs = {indexed_properties, property_indices, 0};
  /*Now we go ahead and set up the indexed hash*/
  //g_hash_table_foreach(properties, print_property, NULL);
  if(properties == NULL) {
    fprintf(stderr, "material::material: properties is NULL!\n");
  }
  if(property_indices == NULL) {
    fprintf(stderr, "material::material: property_indices is NULL!\n");
  }
  g_hash_table_foreach(properties, index_properties, &idxs);
  //g_hash_table_foreach(properties, print_property, NULL);
  matname1 = g_strdup(mat1);
  matname2 = g_strdup(mat2);
  m_x = x;
      }

      double material::get_property(const char* ppt, int* err) {
  //fprintf(stderr, "Looking up property %s: ", ppt);
  if(properties == NULL) {
    fprintf(stderr, "Error getting property %s: properties is NULL!!\n", ppt);
    return nan("NaN");
  }
  double* match = (double*)g_hash_table_lookup(properties, ppt);
  if(match == NULL) {
    //fprintf(stderr, "FAILED\n");
    *err = 1;
    return nan("NaN");
  }
  //fprintf(stderr, "%g\n", *match);
  *err = 0; 
  return *match;
      }


      int material::get_property_index(const char* ppt, int* err) {
  if(property_indices == NULL) {
    return -2;
  }
  int* i = (int*)g_hash_table_lookup(property_indices, ppt);
  if(i == NULL) {*err = 1; return -1;}
  *err = 0;
  return *i;
      }

      /*For some reason, this dosn't work as a const.*/
      char* material::get_name() {
  GString* s = g_string_new("");
  if(matname2 != NULL) {
    g_string_printf(s, "%s(%f)%s", matname1, m_x, matname2);
  }else{
    g_string_printf(s, "%s", matname1);
  }
  char *c = s->str;
  g_string_free(s, FALSE);
  return c;
      }

      bool operator==(const material& m1, const material& m2) {
  if(g_strcmp0(m1.matname1, m2.matname1)) return false;
  if(g_strcmp0(m1.matname2, m2.matname2)) return false;
  return m1.m_x == m2.m_x;
      }
      bool material::operator==(const material& m2) {
  if(g_strcmp0(matname1, m2.matname1)) return false;
  if(g_strcmp0(matname2, m2.matname2)) return false;
  return m_x == m2.m_x;
      }
      bool operator!=(const material& m1, const material& m2) {
  if(!(g_strcmp0(m1.matname1, m2.matname1))) return true;
  if(!(g_strcmp0(m1.matname2, m2.matname2))) return true;
  return m1.m_x != m2.m_x;
      }
      bool material::operator!=(const material& m2) {
  if(!(g_strcmp0(matname1, m2.matname1))) return true;
  if(!(g_strcmp0(matname2, m2.matname2))) return true;
  return m_x != m2.m_x;
      }
      bool material::lenient_equals(const material& m2, double tolerance) {
  if(g_strcmp0(matname1, m2.matname1)) return false;
  if(g_strcmp0(matname2, m2.matname2)) return false;
  if(fabs(m_x - m2.m_x) > fabs(tolerance*m_x)) return false;
  return fabs(m_x - m2.m_x) < fabs(tolerance*m2.m_x);
      }

    }
  }
}