API tools faq
paste
Advertisement
Guest User

Untitled

a guest
May 28th, 2015
260
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 10.61 KB | None | 0 0
raw download clone embed print report
  1. import numpy as np
  2. from scipy.optimize import curve_fit
  3. from vast import models
  4. import math
  5. import scipy
  6. import data_analysis as DA
  7. import operator
  8. import random
  9.  
  10. class Weather:
  11. wind_force = None
  12. wind_direction = None
  13. wave_height = None
  14. wave_direction = None
  15. swell_height = None
  16. swell_direction = None
  17. current_speed=None
  18. current_direction=None
  19.  
  20. def print_me(self):
  21. print "Wind force: %s,\tWind direction: %s,\tWave height: %s,\tWave direction: %s,\tSwell height: %s,\tSwell direction: %s" % (str(self.wind_force), str(self.wind_direction), str(self.wave_height), str(self.wave_direction), str(self.swell_height), str(self.swell_direction))
  22.  
  23. def return_me(self):
  24. string = "Wind force: %s,\tWind direction: %s,\tWave height: %s,\tWave direction: %s,\tSwell height: %s,\tSwell direction: %s" % (str(self.wind_force), str(self.wind_direction), str(self.wave_height), str(self.wave_direction), str(self.swell_height), str(self.swell_direction))
  25.  
  26. return string
  27.  
  28. class Speed_Schedule: # We make a Speed_Schedule object for every 6 hours of the path
  29. weather = None # and initialise it with calculated values
  30. eco_rpm = None
  31. eco_speed = None
  32. actual_speed = None
  33. actual_rpm = None
  34. quarters_to_go = None
  35. distance_covered = None
  36. foc = None
  37. load_disp = None
  38. params_aw_speed = None
  39.  
  40. def __init__(self, weather):
  41. self.weather = None # and initialise it with calculated values
  42. self.eco_rpm = None
  43. self.eco_speed = None
  44. self.actual_speed = None
  45. self.actual_rpm = None
  46. self.quarters_to_go = None
  47. self.distance_covered = None
  48. self.foc = None
  49. self.load_disp = None
  50. self.params_aw_speed = None
  51.  
  52. self.weather = weather
  53.  
  54. def print_me(self):
  55. print "Eco rpm: %s,\tEco speed: %s,\tActual speed: %s,\tDist covered: %s,\tFO Cons: %s" \
  56. % (str(self.eco_rpm), str(self.eco_speed), str(self.actual_speed), str(self.distance_covered), str(self.foc))
  57.  
  58. def return_me(self):
  59. string = "Eco rpm: %s,\tEco speed: %s,\tActual speed: %s,\tDist covered: %s,\tFO Cons: %s" \
  60. % (str(self.eco_rpm), str(self.eco_speed), str(self.actual_speed), str(self.distance_covered), str(self.foc))
  61.  
  62. return string
  63.  
  64. # def find_eco_rpm(self, params_foc, params_speed):
  65.  
  66. # self.params_foc = params_foc
  67. # self.params_speed = params_speed
  68.  
  69. # x = [[], [], []] # [[rpm], [load_disp], [steaming_hours]]
  70. # rpm = range(60, 120)
  71. # for i in xrange(0, 60):
  72. # x[0].append( rpm[i] )
  73. # x[1].append( self.load_disp )
  74. # x[2].append( 6 )
  75. # x = np.array(x)
  76.  
  77. # a1, b1, c1, d1 = params_foc
  78. # a2, b2, c2 = params_speed
  79.  
  80. # # print x
  81.  
  82. # foc = DA.fit_rpm_vs_fo_cons(x, a1, b1, c1, d1)
  83. # speed = DA.fit_rpm_vs_speed(x, a2, b2, c2)
  84.  
  85. # optimum_ratio = 10000000.0
  86. # for i in xrange(0, 60):
  87. # if float(foc[i]) / float(speed[i]) < optimum_ratio:
  88. # optimum_ratio = float(foc[i]) / float(speed[i])
  89. # eco_rpm = rpm[i]
  90.  
  91. # return float(eco_rpm)
  92.  
  93. def find_eco_speed(self, params_fw_speed):
  94. x = [self.eco_rpm, self.load_disp]
  95. x = np.array(x)
  96. a1, b1, c1 = params_fw_speed
  97.  
  98. fw_speed = DA.fit_rpm_vs_speed(x, a1, b1, c1) # fair weather eco_speed
  99. #print "DEBUG>>>>> fw_speed: " + str(fw_speed)
  100. return self.find_actual_speed(fw_speed) # actual weather eco_speed
  101.  
  102. def find_actual_rpm(self, params_speed_rpm):
  103. return math.pow( (self.actual_speed / self.eco_speed), 1/params_speed_rpm[1] ) \
  104. * self.eco_rpm
  105.  
  106. def find_actual_speed(self, fw_speed):
  107. params_aw_speed = self.params_aw_speed # actual weather speed params
  108. gs_theta, gw_theta, sine_theta_r = DA.theta_funcs( self.weather.wind_direction )
  109. wind_speed = DA.wind_force_speed( self.weather.wind_force )
  110.  
  111. x = [fw_speed, gw_theta, self.weather.wave_height, wind_speed, sine_theta_r,
  112. gs_theta, self.weather.swell_height]
  113.  
  114. #print x
  115.  
  116. a = params_aw_speed
  117. aw_speed = DA.fit_speed_vs_weather(x, a)
  118. return aw_speed[0]
  119.  
  120. class Voyage_Plan:
  121. distance = None
  122. total_safe_quarters = None
  123. weather_expected = [] # size equal to number of quarters
  124. speed_schedule = [] # size equal to number of quarters
  125. load_disp = None
  126. params_foc = None
  127. params_speed_rpm = None
  128. net_avg_rpm = 0.0
  129. total_foc = 0.0
  130. net_avg_speed = 0.0
  131. total_voyage_hours = 0
  132.  
  133. def print_me(self):
  134. print "Distance: %s" % str(self.distance)
  135. print "Total quarters: %s" % str(self.total_safe_quarters)
  136. print "Load Displacement: %s" % str(self.load_disp)
  137. print "Total FOC: %s" % str(total_foc)
  138. print "Net average rpm: %s" % str(net_avg_rpm)
  139. print "Net average speed: %s" % str(net_avg_speed)
  140.  
  141. for i in xrange(0, self.total_safe_quarters):
  142. print "\nWEATHER for quarter %d:" % (i+1)
  143. self.weather_expected[i].print_me()
  144. print "SCHEDULE for quarter %d:" % (i+1)
  145. self.speed_schedule[i].print_me()
  146.  
  147. def return_me(self):
  148. string = "Distance: %s" % str(self.distance)
  149. string += "Total quarters: %s" % str(self.total_safe_quarters)
  150. string += "Load Displacement: %s" % str(self.load_disp)
  151.  
  152. for i in xrange(0, self.total_safe_quarters):
  153. string += "\nWEATHER for quarter %d:" % (i+1)
  154. string += self.weather_expected[i].return_me()
  155. string += "SCHEDULE for quarter %d:" % (i+1)
  156. string += self.speed_schedule[i].return_me()
  157.  
  158. return string
  159.  
  160. def __init__(self, distance, total_safe_quarters, weather_expected, load_disp):
  161. self.distance = None
  162. self.total_safe_quarters = None
  163. self.weather_expected = [] # size equal to number of quarters
  164. self.speed_schedule = [] # size equal to number of quarters
  165. self.load_disp = None
  166. self.params_foc = None
  167. self.params_speed_rpm = None
  168. self.net_avg_rpm = 0.0
  169. self.total_foc = 0.0
  170. self.net_avg_speed = 0.0
  171. self.total_voyage_hours = 0
  172.  
  173. self.params_foc = DA.rpm_vs_fo_cons()
  174. self.params_speed_rpm = DA.rpm_vs_speed()
  175. self.distance = distance
  176. self.total_safe_quarters = total_safe_quarters
  177. self.weather_expected = weather_expected
  178. self.load_disp = load_disp
  179. self.initialize_speed_schedule()
  180.  
  181. def initialize_speed_schedule(self):
  182. parmas_fw_speed = DA.rpm_vs_speed()
  183. params_foc = DA.rpm_vs_fo_cons()
  184. params_speed = DA.rpm_vs_speed()
  185. eco_rpm = self.find_eco_rpm()
  186. params_aw_speed = DA.speed_vs_weather()
  187.  
  188. for i in xrange(0, self.total_safe_quarters + 100):
  189. S = Speed_Schedule(self.weather_expected[i])
  190. S.quarters_to_go = self.total_safe_quarters
  191. S.load_disp = self.load_disp
  192. S.eco_rpm = eco_rpm
  193. # print "eco rpm"
  194. S.params_aw_speed = params_aw_speed
  195. S.eco_speed = S.find_eco_speed(parmas_fw_speed)
  196. # S.eco_speed = 12
  197. # print "eco.. speed"
  198. # S.actual_speed = S.find_actual_speed(S.eco_speed)
  199. self.speed_schedule.append(S)
  200.  
  201. def find_eco_rpm(self):
  202.  
  203. x = [[], [], []] # [[rpm], [load_disp], [steaming_hours]]
  204. rpm = range(60, 120)
  205. for i in xrange(0, 60):
  206. x[0].append( rpm[i] )
  207. x[1].append( self.load_disp )
  208. x[2].append( 6 )
  209. x = np.array(x)
  210.  
  211. a1, b1, c1, d1 = self.params_foc
  212. a2, b2, c2 = self.params_speed_rpm
  213.  
  214. # print x
  215.  
  216. foc = DA.fit_rpm_vs_fo_cons(x, a1, b1, c1, d1)
  217. speed = DA.fit_rpm_vs_speed(x, a2, b2, c2)
  218.  
  219. optimum_ratio = 10000000.0
  220. for i in xrange(0, 60):
  221. if float(foc[i]) / float(speed[i]) < optimum_ratio:
  222. optimum_ratio = float(foc[i]) / float(speed[i])
  223. eco_rpm = rpm[i]
  224.  
  225. return float(eco_rpm)
  226.  
  227. def plan_voyage_economic(self):
  228. eco_dist = 0
  229.  
  230. flag, eco_dist = self.can_go_eco()
  231.  
  232. if flag:
  233. dist_covered = 0.0
  234. for i in xrange(0, self.total_safe_quarters):
  235. if dist_covered > self.distance:
  236. break
  237. ss = self.speed_schedule[i]
  238. ss.actual_speed = ss.eco_speed
  239. ss.distance_covered = ss.actual_speed * 6.0 * 1.852
  240. dist_covered += ss.distance_covered
  241. ss.actual_rpm = ss.eco_rpm
  242. a, b, c, d = self.params_foc
  243. x = np.array( [ss.actual_rpm, self.load_disp, 6] )
  244. ss.foc = DA.fit_rpm_vs_fo_cons(x, a, b, c, d)
  245. self.total_foc += ss.foc
  246. else:
  247. # Plan new voyage
  248. ratio_denominator = 0.0
  249. ratios = []
  250. distance_split = []
  251. distance_left = self.distance - eco_dist
  252.  
  253. for weather in self.weather_expected:
  254. if weather.wind_force < 8:
  255. if weather.wind_force == 0:
  256. weather.wind_force = 0.1
  257. ratio_denominator += 1.0 / weather.wind_force
  258.  
  259. for i in xrange(0, self.total_safe_quarters):
  260. weather = self.weather_expected[i]
  261. if weather.wind_force < 8:
  262. ratios.append( (1.0 / weather.wind_force) / ratio_denominator)
  263. else:
  264. ratios.append(0.0)
  265.  
  266. #print "i= %d, %d, %d" % (i-1, len(distance_split), len(ratios))
  267. distance_split.append( distance_left * ratios[i-1] )
  268. ss = self.speed_schedule[i-1]
  269. ss.actual_speed = ss.eco_speed + (distance_split[i-1] / 6.0/ 1.852)
  270. ss.distance_covered = ss.actual_speed * 6.0 * 1.852
  271. ss.actual_rpm = ss.find_actual_rpm(self.params_speed_rpm)
  272. a, b, c, d = self.params_foc
  273. x = np.array( [ss.actual_rpm, self.load_disp, 6] )
  274. ss.foc = DA.fit_rpm_vs_fo_cons(x, a, b, c, d)
  275. self.total_foc += ss.foc
  276.  
  277. self.calc_net_avg()
  278.  
  279. def plan_voyage_at_speed(self, speed):
  280. dist_covered = 0
  281. quarter = 0
  282.  
  283. while dist_covered < self.distance:
  284. ss = self.speed_schedule[quarter]
  285. ss.actual_speed = ss.find_actual_speed( speed )
  286. ss.actual_rpm = ss.find_actual_rpm( self.params_speed_rpm )
  287.  
  288. dist_covered += ss.actual_speed * 6.0 * 1.852
  289. ss.distance_covered = ss.actual_speed * 6.0 * 1.852
  290. a, b, c, d = self.params_foc
  291. x = np.array( [ss.actual_rpm, self.load_disp, 6] )
  292. ss.foc = DA.fit_rpm_vs_fo_cons(x, a, b, c, d)
  293. self.total_foc += ss.foc
  294. quarter += 1
  295.  
  296. self.calc_net_avg()
  297.  
  298. def calc_net_avg(self):
  299. ctr = 0
  300. for ss in self.speed_schedule:
  301. if (ss.actual_speed):
  302. ctr += 1
  303. self.net_avg_speed += ss.actual_speed
  304. self.net_avg_rpm += ss.actual_rpm
  305. self.total_voyage_hours += 6
  306.  
  307. self.net_avg_rpm /= ctr
  308. self.net_avg_speed /= ctr
  309.  
  310. def can_go_eco(self):
  311. dist = 0
  312. for i in xrange(0, self.total_safe_quarters):
  313. #self.speed_schedule[i].print_me()
  314. dist += self.speed_schedule[i].eco_speed * 6.0 * 1.852
  315.  
  316. if dist > self.distance:
  317. return True, dist
  318. else:
  319. return False, dist
  320.  
  321.  
  322. def do_it():
  323. distance1 = 7776
  324. total_safe_quarters1 = 60
  325. we = []
  326.  
  327. for i in xrange(0, 60):
  328. we1 = Weather()
  329. we1.wind_force = random.randint(1, 5)
  330. we1.wind_direction = random.randint(0, 360)
  331. we1.wave_direction = we1.wind_direction
  332. wind_speed = DA.wind_force_speed(we1.wind_force)
  333. we1.wave_height = wind_speed * 0.06
  334. we1.swell_height = 2
  335. we1.swell_direction = 1
  336. we.append(we1)
  337.  
  338. load_disp = 90000
  339. v = Voyage_Plan(distance1, total_safe_quarters1, we, load_disp)
  340. v.plan_voyage_economic()
  341. #v.print_me()
  342. string = v.return_me()
  343. f = open( 'results', 'w')
  344. f.write(string)
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!