impNRM.c

Go to the documentation of this file.

/*
%M This modules contains the driver methods to solve a problem using the 
   NRM algorithm.
*  André Luis Muller:  06/2007
*/

/*
** ------------------------------------------------------------------------
** 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"
#include "rui.h"


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

/*
** ------------------------------------------------------------------------
** Local functions:
*/
static void ImpNRMNew(sDriver **);
static void ImpNRMFree(sDriver *);
static int  ImpNRMAnalysis(UI_State *);
static int  ImpNRMPrintResult(int, double *, double *);


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

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

} /* End of ImpNRMNew */


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

} /* End of ImpNRMFree */


/*
%F This function process the probleam analysis using a ImpNRM 
   algorithm.
*/
static int ImpNRMAnalysis(UI_State *R)
{
 int     i;
 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));

/* Apply prescribed values
 */
 PrescribedValues();

/* Start graphic module
 */
 XGPBegin();

/* Print feedback message
 */
 printf("\tSolve problem........................:\n");
 fflush(stdout);

/* Call the dynamic NRM algorithm
 */
 if( !IMPNRMSolver(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);

/* Finish graphic module
 */
 XGPEnd();

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

 return 1;

} /* End of ImpNRMAnalysis */


/*
%F
*/
static int ImpNRMPrintResult( int iteration, double *U, double *V )
{
 int i;

/* Check to see if this step must be processed
 */
 if( !Config.print_step || ((iteration != 1) && (iteration%Config.print_step)) )
  return 1;

/* Update number of result steps
 */
 Config.num_step++;

/* Process output
 */
 if( !IoStartSave( ) ) return 0;

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

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

 return 1;

} /* End of ImpNRMPrintResult */


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

/*
%F This function initializes the sub-class IMPNRM.
*/
void ImpNRMInit( void );
void ImpNRMInit( void )
{
/* Initialize IMPNRM driver sub-class
 */
 DrvClass[IMPNRM].new      = ImpNRMNew;
 DrvClass[IMPNRM].free     = ImpNRMFree;
 DrvClass[IMPNRM].analysis = ImpNRMAnalysis;
 DrvClass[IMPNRM].printres = ImpNRMPrintResult;

} /* End of ImpNRMInit */


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

---