load_db.c

Go to the documentation of this file.

/* src/load_db.c
 *
 * Copyright (C) 2011-2018 Dongdong Li
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundataion; 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
 * MERCHANTABLITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
 */

/* load gas phases */
static bool load_gas_phases (FILE *temp_fp)
{
  int species_num;
  int i;
  int rv;

  for (i = 0; i < gas_phase_num; i++)
    {
      rv = fscanf (temp_fp, "%s\t%d\n", phase_keyword, &species_num);

      if (rv != 2) 
    {
      printf ("ERROR: load_db.c: load_gas_phases () load gas phase ");
      printf ("error (phase keyword and species number).\n");
      return false;
    }

      // Gas Phase
      if (strcmp(phase_keyword, PHASE_KEYWORDS[0]) == 0)
    {
      phases.gas[i].species_num = species_num;

      phases.gas[i].gas_species = (SPECIES *)malloc (sizeof (SPECIES) * phases.gas[i].species_num);

      int j;
      for (j = 0; j < phases.gas[i].species_num; j ++)
        {
          rv = fscanf (temp_fp, "%s\t%d\n", phases.gas[i].gas_species[j].species_symbol, 
               &phases.gas[i].gas_species[j].charge);

          if (rv != 2) 
        {
          printf ("ERROR: load_db.c: load_gas_phases () load gas phase ");
          printf ("error (species symbol and species charge).\n");
          return false;
        }

          phases.gas[i].gas_species[j].elements = (double *)malloc (sizeof (double) * total_comp_num);
          
          char compi;
          char *cbuf = (char*)malloc(32*sizeof(char));
          memset(cbuf, 0, 32); // initialize memory

          int k = 0, l = 0;
          while ((compi = fgetc (temp_fp)) != '\n')
        {
          if (compi != '\t' && compi != ' ')
            {
              cbuf[k] = compi;
              k++;
            }
          else
            {
              phases.gas[i].gas_species[j].elements[l] = atof (cbuf);
              free (cbuf);

              cbuf = (char*)malloc(32*sizeof(char));
              memset(cbuf, 0, 32); // initialize memory

              k = 0;
              l ++;
            }
        }

          phases.gas[i].gas_species[j].elements[l] = atof (cbuf); // set the last column
          free (cbuf);

          rv = fscanf (temp_fp, "%lf\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\n", 
               &phases.gas[i].gas_species[j].thermo_coeff[0], 
               &phases.gas[i].gas_species[j].thermo_coeff[1],
               &phases.gas[i].gas_species[j].thermo_coeff[2],
               &phases.gas[i].gas_species[j].thermo_coeff[3],
               &phases.gas[i].gas_species[j].thermo_coeff[4],
               &phases.gas[i].gas_species[j].thermo_coeff[5],
               &phases.gas[i].gas_species[j].thermo_coeff[6]);
          if (rv != 7) 
        {
          printf ("ERROR: load_db.c: load_gas_phases () load gas phase ");
          printf ("error (species standard state thermodynamic parameters).\n");
          return false;
        }
        }
    }
      else
    {
      printf ("ERROR: load_db.c: load_gas_phases () load gas phase ");
      printf ("error (invalid gas phase keyword, valid keyword is 'GAS').\n");
      return false;
    }
    }

  return true;
}

/* load aqueous phases */
static bool load_aqueous_phases (FILE *temp_fp)
{
  int species_num; // aqueous species number
  int i;
  int rv;

  for (i = 0; i < aqueous_phase_num; i++)
    {
      rv = fscanf (temp_fp, "%s\t%d\n", phase_keyword, &species_num);

      if (rv != 2) 
    {
      printf ("ERROR: load_db.c: load_aqueous_phases () load aqueous phase ");
      printf ("error (phase keyword and species number).\n");
      return false;
    }

      // Aqueous Phase
      if (strcmp(phase_keyword, PHASE_KEYWORDS[1]) == 0)
    {
      phases.aqueous[i].species_num = species_num;

      phases.aqueous[i].aqueous_species = (SPECIES *)malloc (sizeof (SPECIES) * phases.aqueous[i].species_num);

      int j;
      for (j = 0; j < phases.aqueous[i].species_num; j ++)
        {
          rv = fscanf (temp_fp, "%s\t%d\n", phases.aqueous[i].aqueous_species[j].species_symbol, 
               &phases.aqueous[i].aqueous_species[j].charge);

          if (rv != 2) 
        {
          printf ("ERROR: load_db.c: load_aqueous_phases () load aqueous phase ");
          printf ("error (species symbol and species charge).\n");
          return false;
        }

          phases.aqueous[i].aqueous_species[j].elements = (double *)malloc (sizeof (double) * total_comp_num);
          
          char compi;
          char *cbuf = (char*)malloc(32*sizeof(char));
          memset(cbuf, 0, 32); // initialize memory

          int k = 0, l = 0;
          while ((compi = fgetc (temp_fp)) != '\n')
        {
          if (compi != '\t' && compi != ' ')
            {
              cbuf[k] = compi;
              k++;
            }
          else
            {
              phases.aqueous[i].aqueous_species[j].elements[l] = atof (cbuf);
              free (cbuf);

              cbuf = (char*)malloc(32*sizeof(char));
              memset(cbuf, 0, 32); // initialize memory

              k = 0;
              l ++;
            }
        }

          phases.aqueous[i].aqueous_species[j].elements[l] = atof (cbuf); // set the last column 
          free (cbuf);

          rv = fscanf (temp_fp, "%lf\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\n", 
               &phases.aqueous[i].aqueous_species[j].thermo_coeff[0], 
               &phases.aqueous[i].aqueous_species[j].thermo_coeff[1],
               &phases.aqueous[i].aqueous_species[j].thermo_coeff[2],
               &phases.aqueous[i].aqueous_species[j].thermo_coeff[3],
               &phases.aqueous[i].aqueous_species[j].thermo_coeff[4],
               &phases.aqueous[i].aqueous_species[j].thermo_coeff[5],
               &phases.aqueous[i].aqueous_species[j].thermo_coeff[6]);
          if (rv != 7) 
        {
          printf ("ERROR: load_db.c: load_aqueous_phases () load aqueous phase ");
          printf ("error (species standard state thermodynamic parameters).\n");
          return false;
        }
        }

      // loading binary parameters
      // cation-anion binary parameters
      rv = fscanf (temp_fp, "%d\n", &phases.aqueous[i].ii_bin_param_num);
      if (rv != 1) 
        {
          printf ("ERROR: load_db.c: load_aqueous_phases () load aqueous phase error (cation-anion parameters).\n");
          return false;
        }

      phases.aqueous[i].ii_bin_params = (IIBINPARAM *)malloc (sizeof (IIBINPARAM) * 
                                  phases.aqueous[i].ii_bin_param_num);

      for (j = 0; j < phases.aqueous[i].ii_bin_param_num; j ++)
        {
          rv = fscanf (temp_fp, "%s\t%s\t%lf\t%lf\n", 
               phases.aqueous[i].ii_bin_params[j].species_s1, 
               phases.aqueous[i].ii_bin_params[j].species_s2,
               &phases.aqueous[i].ii_bin_params[j].alpha,
               &phases.aqueous[i].ii_bin_params[j].alpha1);
          if (rv != 4) 
        {
          printf ("Load Databank Error (cation-anion)!!!\n");
          exit (1);
        }

          rv = fscanf (temp_fp, "%lf\t%lf\t%lf\t%lf\t%lf\t%lf\n", 
               &phases.aqueous[i].ii_bin_params[j].B0ss[0], 
               &phases.aqueous[i].ii_bin_params[j].B0ss[1], 
               &phases.aqueous[i].ii_bin_params[j].B0ss[2], 
               &phases.aqueous[i].ii_bin_params[j].B0ss[3], 
               &phases.aqueous[i].ii_bin_params[j].B0ss[4], 
               &phases.aqueous[i].ii_bin_params[j].B0ss[5]);
          if (rv != 6) 
        {
          printf ("Load Databank Error (cation-anion)!!!\n");
          exit (1);
        }

          rv = fscanf (temp_fp, "%lf\t%lf\t%lf\t%lf\t%lf\t%lf\n", 
               &phases.aqueous[i].ii_bin_params[j].B1ss[0], 
               &phases.aqueous[i].ii_bin_params[j].B1ss[1], 
               &phases.aqueous[i].ii_bin_params[j].B1ss[2], 
               &phases.aqueous[i].ii_bin_params[j].B1ss[3], 
               &phases.aqueous[i].ii_bin_params[j].B1ss[4], 
               &phases.aqueous[i].ii_bin_params[j].B1ss[5]);
          if (rv != 6) 
        {
          printf ("Load Databank Error (cation-anion)!!!\n");
          exit (1);
        }
        }

      // neutral-neutral binary parameters
      rv = fscanf (temp_fp, "%d\n", &phases.aqueous[i].nn_bin_param_num);
      if (rv != 1) 
        {
          printf ("Load Databank Error (neutral-neutral)!!!\n");
          exit (1);
        }

      phases.aqueous[i].nn_bin_params = (NNBINPARAM *)malloc (sizeof (NNBINPARAM) * 
                                  phases.aqueous[i].nn_bin_param_num);

      for (j = 0; j < phases.aqueous[i].nn_bin_param_num; j ++)
        {
          rv = fscanf (temp_fp, "%s\t%s\n", 
               phases.aqueous[i].nn_bin_params[j].species_s1, 
               phases.aqueous[i].nn_bin_params[j].species_s2);
          if (rv != 2) 
        {
          printf ("Load Databank Error (neutral-neutral)!!!\n");
          exit (1);
        }

          rv = fscanf (temp_fp, "%lf\t%lf\t%lf\t%lf\t%lf\t%lf\n", 
               &phases.aqueous[i].nn_bin_params[j].Wss[0], 
               &phases.aqueous[i].nn_bin_params[j].Wss[1], 
               &phases.aqueous[i].nn_bin_params[j].Wss[2], 
               &phases.aqueous[i].nn_bin_params[j].Wss[3], 
               &phases.aqueous[i].nn_bin_params[j].Wss[4], 
               &phases.aqueous[i].nn_bin_params[j].Wss[5]);
          if (rv != 6) 
        {
          printf ("Load Databank Error (neutral-neutral)!!!\n");
          exit (1);
        }

          rv = fscanf (temp_fp, "%lf\t%lf\t%lf\t%lf\t%lf\t%lf\n", 
               &phases.aqueous[i].nn_bin_params[j].Uss[0], 
               &phases.aqueous[i].nn_bin_params[j].Uss[1], 
               &phases.aqueous[i].nn_bin_params[j].Uss[2], 
               &phases.aqueous[i].nn_bin_params[j].Uss[3], 
               &phases.aqueous[i].nn_bin_params[j].Uss[4], 
               &phases.aqueous[i].nn_bin_params[j].Uss[5]);
          if (rv != 6) 
        {
          printf ("Load Databank Error (neutral-neutral)!!!\n");
          exit (1);
        }
        }

      // neutral-cation-anion ternary parameters
      rv = fscanf (temp_fp, "%d\n", &phases.aqueous[i].nii_ter_param_num);
      if (rv != 1) 
        {
          printf ("Load Databank Error (neutral-cation-anion)!!!\n");
          exit (1);
        }

      phases.aqueous[i].nii_ter_params = (NIITERPARAM *)malloc (sizeof (NIITERPARAM) * 
                                    phases.aqueous[i].nii_ter_param_num);

      for (j = 0; j < phases.aqueous[i].nii_ter_param_num; j ++)
        {
          rv = fscanf (temp_fp, "%s\t%s\t%s\n", 
               phases.aqueous[i].nii_ter_params[j].species_s1, 
               phases.aqueous[i].nii_ter_params[j].species_s2, 
               phases.aqueous[i].nii_ter_params[j].species_s3);
          if (rv != 3) 
        {
          printf ("Load Databank Error (neutral-cation-anion)!!!\n");
          exit (1);
        }

          rv = fscanf (temp_fp, "%lf\t%lf\t%lf\t%lf\t%lf\t%lf\n", 
               &phases.aqueous[i].nii_ter_params[j].Wsss[0], 
               &phases.aqueous[i].nii_ter_params[j].Wsss[1], 
               &phases.aqueous[i].nii_ter_params[j].Wsss[2], 
               &phases.aqueous[i].nii_ter_params[j].Wsss[3], 
               &phases.aqueous[i].nii_ter_params[j].Wsss[4], 
               &phases.aqueous[i].nii_ter_params[j].Wsss[5]);
          if (rv != 6) 
        {
          printf ("Load Databank Error (neutral-cation-anion)!!!\n");
          exit (1);
        }

          rv = fscanf (temp_fp, "%lf\t%lf\t%lf\t%lf\t%lf\t%lf\n", 
               &phases.aqueous[i].nii_ter_params[j].Usss[0], 
               &phases.aqueous[i].nii_ter_params[j].Usss[1], 
               &phases.aqueous[i].nii_ter_params[j].Usss[2], 
               &phases.aqueous[i].nii_ter_params[j].Usss[3], 
               &phases.aqueous[i].nii_ter_params[j].Usss[4], 
               &phases.aqueous[i].nii_ter_params[j].Usss[5]);
          if (rv != 6) 
        {
          printf ("Load Databank Error (neutral-cation-anion)!!!\n");
          exit (1);
        }

          rv = fscanf (temp_fp, "%lf\t%lf\t%lf\t%lf\t%lf\t%lf\n", 
               &phases.aqueous[i].nii_ter_params[j].Vsss[0], 
               &phases.aqueous[i].nii_ter_params[j].Vsss[1], 
               &phases.aqueous[i].nii_ter_params[j].Vsss[2], 
               &phases.aqueous[i].nii_ter_params[j].Vsss[3], 
               &phases.aqueous[i].nii_ter_params[j].Vsss[4], 
               &phases.aqueous[i].nii_ter_params[j].Vsss[5]);
          if (rv != 6) 
        {
          printf ("Load Databank Error (neutral-cation-anion)!!!\n");
          exit (1);
        }
        }

      // cation-cation-anion or cation-anion-anion ternary parameters
      rv = fscanf (temp_fp, "%d\n", &phases.aqueous[i].iii_ter_param_num);
      if (rv != 1) 
        {
          printf ("Load Databank Error (cation-cation-anion or cation-anion-anion)!!!\n");
          exit (1);
        }

      phases.aqueous[i].iii_ter_params = (IIITERPARAM *)malloc (sizeof (IIITERPARAM) * 
                                    phases.aqueous[i].iii_ter_param_num);

      for (j = 0; j < phases.aqueous[i].iii_ter_param_num; j ++)
        {
          rv = fscanf (temp_fp, "%s\t%s\t%s\n", 
               phases.aqueous[i].iii_ter_params[j].species_s1, 
               phases.aqueous[i].iii_ter_params[j].species_s2, 
               phases.aqueous[i].iii_ter_params[j].species_s3);
          if (rv != 3) 
        {
          printf ("Load Databank Error (cation-cation-anion or cation-anion-anion)!!!\n");
          exit (1);
        }

          rv = fscanf (temp_fp, "%lf\t%lf\t%lf\t%lf\t%lf\t%lf\n", 
               &phases.aqueous[i].iii_ter_params[j].Wsss[0], 
               &phases.aqueous[i].iii_ter_params[j].Wsss[1], 
               &phases.aqueous[i].iii_ter_params[j].Wsss[2], 
               &phases.aqueous[i].iii_ter_params[j].Wsss[3], 
               &phases.aqueous[i].iii_ter_params[j].Wsss[4], 
               &phases.aqueous[i].iii_ter_params[j].Wsss[5]);
          if (rv != 6) 
        {
          printf ("Load Databank Error (cation-cation-anion or cation-anion-anion)!!!\n");
          exit (1);
        }
        }

      // neutral-cation-cation-anion or neutral-cation-anion-anion quaternary parameters
      rv = fscanf (temp_fp, "%d\n", &phases.aqueous[i].niii_qua_param_num);
      if (rv != 1) 
        {
          printf ("Load Databank Error (neutral-cation-cation-anion or neutral-cation-anion-anion)!!!\n");
          exit (1);
        }

      phases.aqueous[i].niii_qua_params = (NIIIQUAPARAM *)malloc (sizeof (NIIIQUAPARAM) * 
                                      phases.aqueous[i].niii_qua_param_num);

      for (j = 0; j < phases.aqueous[i].niii_qua_param_num; j ++)
        {
          rv = fscanf (temp_fp, "%s\t%s\t%s\t%s\n", 
               phases.aqueous[i].niii_qua_params[j].species_s1, 
               phases.aqueous[i].niii_qua_params[j].species_s2, 
               phases.aqueous[i].niii_qua_params[j].species_s3, 
               phases.aqueous[i].niii_qua_params[j].species_s4);
          if (rv != 4)
        {
          printf ("Load Databank Error (neutral-cation-cation-anion or neutral-cation-anion-anion)!!!\n");
          exit (1);
        }

          rv = fscanf (temp_fp, "%lf\t%lf\t%lf\t%lf\t%lf\t%lf\n", 
               &phases.aqueous[i].niii_qua_params[j].Qssss[0], 
               &phases.aqueous[i].niii_qua_params[j].Qssss[1], 
               &phases.aqueous[i].niii_qua_params[j].Qssss[2], 
               &phases.aqueous[i].niii_qua_params[j].Qssss[3], 
               &phases.aqueous[i].niii_qua_params[j].Qssss[4], 
               &phases.aqueous[i].niii_qua_params[j].Qssss[5]);
          if (rv != 6) 
        {
          printf ("Load Databank Error (neutral-cation-cation-anion or neutral-cation-anion-anion)!!!\n");
          exit (1);
        }

          rv = fscanf (temp_fp, "%lf\t%lf\t%lf\t%lf\t%lf\t%lf\n", 
               &phases.aqueous[i].niii_qua_params[j].Yssss[0], 
               &phases.aqueous[i].niii_qua_params[j].Yssss[1], 
               &phases.aqueous[i].niii_qua_params[j].Yssss[2], 
               &phases.aqueous[i].niii_qua_params[j].Yssss[3], 
               &phases.aqueous[i].niii_qua_params[j].Yssss[4], 
               &phases.aqueous[i].niii_qua_params[j].Yssss[5]);
          if (rv != 6) 
        {
          printf ("Load Databank Error (neutral-cation-cation-anion or neutral-cation-anion-anion)!!!\n");
          exit (1);
        }
        }

      // neutral-neutral-cation-anion quaternary parameters
      rv = fscanf (temp_fp, "%d\n", &phases.aqueous[i].nnii_qua_param_num);
      if (rv != 1) 
        {
          printf ("Load Databank Error (neutral-cation-cation-anion or neutral-cation-anion-anion)!!!\n");
          exit (1);
        }

      phases.aqueous[i].nnii_qua_params = (NNIIQUAPARAM *)malloc (sizeof (NNIIQUAPARAM) * 
                                      phases.aqueous[i].nnii_qua_param_num);

      for (j = 0; j < phases.aqueous[i].nnii_qua_param_num; j ++)
        {
          rv = fscanf (temp_fp, "%s\t%s\t%s\t%s\n", 
               phases.aqueous[i].nnii_qua_params[j].species_s1, 
               phases.aqueous[i].nnii_qua_params[j].species_s2, 
               phases.aqueous[i].nnii_qua_params[j].species_s3, 
               phases.aqueous[i].nnii_qua_params[j].species_s4);
          if (rv != 4)
        {
          printf ("Load Databank Error (neutral-cation-cation-anion or neutral-cation-anion-anion)!!!\n");
          exit (1);
        }

          rv = fscanf (temp_fp, "%lf\t%lf\t%lf\t%lf\t%lf\t%lf\n", 
               &phases.aqueous[i].nnii_qua_params[j].Yssss[0], 
               &phases.aqueous[i].nnii_qua_params[j].Yssss[1], 
               &phases.aqueous[i].nnii_qua_params[j].Yssss[2], 
               &phases.aqueous[i].nnii_qua_params[j].Yssss[3], 
               &phases.aqueous[i].nnii_qua_params[j].Yssss[4], 
               &phases.aqueous[i].nnii_qua_params[j].Yssss[5]);
          if (rv != 6) 
        {
          printf ("Load Databank Error (neutral-cation-cation-anion or neutral-cation-anion-anion)!!!\n");
          exit (1);
        }
        }
    }
      else
    {
      printf ("load_db.c: load_aqueous_phases () load aqueous phase ");
      printf ("error (invalid aqueous phase keyword, valid keyword is 'LIQUID').\n");
      return false;
    }
    }

  return true;
}

static void load_solid_phases (FILE *temp_fp)
{
  int species_num;
  int i;
  int rv;

  for (i = 0; i < solid_phase_num; i++)
    {
      rv = fscanf (temp_fp, "%s\t%d\n", phase_keyword, &species_num);

      if (rv != 2) 
    {
      printf ("Load Databank Error!!!\n");
      exit (1);
    }

      // Solid Phase
      if (strcmp(phase_keyword, PHASE_KEYWORDS[2]) == 0)
    {
      phases.solids[i].species_num = species_num;

      phases.solids[i].solid_species = (SPECIES *)malloc (sizeof (SPECIES) * phases.solids[i].species_num);

      int j;
      for (j = 0; j < phases.solids[i].species_num; j ++)
        {
          rv = fscanf (temp_fp, "%s\t%d\n", phases.solids[i].solid_species[j].species_symbol, 
               &phases.solids[i].solid_species[j].charge);

          if (rv != 2) 
        {
          printf ("Load Databank Error!!!\n");
          exit (1);
        }

          phases.solids[i].solid_species[j].elements = (double *)malloc (sizeof (double) * total_comp_num);
          
          char compi;
          char *cbuf = (char*)malloc(32*sizeof(char));
          memset(cbuf, 0, 32); // initialize memory

          int k = 0, l = 0;
          while ((compi = fgetc (temp_fp)) != '\n')
        {
          if (compi != '\t' && compi != ' ')
            {
              cbuf[k] = compi;
              k++;
            }
          else
            {
              phases.solids[i].solid_species[j].elements[l] = atof (cbuf);
              free (cbuf);

              cbuf = (char*)malloc(32*sizeof(char));
              memset(cbuf, 0, 32); // initialize memory

              k = 0;
              l ++;
            }
        }

          phases.solids[i].solid_species[j].elements[l] = atof (cbuf); // set the last column 
          free (cbuf);

          rv = fscanf (temp_fp, "%lf\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\n", 
               &phases.solids[i].solid_species[j].thermo_coeff[0], 
               &phases.solids[i].solid_species[j].thermo_coeff[1],
               &phases.solids[i].solid_species[j].thermo_coeff[2],
               &phases.solids[i].solid_species[j].thermo_coeff[3],
               &phases.solids[i].solid_species[j].thermo_coeff[4],
               &phases.solids[i].solid_species[j].thermo_coeff[5],
               &phases.solids[i].solid_species[j].thermo_coeff[6]);
          if (rv != 7) 
        {
          printf ("Load Databank Error!!!\n");
          exit (1);
        }
        }

    }
      else
    {
      printf ("Invalid Keyword!!!\n");
      exit (1);
    }
    }
}

static void load_solidsolution_phases (FILE *temp_fp)
{
  int species_num;
  int i;
  int rv;

  for (i = 0; i < solidsolution_phase_num; i++)
    {
      rv = fscanf (temp_fp, "%s\t%d\n", phase_keyword, &species_num);

      if (rv != 2) 
    {
      printf ("Load Databank Error!!!\n");
      exit (1);
    }

      // Binary Solid Solution Phase
      if (strcmp(phase_keyword, PHASE_KEYWORDS[3]) == 0)
    {
      phases.solidsolution[i].species_num = species_num;

      phases.solidsolution[i].solidsolution_species = 
        (SPECIES *)malloc (sizeof (SPECIES) * phases.solidsolution[i].species_num);

      int j;
      for (j = 0; j < phases.solidsolution[i].species_num; j ++)
        {
          rv = fscanf (temp_fp, "%s\t%d\n", phases.solidsolution[i].solidsolution_species[j].species_symbol, 
               &phases.solidsolution[i].solidsolution_species[j].charge);

          if (rv != 2) 
        {
          printf ("Load Databank Error!!!\n");
          exit (1);
        }

          phases.solidsolution[i].solidsolution_species[j].elements = 
        (double *)malloc (sizeof (double) * total_comp_num);
          
          char compi;
          char *cbuf = (char*)malloc(32*sizeof(char));
          memset(cbuf, 0, 32); // initialize memory

          int k = 0, l = 0;
          while ((compi = fgetc (temp_fp)) != '\n')
        {
          if (compi != '\t' && compi != ' ')
            {
              cbuf[k] = compi;
              k++;
            }
          else
            {
              phases.solidsolution[i].solidsolution_species[j].elements[l] = atof (cbuf);
              free (cbuf);

              cbuf = (char*)malloc(32*sizeof(char));
              memset(cbuf, 0, 32); // initialize memory

              k = 0;
              l ++;
            }
        }

          phases.solidsolution[i].solidsolution_species[j].elements[l] = atof (cbuf); // set the last column 
          free (cbuf);

          rv = fscanf (temp_fp, "%lf\t%lf\t%lf\t%lf\t%lf\t%lf\t%lf\n", 
               &phases.solidsolution[i].solidsolution_species[j].thermo_coeff[0], 
               &phases.solidsolution[i].solidsolution_species[j].thermo_coeff[1],
               &phases.solidsolution[i].solidsolution_species[j].thermo_coeff[2],
               &phases.solidsolution[i].solidsolution_species[j].thermo_coeff[3],
               &phases.solidsolution[i].solidsolution_species[j].thermo_coeff[4],
               &phases.solidsolution[i].solidsolution_species[j].thermo_coeff[5],
               &phases.solidsolution[i].solidsolution_species[j].thermo_coeff[6]);
          if (rv != 7) 
        {
          printf ("Load Databank Error!!!\n");
          exit (1);
        }
        }

      rv = fscanf (temp_fp, "%d\n", &phases.solidsolution[i].param_num);
      if (rv != 1) 
        {
          printf ("Load Databank Error!!!\n");
          exit (1);
        }
                
      phases.solidsolution[i].params = (SUBRPARAM *)malloc (sizeof (SUBRPARAM) * 
                                phases.solidsolution[i].param_num);

      for (j = 0; j < phases.solidsolution[i].param_num; j++)
        {
          rv = fscanf (temp_fp, "%s\t%s\t%lf\t%lf\n", 
               phases.solidsolution[i].params[j].species_a, 
               phases.solidsolution[i].params[j].species_b,
               &phases.solidsolution[i].params[j].A0,
               &phases.solidsolution[i].params[j].A1);
          if (rv != 4) 
        {
          printf ("Load Databank Error!!!\n");
          exit (1);
        }
        }
    }
      else
    {
      printf ("Invalid Keyword!!!\n");
      exit (1);
    }
    }
}

extern bool load_db (char *input, char *temp)
{
  FILE *temp_fp;

  clear_comments (input, temp);

  if ((temp_fp = fopen (temp, "r")) == NULL)
    {
      printf ("ERROR: load_db.c: load_db () open temporary file error.\n ");
      return false;
    }
  else
    {
      int rv;

      /* start to load components block */
      rv = fscanf (temp_fp, "%s\t%d\n", block_keyword, &total_comp_num);

      if (rv != 2) 
    {
      printf ("ERROR: load_db.c: load_db () load components block ");
      printf ("error (block keyword and total components number).\n");
      return false;
    }

      if (strcmp(block_keyword, BLOCK_KEYWORDS[0]) == 0)
    {

      components = (ELEMENT *)malloc (sizeof (ELEMENT) * total_comp_num);

      int i;

      for (i = 0; i < total_comp_num; i++)
        {
          rv = fscanf (temp_fp, "%s\t%d\t%lf\n", components[i].element_symbol, 
               &components[i].element_number,
               &components[i].element_mass);

          if (rv != 3) 
        {
          printf ("ERROR: load_db.c: load_db () load components block ");
          printf ("error (element symbol, element number and element mass).\n");
          return false;
        }
        }
    }
      else
    {
      printf ("ERROR: load_db.c: load_db () load components block ");
      printf ("error (invalid components block keyword, valid is 'COMPONENTS').\n");
      return false;
    }
      // end to load components block

      // start to load phases block
      rv = fscanf (temp_fp, "%s\t%d\t%d\t%d\t%d\n", block_keyword, 
           &gas_phase_num, 
           &aqueous_phase_num, 
           &solid_phase_num,
           &solidsolution_phase_num);

      if (rv != 5) 
    {
      printf ("ERROR: load_db.c: load_db () load phases block ");
      printf ("error (block keyword and gase, liquid, solid, solid solution phases number).\n");
      return false;
    }

      if (strcmp(block_keyword, BLOCK_KEYWORDS[1]) == 0)
    {
      total_phase_num = gas_phase_num + aqueous_phase_num + solid_phase_num
        + solidsolution_phase_num;

      phases.gas = (GAS_PHASE *)malloc (sizeof (GAS_PHASE) * gas_phase_num);
      phases.aqueous = (AQUEOUS_PHASE *)malloc (sizeof (AQUEOUS_PHASE) * aqueous_phase_num);
      phases.solids = (SOLID_PHASE *)malloc (sizeof (SOLID_PHASE) * solid_phase_num);
      phases.solidsolution = (SOLIDSOLUTION_PHASE *)malloc (sizeof (SOLIDSOLUTION_PHASE) * solidsolution_phase_num);
    }
      else
    {
      printf ("ERROR: load_db.c: load_db () load phases block ");
      printf ("error (invalid phase block keyword, valid is 'PHASES').\n");
      return false;
    }

      /* start to load phases block */
      load_gas_phases (temp_fp);
      load_aqueous_phases (temp_fp);
      load_solid_phases (temp_fp);
      load_solidsolution_phases (temp_fp);
      /* end to load phases block */

    }

  total_species_num = 0;
  int i, j;
  
  for (i = 0; i < gas_phase_num; i ++)
    {
      total_species_num += phases.gas[i].species_num;
    }

  for (i = 0; i < aqueous_phase_num; i ++)
    {
      total_species_num += phases.aqueous[i].species_num;
    }

  for (i = 0; i < solid_phase_num; i ++)
    {
      total_species_num += phases.solids[i].species_num;
    }

  for (i = 0; i < solidsolution_phase_num; i ++)
    {
      total_species_num += phases.solidsolution[i].species_num;
    }

  fclose(temp_fp);
  remove (temp);

  return true;
}