Context Navigation

source: src/mlx/acft.py@ 1165:3f5bc889907b

Visit:

python3

Last change on this file since 1165:3f5bc889907b was 1165:3f5bc889907b, checked in by István Váradi <ivaradi@…>, 2 weeks ago
The altitude above which the speed is reported in Mach can be specified for each aircraft type (re #389).
File size: 51.2 KB

Rev	Line
[298]	1
[919]	2	from . import const
	3	from . import gates
	4	from . import checks
	5	from . import fs
	6	from .i18n import xstr
	7	from . import util
[298]	8
	9	import sys
	10	import time
	11	import traceback
	12
	13	from collections import deque
	14
	15	#---------------------------------------------------------------------------------------
	16
[297]	17	## @package mlx.acft
	18	#
	19	# The simulator-independent aircraft classes.
	20	#
	21	# This module contains the aircraft classes that contain some general data
	22	# about each aircraft type in the MAVA Fleet. The base class, \ref Aircraft
	23	# also implements some parts of the logging and traces some data. The classes
	24	# are also responsible for creating the \ref mlx.checks "checkers". Most of
	25	# them are created by the \ref Aircraft class' constructor, but there can be
	26	# type-specific differences. For example the lights are different for different
	27	# types, so there is a \ref Aircraft._appendLightsLoggers "function" which can
	28	# be reimplemented in child classes, if needed. This class maintains also the
	29	# \ref SmoothedValue "smoothed values" of the IAS and the VS and set these
	30	# values in the \ref mlx.fs.AircraftState "aircraft state" when it is received
	31	# from the simulator.
[4]	32
	33	#---------------------------------------------------------------------------------------
	34
[512]	35	# Derate type: no derate possible
	36	DERATE_NONE = 0
	37
	38	# Derate type: Boeing, i.e. a percentage value.
	39	# For logging, the percentage value is expected as a string (i.e. whatever the
	40	# pilot enters into the text field).
	41	DERATE_BOEING = 1
	42
	43	# Derate type: EPR, i.e. an EPR value.
	44	# For logging, the EPR value is expected as a string (i.e. whatever the pilot
	45	# enters into the text field).
	46	DERATE_EPR = 2
	47
	48	# Derate type: Tupolev, i.e. nominal or takeoff
	49	# For logging, one of the DERATE_TUPOLEV_xxx values are expected.
	50	DERATE_TUPOLEV = 3
	51
	52	# Tupolev derate value: nominal
	53	DERATE_TUPOLEV_NOMINAL = 1
	54
	55	# Tupolev derate value: takeoff
	56	DERATE_TUPOLEV_TAKEOFF = 2
	57
	58	# Derate type: BAe-146, i.e. enabled or not
	59	# For logging, a boolean is expected.
	60	DERATE_B462 = 4
	61
	62	#---------------------------------------------------------------------------------------
	63
[197]	64	class SmoothedValue(object):
	65	"""A smoothed value."""
	66	def __init__(self):
	67	"""Construct the value."""
	68	self._deque = deque()
	69	self._sum = 0
	70
	71	def add(self, length, value):
	72	"""Add the given value and smooth with the given length."""
	73	dequeLength = len(self._deque)
	74	while dequeLength>=length:
	75	self._sum -= self._deque.popleft()
	76	dequeLength -= 1
	77
	78	self._sum += value
	79	self._deque.append(value)
	80
	81	def get(self):
	82	"""Get the average."""
	83	return self._sum / len(self._deque)
[331]	84
[4]	85	#---------------------------------------------------------------------------------------
	86
[709]	87	class SimBriefData(object):
	88	"""Data to be used when creating SimBrief briefings."""
[1087]	89	def __init__(self, climbProfiles, cruiseProfiles, descentProfiles,
	90	cruiseParameters = {}):
	91	"""Construct the SimBrief data with the given profiles.
	92
	93	cruiseParameters is a dictionary keyed by the cruise profile index. It
	94	contains a tuple of:
	95	- a boolean indicating if the parameter is mandatory,
	96	- the name of the parameter for the SimBrief API
	97	"""
[709]	98	self.climbProfiles = climbProfiles
	99	self.cruiseProfiles = cruiseProfiles
	100	self.descentProfiles = descentProfiles
[1087]	101	self.cruiseParameters = cruiseParameters
[709]	102
	103	#---------------------------------------------------------------------------------------
	104
[4]	105	class Aircraft(object):
	106	"""Base class for aircraft."""
[8]	107	@staticmethod
[798]	108	def create(flight, bookedFlight):
[8]	109	"""Create an aircraft instance for the type in the given flight."""
[798]	110	acft = _classes[flight.aircraftType](flight)
	111	acft.setBookedFlight(bookedFlight)
	112	return acft
[8]	113
[592]	114	def __init__(self, flight, minLandingFuel = None,
	115	recommendedLandingFuel = None):
[4]	116	"""Construct the aircraft for the given type."""
[8]	117	self._flight = flight
[591]	118	self._minLandingFuel = minLandingFuel
[592]	119	self._recommendedLandingFuel = recommendedLandingFuel
[369]	120
	121	self._name = None
	122	self._modelName = None
	123
[4]	124	self._aircraftState = None
[331]	125
[9]	126	self._maxVS = -10000.0
	127	self._minVS = 10000.0
[4]	128
[101]	129	self._v1r2LineIndex = None
[384]	130	self._derateLineID = None
[391]	131	self._takeoffAntiIceLineID = None
[96]	132	self._vrefLineIndex = None
[391]	133	self._landingAntiIceLineID = None
[96]	134
[117]	135	self.humanWeight = 82.0
	136
[598]	137	self.initialClimbSpeedAltitude = 1500
	138	self.reverseMinSpeed = 50
[360]	139
[644]	140	self.hasStrobeLight = True
	141
[611]	142	self.maxTakeOffPitch = 15.0
	143	self.maxTouchDownPitch = 15.0
[624]	144	self.brakeCoolTime = 10.0
[611]	145
[709]	146	self.simBriefData = None
	147
[8]	148	self._checkers = []
	149
[197]	150	config = flight.config
[11]	151	# Loggers
	152
[8]	153	self._checkers.append(checks.StageChecker())
[9]	154	self._checkers.append(checks.TakeOffLogger())
[8]	155
	156	self._checkers.append(checks.AltimeterLogger())
[321]	157
[366]	158	self._ilsLogger = checks.ILSLogger()
	159	self._checkers.append(self._ilsLogger)
[321]	160	self._nav1Logger = checks.NAV1Logger()
	161	self._checkers.append(self._nav1Logger)
	162	self._nav2Logger = checks.NAV2Logger()
	163	self._checkers.append(self._nav2Logger)
	164
	165	self._adf1Logger = checks.ADF1Logger()
	166	self._checkers.append(self._adf1Logger)
	167	self._adf2Logger = checks.ADF2Logger()
	168	self._checkers.append(self._adf2Logger)
[331]	169
[8]	170	self._checkers.append(checks.SquawkLogger())
	171
[211]	172	self._appendLightsLoggers()
[8]	173
	174	self._checkers.append(checks.FlapsLogger())
	175
	176	self._checkers.append(checks.GearsLogger())
[601]	177	self._checkers.append(checks.InitialClimbSpeedLogger())
[9]	178	self._checkers.append(checks.CruiseSpeedLogger())
[10]	179	self._checkers.append(checks.SpoilerLogger())
[338]	180	self._checkers.append(checks.APLogger())
[9]	181
[197]	182	if config.isMessageTypeFS(const.MESSAGETYPE_VISIBILITY):
[134]	183	self._checkers.append(checks.VisibilityChecker())
	184
[139]	185	# FIXME: we should have a central data model object, and not collect
	186	# the data from the GUI. However, some pieces of data (e.g. V-speeds,
	187	# etc. that is entered into the GUI) should be a part of the GUI and
	188	# queried from it, so the model should have a reference to the GUI as
	189	# well and access such data via the GUI!
[215]	190	if config.onlineACARS and flight.loggedIn and not flight.entranceExam:
[139]	191	self._checkers.append(checks.ACARSSender(flight._gui))
	192
[11]	193	# Fault checkers
[211]	194
	195	self._appendLightsCheckers()
[11]	196
[335]	197	self._checkers.append(checks.TransponderChecker())
	198
[11]	199	self._checkers.append(checks.BankChecker())
	200
	201	self._checkers.append(checks.FlapsRetractChecker())
	202	self._checkers.append(checks.FlapsSpeedLimitChecker())
	203
	204	self._checkers.append(checks.GearsDownChecker())
	205	self._checkers.append(checks.GearSpeedLimitChecker())
	206
	207	self._checkers.append(checks.GLoadChecker())
	208
	209	self._checkers.append(checks.MLWChecker())
	210	self._checkers.append(checks.MTOWChecker())
	211	self._checkers.append(checks.MZFWChecker())
	212	self._checkers.append(checks.PayloadChecker())
	213
[539]	214	self._checkers.append(checks.SpeedChecker())
[11]	215	self._checkers.append(checks.VSChecker())
[197]	216
[447]	217	timeout = 30.0 + config.realIASSmoothingLength - 1
[622]	218	self._checkers.append(checks.OverspeedChecker(faultTimeout = timeout))
[331]	219
[11]	220	self._checkers.append(checks.StallChecker())
	221
	222	self._checkers.append(checks.PitotChecker())
[331]	223
[598]	224	self._checkers.append(checks.ReverserLogger())
[11]	225	self._checkers.append(checks.ReverserChecker())
	226
[273]	227	if flight.aircraftType is not None and config.enableApproachCallouts:
	228	approachCallouts = flight.config.getApproachCallouts(flight.aircraftType)
	229	if approachCallouts:
	230	self._checkers.append(checks.ApproachCalloutsPlayer(approachCallouts))
	231
[197]	232	self._smoothedIAS = SmoothedValue()
	233	self._smoothedVS = SmoothedValue()
	234
[4]	235	@property
	236	def type(self):
	237	"""Get the type of the aircraft."""
[8]	238	return self._flight.aircraftType
	239
	240	@property
	241	def flight(self):
	242	"""Get the flight the aircraft belongs to."""
	243	return self._flight
[4]	244
[8]	245	@property
[592]	246	def minLandingFuel(self):
	247	"""Get the minimum acceptable amount of the landing fuel."""
	248	return self._minLandingFuel
	249
	250	@property
	251	def recommendedLandingFuel(self):
	252	"""Get the recommended amount of the landing fuel."""
	253	return self._recommendedLandingFuel
	254
	255	@property
[8]	256	def logger(self):
	257	"""Get the logger to use for the aircraft."""
	258	return self._flight.logger
	259
[139]	260	@property
	261	def state(self):
	262	"""Get the current aircraft state."""
	263	return self._aircraftState
[241]	264
	265	@property
	266	def speedInKnots(self):
	267	"""Indicate if the speed is in knots.
	268
	269	This default implementation returns True."""
	270	return True
[304]	271
	272	@property
[635]	273	def aglInFeet(self):
	274	"""Indicate if AGL altitudes are to be logged in feet.
	275
	276	This default implementation returns True."""
	277	return True
	278
	279	@property
[304]	280	def timestamp(self):
	281	"""Get the timestamp of the current state."""
	282	return None if self._aircraftState is None \
	283	else self._aircraftState.timestamp
[331]	284
[384]	285	@property
[512]	286	def derateType(self):
	287	"""Get the derate type for this aircraft.
	288
	289	This default implementation returns DERATE_NONE."""
	290	return DERATE_NONE
[384]	291
[1165]	292	@property
	293	def machSpeedAbove(self):
	294	"""Get the altitude above which the cruise speed should be reported
	295	in Machs."""
	296	return 24500
	297
[798]	298	def setBookedFlight(self, bookedFlight):
	299	"""Update the aircraft based on the booked flight data (e.g. tail number).
	300
	301	This default implementation does nothing."""
	302
[512]	303	def getDerateLine(self, value):
	304	"""Get the log line for the given derate value.
	305
	306	It uses the the derate type and produces the standard message for
	307	each. This children need not override it, although they can."""
	308	dt = self.derateType
[384]	309
[512]	310	if dt==DERATE_BOEING:
	311	return "Derate calculated by the pilot: %s %%" % \
	312	("-" if value is None else value,)
	313	elif dt==DERATE_EPR:
	314	return "EPR calculated by the pilot: %s" % \
	315	("-" if value is None else value,)
	316	elif dt==DERATE_TUPOLEV:
	317	return "Thrust setting calculated by the pilot: %s" % \
	318	("-" if value is None else
	319	"nominal" if value==DERATE_TUPOLEV_NOMINAL else "takeoff",)
	320	elif dt==DERATE_B462:
	321	return "Derate setting: %s" % \
	322	("-" if value is None else "enabled" if value else "disabled",)
	323	elif dt!=DERATE_NONE:
[919]	324	print("mlx.acft.getDerateLine: invalid derate type: " + dt)
[384]	325
	326	return None
	327
[11]	328	def getFlapsSpeedLimit(self, flaps):
	329	"""Get the speed limit for the given flaps setting."""
	330	return self.flapSpeedLimits[flaps] if flaps in self.flapSpeedLimits \
	331	else None
	332
[8]	333	def modelChanged(self, timestamp, aircraftName, modelName):
[4]	334	"""Called when the simulator's aircraft changes."""
[369]	335	self._name = aircraftName
	336	self._modelName = modelName
	337	if self._flight.stage is not None:
	338	self._logNameAndModel(timestamp)
[4]	339
	340	def handleState(self, aircraftState):
[197]	341	"""Called when the state of the aircraft changes.
	342
	343	This is the function that the simulator calls directly with the new
	344	state."""
[274]	345	try:
	346	config = self._flight.config
[197]	347
[274]	348	self._smoothedIAS.add(config.realIASSmoothingLength, aircraftState.ias)
	349	aircraftState.smoothedIAS = self._smoothedIAS.get()
	350
	351	self._smoothedVS.add(config.realVSSmoothingLength, aircraftState.vs)
	352	aircraftState.smoothedVS = self._smoothedVS.get()
[197]	353
[274]	354	for checker in self._checkers:
	355	try:
	356	checker.check(self._flight, self, self._flight.logger,
	357	self._aircraftState, aircraftState)
	358	except:
[919]	359	print("Checker", checker, "failed", file=sys.stderr)
[274]	360	traceback.print_exc()
[7]	361
[274]	362	self._flight.handleState(self._aircraftState, aircraftState)
[89]	363
[274]	364	self._maxVS = max(self._maxVS, aircraftState.vs)
	365	self._minVS = min(self._minVS, aircraftState.vs)
	366	except:
[919]	367	print("Failed to handle the state", file=sys.stderr)
[274]	368	traceback.print_exc()
	369	finally:
	370	self._aircraftState = aircraftState
[331]	371
[8]	372	def setStage(self, aircraftState, newStage):
	373	"""Set the given stage as the new one and do whatever should be
	374	done."""
[369]	375	if newStage==const.STAGE_BOARDING:
	376	self._logNameAndModel(aircraftState.timestamp)
	377
[624]	378	oldStage = self._flight.stage
	379
[9]	380	if self._flight.setStage(aircraftState.timestamp, newStage):
	381	if newStage==const.STAGE_PUSHANDTAXI:
	382	self.logger.message(aircraftState.timestamp, "Block time start")
[274]	383	self._flight.logFuel(aircraftState)
[331]	384	self.logger.message(aircraftState.timestamp,
[313]	385	"ZFW: %.2f kg" % (aircraftState.zfw))
[134]	386	flight = self._flight
	387	if flight.v1 is None or flight.vr is None or flight.v2 is None:
	388	fs.sendMessage(const.MESSAGETYPE_HELP,
	389	"Don't forget to set the takeoff V-speeds!",
	390	5)
[9]	391	elif newStage==const.STAGE_TAKEOFF:
[624]	392	if oldStage == const.STAGE_RTO and self._flight.hasRTO:
	393	rtoState = self._flight.rtoState
	394	if (aircraftState.timestamp - rtoState.timestamp) < \
	395	(self.brakeCoolTime * 60.0):
	396	self.logger.fault("brakeCoolTime",
	397	aircraftState.timestamp,
	398	"Did not cool the brakes for at least %.f minutes after the RTO" % (self.brakeCoolTime,),
	399	15.0)
[241]	400	self.logger.message(aircraftState.timestamp,
	401	"Flight time start")
[331]	402	self.logger.message(aircraftState.timestamp,
[9]	403	"Takeoff weight: %.0f kg, MTOW: %.0f kg" % \
	404	(aircraftState.grossWeight, self.mtow))
[409]	405	self._logQNH(aircraftState)
[9]	406	self.logger.message(aircraftState.timestamp,
[333]	407	"Wind %03.0f/%.0f" % \
[331]	408	(aircraftState.windDirection,
[9]	409	aircraftState.windSpeed))
[321]	410	self._logRadios(aircraftState)
[345]	411	self._logV1R2(aircraftState)
[384]	412	self._logDerate(aircraftState)
[391]	413	self._logTakeoffAntiIce(aircraftState)
[321]	414	elif newStage==const.STAGE_DESCENT or newStage==const.STAGE_LANDING:
	415	self._logRadios(aircraftState)
[409]	416	if newStage==const.STAGE_LANDING:
	417	self._logQNH(aircraftState)
[634]	418	elif newStage==const.STAGE_GOAROUND:
[919]	419	from .logger import Logger
[634]	420	self._flight.handleFault("goaround",
	421	aircraftState.timestamp,
	422	"Go-around detected, please, explain!",
	423	Logger.NO_SCORE)
[9]	424	elif newStage==const.STAGE_TAXIAFTERLAND:
[184]	425	flight = self._flight
	426	bookedFlight = flight.bookedFlight
	427	config = flight.config
[136]	428	if config.onlineGateSystem and \
[215]	429	flight.loggedIn and \
[184]	430	not flight.entranceExam and \
[136]	431	bookedFlight.arrivalICAO=="LHBP" and \
	432	config.isMessageTypeFS(const.MESSAGETYPE_GATE_SYSTEM):
[134]	433	self._flight.getFleet(callback = self._fleetRetrieved,
	434	force = True)
[9]	435	self.logger.message(aircraftState.timestamp, "Flight time end")
[274]	436	self._flight.logFuel(aircraftState)
[591]	437	if self._minLandingFuel is not None and \
	438	aircraftState.totalFuel<self._minLandingFuel:
[597]	439	self._flight.handleFault(self.__class__,
	440	aircraftState.timestamp,
	441	"The amount of the landing fuel is less than the minimum for this type: %ukgs (possible NO GO!)" %
	442	(self._minLandingFuel,), 0)
[9]	443	self.logger.message(aircraftState.timestamp,
	444	"Landing weight: %.0f kg, MLW: %.0f" % \
	445	(aircraftState.grossWeight, self.mlw))
	446	self.logger.message(aircraftState.timestamp,
	447	"Vertical speed range: %.0f..%.0f feet/min" % \
[12]	448	(self._minVS, self._maxVS))
[359]	449	# elif newStage==const.STAGE_PARKING:
	450	# self.logger.message(aircraftState.timestamp, "Block time end")
[89]	451	elif newStage==const.STAGE_END:
	452	flightLength = self._flight.flightTimeEnd - self._flight.flightTimeStart
[359]	453	self.logger.message(aircraftState.timestamp, "Block time end")
[89]	454	self.logger.message(aircraftState.timestamp,
	455	"Flight time: " +
	456	util.getTimeIntervalString(flightLength))
	457	self.logger.message(aircraftState.timestamp,
	458	"Flown distance: %.2f NM" % \
[331]	459	(self._flight.flownDistance,))
[89]	460	blockLength = self._flight.blockTimeEnd - self._flight.blockTimeStart
	461	self.logger.message(aircraftState.timestamp,
	462	"Block time: " +
	463	util.getTimeIntervalString(blockLength))
[8]	464
[9]	465	def prepareFlare(self):
	466	"""Called when it is detected that we will soon flare.
[8]	467
	468	On the first call, it should start monitoring some parameters more
	469	closely to determine flare time."""
[9]	470	self.flight.simulator.startFlare()
	471
[331]	472	def flareStarted(self, windSpeed, windDirection, visibility,
[9]	473	flareStart, flareStartFS):
	474	"""Called when the flare has started."""
	475	self.logger.message(self._aircraftState.timestamp, "The flare has begun")
	476	self.logger.message(self._aircraftState.timestamp,
[333]	477	"Wind %03.0f/%.0f" % \
[9]	478	(windDirection, windSpeed))
	479	self.logger.message(self._aircraftState.timestamp,
	480	"Visibility: %.0f metres" % (visibility,))
[409]	481	self._logQNH(self._aircraftState)
[101]	482	self._logVRef()
[391]	483	self._logLandingAntiIce(self._aircraftState)
[9]	484	self.flight.flareStarted(flareStart, flareStartFS)
[134]	485	fs.sendMessage(const.MESSAGETYPE_INFORMATION, "Flare-time", 3)
[331]	486
[9]	487	def flareFinished(self, flareEnd, flareEndFS, tdRate, tdRateCalculatedByFS,
[1137]	488	ias, pitch, bank, heading, gLoad):
[9]	489	"""Called when the flare has finished."""
	490	(flareTimeFromFS, flareTime) = self.flight.flareFinished(flareEnd,
[170]	491	flareEndFS,
	492	tdRate)
[9]	493	self.logger.message(self._aircraftState.timestamp,
[153]	494	"Flaretime: %.3f (from %s)" % \
[331]	495	(flareTime,
[9]	496	"the simulator" if flareTimeFromFS else "real time",))
	497	self.logger.message(self._aircraftState.timestamp,
	498	"Touchdown rate: %.0f feet/min" % (tdRate,))
	499	self.logger.message(self._aircraftState.timestamp,
	500	"Touchdown rate was calculated by the %s" % \
	501	("simulator" if tdRateCalculatedByFS else "logger",))
[1137]	502	self.logger.message(self._aircraftState.timestamp,
	503	"Touchdown G-load: %.2f" % (gLoad,))
[241]	504	flight = self._flight
[9]	505	self.logger.message(self._aircraftState.timestamp,
[241]	506	"Touchdown speed: %.0f %s" % \
	507	(flight.speedFromKnots(ias),
	508	flight.getEnglishSpeedUnit()))
[9]	509	self.logger.message(self._aircraftState.timestamp,
	510	"Touchdown pitch: %.1f degrees" % (pitch,))
	511	self.logger.message(self._aircraftState.timestamp,
	512	"Touchdown bank: %.1f degrees" % (bank,))
	513	self.logger.message(self._aircraftState.timestamp,
	514	"Touchdown heading: %03.0f degrees" % (heading,))
[331]	515	self.logger.message(self._aircraftState.timestamp,
[340]	516	"CG: %.1f%%" % \
[271]	517	(self._aircraftState.cog*100.0,))
[8]	518
[611]	519	if abs(pitch)>self.maxTouchDownPitch:
	520	self._flight.handleNoGo("TDPitch", self._aircraftState.timestamp,
	521	"Touchdown pitch higher than aircraft maximum (%.2f)" % \
	522	(self.maxTouchDownPitch,),
	523	"TD TAILSTRIKE NO GO")
	524
[8]	525	def cancelFlare(self):
	526	"""Cancel flare, if it has started."""
[9]	527	self.flight.simulator.cancelFlare()
[8]	528
	529	def checkFlightEnd(self, aircraftState):
	530	"""Check if the end of the flight has arrived.
	531
	532	This default implementation checks the N1 values, but for
	533	piston-powered aircraft you need to check the RPMs."""
[1043]	534	if aircraftState.n1 is not None:
	535	for n1 in aircraftState.n1:
	536	if n1 is not None and n1>=0.5: return False
[8]	537	return True
	538
[101]	539	def updateV1R2(self):
	540	"""Update the V1, Vr and V2 values from the flight, if the these values
	541	have already been logged."""
	542	if self._v1r2LineIndex is not None:
	543	self._logV1R2()
	544
[384]	545	def updateDerate(self):
	546	"""Update the derate value from the flight, if the these values
	547	have already been logged."""
	548	if self._derateLineID is not None:
	549	self._logDerate()
	550
[391]	551	def updateTakeoffAntiIce(self):
	552	"""Update the take-off anti-ice setting."""
	553	if self._takeoffAntiIceLineID is not None:
	554	self._logTakeoffAntiIce()
	555
[211]	556	def _appendLightsLoggers(self):
	557	"""Append the loggers needed for the lights.
	558
	559	This default implementation adds the loggers for the anti-collision
	560	lights, the landing lights, the strobe lights and the NAV lights."""
	561	self._checkers.append(checks.AnticollisionLightsLogger())
	562	self._checkers.append(checks.LandingLightsLogger())
	563	self._checkers.append(checks.StrobeLightsLogger())
	564	self._checkers.append(checks.NavLightsLogger())
	565
	566	def _appendLightsCheckers(self):
	567	"""Append the checkers needed for the lights.
	568
	569	This default implementation adds the checkers for the anti-collision
	570	lights, the landing lights, the strobe lights and the NAV lights."""
	571	self._checkers.append(checks.AntiCollisionLightsChecker())
	572	self._checkers.append(checks.LandingLightsChecker())
	573	self._checkers.append(checks.NavLightsChecker())
	574	self._checkers.append(checks.StrobeLightsChecker())
	575
[241]	576	def _speedToLog(self, speed):
	577	"""Convert the given speed (being either None or expressed in the
	578	flight's speed unit into a string."""
	579	if speed is None:
	580	return "-"
	581	else:
	582	return str(speed) + " " + self._flight.getEnglishSpeedUnit()
	583
[345]	584	def _logV1R2(self, state = None):
[101]	585	"""Log the V1, Vr and V2 value either newly, or by updating the
	586	corresponding line."""
[526]	587	message = "Calc. TO speeds: V1: %s, VR: %s, V2: %s" % \
[241]	588	(self._speedToLog(self._flight.v1),
	589	self._speedToLog(self._flight.vr),
	590	self._speedToLog(self._flight.v2))
[101]	591
	592	if self._v1r2LineIndex is None:
[345]	593	if state is None:
	594	state = self._aircraftState
[101]	595	self._v1r2LineIndex = \
[345]	596	self.logger.message(state.timestamp, message)
[101]	597	else:
	598	self.logger.updateLine(self._v1r2LineIndex, message)
	599
[384]	600	def _logDerate(self, state = None):
	601	"""Log the derate values either newly or by updating the corresponding
	602	line."""
[512]	603	dt = self.derateType
	604	if dt==DERATE_NONE:
[384]	605	return
	606
[512]	607	message = self.getDerateLine(self._flight.derate)
	608	if message is not None:
	609	if self._derateLineID is None:
	610	if state is None:
	611	state = self._aircraftState
	612	self._derateLineID = \
	613	self.logger.message(state.timestamp, message)
	614	else:
	615	self.logger.updateLine(self._derateLineID, message)
[384]	616
[391]	617	def _logTakeoffAntiIce(self, state = None):
	618	"""Log the take-off anti-ice setting either newly or by updating the
	619	corresponding line."""
	620	antiIceOn = self._flight.takeoffAntiIceOn
	621	if state is not None:
	622	antiIceOn = antiIceOn or state.antiIceOn is True
	623	self._flight.takeoffAntiIceOn = antiIceOn
	624
	625	message = "Anti-ice was turned %s" % \
	626	("ON" if antiIceOn else "OFF")
	627
	628	if self._takeoffAntiIceLineID is None:
	629	if state is None:
	630	state = self._aircraftState
	631	self._takeoffAntiIceLineID = \
	632	self.logger.message(state.timestamp, message)
	633	else:
	634	self.logger.updateLine(self._takeoffAntiIceLineID, message)
	635
[96]	636	def updateVRef(self):
	637	"""Update the Vref value from the flight, if the Vref value has already
	638	been logged."""
	639	if self._vrefLineIndex is not None:
	640	self._logVRef()
	641
	642	def _logVRef(self):
	643	"""Log the Vref value either newly, or by updating the corresponding
	644	line."""
	645	message = "VRef speed calculated by the pilot: %s" % \
[241]	646	(self._speedToLog(self._flight.vref),)
[96]	647	if self._vrefLineIndex is None:
	648	self._vrefLineIndex = \
	649	self.logger.message(self._aircraftState.timestamp, message)
	650	else:
	651	self.logger.updateLine(self._vrefLineIndex, message)
	652
[391]	653	def updateLandingAntiIce(self):
	654	"""Update the landing anti-ice setting."""
	655	if self._landingAntiIceLineID is not None:
	656	self._logLandingAntiIce()
	657
	658	def _logLandingAntiIce(self, state = None):
	659	"""Log the landing anti-ice setting either newly or by updating the
	660	corresponding line."""
	661	antiIceOn = self._flight.landingAntiIceOn
	662	if state is not None:
	663	antiIceOn = antiIceOn or state.antiIceOn is True
	664	self._flight.landingAntiIceOn = antiIceOn
	665
	666	message = "Anti-ice was turned %s" % \
	667	("ON" if antiIceOn else "OFF")
	668
	669	if self._landingAntiIceLineID is None:
	670	if state is None:
	671	state = self._aircraftState
	672	self._landingAntiIceLineID = \
	673	self.logger.message(state.timestamp, message)
	674	else:
	675	self.logger.updateLine(self._landingAntiIceLineID, message)
	676
[134]	677	def _fleetRetrieved(self, fleet):
	678	"""Callback for the fleet retrieval result."""
	679	if fleet is not None:
	680	gateList = ""
[1154]	681	for gate in fleet.iterAvailableLHBPGates(self.flight.bookedFlight.tailNumber):
	682	if gateList: gateList += ", "
	683	gateList += gate.number
[134]	684	fs.sendMessage(const.MESSAGETYPE_GATE_SYSTEM,
	685	"Free gates: " + gateList, 20)
[331]	686
[134]	687
[321]	688	def _logRadios(self, aircraftState):
	689	"""Log the radios from the given aircraft state."""
	690	flight = self._flight
	691	logger = flight.logger
	692
[366]	693	self._ilsLogger.forceLog(flight, logger, aircraftState)
[321]	694	self._nav1Logger.forceLog(flight, logger, aircraftState)
	695	self._nav2Logger.forceLog(flight, logger, aircraftState)
[329]	696	self._adf1Logger.forceLog(flight, logger, aircraftState)
	697	self._adf2Logger.forceLog(flight, logger, aircraftState)
[321]	698
[409]	699	def _logQNH(self, aircraftState):
	700	"""Log the current QNH along with the altimeter setting."""
	701	self.logger.message(aircraftState.timestamp,
	702	"QNH: %.2f hPa, altimeter: %.2f hPa" % \
	703	(aircraftState.qnh, aircraftState.altimeter))
	704
[369]	705	def _logNameAndModel(self, timestamp):
	706	"""Log the aircraft's name and model with taking the timestamp from the
	707	given state."""
	708	self._flight.logger.message(timestamp,
	709	"Aircraft: name='%s', model='%s'" % \
	710	(self._name, self._modelName))
	711
[4]	712	#---------------------------------------------------------------------------------------
[7]	713
	714	class Boeing737(Aircraft):
	715	"""Base class for the various aircraft in the Boeing 737 family.
	716
	717	The aircraft type-specific values in the aircraft state have the following
	718	structure:
[140]	719	- fuel: left, centre, right
[7]	720	- n1: left, right
[331]	721	- reverser: left, right"""
[592]	722	def __init__(self, flight, minLandingFuel = 2500,
	723	recommendedLandingFuel = 3500):
	724	super(Boeing737, self).__init__(flight,
	725	minLandingFuel = minLandingFuel,
	726	recommendedLandingFuel =
	727	recommendedLandingFuel)
[95]	728
[9]	729	self.gearSpeedLimit = 270
	730	self.flapSpeedLimits = { 1 : 260,
	731	2 : 260,
	732	5 : 250,
	733	10 : 210,
	734	15 : 200,
	735	25 : 190,
	736	30 : 175,
	737	40 : 162 }
[7]	738
[384]	739	@property
[512]	740	def derateType(self):
	741	"""Get the derate type for this type."""
	742	return DERATE_BOEING
[384]	743
[7]	744	#---------------------------------------------------------------------------------------
	745
	746	class B736(Boeing737):
	747	"""Boeing 737-600 aircraft."""
[861]	748	dow = 38307
	749
[8]	750	def __init__(self, flight):
	751	super(B736, self).__init__(flight)
[9]	752	self.mtow = 58328
	753	self.mlw = 54657
	754	self.mzfw = 51482
[611]	755	self.maxTakeOffPitch = 16.2
	756	self.maxTouchDownPitch = 14.7
[709]	757	self.simBriefData = SimBriefData(["250/280/78"],
	758	["CI", "M75", "M78", "M79", "M80", "LRC"],
[1087]	759	["78/280/250"],
	760	cruiseParameters = {0: (False, "civalue")})
[7]	761
	762	#---------------------------------------------------------------------------------------
	763
	764	class B737(Boeing737):
	765	"""Boeing 737-700 aircraft."""
[861]	766	dow = 39250
	767
[8]	768	def __init__(self, flight):
	769	super(B737, self).__init__(flight)
[9]	770	self.mtow = 61410
	771	self.mlw = 58059
	772	self.mzfw = 54657
[611]	773	self.maxTakeOffPitch = 14.7
	774	self.maxTouchDownPitch = 13.2
[709]	775	self.simBriefData = SimBriefData(["250/280/78"],
	776	["CI", "M75", "M78", "M79", "M80", "LRC"],
[1087]	777	["78/280/250", "78/250/250"],
	778	cruiseParameters = {0: (False, "civalue")})
[7]	779
	780	#---------------------------------------------------------------------------------------
	781
	782	class B738(Boeing737):
	783	"""Boeing 737-800 aircraft."""
[861]	784	dow = 42690
	785
[8]	786	def __init__(self, flight):
	787	super(B738, self).__init__(flight)
[797]	788	self.mtow = 71791
[9]	789	self.mlw = 65317
	790	self.mzfw = 61688
[611]	791	self.maxTakeOffPitch = 11
	792	self.maxTouchDownPitch = 9.5
[709]	793	self.simBriefData = SimBriefData(["250/280/78"],
	794	["CI", "M76", "M78", "M79", "M80", "LRC"],
[1087]	795	["78/280/250", "78/250/250"],
	796	cruiseParameters = {0: (False, "civalue")})
[9]	797
	798	#---------------------------------------------------------------------------------------
	799
	800	class B738Charter(B738):
	801	"""Boeing 737-800 aircraft used for charters."""
	802	def __init__(self, flight):
	803	super(B738Charter, self).__init__(flight)
	804	self.mtow = 77791
[709]	805	self.simBriefData = SimBriefData(["AUTO"],
	806	["280/M74"],
	807	["AUTO"])
[7]	808
	809	#---------------------------------------------------------------------------------------
	810
[591]	811	class Boeing737CL(Boeing737):
	812	"""Base class for the various aircraft in the Boeing 737 Classic family."""
	813	def __init__(self, flight):
[592]	814	super(Boeing737CL, self).__init__(flight, minLandingFuel = 3500,
	815	recommendedLandingFuel = None)
[591]	816
	817	#---------------------------------------------------------------------------------------
	818
[790]	819	class B732(Boeing737CL):
	820	"""Boeing 737-200 aircraft."""
[861]	821	dow = 27646
	822
[790]	823	def __init__(self, flight):
	824	super(B732, self).__init__(flight)
[796]	825	self.mtow = 52390
	826	self.mlw = 46720
	827	self.mzfw = 43091
	828	self.maxTakeOffPitch = 15.5
	829	self.maxTouchDownPitch = 15.5
[1116]	830	self.simBriefData = SimBriefData(["250/280/70"],
	831	["LRC", "M72", "M73", "M74"],
	832	["74/320/250"])
[790]	833
	834	#---------------------------------------------------------------------------------------
	835
[591]	836	class B733(Boeing737CL):
[7]	837	"""Boeing 737-300 aircraft."""
[861]	838	dow = 32900
	839
[8]	840	def __init__(self, flight):
	841	super(B733, self).__init__(flight)
[797]	842	self.mtow = 56472
	843	self.mlw = 51710
	844	self.mzfw = 47625
[611]	845	self.maxTakeOffPitch = 13.4
	846	self.maxTouchDownPitch = 12.0
[1116]	847	self.simBriefData = SimBriefData(["250/280/74"],
	848	["CI", "M74", "M76", "M78", "LRC"],
	849	["74/280/250"],
	850	cruiseParameters = {0: (False, "civalue")})
[7]	851
	852	#---------------------------------------------------------------------------------------
	853
[591]	854	class B734(Boeing737CL):
[7]	855	"""Boeing 737-400 aircraft."""
[8]	856	def __init__(self, flight):
	857	super(B734, self).__init__(flight)
[797]	858	self.dow = 35100
	859	self.mtow = 62822
	860	self.mlw = 54885
	861	self.mzfw = 51256
[611]	862	self.maxTakeOffPitch = 11.4
	863	self.maxTouchDownPitch = 10
[1116]	864	self.simBriefData = SimBriefData(["250/280/74"],
	865	["CI", "M74", "M76", "M78", "LRC"],
	866	["74/280/250"],
	867	cruiseParameters = {0: (False, "civalue")})
[7]	868
	869	#---------------------------------------------------------------------------------------
	870
[591]	871	class B735(Boeing737CL):
[7]	872	"""Boeing 737-500 aircraft."""
[861]	873	dow = 31900
	874
[8]	875	def __init__(self, flight):
	876	super(B735, self).__init__(flight)
[797]	877	self.mtow = 62823
	878	self.mlw = 49895
	879	self.mzfw = 46720
[611]	880	self.maxTakeOffPitch = 14.7
	881	self.maxTouchDownPitch = 13.2
[1116]	882	self.simBriefData = SimBriefData(["250/280/74"],
	883	["CI", "M74", "M76", "M78", "LRC"],
	884	["74/280/250"],
	885	cruiseParameters = {0: (False, "civalue")})
[7]	886
	887	#---------------------------------------------------------------------------------------
	888
	889	class DH8D(Aircraft):
	890	"""Bombardier Dash-8 Q400 aircraft.
	891
	892	The aircraft type-specific values in the aircraft state have the following
	893	structure:
[140]	894	- fuel: left, right
[7]	895	- n1: left, right
	896	- reverser: left, right."""
[861]	897	dow = 18508
[140]	898
[8]	899	def __init__(self, flight):
[591]	900	super(DH8D, self).__init__(flight, minLandingFuel = 2000)
[797]	901	self.mtow = 29574
	902	self.mlw = 28123
	903	self.mzfw = 26308
[9]	904	self.gearSpeedLimit = 215
	905	self.flapSpeedLimits = { 5 : 200,
	906	10 : 181,
	907	15 : 172,
	908	35 : 158 }
[611]	909	self.maxTakeOffPitch = 8.0
	910	self.maxTouchDownPitch = 7.0
[709]	911	self.simBriefData = SimBriefData(["I-900", "II-900", "III-900",
	912	"I-850", "II-850", "III-850"],
	913	["MCR", "ISC", "LRC", "HSC"],
	914	["I-850", "II-850", "III-850"])
[9]	915
[7]	916	#---------------------------------------------------------------------------------------
	917
	918	class Boeing767(Aircraft):
	919	"""Base class for the various aircraft in the Boeing 767 family.
	920
	921	The aircraft type-specific values in the aircraft state have the following
	922	structure:
[140]	923	- fuel: left, centre, right
[7]	924	- n1: left, right
	925	- reverser: left, right"""
[140]	926
[612]	927	def __init__(self, flight, minLandingFuel = 7000):
[591]	928	super(Boeing767, self).__init__(flight, minLandingFuel = minLandingFuel)
[9]	929	self.gearSpeedLimit = 270
	930	self.flapSpeedLimits = { 1 : 255,
	931	5 : 235,
	932	10 : 215,
	933	20 : 215,
	934	25 : 185,
	935	30 : 175 }
[7]	936
[384]	937	@property
[512]	938	def derateType(self):
	939	"""Get the derate type for this type."""
	940	return DERATE_BOEING
[384]	941
[7]	942	#---------------------------------------------------------------------------------------
	943
	944	class B762(Boeing767):
	945	"""Boeing 767-200 aircraft."""
[861]	946	dow = 84507
	947
[8]	948	def __init__(self, flight):
	949	super(B762, self).__init__(flight)
[797]	950	self.mtow = 159210
[9]	951	self.mlw = 126098
	952	self.mzfw = 114758
[611]	953	self.maxTakeOffPitch = 13.1
	954	self.maxTouchDownPitch = 11.6
[1116]	955	self.simBriefData = SimBriefData(["250/290/78"],
	956	["CI", "M76", "M78", "M80", "M82",
	957	"M84", "M85", "LRC"],
	958	["78/290/250"],
	959	cruiseParameters = {0: (False, "civalue")})
[7]	960
	961	#---------------------------------------------------------------------------------------
	962
	963	class B763(Boeing767):
	964	"""Boeing 767-300 aircraft."""
[861]	965	dow = 91311
	966
[8]	967	def __init__(self, flight):
[331]	968	super(B763, self).__init__(flight)
[9]	969	self.mtow = 181436
	970	self.mlw = 137892
[797]	971	self.mzfw = 114758
[611]	972	self.maxTakeOffPitch = 9.6
	973	self.maxTouchDownPitch = 8.1
[709]	974	self.simBriefData = SimBriefData(["250/290/78"],
	975	["CI", "M76", "M78", "M80", "M82", "M84", "LRC"],
[1116]	976	["78/290/250"],
	977	cruiseParameters = {0: (False, "civalue")})
[7]	978
[799]	979	def setBookedFlight(self, bookedFlight):
	980	"""Update the aircraft based on the booked flight data (e.g. tail number)."""
	981	if bookedFlight.tailNumber=="HA-LHD":
	982	self.mtow = 159210
	983	self.mlw = 126098
	984
[7]	985	#---------------------------------------------------------------------------------------
	986
	987	class CRJ2(Aircraft):
	988	"""Bombardier CRJ-200 aircraft.
	989
	990	The aircraft type-specific values in the aircraft state have the following
	991	structure:
[140]	992	- fuel: left, centre, right
[7]	993	- n1: left, right
	994	- reverser: left, right."""
[861]	995	dow = 14549
	996
[8]	997	def __init__(self, flight):
[591]	998	super(CRJ2, self).__init__(flight, minLandingFuel = 1000)
[9]	999	self.mtow = 22995
	1000	self.mlw = 21319
	1001	self.mzfw = 19958
	1002	self.gearSpeedLimit = 240
	1003	self.flapSpeedLimits = { 8 : 260,
	1004	20 : 220,
	1005	30 : 190,
	1006	45 : 175 }
[611]	1007	self.maxTakeOffPitch = 18.0
	1008	self.maxTouchDownPitch = 18.0
[709]	1009	self.simBriefData = SimBriefData(["250/70", "290/74"],
	1010	["CI", "LRC", "M70", "M72", "M74", "M77", "M80"],
[1116]	1011	["74/290/250", "77/320/250"],
	1012	cruiseParameters = {0: (False, "civalue")})
[7]	1013
	1014	#---------------------------------------------------------------------------------------
	1015
	1016	class F70(Aircraft):
	1017	"""Fokker 70 aircraft.
	1018
	1019	The aircraft type-specific values in the aircraft state have the following
	1020	structure:
[140]	1021	- fuel: left, centre, right
[7]	1022	- n1: left, right
	1023	- reverser: left, right."""
[861]	1024	dow = 24283
	1025
[8]	1026	def __init__(self, flight):
[591]	1027	super(F70, self).__init__(flight, minLandingFuel = 1900)
[9]	1028	self.mtow = 38100 # FIXME: differentiate by registration number,
	1029	# MTOW of HA-LMF: 41955
	1030	self.mlw = 36740
	1031	self.mzfw = 32655
	1032	self.gearSpeedLimit = 200
	1033	self.flapSpeedLimits = { 8 : 250,
	1034	15 : 220,
	1035	25 : 220,
	1036	42 : 180 }
[360]	1037	self.reverseMinSpeed = 50
[611]	1038	self.maxTakeOffPitch = 16.0
	1039	self.maxTouchDownPitch = 16.0
[1116]	1040	self.simBriefData = SimBriefData(["250/280/70"],
	1041	["M70", "LRC"],
	1042	["70/280/250"])
[7]	1043
[384]	1044	@property
[512]	1045	def derateType(self):
	1046	"""Get the derate type for this type."""
	1047	return DERATE_EPR
[384]	1048
[7]	1049	#---------------------------------------------------------------------------------------
	1050
	1051	class DC3(Aircraft):
	1052	"""Lisunov Li-2 (DC-3) aircraft.
	1053
	1054	The aircraft type-specific values in the aircraft state have the following
	1055	structure:
[140]	1056	- fuel: left aux, left, right, right aux
[7]	1057	- rpm: left, right
	1058	- reverser: left, right."""
[861]	1059	dow = 8627
	1060
[8]	1061	def __init__(self, flight):
	1062	super(DC3, self).__init__(flight)
[9]	1063	self.mtow = 11884
	1064	self.mlw = 11793
	1065	self.mzfw = 11780
	1066	self.gearSpeedLimit = 148
	1067	self.flapSpeedLimits = { 15 : 135,
	1068	30 : 99,
	1069	45 : 97 }
[8]	1070
	1071	def _checkFlightEnd(self, aircraftState):
	1072	"""Check if the end of the flight has arrived.
	1073
	1074	This implementation checks the RPM values to be 0."""
	1075	for rpm in aircraftState.rpm:
[29]	1076	if rpm>0: return False
	1077	return True
[7]	1078
	1079	#---------------------------------------------------------------------------------------
	1080
	1081	class T134(Aircraft):
	1082	"""Tupolev Tu-134 aircraft.
	1083
	1084	The aircraft type-specific values in the aircraft state have the following
	1085	structure:
[140]	1086	- fuel: left tip, left aux, centre, right aux, right tip, external 1,
[7]	1087	external 2
	1088	- n1: left, right
	1089	- reverser: left, right."""
[861]	1090	dow = 29500
	1091
[8]	1092	def __init__(self, flight):
[591]	1093	super(T134, self).__init__(flight, minLandingFuel = 3000)
[210]	1094	self.mtow = 49000
[9]	1095	self.mlw = 43000
	1096	self.mzfw = 38500
	1097	self.gearSpeedLimit = 216
[210]	1098	self.flapSpeedLimits = { 10 : 450,
	1099	20 : 400,
	1100	30 : 300 }
[360]	1101	self.reverseMinSpeed = 50
[7]	1102
[644]	1103	self.hasStrobeLight = False
	1104
[611]	1105	self.maxTakeOffPitch = 16.0
	1106	self.maxTouchDownPitch = 16.0
	1107
[241]	1108	@property
[512]	1109	def derateType(self):
	1110	"""Get the derate type for this type."""
	1111	return DERATE_TUPOLEV
[384]	1112
	1113	@property
[241]	1114	def speedInKnots(self):
	1115	"""Indicate if the speed is in knots."""
	1116	return False
[331]	1117
[635]	1118	@property
	1119	def aglInFeet(self):
	1120	"""Indicate if AGL altituedes are in feet."""
	1121	return False
	1122
[211]	1123	def _appendLightsLoggers(self):
	1124	"""Append the loggers needed for the lights."""
	1125	self._checkers.append(checks.AnticollisionLightsLogger())
	1126	self._checkers.append(checks.LandingLightsLogger())
	1127	self._checkers.append(checks.NavLightsLogger())
	1128
	1129	def _appendLightsCheckers(self):
	1130	"""Append the checkers needed for the lights."""
	1131	self._checkers.append(checks.TupolevAntiCollisionLightsChecker())
[631]	1132	self._checkers.append(checks.TupolevLandingLightsChecker())
[211]	1133	self._checkers.append(checks.LandingLightsChecker())
	1134	self._checkers.append(checks.NavLightsChecker())
	1135
[7]	1136	#---------------------------------------------------------------------------------------
	1137
	1138	class T154(Aircraft):
	1139	"""Tupolev Tu-154 aircraft.
	1140
	1141	The aircraft type-specific values in the aircraft state have the following
	1142	structure:
[140]	1143	- fuel: left aux, left, centre, centre 2, right, right aux
[7]	1144	- n1: left, centre, right
	1145	- reverser: left, right"""
[888]	1146	dow = 53259
[861]	1147
[8]	1148	def __init__(self, flight):
[591]	1149	super(T154, self).__init__(flight, minLandingFuel = 5000)
[9]	1150	self.mtow = 98000
	1151	self.mlw = 78000
	1152	self.mzfw = 72000
	1153	self.gearSpeedLimit = 216
	1154	self.flapSpeedLimits = { 15 : 227,
	1155	28 : 194,
	1156	45 : 162 }
[360]	1157	self.reverseMinSpeed = 50
[9]	1158
[644]	1159	self.hasStrobeLight = False
	1160
[611]	1161	self.maxTakeOffPitch = 16.0
	1162	self.maxTouchDownPitch = 16.0
[709]	1163	self.simBriefData = SimBriefData(["AUTO"],
[1116]	1164	["AUTO"],
[709]	1165	["AUTO"])
[611]	1166
[241]	1167	@property
	1168	def speedInKnots(self):
	1169	"""Indicate if the speed is in knots."""
	1170	return False
[331]	1171
[384]	1172	@property
[635]	1173	def aglInFeet(self):
	1174	"""Indicate if AGL altituedes are in feet."""
	1175	return False
	1176
	1177	@property
[512]	1178	def derateType(self):
	1179	"""Get the derate type for this type."""
	1180	return DERATE_TUPOLEV
[384]	1181
[799]	1182	def setBookedFlight(self, bookedFlight):
	1183	"""Update the aircraft based on the booked flight data (e.g. tail number)."""
	1184	if bookedFlight.tailNumber in ["HA-LCM", "HA-LCN", "HA-LCO", "HA-LCP",
	1185	"HA-LCR", "HA-LCU", "HA-LCV"]:
	1186	self.mtow = 100000
	1187	self.mlw = 80000
[904]	1188	elif bookedFlight.tailNumber=="HA-LCX":
	1189	self.mtow = 100000
	1190	self.mlw = 80000
	1191	self.mzfw = 74000
	1192
	1193	self.flapSpeedLimits = { 15 : 227,
	1194	28 : 194,
[905]	1195	36 : 178,
[904]	1196	45 : 162 }
[799]	1197
[211]	1198	def _appendLightsLoggers(self):
	1199	"""Append the loggers needed for the lights."""
	1200	self._checkers.append(checks.AnticollisionLightsLogger())
	1201	self._checkers.append(checks.LandingLightsLogger())
	1202	self._checkers.append(checks.NavLightsLogger())
	1203
	1204	def _appendLightsCheckers(self):
	1205	"""Append the checkers needed for the lights."""
	1206	self._checkers.append(checks.AntiCollisionLightsChecker())
[631]	1207	self._checkers.append(checks.TupolevLandingLightsChecker())
[211]	1208	self._checkers.append(checks.LandingLightsChecker())
	1209	self._checkers.append(checks.NavLightsChecker())
	1210
[539]	1211	#---------------------------------------------------------------------------------------
	1212
	1213	class YK40(Aircraft):
	1214	"""Yakovlev Yak-40 aircraft.
	1215
	1216	The aircraft type-specific values in the aircraft state have the following
	1217	structure:
	1218	- fuel: left, right
	1219	- n1: left, right
	1220	- reverser: left, right"""
[861]	1221	dow = 9400
	1222
[539]	1223	def __init__(self, flight):
	1224	super(YK40, self).__init__(flight)
	1225	self.mtow = 17200
	1226	self.mlw = 16800
	1227	self.mzfw = 12100
	1228	self.gearSpeedLimit = 165
	1229	self.flapSpeedLimits = { 20 : 165,
	1230	35 : 135 }
	1231
[644]	1232	self.hasStrobeLight = False
	1233
[539]	1234	@property
	1235	def speedInKnots(self):
	1236	"""Indicate if the speed is in knots."""
	1237	return False
	1238
	1239	@property
[635]	1240	def aglInFeet(self):
	1241	"""Indicate if AGL altituedes are in feet."""
	1242	return False
	1243
	1244	@property
[539]	1245	def derateType(self):
	1246	"""Get the derate type for this type."""
	1247	return DERATE_TUPOLEV
	1248
	1249	def _appendLightsLoggers(self):
	1250	"""Append the loggers needed for the lights."""
	1251	self._checkers.append(checks.AnticollisionLightsLogger())
	1252	self._checkers.append(checks.LandingLightsLogger())
	1253	self._checkers.append(checks.NavLightsLogger())
	1254
	1255	def _appendLightsCheckers(self):
	1256	"""Append the checkers needed for the lights."""
	1257	self._checkers.append(checks.AntiCollisionLightsChecker())
	1258	self._checkers.append(checks.LandingLightsChecker())
	1259	self._checkers.append(checks.NavLightsChecker())
[403]	1260
[7]	1261	#---------------------------------------------------------------------------------------
	1262
[443]	1263	class B462(Aircraft):
	1264	"""British Aerospace BAe-146 aircraft.
	1265
	1266	The aircraft type-specific values in the aircraft state have the following
	1267	structure:
	1268	- fuel: left, centre, right
	1269	- n1: left outer, left inner, right inner, right outer
	1270	- reverser: empty (the plane has no reversers)"""
[861]	1271	dow = 25706
	1272
[443]	1273	def __init__(self, flight):
	1274	super(B462, self).__init__(flight)
	1275	self.mtow = 43998
	1276	self.mlw = 38599
	1277	self.mzfw = 33792
	1278	self.gearSpeedLimit = 210
	1279	self.flapSpeedLimits = { 18 : 217,
	1280	24 : 180,
	1281	30 : 170,
	1282	33 : 150 }
[1116]	1283	self.simBriefData = SimBriefData(["HighSpeed", "LongRange"],
	1284	["M70", "MCR", "LRC"],
	1285	["HighSpeed", "LongRange"])
[445]	1286	@property
[512]	1287	def derateType(self):
	1288	"""Get the derate type for this type."""
	1289	return DERATE_B462
[445]	1290
[443]	1291	#---------------------------------------------------------------------------------------
	1292
[274]	1293	mostFuelTanks = [const.FUELTANK_LEFT_TIP, const.FUELTANK_EXTERNAL1,
	1294	const.FUELTANK_LEFT_AUX,
	1295	const.FUELTANK_CENTRE,
	1296	const.FUELTANK_RIGHT_AUX,
	1297	const.FUELTANK_EXTERNAL2, const.FUELTANK_RIGHT_TIP]
[141]	1298
	1299	#---------------------------------------------------------------------------------------
	1300
[191]	1301	_classes = { const.AIRCRAFT_B736 : B736,
	1302	const.AIRCRAFT_B737 : B737,
	1303	const.AIRCRAFT_B738 : B738,
	1304	const.AIRCRAFT_B738C : B738Charter,
[790]	1305	const.AIRCRAFT_B732 : B732,
[191]	1306	const.AIRCRAFT_B733 : B733,
	1307	const.AIRCRAFT_B734 : B734,
	1308	const.AIRCRAFT_B735 : B735,
	1309	const.AIRCRAFT_DH8D : DH8D,
	1310	const.AIRCRAFT_B762 : B762,
	1311	const.AIRCRAFT_B763 : B763,
	1312	const.AIRCRAFT_CRJ2 : CRJ2,
	1313	const.AIRCRAFT_F70 : F70,
	1314	const.AIRCRAFT_DC3 : DC3,
	1315	const.AIRCRAFT_T134 : T134,
	1316	const.AIRCRAFT_T154 : T154,
[443]	1317	const.AIRCRAFT_YK40 : YK40,
	1318	const.AIRCRAFT_B462 : B462 }
[8]	1319
	1320	#---------------------------------------------------------------------------------------
[197]	1321
[862]	1322	def getClass(aircraftType):
	1323	"""Get the class representing the given aircraft types"""
	1324	return _classes[aircraftType]
	1325
	1326	#---------------------------------------------------------------------------------------
	1327
[197]	1328	if __name__ == "__main__":
	1329	value = SmoothedValue()
	1330
[919]	1331	print("Adding 1, 12.0")
[197]	1332	value.add(1, 12.0)
[919]	1333	print(value.get())
[197]	1334
[919]	1335	print("Adding 1, 15.0")
[197]	1336	value.add(1, 15.0)
[919]	1337	print(value.get())
[197]	1338
[919]	1339	print("Adding 2, 18.0")
[197]	1340	value.add(2, 18.0)
[919]	1341	print(value.get())
[197]	1342
[919]	1343	print("Adding 2, 20.0")
[197]	1344	value.add(2, 20.0)
[919]	1345	print(value.get())
[197]	1346
[919]	1347	print("Adding 5, 22.0")
[197]	1348	value.add(5, 22.0)
[919]	1349	print(value.get())
[197]	1350
[919]	1351	print("Adding 5, 25.0")
[197]	1352	value.add(5, 25.0)
[919]	1353	print(value.get())
[197]	1354
[919]	1355	print("Adding 5, 29.0")
[197]	1356	value.add(5, 29.0)
[919]	1357	print(value.get())
[197]	1358
[919]	1359	print("Adding 5, 21.0")
[197]	1360	value.add(5, 21.0)
[919]	1361	print(value.get())
[197]	1362
[919]	1363	print("Adding 5, 26.0")
[197]	1364	value.add(5, 26.0)
[919]	1365	print(value.get())
[197]	1366
[919]	1367	print("Adding 2, 30.0")
[197]	1368	value.add(2, 30.0)
[919]	1369	print(value.get())
[197]	1370
[919]	1371	print("Adding 2, 55.0")
[197]	1372	value.add(2, 55.0)
[919]	1373	print(value.get())
[197]	1374
	1375	#---------------------------------------------------------------------------------------

Note: See TracBrowser for help on using the repository browser.

Download in other formats: