Method for calculating takeoff and landing weight of multi-aircraft aircraft based on micro-service architecture

Abstract

The invention discloses a takeoff and landing weight calculation method for a multi-aircraft-type aircraft based on a micro-service architecture, and belongs to the technical field of data processing, and the method comprises the following steps: S1, calling airport data, aircraft-type data and meteorological data to generate a * *. In file required by a performance analysis software package by using a Java program; the problem of deployment of a C / S program client and the problem of difficulty in upgrading of the C / S program are solved only by introducing the scapubus.dll and the ARJALLLLPublic. Dll in a back-end server program, a server module is added when the calculation amount is large, the problem of single-machine performance is solved, the program can be expanded to more types, the use of a user is not influenced, and the problem of compatibility of multiple types is solved.

Description

Technical Field

[0001] The present invention relates to the field of data processing technology, and in particular to a method for calculating the take-off and landing weight of multiple aircraft types based on a microservice architecture. Background Art

[0002] The scap_octopus software package is a performance analysis function calculation component provided by Airbus. Airbus's own desktop program calls this software package to generate weight data. The software defines the input scap.in and the output scap.out. scap_octopus provides an interface for performing performance analysis and defines the input parameter specifications and output result specifications.

[0003] ARJ_ALL_DLL_Publish is a domestic ARJ21 performance analysis software package, which generates different .in files and .out files according to different input business rules, such as: TLP01_TAKEOFF_POINT_N0_xxx.in.

[0004] JNA (Java Native Access) provides a set of Java tool classes for dynamically accessing system native libraries (such as Window's dll) during runtime without writing any Native / JNI code. As long as the functions and structures of the target native library are described in a Java interface, JNA will automatically implement the mapping of the Java interface to the native function.

[0005] Microservice architecture (Spring Cloud) is a cloud-native architecture approach that includes many loosely coupled and independently deployable small components or services in a single application. These services usually have their own technology stack, including databases and data management models, and are organized according to business capabilities.

[0006] The microservice architecture is characterized by easier code updates, and new features or functions can be added directly without having to update the entire application. Components can be scaled independently of each other, reducing the waste and costs associated with having to scale the entire application. At the same time, the functions of individual components can be scaled horizontally, and the system comes with a load balancing strategy. Summary of the invention

[0007] The invention provided by the present invention aims to provide a method for calculating the take-off and landing weight of multiple aircraft models based on a microservice architecture. At present, the calculation of Airbus load data is performed by calling a desktop program, and the input parameter data usually comes from the local system. The desktop program is used by a single person, and the parameters need to be manually configured once it is executed. The change of basic data depends on manual copying, which is inconvenient for business personnel to use and share. By using a Web program with a Java microservice architecture, the input parameters can be defined once for multiple people to use, the basic data is uniformly configured, and the program can be set to generate data in batches. At the same time, the performance analysis module can register multiple services, increase or reduce the performance analysis server according to the amount of calculation, and users access the system through a browser, which is convenient for users to use and share data, share calculation results, and expand server computing resources when the number of visits is relatively large.

[0008] In order to achieve the above effect, the present invention provides the following technical solution: a method for calculating the takeoff and landing weight of multiple aircraft models based on a microservice architecture, comprising the following steps:

[0009] S1. Use Java program to call airport data, aircraft model data and meteorological data to generate **.in file required by performance analysis software package.

[0010] S2. Use Java's JNA technology to call the DLL package and bind the scap_octopus.dll and ARJ_ALL_DLL_Publish.dll performance analysis component functions to the microservice environment. The system can register multiple identical microservice components.

[0011] S3, Java executes the scap_octopus or ARJ_ALL_DLL_Publish performance analysis takeoff and landing analysis functions through the defined interface according to the **.in parameter file.

[0012] S4. Use the Java program to copy the result **.out to the specified folder, and parse the file content to obtain the takeoff and landing weight information.

[0013] Further, according to the operation steps in S1,

[0014] S101. The system establishes an airport database, including data on runway elements and obstacles, opens a meteorological data interface, obtains current and future forecast meteorological data for airport runways, stores ARJ21 and Airbus models and defines the takeoff and landing parameters of the models, and the basic data is stored in a relational database.

[0015] S102. Create an aircraft performance analysis software **.in template, define input parameters that do not need to be changed and parameters that need to change according to external conditions, make airport, weather and aircraft model data into parameters that can be filled in dynamically, fill the data into the **.in template when the system is running to generate a file, and copy it to the scap_octopus.dll and ARJ_ALL_DLL_Publish.dll file directories.

[0016] Further, according to the operation steps in S2,

[0017] S201. When the program development is completed, copy scap_octopus.dll and ARJ_ALL_DLL_Publish.dll to the same directory of the microservice performance calculation module.

[0018] S202. Define the JNA interface of the Java program, bind the functions of scap_octopus.dll and ARJ_ALL_DLL_Publish.dll, and define the same interface name in the Java program.

[0019] Further, according to the operation steps in S3,

[0020] S301. The system copies **.in to the Java weight calculation microservice module execution directory, which is the same directory as scap_octopus.dll and ARJ_ALL_DLL_Publish.dll.

[0021] S302. Through the microservice framework program, call the runscap interface or ARJ21 interface in the method, and output the **.out file after execution.

[0022] Further, according to the operation steps in S4,

[0023] S401. The calculation result **.out is in the same execution directory as **.in by default. Since the result generated each time has the same file name, it is copied to the specified directory and then the file is renamed.

[0024] S402, parse the **.out file content, obtain the file content, extract weight-related information, determine the flight load, and then calculate the number of seats available for sale.

[0025] The present invention provides a method for calculating the take-off and landing weight of multiple aircraft models based on a microservice architecture, which has the following beneficial effects: currently, the calculation of Airbus load data is performed by calling a desktop program, and the input parameter data usually comes from the local system. The desktop program is used by a single person, and the parameters need to be manually configured once it is executed. The change of basic data depends on manual copying, which is inconvenient for business personnel to use and share. By using a Web program with a Java microservice architecture, the input parameters can be defined once for multiple people to use, the basic data is uniformly configured, and the program can be set to generate data in batches. At the same time, the performance analysis module can register multiple services, and the performance analysis server can be increased or reduced according to the amount of calculation. The user accesses the system through a browser, which is convenient for users to use and share data, share calculation results, and expand server computing resources when the number of visits is relatively large. BRIEF DESCRIPTION OF THE DRAWINGS

[0026] Figure 1 A schematic diagram of specific functional points of multi-aircraft takeoff and landing weight calculation of a multi-aircraft takeoff and landing weight calculation method based on a microservice architecture of the present invention;

[0027] Figure 2 The figure is a schematic diagram of the process of calculating the number of seats available for sale on a passenger aircraft according to the method for calculating the take-off and landing weight of multiple aircraft types based on a microservice architecture of the present invention. DETAILED DESCRIPTION

[0028] In order to make the objectives, technical solutions and advantages of the present invention more clearly understood, the present invention is further described in detail below in conjunction with specific embodiments.

[0029] For example, see Figure 1-2 :

[0030] The method for calculating the takeoff and landing weight of multiple aircraft models based on a microservice architecture includes the following steps:

[0031] S1. Use Java program to call airport data, aircraft model data, and meteorological data to generate **.in files required by the aircraft performance software package. Mysql stores data, and Mybatis reads and writes data.

[0032] S2. Introduce Java's com.sun.jna component package, use JNA technology to call the DLL interface, bind the scap_octopus.dll and ARJ_ALL_DLL_Publish.dll performance analysis component functions to Spring Cloud, and the system can register multiple identical microservice components, a single component Spring Boot;

[0033] S3, Java executes the scap_octopus performance analysis takeoff and landing analysis function through the defined interface according to the **.in parameter file;

[0034] S4. Use the Java program to copy **.out to the specified folder, and parse the file content to obtain the takeoff weight information.

[0035] Specifically, the steps include: according to the operation steps in S1,

[0036] S101. The system uses Mysql to store the basic data of the storage system. The system establishes an airport database, including runway elements, obstacles and other data, opens the meteorological data interface, obtains the current and future forecast meteorological data of the airport runway, stores Airbus and ARJ21 models and defines the take-off parameters of the models. The basic data is saved in the Mysql database, and the Mybatis ORM component is used to read the data.

[0037] S102. Create the scap.in template for Airbus performance analysis software and TLP_**.in for ARJ21, define the input parameters that do not need to be changed and the parameters that need to change according to external conditions, and make the airport, weather, and aircraft model data into parameters that can be filled in dynamically. When the system is running, fill the data into the **.in template to generate a file, and copy it to the dll file directory.

[0038] Specifically, the steps include: according to the operation steps in S2,

[0039] S201. When the program development is completed, copy scap_octopus.dll and ARJ_ALL_DLL_Publish.dll to the same directory of the microservice performance calculation module.

[0040] S202, introduce JNA package

[0041]

[0042] Define the JNA interface of the Java program, bind the functions of scap_octopus.dll and ARJ_ALL_DLL_Publish.dll, and define the same interface name in the Java program. The example is as follows:

[0043] JNAAirbus.Clibrary INSTANTCE=(JNAAirbus.Clibrary)

[0044] Native.loadLibrary("scap_octopus",

[0045] JNAAirbus.Clibrary.class);

[0046] Specifically, the following steps are included: according to the operation steps in S3,

[0047] S301. Use Spring Cloud as the microservice framework, Spring Boot as a single component, and Nacos as the service registration center and configuration management center.

[0048] S302. The system copies **.in to the Java load calculation microservice module execution directory, the same directory as scap_octopus.dll and ARJ_ALL_DLL_Publish.dll, and reads the file content: FileWriter writer = new FileWriter ("SCAP.IN").

[0049] S303. Through the microservice framework program, call the runscap interface in the method, JNAAirbus.Clibrary.INSTANTCE.runscap(), and output files such as scap.out after execution.

[0050] Specifically, the steps include: according to the operation steps in S4,

[0051] S401. The calculation result **.out is in the same execution directory as **.in by default. Since the result generated each time has the same file name, it is copied to the specified directory and then renamed, FileUtils.moveFile(sourceFile,destinationFile).

[0052] S402, parse the contents of the **.out file, the code example is as follows: BufferedReader reader = newBufferedReader (new FileReader (outputFile)), obtain the contents of the file, extract the information related to takeoff and landing, determine the flight load, and then calculate the number of seats available for sale.

[0053] Example 2, see Figure 1-2 :

[0054] This embodiment describes a specific application scenario of multi-aircraft takeoff and landing weight calculation based on a microservice architecture. This function can be applied to the function of obtaining the takeoff and landing weight calculation function of Airbus and ARJ21 models, and determining the payload according to the current flight. The specific process of this solution is as follows: Figure 2 shown.

[0055] The takeoff of a passenger plane requires the current maximum takeoff weight and maximum payload weight to calculate the number of seats available for sale. The specific implementation process includes the following steps:

[0056] Step 1: According to the flight schedule, select the aircraft model and determine the input for the flight:

[0057] Step 101: Determine aircraft performance parameter data according to the current aircraft model;

[0058] Step 102: Determine the runway data and obstacle data, and the altitude of the current airport according to the airport data;

[0059] Step 103: Obtain weather wind and temperature data according to the take-off time, airport coordinates and altitude.

[0060] Step 2: Call the microservice weight calculation module based on the parameters:

[0061] Step 201: Obtain various parameters, generate input format data according to the .in input parameter template, and complete the .in assembly work;

[0062] Step 202: calling the load calculation module through the gateway, creating a .in file at the service node, executing the load calculation analysis program, and generating a .out program;

[0063] Step 203: Parse the .out file to obtain the maximum takeoff and landing weights for this flight.

[0064] Step 3: Determine the maximum number of seats on the flight based on the maximum takeoff weight:

[0065] Step 301: Obtaining the maximum takeoff load according to the weight calculation result;

[0066] Step 302: Calculate fuel quantity data through the flight plan according to the route information;

[0067] Step 303: Obtain the aircraft's own weight information according to the aircraft model information;

[0068] Step 304: Obtain the payload weight by subtracting the fuel amount and the aircraft weight from the takeoff weight;

[0069] Step 305: Calculate the number of seats according to the payload weight and determine the number of seats that can be pre-sold for the current flight.

[0070] Although embodiments of the present invention have been shown and described, it will be appreciated by those skilled in the art that various changes, modifications, substitutions and variations may be made to the embodiments without departing from the principles and spirit of the present invention, and that the scope of the present invention is defined by the appended claims and their equivalents.

Claims

1. A method for calculating the takeoff and landing weight of multiple aircraft types based on a microservice architecture, characterized in that: The following steps are involved: S1. Use Java program to call airport data, aircraft model data and meteorological data to generate **.in file required by performance analysis software package; S2. Use Java's JNA technology to call the DLL package and bind the scap_octopus.dl l and ARJ_ALL_DLL_Publish.dll performance analysis component functions to the microservice environment. The system can register multiple identical microservice components. S3, Java executes scap_octopus or ARJ_ALL_DLL_Publ ish performance analysis takeoff and landing analysis functions through the defined interface according to the **.in parameter file; S4. Use the Java program to copy the result **.out to the specified folder, and parse the file content to obtain the takeoff and landing weight information.

2. The method for calculating takeoff and landing weight of multiple aircraft types based on microservice architecture according to claim 1 is characterized in that: The following steps are involved: According to the steps in S1, S101. The system establishes an airport database, including data on runway elements and obstacles, opens a meteorological data interface, obtains current and future forecast meteorological data for airport runways, stores ARJ21 and Airbus models, and defines takeoff and landing parameters for the models. Basic data is stored in a relational database; S102. Create an aircraft performance analysis software **.in template, define input parameters that do not need to be changed and parameters that need to change according to external conditions, make airport, weather and aircraft model data into parameters that can be filled in dynamically, fill the data into the **.in template when the system is running to generate a file, and copy it to the scap_octopus.dl l and ARJ_ALL_DLL_Publish.dl l file directories.

3. The method for calculating takeoff and landing weight of multiple aircraft types based on microservice architecture according to claim 1 is characterized in that: The following steps are involved: According to the operation steps in S2, S201. When the program development is completed, copy scap_octopus.dl l and ARJ_ALL_DLL_Publish.dl l to the same directory of the microservice performance calculation module; S202. Define the JNA interface of the Java program, bind the functions of scap_octopus.dll and ARJ_ALL_DLL_Publish.dll, and define the same interface name in the Java program.

4. The method for calculating takeoff and landing weight of multiple aircraft types based on microservice architecture according to claim 1 is characterized in that: The following steps are involved: According to the operation steps in S3, S301. The system copies **.in to the Java weight calculation microservice module execution directory, which is the same directory as scap_octopus.dl l and ARJ_ALL_DLL_Publish.dl l; S302. Through the microservice framework program, call the runscap interface or ARJ21 interface in the method, and output the **.out file after execution.

5. The method for calculating takeoff and landing weight of multiple aircraft types based on microservice architecture according to claim 1, characterized in that: The following steps are involved: According to the operation steps in S4, S401, the calculation result **.out is in the same execution directory as **.in by default. Since the result generated each time has the same file name, it is copied to the specified directory and then renamed. S402, parse the **.out file content, obtain the file content, extract weight-related information, determine the flight load, and then calculate the number of seats available for sale.

Images