[Elecraft] Elecraft CW Net Report

[kevin]

Good Evening,

    Conditions were so so.  Moderate, slow QSB with a steady hiss.  On 
twenty meters the signals were all down a bit, but my reach was better.  
Forty meters was noisier with deeper QSB.

    I rewrote some antenna modelling code I created a long time ago.  
Unwrapping the dipole algorithm was not too difficult.  Then I got to 
the 1/4 wave vertical algorithm.  The electric field equation has an 
exponential raised to an imaginary power.  Euler's identity unwraps that 
into real and an imaginary parts.  Normally you ignore the imaginary 
part.  The resulting function creates its own problems by generating 
some unreal lobes.  I'm trying to figure out how space can have a volume 
with less than no electric field.  Hence the guards on my output.  
However, this code creates the electric field pattern of a 1/4 wave 
dipole antenna which matches standard antenna modeling images.

   On 14050.5 kHz at 2200z:

W0CZ - Ken - ND

NO8V - John - MI

K4JPN - Steve - GA

K6XK - Roy - IA


   On 7047.5 kHz at 0000z:

K0DTJ - Brian - CA

WM5F - Dwight - ID

K6PJV - Dale - CA


Until next week 73,

    Kevin.  KD5ONS



-





// vertical.c
// K. J. Rock
// August 27, 2023

//  g++ -o vert vertical.c

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

#define ETA  376.991118308                // characteristic impedance of 
free space
#define RAD 0.017453293                    // radian to degree
#define PI  3.1415926535                     // cherry, of course
#define TWOPI  6.28318530718            // Katzenjammer feast

struct pt                                                  // 4 space vector
     {
     float w, x, y, z;
     }  arc[20], vert[1300];                // buffers for template and 
pattern

int main( void )
     {
     int i=0;                                       // template index
     float f = 100;                              // frequency in MHz
     float lambda = 300 / f;               // wavelength in meters
     float l = lambda / 4;                   // length of antenna in meters
     float k = TWOPI / lambda;          // save some space
     float h = 1.0;                              // height of antenna in 
wavelengths
     float I0 = 2;                                // maximum current in 
amperes
     float r = 1000;                            // distance from antenna 
to observer in meters
     float dTheta = 5.0;                     // azimuth step size
     float dPhi = 5.0;                         // elevation step size
     float scale = 1.0;                        // fudge factor for 
display purposes
     float radius;                                // E(θ,φ)  in 
Volt/meter  or Newton/Coulomb

    // create one set of points in the X,Y plane at θ = 0
     for (float phi=0; phi<90; phi += dPhi)        // elevation NOT azimuth
       {
       radius = scale * cos(k * r)
                * (k * l * ETA * I0 * cos(phi * RAD) * cos(h * k * 
sin(phi * RAD)))
                / (TWOPI * r);

          // store X,Y in arc[] of struct pt
       if (radius > 0)                   // remove negative lobes
           {
          printf("%7.4f ", radius );             // E(θ,φ)   where θ = 0
          arc[i].x = radius*cos(phi*RAD);  // store phi, radius in X,Y 
coordinates
          arc[i].y = radius*sin(phi*RAD);
          arc[i++].z = 0.0;                        // at Z = 0
          }

       radius = scale * sin(k * r)
                   * (k * l * ETA * I0 * cos(phi * RAD) * cos(h * k * 
sin(phi * RAD)))
                   / (TWOPI * r);

         if (radius > 0)                   // remove negative lobes
          {
          printf("%7.4f ", radius );                // E(θ,φ) where θ = 0
             arc[i].x = radius*cos(phi*RAD);  // store radius in X,Y 
coordinates with Z = 0
          arc[i].y = radius*sin(phi*RAD);
          arc[i++].z = 0.0;                           // count vertices 
per slice
          }
       }
    printf("\n%3d points in the template\n", i);

// sweep the X,Y arc[] template around the Y axis
// vert[] is indexed serially, there are no delimiters between slices
       int m = 0;                                // count vertices
    for (int j=0; j<i; j++)                  // step from the bottom to 
the top (0 to 90 degrees)
       {
       for (float theta=0; theta<360; theta += dTheta)
          {
          vert[m].x = arc[j].x * cos(theta*RAD);
          vert[m].y = arc[j].y;
          vert[m++].z = arc[j].x * sin(theta*RAD);
          }
       }
     printf("%4d vertices in radiation pattern\n", m);     // vertex count
     return m;
     }