Good Evening,

    It was a much less gloomy week.  In fact it was downright sunny.  Cold though, at least for here.  Last night it dropped into the high teens.  It did get above freezing today but not by much.  The bird basin has not thawed.  The elk have carved a new path just inside a younger stand of trees nearby.  The hunters have been plentiful so they change their habits and don't cross the roads until well after dark.

   The sun is quite speckled, active with current and impending events.  The sunspot number and the solar flux are both high, 184 and 178 respectively.  We are also in the midst of the CQ WW DX contest.  I may not be able to find an open space for the twenty meter net.  However, the contest will terminate right at the forty meter net's time.  Again, I will seek an open frequency.



Please join us on (or near):

14050 kHz at 2300z Sunday  (3 PM PST Sunday)
 7047 kHz at 0100z Monday  (5 PM PST Sunday)



73,
      Kevin.  KD5ONS





-





   I am teaching a multi-layered, cylindrical, spring-node mesh how to be elastic. These are the elastic functions, based on Hooke's law and Newton's first.  I will merge a few of the loops to hasten recovery time.  I have implemented a heat gradient function for various heating (cooling) geometries to add some color.  Now to invent some creative impulse functions to deform the mesh.


float Req = 15.0;                                       // Radial equilibrium spacing between nodes float Teq = 10.0;                                        // Torsion spring spacing at equilibrium float Aeq = 20.0;                                       // Axial spring spacing

void map( void )                                        // accumulate applied forces
    {
    float RLc, RGc, TLc, TGc;                       // local, global change rotation, torsion
    struct node *tmp;                                  // shorten name
    struct node *m1 = m1head;                  // M1 node buffer

        // Axial
    struct pt L, R;                                        // left, right force vectors     float Ka = 0.95;                                     // Axial spring constant
    for(int k=0; k<thick; k++)                    // step by cylinder
        for(int j=1; j<leng-1; j++)                // step by ring    guard ends
            for(int i=0; i<ring; i++)                // step around ring
                {
                tmp = (m1 +k*leng*ring +j*ring +i);

                L = vecMinusVec( tmp->X, (m1 +k*leng*ring +(j-1)*ring +i)->X );                 R = vecMinusVec( tmp->X, (m1 +k*leng*ring +(j+1)*ring +i)->X );

                float mag1 = Aeq - length( L );    // L magnitude
                float mag2 = Aeq - length( R );    // R magnitude
                tmp->FA = vecMult( vecPlusVec( scale( L, mag1 ), scale( R, mag2 ) ), Ka );
                }

        // Radial
    struct pt C;                                            // center of this ring     struct pt N;                                            // temporary line segment     struct pt In, Out;                                    // vector to inner, vector to outer     float Kr = 0.33;                                      // radial spring constant
    for(int k=0; k<thick; k++)                    // step by cylinder
        for(int j=0; j<leng; j++)                    // step along cylinder
            {        // Need center to create line segments
            C = vector( (m1 +k*leng*ring +j*ring)->X.x, 0, 0); // at i=0;
            for(int i=0; i<ring; i++)                // step around cylinder
                {
                    // Extract node location
                N = (m1 +k*leng*ring +j*ring +i)->X;

                    // Difference between N and the next inner cylinder
                if( k==0 )
                    In = vector(0.0, 0.0, 0.0);      // inner node
                else
                    In = vecMinusVec( N, (m1 +(k-1)*leng*ring +j*ring +i)->X );
                    // Difference between N and the next outer cylinder
                if( k==thick-1 )
                    Out = vector( 0.0, 0.0, 0.0 ); // outer node
                else
                    Out = vecMinusVec( (m1 +(k+1)*leng*ring +j*ring +i)->X, N );

                    // Calculate local and global differences
                RLc = length( Out ) - length( In );
                RGc = (r0 +k*Req) - length( vecMinusVec( N, C ) );

                    // Radial restoring force
                (m1 +k*leng*ring +j*ring +i)->Fr = Kr * ( RGc + RLc );
                }
            }

        // Torsional
    float Dm, Dp;                                           // angle to neighbor -/+ directions     float Kt = 0.37;                                        // torsional spring constant
    for(int k=0; k<thick; k++)                      // step by cylinder
        for(int j=0; j<leng; j++)                      // step along cylinder             for(int i=0; i<ring; i++)                   // step around cylinder
                { //        { 0 <= ring <= 35 }
                if( i-1 == -1 )                               // guard -1 = 35        -1 = ring-1                     Dm = (360.0 + (m1 +k*leng*ring +j*ring)->pa) - (m1 +k*leng*ring +j*ring+35)->pa;
                else // angular distance to previous node
                    Dm = (m1 +k*leng*ring +j*ring +i)->pa - (m1 +k*leng*ring +j*ring +i-1)->pa;

                if( i+1 == ring )                            // guard 36 = 0        i+1 = 36                     Dp = (360.0 + (m1 +k*leng*ring +j*ring)->pa) - (m1 +k*leng*ring +j*ring+35)->pa;
                else // angular distance to next node
                    Dp = (m1 +k*leng*ring +j*ring +i+1)->pa - (m1 +k*leng*ring +j*ring +i)->pa;

                Dm = Teq - Dm;                            // set circumferential metric                 Dp = Teq - Dp;                              // +/- = compression / tension
                if( Dp < -359.9 ) Dp += 360;        // bound endpoints
                if( Dp > 359.9 )  Dp -= 360;
                if( Dm < -359.9 ) Dm += 360;
                if( Dm > 359.9 )  Dm -= 360;
                TLc = Dm - Dp;                            // local change

                if( i==35 )                                   // global change
                    TGc = (i*Teq) - (m1 +k*leng*ring +j*ring +i)->pa;
                else
                    { // preferred angle - present angle
                    TGc = (i*Teq) - (m1 +k*leng*ring +j*ring +i)->pa;
                    if( TGc < -340.0 )   TGc += 360.0; // MAX twist is 20 degrees
                    }

                    // Torsional restoring force
                (m1 +k*leng*ring +j*ring +i)->Ft = Kt * ( TGc + TLc );
                }

    if( data2 )
        {            // sample at (thick-2, 2, 1)
        tmp = (m1 +(thick-2)*leng*ring +2*ring +1);
        printf("Fr %9.4f   Ft %9.4f   ", tmp->Fr, tmp->Ft );
        printf("FA %9.4f %9.4f %9.4f \n", tmp->FA.x, tmp->FA.y, tmp->FA.z );
        }
    }

void restore( void )                                    // move node to relieve forces on it
    {
    float rho, Rr;                                          // current and new radii
    struct pt X = vector( 0.0, 0.0, 0.0 );      // axial restoration
    struct pt C;                                            // center and working vector     struct node *m1 = m1head;                  // point at head of spring mass mesh memory
    struct node *tmp;                                  // shorten name

    for(int k=0; k<thick; k++)                    // step by cylinder
        for(int j=0; j<leng; j++)                    // step by ring  guard ends
            { // center the i=0 point
            C = vector( (m1 +k*leng*ring +j*ring)->X.x, 0, 0 );
            for(int i=0; i<ring; i++)                // step around ring
                {                                               // spring restoration
                tmp = m1 +k*leng*ring+j*ring+i;    // shorten name

                    // torsional portion                 X = F/m *dt*dt
                tmp->pa += (tmp->Ft / m) *dt*dt;    // current angle plus change                 if( tmp->pa > 359.9 )     tmp->pa -= 360.0;    // bound result
                if( tmp->pa < -359.9 )     tmp->pa += 360.0;

                    // radial portion
                rho = length( vecMinusVec( tmp->X, C ));  // current radius                 Rr = rho + (tmp->Fr / m) *dt*dt;     // current radius plus change

                    // axial portion
                X = vecPlusVec( tmp->X, vecMult( vecDiv( tmp->FA, m ), dt*dt ));                 X.z = Rr * cos( tmp->pa * RAD );    // convert Rr,->pa to Y,Z location
                X.y = Rr * sin( tmp->pa * RAD );
                tmp->X = X; // update changes
                }
            }
    }



"How old are you?  I mean really, you are old now, aren't you?"

"For an apricot, yes.  For a head of lettuce, even more so.
For a mountain, I have not even begun in years.  For a man, I am just right."



______________________________________________________________
Elecraft mailing list
Home: http://mailman.qth.net/mailman/listinfo/elecraft
Help: http://mailman.qth.net/mmfaq.htm
Post: mailto:Elecraft@mailman.qth.net

This list hosted by: http://www.qsl.net
Please help support this email list: http://www.qsl.net/donate.html
Message delivered to arch...@mail-archive.com 

Reply via email to