Exemplo n.º 1
0
    def test_main_five(self):

        airportsDb = AirportsDatabase()
        assert (airportsDb.read())

        print ' ============== g3 performance ==============='
        t0 = time.clock()
        g3 = Graph()
        index = 0
        for airport in airportsDb.getAirports():
            print airport
            g3.addVertex(airport)
            index += 1
        t1 = time.clock()
        print 'number of airports= {0} - duration= {1} seconds'.format(
            index, t1 - t0)

        airport = airportsDb.getAirportFromICAOCode('LFPG')
        t2 = time.clock()
        g4 = Graph()
        for i in range(0, 10000):
            g4.addVertex(airport)
        t3 = time.clock()
        print 'number of addVertex = {0} - duration= {1:.8f} seconds'.format(
            i, t3 - t2)
Exemplo n.º 2
0
    def test_class_one(self):

        print '==================== Main start ==================== ' + time.strftime(
            "%c")

        t0 = time.clock()
        print "time start= {0}".format(t0)
        atmosphere = Atmosphere()

        t1 = time.clock()
        print "simulation time= {0} - simulation duration= {1:3.10f} seconds".format(
            t1, (t1 - t0))

        print '==================== load airports ==================== ' + time.strftime(
            "%c")
        airportsDB = AirportsDatabase()
        assert airportsDB.read()
        print '==================== air density at airports field elevation ==================== ' + time.strftime(
            "%c")

        for airport in airportsDB.getAirports():
            print '=======================' + airport.getName(
            ) + '===================='
            print 'field elevation= ' + str(
                airport.getFieldElevationAboveSeaLevelMeters()) + ' meters'
            altitudeMeters = airport.getFieldElevationAboveSeaLevelMeters()
            print 'air density= ' + str(
                atmosphere.getAirDensityKilogramsPerCubicMeters(
                    altitudeMeters)) + ' kg / meters ^^ 3'
Exemplo n.º 3
0
    def test_create_Country_Airports_KML(self):
        print(
            '============ create country specific airports KML file ============='
        )
        airportsDb = AirportsDatabase()
        self.assertTrue(airportsDb.read())
        country = 'France'

        CountryList = [
            'France', 'Japan', 'United Kingdom', 'Germany', 'Spain',
            'United States', 'Canada', 'Italy', 'Spain', 'United Kingdom'
        ]

        for country in CountryList:
            fileName = country + '_Airports.kml'
            kmlOutputFile = KmlOutput(fileName=fileName)

            for airport in airportsDb.getAirportsFromCountry(Country=country):
                airportName = str(airport.getName())
                kmlOutputFile.write(
                    name=airportName,
                    LongitudeDegrees=airport.getLongitudeDegrees(),
                    LatitudeDegrees=airport.getLatitudeDegrees(),
                    AltitudeAboveSeaLevelMeters=airport.
                    getAltitudeMeanSeaLevelMeters())
            kmlOutputFile.close()
    def test_performance_graph_with_airport(self):

        airportsDb = AirportsDatabase()
        assert (airportsDb.read())

        print(' ============== g3 performance ===============')
        t0 = time.process_time()
        g3 = Graph()
        count = 0
        for airport in airportsDb.getAirports():
            print(airport)
            g3.addVertex(airport)
            count += 1
        t1 = time.process_time()
        print('number of airports= {0} - duration= {1} seconds'.format(
            count, t1 - t0))
        self.assertEqual(g3.getNumberOfVertices(), count)

        g3.createXlsxOutputFile()
        g3.createKmlOutputFile()

        print(' ============== g4 performance ===============')
        airport = airportsDb.getAirportFromICAOCode('LFPG')
        t2 = time.process_time()
        g4 = Graph()
        for i in range(0, 10000):
            g4.addVertex(airport)
        t3 = time.process_time()
        print('number of addVertex = {0} - duration= {1:.8f} seconds'.format(
            i, t3 - t2))
Exemplo n.º 5
0
    def test_get_countries(self):

        print('============ test get countries =============')
        airportsDb = AirportsDatabase()
        self.assertTrue(airportsDb.read())

        for country in airportsDb.getCountries():
            print('test get country= ' + country)
    def test_Vstall(self):

        t0 = time.clock()
        print("time start= ", t0)

        atmosphere = Atmosphere()
        earth = Earth()
        print(
            '==================== Stall Speed according to airport field elevation ==================== '
            + time.strftime("%c"))
        acBd = BadaAircraftDatabase()
        aircraftICAOcode = 'B743'
        if acBd.read():
            if (acBd.aircraftExists(aircraftICAOcode)
                    and acBd.aircraftPerformanceFileExists(
                        acBd.getAircraftPerformanceFile(aircraftICAOcode))):

                print(
                    '==================== aircraft found  ==================== '
                    + time.strftime("%c"))
                aircraft = BadaAircraft(
                    ICAOcode=aircraftICAOcode,
                    aircraftFullName=acBd.getAircraftFullName(
                        aircraftICAOcode),
                    badaPerformanceFilePath=acBd.getAircraftPerformanceFile(
                        aircraftICAOcode),
                    atmosphere=atmosphere,
                    earth=earth)
                aircraft.dump()

        print('==================== Airport database ==================== ' +
              time.strftime("%c"))
        airportsDB = AirportsDatabase()
        assert airportsDB.read()
        for airport in airportsDB.getAirports():
            print('============' + airport.getName() + ' ============')
            #print airport
            aircraft = BadaAircraft(
                ICAOcode=aircraftICAOcode,
                aircraftFullName=acBd.getAircraftFullName(aircraftICAOcode),
                badaPerformanceFilePath=acBd.getAircraftPerformanceFile(
                    aircraftICAOcode),
                atmosphere=atmosphere,
                earth=earth)
            print('airport field elevation= {0:.2f} meters'.format(
                airport.getFieldElevationAboveSeaLevelMeters()))
            CAS = aircraft.computeStallSpeedCasKnots()
            print('V stall Calibrated AirSpeed= {0:.2f} knots'.format(CAS))
            TAS = cas2tas(
                cas=CAS,
                altitude=airport.getFieldElevationAboveSeaLevelMeters(),
                temp='std',
                speed_units='kt',
                alt_units='m',
                temp_units=default_temp_units,
            )
            print('V stall True AirSpeed= {0:.2f} knots'.format(TAS))
    def test_graph_with_airport(self):

        print(" ========== AirportsDatabase testing ======= time start= ")
        airportsDb = AirportsDatabase()
        assert (airportsDb.read())

        airportsDb.dumpCountry(Country="France")
        print("number of airports= ", airportsDb.getNumberOfAirports())

        for ap in [
                'Orly', 'paris', 'toulouse', 'marseille', 'roissy', 'blagnac',
                'provence', 'de gaulle'
        ]:
            print("ICAO Code of= ", ap, " ICAO code= ",
                  airportsDb.getICAOCode(ap))

        t1 = time.clock()
        print(" ========== AirportsDatabase testing ======= time start= ", t1)
        CharlesDeGaulleRoissy = airportsDb.getAirportFromICAOCode('LFPG')
        print(CharlesDeGaulleRoissy)
        MarseilleMarignane = airportsDb.getAirportFromICAOCode('LFML')
        print(MarseilleMarignane)

        g0 = Graph()
        for icao in ['LFPO', 'LFMY', 'LFAT', 'LFGJ']:
            airport = airportsDb.getAirportFromICAOCode(icao)
            g0.addVertex(airport)
        print('================ g0 =================')
        for node in g0.getVertices():
            print(node)
        self.assertEqual(g0.getNumberOfVertices(), 4)

        g1 = Graph()
        for icao in ['LFKC', 'LFBO', 'LFKB']:
            airport = airportsDb.getAirportFromICAOCode(icao)
            g1.addVertex(airport)
        self.assertEqual(g1.getNumberOfVertices(), 3)

        print('================ g1 =================')
        for node in g1.getVertices():
            print(node)

        print(' ============== g0.add_graph(g1) ===============')
        g0.addGraph(g1)
        for node in g0.getVertices():
            print(node)

        self.assertEqual(g0.getNumberOfVertices(), 7)

        print('============== g0.create XLS file ===============')

        g0.createXlsxOutputFile()
        g0.createKmlOutputFile()
    def test_main_five(self):
        
        print ( '==================== run-ways test five ====================' )

        airportsDb = AirportsDatabase()
        self.assertTrue (airportsDb.read())
        
        CharlesDeGaulleRoissy = airportsDb.getAirportFromICAOCode('LFPG')
        print ( CharlesDeGaulleRoissy )
        
        runWaysDatabase = RunWayDataBase()
        self.assertTrue( runWaysDatabase.read() )
        
        airportICAOcode = 'LFPG'
        runwayName = "08L"
        runway = runWaysDatabase.getFilteredRunWays(airportICAOcode = airportICAOcode, runwayName  = runwayName)
        print ( runway )
        
        fileName = airportICAOcode + "-" + runwayName
        kmlOutputFile = KmlOutput(fileName=fileName)
        
        kmlOutputFile.write(name = fileName, 
            LongitudeDegrees = runway.getLongitudeDegrees(),
            LatitudeDegrees = runway.getLatitudeDegrees(),
            AltitudeAboveSeaLevelMeters = CharlesDeGaulleRoissy.getAltitudeMeanSeaLevelMeters())


        latitudeDegrees , longitudeDegrees = runway.getGeoPointAtDistanceHeading(runway.getLengthMeters(), runway.getTrueHeadingDegrees())
        
        name = airportICAOcode + "-" + runwayName + "-" + "Runway-End"
        kmlOutputFile.write(name = name, 
            LongitudeDegrees = longitudeDegrees,
            LatitudeDegrees = latitudeDegrees,
            AltitudeAboveSeaLevelMeters = CharlesDeGaulleRoissy.getAltitudeMeanSeaLevelMeters())
        
        ''' GreatCircleRoute: final way-point= turn-pt-189-229.70-degrees - latitude= 48.93 degrees - longitude= 2.75 degrees - altitudeMSL= 500.49 meters '''
        routeLatitudeDegrees = 48.93
        routeLongitudeDegrees = 2.75
        routeGeographicalPoint = GeographicalPoint(routeLatitudeDegrees, routeLongitudeDegrees, CharlesDeGaulleRoissy.getAltitudeMeanSeaLevelMeters())
        
        kmlOutputFile.write(name = "Route-Point", 
            LongitudeDegrees = routeLongitudeDegrees,
            LatitudeDegrees = routeLatitudeDegrees,
            AltitudeAboveSeaLevelMeters = CharlesDeGaulleRoissy.getAltitudeMeanSeaLevelMeters())
        
        shortestDistanceMeters = runway.computeShortestDistanceToRunway(routeGeographicalPoint)
        print ( "Shortest distance = {0} meters".format( shortestDistanceMeters ) )
        
        kmlOutputFile.close()
Exemplo n.º 9
0
    def test_main(self):

        t0 = time.process_time()
        print(' ========== AirportsDatabase testing ======= ')
        airportsDb = AirportsDatabase()
        ret = airportsDb.read()
        self.assertTrue(ret)
        t1 = time.process_time()
        print(t1 - t0)

        print(' ========== AirportsDatabase testing ======= ')

        airportsDb.dumpCountry(Country="France")
        print("number of airports= ", airportsDb.getNumberOfAirports())

        print(' ========== AirportsDatabase testing ======= ')

        for ap in [
                'Orly', 'paris', 'toulouse', 'marseille', 'roissy', 'blagnac',
                'provence', 'de gaulle'
        ]:
            print("ICAO Code of= ", ap, " ICAO code= ",
                  airportsDb.getICAOCode(ap))

        t2 = time.process_time()
        print(t2 - t1)
        print('========== AirportsDatabase testing ======= ')
        CharlesDeGaulleRoissy = airportsDb.getAirportFromICAOCode('LFPG')
        print(CharlesDeGaulleRoissy)

        print(' ========== AirportsDatabase testing ======= ')
        MarseilleMarignane = airportsDb.getAirportFromICAOCode('LFML')
        print(MarseilleMarignane)

        print(' ========== AirportsDatabase testing ======= ')
        Lisbonne = airportsDb.getAirportFromICAOCode('LPPT')
        print(Lisbonne)

        print(' ========== AirportsDatabase testing ======= ')
        JohnFKennedy = airportsDb.getAirportFromICAOCode('KJFK')
        self.assertTrue(isinstance(JohnFKennedy, Airport))
        print(JohnFKennedy)

        print('========== AirportsDatabase testing =======')
        LosAngeles = airportsDb.getAirportFromICAOCode('KLAX')
        print(LosAngeles)

        self.assertTrue(True)
Exemplo n.º 10
0
    def test_main_four(self):

        print " ========== AirportsDatabase testing ======= time start= "
        airportsDb = AirportsDatabase()
        assert (airportsDb.read())
        airportsDb.dumpCountry(Country="France")
        print "number of airports= ", airportsDb.getNumberOfAirports()
        for ap in [
                'Orly', 'paris', 'toulouse', 'marseille', 'roissy', 'blagnac',
                'provence', 'de gaulle'
        ]:
            print "ICAO Code of= ", ap, " ICAO code= ", airportsDb.getICAOCode(
                ap)

        t1 = time.clock()
        print " ========== AirportsDatabase testing ======= time start= ", t1
        CharlesDeGaulleRoissy = airportsDb.getAirportFromICAOCode('LFPG')
        print CharlesDeGaulleRoissy
        MarseilleMarignane = airportsDb.getAirportFromICAOCode('LFML')
        print MarseilleMarignane

        g0 = Graph()
        for icao in ['LFPO', 'LFMY', 'LFAT', 'LFGJ']:
            airport = airportsDb.getAirportFromICAOCode(icao)
            g0.addVertex(airport)
        print '================ g0 ================='
        for node in g0.getVertices():
            print node

        g1 = Graph()
        for icao in ['LFKC', 'LFBO', 'LFKB']:
            airport = airportsDb.getAirportFromICAOCode(icao)
            g1.addVertex(airport)

        print '================ g1 ================='
        for node in g1.getVertices():
            print node

        print ' ============== g0.add_graph(g1) ==============='
        g0.addGraph(g1)
        for node in g0.getVertices():
            print node

        print ' ============== g0.create XLS file ==============='

        g0.createXlsxOutputFile()
        g0.createKmlOutputFile()
Exemplo n.º 11
0
    def buildFixList(self):
        '''
        from the route build a fix list and from the fix list build a way point list
        '''
        self.wayPointsDict = {}
        wayPointsDb = WayPointsDatabase()
        assert (wayPointsDb.read())

        airportsDb = AirportsDatabase()
        assert airportsDb.read()

        runwaysDb = RunWayDataBase()
        assert runwaysDb.read()

        self.createFixList()
        for fix in self.getFix():
            wayPoint = wayPointsDb.getWayPoint(fix)
            if not (wayPoint is None) and isinstance(wayPoint, WayPoint):
                #print wayPoint
                self.wayPointsDict[fix] = wayPoint
            else:
                self.deleteFix(fix)

        self.arrivalRunway = runwaysDb.getFilteredRunWays(
            airportICAOcode=self.arrivalAirportICAOcode,
            runwayName=self.arrivalRunwayName)
        assert (not (self.arrivalRunway is None)
                and isinstance(self.arrivalRunway, RunWay))

        self.arrivalAirport = airportsDb.getAirportFromICAOCode(
            ICAOcode=self.arrivalAirportICAOcode)
        assert (not (self.arrivalAirport is None)
                and isinstance(self.arrivalAirport, Airport))

        self.departureRunway = runwaysDb.getFilteredRunWays(
            airportICAOcode=self.departureAirportICAOcode,
            runwayName=self.departureRunwayName)
        assert (not (self.departureRunway is None)
                and isinstance(self.departureRunway, RunWay))

        self.departureAirport = airportsDb.getAirportFromICAOCode(
            ICAOcode=self.departureAirportICAOcode)
        assert (not (self.departureAirport is None)
                and isinstance(self.departureAirport, Airport))

        #print self.className + ': fix list= ' + str(self.fixList)
        assert (self.allAnglesLessThan90degrees(minIntervalNautics=10.0))
 def test_Vstall(self):
     
     
     t0 = time.clock()
     print "time start= ", t0
     
     atmosphere = Atmosphere()
     earth = Earth()
     print '==================== Stall Speed according to airport field elevation ==================== '+ time.strftime("%c")
     acBd = BadaAircraftDatabase()
     aircraftICAOcode = 'B743'
     if acBd.read():
         if ( acBd.aircraftExists(aircraftICAOcode) 
              and acBd.aircraftPerformanceFileExists(acBd.getAircraftPerformanceFile(aircraftICAOcode))):
             
             print '==================== aircraft found  ==================== '+ time.strftime("%c")
             aircraft = BadaAircraft(ICAOcode = aircraftICAOcode, 
                                     aircraftFullName = acBd.getAircraftFullName(aircraftICAOcode),
                                     badaPerformanceFilePath = acBd.getAircraftPerformanceFile(aircraftICAOcode),
                                     atmosphere = atmosphere,
                                     earth = earth)
             aircraft.dump()
             
     print '==================== Airport database ==================== '+ time.strftime("%c")
     airportsDB = AirportsDatabase()
     assert airportsDB.read()
     for airport in airportsDB.getAirports():
         print '============' + airport.getName() + ' ============'
         #print airport
         aircraft = BadaAircraft(ICAOcode =  aircraftICAOcode, 
                                     aircraftFullName = acBd.getAircraftFullName(aircraftICAOcode),
                                     badaPerformanceFilePath = acBd.getAircraftPerformanceFile(aircraftICAOcode),
                                     atmosphere = atmosphere,
                                     earth = earth)
         print 'airport field elevation= {0:.2f} meters'.format( airport.getFieldElevationAboveSeaLevelMeters())
         CAS = aircraft.computeStallSpeedCasKnots()
         print 'V stall Calibrated AirSpeed= {0:.2f} knots'.format(CAS) 
         TAS = cas2tas(cas = CAS , 
               altitude = airport.getFieldElevationAboveSeaLevelMeters(),
               temp = 'std',
               speed_units = 'kt',
               alt_units = 'm',
               temp_units=default_temp_units,
               )
         print 'V stall True AirSpeed= {0:.2f} knots'.format(TAS) 
    def test_main_four(self):    

        print " ========== AirportsDatabase testing ======= time start= "
        airportsDb = AirportsDatabase()
        assert (airportsDb.read())
        airportsDb.dumpCountry(Country="France")
        print "number of airports= ", airportsDb.getNumberOfAirports()
        for ap in ['Orly', 'paris', 'toulouse', 'marseille' , 'roissy', 'blagnac' , 'provence' , 'de gaulle']:
            print "ICAO Code of= ", ap, " ICAO code= ", airportsDb.getICAOCode(ap)
        
        t1 = time.clock()
        print " ========== AirportsDatabase testing ======= time start= ", t1
        CharlesDeGaulleRoissy = airportsDb.getAirportFromICAOCode('LFPG')
        print CharlesDeGaulleRoissy
        MarseilleMarignane = airportsDb.getAirportFromICAOCode('LFML')
        print MarseilleMarignane
        
        g0 = Graph()
        for icao in [ 'LFPO', 'LFMY', 'LFAT', 'LFGJ']:
            airport = airportsDb.getAirportFromICAOCode(icao)
            g0.addVertex(airport)
        print '================ g0 =================' 
        for node in g0.getVertices():
            print node
        
        g1 = Graph()
        for icao in [ 'LFKC', 'LFBO' , 'LFKB']:
            airport = airportsDb.getAirportFromICAOCode(icao)
            g1.addVertex(airport)     
            
        print '================ g1 =================' 
        for node in g1.getVertices():
            print node
            
        print ' ============== g0.add_graph(g1) ==============='
        g0.addGraph(g1)
        for node in g0.getVertices():
            print node
            
        print ' ============== g0.create XLS file ==============='
    
        g0.createXlsxOutputFile()
        g0.createKmlOutputFile()
    def test_class_one(self):

        print '==================== Main start ==================== '+ time.strftime("%c")

        t0 = time.clock()
        print "time start= {0}".format( t0)
        atmosphere = Atmosphere()
        
        t1 = time.clock()
        print "simulation time= {0} - simulation duration= {1:3.10f} seconds".format(t1 , (t1-t0))
    
        print '==================== load airports ==================== '+ time.strftime("%c")
        airportsDB = AirportsDatabase()
        assert airportsDB.read()
        print '==================== air density at airports field elevation ==================== '+ time.strftime("%c")
    
        for airport in airportsDB.getAirports():
            print '=======================' + airport.getName() + '===================='
            print 'field elevation= ' + str(airport.getFieldElevationAboveSeaLevelMeters()) + ' meters'
            altitudeMeters = airport.getFieldElevationAboveSeaLevelMeters()
            print 'air density= ' + str(atmosphere.getAirDensityKilogramsPerCubicMeters(altitudeMeters)) + ' kg / meters ^^ 3'
    def test_main_five(self):    

        airportsDb = AirportsDatabase()
        assert (airportsDb.read())
        
        print ' ============== g3 performance ==============='
        t0 = time.clock()
        g3 = Graph()
        index = 0
        for airport in airportsDb.getAirports():
            print airport
            g3.addVertex(airport)
            index += 1
        t1 = time.clock()
        print 'number of airports= {0} - duration= {1} seconds'.format(index, t1-t0)
     
        airport = airportsDb.getAirportFromICAOCode('LFPG')
        t2= time.clock()
        g4 = Graph()
        for i in range (0,10000):
            g4.addVertex(airport)
        t3 = time.clock()
        print 'number of addVertex = {0} - duration= {1:.8f} seconds'.format(i , t3-t2)
Exemplo n.º 16
0
    def test_DescentGlideSlope_Two(self):

        atmosphere = Atmosphere()
        earth = Earth()
        print(
            '==================== three degrees Descent Slope Start  ==================== '
            + time.strftime("%c"))

        acBd = BadaAircraftDatabase()
        aircraftICAOcode = 'A320'
        aircraft = None
        if acBd.read():
            if (acBd.aircraftExists(aircraftICAOcode)
                    and acBd.aircraftPerformanceFileExists(aircraftICAOcode)):

                print(
                    '==================== aircraft found  ==================== '
                    + time.strftime("%c"))

                aircraft = BadaAircraft(
                    ICAOcode=aircraftICAOcode,
                    aircraftFullName=acBd.getAircraftFullName(
                        aircraftICAOcode),
                    badaPerformanceFilePath=acBd.getAircraftPerformanceFile(
                        aircraftICAOcode),
                    atmosphere=atmosphere,
                    earth=earth)
                aircraft.dump()

        assert not (aircraft is None)
        print('==================== runways database ==================== ' +
              time.strftime("%c"))
        runWaysDatabase = RunWayDataBase()
        assert runWaysDatabase.read()

        runway = runWaysDatabase.getFilteredRunWays(airportICAOcode='LFPG',
                                                    runwayName='08L')
        print(runway)

        print("=========== airports  =========== " + time.strftime("%c"))
        airportsDB = AirportsDatabase()
        assert (airportsDB.read())

        CharlesDeGaulle = airportsDB.getAirportFromICAOCode('LFPG')
        print(CharlesDeGaulle)

        print("=========== descent glide slope  =========== " +
              time.strftime("%c"))
        threeDegreesGlideSlope = DescentGlideSlope(
            runway=runway, aircraft=aircraft, arrivalAirport=CharlesDeGaulle)

        threeDegreesGlideSlope.buildSimulatedGlideSlope(
            descentGlideSlopeSizeNautics=5.0)

        print("=========== DescentGlideSlope  =========== " +
              time.strftime("%c"))
        for node in threeDegreesGlideSlope.getVertices():
            print(node)

        print("=========== DescentGlideSlope length =========== " +
              time.strftime("%c"))
        print("get number of vertices= {0}".format(
            threeDegreesGlideSlope.getNumberOfVertices()))
        print("get number of edges= {0}".format(
            threeDegreesGlideSlope.getNumberOfEdges()))
        print('Glide Slope overall length= {0} meters'.format(
            threeDegreesGlideSlope.computeLengthMeters()))

        threeDegreesGlideSlope.createKmlOutputFile()
        threeDegreesGlideSlope.createXlsxOutputFile()
        print(
            '==================== three degrees Descent Slope End  ==================== '
            + time.strftime("%c"))
    def test_One(self):

        print('=========== main start ==================')
        aircraftICAOcode = 'A320'

        atmosphere = Atmosphere()
        assert (not (atmosphere is None))

        earth = Earth()
        assert (not (earth is None))

        acBd = BadaAircraftDatabase()
        assert acBd.read()

        if (acBd.aircraftExists(aircraftICAOcode)
                and acBd.aircraftPerformanceFileExists(aircraftICAOcode)):

            aircraft = BadaAircraft(
                ICAOcode=aircraftICAOcode,
                aircraftFullName=acBd.getAircraftFullName(aircraftICAOcode),
                badaPerformanceFilePath=acBd.getAircraftPerformanceFile(
                    aircraftICAOcode),
                atmosphere=atmosphere,
                earth=earth)
            aircraft.dump()
        else:
            raise ValueError(': aircraft not found= ' + aircraftICAOcode)

        assert not (aircraft is None)

        print('================ load airports =================')
        airportsDB = AirportsDatabase()
        assert (airportsDB.read())

        adepIcaoCode = 'LFML'

        departureAirport = airportsDB.getAirportFromICAOCode(adepIcaoCode)
        print(': departure airport= ' + str(departureAirport))
        assert not (departureAirport is None)

        print('================ load runways =================')

        runWaysDatabase = RunWayDataBase()
        assert (runWaysDatabase.read())

        print('====================  take off run-way ==================== ')
        departureRunway = runWaysDatabase.getFilteredRunWays(adepIcaoCode)
        print(
            '=========== minimum and maximum aircraft mass ==================')

        minMassKg = aircraft.getMinimumMassKilograms()
        print('aircraft minimum mass: ' + str(minMassKg) + ' kilograms')

        maxMassKg = aircraft.getMaximumMassKilograms()
        print('aircraft maximum mass: ' + str(maxMassKg) + ' kilograms')

        deltaMass = maxMassKg - minMassKg
        massKg = 39000.0
        while (massKg < maxMassKg):

            massKg += 1000.0
            print(
                '==================== set aircraft reference mass ==================== '
            )
            aircraft = BadaAircraft(
                ICAOcode=aircraftICAOcode,
                aircraftFullName=acBd.getAircraftFullName(aircraftICAOcode),
                badaPerformanceFilePath=acBd.getAircraftPerformanceFile(
                    aircraftICAOcode),
                atmosphere=atmosphere,
                earth=earth)

            aircraft.setTargetCruiseFlightLevel(
                310, departureAirport.getFieldElevationAboveSeaLevelMeters())

            print(
                '==================== aircraft reference mass ==================== '
            )
            print('aircraft reference mass= ' + str(massKg) + ' Kilograms')

            aircraft.setAircraftMassKilograms(massKg)
            print(
                '==================== begin of ground run ==================== '
            )
            groundRunLeg = GroundRunLeg(runway=departureRunway,
                                        aircraft=aircraft,
                                        airport=departureAirport)

            groundRunLeg.buildDepartureGroundRun(
                deltaTimeSeconds=0.1,
                elapsedTimeSeconds=0.0,
                distanceStillToFlyMeters=500000.0,
                distanceToLastFixMeters=500000.0)

            groundRunLeg.computeLengthMeters()
            #groundRunLeg.createXlsxOutputFile()

            print(
                '==================== end of ground run ==================== ')
            initialWayPoint = groundRunLeg.getLastVertex().getWeight()

            print(
                '==================== dump aircraft speed profile ==================== '
            )
            aircraft.createStateVectorOutputFile(aircraftICAOcode + "-Mass-" +
                                                 str(massKg))
            print('=========== main end ==================')
Exemplo n.º 18
0
    print('=========== main start ==================')
    aircraftIcaoCode = 'A320'

    atmosphere = Atmosphere()
    assert (not (atmosphere is None))

    earth = Earth()
    assert (not (earth is None))

    acBd = BadaAircraftDatabase()
    assert acBd.read()

    print('==================== load airports ==================== ' +
          time.strftime("%c"))
    airportsDB = AirportsDatabase()
    assert airportsDB.read()

    departureAirport = airportsDB.getAirportFromICAOCode('LFPG')
    assert not (departureAirport is None)
    print(departureAirport)

    arrivalAirportIcaoCode = 'LFML'
    arrivalAirport = airportsDB.getAirportFromICAOCode(arrivalAirportIcaoCode)
    assert not (arrivalAirport is None)
    print(arrivalAirport)

    runwaysDb = RunWayDataBase()
    assert runwaysDb.read()

    arrivalRunway = runwaysDb.getFilteredRunWays(arrivalAirportIcaoCode,
                                                 'Landing')
 def test_DescentGlideSlope(self):
 
     atmosphere = Atmosphere()
     earth = Earth()
     print '==================== three degrees Descent Slope Start  ==================== '+ time.strftime("%c")
 
     acBd = BadaAircraftDatabase()
     aircraftICAOcode = 'A320'
     if acBd.read():
         if ( acBd.aircraftExists(aircraftICAOcode) 
              and acBd.aircraftPerformanceFileExists(aircraftICAOcode)):
             
             print '==================== aircraft found  ==================== '+ time.strftime("%c")
 
             aircraft = BadaAircraft(ICAOcode = aircraftICAOcode, 
                                     aircraftFullName = acBd.getAircraftFullName(aircraftICAOcode),
                                     badaPerformanceFilePath = acBd.getAircraftPerformanceFile(aircraftICAOcode),
                                     atmosphere = atmosphere,
                                     earth = earth)
             aircraft.dump()
  
     assert not (aircraft is None)
     print '==================== runways database ==================== '+ time.strftime("%c")
     runWaysDatabase = RunWayDataBase()
     assert runWaysDatabase.read()
     
     runway = runWaysDatabase.getFilteredRunWays(airportICAOcode = 'LFML', runwayName = '')
     print runway
   
     print "=========== arrival airport  =========== " + time.strftime("%c")
     airportsDB = AirportsDatabase()
     assert (airportsDB.read())
     
     MarseilleMarignane = airportsDB.getAirportFromICAOCode('LFML')
     print MarseilleMarignane
     
     print "=========== descent glide slope  =========== " + time.strftime("%c")
     threeDegreesGlideSlope = DescentGlideSlope(runway = runway, 
                                                aircraft = aircraft, 
                                                arrivalAirport = MarseilleMarignane )
     
     initialWayPoint = WayPoint(Name = 'startOfDescentGlideSlope',
                                )
     print "=========== DescentGlideSlope build the glide slope  =========== " + time.strftime("%c")
 #     threeDegreesGlideSlope.buildGlideSlope(deltaTimeSeconds = 0.1,
 #                         elapsedTimeSeconds = 0.0, 
 #                         initialWayPoint = None, 
 #                         flownDistanceMeters = 0.0, 
 #                         distanceStillToFlyMeters = 100000.0,
 #                         distanceToLastFixMeters = 100000.0)
 
     threeDegreesGlideSlope.buildSimulatedGlideSlope(descentGlideSlopeSizeNautics = 5.0)
     
     print "=========== DescentGlideSlope  =========== " + time.strftime("%c")
     for node in threeDegreesGlideSlope.getVertices():
         print node
     
     print "=========== DescentGlideSlope length =========== " + time.strftime("%c")
     print "get number of vertices= {0}".format( threeDegreesGlideSlope.getNumberOfVertices() )
     print "get number of edges= {0}".format ( threeDegreesGlideSlope.getNumberOfEdges() )
     print 'Glide Slope overall length= {0} meters'.format( threeDegreesGlideSlope.computeLengthMeters() )
     
     threeDegreesGlideSlope.createKmlOutputFile()
     threeDegreesGlideSlope.createXlsxOutputFile()
     print '==================== three degrees Descent Slope End  ==================== '+ time.strftime("%c")
Exemplo n.º 20
0
    aircraftICAOcode = 'A320'
    assert acBd.read()
    assert acBd.aircraftExists(aircraftICAOcode)
    if acBd.aircraftPerformanceFileExists(
            acBd.getAircraftPerformanceFile(aircraftICAOcode)):

        print('==================== aircraft found  ==================== ')
        acA320 = BadaAircraft(
            aircraftICAOcode,
            acBd.getAircraftPerformanceFile(aircraftICAOcode), atmosphere,
            earth)
        acA320.dump()

    print('==================== read Airports Database ==================== ')
    airportsDb = AirportsDatabase()
    assert (airportsDb.read())

    print('====================  find the run-ways ==================== ')
    runWaysDB = RunWayDataBase()
    if runWaysDB.read():
        print('runways DB correctly read')
    else:
        raise ValueError('runways not read correctly')

    print('====================  find the run-ways ==================== ')
    for arrivalRunway in runWaysDB.getRunWays():

        print('====================  run-way ==================== ')
        print(arrivalRunway)

        airportIcaoCode = arrivalRunway.getAirportICAOcode()
    def test_TurnLeg(self):

        print '==================== Turn Leg ==================== '+ time.strftime("%c")
        atmosphere = Atmosphere()
        earth = Earth()
        
        acBd = BadaAircraftDatabase()
        aircraftICAOcode = 'A320'
        assert acBd.read()
        assert acBd.aircraftExists(aircraftICAOcode) 
        assert acBd.aircraftPerformanceFileExists(aircraftICAOcode)
                
        print '==================== aircraft found  ==================== '+ time.strftime("%c")
        aircraft = BadaAircraft(ICAOcode = aircraftICAOcode, 
                                aircraftFullName = acBd.getAircraftFullName(aircraftICAOcode),
                                badaPerformanceFilePath = acBd.getAircraftPerformanceFile(aircraftICAOcode),
                                atmosphere = atmosphere,
                                earth = earth)
        aircraft.dump()
                
        print '==================== Get Airport ==================== '+ time.strftime("%c")
        airportsDB = AirportsDatabase()
        assert airportsDB.read()
        
        print '==================== Get Arrival Airport ==================== '+ time.strftime("%c")
        Lisbonne = airportsDB.getAirportFromICAOCode('LPPT')
        print Lisbonne
        
        print '====================  find the run-ways ==================== '+ time.strftime("%c")
        runWaysDatabase = RunWayDataBase()
        if runWaysDatabase.read():
            print 'runways DB correctly read'
            
        print '====================  take off run-way ==================== '+ time.strftime("%c")
        arrivalRunway = runWaysDatabase.getFilteredRunWays(
                                                           airportICAOcode = 'LPPT', 
                                                           runwayName = '')
        print arrivalRunway
        
        print '==================== Ground run ==================== '+ time.strftime("%c")
        groundRun = GroundRunLeg(runway = arrivalRunway, 
                                 aircraft = aircraft,
                                 airport = Lisbonne)
        
        touchDownWayPoint = groundRun.computeTouchDownWayPoint()
        print touchDownWayPoint
        groundRun.buildDepartureGroundRun(deltaTimeSeconds = 1.0,
                                          elapsedTimeSeconds = 0.0,
                                          distanceStillToFlyMeters = 0.0,
                                          distanceToLastFixMeters = 0.0)
        print '==================== Climb Ramp ==================== '+ time.strftime("%c")
        
        initialWayPoint = groundRun.getLastVertex().getWeight()
    
        descentGlideSlope = DescentGlideSlope( runway   = arrivalRunway,
                                                aircraft = aircraft,
                                                arrivalAirport = Lisbonne ,
                                                descentGlideSlopeDegrees = 3.0)
        ''' if there is a fix nearer to 5 nautics of the touch-down then limit size of simulated glide slope '''
    
        descentGlideSlope.buildSimulatedGlideSlope(descentGlideSlopeSizeNautics = 5.0)
        descentGlideSlope.createKmlOutputFile()
        
        firstGlideSlopeWayPoint = descentGlideSlope.getVertex(v=0).getWeight()
    
        print '==================== Climb Ramp ==================== '+ time.strftime("%c")
        initialWayPoint = groundRun.getLastVertex().getWeight()
    
        print ' ================== turn leg end =============== '
        wayPointsDb = WayPointsDatabase()
        assert (wayPointsDb.read())
        Exona = wayPointsDb.getWayPoint('EXONA')
        Rosal = wayPointsDb.getWayPoint('ROSAL')
    
        print Rosal.getBearingDegreesTo(Exona) 
        initialHeadingDegrees = arrivalRunway.getTrueHeadingDegrees()
        
        lastTurnLeg = TurnLeg( initialWayPoint = firstGlideSlopeWayPoint, 
                               finalWayPoint = Exona,
                               initialHeadingDegrees = initialHeadingDegrees, 
                               aircraft = aircraft,
                               reverse = True)
        deltaTimeSeconds = 1.0
        lastTurnLeg.buildNewSimulatedArrivalTurnLeg(deltaTimeSeconds = deltaTimeSeconds,
                                                     elapsedTimeSeconds = 0.0,
                                                     distanceStillToFlyMeters = 0.0,
                                                     simulatedAltitudeSeaLevelMeters = firstGlideSlopeWayPoint.getAltitudeMeanSeaLevelMeters(),
                                                     flightPathAngleDegrees = 3.0)
        lastTurnLeg.createKmlOutputFile()
        descentGlideSlope.addGraph(lastTurnLeg)
        #descentGlideSlope.createXlsxOutputFile()
        descentGlideSlope.createKmlOutputFile()
        
        print ' ================== turn leg end =============== '
 def test_ClimbRamp(self):
     
     atmosphere = Atmosphere()
     earth = Earth()
     
     print '==================== Three Degrees climb slope ==================== '+ time.strftime("%c")
     acBd = BadaAircraftDatabase()
     aircraftICAOcode = 'A320'
     if acBd.read():
         if ( acBd.aircraftExists(aircraftICAOcode) 
              and acBd.aircraftPerformanceFileExists(aircraftICAOcode)):
             
             print '==================== aircraft found  ==================== '+ time.strftime("%c")
 
             aircraft = BadaAircraft(
                                 ICAOcode = aircraftICAOcode,
                                 aircraftFullName = acBd.getAircraftFullName(aircraftICAOcode),
                                 badaPerformanceFilePath = acBd.getAircraftPerformanceFile(aircraftICAOcode),
                                 atmosphere = atmosphere,
                                 earth = earth)
             aircraft.dump()
     
     assert not(aircraft is None)
     
     print '==================== get Charles Gaulle airport ==================== '+ time.strftime("%c")
     airportsDB = AirportsDatabase()
     assert(airportsDB.read())
     CharlesDeGaulle = airportsDB.getAirportFromICAOCode('LFPG')
     print CharlesDeGaulle
     assert not(aircraft is None)
     
     aircraft.setTargetCruiseFlightLevel(RequestedFlightLevel = 390, 
                                         departureAirportAltitudeMSLmeters = CharlesDeGaulle.getAltitudeMeanSeaLevelMeters())
 
  
     
     print '==================== Three Degrees climb slope==================== '+ time.strftime("%c")
     runWaysDatabase = RunWayDataBase()
     if runWaysDatabase.read():
         print 'runways DB correctly read'
     
     runway = runWaysDatabase.getFilteredRunWays('LFPG')
     print runway
         
     print '==================== Ground Run ==================== '+ time.strftime("%c")
     groundRun = GroundRunLeg(runway=runway, 
                              aircraft=aircraft,
                              airport=CharlesDeGaulle)
     groundRun.buildDepartureGroundRun(deltaTimeSeconds = 0.1,
                                 elapsedTimeSeconds = 0.0,
                                 distanceStillToFlyMeters = 100000.0,
                                 distanceToLastFixMeters = 100000.0)
     print '==================== Three Degrees climb slope==================== '+ time.strftime("%c")
 
     initialVertex = groundRun.getVertex(groundRun.getNumberOfVertices()-1)
     initialWayPoint = initialVertex.getWeight()
 
     climbRamp = ClimbRamp(initialWayPoint = initialWayPoint,
                            runway=runway, 
                            aircraft=aircraft, 
                            departureAirport=CharlesDeGaulle)
     
     climbRamp.buildClimbRamp(deltaTimeSeconds = 0.1,
                        elapsedTimeSeconds = 0.0, 
                        distanceStillToFlyMeters = 100000.0, 
                        distanceToLastFixMeters = 100000.0,
                        climbRampLengthNautics = 5.0 )
     groundRun.addGraph(climbRamp)
     
     groundRun.createKmlOutputFile()
     print "=========== ThreeDegreesGlideSlope end =========== " + time.strftime("%c")
      

if __name__ == '__main__':

#     import sys
#     temp = sys.stdout #store original stdout object for later
#     sys.stdout = open('log.txt','w') #redirect all prints to this log file

    wayPointsDb = WayPointsDatabase()
    assert wayPointsDb.read()
            
    t0 = time.clock()
    print ( ' ========== Airports Direct Route testing ======= ' )
        
    airportsDb = AirportsDatabase()
    assert  airportsDb.read()
    t1 = time.clock()
    print ( ' time to read airports database= {0:.2f} seconds'.format(t1-t0) )
        
    t2 = time.clock()
    runwaysDb = RunWayDataBase()
    assert runwaysDb.read()
    print ( ' time to read run-way database= {0:.2f} seconds'.format(t2-t1))
        
    print ( ' ========== Airports Direct Route testing ======= ' )
    departureCountry = 'Japan'
    departureCountry = 'United Kingdom'
    departureCountry = 'France'
    departureCountry = 'United States'
    arrivalCountry = 'Canada'
    arrivalCountry = 'France' 
    def buildFixList(self):
        '''
        from the route build a fix list and from the fix list build a way point list
        '''
        
        self.wayPointsDict = {}
        wayPointsDb = WayPointsDatabase()
        assert (wayPointsDb.read())
        
        airportsDb = AirportsDatabase()
        assert airportsDb.read()
        
        runwaysDb = RunWayDataBase()
        assert runwaysDb.read()
        
        #print self.className + ': ================ get Fix List ================='
        self.fixList = []
        index = 0
        for fix in self.strRoute.split('-'):
            fix = str(fix).strip()
            ''' first item is the Departure Airport '''
            if str(fix).startswith('ADEP'):
                ''' fix is the departure airport '''
                if index == 0:
                    ''' ADEP is the first fix of the route '''
                    if len(str(fix).split('/')) >= 2:
                        self.departureAirportIcaoCode = str(fix).split('/')[1]
                        self.departureAirport = airportsDb.getAirportFromICAOCode(ICAOcode = self.departureAirportIcaoCode)
                        print self.className + ': departure airport= {0}'.format( self.departureAirport)
    
                    self.departureRunwayName = ''
                    if len(str(fix).split('/')) >= 3:
                        self.departureRunwayName = str(fix).split('/')[2]
                        
                    if not(self.departureAirport is None):
                        self.departureRunway = runwaysDb.getFilteredRunWays(airportICAOcode = self.departureAirportIcaoCode, 
                                                                            runwayName = self.departureRunwayName)
                        print self.className + ': departure runway= {0}'.format(self.departureRunway)
                else:
                    raise ValueError (self.className + ': ADEP must be the first fix in the route!!!')

                
            elif  str(fix).startswith('ADES'):
                if index == (len(self.strRoute.split('-'))-1):
                    ''' ADES is the last fix of the route '''
                    if len(str(fix).split('/')) >= 2:
                        self.arrivalAirportIcaoCode = str(fix).split('/')[1]
                        self.arrivalAirport = airportsDb.getAirportFromICAOCode(ICAOcode = self.arrivalAirportIcaoCode)
                        print self.className + ': arrival airport= {0}'.format( self.arrivalAirport)
                    
                    self.arrivalRunwayName = ''
                    if len(str(fix).split('/')) >= 3:
                        self.arrivalRunwayName = str(fix).split('/')[2]
                    
                    if not(self.arrivalAirport is None):
                        self.arrivalRunway =  runwaysDb.getFilteredRunWays(airportICAOcode = self.arrivalAirportIcaoCode, 
                                                                           runwayName = self.arrivalRunwayName)
                        print self.className + ': arrival runway= {0}'.format(self.arrivalRunway)
                else:
                    raise ValueError (self.classeName + ': ADES must be the last fix of the route!!!' )

            else:
                ''' do not take the 1st one (ADEP) and the last one (ADES) '''
                constraintFound, levelConstraint, speedConstraint = analyseConstraint(index, fix)
                #print self.className + ': constraint found= {0}'.format(constraintFound)
                if constraintFound == True:
                    constraint = {}
                    constraint['fixIndex'] = index
                    constraint['level'] = levelConstraint
                    constraint['speed'] = speedConstraint
                    self.constraintsList.append(constraint)
                else:
                    self.fixList.append(fix)
                    wayPoint = wayPointsDb.getWayPoint(fix)
                    if not(wayPoint is None):
                        #print wayPoint
                        self.wayPointsDict[fix] = wayPoint
                    else:
                        ''' do not insert way point names when there is no known latitude - longitude '''
                        self.fixList.pop()
                
            index += 1             
        #print self.className + ': fix list= ' + str(self.fixList)
        assert (self.allAnglesLessThan90degrees(minIntervalNautics = 10.0))
    def test_One(self):  
        
        atmosphere = Atmosphere()
        earth = Earth()
        
        print ( '==================== Aircraft ==================== '+ time.strftime("%c") )
        acBd = BadaAircraftDatabase()
        aircraftICAOcode = 'A320'
        if acBd.read():
            if ( acBd.aircraftExists(aircraftICAOcode) 
                 and acBd.aircraftPerformanceFileExists(aircraftICAOcode)):
                
                print ( '==================== aircraft found  ==================== '+ time.strftime("%c") )
                aircraft = BadaAircraft(ICAOcode = aircraftICAOcode, 
                                            aircraftFullName = acBd.getAircraftFullName(aircraftICAOcode),
                                            badaPerformanceFilePath = acBd.getAircraftPerformanceFile(aircraftICAOcode),
                                            atmosphere = atmosphere,
                                            earth = earth)
                print ( aircraft )
                assert not(aircraft is None)
            
        print ( '==================== departure airport ==================== '+ time.strftime("%c") )
        
        airportsDB = AirportsDatabase()
        assert (airportsDB.read())
        
        CharlesDeGaulle = airportsDB.getAirportFromICAOCode('LFPG')
        print ( CharlesDeGaulle )
        
        print ( '==================== arrival airport ==================== '+ time.strftime("%c") )

        MarseilleMarignane = airportsDB.getAirportFromICAOCode('LFML')
        print ( MarseilleMarignane )
            
        print ( '==================== Great Circle ==================== '+ time.strftime("%c") )
    
        aircraft.setCurrentAltitudeSeaLevelMeters( 
                                         elapsedTimeSeconds = 0.0 , 
                                         altitudeMeanSeaLevelMeters = 0.0,
                                         lastAltitudeMeanSeaLevelMeters = 0.0,
                                         targetCruiseAltitudeMslMeters = 10000.0)
        
        aircraft.initStateVector( 
                        elapsedTimeSeconds = 0.0,
                        trueAirSpeedMetersSecond = 70.0,
                        airportFieldElevationAboveSeaLevelMeters = 152.0)
        
        aircraft.setTargetCruiseFlightLevel(RequestedFlightLevel = 310, 
                                   departureAirportAltitudeMSLmeters = 152.0)
        
        print ( '==================== runways database ==================== '+ time.strftime("%c") )
        runWaysDatabase = RunWayDataBase()
        assert runWaysDatabase.read()
        arrivalRunway = runWaysDatabase.getFilteredRunWays(airportICAOcode = 'LFML', runwayName = '')

        print ( '==================== Compute touch down ==================== '+ time.strftime("%c") )

        arrivalGroundRun = GroundRunLeg( runway   = arrivalRunway,
                                         aircraft = aircraft,
                                         airport  = MarseilleMarignane )
        touchDownWayPoint = arrivalGroundRun.computeTouchDownWayPoint()
        aircraft.setArrivalRunwayTouchDownWayPoint(touchDownWayPoint)

        print ( "=========== simulated descent glide slope  =========== " + time.strftime("%c") )
 
        threeDegreesGlideSlope = DescentGlideSlope(runway = arrivalRunway, 
                                                   aircraft = aircraft, 
                                                   arrivalAirport = MarseilleMarignane )
        threeDegreesGlideSlope.buildSimulatedGlideSlope(descentGlideSlopeSizeNautics = 5.0)
        approachWayPoint = threeDegreesGlideSlope.getLastVertex().getWeight()
        
        aircraft.setTargetApproachWayPoint(approachWayPoint)
        
        print ( '==================== Great Circle ==================== '+ time.strftime("%c") )

        greatCircle = GreatCircleRoute(initialWayPoint = CharlesDeGaulle, 
                                           finalWayPoint = approachWayPoint,
                                           aircraft = aircraft)
        
        distanceStillToFlyMeters = CharlesDeGaulle.getDistanceMetersTo(approachWayPoint)
        greatCircle.computeGreatCircle(deltaTimeSeconds = 1.0,
                           elapsedTimeSeconds = 0.0,
                           distanceStillToFlyMeters = distanceStillToFlyMeters,
                           distanceToLastFixMeters = distanceStillToFlyMeters)
        print ( 'main great circle length= ' + str(greatCircle.computeLengthMeters()) + ' meters' )
                        
        greatCircle.createKmlOutputFile()
        greatCircle.createXlsxOutputFile()
 acBd = BadaAircraftDatabase()
 aircraftICAOcode = 'A320'
 if acBd.read():
     if ( acBd.aircraftExists(aircraftICAOcode) 
          and acBd.aircraftPerformanceFileExists(acBd.getAircraftPerformanceFile(aircraftICAOcode))):
         
         print '==================== aircraft found  ==================== '+ time.strftime("%c")
         aircraft = BadaAircraft(aircraftICAOcode, 
                               acBd.getAircraftPerformanceFile(aircraftICAOcode),
                               atmosphere,
                               earth)
         aircraft.dump()
 
 print '==================== Ground run ==================== '+ time.strftime("%c")
 airportsDB = AirportsDatabase()
 assert airportsDB.read()
 
 CharlesDeGaulle = airportsDB.getAirportFromICAOCode('LFPG')
 print CharlesDeGaulle
 
 print '==================== Ground run - read runway database ==================== '+ time.strftime("%c")
 runWaysDatabase = RunWayDataBase()
 assert runWaysDatabase.read()
 
 print '==================== Ground run ==================== '+ time.strftime("%c")
 runway = runWaysDatabase.getFilteredRunWays('LFPG', aircraft.WakeTurbulenceCategory)
 print runway
 
 print '==================== departure Ground run ==================== '+ time.strftime("%c")
 groundRun = GroundRunLeg(runway=runway, 
                          aircraft=aircraft,
    print('====================  find the run-ways ==================== ' +
          time.strftime("%c"))
    runWaysDb = RunWayDataBase()
    assert (runWaysDb.read())

    arrivalAirportICAOcode = 'LFPO'
    arrivalRunway = runWaysDb.getFilteredRunWays(
        airportICAOcode=arrivalAirportICAOcode,
        TakeOffLanding='Landing',
        aircraftWakeTurbulence=aircraft.getWakeTurbulenceCategory())

    print('==================== read Airports Database ==================== ' +
          time.strftime("%c"))
    airportsDB = AirportsDatabase()
    assert (airportsDB.read())

    print('========== departure is LONDON ================')
    departureAirport = airportsDB.getAirportFromICAOCode('EGLL')
    assert not (departureAirport is None)

    print('========== ' + str(arrivalRunway) + ' =================')
    airportIcaoCode = arrivalRunway.getAirportICAOcode()
    arrivalAirport = airportsDB.getAirportFromICAOCode(airportIcaoCode)
    print('arrival airport= {0}'.format(arrivalAirport))

    aircraft.setArrivalAirportElevationMeters(
        arrivalAirport.fieldElevationAboveSeaLevelMeters)

    print(
        '=========== add final turn, descent and ground run ==================='
Exemplo n.º 28
0
    def test_TurnLeg(self):

        print '==================== Turn Leg ==================== ' + time.strftime(
            "%c")
        atmosphere = Atmosphere()
        earth = Earth()

        acBd = BadaAircraftDatabase()
        aircraftICAOcode = 'A320'
        assert acBd.read()
        assert acBd.aircraftExists(aircraftICAOcode)
        assert acBd.aircraftPerformanceFileExists(aircraftICAOcode)

        print '==================== aircraft found  ==================== ' + time.strftime(
            "%c")
        aircraft = BadaAircraft(
            ICAOcode=aircraftICAOcode,
            aircraftFullName=acBd.getAircraftFullName(aircraftICAOcode),
            badaPerformanceFilePath=acBd.getAircraftPerformanceFile(
                aircraftICAOcode),
            atmosphere=atmosphere,
            earth=earth)
        aircraft.dump()

        print '==================== Get Airport ==================== ' + time.strftime(
            "%c")
        airportsDB = AirportsDatabase()
        assert airportsDB.read()

        print '==================== Get Arrival Airport ==================== ' + time.strftime(
            "%c")
        Lisbonne = airportsDB.getAirportFromICAOCode('LPPT')
        print Lisbonne

        print '====================  find the run-ways ==================== ' + time.strftime(
            "%c")
        runWaysDatabase = RunWayDataBase()
        if runWaysDatabase.read():
            print 'runways DB correctly read'

        print '====================  take off run-way ==================== ' + time.strftime(
            "%c")
        arrivalRunway = runWaysDatabase.getFilteredRunWays(
            airportICAOcode='LPPT', runwayName='')
        print arrivalRunway

        print '==================== Ground run ==================== ' + time.strftime(
            "%c")
        groundRun = GroundRunLeg(runway=arrivalRunway,
                                 aircraft=aircraft,
                                 airport=Lisbonne)

        touchDownWayPoint = groundRun.computeTouchDownWayPoint()
        print touchDownWayPoint
        groundRun.buildDepartureGroundRun(deltaTimeSeconds=1.0,
                                          elapsedTimeSeconds=0.0,
                                          distanceStillToFlyMeters=0.0,
                                          distanceToLastFixMeters=0.0)
        print '==================== Climb Ramp ==================== ' + time.strftime(
            "%c")

        initialWayPoint = groundRun.getLastVertex().getWeight()

        descentGlideSlope = DescentGlideSlope(runway=arrivalRunway,
                                              aircraft=aircraft,
                                              arrivalAirport=Lisbonne,
                                              descentGlideSlopeDegrees=3.0)
        ''' if there is a fix nearer to 5 nautics of the touch-down then limit size of simulated glide slope '''

        descentGlideSlope.buildSimulatedGlideSlope(
            descentGlideSlopeSizeNautics=5.0)
        descentGlideSlope.createKmlOutputFile()

        firstGlideSlopeWayPoint = descentGlideSlope.getVertex(v=0).getWeight()

        print '==================== Climb Ramp ==================== ' + time.strftime(
            "%c")
        initialWayPoint = groundRun.getLastVertex().getWeight()

        print ' ================== turn leg end =============== '
        wayPointsDb = WayPointsDatabase()
        assert (wayPointsDb.read())
        Exona = wayPointsDb.getWayPoint('EXONA')
        Rosal = wayPointsDb.getWayPoint('ROSAL')

        print Rosal.getBearingDegreesTo(Exona)
        initialHeadingDegrees = arrivalRunway.getTrueHeadingDegrees()

        lastTurnLeg = TurnLeg(initialWayPoint=firstGlideSlopeWayPoint,
                              finalWayPoint=Exona,
                              initialHeadingDegrees=initialHeadingDegrees,
                              aircraft=aircraft,
                              reverse=True)
        deltaTimeSeconds = 1.0
        lastTurnLeg.buildNewSimulatedArrivalTurnLeg(
            deltaTimeSeconds=deltaTimeSeconds,
            elapsedTimeSeconds=0.0,
            distanceStillToFlyMeters=0.0,
            simulatedAltitudeSeaLevelMeters=firstGlideSlopeWayPoint.
            getAltitudeMeanSeaLevelMeters(),
            flightPathAngleDegrees=3.0)
        lastTurnLeg.createKmlOutputFile()
        descentGlideSlope.addGraph(lastTurnLeg)
        #descentGlideSlope.createXlsxOutputFile()
        descentGlideSlope.createKmlOutputFile()

        print ' ================== turn leg end =============== '
    def test_main(self):

        worldCitiesDatabase = WorldCitiesDatabase()
        self.assertTrue(worldCitiesDatabase.read())

        airportsDb = AirportsDatabase()
        self.assertTrue(airportsDb.read())

        CharlesDeGaulleRoissy = airportsDb.getAirportFromICAOCode('LFPG')
        print(CharlesDeGaulleRoissy)

        BerlinTegel = airportsDb.getAirportFromICAOCode('EDDT')
        print(BerlinTegel)

        distanceMeters = CharlesDeGaulleRoissy.getDistanceMetersTo(BerlinTegel)
        print(
            "distance from CDG to Berlin Tegel = {0:.2f} meters - {1:.2f} nautics"
            .format(distanceMeters, distanceMeters * Meter2NauticalMiles))

        NumberOfPoints = int((distanceMeters * Meter2NauticalMiles) / 10.)
        print("Number of points = {0}".format(NumberOfPoints))

        kmlOutputFile = KmlOutput(fileName="CDG-Berlin-Tegel")
        kmlOutputFile.write(
            name=CharlesDeGaulleRoissy.getName(),
            LongitudeDegrees=CharlesDeGaulleRoissy.getLongitudeDegrees(),
            LatitudeDegrees=CharlesDeGaulleRoissy.getLatitudeDegrees(),
            AltitudeAboveSeaLevelMeters=CharlesDeGaulleRoissy.
            getAltitudeMeanSeaLevelMeters())

        kmlOutputFile.write(name=BerlinTegel.getName(),
                            LongitudeDegrees=BerlinTegel.getLongitudeDegrees(),
                            LatitudeDegrees=BerlinTegel.getLatitudeDegrees(),
                            AltitudeAboveSeaLevelMeters=BerlinTegel.
                            getAltitudeMeanSeaLevelMeters())

        nearestCities = []
        for wayPoint in worldCitiesDatabase.getCities():
            distanceMetersToDeparture = CharlesDeGaulleRoissy.getDistanceMetersTo(
                wayPoint)
            distanceMetersToArrival = BerlinTegel.getDistanceMetersTo(wayPoint)
            if (distanceMetersToDeparture + distanceMetersToArrival) < (
                    distanceMeters + ((10.0 * distanceMeters) / 100.)):
                nearestCities.append({
                    "wayPoint":
                    wayPoint,
                    "distanceMeters":
                    distanceMetersToDeparture + distanceMetersToArrival
                })
        ''' re ordering '''
        nearestCities.sort(key=lambda x: x["distanceMeters"], reverse=False)

        count = 0
        for city in nearestCities:
            count = count + 1
            if (count < NumberOfPoints):
                kmlOutputFile.write(
                    name=city["wayPoint"].getName(),
                    LongitudeDegrees=city["wayPoint"].getLongitudeDegrees(),
                    LatitudeDegrees=city["wayPoint"].getLatitudeDegrees(),
                    AltitudeAboveSeaLevelMeters=0.0)

        kmlOutputFile.close()
    def test_route(self):
    
#     import sys
#     temp = sys.stdout #store original stdout object for later
#     sys.stdout = open('log.txt','w') #redirect all prints to this log file

        wayPointsDb = WayPointsDatabase()
        assert wayPointsDb.read()
            
        t0 = time.clock()
        print ' ========== Airports Direct Route testing ======= '
        
        airportsDb = AirportsDatabase()
        assert  airportsDb.read()
        t1 = time.clock()
        print ' time to read airports database= {0:.2f} seconds'.format(t1-t0)
        
        t2 = time.clock()
        runwaysDb = RunWayDataBase()
        assert runwaysDb.read()
        print ' time to read run-way database= {0:.2f} seconds'.format(t2-t1)
        
        print ' ========== Airports Direct Route testing ======= '
        departureCountry = 'Japan'
        departureCountry = 'United Kingdom'
        departureCountry = 'France'
        departureCountry = 'United States'
        arrivalCountry = 'Canada'
        arrivalCountry = 'France' 
        arrivalCountry = 'United States' 
        for departureAirport in  airportsDb.getAirportsFromCountry(Country = departureCountry):
            departureAirportICAOcode = departureAirport.getICAOcode()
            
            departureRunwayName = ''
            departureRunwayFound = False
            
            for runwayName in runwaysDb.findAirportRunWays(airportICAOcode = departureAirportICAOcode, 
                                                           runwayLengthFeet = 11000.0):
                if not(runwaysDb.getFilteredRunWays(
                                                    airportICAOcode = departureAirportICAOcode, 
                                                    runwayName = runwayName) is None):
                    departureRunwayName  = runwayName
                    departureRunwayFound = True
                    break
                
            if departureRunwayFound:
                
                for arrivalAirport in airportsDb.getAirportsFromCountry(Country = arrivalCountry):
                    
                    arrivalRunwayName = ''
                    arrivalRunwayFound = False
                    arrivalAirportICAOcode =  arrivalAirport.getICAOcode()
                    for runwayName in runwaysDb.findAirportRunWays(airportICAOcode = arrivalAirportICAOcode, 
                                                               runwayLengthFeet = 11000.0):
                        if not(runwaysDb.getFilteredRunWays(
                                                        airportICAOcode = arrivalAirportICAOcode, 
                                                        runwayName = runwayName) is None):
                            arrivalRunwayName = runwayName
                            arrivalRunwayFound = True
                            break
                    ''' we have a pair of airports '''
                    
                    if departureRunwayFound and arrivalRunwayFound:
                        distanceMeters = departureAirport.getDistanceMetersTo(arrivalAirport)
                        if  distanceMeters > 300000.0:
                            print ' ========== Airports Direct Route testing ======= '
                            print '{0} - {1} - distance  = {2} meters'.format(departureAirport.getName(), arrivalAirport.getName(), distanceMeters)
                
                            print departureAirport
                            print arrivalAirport
                            routeFinder = RouteFinder()
                            if routeFinder.isConnected():    
                                RFL = 'FL390'
                        
                                if routeFinder.findRoute(departureAirport.getICAOcode(), arrivalAirport.getICAOcode(), RFL):
                                    routeList = routeFinder.getRouteAsList()
                                    print routeList
                                    routeFinder.insertWayPointsInDatabase(wayPointsDb)
                
                                    strRoute = 'ADEP/' + departureAirport.getICAOcode() + '/' + departureRunwayName + '-'
                                    for fix in routeList:    
                                        strRoute += fix['Name'] + '-'
                                    strRoute += 'ADES/' + arrivalAirport.getICAOcode() + '/' + arrivalRunwayName
                                    
                                    print strRoute
                                    
                                    flightPath = FlightPath(route = strRoute, 
                                                                aircraftICAOcode = 'B744',
                                                                RequestedFlightLevel = 390, 
                                                                cruiseMach = 0.92, 
                                                                takeOffMassKilograms = 280000.0)
        
                                
                                    print "=========== Flight Plan compute  =========== " 
                      
                                    t0 = time.clock()
                                    print 'time zero= ' + str(t0)
                                    lengthNauticalMiles = flightPath.computeLengthNauticalMiles()
                                    print 'flight path length= {0:.2f} nautics '.format(lengthNauticalMiles)
                                    flightPath.computeFlight(deltaTimeSeconds = 1.0)
                                    print 'simulation duration= ' + str(time.clock()-t0) + ' seconds'
                                    print "=========== Flight Plan create output files  =========== "
                                    flightPath.createFlightOutputFiles()
Exemplo n.º 31
0
    def test_ClimbRamp(self):

        atmosphere = Atmosphere()
        earth = Earth()

        print '==================== Three Degrees climb slope ==================== ' + time.strftime(
            "%c")
        acBd = BadaAircraftDatabase()
        aircraftICAOcode = 'A320'
        if acBd.read():
            if (acBd.aircraftExists(aircraftICAOcode)
                    and acBd.aircraftPerformanceFileExists(aircraftICAOcode)):

                print '==================== aircraft found  ==================== ' + time.strftime(
                    "%c")

                aircraft = BadaAircraft(
                    ICAOcode=aircraftICAOcode,
                    aircraftFullName=acBd.getAircraftFullName(
                        aircraftICAOcode),
                    badaPerformanceFilePath=acBd.getAircraftPerformanceFile(
                        aircraftICAOcode),
                    atmosphere=atmosphere,
                    earth=earth)
                aircraft.dump()

        assert not (aircraft is None)

        print '==================== get Charles Gaulle airport ==================== ' + time.strftime(
            "%c")
        airportsDB = AirportsDatabase()
        assert (airportsDB.read())
        CharlesDeGaulle = airportsDB.getAirportFromICAOCode('LFPG')
        print CharlesDeGaulle
        assert not (aircraft is None)

        aircraft.setTargetCruiseFlightLevel(
            RequestedFlightLevel=390,
            departureAirportAltitudeMSLmeters=CharlesDeGaulle.
            getAltitudeMeanSeaLevelMeters())

        print '==================== Three Degrees climb slope==================== ' + time.strftime(
            "%c")
        runWaysDatabase = RunWayDataBase()
        if runWaysDatabase.read():
            print 'runways DB correctly read'

        runway = runWaysDatabase.getFilteredRunWays('LFPG')
        print runway

        print '==================== Ground Run ==================== ' + time.strftime(
            "%c")
        groundRun = GroundRunLeg(runway=runway,
                                 aircraft=aircraft,
                                 airport=CharlesDeGaulle)
        groundRun.buildDepartureGroundRun(deltaTimeSeconds=0.1,
                                          elapsedTimeSeconds=0.0,
                                          distanceStillToFlyMeters=100000.0,
                                          distanceToLastFixMeters=100000.0)
        print '==================== Three Degrees climb slope==================== ' + time.strftime(
            "%c")

        initialVertex = groundRun.getVertex(groundRun.getNumberOfVertices() -
                                            1)
        initialWayPoint = initialVertex.getWeight()

        climbRamp = ClimbRamp(initialWayPoint=initialWayPoint,
                              runway=runway,
                              aircraft=aircraft,
                              departureAirport=CharlesDeGaulle)

        climbRamp.buildClimbRamp(deltaTimeSeconds=0.1,
                                 elapsedTimeSeconds=0.0,
                                 distanceStillToFlyMeters=100000.0,
                                 distanceToLastFixMeters=100000.0,
                                 climbRampLengthNautics=5.0)
        groundRun.addGraph(climbRamp)

        groundRun.createKmlOutputFile()
        print "=========== ThreeDegreesGlideSlope end =========== " + time.strftime(
            "%c")
Exemplo n.º 32
0
    def test_DescentGlideSlope(self):

        atmosphere = Atmosphere()
        earth = Earth()
        print '==================== three degrees Descent Slope Start  ==================== ' + time.strftime(
            "%c")

        acBd = BadaAircraftDatabase()
        aircraftICAOcode = 'A320'
        if acBd.read():
            if (acBd.aircraftExists(aircraftICAOcode)
                    and acBd.aircraftPerformanceFileExists(aircraftICAOcode)):

                print '==================== aircraft found  ==================== ' + time.strftime(
                    "%c")

                aircraft = BadaAircraft(
                    ICAOcode=aircraftICAOcode,
                    aircraftFullName=acBd.getAircraftFullName(
                        aircraftICAOcode),
                    badaPerformanceFilePath=acBd.getAircraftPerformanceFile(
                        aircraftICAOcode),
                    atmosphere=atmosphere,
                    earth=earth)
                aircraft.dump()

        assert not (aircraft is None)
        print '==================== runways database ==================== ' + time.strftime(
            "%c")
        runWaysDatabase = RunWayDataBase()
        assert runWaysDatabase.read()

        runway = runWaysDatabase.getFilteredRunWays(airportICAOcode='LFML',
                                                    runwayName='')
        print runway

        print "=========== arrival airport  =========== " + time.strftime("%c")
        airportsDB = AirportsDatabase()
        assert (airportsDB.read())

        MarseilleMarignane = airportsDB.getAirportFromICAOCode('LFML')
        print MarseilleMarignane

        print "=========== descent glide slope  =========== " + time.strftime(
            "%c")
        threeDegreesGlideSlope = DescentGlideSlope(
            runway=runway,
            aircraft=aircraft,
            arrivalAirport=MarseilleMarignane)

        initialWayPoint = WayPoint(Name='startOfDescentGlideSlope', )
        print "=========== DescentGlideSlope build the glide slope  =========== " + time.strftime(
            "%c")
        #     threeDegreesGlideSlope.buildGlideSlope(deltaTimeSeconds = 0.1,
        #                         elapsedTimeSeconds = 0.0,
        #                         initialWayPoint = None,
        #                         flownDistanceMeters = 0.0,
        #                         distanceStillToFlyMeters = 100000.0,
        #                         distanceToLastFixMeters = 100000.0)

        threeDegreesGlideSlope.buildSimulatedGlideSlope(
            descentGlideSlopeSizeNautics=5.0)

        print "=========== DescentGlideSlope  =========== " + time.strftime(
            "%c")
        for node in threeDegreesGlideSlope.getVertices():
            print node

        print "=========== DescentGlideSlope length =========== " + time.strftime(
            "%c")
        print "get number of vertices= {0}".format(
            threeDegreesGlideSlope.getNumberOfVertices())
        print "get number of edges= {0}".format(
            threeDegreesGlideSlope.getNumberOfEdges())
        print 'Glide Slope overall length= {0} meters'.format(
            threeDegreesGlideSlope.computeLengthMeters())

        threeDegreesGlideSlope.createKmlOutputFile()
        threeDegreesGlideSlope.createXlsxOutputFile()
        print '==================== three degrees Descent Slope End  ==================== ' + time.strftime(
            "%c")