loadcase.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.
*
* Modificação: Modulo passa a se chamar loadcase
*              pois será criado o módulo loadstep
*/

/*
** ------------------------------------------------------------------------
** 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 LoadCaseNew        ( sDriver ** );
static void LoadCaseFree       ( sDriver * );
static int  LoadCaseAnalysis   ( UI_State * );
static int  LoadCasePrintResult( int, double *, double * );


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

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

} /* End of LoadCaseNew */


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

} /* End of LoadCaseFree */


/*
%F This function process the probleam analysis using a solver
*/
static int LoadCaseAnalysis(UI_State *R)
{
 int     i, lstep = 0;
 double *FVector = 0L;
 double *UVector = 0L;
 double *VVector = 0L;
 double *MVector = 0L;
 sTensor stress[8];
 sTensor strain[8];
 
/* 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 < NumLoadCase )
 {
 /* Print feedback message
  */
  printf( "\tProcess load case..................: %d\n", lstep+1 );
  fflush( stdout );

 /* Set current load step
  */
  CurrLoadCase = lstep;

 /* Process load step
  */
  PrescribedValues( );

 /* Call the solver algorithm for each load step step
  */
  if(Config.algtype == 0)
   if( !DRSolver(R, FVector, UVector, VVector, MVector, 0 ) ) return 0;
  else if(Config.algtype == 1)
   if( !IMPLINEARSolver(R, FVector, UVector, VVector, MVector, 0 ) ) return 0;
  else if(Config.algtype == 2)
   if( !IMPNRMSolver(R, FVector, UVector, VVector, MVector, 0 ) ) return 0;
  else if(Config.algtype == 3)
   if( !IMPBFGSSolver(R, FVector, UVector, VVector, MVector, 0 ) ) return 0;
  else if(Config.algtype == 4)
   if( !HYBRIDSolver(R, FVector, UVector, VVector, MVector, 0 ) ) 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 );

  for( i = 0; i < NumElements; i++ )
  {
   ElmStressStrain( ElmList[i], 0.0, UVector, 0L, stress, strain );
   ElmSetInitStress( ElmList[i], stress );
  }
  UVector = (double *)memset( (void *)UVector, 0, sizeof(double) );
  VVector = (double *)memset( (void *)VVector, 0, sizeof(double) );

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

/* Finish graphic module
 */
 XGPEnd( );

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

 return 1;

} /* End of LoadCaseAnalysis */


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


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

/*
%F This function initializes the sub-class LOAD_CASE.
*/
void LoadCaseInit( void );
void LoadCaseInit( void )
{
/* Initialize LOAD_STEP driver sub-class
 */
 DrvClass[LOAD_CASE].new      = LoadCaseNew;
 DrvClass[LOAD_CASE].free     = LoadCaseFree;
 DrvClass[LOAD_CASE].analysis = LoadCaseAnalysis;
 DrvClass[LOAD_CASE].printres = LoadCasePrintResult;

} /* End of LoadCaseInit */


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

---