Context Navigation

source: src/mlx/acft.py@ 150:0a6ffbd72d7e

Visit:

Last change on this file since 150:0a6ffbd72d7e was 150:0a6ffbd72d7e, checked in by István Váradi <ivaradi@…>, 12 years ago
Updated the fuel logging to the new order
File size: 30.2 KB

Rev	Line
[4]	1	# Module for the simulator-independent aircraft classes
	2
	3	#---------------------------------------------------------------------------------------
	4
[8]	5	import const
	6	import checks
[134]	7	import fs
[89]	8	import util
[4]	9
[139]	10	import sys
[8]	11	import time
[139]	12	import traceback
[7]	13
[4]	14	#---------------------------------------------------------------------------------------
	15
	16	class Aircraft(object):
	17	"""Base class for aircraft."""
[8]	18	@staticmethod
	19	def create(flight):
	20	"""Create an aircraft instance for the type in the given flight."""
	21	return _classes[flight.aircraftType](flight)
	22
	23	def __init__(self, flight):
[4]	24	"""Construct the aircraft for the given type."""
[8]	25	self._flight = flight
[4]	26	self._aircraftState = None
[9]	27
	28	self._maxVS = -10000.0
	29	self._minVS = 10000.0
[4]	30
[101]	31	self._v1r2LineIndex = None
[96]	32	self._vrefLineIndex = None
	33
[117]	34	self.humanWeight = 82.0
	35
[8]	36	self._checkers = []
	37
[11]	38	# Loggers
	39
[8]	40	self._checkers.append(checks.StageChecker())
[9]	41	self._checkers.append(checks.TakeOffLogger())
[8]	42
	43	self._checkers.append(checks.AltimeterLogger())
	44
	45	self._checkers.append(checks.NAV1Logger())
	46	self._checkers.append(checks.NAV2Logger())
	47	self._checkers.append(checks.SquawkLogger())
	48
	49	self._checkers.append(checks.AnticollisionLightsLogger())
	50	self._checkers.append(checks.LandingLightsLogger())
	51	self._checkers.append(checks.StrobeLightsLogger())
	52	self._checkers.append(checks.NavLightsLogger())
	53
	54	self._checkers.append(checks.FlapsLogger())
	55
	56	self._checkers.append(checks.GearsLogger())
[9]	57	self._checkers.append(checks.CruiseSpeedLogger())
[10]	58	self._checkers.append(checks.SpoilerLogger())
[9]	59
[134]	60	if flight.config.isMessageTypeFS(const.MESSAGETYPE_VISIBILITY):
	61	self._checkers.append(checks.VisibilityChecker())
	62
[139]	63	# FIXME: we should have a central data model object, and not collect
	64	# the data from the GUI. However, some pieces of data (e.g. V-speeds,
	65	# etc. that is entered into the GUI) should be a part of the GUI and
	66	# queried from it, so the model should have a reference to the GUI as
	67	# well and access such data via the GUI!
	68	if flight.config.onlineACARS:
	69	self._checkers.append(checks.ACARSSender(flight._gui))
	70
[11]	71	# Fault checkers
	72
	73	self._checkers.append(checks.AntiCollisionLightsChecker())
	74	self._checkers.append(checks.LandingLightsChecker())
	75	self._checkers.append(checks.NavLightsChecker())
	76	self._checkers.append(checks.StrobeLightsChecker())
	77
	78	self._checkers.append(checks.BankChecker())
	79
	80	self._checkers.append(checks.FlapsRetractChecker())
	81	self._checkers.append(checks.FlapsSpeedLimitChecker())
	82
	83	self._checkers.append(checks.GearsDownChecker())
	84	self._checkers.append(checks.GearSpeedLimitChecker())
	85
	86	self._checkers.append(checks.GLoadChecker())
	87
	88	self._checkers.append(checks.MLWChecker())
	89	self._checkers.append(checks.MTOWChecker())
	90	self._checkers.append(checks.MZFWChecker())
	91	self._checkers.append(checks.PayloadChecker())
	92
	93	self._checkers.append(checks.SpeedChecker())
	94	self._checkers.append(checks.VSChecker())
	95	self._checkers.append(checks.OverspeedChecker())
	96	self._checkers.append(checks.StallChecker())
	97
	98	self._checkers.append(checks.PitotChecker())
	99
	100	self._checkers.append(checks.ReverserChecker())
	101
[4]	102	@property
	103	def type(self):
	104	"""Get the type of the aircraft."""
[8]	105	return self._flight.aircraftType
	106
	107	@property
	108	def flight(self):
	109	"""Get the flight the aircraft belongs to."""
	110	return self._flight
[4]	111
[8]	112	@property
	113	def logger(self):
	114	"""Get the logger to use for the aircraft."""
	115	return self._flight.logger
	116
[139]	117	@property
	118	def state(self):
	119	"""Get the current aircraft state."""
	120	return self._aircraftState
	121
[11]	122	def getFlapsSpeedLimit(self, flaps):
	123	"""Get the speed limit for the given flaps setting."""
	124	return self.flapSpeedLimits[flaps] if flaps in self.flapSpeedLimits \
	125	else None
	126
[8]	127	def modelChanged(self, timestamp, aircraftName, modelName):
[4]	128	"""Called when the simulator's aircraft changes."""
[8]	129	self._flight.logger.message(timestamp,
	130	"Aircraft: name='%s', model='%s'" % \
	131	(aircraftName, modelName))
[4]	132
	133	def handleState(self, aircraftState):
	134	"""Called when the state of the aircraft changes."""
[8]	135	for checker in self._checkers:
[139]	136	try:
	137	checker.check(self._flight, self, self._flight.logger,
	138	self._aircraftState, aircraftState)
	139	except:
	140	print >> sys.stderr, "Checker", checker, "failed"
	141	traceback.print_exc()
[7]	142
[89]	143	self._flight.handleState(self._aircraftState, aircraftState)
	144
[9]	145	self._maxVS = max(self._maxVS, aircraftState.vs)
	146	self._minVS = min(self._minVS, aircraftState.vs)
	147
[4]	148	self._aircraftState = aircraftState
[8]	149
	150	def setStage(self, aircraftState, newStage):
	151	"""Set the given stage as the new one and do whatever should be
	152	done."""
[9]	153	if self._flight.setStage(aircraftState.timestamp, newStage):
	154	if newStage==const.STAGE_PUSHANDTAXI:
	155	self.logger.message(aircraftState.timestamp, "Block time start")
	156	self.logFuel(aircraftState)
	157	self.logger.message(aircraftState.timestamp,
	158	"Zero-fuel weight: %.0f kg" % (aircraftState.zfw))
[134]	159	flight = self._flight
	160	if flight.v1 is None or flight.vr is None or flight.v2 is None:
	161	fs.sendMessage(const.MESSAGETYPE_HELP,
	162	"Don't forget to set the takeoff V-speeds!",
	163	5)
[9]	164	elif newStage==const.STAGE_TAKEOFF:
	165	self.logger.message(aircraftState.timestamp, "Flight time start")
	166	self.logger.message(aircraftState.timestamp,
	167	"Takeoff weight: %.0f kg, MTOW: %.0f kg" % \
	168	(aircraftState.grossWeight, self.mtow))
	169	self.logger.message(aircraftState.timestamp,
	170	"Wind %03.0f degrees at %.0f knots" % \
	171	(aircraftState.windDirection,
	172	aircraftState.windSpeed))
[101]	173	self._logV1R2()
[9]	174	elif newStage==const.STAGE_TAXIAFTERLAND:
[134]	175	bookedFlight = self._flight.bookedFlight
[136]	176	config = self._flight.config
	177	if config.onlineGateSystem and \
	178	bookedFlight.arrivalICAO=="LHBP" and \
	179	config.isMessageTypeFS(const.MESSAGETYPE_GATE_SYSTEM):
[134]	180	self._flight.getFleet(callback = self._fleetRetrieved,
	181	force = True)
[9]	182	self.logger.message(aircraftState.timestamp, "Flight time end")
	183	self.logFuel(aircraftState)
	184	self.logger.message(aircraftState.timestamp,
	185	"Landing weight: %.0f kg, MLW: %.0f" % \
	186	(aircraftState.grossWeight, self.mlw))
	187	self.logger.message(aircraftState.timestamp,
	188	"Vertical speed range: %.0f..%.0f feet/min" % \
[12]	189	(self._minVS, self._maxVS))
[9]	190	elif newStage==const.STAGE_PARKING:
	191	self.logger.message(aircraftState.timestamp, "Block time end")
[89]	192	elif newStage==const.STAGE_END:
	193	flightLength = self._flight.flightTimeEnd - self._flight.flightTimeStart
	194	self.logger.message(aircraftState.timestamp,
	195	"Flight time: " +
	196	util.getTimeIntervalString(flightLength))
	197	self.logger.message(aircraftState.timestamp,
	198	"Flown distance: %.2f NM" % \
	199	(self._flight.flownDistance,))
	200	blockLength = self._flight.blockTimeEnd - self._flight.blockTimeStart
	201	self.logger.message(aircraftState.timestamp,
	202	"Block time: " +
	203	util.getTimeIntervalString(blockLength))
[134]	204	bookedFlight = self._flight.bookedFlight
	205	# FIXME: translate the ICAO into an airport name
	206	fs.sendMessage(const.MESSAGETYPE_ENVIRONMENT,
	207	"Flight plan closed. Welcome to %s" % \
	208	(bookedFlight.arrivalICAO,),
	209	5)
[8]	210
[9]	211	def prepareFlare(self):
	212	"""Called when it is detected that we will soon flare.
[8]	213
	214	On the first call, it should start monitoring some parameters more
	215	closely to determine flare time."""
[9]	216	self.flight.simulator.startFlare()
	217
	218	def flareStarted(self, windSpeed, windDirection, visibility,
	219	flareStart, flareStartFS):
	220	"""Called when the flare has started."""
	221	self.logger.message(self._aircraftState.timestamp, "The flare has begun")
	222	self.logger.message(self._aircraftState.timestamp,
	223	"Wind %03.0f degrees at %.0f knots" % \
	224	(windDirection, windSpeed))
	225	self.logger.message(self._aircraftState.timestamp,
	226	"Visibility: %.0f metres" % (visibility,))
	227	self.logger.message(self._aircraftState.timestamp,
	228	"Altimeter setting: %.0f hPa" % \
	229	(self._aircraftState.altimeter,))
[101]	230	self._logVRef()
[9]	231	self.flight.flareStarted(flareStart, flareStartFS)
[134]	232	fs.sendMessage(const.MESSAGETYPE_INFORMATION, "Flare-time", 3)
[9]	233
	234	def flareFinished(self, flareEnd, flareEndFS, tdRate, tdRateCalculatedByFS,
	235	ias, pitch, bank, heading):
	236	"""Called when the flare has finished."""
	237	(flareTimeFromFS, flareTime) = self.flight.flareFinished(flareEnd,
	238	flareEndFS)
	239	self.logger.message(self._aircraftState.timestamp,
	240	"Flare time: %.1f s (from %s)" % \
	241	(flareTime,
	242	"the simulator" if flareTimeFromFS else "real time",))
	243	self.logger.message(self._aircraftState.timestamp,
	244	"Touchdown rate: %.0f feet/min" % (tdRate,))
	245	self.logger.message(self._aircraftState.timestamp,
	246	"Touchdown rate was calculated by the %s" % \
	247	("simulator" if tdRateCalculatedByFS else "logger",))
	248	self.logger.message(self._aircraftState.timestamp,
	249	"Touchdown speed: %.0f knots" % (ias,))
	250	self.logger.message(self._aircraftState.timestamp,
	251	"Touchdown pitch: %.1f degrees" % (pitch,))
	252	self.logger.message(self._aircraftState.timestamp,
	253	"Touchdown bank: %.1f degrees" % (bank,))
	254	self.logger.message(self._aircraftState.timestamp,
	255	"Touchdown heading: %03.0f degrees" % (heading,))
[8]	256
	257	def cancelFlare(self):
	258	"""Cancel flare, if it has started."""
[9]	259	self.flight.simulator.cancelFlare()
[8]	260
	261	def checkFlightEnd(self, aircraftState):
	262	"""Check if the end of the flight has arrived.
	263
	264	This default implementation checks the N1 values, but for
	265	piston-powered aircraft you need to check the RPMs."""
	266	for n1 in aircraftState.n1:
	267	if n1>=0.5: return False
	268	return True
	269
[101]	270	def updateV1R2(self):
	271	"""Update the V1, Vr and V2 values from the flight, if the these values
	272	have already been logged."""
	273	if self._v1r2LineIndex is not None:
	274	self._logV1R2()
	275
	276	def _logV1R2(self):
	277	"""Log the V1, Vr and V2 value either newly, or by updating the
	278	corresponding line."""
	279	message = "Speeds calculated by the pilot: V1: %s, VR: %s, V2: %s" % \
	280	("-" if self._flight.v1 is None
	281	else str(self._flight.v1),
	282	"-" if self._flight.vr is None
	283	else str(self._flight.vr),
	284	"-" if self._flight.v2 is None
	285	else str(self._flight.v2))
	286
	287	if self._v1r2LineIndex is None:
	288	self._v1r2LineIndex = \
	289	self.logger.message(self._aircraftState.timestamp, message)
	290	else:
	291	self.logger.updateLine(self._v1r2LineIndex, message)
	292
[96]	293	def updateVRef(self):
	294	"""Update the Vref value from the flight, if the Vref value has already
	295	been logged."""
	296	if self._vrefLineIndex is not None:
	297	self._logVRef()
	298
	299	def _logVRef(self):
	300	"""Log the Vref value either newly, or by updating the corresponding
	301	line."""
	302	message = "VRef speed calculated by the pilot: %s" % \
	303	("-" if self._flight.vref is None else str(self._flight.vref))
	304	if self._vrefLineIndex is None:
	305	self._vrefLineIndex = \
	306	self.logger.message(self._aircraftState.timestamp, message)
	307	else:
	308	self.logger.updateLine(self._vrefLineIndex, message)
	309
[134]	310	def _fleetRetrieved(self, fleet):
	311	"""Callback for the fleet retrieval result."""
	312	if fleet is not None:
	313	gateList = ""
	314	occupiedGateNumbers = fleet.getOccupiedGateNumbers()
	315	for gateNumber in const.lhbpGateNumbers:
	316	if gateNumber not in occupiedGateNumbers:
	317	if gateList: gateList += ", "
	318	gateList += gateNumber
	319	fs.sendMessage(const.MESSAGETYPE_GATE_SYSTEM,
	320	"Free gates: " + gateList, 20)
	321
	322
[4]	323	#---------------------------------------------------------------------------------------
[7]	324
	325	class Boeing737(Aircraft):
	326	"""Base class for the various aircraft in the Boeing 737 family.
	327
	328	The aircraft type-specific values in the aircraft state have the following
	329	structure:
[140]	330	- fuel: left, centre, right
[7]	331	- n1: left, right
	332	- reverser: left, right"""
[140]	333	fuelTanks = [const.FUELTANK_LEFT, const.FUELTANK_CENTRE, const.FUELTANK_RIGHT]
	334
[9]	335	def __init__(self, flight):
	336	super(Boeing737, self).__init__(flight)
[95]	337	self._checkers.append(checks.ThrustChecker())
	338
[9]	339	self.gearSpeedLimit = 270
	340	self.flapSpeedLimits = { 1 : 260,
	341	2 : 260,
	342	5 : 250,
	343	10 : 210,
	344	15 : 200,
	345	25 : 190,
	346	30 : 175,
	347	40 : 162 }
[7]	348
[9]	349	def logFuel(self, aircraftState):
	350	"""Log the amount of fuel"""
	351	self.logger.message(aircraftState.timestamp,
	352	"Fuel: left=%.0f kg - centre=%.0f kg - right=%.0f kg" % \
[150]	353	(aircraftState.fuel[0], aircraftState.fuel[1],
[9]	354	aircraftState.fuel[2]))
	355	self.logger.message(aircraftState.timestamp,
	356	"Total fuel: %.0f kg" % (sum(aircraftState.fuel),))
	357
[7]	358	#---------------------------------------------------------------------------------------
	359
	360	class B736(Boeing737):
	361	"""Boeing 737-600 aircraft."""
[8]	362	def __init__(self, flight):
	363	super(B736, self).__init__(flight)
[9]	364	self.dow = 38307
	365	self.mtow = 58328
	366	self.mlw = 54657
	367	self.mzfw = 51482
[7]	368
	369	#---------------------------------------------------------------------------------------
	370
	371	class B737(Boeing737):
	372	"""Boeing 737-700 aircraft."""
[8]	373	def __init__(self, flight):
	374	super(B737, self).__init__(flight)
[9]	375	self.dow = 39250
	376	self.mtow = 61410
	377	self.mlw = 58059
	378	self.mzfw = 54657
[7]	379
	380	#---------------------------------------------------------------------------------------
	381
	382	class B738(Boeing737):
	383	"""Boeing 737-800 aircraft."""
[8]	384	def __init__(self, flight):
	385	super(B738, self).__init__(flight)
[9]	386	self.dow = 42690
	387	self.mtow = 71709
	388	self.mlw = 65317
	389	self.mzfw = 61688
	390
	391	#---------------------------------------------------------------------------------------
	392
	393	class B738Charter(B738):
	394	"""Boeing 737-800 aircraft used for charters."""
	395	def __init__(self, flight):
	396	super(B738Charter, self).__init__(flight)
	397	self.mtow = 77791
[7]	398
	399	#---------------------------------------------------------------------------------------
	400
	401	class B733(Boeing737):
	402	"""Boeing 737-300 aircraft."""
[8]	403	def __init__(self, flight):
	404	super(B733, self).__init__(flight)
[9]	405	self.dow = 32700
	406	self.mtow = 62820
	407	self.mlw = 51700
	408	self.mzfw = 48410
[7]	409
	410	#---------------------------------------------------------------------------------------
	411
	412	class B734(Boeing737):
	413	"""Boeing 737-400 aircraft."""
[8]	414	def __init__(self, flight):
	415	super(B734, self).__init__(flight)
[9]	416	self.dow = 33200
	417	self.mtow = 68050
	418	self.mlw = 56200
	419	self.mzfw = 53100
[7]	420
	421	#---------------------------------------------------------------------------------------
	422
	423	class B735(Boeing737):
	424	"""Boeing 737-500 aircraft."""
[8]	425	def __init__(self, flight):
	426	super(B735, self).__init__(flight)
[9]	427	self.dow = 31300
	428	self.mtow = 60550
	429	self.mlw = 50000
	430	self.mzfw = 46700
[7]	431
	432	#---------------------------------------------------------------------------------------
	433
	434	class DH8D(Aircraft):
	435	"""Bombardier Dash-8 Q400 aircraft.
	436
	437	The aircraft type-specific values in the aircraft state have the following
	438	structure:
[140]	439	- fuel: left, right
[7]	440	- n1: left, right
	441	- reverser: left, right."""
[140]	442	fuelTanks = [const.FUELTANK_LEFT, const.FUELTANK_RIGHT]
	443
[8]	444	def __init__(self, flight):
	445	super(DH8D, self).__init__(flight)
[9]	446	self.dow = 17185
	447	self.mtow = 29257
	448	self.mlw = 28009
	449	self.mzfw = 25855
	450	self.gearSpeedLimit = 215
	451	self.flapSpeedLimits = { 5 : 200,
	452	10 : 181,
	453	15 : 172,
	454	35 : 158 }
	455
	456	def logFuel(self, aircraftState):
	457	"""Log the amount of fuel"""
	458	self.logger.message(aircraftState.timestamp,
[150]	459	"Fuel: left=%.0f kg - right=%.0f kg" % \
	460	(aircraftState.fuel[0], aircraftState.fuel[1]))
[9]	461	self.logger.message(aircraftState.timestamp,
	462	"Total fuel: %.0f kg" % (sum(aircraftState.fuel),))
[7]	463
	464	#---------------------------------------------------------------------------------------
	465
	466	class Boeing767(Aircraft):
	467	"""Base class for the various aircraft in the Boeing 767 family.
	468
	469	The aircraft type-specific values in the aircraft state have the following
	470	structure:
[140]	471	- fuel: left, centre, right
[7]	472	- n1: left, right
	473	- reverser: left, right"""
[140]	474	fuelTanks = [const.FUELTANK_LEFT, const.FUELTANK_CENTRE, const.FUELTANK_RIGHT]
	475
[9]	476	def __init__(self, flight):
	477	super(Boeing767, self).__init__(flight)
[95]	478	self._checkers.append(checks.ThrustChecker())
[9]	479	self.gearSpeedLimit = 270
	480	self.flapSpeedLimits = { 1 : 255,
	481	5 : 235,
	482	10 : 215,
	483	20 : 215,
	484	25 : 185,
	485	30 : 175 }
[7]	486
[9]	487	def logFuel(self, aircraftState):
	488	"""Log the amount of fuel"""
	489	self.logger.message(aircraftState.timestamp,
	490	"Fuel: left=%.0f kg - centre=%.0f kg - right=%.0f kg" % \
[150]	491	(aircraftState.fuel[0], aircraftState.fuel[1],
[9]	492	aircraftState.fuel[2]))
	493	self.logger.message(aircraftState.timestamp,
	494	"Total fuel: %.0f kg" % (sum(aircraftState.fuel),))
	495
[7]	496	#---------------------------------------------------------------------------------------
	497
	498	class B762(Boeing767):
	499	"""Boeing 767-200 aircraft."""
[8]	500	def __init__(self, flight):
	501	super(B762, self).__init__(flight)
[9]	502	self.dow = 84507
	503	self.mtow = 175540
	504	self.mlw = 126098
	505	self.mzfw = 114758
[7]	506
	507	#---------------------------------------------------------------------------------------
	508
	509	class B763(Boeing767):
	510	"""Boeing 767-300 aircraft."""
[8]	511	def __init__(self, flight):
	512	super(B763, self).__init__(cflight)
[9]	513	self.dow = 91311
	514	self.mtow = 181436
	515	self.mlw = 137892
	516	self.mzfw = 130635
[7]	517
	518	#---------------------------------------------------------------------------------------
	519
	520	class CRJ2(Aircraft):
	521	"""Bombardier CRJ-200 aircraft.
	522
	523	The aircraft type-specific values in the aircraft state have the following
	524	structure:
[140]	525	- fuel: left, centre, right
[7]	526	- n1: left, right
	527	- reverser: left, right."""
[140]	528	fuelTanks = [const.FUELTANK_LEFT, const.FUELTANK_CENTRE, const.FUELTANK_RIGHT]
	529
[8]	530	def __init__(self, flight):
	531	super(CRJ2, self).__init__(flight)
[95]	532	self._checkers.append(checks.ThrustChecker())
[9]	533	self.dow = 14549
	534	self.mtow = 22995
	535	self.mlw = 21319
	536	self.mzfw = 19958
	537	self.gearSpeedLimit = 240
	538	self.flapSpeedLimits = { 8 : 260,
	539	20 : 220,
	540	30 : 190,
	541	45 : 175 }
[7]	542
[9]	543	def logFuel(self, aircraftState):
	544	"""Log the amount of fuel"""
	545	self.logger.message(aircraftState.timestamp,
	546	"Fuel: left=%.0f kg - centre=%.0f kg - right=%.0f kg" % \
[150]	547	(aircraftState.fuel[0], aircraftState.fuel[1],
[9]	548	aircraftState.fuel[2]))
	549	self.logger.message(aircraftState.timestamp,
	550	"Total fuel: %.0f kg" % (sum(aircraftState.fuel),))
	551
[7]	552	#---------------------------------------------------------------------------------------
	553
	554	class F70(Aircraft):
	555	"""Fokker 70 aircraft.
	556
	557	The aircraft type-specific values in the aircraft state have the following
	558	structure:
[140]	559	- fuel: left, centre, right
[7]	560	- n1: left, right
	561	- reverser: left, right."""
[140]	562	fuelTanks = [const.FUELTANK_LEFT, const.FUELTANK_CENTRE, const.FUELTANK_RIGHT]
	563
[8]	564	def __init__(self, flight):
	565	super(F70, self).__init__(flight)
[95]	566	self._checkers.append(checks.ThrustChecker())
[9]	567	self.dow = 24283
	568	self.mtow = 38100 # FIXME: differentiate by registration number,
	569	# MTOW of HA-LMF: 41955
	570	self.mlw = 36740
	571	self.mzfw = 32655
	572	self.gearSpeedLimit = 200
	573	self.flapSpeedLimits = { 8 : 250,
	574	15 : 220,
	575	25 : 220,
	576	42 : 180 }
[7]	577
[9]	578	def logFuel(self, aircraftState):
	579	"""Log the amount of fuel"""
	580	self.logger.message(aircraftState.timestamp,
	581	"Fuel: left=%.0f kg - centre=%.0f kg - right=%.0f kg" % \
[150]	582	(aircraftState.fuel[0], aircraftState.fuel[1],
[9]	583	aircraftState.fuel[2]))
	584	self.logger.message(aircraftState.timestamp,
	585	"Total fuel: %.0f kg" % (sum(aircraftState.fuel),))
	586
[7]	587	#---------------------------------------------------------------------------------------
	588
	589	class DC3(Aircraft):
	590	"""Lisunov Li-2 (DC-3) aircraft.
	591
	592	The aircraft type-specific values in the aircraft state have the following
	593	structure:
[140]	594	- fuel: left aux, left, right, right aux
[7]	595	- rpm: left, right
	596	- reverser: left, right."""
[140]	597	fuelTanks = [const.FUELTANK_LEFT_AUX, const.FUELTANK_LEFT,
	598	const.FUELTANK_RIGHT, const.FUELTANK_RIGHT_AUX]
	599
[8]	600	def __init__(self, flight):
	601	super(DC3, self).__init__(flight)
[9]	602	self.dow = 8627
	603	self.mtow = 11884
	604	self.mlw = 11793
	605	self.mzfw = 11780
	606	self.gearSpeedLimit = 148
	607	self.flapSpeedLimits = { 15 : 135,
	608	30 : 99,
	609	45 : 97 }
[8]	610
	611	def _checkFlightEnd(self, aircraftState):
	612	"""Check if the end of the flight has arrived.
	613
	614	This implementation checks the RPM values to be 0."""
	615	for rpm in aircraftState.rpm:
[29]	616	if rpm>0: return False
	617	return True
[7]	618
[9]	619	def logFuel(self, aircraftState):
	620	"""Log the amount of fuel"""
	621	self.logger.message(aircraftState.timestamp,
	622	"Fuel: left aux=%.0f kg - left=%.0f kg - right=%.0f kg - right aux=%.0f kg" % \
[150]	623	(aircraftState.fuel[0], aircraftState.fuel[1],
	624	aircraftState.fuel[2], aircraftState.fuel[3]))
[9]	625	self.logger.message(aircraftState.timestamp,
	626	"Total fuel: %.0f kg" % (sum(aircraftState.fuel),))
	627
[7]	628	#---------------------------------------------------------------------------------------
	629
	630	class T134(Aircraft):
	631	"""Tupolev Tu-134 aircraft.
	632
	633	The aircraft type-specific values in the aircraft state have the following
	634	structure:
[140]	635	- fuel: left tip, left aux, centre, right aux, right tip, external 1,
[7]	636	external 2
	637	- n1: left, right
	638	- reverser: left, right."""
[140]	639	fuelTanks = [const.FUELTANK_LEFT_TIP, const.FUELTANK_LEFT_AUX,
	640	const.FUELTANK_CENTRE,
	641	const.FUELTANK_RIGHT_AUX, const.FUELTANK_RIGHT_TIP,
	642	const.FUELTANK_EXTERNAL1, const.FUELTANK_EXTERNAL2]
	643
[8]	644	def __init__(self, flight):
	645	super(T134, self).__init__(flight)
[95]	646	self._checkers.append(checks.ThrustChecker())
[9]	647	self.dow = 29927
	648	self.mtow = 47600
	649	self.mlw = 43000
	650	self.mzfw = 38500
	651	self.gearSpeedLimit = 216
	652	self.flapSpeedLimits = { 10 : 240,
	653	20 : 216,
	654	30 : 161 }
[7]	655
[9]	656	def logFuel(self, aircraftState):
	657	"""Log the amount of fuel"""
	658	self.logger.message(aircraftState.timestamp,
	659	"Fuel: left aux=%.0f kg - left tip=%.0f kg - centre= %.0f kg - right tip=%.0f kg - right aux=%.0f kg - external 1=%.0f kg - external 2=%.0f kg" % \
[150]	660	(aircraftState.fuel[1], aircraftState.fuel[0],
	661	aircraftState.fuel[2],
	662	aircraftState.fuel[4], aircraftState.fuel[3],
[9]	663	aircraftState.fuel[5], aircraftState.fuel[6]))
	664	self.logger.message(aircraftState.timestamp,
	665	"Total fuel: %.0f kg" % (sum(aircraftState.fuel),))
	666
[7]	667	#---------------------------------------------------------------------------------------
	668
	669	class T154(Aircraft):
	670	"""Tupolev Tu-154 aircraft.
	671
	672	The aircraft type-specific values in the aircraft state have the following
	673	structure:
[140]	674	- fuel: left aux, left, centre, centre 2, right, right aux
[7]	675	- n1: left, centre, right
	676	- reverser: left, right"""
[140]	677	fuelTanks = [const.FUELTANK_LEFT_AUX, const.FUELTANK_LEFT,
	678	const.FUELTANK_CENTRE, const.FUELTANK_CENTRE2,
	679	const.FUELTANK_RIGHT, const.FUELTANK_RIGHT_AUX]
[8]	680	def __init__(self, flight):
	681	super(T154, self).__init__(flight)
[95]	682	self._checkers.append(checks.ThrustChecker())
[9]	683	self.dow = 53259
	684	self.mtow = 98000
	685	self.mlw = 78000
	686	self.mzfw = 72000
	687	self.gearSpeedLimit = 216
	688	self.flapSpeedLimits = { 15 : 227,
	689	28 : 194,
	690	45 : 162 }
	691
	692	def logFuel(self, aircraftState):
	693	"""Log the amount of fuel"""
	694	self.logger.message(aircraftState.timestamp,
	695	"Fuel: left aux=%.0f kg - left=%.0f kg - centre=%.0f kg - centre 2=%.0f kg - right=%.0f kg - right aux=%.0f kg" % \
[150]	696	(aircraftState.fuel[0], aircraftState.fuel[1],
	697	aircraftState.fuel[2], aircraftState.fuel[3],
	698	aircraftState.fuel[4], aircraftState.fuel[5]))
[9]	699	self.logger.message(aircraftState.timestamp,
	700	"Total fuel: %.0f kg" % (sum(aircraftState.fuel),))
[7]	701
	702	#---------------------------------------------------------------------------------------
	703
[9]	704
[7]	705	class YK40(Aircraft):
	706	"""Yakovlev Yak-40 aircraft.
	707
	708	The aircraft type-specific values in the aircraft state have the following
	709	structure:
	710	- fuel: left, right
	711	- n1: left, right
	712	- reverser: left, right"""
[140]	713	fuelTanks = [const.FUELTANK_LEFT, const.FUELTANK_RIGHT]
	714
[8]	715	def __init__(self, flight):
	716	super(YK40, self).__init__(flight)
[95]	717	self._checkers.append(checks.ThrustChecker())
[9]	718	self.dow = 9400
	719	self.mtow = 17200
	720	self.mlw = 16800
	721	self.mzfw = 12100
	722	self.gearSpeedLimit = 165
	723	self.flapSpeedLimits = { 20 : 165,
	724	35 : 135 }
	725
	726	def logFuel(self, aircraftState):
	727	"""Log the amount of fuel"""
	728	self.logger.message(aircraftState.timestamp,
	729	"Fuel: left=%.0f kg - right=%.0f kg" % \
	730	(aircraftState.fuel[0], aircraftState.fuel[1]))
	731	self.logger.message(aircraftState.timestamp,
	732	"Total fuel: %.0f kg" % (sum(aircraftState.fuel),))
[7]	733
	734	#---------------------------------------------------------------------------------------
	735
[141]	736	MostFuelTankAircraft = T134
	737
	738	#---------------------------------------------------------------------------------------
	739
[8]	740	_classes = { const.AIRCRAFT_B736 : B736,
	741	const.AIRCRAFT_B737 : B737,
	742	const.AIRCRAFT_B738 : B738,
	743	const.AIRCRAFT_B733 : B733,
	744	const.AIRCRAFT_B734 : B734,
	745	const.AIRCRAFT_B735 : B735,
	746	const.AIRCRAFT_DH8D : DH8D,
	747	const.AIRCRAFT_B762 : B762,
	748	const.AIRCRAFT_B763 : B763,
	749	const.AIRCRAFT_CRJ2 : CRJ2,
	750	const.AIRCRAFT_F70 : F70,
	751	const.AIRCRAFT_DC3 : DC3,
	752	const.AIRCRAFT_T134 : T134,
	753	const.AIRCRAFT_T154 : T154,
	754	const.AIRCRAFT_YK40 : YK40 }
	755
	756	#---------------------------------------------------------------------------------------

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

Download in other formats: