How to Run the 'Wing.jl' using Actuator Surface Model(ASM) ?

[inse0918]

Hi, all.

I want to run the 'wing.jl' using Actuator Surface Model(ASM).

The ASM is vortex sheet + VLM.

The original code of the 'wing.jl' : running with ALM(Actuator Line Model: Lifting Line + VLM).

So I change the 'wing.jl' code with this LINK.

And the code is running well, but the number of particles is same with the original 'wing.jl' code.

Could you check this code for running the code with ASM ?

Thank you.
Best regards,
Inseo

ASM-example_pfield.log

*[Code(the .jl file does not uploaded,,,)]

import FLOWUnsteady as uns
import FLOWVLM as vlm
import FLOWVPM as vpm

run_name        = "ASM-example"            # Name of this simulation
save_path       = run_name                  # Where to save this simulation
paraview        = true                      # Whether to visualize with Paraview

# ----------------- SIMULATION PARAMETERS --------------------------------------
AOA             = 4.2                       # (deg) angle of attack
magVinf         = 49.7                      # (m/s) freestream velocity
rho             = 0.93                      # (kg/m^3) air density
qinf            = 0.5*rho*magVinf^2         # (Pa) static pressure

Vinf(X, t)      = magVinf*[cosd(AOA), 0.0, sind(AOA)]  # Freestream function

# ----------------- GEOMETRY PARAMETERS ----------------------------------------
b               = 2.489                     # (m) span length
ar              = 5.0                       # Aspect ratio b/c_tip
tr              = 1.0                       # Taper ratio c_tip/c_root
twist_root      = 0.0                       # (deg) twist at root
twist_tip       = 0.0                       # (deg) twist at tip
lambda          = 45.0                      # (deg) sweep
gamma           = 0.0                       # (deg) dihedral

# Discretization
n               = 50                        # Number of spanwise elements per side
r               = 10.0                      # Geometric expansion of elements
central         = false                     # Whether expansion is central

# ----------------- SOLVER PARAMETERS ------------------------------------------
# Time parameters
wakelength      = 2.75*b                    # (m) length of wake to be resolved
ttot            = wakelength/magVinf        # (s) total simulation time
nsteps          = 200                       # Number of time steps

# VLM and VPM parameters
p_per_step      = 1                         # Number of particle sheds per time step

lambda_vpm      = 2.0                       # VPM core overlap
sigma_vpm_overwrite = lambda_vpm * magVinf * (ttot/nsteps)/p_per_step # Smoothing core size
sigma_vlm_solver= -1                        # VLM-on-VLM smoothing radius (deactivated with <0)
sigma_vlm_surf  = 0.05*b                    # VLM-on-VPM smoothing radius

shed_starting   = true                      # Whether to shed starting vortex
vlm_rlx         = 0.7                       # VLM relaxation

# ----------------- 1) VEHICLE DEFINITION --------------------------------------
println("Generating geometry...")

# Generate wing
wing = vlm.simpleWing(b, ar, tr, twist_root, lambda, gamma;
                        twist_tip=twist_tip, n=n, r=r, central=central);

println("Generating vehicle...")

# Generate vehicle
system = vlm.WingSystem()                   # System of all FLOWVLM objects
vlm.addwing(system, "Wing", wing)

vlm_system = system;                        # System solved through VLM solver
wake_system = system;                       # System that will shed a VPM wake

vehicle = uns.VLMVehicle(   system;
                            vlm_system=vlm_system,
                            wake_system=wake_system
                         );


# ------------- 2) MANEUVER DEFINITION -----------------------------------------

Vvehicle(t) = zeros(3)                      # Translational velocity of vehicle over time
anglevehicle(t) = zeros(3)                  # Angle of the vehicle over time

angle = ()                                  # Angle of each tilting system (none)
RPM = ()                                    # RPM of each rotor system (none)

maneuver = uns.KinematicManeuver(angle, RPM, Vvehicle, anglevehicle)

# ------------- 3) SIMULATION DEFINITION ---------------------------------------

Vref = 0.0                                  # Reference velocity to scale maneuver by
RPMref = 0.0                                # Reference RPM to scale maneuver by
Vinit = Vref*Vvehicle(0)                    # Initial vehicle velocity
Winit = pi/180*(anglevehicle(1e-6) - anglevehicle(0))/(1e-6*ttot)  # Initial angular velocity

                                            # Maximum number of particles
max_particles = (nsteps+1)*(vlm.get_m(vehicle.vlm_system)*(p_per_step+1) + p_per_step)

simulation = uns.Simulation(vehicle, maneuver, Vref, RPMref, ttot;
                                                    Vinit=Vinit, Winit=Winit);

thickness_w     = 0.15                      # Wing airfoil thickness t/c

# ---------- Vortex sheet parameters ---------------
vlm_vortexsheet = true                      # Whether to spread the wing circulation as a vortex sheet
vlm_vortexsheet_overlap = 2.125             # Overlap of the particles that make the vortex sheet
vlm_vortexsheet_distribution = uns.g_pressure   # Distribution of the vortex sheet

sigma_vlm_surf  = b/100         # Smoothing radius of lifting bound vorticity
vlm_vortexsheet_sigma_tbv = thickness_w*(b/ar) / 100 # Smoothing radius of trailing bound vorticity

vlm_vortexsheet_maxstaticparticle = 1000000 # How many particles to preallocate for the vortex sheet


# ---------- Force calculation parameters ----------
KJforce_type                = "regular"     # KJ force evaluated at middle of bound vortices
# KJforce_type              = "averaged"  # KJ force evaluated at average vortex sheet
# KJforce_type              = "weighted"  # KJ force evaluated at strength-weighted vortex sheet

include_trailingboundvortex = false         # Include trailing bound vortices in force calculations

include_freevortices        = false         # Include free vortices in force calculation
include_freevortices_TBVs   = false         # Include trailing bound vortex in free-vortex force

include_unsteadyforce       = true          # Include unsteady force
add_unsteadyforce           = false         # Whether to add the unsteady force to Ftot or to simply output it

include_parasiticdrag       = true          # Include parasitic-drag force
add_skinfriction            = true          # If false, the parasitic drag is purely parasitic, meaning no skin friction
calc_cd_from_cl             = false         # Whether to calculate cd from cl or effective AOA
wing_polar_file             = "xf-rae101-il-1000000.csv"    # Airfoil polar for parasitic drag

# ---------- Aerodynamic forces --------------

forces = []
data_path       = uns.def_data_path         # Path to rotor database
speedofsound    = 342.35                    # (m/s) speed of sound
magVvehicle = 0
magVref         = sqrt(magVinf^2 + magVvehicle^2) # (m/s) reference velocity

# Calculate Kutta-Joukowski force
# kuttajoukowski = uns.generate_calc_aerodynamicforce_kuttajoukowski(KJforce_type,
#                                 sigma_vlm_surf, sigma_rotor_surf,
#                                 vlm_vortexsheet, vlm_vortexsheet_overlap,
#                                 vlm_vortexsheet_distribution,
#                                 vlm_vortexsheet_sigma_tbv;
#                                 vehicle=vehicle)
# push!(forces, kuttajoukowski)

# Free-vortex force
if include_freevortices
    freevortices = uns.generate_calc_aerodynamicforce_freevortices(
                                            vlm_vortexsheet_maxstaticparticle,
                                            sigma_vlm_surf,
                                            vlm_vortexsheet,
                                            vlm_vortexsheet_overlap,
                                            vlm_vortexsheet_distribution,
                                            vlm_vortexsheet_sigma_tbv;
                                            Ffv=uns.Ffv_direct,
                                            include_TBVs=include_freevortices_TBVs
                                            )
    push!(forces, freevortices)
end

# Force due to unsteady circulation
if include_unsteadyforce
    unsteady(args...; optargs...) = uns.calc_aerodynamicforce_unsteady(args...; add_to_Ftot=add_unsteadyforce, optargs...)

    push!(forces, unsteady)
end

# Parasatic-drag force (form drag and skin friction)
if include_parasiticdrag
    parasiticdrag = uns.generate_aerodynamicforce_parasiticdrag(wing_polar_file;
                                                            read_path=joinpath(data_path, "airfoils"),
                                                            calc_cd_from_cl=calc_cd_from_cl,
                                                            add_skinfriction=add_skinfriction,
                                                            Mach=speedofsound!=nothing ? magVref/speedofsound : nothing)
    push!(forces, parasiticdrag)
end


# Stitch all the forces into one function
function calc_aerodynamicforce_fun(vlm_system, args...; per_unit_span=false, optargs...)

    # Delete any previous force field
    fieldname = per_unit_span ? "ftot" : "Ftot"
    if fieldname in keys(vlm_system.sol)
        pop!(vlm_system.sol, fieldname)
    end

    Ftot = nothing

    for (fi, force) in enumerate(forces)
        Ftot = force(vlm_system, args...; per_unit_span=per_unit_span, optargs...)
    end

    return Ftot
end

# ------------- 4) MONITORS DEFINITIONS ----------------------------------------

D_dir = [cosd(AOA), 0.0, sind(AOA)]         # Direction of drag
L_dir = uns.cross(D_dir, [0,1,0])           # Direction of lift

figs, figaxs = [], []                       # Figures generated by monitor

# Generate wing monitor
monitor_wing = uns.generate_monitor_wing(wing, Vinf, b, ar,
                                            rho, qinf, nsteps;
                                            calc_aerodynamicforce_fun=calc_aerodynamicforce_fun,
                                            L_dir=L_dir,
                                            D_dir=D_dir,
                                            out_figs=figs,
                                            out_figaxs=figaxs,
                                            save_path=save_path,
                                            run_name=run_name,
                                            include_trailingboundvortex=include_trailingboundvortex,
                                            figname="wing monitor",
                                            );

println("Running simulation...")

uns.run_simulation(simulation, nsteps;
                    # ----- SIMULATION OPTIONS -------------
                    Vinf=Vinf,
                    rho=rho,
                    # ----- SOLVERS OPTIONS ----------------
                    p_per_step=p_per_step,
                    max_particles=vlm_vortexsheet_maxstaticparticle,
                    sigma_vlm_solver=sigma_vlm_solver,
                    sigma_vlm_surf=sigma_vlm_surf,
                    sigma_rotor_surf=sigma_vlm_surf,
                    sigma_vpm_overwrite=sigma_vpm_overwrite,
                    shed_starting=shed_starting,
                    vlm_rlx=vlm_rlx,
                    extra_runtime_function=monitor_wing,
                    vlm_vortexsheet=vlm_vortexsheet,
                    vlm_vortexsheet_overlap=vlm_vortexsheet_overlap,
                    vlm_vortexsheet_distribution=vlm_vortexsheet_distribution,
                    vlm_vortexsheet_sigma_tbv=vlm_vortexsheet_sigma_tbv,
                    max_static_particles=vlm_vortexsheet_maxstaticparticle,
                    # ----- OUTPUT OPTIONS ------------------
                    save_path=save_path,
                    run_name=run_name
                    );

[EdoAlvarezR]

Hi Inseo!

Indeed, the number of particles printed on screen (and the log file) should stay the same. When you pull up the *_pfield.*.xmf in ParaView you should also see no difference. However, the field of static particles that is saved under *_staticpfield.*.xmf should have a considerably larger amount of particles discretizing the entire surface.

Would you mind pulling up the *_staticpfield.*.xmf files in ParaView and confirming that?

---

P.S. As I mention in the docs, ASM is needed for cases with very strong wake interactions (e.g., a prop wake impinging directly on a wing surface). For anything else, like the isolated wing example under wing.jl, the actuator line model (ALM) will give as good of a result but with considerably lower computational resources.

[inse0918]

Hi Ed.

Thank you for your kind reply !

Now I'm running the code and I'll check the *_staticpfield.*.xmf and confirm it soon.

I want to validate the propeller-wing interaction(interference) for analysis DEP Aircraft.

I create the propeller-wing interaction script by using FLOWUnsteady source code.

But the result of the ALM is not good as you mentioned.

So I want to check the effect of the ASM on wing first.

But the Lift coefficient(section) is not fit with Gamma(Circulation) like this.

This results of the Cl is unreal...

================================================================================

Was the wing(PROWIM by Veldhuis) taken into account as ASM in this calculation ?

Could you upload the PROWIM validation code if you can (your choice of course !) ?

Thank you
Best regards,
Inseo

[inse0918]

Hi Ed.

I checked the large amount of the particles on the wing surface.

The point on the surface looks like collocation point in vortex lattice method.

So, you mean that the ASM(with Vortex sheet) can calculate the aerodynamic coefficient of the wing using high resolution better than ALM(With Lifting Line).

And then, Propeller-wing interaction can be solved by ASM with high resolution of the wing surface as you mentioned.

But the section aerodynamic data and wing aerodynamic coefficient still weird.

ASM-example_pfield.log
ASM-example_convergence.csv

Can you check it ? I think the ASM script that I wrote is something wrong.

Thank you.
Best regards,
Inseo.

[Turbulence1116]

Hi, how did you manage to visualise these shedding particles and the elements on the wing? I can only see the wing is moving or the rotor is spinning. Thanks.

[Turbulence1116]

I did not load the pfield.xmf file, therefore there was no particle field

[inse0918]

Hi, I checked too late sorry ...
Did you solve the problem ?
Thank you.
Inseo.

[Turbulence1116]

Hi Inseo, no worries, it was my mistake :)

[inse0918]

Hi, It's been a while.

I made the ASM code with reference to vahana.jl code.

Here is the ASM code that can analysis the wing aerodynamic force with Actuator Surface Model.

import FLOWUnsteady as uns
import FLOWUnsteady: vlm, vpm, gt, Im


run_name        = "ASM-example"            # Name of this simulation
BasePath = "/home/inse0918/.julia/packages/FLOWUnsteady/Jl5A6/Results/ASM"

add_wings       = true                      # Whether to include wings
save_path       = run_name                  # Where to save this simulation
paraview        = true                      # Whether to visualize with Paraview
data_path       = uns.def_data_path         # Path to rotor database

# ----------------- SIMULATION PARAMETERS --------------------------------------
AOA             = 4                       # (deg) angle of attack
magVinf         = 49.5                      # (m/s) freestream velocity
rho             = 0.93                      # (kg/m^3) air density
qinf            = 0.5*rho*magVinf^2         # (Pa) static pressure
speedofsound    = 342.35                    # (m/s) speed of sound
magVvehicle     = 0
magVref         = sqrt(magVinf^2 + magVvehicle^2) # (m/s) reference velocity
Vinf(X, t)      = magVinf*[cosd(AOA), 0.0, sind(AOA)]  # Freestream function
# VLM and VPM parameters
p_per_step      = 1                         # Number of particle sheds per time step

# ----------------- GEOMETRY PARAMETERS ----------------------------------------
b               = 1.28                     # (m) span length
ar              = 5.33333333333                       # Aspect ratio b/c_tip
tr              = 1.0                       # Taper ratio c_tip/c_root
twist_root      = 0.0                       # (deg) twist at root
twist_tip       = 0.0                       # (deg) twist at tip
lambda          = 20.0                      # (deg) sweep
gamma           = 0.0                       # (deg) dihedral
nsteps          = 10                       # Number of time steps

thickness_w     = 0.15                      # Wing airfoil thickness t/c
# Discretization
n               = 50                        # Number of spanwise elements per side
r               = 10.0                      # Geometric expansion of elements
central         = false                     # Whether expansion is central
shed_starting   = true                      # Whether to shed starting vortex
# ----------------- 1) VEHICLE DEFINITION --------------------------------------
println("Generating geometry...")

# Generate wing
wing = vlm.simpleWing(b, ar, tr, twist_root, lambda, gamma;
                        twist_tip=twist_tip, n=n, r=r, central=central);

# NOTE: `FLOWVLM.simpleWing` is an auxiliary function in FLOWVLM for creating a
#       VLM wing with constant sweep, dihedral, and taper ratio, and a linear
#       twist between the root and the wing tips

println("Generating vehicle...")

# Generate vehicle
system = vlm.WingSystem()                   # System of all FLOWVLM objects
vlm.addwing(system, "Wing", wing)

vlm_system = system;                        # System solved through VLM solver
wake_system = system;                       # System that will shed a VPM wake

vehicle = uns.VLMVehicle(   system;
                            vlm_system=vlm_system,
                            wake_system=wake_system
                         );
# ------------- 2) MANEUVER DEFINITION -----------------------------------------

Vvehicle(t) = zeros(3)                      # Translational velocity of vehicle over time
anglevehicle(t) = zeros(3)                  # Angle of the vehicle over time

angle = ()                                  # Angle of each tilting system (none)
RPM = ()                                    # RPM of each rotor system (none)

maneuver = uns.KinematicManeuver(angle, RPM, Vvehicle, anglevehicle)

vlm_rlx         = 0.7                       # VLM relaxation
Vref = 0.0                                  # Reference velocity to scale maneuver by
RPMref = 0.0                                # Reference RPM to scale maneuver by
Vinit = Vref*Vvehicle(0)                    # Initial vehicle velocity


wakelength      = 2.75*b                    # (m) length of wake to be resolved
ttot            = wakelength/magVinf        # (s) total simulation time
Winit = pi/180*(anglevehicle(1e-6) - anglevehicle(0))/(1e-6*ttot)  # Initial angular velocity
simulation = uns.Simulation(vehicle, maneuver, Vref, RPMref, ttot;
                                                    Vinit=Vinit, Winit=Winit);

# ---------- Vortex sheet parameters ---------------
vlm_vortexsheet = true                      # Whether to spread the wing circulation as a vortex sheet
vlm_vortexsheet_overlap = 2.125             # Overlap of the particles that make the vortex sheet
vlm_vortexsheet_distribution = uns.g_pressure   # Distribution of the vortex sheet

R = 0.75
sigma_vlm_surf  = b/100         # Smoothing radius of lifting bound vorticity
# Regularization of embedded vorticity
sigma_rotor_surf= R/20                      # Rotor-on-VPM smoothing radius
lambda_vpm      = 2.125                     # VPM core overlap
sigma_vpm_overwrite = lambda_vpm * magVinf * (ttot/nsteps)/p_per_step # Smoothing core size
sigma_vlm_solver= -1                        # VLM-on-VLM smoothing radius (deactivated with <0)
vlm_vortexsheet_sigma_tbv = thickness_w*(b/ar) / 100 # Smoothing radius of trailing bound vorticity

vlm_vortexsheet_maxstaticparticle = 1000000 # How many particles to preallocate for the vortex sheet
max_particles = (nsteps+1)*(vlm.get_m(vehicle.vlm_system)*(p_per_step+1) + p_per_step)

# ---------- Force calculation parameters ----------
KJforce_type                = "regular"     # KJ force evaluated at middle of bound vortices
# KJforce_type              = "averaged"  # KJ force evaluated at average vortex sheet
# KJforce_type              = "weighted"  # KJ force evaluated at strength-weighted vortex sheet

include_trailingboundvortex = false         # Include trailing bound vortices in force calculations

include_freevortices        = false         # Include free vortices in force calculation
include_freevortices_TBVs   = false         # Include trailing bound vortex in free-vortex force

include_unsteadyforce       = true          # Include unsteady force
add_unsteadyforce           = false         # Whether to add the unsteady force to Ftot or to simply output it

include_parasiticdrag       = true          # Include parasitic-drag force
add_skinfriction            = true          # If false, the parasitic drag is purely parasitic, meaning no skin friction
calc_cd_from_cl             = false         # Whether to calculate cd from cl or effective AOA
wing_polar_file             = "xf-n64015-il-1000000.csv"    # Airfoil polar for parasitic drag

# ---------- Aerodynamic forces --------------

forces = []

# Calculate Kutta-Joukowski force
kuttajoukowski = uns.generate_aerodynamicforce_kuttajoukowski(KJforce_type,
                                sigma_vlm_surf, sigma_rotor_surf,
                                vlm_vortexsheet, vlm_vortexsheet_overlap,
                                vlm_vortexsheet_distribution,
                                vlm_vortexsheet_sigma_tbv;
                                vehicle=vehicle)
push!(forces, kuttajoukowski)

# Free-vortex force
if include_freevortices
    freevortices = uns.generate_calc_aerodynamicforce_freevortices(
                                            vlm_vortexsheet_maxstaticparticle,
                                            sigma_vlm_surf,
                                            vlm_vortexsheet,
                                            vlm_vortexsheet_overlap,
                                            vlm_vortexsheet_distribution,
                                            vlm_vortexsheet_sigma_tbv;
                                            Ffv=uns.Ffv_direct,
                                            include_TBVs=include_freevortices_TBVs
                                            )
    push!(forces, freevortices)
end

# Force due to unsteady circulation
if include_unsteadyforce
    unsteady(args...; optargs...) = uns.calc_aerodynamicforce_unsteady(args...; add_to_Ftot=add_unsteadyforce, optargs...)

    push!(forces, unsteady)
end

# Parasatic-drag force (form drag and skin friction)
if include_parasiticdrag
    parasiticdrag = uns.generate_aerodynamicforce_parasiticdrag(wing_polar_file;
                                                            read_path=joinpath(data_path, "airfoils"),
                                                            calc_cd_from_cl=calc_cd_from_cl,
                                                            add_skinfriction=add_skinfriction,
                                                            Mach=speedofsound!=nothing ? magVref/speedofsound : nothing)
    push!(forces, parasiticdrag)
end


# Stitch all the forces into one function
function calc_aerodynamicforce_fun(vlm_system, args...; per_unit_span=false, optargs...)

    # Delete any previous force field
    fieldname = per_unit_span ? "ftot" : "Ftot"
    if fieldname in keys(vlm_system.sol)
        pop!(vlm_system.sol, fieldname)
    end

    Ftot = nothing

    for (fi, force) in enumerate(forces)
        Ftot = force(vlm_system, args...; per_unit_span=per_unit_span, optargs...)
    end

    return Ftot
end
D_dir = [cosd(AOA), 0.0, sind(AOA)]         # Direction of drag
L_dir = uns.cross(D_dir, [0,1,0])           # Direction of lift
figs, figaxs = [], []                       # Figures generated by monitor
# Extra options for generation of wing monitors

# Extra options for generation of wing monitors
wingmonitor_optargs = (
                        include_trailingboundvortex=include_trailingboundvortex,
                        calc_aerodynamicforce_fun=calc_aerodynamicforce_fun
                      )

# ------------- Create monitors
# Generate wing monitor
monitor_wing = uns.generate_monitor_wing(wing, Vinf, b, ar,
                                            rho, qinf, nsteps;
                                            calc_aerodynamicforce_fun=calc_aerodynamicforce_fun,
                                            L_dir=L_dir,
                                            D_dir=D_dir,
                                            out_figs=figs,
                                            out_figaxs=figaxs,
                                            save_path=save_path,
                                            run_name=run_name,
                                            figname="wing monitor",
                                            );

println("Running simulation...")

# ------------- 5) RUN SIMULATION ------------------------------------------
uns.run_simulation( simulation, nsteps;
                    # ----- SIMULATION OPTIONS -------------
                    Vinf=Vinf,
                    rho=rho,
                    # ----- SOLVERS OPTIONS ----------------
                    p_per_step=p_per_step,
                    max_particles=1000000,
                    sigma_vlm_solver=sigma_vlm_solver,
                    sigma_vlm_surf=sigma_vlm_surf,
                    sigma_rotor_surf=sigma_vlm_surf,
                    sigma_vpm_overwrite=sigma_vpm_overwrite,
                    shed_starting=shed_starting,
                    vlm_rlx=vlm_rlx,
                    extra_runtime_function=monitor_wing,
                    vlm_vortexsheet=vlm_vortexsheet,
                    vlm_vortexsheet_overlap=vlm_vortexsheet_overlap,
                    vlm_vortexsheet_distribution=vlm_vortexsheet_distribution,
                    vlm_vortexsheet_sigma_tbv=vlm_vortexsheet_sigma_tbv,
                    max_static_particles=vlm_vortexsheet_maxstaticparticle,
                    # ----- OUTPUT OPTIONS ------------------
                    save_path=save_path,
                    run_name=run_name
                    )

import FLOWUnsteady: cross, dot, norm, plt, @L_str
Xac         = [0.25*b/ar, 0, 0]             # (m) aerodynamic center for moment calculation
ls, ds      = [], []                        # Load and drag distributions
spanposs    = []                            # Spanwise positions for load distributions
# Integrate total lift and drag
L = sum(wing.sol["L"])
D = sum(wing.sol["D"])

# Lift and drag coefficients
CL = norm(L) / (qinf*b^2/ar)
CD = norm(D) / (qinf*b^2/ar)

# Control point of each element
Xs = [vlm.getControlPoint(wing, i) for i in 1:vlm.get_m(wing)]

# # Force of each element
Fs = wing.sol["Ftot"]

# Integrate the total moment with respect to aerodynamic center

M = sum( cross(X - Xac, F) for (X, F) in zip(Xs, Fs) )
Shat = [0, 1, 0]                            # Spanwise direction
Dhat = [cosd(AOA), 0.0, sind(AOA)]          # Direction of drag
Lhat = cross(Dhat, Shat)                    # Direction of lift

# Integrated moment decomposed into rolling, pitching, and yawing moments
lhat = Dhat                   # Rolling direction
mhat = Shat                   # Pitching direction
nhat = Lhat                   # Yawing direction

roll = dot(M, lhat)
pitch = dot(M, mhat)
yaw = dot(M, nhat)

# Sectional loading (in vector form) at each control point
fs = wing.sol["ftot"]

# Decompose vectors into lift and drag distribution
l = [ dot(f, Lhat) for f in fs ]
d = [ dot(f, Dhat) for f in fs ]

# Span position of each control point
spanpos = [ dot(X, Shat) / (b/2) for X in Xs ]

nondim = 0.5*rho*magVinf^2*b/ar   # Normalization factor

cls = l / nondim
cds = d / nondim

using DelimitedFiles
# saving the section aerodynamic data
writedlm(BasePath*"pos.dat", spanpos)
writedlm(BasePath*"cl.dat", cls)
writedlm(BasePath*"cd.dat", cds)

You can save the section aerodynamic data using *pos.dat, *cl.dat and *cd.dat.

Thank you,
Best regards,
Inseo.

[Turbulence1116]

There is no problem with the code, thanks for sharing. From the ALM to ASM, it is not straightforward. I think the wing is also discretised into 2D sections and loads are calculated from look-up table. There are significantly more control points on the wing surface than ALM, resulting a much greater simulation time.

[inse0918]

Oh, did you solve the problem about the loading files or any else ?
I'm glad that you ran the code.

I wanna compare the sectional lift coefficient data with the Veldhuis PROWIM data using this code.
But, the results are not fit with reference data ... like this

Did you validate the sectional aerodynamic load ?

Thank you.

Inseo.

[Turbulence1116]

Hey, thanks for getting back. I began to look into this last week. It is not too easy to setup the prowim case like in Veldhuis. The ASM is way too slow compare to ALM (maybe I made mistakes somewhere again?). The results I have so far on the clean wing is weired, the lift coefs are way too small. I am setting up the prowim case with reference to the Blown Wing tutorial, for the propeller position, xpos = [-1.5] (don't remember the exact number, I'll be in the office later today), but the propeller is always on the back to the wing, then I changed the inflow velocity direction, the results are really terrible. May I ask, how did you manage to put the propeller in the front of the wing?

[Turbulence1116]

Hi Inseo, my results look like this:

[inse0918]

Hi, did you solve the problem about the setting the propeller position ?

The result looks that you solved the setting the prop position about x location.

Can you share the bunch of the codes about ASM ?

Thank you.

email : [email protected]