main.cpp

   1 /*
   2  * Determination of lateral interaction parameters on a c(2x2) square lattice
   3  * using linear combinations to express each interaction and then counting them in terms of cluster-expansion
   4  * coefficients
   5  *
   6  * Michael Rieger, FHI, 2008
   7  *
   8  */
   9
  10 #include <iostream>
  11 #include <string>
  12
  13 #include <blitz/array.h>                // http://www.oonumerics.org/blitz/
  14 #include <random/uniform.h>             // blitz Random Number Generator - Mersenne Twister type
  15 #include "SimpleIni.h"          // Ini File Parser
  16
  17 using namespace std;
  18 using namespace blitz;
  19 using namespace ranlib;
  20
  21 Array<int, 2> lattice;
  22 Array<int, 2> CObr_pos;
  23
  24 enum occupation
  25                 {
  26                         empty_site,
  27                         Pd,
  28                         CO
  29                 };
  30
  31 enum directions
  32                 {
  33                         x_direction,
  34                         y_direction,
  35                         max_directions
  36                 };
  37
  38
  39 int read_ini_structure(const char *input_file_name, int &lattice_size_x, int &lattice_size_y, int &nr_of_CObr)
  40 {
  41         CSimpleIni ini;
  42         int unit_cell_x,unit_cell_y;
  43
  44         //loading input file
  45         SI_Error rc = ini.LoadFile(input_file_name);
  46     if (rc < 0) return false;
  47
  48         // getting cell dimensions from [cell] section in input file
  49         unit_cell_x = atoi(ini.GetValue("cell", "unit_cell_x"));
  50         std::cout << unit_cell_x << endl;
  51         unit_cell_y = atoi(ini.GetValue("cell", "unit_cell_y"));
  52         std::cout << unit_cell_y << endl;
  53
  54         // creating simulation lattice
  55         lattice_size_x = 4*unit_cell_x;
  56         lattice_size_y = 4*unit_cell_y;
  57         std::cout << lattice_size_x << "   " << lattice_size_y << endl;
  58
  59
  60         // output all of the items of the input file
  61         CSimpleIniA::TNamesDepend sections;
  62         CSimpleIniA::TNamesDepend::const_iterator sections_iterator;
  63         ini.GetAllSections(sections);
  64
  65
  66         CSimpleIniA::TNamesDepend::size_type sections_size;
  67         sections_size = sections.size();
  68
  69         nr_of_CObr = int(sections_size) - 1;
  70
  71         string key_word = "cell";
  72
  73
  74         for (sections_iterator = sections.begin(); sections_iterator != sections.end(); sections_iterator++)
  75                 {
  76                 printf("%s\n", sections_iterator->pItem);
  77                 std::cout << "direkt per cout " << sections_iterator->pItem << endl;
  78
  79                 string section_name = sections_iterator->pItem;
  80
  81                 if (key_word == section_name)
  82                         printf("\t\t\t FOUND \n\n\n");
  83
  84         };
  85
  86         printf("nr of sections given by sections.size() %i\n", sections.size());
  87
  88
  89         // next step.. printing all keys of a section
  90
  91         CSimpleIniA::TNamesDepend::const_iterator section_iterator;
  92         section_iterator = sections.begin();
  93
  94         section_iterator++;
  95
  96
  97         printf("second section name: - %s - contains the keys: \n", section_iterator->pItem);
  98
  99         key_word = "x";
 100         float x = 0.0;
 101
 102         CSimpleIniA::TNamesDepend keys;
 103         ini.GetAllKeys(sections_iterator->pItem, keys);
 104         CSimpleIniA::TNamesDepend::const_iterator k;
 105
 106         for (k = keys.begin(); k != keys.end(); ++k)
 107                 {
 108                 printf("%s\n", k->pItem);
 109                 string key_name = k->pItem;
 110                 if (key_word == key_name)
 111                         {
 112                         printf("\t\t\t FOUND an X\n\n\n");
 113                         x = atof(ini.GetValue(section_iterator->pItem, k->pItem));
 114                         std::cout << "value is now (here): " << x << endl;
 115                         };
 116         };
 117
 118     printf("end of input file reading");
 119
 120
 121
 122
 123         return 1;
 124 }
 125
 126 int fill_surface_atoms(Array<int, 2> lattice, occupation site_occupation, int lattice_size_x, int lattice_size_y)
 127 {
 128         int pos_x, pos_y;
 129
 130         for (pos_x = 0; pos_x < lattice_size_x; pos_x = pos_x + 2) // for test... only every second x
 131                 {
 132                         for (pos_y = 0; pos_y < lattice_size_y; pos_y++)
 133                                 {
 134                                         lattice(pos_x,pos_y) = site_occupation;
 135                                 };
 136                 };
 137
 138         std::cout << lattice << endl;
 139         return 1;
 140 }
 141
 142 int get_and_fill_adorbates(const char *input_file_name, Array<int, 2> lattice, Array<int, 2> CObr_pos, occupation atom, int lattice_size_x, int lattice_size_y)
 143 {
 144         CSimpleIni ini;
 145         CSimpleIniA::TNamesDepend sections;
 146     CSimpleIniA::TNamesDepend keys;
 147         CSimpleIniA::TNamesDepend::const_iterator sections_iterator;
 148
 149         //loading input file
 150         SI_Error rc = ini.LoadFile(input_file_name);
 151     if (rc < 0) return false;
 152
 153     //getting all sections, setting pointer to first CO section
 154         ini.GetAllSections(sections);
 155     sections_iterator = sections.begin();
 156     sections_iterator++;
 157
 158     string coord_x, coord_y, coord_read;
 159     int CO_counter = 0;
 160
 161     coord_x = "x";
 162     coord_y = "y";
 163
 164
 165     while (sections_iterator != sections.end())
 166                 {
 167                 std::cout << sections_iterator->pItem << endl;
 168
 169                 ini.GetAllKeys(sections_iterator->pItem, keys);
 170
 171
 172
 173                 for (CSimpleIniA::TNamesDepend::const_iterator key_iterator = keys.begin(); key_iterator != keys.end(); ++key_iterator)
 174                                 {
 175
 176                                 std::cout << key_iterator->pItem << endl;
 177
 178                                 };
 179
 180                         CO_counter++;
 181                         sections_iterator++;
 182                 };
 183
 184
 185         return 1;
 186 }
 187
 188
 189 int main(int argc, char* argv[])
 190 {
 191         int lattice_size_x, lattice_size_y;
 192         int nr_of_CObr;
 193
 194         // subroutine to read all necessary input files
 195          if (read_ini_structure(argv[1], lattice_size_x, lattice_size_y, nr_of_CObr))
 196          {
 197                 std::cout << "\n\n filling surface atoms now\n" << std::endl;
 198                 Array<int, 2> lattice(lattice_size_x,lattice_size_y); // array constructor
 199                 Array<int, 2> CObr_pos(nr_of_CObr, max_directions);
 200
 201                 lattice = 0;
 202                 CObr_pos = 1;
 203
 204                 std::cout << lattice;
 205                 std::cout << CObr_pos;
 206
 207
 208                 // filling surface atoms
 209                 fill_surface_atoms(lattice, Pd, lattice_size_x, lattice_size_y);
 210
 211                 get_and_fill_adorbates(argv[1], lattice, CObr_pos, CO, lattice_size_x, lattice_size_y);
 212
 213
 214          }
 215          else
 216          {
 217                 std::cout << "sth wrong with input file reading" << std::endl;
 218          };
 219
 220         return 0;
 221 }
 222