/*
    This file is part of the FElt finite element analysis package.
    Copyright (C) 1993-2000 Jason I. Gobat and Darren C. Atkinson

    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 2 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program; if not, write to the Free Software
    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/

/************************************************************************
 * File:	timoshenko.c						*
 *									*
 * Description:	This file contains the definition structure and		*
 *		stiffness function for a Timoshenko beam element.	*
 ************************************************************************/

# include <math.h>
# include "allocate.h"
# include "fe.h"
# include "error.h"
# include "misc.h"

	/*	
         * Here's the definition structure.  This is a very simple
         * implementation, 2 nodes, possible effect on 3 global DOF
         * per node.  We need to prototype the setup and stress functions
         * thing so we can use them in the definition declaration.
	 */

int timoshenkoEltSetup ( );
int timoshenkoEltStress ( );

struct definition timoshenkoDefinition = {
    "timoshenko",
    timoshenkoEltSetup,
    timoshenkoEltStress,
    Linear, 			/* The shape of this element		   */
    2, 				/* 2 nodes per element			   */
    2, 				/* 2 nodes define the shape (it's a line!) */
    2, 				/* 2 magnitudes in each stress structure   */
    3, 				/* 3 global DOF / node			   */
   {0, 1, 2, 6, 0, 0, 0},      	/* DOF 1 is Tx, DOF 2 is Ty DOF 3 is Rz .. */
    1				/* retain stiffness after assembling	   */
};

	/*
	 * We'll declare these three functions as static because other
	 * people might use these same names for their element.  The
	 * static declaration makes them private to this file.
	 * There is nothing magical about them.  They could be called
	 * anything, your element may not use any local functions,
	 * etc., etc.  It's all a matter of preference and style. 
	 */

static Matrix LocalK ( );
static Matrix TransformMatrix ( );
static Matrix LumpedMassMatrix ( );
static Matrix ConsistentMassMatrix ( );
static int    EquivNodalForces ( );

	/*
	 * The element setup function (the one that the general
	 * routines actually call to define element -> K for
	 * Timoshenko beams).  We'll break it up a little more
	 * for our own internal purposes and call some functions
	 * of our own to actually fill out the guts of the thing.
	 */

int timoshenkoEltSetup (element, mass_mode, tangent)
    Element	   element;
    char	   mass_mode;
    int	           tangent;
{
    int 	   count;	/* a count of errors encountered	   */
    Matrix	   T;		/* transform matrix			   */
    Matrix	   khat;	/* local coordinate stiffness matrix	   */
    Matrix         mhat; 	/* local coordinate mass matrix		   */
	
	/*
	 * Since we're nice and we like to do as much error checking
	 * as possible, we'll also check to make sure that all necessary
	 * material properties are set for this element
	 */

    count = 0;
    if (element -> material -> E == 0.0) {
        error ("timoshenko element %d has 0.0 for Young's modulus (E)",
               element -> number);
        count++;
    }
    if (element -> material -> Ix == 0.0) {
        error ("timoshenko element %d has 0.0 for moment of inertia (Ix)",
               element -> number);
        count++;
    }
    if (element -> material -> G == 0.0) {
        error ("timoshenko element %d has 0.0 for bulk modulus (G)",
               element -> number);
        count++;
    }
    if (element -> material -> A == 0.0) {
        error ("timoshenko element %d has 0.0 for cross-section area (A)",
               element -> number);
        count++;
    }
   
	/*
	 * nu and kappa are somewhat special because we have to have
	 * at least one.  If we have nu we'll use it to estimate
	 * element -> kappa according to Cowper's (1966) approximation.
	 * If we have kappa we will of course always use it.  If
	 * we have neither, it's an error
	 */

    if (element -> material -> kappa == 0.0) {
        if (element -> material -> nu == 0.0) {
            error ("timoshenko element %d has 0.0 for Poisson's ratio (nu)",
                   element -> number);
            count++;
        }
        else {
            element -> material -> kappa = 
                 10.0*(1.0 + element -> material -> nu)/
                 (12.0 + 11.0*element -> material -> nu);
        }
    }

	/*
	 * if we've had any errors there is no point in continuing
	 */

    if (count)
        return count;

	/*
	 * get the local stiffness matrix and the transform matrix.
	 * we never allocated any memory for these two because the
	 * functions that we are calling will do that.
	 */

    khat = LocalK (element);
    if (khat == NullMatrix)
       return 1;
 
    T = TransformMatrix (element);

	/*
	 * We can form the element stiffness matrix now through
	 * some simple matrix multiplications.  I like to create
	 * it first just for clarity and to make sure the allocation
	 * went OK (the multiply routine could do it for me, but ...).
 	 * The multiply function here just saves us having to allocate
	 * some temporary space and actually transposing the transform
	 * matrix, it will simply carry out k = T(trans) * K * T
	 */

    if (element -> K == NullMatrix)
       element -> K = CreateMatrix (6,6);

    MultiplyAtBA (element -> K, T, khat);

	/*
	 * Things can get a little tricky here; we'll check if there
	 * are any distributed loads - if there are we need to resolve
	 * them and modify this element's node's equivalent nodal forces.
	 * If not we're home free and we can bail.  In this case I have
	 * relegated all the distributed load handling to a separate
	 * little module.
	 */

    if (element -> numdistributed > 0) {
        count = EquivNodalForces (element, T, NULL, 1);

        if (count)
            return count;
    }
	
	/* 
	 * there's also the possibility that some of this element's nodes
	 * have a hinged DOF ... that's easy to deal with we have a
	 * convenience routine to do all the checking and modifying for us.
	 */

    ResolveHingeConditions (element);

	/*
	 * check to see if we need to form a mass matrix
	 */

    if (mass_mode) {
        if (mass_mode == 'c')
           mhat = ConsistentMassMatrix (element);
        else if (mass_mode == 'l')
           mhat = LumpedMassMatrix (element);
        else
           mhat = NullMatrix;

        if (mhat == NullMatrix)
           return 1;

        if (element -> M == NullMatrix)
           element -> M = CreateMatrix (6,6);

        MultiplyAtBA (element -> M, T, mhat);
    }

	/*
	 * we made it here, everything must have worked!
	 */

    return 0;
}

	/*
	 * The element stress function that actually gets called
	 * to fill in the element's stress structures.  I realize
	 * that a lot of this seems awfully inefficient ... beam type
	 * elements are a bit of an anomaly because they need their
	 * stiffness matrix back and a bunch of local<->global transforms.
	 */

int timoshenkoEltStress (element)
    Element	    element;
{
    unsigned	    i;			/* loop index			 */
    int		    count;		/* count of errors		 */
    static Vector   dlocal = NULL;	/* local nodal displacements	 */
    static Vector   d;			/* global nodal displacements	 */
    static Vector   f;  		/* actual internal forces	 */
    Vector	    equiv;		/* equivalent nodal forces	 */
    Matrix	    T;			/* transform matrix		 */
    static Matrix   khat;		/* local stiffness matrix	 */
    static Matrix   Tt;			/* transpose of transform	 */

	/*
	 * our usual trick to set-up the matrices and vectors that
	 * we need memory for, but that are really just local to this function.
	 */

    if (dlocal == NULL) {
        dlocal = CreateVector (4);
        d = CreateVector (6);
        f = CreateVector (4);
        khat = CreateMatrix (4,4);
        Tt = CreateMatrix (6,4);
    }
        
	/*
	 * set the number of points where we will calculate stresses.
	 * In this case it's two (one at each end).
	 */

    element -> ninteg = 2;

    	/*
	 * Fill out a vector with the element's nodal displacements.
	 * These are in global coordinates of course.  We need to
	 * do a transformation to get them into local coordinates.
	 */

    VectorData (d) [1] = element -> node[1] -> dx[Tx];
    VectorData (d) [2] = element -> node[1] -> dx[Ty];
    VectorData (d) [3] = element -> node[1] -> dx[Rz];
    VectorData (d) [4] = element -> node[1] -> dx[Tx];
    VectorData (d) [5] = element -> node[2] -> dx[Ty];
    VectorData (d) [6] = element -> node[2] -> dx[Rz];

    T = TransformMatrix (element);

    MultiplyMatrices (dlocal, T, d);
   
    	/*
	 * We already have the element stiffness matrix because we
	 * set element -> retainK = 1 in the definition structure.  This
	 * means that the global stiffness assembly routine didn't
	 * trash element -> K after it was done with it and we can
	 * use it again.  We will have to transform it back to local
	 * coordinates, however.
	 */

    TransposeMatrix (Tt, T);

    MultiplyAtBA (khat, Tt, element -> K);

	/*
	 * we can get the internal force vector through a simple
	 * matrix multiplication.
	 */

    MultiplyMatrices (f, khat, dlocal);

	/*
	 * Of course, we may need to modify that for equiv nodal forces
	 */

    if (element -> numdistributed > 0) {
        count = EquivNodalForces (element, NULL, &equiv, 2);
        if (count)
            return count;

        for (i = 1; i <= 4; i++)
            VectorData (f) [i] -= VectorData (equiv) [i];
    }

	/*
	 * set-up some memory for the stress structure and for the values
	 * in the stress structure.  We'll just use a quicky little
	 * convenience routine to do it for us.  It's important to
	 * set element -> ninteg before we call this function.
	 */

    SetupStressMemory (element);

	/*
	 * establish the location of the stresses and the magnitudes
	 * of the stresses at each point.  This particular loop
	 * only works because there are two stress points and two
	 * stress values at each point.
	 */


    for (i = 1; i <= 2; i++) {
        element -> stress[i] -> x = element -> node[i] -> x;
        element -> stress[i] -> y = element -> node[i] -> y;

        element -> stress[1] -> values[i] = VectorData (f)[i];
        element -> stress[2] -> values[i] = VectorData (f)[i+2];
    }
    
    return 0; 
}
   
	/* 
	 * Our own function to define the stiffness matrix in
	 * local coordinates.
	 */

static Matrix LocalK (element)
    Element	  element;
{
    static Matrix k = NULL;	/* the local stiffness matrix	       */
    double	  L;		/* the element length		       */
    double	  phi;		/* bending stiffness / shear stiffness */
    double	  factor;	/* common factor in stiffness matrix   */

    	/*
	 * Our same old trick to make sure we only allocate this memory
	 * once and then use it over and over again each time we need to
	 * create an element of this kind.
	 */

    if (k == NULL) 
        k = CreateMatrix (4,4);

    L = ElementLength (element, 2);
    if (L <= TINY) {
        error ("length of element %d is zero to machine precision",
               element -> number);
        return NullMatrix;
    }   

    phi = 12.0/(L*L)*(element -> material -> E*element -> material -> Ix/
                      (element -> material -> kappa*
                       element -> material -> G*element -> material -> A));

    	/*
	 * We know how the integration works out for the stiffness
	 * matrix so we're just going to fill it out an entry at
	 * a time.  For some element types this wouldn't be possible and
	 * we would do some integrating right here to fill in k.
	 * Also, because this is a symmetric matrix we'll just
	 * fill in everything above the diagonal and then use MirrorMatrix
	 */

   MatrixData (k) [1][1] = 12.0;
   MatrixData (k) [1][2] = 6.0*L;
   MatrixData (k) [1][3] = -12.0;
   MatrixData (k) [1][4] = 6.0*L;
   MatrixData (k) [2][2] = (4.0 + phi)*L*L;
   MatrixData (k) [2][3] = -6.0*L;
   MatrixData (k) [2][4] = (2.0 - phi)*L*L;
   MatrixData (k) [3][3] = 12.0;
   MatrixData (k) [3][4] = -6*L;
   MatrixData (k) [4][4] = (4.0 + phi)*L*L;

   MirrorMatrix (k);

	/*
	 * the above numbers aren't quite right, we've got a term out
	 * front of the matrix that we need to scale the entire
	 * matrix by
	 */

   factor = (element -> material -> E*element -> material -> Ix)/
            ((1.0 +phi)*L*L*L);

   ScaleMatrix (k, k, factor, 0.0);

	/*
	 * that's all for this part
	 */

   return k;
}

	/* 
	 * much like the local K function above all we do here is fill in
	 * the mass matrix - this function fills it out for consistent
	 * mass, the following function is used if the user wanted a lumped
	 * mass
	 */

static Matrix ConsistentMassMatrix (element)
    Element	   element;
{
    static Matrix m = NULL;       /* the local stiffness matrix	          */
    double	  L;		  /* the element length		          */
    double	  phi;		  /* bending stiffness / shear stiffness  */
    double        phi2;           /* phi squared		          */
    double	  const1;	  /* constant term for rotational mass    */
    double	  const2;	  /* constant term for translational mass */

    if (m == NULL) 
        m = CreateMatrix (4, 4);

	/*
	 * the constants that we'll need, including the constant terms
	 * in front of the rotational (first terms) and translational
	 * (second terms) portions of the matrix.
	 */

    L = ElementLength (element, 2);
    phi = 12.0/(L*L)*(element -> material -> E*element -> material -> Ix/
                      (element -> material -> kappa*
                       element -> material -> G*element -> material -> A));
    phi2 = phi*phi;
    const1 = element -> material -> rho * element -> material -> Ix /
             (30.0*(1.0 + phi)*(1.0 + phi)*L);
    const2 = element -> material -> rho * element -> material -> A * L /
             (210.0*(1.0 + phi)*(1.0 + phi));

	/*
	 * fill out the top half of the mass matrix (no need to 
	 * explicitly integrate of course)
	 */

   MatrixData (m) [1][1] = 36.0*const1 + (70.0*phi2 + 147.0*phi + 78)*const2;
   MatrixData (m) [1][2] = -L*(15.0*phi - 3.0)*const1 + 
                           (35.0*phi2 + 77.0*phi + 44.0)*L/4.0*const2;
   MatrixData (m) [1][3] = -36.0*const1 + (35.0*phi2 + 63.0*phi + 27.0)*const2;
   MatrixData (m) [1][4] = -L*(15.0*phi - 3.0)*const1 - 
                           (35.0*phi2 + 63.0*phi + 26.0)*L/4.0*const2;
   MatrixData (m) [2][2] = (10.0*phi2 + 5.0*phi + 4)*L*L*const1 +
                           (7.0*phi2 + 14.0*phi + 8.0)*L*L/4.0*const2;
   MatrixData (m) [2][3] = -MatrixData (m) [1][4];
   MatrixData (m) [2][4] = (5.0*phi2 - 5.0*phi - 1.0)*L*L*const1 -
                           (7.0*phi2 + 14.0*phi + 6.0)*L*L/4.0*const2;
   MatrixData (m) [3][3] = 36.0*const1 + (70.0*phi2 + 147.0*phi + 78.0)*const2;
   MatrixData (m) [3][4] = -MatrixData (m) [1][2];
   MatrixData (m) [4][4] = (10.0*phi2 + 5.0*phi + 4.0)*L*L*const1 +
                           (7.0*phi2 + 14.0*phi + 8.0)*L*L/4.0*const2;

	/*	
	 * complete it by mirroring
	 */

   MirrorMatrix (m);

	/*
	 * and we're done;
	 */

   return m;
}

static Matrix LumpedMassMatrix (element)
    Element	   element;
{
    static Matrix m = NULL;       /* the local stiffness matrix	 */
    double	  factor ;	  /* constant term		 */
    double	  I_factor;
    double	  L;

    if (m == NULL) {
        m = CreateMatrix (4, 4);
        ZeroMatrix (m);
    }

    L = ElementLength (element, 2);
    factor = L * element -> material -> rho * element -> material -> A / 2;
    I_factor = factor*L*L/12.0;

    MatrixData (m) [1][1] = factor;
    MatrixData (m) [2][2] = I_factor;
    MatrixData (m) [3][3] = factor;
    MatrixData (m) [4][4] = I_factor;

    return m;
}

	/*
	 * a simple little function to compute the transform matrix
	 * for a simple 2d beam element with no axial DOF.
	 * This should be a convenience routine, but none of the other
	 * elements actually use this one because they are more complicated.
	 */

static Matrix TransformMatrix (element)
    Element	   element;
{
    double         s,c; 	/* direction cosines			*/
    static Matrix  T = NULL; 	/* transform matrix to return		*/
    double	   L;		/* element length			*/

	/*
	 * no surprise here, we only want to allocate memory for this
	 * guy once!
	 */

    if (T == NULL) 
       T = CreateMatrix (4,6);

	/*
	 * This is a pretty sparse matrix so we'll just zero it out
	 * then fill in the few relevant entries. 
	 */

    ZeroMatrix (T);

    L = ElementLength (element, 2);
    c = (element -> node[2] -> x - element -> node[1] -> x) / L;
    s = (element -> node[2] -> y - element -> node[1] -> y) / L;

    MatrixData (T) [1][1] = -s;
    MatrixData (T) [1][2] = c;
    MatrixData (T) [2][3] = 1.0;
    MatrixData (T) [3][4] = -s;
    MatrixData (T) [3][5] = c;
    MatrixData (T) [4][6] = 1.0;

    return T;
}

	/*
  	 * We need to compute the equivalent nodal load
  	 * vector here. Just for convenience we are going to call 
	 * this function in two different ways (mode=1 and mode=2).
	 * The first way is for the element stiffness function
	 * which just wants to get the forces applied to the 
	 * element's nodes.  The second is for the stress routine
	 * which actually needs the equiv force vector in local coordinates.
	 * There are lots of ways to handle all these cases;
	 * see the Bernoulli beam elements for example. In mode 1,
	 * eq_stress can be NULL, in mode 2, T can be NULL.
	 */

static int EquivNodalForces (element, T, eq_stress, mode)
    Element	   element;
    Matrix	   T;			/* passing it in saves a few FLOPs */ 
    Vector	   *eq_stress;		/* vector pointer to set in mode 2 */
    int		   mode;		/* mode of operation		   */
{
    static Vector  equiv = NULL;	/* the equiv vector in local coord */
    static Vector  eq_global;		/* equiv in global coordinates     */
    double	   wa, wb;		/* values of load at nodes	   */
    double	   L;			/* the element length		   */
    unsigned	   i,j;			/* some loop conuters		   */
    double	   factor;		/* constant factor for sloped load */
    double	   phi;			/* bending / shear stiffness	   */
    int		   count;		/* error count			   */
    static Matrix  Tt;			/* transpose of transform matrixi  */

    if (equiv == NULL) {
        equiv     = CreateVector (4);
        eq_global = CreateVector (6);
        Tt	  = CreateMatrix (6,4);
    }

    ZeroMatrix (equiv);

    count = 0;
    wa = wb = 0; /* gcc -Wall */

	/*
	 * Again, we want to do as much error checking and descriptive
	 * error reporting as possible.  Seem like overkill?  It probably
	 * is, but it's not hurting anybody either :-)
	 */

    if (element -> numdistributed > 2) {
       error ("Timoshenko beam element %d has more than 2 distributed loads",
              element -> number);
       count++;
    }

    L = ElementLength (element, 2);
    if (L <= TINY) {
        error ("length of element %d is zero to machine precision",
               element -> number);
        count++;
    }   

    for (i = 1; i <= element -> numdistributed; i++) {
        if (element -> distributed[i] -> nvalues != 2) {
            error ("Timoshenko beam element %d must have 2 values for load",
                   element -> number);
            count++;
        }

	/*
	 * We only want to deal with loads in the perpendicular (LocalY)
	 * direction ... this is a very simple instantiation of this
	 * element after all.
	 */

        if (element -> distributed[i] -> direction != LocalY &&
            element -> distributed[i] -> direction != Perpendicular) {
        
            error ("invalid direction for element %d distributed load",
                   element -> number);
            count++;
        }
              
	/*
	 * make sure that the user isn't try to apply part of this
	 * load to a non-existent node (some local node other than
	 * number 1 or 2)
	 */

        for (j = 1 ;j <= element -> distributed[i] -> nvalues; j++) {
            if (element -> distributed[i] -> value[j].node < 1 ||
                element -> distributed[i] -> value[j].node > 2) {

                error ("invalid node numbering for elt %d distributed load %s",
                       element -> number, element -> distributed[i] -> name);
                count++;
            }
        }

        if (element -> distributed[i] -> value[1].node ==
            element -> distributed[i] -> value[2].node) {

            error ("incorrect node numbering for elt %d distributed load %s",
                   element -> number, element -> distributed[i] -> name);
            count++;
        }
    }

	/* 
	 * Have we had any errors? If so bail out.
 	 */

    if (count) 
        return count;

    phi = 12.0/(L*L)*(element -> material -> E*element -> material -> Ix/
                      (element -> material -> kappa*
                       element -> material -> G*element -> material -> A));

	/*
	 * loop over all of the applied distributed loads, superposing
	 * the effects of each
	 */

    for (i = 1 ; i <= element -> numdistributed ; i++) {

	/*
	 * First we have to sort out what order the load values
	 * were supplied in.  We need to get it so that wa is
	 * the value on element node 1 and wb is the value on 
	 * element node 2.
	 */

        if (element -> distributed[i] -> value[1].node == 1) {
            wa = element -> distributed[i] -> value[1].magnitude;
            wb = element -> distributed[i] -> value[2].magnitude;
        }
        else if (element -> distributed[i] -> value[1].node == 2) {
            wb = element -> distributed[i] -> value[1].magnitude;
            wa = element -> distributed[i] -> value[2].magnitude;
        }

	/*
	 * Again, since we know how the integration turns out, we'll
	 * just go head and plug straight into the entries in the equiv
	 * vector.  The order of entries in equiv is Fy1,Mz1,Fy2,Mz2.
	 * There are three cases we need to deal with.  The first is 
	 * a uniform load.  The second two are sloped loads which we'll
	 * treat as the superposition of the uniform case and a case
	 * in which the load can be treated as q(x) = q0*(1 - x/L)
	 * (i.e., a load which goes from q0 to 0)
	 */

        if (wa == wb) {				/* uniform distributed load   */
            VectorData (equiv) [1] += wa*L/2.0;
            VectorData (equiv) [3] += wa*L/2.0;
            VectorData (equiv) [2] += wa*L*L/12.0;
            VectorData (equiv) [4] += -wa*L*L/12.0;
        }
        else if (fabs(wa) > fabs(wb)) {		/* load sloping node 1-node 2 */
            factor = (wa - wb)*L/120.0/(1.0 + phi);
            VectorData (equiv) [1] += wb*L/2.0 + factor*(42.0 + 40.0*phi);
            VectorData (equiv) [3] += wb*L/2.0 + factor*(18.0 + 20.0*phi);
            VectorData (equiv) [2] += wb*L*L/12.0 + factor*(6.0 + 5.0*phi)*L;
            VectorData (equiv) [4] += -wb*L*L/12.0 - factor*(4.0 + 5.0*phi)*L;
        }
	else if (fabs (wa) < fabs (wb)) {	/* load sloping node 2-node 1 */
            factor = (wb - wa)*L/120.0/(1.0 + phi);
            VectorData (equiv) [1] += wa*L/2.0 + factor*(18.0 + 20.0*phi);
            VectorData (equiv) [3] += wa*L/2.0 + factor*(42.0 + 40.0*phi);
            VectorData (equiv) [2] += wa*L*L/12.0 + factor*(4.0 + 5.0*phi)*L;
            VectorData (equiv) [4] += -wa*L*L/12.0 - factor*(6.0 + 5.0*phi)*L;
        } 
    }

	/*
	 * if this is mode 2, we're done, just hand the equiv vector 
	 * back by setting eq_stress.
	 */

    if (mode == 2) {
        *eq_stress = equiv;
        return 0;
    }

	/* 
	 * We have the load vector in local coordinates now.  
	 * All of this is taken care of by a convenience routine.
	 * What it is doing is checking if the eq_force array has been 
	 * allocated for this element's nodes.  If it hasn't it will set
	 * it up.  If it has it will do nothing and simply return
	 * to us.  It has to allocate space for six doubles (even
	 * though we will only ever use two entries for Timoshenko
	 * elements) because other element types may try to insert
	 * something into this array in different locations. Also,
	 * remember that we will access it as a standard array, 
	 * it's not a Vector or Matrix type.
	 */

    SetEquivalentForceMemory (element);

	/*
	 * The equiv vector has four things in it.  We need to transform
	 * these to global coordinate and then add them 
	 * incrementally into the eq_force [] array on the nodes
	 * because some other element may have also already added 
	 * something onto this node.  Note the use of Tx, Ty and Rz
	 * to access the eq_force array.  These are just enumerated
	 * so that they expand to 2 and 6 ... no real magic there, it
	 * is just little more intuitive to look at.
 	 */

    TransposeMatrix (Tt, T);
    MultiplyMatrices (eq_global, Tt, equiv);
    element -> node[1] -> eq_force[Tx] += VectorData (eq_global) [1];
    element -> node[1] -> eq_force[Ty] += VectorData (eq_global) [2];
    element -> node[1] -> eq_force[Rz] += VectorData (eq_global) [3];
    element -> node[2] -> eq_force[Tx] += VectorData (eq_global) [4];
    element -> node[2] -> eq_force[Ty] += VectorData (eq_global) [5];
    element -> node[2] -> eq_force[Rz] += VectorData (eq_global) [6];

    return 0;
}
