Clarification on Recommended Workflow for Heterogeneous Engines

[OscarEspinosaBarcenas]

Hi Aviary Team,

I'm working on modeling an aircraft with two heterogeneous engines and I'm finding the integration process a bit confusing. I would be very grateful for some clarification on the recommended workflow.

Currently, my setup involves a main AviaryValues object, which I'll call inputs, where I define a single propulsion system (and other non-propulsion aircraft data) in detail. It looks something like this:

# My main AviaryValues object
inputs = av.AviaryValues()

# Propulsion and Engine variables are set directly
# ---------------------------
inputs.set_val(Aircraft.Propulsion.ENGINE_OIL_MASS_SCALER, 1.0)
inputs.set_val(Aircraft.Engine.DATA_FILE, 'path/to/single_engine.deck')
inputs.set_val(Aircraft.Engine.MASS, 18.0, units='lbm')
inputs.set_val(Aircraft.Engine.SCALED_SLS_THRUST, 115.2, units='lbf')
# ... and many other Aircraft.Engine.* variables

My goal is to replace this single-engine definition with two different engines, each with its own data deck. My understanding is that I need to:

1. Create two av.EngineDeck objects, one for each engine.
2. Run av.preprocess_propulsion() with a list of these engine objects.
3. Run prob.load_inputs() as before.

My main point of confusion is how to properly create these EngineDeck objects and how they interact with my main inputs object, which already contains values for a single engine.

My specific questions are:

1. Given that my inputs object already defines one engine, what is the correct way to introduce two new, different engines? Do I need to create a separate AviaryValues object for each engine's configuration?

2. For example, is this the correct approach?

   • First, create a dedicated AviaryValues for each engine to hold its unique data (like its deck file, mass, etc.).
   • Then, create the EngineDeck objects using these dedicated options.
   • Finally, run preprocess_propulsion, passing in my main inputs object.

   # Is this the correct workflow?
   
   # 1. Main AviaryValues object (without the detailed engine definitions)
   inputs = av.AviaryValues()
   # ... (all other non-propulsion aircraft data is set here)
   
   # 2. Configure Engine 1
   engine1_options = av.AviaryValues()
   engine1_options.set_val(av.Aircraft.Engine.DATA_FILE, 'path/to/engine_1.deck')
   engine1_options.set_val(av.Aircraft.Engine.MASS, 13.0, units='lbm')
   engine_1 = av.EngineDeck(name='engine_1', options=engine1_options)
   
   # 3. Configure Engine 2
   engine2_options = av.AviaryValues()
   engine2_options.set_val(av.Aircraft.Engine.DATA_FILE, 'path/to/engine_2.deck')
   engine2_options.set_val(av.Aircraft.Engine.MASS, 25.0, units='lbm') # A different mass
   engine_2 = av.EngineDeck(name='engine_2', options=engine2_options)
   
   # 4. Let preprocess handle the integration
   av.preprocess_propulsion(
       aviary_options=inputs,
       engine_models=[engine_1, engine_2]
   )

3. After running preprocess_propulsion, is it still correct to use prob.load_inputs(inputs, phase_info, verbosity=verbosity) to load all the aircraft and phase data, or does using the EngineDeck objects require a different approach for this step?

Thank you for your time and for developing such a powerful and flexible tool. Any guidance you can provide on this workflow would be extremely helpful.

Best regards,
Oscar Espinosa

[jkirk5]

Hey Oscar,
Your setup will definitely work, in fact we've used that same process for our internal testing of multi-engine setups. You can actually skip a step, which is individually calling preprocess_propulsion(), as that function is actually part of the prob.check_and_preprocess_inputs() step.

So, in pseudocode this is what the setup would look like once you've defined all your individual engine and full aircraft input sets:

engine1 = EngineDeck(name, engine1_inputs) # setup engine 1
engine2 = EngineDeck(name, engine2_inputs) # setup engine 2

# define problem
prob = AviaryProblem()
prob.load_inputs(full_input_set, phase_info, engine_builders=[engine1, engine2])
prob.check_and_preprocess_inputs()
# and the rest of the level2 API calls

[jkirk5]

If you want to see the test case I was talking about, it's this one here. We use a slightly fancier function (build_engine_deck()) for creating the EngineDeck object but that step is largely necessary. It does some checks on the AviaryValues you give to it and fills in missing variables with default values. If you don't get any errors related to missing variables, incorrect typing, etc. from your EngineDecks when you run your problem, you won't need that function.