source: util/src/ReadSrcIon.c@ ef87ee

/*
   Project: CP
   Jan Hamaekers
   1999

   File: CreateH2.c
   
*/
/*$Id: ReadSrcIon.c,v 1.2 2007-09-03 16:28:58 heber Exp $*/

#include<stdlib.h>
#include<stdio.h> 
#include<math.h>
#include<string.h>

#include "version.h"

#define NDIM (3)
#define NDIM_NDIM (NDIM*NDIM)

#define MAXDUMMYSTRING (199)

/* Verschiedene Fehlertypen */
enum Errors { SomeError, FileOpenParams, InitReading, MallocError};
/* SomeError: Falls man noch zu faul ist */

/* Behandelt aufgetretene Fehler. error ist der Fehlertyp(enum Errors)
   void *SpecialData ist ein untypisierter Zeiger auf Spezielle Daten zur Fehlerbehandlung.
   Man koennte auch noch einen Zeiger auf eine Funktion uebergeben */
void Error(enum Errors error, const void *SpecialData);


/* Behandelt aufgetretene Fehler. error ist der Fehlertyp(enum Errors)
   void *SpecialData ist ein untypisierter Zeiger auf Spezielle Daten zur Fehlerbehandlung.
   Man koennte auch noch einen Zeiger auf eine Funktion uebergeben */
void Error(enum Errors error, const void *SpecialData)
{
  const char *const error_msg[] = {
    "SomeError",
    "FileOpenParams\nUnable to open parameter file",
    "InitReading\nUnable to interpret the parameter file",
    "MallocError\nUnable to allocate memory!"
  };
  fprintf(stderr, "It has occured an error (%i): %s\n", error, error_msg[error]);
  switch (error) {
  case SomeError:
  case MallocError:
    if (SpecialData) fprintf(stderr, "%s\n", (const char*)SpecialData);
    break;
  default:
    break;
  }

  exit(EXIT_FAILURE); /* exit schreibt sowieso alle Dateipuffer aus */
}

/* Eigene malloc, die bei einem Fehler an Error output uebergibt.
 */
void* Malloc(size_t size, const char* output)
{
  void* dummy = malloc(size);
  if (!dummy)
    Error(MallocError, output);
  return dummy;
}

/* Eigene malloc, die bei einem Fehler erzeugten (ein int rein) output  an Error uebergibt */
void* Malloci(size_t size, const char* output, int i)
{
  char dummyoutput[MAXDUMMYSTRING];
  void* dummy = malloc(size);
  if (!dummy) {
    sprintf(dummyoutput,output,i);
    Error(MallocError, dummyoutput);
  }
  return dummy;
}

/* Eigene malloc, die bei einem Fehler erzeugten (zwei int rein) output  an Error uebergibt */
void* Mallocii(size_t size, const char* output, int i, int j)
{
  char dummyoutput[MAXDUMMYSTRING];
  void* dummy = malloc(size);
  if (!dummy) {
    sprintf(dummyoutput,output,i,j);
    Error(MallocError, dummyoutput);
  }
  return dummy;
}

void* Realloc(void* pointer, size_t size, const char* output)
{
  void *dummy = realloc(pointer, size);
  if (!dummy)
    Error(MallocError, output);
  return dummy;
}

void* Realloci(void* pointer, size_t size, const char* output, int i)
{
  char dummyoutput[MAXDUMMYSTRING];
  void *dummy = realloc(pointer, size);
  if (!dummy) {
    sprintf(dummyoutput, output, i);
    Error(MallocError, dummyoutput);
  }
  return dummy;
}

void* Reallocii(void* pointer, size_t size, const char* output, int i, int j)
{
  char dummyoutput[MAXDUMMYSTRING];
  void *dummy = realloc(pointer, size);
  if (!dummy) {
    sprintf(dummyoutput,output,i,j);
    Error(MallocError, dummyoutput);
  }
  return dummy;
}

void Free (void *ptr) {
  if (ptr) free(ptr);
}

int OpenFile(FILE** file, const char* suffix, const char* what)
{
  char* name; /* Zu erzeugender Dateiname */
  name = (char*)
    Malloc(3 + strlen(suffix) + 1,"OpenFile");
  sprintf(name, "pcp%s", suffix);
  *file = fopen(name, what);
  if (*file == 0) {
    fprintf(stderr,"\nError: Cannot open file: %s\n",name);
    Free(name);
    return(0);
  } else {
    fprintf(stderr,"File is open: %s\n",name);
    Free(name);
    return(1);
  }
}

static const char suffixsrciondoc[] = ".srcion.doc";
static const char suffixsrciondat[] = ".srcion.data";

int main(int argc, char** argv) {
  double data[2*NDIM];
  int is,ia,i;
  int Max_Types;
  int *Max_IonsOfType;
  double RealBasis[NDIM_NDIM];
  FILE *SrcIonDoc, *SrcIonData;
  
  fprintf(stdout, "%s\n", ESPACKVersion);

  OpenFile(&SrcIonDoc, suffixsrciondoc, "r");
  if (fscanf(SrcIonDoc,"%i", &Max_Types) != 1)
    Error(SomeError, "ReadSrcIons: read error");
  fprintf(stdout, "Max_Types:\t%i\n",Max_Types);
  Max_IonsOfType = Malloc(Max_Types*sizeof(int), "ReadSrcIons: Max_IonsOfType");
  for (is=0; is < Max_Types; is++) {
    if (fscanf(SrcIonDoc,"%i", &Max_IonsOfType[is]) != 1)
      Error(SomeError, "ReadSrcIons: read error");
    fprintf(stdout, "Max_IonsOfType[%i]:\t%i\n",is,Max_IonsOfType[is]);
  }
  fclose(SrcIonDoc);
  
  OpenFile(&SrcIonData, suffixsrciondat, "rb");
  if (fread(RealBasis, sizeof(double), (size_t)(NDIM_NDIM), SrcIonData) != NDIM_NDIM)
    Error(SomeError, "ReadSrcIons: read error");
  for (i=0; i < NDIM_NDIM; i++)
    fprintf(stdout, "RealBasis[%i] = %e\n", i, RealBasis[i]);
  for (is=0; is < Max_Types; is++) {
    for (ia=0; ia < Max_IonsOfType[is]; ia++) {
      if (fread(&data, sizeof(double), (size_t)(2*NDIM), SrcIonData) != 2*NDIM)
        Error(SomeError, "ReadSrcIons: read error");
      fprintf(stdout,"%i\t%i\t%e\t%e\t%e\t%e\t%e\t%e\n",is,ia,data[0],data[1],data[2],data[3],data[4],data[5]);
    }
  }
  fclose(SrcIonData);
  Free(Max_IonsOfType);
  return(0);
}