scan.c

This document explains the basic algorithms and functions which are used to read in data from RHF Tables atom files and to store the values in the atom data structure.

Comments

The code is straight forward.

orbital_type_ptr XAInsertR(orbital_type_ptr start, int shell_value, char orbital, int r, float r_value)

inserts the R values, e.g. <R>, <1/R> etc., into the atom data structure.

The while loop, #1, looks for the orbital symbol in the atom structure. If the symbol is not found, #2, memory for a new orbital structure is allocated and the values are stored there. Otherwise, #3, the values are written into the existing orbital structure. The following while loop, #4, examines the shell pointers to look for a shell which has the same number as shell_value. If this one is not found, #5, a pointer to a new shell is created. Finally the R values can be stored.

orbital_type_ptr XAInsertData(orbital_type_ptr start, int shell_value, char orbital, int n_value, float alpha_value, float data)

stores the values of the data section of an atom data file into the atom structure.

This procedure works like XAInsertR which is mentioned above: if orbitals, shells or data blocks do not exist, new ones are created whereas existing ones are updated.

atom_ptr XAScan(char *filename)

XAScan opens the RHF Table file filenname and tries to read in the different atom data values. By extracting the values XAScan looks for certain keywords and stores the following data by calling the procedures XAInsertR and XAInsertData.

• #6
  The while loop is executed until a line with text is found. Therefore empty lines are neglected.

• #7
  XAScan looks for the atom name in the atom data file. The atom name has to be the first string of a line and should be in the first line of the file.

• #8
  The remaining items of the first data line are read in. The variable number_electrons is set to the integer value which comes after a preceding "Z", base to the string which consists of two characters and electron_configuration to the string whose last character is a right bracket.

• #9
  The second data section, i.e. the energy values, is examined till the header of the data section is found. The condition for this header is a line element consisting of an integer value combined with a character, e.g. 1S. Normally the line is directly above the R Values block.

  In the inner while loop XAScan looks for the key words TOTAL, KINETIC, POTENTIAL, VIRIAL, RHOAT0 and KATO to create a second string which contains the order of these keywords. This string is build up by the first letter of each word. After that the float values, which are just mentioned in the next line, can be stored into the right atom structure position. The start of the "values line" is found if the first character of parse_token_pointer is a digit or a minus sign.

• #10
  After having finished with the second data section the main block which stores the alpha-, constant- and n-values is examined. The variable parse_token_pointer already contains the header line of the third section. If not, an error code will be printed out soon afterwards.

• #11
  The table header line, which precedes the R-values table or the data table, is analyzed and the variable system_string is very created. system_string stores the order of the orbitals in a simple string structure, e.g "||1S2S3S||2P3P" which says that there are two n- and two alpha-columns (i.e. "||" where the first "|" stands for the "n-column" and the second one for the "alpha-column") and five different c-data columns (orbital names).

  Note
  The data block table and R Value table, both stored in the third data section, have to be separated by one or more empty lines.

• #12
  The R Values are scanned. If a token which consists of an integer part and a character e.g. 1S is found, then the first line of the data block table is reached.

  The analysis of the R table has to cope with some irregularities. At #13 the starting point of P- or D-orbitals in system_string has to be searched, because these got one R Value more than S-orbitals. Therefore, in mixed data tables which store S- and P-orbital values this additional line has to be treated separately. The second i-- just "moves" the "string position pointer" i to the first "|" of the "||" element.

  In line #14 the problem of some R tables is solved that two or more negative values may not be separated by a space. Unfortunately this has to be done by a tricky command structure, which should be examined more carefully when changes are necessary (in general, the different R values are going to be separated by a "#" character and inserted into the atom data structure shortly afterwards).

• #15
  If a single newline character is found then the scan of a data section has finished. Otherwise, according to the given letter stored in system_string, the n-, alpha- or c-data values are added to the atom structure.

• #16
  This if branch reads in the n- and alpha-columns, whereas ...

• #17
  ... is responsible for the constant-columns and stores n-, alpha- and constant-values in the atom data structure.

• #18
  If the EOF flag is found the analysis is finished. Otherwise more data section lines have to be "scanned".