#include <stdio.h>

/* this program assumes that the user has written the elements and nodes
from ansys using the nwrite command.  The node numbers are assumed to be
numbered consecutively.
*/

/*
*****************************************************************************
** SYMBOLIC CONSTANTS                                                      **
*****************************************************************************
*/

#define NUMNODES 8        /* Number of nodes for each element */
#define MAXNODE 20000     /* Storage allocated for this number of nodes */
#define MAXELEM 20000     /* Storage allocated for this number of elements */
/*
*****************************************************************************
** STRUCTURES                                                              **
*****************************************************************************
*/

struct _elem{
    int node[NUMNODES] ;        /* Nodes for each elemeent */
    int mat ;
    int layer;
    int add_flag;
} ;
static struct _elem *elem ;     /* Pointer to element data */

struct _node{
    float x ;                   /* X coordinate of node */
    float y ;                   /* Y coordinate of node */
} ;
static struct _node *node ;     /* Pointer to node data */

/*
*****************************************************************************
** GLOBAL VARIABLES                                                        **
*****************************************************************************
*/

int curr_elem = 0 ;      /* Current element number */
int curr_node = 0 ;      /* Number of nodes */ 
int min_node = 99999;   /* minimum node number */
int nummat ;             /* Number of materials */
int numel[MAXELEM] ;     /* Number of elements */
int numnp[MAXNODE] ;     /* Number of nodes */
int numedges = 0;             
int lay_numel, lay_numnp;
int numlayer;
int curr_layer;  
int num_nodes ;
int num_elems ;

int prob_type = 1;
int mat_type = 1;
double yng_mod =  1.0e+7;
double poisson =  0.3;
double thickness = 1.0;

double frac_toughness =  1.0;



FILE *input_elem ;       /* Element data file pointer */
FILE *input_node ;       /* Node data file pointer */
FILE *output_file ;      /* Output file pointer */

/*
*****************************************************************************
** FUNCTIONS                                                               **
*****************************************************************************
*/

void    GetStorage() ;
void    OpenFile() ;
void    ReadGeom() ;
void    WriteGeom() ;
void    CheckCCW() ;

/*
*****************************************************************************
** This program reads data from an ANSYS output and translates it for      **
** input to CRACKER.                                                       **
*****************************************************************************
*/

main()
{
    
     int ii;

/*
    printf(" Enter number of layers : ");
    scanf("%d",&numlayer);
*/
    numlayer = 1 ;
     
    GetStorage() ;

    for(ii=0; ii< numlayer;ii++){
	curr_layer = ii;
	lay_numel = lay_numnp =0;

	OpenFile() ;
	ReadGeom() ;
        numel[curr_layer] = lay_numel;
        numnp[curr_layer] = lay_numnp;
	
    }

    CheckCCW() ;	
    WriteGeom() ;

    free(node);
    free(elem);
}



/*
*****************************************************************************
** This makes sure all the elements are ordered CCW.                        *         **
*****************************************************************************
*/
void CheckCCW()
{
    float   area ;            /* Area, positive => CCW */
    float   xi, xj, xk ;      /* Coordinates */
    float   yi, yj, yk ;      /* Coordinates */

    int i, j, k, l, m, n ,o ,p;    /* Nodes */
    int ii ,jj, ll,add_nodes;                      /* Counter */
 /*                                                                               
 ** Make sure the new element is CCW.                                            
 */                                                                               
    add_nodes = 0;
    ii =0; 
     
    for( jj=0; jj < numlayer; jj++ ){
       
       	for(ll =0; ll < numel[jj]; ll++, ii++){

        	i = elem[ii].node[0] ;
        	j = elem[ii].node[1] ;
        	k = elem[ii].node[2] ;
        	l = elem[ii].node[3] ;
        	m = elem[ii].node[4] ;
        	n = elem[ii].node[5] ;
       		o = elem[ii].node[6] ;
        	p = elem[ii].node[7] ; 

        	xi = node[i-1+add_nodes].x ;
        	xj = node[j-1+add_nodes].x ;
        	xk = node[k-1+add_nodes].x ;
        	yi = node[i-1+add_nodes].y ;
        	yj = node[j-1+add_nodes].y ;
        	yk = node[k-1+add_nodes].y ;

       		area = ( xj * yk + xk * yi + xi * yj ) - ( yi * xj + yj * xk + yk * xi );

        
        
		if( area < 0.0 ) {
	    		if (o == 0  && p == 0){
	         		elem[ii].node[0] = i;
                 		elem[ii].node[1] = n;
                 		elem[ii].node[2] = k;
                 		elem[ii].node[3] = m;
                 		elem[ii].node[4] = j;
                 		elem[ii].node[5] = l;
            		}   
            		else {
	         		elem[ii].node[0] = i ;
		 		elem[ii].node[1] = p ;
		 		elem[ii].node[2] = l ;
		 		elem[ii].node[3] = o ;
		 		elem[ii].node[4] = k ;
		 		elem[ii].node[5] = n ;
		 		elem[ii].node[6] = j ;
		 		elem[ii].node[7] = m ;
	  		 }	 
       		 }
       		 else{
           		if (o == 0  && p == 0){ 
                 		elem[ii].node[0] = i;
                 		elem[ii].node[1] = l;
                 		elem[ii].node[2] = j;
                 		elem[ii].node[3] = m;
                 		elem[ii].node[4] = k;
                 		elem[ii].node[5] = n;
             		}
             		else{
		 		elem[ii].node[0] = i ;
				elem[ii].node[1] = m ;
		 		elem[ii].node[2] = j ;
		 		elem[ii].node[3] = n ;
		 		elem[ii].node[4] = k ;
		 		elem[ii].node[5] = o ;
		 		elem[ii].node[6] = l ;
		 		elem[ii].node[7] = p ;
             		}
      		} 
   	}
        add_nodes = numnp[jj];
   } /* for */
}
/*
*****************************************************************************
** This function gets memory for the data.                                 **
*****************************************************************************
*/
void GetStorage()
{
 /*
 ** Allocate storage
 */
    elem = (struct _elem *) calloc(MAXELEM, sizeof(struct _elem)) ;
    if( elem == NULL ) {
        printf("Unable to allocate memory for element storage.") ;
    }

    node = (struct _node *) calloc(MAXNODE, sizeof(struct _node)) ;
    if( node == NULL ) {
        printf("Unable to allocate memory for node storage.") ;
    }

}
/*
*****************************************************************************
** This function reads the data from the ANSYS files.                      **
*****************************************************************************
*/
void ReadGeom()
{
    float fdum ;    /* Dummy variable */

    int idum ;      /* Dummy variable */
    int ii ,jj;		/* Counter */
    int prev_node = -1;
    int reap_node = -1;
    int t6_flag = 0;
 /*
 ** Read in the element data
 */
    while( (fscanf( input_elem, "%d ", &idum )) != EOF ) {
        elem[curr_elem].node[0] = prev_node = idum; 
        if (idum <  min_node) 
	    min_node = idum;
        for( ii = 1,jj =1; ii < NUMNODES; ii++,jj++ ) {
            fscanf( input_elem, "%d", &idum ) ;
	    if (idum == 0){
                  elem[curr_elem].node[jj] = 0;
		  continue;
            }
            if (idum <  min_node) 
	        min_node = idum;
            if (idum == reap_node){
                jj--;
                continue;
            }
            else if (idum == prev_node){ 
                 reap_node = idum;
                 t6_flag =1;
                 jj--;
                 continue;
            }
            else { 
                  elem[curr_elem].node[jj] =  prev_node = idum ; 
            }
        }
        if (t6_flag){
               elem[curr_elem].node[6] = 0;
               elem[curr_elem].node[7] = 0;
        }
        t6_flag = 0;
        prev_node = reap_node = -1; 
        fscanf( input_elem, "%d ", &elem[curr_elem].mat ) ;
        fscanf( input_elem, "%d ", &idum ) ;
        fscanf( input_elem, "%d ", &idum ) ;
        fscanf( input_elem, "%d ", &idum ) ;
        fscanf( input_elem, "%d ", &idum ) ;
        elem[curr_elem].layer = curr_layer;
        elem[curr_elem].add_flag = 0; 
        curr_elem++ ;
	lay_numel++;
        if( curr_elem == MAXELEM ) {
            printf("Not enough storage for elements.  Increase MAXELEM.") ;
            exit(0) ;
        }
    }

    num_elems = curr_elem ;

 /*
 ** Read in the node data
 */
    while( (fscanf( input_node, "%d ", &idum )) != EOF ) {
        fscanf( input_node, "%f %f %f", 
                            &node[curr_node].x,
                            &node[curr_node].y,
                            &fdum ) ;
        curr_node++ ;
	lay_numnp++;
        if( curr_node == MAXNODE ) {
            printf("Not enough storage for nodes.  Increase MAXNODE.") ;
            exit(0) ;
        }
    }

    num_nodes = curr_node ;
}
/*
*****************************************************************************
** This function writes the data in a format for FRANC2D                   **
*****************************************************************************
*/
void WriteGeom()
{
	int idum = 0 ;  			/* Dummy variable */
	int type = 1 ;  			/* Flag for type of element */
	int ii ,jj,kk,ll,nn;
        int addnode;				/* Counter */
        float dummy;
	int elem_added;
 
	char title[80] ;			/* Title */
	char output_name[80] ;      /* Output file name */

 /*
 ** Store problem size
 */
      
	nummat = 0 ;
	for ( ii = 0; ii < curr_elem; ii++ ) {
	    if( elem[ii].mat > nummat ) {
			nummat = elem[ii].mat ;
		}
	}

	printf("\nEnter problem title: ") ;
    	scanf("%s", title ) ;

	printf("\nEnter name of the output file: ") ;
    	scanf("%s", output_name ) ;
	output_file = fopen(output_name, "w") ;
	if( output_file == NULL ) {
		printf("*** Problems opening output file ***") ;
		exit(0) ;
	}
 /*
 ** Print the data
 */
	fprintf(output_file, "%s\n", title) ;
        fprintf(output_file," %3d %3d %3d %3d\n",num_nodes,num_elems,nummat,prob_type);

	dummy = 0.0;
	for (ii =0; ii< nummat; ii++){
        fprintf(output_file, "%5d%10.2E%10.2E%10.2E%10.2E%10.2E%10.2E%10.2E%10.2E%10.2E%10.2E%10.2E%10.2E%10.2E%10.2E\n",
                            mat_type,
                            yng_mod,
                            poisson,
                            thickness,
                            frac_toughness,dummy,dummy,dummy,dummy,dummy,
                            dummy,dummy,dummy,dummy,dummy) ;
	

        }

	for ( ii = 0; ii < num_elems; ii++ ) {
            fprintf(output_file," %4d %4d %4d %4d %4d %4d %4d %4d %4d %4d\n",
            	ii+1, elem[ii].mat,
		elem[ii].node[0],
		elem[ii].node[1],
		elem[ii].node[2],
		elem[ii].node[3],
		elem[ii].node[4],
		elem[ii].node[5],
		elem[ii].node[6],
		elem[ii].node[7] );
	}

	for( ii = 0; ii < num_nodes; ii++ ) {
		fprintf(output_file, "%5d%22.6E%22.6E\n",
		                     ii+min_node, node[ii].x, node[ii].y ) ;
	}
}

/*
*****************************************************************************
** This function opens the input and output files.                         **
*****************************************************************************
*/
void OpenFile()

{
	char input_elem_name[80] ;     /* Element input file name */
	char input_node_name[80] ;     /* Node input file name */

	printf("\nEnter name of ANSYS file with element data (d=>file14.dat): ") ;
    scanf("%s", input_elem_name ) ;
	if( input_elem_name[0] == 'd' ) {
		strcpy(input_elem_name,"file14.dat") ;
	}
	input_elem = fopen(input_elem_name, "r") ;
	if( input_elem == NULL ) {
		printf("*** Problems opening element data file ***") ;
		exit(0) ;
	}

	printf("\nEnter name of ANSYS file with node data (d=>file15.dat): ") ;
    scanf("%s", input_node_name ) ;
	if( input_node_name[0] == 'd') {
		strcpy(input_node_name,"file15.dat") ;
	}
	input_node = fopen(input_node_name, "r") ;
	if( input_node == NULL ) {
		printf("*** Problems opening node data file ***") ;
		exit(0) ;
	}
}