Implementation discussion

Olika punkter

Vi diskuterade implementationskopplingen mellan plan recognition och task prioritization. Eftersom DBN:et modifieras när det förses med input kom vi överens om att kopiera det innan det matas med en sampling.
Eftersom observationer inte kommer regelbundet i den här tillämpningen behöver vi modellera att osäkerheten i position och riktning och för fordon öker med tiden. Vi ansätter en funktion r=f(t) där t är tiden sedan senaste observation av fordonet. Vi vill alltså använda en mycket enkel modell för observation. Förslagsvis kan vi låta en UAV deterministiskt finna ett mål efter en förbestämd tid som är beroende av avstånd mellan UAV:n och osäkerhetsområdet samt osäkerhetsområdets storlek (UAV:n måste ju "scanna" av området på något sätt för att kunna finna fordonen).
Planigenkänningen kräver uppskattningar av position för alla mål. Eftersom vi pga resursbrist inte kan få det får vi använda gammal information för de som vi inte har någon ny information om. Vi får försöka sampla även de fordon som vi inte har haft koll på på ett tag. Vi måste samsampla fordonen i ett förband så att de inte kommer för långt ifrån varandra. En förenkling är att vi kan anta att de har samma formation som när vi såg dem sist (egentligen skall det vara beroende av terrängen). För samampling, sampla tyngdpunkten plutonen och flytta samtliga fordon med vektorn mellan tidigare tyngdpunkt och nuvarande.

Mjukvaruarkitektur

Sketch of the proposed system architecture

Huvudloop

Huvudprogram har hand om att räkna upp tiden och uppdatera omvärldens och systemets (observatörens) uppfattning om omvärlden. Huvudloopen kan se ut så här (med aktuell ansvarsfördelning):

läs in data från konfigurationsfil
initiera en oldpolicy
loop
- uppdatera tiden; t++ (ansvar: S)
- uppdatera världen; objekts, sensorers, fiende styrkor, och vänliga styrkors egenskaper (ex.vis position) (J)
- uppdatera situationsbilden med avseende på sensordata;
targets = update(targets, sensordata) (J)
-- iterera över alla mål/fiendefordon och utöka osäkerheterna för de fordon som ej observerats
-- iterera över alla sensorer och uppdatera observerade mål i förekommande fall.
- uppdatera hotanalys; anropa planigenkänningen och returnera policier (pluton och kompani), hotväntevärde och hotvarians för kompanier
ex.vis hotanalys() eller hotanalys_fuzzy() (S)
- tasks = task_management(enemies, own_forces, old_policy_Mx, old_ev_Mx); utför prioritering (J)
- svs = services(sensors) (J)
- sensors = alloc_scheme(svs,tasks); eventuell omprioritering (J)
- spara undan gammal policy; oldpolicy = policy(t-1) (S)

Update(targets)
%% policy update start %%
DBN_Mx_copy = DBN_Mx;
for own_force = 1:own_forceNo
   for currEnemy = 1:enemyNo
      enemyPos = getPos(currEnemy);
      own_force_pos = getPos(own_force)
      enemyVel = getVelocity(fi);
      [DBN_Mx, policiesStruct] =
      getPolicy(DBN_Mx{own_force, currEnemy},enemyPos, own_force_pos,   
enemyVel);
   end;
end;
%% policy update end %%
tasks = task_mangement(DBN_Mx_copy);

Simulation Parameters

Description of different parameters that can be changed for different simultions and where they can be found.

simulationLoop - function parameters
- start - simulation start time (integer). Default is 1.
- stop - simulation stop time (integer). Default is 100.
- diary - save all output to a diary file (string)
- video - make a video of all time steps
- sensordata - specification of sensors (string). Default is 'sensorData.mat'.
- outputstyle - print a lot or not as much (string: 'verbose' or 'brief'). Default is 'verbose'.
- graphics - visualise each timestep if 'on'. Don't if 'off'. Default is 'off'. (string)
- preemption - allow services to be preempted. 'on' or 'off'. Default is 'off'. (string)
simulationLoop - internal parameters
- task_management_func - which task management function to run. (function pointer)
- get_prior_func - which function to use to select a representative probability distribution given a set of distributions. (function pointer)
- preferenceRelation - preference relation to use to order tasks (function pointer)
- noOfPart - the number of particles to draw in Monte Carlo simulation from a set of particles
initializeEnemy.m
- noOfParticles - the number of particles to use for each platoon in the PF tracking.
- max_speed - the max_speed of the enemies. (I'm not sure if it is in use.)
initializeSensors.m
- erroneous_observations - the probability that a sensors believes it it seeing another platoon (0-1 real)
- uav_detection_model - the detection model of a UAV sensor
- markus_detection_model - the detection model of a ground soldier
- UAV_range - maximum detection range of UAV sensor
- UAV_speed - maximum speed of UAV
- markus_range - maximum detection range of ground soldier
- markus_speed - maximum speed of ground soldier
particle_filter.m
- replacement_ratio - the fraction of particles to replace in the case of spurious observations (outliers). A number greater than zero (and less than one) is useful when observations are sparse. This allows a partial restart of the particle filter. If the ratio is 1, the whole particle filter is restarted close to the state of the latest observation (this is not robust if observations might be erroneous).
- minmax_likelihood_deg - simply, this is the minimum likelihood acceptable for a particle set. Partially restart the particle filter (in the position of the observation) if this level is not reached by the particle set.
- negative_obs_discount - how much to discount a "non-observed" particle. This variable is used as a parameter for negative_observations.m, but NOT for negative_observations_new.m which has a more strict treatment of missing observations.
negative_observations.m and negative_observations_new.m
- the weighing of particles that should have been observed but wasn't.
task_management_robust.m
- The prioritisation function: e.g., prioritize_robust.m
prioritize_robust.m
- platoon_weights - the importance weights of platoon plans
- company_weights - the importance weights of company plans
- threat_robust.m - calculates the threat values (mean, std)

Variables

ALL_policy_stuct ( time )
- an array of policy_stuct
policy_stuct ( own_force, enemy_force )
- a 2 by 3 cell array with each cell containing a plan_rec_struct
plan_rec_struct ( int )
- a 1 by 4 cell array data structures (for more information look for plan-rec_struct in the data section below)

Data

Datastrukturer i pdf-format (OBS! jättegammal)

Allocation
- task_id - namn (string)
- service_id - namn (string)
- time - timestep of creation (string)
- activated - true or false (numeric)
Enemy/Mål: Company (cmp)
- id - namn (string)
- plt - pluton-struct array (se nedan)
Enemy/Mål: Pluton (plt)

id - namn (string)
particles - particles for use with particle filter
est_pos - senaste uppskattade position (numerics [x y])
est_dir - senaste uppskattade riktning: (numerics [x_dir y_dir])
real_pos - verklig position (alltså enligt facit) (numerics [x y])
radius - position uncertainty radius: (numeric - antal pixlars positionsosäkerhet)
obs_time - simulationstidssteg sedan senaste observation (numeric)
velocity - uppskattad maximal hastighet för plutonen (numeric pixlar/tidssteg)

Own resources

id - namn (string)
pos - aktuell position (numerics [x y])
strat_val - strategiskt värde (numeric)

Sensorresurser

id - namn (string)
type - typ av resurs (string)
available - upptagen resurs? (0,1)
pos - aktuell position (numeric pixlar [x y])
max_speed - maximal förflyttningsfart för denna typ av resurs
cost - cost/timestep for using resource (numeric)
time_to_target - number of timesteps until detection (obsolete)
target_id - id of the target to detect (string)
home_base - the position of the sensor's home base (1x2 numeric)
detection_model - detection model (function pointer, should accept a sensor struct and a target struct)
plan - the plan of a sensor; is sensor dependent (for a UAV this may be a matrix of planned observation points)

Observations

sensor_id - sensor id (string)
target_id - target label for observed platoon (string)
data_format - specifies the format of data
data - details of the observation
accuracy - the accuracy of the observation

Services

id - name (string)
type - type of service (string)
quality - quality properties of using service (quality struct)
cost - cost properties of using service (cost struct)
resources - underlying resources ( a cell array of sensor id:s )
occupied - '1' means that is has a task assigned
target_id - label of the target(s) to look for (string)
ttc - time to completion (deprecated)
plvl - preemption level (priority of a competing task has to reach above this level) [NOTE! This value logically belongs to the allocation rather than the service, should perhaps be changed in the future]
detection_model - detections model (function pointer @)
data_format - the format of value of field data (string)
data - data produced by service from observations made by underlying resources
process - the process performed by the service to generate the value of the data field (a function pointer @). Process should be called when there are new observations. The function must accept observations, sensors and targets.

Image Quality

reach - a measure of the expected time delay before the service can produce a result. Reach is expressed in pixels/s (platform speed) (integer)
accuracy - expected measurement accuracy (e.g., the imprecision of the measurement expressed in a pixel radius) (integer)

Cost

static_cost - cost for initiating service
dynamic_cost - cost per moved pixel
scanning_cost - cost for scanning per square pixel.
max_cost - the maximum acceptable cost for the service. If the cost of applying the service for a specific task exceeds this limit, the service will refuse to take the assignment.

Task

id - the id (name) of the task (string)
objid - the id (name) of the object (target) the task refers to (string)
prio - the priority information of this task (currently a struct with fields high_exp and high_std, corresponding to the tasks memberships in the HighExpectedThreat and the HighStandardDeviation fuzzy sets.)
ptime - the time step the priority of this task was last changed (integer)

plan_rec_struct

cell 1 - company information
CmpPol - a row vector of probabilities over company plan/policy alternatives
Discovered - a column vector with our belief of the enemy thinking he has been detected.
CmpFor - a probability distribution over company formations
cell 2 - platoon 1
PltPol - a row vector of probabilities over platoon plans
cell 3 - platoon 2
PltPol - a row vector of probabilities over platoon plans
cell 4 - platoon 3
PltPol - a row vector of probabilities over platoon plans

threat_data_str

exp - column vector with the expected threat for all platoons in a company
std - column vector with the standard deviation for all platoons in a company

great_data_struct (used in simulationloop.m)

time - simulation time for this data (integer)
enemy - array of enemy struct
own - array of own struct
sensors - array of sensor structs
threat - a 2 by 3 cell array with a threat_data_str in each cell
tasks - array of task structs
services - array or service structs
allocs - array of allocation structs

Latest change: 2005-12-09
Author: Ronnie Johansson