/******************************************************************
 * FUNCTION regen - specifies regenerator geometric and thermal   *
 *                  parameters                                    *
 * FILENAME regen.c                                               *
 * PROGRAMMER I.Urieli (FORTRAN)                                  *
 *            E. Malroy   (C Translation)                         *
 * DATE:      12/01/94  (FORTRAN), 02/27/96 (C Translation)       *
 * LAST MODIFICATION: 08/16/96 BY I Urieli                        *
 * INCLUDE:  <stdio.h>, <math.h>,"define.h"                       *
 * GLOBAL VARIABLES:                                              *
 *       FILE *infile - pointer to the input data file            *
 *       FILE *outfile  - pointer to the output data file         *
 *       FILE *printfile - pointer to the print output file       *
 *       lr: regenerator effective length (m)                     *
 *       cqwr: regenerator wall thermal conductance (Watts/K)     *
 * SYMBOLIC CONSTANTS: PI 3.14159265359                           *
 * PROTOTYPE: void regen(void);                                   *
 * PRE:   infile, outfile, printfile                              *
 * POST:  lr, cqwr have been specified                            *
 *        matrix has been invoked to specify mesh properties      *
 ******************************************************************/
#include <stdio.h>
#include <math.h>
#include "define.h"

void matrix(double); /* regenerator matrix choice */
void mesh(double); /* wire mesh matrix */
void foil(double); /* coiled foil matrix */

/*************temporary fix**********/
double kwr = 25.0; /* thermal conductivity (W/m/K) */
/* stainless steel thermal conductivity - temperature dependent:
    25 W/m/K for normal engine conditions,
     6 W/m/K for cryogenic coolers. */
double csm = 3.545e6; /* matrix volumetric heat capacity (J/cu.m/K) */
    /* specific heat capacity * density for stainless steel */
/***********************  end temporary fix - I Urieli *************/

void regen()
{
   double doreg; /* regenerator housing external diameters */
   double dreg;  /* regenerator housing internal diameters */
   double direg; /* regenerator matrix internal diameter   */
   double areg;  /* regenerator matrix frontal area        */
   double awr;   /* variable to make cqwr                  */
   int nreg;     /* number of regenerator tubes            */
   char myreg;   /* regenerator housing configuration      */

   fgetc(infile); /* remove the "return" char from the buffer */
   do {
      printf("\nenter regenerator housing configuration\n");
      printf("     t, for tubular regenerator set\n");
      printf("     a, for annular regenerator\n");
      myreg=fgetc(infile);
      if(myreg == 't') {
         fprintf(outfile, "%c\n", myreg);
         printf("tubular regenerator housing\n");
         printf(" enter tube ext,int diam(m)\n");
         fscanf(infile,"%lf %lf", &doreg,&dreg);
         fprintf(outfile,"  %e  %e\n", doreg,dreg);
         printf(" enter length (m), no.of tubes\n");
         fscanf(infile,"%lf %d", &lr,&nreg);
         fprintf(outfile,"  %e  %d\n", lr,nreg);
         fprintf(printfile, "tubular regenerator housing\n");
         fprintf(printfile," tube ext,int diam(m):\n");
         fprintf(printfile,"    %e  %e\n", doreg,dreg);
         fprintf(printfile," length(m), no.of tubes:\n");
         fprintf(printfile,"    %e  %d\n", lr,nreg);
         direg = 0.0;
      }
      else if(myreg == 'a') {
         fprintf(outfile,"%c\n", myreg);
         printf("annular regenerator housing\n");
         printf(" enter housing ext,int diam(m)\n");
         fscanf(infile,"%lf %lf", &doreg,&dreg);
         fprintf(outfile,"  %e  %e\n", doreg,dreg);
         printf(" enter matrix int diam(m), length(m)\n");
         fscanf(infile,"%lf %lf", &direg,&lr);
         fprintf(outfile,"  %e  %e\n", direg,lr);
         fprintf(printfile, "annular regenerator housing\n");
         fprintf(printfile," housing ext,int diam(m): \n");
         fprintf(printfile,"    %e %e\n", doreg,dreg);
         fprintf(printfile," matrix int diam(m), length(m): \n");
         fprintf(printfile,"    %e  %e\n", direg,lr);
         nreg = 1;
      }
      else {
         printf("regen config %c undefined\n",myreg);
         myreg = 'u';
      }
   }
   while(myreg=='u');

   areg = nreg*PI*(dreg*dreg - direg*direg)/4.0;
   awr = nreg*PI*(doreg*doreg - dreg*dreg)/4.0;
   cqwr = kwr*awr/lr;

   matrix(areg);
}

/******************************************************************
 * FUNCTION matrix - specifies regenerator matrix geometric and   *
 *                   thermal parameters                           *
 * FILENAME regen.c                                               *
 * PROGRAMMER I.Urieli (FORTRAN)                                  *
 *            E. Malroy   (C Translation)                         *
 * DATE:      12/01/94  (FORTRAN), 02/27/96 (C Translation)       *
 * LAST MODIFICATION: 08/16/96 BY I Urieli                        *
 * INCLUDE:  <stdio.h>, "define.h"                                *
 * GLOBAL VARIABLES:                                              *
 *       FILE *infile - pointer to the input data file            *
 *       FILE *outfile  - pointer to the output data file         *
 *       FILE *printfile - pointer to the print output file       *
 *       rmatrx: regen matrix type (foil or mesh)                 *
 * PROTOTYPE: void matrix(double);                                *
 * PRE:   infile, outfile, printfile                              *
 *        areg (total cross-section area, void & matrix)          *
 * POST:  matrix type (rmatrx) has been chosen                    *
 *        either mesh or foil has been invoked                    *
 ******************************************************************/
void matrix(double areg)
{
   fgetc(infile); /* remove the "return" char from the buffer */
   do {
      printf("enter regen matrix type:\n");
      printf("   m for mesh\n");
      printf("   f for foil\n");
      rmatrx=fgetc(infile);
      if(rmatrx == 'm') {
         fprintf(outfile, "%c\n", rmatrx);
         printf("mesh regenerator matrix:\n");
         fprintf(printfile, "mesh regenerator matrix:\n");
         mesh(areg);
      }
      else if(rmatrx == 'f') {
         fprintf(outfile, "%c\n", rmatrx);
         printf("foil regenerator matrix:\n");
         fprintf(printfile, "foil regenerator matrix:\n");
         foil(areg);
      }
      else {
         printf("regen matrix %c undefined\n",rmatrx);
         rmatrx = 'u';
      }
   }
   while(rmatrx == 'u');
}

/******************************************************************
 * FUNCTION mesh - specifies regenerator mesh matrix properties   *
 * FILENAME regen.c                                               *
 * PROGRAMMER I.Urieli    (FORTRAN)                               *
 *            E. Malroy   (C Translation)                         *
 * LAST MODIFICATION: 08/16/96 BY I Urieli                        *
 * DATE:      12/01/94  (FORTRAN), 02/27/96 (C Translation)       *
 * INCLUDE:  <stdio.h>, <math.h>, "define.h"                      *
 * GLOBAL VARIABLES:                                              *
 *       FILE *infile - pointer to the input data file            *
 *       FILE *outfile  - pointer to the output data file         *
 *       FILE *printfile - pointer to the print output file       *
 *       vr: regenerator void volume (cu.m)                       *
 *       ar: regenerator internal free flow area (sq.m)           *
 *       awgr: regenerator internal wetted area (sq.m)            *
 *       dr: regenerator hydraulic diameter (m)                   *
 *       cmr: regenerator matrix thermal capacity (Joules/K)      *
 * PROTOTYPE:  void mesh(double);                                 *
 * PRE:  infile, outfile, printfile                               *
 *       areg (total cross-section area, void & matrix)           *
 * POST: ar, vr, dr, awgr, cmr have been determined               *
 ******************************************************************/
void mesh(double areg)
{
   double dwire;     /*  mesh wire diameter(m)      */
   double vmetal;    /*  matrix metal volume        */
   double psi;       /*  matrix porosity            */

   printf(" stacked wire mesh matrix\n");
   printf(" enter porosity, wire diam(m)\n");
   fscanf(infile,"%lf%lf", &psi,&dwire);
   fprintf(outfile,"  %6.3f  %e\n", psi,dwire);
   fprintf(printfile," stacked wire mesh matrix\n");
   fprintf(printfile, " porosity, wire diam(m):\n");
   fprintf(printfile,"    %6.3f  %e\n", psi,dwire);

   ar = areg*psi;
   vr = ar*lr;
   dr = dwire*psi/(1.0 - psi);
   awgr = 4.0*vr/dr;

   printf(" hydraulic diam %7.3f(mm)\n", dr*1.0e3);
   printf(" total wetted area %e(sq.m)\n",awgr);
   printf(" void volume %10.2f(cc)\n",vr*1.0e6);
   fprintf(printfile, " hydraulic diam %7.3f(mm)\n", dr*1.0e3);
   fprintf(printfile, " total wetted area %e(sq.m)\n",awgr);
   fprintf(printfile, " void volume %10.2f(cc)\n",vr*1.0e6);

   vmetal = (1.0 - psi)*vr;
   cmr = csm*vmetal;
   printf(" mesh thermal capacity %10.3f(joules/K)\n", cmr);
   fprintf(printfile, " mesh thermal capacity %10.3f(joules/K)\n", cmr);
}

/******************************************************************
 * FUNCTION foil - specifies regenerator matrix properties        *
 * FILENAME regen.c                                               *
 * PROGRAMMER E. Malroy                                           *
 * DATE:      5/14/96                                             *
 * LAST MODIFICATION: 08/16/96 by I Urieli                        *
 * INCLUDE:  <stdio.h>, <math.h>,"define.h"                       *
 * GLOBAL VARIABLES:                                              *
 *       FILE *infile - pointer to the input data file            *
 *       FILE *outfile  - pointer to the output data file         *
 *       FILE *printfile - pointer to the print output file       *
 *       lr: regenerator effective length (m)                     *
 *       vr: regenerator void volume (cu.m)                       *
 *       ar: regenerator internal free flow area (sq.m)           *
 *       awgr: regenerator internal wetted area (sq.m)            *
 *       dr: regenerator hydraulic diameter (m)                   *
 *       cmr: regenerator matrix thermal capacity (Joules/K)      *
 * PROTOTYPE:  void foil(double);                                 *
 * PRE:  infile, outfile, printfile                               *
 *       areg (total cross-section area, void & matrix)           *
 * POST: ar, vr, dr, awgr, cmr have been determined               *
 ******************************************************************/
void foil(double areg)
{
   double th;      /* foil thickness (m)                         */
   double fl;      /* unrolled foil length  (m)                  */
   double am;      /* foil frontal area (sq.m)                   */
   double psi;     /* matrix porosity                            */
   double vmetal;  /* volume of metal foil                       */


   printf(" enter unrolled length of foil(m), foil thickness(m)\n");
   fscanf(infile," %lf %lf", &fl, &th);
   fprintf(outfile,"  %f  %e\n", fl, th);
   fprintf(printfile," unrolled length of foil, foil thickness\n");
   fprintf(printfile,"  %f(m) %e(m)\n", fl, th);

   am = th*fl;
   ar = areg - am;
   vr = ar*lr;
   awgr = 2.0*lr*fl;
   dr = 4.0*vr/awgr;
   psi = ar/areg;

   printf(" hydraulic diam %7.3f(mm)\n", dr*1.0e3);
   printf(" total wetted area %f(sq.m)\n",awgr);
   printf(" void volume %10.2f(cc)\n",vr*1.0e6);
   printf(" porosity %6.3f\n", psi);
   fprintf(printfile, " hydraulic diam %7.3f(mm)\n", dr*1.0e3);
   fprintf(printfile, " total wetted area %f(sq.m)\n",awgr);
   fprintf(printfile, " void volume %10.2f(cc)\n",vr*1.0e6);
   fprintf(printfile, " porosity %6.3f\n", psi);

   vmetal = am*lr;
   cmr = csm*vmetal;
   printf(" foil thermal capacity %10.3f(joules/K)\n", cmr);
   fprintf(printfile, " foil thermal capacity %10.3f(joules/K)\n", cmr);
}