Elevating Design: The Confluence of Aerodynamics and Aircraft Control
This focused webinar on the intersection of Aerodynamics and Control in Aircraft Design covers:
- Laying the groundwork with an overview of fundamental aerodynamic principles and their critical role in flight control.
- For most flight control designs, the airframe, or plant model, needs to be modelled, simulated, and analyzed. We will see how to quickly model the airframe, reusing blocks or model structure to reduce validation time and leave more time available for control design.
- Later we will design and tune angular rates controller as inner loop while roll, pitch, and yaw of the vehicle as outer loop control.
- Finally, we will see the various ways to visualize the aircraft dynamics and explore the results for analysis.
About the Presenter
Brijith Balakrishnan is a Systems Engineer at Moog India Technology Centre, Bangalore, with experience in modeling and simulation, aircraft system integration, verification and validation. He has worked on various projects related to aircraft systems, including the Primary Control System, High Lift System, and Electric Propulsion System. Before joining Moog India, Brijith completed his master’s dissertation at the U.R Rao Satellite Center, which is one of the research centers of ISRO (Indian Space Research Organization), where his research focused on modeling and simulation of a planetary aerial rover. He holds a master’s degree in mechatronics engineering from the National Institute of Technology Karnataka and a bachelor’s degree in electrical and electronics engineering from the University of Calicut.
Mukesh Prasad is a Principal Application Engineer in MathWorks India and enables engineers & scientists to adopt Model-based Design workflows. He closely works with customers in Aerospace & Defence industry to help them use MATLAB® and Simulink® products for control system design, multi-domain physical modeling, production code generation, test automation and software verification & validation. Mukesh has over 17 years of experience in jet engine control and flight control systems. Prior to joining MathWorks, Mukesh worked as Systems Specialist with Moog India, where he gained hands-on experience in Model-Based Systems Engineering (MBSE) and Test Equipment Design for aircraft applications. He started his career as Scientist at Gas Turbine Research Establishment (GTRE), one of the labs of DRDO, and worked on aircraft engine control design, testing, and certification using model-based design workflows. Mukesh holds a master’s degree in mechatronics engineering from NIT Surathkal while bachelor’s degree in mechanical engineering from NIT Kurukshetra.
Recorded: 8 Feb 2024
Good evening to all, and welcome to the MathWorks Modern Aircraft Design and Engineering Webinar Series. I'm Prashant, part of the marketing team here at MathWorks, and will be your host for today. So session 2 today, the topic for the session is on "Elevating Design-- The Confluence of Aerodynamics and Aircraft Control."
I would like to introduce the speakers for our session today, starting with Mr. Brijith Balakrishnan. We are really happy to invite him to our webinar series. And Brijith is a Systems Engineer at Moog India Technology Center, Bangalore, with experience in modeling and simulation, aircraft system integration, verification, and validation. He has worked on various projects related to aircraft systems including the primary control system, high-lift system, and electrical propulsion system. Before joining Moog, Brijith completed his master's at URSC, which is one of the research centers of EASA, where his research focused on modeling and simulation of a planetary aerial robot.
Our second speaker is Mukesh Prasad. Mukesh is a Principal Application Engineer in MathWorks and enables engineers and scientists towards adopting model-based design workflows. He closely works with customers in aerospace and defense industry to help them use MATLAB and Simulink products for control system design, multidomain physical modeling, production code generation, and software verification and validation.
He has over 17 years of experience in jet engine control and flight control systems. I would now like to hand the session to Mukesh. Thank you, all.
Thank you, Prashant, for your introduction. May I please share the screen? Yeah. So, hello, everyone. Myself, I'm Mukesh Prasad, and I'm working as an application engineer in MathWorks.
So let's talk about the agenda. So we are going to discuss about the fundamentals of the aerodynamics principles and its critical role in the flight control. Then we'll move on to the how to model the airframe in the Simulink using the blocks, which is available, readily available, and quickly, you can model the airframe.
Then we'll talk about the control system design, where we will be tuning and designing the angular rates control, which is the inner loop and the outer loop, which is the attitude control for the vehicle. And then finally, we'll be discussing about the visualizations which is available in the MATLAB environment to explore the results.
So what is "six degrees of freedom" modeling? So we are talking about a "six degree of freedom" rigid-body modeling over here. So this is a very typical figure you would have seen earlier, that the aircraft is flying and it is experiencing different forces like aerodynamic forces, gravitational, and the propulsion forces. And it is making an angle of alpha with the free-stream velocity, which is nothing but the angle of attack, and while in the sideways, it is making an angle of beta, which is sideslip angle.
So generally, it means it is needed to transform these kind of forces into the wind frame. First, we have to do with the stability frame by bringing it from the alpha rotation and then from the beta rotation. And finally, we get that in the wind frame, which you can see all three equations are showing up over here.
Continuing with that means that we have these axes of rotation and translation. When these forces-- like X, Y, Z-- and the moments-- like L, M, N-- are applied to the airframe, then it is actually causing it to move in a certain way, which can be described from u, v, w; p, q, r; and the Euler angles, called phi, theta, psi.
So going one step forward and talking about the different equations which can be used to model the aircraft dynamics, are translational acceleration equations, rotational acceleration equations, and Euler rate equations. So these nine differential equations are actually enough to describe the movement of the aircraft whenever the forces and moments are applied to the body.
When we do the simulation, so this aircraft dynamics is kind of given inputs, like the surface deflections and the engine throttle, which causes the forces and moment to change over the body. And then we kind of integrate those nine differential equations using the initial conditions and the new states that have been obtained, and which is fed back again, and iteratively, and this simulation keeps on running again and again to give you the different movements and motion and position of the aircraft based on the different control deflection surfaces.
So we are today taking up an example of the HL-20 Lifting Body, which is a component of the PLS, Personal Launch System, which is designed by the NASA, and there are two ways it can be launched. It can be launched to the orbit with the booster rocket as well as it can be taken as a payload and taken to space. While coming back, in reentry to the atmosphere, it performs the nose-first reentry. And it is kind of unpowered, so it does not have any propeller, propulsion systems into it.
So let's talk about the closed-loop control upgrade. So we have already discussed how the airframe can be modeled using the nine differential equations, and then these values-- like the p, q, r, and phi, alpha, beta-- can be taken as a feedback to control the aircraft as you desire. So the guidance systems actually give you the kind of roll, angle of attack, and beta demand, which actually goes to the outer loop, and it closes that and generates the other command-- p, q, r-- which is the angular rate commands.
Then, further, the closed-loop control is done using the actual value of that, and then you get the actuator position demand. So when the actuator deflections are created, these deflections actually create the forces, new forces to the airframe. And then, further, the loop is getting executed again and again, and you do the closed-loop control to meet the different orientation and the location of the aircraft.
So before going ahead and exploring the model and the control system part of it and visualization part of it, so let's look at everything at one shot. So this is the complete model available, where you have everything built on, and this is the video we'll show you, that how the aircraft is actually doing the reentry and landing to the runway. So in the rightmost upper side, you can see that, actually, the aircraft is showing up in the UE-- that means visualization, that is, Unreal Engine, from the Epic Games, visualization-- while in this bottom side, you can see that these are the different flight instruments which can be shown. And the bottom one is the one which is the scope one, general one, which you can see and read the values and understand the physics about it.
Let's look into the Airframe in detail. You can see in the left-hand side, the position is getting as an input, and right-hand side, you have the different outputs, like explaining the different positions and accelerations and velocities. So I'll take you to the model now and show you what is there inside.
So you can see that there are the components-- like, means when the actuator position, it gets into this subsystem, then it generates kind of coefficient. So a lot of lookup tables are there based on the wind tunnel data, so those coefficients are getting derived in this subsystem, which leads to creation of the forces. In our case, the thrust is zero, and we are also putting the dynamic pressure as an input to the forces and moment calculation.
This block actually explains to you about the aerodynamics, the creation of the forces and moments, which we will see very shortly. And then, once the forces and moments are created, this is getting into the 6DOF model, which is actually creating your positions, accelerations, Euler angles, and all. And finally, there are some disturbances been included into that, which is created in the environmental model, and few of the parameter calculations-- like alpha, beta, and Mach number-- is getting done in this block.
So let's look into this block one by one. So if you see the coefficient-of-friction-- oh, sorry, the coefficient-of-lift calculations are here, then you can see that these all coefficients are getting added up. And one of them, if you look into that, these are the lookup tables. Based on the alpha and beta, it is calculating the coefficient of lift and getting added up, finally, and generating the forces.
If you go inside this, then you have the-- based on the coefficients and the dynamic pressure, you find that the aerodynamic forces are getting created for the given surface area, reference span, and the reference length of the airframe. So this is-- you can do it in body axis. You can do it in wind axis. You can do it in the stability axis.
So there is a dropdown here, you can do that. Right now it's Body Axis is selected. So all transformations can also be done using this block.
6 Degrees Of Freedom is the one where you have to define all the initial conditions, which I mentioned earlier, to start the integration activity for all nine differential equations. So here you can see that all positions, velocities, roll, pitch, your p, q, r, all these initial conditions has been defined in the beginning. And all the nine equations will be integrated, finally, and then it will be creating all the desired outputs.
In the Environment Model, you can see that there are Wind Model, Atmospheric Model, and the Gravity Model has been simulated. In the Wind Model, if you go inside, you will find that there is a Wind Shear Model. You have the Dryden Wind Turbulence Model, and the Wind Gust Model is defined. Wind Gust Model, if I look to want to see, you can see that at this particular point of time, there is a wind gust of this size will be kind of injected to the model and model how it is going to respond to this particular wind gust. We can see that.
This block is Atmospheric Model. You can see that based on the altitude, actually, it kind of finds out the temperature, the speed of the sound, and air density. The speed of the sound is getting used for calculating the Mach number, while the air density is getting used to calculate the stable-- the q-bar, dynamic pressure.
In this case, we are using the WGS84 Gravity Model. This model is used to create the G for that, which is getting multiplied with the mass, and finally, by direction quotient and metrics, we are converting from a body-- from the flat Earth-fixed reference frame to body-fixed frame and creating this force, which is getting added to the forces which is created with the-- by the forces and moments, actually. So this final force is getting into the 6DOF model.
One more block which we can see is this Alpha Beta. This is-- like, readily, these blocks are available in the Aerospace Blockset, which you can pull and you can find out the incidence angle, slip angle, and the airspeed as well as the Mach number and the q-bar, very readily, without actually worrying much about the equation level. So basically, it means that-- here I wanted to show you quickly that based on the available blocks in the Aerospace Blockset, means you can quickly make your aircraft modeling, and finally, you can use it for the control system design. So the whole task right now, apart from this-- I will be concentrating more on that, the controller design for the given aircraft.
Let me show you one more thing. You are here. It's the visualization part right now because this model is open.
So there are multiple ways it can be visualized. So you can see this is the Scope, using which you can visualize and you can open and see how the aircraft's actually behaving in the scope. So this, most of the engineers are actually willing to know the values, actual values, so you can look into this.
The other way is the UE visualization, which is the kind of photorealistic visualization where you can do-- by just double-clicking here, you can configure that, default scenes or the different scenes you can import, and you can actually perform the simulation in the UE environment. You can set that, what are all the components you have there in the aircraft.
In our aircraft, actually, the only-- right now, there is no propulsion system, so you don't see anything ticked. But you can see that the control, which is available from the flap, aileron elevators, has been clicked, actually. So this has been selected, so that using this means you can do the simulation.
The third thing which is the visualization part is that through the instruments, so these, all parameters, what you see is mapped into the instruments here. And you can see that you have airspeed. You have the horizon and then altimeter, and then different, like, turn indicators and heading and vertical speeds can be seen over here. So these are the different visual techniques that are available which can be explored.
So let me take you to the control system design part now. Control design, we need to do-- in a different way, we can actually perform the control system design. Either you can do it through the normal app based, or you can do programmatically.
Even the app allows you to create the MATLAB code automatically, which you can further alter and generate the script out of it, and then use the scripts iteratively again and again to actually refine your design of the control system. In our case, actually, I have taken the live scripts, and these all are the script-based control system design which I'll be showing you today. So basically, we'll be delving into the three-- mostly three aspects of it.
First is the trimming and linearization part. Then we'll be tuning the angular rate, and then we'll be talking about the attitude control. And then finally, we'll see how to analyze the result. So these, all steps, actually has been done using some function. So that function name, I have kept over here, but these are all things you will come to know once I will walk you through the live script.
All right, so let me take you to the first script, where it means we are doing the trimming and linearization of the HL-20 aircraft. So we are opening the model, and then finally, we are kind of setting up the trimming. operspec means whatever the operating point you want to tune for that specification has to be given. In this case, we are doing it for the multiple operating points. So because of that, you can see that the alpha value is ranging from minus 10 to 25, which is total of eight numbers, and beta is minus 10 to 10, which is a total of five numbers. So total, eight into five, there will be 40 different operating points will be created.
You can see over here in this operspec(1), actually, what and all things are there, there will be a total of 40, out of which the first one has been shown over here, that what kind of things are inside that, you can see these states are available, which are known or not known, that steady-state values and all those things are there. Its inputs are available, like here, in this case, like a da dr, which is the deflection in the surfaces, and the outputs, like p, q, r, theta, phi, and all those things. So right now you can see that there is no value. It's all zeros showing up here or here.
But now we can define, actually, so once the operating specification object has been created, then we can actually push the value of our interest. Like, alpha, we have the total of 40 values, and we will be running this loop. And for every value of the alpha and beta, we'll be creating the different specification.
So you can see that alpha, beta, Mach number, and also, we can set for a few of the states. Suppose we don't want rolling, so we can make it a zero. Likewise, it means we can set, based on your desire, that, What do you want from the operating specifications?
Once you set, you can, again, run another operspec and see that it's changed or not. You can see here in the output, I can show you at least that-- see, alpha has been minus 10 and beta has been minus 10, so it has been updated. And many things-- like, it was false, all the things were false, and having the value zero, but now its value is true because it means we have forced it to have some values for the given equilibrium point.
In this step 3, we'll be using the findop command, where it means we are kind of finding the operating point for the given specifications, which we have already set for the 40 different operating points. So the TrimOptions is the algorithm which you want to use it for doing the optimization. You can use gradient descent. I have used here, in this case, sqp, which is sequential quadratic programming. And you see that it returns an 8-by-5 array of the operating conditions.
Here, in this case, operating one, if I see, then you can easily see that there are 12 states-- phi, theta, psi; p, q, r; u, v, w; and x, y, z. And the inputs are the values of the deflections. Likewise, there will be a total of 40, and we can also print out the terminating string saying that means whether our operating specification has been met or not. In our case, it is met.
Going to the fourth step, here we are using the linearize command to linearize all of the 40 operating points. Using all of the 40 operating points, we are kind of realizing one-- it means linearizing one by one using a single command. There is no for loop. It's like we're using a single command you can actually do for all operating points. You can linearize the frame as well as the control selector, which is coming from your surfaces or positions.
We are stepping out a few things here, airbrakes, and this is because we don't need that. So we are making it zero as an input. So that is not needed. So if you go to the model, then you can see that, that that is no more needed.
OK, so in the step 5, you can see that we are talking about the linear-- we are kind of simplifying the model this time. Here, there are actually 12 states that are available. We not may not be interested in all 12 states because those are not contributing to the motion which we are interested in.
We are are only interested in the phi because that is the roll part of it. The rest of the theta and psi, we are actually controlling it through the alpha and beta, so we are kind of eliminating that. And finally, we are reducing the model, using the modred, from 12th order to the 7th order. So we are naming it as a G7, and the new states are like this.
Finally, once everything is done, then this has been saved into the file, the reduced model. The control surface model has been saved to the file and which we can use in the next script. So these are-- this part completely is all talking about the trimming, finding out the trim operating conditions and linearization part of it. So once you do that, you can move on to the next part, where it means you are doing the angular rate control.
In this case, in the first step, we are loading that G7 and CS, which we have already checked the trim condition, all 40 different GS. Now we are giving this access point for these values which we are interested in, and then we can do the block substitution because we have to substitute the nonlinear block from the airframe by G7. So this command will allow you to replace these blocks by the linearized blocks which we have right now, and then BlockSubstitutions command will kind of replace them.
So whatever the ST0 is the tuner command, so this tuner command actually generates that object. And in that object, we are kind of replacing it and working on that. Then we are finding out the transfer function out of it and seeing that, How does it behave?
So we see that for the inputs of these deflections and the output of the pqr-- which is the inner loop, pqr control-- and we are opening the loop at this point, also. So we see that means it looks like this, and when we analyze closely, we'll find that this is like a 20 dB roll-off rate, actually, for the gain, which shows that it is having the integrator in it. So we don't need to put the integrator for the inner loop. More or less, we can see that these two, q and r, we see that it is positive, so we need to put the negative gain for this, for the negative feedback control.
So if you go down, that's what we did. We have put the negative gain for the q and r, and the only requirement right now is the bandwidth. So for that, it means we are giving a bandwidth of 30 radian per second, 22.5, or 37.5, for these three loops. And based on that, you have fr, which is finding out the magnitude of beta and then inversing. When you do that, 1 over that, you will find that Kp, the proportional gain for all three.
So this is how we are tuning it in this case. We are not bothered about the Ki in this case, the integrator thing, because already it is having the integration in it, so we are keeping it simple. And now we are again multiplying with these gains to the plant, and seeing the response to it. It looks very good, and then you can see that all of them are kind of-- negative feedback control is there.
In the last step, we are actually pushing this data to the MATLAB workspace, model workspace, and updating these values to the model. Let me open the model and show it to you. The-- then you would be appreciating that. So let me just open the Rate Control.
So I will just show you that what, in all, blocks are available. So if you go in the top-level model, you will find that we have this controller, which is taking a lot of inputs from the air data and the sensor and the guidance, as a command it is taking, and finally, when you go inside that controller, you will find this control is implemented over here.
So in this case, it means these are the inner loop-- so Kp, Kq, and Kr-- which is getting multiplied, and then we are calculating the error out of it. So this is the command, and this is the feedback, feedback rates. And these are the proportional gains scheduled, actually, whatever we got from there.
So now we'll be delving into the outer loop control. In the outer-loop control, you can see that both the Kp and Ki are available. This is the Pi control, and these are gain scheduled. So because of that, you can see that it is coming from the outside. So one is from the function, quadratic function, and another one is from the lookup table, which is point-based calculation, which is the integrator.
In the outer loop, you see that the demand is coming, input, and by angle of attack and sideslip angle, is coming as a feedback. Error is getting calculated, and finally, it is getting multiplied with the PID to create the inner-loop pqr commands. So this is a very simple one. It is not very intuitive, like this, so I just kept it over here so that it can be kind of-- you can see one on one.
All right, so let me take you to the last script, where we'll be talking about tuning the attitude control. So we are loading the classical control in the variant subsystem. And this time, we are kind of, again, substituting the blocks, because we are doing the outer-loop tuning, so we don't need the inner loop. In this case, inner loop, we are replacing that product block with all the values we got it from there. So it is-- ss(Kp) will create the D matrix of the state space, and it will replace, it will replace the product by the array of the values, which you can see over here.
So once you do that, you can look into that Tuner block and see that means, What are the analysis points? Like, over here, it is listed out. You can see that one of the blocks, the chief substitution, has been done, so all these things will be visible to you. You can just click it, and it will take you to that and analyze that further.
Then you can get the transfer function out of it. So this is not the tuned one, so it is without tuning the transfer functions we are taking out from the demand, which is the input to the outer loop, and this is the output of the outer loop. So input and output, you have to define to get the transfer function, and once it is gotten, we can run the step command to see how it behaves.
So you can see over here that we are having this kind of command. So this is for the phi, this is for the alpha, and this is for the beta. And these are the disturbances, How disturbances can come to the other loop, it can be seen over here.
So if you go ahead and tune the controller for the TuningGoals-- like, here you see that we have the TuningGoals defined for-- there are multiple objectives we can create over here. So one of the tuning goals is that it should have this kind of frequency response. So basically, if you see here, it's 0.5, value of the frequency, and the magnitude is 1.
1 is like G or dB, and 0.5 is the value. So if you see closely here, I can show you that that this is zero, so this part your dropdown, so you'll find that it is 5. So at 0.5, you have the 1's, and this rolling will be 1 based on the integrated, which is 20 dB per decade.
So this, what is the goal we are setting it, one of the goals we are setting it and viewing it? Similarly, we can set the other goal for the MaxLoopGain, and we can define it, too, using the transfer function this time. So there are multiple ways you can define the TuningGoals.
So there are two ways we define it, and the third way, with varying function, we'll be defining. So we are defining the gain margin for all 40 different things. For the corner, we are keeping it a little less, gain margin and phase margin of 7 and 45.
And we are passing it to the anonymous functions, and we are defining it through the varyingGoal, the value of the gain margin, and phase margin. So this is our goal 3. So once all three gains has been done, so we'll be using these gains-- goals, tuning goals, for doing the tuning activity.
Now we need to define, OK, what kind of the block we want to tune. So here you can see that the TunedBlocks are defined. Like, this time, we want to define the proportional gains for the phi, alpha, beta, which is the outer loop, and integral gains for the phi, alpha, beta, which is, again, the outer loop.
So once TunedBlocks is defined, we can add that, and we can define that for what grid of Alpha Beta we want to do that. We can define the surface for the proportional and integral gain. You can see that by default we are giving the value of 0.5 right now and minus 0.5-- 0.05. So these are the values we are defining over here and here, and creating a surface out of it.
Now, here, the point to be noted that we are doing, the proportional gain using the polyBasis, it means that quadratic polynomial equation will be created in this case, while in the case of the integral, it is ndBasis, means it will be created lookup-table based. So that is the reason you see in the model that we have a function defined for the P, while the lookup table is defined for the I. So it is upon you, what kind of thing you want, and right now, in our case we have taken the two different approaches to define surfaces.
And once you do that, we can use this very powerful command called systune to tune, for the given goals, the object we created for the tuner. Once you see that value is close to the 1, it means that you are meeting to the objectives. So the optimization algorithm has worked well, and then, it kind of satisfies all of the requirements which you have given through the tuning goals.
Finally, you can see the difference in between the previous baseline version and the tuned version, and whatever cross-coupling was happening in between the loops has also been minimized a lot because you are doing it at once. So that is the beauty of it. You are doing the multivariable tuning, multiloop tuning for the given multi-objectives at the same time. So because of that, the loop interaction becomes low, and you are getting a better response.
Finally, you can see how the gain has been tuned for the given alpha and beta. So these are the surfaces for the P and I, value for the alpha, beta, and phi, and you can visualize that and see how it has been changed. If it is too abrupt, like this, then you can actually increase the number of the operating points and do it again, so that means that kick in between the transition will be less.
In the Validation part, we can see that means we are updating that block to the model using the writeBlockValue, and once it is updated, you can do the simulation and see how the system is behaving. So you can see that roll command, it is pretty well, pretty well following. Our angle of attack is also following. And whatever the zero value, we don't want any sideslip, so because of that, you can see that this also is not more than two degrees.
So this is all about the trimming and linearization and doing the control for the inner loop and outer loop. So I would like to say that, what is the takeaway out of it, is the Aerospace Blockset. So Aerospace Blockset, we have a lot of different things.
We have talked about the Equation of Motion. We have talked about the Actuators. We have talked about the Flight Instruments. So there are, apart from that, means we have many other things, like the Pilot Model, like Guidance Navigation System.
Environmental, we talked about. Aerodynamics, we talked about. So apart from that, there are a lot of examples that are available, which you can look into that and learn about it. Spacecraft modeling is a different, entirely different thing, so this is also available along with this blockset.
We have also seen the different visualization techniques like Unreal Engine, the Instrument Panel. Flight Gear is another one which can be used to do the visualization part. Scope is the traditional way to see that, and there is a Data Inspector, which I think you can see like this. So once you have the system open, you can actually look into the Data Inspector, and if your simulation is done, you can populate these values and see that in the Data Inspector also.
All right, so this is the last slide for me, and the control system tuning, we have done using the programmatic method, not through the app. And you can see that we have used these functions for doing the operating system specification, finding the operating point, linearizing that, getting the transfer functions, setting the goals, and then, finally, tuning it using the command like slTuner and systune.
All right, so now I will invite Brijith, who has done a lot of model-based design work, and he he would like to show you what he has done. Brijith, over to you.
Yeah. Thanks, Mukesh. Thanks for the introduction. Yeah. So good afternoon.
So myself, Brijith Balakrishnan, I'm a systems engineer at Moog India Technology Center. So today, I would like to talk about electric propulsion system, especially in the context of urban air mobility. So in that, I will be discussing about the aspects of development process, typical architecture of an electric propulsion system, and the verification.
So what are electric propulsion systems, right? So it is a type of propulsion system that accelerate the propeller to generate the thrust using an electrical energy, with the help of some power conversion devices like a motor. So you might have seen that electrification is kind of a trend these days.
That's happening in almost everything, like automobiles or aircrafts, right? So have you thought about why, these days, people are more concerned about electrification? So a few of the reasons are, maybe in the aircraft level, it'll be like less fuel consumption, then emission and the noise, so, which makes the EPSA key focus for all of the governments as well as the private organizations or companies to start research on.
Now, yeah, let's start with looking into the development process. So development of a civil aircraft-- yeah, can you-- yeah. Development of civil aircraft and their systems, that includes the APS.
I would say it's a rigorous process, so that starts with a function definition for the aircraft, allocating the functions to the systems, and developing the system architecture and applying requirements and implementation. So in our case, I would say that thrust control is the aircraft function that is being assigned to the electric propulsion system. This is something what you see in that ARP documents as well.
So this process is iterative and concurrent with having a strong focus on ensuring safety and validation of the requirement. And another crucial part of this process is the safety evaluation. So that includes FHAs, Functional Hazards Assessment, so that identifies the potential failures that can occur during the operation.
So it finds out each function and classifies it based on the severity, actually, so severity of a function, right? So the severity of a function's failure, so that directly influences the development assurance level required for the function. Suppose if you look into that graph in the right side, so you can see that whenever the severity increases, like a catastrophic increase, you could see that's extremely improbable. So you should have something, a more reliable system for that purpose.
Then, Development Assurance System, or DAS, so that's kind of a measure of-- it's kind of a measure of a level of rigor required in the development process-- not only development process, during the verification as well. So more severe the function's failure condition, the higher the DAL requirement, what is required.
So you could see that, the left-side table-- so that is from EASA-- you could see that, and this is for electric vertical takeoff and landing vehicles, they have given. So you could see that whenever the catastrophic, more severity-- whenever there is a more severe function failure coming up, it should be assigned to the higher DAL level. That's kind of a DAL A or DAL B.
So I would say the development process is a rigorous activity, making sure in delivering more reliable systems. So now let's see so how a typical propulsion system architecture looks like. Can you go to the next slide?
Yeah, that's-- so this consists of a controller, a motor-- can be a PMSM motor-- and inverter for converting the power from DC to AC, and a propeller for generating the thrust. So controller is-- and also, nevertheless, the thermal management, you need to manage the heat generated inside the system, and you need to dissipate it properly.
So controller is something which manages the operation of the propeller systems. That includes torque, speed controls, then monitoring your systems, something like speed or temperature, and also monitoring the health of your sensor and the motor. And also, it can do some level of supervisory control, something like, if any event happens, right, you need to shut down the system or you need to switch to another controller.
Then comes, yeah, power conversion devices, so inverter over here, which converts that AC to DC power, and it also controls the power flow to the motor. Then the mechanical device, so propeller is a mechanical device which is connected to the motor through a shaft, so that will generate a thrust from the motor box.
Then the thermal management, as I told, right, most of the components, like whenever you develop a system which is compact, right, so most of the components will be-- size will be less, and you need to handle a higher power. So in that case, a lot of heat dissipation will happen, so you need to manage that heat dissipation properly. Otherwise, failure for that component will happen.
Then, yeah, here I have shown-- here only shown with only one architecture, like one controller inverter, so you can add more components into that. So that will induce a more redundant system so that if one fails, right, you can operate with the other component and save. So this is what is called redundant system. So redundancy is a strategy to reduce overall failure of the system. There is something like probability of occurrence of both failure, right, two systems failing at the same time, is less than one.
So whatever you have seen over the architecture, right, so that is being visualized through mathematical model in the MATLAB. So the propulsion system components and the system-level model has been developed using MATLAB and Simulink, using the model-based design. So one of the benefits of this mathematical model is it enabled the visualization of the system virtually through equations so that you can conduct simulations and analysis for the same. So this model can also be used to evaluate your controller algorithm with the plan model and optimize your controller responses. Can you go to the next slide, please?
So as I told, right, so we can visualize that system, whatever this EPS, using equation, through modeling. So once you develop the model, right, you need to check that model towards the industry standard, How did you model it? So Simulink Check is something helping us to check the developed model in an automatic way with different industry standards, like DO/MAB checks, and this was saving a lot of hours for us during the development phase.
So once you develop the model, including the plan as well as the controller, now you need to test it, so you will be developing your scripts for doing the tests. So once the script is developed, you will be conducting simulations, like iterative simulations, for the testing. So one of the tools what helps us is the Coverage Analysis tool. So once you enable that feature in the MATLAB and you run your test cases, it will show you the deviations from kind of the part of the model, right, which is not covered in your test cases, so that helps us in optimizing the test cases and also generating artifacts for the test.
Then another one is kind of a failure injection, so in our rigs, right, so whenever you want to do a failure injection, you need an expensive system, so prototype to inject the failure. So those things are modeled in MATLAB, and you can evaluate the same failure scenarios what have been identified in FHAs, and you can evaluate the model response over there.
So for that, responses, so there are some in-house tools developed for us-- that is, app-based design tools-- that we use for our test development and optimization and to run the tests in MATLAB. And this, what helps with this tool and MATLAB model, is like the test cases which we developed, right, so that can be matured before we start running in the actual rig or test.
And another one is test-case data visualization, test data visualization. So there are MATLAB scripts that are developed, so that saves a lot of hours visualizing the response. Right, say, either from the MATLAB or from the data from the rig, you can visualize seamlessly in that you can just analyze the responses, and you can find out whether it's a pass or fail.
Then the representation is something like what you need to submit to the customer at the end of your testing. So report generation also makes it seamlessly easy with the tools. So it was taking around-- manual writing of tests' reports was taking a hours long, but with the automation, right, we were able to bring down to within the minutes we were able to complete the reports. So it's like you do the test and generate the report the same day, so that it's ready for review.
Yeah, so-- sure, next slide, please. Yeah, so overall, I would say that the tool helps us in reducing the development time, so whether it is generating the documentation or else generating the test case or running the test case, maturing the test case, in all aspects, as well as in visualizing the data. So another benefit would-- we got it from the model, right.
So it's kind of the actual flight data, recorded data, can be directly fed into the model, and you can replicate the scenarios. And you can take the actions to rectify those failures which are not seen in our tests as well. So with this, I will conclude my talk.