/* Planar Spiral Inductor Synthesis -  main routine - V1.4.1 - Bill Tompkins */
/* This program is based on a paper written by H.M. Greenhouse */

#include <string.h>
#include <stdio.h>
#include <stdlib.h>
#include <math.h>

/*********************************************/
/* Third party 'include' files               */
/*********************************************/

#include "ac.h"		    /* Program's defines and structures	         */
#include "external.h"	    /* Program's external variable definitions   */  
 
/*********************************************/
/* NOTE: ac.h must always preceed external.h */
/*********************************************/
 

main(int argc, char *argv[])
{
  int stat, i, j, x, y, orientation;
  int segments, full_turns, units_flag;
  int pos_mutual_terms, neg_mutual_terms;
  float gmd, coil_l, m_pos_total, m_neg_total, turns;
  float width, space, thickness, track_center, total;
  float inner_lead_width, inner_lead_length, inner_lead_thickness, inner_lead_l;
  float outer_lead_width, outer_lead_length, outer_lead_thickness, outer_lead_l;
  float x_length, y_length, length;
  float q, m1, m2, m2sub;
  char *str_upr(char *);

  j                    = 1;
  coil_l               = 0.0;
  x_length             = 0.0;
  y_length             = 0.0;
  width                = 0.0;
  thickness            = .0004;  /* microns */        
  inner_lead_l         = 0.0;
  outer_lead_l         = 0.0;
  inner_lead_length    = 0.0;
  outer_lead_length    = 0.0;
  inner_lead_width     = 0.0;
  outer_lead_width     = 0.0;
  inner_lead_thickness = 0.0;
  outer_lead_thickness = 0.0;
  m_pos_total          = 0.0;
  m_neg_total          = 0.0;
  units_flag           = 0;     /* 0 = microns, 1 = inches*/
  orientation          = 0;	/* 0 = ID, 1 = OD         */


  for(i=1; i<argc; i++){
    if(str_find(str_upr(argv[i]),"-X") == YES)
      x_length    = atof(argv[i]+2)/10000;					/* microns */
	
    if(str_find(str_upr(argv[i]),"-Y") == YES)
      y_length    = atof(argv[i]+2)/10000;					/* microns */
	  
    if(str_find(str_upr(argv[i]),"-W") == YES)
      width       = atof(argv[i]+2)/10000;					/* microns */
	 	
    if(str_find(str_upr(argv[i]),"-S") == YES)
      space       = atof(argv[i]+2)/10000;					/* microns */
	
    if(str_find(str_upr(argv[i]),"-T") == YES)
      thickness   = atof(argv[i]+2)/10000;					
		
    if(str_find(str_upr(argv[i]),"-N") == YES)
      turns       = atof(argv[i]+2);					
	
    if(str_find(str_upr(argv[i]),"-IL") == YES)
      inner_lead_length  = atof(argv[i]+3)/10000;					
		
    if(str_find(str_upr(argv[i]),"-OL") == YES)
      outer_lead_length  = atof(argv[i]+3)/10000;					
		
    if(str_find(str_upr(argv[i]),"-IW") == YES)
      inner_lead_width   = atof(argv[i]+3)/10000;					
		
    if(str_find(str_upr(argv[i]),"-OW") == YES)
      outer_lead_width   = atof(argv[i]+3)/10000;					
		
    if(str_find(str_upr(argv[i]),"-IT") == YES)
      inner_lead_thickness = atof(argv[i]+3)/10000;					
		
    if(str_find(str_upr(argv[i]),"-OT") == YES)
      outer_lead_thickness = atof(argv[i]+3)/10000;					
	
    if(str_find(str_upr(argv[i]),"-ID") == YES)
      orientation = 0;					

    if(str_find(str_upr(argv[i]),"-OD") == YES)
      orientation = 1;					
	
    if(str_find(str_upr(argv[i]),"-CM") == YES)
      units_flag = 0;					

    if(str_find(str_upr(argv[i]),"-IN") == YES)
      units_flag = 1;					
    }

  x_length = (x_length == 0.0) ? y_length : x_length;
  y_length = (y_length == 0.0) ? x_length : y_length;
  inner_lead_width = (inner_lead_width == 0.0) ? width : inner_lead_width;
  outer_lead_width = (outer_lead_width == 0.0) ? width : outer_lead_width;
  inner_lead_thickness = (inner_lead_thickness == 0.0) ? thickness : inner_lead_thickness;
  outer_lead_thickness = (outer_lead_thickness == 0.0) ? thickness : outer_lead_thickness;

  full_turns = (int)floor(turns);
  segments = (int)(turns/0.25);

/* ADD IN u and T!!!! */

/* term calculation */
  pos_mutual_terms = 4*(full_turns*(full_turns-1)) + 2*full_turns*(segments-(4*full_turns));
  neg_mutual_terms = 4*pow(full_turns,2) + 2*full_turns*(segments-(4*full_turns)) + 
     (segments - (4*full_turns) - 2)*(segments - (4*full_turns) - 1)*((segments - (4*full_turns))/3);

/* allocate memory */
  if(allocate(2*segments + 10) == ERR){
    printf("\nAllocation Error - Can't allocate memory!\n");
		}

/* find segment lengths * inside to outside */
  if(orientation == 0){
    va.tmp_ptr[1] = x_length + width - (width + space);
    va.tmp_ptr[2] = y_length + width;

    for(y=2;y<=segments;y++){					
      va.tmp_ptr[2*y-1] = va.tmp_ptr[1] + (y-1)*(width + space);
      va.tmp_ptr[2*y]   = va.tmp_ptr[2] + (y-1)*(width + space);
	  	}
      va.tmp_ptr[segments] = va.tmp_ptr[segments] - width - space;

      for(y=1;y<=segments;y++){
        va.length_ptr[y] = va.tmp_ptr[segments - y+1];
	}
      }

/* find segment lengths * outside to inside */
  else{
    va.length_ptr[1] = x_length - width;
    va.length_ptr[2] = y_length - width;
    for(y=2;y<=segments;y++){					
      va.length_ptr[2*y-1] = va.length_ptr[1] - (y - 2)*(width + space);
      va.length_ptr[2*y]   = va.length_ptr[2] - (y - 1)*(width + space);
      }				
   }	 

/* self inductance - inner lead*/
  if(inner_lead_length != 0.0){
    inner_lead_l  = 2.0*inner_lead_length*
    (log(2.0*inner_lead_length/(inner_lead_width + inner_lead_thickness)) + 
    0.50049 + ((inner_lead_width + inner_lead_thickness)/(3.0*inner_lead_length)));
			}

/* self inductance - outer lead*/
  if(outer_lead_length != 0.0){
    outer_lead_l = 2.0*outer_lead_length*
    (log(2.0*outer_lead_length/(outer_lead_width + outer_lead_thickness)) + 
    0.50049 + ((outer_lead_width + outer_lead_thickness)/(3.0*outer_lead_length)));
    }

/* self inductance - spiral*/
  coil_l = 0.0;
  for(y=1;y<=segments;y++){			
    coil_l += 2.0*va.length_ptr[y]*
    (log(2.0*va.length_ptr[y]/(width + thickness)) + 
    0.50049 + ((width + thickness)/(3.0*va.length_ptr[y])));
    }


/* positive mutual inductance */
  for(x=1; x<=full_turns; x++){
    for(y=1; y<=segments-4 ;y++){
      if(y + (4*x) <= segments){
	track_center = x*space + x*width;
	gmd = exp(log(track_center) - ( (1/12 *pow((track_center/width), 2)) +
  	  (1/60 *pow((track_center/width), 4)) +
	  (1/168*pow((track_center/width), 6)) +
	  (1/360*pow((track_center/width), 8)) +
	  (1/660*pow((track_center/width),10)) ));

     	  length = va.length_ptr[y];
			
	  q = log((length/gmd) + 
	    pow((1 + ((length*length)/(gmd*gmd))),0.5)) - 
	    pow((1 + ((gmd*gmd)/(length*length))),0.5) + 
	    (gmd/length);
   	 		
	  m1 = 2*length*q;

          length = va.length_ptr[y + (4*x)];
			
	  q = log((length/gmd) + 
	    pow((1 + ((length*length)/(gmd*gmd))),0.5)) - 
	    pow((1 + ((gmd*gmd)/(length*length))),0.5) + 
	    (gmd/length);
   			
  	  m2 = 2*length*q;
					
	  length = va.length_ptr[y] - va.length_ptr[y + (4*x)];
	
	  q = log((length/gmd) + 
	    pow((1 + ((length*length)/(gmd*gmd))),0.5)) - 
	    pow((1 + ((gmd*gmd)/(length*length))),0.5) + 
	    (gmd/length);
				
  	  m2sub = 2*length*q;
  					  
  	  m_pos_total += (m1+m2) - m2sub;
          }
	}
      }

/* negative mutual inductance */
  for(x=1; x<=full_turns; x++){
    for(y=1; y<=segments - 2 ;y++){
      if(y + (4*x) - 2 <= segments){

        if((float)y/2.0 - floor((float)y/2.0) != 0.0)	 /* odd/even toggle */


	track_center = (va.length_ptr[1]) -	
          ( (int) floor(((2*y)+(4*x)-2)/4) - 1)*space -
          ( (int) floor(((2*y)+(4*x)-2)/4) - 1)*width;
				else
        track_center = (va.length_ptr[2]) -
	  ( (int) floor(((2*y)+(4*x)-2)/4) - 1)*space -
  	  ( (int) floor(((2*y)+(4*x)-2)/4) - 1)*width;
	
  	gmd = exp(log(track_center) - ( (1/12 *pow((track_center/width), 2)) +
	  (1/60 *pow((track_center/width), 4)) +
	  (1/168*pow((track_center/width), 6)) +
	  (1/360*pow((track_center/width), 8)) +
	  (1/660*pow((track_center/width),10)) ));

	length = va.length_ptr[y];
        
	q = log((length/gmd) + 
	  pow((1 + ((length*length)/(gmd*gmd))),0.5)) - 
	  pow((1 + ((gmd*gmd)/(length*length))),0.5) + 
	  (gmd/length);
   			
        m1 = 2*length*q;

        length = va.length_ptr[y+(4*x)-2];
    
        q = log((length/gmd) + 
	  pow((1 + ((length*length)/(gmd*gmd))),0.5)) - 
	  pow((1 + ((gmd*gmd)/(length*length))),0.5) + 
	  (gmd/length);
   			
	m2 = 2*length*q;

	length = va.length_ptr[y] - va.length_ptr[y+(4*x)-2];	

        if(length != 0){
	  q = log((length/gmd) + 
	  pow((1 + ((length*length)/(gmd*gmd))),0.5)) - 
	  pow((1 + ((gmd*gmd)/(length*length))),0.5) + 
	  (gmd/length);
   			
	  m2sub = 2*length*q;
	  }
	
        else
	  m2sub = 0;
							  
   	m_neg_total += (m1+m2) - m2sub;
	}
      }
    }

    total = inner_lead_l + outer_lead_l + (coil_l + m_pos_total - m_neg_total);
 
    printf("\n");
    printf("Inner Lead Inductance (nH)      = %   7.4f\n",inner_lead_l);
    printf("Outer Lead Inductance (nH)      = %   7.4f\n",outer_lead_l);
    printf("Coil Self Inductance (nH)       = %   7.4f\n",coil_l);
    printf("Positive Mutual Inductance (nH) = %   7.4f\n",m_pos_total);
    printf("Negative Mutual Inductance (nH) = %   7.4f\n",m_neg_total);
    printf("Total Inductance (nH)           = %   7.4f\n",total);

    exitprog();
}