continuous_structure.h++

Go to the documentation of this file.

/*
 * Structures for creating a (temporary; will be discretized)
 * continuous structure from an input.

 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 ____LIBMODELING_CONTINUOUS_STRUCTURE_HXX____
#define ____LIBMODELING_CONTINUOUS_STRUCTURE_HXX____

#include <glib.h>
#include <libmodelxx/grid.h++>
#include <libmodelxx/material.h++>
#include <libmodelxx/generic_structure.h++>
#include <libmodelxx/function_specification.h++>

#define CONTINUOUS_STRUCTURE_DOMAIN 56931

namespace kdotp {
  namespace libmodelxx {
    namespace continuous_structure {

      struct region {
  struct grid::shape_tree* st;
  structure::material* m;
  /*Material, or first material in a blended system*/
  char* mat1;
  /*Null, or second material in a blended system*/
  char* mat2;
  /*Percentage of mat1, from 0 to 1, exclusive*/
  float x;
  /*Expression to use instead of float, if present*/
  postprocessing::function_exp* f;
  /*Storage for key/value pairs in raw input.*/
  GList* key_values;
      };

      struct doping {
  struct grid::shape_tree* st;
  /*Doping density units are dependent upon dimensionality:
   * TODO: THIS IS CURRENTLY A LIE! Units are currently #(singly-ionized dopants)/cm^-3
   * 1D: mC/nm^2
   * 2D: mC/nm^1
   * 3D: mC
   */
  postprocessing::function_exp* f;
  /*Storage for key/value pairs in raw input.*/
  GList* key_values;
      };

      struct potential {
  double* E;
  postprocessing::function_exp* function;
  GList *Evec;
      };

      struct continuous_structure {
  struct grid::grid* g;
  /*Placeholder for raw key/value pairs*/
  GList* key_values;
  /*\var list containing the regions, in order of occurrance*/
  GList* regions;
  GList* dopings;
  GList* potential;
      };

      enum length {
  ANGSTROM,
  NANOMETER,
  MICROMETER,
  MILLIMETER,
  CENTIMETER,
  METER,
  UNKNOWN_LENGTH
      };

      enum energy {
  EVOLT,
  JOULE,
  ERG,
  HARTREE,
  UNKNOWN_ENERGY
      };

      /**
       *Processes the structure after it's been read in from a file.*
       *\param s pointer to the structure from the input file
       */
      struct structure::generic_structure* postprocess_structure(struct continuous_structure *s, const struct structure::matdb* mdb, GHashTable* global_symbol_table,GError **err);

      /**
       *pretty-prints a processed structure.
       *\param s pointer to the structure from the input file
       */
      void print_structure(const struct continuous_structure *s);

      /**
       *converts a length to nm
       *\param len length
       *\param unit units
       */
      double convert_length_to_nm(double len, enum length unit);

      /**
       *converts an energy to hartree
       *\param en energy
       *\param unit units
       */
      double convert_energy_to_hartree(double en, enum energy unit);

      /**
       *Gets the length corresponding to a string
       *\param str the string to convert
       */
      enum length length_from_str(const char* str);

      /**
       *Gets the energy corresponding to a string
       *\param str the string to convert
       */
      enum energy energy_from_str(const char* str);

      /**
       *Gets the length string from a length
       *\param l the length
       */
      const char* str_from_length(enum length l);

      /**
       *Gets the energy string from an energy
       *\param e the energy
       */
      const char* str_from_energy(enum energy e);
    }
  }
}


#endif