If it flies, it dies™.

Report article RSS Feed Command to LOS (CLOS) Guidance Implementation

Posted by blahdy on Oct 26th, 2013

Implementing the Command to Line of Sight (CLOS) guidance method in World in Conflict (also can be ported to other game environments).

YouTube Video:
Link - Youtube.com


def GCFLINT_Command_to_LOS( msl_pos, launcher_pos, tgt_pos, latax, cre_data, beam_motion_data ):
	"""
		Command to Line of Sight (CLOS) Guidance
		
		msl_pos 		= (Vector3) missile's current position
		launcher_pos	= (Vector3) launcher's current position
		tgt_pos 		= (Vector3) target's current position
		latax 			= (Mutable Vector3) mutable object for providing guidance command
		cre_data		= (Mutable dict) dict object for Kalman estimation states on CRE
		beam_motion_data = (Mutable Vector3) mutable object for recording previous
						   beam motion
	
		Command to LOS (CLOS) Guidance or "three point guidance" is probably the
		oldest and the first rudimentary form of missile guidance methods.  
		Tracing its roots back to the Nazi Germany's Wasserfall experimental SAM
		and early forms of anti-shipping guided PGMs, it was originally conceived
		as Manual Command to LOS (MaCLOS or MCLOS), where a human operator 
		remotely steered the missile along his visible line of sight toward the
		target.
		
		After the World War, MCLOS was further modified with improvements in
		sensors and analog computing technology, spawning new derivatives such as
		Semi-Automatic Command to LOS (SACLOS), Automatic Command to LOS (ACLOS or
		simply CLOS) and Beamriding Guidance.  In case of SACLOS, the operator has
		to maintain his sight on the target and the guidance computer will 
		automatically generate the necessary steering commands to the outgoing 
		missile -- a good example of this is BGM-71 TOW missile.  Fully automatic
		CLOS (ACLOS) was used on first generation SAMs (i.e. Talos, Nike Zeus, etc).
		Even to this day, ACLOS is widely popular for cheap short-range AA uses 
		(i.e. SA-22 Pantsir/SA-19 Tunguska, Crotale, RBS-70, Roland, etc), because
		the missile is very cheap to manufacture (there is no need for seeker and
		complex embedded electronics).
		
		
		
		CLOS works on the premise that the target, outgoing missile and the launcher
		are all on the same Line of Sight (LOS) line.  As missile is outgoing, the
		guidance computer on the launcher will steer the missile to snap it on its
		sightline/LOS toward the target.
		
		The outgoing missile's distance normal to the launcher-to-target LOS (that
		is, how far the missile is off from the LOS line) is known as the 
		'Cross Range Error' or 'CRE'.  It is this 'CRE' that the guidance computer
		will have to reduce to zero in order to get the outgoing missile to snap 
		back on the LOS line toward the target.  CRE is to be calculated as follows:
		
		CRE = |radar_to_missile| x<cross product> |radar_to_target|
			  -----------------------------------------------------
								|radar_to_target|
		
		The guidance computer will calculate the required lateral acceleration to
		bring CRE to zero, where:
		
			required acceleration = K * CRE + Beam_Motion_Term
			K = optional Guidance Gain
		
		Because CLOS relies on the launcher-target LOS as its principal tracking
		reference, it is quite vulnerable to high velocity situations, especially in
		situations where the target is crossing; in such cases, it can behave as bad
		as pure-pursuit/tail-chase homing guidance.  To help mitigate the increased
		acceleration requirements against crossing targets, a "Beam motion" term is
		added after the guidance command.  Beam motion is the target's acceleration 
		normal to the launcher-target LOS.
		
		Addition of beam motion term allows CLOS missile to more quickly react to
		changing LOS rate, but ultimately, CLOS is at best, good for producing lot
		of cheap anti-aircraft and anti-slow-moving (i.e. tank) missiles.  For 
		intercepting high performance targets with good accuracy, or to achieve
		sophisticated "hit to kill" type of interception, you would want to use one
		of the modern derivatives of Proportional Navigation (PN) family of 
		guidance methods.
		
	"""
	import wic.common.math as math
	from predictorFCS_flint__includes__ import EXFLINT_Kalman_Filter
	
	launcher_to_msl = math.Vector3( msl_pos ) - launcher_pos
	msl_heading_direction = ( math.Vector3( tgt_pos ) - msl_pos ).NormalizeSafe()	
	command_los = math.Vector3( tgt_pos ) - launcher_pos
	
	# Cross Range Error (CRE) - 
	# radar_to_msl <X cross product> radar_to_tgt * ( 1.0 / radar_to_target )
	CRE = EXFLINT_Kalman_Filter( cre_data, ( launcher_to_msl.Cross(command_los) * ( 1.0 / command_los.Length() ) ).Length() )
	
	# Beam motion term -- perceived target's inertial acceleration normal
	# to Line of Sight
	Bmp = math.Vector3( tgt_pos ) - beam_motion_data
	beam_motion_data = math.Vector3( tgt_pos )
	
	# Now, calculate the final Lateral Acceleration required for our missile
	# to home into our target.
	latax = msl_heading_direction * CRE + Bmp
	
	# my job is done, it's now up to EXFLINT.Integrate() to steer the missile.
	return True
Post a Comment
click to sign in

You are not logged in, your comment will be anonymous unless you join the community today (totally free - or sign in with your social account on the right) which we encourage all contributors to do.

2000 characters limit; HTML formatting and smileys are not supported - text only

Level
Avatar
Avatar
Offline Since
Jul 4, 2015
Country
United States United States
Gender
Male
Member Watch
Track this member
Blog
Browse
Blogs
Report Abuse
Report article
Share