damp.c

Go to the documentation of this file.

/*
%M This module contains the funtions to compute the damping value.
%a Joao Luiz Elias Campos.
%d September 16th, 2000.
%r $Id: damp.c,v 1.1 2004/06/22 05:29:58 joaoluiz Exp $
%w (C) COPYRIGHT 2000, Joao Luiz Elias Campos.
   All Rights Reserved
   Duplication of this program or any part thereof without the express
   written consent of the author is prohibited.

   Modificacao: 28/04/2005    Alexandre A. Del Savio
     Foram substituídas todas as alocações dinâmicas feitas com malloc 
     por calloc.

*/

/*
** ------------------------------------------------------------------------
** Global variables and symbols:
*/
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <math.h>
#include <time.h>

#include "load.h"
#include "elm.h"
#include "node.h"
#include "nfi.h"
#include "rio.h"
#include "damp.h"

sDampClass DampClass[NumDampTypes];

sDamp *DampObj = 0L;


/*
** ------------------------------------------------------------------------
** Local variables and symbols:
*/

#ifndef PI
#define PI 3.141592654
#endif


/*
** ------------------------------------------------------------------------
** Local functions:
*/


/*
** ------------------------------------------------------------------------
** Auto-Global damping methods:
*/
static void AutoGlobalNew ( sDamp ** );
static void AutoGlobalFree( sDamp * );
static void AutoGlobalRead( sDamp * );
static void AutoGlobalCalc( sDamp *, int, double, double *, double *,
                                                  double *, double * );

typedef struct _autoglobal
{
 double freq;
 double frac;
 double adfac;
 double admul;
} sAutoGlobal;


static void AutoGlobalNew( sDamp **damp )
{
 sAutoGlobal *data = 0L;

/* Get memory for the damping object
 */
 (*damp) = (sDamp *)calloc(1, sizeof(sDamp));

/* Get memory for the data object
 */
 data = (sAutoGlobal *)calloc(1, sizeof(sAutoGlobal));

/* Initialize data structure
 */
 data->freq  = 0.0;
 data->frac  = 0.0;
 data->adfac = 0.0;
 data->admul = 0.0;

/* Fill up damping object descriptor
 */
 (*damp)->type = AUTO_GLOBAL;
 (*damp)->data = (void *)data;

} /* End of AutoGlobalNew */

static void AutoGlobalFree( sDamp *damp )
{
 sAutoGlobal *data = 0L;

/* Get damping data
 */
 data = (sAutoGlobal *)damp->data;

/* Release data
 */
 free( data );

/* Reset data value
 */
 damp->data = 0L;

} /* End of AutoGlobalFree */

static void AutoGlobalRead( sDamp *damp )
{
 sAutoGlobal *data = 0L;
 double       freq, frac, adfac, admul;

/* Get the element data
 */
 data = (sAutoGlobal *)damp->data;

/* Read the damping incidence
 */
 fscanf( nf, "%lf %lf %lf %lf", &freq, &frac, &adfac, &admul );

/* Fill element information
 */
 data->freq  = freq;
 data->frac  = frac;
 data->adfac = adfac;
 data->admul = admul;

} /* End of AutoGlobalRead */

static void AutoGlobalCalc( sDamp *damp, int iteration, double dtime, 
                            double *MVector, double *VVector, double *alpha, 
                            double *CinEng )
{
 sAutoGlobal *data = 0L;
 double       damppar, DEnergy, CurrEng;
 int          i;

/* Get the auto-global data
 */
 data = (sAutoGlobal *)damp->data;

/* Check for the first iteration
 */
 if( iteration == 0 )
 {
 /* Compute the damp value for the first iteration
  */
  (*alpha) = 2.0 * PI * data->freq * data->frac;
 }
 else
 {
 /* Compute for the odd iteration
  */
  if( (iteration%2) == 0 )
  {
  /* Initialize the current cinetc energy
   */
   CurrEng = 0.0;

  /* Loop over the nodes
   */
   for( i = 0; i < NumNodes; i++ )
   {
    if( NodeVector[i].rezone == NONE )
    {
     if( NodeVector[i].dof.x != DISPLACEMENT )
      CurrEng += (MVector[NDof*i]*VVector[NDof*i]*VVector[NDof*i])/2.0;
     if( NodeVector[i].dof.y != DISPLACEMENT )
      CurrEng += (MVector[NDof*i+1]*VVector[NDof*i+1]*VVector[NDof*i+1])/2.0;
     if( (NDof == 3) && (NodeVector[i].dof.z != DISPLACEMENT) )
      CurrEng += (MVector[NDof*i+2]*VVector[NDof*i+2]*VVector[NDof*i+2])/2.0;
    }
   }

  /* Compute the cinetic energy variation
   */
   DEnergy = CurrEng - (*CinEng);

   if( DEnergy != 0.0 )
   {
   /* Update the damping parameter
    */
    damppar = (2.0 * (*alpha) * CurrEng * dtime) / fabs(DEnergy);

    if( damppar < data->admul )
     (*alpha) *= data->admul;
    else
     (*alpha) /= data->admul;
   }

  /* Update the total cinetic energy
   */
   (*CinEng) = CurrEng;

  }
 }

} /* End of AutoGlobalCalc */


/*
** ------------------------------------------------------------------------
** Auto-Local damping methods:
*/
static void AutoLocalNew ( sDamp ** );
static void AutoLocalFree( sDamp * );
static void AutoLocalRead( sDamp * );
static void AutoLocalCalc( sDamp *, int, double, double *, double *,
                                                 double *, double * );

typedef struct _autolocal
{
 double cadl;
} sAutoLocal;


static void AutoLocalNew( sDamp **damp )
{
 sAutoLocal *data = 0L;

/* Get memory for the damping object
 */
 (*damp) = (sDamp *)calloc(1, sizeof(sDamp));

/* Get memory for the data object
 */
 data = (sAutoLocal *)calloc(1, sizeof(sAutoLocal));

/* Initialize data structure
 */
 data->cadl = 0.0;

/* Fill up damping object descriptor
 */
 (*damp)->type = AUTO_LOCAL;
 (*damp)->data = (void *)data;

} /* End of AutoLocalNew */

static void AutoLocalFree( sDamp *damp )
{
 sAutoLocal *data = 0L;

/* Get damping data
 */
 data = (sAutoLocal *)damp->data;

/* Release data
 */
 free( data );

/* Reset data value
 */
 damp->data = 0L;

} /* End of AutoLocalFree */

static void AutoLocalRead( sDamp *damp )
{
 sAutoLocal *data = 0L;
 double      cadl;

/* Get the damping data
 */
 data = (sAutoLocal *)damp->data;

/* Read the damping parameters
 */
 fscanf( nf, "%lf", &cadl );

/* Fill up damping information
 */
 data->cadl = cadl;

} /* End of AutoLocalRead */

static void AutoLocalCalc( sDamp *damp, int iteration, double dtime, 
                           double *MVector, double *VVector, double *alpha, 
                           double *CinEng )
{
 sAutoLocal *data = 0L;
 double      CurrEng;
 int         i;

/* Get the auto-local data
 */
 data = (sAutoLocal *)damp->data;

/* Check for the first iteration
 */
 if( iteration == 0 )
 {
 /* Compute the damp value for the first iteration
  */
  (*alpha) = data->cadl;
 }
 else
 {
 /* Compute for the odd iteration
  */
  if( (iteration%2) == 0 )
  {
  /* Initialize the current cinetc energy
   */
   CurrEng = 0.0;

  /* Loop over the nodes
   */
   for( i = 0; i < NumNodes; i++ )
   {
    if( NodeVector[i].rezone == NONE )
    {
     if( NodeVector[i].dof.x != DISPLACEMENT )
      CurrEng += (MVector[NDof*i]*VVector[NDof*i]*VVector[NDof*i])/2.0;
     if( NodeVector[i].dof.y != DISPLACEMENT )
      CurrEng += (MVector[NDof*i+1]*VVector[NDof*i+1]*VVector[NDof*i+1])/2.0;
     if( (NDof == 3) && (NodeVector[i].dof.z != DISPLACEMENT) )
      CurrEng += (MVector[NDof*i+2]*VVector[NDof*i+2]*VVector[NDof*i+2])/2.0;
    }
   }

  /* Update the total cinetic energy
   */
   (*CinEng) = CurrEng;

  }
 }

} /* End of AutoLocalCalc */


/*
** ------------------------------------------------------------------------
** Rayleigh damping methods:
*/
static void RayleighNew ( sDamp ** );
static void RayleighFree( sDamp * );
static void RayleighRead( sDamp * );
static void RayleighCalc( sDamp *, int, double, double *, double *,
                                                double *, double * );

typedef struct _rayleigh
{
 double freq;
 double frac;
 double f1;
 double f2;
} sRayleigh;


static void RayleighNew( sDamp **damp )
{
 sRayleigh *data = 0L;

/* Get memory for the damping object
 */
 (*damp) = (sDamp *)calloc(1, sizeof(sDamp));

/* Get memory for the data object
 */
 data = (sRayleigh *)calloc(1, sizeof(sRayleigh));

/* Initialize data structure
 */
 data->freq = 0.0;
 data->frac = 0.0;
 data->f1   = 0.0;
 data->f2   = 0.0;

/* Fill up damping object descriptor
 */
 (*damp)->type = RAYLEIGH;
 (*damp)->data = (void *)data;

} /* End of RayleighNew */

static void RayleighFree( sDamp *damp )
{
 sRayleigh *data = 0L;

/* Get damping data
 */
 data = (sRayleigh *)damp->data;

/* Release data
 */
 free( data );

/* Reset data value
 */
 damp->data = 0L;

} /* End of RayleighFree */

static void RayleighRead( sDamp *damp )
{
 sRayleigh *data = 0L;
 double     freq, frac, f1, f2;

/* Get the damping data
 */
 data = (sRayleigh *)damp->data;

/* Read the damping parameters
 */
 fscanf( nf, "%lf %lf %lf %lf", &freq, &frac, &f1, &f2 );

/* Fill up damping information
 */
 data->freq = freq;
 data->frac = frac;
 data->f1   = f1;
 data->f2   = f2;

} /* End of RayleighRead */

static void RayleighCalc( sDamp *damp, int iteration, double dtime, 
                          double *MVector, double *VVector, double *alpha, 
                          double *CinEng )
{
 sRayleigh *data = 0L;

/* Get the rayleigh data
 */
 data = (sRayleigh *)damp->data;

} /* End of AutoRayleighCalc */


/*
** ------------------------------------------------------------------------
** Dampping initialize functions:
*/

void AutoGlobalInit( void );
void AutoGlobalInit( void )
{
/* Initialize Auto-Global damping
 */
 DampClass[AUTO_GLOBAL].new  = AutoGlobalNew;
 DampClass[AUTO_GLOBAL].free = AutoGlobalFree;
 DampClass[AUTO_GLOBAL].read = AutoGlobalRead;
 DampClass[AUTO_GLOBAL].calc = AutoGlobalCalc;

} /* End of AutoGlobalInit */


void AutoLocalInit( void );
void AutoLocalInit( void )
{
/* Initialize Auto-Local damping
 */
 DampClass[AUTO_LOCAL].new  = AutoLocalNew;
 DampClass[AUTO_LOCAL].free = AutoLocalFree;
 DampClass[AUTO_LOCAL].read = AutoLocalRead;
 DampClass[AUTO_LOCAL].calc = AutoLocalCalc;

} /* End of AutoLocalInit */


void RayleighInit( void );
void RayleighInit( void )
{
/* Initialize Rayleigh damping
 */
 DampClass[RAYLEIGH].new  = RayleighNew;
 DampClass[RAYLEIGH].free = RayleighFree;
 DampClass[RAYLEIGH].read = RayleighRead;
 DampClass[RAYLEIGH].calc = RayleighCalc;

} /* End of RayleighInit */


/*
** ------------------------------------------------------------------------
** Public functions:
*/

/*
%F
*/
void DampingInit( void )
{
 int i;

/* Define the subclasses initialization methods
 */
 DampClass[AUTO_GLOBAL].init = AutoGlobalInit;
 DampClass[AUTO_LOCAL].init  = AutoLocalInit;
 DampClass[RAYLEIGH].init    = RayleighInit;

 for( i = 0; i < NumDampTypes; i++ )
  DampInit( i );

} /* End of DampingInit */


/* =======================================================  End of File  */

---