Skattning av resonansfrekvenser med hjälp av MUSIC och ESPRIT har visat sig kunna fungera. Problem finns fortfarande då skattningarna ofta varierar för myc- ket för att tydligt säkerställa att en resonansfrekvens följs. Nedan följer ett par förslag som skulle kunna arbetas vidare med för att försöka förbättra resultatet i algoritmerna som presenterats i detta examensarbete.
Verifiera MUSIC och ESPRIT på fler signaler
Examensarbetet har genomförts med en begränsad mängd signaler från två värme- pannor, se avsnitt 4.1.2. Genom att testa MUSIC och ESPRIT på fler signaler från olika värmepannor under en längre tidsperiod skulle robusthet hos dessa kunna undersökas. Långsamma trender hos skattningarna som pågår över flera sotningar skulle också kunna detekteras. Om möjlighet finns skulle resultatet från skattning- arna kunna jämföras med faktiskt sotpåslag på överhettartuberna.
Undersöka lösningar för att förbättra signalkvalitén
För att förbättra skattningarna skulle ett fortsatt arbete kunna handla om att undersöka signalkvalitén och se om den går att göra bättre. Förbättrad mätutrust-
7.3 Fortsatt arbete 75
ning eller fler givare monterade på samma plats på överhettartuben skulle kunna minska påverkan från störningar och tydliggöra resonansfrekvenserna i signalerna.
Hitta ”optimala” parameterval för målföljningsalgoritmen
Parameterval för målföljningsalgoritmen har i detta arbete testats fram utifrån vad som gett rimliga resultat. Ett fortsatt arbete skulle kunna undersöka om det finns en bättre utgångspunkt när parametrarna ska ställas in.
Det skulle också kunna undersökas om en mer detaljerad modell för resonans- frekvenserna går att använda och om det skulle göra det lättare med parameterval i målföljningsalgoritmen.
Litteraturförteckning
[1] Directive 2000/76/EC of the European parliament and of the council. URL: http://www.central2013.eu/
fileadmin/user_upload/Downloads/Document_Centre/OP_Resources/ Incineration_Directive_2000_76.pdf, Maj 2010.
[2] Rudolph Emil Kalman. A new approach to linear filtering and prediction problems. Transactions of the ASME–Journal of Basic Engineering, 82(Series D):35–45, 1960.
[3] Den Hartog och Jacob Pieter. Mechanical Vibrations. Dover Publications, Inc. New York, 4 edition, 1985.
[4] Elisabet Blom, Claes Fredö och Lars Gabrielsson. Förbättrad behovsstyrd sotning med hjälp av värmeöverförande tubens mekaniska egenskaper. 2007. [5] Elisabet Blom och Chistofer Ivarsson. Förbättrad behovsstyrd sotning genom
mätning av värmeöverförande tubernas egenfrekvens, 2007.
[6] Fredrik Gustafsson, Lennart Ljung och Mille Millnert. Signalbehandling. Studentlitteratur, 2 edition, 2001. ISBN 978-91-44-01709-9.
[7] Julius S. Bendat och Allan G. Piersol. Engineering applications of correla- tion and specral analysis. John Wiley & Sons, Inc, 2 edition, 1993. ISBN 0-471-57055-9.
[8] Lennart Ljung och Torkel Glad. Modellbygge och simulering. Studentlittera- tur, 2 edition, 2004. ISBN 9144024436.
[9] Lennart Ljung och Torkel Glad. Reglerteknik. Studentlitteratur, 4 edition, 2006. ISBN 978-91-44-02275-8.
[10] Petre Stoica och Randolph Moses. Spectral analysis of signals. Pearson Pren- tice Hall, 1 edition, 2005. ISBN 0-13-113956-8.
[11] Samuel Blackman och Robert Popoli. Design and Analysis of Modern Trac- king Systems. Artech House, 1 edition, 1999. ISBN 1-58053-006-0.
[12] Randolph Moses. URL: http://www.ece.osu.edu/˜randy/SAtext/ sm-matlab-2ed.zip, Maj 2010.
[13] LabVIEW Sound and Vibration Analysis VIs Readme. URL: http:// digital.ni.com/public.nsf/3efedde4322fef19862567740067f3cc/ 490939efddfff1c4862574fe001e70aa/$FILE/readme_SVMS.html, Juni 2010.
[14] Umut Orguner. Target tracking. URL: http://www.control.isy.liu.se/ student/graduate/TargetTracking/lectures.html, mars 2010.
[15] Qring Technology AB. URL: http://www.qringtech.com, Maj 2010. [16] Ryaverket i Borås. URL: http://www.boras.se/vanstermeny/
omforetaget/varaanlaggningar/, februari 2010.
[17] Bengt Sundström. Energimetoder - Svängningar i kontinuerliga system. Insti- tutionen för hållfasthetslära, Kungliga tekniska högskolan (KTH), 2 edition, 1990.
[18] Värmeforsk. URL: http://www.varmeforsk.se/, februari 2010. [19] Fluidized bed combustion. URL: http://en.wikipedia.org/wiki/
Bilaga A
Implementerad
MATLAB-kod
Detta appendix innehåller delar av den Matlab-kod som använts för att genomföra testerna. Koden är uppdelad i två delar: I avsnitt A finns koden som används för att skatta resonansfrekvenser. I avsnitt A.2 finns koden från målföljningsalgoritmen.
Implementeringen av MUSIC och ESPRIT som har använts är hämtad från [12].
A.1
Skattning av resonansfrekvenser med MU-
SIC eller ESPRIT
%% Denna kod läser in alla mätdatafiler i en katalog och skattar %% frekvenskomponenter som sparas i ’skattningar’.
%% Variabler
skattningar = []; ny_matserie = [];
t_skattningsintervall = [];
%% Parametrar till algoritmen
% Från vilken kanal ska signalen analyseras
kanal = 2;
% Nedsampla signalen till var .. sampel
nedsampla_till = 40;
% Hur mycket samplingsintervallen ska överlappa i procent
procent_overlapp = 0; % procent % Intervall för bandpassfiltrering
bandpassfiltrering_undre_grans = 4; %Hz
bandpassfiltrering_ovre_grans = 9; %Hz
% Fyll i de intervall där en oönskad frekvenskomponent finns som ska % plockas bort.
storningsintervall = []; %[5.5 6, 11 12, 16.5 18, 21 25]; % Antal sampel per skattning
antal_sampel_per_skattning = 89000/2;
% MUSIC eller ESPRIT
valj_algoritm = ’ESPRIT’;
% MUSIC(n,m) eller ESPRIT(n,m)
n = 8; m = 100;
%% Läs in filer som finns och spara automatiskt i en cellarray ’filer’
lsList = ls; filer = {};
% Sortera in i en cell
% Filnamnen måste vara sorterade för att de ska behandlas i % rätt ordning.
% Filer får inte innehålla mellanslag i filnamnet.
while 1
[fil lsList] = strtok(lsList); if isempty(fil) break; end if isempty(findstr(fil, ’.’)) continue; end filer{end+1} = fil; end filer = sort(filer);
fprintf(’Det finns %d filer i katalogen.\n’, length(filer));
%% Genomför skattningar i varje fil
for loopindex = 1:length(filer)
tic % Beräkna tid
%% Ladda data
fprintf(’> Laddar filen %s. (%d av totalt %d)\n’, ... filer{loopindex}, loopindex, length(filer));
%% Läs in fil
try
eval([’load ’, filer{loopindex}]); catch
A.1 Skattning av resonansfrekvenser med MUSIC eller ESPRIT 81 filer{loopindex}); continue; end %% ladda in kanal [channels t dt N] = ladda_data(VXI_DSA_DATA); %% Nedsampling
[signal t dt N] = nedsampling(channels(:,kanal), nedsampla_till, ... t, dt);
fprintf(’> Läsning av data klart.\n’);
%% Behandla data
fprintf(’> Analysera data.\n’);
%% Loopa igenom signalen
skattningar_fil = [];
% Frekvenstoppar som ska filtreras bort.
toppar = [];
signal_bp = signal;
% Om störningsintervall är valda så plocka bort högsta frekvenstopp % i dessa med Notchfilter.
if isempty(storningsintervall)
fprintf(’> Plockar bort oönskade frekvenskomponenter: ’); [Pxx F] = pwelch(signal, length(signal)/20, ...
floor(length(signal)/20/3), [], 1/dt);
toppar = hitta_toppar(Pxx, F, storningsintervall);
% Plocka bort frekvenskomponenterna med Notchfilter
for i = 1:length(toppar)
signal_bp = filtfilt([1 -2*cos(2*pi*toppar(i)*dt) 1], ... [1 -2*0.99*cos(2*pi*toppar(i)*dt) 0.99ˆ2*1], signal_bp); fprintf(’%3.2f Hz ’, toppar(i)); end fprintf(’Klart.\n’); end % Bandpassfiltrera signalen [B A] = bandpassfilter(bandpassfiltrering_undre_grans, ... bandpassfiltrering_ovre_grans, dt);
signal_bp = filtfilt(B,A, signal_bp); skattningar_fil = [];
% Loopa igenom en signal och skatta frekvenskomponenter
for i = 1:floor(antal_sampel_per_skattning*(1-procent_overlapp/100)):... length(signal_bp)-antal_sampel_per_skattning+1
% Använd den algoritm som är vald.
if strcmpi(valj_algoritm, ’MUSIC’)
w = music(signal_bp(i:i+antal_sampel_per_skattning-1), n, m); elseif strcmpi(valj_algoritm, ’ESPRIT’)
w = esprit(signal_bp(i:i+antal_sampel_per_skattning-1), n, m); else
error(’Felaktig algoritm vald.\n’); end
% Spara om de normerade frekvenserna i Hz
w = w(w > 0);
frekvenser = w/(2*pi*dt); frekvenser = frekvenser’;
% Sortera ut så att n/2 skattningar returneras.
if length(frekvenser) > n/2
fprintf(’> Klipper bort skattningar.\n’); frekvenser = frekvenser(1:n/2);
elseif length(frekvenser) < n/2
fprintf(’> Lägger till nollor.\n’);
frekvenser = [frekvenser zeros(1, n/2 - length(frekvenser))]; end
% Spara skattningar ifrån samma fil
skattningar_fil(end + 1, 1:n/2) = frekvenser;
% Spara tid för slutet av intervallet
t_skattningsintervall(end+1) = t(i+antal_sampel_per_skattning-1); end
skattningar = [skattningar; skattningar_fil];
ny_matserie = [ny_matserie; zeros(length(skattningar_fil(:,1))-1,1); 1];
fprintf(’> Skattningar sparade.\n’);
toc % Visa hur lång tid det tog att analysera en fil
A.1 Skattning av resonansfrekvenser med MUSIC eller ESPRIT 83
A.1.1
Funktioner
%% Decimera signal
function [signal t dt N] = nedsampling(signal,decimering, t, dt)
%% Nedsampla signalen
signal = decimate(signal, decimering);
%% Uppdatera signallängd
N = length(signal);
%% Uppdatera samplingstiden
t = t(1:decimering:end); dt = t(2) - t(1);
%% Hitta högsta topparna som ligger inom de intervall % som bestäms av intervallerna
function [frekvenstoppar amplituder] = ... hitta_toppar(signal, f, intervaller) frekvenstoppar = [];
amplituder = []; if nargin == 3
for ef = 1:2:length(intervaller)
frekvenstopp = find(signal == max(signal(f > intervaller(ef) & ...
f < intervaller(ef + 1))) & f > intervaller(ef) & ... f < intervaller(ef + 1)); frekvenstoppar(1,end+1) = f(frekvenstopp); amplituder(1,end+1) = signal(frekvenstopp); end elseif nargin == 2 for i = 2:length(signal)-1
if signal(i) - signal(i-1) > 0 && signal(i+1) - signal(i) < 0 frekvenstoppar(1, end+1) = f(i);
amplituder(1,end+1) = signal(i); end
end end
%% Returnerar B, A för ett sjätte (12) ordningens Butterworthfilter
function [B A] = bandpassfilter(min, max, dt) [B A] = butter(6, 2*dt*[min max]);
A.2
Målföljningsalgoritm
% Kör igenom målföljningsalgoritmen på skattningar sparade i matrisen % ’skattningar’ där ’datalangder’ visar när ny mätserie skattats.
fprintf(’Målföljningsalgorithm.\n’); datalangder = find(ny_matserie); % Resonansfrekvensmodell A = (1 - 0.0033/(2*(datalangder(2) - datalangder(1)))); B = 1; C = 1; % Processbrus
Qtil = (0.006/(2*(datalangder(2) - datalangder(1))))ˆ2;
% Mätbrus R = 0.006; % Initialvillkor P0 = 0.001; % N&M-logik M = [7]; N = [7]; % Bestäm gränsvärde chi2 = chi2inv(0.98,1); % Skapa klass clear w; w = objTrackingAlgorithm(A,B,C,Qtil,R, P0, M, N, chi2); x = []; y = skattningar(1:end,:); fprintf(’\nResonansfrekvensmodell:\n’); fprintf(’x(t+1) = %d*x(t) + %d*e(t)\n’, A, B); fprintf(’ y(t) = %d*x(t)\n\n’, C); fprintf(’Status: ’);
% Börja simulering på noll
fprintf(’%6.2f %% klart.’,0); for i = 1:length(y(:,1))
% Ta bort NaN ur data
detections = y(i, isnan(y(i,:)));
A.2 Målföljningsalgoritm 85
w.new_measurements(detections, i);
if any(i == [datalangder(8+1), datalangder(48+7+1), ...
datalangder(96+7+1), datalangder(144+9+1), datalangder(192+12+1)])
% Anropas vid sotningstillfällen och flyttar upp frekvensen % till samma som vid senaste sotningstillfället.
w.reset(); end
fprintf(’%s%6.2f %% done.’,char(ones(1,14)*8),i/length(y(:,1))*100); end
fprintf(’\n’);
% Ta bort icke-aktiva mål
w.force_kill();
A.2.1
Klasser
%% Klassen objTrack hanterar data för varje enskilt mål
classdef objTrack < handle properties
% System A, B, C
sys;
% Parameters R, Qtil
param;
% States xhat, yhat
state;
% Time
time; P = [];
% Used for track status
track_state = []; logic;
end % properties
methods
%% Constructor
function obj = objTrack(new_A, new_B, new_C, new_Qtil, new_R) obj.sys.A = new_A; obj.sys.B = new_B; obj.sys.C = new_C; obj.param.Qtil = new_Qtil; obj.param.R = new_R; obj.state.xhat = [];
obj.state.yhat = []; obj.state.last_reset = 0; obj.track_state = ’init’; end
%% Add xhat
function obj = add_xhat(obj, xhat) s = size(xhat);
if s(2) > 1
error(’X-vektorn ska vara en kolumnvektor.’) end
obj.state.xhat = [obj.state.xhat, xhat]; end
%% Add yhat
function obj = add_yhat(obj, yhat) s = size(yhat);
if s(2) > 1
error(’X-vektorn ska vara en kolumnvektor.’) end
obj.state.yhat = [obj.state.yhat, yhat]; end
%% Update P
function obj = update_P(obj, P) if isempty(obj.P) if size(P) = size(obj.P) error(’Felaktigt P’); end end obj.P = P; end %% Get xhat
function xhat = get_xhat(obj) xhat = obj.state.xhat(:,end); end
%% Get yhat
function yhat = get_yhat(obj) yhat = obj.state.yhat(:,end); end %% Get P function P = get_P(obj) P = obj.P; end %% Get Qtil
function Qtil = get_Qtil(obj) Qtil = obj.param.Qtil;
end
A.2 Målföljningsalgoritm 87 function R = get_R(obj) R = obj.param.R; end %% Get chi2 function R = get_chi2(obj) R = obj.param.chi2; end
%% Set initial state
function obj = set_initial_state(obj,new_x0,new_tstart, ... new_P0, M, N, chi2)
if isempty(obj.sys.A)
error(’A ej initierad.’);
elseif length(obj.sys.A) = length(new_x0) error(’Fel dimension på x0’);
elseif length(obj.sys.A) = length(new_P0) error(’Fel dimension på P0’);
end obj.add_xhat(new_x0); obj.add_yhat(obj.sys.C*new_x0); obj.time.start = new_tstart; obj.time.stop = new_tstart; obj.update_P(new_P0); obj.param.chi2 = chi2;
% Lägg till M och N till logiken
if nargin > 4 obj.logic.M = M; obj.logic.N = N; obj.logic.obsv = []; obj.add_observation_in_gate(); end end
%% Estimate next state
function [yhat_next P xhat_next] = ... estimate_next_state(obj, varargin)
% Hur mycket ska osäkerheten öka om detektering saknas?
increase_uncertainty = 1.3;
Q=obj.sys.B*obj.get_Qtil()*obj.sys.B’;
S=obj.sys.C*obj.get_P()*obj.sys.C’+obj.get_R(); K=obj.sys.A*obj.get_P()*obj.sys.C’*inv(S);
% Om inget nytt y stoppas in använd skattningen och öka P
if nargin == 1
y_now = obj.get_yhat();
% Uppdatera inte P med Riccatiekvationen utan förstora den % för att öka osäkerheten
P = increase_uncertainty*obj.get_P(); else % Riccati y_now = varargin{1}; P = obj.sys.A*obj.P*obj.sys.A’+ ... Q-obj.sys.A*obj.get_P()*obj.sys.C’*inv(S)*... obj.sys.C*obj.get_P()*obj.sys.A’; end % Estimate next xhat_next=(obj.sys.A-K*obj.sys.C)*obj.get_xhat()+K*y_now’; yhat_next = obj.sys.C*xhat_next; end %% Update estimation
function [yhat, P, xhat] = update_estimation(obj, varargin) [yhat, P, xhat] = obj.estimate_next_state(varargin{:}); obj.add_yhat(yhat);
obj.add_xhat(xhat); obj.update_P(P); end
%% Gaussian probability density function for residual
function d2 = gating_value(obj, y)
S = obj.sys.C*obj.get_P()*obj.sys.C’+obj.get_R(); y_tilde = y - obj.get_yhat();
d2 = y_tilde’*inv(S)*y_tilde; end
%% Update new measurement
function new_y = update_new_measurements(obj, y) closest_y = 0;
% Find the closest measurement within threshold
for i = 1:length(y)
d2 = obj.gating_value(y(i));
% If measurement within gate
if d2 < obj.param.chi2
% Update to closest
if closest_y == 0 closest_y = i;
elseif (y(closest_y) - obj.get_yhat())ˆ2 > ... (y(i) - obj.get_yhat())ˆ2
A.2 Målföljningsalgoritm 89 end end end % Update measurements if closest_y == 0 % No new measurement obj.update_estimation(); obj.add_no_observation_in_gate(); else
% Update new measurement
obj.update_estimation(y(closest_y)); obj.add_observation_in_gate(); % remove estimation y(closest_y) = []; end % Update time obj.time.stop = obj.time.stop + 1; new_y = y; end
%% Add that there was an observation in gate
function add_observation_in_gate(obj) obj.logic.obsv = [obj.logic.obsv, 1]; end
%% Add that there was no observation in gate
function add_no_observation_in_gate(obj) obj.logic.obsv = [obj.logic.obsv, 0]; end
%% Get track state
function track_state = get_track_state(obj) track_state = obj.track_state;
end
%% Update track state according to M and N % Behöver fixas
function new_state = update_track_state(obj) new_state = [];
% Används för att hålla reda på vilka skattningar som kollas
logic_stop = 0;
total_nr_est = length(obj.logic.obsv);
% Om målet är i initierat läge
if strcmpi(obj.track_state, ’init’)
% Loopa igenom de olika kraven i M&N-logiken % Skulle någon inte uppfyllas dödas målet.
% Uppfylls alla krav till och med sista aktiveras målet.
for i = 1:length(obj.logic.N)
% Uppdatera intervall för M&N-logiken
logic_stop = logic_stop + obj.logic.N(i); logic_start = logic_stop - obj.logic.N(i) + 1; if logic_stop > total_nr_est
logic_stop = total_nr_est; end
% Se om M&N-logiken inte uppfylls
if length(find( obj.logic.obsv(logic_start:logic_stop))) ... > obj.logic.N(i) - obj.logic.M(i)
new_state = ’never_active’; break;
end
% Har alla M&N-logikkrav uppfyllts sätt som aktiv
if i == length(obj.logic.N) if length(find(obj.logic.obsv(logic_start:logic_stop))) ... >= obj.logic.M(i) new_state = ’active’; break; end end if total_nr_est > sum(obj.logic.N) new_state = ’never_active’; break; end
% Hoppa ur loopen när alla estimeringar kollats
if logic_stop == total_nr_est break;
end end
elseif strcmpi(obj.track_state, ’active’)
% Ta bort mål som inte fått associeringar de senaste tidpunkterna
tillfallen_utan_associering = 6; if tillfallen_utan_associering >= length(obj.logic.obsv) tillfallen_utan_associering = length(obj.logic.obsv) - 1; end if any(obj.logic.obsv(end-tillfallen_utan_associering+1:end)) new_state = ’dead’;
A.2 Målföljningsalgoritm 91
end end
% Uppdatera status om ny status
if isempty(new_state)
obj.track_state = new_state; end
end
%% Döda målet
function new_state = force_kill(obj) if strcmpi(obj.track_state, ’init’)
obj.track_state = ’never_active’; elseif strcmpi(obj.track_state, ’active’)
obj.track_state = ’dead’; end new_state = obj.track_state; end end % methods end
%% Klassen objTrackAlgorithm hanterar alla mål,
% tar emot detekteringar och associerar dessa till målen.
classdef objTrackingAlgorithm < handle properties tracks; track_init; end % properties methods %% Konstruktor function obj = ...
objTrackingAlgorithm(A, B, C, Qtil, R, P0, M, N, chi2) obj.track_init.A = A; obj.track_init.B = B; obj.track_init.C = C; obj.track_init.Qtil = Qtil; obj.track_init.R = R; obj.track_init.P0 = P0; obj.track_init.M = M; obj.track_init.N = N; obj.track_init.chi2 = chi2; end %% Initiera nya mål function create_new_track...
(obj, A, B, C, Qtil, R, x0, t0, P0, M, N, chi2) new_track = objTrack(A, B, C, Qtil, R);
new_track.set_initial_state(x0, t0, P0, M, N, chi2); obj.add_track(new_track);
end
%% Lägg till mål
function add_track(obj, new_track) try obj.tracks(end+1) = new_track; catch obj.tracks = new_track; end end
%% Uppdatera aktiva mål med nya mätuppdateringar % Remove used measurements
function new_y = update_active_tracks(obj, y, state) new_y = y;
% Uppdatera tracks som är i ’state’
for i = 1:length(obj.tracks)
if strcmpi(obj.tracks(i).get_track_state(), state) new_y = obj.tracks(i).update_new_measurements(new_y); end
A.2 Målföljningsalgoritm 93
end end
%% Ta emot nya detekteringar
function new_measurements(obj, y, t)
% Associera aktiva mål med nya detekteringar
y = obj.update_active_tracks(y, ’active’);
% Associera initierade mål med nya detekteringar
y = obj.update_active_tracks(y, ’init’);
% Skapa nya mål
for i = 1:length(y)
new_track = objTrack(obj.track_init.A, obj.track_init.B, ... obj.track_init.C, obj.track_init.Qtil, obj.track_init.R); new_track.set_initial_state(y(i), t, obj.track_init.P0, ... obj.track_init.M, obj.track_init.N, obj.track_init.chi2); obj.add_track(new_track);
end
% Uppdatera mål
[new_active new_dead] = obj.update_track_states(); end
%% Uppdatera tillstånd
function [new_active new_dead] = update_track_states(obj) new_active = 0; new_dead = 0; remove_tracks = []; for i = 1:length(obj.tracks) new_state = obj.tracks(i).update_track_state(); if isempty(new_state)
elseif strcmpi(new_state, ’active’) new_active = new_active + 1; y = obj.tracks(i).state.yhat; elseif strcmpi(new_state, ’dead’)
new_dead = new_dead + 1;
elseif strcmpi(new_state, ’never_active’) remove_tracks(end+1) = i;
end end
% Ta bort mål som inte varit aktiva
obj.tracks(remove_tracks) = []; end %% Döda mål function force_kill(obj) remove_tracks = []; for i = 1:length(obj.tracks) new_state = obj.tracks(i).force_kill();
% Lägg till mål som inte varit aktiva if strcmpi(new_state, ’never_active’) remove_tracks(end+1)= i; end end % Ta bort mål obj.tracks(remove_tracks) = []; end
%% Uppdatera mål vid sotning
function reset(obj) remove_tracks = [];
for i = 1:length(obj.tracks)
% Om ett mål är aktivt, uppdatera tillstånd % efter sotning vilket motsvarar nivån vid % senaste sotning if strcmpi(obj.tracks(i).track_state, ’active’) if obj.tracks(i).state.last_reset == 0 obj.tracks(i).state.xhat(end) = obj.tracks(i).state.xhat(1); obj.tracks(i).state.yhat(end) = obj.tracks(i).state.xhat(1); else
% Använd skattning från tre tidpunkter efter senaste sotning
obj.tracks(i).state.xhat(end) = ...
obj.tracks(i).state.xhat(obj.tracks(i).state.last_reset+3); obj.tracks(i).state.yhat(end) = ...
obj.tracks(i).state.xhat(obj.tracks(i).state.last_reset+3); end
% Öka osäkerheten i skattningarna
obj.tracks(i).P(end) = obj.tracks(i).P(end)*5; obj.tracks(i).state.last_reset = ...
length(obj.tracks(i).state.xhat);
elseif strcmpi(obj.tracks(i).track_state, ’init’)
% Ta bort mål som inte varit aktiva
remove_tracks(end+1)= i; end end % Ta bort mål obj.tracks(remove_tracks) = []; end end % methods end
Upphovsrätt
Detta dokument hålls tillgängligt på Internet — eller dess framtida ersättare — under 25 år från publiceringsdatum under förutsättning att inga extraordinära omständigheter uppstår.
Tillgång till dokumentet innebär tillstånd för var och en att läsa, ladda ner, skriva ut enstaka kopior för enskilt bruk och att använda det oförändrat för icke- kommersiell forskning och för undervisning. Överföring av upphovsrätten vid en senare tidpunkt kan inte upphäva detta tillstånd. All annan användning av doku- mentet kräver upphovsmannens medgivande. För att garantera äktheten, säkerhe- ten och tillgängligheten finns det lösningar av teknisk och administrativ art.
Upphovsmannens ideella rätt innefattar rätt att bli nämnd som upphovsman i den omfattning som god sed kräver vid användning av dokumentet på ovan be- skrivna sätt samt skydd mot att dokumentet ändras eller presenteras i sådan form eller i sådant sammanhang som är kränkande för upphovsmannens litterära eller konstnärliga anseende eller egenart.
För ytterligare information om Linköping University Electronic Press se förla- gets hemsida http://www.ep.liu.se/
Copyright
The publishers will keep this document online on the Internet — or its possi- ble replacement — for a period of 25 years from the date of publication barring exceptional circumstances.
The online availability of the document implies a permanent permission for anyone to read, to download, to print out single copies for his/her own use and to use it unchanged for any non-commercial research and educational purpose. Subsequent transfers of copyright cannot revoke this permission. All other uses of the document are conditional on the consent of the copyright owner. The publisher has taken technical and administrative measures to assure authenticity, security and accessibility.
According to intellectual property law the author has the right to be mentioned when his/her work is accessed as described above and to be protected against infringement.
For additional information about the Linköping University Electronic Press and its procedures for publication and for assurance of document integrity, please refer to its www home page: http://www.ep.liu.se/
c