nfi.c

Go to the documentation of this file.

/*
%M This modules contains functions to handle the neutral file interpretation.
%a Joao Luiz Elias Campos
%d April 6th, 1998.
%r $Id: nfi.c,v 1.6 2004/06/24 04:43:55 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:    30-Aug-05    Alexandre A. Del Savio
 *     Criada a função _NfiReadNodePilot e  modificada a função 
 *     NfiInterpFile onde adicionou-se um novo label, "NODE.PILOT", 
 *     e a chamada a função _NfiReadNodePilot.  
 *     Modificada também a função _NfiReadNodeCoord que passou
 *     a inicializar "NodeVector[i].pilot" com zero.
 *
 *   Modified:    08-Dec-05    Juan Pablo Ibañez
 *     Criada a funcão NfiReadNumStepTol e  modificada a função 
 *     NfiInterpFile onde adicionou-se um novo label, 
 *     "HEADER.ANALYSIS.NUM.STEP.TOLERANCE".
 *     Criado o flag NumStepTol para control de leitura.
 *
 *   Modified:    23-Jan-06    Alexandre A. Del Savio
 *     Criada a função _NfiReadConstrainSurface e  modificada a função 
 *     NfiInterpFile onde adicionou-se um novo label,
 *     "CONSTRAIN.SURFACE".
 *
 *   Modified:    22-Fev-06    Juan Pablo Ibañez
 *     Modificadas as funcões NfiInterpFile, _NfiReadAnalysisType,
 *     _NfiReadDamping, _NfiReadNode, _NfiReadNodeCoord, _NfiReadElement,
 *     _NfiReadLoadCaseDomainInitStressUni, _NfiReadConstrain, 
 *     NfiWriteResults, que retorna 0 ou 1 em caso de erro ou sucesso
 *     respectivamente.
 *
 *   Modified:    29-Mar-06    Juan Pablo Ibañez
 *     Modificada a funcão NfiReadConstrainCurve onde ConstNew passa
 *     mais um parametro, "i".
 *
 *   Modified:    21-Jun-06    Alexandre A. Del Savio
 *     Modified the _NfiReadNodeConstrain function when it was added the
 *     case of move on rain.
 *     Modified _NfiReadConstrainCurve and _NfiReadSurfaceCurve functions
 *     due the change of ConstNew.
 *   
 *   Modificado: André Luis Muller 06/2007
 *     Adicionado os modulos para análise implícita e híbrida
 *
 *   Modificado: André Luis Muller 07/2007
 *     Adicionada a possibilidade de escolher as respostas dos pontos de gauss
 *     a serem escritas no arquivo de resultados.
 */

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

#include "nfi.h"
#include "drv.h"
#include "load.h"
#include "elm.h"
#include "node.h"
#include "material.h"
#include "load.h"
#include "alg.h"
#include "xgplib.h"
#include "rio.h"
#include "damp.h"
#include "constrain.h"
#include "relax.h" 


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

/*
%T Neutral File version descriptor definition
*/
typedef struct _nfiversion
{
 int version;
 int release;
 int revision;
} sNfiVersion;


/*
%V Neutral File version descriptor
*/
static sNfiVersion _NfiVersion = { 2, 0, 0 };


/*
%K Label size
*/
#define LABEL_SIZE  12


/*
%V Neutral file handle
*/
static FILE *_NfiName = 0L;


/*
%V Current rezone case id
*/
static int _CurrCase = 0;


/*
%V Read flags to check the input data
*/
static int _TimeStep       = 0;
static int _TotalTime      = 0;
static int _TimeFraction   = 0;
static int _DampParameters = 0;
static int _Tolerance      = 0;
static int _NumStepTol     = 0; 
static int _MaxIterations  = 0;
static int _GeomNonLinear  = 0;
static int _Fsolution      = 0;
static int _NumLoadStep    = 0;
static int _AlgType        = 0;
static int _NumRes         = 0; 
static int _SolverType     = 0;

/*
** ------------------------------------------------------------------------
** Local functions:
*/
static int  _NfiNextLabel                       ( char * );
static int  _NfiReadString                      ( char * );
static void _NfiReadVersion                     ( void );
static int  _NfiReadAnalysisType                ( void );
static int  _NfiReadNode                        ( void );
static int  _NfiReadNodeCoord                   ( void );
static void _NfiReadNodeSupport                 ( void );
static void _NfiReadNodeDispTimeDisplay         ( void );
static void _NfiReadNodeDispDisplay             ( void );
static void _NfiReadNodeVelocDisplay            ( void );
static void _NfiReadIntegrationOrder            ( void );
static void _NfiReadThickness                   ( void );
static void _NfiReadMaterial                    ( void );
static void _NfiReadMaterialPROPERTYDENSITY     ( void );
static void _NfiReadMaterialPROPERTYLAMBDA      ( void );
static void _NfiReadMaterialFLUIDDENSITY        ( void );
static void _NfiReadMaterialFLUIDLAMBDA         ( void );
static void _NfiReadMaterialMISES               ( void );
static void _NfiReadMaterialINTERFACEMOHRCOULOMB( void );
static void _NfiReadMaterialINTERFACE           ( void );
static void _NfiReadMaterialISOTROPIC           ( void );
static void _NfiReadMaterialISOTROPICFAIL       ( void );
static void _NfiReadMaterialORTHOTROPIC         ( void );
static void _NfiReadMaterialHIPERBOLIC          ( void );
static void _NfiReadMaterialMOHRCOULOMB         ( void );
static void _NfiReadMaterialMOHRCOULOMBCUTOFF   ( void );
static void _NfiReadMaterialMOHRCOULOMBNAC      ( void );
static void _NfiReadMaterialMOHRCOULOMBNAV      ( void );
static void _NfiReadMaterialKELVIN              ( void );
static void _NfiReadMaterialMAXWELL             ( void );
static void _NfiReadMaterialGENERIC             ( void );
static int  _NfiReadElement                     ( void );
static void _NfiReadElementLINE2                ( void );
static void _NfiReadElementT3                   ( void );
static void _NfiReadElementQ4                   ( void );
static void _NfiReadElementBRICK8               ( void );
static void _NfiReadElementTETR4                ( void );
static void _NfiReadElementINTERFACE            ( void );
static void _NfiReadElementINFINITE             ( void );
static void _NfiReadLoad                        ( void );
static void _NfiReadLoadCase                    ( void );
static void _NfiReadLoadCaseGravity             ( void );
static void _NfiReadLoadCaseNodalPressure       ( void );
static void _NfiReadLoadCaseNodalForces         ( void );
static void _NfiReadLoadCaseNodalVelocity       ( void );
static void _NfiReadLoadCaseLineForcesUni       ( void );
static void _NfiReadLoadCaseLineForcesVar       ( void );
static int  _NfiReadLoadCaseDomainInitStressUni ( void );
static void _NfiReadLoadCaseDomainTempUni       ( void );
static void _NfiReadLoadCaseNodalDisplacements  ( void );
static void _NfiReadLoadCaseElementPotencial    ( void );
static void _NfiReadLoadCaseNodalSupport        ( void );
static void _NfiReadTotalTime                   ( void );
static void _NfiReadTimeStep                    ( void );
static void _NfiReadTimeFraction                ( void );
static int  _NfiReadDamping                     ( void );
static void _NfiReadDampingGlobalParameter      ( void );
static void _NfiReadDampingLocalParameter       ( void );
static void _NfiReadDampingRayleighParameter    ( void );
static void _NfiReadTolerance                   ( void );
static void _NfiReadNumStepTol                  ( void );
static void _NfiReadMaximumIteration            ( void );
static void _NfiReadPrintStep                   ( void );
static void _NfiReadDrawStep                    ( void );
static void _NfiReadGeometricallyNonLinear      ( void );
static void _NfiReadRezone                      ( void );
static void _NfiReadRezoneCase                  ( void );
static void _NfiReadRezoneCaseElement           ( void );
static void _NfiWriteResultStep                 ( int, long, long, double * );
static int  _NfiReadConstrain                   ( void );
static void _NfiReadConstrainCurve              ( void );
static void _NfiReadNodeConstrain               ( void );
static void _NfiReadNodePilot                   ( void );
static void _NfiReadElementProfileT3            ( void );
static void _NfiReadElementProfileQ4            ( void );
static void _NfiReadElementProfileBRICK8        ( void );
static void _NfiReadElementProfileTETRA4        ( void );

static void _NfiReadLoadCaseAreaUniform         ( void );
static int  _NfiReadAlgorithmType               ( void );
static void _NfiReadNumLoadStep                 ( void );
static void _NfiReadNumGaussResults             ( void );
static int  _NfiReadSolverType                  ( void );
static void _NfiReadLoadCaseAreaPressure        ( void ); 

static void _NfiReadElementDKT                  ( void );
static void _NfiReadNodePilot( void )
{
  int id, c, num, i;

  /* Lê o número de nós pilotos. 
   */
  fscanf(_NfiName, "%d", &num);

  /* Lê o atributo de cada nó piloto. 
   */
  for(i = 0; i < num; i++) 
  {
    fscanf(_NfiName, "%d%d", &id, &c);
    NodeVector[id-1].pilot = c;
  }

} /* End of _NfiReadNodePilot */

static void _NfiReadNodeConstrain(void)
{
 int id, c, num, i;

 fscanf(_NfiName, "%d", &num);
 for( i = 0; i < num; i++ )
 {
  fscanf(_NfiName, "%d%d", &id, &c);
  NodeVector[id-1].dof.x = OBJECT;
  NodeVector[id-1].dof.y = OBJECT;
  NodeVector[id-1].dof.z = OBJECT;
  NodeVector[id-1].constrain.id = c;
 }
} /* End of _NfiReadNodeConstrain */

static int _NfiReadConstrain(void)
{
 int nconst;

/* Read number of constrains
 */
 fscanf(_NfiName, "%d", &nconst);

/* Check to see if the number of constrains were given
 */
 if( nconst == 0 ) {
  printf("\nThe number of constrains must be given!\n");
  return 0;
 }

/* Set number of constrains
 */
 NumConstrains = nconst;

/* Initialize constrains class
 */
 ConstrainInit();

 return 1;

} /* End of _NfiReadConstrain */

static void _NfiReadConstrainCurve(void)
{
 int n, i;
 int id, num_nodes, num_elems;
 sConstrain *c = 0L;

/* Read the number of constrains in this section
 */
 fscanf(_NfiName, "%d", &n);

/* Read constrains information
 */
 for( i = 0; i < n; i++ ) 
 {
  fscanf(_NfiName, "%d%d%d", &id, &num_nodes, &num_elems);
  ConstNew(CURVE, id, num_nodes, num_elems, &c, ConstList);
  ConstRead(c);
 }

} /* End of _NfiReadConstrainCurve */

static void _NfiReadConstrainShot(void)
{
  int n, i;
  int id; 
  int num_nodes = 2;
  int num_elems = 1;
  sConstrain *c = 0L;

  /* Read the number of constrains in this section
   */
  fscanf(_NfiName, "%d", &n);

  /* Read constrains information
  */
  for( i = 0; i < n; i++ )
  {
    fscanf(_NfiName, "%d", &id);
    ConstNew(SHOT, id, num_nodes, num_elems, &c, ConstList);
    ConstRead(c);
  }
} /* End of _NfiReadConstrainShot */

static void _NfiReadConstrainSurface(void)
{
  int n, i;
  int id, num_nodes, num_elems;
  sConstrain *c = 0L;

  /* Read the number of constrains in this section
   */
  fscanf(_NfiName, "%d", &n);

  /* Read constrains information
   */
  for( i = 0; i < n; i++ ) 
  {
    fscanf(_NfiName, "%d%d%d", &id, &num_nodes, &num_elems);
    ConstNew(SURFACE, id, num_nodes, num_elems, &c, ConstList);
    ConstRead(c);
  }

} /* End of _NfiReadConstrainSurface */


/*
%F This function find the next label in the file. The label is identified 
   by the character "%". The function returns the section label without 
   the "%" character.
%o Section label.
%o Flag variable to identify the sucess or failure of the function.
*/
static int _NfiNextLabel( char *label )
{
 int c;

/* Find the next %
 */
 while( (c = fgetc( _NfiName )) != '%' )
  if( c == EOF )
   return( 0 );

/* Scan label string
 */
 if( fscanf( _NfiName, "%s", label ) != 1 )
  return( 0 );
 else
  return( 1 );

} /* End of _NfiNextLabel */


/*
%F This function reads a string that must be delimited by ''.
%o String value.
%o Flag variable to identify the sucess or failure of the function.
*/
static int _NfiReadString( char *s )
{
 char c;
 char tmp[256];

 if( fscanf( _NfiName, " '%[^\n']", tmp ) != 1 )
  return( 0 );

#if 0
 strncpy( s, tmp, LABEL_SIZE );
#else
 strcpy( s, tmp );
#endif

 fscanf( _NfiName, "%c", &c );

 if( c == '\'' )
  return( 1 );
 else
  return( 0 );

} /* End of _NfiReadString */


/*
%F This function reads the Neutral File version number.
*/
static void _NfiReadVersion( void )
{
 char version[80];

/* Read the Neutral File version string
 */
 if( !_NfiReadString( version ) )
  return;

/* Fill up version descriptor
 */
 sscanf( version, "%d.%d.%d", &_NfiVersion.version,
                              &_NfiVersion.release,
                              &_NfiVersion.revision );

} /* End of _NfiReadVersion */


/*
%F This function reads the analysis type for the model.
*/
static int _NfiReadAnalysisType( void )
{
 char anmtype[80];

/* Initialze driver sub-classes
 */
 DriverInit( );

/* Read the analysis type string
 */
 if( !_NfiReadString( anmtype ) )
 {
  printf( "\n\n\tError on read the analysis type...\n\n" );
  return 0;
 }

/* Set the number of degrees of freedown according the analysis type
 */
 if( (strcmp( anmtype, "plane_strain" ) == 0) ||
     (strcmp( anmtype, "Plane_Strain" ) == 0) ||
     (strcmp( anmtype, "PLANE_STRAIN" ) == 0) )
 {
  NDof = 2;
 }
 else if( (strcmp( anmtype, "solid" ) == 0) ||
          (strcmp( anmtype, "Solid" ) == 0) ||
          (strcmp( anmtype, "SOLID" ) == 0) )
 {
  NDof = 3;
 }
 else
 {
  printf( "\n\n\tThis Analysis type is not implemented yet...\n\n" );
  return 0;
 }

 return 1;
} /* End of _NfiReadAnalysisType */


/*
%F This function reads the analysis algorithm type for the model.
*/
static int _NfiReadAlgorithmType( void )
{
 char algtype[80];
/* Read the analysis algorithm type string
 */
 if( !_NfiReadString( algtype ) )
 {
  printf( "\n\n\tError on read the analysis algorithm type...\n\n" );
  return 0;
 }
      if(strcmp( algtype, "dr" ) == 0){     Config.algtype = 0; }
 else if(strcmp( algtype, "linear" ) == 0 ){Config.algtype = 1; }
 else if(strcmp( algtype, "nrm" ) == 0){    Config.algtype = 2; }
 else if(strcmp( algtype, "bfgs" ) == 0){   Config.algtype = 3; }
 else if(strcmp( algtype, "hs" ) == 0){     Config.algtype = 4; }
 else{
  printf( "\n\n\tThis Analysis algorithm type is not implemented yet...\n\n" );
  return 0;
 }
 
 _AlgType = 1;
 
 return ( _AlgType );
} /* End of _NfiReadAlgorithmType */


/*
%F This function reads the solver algorithm type for the model.
*/
static int _NfiReadSolverType( void )
{
 char solvertype[80];
/* Read the solver algorithm type string
 */
 if( !_NfiReadString( solvertype ) )
 {
  printf( "\n\n\tError on read the solver algorithm type...\n\n" );
  return 0;
 }
      if(strcmp( solvertype, "pcg" )  == 0) {   Config.solver = 0; }
 else if(strcmp( solvertype, "samg" ) == 0 ){   Config.solver = 1; }
 else{
  printf( "\n\n\tThis Solver type is not implemented yet...\n\n" );
  return 0;
 }
 
 _SolverType = 1;
 
 return ( _SolverType );
} /* End of _NfiReadSolverType */


/*
%F This function reads the reduction factor for the time step.
*/
static void _NfiReadTimeFraction( void )
{
 double time_frac;

/* Read the time fraction
 */
 fscanf( _NfiName, "%lf", &time_frac );

/* Set time fraction
 */
 Config.dtfrac = time_frac;

/* Set check flag
 */
 _TimeFraction = 1;

} /* End of _NfiReadTimeFraction */

/*
%F This function reads the time step for the viscos analysis.
*/
static void _NfiReadTimeStep( void )
{
 double time_step;

/* Read the time step
 */
 fscanf( _NfiName, "%lf", &time_step );

/* Set time step
 */
 Config.timeStep = time_step;

/* Set check flag
 */
 _TimeStep = 1;

} /* End of _NfiReadTimeStep */

/*
%F This function reads the total time for the viscos analysis.
*/
static void _NfiReadTotalTime( void )
{
 double total_time;

/* Read the total time 
 */
 fscanf( _NfiName, "%lf", &total_time );

/* Set total time
 */
 Config.totalTime = total_time;

/* Set check flag
 */
 _TotalTime = 1;

} /* End of _NfiReadTotalTime */

static int _NfiReadDamping(void)
{
 char damptype[80];

/* Read the damping type string
 */
 if( !_NfiReadString(damptype) ) {
  printf("\n\n\tError on read the damping type...\n\n");
  return 0;
 }

 if( strcmp(damptype, "auto_global") == 0 ) {
  DampNew(AUTO_GLOBAL,&DampObj);
 }
 else if( strcmp(damptype, "auto_local") == 0 ) {
  DampNew(AUTO_LOCAL,&DampObj);
 }
 else {
  DampNew(RAYLEIGH,&DampObj);
 }
 DampRead(DampObj);
 _DampParameters = 1;

 return 1;

} /* End of _NfiReadDamping */

/*
%F This function reads the global damping parameters
*/
static void _NfiReadDampingGlobalParameter( void )
{
/* Create a global damping object and read its parameters
 */
 DampNew(AUTO_GLOBAL,&DampObj);
 DampRead(DampObj);

/* Set check flag
 */
 _DampParameters = 1;

} /* End of _NfiReadDampingGlobalParameter */

/*
%F This function reads the local damping parameters
*/
static void _NfiReadDampingLocalParameter( void )
{
/* Create a local damping object and read its parameters
 */
 DampNew(AUTO_LOCAL,&DampObj);
 DampRead(DampObj);

/* Set check flag
 */
 _DampParameters = 2;

} /* End of _NfiReadDampingLocalParameter */

/*
%F This function reads the rayleigh damping parameters
*/
static void _NfiReadDampingRayleighParameter( void )
{
/* Create a rayleigh damping object and read its parameters
 */
 DampNew(RAYLEIGH,&DampObj);
 DampRead(DampObj);

/* Set check flag
 */
 _DampParameters = 3;

} /* End of _NfiReadDampingRayleighParameter */


/*
%F This function reads the analysis iteration tolerance
*/
static void _NfiReadTolerance( void )
{
 double tol;

/* Read iteration tolerance
 */
 fscanf( _NfiName, "%lf", &tol );

/* Set tolerance
 */
 Config.tolerance = tol;

/* Set check flag
 */
 _Tolerance = 1;

} /* End of _NfiReadTolerance */


/*
%F This function reads the dimension of error vector
   used in convergence control
*/
static void _NfiReadNumStepTol( void )
{
 int step;

/* Read step number for tolerance control
 */
 fscanf( _NfiName, "%d", &step );

/* Set step number for tolerance control
 */
 Config.numsteptol = step;

/* Set check flag
 */
 _NumStepTol = 1;

} /* End of _NfiReadNumStepTol */


/*
%F This function reads the number of the gauss results
*/
static void _NfiReadNumGaussResults( void )
{
 int    i,numres; 
 char   res[80];

/* Read number of the gauss results
 */
 fscanf( _NfiName, "%d", &numres );

/* Set number of the gauss results
 */
 Config.numgaussresults = numres;
 
 Config.gaussresults = (char**) malloc( numres * sizeof( char * ) );

 for( i = 0; i < numres; i++){
  fscanf( _NfiName, "%s", &res );
  Config.gaussresults[i] = strdup ( res );
 }

/* Set check flag
 */
 _NumRes = 1;
 
} /* End of _NfiReadNumGaussResults */


/*
%F This function reads the geometrically nonlinear flag that identify this
   kind of problem.
*/
static void _NfiReadGeometricallyNonLinear( void )
{
 int flag;

/* Read geometrically nonlinear flag
 */
 fscanf( _NfiName, "%d", &flag );

/* Set geometrically nonlinear flag
 */
 Config.nonlinear = flag;

/* Set check flag
 */
 _GeomNonLinear = 1;

} /* End of _NfiReadGeometricallyNonLinear */


static void _NfiReadNumLoadStep( void )
{
 int flag;

/* Read num load step flag
 */
 fscanf( _NfiName, "%d", &flag );

/* Set num load step flag
 */
 Config.num_load_step = flag;

/* Set check flag
 */
 _NumLoadStep = 1;

} /* End of _NfiReadNumLoadStep */


/*
%F This function reads the analysis maximum iteration number
*/
static void _NfiReadMaximumIteration( void )
{
 int iter;

/* Read iteration number
 */
 fscanf( _NfiName, "%d", &iter );

/* Set maximum iteration
 */
 Config.max_iter = iter;

/* Set graphic maximum points
 */
 NumMaxPoints = iter;

/* Set check flag
 */
 _MaxIterations = 1;

} /* End of _NfiReadMaximumIteration */


/*
%F This function reads the analysis print step number
*/
static void _NfiReadPrintStep( void )
{
 int step;

/* Read print step number
 */
 fscanf( _NfiName, "%d", &step );

/* Set print step
 */
 Config.print_step = step;

} /* End of _NfiReadPrintStep */

static void _NfiReadDrawStep(void)
{
 int step;

/* Read draw step number
 */
 fscanf(_NfiName, "%d", &step);

/* Set draw step
 */
 Config.draw_step = step;

} /* End of _NfiReadDrawStep */


/*
%F This function reads the mesh number of nodes. It reads the number of
   nodes and allocate the node vector.
*/
static int _NfiReadNode( void )
{
 int nnode;

/* Read number of nodes
 */
 fscanf( _NfiName, "%d", &nnode );

/* Check to see if the number of nodes were given
 */
 if( nnode == 0 )
 {
  printf( "\nThe number of nodes must be given!\n" );
  return 0;
 }

/* Set number of nodes
 */
 NumNodes = nnode;

/* Get memory for the node description vector
 */
 NodeVector = (sNode *)calloc( nnode, sizeof(sNode) );

 return 1;
} /* End of _NfiReadNode */


/*
%F This function reads the node information from the file. It fills the 
   node vector with the node information.
*/
static int _NfiReadNodeCoord( void )
{
 int    nnode, i, id;
 double x, y, z;

/* Read the number of nodes
 */
 fscanf( _NfiName, "%d", &nnode );

/* Check to see if the number of nodes were redefined
 */
 if( nnode != NumNodes )
 {
  printf( "\nThe number of nodes were redefined!\n" );
  return 0;
 }

/* Read node information
 */
 for( i = 0; i < NumNodes; i++ )
 {
  fscanf( _NfiName, "%d%lf%lf%lf", &id, &x, &y, &z );
  NodeVector[i].id           = id;
  NodeVector[i].coord.x      = x;
  NodeVector[i].coord.y      = y;
  NodeVector[i].coord.z      = z;
  NodeVector[i].dof.x        = FORCE;
  NodeVector[i].dof.y        = FORCE;
  NodeVector[i].dof.z        = FORCE;
  NodeVector[i].dof.psi      = 0.0;
  NodeVector[i].rezone       = NONE;
  NodeVector[i].curve        = 0;
  NodeVector[i].dspIteration = DSP_NO;
  NodeVector[i].dspTime      = DSP_NO;
  NodeVector[i].pilot        = 0;
 }

 return 1;
} /* End of _NfiReadNodeCoord */


/*
%F This function reads the node support information
*/
static void _NfiReadNodeSupport( void )
{
 int i, num;
 int id, dx, dy, dz;

/* Read the number of supports
 */
 fscanf( _NfiName, "%d", &num );

/* Read support definition
 */
 for( i = 0; i < num; i++ )
 {
  fscanf( _NfiName, "%d %d %d %d %*d%*d%*d", &id, &dx, &dy, &dz );

  if( dx == 1 ) NodeVector[id-1].dof.x = DISPLACEMENT;

  if( dy == 1 ) NodeVector[id-1].dof.y = DISPLACEMENT;

  if( dz == 1 ) NodeVector[id-1].dof.z = DISPLACEMENT;
 }

} /* End of _NfiReadNodeSupport */


/*
%F This function reads the node display information
*/
static void _NfiReadNodeDispDisplay( void )
{
 int i, num;
 int id;

/* Read the number of nodes
 */
 fscanf( _NfiName, "%d", &num );

/* Set the number of nodes and get memory for the labels
 */
 NumCurves = num;
 Labels = (char **)calloc( num, sizeof(char *) );
 for( i = 0; i < num; i++ )
  Labels[i] = (char *)calloc( 20, sizeof(char) );

/* Read node id and set its labels
 */
 for( i = 0; i < num; i++ )
 {
  fscanf( _NfiName, "%d", &id );

  NodeVector[id-1].dspIteration = DSP_YES;
  NodeVector[id-1].curve        = i;
  sprintf( Labels[i], "Node %d", id );
 }

/* Set graphic type
 */
 GpType = 0;

} /* End of _NfiReadNodeDispDisplay */


/*
%F This function reads the node display information
*/
static void _NfiReadNodeDispTimeDisplay( void )
{
 int i, num;
 int id;

/* Read the number of nodes
 */
 fscanf( _NfiName, "%d", &num );

/* Set the number of nodes and get memory for the labels
 */
 NumCurves = num;
 Labels = (char **)calloc( num, sizeof(char *) );
 for( i = 0; i < num; i++ )
  Labels[i] = (char *)calloc( 20, sizeof(char) );

/* Read node id and set its labels
 */
 for( i = 0; i < num; i++ )
 {
  fscanf( _NfiName, "%d", &id );

  NodeVector[id-1].dspTime = DSP_YES;
  NodeVector[id-1].curve   = i;
  sprintf( Labels[i], "Node %d", id );
 }

/* Set graphic type
 */
 GpType = 4;

} /* End of _NfiReadNodeDispTimeDisplay */


/*
%F This function reads the node display information
*/
static void _NfiReadNodeVelocDisplay( void )
{
 int i, num;
 int id;

/* Read the number of nodes
 */
 fscanf( _NfiName, "%d", &num );

/* Set the number of nodes and get memory for the labels
 */
 NumCurves = num;
 Labels = (char **)calloc( num, sizeof(char *) );
 for( i = 0; i < num; i++ )
  Labels[i] = (char *)calloc( 20, sizeof(char) );

/* Read node id and set its labels
 */
 for( i = 0; i < num; i++ )
 {
  fscanf( _NfiName, "%d", &id );

  NodeVector[id-1].dspIteration = DSP_YES;
  NodeVector[id-1].curve        = i;
  sprintf( Labels[i], "Node %d", id );
 }

/* Set graphic type
 */
 GpType = 1;

} /* End of _NfiReadNodeVelocDisplay */


/*
%F This function reads the integration order information.
*/
static void _NfiReadIntegrationOrder( void )
{
 int num, i, r, s, t, id;

/* Read the number of defined integration order
 */
 fscanf( _NfiName, "%d", &num );

/* Set the number of integration order
 */
 NumIntOrder = num;

/* Get memory for the integration order vector
 */
 IntOrder = (sOrder *)calloc( NumIntOrder, sizeof(sOrder) );

/* Read the integration order information and fill its vector
 */
 for( i = 0; i < num; i++ )
 {
  fscanf( _NfiName, "%d %d %d %d %*d %*d %*d", &id, &r, &s, &t );
  IntOrder[id-1].r = r;
  IntOrder[id-1].s = s;
  IntOrder[id-1].t = t;
 }

} /* End of _NfiReadIntegrationOrder */


/*
%F This function reads the thickness vector.
*/
static void _NfiReadThickness( void )
{
 int    num, i, id;
 double tck;

/* Read the number of defined thickness
 */
 fscanf( _NfiName, "%d", &num );

/* Set the number of definied thickness
 */
 NumThickness = num;

/* Get memory for the thickness vector
 */
 Thickness = (double *)calloc( NumThickness, sizeof(double) );

/* Read the defined thickness
 */
 for( i = 0; i < num; i++ )
 { 
  fscanf( _NfiName, "%d %lf", &id, &tck );
  Thickness[id-1] = tck;
 }

} /* End of _NfiReadThickness */


/*
%F
*/
static void _NfiReadMaterial( void )
{
 int num;

/* Read the number of materials
 */
 fscanf( _NfiName, "%d", &num );

/* Set the number of materials
 */
 NumMaterials = num;

/* Initialize material class
 */
 MaterialInit( );
 
} /* End of _NfiReadMaterial */


/*
%F
*/
static void _NfiReadMaterialFLUIDDENSITY( void )
{
 int    num, i, id;
 double rho;

/* Read the number of fluid densities
 */
 fscanf( _NfiName, "%d", &num );

/* Read the fluid density information
 */
 for( i = 0; i < num; i++ )
 {
  fscanf( _NfiName, "%d %lf", &id, &rho );
  MatList[id-1]->Rhof = rho;
 }

} /* End of _NfiReadMaterialFLUIDDENSITY */


/*
%F This function reads the material density information.
*/
static void _NfiReadMaterialPROPERTYDENSITY( void )
{
 int    num, i, id;
 double gamma;

/* Read the number of materials densities
 */
 fscanf( _NfiName, "%d", &num );

/* Read the material density information
 */
 for( i = 0; i < num; i++ )
 {
  fscanf( _NfiName, "%d %lf", &id, &gamma );
  MatList[id-1]->Gamma = gamma;
 }

} /* End of _NfiReadMaterialPROPERTYDENSITY */

/*
%F This function reads the material density information.
*/
static void _NfiReadMaterialPROPERTYLAMBDA( void )
{
 int    num, i, id;
 double lambda;

/* Read the number of materials lambda
 */
 fscanf( _NfiName, "%d", &num );

/* Read the material lambda information
 */
 for( i = 0; i < num; i++ )
 {
  fscanf( _NfiName, "%d %lf", &id, &lambda );
  MatList[id-1]->Lambda = lambda;
 }

} /* End of _NfiReadMaterialPROPERTYLAMBDA */


/*
%F This function reads the von mises material information.
*/
static void _NfiReadMaterialMISES( void )
{
 int        num, i, id;
 sMaterial *mat = 0L;

/* Read the number of von mises materials
 */
 fscanf( _NfiName, "%d", &num );

/* Read the von mises material information
 */
 for( i = 0; i < num; i++ )
 {
  fscanf( _NfiName, "%d", &id );
  MatNew( MISES, id, &mat );
  MatRead( mat );
 }

} /* End of _NfiReadMaterialMISES */


/*
%F This function reads the interface mohr coulomb material information.
*/
static void _NfiReadMaterialINTERFACEMOHRCOULOMB( void )
{
 int        num, i, id;
 sMaterial *mat = 0L;

/* Read the number of interface mohr coulomb materials
 */
 fscanf( _NfiName, "%d", &num );

/* Read the interface mohr coulomb material information
 */
 for( i = 0; i < num; i++ )
 {
  fscanf( _NfiName, "%d", &id );
  MatNew( ITF_MOHR_COULOMB, id, &mat );
  MatRead( mat );
 }

} /* End of _NfiReadMaterialINTERFACEMOHRCOULOMB */


/*
%F This function reads the interface material information.
*/
static void _NfiReadMaterialINTERFACE( void )
{
 int        num, i, id;
 sMaterial *mat = 0L;

/* Read the number of interface materials
 */
 fscanf( _NfiName, "%d", &num );

/* Read the interface material information
 */
 for( i = 0; i < num; i++ )
 {
  fscanf( _NfiName, "%d", &id );
  MatNew( INTERFACE_MAT, id, &mat );
  MatRead( mat );
 }

} /* End of _NfiReadMaterialINTERFACE */


/*
%F This function reads the kelvin material information.
*/
static void _NfiReadMaterialKELVIN( void )
{
 int        num, i, id;
 sMaterial *mat = 0L;

/* Read the number of kelvin materials
 */
 fscanf( _NfiName, "%d", &num );

/* Read the kelvin material information
 */
 for( i = 0; i < num; i++ )
 {
  fscanf( _NfiName, "%d", &id );
  MatNew( KELVIN, id, &mat );
  MatRead( mat );
 }

} /* End of _NfiReadMaterialKELVIN */


/*
%F This function reads the maxwell material information.
*/
static void _NfiReadMaterialMAXWELL( void )
{
 int        num, i, id;
 sMaterial *mat = 0L;

/* Read the number of maxwell materials
 */
 fscanf( _NfiName, "%d", &num );

/* Read the maxwell material information
 */
 for( i = 0; i < num; i++ )
 {
  fscanf( _NfiName, "%d", &id );
  MatNew( MAXWELL, id, &mat );
  MatRead( mat );
 }

} /* End of _NfiReadMaterialMAXWELL */


/*
%F This function reads the generic material information, to provide 
   the compatibility to the older versions.
*/
static void _NfiReadMaterialGENERIC( void )
{
 int        num, numpar, mtype, i, id;
 long       fpos;
 sMaterial *mat = 0L;

/* Read the number of generic materials
 */
 fscanf( _NfiName, "%d", &num );

/* Read the generic material information
 */
 for( i = 0; i < num; i++ )
 {
  fscanf( _NfiName, "%d %d", &id, &numpar );
  switch( numpar )
  {
   case 4:
   /* Get file position
    */
    fpos = ftell( _NfiName ); 

   /* Read the viscos material type
    */
    fscanf( _NfiName, "%*f %*f %*f %d", &mtype );
   
   /* Create a material descriptor according its type
    */
    if( mtype == 0 )
    {
     MatNew( KELVIN, id, &mat );
    }
    else
    {
     MatNew( MAXWELL, id, &mat );
    }

   /* Set new file position
    */
    fseek( _NfiName, fpos, SEEK_SET );

   /* Read the material parameters
    */
    MatRead( mat );

   /* Discart the viscos material type id
    */
    fscanf( _NfiName, "%d", &mtype );
    break;

   case 5:
   /* Create a mohr coulomb nonassociated constant material
    */
    MatNew( MOHR_COULOMB_NAC, id, &mat );
    MatRead( mat );
   
   case 11:
   /* Create a mohr coulomb nonassociated constant material
    */
    MatNew( MOHR_COULOMB_NAV, id, &mat );
    MatRead( mat );
   
   default:
    break;
  }
 }

} /* End of _NfiReadMaterialGENERIC */


/*
%F This function reads the isotropic material information.
*/
static void _NfiReadMaterialISOTROPIC( void )
{
 int        num, i, id;
 sMaterial *mat = 0L;

/* Read the number of isotropic materials
 */
 fscanf( _NfiName, "%d", &num );

/* Read the isotropic material information
 */
 for( i = 0; i < num; i++ )
 {
  fscanf( _NfiName, "%d", &id );
  MatNew( ISOTROPIC, id, &mat );
  MatRead( mat );
 }

} /* End of _NfiReadMaterialISOTROPIC */


/*
%F This function reads the isotropic fail material information.
*/
static void _NfiReadMaterialISOTROPICFAIL( void )
{
 int        num, i, id;
 sMaterial *mat = 0L;

/* Read the number of isotropic materials
 */
 fscanf( _NfiName, "%d", &num );

/* Read the isotropic material information
 */
 for( i = 0; i < num; i++ )
 {
  fscanf( _NfiName, "%d", &id );
  MatNew( ISOTROPIC_FAIL, id, &mat );
  MatRead( mat );
 }

} /* End of _NfiReadMaterialISOTROPICFAIL */


/*
%F This function reads the orthotropic material information.
*/
static void _NfiReadMaterialORTHOTROPIC( void )
{
 int        num, i, id;
 sMaterial *mat = 0L;

/* Read the number of orthotropic materials
 */
 fscanf( _NfiName, "%d", &num );

/* Read the orthotropic material information
 */
 for( i = 0; i < num; i++ )
 {
  fscanf( _NfiName, "%d", &id );
  MatNew( ORTHOTROPIC, id, &mat );
  MatRead( mat );
 }

} /* End of _NfiReadMaterialORTHOTROPIC */


/*
%F This function reads the hiperbolic material information.
*/
static void _NfiReadMaterialHIPERBOLIC( void )
{
 int        num, i, id;
 sMaterial *mat = 0L;

/* Read the number of hiperbolic materials
 */
 fscanf( _NfiName, "%d", &num );

/* Read the hiperbolic material information
 */
 for( i = 0; i < num; i++ )
 {
  fscanf( _NfiName, "%d", &id );
  MatNew( HIPERBOLIC, id, &mat );
  MatRead( mat );
 }

} /* End of _NfiReadMaterialHIPERBOLIC */


/*
%F This function reads the mohr coulomb material information.
*/
static void _NfiReadMaterialMOHRCOULOMB( void )
{
 int        num, i, id;
 sMaterial *mat = 0L;

/* Read the number of mohr coulomb materials
 */
 fscanf( _NfiName, "%d", &num );

/* Read the mohr coulomb material information
 */
 for( i = 0; i < num; i++ )
 {
  fscanf( _NfiName, "%d", &id );
  MatNew(MOHR_COULOMB,id,&mat);
  MatRead(mat);
 }

} /* End of _NfiReadMaterialMOHRCOULOMB */


/*
%F This function reads the mohr coulomb with traction cutoff material 
   information.
*/
static void _NfiReadMaterialMOHRCOULOMBCUTOFF( void )
{
 int        num, i, id;
 sMaterial *mat = 0L;

/* Read the number of mohr coulomb materials
 */
 fscanf( _NfiName, "%d", &num );

/* Read the mohr coulomb material information
 */
 for( i = 0; i < num; i++ )
 {
  fscanf( _NfiName, "%d", &id );
  MatNew(MOHR_COULOMB_CUTOFF,id,&mat);
  MatRead(mat);
 }

} /* End of _NfiReadMaterialMOHRCOULOMBCUTOFF */


/*
%F This function reads the mohr coulomb nonassociated constant material 
   information.
*/
static void _NfiReadMaterialMOHRCOULOMBNAC( void )
{
 int        num, i, id;
 sMaterial *mat = 0L;

/* Read the number of mohr coulomb materials
 */
 fscanf( _NfiName, "%d", &num );

/* Read the mohr coulomb nonassociated constant material information
 */
 for( i = 0; i < num; i++ )
 {
  fscanf( _NfiName, "%d", &id );
  MatNew(MOHR_COULOMB_NAC,id,&mat);
  MatRead(mat);
 }

} /* End of _NfiReadMaterialMOHRCOULOMBNAC */


/*
%F This function reads the mohr coulomb nonassociated variable material 
   information.
*/
static void _NfiReadMaterialMOHRCOULOMBNAV( void )
{
 int        num, i, id;
 sMaterial *mat = 0L;

/* Read the number of mohr coulomb materials
 */
 fscanf( _NfiName, "%d", &num );

/* Read the mohr coulomb nonassociated constant material information
 */
 for( i = 0; i < num; i++ )
 {
  fscanf( _NfiName, "%d", &id );
  MatNew(MOHR_COULOMB_NAV,id,&mat);
  MatRead(mat);
 }

} /* End of _NfiReadMaterialMOHRCOULOMBNAV */


/*
%F
*/
static int _NfiReadElement( void )
{
 int nelem;

/* Read number of elements
 */
 fscanf( _NfiName, "%d", &nelem );

/* Check to see if the number of element were given
 */
 if( nelem == 0 )
 {
  printf( "\nThe number of elements must be given!\n" );
  return 0;
 }

/* Set number of elements
 */
 NumElements = nelem;

/* Initialize element class
 */
 ElementInit( );

 return 1;

} /* End of _NfiReadElement */

static void _NfiReadElementLINE2(void)
{
 int nelem, i;
 int id, matid, tckid, ordid;
 sElement *elm = 0L;

/* Read the number of elements in this section
 */
 fscanf(_NfiName, "%d", &nelem);

/* Read element information
 */
 for( i = 0; i < nelem; i++ ) {
  fscanf( _NfiName, "%d%d%d%d", &id, &matid, &tckid, &ordid );
  ElmNew(LINE2,id,matid,ordid,tckid,&elm,ElmList,NodeVector);
  ElmRead(elm);
 }

} /* End of _NfiReadElementLINE2 */

/*
%F
*/
static void _NfiReadElementT3( void )
{
 int       nelem, i;
 int       id, matid, tckid, ordid;
 sElement *elm = 0L;

/* Read the number of elements in this section
 */
 fscanf( _NfiName, "%d", &nelem );

/* Read element information
 */
 for( i = 0; i < nelem; i++ )
 {
  fscanf( _NfiName, "%d%d%d%d", &id, &matid, &tckid, &ordid );
  ElmNew(T3,id,matid,ordid,tckid,&elm,ElmList,NodeVector);
  ElmRead(elm);
 }

} /* End of _NfiReadElementT3 */

/*
%F
*/
static void _NfiReadElementDKT( void )
{
 int       nelem, i;
 int       id, matid, tckid, ordid;
 sElement *elm = 0L;

/* Read the number of elements in this section
 */
 fscanf( _NfiName, "%d", &nelem );

/* Read element information
 */
 for( i = 0; i < nelem; i++ )
 {
  fscanf( _NfiName, "%d%d%d%d", &id, &matid, &tckid, &ordid );
  ElmNew(DKT,id,matid,ordid,tckid,&elm,ElmList,NodeVector);
  ElmRead(elm);
 }

} /* End of _NfiReadElementDKT */


/*
%F
*/
static void _NfiReadElementQ4( void )
{
 int       nelem, i;
 int       id, matid, tckid, ordid;
 sElement *elm = 0L;

/* Read the number of elements in this section
 */
 fscanf( _NfiName, "%d", &nelem );

/* Read element information
 */
 for( i = 0; i < nelem; i++ )
 {
  fscanf( _NfiName, "%d%d%d%d", &id, &matid, &tckid, &ordid );
  ElmNew(Q4,id,matid,ordid,tckid,&elm,ElmList,NodeVector);
  ElmRead(elm);
 }

} /* End of _NfiReadElementQ4 */


/*
%F
*/
static void _NfiReadElementBRICK8( void )
{
 int       nelem, i;
 int       id, matid, ordid;
 sElement *elm = 0L;

/* Read the number of elements in this section
 */
 fscanf( _NfiName, "%d", &nelem );

/* Read element information
 */
 for( i = 0; i < nelem; i++ )
 {
  fscanf( _NfiName, "%d%d%d", &id, &matid, &ordid );
  ElmNew(BRICK8,id,matid,ordid,0,&elm,ElmList,NodeVector);
  ElmRead(elm);
 }

} /* End of _NfiReadElementBRICK8 */


/*
%F
*/
static void _NfiReadElementTETR4( void )
{
 int       nelem, i;
 int       id, matid, ordid;
 sElement *elm = 0L;

/* Read the number of elements in this section
 */
 fscanf( _NfiName, "%d", &nelem );

/* Read element information
 */
 for( i = 0; i < nelem; i++ )
 {
  fscanf( _NfiName, "%d%d%d", &id, &matid, &ordid );
  ElmNew(TETR4,id,matid,ordid,0,&elm,ElmList,NodeVector);
  ElmRead(elm);
 }

} /* End of _NfiReadElementTETR4 */


/*
%F
*/
static void _NfiReadElementINTERFACE( void )
{
 int       nelem, i;
 int       id, matid, tckid, ordid;
 sElement *elm = 0L;

/* Read the number of elements in this section
 */
 fscanf( _NfiName, "%d", &nelem );

/* Read element information
 */
 for( i = 0; i < nelem; i++ )
 {
  fscanf( _NfiName, "%d%d%d%d", &id, &matid, &tckid, &ordid );
  ElmNew(INTERFACE,id,matid,ordid,tckid,&elm,ElmList,NodeVector);
  ElmRead(elm);
 }

} /* End of _NfiReadElementINTERFACE */


/*
%F
*/
static void _NfiReadElementINFINITE( void )
{
 int       nelem, i;
 int       id, matid, tckid, ordid;
 sElement *elm = 0L;

/* Read the number of elements in this section
 */
 fscanf( _NfiName, "%d", &nelem );

/* Read element information
 */
 for( i = 0; i < nelem; i++ )
 {
  fscanf( _NfiName, "%d%d%d%d", &id, &matid, &tckid, &ordid );
  ElmNew(INFINITE,id,matid,ordid,tckid,&elm,ElmList,NodeVector);
  ElmRead(elm);
 }

} /* End of _NfiReadElementINFINITE */


/*
%F
*/
static void _NfiReadElementProfileT3( void )
{
 int       nelem, i, id;

 /* Read the number of elements in this section
 */
 fscanf( _NfiName, "%d", &nelem );


 /* Read the profile
 */
 for( i = 0; i < nelem; i++ )
 {
  fscanf( _NfiName, "%d", &id );
  ElmReadProfile( ElmList[id-1] );
 }

} /* End of _NfiReadElementProfileT3 */

static void _NfiReadElementProfileQ4( void )
{
 int      nelem, i, id;

 /* Read the number of elements in this section
 */
 fscanf( _NfiName, "%d", &nelem );


 /* Read the profile
 */
 for( i = 0; i < nelem; i++ )
 {
  fscanf( _NfiName, "%d", &id );
  ElmReadProfile( ElmList[id-1] );
 }

} /* End of _NfiReadElementProfileQ4 */

static void _NfiReadElementProfileBRICK8( void )
{
 int       nelem, i, id;

 /* Read the number of elements in this section
 */
 fscanf( _NfiName, "%d", &nelem );


 /* Read the profile
 */
 for( i = 0; i < nelem; i++ )
 {
  fscanf( _NfiName, "%d", &id );
  ElmReadProfile( ElmList[id-1] );
 }

} /* End of _NfiReadElementProfileBRICK8 */

static void _NfiReadElementProfileTETRA4( void )
{
 int       nelem, i, id;

 /* Read the number of elements in this section
 */
 fscanf( _NfiName, "%d", &nelem );


 /* Read the profile
 */
 for( i = 0; i < nelem; i++ )
 {
  fscanf( _NfiName, "%d", &id );
  ElmReadProfile( ElmList[id-1] );
 }

} /* End of _NfiReadElementProfileTETRA4 */


/*
%F
*/
static void _NfiReadLoad( void )
{
 int i, id;

/* Read the number of load cases
 */
 fscanf( _NfiName, "%d", &NumLoadCase );

/* Get memory for the load case vector
 */
 LoadCase = (sLoadCase *)calloc( NumLoadCase, sizeof(sLoadCase) );

/* Set the case id
 */
 for( i = 0; i < NumLoadCase; i++ )
 {
  fscanf( _NfiName, "%d", &id );
  _NfiReadString( LoadCase[i].label );
  LoadCase[i].icase = id;
 }

/* Create a LOAD_STEP driver
 */
 if( NumLoadCase > 1 )
  DrvNew( LOAD_CASE, &DrvObj );

} /* End of _NfiReadLoad */


/*
%F
*/
static void _NfiReadLoadCase( void )
{
 int icase;

/* Set the current load case
 */
 fscanf( _NfiName, "%d", &icase );
 
 CurrLoadCase = icase - 1;

} /* End of _NfiReadLoadCase */


/*
%F
*/
static void _NfiReadLoadCaseGravity( void )
{
 double gx, gy, gz;

/* Read the gravity forces
 */
 fscanf( _NfiName, "%lf%lf%lf", &gx, &gy, &gz );
 GravForce.gx = gx;
 GravForce.gy = gy;
 GravForce.gz = gz;

} /* End of _NfiReadLoadCaseGravity */


/*
%F
*/
static void _NfiReadLoadCaseElementPotencial( void )
{
 int    i, elem;
 double pot;

/* Read the elemental potencial number
 */
 fscanf( _NfiName, "%d", &NumElemPoten );

/* Get memory for the elemental potencial vector
 */
 ElemPoten = (sElemPoten *)calloc( NumElemPoten, sizeof(sElemPoten) );

/* Read the elemental potencial information
 */
 for( i = 0; i < NumElemPoten; i++ )
 {
  fscanf( _NfiName, "%d%lf", &elem, &pot );
  ElemPoten[i].elem = elem;
  ElemPoten[i].phi  = pot;
 }

} /* End of _NfiReadLoadCaseElementPotencial */

/*
%F
*/
static void _NfiReadLoadCaseNodalSupport( void )
{
 int i, node, tx, ty, tz;

/* Read the number of nodal support
 */
 fscanf( _NfiName, "%d", &NumNodalSupp );

/* Get memory for the nodal support vector
 */
 NodalSupp = (sNodalSupp *)calloc( NumNodalSupp, sizeof(sNodalSupp) );

/* Read de nodal support information
 */
 for( i = 0; i < NumNodalSupp; i++ )
 {
  fscanf( _NfiName, "%d%d%d%d%*d%*d%*d", &node, &tx, &ty, &tz );
  NodalSupp[i].node = node;
  NodalSupp[i].tx   = tx;
  NodalSupp[i].ty   = ty;
  NodalSupp[i].tz   = tz;
 }

} /* End of _NfiReadLoadCaseNodalSupport */

/*
%F
*/
static void _NfiReadLoadCaseNodalPressure( void )
{
 int    i, node;
 double press;

/* Read the nodal pressure number
 */
 fscanf( _NfiName, "%d", &NumNodalPress );

/* Get memory for the nodal pressure vector
 */
 NodalPress = (sNodalPress *)calloc( NumNodalPress, sizeof(sNodalPress) );

/* Read the nodal pressure information
 */
 for( i = 0; i < NumNodalPress; i++ )
 {
  fscanf( _NfiName, "%d%lf", &node, &press );
  NodalPress[i].node = node;
  NodalPress[i].psi  = press;
 }

} /* End of _NfiReadLoadCaseNodalPressure */


/*
%F
*/
static void _NfiReadLoadCaseNodalForces( void )
{
 int    i, node;
 double fx, fy, fz;

/* Read the nodal forces number
 */
 fscanf( _NfiName, "%d", &NumNodalForce );

/* Get memory for the nodal forces vector
 */
 NodalForce = (sNodalForce *)calloc( NumNodalForce, sizeof(sNodalForce) );

/* Read the nodal force information
 */
 for( i = 0; i < NumNodalForce; i++ )
 {
  fscanf( _NfiName, "%d%lf%lf%lf%*f%*f%*f", &node, &fx, &fy, &fz );
  NodalForce[i].node = node;
  NodalForce[i].fx   = fx;
  NodalForce[i].fy   = fy;
  NodalForce[i].fz   = fz;
 }

} /* End of _NfiReadLoadCaseNodalForces */


/*
%F
*/
static void _NfiReadLoadCaseNodalVelocity( void )
{
 int    i, node;
 double vx, vy, vz;

/* Read the nodal velocities number
 */
 fscanf( _NfiName, "%d", &NumNodalVel );

/* Get memory for the nodal velocities vector
 */
 NodalVel = (sNodalVel *)calloc( NumNodalVel, sizeof(sNodalVel) );

/* Read the nodal velocity information
 */
 for( i = 0; i < NumNodalVel; i++ )
 {
  fscanf( _NfiName, "%d%lf%lf%lf", &node, &vx, &vy, &vz );
  NodalVel[i].node = node;
  NodalVel[i].vx   = vx;
  NodalVel[i].vy   = vy;
  NodalVel[i].vz   = vz;
 }

} /* End of _NfiReadLoadCaseNodalVelocity */


/*
%F
*/
static void _NfiReadLoadCaseLineForcesUni( void )
{
 int    i, elem, key, noi, noj;
 double qx, qy, qz;

/* Read the line force uniform number
 */
 fscanf( _NfiName, "%d", &NumLineForce );

/* Get memory for the line force uniform vector
 */
 LineForce = (sLineForce *)calloc( NumLineForce, sizeof(sLineForce) );

/* Read the line force uniform information
 */
 for( i = 0; i < NumLineForce; i++ )
 {
  fscanf( _NfiName, "%d%d%d%d%lf%lf%lf", &elem,
                                         &noi,
                                         &noj,
                                         &key, 
                                         &qx,
                                         &qy,
                                         &qz );
  LineForce[i].elem = elem;
  LineForce[i].type = UNIFORM;
  LineForce[i].noi  = noi;
  LineForce[i].noj  = noj;
  LineForce[i].key  = key;
  LineForce[i].q1x  = qx;
  LineForce[i].q1y  = qy;
  LineForce[i].q1z  = qz;
  LineForce[i].q2x  = qx;
  LineForce[i].q2y  = qy;
  LineForce[i].q2z  = qz;
 }

} /* End of _NfiReadLoadCaseLineForcesUni */

/*
%F
*/
static void _NfiReadLoadCaseAreaUniform( void )
{
 int    i, elem, key, noi, noj, nok;
 double qx, qy, qz;

/* Read the area force uniform number
 */
 fscanf( _NfiName, "%d", &NumAreaForceUniform );

/* Get memory for the line force uniform vector
 */
 AreaForceUniform = (sAreaForceUniform *)calloc( NumAreaForceUniform, sizeof(sAreaForceUniform) );
 
/* Read the area force uniform information
 */
 for( i = 0; i < NumAreaForceUniform; i++ )
 {
  fscanf( _NfiName, "%d%d%d%d%d%lf%lf%lf", &elem,
                                           &noi,
                                           &noj,
                                           &nok,
                                           &key, 
                                           &qx,
                                           &qy,
                                           &qz );
  AreaForceUniform[i].elem = elem;
  AreaForceUniform[i].type = AREAUNIFORM;
  AreaForceUniform[i].noi  = noi;
  AreaForceUniform[i].noj  = noj;
  AreaForceUniform[i].nok  = nok;
  AreaForceUniform[i].key  = key;
  AreaForceUniform[i].qx   = qx;
  AreaForceUniform[i].qy   = qy;
  AreaForceUniform[i].qz   = qz;
 
 }

} /* End of _NfiReadLoadCaseAreaUniform */


/*
%F
*/
static void _NfiReadLoadCaseAreaPressure( void )
{
 int    i, elem, key, noi, noj, nok;
 double qx, qy, qz;

/* Read the area force pressure number
 */
 fscanf( _NfiName, "%d", &NumAreaForcePressure );

/* Get memory for the line force pressure vector
 */
 AreaForcePressure = (sAreaForcePressure *)calloc( NumAreaForcePressure, sizeof(sAreaForcePressure) );
 
/* Read the area force pressure information
 */
 for( i = 0; i < NumAreaForcePressure; i++ )
 {
  fscanf( _NfiName, "%d%d%d%d%d%lf%lf%lf", &elem,
                                           &noi,
                                           &noj,
                                           &nok,
                                           &key, 
                                           &qx,
                                           &qy,
                                           &qz );
  AreaForcePressure[i].elem = elem;
  AreaForcePressure[i].type = AREAPRESSURE;
  AreaForcePressure[i].noi  = noi;
  AreaForcePressure[i].noj  = noj;
  AreaForcePressure[i].nok  = nok;
  AreaForcePressure[i].key  = key;
  AreaForcePressure[i].qx   = qx;
  AreaForcePressure[i].qy   = qy;
  AreaForcePressure[i].qz   = qz;
 
 }

} /* End of _NfiReadLoadCaseAreaPressure */


/*
%F
*/
static void _NfiReadLoadCaseLineForcesVar( void )
{
 int    i, elem, key, noi, noj;
 double q1x, q1y, q1z;
 double q2x, q2y, q2z;

/* Read the line force variable number
 */
 fscanf( _NfiName, "%d", &NumLineForce );

/* Get memory for the line force variable vector
 */
 LineForce = (sLineForce *)calloc( NumLineForce, sizeof(sLineForce) );

/* Read the line force variable information
 */
 for( i = 0; i < NumLineForce; i++ )
 {
  fscanf( _NfiName, "%d%d%d%d%lf%lf%lf%lf%lf%lf", &elem, &noi, &noj, &key, 
                                                  &q1x, &q1y, &q1z,
                                                  &q2x, &q2y, &q2z );
  LineForce[i].elem = elem;
  LineForce[i].type = VARIABLE;
  LineForce[i].noi  = noi;
  LineForce[i].noj  = noj;
  LineForce[i].key  = key;
  LineForce[i].q1x  = q1x;
  LineForce[i].q1y  = q1y;
  LineForce[i].q1z  = q1z;
  LineForce[i].q2x  = q2x;
  LineForce[i].q2y  = q2y;
  LineForce[i].q2z  = q2z;
 }

} /* End of _NfiReadLoadCaseLineForcesVar */


/*
%F
*/
static int _NfiReadLoadCaseDomainInitStressUni( void )
{
 int status;
 int i, nelem, id;

/* Read the number of elements
 */
 fscanf( _NfiName, "%d", &nelem );

/* Check to see if the number of element were redefined
 */
 if( nelem != NumElements )
 {
  printf( "\nThe number of elements were redefined!\n" );
  return 0;
 }

/* Read the initial stress
 */
 for( i = 0; i < nelem; i++ )
 {
  fscanf( _NfiName, "%d", &id );
  status = ElmReadInitStress( ElmList[id-1] );
  if( !status ) return 0;
 }

 return 1;
} /* End of _NfiReadLoadCaseDomainInitStressUni */


/*
%F
*/
static void _NfiReadLoadCaseDomainTempUni( void )
{
} /* End of _NfiReadLoadCaseDomainTempUni */


/*
%F
*/
static void _NfiReadLoadCaseNodalDisplacements( void )
{
 int    i, node;
 double dx, dy, dz;

/* Read the nodal displacement number
 */
 fscanf( _NfiName, "%d", &NumNodalDisp );

/* Get memory for the nodal displacement vector
 */
 NodalDisp = (sNodalDisp *)calloc( NumNodalDisp, sizeof(sNodalDisp) );

/* Read the nodal displacement information
 */
 for( i = 0; i < NumNodalDisp; i++ )
 {
  fscanf( _NfiName, "%d%lf%lf%lf%*f%*f%*f", &node, &dx, &dy, &dz );
  NodalDisp[i].node = node;
  NodalDisp[i].dx   = dx;
  NodalDisp[i].dy   = dy;
  NodalDisp[i].dz   = dz;
 }

} /* End of _NfiReadLoadCaseNodalDisplacements */


/*
%F This function reads the rezone number.
*/
static void _NfiReadRezone( void )
{
 int i;

/* Read the number of rezone cases
 */
 fscanf( _NfiName, "%d", &NumRezones );

/* Allocate each descriptor
 */
 Rezone = (sRezone *)calloc( NumRezones, sizeof(sRezone) );

/* Read the rezone case labels
 */
 for( i = 0; i < NumRezones; i++ )
 {
  fscanf( _NfiName, "%d", &Rezone[i].id );
  _NfiReadString( Rezone[i].label );
 }

/* Create a Rezone Driver
 */
 DrvNew( REZONE, &DrvObj );

} /* End of _NfiReadRezone */


/*
%F 
*/
static void _NfiReadRezoneCase( void )
{
/* Set the current rezone case
 */
 fscanf( _NfiName, "%d", &_CurrCase );
 
 _CurrCase--;

} /* End of _NfiReadRezoneCase */


/*
%F
*/
static void _NfiReadRezoneCaseElement( void )
{
 int num, elm, i;

/* Read the number of element in the current rezone case
 */
 fscanf( _NfiName, "%d", &num );
 Rezone[_CurrCase].numelm = num;

/* Get memory for the list of elements
 */
 Rezone[_CurrCase].elm = (int *)calloc( num, sizeof(int) );

/* Read the element list for the current rezone
 */
 for( i = 0; i < num; i++ )
 {
  fscanf( _NfiName, "%d", &elm );
  Rezone[_CurrCase].elm[i] = elm;
 }

} /* End of _NfiReadRezoneCaseElement */


/*
%F
*/
static void _NfiWriteResultStep( int step, long ndlrpos, long elmrpos,
                                 double *disp )
{
 int i;
 double gauge;
 int totstepgauge;
 
 totstepgauge = (Config.max_iter/Config.print_step)+1; 
 

/* Write step label
 */
 fprintf( _NfiName, "%%RESULT.CASE.STEP\n%d\n\n", step );

 gauge = ((double)(step-1) / (double)totstepgauge); 
 if( _fposgauge != NULL )
 {
   (*_fposgauge) ( gauge );
 } 

/* Read displacement from temporary result file
 */
 fread( disp, sizeof(double), NDof*NumNodes, ndlr );

/* Write displacements
 */
 fprintf( _NfiName, "%%RESULT.CASE.STEP.NODAL.DISPLACEMENT\n" );
 fprintf( _NfiName, "%d\t'Displacement'\n", NumNodes );
 for( i = 0; i < NumNodes; i++ )
 {
  if( NDof == 2 )
   fprintf( _NfiName, "%d\t%+10.5e\t%+10.5e\t%+10.5e", i+1, disp[2*i],
                                                            disp[2*i+1],
                                                            0.0 );
  else
   fprintf( _NfiName, "%d\t%+10.5e\t%+10.5e\t%+10.5e", i+1, disp[3*i],
                                                            disp[3*i+1],
                                                            disp[3*i+2] );
  fprintf( _NfiName, "\t%+10.5e\t%+10.5e\t%+10.5e\n", 0.0, 0.0, 0.0 );
 }
 fprintf( _NfiName, "\n" );
 
/* Write element gauss results
 */
 if( NDof == 2 )
 {
  if(Config.numgaussresults == -1){
   Config.numgaussresults = 24;
   Config.gaussresults = (char**) malloc( Config.numgaussresults * sizeof( char * ) );
   Config.gaussresults[0]  = strdup ( "Yield" );
   Config.gaussresults[1]  = strdup ( "Rf" );
   Config.gaussresults[2]  = strdup ( "Sxx" );
   Config.gaussresults[3]  = strdup ( "Syy" );
   Config.gaussresults[4]  = strdup ( "Sxy" );
   Config.gaussresults[5]  = strdup ( "Pf" );
   Config.gaussresults[6]  = strdup ( "SExx" );
   Config.gaussresults[7]  = strdup ( "SEyy" );
   Config.gaussresults[8]  = strdup ( "Siso" );
   Config.gaussresults[9]  = strdup ( "SDxx" );
   Config.gaussresults[10] = strdup ( "SDyy" );
   Config.gaussresults[11] = strdup ( "S1" );
   Config.gaussresults[12] = strdup ( "S3" );
   Config.gaussresults[13] = strdup ( "SE1" );
   Config.gaussresults[14] = strdup ( "SE3" );
   Config.gaussresults[15] = strdup ( "SD1" );
   Config.gaussresults[16] = strdup ( "SD3" );
   Config.gaussresults[17] = strdup ( "Exx" );
   Config.gaussresults[18] = strdup ( "Eyy" );
   Config.gaussresults[19] = strdup ( "Exy" );
   Config.gaussresults[20] = strdup ( "E1" );
   Config.gaussresults[21] = strdup ( "E3" );
   Config.gaussresults[22] = strdup ( "Ev" );
   Config.gaussresults[23] = strdup ( "K0" );
  }
 }
 else
 {
  if(Config.numgaussresults == -1){
   Config.numgaussresults = 22;
   Config.gaussresults = (char**) malloc( Config.numgaussresults * sizeof( char * ) );
   Config.gaussresults[0]  = strdup ( "Sxx" );
   Config.gaussresults[1]  = strdup ( "Syy" );
   Config.gaussresults[2]  = strdup ( "Szz" );
   Config.gaussresults[3]  = strdup ( "Sxy" );
   Config.gaussresults[4]  = strdup ( "Sxz" );
   Config.gaussresults[5]  = strdup ( "Syz" );
   Config.gaussresults[6]  = strdup ( "S1" );
   Config.gaussresults[7]  = strdup ( "S2" );
   Config.gaussresults[8]  = strdup ( "S3" );
   Config.gaussresults[9]  = strdup ( "Sdx" );
   Config.gaussresults[10] = strdup ( "Sdy" );
   Config.gaussresults[11] = strdup ( "Sdz" );
   Config.gaussresults[12] = strdup ( "Exx" );
   Config.gaussresults[13] = strdup ( "Eyy" );
   Config.gaussresults[14] = strdup ( "Ezz" );
   Config.gaussresults[15] = strdup ( "Exy" );
   Config.gaussresults[16] = strdup ( "Exz" );
   Config.gaussresults[17] = strdup ( "Eyz" );
   Config.gaussresults[18] = strdup ( "E1" );
   Config.gaussresults[19] = strdup ( "E2" );
   Config.gaussresults[20] = strdup ( "E3" );
   Config.gaussresults[21] = strdup ( "Ev" );
  }
 }
 if(Config.numgaussresults > 0){
  fprintf( _NfiName, "\n%%RESULT.CASE.STEP.ELEMENT.GAUSS.SCALAR\n%d\n",Config.numgaussresults );
  for( i = 0; i < Config.numgaussresults; i++){
   fprintf( _NfiName, "'%s'", Config.gaussresults[i] );
  }
  fprintf( _NfiName, "\n" );
  fprintf( _NfiName, "%%RESULT.CASE.STEP.ELEMENT.GAUSS.SCALAR.DATA\n" );
  fprintf( _NfiName, "%d\n", NumElements );
 
  fseek( elmr, elmrpos, SEEK_SET );
  for( i = 0; i < NumElements; i++ )
   ElmWriteGaussResults( ElmList[i], _NfiName, elmr );
  fprintf( _NfiName, "\n" );
 }

#if 0
/* Write element nodal results
 */

 if( _NfiVersion.version == 1 )
 {
  if( NDof == 2 )
  {
   fprintf( _NfiName, "%%RESULT.CASE.STEP.ELEMENT.NODAL.SCALAR\n17\n" );
   fprintf( _NfiName, "'Sxx'\t'Syy'\t'Szz'\t'Sxy'\t'S1'\t'S2'\t'S3'\t" );
   fprintf( _NfiName, "'Sdx'\t'Sdy'\t'Iso'\t" );
   fprintf( _NfiName, "'Exx'\t'Eyy'\t'Exy'\t'E1'\t'E2'\t'E3'\t" );
   fprintf( _NfiName, "'Yield'\n\n" );
   fprintf( _NfiName, "%%RESULT.CASE.STEP.ELEMENT.NODAL.SCALAR.DATA\n" );
   fprintf( _NfiName, "%d\n", NumElements );
  }
  else
  {
   fprintf( _NfiName, "%%RESULT.CASE.STEP.ELEMENT.NODAL.SCALAR\n21\n" );
   fprintf( _NfiName, "'Sxx'\t'Syy'\t'Szz'\t'Sxy'\t'Sxz'\t'Syz'\t" );
   fprintf( _NfiName, "'S1'\t'S2'\t'S3'\t'Sdx'\t'Sdy'\t'Sdz'\t" );
   fprintf( _NfiName, "'Exx'\t'Eyy'\t'Ezz'\t'Exy'\t'Exz'\t'Eyz'\t" );
   fprintf( _NfiName, "'E1'\t'E2'\t'E3'\t'Yield'\n\n" );
   fprintf( _NfiName, "%%RESULT.CASE.STEP.ELEMENT.NODAL.SCALAR.DATA\n" );
   fprintf( _NfiName, "%d\n", NumElements );
  }
  fseek( elmr, elmrpos, SEEK_SET );
  for( i = 0; i < NumElements; i++ )
   ElmWriteNodalResults( ElmList[i], _NfiName, elmr );
  fprintf( _NfiName, "\n" );
 }
 
#endif
 
/* Write element gauss principal tensor result
 */
 if( _NfiVersion.version == 1 )
 {
  if( NDof == 2 )
  {
   fprintf( _NfiName, "%%RESULT.CASE.STEP.ELEMENT.GAUSS.VECTOR\n8\n" );
   fprintf( _NfiName, "'S1+'\t'S1-'\t'S3+'\t'S3-'\t" );
   fprintf( _NfiName, "'E1+'\t'E1-'\t'E3+'\t'E3-'\n\n" );
   fprintf( _NfiName, "%%RESULT.CASE.STEP.ELEMENT.GAUSS.VECTOR.DATA\n" );
   fprintf( _NfiName, "%d\n", NumElements );
  }
  else
  {
   fprintf( _NfiName, "%%RESULT.CASE.STEP.ELEMENT.GAUSS.VECTOR\n12\n" );
   fprintf( _NfiName, "'S1+'\t'S1-'\t'S2+'\t'S2-'\t'S3+'\t'S3-'\t" );
   fprintf( _NfiName, "'E1+'\t'E1-'\t'E2+'\t'E2-'\t'E3+'\t'E3-'\n\n" );
   fprintf( _NfiName, "%%RESULT.CASE.STEP.ELEMENT.GAUSS.VECTOR.DATA\n" );
   fprintf( _NfiName, "%d\n", NumElements );
  }
 }
 else
 {
  fprintf( _NfiName, "%%RESULT.CASE.STEP.ELEMENT.GAUSS.PRINCIPAL_TENSOR\n2\n" );
  fprintf( _NfiName, "'Stress'\t'Strain'\n\n" );
  fprintf( _NfiName, "%%RESULT.CASE.STEP.ELEMENT.GAUSS.PRINCIPAL_TENSOR.DATA\n" );
  fprintf( _NfiName, "%d\n", NumElements );
 }
 fseek( elmr, elmrpos, SEEK_SET );
 for( i = 0; i < NumElements; i++ )
  ElmWriteGaussVectorResults( ElmList[i], _NfiVersion.version, _NfiName, elmr );
 fprintf( _NfiName, "\n" );

} /* End of _NfiWriteResultStep */


/*
** ------------------------------------------------------------------------
** Global functions:
*/

/*
%F
*/
void NfiSetFileHandle( FILE *file )
{
/* Set file handle
 */
 _NfiName = file;

} /* End of NfiSetFileHandle */


/*
%F This function interprete a neutral file calling "Nfi" procedures.
*/
int NfiInterpFile( void )
{
 char label[80];

/* Initialize Damp class
 */
 DampingInit( );

/* Interprete the neutral file
 */
 while( 1 )
 {
  if( _NfiNextLabel( label ) == 0 )
  {
   printf( "\n\n" );
   return 0;
  }

  else if( strcmp( label, "HEADER.VERSION" ) == 0 )
  {
   _NfiReadVersion( );
  }

  else if( strcmp( label, "HEADER.ANALYSIS" ) == 0 )
  {
   if ( !_NfiReadAnalysisType( ) ) return 0;
  }

  else if( strcmp( label, "HEADER.ANALYSIS.ALGORITHM" ) == 0 )
  {
   if ( !_NfiReadAlgorithmType( ) ) return 0;
  }
  
  else if( strcmp( label, "HEADER.ANALYSIS.SOLVER" ) == 0 )
  {
   if ( !_NfiReadSolverType( ) ) return 0;
  }

  else if( strcmp( label, "HEADER.ANALYSIS.TOTAL.TIME" ) == 0 )
  {
   _NfiReadTotalTime( );
  }

  else if( strcmp( label, "HEADER.ANALYSIS.TIME.STEP" ) == 0 )
  {
   _NfiReadTimeStep( );
  }

  else if( strcmp( label, "HEADER.ANALYSIS.TIME.FRACTION" ) == 0 )
  {
   _NfiReadTimeFraction( );
  }

  else if( strcmp( label, "HEADER.ANALYSIS.DAMPPING" ) == 0 )
  {
   if( !_NfiReadDamping() ) return 0;
  }

  else if( strcmp( label, "HEADER.ANALYSIS.DAMPING.GLOBAL.PARAMETER" ) == 0 )
  {
   _NfiReadDampingGlobalParameter( );
  }

  else if( strcmp( label, "HEADER.ANALYSIS.DAMPING.LOCAL.PARAMETER" ) == 0 )
  {
   _NfiReadDampingLocalParameter( );
  }

  else if( strcmp( label, "HEADER.ANALYSIS.DAMPING.RAYLEIGH.PARAMETER" ) == 0 )
  {
   _NfiReadDampingRayleighParameter( );
  }

  else if( strcmp( label, "HEADER.ANALYSIS.LOAD.STEP" ) == 0 )
  {
   _NfiReadNumLoadStep( );
  }

  else if( strcmp( label, "HEADER.ANALYSIS.TOLERANCE" ) == 0 )
  {
   _NfiReadTolerance( );
  }

  else if( strcmp( label, "HEADER.ANALYSIS.NUM.STEP.TOLERANCE" ) == 0 )
  {
   _NfiReadNumStepTol( );       
  }
  
  else if( strcmp( label, "HEADER.ANALYSIS.NUM.GAUSS.RESULTS" ) == 0 )
  {
   _NfiReadNumGaussResults( );  
  }

  else if( strcmp( label, "HEADER.ANALYSIS.GEOMETRICALLY.NONLINEAR" ) == 0 )
  {
   _NfiReadGeometricallyNonLinear( );
  }

  else if( strcmp( label, "HEADER.ANALYSIS.MAXIMUM.ITERATION" ) == 0 )
  {
   _NfiReadMaximumIteration( );
  }

  else if( strcmp( label, "HEADER.ANALYSIS.PRINT.STEP" ) == 0 )
  {
   _NfiReadPrintStep( );
  }

  else if( strcmp( label, "HEADER.ANALYSIS.DRAW.STEP" ) == 0 )
  {
   _NfiReadDrawStep( );
  }

  else if( strcmp( label, "NODE" ) == 0 )
  {
   if( !_NfiReadNode( ) ) return 0;
  }

  else if( strcmp( label, "NODE.COORD" ) == 0 )
  {
   if( !_NfiReadNodeCoord( ) ) return 0;
  }

  else if( strcmp( label, "NODE.SUPPORT" ) == 0 )
  {
   _NfiReadNodeSupport( );
  }

  else if( (strcmp( label, "NODE.DISPLAY" ) == 0) ||
           (strcmp( label, "NODE.DISPLAY.GRAPHIC" ) == 0) ||
           (strcmp( label, "NODE.DISPLAY.DISPLACEMENT.GRAPHIC" ) == 0) )
  {
   _NfiReadNodeDispDisplay( );
  }

  else if( strcmp( label, "NODE.DISPLAY.DISPLACEMENT.TIME.GRAPHIC" ) == 0 )
  {
   _NfiReadNodeDispTimeDisplay( );
  }

  else if( strcmp( label, "NODE.DISPLAY.VELOCITY.GRAPHIC" ) == 0 )
  {
   _NfiReadNodeVelocDisplay( );
  }

  else if( strcmp( label, "INTEGRATION.ORDER" ) == 0 )
  {
   _NfiReadIntegrationOrder( );
  }

  else if( strcmp( label, "THICKNESS" ) == 0 )
  {
   _NfiReadThickness( );
  }

  else if( strcmp( label, "MATERIAL" ) == 0 )
  {
   _NfiReadMaterial( );
  }

  else if( strcmp( label, "MATERIAL.PROPERTY.DENSITY" ) == 0 )
  {
   _NfiReadMaterialPROPERTYDENSITY( );
  }

  else if( strcmp( label, "MATERIAL.PROPERTY.LAMBDA" ) == 0 )
  {
   _NfiReadMaterialPROPERTYLAMBDA( );
  }

  else if( strcmp( label, "MATERIAL.FLUID.DENSITY" ) == 0 )
  {
   _NfiReadMaterialFLUIDDENSITY( );
  }

  else if( strcmp( label, "MATERIAL.MISES" ) == 0 )
  {
   _NfiReadMaterialMISES( );
  }

  else if( strcmp( label, "MATERIAL.INTERFACE.MOHR.COULOMB" ) == 0 )
  {
   _NfiReadMaterialINTERFACEMOHRCOULOMB( );
  }

  else if( strcmp( label, "MATERIAL.INTERFACE" ) == 0 )
  {
   _NfiReadMaterialINTERFACE( );
  }

  else if( strcmp( label, "MATERIAL.KELVIN" ) == 0 )
  {
   _NfiReadMaterialKELVIN( );
  }

  else if( strcmp( label, "MATERIAL.MAXWELL" ) == 0 )
  {
   _NfiReadMaterialMAXWELL( );
  }

  else if( strcmp( label, "MATERIAL.GENERIC" ) == 0 )
  {
   _NfiReadMaterialGENERIC( );
  }

  else if( strcmp( label, "MATERIAL.ISOTROPIC" ) == 0 )
  {
   _NfiReadMaterialISOTROPIC( );
  }

  else if( strcmp( label, "MATERIAL.ISOTROPIC.FAIL" ) == 0 )
  {
   _NfiReadMaterialISOTROPICFAIL( );
  }

  else if( strcmp( label, "MATERIAL.ORTHOTROPIC" ) == 0 )
  {
   _NfiReadMaterialORTHOTROPIC( );
  }

  else if( strcmp( label, "MATERIAL.HIPERBOLIC" ) == 0 )
  {
   _NfiReadMaterialHIPERBOLIC( );
  }

  else if( strcmp( label, "MATERIAL.MOHR.COULOMB" ) == 0 )
  {
   _NfiReadMaterialMOHRCOULOMB( );
  }

  else if( strcmp( label, "MATERIAL.MOHR.COULOMB.CUTOFF" ) == 0 )
  {
   _NfiReadMaterialMOHRCOULOMBCUTOFF( );
  }

  else if( strcmp( label, "MATERIAL.MOHR.COULOMB.NONASSOCIATED.CONSTANT" ) == 0 )
  {
   _NfiReadMaterialMOHRCOULOMBNAC( );
  }

  else if( strcmp( label, "MATERIAL.MOHR.COULOMB.NONASSOCIATED.VARIABLE" ) == 0 )
  {
   _NfiReadMaterialMOHRCOULOMBNAV( );
  }

  else if( strcmp( label, "ELEMENT" ) == 0 )
  {
   if ( !_NfiReadElement( ) ) return 0;
  }

  else if( strcmp( label, "ELEMENT.LINE2" ) == 0 )
  {
   _NfiReadElementLINE2();
  }

  else if( strcmp( label, "ELEMENT.T3" ) == 0 )
  {
   _NfiReadElementT3( );
  }
  
  else if( strcmp( label, "ELEMENT.DKT" ) == 0 )
  {
   _NfiReadElementDKT( );
  }

  else if( strcmp( label, "ELEMENT.Q4" ) == 0 )
  {
   _NfiReadElementQ4( );
  }

  else if( strcmp( label, "ELEMENT.BRICK8" ) == 0 )
  {
   _NfiReadElementBRICK8( );
  }

  else if( strcmp( label, "ELEMENT.TETR4" ) == 0 )
  {
   _NfiReadElementTETR4( );
  }

  else if( strcmp( label, "ELEMENT.INTERFACE" ) == 0 )
  {
   _NfiReadElementINTERFACE( );
  }

  else if( strcmp( label, "ELEMENT.INFINITE" ) == 0 )
  {
   _NfiReadElementINFINITE( );
  }

  else if( strcmp( label, "ELEMENT.PROFILE.T3" ) == 0 )
  {
   _NfiReadElementProfileT3( );
  }
  
  else if( strcmp( label, "ELEMENT.PROFILE.Q4" ) == 0 )
  {
   _NfiReadElementProfileQ4( );
  }
  
  else if( strcmp( label, "ELEMENT.PROFILE.BRICK8" ) == 0 )
  {
   _NfiReadElementProfileBRICK8( );
  }
  
  else if( strcmp( label, "ELEMENT.PROFILE.TETR4" ) == 0 )
  {
   _NfiReadElementProfileTETRA4( );
  }

  else if( strcmp( label, "LOAD" ) == 0 )
  {
   _NfiReadLoad( );
  }

  else if( strcmp( label, "LOAD.CASE" ) == 0 )
  {
   _NfiReadLoadCase( );
  }

  else if( strcmp( label, "LOAD.CASE.GRAVITY" ) == 0 )
  {
   _NfiReadLoadCaseGravity( );
  }

  else if( strcmp( label, "LOAD.CASE.NODAL.PRESSURE" ) == 0 )
  {
   _NfiReadLoadCaseNodalPressure( );
  }

  else if( strcmp( label, "LOAD.CASE.NODAL.FORCES" ) == 0 )
  {
   _NfiReadLoadCaseNodalForces( );
  }

  else if( strcmp( label, "LOAD.CASE.NODAL.VELOCITY" ) == 0 )
  {
   _NfiReadLoadCaseNodalVelocity( );
  }

  else if( strcmp( label, "LOAD.CASE.NODAL.SUPPORT" ) == 0 )
  {
   _NfiReadLoadCaseNodalSupport( );
  }

  else if( strcmp( label, "LOAD.CASE.LINE.FORCE.UNIFORM" ) == 0 )
  {
   _NfiReadLoadCaseLineForcesUni( );
  }

  else if( strcmp( label, "LOAD.CASE.LINE.FORCE.VARIABLE" ) == 0 )
  {
   _NfiReadLoadCaseLineForcesVar( );
  }

  else if( strcmp( label, "LOAD.CASE.DOMAIN.INITIAL.STRESS.UNIFORM" ) == 0 )
  {
   if( !_NfiReadLoadCaseDomainInitStressUni( ) ) return 0;
  }

  else if( strcmp( label, "LOAD.CASE.DOMAIN.TEMPERATURE.UNIFORM" ) == 0 )
  {
   _NfiReadLoadCaseDomainTempUni( );
  }

  else if( strcmp( label, "LOAD.CASE.NODAL.DISPLACEMENT" ) == 0 )
  {
   _NfiReadLoadCaseNodalDisplacements( );
  }

  else if( strcmp( label, "LOAD.CASE.ELEMENT.POTENCIAL" ) == 0 )
  {
   _NfiReadLoadCaseElementPotencial( );
  }

  /*Aqui*/
  else if( strcmp( label, "LOAD.CASE.AREA.UNIFORM" ) == 0 )
  {
   _NfiReadLoadCaseAreaUniform( );
  }
  
  else if( strcmp( label, "LOAD.CASE.AREA.PRESSURE" ) == 0 )
  {
   _NfiReadLoadCaseAreaPressure( );
  }
  /*fim*/

  else if( strcmp( label, "REZONE" ) == 0 )
  {
   _NfiReadRezone( );
  }

  else if( strcmp( label, "REZONE.CASE" ) == 0 )
  {
   _NfiReadRezoneCase( );
  }

  else if( strcmp( label, "REZONE.CASE.ELEMENT" ) == 0 )
  {
   _NfiReadRezoneCaseElement( );
  }

  else if( strcmp( label, "CONSTRAIN" ) == 0 )
  {
   if( !_NfiReadConstrain() ) return 0;
  }

  else if( strcmp( label, "CONSTRAIN.CURVE" ) == 0 )
  {
   _NfiReadConstrainCurve();
  }

  else if( strcmp( label, "CONSTRAIN.SHOT" ) == 0 )
  {
   _NfiReadConstrainShot();
  }

  else if( strcmp( label, "CONSTRAIN.SURFACE" ) == 0 )
  {
   _NfiReadConstrainSurface();
  }

  else if( strcmp( label, "NODE.CONSTRAIN" ) == 0 )
  {
   _NfiReadNodeConstrain();
  }

  else if( strcmp( label, "NODE.PILOT" ) == 0 )
  {
   _NfiReadNodePilot();
  }

  else if( strcmp( label, "REMARK" ) == 0 )
   continue;

  else if( strcmp( label, "END" ) == 0 )
   break;

  else
   continue;
 }

/* Check to see if a driver was created. If not create one.
 */
 
 if( (DrvObj == 0L) && (_TotalTime == 0) && (Config.algtype == 0) && (Config.num_load_step == 1))
 {
  DrvNew( STANDARD, &DrvObj );
 }
 else if( (DrvObj == 0L) && (Config.num_load_step == 1) && (Config.algtype == 1))
 {
  DrvNew( IMPLINEAR, &DrvObj );
 }
 else if( (DrvObj == 0L) && (Config.num_load_step == 1) && (Config.algtype == 2))
 {
  DrvNew( IMPNRM, &DrvObj );
 }
 else if( (DrvObj == 0L) && (Config.num_load_step == 1) && (Config.algtype == 3))
 {
  DrvNew( IMPBFGS, &DrvObj );
 }
 else if( (DrvObj == 0L) && (Config.num_load_step == 1) && (Config.algtype == 4))
 {
  DrvNew( HYBRID, &DrvObj );
 }
 else if( (DrvObj == 0L) && (_DampParameters == 1) && (Config.num_load_step == 1))
 {
  DrvNew( STANDARD_VE, &DrvObj );
 }
 else if( (DrvObj == 0L) && (_DampParameters == 2) && (Config.num_load_step == 1))
 {
  DrvNew( STANDARD_VE_FLAC, &DrvObj );
 }
 else if( (DrvObj == 0L) && (Config.num_load_step > 1) )
 {
  DrvNew( LOAD_STEP, &DrvObj );
 }

 if( NumConstrains != 0 ) {
  ConstrainBuild();
 }
 return 1;

} /* End of NfiInterpFile */


/*
%F
*/
int NfiWriteResults( void )
{
 int     i,j;
 long    ndlrpos, elmrpos;
 double *disp = 0L;

/* Get memory for the displacement vector
 */
 disp = (double *)calloc( NDof*NumNodes, sizeof(double) );

/* Check to see if have a rezone analysis or more than one load step
 */
 if( NumRezones > 0 )
 {
 /* Write results headers
  */
  fprintf( _NfiName, "%%RESULT\n1\n1\t'Rezone'\n\n" );
  fprintf( _NfiName, "%%RESULT.CASE\n1\t%d\n", NumRezones+1 );
  for( i = 0; i <= NumRezones; i++ )
   fprintf( _NfiName, "%d\t'Step_%d'\n", i+1, i+1 );
  fprintf( _NfiName, "\n" );
 }
 else if( NumLoadCase > 1 )
 {
 /* Write results headers
  */
  fprintf( _NfiName, "%%RESULT\n" );
  fprintf( _NfiName, "%d\n", NumLoadCase);
  for( i = 0; i < NumLoadCase; i++ )
   fprintf( _NfiName, "%d\t'LoadCase_%d'\n", i+1, i+1 );  
 }
 else if( Config.num_load_step > 1 )
 {
 /* Write results headers
  */
  fprintf( _NfiName, "%%RESULT\n" );
  fprintf( _NfiName, "%d\n", Config.num_load_step);
  for( i = 0; i < Config.num_load_step; i++ )
   fprintf( _NfiName, "%d\t'LoadStep_%d'\n", i+1, i+1 );  
 }
 else if( Config.num_step > 0 )
 {
 /* Write results headers
  */
  fprintf( _NfiName, "%%RESULT\n1\n1\t'Solution'\n\n" );
  fprintf( _NfiName, "%%RESULT.CASE\n1\t%d\n", Config.num_step+1 );
  for( i = 0; i < Config.num_step+1; i++ )
   fprintf( _NfiName, "%d\t'Step_%d'\n", i+1, i+1 );
  fprintf( _NfiName, "\n" );
 }
 else if( Config.num_time_step > 0 )
 {
 /* Write results headers
  */
  fprintf( _NfiName, "%%RESULT\n1\n1\t'Solution'\n\n" );
  fprintf( _NfiName, "%%RESULT.CASE\n1\t%d\n", Config.num_time_step );
  for( i = 0; i < Config.num_time_step; i++ )
   fprintf( _NfiName, "%d\t'Step_%d'\n", i+1, i+1 );
  fprintf( _NfiName, "\n" );
 }
 else
 {
 /* Write results headers
  */
  fprintf( _NfiName, "%%RESULT\n1\n1\t'Solution'\n\n" );
  fprintf( _NfiName, "%%RESULT.CASE\n1\t1\n1\t'Step_1'\n\n" );
 }

/* Check to see if have a rezone analysis or more than one load case
 */
 if( NumRezones > 0 )
 {
  for( i = 0; i <= NumRezones; i++ )
  {
   if( !IoFindResultTag( i, &ndlrpos, &elmrpos ) ) return 0;
   
   _NfiWriteResultStep( i+1, ndlrpos, elmrpos, disp );
  }
 }
 else if( NumLoadCase > 1 )
 {
  for( i = 0; i < NumLoadCase; i++ )
  {
   if ( !IoFindResultTag( i, &ndlrpos, &elmrpos ) ) return 0;
   
   fprintf( _NfiName, "%%RESULT.CASE\n" );
   fprintf( _NfiName, "%d\t%d\n", i+1, Config.num_step+1);   
   for( j = 0; j < Config.num_step+1; j++ ){
    fprintf( _NfiName, "%d\t'Step_%d'\n", j+1, j+1 );
    fprintf( _NfiName, "\n" );   
    _NfiWriteResultStep( j+1, ndlrpos, elmrpos, disp );
   }
  }
 }
 else if( Config.num_load_step > 1 )
 {
  for( i = 0; i < Config.num_load_step; i++ )
  {
   if ( !IoFindResultTag( i, &ndlrpos, &elmrpos ) ) return 0;
   
   fprintf( _NfiName, "%%RESULT.CASE\n" );
   fprintf( _NfiName, "%d\t%d\n", i+1, Config.num_step+1);   
   for( j = 0; j < Config.num_step+1; j++ ){
    fprintf( _NfiName, "%d\t'Step_%d'\n", j+1, j+1 );
    fprintf( _NfiName, "\n" );   
    _NfiWriteResultStep( j+1, ndlrpos, elmrpos, disp );
   }
  }
 }
 else if( Config.num_step > 0 )
 { 
 /* Write all steps
  */
  for( i = 0; i < Config.num_step+1; i++ )
  {
   if( !IoFindResultTag( i, &ndlrpos, &elmrpos ) ) return 0;
   
   _NfiWriteResultStep( i+1, ndlrpos, elmrpos, disp );
  }
 }
 else if( Config.num_time_step > 0 )
 { 
 /* Write all time steps
  */
  for( i = 0; i < Config.num_time_step; i++ )
  {
   if( !IoFindResultTag( i, &ndlrpos, &elmrpos ) ) return 0;
   
   fprintf( _NfiName, "%%RESULT.CASE.TIME\n%f\n\n", i * Config.timeStep );
   _NfiWriteResultStep( i+1, ndlrpos, elmrpos, disp );
  }
 }
 else
 {
  if( !IoFindResultTag( 0, &ndlrpos, &elmrpos ) ) return 0;
  
  _NfiWriteResultStep( 1, ndlrpos, elmrpos, disp );
 }
 IoCloseTempFile( );

/* Write END label
 */ 
 fprintf( _NfiName, "%%END\n" );
 return 1;

} /* End of NfiWriteResults */


/*
%F
*/
int NfiReadConfigFile( void )
{
 char label[80];

/* Interprete the config file
 */
 while( 1 )
 {
  if( _NfiNextLabel( label ) == 0 )
  {
   printf( "\n\n" );
   return 0;
  }

  else if( strcmp( label, "RELAX.TIME.FRACTION" ) == 0 )
  {
   _NfiReadTimeFraction( );
  }

  else if( strcmp( label, "RELAX.DAMPING.GLOBAL.PARAMETER" ) == 0 )
  {
   _NfiReadDampingGlobalParameter( );
  }

  else if( strcmp( label, "RELAX.TOLERANCE" ) == 0 )
  {
   _NfiReadTolerance( );
  }

  else if( strcmp( label, "RELAX.GEOMETRICALLY.NONLINEAR" ) == 0 )
  {
   _NfiReadGeometricallyNonLinear( );
  }

  else if( strcmp( label, "RELAX.MAXIMUM.STEPS" ) == 0 )
  {
   _NfiReadMaximumIteration( );
  }

  else if( strcmp( label, "END" ) == 0 )
   break;

  else
   continue;
 }
 return 1;

} /* End of NfiReadConfigFile */


/*
%F
*/
int NfiCheckParameters( void )
{
 if( (_TimeFraction == 0) || (_DampParameters == 0) || 
     (_Tolerance    == 0) || (_MaxIterations  == 0) ||
     (_NumStepTol   == 0))
  return( 0 );
 else
  return( 1 );

} /* End of NfiCheckParameters */


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

---