loadstep.c

Go to the documentation of this file.

/*
%M This modules contains the driver methods to solve a problem using the 
   dynamic relax algorithm with load steps.
%a Joao Luiz Elias Campos.
%d July 27th, 1999.
%r $Id: loadstep.c,v 1.1 2004/06/22 05:29:59 joaoluiz Exp $
%w (C) COPYRIGHT 1995-1996, Eduardo Nobre Lages.
   (C) COPYRIGHT 1997-1999, 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.
*
*  Modified: 28-Apr-2005    Alexandre A. Del Savio
*    Foram substituídas todas as alocações dinâmicas feitas com malloc 
*    por calloc.
*
*  Modified: 23-Fev-2006    Juan Pablo Ibañez
*    Modificada a funcão LoadStepAnalysis, que passa a retornar un valor int.
*/

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

#include "drv.h"
#include "fem.h"
#include "load.h"
#include "elm.h"
#include "node.h"
#include "alg.h"
#include "rio.h"
#include "nfi.h"
#include "load.h"
#include "xgplib.h"


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

/*
** ------------------------------------------------------------------------
** Local functions:
*/
static void LoadStepNew        ( sDriver ** );
static void LoadStepFree       ( sDriver * );
static int  LoadStepAnalysis   ( UI_State * );
static int  LoadStepPrintResult( int, double *, double * );


/*
%F
*/
static void LoadStepNew( sDriver **drv )
{
/* Get memory for the driver descriptor
 */
 (*drv) = (sDriver *)calloc(1, sizeof(sDriver));

/* Fill up driver descriptor
 */
 (*drv)->type = LOAD_STEP;

} /* End of LoadStepNew */


/*
%F
*/
static void LoadStepFree( sDriver *drv )
{
/* Reset driver data
 */
 drv->data = 0L;

} /* End of LoadStepFree */


/*
%F This function process the probleam analysis using a dynamic relax 
   algorithm.
*/
static int LoadStepAnalysis(UI_State *R)
{
 int     i, lstep = 0;
 double *FVector = 0L;
 double *UVector = 0L;
 double *VVector = 0L;
 double *MVector = 0L;
 
/* Get memory for the vectors used during the analysis
 */
 FVector = (double *)calloc( NDof*NumNodes, sizeof(double) );
 UVector = (double *)calloc( NDof*NumNodes, sizeof(double) );
 VVector = (double *)calloc( NDof*NumNodes, sizeof(double) );
 MVector = (double *)calloc( NDof*NumNodes, sizeof(double) );

/* Start graphic module
 */
 XGPBegin( );

/* Solve the problem
 */
 while( lstep < Config.num_load_step )
 {
 /* Print feedback message
  */
  printf( "\tProcess load step..................: %d\n", lstep+1 );
  fflush( stdout );

 /* Process load step
  */
  PrescribedValues( );

 /* Call the solver algorithm for each load step step
  */

  switch( Config.algtype )
  {
    case 0:
      if( !DRSolver(R, FVector, UVector, VVector, MVector, lstep ) ) return 0;
      break;
      
    case 1:
      if( !IMPLINEARSolver(R, FVector, UVector, VVector, MVector, lstep ) ) return 0;
      break;
      
    case 2:
      if( !IMPNRMSolver(R, FVector, UVector, VVector, MVector, lstep ) ) return 0;
      break;
      
    case 3:
      if( !IMPBFGSSolver(R, FVector, UVector, VVector, MVector, lstep ) ) return 0;
      break;
      
    case 4:
      if( !HYBRIDSolver(R, FVector, UVector, VVector, MVector, lstep ) ) return 0;
      break;
      
    default:
      return 0;
  }
   
 /* Write results on a temporary file
  */
  if( !IoStartSave( ) ) return 0;

  fwrite( UVector, sizeof(double), NDof*NumNodes, ndlr );
  fflush( ndlr );

  for( i = 0; i < NumElements; i++ )
   ElmWriteStress( ElmList[i], elmr, UVector, VVector );
  fflush( elmr );

 /* Increase the load step
  */
  lstep++;
 }

/* Finish graphic module
 */
 XGPEnd( );

/* Release memory
 */
 free( FVector );
 free( UVector );
 free( VVector );
 free( MVector );

 return 1;

} /* End of LoadStepAnalysis */


/*
%F
*/
static int LoadStepPrintResult( int iteration, double *U, double *V )
{
 return 1;
} /* End of LoadStepPrintResult */


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

/*
%F This function initializes the sub-class LOAD_STEP.
*/
void LoadStepInit( void );
void LoadStepInit( void )
{
/* Initialize LOAD_STEP driver sub-class
 */
 DrvClass[LOAD_STEP].new      = LoadStepNew;
 DrvClass[LOAD_STEP].free     = LoadStepFree;
 DrvClass[LOAD_STEP].analysis = LoadStepAnalysis;
 DrvClass[LOAD_STEP].printres = LoadStepPrintResult;

} /* End of LoadStepInit */


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

---