#include <stdio.h>
#define FALSE 0
#define TRUE  1

FILE *MF1_FILE;
FILE *MF2_FILE;
FILE *CTM_FILE;

short int buf_out[2812], lbuf_out;

/*-------------------------------------------------------------------*/
/*                                                                   */
/*      open_maf1 opens a DE RIMS MAF1 file                          */
/*                                                                   */
/*-------------------------------------------------------------------*/

open_maf1 (ieof)
int *ieof;

{

   char maf1_file[80];

   int str_length;

   printf (" Enter MAF1 file name: ");
   scanf ("%s", maf1_file);
   str_length = strlen (maf1_file);
   *ieof = 0;
   if (str_length > 0)
   {
      if ((MF1_FILE = fopen(maf1_file, "r")) == NULL)
      {
         printf ("ERROR: cannot open %s\n", maf1_file);
         exit(0);
      }
   }
   else
   {
      *ieof = 1;
   }
}



/*-------------------------------------------------------------------*/
/*                                                                   */
/*      open_output opens the output file for copy_maf1              */
/*                                                                   */
/*-------------------------------------------------------------------*/

open_output (ieof)
int *ieof;

{

   char maf2_file[80];

   int str_length;

   printf (" Enter OUTPUT file name: ");
   scanf ("%s", maf2_file);
   str_length = strlen (maf2_file);
   *ieof = 0;
   if (str_length > 0)
   {
      if ((MF2_FILE = fopen(maf2_file, "wb")) == NULL)
      {
         printf ("ERROR: cannot open %s\n", maf2_file);
         exit(0);
      }
   }
   else
   {
      *ieof = 1;
   }
}



/*-------------------------------------------------------------------*/
/*                                                                   */
/*      open_ctm_out opens the output file for counts_time           */
/*                                                                   */
/*-------------------------------------------------------------------*/

open_ctm_out (ieof)
int *ieof;

{
   if ((CTM_FILE = fopen ("counts_time.dat", "w")) == NULL)
   {
      printf ("ERROR: cannot open output file: counts_time.dat");
      exit(0);
   }
}



/*-------------------------------------------------------------------*/
/*                                                                   */
/*      read_maf1 reads a DE RIMS MAF1 file                          */
/*                                                                   */
/*-------------------------------------------------------------------*/

read_maf1 (buf, lbuf, read_err)

short int buf[];
int       *lbuf, *read_err;

{

   register int    i, itime, lbuf1, lbuf2, nbytes;
   register char   tmp;
   union
   {
      char            c[2];
      short int       i;
   } num;

/*-------------------------------------------------------------------*/
/* initialize some variables                                         */
/*-------------------------------------------------------------------*/

   lbuf_out = *lbuf;
   lbuf1 = *lbuf;
   lbuf1 = lbuf1 - 1;
   lbuf2 = 0;
   *read_err = -1;

/*-------------------------------------------------------------------*/
/* read in first two bytes of this record                            */
/*-------------------------------------------------------------------*/

   for (i = 0; i < 2; ++i)
   {
      num.c[i] = getc(MF1_FILE);
   }

/*-------------------------------------------------------------------*/
/* read the rest of the record                                       */
/*-------------------------------------------------------------------*/

   nbytes = 0;
   if (feof(MF1_FILE) == FALSE)             /* if wasn't file end */
   {
      *read_err = 0;
      for (itime = 0; itime < lbuf1; ++itime)
      {
         buf_out[lbuf2] = num.i;         /* array used in write_maf1 */

         tmp = num.c[0];                /* swap the two bytes */
         num.c[0] = num.c[1];
         num.c[1] = tmp;

         buf[lbuf2++] = num.i;

         for (i = 0; i < 2; ++i)	       /* read in next 2 bytes*/
         {
            num.c[i] = getc(MF1_FILE);
         }
      }

      tmp = num.c[0];                   /* swap the last two bytes */
      num.c[0] = num.c[1];
      num.c[1] = tmp;

      buf_out[lbuf2] = num.i;
      buf[lbuf2] = num.i;

   }
   else
   {
      *read_err = -10;
   }

/*-------------------------------------------------------------------*/
/*-------------------------------------------------------------------*/

}



write_maf1 (write_err)
int *write_err;
{
   int words_wrote;

   *write_err = 0;
   words_wrote = fwrite (buf_out, 2, lbuf_out, MF2_FILE);
   if (words_wrote != lbuf_out) *write_err = -1;
}



/*-------------------------------------------------------------------*/
/*                                                                   */
/*      close_maf1 closes a DE RIMS MAF1 file                        */
/*                                                                   */
/*-------------------------------------------------------------------*/

close_maf1()
{
   fclose (MF1_FILE);
}



/*-------------------------------------------------------------------*/
/*                                                                   */
/*      close_ctm_out closes the counts_time output file             */
/*                                                                   */
/*-------------------------------------------------------------------*/

close_ctm_out()
{
   fclose (CTM_FILE);
}



/*-------------------------------------------------------------------*/
/*                                                                   */
/*      close_output closes the copy_maf1 output file                */
/*                                                                   */
/*-------------------------------------------------------------------*/

close_output()
{
   fclose (MF2_FILE);
}



/*-------------------------------------------------------------------*/
/*                                                                   */
/*      writes the output data for create_spin_rpa                   */
/*                                                                   */
/*-------------------------------------------------------------------*/

write_csr_data (buf1, buf2, buf3, buf4, buf5, nang, ndif, ion_num,
                out)

char buf1[35], buf2[34], buf3[44], buf4[30], buf5[78];
int *nang, *ndif, *ion_num;
float out[12][360];
{

   FILE *fp1;

   int ii;

   fp1 = fopen ("create_spin_rpa.dat", "a");

   fprintf (fp1, "%s\n", buf1);
   fprintf (fp1, "%s\n", buf2);
   fprintf (fp1, "%s\n", buf3);
   fprintf (fp1, "%s\n", buf4);
   fprintf (fp1, "%s\n", buf5);

   fprintf (fp1, "%4d%3d%3d\n", *nang, *ndif, *ion_num);

   for (ii = 0; ii < *nang; ++ii)
   {
      fprintf (fp1, "%8.2f%10.2f%8.2f",
                    out[0][ii], out[1][ii], out[2][ii]);
      fprintf (fp1, "%8.2f%10.2f%8.2f%10.2f%8.2f%10.2f%8.2f",
                    out[3][ii], out[4][ii], out[5][ii], out[6][ii],
                    out[7][ii], out[8][ii], out[9][ii]);
      fprintf (fp1, "%5.0f%5.0f\n", out[10][ii], out[11][ii]);
   }

   fclose (fp1);
}



/*-------------------------------------------------------------------*/
/*                                                                   */
/*      writes the output data for counts_time                       */
/*                                                                   */
/*-------------------------------------------------------------------*/

write_ctm_data (buf1, buf2, buf3, iheads, ndiv, save_time, rcts, rcte)

char buf1[39], buf2[34], buf3[77];
int *iheads, *ndiv;
float rcts[3][8][600], rcte[3][8][600];
double save_time[600];
{

   char ions[8][16] = {"L/H+", "H/He+", "L/He+", "H/O+",
                      "L/He++", "H/O++", "H/N+",
                      "L/Molecular Ions"};

   int hh, hhmm[600], ii, jj, mm;
   float seconds[600];

   for (ii = 0; ii < *ndiv; ii++)
   {
      hh = save_time[ii] / 3600000000.0;
      mm = (save_time[ii] - (hh * 3600000000.0)) / 60000000.0;
      hhmm[ii] = (hh * 100) + mm;
      seconds[ii] = save_time[ii] - ((hh * 3600000000.0) + (mm * 60000000.0));
      seconds[ii] /= 1000000.0;
   }

   fprintf (CTM_FILE, "%s\n", buf1);
   fprintf (CTM_FILE, "%s\n", buf2);
   fprintf (CTM_FILE, "%s\n", buf3);
   fprintf (CTM_FILE, "number of divisions = %3d\n", *ndiv);

   if ((*iheads % 2) == 1)
   {
      for (jj = 0; jj < 8; jj++)
      {
         fprintf (CTM_FILE, "\nRADIAL head: %s\n\n", ions[jj]);
         for (ii = 0; ii < *ndiv; ii++)
         {
            fprintf (CTM_FILE, "%4d:%9.6f%17.3f%10.3f%10.3f\n", hhmm[ii],
                                seconds[ii], save_time[ii], rcts[0][jj][ii],
                                rcte[0][jj][ii]);
         }
      }
   }
   if (*iheads > 3)
   {
      for (jj = 0; jj < 8; jj++)
      {
         fprintf (CTM_FILE, "\n+Z head: %s\n\n", ions[jj]);
         for (ii = 0; ii < *ndiv; ii++)
         {
            fprintf (CTM_FILE, "%4d:%9.6f%17.3f%10.3f%10.3f\n", hhmm[ii],
                                seconds[ii], save_time[ii], rcts[1][jj][ii],
                                rcte[1][jj][ii]);
         }
      }
   }
   if ((*iheads == 2) || (*iheads == 3) || (*iheads > 5))
   {
      for (jj = 0; jj < 8; jj++)
      {
         fprintf (CTM_FILE, "\n-Z head: %s\n\n", ions[jj]);
         for (ii = 0; ii < *ndiv; ii++)
         {
            fprintf (CTM_FILE, "%4d:%9.6f%17.3f%10.3f%10.3f\n", hhmm[ii],
                                seconds[ii], save_time[ii], rcts[1][jj][ii],
                                rcte[1][jj][ii]);
         }
      }
   }
}