Logo Search packages:      
Sourcecode: nec2c version File versions  Download package

main.c

/*** Translated to the C language by N. Kyriazis  20 Aug 2003 ***

 Program NEC(input,tape5=input,output,tape11,tape12,tape13,tape14,
 tape15,tape16,tape20,tape21)

 Numerical Electromagnetics Code (NEC2)  developed at Lawrence
 Livermore lab., Livermore, CA.  (contact G. Burke at 415-422-8414
 for problems with the NEC code. For problems with the vax implem-
 entation, contact J. Breakall at 415-422-8196 or E. Domning at 415
 422-5936)
 file created 4/11/80.

                ***********Notice**********
 This computer code material was prepared as an account of work
 sponsored by the United States government.  Neither the United
 States nor the United States Department Of Energy, nor any of
 their employees, nor any of their contractors, subcontractors,
 or their employees, makes any warranty, express or implied, or
 assumes any legal liability or responsibility for the accuracy,
 completeness or usefulness of any information, apparatus, product
 or process disclosed, or represents that its use would not infringe
 privately-owned rights.

*******************************************************************/

#include "nec2c.h"

/* common  /cmb/ */
complex long double *cm;

/* common  /crnt/ */
crnt_t crnt;

/* common  /data/ */
data_t data;

/*common  /ggrid/ */
extern ggrid_t ggrid;

/* common  /gnd/ */
gnd_t gnd;

/* common  /matpar/ */
matpar_t matpar;

/* common  /netcx/ */
netcx_t netcx;

/* common  /save/ */
save_t save;

/* common  /segj/ */
segj_t segj;

/* common  /yparm/ */
yparm_t yparm;

/* common  /zload/ */
zload_t zload;

/* common  /vsorc/ */
vsorc_t vsorc;

/* common  /fpat/ */
fpat_t fpat;

/* common  /gwav/ */
gwav_t gwav;

/* common  /plot/ */
plot_t plot;

/* common  /smat/ */
smat_t smat;

/* pointers to input/output files */
FILE *input_fp=NULL, *output_fp=NULL, *plot_fp=NULL;

/* signal handler */
static void sig_handler( int signal );

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

int main( int argc, char **argv )
{
  char infile[81] = "", otfile[81] = "";
  char ain[3], line_buf[81];

  /* input card mnemonic list */
#define NUM_CMNDS  20
  char *atst[NUM_CMNDS] =
  {
      "FR", "LD", "GN", "EX", "NT", "TL", \
        "XQ", "GD", "RP", "NX", "PT", "KH", \
        "NE", "NH", "PQ", "EK", "CP", "PL", \
        "EN", "WG"
  };

  char *hpol[3] = { "LINEAR", "RIGHT", "LEFT" };
  char *pnet[3] = { "        ", "STRAIGHT", " CROSSED" };

  int *ldtyp, *ldtag, *ldtagf, *ldtagt;
  int ifrtmw, ifrtmp, mpcnt, igo, nfrq;
  int iexk, iptflg, iptflq, iped, iflow, itmp1, iresrv;
  int itmp3, itmp2, itmp4, nthi=0, nphi=0, iptag=0, iptagf=0, iptagt=0;
  int iptaq=0, iptaqf=0, iptaqt=0, nphic=0, inc=0;
  int i, j, itmp5, nthic=0, mhz=0, ifrq=0, isave=0;

  int
      igox,       /* used in place of "igo" in freq loop */
      next_job,   /* start next job (next sructure) flag */
      idx,        /* general purpose index    */
      ain_num,    /* ain mnemonic as a number */
      jmp_iloop,  /* jump to input loop flag  */
      jmp_floop=0,/* jump to freq. loop flag  */
      mreq;       /* Size req. for malloc's   */

  long double *zlr, *zli, *zlc, *fnorm;
  long double *xtemp, *ytemp, *ztemp, *sitemp, *bitemp;
  long double rkh, tmp1, delfrq=0., tmp2, tmp3, tmp4, tmp5, tmp6;
  long double xpr1=0., xpr2=0., xpr3=0., xpr4=0., xpr5=0.;
  long double zpnorm=0., thetis=0., phiss=0., extim;
  long double tim1, tim, tim2, etha, fr, fr2, cmag, ph, ethm, ephm, epha;
  complex long double eth, eph, curi, ex, ey, ez, epsc;

  /* getopt() variables */
  extern char *optarg;
  extern int optind, opterr, optopt;
  int option;

  /*** signal handler related code ***/
  /* new and old actions for sigaction() */
  struct sigaction sa_new, sa_old;


  /* initialize new actions */
  sa_new.sa_handler = sig_handler;
  sigemptyset( &sa_new.sa_mask );
  sa_new.sa_flags = 0;

  /* register function to handle signals */
  sigaction( SIGINT,  &sa_new, &sa_old );
  sigaction( SIGSEGV, &sa_new, 0 );
  sigaction( SIGFPE,  &sa_new, 0 );
  sigaction( SIGTERM, &sa_new, 0 );
  sigaction( SIGABRT, &sa_new, 0 );

  /*** command line arguments handler ***/
  if( argc == 1 )
  {
      usage();
      exit(-1);
  }

  /* process command line options */
  while( (option = getopt(argc, argv, "i:o:hv") ) != -1 )
  {
      switch( option )
      {
        case 'i' : /* specify input file name */
            if( strlen(optarg) > 75 )
              abort_on_error(-1);
            strcpy( infile, optarg );
            break;

        case 'o' : /* specify output file name */
            if( strlen(optarg) > 75 )
              abort_on_error(-2);
            strcpy( otfile, optarg );
            break;

        case 'h' : /* print usage and exit */
            usage();
            exit(0);

        case 'v' : /* print nec2c version */
            puts( version );
            exit(0);

        default: /* print usage and exit */
            usage();
            exit(-1);

      } /* end of switch( option ) */

  } /* while( (option = getopt(argc, argv, "i:o:hv") ) != -1 ) */

  /*** open input file ***/
  if( (input_fp = fopen(infile, "r")) == NULL )
  {
      char mesg[88] = "nec2c: ";

      strcat( mesg, infile );
      perror( mesg );
      exit(-1);
  }

  /* make an output file name if not */
  /* specified by user on invocation */
  if( strlen( otfile ) == 0 )
  {
      /* strip file name extension if there is one */
      idx = 0;
      while( (infile[++idx] != '.') && (infile[idx] != '\0') );
      infile[idx] = '\0';

      /* make the output file name from input file */
      strcpy( otfile, infile );
      strcat( otfile, ".out" ); /* add extension */
  }

  /* open output file */
  if( (output_fp = fopen(otfile, "w")) == NULL )
  {
      char mesg[88] = "nec2c: ";

      strcat( mesg, otfile );
      perror( mesg );
      exit(-1);
  }

  /*** here we had code to read interactively input/output ***/
  /*** file names. this is done non-interactively above.   ***/

  secnds( &extim );

  /* Null local buffer pointers */
  /* type int */
  ldtyp = ldtag = ldtagf = ldtagt = NULL;
  /* type long double */
  zlr = zli = zlc = fnorm = NULL;
  xtemp = ytemp = ztemp = sitemp = bitemp = NULL;
  /* type complex long double */
  cm = NULL;

  /* Null global pointers */
  Null_Pointers();

  /* Allocate some buffers */
  mem_alloc( (void *)&ggrid.ar1, sizeof(complex long double)*11*10*4 );
  mem_alloc( (void *)&ggrid.ar2, sizeof(complex long double)*17*5*4 );
  mem_alloc( (void *)&ggrid.ar3, sizeof(complex long double)*9*8*4 );

  /* Initialize ground grid parameters for somnec */
  ggrid.nxa[0] = 11;
  ggrid.nxa[1] = 17;
  ggrid.nxa[2] = 9;

  ggrid.nya[0] = 10;
  ggrid.nya[1] = 5;
  ggrid.nya[2] = 8;

  ggrid.dxa[0] = .02;
  ggrid.dxa[1] = .05;
  ggrid.dxa[2] = .1;

  ggrid.dya[0] = .1745329252;
  ggrid.dya[1] = .0872664626;
  ggrid.dya[2] = .1745329252;

  ggrid.xsa[0] = 0.;
  ggrid.xsa[1] = .2;
  ggrid.xsa[2] = .2;

  ggrid.ysa[0] = 0.;
  ggrid.ysa[1] = 0.;
  ggrid.ysa[2] = .3490658504;

  /* l_1: */
  /* main execution loop, exits at various points */
  /* depending on error conditions or end of jobs */
  while( TRUE )
  {
      ifrtmw=0;
      ifrtmp=0;

      /* print the nec2c header to output file */
      fprintf( output_fp,     "\n\n\n"
            "                              "
            " __________________________________________\n"
            "                              "
            "|                                          |\n"
            "                              "
            "|  NUMERICAL ELECTROMAGNETICS CODE (nec2c) |\n"
            "                              "
            "|   Translated to 'C' in Double Precision  |\n"
            "                              "
            "|__________________________________________|\n" );

      /* read a line from input file */
      if( load_line(line_buf, input_fp) == EOF )
        abort_on_error(-3);

      /* separate card's id mnemonic */
      strncpy( ain, line_buf, 2 );
      ain[2] = '\0';

      /* if its a "cm" or "ce" card start reading comments */
      if( (strcmp(ain, "CM") == 0) ||
            (strcmp(ain, "CE") == 0) )
      {
        fprintf( output_fp, "\n\n\n"
              "                               "
              "---------------- COMMENTS ----------------\n" );

        /* write comment to output file */
        fprintf( output_fp,
              "                              %s\n",
              &line_buf[2] );

        /* Keep reading till a non "CM" card */
        while( strcmp(ain, "CM") == 0 )
        {
            /* read a line from input file */
            if( load_line(line_buf, input_fp) == EOF )
              abort_on_error(-3);

            /* separate card's id mnemonic */
            strncpy( ain, line_buf, 2 );
            ain[2] = '\0';

            /* write comment to output file */
            fprintf( output_fp,
                  "                              %s\n",
                  &line_buf[2] );

        } /* while( strcmp(ain, "CM") == 0 ) */

        /* no "ce" card at end of comments */
        if( strcmp(ain, "CE") != 0 )
        {
            fprintf( output_fp,
                  "\n\n  ERROR: INCORRECT LABEL FOR A COMMENT CARD" );
            abort_on_error(-4);
        }

      } /* if( strcmp(ain, "CM") == 0 ... */
      else
        rewind( input_fp );

      /* initializations etc from original fortran code */
      mpcnt=0;
      matpar.imat=0;

      /* set up geometry data in subroutine datagn */
      datagn();
      iflow=1;

      /* Allocate some buffers */
      mreq = data.npm * sizeof(long double);
      mem_realloc( (void *)&crnt.air, mreq );
      mem_realloc( (void *)&crnt.aii, mreq );
      mem_realloc( (void *)&crnt.bir, mreq );
      mem_realloc( (void *)&crnt.bii, mreq );
      mem_realloc( (void *)&crnt.cir, mreq );
      mem_realloc( (void *)&crnt.cii, mreq );
      mem_realloc( (void *)&xtemp,  mreq );
      mem_realloc( (void *)&ytemp,  mreq );
      mem_realloc( (void *)&ztemp,  mreq );
      mem_realloc( (void *)&sitemp, mreq );
      mem_realloc( (void *)&bitemp, mreq );

      mreq = data.np2m * sizeof(int);
      mem_realloc( (void *)&save.ip, mreq );

      mreq = data.np3m * sizeof( complex long double);
      mem_realloc( (void *)&crnt.cur, mreq );

      /* Matrix parameters */
      if( matpar.imat == 0)
      {
        netcx.neq= data.n+2*data.m;
        netcx.neq2=0;
      }

      fprintf( output_fp, "\n\n\n" );

      /* default values for input parameters and flags */
      netcx.npeq= data.np+2*data.mp;
      plot.iplp1=0;
      plot.iplp2=0;
      plot.iplp3=0;
      plot.iplp4=0;
      igo=1;
      nfrq=1;
      rkh=1.;
      iexk=0;
      fpat.ixtyp=0;
      zload.nload=0;
      netcx.nonet=0;
      fpat.near=-1;
      iptflg=-2;
      iptflq=-1;
      gnd.ifar=-1;
      gnd.zrati=CPLX_10;
      iped=0;
      yparm.ncoup=0;
      yparm.icoup=0;
      save.fmhz= CVEL;
      gnd.ksymp=1;
      gnd.nradl=0;
      gnd.iperf=0;

      /* l_14: */

      /* main input section, exits at various points */
      /* depending on error conditions or end of job */
      next_job = FALSE;
      while( ! next_job )
      {
        jmp_iloop = FALSE;

        /* main input section - standard read statement - jumps */
        /* to appropriate section for specific parameter set up */
        readmn( ain, &itmp1, &itmp2, &itmp3, &itmp4,
              &tmp1, &tmp2, &tmp3, &tmp4, &tmp5, &tmp6 );

        /* If its an "XT" card, exit */
        if( strcmp(ain, "XT" ) == 0 )
        {
            fprintf( stderr,
                  "\nnec2c: Exiting after an \"XT\" command in main()\n" );
            fprintf( output_fp,
                  "\n\n  nec2c: Exiting after an \"XT\" command in main()" );
            stop(0);
        }

        mpcnt++;
        fprintf( output_fp,
              "\n  DATA CARD No: %3d "
              "%s %3d %5d %5d %5d %12.5LE %12.5LE %12.5LE %12.5LE %12.5LE %12.5LE",
              mpcnt, ain, itmp1, itmp2, itmp3, itmp4,
              tmp1, tmp2, tmp3, tmp4, tmp5, tmp6 );

        /* identify card id mnemonic (except "ce" and "cm") */
        for( ain_num = 0; ain_num < NUM_CMNDS; ain_num++ )
            if( strncmp( ain, atst[ain_num], 2) == 0 )
              break;

        /* take action according to card id mnemonic */
        switch( ain_num )
        {
            case 0: /* "fr" card, frequency parameters */

              ifrq= itmp1;
              nfrq= itmp2;
              if( nfrq == 0)
                  nfrq=1;
              save.fmhz= tmp1;
              delfrq= tmp2;
              if( iped == 1)
                  zpnorm=0.;
              igo=1;
              iflow=1;

              continue; /* continue card input loop */

            case 1: /* "ld" card, loading parameters */
              {
                  int idx;

                  if( iflow != 3 )
                  {
                    iflow=3;
                    /* Free loading buffers */
                    zload.nload=0;
                    free_ptr( (void *)&ldtyp );
                    free_ptr( (void *)&ldtag );
                    free_ptr( (void *)&ldtagf );
                    free_ptr( (void *)&ldtagt );
                    free_ptr( (void *)&zlr );
                    free_ptr( (void *)&zli );
                    free_ptr( (void *)&zlc );

                    if( igo > 2 )
                        igo=2;
                    if( itmp1 == -1 )
                        continue; /* continue card input loop */
                  }

                  /* Reallocate loading buffers */
                  zload.nload++;
                  idx = zload.nload * sizeof(int);
                  mem_realloc( (void *)&ldtyp,  idx );
                  mem_realloc( (void *)&ldtag,  idx );
                  mem_realloc( (void *)&ldtagf, idx );
                  mem_realloc( (void *)&ldtagt, idx );
                  idx = zload.nload * sizeof(long double);
                  mem_realloc( (void *)&zlr, idx );
                  mem_realloc( (void *)&zli, idx );
                  mem_realloc( (void *)&zlc, idx );

                  idx = zload.nload-1;
                  ldtyp[idx]= itmp1;
                  ldtag[idx]= itmp2;
                  if( itmp4 == 0)
                    itmp4= itmp3;
                  ldtagf[idx]= itmp3;
                  ldtagt[idx]= itmp4;

                  if( itmp4 < itmp3 )
                  {
                    fprintf( output_fp,
                          "\n\n  DATA FAULT ON LOADING CARD No: %d: ITAG "
                          "STEP1: %d IS GREATER THAN ITAG STEP2: %d",
                          zload.nload, itmp3, itmp4 );
                    stop(-1);
                  }

                  zlr[idx]= tmp1;
                  zli[idx]= tmp2;
                  zlc[idx]= tmp3;
              }

              continue; /* continue card input loop */

            case 2: /* "gn" card, ground parameters under the antenna */

              iflow=4;

              if( igo > 2)
                  igo=2;

              if( itmp1 == -1 )
              {
                  gnd.ksymp=1;
                  gnd.nradl=0;
                  gnd.iperf=0;
                  continue; /* continue card input loop */
              }

              gnd.iperf= itmp1;
              gnd.nradl= itmp2;
              gnd.ksymp=2;
              save.epsr= tmp1;
              save.sig= tmp2;

              if( gnd.nradl != 0)
              {
                  if( gnd.iperf == 2)
                  {
                    fprintf( output_fp,
                          "\n\n  RADIAL WIRE G.S. APPROXIMATION MAY "
                          "NOT BE USED WITH SOMMERFELD GROUND OPTION" );
                    stop(-1);
                  }

                  save.scrwlt= tmp3;
                  save.scrwrt= tmp4;
                  continue; /* continue card input loop */
              }

              fpat.epsr2= tmp3;
              fpat.sig2= tmp4;
              fpat.clt= tmp5;
              fpat.cht= tmp6;

              continue; /* continue card input loop */

            case 3: /* "ex" card, excitation parameters */

              if( iflow != 5)
              {
                  /* Free vsource buffers */
                  free_ptr( (void *)&vsorc.ivqd );
                  free_ptr( (void *)&vsorc.iqds );
                  free_ptr( (void *)&vsorc.vqd );
                  free_ptr( (void *)&vsorc.vqds );
                  free_ptr( (void *)&vsorc.isant );
                  free_ptr( (void *)&vsorc.vsant );

                  vsorc.nsant=0;
                  vsorc.nvqd=0;
                  iped=0;
                  iflow=5;
                  if( igo > 3)
                    igo=3;
              }

              fpat.ixtyp= itmp1;
              netcx.masym= itmp4/10;
              if( (itmp1 == 0) || (itmp1 == 5) )
              {
                  netcx.ntsol=0;

                  if( fpat.ixtyp == 5)
                  {
                    vsorc.nvqd++;
                    mem_realloc( (void *)&vsorc.ivqd, vsorc.nvqd * sizeof(int) );
                    mem_realloc( (void *)&vsorc.iqds, vsorc.nvqd * sizeof(int) );
                    mem_realloc( (void *)&vsorc.vqd,  vsorc.nvqd * sizeof(complex long double) );
                    mem_realloc( (void *)&vsorc.vqds, vsorc.nvqd * sizeof(complex long double) );

                    {
                        int indx = vsorc.nvqd-1;

                        vsorc.ivqd[indx]= isegno( itmp2, itmp3);
                        vsorc.vqd[indx]= cmplx( tmp1, tmp2);
                        if( cabsl( vsorc.vqd[indx]) < 1.e-20)
                          vsorc.vqd[indx] = CPLX_10;

                        iped= itmp4- netcx.masym*10;
                        zpnorm= tmp3;
                        if( (iped == 1) && (zpnorm > 0.0) )
                          iped=2;
                        continue; /* continue card input loop */
                    }

                  } /* if( fpat.ixtyp == 5) */

                  vsorc.nsant++;
                  mem_realloc( (void *)&vsorc.isant, vsorc.nsant * sizeof(int) );
                  mem_realloc( (void *)&vsorc.vsant, vsorc.nsant * sizeof(complex long double) );

                  {
                    int indx = vsorc.nsant-1;

                    vsorc.isant[indx]= isegno( itmp2, itmp3);
                    vsorc.vsant[indx]= cmplx( tmp1, tmp2);
                    if( cabsl( vsorc.vsant[indx]) < 1.e-20)
                        vsorc.vsant[indx] = CPLX_10;

                    iped= itmp4- netcx.masym*10;
                    zpnorm= tmp3;
                    if( (iped == 1) && (zpnorm > 0.0) )
                        iped=2;
                    continue; /* continue card input loop */
                  }

              } /* if( (itmp1 <= 0) || (itmp1 == 5) ) */

              nthi= itmp2;
              nphi= itmp3;
              xpr1= tmp1;
              xpr2= tmp2;
              xpr3= tmp3;
              xpr4= tmp4;
              xpr5= tmp5;
              fpat.xpr6= tmp6;
              vsorc.nsant=0;
              vsorc.nvqd=0;
              thetis= xpr1;
              phiss= xpr2;

              continue; /* continue card input loop */

            case 4: case 5: /* "nt" & "tl" cards, network parameters */
              {
                  int idx;

                  if( iflow != 6)
                  {
                    netcx.nonet=0;
                    netcx.ntsol=0;
                    iflow=6;

                    /* Free network buffers */
                    free_ptr( (void *)&netcx.ntyp );
                    free_ptr( (void *)&netcx.iseg1 );
                    free_ptr( (void *)&netcx.iseg2 );
                    free_ptr( (void *)&netcx.x11r );
                    free_ptr( (void *)&netcx.x11i );
                    free_ptr( (void *)&netcx.x12r );
                    free_ptr( (void *)&netcx.x12i );
                    free_ptr( (void *)&netcx.x22r );
                    free_ptr( (void *)&netcx.x22i );

                    if( igo > 3)
                        igo=3;

                    if( itmp2 == -1 )
                        continue; /* continue card input loop */
                  }

                  /* Re-allocate network buffers */
                  netcx.nonet++;
                  idx = netcx.nonet * sizeof(int);
                  mem_realloc( (void *)&netcx.ntyp, idx );
                  mem_realloc( (void *)&netcx.iseg1, idx );
                  mem_realloc( (void *)&netcx.iseg2, idx );
                  idx = netcx.nonet * sizeof(long double);
                  mem_realloc( (void *)&netcx.x11r, idx );
                  mem_realloc( (void *)&netcx.x11i, idx );
                  mem_realloc( (void *)&netcx.x12r, idx );
                  mem_realloc( (void *)&netcx.x12i, idx );
                  mem_realloc( (void *)&netcx.x22r, idx );
                  mem_realloc( (void *)&netcx.x22i, idx );

                  idx = netcx.nonet-1;
                  if( ain_num == 4 )
                    netcx.ntyp[idx]=1;
                  else
                    netcx.ntyp[idx]=2;

                  netcx.iseg1[idx]= isegno( itmp1, itmp2);
                  netcx.iseg2[idx]= isegno( itmp3, itmp4);
                  netcx.x11r[idx]= tmp1;
                  netcx.x11i[idx]= tmp2;
                  netcx.x12r[idx]= tmp3;
                  netcx.x12i[idx]= tmp4;
                  netcx.x22r[idx]= tmp5;
                  netcx.x22i[idx]= tmp6;

                  if( (netcx.ntyp[idx] == 1) || (tmp1 > 0.) )
                    continue; /* continue card input loop */

                  netcx.ntyp[idx]=3;
                  netcx.x11r[idx]=- tmp1;

                  continue; /* continue card input loop */
              }

            case 6: /* "xq" execute card - calc. including radiated fields */

              if( ((iflow == 10) && (itmp1 == 0)) ||
                    ((nfrq  ==  1) && (itmp1 == 0) && (iflow > 7)) )
                  continue; /* continue card input loop */

              if( itmp1 == 0)
              {
                  if( iflow > 7)
                    iflow=11;
                  else
                    iflow=7;
              }
              else
              {
                  gnd.ifar=0;
                  fpat.rfld=0.;
                  fpat.ipd=0;
                  fpat.iavp=0;
                  fpat.inor=0;
                  fpat.iax=0;
                  fpat.nth=91;
                  fpat.nph=1;
                  fpat.thets=0.;
                  fpat.phis=0.;
                  fpat.dth=1.0;
                  fpat.dph=0.;

                  if( itmp1 == 2)
                    fpat.phis=90.;

                  if( itmp1 == 3)
                  {
                    fpat.nph=2;
                    fpat.dph=90.;
                  }

              } /* if( itmp1 == 0) */

              break;

            case 7: /* "gd" card, ground representation */

              fpat.epsr2= tmp1;
              fpat.sig2= tmp2;
              fpat.clt= tmp3;
              fpat.cht= tmp4;
              iflow=9;

              continue; /* continue card input loop */

            case 8: /* "rp" card, standard observation angle parameters */

              gnd.ifar= itmp1;
              fpat.nth= itmp2;
              fpat.nph= itmp3;

              if( fpat.nth == 0)
                  fpat.nth=1;
              if( fpat.nph == 0)
                  fpat.nph=1;

              fpat.ipd= itmp4/10;
              fpat.iavp= itmp4- fpat.ipd*10;
              fpat.inor= fpat.ipd/10;
              fpat.ipd= fpat.ipd- fpat.inor*10;
              fpat.iax= fpat.inor/10;
              fpat.inor= fpat.inor- fpat.iax*10;

              if( fpat.iax != 0)
                  fpat.iax=1;
              if( fpat.ipd != 0)
                  fpat.ipd=1;
              if( (fpat.nth < 2) || (fpat.nph < 2) || (gnd.ifar == 1) )
                  fpat.iavp=0;

              fpat.thets= tmp1;
              fpat.phis= tmp2;
              fpat.dth= tmp3;
              fpat.dph= tmp4;
              fpat.rfld= tmp5;
              fpat.gnor= tmp6;
              iflow=10;

              break;

            case 9: /* "nx" card, do next job */
              next_job = TRUE;
              continue; /* continue card input loop */

            case 10: /* "pt" card, print control for current */

              iptflg= itmp1;
              iptag= itmp2;
              iptagf= itmp3;
              iptagt= itmp4;

              if( (itmp3 == 0) && (iptflg != -1) )
                  iptflg=-2;
              if( itmp4 == 0)
                  iptagt= iptagf;

              continue; /* continue card input loop */

            case 11: /* "kh" card, matrix integration limit */

              rkh= tmp1;
              if( igo > 2)
                  igo=2;
              iflow=1;

              continue; /* continue card input loop */

            case 12: case 13:  /* "ne"/"nh" cards, near field calculation parameters */

              if( ain_num == 13 )
                  fpat.nfeh=1;
              else
                  fpat.nfeh=0;

              if( (iflow == 8) && (nfrq != 1) )
              {
                  fprintf( output_fp,
                        "\n\n  WHEN MULTIPLE FREQUENCIES ARE REQUESTED, "
                        "ONLY ONE NEAR FIELD CARD CAN BE USED -"
                        "\n  LAST CARD READ WILL BE USED" );
              }

              fpat.near= itmp1;
              fpat.nrx= itmp2;
              fpat.nry= itmp3;
              fpat.nrz= itmp4;
              fpat.xnr= tmp1;
              fpat.ynr= tmp2;
              fpat.znr= tmp3;
              fpat.dxnr= tmp4;
              fpat.dynr= tmp5;
              fpat.dznr= tmp6;
              iflow=8;

              if( nfrq != 1)
                  continue; /* continue card input loop */

              break;

            case 14: /* "pq" card, write control for charge */

              iptflq= itmp1;
              iptaq= itmp2;
              iptaqf= itmp3;
              iptaqt= itmp4;

              if( (itmp3 == 0) && (iptflq != -1) )
                  iptflq=-2;
              if( itmp4 == 0)
                  iptaqt= iptaqf;

              continue; /* continue card input loop */

            case 15: /* "ek" card,  extended thin wire kernel option */

              iexk=1;
              if( itmp1 == -1)
                  iexk=0;
              if( igo > 2)
                  igo=2;
              iflow=1;

              continue; /* continue card input loop */

            case 16: /* "cp" card, maximum coupling between antennas */

              if( iflow != 2)
              {
                  yparm.ncoup=0;
                  free_ptr( (void *)&yparm.nctag );
                  free_ptr( (void *)&yparm.ncseg );
                  free_ptr( (void *)&yparm.y11a );
                  free_ptr( (void *)&yparm.y12a );
              }

              yparm.icoup=0;
              iflow=2;

              if( itmp2 == 0)
                  continue; /* continue card input loop */

              yparm.ncoup++;
              mem_realloc( (void *)&yparm.nctag, (yparm.ncoup) * sizeof(int) );
              mem_realloc( (void *)&yparm.ncseg, (yparm.ncoup) * sizeof(int) );
              yparm.nctag[yparm.ncoup-1]= itmp1;
              yparm.ncseg[yparm.ncoup-1]= itmp2;

              if( itmp4 == 0)
                  continue; /* continue card input loop */

              yparm.ncoup++;
              mem_realloc( (void *)&yparm.nctag, (yparm.ncoup) * sizeof(int) );
              mem_realloc( (void *)&yparm.ncseg, (yparm.ncoup) * sizeof(int) );
              yparm.nctag[yparm.ncoup-1]= itmp3;
              yparm.ncseg[yparm.ncoup-1]= itmp4;

              continue; /* continue card input loop */

            case 17: /* "pl" card, plot flags */

              plot.iplp1= itmp1;
              plot.iplp2= itmp2;
              plot.iplp3= itmp3;
              plot.iplp4= itmp4;

              if( plot_fp == NULL )
              {
                  char plotfile[81];

                  /* Make a plot file name */
                  strcpy( plotfile, infile );
                  strcat( plotfile, ".plt" );

                  /* Open plot file */
                  if( (plot_fp = fopen(plotfile, "w")) == NULL )
                  {
                    char mesg[88] = "nec2c: ";

                    strcat( mesg, plotfile );
                    perror( mesg );
                    exit(-1);
                  }
              }

              continue; /* continue card input loop */

            case 19: /* "wg" card, not supported */
              abort_on_error(-5);

            default:
              if( ain_num != 18 )
              {
                  fprintf( output_fp,
                        "\n\n  FAULTY DATA CARD LABEL AFTER GEOMETRY SECTION" );
                  stop(-1);
              }

              /******************************************************
               *** normal exit of nec2c when all jobs complete ok ***
               ******************************************************/

              /* time the process */
              secnds( &tmp1 );
              tmp1 -= extim;
              fprintf( output_fp, "\n\n  TOTAL RUN TIME: %d msec", (int)tmp1 );
              stop(0);

        } /* switch( ain_num ) */

        /**************************************
         *** end of the main input section. ***
         *** beginning of frequency do loop ***
         **************************************/

        /* Allocate to normalization buffer */
        {
            int mreq1, mreq2;

            mreq1 = mreq2 = 0;
            if( iped )
              mreq1 = 4*nfrq * sizeof(long double);
            if( iptflg >= 2 )
              mreq2 = nthi*nphi * sizeof(long double);

            if( (mreq1 > 0) || (mreq2 > 0) )
            {
              if( mreq1 > mreq2 )
                  mem_realloc( (void *)&fnorm, mreq1 );
              else
                  mem_realloc( (void *)&fnorm, mreq2 );
            }
        }

        /* igox is used in place of "igo" in the   */
        /* freq loop. below is a special igox case */
        if( ((ain_num == 6) || (ain_num == 8)) && (igo == 5) )
            igox = 6;
        else
            igox = igo;

        switch( igox )
        {
            case 1: /* label 41 */
              /* Memory allocation for primary interacton matrix. */
              iresrv = data.np2m * (data.np+2*data.mp);
              mem_realloc( (void *)&cm, iresrv * sizeof(complex long double) );

              /* Memory allocation for symmetry array */
              smat.nop = netcx.neq/netcx.npeq;
              mem_realloc( (void *)&smat.ssx, smat.nop*smat.nop* sizeof( complex long double) );

              mhz=1;

              if( (data.n != 0) && (ifrtmw != 1) )
              {
                  ifrtmw=1;
                  for( i = 0; i < data.n; i++ )
                  {
                    xtemp[i]= data.x[i];
                    ytemp[i]= data.y[i];
                    ztemp[i]= data.z[i];
                    sitemp[i]= data.si[i];
                    bitemp[i]= data.bi[i];
                  }
              }

              if( (data.m != 0) && (ifrtmp != 1) )
              {
                  ifrtmp=1;
                  for( i = 0; i < data.m; i++ )
                  {
                    j = i+data.n;
                    xtemp[j]= data.px[i];
                    ytemp[j]= data.py[i];
                    ztemp[j]= data.pz[i];
                    bitemp[j]= data.pbi[i];
                  }
              }

              /* irngf is not used (NGF function not implemented) */
              if( matpar.imat == 0)
                  fblock( netcx.npeq, netcx.neq, iresrv, data.ipsym);

              /* label 42 */
              /* frequency do loop */
              do
              {
                  jmp_floop = FALSE;

                  if( mhz != 1)
                  {
                    if( ifrq == 1)
                        save.fmhz *= delfrq;
                    else
                        save.fmhz += delfrq;
                  }

                  fr= save.fmhz/ CVEL;
                  data.wlam= CVEL/ save.fmhz;
                  fprintf( output_fp, "\n\n\n"
                        "                               "
                        "--------- FREQUENCY --------\n"
                        "                                "
                        "FREQUENCY :%11.4LE MHz\n"
                        "                                "
                        "WAVELENGTH:%11.4LE Mtr", save.fmhz, data.wlam );

                  fprintf( output_fp, "\n\n"
                        "                        "
                        "APPROXIMATE INTEGRATION EMPLOYED FOR SEGMENTS \n"
                        "                        "
                        "THAT ARE MORE THAN %.3LF WAVELENGTHS APART", rkh );

                  if( iexk == 1)
                    fprintf( output_fp, "\n"
                          "                        "
                          "THE EXTENDED THIN WIRE KERNEL WILL BE USED" );

                  /* frequency scaling of geometric parameters */
                  if( data.n != 0)
                  {
                    for( i = 0; i < data.n; i++ )
                    {
                        data.x[i]= xtemp[i]* fr;
                        data.y[i]= ytemp[i]* fr;
                        data.z[i]= ztemp[i]* fr;
                        data.si[i]= sitemp[i]* fr;
                        data.bi[i]= bitemp[i]* fr;
                    }
                  }

                  if( data.m != 0)
                  {
                    fr2= fr* fr;
                    for( i = 0; i < data.m; i++ )
                    {
                        j = i+data.n;
                        data.px[i]= xtemp[j]* fr;
                        data.py[i]= ytemp[j]* fr;
                        data.pz[i]= ztemp[j]* fr;
                        data.pbi[i]= bitemp[j]* fr2;
                    }
                  }

                  igo = 2;

                  /* label 46 */
                  case 2: /* structure segment loading */
                  fprintf( output_fp, "\n\n\n"
                        "                          "
                        "------ STRUCTURE IMPEDANCE LOADING ------" );

                  if( zload.nload != 0)
                    load( ldtyp, ldtag, ldtagf, ldtagt, zlr, zli, zlc );

                  if( zload.nload == 0 )
                    fprintf( output_fp, "\n"
                          "                                 "
                          "THIS STRUCTURE IS NOT LOADED" );

                  fprintf( output_fp, "\n\n\n"
                        "                            "
                        "-------- ANTENNA ENVIRONMENT --------" );

                  if( gnd.ksymp != 1)
                  {
                    gnd.frati=CPLX_10;

                    if( gnd.iperf != 1)
                    {
                        if( save.sig < 0.)
                          save.sig=- save.sig/(59.96*data.wlam);

                        epsc= cmplx( save.epsr, -save.sig*data.wlam*59.96);
                        gnd.zrati=1./ csqrtl( epsc);
                        gwav.u= gnd.zrati;
                        gwav.u2= gwav.u* gwav.u;

                        if( gnd.nradl != 0)
                        {
                          gnd.scrwl= save.scrwlt/ data.wlam;
                          gnd.scrwr= save.scrwrt/ data.wlam;
                          gnd.t1= CPLX_01*2367.067/ (long double)gnd.nradl;
                          gnd.t2= gnd.scrwr* (long double)gnd.nradl;

                          fprintf( output_fp, "\n"
                                "                            "
                                "RADIAL WIRE GROUND SCREEN\n"
                                "                            "
                                "%d WIRES\n"
                                "                            "
                                "WIRE LENGTH: %8.2LF METERS\n"
                                "                            "
                                "WIRE RADIUS: %10.3LE METERS",
                                gnd.nradl, save.scrwlt, save.scrwrt );

                          fprintf( output_fp, "\n"
                                "                            "
                                "MEDIUM UNDER SCREEN -" );

                        } /* if( gnd.nradl != 0) */

                        if( gnd.iperf != 2)
                          fprintf( output_fp, "\n"
                                "                            "
                                "FINITE GROUND - REFLECTION COEFFICIENT APPROXIMATION" );
                        else
                        {
                          somnec( save.epsr, save.sig, save.fmhz );
                          gnd.frati=( epsc-1.)/( epsc+1.);
                          if( cabsl(( ggrid.epscf- epsc)/ epsc) >= 1.0e-3 )
                          {
                              fprintf( output_fp,
                                    "\n ERROR IN GROUND PARAMETERS -"
                                    "\n COMPLEX DIELECTRIC CONSTANT FROM FILE IS: %12.5LE%+12.5LEj"
                                    "\n                                REQUESTED: %12.5LE%+12.5LEj",
                                    creall(ggrid.epscf), cimagl(ggrid.epscf), creall(epsc), cimagl(epsc) );
                              stop(-1);
                          }

                          fprintf( output_fp, "\n"
                                "                            "
                                "FINITE GROUND - SOMMERFELD SOLUTION" );

                        } /* if( gnd.iperf != 2) */

                        fprintf( output_fp, "\n"
                              "                            "
                              "RELATIVE DIELECTRIC CONST: %.3LF\n"
                              "                            "
                              "CONDUCTIVITY: %10.3LE MHOS/METER\n"
                              "                            "
                              "COMPLEX DIELECTRIC CONSTANT: %11.4LE%+11.4LEj",
                              save.epsr, save.sig, creall(epsc), cimagl(epsc) );

                    } /* if( gnd.iperf != 1) */
                    else
                        fprintf( output_fp, "\n"
                              "                            "
                              "PERFECT GROUND" );

                  } /* if( gnd.ksymp != 1) */
                  else
                    fprintf( output_fp, "\n"
                          "                            "
                          "FREE SPACE" );

                  /* label 50 */
                  /* fill and factor primary interaction matrix */
                  secnds( &tim1 );
                  cmset( netcx.neq, cm, rkh, iexk );
                  secnds( &tim2 );
                  tim= tim2- tim1;
                  factrs( netcx.npeq, netcx.neq, cm, save.ip );
                  secnds( &tim1 );
                  tim2= tim1- tim2;
                  fprintf( output_fp, "\n\n\n"
                        "                             "
                        "---------- MATRIX TIMING ----------\n"
                        "                               "
                        "FILL: %d msec  FACTOR: %d msec",
                        (int)tim, (int)tim2 );

                  igo=3;
                  netcx.ntsol=0;

                  /* label 53 */
                  case 3: /* excitation set up (right hand side, -e inc.) */

                  nthic=1;
                  nphic=1;
                  inc=1;
                  netcx.nprint=0;

                  /* l_54 */
                  do
                  {
                    if( (fpat.ixtyp != 0) && (fpat.ixtyp != 5) )
                    {
                        if( (iptflg <= 0) || (fpat.ixtyp == 4) )
                          fprintf( output_fp, "\n\n\n"
                                "                             "
                                "---------- EXCITATION ----------" );

                        tmp5= TA* xpr5;
                        tmp4= TA* xpr4;

                        if( fpat.ixtyp == 4)
                        {
                          tmp1= xpr1/ data.wlam;
                          tmp2= xpr2/ data.wlam;
                          tmp3= xpr3/ data.wlam;
                          tmp6= fpat.xpr6/( data.wlam* data.wlam);

                          fprintf( output_fp, "\n"
                                "                                  "
                                "    CURRENT SOURCE\n"
                                "                     -- POSITION (METERS) -- "
                                "      ORIENTATION (DEG)\n"
                                "                     X          Y          Z "
                                "      ALPHA        BETA   DIPOLE MOMENT\n"
                                "               %10.5LF %10.5LF %10.5LF "
                                " %7.2LF     %7.2LF    %8.3LF",
                                xpr1, xpr2, xpr3, xpr4, xpr5, fpat.xpr6 );
                        }
                        else
                        {
                          tmp1= TA* xpr1;
                          tmp2= TA* xpr2;
                          tmp3= TA* xpr3;
                          tmp6= fpat.xpr6;

                          if( iptflg <= 0)
                              fprintf( output_fp,
                                    "\n  PLANE WAVE - THETA: %7.2LF deg, PHI: %7.2LF deg,"
                                    " ETA=%7.2LF DEG, TYPE - %s  AXIAL RATIO: %6.3LF",
                                    xpr1, xpr2, xpr3, hpol[fpat.ixtyp-1], fpat.xpr6 );

                        } /* if( fpat.ixtyp == 4) */

                    } /* if( (fpat.ixtyp  != 0) && (fpat.ixtyp <= 4) ) */

                    /* fills e field right-hand matrix */
                    etmns( tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, fpat.ixtyp, crnt.cur);

                    /* matrix solving  (netwk calls solves) */
                    if( (netcx.nonet != 0) && (inc <= 1) )
                    {
                        fprintf( output_fp, "\n\n\n"
                              "                                            "
                              "---------- NETWORK DATA ----------" );

                        itmp3=0;
                        itmp1= netcx.ntyp[0];

                        for( i = 0; i < 2; i++ )
                        {
                          if( itmp1 == 3)
                              itmp1=2;

                          if( itmp1 == 2)
                              fprintf( output_fp, "\n"
                                    "  -- FROM -  --- TO --      TRANSMISSION LINE       "
                                    " --------- SHUNT ADMITTANCES (MHOS) ---------   LINE\n"
                                    "  TAG   SEG  TAG   SEG    IMPEDANCE      LENGTH    "
                                    " ----- END ONE -----      ----- END TWO -----   TYPE\n"
                                    "  No:   No:  No:   No:         OHMS      METERS     "
                                    " REAL      IMAGINARY      REAL      IMAGINARY" );
                          else
                              if( itmp1 == 1)
                                fprintf( output_fp, "\n"
                                      "  -- FROM -  --- TO --            --------"
                                      " ADMITTANCE MATRIX ELEMENTS (MHOS) ---------\n"
                                      "  TAG   SEG  TAG   SEG   ----- (ONE,ONE) ------  "
                                      " ----- (ONE,TWO) -----   ----- (TWO,TWO) -------\n"
                                      "  No:   No:  No:   No:      REAL      IMAGINARY     "
                                      " REAL     IMAGINARY       REAL      IMAGINARY" );

                          for( j = 0; j < netcx.nonet; j++)
                          {
                              itmp2= netcx.ntyp[j];

                              if( (itmp2/itmp1) != 1 )
                                itmp3 = itmp2;
                              else
                              {
                                int idx4, idx5;

                                itmp4= netcx.iseg1[j];
                                itmp5= netcx.iseg2[j];
                                idx4 = itmp4-1;
                                idx5 = itmp5-1;

                                if( (itmp2 >= 2) && (netcx.x11i[j] <= 0.) )
                                {
                                    long double xx, yy, zz;

                                    xx = data.x[idx5]- data.x[idx4];
                                    yy = data.y[idx5]- data.y[idx4];
                                    zz = data.z[idx5]- data.z[idx4];
                                    netcx.x11i[j]= data.wlam* sqrtl( xx*xx + yy*yy + zz*zz );
                                }

                                fprintf( output_fp, "\n"
                                      " %4d %5d %4d %5d  %11.4LE %11.4LE  "
                                      "%11.4LE %11.4LE  %11.4LE %11.4LE %s",
                                      data.itag[idx4], itmp4, data.itag[idx5], itmp5,
                                      netcx.x11r[j], netcx.x11i[j], netcx.x12r[j], netcx.x12i[j],
                                      netcx.x22r[j], netcx.x22i[j], pnet[itmp2-1] );

                              } /* if(( itmp2/ itmp1) == 1) */

                          } /* for( j = 0; j < netcx.nonet; j++) */

                          if( itmp3 == 0)
                              break;

                          itmp1= itmp3;

                        } /* for( j = 0; j < netcx.nonet; j++) */

                    } /* if( (netcx.nonet != 0) && (inc <= 1) ) */

                    if( (inc > 1) && (iptflg > 0) )
                        netcx.nprint=1;

                    netwk( cm, save.ip, crnt.cur );
                    netcx.ntsol=1;

                    if( iped != 0)
                    {
                        itmp1= 4*( mhz-1);

                        fnorm[itmp1  ]= creall( netcx.zped);
                        fnorm[itmp1+1]= cimagl( netcx.zped);
                        fnorm[itmp1+2]= cabsl( netcx.zped);
                        fnorm[itmp1+3]= cang( netcx.zped);

                        if( iped != 2 )
                        {
                          if( fnorm[itmp1+2] > zpnorm)
                              zpnorm= fnorm[itmp1+2];
                        }

                    } /* if( iped != 0) */

                    /* printing structure currents */
                    if( data.n != 0)
                    {
                        if( iptflg != -1)
                        {
                          if( iptflg <= 0)
                          {
                              fprintf( output_fp, "\n\n\n"
                                    "                           "
                                    "-------- CURRENTS AND LOCATION --------\n"
                                    "                                  "
                                    "DISTANCES IN WAVELENGTHS" );

                              fprintf( output_fp,     "\n\n"
                                    "   SEG  TAG    COORDINATES OF SEGM CENTER     SEGM"
                                    "    ------------- CURRENT (AMPS) -------------\n"
                                    "   No:  No:       X         Y         Z      LENGTH"
                                    "     REAL      IMAGINARY    MAGN        PHASE" );
                          }
                          else
                          {
                              if( (iptflg != 3) && (inc <= 1) )
                                fprintf( output_fp, "\n\n\n"
                                      "                        "
                                      "-------- RECEIVING PATTERN PARAMETERS --------\n"
                                      "                        "
                                      "         ETA: %7.2LF DEGREES\n"
                                      "                        "
                                      "         TYPE: %s\n"
                                      "                        "
                                      "         AXIAL RATIO: %6.3LF\n\n"
                                      "                        "
                                      "THETA     PHI      ----- CURRENT ----    SEG\n"
                                      "                        "
                                      "(DEG)    (DEG)     MAGNITUDE    PHASE    No:",
                                      xpr3, hpol[fpat.ixtyp-1], fpat.xpr6 );

                          } /* if( iptflg <= 0) */

                        } /* if( iptflg != -1) */

                        fpat.ploss=0.;
                        itmp1=0;

                        for( i = 0; i < data.n; i++ )
                        {
                          curi= crnt.cur[i]* data.wlam;
                          cmag= cabsl( curi);
                          ph= cang( curi);

                          if( (zload.nload != 0) && (fabsl(creall(zload.zarray[i])) >= 1.e-20) )
                              fpat.ploss += 0.5* cmag* cmag* creall( zload.zarray[i])* data.si[i];

                          if( iptflg == -1 )
                              continue;

                          if( iptflg >= 0 )
                          {
                              if( (iptag != 0) && (data.itag[i] != iptag) )
                                continue;

                              itmp1++;
                              if( (itmp1 < iptagf) || (itmp1 > iptagt) )
                                continue;

                              if( iptflg != 0)
                              {
                                if( iptflg >= 2 )
                                {
                                    fnorm[inc-1]= cmag;
                                    isave= (i+1);
                                }

                                if( iptflg != 3)
                                {
                                    fprintf( output_fp, "\n"
                                          "                      "
                                          "%7.2LF  %7.2LF   %11.4LE  %7.2LF  %5d",
                                          xpr1, xpr2, cmag, ph, i+1 );
                                    continue;
                                }

                              } /* if( iptflg != 0) */
                              else
                                fprintf( output_fp, "\n"
                                      " %5d %4d %9.4LF %9.4LF %9.4LF %9.5LF"
                                      " %11.4LE %11.4LE %11.4LE %8.3LF",
                                      i+1, data.itag[i], data.x[i], data.y[i], data.z[i],
                                      data.si[i], creall(curi), cimagl(curi), cmag, ph );

                          } /* if( iptflg >= 0 ) */
                          else
                          {
                              fprintf( output_fp, "\n"
                                    " %5d %4d %9.4LF %9.4LF %9.4LF %9.5LF"
                                    " %11.4LE %11.4LE %11.4LE %8.3LF",
                                    i+1, data.itag[i], data.x[i], data.y[i], data.z[i],
                                    data.si[i], creall(curi), cimagl(curi), cmag, ph );

                              if( plot.iplp1 != 1 )
                                continue;

                              if( plot.iplp2 == 1)
                                fprintf( plot_fp, "%12.4LE %12.4LE\n", creall(curi), cimagl(curi) );
                              else
                                if( plot.iplp2 == 2)
                                    fprintf( plot_fp, "%12.4LE %12.4LE\n", cmag, ph );
                          }

                        } /* for( i = 0; i < n; i++ ) */

                        if( iptflq != -1)
                        {
                          fprintf( output_fp, "\n\n\n"
                                "                                  "
                                "------ CHARGE DENSITIES ------\n"
                                "                                  "
                                "   DISTANCES IN WAVELENGTHS\n\n"
                                "   SEG   TAG    COORDINATES OF SEG CENTER     SEG        "
                                "  CHARGE DENSITY (COULOMBS/METER)\n"
                                "   No:   No:     X         Y         Z       LENGTH   "
                                "  REAL      IMAGINARY     MAGN       PHASE" );

                          itmp1 = 0;
                          fr = 1.e-6/save.fmhz;

                          for( i = 0; i < data.n; i++ )
                          {
                              if( iptflq != -2 )
                              {
                                if( (iptaq != 0) && (data.itag[i] != iptaq) )
                                    continue;

                                itmp1++;
                                if( (itmp1 < iptaqf) || (itmp1 > iptaqt) )
                                    continue;

                              } /* if( iptflq == -2) */

                              curi= fr* cmplx(- crnt.bii[i], crnt.bir[i]);
                              cmag= cabsl( curi);
                              ph= cang( curi);

                              fprintf( output_fp, "\n"
                                    " %5d %4d %9.4LF %9.4LF %9.4LF %9.5LF"
                                    " %11.4LE %11.4LE %11.4LE %8.3LF",
                                    i+1, data.itag[i], data.x[i], data.y[i], data.z[i],
                                    data.si[i], creall(curi), cimagl(curi), cmag, ph );

                          } /* for( i = 0; i < n; i++ ) */

                        } /* if( iptflq != -1) */

                    } /* if( n != 0) */

                    if( data.m != 0)
                    {
                        fprintf( output_fp, "\n\n\n"
                              "                                      "
                              " --------- SURFACE PATCH CURRENTS ---------\n"
                              "                                                "
                              " DISTANCE IN WAVELENGTHS\n"
                              "                                                "
                              " CURRENT IN AMPS/METER\n\n"
                              "                                 ---------"
                              " SURFACE COMPONENTS --------   "
                              " ---------------- RECTANGULAR COMPONENTS ----------------\n"
                              "  PCH   --- PATCH CENTER ---     TANGENT VECTOR 1    "
                              " TANGENT VECTOR 2    ------- X ------    ------- Y ------   "
                              " ------- Z ------\n  No:    X       Y       Z       MAG.    "
                              "   PHASE     MAG.       PHASE    REAL   IMAGINARY    REAL  "
                              " IMAGINARY    REAL   IMAGINARY" );

                        j= data.n-3;
                        itmp1= -1;

                        for( i = 0; i <data. m; i++ )
                        {
                          j += 3;
                          itmp1++;
                          ex= crnt.cur[j];
                          ey= crnt.cur[j+1];
                          ez= crnt.cur[j+2];
                          eth= ex* data.t1x[itmp1]+ ey* data.t1y[itmp1]+ ez* data.t1z[itmp1];
                          eph= ex* data.t2x[itmp1]+ ey* data.t2y[itmp1]+ ez* data.t2z[itmp1];
                          ethm= cabsl( eth);
                          etha= cang( eth);
                          ephm= cabsl( eph);
                          epha= cang( eph);

                          fprintf( output_fp, "\n"
                                " %4d %7.3LF %7.3LF %7.3LF %11.4LE %8.2LF %11.4LE %8.2LF"
                                " %9.2LE %9.2LE %9.2LE %9.2LE %9.2LE %9.2LE",
                                i+1, data.px[itmp1], data.py[itmp1], data.pz[itmp1],
                                ethm, etha, ephm, epha, creall(ex), cimagl(ex),
                                creall(ey), cimagl(ey), creall(ez), cimagl(ez) );

                          if( plot.iplp1 != 1)
                              continue;

                          if( plot.iplp3 == 1)
                              fprintf( plot_fp, "%12.4LE %12.4LE\n", creall(ex), cimagl(ex) );
                          if( plot.iplp3 == 2)
                              fprintf( plot_fp, "%12.4LE %12.4LE\n", creall(ey), cimagl(ey) );
                          if( plot.iplp3 == 3)
                              fprintf( plot_fp, "%12.4LE %12.4LE\n", creall(ez), cimagl(ez) );
                          if( plot.iplp3 == 4)
                              fprintf( plot_fp, "%12.4LE %12.4LE %12.4LE %12.4LE %12.4LE %12.4LE\n",
                                    creall(ex),cimagl(ex),creall(ey),cimagl(ey),creall(ez),cimagl(ez) );

                        } /* for( i=0; i<m; i++ ) */

                    } /* if( m != 0) */

                    if( (fpat.ixtyp == 0) || (fpat.ixtyp == 5) )
                    {
                        tmp1= netcx.pin- netcx.pnls- fpat.ploss;
                        tmp2= 100.* tmp1/ netcx.pin;

                        fprintf( output_fp, "\n\n\n"
                              "                               "
                              "---------- POWER BUDGET ---------\n"
                              "                               "
                              "INPUT POWER   = %11.4LE Watts\n"
                              "                               "
                              "RADIATED POWER= %11.4LE Watts\n"
                              "                               "
                              "STRUCTURE LOSS= %11.4LE Watts\n"
                              "                               "
                              "NETWORK LOSS  = %11.4LE Watts\n"
                              "                               "
                              "EFFICIENCY    = %7.2LF Percent",
                              netcx.pin, tmp1, fpat.ploss, netcx.pnls, tmp2 );

                    } /* if( (fpat.ixtyp == 0) || (fpat.ixtyp == 5) ) */

                    igo = 4;

                    if( yparm.ncoup > 0)
                        couple( crnt.cur, data.wlam );

                    if( iflow == 7)
                    {
                        if( (fpat.ixtyp > 0) && (fpat.ixtyp < 4) )
                        {
                          nthic++;
                          inc++;
                          xpr1 += xpr4;

                          if( nthic <= nthi )
                              continue; /* continue excitation loop */

                          nthic=1;
                          xpr1= thetis;
                          xpr2= xpr2+ xpr5;
                          nphic++;

                          if( nphic <= nphi )
                              continue; /* continue excitation loop */

                          break;

                        } /* if( (fpat.ixtyp >= 1) && (fpat.ixtyp <= 3) ) */

                        if( nfrq != 1)
                        {
                          jmp_floop = TRUE;
                          break; /* continue the freq loop */
                        }

                        fprintf( output_fp, "\n\n\n" );
                        jmp_iloop = TRUE;

                        break; /* continue card input loop */

                    } /*if( iflow == 7) */


                    case 4: /* label_71 */
                    igo = 5;

                    /* label_72 */
                    case 5: /* near field calculation */

                    if( fpat.near != -1)
                    {
                        nfpat();

                        if( mhz == nfrq)
                          fpat.near=-1;

                        if( nfrq == 1)
                        {
                          fprintf( output_fp, "\n\n\n" );
                          jmp_iloop = TRUE;
                          break; /* continue card input loop */
                        }

                    } /* if( fpat.near != -1) */


                    /* label_78 */
                    case 6: /* standard far field calculation */

                    if( gnd.ifar != -1)
                    {
                        fpat.pinr= netcx.pin;
                        fpat.pnlr= netcx.pnls;
                        rdpat();
                    }

                    if( (fpat.ixtyp == 0) || (fpat.ixtyp >= 4) )
                    {
                        if( mhz == nfrq )
                          gnd.ifar=-1;

                        if( nfrq != 1)
                        {
                          jmp_floop = TRUE;
                          break;
                        }

                        fprintf( output_fp, "\n\n\n" );
                        jmp_iloop = TRUE;
                        break;

                    } /* if( (fpat.ixtyp == 0) || (fpat.ixtyp >= 4) ) */

                    nthic++;
                    inc++;
                    xpr1 += xpr4;

                    if( nthic <= nthi )
                        continue; /* continue excitation loop */

                    nthic = 1;
                    xpr1  = thetis;
                    xpr2 += xpr5;
                    nphic++;

                    if( nphic > nphi )
                        break;

                  } /* do (l_54) */
                  while( TRUE );

                  /* jump to freq. or input loop */
                  if( jmp_iloop )
                    break;

                  if( jmp_floop )
                    continue;

                  nphic = 1;
                  xpr2  = phiss;

                  /* normalized receiving pattern printed */
                  if( iptflg >= 2)
                  {
                    itmp1= nthi* nphi;

                    tmp1= fnorm[0];
                    for( j = 1; j < itmp1; j++ )
                        if( fnorm[j] > tmp1)
                          tmp1= fnorm[j];

                    fprintf( output_fp, "\n\n\n"
                          "                     "
                          "---- NORMALIZED RECEIVING PATTERN ----\n"
                          "                      "
                          "NORMALIZATION FACTOR: %11.4LE\n"
                          "                      "
                          "ETA: %7.2LF DEGREES\n"
                          "                      "
                          "TYPE: %s\n"
                          "                      AXIAL RATIO: %6.3LF\n"
                          "                      SEGMENT No: %d\n\n"
                          "                      "
                          "THETA     PHI       ---- PATTERN ----\n"
                          "                      "
                          "(DEG)    (DEG)       DB     MAGNITUDE",
                          tmp1, xpr3, hpol[fpat.ixtyp-1], fpat.xpr6, isave );

                    for( j = 0; j < nphi; j++ )
                    {
                        itmp2= nthi*j;

                        for( i = 0; i < nthi; i++ )
                        {
                          itmp3= i + itmp2;

                          if( itmp3 < itmp1)
                          {
                              tmp2= fnorm[itmp3]/ tmp1;
                              tmp3= db20( tmp2);

                              fprintf( output_fp, "\n"
                                    "                    %7.2LF  %7.2LF   %7.2LF  %11.4LE",
                                    xpr1, xpr2, tmp3, tmp2 );

                              xpr1 += xpr4;
                          }

                        } /* for( i = 0; i < nthi; i++ ) */

                        xpr1= thetis;
                        xpr2 += xpr5;

                    } /* for( j = 0; j < nphi; j++ ) */

                    xpr2= phiss;

                  } /* if( iptflg >= 2) */

                  if( mhz == nfrq)
                    gnd.ifar=-1;

                  if( nfrq == 1)
                  {
                    fprintf( output_fp, "\n\n\n" );
                    jmp_iloop = TRUE;
                    break; /* continue card input loop */
                  }

              } /*** do (frequency loop) (l_42) ***/
              while( (++mhz <= nfrq) );

              /* Jump to card input loop */
              if( jmp_iloop )
                  break;

              if( iped != 0)
              {
                  int iss;

                  if( vsorc.nvqd > 0)
                    iss = vsorc.ivqd[vsorc.nvqd-1];
                  else
                    iss = vsorc.isant[vsorc.nsant-1];

                  fprintf( output_fp, "\n\n\n"
                        "                            "
                        " -------- INPUT IMPEDANCE DATA --------\n"
                        "                                     "
                        " SOURCE SEGMENT No: %d\n"
                        "                                  "
                        " NORMALIZATION FACTOR:%12.5LE\n\n"
                        "              ----------- UNNORMALIZED IMPEDANCE ----------  "
                        "  ------------ NORMALIZED IMPEDANCE -----------\n"
                        "      FREQ    RESISTANCE    REACTANCE    MAGNITUDE    PHASE  "
                        "  RESISTANCE    REACTANCE    MAGNITUDE    PHASE\n"
                        "       MHz       OHMS         OHMS         OHMS     DEGREES  "
                        "     OHMS         OHMS         OHMS     DEGREES",
                        iss, zpnorm );

                  itmp1= nfrq;
                  if( ifrq == 0)
                    tmp1= save.fmhz-( nfrq-1)* delfrq;
                  else
                    if( ifrq == 1)
                        tmp1= save.fmhz/( powl(delfrq, (nfrq-1)) );

                  for( i = 0; i < itmp1; i++ )
                  {
                    itmp2= 4*i;
                    tmp2= fnorm[itmp2  ]/ zpnorm;
                    tmp3= fnorm[itmp2+1]/ zpnorm;
                    tmp4= fnorm[itmp2+2]/ zpnorm;
                    tmp5= fnorm[itmp2+3];

                    fprintf( output_fp, "\n"
                          " %9.3LF   %11.4LE  %11.4LE  %11.4LE  %7.2LF  "
                          " %11.4LE  %11.4LE  %11.4LE  %7.2LF",
                          tmp1, fnorm[itmp2], fnorm[itmp2+1], fnorm[itmp2+2],
                          fnorm[itmp2+3], tmp2, tmp3, tmp4, tmp5 );

                    if( ifrq == 0)
                        tmp1 += delfrq;
                    else
                        if( ifrq == 1)
                          tmp1 *= delfrq;

                  } /* for( i = 0; i < itmp1; i++ ) */

                  fprintf( output_fp, "\n\n\n" );

              } /* if( iped != 0) */

              nfrq=1;
              mhz=1;

        } /* switch( igox ) */

      } /* while( ! next_job ): Main input section (l_14) */

  } /* while(TRUE): Main execution loop (l_1) */

  return(0);

} /* end of main() */

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

/*  Null_Pointers()
 *
 *  Nulls pointers used in mem_realloc
 */
  void
Null_Pointers( void )
{
  crnt.air = crnt.aii = NULL;
  crnt.bir = crnt.bii = NULL;
  crnt.cir = crnt.cii = NULL;
  crnt.cur = NULL;

  data.x = data.y = data.z = NULL;
  data.x1 = data.y1 = data.z1 = NULL;
  data.x2 = data.y2 = data.z2 = NULL;
  data.si = data.bi = data.sab = NULL;
  data.cab = data.salp = NULL;
  data.itag = data.icon1 = data.icon2 = NULL;
  data.px = data.py = data.pz = NULL;
  data.t1x = data.t1y = data.t1z = NULL;
  data.t2x = data.t2y = data.t2z = NULL;
  data.pbi = data.psalp = NULL;

  netcx.ntyp = netcx.iseg1 = netcx.iseg2 = NULL;
  netcx.x11r = netcx.x11i = NULL;
  netcx.x12r = netcx.x12i = NULL;
  netcx.x22r = netcx.x22i = NULL;

  save.ip = NULL;

  segj.jco = NULL;
  segj.ax = segj.bx = segj.cx = NULL;

  smat.ssx = NULL;

  vsorc.isant = vsorc.ivqd = vsorc.iqds = NULL;
  vsorc.vqd = vsorc.vqds = vsorc.vsant = NULL;

  yparm.y11a = yparm.y12a = NULL;
  yparm.ncseg = yparm.nctag = NULL;

  zload.zarray = NULL;

} /* Null_Pointers() */

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

/* prnt sets up the print formats for impedance loading */
void prnt( int in1, int in2, int in3, long double fl1, long double fl2,
               long double fl3, long double fl4, long double fl5,
               long double fl6, char *ia, int ichar )
{
  /* record to be output and buffer used to make it */
  char record[101+ichar*4], buff[15];
  int in[3], i1, i;
  long double fl[6];

  in[0]= in1;
  in[1]= in2;
  in[2]= in3;
  fl[0]= fl1;
  fl[1]= fl2;
  fl[2]= fl3;
  fl[3]= fl4;
  fl[4]= fl5;
  fl[5]= fl6;

  /* integer format */
  i1=0;
  strcpy( record, "\n " );

  if( (in1 == 0) && (in2 == 0) && (in3 == 0) )
  {
      strcat( record, " ALL" );
      i1=1;
  }

  for( i = i1; i < 3; i++ )
  {
      if( in[i] == 0)
        strcat( record, "     " );
      else
      {
        snprintf( buff, 6, "%5d", in[i] );
        strcat( record, buff );
      }
  }

  /* floating point format */
  for( i = 0; i < 6; i++ )
  {
      if( fabsl( fl[i]) >= 1.0e-20 )
      {
        snprintf( buff, 15, " %11.4LE", fl[i] );
        strcat( record, buff );
      }
      else
        strcat( record, "            " );
  }

  strcat( record, "   " );
  strcat( record, ia );
  fprintf( output_fp, "%s", record );

  return;
}

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

static void sig_handler( int signal )
{
  fprintf( stderr, "\n" );
  switch( signal )
  {
      case SIGINT :
        fprintf( stderr, "%s\n", "nec2c: exiting via user interrupt" );
        exit( signal );

      case SIGSEGV :
        fprintf( stderr, "%s\n", "nec2c: segmentation fault" );
        exit( signal );

      case SIGFPE :
        fprintf( stderr, "%s\n", "nec2c: floating point exception" );
        exit( signal );

      case SIGABRT :
        fprintf( stderr, "%s\n", "nec2c: abort signal received" );
        exit( signal );

      case SIGTERM :
        fprintf( stderr, "%s\n", "nec2c: termination request received" );

        stop( signal );
  }

} /* end of sig_handler() */

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


Generated by  Doxygen 1.6.0   Back to index