Facing error while running uns.run_simulation

[HSP100]

hello, I am getting this error when running Simulation. How can I solve this error.?

uns.run_simulation(simulation, nsteps;
# ----- SIMULATION OPTIONS -------------
Vinf=Vinf,
rho=rho, mu=mu, sound_spd=speedofsound,
# ----- SOLVERS OPTIONS ----------------
p_per_step=p_per_step,
max_particles=max_particles,
vpm_integration=vpm_integration,
vpm_viscous=vpm_viscous,
vpm_SFS=vpm_SFS,
sigma_vlm_solver=sigma_vlm_solver,
sigma_vlm_surf=sigma_vlm_surf,
sigma_rotor_surf=sigma_rotor_surf,
sigma_vpm_overwrite=sigma_vpm_overwrite,
sigmafactor_vpmonvlm=sigmafactor_vpmonvlm,
vlm_rlx=vlm_rlx,
hubtiploss_correction=hubtiploss_correction,
shed_starting=shed_starting,
shed_unsteady=shed_unsteady,
unsteady_shedcrit=unsteady_shedcrit,
omit_shedding=omit_shedding,
extra_runtime_function=runtime_function,
# ----- RESTART OPTIONS -----------------
restart_vpmfile=restart_file,
# ----- OUTPUT OPTIONS ------------------
save_path=save_path,
run_name=run_name,
save_wopwopin=true, # <--- Generates input files for PSU-WOPWOP noise analysis
);

Folder WakeInteractionOfRotor-example already exists. Remove? (y/n) y

---

    SOLVER SETTINGS
              maxparticles----> 233765
               formulation----> formulation_rVPM
                   viscous----> (Symbol("*userfunction"), "FLOWVPM.Inviscid{Float64}(0.0)")
                    kernel----> gaussianerf
                        UJ----> UJ_fmm
                      Uinf----> (Symbol("*userfunction"), "#147")
                       SFS----> SFS_none
               integration----> euler
                transposed----> true
                relaxation----> pedrizzetti
                       fmm----> FLOWVPM.FMM(4, 50, 0.4, 0.5)

    SIMULATION SETTINGS
            dt:                     0.00030864197530864197
            Runtime function:       Yes
            Static particles:       Yes
            nsteps_save:            1

---

---

START WakeInteractionOfRotor-example/WakeInteractionOfRotor-example_pfield
2023-06-13T11:21:37.181

---

    Time step 0 out of 360  Particles: 0

ERROR: KeyError: key "Gamma" not found
Stacktrace:
[1] getindex(h::Dict{String, Any}, key::String)
@ Base ./dict.jl:498
[2] precalculations(self::FLOWUnsteady.UVLMVehicle{1, 1, Float64}, Vinf::Function, pfield::FLOWVPM.ParticleField{Float64, FLOWVPM.ReformulatedVPM{Float64}, FLOWVPM.Inviscid{Float64}, FLOWVPM.NoSFS{Float64}}, t::Float64, dt::Float64, nt::Int64)
@ FLOWUnsteady ~/.julia/packages/FLOWUnsteady/Jl5A6/src/FLOWUnsteady_vehicle_vlm.jl:159
[3] precalculations
@ ~/.julia/packages/FLOWUnsteady/Jl5A6/src/FLOWUnsteady_simulation_types.jl:151 [inlined]
[4] (::FLOWUnsteady.var"#runtime_function#161"{FLOWUnsteady.var"#runtime_function#149#162"{typeof(Vinf), Float64, Float64, Float64, FLOWUnsteady.var"#monitor#370"{FLOWUnsteady.var"#monitor#368#371"{Tuple{FLOWUnsteady.var"#monitor#370"{FLOWUnsteady.var"#monitor#368#371"{Tuple{FLOWUnsteady.var"#extra_runtime_function#338"{FLOWUnsteady.var"#extra_runtime_function#329#339"{typeof(L_dir), typeof(D_dir), Bool, FLOWUnsteady.var"#calc_aerodynamicforce#276"{FLOWUnsteady.var"#calc_aerodynamicforce#273#277"{Bool, FLOWUnsteady.var"#calc_aerodynamicforce_kuttajoukowski#285"{FLOWUnsteady.var"#calc_aerodynamicforce_kuttajoukowski#279#286"{Nothing, String, Nothing, Nothing, Bool, Nothing, Nothing, Nothing}}}}, Nothing, Nothing, Nothing, Nothing, String, String, Bool, FLOWUnsteady.var"#336#346", FLOWUnsteady.var"#337#347", Int64, Int64, Bool, FLOWVLM.Wing, typeof(Vinf), Float64, Float64, Float64, Float64, Int64, Float64}}, FLOWUnsteady.var"#extra_runtime_function#325"{FLOWUnsteady.var"#extra_runtime_function#323#326"{Float64, String, String, String, Bool, Bool, Int64, Int64, String, Vector{FLOWVLM.Rotor}, Float64, Float64, Int64, Int64}}}}}, typeof(wake_treatment_supress)}}}, Int64, Float64, Bool, Tuple{Tuple{Float64, Int64, Float64, Float64}, Tuple{Int64, Int64, Float64, Float64}}, Bool, Bool, Float64, Bool, Bool, Float64, Float64, Vector{Any}, Float64, Float64, Float64, Int64, Float64, String, String, Bool, Int64, Bool, Bool, FLOWUnsteady.Simulation{FLOWUnsteady.UVLMVehicle{1, 1, Float64}, FLOWUnsteady.KinematicManeuver{1, 1}, Float64}, FLOWVPM.ParticleField{Float64, FLOWVPM.ReformulatedVPM{Float64}, FLOWVPM.Inviscid{Float64}, FLOWVPM.NoSFS{Float64}}, Float64}})(PFIELD::FLOWVPM.ParticleField{Float64, FLOWVPM.ReformulatedVPM{Float64}, FLOWVPM.Inviscid{Float64}, FLOWVPM.NoSFS{Float64}}, T::Float64, DT::Float64; vprintln::FLOWVPM.var"#74#75"{Int64, Int64, FLOWVPM.var"#vprintln#114"{Bool, String}, Int64})
@ FLOWUnsteady ~/.julia/packages/FLOWUnsteady/Jl5A6/src/FLOWUnsteady_simulation.jl:277
[5] run_vpm!(pfield::FLOWVPM.ParticleField{Float64, FLOWVPM.ReformulatedVPM{Float64}, FLOWVPM.Inviscid{Float64}, FLOWVPM.NoSFS{Float64}}, dt::Float64, nsteps::Int64; runtime_function::FLOWUnsteady.var"#runtime_function#161"{FLOWUnsteady.var"#runtime_function#149#162"{typeof(Vinf), Float64, Float64, Float64, FLOWUnsteady.var"#monitor#370"{FLOWUnsteady.var"#monitor#368#371"{Tuple{FLOWUnsteady.var"#monitor#370"{FLOWUnsteady.var"#monitor#368#371"{Tuple{FLOWUnsteady.var"#extra_runtime_function#338"{FLOWUnsteady.var"#extra_runtime_function#329#339"{typeof(L_dir), typeof(D_dir), Bool, FLOWUnsteady.var"#calc_aerodynamicforce#276"{FLOWUnsteady.var"#calc_aerodynamicforce#273#277"{Bool, FLOWUnsteady.var"#calc_aerodynamicforce_kuttajoukowski#285"{FLOWUnsteady.var"#calc_aerodynamicforce_kuttajoukowski#279#286"{Nothing, String, Nothing, Nothing, Bool, Nothing, Nothing, Nothing}}}}, Nothing, Nothing, Nothing, Nothing, String, String, Bool, FLOWUnsteady.var"#336#346", FLOWUnsteady.var"#337#347", Int64, Int64, Bool, FLOWVLM.Wing, typeof(Vinf), Float64, Float64, Float64, Float64, Int64, Float64}}, FLOWUnsteady.var"#extra_runtime_function#325"{FLOWUnsteady.var"#extra_runtime_function#323#326"{Float64, String, String, String, Bool, Bool, Int64, Int64, String, Vector{FLOWVLM.Rotor}, Float64, Float64, Int64, Int64}}}}}, typeof(wake_treatment_supress)}}}, Int64, Float64, Bool, Tuple{Tuple{Float64, Int64, Float64, Float64}, Tuple{Int64, Int64, Float64, Float64}}, Bool, Bool, Float64, Bool, Bool, Float64, Float64, Vector{Any}, Float64, Float64, Float64, Int64, Float64, String, String, Bool, Int64, Bool, Bool, FLOWUnsteady.Simulation{FLOWUnsteady.UVLMVehicle{1, 1, Float64}, FLOWUnsteady.KinematicManeuver{1, 1}, Float64}, FLOWVPM.ParticleField{Float64, FLOWVPM.ReformulatedVPM{Float64}, FLOWVPM.Inviscid{Float64}, FLOWVPM.NoSFS{Float64}}, Float64}}, static_particles_function::FLOWUnsteady.var"#static_particles_function#10"{Bool, Float64, typeof(FLOWUnsteady.g_pressure), Nothing, String, String, String, Int64, FLOWVPM.ParticleField{Float64, FLOWVPM.ReformulatedVPM{Float64}, FLOWVPM.Inviscid{Float64}, FLOWVPM.NoSFS{Float64}}, FLOWUnsteady.UVLMVehicle{1, 1, Float64}, Float64, Float64, Bool}, save_path::String, create_savepath::Bool, run_name::String, save_code::String, nsteps_save::Int64, prompt::Bool, verbose::Bool, verbose_nsteps::Int64, v_lvl::Int64, save_time::Bool)
@ FLOWVPM ~/.julia/packages/FLOWVPM/WA9ug/src/FLOWVPM_utils.jl:115
[6] run_simulation(sim::FLOWUnsteady.Simulation{FLOWUnsteady.UVLMVehicle{1, 1, Float64}, FLOWUnsteady.KinematicManeuver{1, 1}, Float64}, nsteps::Int64; Vinf::typeof(Vinf), sound_spd::Float64, rho::Float64, mu::Float64, tquit::Float64, rand_RPM::Bool, extra_runtime_function::FLOWUnsteady.var"#monitor#370"{FLOWUnsteady.var"#monitor#368#371"{Tuple{FLOWUnsteady.var"#monitor#370"{FLOWUnsteady.var"#monitor#368#371"{Tuple{FLOWUnsteady.var"#extra_runtime_function#338"{FLOWUnsteady.var"#extra_runtime_function#329#339"{typeof(L_dir), typeof(D_dir), Bool, FLOWUnsteady.var"#calc_aerodynamicforce#276"{FLOWUnsteady.var"#calc_aerodynamicforce#273#277"{Bool, FLOWUnsteady.var"#calc_aerodynamicforce_kuttajoukowski#285"{FLOWUnsteady.var"#calc_aerodynamicforce_kuttajoukowski#279#286"{Nothing, String, Nothing, Nothing, Bool, Nothing, Nothing, Nothing}}}}, Nothing, Nothing, Nothing, Nothing, String, String, Bool, FLOWUnsteady.var"#336#346", FLOWUnsteady.var"#337#347", Int64, Int64, Bool, FLOWVLM.Wing, typeof(Vinf), Float64, Float64, Float64, Float64, Int64, Float64}}, FLOWUnsteady.var"#extra_runtime_function#325"{FLOWUnsteady.var"#extra_runtime_function#323#326"{Float64, String, String, String, Bool, Bool, Int64, Int64, String, Vector{FLOWVLM.Rotor}, Float64, Float64, Int64, Int64}}}}}, typeof(wake_treatment_supress)}}}, max_particles::Int64, max_static_particles::Nothing, p_per_step::Int64, vpm_formulation::FLOWVPM.ReformulatedVPM{Float64}, vpm_kernel::FLOWVPM.Kernel, vpm_UJ::typeof(FLOWVPM.UJ_fmm), vpm_SFS::FLOWVPM.NoSFS{Float64}, vpm_integration::typeof(FLOWVPM.euler), vpm_transposed::Bool, vpm_viscous::FLOWVPM.Inviscid{Float64}, vpm_fmm::FLOWVPM.FMM, vpm_relaxation::FLOWVPM.Relaxation{Float64}, vpm_surface::Bool, vlm_vortexsheet::Bool, vlm_vortexsheet_overlap::Float64, vlm_vortexsheet_distribution::typeof(FLOWUnsteady.g_pressure), vlm_vortexsheet_sigma_tbv::Nothing, vlm_rlx::Float64, vlm_init::Bool, hubtiploss_correction::Tuple{Tuple{Float64, Int64, Float64, Float64}, Tuple{Int64, Int64, Float64, Float64}}, wake_coupled::Bool, shed_unsteady::Bool, unsteady_shedcrit::Float64, shed_starting::Bool, shed_boundarylayer::Bool, boundarylayer_prescribedCd::Float64, boundarylayer_d::Float64, omit_shedding::Vector{Any}, sigma_vlm_solver::Int64, sigma_vlm_surf::Float64, sigma_rotor_surf::Float64, sigmafactor_vpm::Float64, sigmafactor_vpmonvlm::Int64, sigma_vpm_overwrite::Float64, restart_vpmfile::Nothing, save_path::String, run_name::String, create_savepath::Bool, prompt::Bool, verbose::Bool, v_lvl::Int64, verbose_nsteps::Int64, raisewarnings::Bool, debug::Bool, nsteps_save::Int64, nsteps_restart::Int64, save_code::String, save_horseshoes::Bool, save_static_particles::Bool, save_wopwopin::Bool)
@ FLOWUnsteady ~/.julia/packages/FLOWUnsteady/Jl5A6/src/FLOWUnsteady_simulation.jl:350
[7] top-level scope
@ REPL[715]:1

[inse0918]

Hi, Could you upload the full script of the run code ?

[HSP100]

yes Sure!

[HSP100]

#------------------Important imports ------------------------------------------
import FLOWUnsteady as uns
import FLOWVLM as vlm
import FLOWVPM as vpm

run_name = "WakeInteractionOfRotor-example" # Name of this simulation

save_path = run_name # Where to save this simulation
paraview = true # Whether to visualize with Paraview

#----------------- GEOMETRY PARAMETERS ----------------------------------------
#Back
b_back = 24.89 # (m) span length

#Rotor geometry
rotor_file = "DJI9443.csv" # Rotor geometry
data_path = uns.def_data_path # Path to rotor database
pitch = 0.0 # (deg) collective pitch of blades
CW = false # Clock-wise rotation
xfoil = false # Whether to run XFOIL
read_polar = vlm.ap.read_polar2 # What polar reader to use

#Front wing description
b_front = 0.75*b_back
ar_front = 5.0
tr_front = 1.0
twist_root_front= 5.0
twist_tip_front = 0.0
lambda_front = 0.0
gamma = 0.0

dx = 0.75*b_back # (m) spacing between back and front wings

#Discretization
n = 20 # Number of blade elements per blade
r = 1/10 # Geometric expansion of elements

n_front = 40
r_front = 10.0
central_front = false

#Read radius of this rotor and number of blades
R, B = uns.read_rotor(rotor_file; data_path=data_path)[[1,3]]

#----------------- SIMULATION PARAMETERS --------------------------------------
#Operating conditions

RPM = 5400 # RPM
J = 0.0001 # Advance ratio Vinf/(nD)
AOA = 0 # (deg) Angle of attack (incidence angle)

#Vehicle motion
magVvehicle = 1e-8 # (m/s) vehicle velocity
#AOA = 4.2 # (deg) angle of attack of back wing
frequency = 100.0 # (Hz) oscillation frequency in heaving motion
amplitude = 5.0 # (deg) AOA amplitude in heaving motion

#Freestream
magVinf = 49.7 # (m/s) freestream velocity
rho = 0.93 # (kg/m^3) air density
qinf = 0.5rhomagVinf^2 # (Pa) static pressure (reference)
mu = 1.85508e-5 # (kg/ms) air dynamic viscosity
speedofsound = 342.35 # (m/s) speed of sound

ReD = 2piRPM/60R * rho/mu * 2R # Diameter-based Reynolds number
Matip = 2piRPM/60 * R / speedofsound # Tip Mach number

Vinf(X, t) = magVinf*[1,0,0] # Freestream function
magVref = magVinf # (m/s) reference velocity (for calculation
# purposes since freestream is zero)

println("""
RPM: $(RPM)
Vinf: $(Vinf(zeros(3), 0)) m/s
Matip: $(round(Matip, digits=3))
ReD: $(round(ReD, digits=0))
""")

#----------------- SOLVER PARAMETERS ------------------------------------------

#Aerodynamic solver
VehicleType = uns.UVLMVehicle # Unsteady solver
const_solution = VehicleType==uns.QVLMVehicle # Whether to assume that the
# solution is constant or not

#Time parameters
nrevs = 10 # Number of revolutions in simulation
nsteps_per_rev = 36 # Time steps per revolution

nsteps = const_solution ? 2 : nrevsnsteps_per_rev # Number of time steps
wakelength = 4.0b_back # (m) length of wake to be resolved
ttot = nsteps/nsteps_per_rev / (RPM/60) # (s) total simulation time

#VLM and VPM parameters
sigma_vlm_solver= -1 # VLM-on-VLM smoothing radius (deactivated with <0)
# VPM smoothing radius

#VPM particle shedding
p_per_step = 2 # Sheds per time step
shed_starting = true # Whether to shed starting vortex
shed_unsteady = true # Whether to shed vorticity from unsteady loading
unsteady_shedcrit = 0.001 # Shed unsteady loading whenever circulation
# fluctuates by more than this ratio

#Regularization
sigma_vlm_surf = 0.05b_back # VLM-on-VPM smoothing radius
sigma_rotor_surf= R/10 # Rotor-on-VPM smoothing radius
lambda_vpm = 2.125 # VPM core overlap
# VPM smoothing radius
sigma_vpm_overwrite = lambda_vpm * 2piR/(nsteps_per_revp_per_step)
sigmafactor_vpmonvlm= 1 # Shrink particles by this factor when
# calculating VPM-on-VLM/Rotor induced velocities

#Rotor solver
hubtiploss_correction = ((0.4, 5, 0.1, 0.05), (2, 1, 0.25, 0.05)) # Hub and tip correction
vlm_rlx = 0.5 # VLM relaxation

#VPM solver
vpm_integration = vpm.euler # VPM temporal integration scheme

vpm_viscous = vpm.Inviscid() # VPM viscous diffusion scheme

vpm_SFS = vpm.SFS_none # VPM LES subfilter-scale model

if VehicleType == uns.QVLMVehicle
uns.vlm.VLMSolver._mute_warning(true)
end

#----------------- WAKE TREATMENT ---------------------------------------------

suppress_fountain = true # Toggle

#Supress wake shedding on blade elements inboard of this r/R radial station
no_shedding_Rthreshold = suppress_fountain ? 0.35 : 0.0

#Supress wake shedding for this many time steps
no_shedding_nstepsthreshold = 3*nsteps_per_rev

omit_shedding = [] # Index of blade elements to supress wake shedding

#Function to suppress or activate wake shedding
function wake_treatment_supress(sim, args...; optargs...)

# Case: start of simulation -> suppress shedding
if sim.nt == 1

    # Identify blade elements on which to suppress shedding
    for i in 1:vlm.get_m(rotor)
        HS = vlm.getHorseshoe(rotor, i)
        CP = HS[5]

        if uns.vlm.norm(CP - vlm._get_O(rotor)) <= no_shedding_Rthreshold*R
            push!(omit_shedding, i)
        end
    end
end

# Case: sufficient time steps -> enable shedding
if sim.nt == no_shedding_nstepsthreshold

    # Flag to stop suppressing
    omit_shedding .= -1

end

return false

end

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

#Generate rotor

#Generate front wing
frontwing = vlm.simpleWing(b_front, ar_front, tr_front, twist_root_front,
lambda_front, gamma; twist_tip=twist_tip_front,
n=n_front, r=r_front, central=central_front);

rotor = uns.generate_rotor(rotor_file; pitch=pitch,
n=n, CW=CW, blade_r=r,
altReD=[RPM, J, mu/rho],
xfoil=xfoil,
read_polar=read_polar,
data_path=data_path,
verbose=true,
plot_disc=true
);

#Move wing to the front
O = [-dx, 0.0, 0.0] # New position
Oaxis = uns.gt.rotation_matrix2(0.0, 0.0, 0.0) # New orientation
vlm.setcoordsystem(rotor, O, Oaxis; user = false)

println("Generating vehicle...")

#Places the front wing into its own system that will be heaving
heavingsystem = vlm.WingSystem() # Tilting system
vlm.addwing(heavingsystem, "FrontWing", frontwing)

#Generate vehicle
system = vlm.WingSystem() # System of all FLOWVLM objects
vlm.addwing(system, "Heaving", heavingsystem)
vlm.addwing(system, "Rotor", rotor)

tilting_systems = (heavingsystem, ); # Tilting systems

rotors = [rotor]; # Defining this rotor as its own system
rotor_systems = (rotors, ); # All systems of rotors

vlm_system = vlm.WingSystem() # System solved through VLM solver
vlm.addwing(vlm_system, "FrontWing", frontwing)
vlm.addwing(wake_system, "Rotor", rotor)

wake_system = vlm.WingSystem() # System of all FLOWVLM objects
vlm.addwing(wake_system, "Heaving", heavingsystem)
if VehicleType != uns.QVLMVehicle
vlm.addwing(wake_system, "Rotor", rotor)
end

#Pitch vehicle to its angle of attack
O = [0.0, 0.0, 0.0] # New position
Oaxis = uns.gt.rotation_matrix2(0, -AOA, 0) # New orientation
vlm.setcoordsystem(system, O, Oaxis)

vehicle = VehicleType( system;
tilting_systems=tilting_systems,
rotor_systems=rotor_systems,
vlm_system=vlm_system,
wake_system=wake_system
);

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

#Non-dimensional translational velocity of vehicle over time
Vvehicle(t) = [-1, 0, 0] # <---- Vehicle is traveling in the -x direction

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

#Control inputs
angle_frontwing(t) = [0, amplitudesin(2pifrequency * tttot), 0] # Tilt angle of front wing

#RPM control input over time (RPM over RPMref)
RPMcontrol(t) = 1.0

angle = (angle_frontwing, ) # Angle of each tilting system
RPMs = (RPMcontrol, ) # RPM of each rotor system (none)

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

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

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

                                        # Maximum number of particles

max_particles = ((2*n+1)B)nstepsp_per_step + 1 + (nsteps+1)2(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);

#Restart simulation
restart_file = nothing

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

#Generate function that computes aerodynamic forces
calc_aerodynamicforce_fun = uns.generate_calc_aerodynamicforce(;
add_parasiticdrag=true,
add_skinfriction=true,
airfoilpolar="xf-rae101-il-1000000.csv"
)

L_dir(t) = [0, 0, 1] # Direction of lift
D_dir(t) = [1, 0, 0] # Direction of drag

#Generate front wing monitor
monitor_frontwing = uns.generate_monitor_wing(frontwing, Vinf, b_front, ar_front,
rho, qinf, nsteps;
calc_aerodynamicforce_fun=calc_aerodynamicforce_fun,
L_dir=L_dir,
D_dir=D_dir,
save_path=save_path,
run_name=run_name*"-frontwing",
title_lbl="Front Wing",
figname="front-wing monitor",
)

#Generate rotor monitor
monitor_rotor = uns.generate_monitor_rotors(rotors, J, rho, RPM, nsteps;
t_scale=RPM/60, # Scaling factor for time in plots
t_lbl="Revolutions", # Label for time axis
save_path=save_path,
run_name=run_name,
figname="rotor monitor",
)

#Concatenate monitors
monitors = uns.concatenate(monitor_frontwing, monitor_rotor)

#------------- 5) RUN SIMULATION ----------------------------------------------
println("Running simulation...")
#Concatenate monitors and wake treatment procedure into one runtime function
runtime_function = uns.concatenate(monitors, wake_treatment_supress)

uns.run_simulation(simulation, nsteps;
# ----- SIMULATION OPTIONS -------------
Vinf=Vinf,
rho=rho, mu=mu, sound_spd=speedofsound,
# ----- SOLVERS OPTIONS ----------------
p_per_step=p_per_step,
max_particles=max_particles,
vpm_integration=vpm_integration,
vpm_viscous=vpm_viscous,
vpm_SFS=vpm_SFS,
sigma_vlm_solver=sigma_vlm_solver,
sigma_vlm_surf=sigma_vlm_surf,
sigma_rotor_surf=sigma_rotor_surf,
sigma_vpm_overwrite=sigma_vpm_overwrite,
sigmafactor_vpmonvlm=sigmafactor_vpmonvlm,
vlm_rlx=vlm_rlx,
hubtiploss_correction=hubtiploss_correction,
shed_starting=shed_starting,
shed_unsteady=shed_unsteady,
unsteady_shedcrit=unsteady_shedcrit,
omit_shedding=omit_shedding,
extra_runtime_function=runtime_function,
# ----- RESTART OPTIONS -----------------
restart_vpmfile=restart_file,
# ----- OUTPUT OPTIONS ------------------
save_path=save_path,
run_name=run_name,
save_wopwopin=true, # <--- Generates input files for PSU-WOPWOP noise analysis
);

#----------------- 6) VISUALIZATION -------------------------------------------
if paraview
println("Calling Paraview...")

# Files to open in Paraview
files = joinpath(save_path, run_name*"_pfield...xmf;")
files = run_name"_Heaving_FrontWing_vlm...vtk;"
#files = run_name"_pfield...xmf;"
for bi in 1:B
    global files
    files = run_name"_Rotor_Blade$(bi)_loft...vtk;"
    files = run_name"_Rotor_Blade$(bi)_vlm...vtk;"
end

# Call Paraview
run(`paraview --data=$(files)`)

end

[inse0918]

Hi, did you solve this problem ?

the script that you sent to me looks incomplete code as I think (if is not, sorry...)

for example, [angle_frontwing(t) = [0, amplitudesin(2pifrequency * tttot), 0] # Tilt angle of front wing] the calculation operator(*) is missing

and the [LoadError: Wing 'Rotor' already exists in the system. Use overwrite option.] error message pop on(in defining geometry)

I hope you solve the problem... ㅠㅠ

Thank you.

[inse0918]

For me, when I try to running the propeller wing interaction code, this error was popped up(not exact memory).

So, I wanna check the simulation script as I can.

[inse0918]

Oh, my memory is correct.

This is my result about the running the propeller-wing interaction script.

ASM.txt
This is my script that run the propeller wing interaction using ASM.

This script is not perfect running script.

[HSP100]

okay.. here is what I am getting .. I will share my script shortly

[HSP100]

hevingairfoil_rotor (1).txt

[inse0918]

Hi, How about this script ?

I checked your running script, and I found the somethings

First, the distance between the rotor and wing is very far.
And, I did not use the wake treatment option.
Last, the hub correction variables were very specific(I cannot assume what it is).

You can handle the number of the propellers and position and tilt angle.

heavePWI.txt

And, did you validate the propeller-wing interaction ?
Actually, this script assume the wing as a line modle(ALM).

I wanna validate the propeller wing interaction using Actuator Surface Model(ASM).

Thank you.