471 lines
15 KiB
Plaintext
471 lines
15 KiB
Plaintext
# ****************************************************************************
|
|
# CUI
|
|
#
|
|
# The Advanced Framework for Simulation, Integration, and Modeling (AFSIM)
|
|
#
|
|
# The use, dissemination or disclosure of data in this file is subject to
|
|
# limitation or restriction. See accompanying README and LICENSE for details.
|
|
# ****************************************************************************
|
|
# * * ************************************** * *
|
|
# * ****** Demonstration input file ****** *
|
|
# * ****** UNCLASSIFIED ****** *
|
|
# * * ************************************** * *
|
|
|
|
include_once signatures/fighter_sigs.txt
|
|
include_once sensors/esm_rwr/ucav_esm.txt
|
|
include_once weapons/jammer/soj_vhf_jammer.txt
|
|
include_once weapons/jammer/soj_sband_jammer.txt
|
|
include_once weapons/jammer/soj_xband_jammer.txt
|
|
|
|
# -------------------------------------------------------------------------
|
|
|
|
# script to make jamming assignemnts based on
|
|
# frequency band and FOV of the jamming weapons system.
|
|
|
|
processor SOJ_TASK_MGR WSF_TASK_PROCESSOR
|
|
|
|
#script_debug_writes on
|
|
#show_state_transitions
|
|
#show_task_messages
|
|
|
|
script_variables
|
|
# Track time since updated to consider track stale
|
|
double mTrackUpdateStaleTime = 10.0; # seconds
|
|
|
|
# MUST BE DIFFERENT FOR EACH JAMMER TASK MANAGER CONTROLLING DIFFERENT SYSTEMS
|
|
string mJamTaskStr = "SOJ_JAM"; # Reset to all caps in the on_initialize script below.
|
|
|
|
# Map of the previous signal count for the given track Id
|
|
Map<WsfTrackId, int> mSignalCountMap = Map<WsfTrackId, int>();
|
|
|
|
|
|
# Default technique to assign for threats not defined in mThreatTechniqueMap below
|
|
string mDefaultTechnique = "noise_jamming";
|
|
|
|
# Available types: noise_jamming, random_pulse_jamming, false_target_jamming,
|
|
# simple_false_target_jamming, track_error, jtos_gain_jamming
|
|
Map<string, struct> mThreatData = Map<string, struct>();
|
|
|
|
// EW Radar
|
|
struct ew_data = struct();
|
|
ew_data->mAssign = true;
|
|
ew_data->mTechnique = "noise_jamming";
|
|
#ew_data->mTechnique = "false_target_jamming";
|
|
|
|
//ACQ Radar
|
|
struct acq_data = struct();
|
|
acq_data->mAssign = true;
|
|
acq_data->mTechnique = "random_pulse_jamming";
|
|
|
|
//TTR Radar
|
|
struct ttr_data = struct();
|
|
ttr_data->mAssign = true;
|
|
ttr_data->mTechnique = "jtos_gain_jamming";
|
|
|
|
// Create data map for use by scripts
|
|
# Must be top level names or types, does not drill into sub-types
|
|
mThreatData["EW_RADAR"] = ew_data;
|
|
mThreatData["ACQ_RADAR"] = acq_data;
|
|
mThreatData["TTR_RADAR"] = ttr_data;
|
|
|
|
# Must be top level names or types, does not drill into sub-types
|
|
Map<string, bool> mWeaponAssignMap = Map<string, bool>();
|
|
mWeaponAssignMap["SOJ_VHF_JAMMER"] = true;
|
|
mWeaponAssignMap["SOJ_SBAND_JAMMER"] = true;
|
|
mWeaponAssignMap["SOJ_XBAND_JAMMER"] = true;
|
|
end_script_variables
|
|
|
|
on_initialize
|
|
mJamTaskStr = Name().Upper();
|
|
end_on_initialize
|
|
|
|
# Script to determine if the given threat is in the list
|
|
# and its status for assignments
|
|
script bool AllowTrack()
|
|
bool allowAssign = false;
|
|
int emitterCount = TRACK.EmitterCount();
|
|
for (int i = 0; i < emitterCount; i = i + 1)
|
|
{
|
|
string emitterType = TRACK.EmitterType(i);
|
|
if (emitterType == "")
|
|
{
|
|
emitterType = TRACK.TargetType();
|
|
}
|
|
|
|
if (mThreatData.Exists(TRACK.TargetName()) &&
|
|
mThreatData.Get(TRACK.TargetName())->mAssign)
|
|
{
|
|
return true;
|
|
}
|
|
else if (mThreatData.Exists(emitterType) &&
|
|
mThreatData.Get(emitterType)->mAssign)
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
return allowAssign;
|
|
end_script
|
|
|
|
# Script to determine if the given jammer is in the list
|
|
# and its status for assignments
|
|
# must be top level names or types, does not drill into sub-types
|
|
script bool AllowWeaponTasking(WsfWeapon aWeapon)
|
|
bool allowAssign = false;
|
|
if (aWeapon.IsValid() &&
|
|
aWeapon.IsA_TypeOf("WSF_RF_JAMMER"))
|
|
{
|
|
if (mWeaponAssignMap.Exists(aWeapon.Name()))
|
|
{
|
|
allowAssign = mWeaponAssignMap.Get(aWeapon.Name());
|
|
}
|
|
else if (mWeaponAssignMap.Exists(aWeapon.Type()))
|
|
{
|
|
allowAssign = mWeaponAssignMap.Get(aWeapon.Type());
|
|
}
|
|
}
|
|
return allowAssign;
|
|
end_script
|
|
|
|
# Script to determine the appropriate jammer types based on frequency
|
|
# must be top level names or types, does not drill into sub-types
|
|
script Map<string, bool> JammerTypes(double aFrequency)
|
|
Map<string, bool> jammerTypes = Map<string, bool>();
|
|
if (TRACK.FrequencyValid())
|
|
{
|
|
for (int i = 0; i < PLATFORM.WeaponCount(); i = i + 1)
|
|
{
|
|
WsfWeapon weapon = PLATFORM.WeaponEntry(i);
|
|
if (AllowWeaponTasking(weapon))
|
|
{
|
|
double minFreq = weapon.MinimumFrequency();
|
|
double maxFreq = weapon.MaximumFrequency();
|
|
if ((aFrequency >= minFreq) && (aFrequency <= maxFreq))
|
|
{
|
|
jammerTypes[weapon.Type()] = true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return jammerTypes;
|
|
end_script
|
|
|
|
# Script to determine the appropriate technique to use based on target type
|
|
script string TechniqueType(int aSignalIndex)
|
|
string techniqueType = mDefaultTechnique; // default technique
|
|
string emitterType = TRACK.SignalEmitterType(aSignalIndex);
|
|
if (emitterType == "")
|
|
{
|
|
emitterType = TRACK.TargetType();
|
|
}
|
|
|
|
if (TRACK.IsValid())
|
|
{
|
|
if (mThreatData.Exists(TRACK.TargetName()))
|
|
{
|
|
techniqueType = mThreatData.Get(TRACK.TargetName())->mTechnique;
|
|
}
|
|
else if (mThreatData.Exists(TRACK.TargetType()))
|
|
{
|
|
techniqueType = mThreatData.Get(emitterType)->mTechnique;
|
|
}
|
|
}
|
|
return techniqueType ;
|
|
end_script
|
|
|
|
# Script to determine the appropriate bandwidth to use based on technique
|
|
# Note: Could also add in the target type if required
|
|
script double Bandwidth(int aSignalIndex, double aPulsewidth)
|
|
double bandwidth = 1.e6; // default bandwidth
|
|
if (TechniqueType(aSignalIndex) == "false_target_jamming")
|
|
{
|
|
bandwidth = 1.0e6;
|
|
if (aPulsewidth > 0.0)
|
|
{
|
|
bandwidth = 1 / aPulsewidth;
|
|
}
|
|
}
|
|
else if (TechniqueType(aSignalIndex) == "random_pulse_jamming")
|
|
{
|
|
bandwidth = 1.5e6;
|
|
}
|
|
return bandwidth;
|
|
end_script
|
|
|
|
// Add spot for the current signal index in the track
|
|
script bool AddSpot(int aSignalIndex)
|
|
bool addedSpot = false;
|
|
WsfWeapon jammer;
|
|
Map<string, bool> requiredTypes = Map<string, bool>();
|
|
string jammerType = "";
|
|
double freq = TRACK.SignalFrequency(aSignalIndex);
|
|
requiredTypes = JammerTypes(freq);
|
|
for (int i=0; i < PLATFORM.WeaponCount(); i = i + 1)
|
|
{
|
|
jammer = PLATFORM.WeaponEntry(i);
|
|
jammerType = jammer.Type();
|
|
if (requiredTypes.Exists(jammerType))
|
|
{
|
|
if(PLATFORM.WithinFieldOfView(TRACK, jammer.Name()))
|
|
{
|
|
# check to see if any maximum spots have been allocated
|
|
if ((jammer.QuantityRemaining() > 0) || (jammer.MaximumRequestCount() == 1))
|
|
{
|
|
string jamStr = write_str(mJamTaskStr, aSignalIndex);
|
|
double pulsewidth = TRACK.SignalPW(aSignalIndex);
|
|
if (StartJamming(TRACK,
|
|
jamStr,
|
|
jammer,
|
|
freq,
|
|
Bandwidth(aSignalIndex, pulsewidth),
|
|
TechniqueType(aSignalIndex)))
|
|
{
|
|
writeln_d("T=", TIME_NOW, " ", PLATFORM.Name(), ":", jammer.Name(), " started jamming ",
|
|
TRACK.TargetName(), ":", TRACK.SignalEmitterType(aSignalIndex),
|
|
", task=", jamStr, " freq=", freq, " BW=", Bandwidth(aSignalIndex,pulsewidth),
|
|
" Technique=", TechniqueType(aSignalIndex));
|
|
addedSpot = true;
|
|
break; # only allow one weapon per assignment for now, script needs work to do more than one
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return addedSpot;
|
|
end_script
|
|
|
|
# Script to start jamming a track
|
|
script bool StartJammingTrack()
|
|
bool startedJamming = false;
|
|
int signalCount = TRACK.SignalCount();
|
|
mSignalCountMap[TRACK.TrackId()] = signalCount; // Update the signal count map
|
|
for (int signalIndex = 0; signalIndex < signalCount; signalIndex = signalIndex + 1)
|
|
{
|
|
if (AddSpot(signalIndex))
|
|
{
|
|
startedJamming = true;
|
|
}
|
|
}
|
|
return startedJamming;
|
|
end_script
|
|
|
|
# Script to update jamming assignments for a track
|
|
script void UpdateJammingTrack()
|
|
string reason = "UNKNOWN";
|
|
int curSignalCount = TRACK.SignalCount();
|
|
int prevSignalCount = mSignalCountMap[TRACK.TrackId()];
|
|
int loopSignalCount = MATH.Max(curSignalCount, prevSignalCount); # use the max to add/remove spots
|
|
for (int signalIndex = 0; signalIndex < loopSignalCount; signalIndex = signalIndex + 1)
|
|
{
|
|
bool addSpot = false;
|
|
|
|
string jamStr = write_str(mJamTaskStr, signalIndex);
|
|
|
|
WsfTaskList taskList = AssignedTaskList(TRACK.TrackId(), jamStr);
|
|
if (taskList.Count() == 0)
|
|
{
|
|
addSpot = true;
|
|
reason = "frequency added";
|
|
}
|
|
else if (taskList.Count() == 1)
|
|
{
|
|
WsfTask task = taskList.Entry(0);
|
|
bool needToStopJamming = true;
|
|
if (signalIndex >= curSignalCount)
|
|
{
|
|
reason = write_str("signal_", signalIndex, "_invalid");
|
|
}
|
|
else if (PLATFORM.WithinFieldOfView(TRACK, task.ResourceName()))
|
|
{
|
|
if (task.ResourceFrequency() == TRACK.SignalFrequency(signalIndex))
|
|
{
|
|
needToStopJamming = false;
|
|
}
|
|
|
|
if (needToStopJamming)
|
|
{
|
|
reason = "frequency change";
|
|
}
|
|
}
|
|
else
|
|
{
|
|
reason = "FOV limits";
|
|
}
|
|
|
|
if (needToStopJamming)
|
|
{
|
|
writeln_d("T=", TIME_NOW, " ", PLATFORM.Name(), ":", task.ResourceName(), " stopped jamming ",
|
|
TRACK.TargetName(), ":", TRACK.SignalEmitterType(signalIndex),
|
|
", task=", task.TaskType()," freq=", task.ResourceFrequency(),
|
|
" due to ", reason);
|
|
if (CancelTask(task.TrackId(), task.TaskType(), task.ResourceName()))
|
|
{
|
|
addSpot = true;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
# script setup for single jamming task for now, needs work for multiples?
|
|
writeln("*****WARNING: More than one task found in.", PLATFORM.Name(), " jamming script.");
|
|
}
|
|
|
|
if (addSpot)
|
|
{
|
|
AddSpot(signalIndex);
|
|
}
|
|
}
|
|
mSignalCountMap[TRACK.TrackId()] = curSignalCount;
|
|
end_script
|
|
|
|
# script to stop jamming against the current track
|
|
script void StopJammingTrack(string aReasonStr)
|
|
WsfTaskList taskList = AssignedTaskList(TRACK.TrackId(), "");
|
|
foreach(WsfTask task in taskList)
|
|
{
|
|
if (task.ResourceIsJammer() && task.TaskType().StartsWith(mJamTaskStr))
|
|
{
|
|
writeln_d("T=", TIME_NOW, " ", PLATFORM.Name(), ":", task.ResourceName(), " stopped jamming ",
|
|
TRACK.TargetName(), ", task=", task.TaskType()," freq=", task.ResourceFrequency(),
|
|
" due to ", aReasonStr);
|
|
if (! CancelTask(task.TrackId(), task.TaskType(), task.ResourceName()))
|
|
{
|
|
writeln_d("FAILED");
|
|
}
|
|
}
|
|
}
|
|
end_script
|
|
|
|
# script to determine if platform is still jamming current track
|
|
script bool StoppedJammingTrack()
|
|
bool stoppedJammingTrack = true;
|
|
WsfTaskList taskList = AssignedTaskList(TRACK.TrackId(),"");
|
|
foreach(WsfTask task in taskList)
|
|
{
|
|
if (task.ResourceIsJammer() && task.TaskType().StartsWith(mJamTaskStr))
|
|
{
|
|
stoppedJammingTrack = false;
|
|
}
|
|
}
|
|
|
|
if (stoppedJammingTrack)
|
|
{
|
|
writeln_d("T=", TIME_NOW, " ", PLATFORM.Name(), " stopped jamming track ",
|
|
TRACK.TargetName(), " due to all jamming assignments being stopped");
|
|
mSignalCountMap.Erase(TRACK.TrackId());
|
|
}
|
|
return stoppedJammingTrack;
|
|
end_script
|
|
|
|
# -------------------------------------------------------------------------
|
|
|
|
evaluation_interval DETECTED 1.0 sec
|
|
state DETECTED
|
|
next_state CAN_JAM
|
|
return ((TRACK.TimeSinceUpdated() < mTrackUpdateStaleTime) && AllowTrack());
|
|
end_next_state
|
|
end_state
|
|
|
|
evaluation_interval CAN_JAM 1.0 sec
|
|
state CAN_JAM
|
|
next_state DETECTED
|
|
return (TRACK.TimeSinceUpdated() >= mTrackUpdateStaleTime);
|
|
end_next_state
|
|
|
|
next_state IS_JAMMING
|
|
return StartJammingTrack();
|
|
end_next_state
|
|
end_state
|
|
|
|
evaluation_interval IS_JAMMING 1.0 sec
|
|
state IS_JAMMING
|
|
next_state CAN_JAM
|
|
if (TRACK.TimeSinceUpdated() < mTrackUpdateStaleTime)
|
|
{
|
|
UpdateJammingTrack();
|
|
}
|
|
else
|
|
{
|
|
StopJammingTrack("STALE_TRACK");
|
|
}
|
|
return StoppedJammingTrack();
|
|
end_next_state
|
|
end_state
|
|
end_processor
|
|
|
|
# -------------------------------------------------------------------------
|
|
|
|
platform_type SOJ WSF_PLATFORM
|
|
icon weasel
|
|
|
|
infrared_signature FIGHTER_INFRARED_SIG
|
|
optical_signature FIGHTER_OPTICAL_SIG
|
|
radar_signature FIGHTER_RADAR_SIG
|
|
|
|
sensor esm UCAV_ESM
|
|
on
|
|
internal_link data_mgr
|
|
ignore_same_side
|
|
end_sensor
|
|
|
|
mover WSF_AIR_MOVER
|
|
default_radial_acceleration 2.0 g
|
|
at_end_of_path remove
|
|
end_mover
|
|
|
|
weapon fwd_vhf_jammer SOJ_VHF_JAMMER
|
|
off
|
|
ignore_same_side
|
|
end_weapon
|
|
|
|
weapon aft_vhf_jammer SOJ_VHF_JAMMER
|
|
off
|
|
yaw 180.0 deg
|
|
ignore_same_side
|
|
end_weapon
|
|
|
|
weapon fwd_sband_jammer SOJ_SBAND_JAMMER
|
|
off
|
|
ignore_same_side
|
|
end_weapon
|
|
|
|
weapon aft_sband_jammer SOJ_SBAND_JAMMER
|
|
off
|
|
yaw 180.0 deg
|
|
ignore_same_side
|
|
end_weapon
|
|
|
|
weapon fwd_xband_jammer SOJ_XBAND_JAMMER
|
|
off
|
|
ignore_same_side
|
|
end_weapon
|
|
|
|
weapon aft_xband_jammer SOJ_XBAND_JAMMER
|
|
off
|
|
yaw 180.0 deg
|
|
ignore_same_side
|
|
end_weapon
|
|
|
|
processor data_mgr WSF_TRACK_PROCESSOR
|
|
purge_interval 60.0 sec
|
|
end_processor
|
|
|
|
processor soj_task_mgr SOJ_TASK_MGR
|
|
end_processor
|
|
end_platform_type
|
|
|
|
route soj_orbit
|
|
navigation
|
|
label start
|
|
offset 20 0 km speed 450 kts altitude 35000 ft msl
|
|
radial_acceleration 2 g
|
|
offset 20 5 km speed 450 kts altitude 35000 ft msl
|
|
radial_acceleration 2 g
|
|
offset 0 5 km speed 450 kts altitude 35000 ft msl
|
|
radial_acceleration 2 g
|
|
offset 0 0 km speed 450 kts altitude 35000 ft msl
|
|
radial_acceleration 2 g
|
|
goto start
|
|
end_navigation
|
|
end_route
|
|
|