input CL constraint / read runcase file

[costadelcos]

Hi,
I am trying to give a lift constraint for a series of runs with geometry variations.
In AVL, a runcase file can be read into the avl console before getting into OPER mode. Such a file would look like this (see below)
I have tried to get ABS to read the file before getting into OPER mode by adapting the run() and _default_keystroke_file_contents() functions in the AVL class. With no succes. I feel like there might be an easier way to impose such a lift constraint.

If someone could lend a hand that would be great!

 ---------------------------------------------
 Run case  1:   case1                            

 alpha        ->  CL          =   0.60000    
 beta         ->  beta        =   0.00000    
 pb/2V        ->  pb/2V       =   0.00000    
 qc/2V        ->  qc/2V       =   0.00000    
 rb/2V        ->  rb/2V       =   0.00000    

 alpha     =   0.00000     deg                             
 beta      =   0.00000     deg                             
 pb/2V     =   0.00000                                     
 qc/2V     =   0.00000                                     
 rb/2V     =   0.00000                                     
 CL        =   0.60000                                     
 CDo       =  0.00000                                 
 bank      =   0.00000     deg                             
 elevation =   0.00000     deg                             
 heading   =   0.00000     deg                             
 Mach      =  0.400000                                     
 velocity  =   137.2     Lunit/Tunit                     
 density   =   1.25     Munit/Lunit^3                   
 grav.acc. =   1.00000     Lunit/Tunit^2                   
 turn_rad. =   0.00000     Lunit                           
 load_fac. =   0.00000                                     
 X_cg      =   3.00000     Lunit                           
 Y_cg      =   0.00000     Lunit                           
 Z_cg      =  0.500000     Lunit                           
 mass      =   1.00000     Munit                           
 Ixx       =   1.00000     Munit-Lunit^2                   
 Iyy       =   1.00000     Munit-Lunit^2                   
 Izz       =   1.00000     Munit-Lunit^2                   
 Ixy       =   0.00000     Munit-Lunit^2                   
 Iyz       =   0.00000     Munit-Lunit^2                   
 Izx       =   0.00000     Munit-Lunit^2                   
 visc CL_a =   0.00000                                     
 visc CL_u =   0.00000                                     
 visc CM_a =   0.00000                                     
 visc CM_u =   0.00000                                     

[peterdsharpe]

Hi @costadelcos ,

I would recommend subclassing asb.AVL and making the following modifications:

• Overwrite the __init__ method to take in a CL parameter, and save it to self.CL.
• Overwrite the _default_keystroke_file_contents method, in particular this line:

  AeroSandbox/aerosandbox/aerodynamics/aero_3D/avl.py

  Line 359 in ca8c8b1

  f"a a {float(self.op_point.alpha)}",

  so that it maps to the desired CL.

Happy to help more, but would need a bit more detail about what exactly the barriers you're running into are, as well as precisely defining the discrepancies between observed and desired behavior.

[costadelcos]

Thanks for your reply!
As you said I added a CLparameter to the __init__ method and saved it to self.CL. Then I modified the line adding to the run_file_contents as follows. I assumed that I could just replace the second a to CL in f"a a {float(self.op_point.alpha)}", as I would do in the runcase file (not sure if it is exactly best practice):

        # Assign CL constraint to angle of attack variable if CL is given:
        if not self.CL == 0: 
            run_file_contents += [
                f"a CL {float(self.CL)}",
                f"b b {float(self.op_point.beta)}",
                f"r r {float(p_bar)}",
                f"p p {float(q_bar)}",
                f"y y {float(r_bar)}"
            ]
        else:
            run_file_contents += [
                f"a a {float(self.op_point.alpha)}",
                f"b b {float(self.op_point.beta)}",
                f"r r {float(p_bar)}",
                f"p p {float(q_bar)}",
                f"y y {float(r_bar)}"
            ]

The code is running fine when no CL is assigned. When I run the code with a given CL, I get the following error:

FileNotFoundError                         Traceback (most recent call last)
c:\dir\file.py in line 1
----> 53 res=ap.run()
      54 for k, v in res.items():
      55     if k=='CL' or k =='CD':

File c:\dir\file.py:232, in AVL.run(self, run_command)
    223     warnings.warn(
    224         "AVL run timed out!\n"
    225         "If this was not expected, try increasing the `timeout` parameter\n"
    226         "when you create this AeroSandbox XFoil instance.",
    227         stacklevel=2
    228     )
    230 ##### Parse the output file
    231 # Read the file
--> 232 with open(directory / output_filename, "r") as f:
    233     output_data = f.read()
    235 res = self.parse_unformatted_data_output(output_data, data_identifier=" =", overwrite=False)

FileNotFoundError: [Errno 2] No such file or directory: 'C:dir\\Temp\\tmpij6qlr4v\\output.txt'

As if the modification of the _default_keystroke_file_contents output prevents to parse the output file and to read the output data in the run() function. Not exactly sure what happens there to be honest..

[peterdsharpe]

Hey @costadelcos

This error message means that AVL didn't generate an output file, usually because it either crashed or encountered some other issue.

I've improved the error messages here to make it easier to troubleshoot; see here: 15b257b

Here is a fuller description from the new error message:

It appears AVL didn't produce an output file, probably because it crashed.
To troubleshoot, try some combination of the following:
	 - In the AVL constructor, verify that either AVL is on PATH or that the `avl_command` parameter is set.
	 - In the AVL constructor, run with `verbose=True`.
	 - In the AVL constructor, set the `working_directory` parameter to a known folder to see the AVL input and output files.
	 - In the AVL constructor, set the `timeout` parameter to a large number to see if AVL is just taking a long time to run.
	 - On Windows, use `avl.open_interactive()` to run AVL interactively in a new window.

Give these troubleshooting methods a shot, and let me know if you still have trouble here!

[costadelcos]

Got it working by looking at the AVL output with the verbose on, thanks man! It turns out AVL doesnt read the CL in
alpha -> CL = 0.60000 but only responds to c.

[peterdsharpe]

Glad to hear it! Good find!