#!/usr/bin/env python

import os
import sys
import math

# Gmsh
# Check is API is present
try:
  import gmsh
except ImportError:
  print "Error Importing Gmsh module!\nMake sure the Gmsh API is installed and included in PYTHONPATH"
  sys.exit(-1)

# Defaults 
geometry_inputs = { \
'diameter' : 11.33*0.0254,\
'body_ld' : 11.62,\
'nose_cone_ld' : 4.0,\
'nozzle_radius' : 0.05156,\
'aft_ld' : 0.5,\
'half_angle': 60.0,\
'farfield_type': 'sphere'  # sphere
}

# Fin Inputs
# None
# lv3 - symmetric trapazoidal design
fin_inputs = { \
'build_fins': 'lv3',\
'tip_chord' : 0.2,\
'taper_angle' : (15.0/180.0*math.pi),\
'span' : 0.2,\
'thickness' : 0.25*0.0254,\
}

# Mesh Spacing Inputs
lc = {\
'nose_tip' : 0.01,\
'body' : 0.02,\
'aft' : 0.005,\
'fin' : 0.005,\
'farfield' : 0.1,\
}
circum_layers = 10

# Intermediate Body Parameters
radius = geometry_inputs['diameter']*0.5
nose_cone_length = geometry_inputs['diameter']*geometry_inputs['nose_cone_ld']
ogive_radius = (radius**2 + nose_cone_length**2)/(2*radius)
body_length = geometry_inputs['diameter']*geometry_inputs['body_ld']
body_aft_x = nose_cone_length + body_length 
aft_length = geometry_inputs['diameter']*geometry_inputs['aft_ld']
nozzle_x = body_aft_x + aft_length

# Intermediate Fin Paramters
fin_center_chord_x = body_aft_x - (fin_inputs['tip_chord']/2 + fin_inputs['span']*math.cos(fin_inputs['taper_angle']))
fin_outboard_distance = radius+fin_inputs['span']

print "\nStarting Gmsh API"
model = gmsh.model
#factory = model.geo
factory = model.occ
gmsh.initialize()

# Set optiopns  
gmsh.option.setNumber("General.Terminal",1) # 0 No output, 1 output 
gmsh.option.setNumber("Geometry.AutoCoherence",2) # 0 1 2 
gmsh.option.setNumber("Mesh.Algorithm",6) 

# Main Body
print 'Building Body'
# Points
body_p1 = factory.addPoint(0,0,0,lc['nose_tip'])  # Nose Cone Tip
body_p2 = factory.addPoint(nose_cone_length,0,radius,lc['body']) # Cone-Cylinder Interface
body_p3 = factory.addPoint(nose_cone_length,0,(radius-ogive_radius),lc['body']) # Ogive Radius Center
body_p4 = factory.addPoint(body_aft_x,0,radius,lc['aft']) # End of Body
body_p5 = factory.addPoint(nozzle_x,0,geometry_inputs['nozzle_radius'],lc['aft']) # End of Nozzle 
body_p6 = factory.addPoint(nozzle_x,0,0,lc['aft']) # Center of Nozzle 

# Lines
#body_l1 = factory.addCircleArc(body_p1,body_p3,body_p2,0,1,0); GEO
curve_dimtags = []
body_l1 = factory.addCircleArc(body_p1,body_p3,body_p2);
curve_dimtags.append((1,body_l1))
body_l2 = factory.addLine(body_p2,body_p4)
curve_dimtags.append((1,body_l2))
body_l3 = factory.addLine(body_p4,body_p5)
curve_dimtags.append((1,body_l3))
body_l4 = factory.addLine(body_p5,body_p6)
curve_dimtags.append((1,body_l4))

# Get Curves
factory.synchronize()

# Rotate Curves
factory.rotate(curve_dimtags,0,0,0,1,0,0,-math.pi*geometry_inputs['half_angle']/180.0)

# Generate Body Surfs by Revolving
#body_surfs_0 = factory.revolve(curve_dimtags,0,0,0,1,0,0,(2.0*math.pi*geometry_inputs['half_angle']/180.0),[circum_layers],[],True)
body_surfs_0 = factory.revolve(curve_dimtags,0,0,0,1,0,0,(2.0*math.pi*geometry_inputs['half_angle']/180.0),[],[],True)
factory.synchronize()
body_surfs_0_dimtags = model.getEntities(2)
body_surfs_1_dimtags = factory.copy(body_surfs_0_dimtags)
body_surfs_2_dimtags = factory.copy(body_surfs_0_dimtags)
factory.rotate(body_surfs_1_dimtags,0,0,0,1,0,0,-2.0*math.pi*geometry_inputs['half_angle']/180.0)
factory.rotate(body_surfs_2_dimtags,0,0,0,1,0,0,2.0*math.pi*geometry_inputs['half_angle']/180.0)
factory.synchronize()

body_dimtags = model.getEntities(2)
body_tags = []
for item in body_dimtags:
  body_tags.append(item[1])
num_body_tags = len(body_tags)
#print body_tags
#print num_body_tags
#model.addPhysicalGroup(2,body_tags,1)
#model.setPhysicalName(2,1,'body')
body_shell = factory.addSurfaceLoop(body_tags)
body_volume = factory.addVolume([body_shell])
#model.removeEntities(body_dimtags)
factory.synchronize()

gmsh.fltk.run() # Open GUI
gmsh.finalize()

# Farfield
if geometry_inputs['farfield_type'] == 'sphere':
  print 'Building Farfield'
  farfield_volume_tag = factory.addSphere(body_aft_x/2.0,0,0,5)
  factory.synchronize()
  # Find Surface tags to assign physical group
  farfield_surface_dimtags = model.getBoundary([(3,farfield_volume_tag)])
  farfield_tags = []
  for item in farfield_surface_dimtags:
    farfield_tags.append(item[1])
  farfield_points_dimtags = model.getEntities(0)
  factory.setMeshSize(farfield_points_dimtags,lc['farfield'])
else:
  print 'Farfield type needs to be specified'
  sys.exit()

# Cut Body from Fluid Volume
print 'Cutting Body from Fluid Volume'
factory.cut([(3,farfield_volume_tag)],[(3,body_volume)],-1,True,True) # Object, Tool
factory.synchronize()

#model.addPhysicalGroup(2,farfield_tags,10)
#model.setPhysicalName(2,10,'farfield')

#factory.removeAllDuplicates()
factory.synchronize()

#gmsh.fltk.run() # Open GUI
#gmsh.finalize()

# Fin
if fin_inputs['build_fins'] == 'lv3':
  print 'Building Fins'

  # Points
  fin_p1 = factory.addPoint(fin_center_chord_x-fin_inputs['tip_chord']/2,0,fin_inputs['span']+radius,lc['fin'])
  fin_p2 = factory.addPoint(fin_center_chord_x+fin_inputs['tip_chord']/2,0,fin_inputs['span']+radius,lc['fin'])
  fin_p3 = factory.addPoint(fin_center_chord_x+(fin_inputs['span']+radius)*math.cos(fin_inputs['taper_angle']),0,0,lc['fin'])
  fin_p4 = factory.addPoint(fin_center_chord_x-(fin_inputs['span']+radius)*math.cos(fin_inputs['taper_angle']),0,0,lc['fin'])

  # Lines
  fin_l1 = factory.addLine(fin_p1,fin_p2)
  fin_l2 = factory.addLine(fin_p2,fin_p3)
  fin_l3 = factory.addLine(fin_p3,fin_p4)
  fin_l4 = factory.addLine(fin_p4,fin_p1)

  fin_curve_dimtags = []
  fin_curve_dimtags.append((1,fin_l1))
  fin_curve_dimtags.append((1,fin_l2))
  fin_curve_dimtags.append((1,fin_l3))
  fin_curve_dimtags.append((1,fin_l4))

  # Create Lines
  starboard_curves = factory.copy(fin_curve_dimtags)
  starboard_tags = []
  for item in starboard_curves:
    starboard_tags.append(item[1])
  factory.dilate(starboard_curves,fin_center_chord_x,0,0,0.95,0.95,0.95)
  factory.translate(starboard_curves,0.0,fin_inputs['thickness']/2.0,0.0)
  port_curves = factory.copy(starboard_curves)
  port_tags = []
  for item in port_curves:
    port_tags.append(item[1])
  factory.translate(starboard_curves,0.0,-fin_inputs['thickness'],0.0)

  # Create Wires 
  fin_loop_center = factory.addCurveLoop((fin_l1,fin_l2,fin_l3,fin_l4))
  fin_loop_starboard = factory.addCurveLoop(starboard_tags)
  fin_loop_port = factory.addCurveLoop(port_tags)

  # Create fin volumes from wires
  fin_0_starboard_dimtag = factory.addThruSections([fin_loop_center,fin_loop_starboard])
  fin_0_port_dimtag = factory.addThruSections([fin_loop_center,fin_loop_port])
  factory.remove(port_curves,True) 
  factory.remove(starboard_curves,True) 

  fin_1_starboard_dimtag = factory.copy(fin_0_starboard_dimtag)
  fin_1_port_dimtag = factory.copy(fin_0_port_dimtag)
  fin_2_starboard_dimtag = factory.copy(fin_0_starboard_dimtag)
  fin_2_port_dimtag = factory.copy(fin_0_port_dimtag)
  factory.rotate(fin_1_starboard_dimtag,0,0,0,1,0,0,-2.0*math.pi*geometry_inputs['half_angle']/180.0)
  factory.rotate(fin_1_port_dimtag,0,0,0,1,0,0,-2.0*math.pi*geometry_inputs['half_angle']/180.0)
  factory.rotate(fin_2_starboard_dimtag,0,0,0,1,0,0,2.0*math.pi*geometry_inputs['half_angle']/180.0)
  factory.rotate(fin_2_port_dimtag,0,0,0,1,0,0,2.0*math.pi*geometry_inputs['half_angle']/180.0)

  print 'Cutting Fins from Fluid Volume'
  factory.cut([(3,farfield_volume_tag)],fin_0_starboard_dimtag,-1,True,True) # Object, Tool
  factory.cut([(3,farfield_volume_tag)],fin_0_port_dimtag,-1,True,True) # Object, Tool
  factory.cut([(3,farfield_volume_tag)],fin_1_starboard_dimtag,-1,True,True) # Object, Tool
  factory.cut([(3,farfield_volume_tag)],fin_1_port_dimtag,-1,True,True) # Object, Tool
  factory.cut([(3,farfield_volume_tag)],fin_2_starboard_dimtag,-1,True,True) # Object, Tool
  factory.cut([(3,farfield_volume_tag)],fin_2_port_dimtag,-1,True,True) # Object, Tool
  factory.synchronize()

  volume_dimtags = model.getBoundary([(3,farfield_volume_tag)],True,True,False)
  total_tags = len(volume_dimtags)

  # Assign Physical Surfaces
  farfield_tags = [num_body_tags+1]
  wall_tags = []
  for i in range(num_body_tags+2,num_body_tags+total_tags+1):
    wall_tags.append(i) 

  print farfield_tags
  print wall_tags

  model.addPhysicalGroup(2,wall_tags,1)
  model.addPhysicalGroup(2,farfield_tags,2)

  '''
  # Create physical group for fins
  print body_tags
  print farfield_tags
  surface_dimtags = model.getEntities(2)
  fin_surf_tags = [] 
  for item in surface_dimtags:
    tag = item[1]
    if tag in body_tags:
      pass
    elif tag in farfield_tags:
      pass
    else: 
      fin_surf_tags.append(tag) 
  model.addPhysicalGroup(2,fin_surf_tags,2)
  model.setPhysicalName(2,2,'fins')
  '''

  # Set spacing for intersection points
  points_dimtags = model.getEntities(0)
  #print points_dimtags
  #factory.setMeshSize(points_dimtags,lc['fin'])
  model.mesh.setSize(points_dimtags,0.1)
  factory.synchronize()
  #gmsh.fltk.run() # Open GUI
  #gmsh.finalize()

# Create Mesh
#model.mesh.generate(2)

# Add Physical Groups
# Set shock surface (2) to physical surface 100
#model.addPhysicalGroup(2,[2],100)

#print "  Writing Output"
gmsh.write("test.msh") # DEBUG ONLY 

gmsh.fltk.run() # Open GUI
gmsh.finalize()

print "Gmsh API complete"