source: src/periodentafel.cpp@ 260934

/** \file periodentafel.cpp
 * 
 * Function implementations for the class periodentafel.
 * 
 */

#include "molecules.hpp"

/************************************* Functions for class periodentafel ***************************/

/** constructor for class periodentafel
 * Initialises start and end of list and resets periodentafel::checkliste to false.
 */
periodentafel::periodentafel() 
{ 
  start = new element; 
  end = new element; 
  start->previous = NULL; 
  start->next = end; 
  end->previous = start; 
  end->next = NULL;
};

/** destructor for class periodentafel
 * Removes every element and afterwards deletes start and end of list.
 */
periodentafel::~periodentafel() 
{ 
  CleanupPeriodtable(); 
  delete(end); 
  delete(start); 
}; 

/** Adds element to period table list
 * \param *pointer element to be added
 * \return true - succeeded, false - does not occur
 */
bool periodentafel::AddElement(element *pointer) 
{ 
  pointer->sort = &pointer->Z;
  if (pointer->Z < 1 && pointer->Z >= MAX_ELEMENTS)
    cout << Verbose(0) << "Invalid Z number!\n";
  return add(pointer, end); 
};

/** Removes element from list.
 * \param *pointer element to be removed
 * \return true - succeeded, false - element not found
 */
bool periodentafel::RemoveElement(element *pointer) 
{ 
  return remove(pointer, start, end); 
};

/** Removes every element from the period table.
 * \return true - succeeded, false - does not occur
 */
bool periodentafel::CleanupPeriodtable() 
{ 
  return cleanup(start,end); 
};

/** Finds an element by its atomic number.
 * If element is not yet in list, datas are asked and stored in database.
 * \param Z atomic number
 * \return pointer to element
 */
element * periodentafel::FindElement(int Z)
{
  element *walker = find(&Z, start,end);
  if (walker == NULL) { // not found: enter and put into db
    cout << Verbose(0) << "Element not found in database, please enter." << endl;
    walker = new element;
    cout << Verbose(0) << "Mass: " << endl;
    cin >> walker->mass;
    walker->Z = Z;  
    cout << Verbose(0) << "Atomic number: " << walker->Z << endl;  
    cout << Verbose(0) << "Name [max 64 chars]: " << endl;
    cin >> walker->name;
    cout << Verbose(0) << "Short form [max 3 chars]: " << endl;
    cin >> walker->symbol;
    periodentafel::AddElement(walker);
  }
  return(walker);
};

/** Finds an element by its atomic number.
 * If element is not yet in list, datas are asked and stored in database.
 * \param shorthand chemical symbol of the element, e.g. H for hydrogene
 * \return pointer to element
 */
element * periodentafel::FindElement(char *shorthand) const
{
  element *walker =  periodentafel::start;
  while (walker->next != periodentafel::end) {
    walker = walker->next;
    if (strncmp(walker->symbol, shorthand, 3) == 0)
      return(walker);
  }
  return (NULL);
};

/** Asks for element number and returns pointer to element
 */
element * periodentafel::AskElement() 
{
  element *walker = NULL;
  int Z;
  do {
    cout << Verbose(0) << "Atomic number Z: ";
    cin >> Z;
    walker = this->FindElement(Z);  // give type
  } while (walker == NULL);
  return walker;
};


/** Prints period table to given stream.
 * \param output stream
 */ 
bool periodentafel::Output(ofstream *output) const
{
  bool result = true;
  element *walker = start;
  if (output != NULL) {
    while (walker->next != end) {
      walker = walker->next;
      result = result && walker->Output(output);
    }
    return result;
  } else 
    return false;
};

/** Prints period table to given stream.
 * \param *output output stream
 * \param *checkliste elements table for this molecule
 */ 
bool periodentafel::Checkout(ofstream *output, const int *checkliste) const
{
  element *walker = start;
  bool result = true;
  int No = 1;

  if (output != NULL) {
    *output << "# Ion type data (PP = PseudoPotential, Z = atomic number)" << endl;
    *output << "#Ion_TypeNr.\tAmount\tZ\tRGauss\tL_Max(PP)L_Loc(PP)IonMass\t# chemical name, symbol" << endl;
    while (walker->next != end) {
      walker = walker->next;
      if (checkliste[walker->Z]) {
        walker->No = No;
        result = result && walker->Checkout(output, No++, checkliste[walker->Z]);      
      }
    }
    return result;
  } else 
    return false;
};


/** Loads element list from file.
 */
bool periodentafel::LoadPeriodentafel(char *filename)
{
  ifstream infile;
  double tmp;
  element *ptr;
  bool status = true;
  bool otherstatus = true;
  
  // fill elements DB
  if (filename == NULL)
    infile.open(STANDARDELEMENTSDB);
  else
    infile.open(filename);
  if (infile != NULL) {
    infile.getline(header1, MAXSTRINGSIZE);
    infile.getline(header2, MAXSTRINGSIZE); // skip first two header lines
    cout <<  "Parsed elements:";
    while (!infile.eof()) {
      element *neues = new element;
      infile >> neues->name;
      //infile >> ws;
      infile >> neues->symbol;
      //infile >> ws;
      infile >> neues->period;
      //infile >> ws;
      infile >> neues->group;
      //infile >> ws;
      infile >> neues->block;
      //infile >> ws;
      infile >> neues->Z;
      //infile >> ws;
      infile >> neues->mass;
      //infile >> ws;
      infile >> neues->CovalentRadius;
      //infile >> ws;
      infile >> neues->VanDerWaalsRadius;
      //infile >> ws;
      periodentafel::AddElement(neues);
      infile >> ws;
      cout << " " << neues->symbol;
      //neues->Output((ofstream *)&cout);
    }
    cout << endl;
    infile.close();
    infile.clear();
  } else
    status = false;

  // fill valence DB per element
  infile.open(STANDARDVALENCEDB);
  if (infile != NULL) {
    while (!infile.eof()) {
        infile >> tmp;
        infile >> ws;
        infile >> FindElement((int)tmp)->Valence;
        infile >> ws;
        //cout << Verbose(3) << "Element " << (int)tmp << " has " << find_element((int)tmp)->Valence << " valence electrons." << endl;
    }
    infile.close();
    infile.clear();
  } else
    otherstatus = false;

  // fill valence DB per element
  infile.open(STANDARDORBITALDB);
  if (infile != NULL) {
    while (!infile.eof()) {
      infile >> tmp;
      infile >> ws;
      infile >> FindElement((int)tmp)->NoValenceOrbitals;
      infile >> ws;
      //cout << Verbose(3) << "Element " << (int)tmp << " has " << find_element((int)tmp)->NoValenceOrbitals << " number of singly occupied valence orbitals." << endl;
    }
    infile.close();
    infile.clear();
  } else
    otherstatus = false;
  
  // fill H-BondDistance DB per element
  infile.open(STANDARDHBONDDISTANCEDB);
  if (infile != NULL) {
    while (!infile.eof()) {
        infile >> tmp;
      ptr = FindElement((int)tmp);
        infile >> ws;
      infile >> ptr->HBondDistance[0];
      infile >> ptr->HBondDistance[1];
      infile >> ptr->HBondDistance[2];
        infile >> ws;
      //cout << Verbose(3) << "Element " << (int)tmp << " has " << find_element((int)tmp)->HBondDistance[0] << " Angstrom typical distance to hydrogen." << endl;
    }
    infile.close();
    infile.clear();
  } else
    otherstatus = false;
  
  // fill H-BondAngle DB per element
  infile.open(STANDARDHBONDANGLEDB);
  if (infile != NULL) {
    while (!infile.eof()) {
      infile >> tmp;
      ptr = FindElement((int)tmp);
      infile >> ws;
      infile >> ptr->HBondAngle[0];
      infile >> ptr->HBondAngle[1];
      infile >> ptr->HBondAngle[2];
      infile >> ws;
      //cout << Verbose(3) << "Element " << (int)tmp << " has " << FindElement((int)tmp)->HBondAngle[0] << ", " << FindElement((int)tmp)->HBondAngle[1] << ", " << FindElement((int)tmp)->HBondAngle[2] << " degrees bond angle for one, two, three connected hydrogens." << endl;
    }
    infile.close();
  } else
    otherstatus = false;
  
  return status;
};

/** Stores element list to file.
 */
bool periodentafel::StorePeriodentafel(char *filename) const
{
  bool result = true;
  ofstream f;
  
  if (filename == NULL)
    f.open("elements.db");
  else
    f.open(filename);
  if (f != NULL) {
    f << header1 << endl;
    f << header2 << endl;
    element *walker = periodentafel::start;
    while (walker->next != periodentafel::end) {
      walker = walker->next;
      result = result && walker->Output(&f);
    }
    f.close();
  } else
    result = false;
  return result;
};