523 lines
19 KiB
Matlab
Executable File
523 lines
19 KiB
Matlab
Executable File
%% Funzione che calcola gli spostamenti in modalità biassiale per i
|
|
% Tilt Link HR (ampolle)
|
|
|
|
function [X_HR,Y_HR,Z_HR,Xlocal_HR,Ylocal_HR,Zlocal_HR,HShift_HR,HShift_local_HR,...
|
|
AlfaX_HR,AlfaY_HR,Azimuth_HR,Speed_local_HR,Speed_HR,Acceleration_local_HR,...
|
|
Acceleration_HR,TempDef_TLHR,ARRAYdateTLHR,ErrTiltLinkHR] = biax_TLHR(IDcentralina,...
|
|
DTcatena,rTLHR,rTL,ANGdef_TLHR,ACCdef_TL,MAGdef_TL,TempDef_TLHR,SpeTLHR,...
|
|
PsTLHR,yesTL,yesTLHR3D,NodoTiltLinkHR,NodoTiltLink,NodoTiltLinkHR3D,...
|
|
DatiElabTiltLinkHR,segnoNS_HR,segnoEO_HR,Ndevst_HR,Wdevst_HR,ARRAYdateTLHR,...
|
|
NuovoZeroTLHR,NdatiMedia,Ndatidespike,allineato,ErrTiltLinkHR,Tmax,Tmin,datainiTLHR,...
|
|
margine,date,FileName)
|
|
|
|
%% Inizializzazione
|
|
fileID = fopen(FileName,'a');
|
|
fmt = '%s \r';
|
|
text = 'biax_TLHR function started';
|
|
fprintf(fileID,fmt,text);
|
|
|
|
if NuovoZeroTLHR == 1
|
|
if NdatiMedia > Ndatidespike
|
|
Ndati = NdatiMedia;
|
|
else
|
|
Ndati = Ndatidespike;
|
|
end
|
|
ini = round(Ndati/2)+1;
|
|
if rem(Ndati,2) == 0
|
|
ini = ini+1;
|
|
end
|
|
clear NDati
|
|
ini = ini + margine;
|
|
if ini < 6
|
|
ini = 6;
|
|
end
|
|
if Ndevst_HR ~= 0 % Allora prendo tutti i dati e solo in seguito considero i nuovi, a valle della funzione filtro
|
|
ini = 1;
|
|
end
|
|
[rA,~] = size(ANGdef_TLHR); % Numero di dati delle ampolle
|
|
[rM,~] = size(ACCdef_TL); % Numero di dati dei MEMS
|
|
if rA~=rM
|
|
if rM > rA
|
|
ini_MEMS = rM-rA+ini;
|
|
ini_Ampolle = ini;
|
|
elseif rM < rA
|
|
ini_Ampolle = rA-rM+ini; % Si presume che la data finale sia identica per entrambi
|
|
ini_MEMS = ini;
|
|
end
|
|
else
|
|
ini_MEMS = ini;
|
|
ini_Ampolle = ini;
|
|
end
|
|
ANGdef_TLHR = ANGdef_TLHR(ini_Ampolle:end,:);
|
|
MAGdef_TL = MAGdef_TL(ini_MEMS:end,:);
|
|
TempDef_TLHR = TempDef_TLHR(ini_Ampolle:end,:);
|
|
DatiElabTiltLinkHR = DatiElabTiltLinkHR(ini_Ampolle:end,:);
|
|
ARRAYdateTLHR = ARRAYdateTLHR(ini_Ampolle:end,1);
|
|
ErrTiltLinkHR = ErrTiltLinkHR(ini_Ampolle:end,:);
|
|
end
|
|
|
|
%% Elaborazione sfruttando il magnetometro del MEMS
|
|
if allineato == 0 && yesTLHR3D == 1
|
|
|
|
% Definisco i dati MEMS
|
|
[r,~] = size(MAGdef_TL);
|
|
Nnodi = rTL;
|
|
mx = zeros(r,Nnodi);
|
|
my = zeros(r,Nnodi);
|
|
for i=1:Nnodi
|
|
mx(:,i)= -1*MAGdef_TL(:,(i-1)*3+1); % mx
|
|
my(:,i) = -1*MAGdef_TL(:,(i-1)*3+2:(i-1)*3+2); % my
|
|
end
|
|
|
|
mx = mx'; % riga nodi, colonna date
|
|
my = my'; % riga nodi, colonna date
|
|
|
|
NodoTiltLink = cell2mat(NodoTiltLink(:,2));
|
|
NodoDoppio = cell2mat(NodoTiltLinkHR3D(:,2));
|
|
[S] = size(NodoDoppio);
|
|
Nodes = zeros(S(1),1);
|
|
for s = 1:S(1)
|
|
Nodes(s,1) = find(NodoTiltLink == NodoDoppio(s,1));
|
|
end
|
|
end
|
|
|
|
% Definisco i dati della cella elettrolitica
|
|
[Ndate,~] = size(ARRAYdateTLHR);
|
|
Nnodi = rTLHR;
|
|
AngoloX = zeros(Ndate,Nnodi); % angoli di inclinazione asse X
|
|
AngoloY = zeros(Ndate,Nnodi); % angoli di inclinazione asse Y
|
|
ii = 1;
|
|
for i=1:Nnodi
|
|
AngoloX(:,i) = ANGdef_TLHR(:,ii); % ax
|
|
AngoloY(:,i) = ANGdef_TLHR(:,ii+1);% ay
|
|
ii = ii+2;
|
|
end
|
|
|
|
AngoloX = AngoloX';
|
|
AngoloY = AngoloY';
|
|
|
|
%% Costruzione delle matrici spostamento e rotazione
|
|
sX = zeros(rTLHR,Ndate); % in riga i nodi, in colonna le date
|
|
sY = zeros(rTLHR,Ndate);
|
|
sZ = zeros(rTLHR,Ndate);
|
|
|
|
% Inizio del ciclo di elaborazione
|
|
text = 'Elaboration of Tilt Link HR V started';
|
|
fprintf(fileID,fmt,text);
|
|
|
|
for Imis = 1:Ndate % date
|
|
for jjj=1:Nnodi % nodi
|
|
%% Uso magnetometro MEMS
|
|
if allineato == 0 && yesTLHR3D == 1 % uso il magnetometro del MEMS
|
|
Mx = mx(Nodes(jjj,1),:);
|
|
My = my(Nodes(jjj,1),:);
|
|
angle = arotHR(Mx,My,Imis);
|
|
% angolo di inclinazione rispetto all'orizzontale registrato da asse x
|
|
xAngTLHR = AngoloX(jjj,Imis);
|
|
% angolo di inclinazione rispetto all'orizzontale registrato da asse y
|
|
yAngTLHR = AngoloY(jjj,Imis);
|
|
% converto gli angoli in radianti (matlab ragiona così)
|
|
xAngTLHR = 0.01745329251994329576923690768489*xAngTLHR;
|
|
yAngTLHR = 0.01745329251994329576923690768489*yAngTLHR;
|
|
% Segmento di pertinenza
|
|
if yesTLHR3D == 1
|
|
SpTLHR = SpeTLHR(jjj+1); % correzione che salta l'ancora
|
|
else
|
|
% Correzione che salta l'ancora e il primo nodo Tilt Link (se
|
|
% presente)
|
|
SpTLHR = SpeTLHR(jjj+2);
|
|
end
|
|
% Finalizzo
|
|
if datenum(date) > 737643 % Codice post Correzione
|
|
[Na,Ea,Za] = ASSEa_HR(xAngTLHR,angle,SpTLHR);
|
|
[Nb,Eb,Zb] = ASSEb_HR(yAngTLHR,angle,SpTLHR);
|
|
else % Codice pre-correzione
|
|
[Na,Ea,Za] = ASSEa_HR(xAngTLHR,angle,SpTLHR);
|
|
[Nb,Eb,Zb] = ASSEb_HR_OLD(yAngTLHR,angle,SpTLHR);
|
|
end
|
|
sX(jjj,Imis) = Na+Nb;
|
|
sY(jjj,Imis) = Ea+Eb;
|
|
% Calcolo l'abbassamento (positivo) considerando il MAGGIORE dei due calcolati sui due assi
|
|
sZ(jjj,Imis) = max(Za,Zb);
|
|
else
|
|
%% NON uso magnetometro MEMS
|
|
|
|
% angolo di inclinazione rispetto all'orizzontale registrato da asse x
|
|
xAngTLHR = AngoloX(jjj,Imis);
|
|
% angolo di inclinazione rispetto all'orizzontale registrato da asse y
|
|
yAngTLHR = AngoloY(jjj,Imis);
|
|
% converto gli angoli in radianti (matlab ragiona così)
|
|
xAngTLHR = 0.01745329251994329576923690768489*xAngTLHR;
|
|
yAngTLHR = 0.01745329251994329576923690768489*yAngTLHR;
|
|
% Segmento di pertinenza
|
|
if yesTL == 1
|
|
if yesTLHR3D == 1
|
|
SpTLHR = SpeTLHR(jjj+1); % correzione che salta l'ancora
|
|
else
|
|
% Correzione che salta l'ancora e il primo nodo Tilt Link (se
|
|
% presente)
|
|
SpTLHR = SpeTLHR(jjj+2);
|
|
end
|
|
else
|
|
SpTLHR = SpeTLHR(jjj+1); % correzione che salta l'ancora
|
|
end
|
|
% calcolo spostamenti lungo x e y
|
|
sX(jjj,Imis) = SpTLHR*sin(xAngTLHR);
|
|
sY(jjj,Imis) = SpTLHR*sin(yAngTLHR);
|
|
% Abbassamento registrato dai due assi
|
|
sXZ = SpTLHR - SpTLHR*cos(xAngTLHR);
|
|
sYZ = SpTLHR - SpTLHR*cos(yAngTLHR);
|
|
% Calcolo l'abbassamento considerando il maggiore dei due calcolati sui due assi
|
|
sZ(jjj,Imis) = max(sXZ,sYZ);
|
|
|
|
end
|
|
end
|
|
end
|
|
|
|
% dsX, dsY e dsZ raccolgono i dati del singolo nodo nella singola data
|
|
dsX = diff(sX,1,2);
|
|
dsY = diff(sY,1,2);
|
|
dsZ = diff(sZ,1,2);
|
|
|
|
%% Cambio di segno le direzioni!
|
|
if segnoNS_HR == 0
|
|
dsX= -1*dsX;
|
|
end
|
|
if segnoEO_HR == 0
|
|
dsY = -1*dsY;
|
|
end
|
|
|
|
%% Filtro su temperatura
|
|
clear i
|
|
clear j
|
|
cont2 = 1; % contatore
|
|
TempDef_TLHR = TempDef_TLHR';
|
|
textT = 'There are not correction of Tilt Link HR V based on temperature filter';
|
|
|
|
FileTemperature = ['' IDcentralina '-' DTcatena '-TLHR-Therm.csv'];
|
|
if isfile(FileTemperature) == 1
|
|
DatiRaw = csvread(FileTemperature);
|
|
[rDR,cDR] = size(DatiRaw);
|
|
DatiRaw(:,1) = DatiRaw(:,1) + 730000;
|
|
else
|
|
rDR = 1;
|
|
cDR = 1;
|
|
end
|
|
for j = 1:Ndate % Data
|
|
for i = 1:Nnodi % Nodo
|
|
% NON considero i dati al di sopra di Tmax o al di sotto di Tmin
|
|
if TempDef_TLHR(i,j) > Tmax || TempDef_TLHR(i,j) < Tmin
|
|
cont2 = cont2+1;
|
|
if j == 1
|
|
if isfile(FileTemperature) == 1
|
|
RawDate = find(DatiRaw(:,1)<=datenum(datainiTLHR));
|
|
if isempty(RawDate) == 1
|
|
cc = 2;
|
|
while cc <= Ndate
|
|
if TempDef_TLHR(i,cc) > Tmax || TempDef_TLHR(i,cc) < Tmin
|
|
cc = cc+1;
|
|
else
|
|
break
|
|
end
|
|
end
|
|
TempDef_TLHR(i,j) = TempDef_TLHR(i,cc);
|
|
else
|
|
if isnan(DatiRaw(RawDate(end),i+1)) == 0
|
|
TempDef_TLHR(i,j) = DatiRaw(RawDate(end),i+1);
|
|
ErrTiltLinkHR(j,i) = 0.5;
|
|
wardat = 'Temperature data of Tilt Link HR nodes corrected using Raw Data of reference Csv file.';
|
|
fprintf(fileID,fmt,wardat);
|
|
else
|
|
cc = 2;
|
|
while cc <= c
|
|
if TempDef_TLHR(i,cc) > Tmax || TempDef_TLHR(i,cc) < Tmin
|
|
cc = cc+1;
|
|
else
|
|
break
|
|
end
|
|
end
|
|
TempDef_TLHR(i,j) = TempDef_TLHR(i,cc);
|
|
end
|
|
end
|
|
else
|
|
cc = 2;
|
|
while cc <= c
|
|
if TempDef_TLHR(i,cc) > Tmax || TempDef_TLHR(i,cc) < Tmin
|
|
cc = cc+1;
|
|
else
|
|
break
|
|
end
|
|
end
|
|
TempDef_TLHR(i,j) = TempDef_TLHR(i,cc);
|
|
end
|
|
else
|
|
dsX(i,j-1) = 0;
|
|
dsY(i,j-1) = 0;
|
|
dsZ(i,j-1) = 0;
|
|
TempDef_TLHR(i,j) = TempDef_TLHR(i,j-1);
|
|
ErrTiltLinkHR(j,i) = 0.5;
|
|
end
|
|
end
|
|
textT = ['' num2str(cont2) ' correction executed for Tilt Link HR V - Temperature filter!'];
|
|
end
|
|
end
|
|
|
|
if rDR~=1 && cDR~=1 && isempty(DatiRaw) == 0
|
|
RawDate1 = find(DatiRaw(:,1)<=ARRAYdateTLHR(1));
|
|
if isempty(RawDate1) == 1
|
|
RawDate2 = 1;
|
|
elseif RawDate1(end) == rDR
|
|
RawDate2 = find(ARRAYdateTLHR(:,1)>DatiRaw(end,1));
|
|
else
|
|
RawDate2 = find(ARRAYdateTLHR(:,1)>DatiRaw(RawDate1(end)+1,1));
|
|
end
|
|
else
|
|
RawDate1 = [];
|
|
RawDate2 = 1;
|
|
end
|
|
if isempty(RawDate1) == 0 && isempty(RawDate2) == 0
|
|
Dati = [DatiRaw(1:RawDate1(end),:); ARRAYdateTLHR(RawDate2(1):end) TempDef_TLHR(:,RawDate2(1):end)'];
|
|
elseif isempty(RawDate1) == 1 && isempty(RawDate2) == 0
|
|
Dati = [ARRAYdateTLHR TempDef_TLHR'];
|
|
else
|
|
Dati = DatiRaw;
|
|
end
|
|
% Elimino appoggio più vecchio di un mese
|
|
RawDate3 = find(Dati(:,1)<now-30);
|
|
if isempty(RawDate3) == 0
|
|
[rDati,~] = size(Dati);
|
|
if RawDate3(end) == rDati
|
|
else
|
|
Dati = Dati(RawDate3(end)+1:end,:);
|
|
end
|
|
end
|
|
if isfile(FileTemperature) == 1
|
|
delete(FileTemperature);
|
|
end
|
|
Dati(:,1) = Dati(:,1) - 730000;
|
|
csvwrite(FileTemperature,Dati);
|
|
|
|
TempDef_TLHR = TempDef_TLHR';
|
|
|
|
fprintf(fileID,fmt,textT);
|
|
fclose(fileID);
|
|
|
|
% azzeramenti di alcuni nodi in particolare
|
|
[dsX,dsY,dsZ] = azzeramenti_TLHR(IDcentralina,DTcatena,dsX,dsY,dsZ,NodoTiltLinkHR,FileName);
|
|
|
|
% filtro
|
|
[dsX,dsY,dsZ] = filtro(dsX,dsY,dsZ,Ndevst_HR,Wdevst_HR,FileName);
|
|
if NuovoZeroTLHR == 1 && Ndevst_HR ~= 0
|
|
if NdatiMedia > Ndatidespike
|
|
NdatiF = NdatiMedia;
|
|
else
|
|
NdatiF = Ndatidespike;
|
|
end
|
|
ini = round(NdatiF/2)+1;
|
|
if rem(NdatiF,2) == 0
|
|
ini = ini+1;
|
|
end
|
|
clear NDatiF
|
|
iniST = round(Wdevst_HR/2);
|
|
if rem(Wdevst_HR,2) == 0
|
|
iniST = iniST+1;
|
|
end
|
|
iniST = iniST + margine;
|
|
if iniST > ini
|
|
ini = iniST;
|
|
end
|
|
if ini < 6
|
|
ini = 6;
|
|
end
|
|
dsX = dsX(:,ini:end);
|
|
dsY = dsY(:,ini:end);
|
|
dsZ = dsZ(:,ini:end);
|
|
TempDef_TLHR = TempDef_TLHR(ini:end,:);
|
|
DatiElabTiltLinkHR = DatiElabTiltLinkHR(ini:end,:);
|
|
ARRAYdateTLHR = ARRAYdateTLHR(ini:end,1);
|
|
ErrTiltLinkHR = ErrTiltLinkHR(ini:end,:);
|
|
end
|
|
|
|
%% Finalizzo i calcoli
|
|
[rX,cX] = size(dsX);
|
|
sommaX_HR = zeros(rTLHR,1);
|
|
Xlocal_HR = zeros(rX,cX+1); % totale del singolo nodo data per data
|
|
AlfaX_HR = zeros(rX,cX+1); % Angoli
|
|
sommaY_HR = zeros(rTLHR,1);
|
|
Ylocal_HR = zeros(rX,cX+1);
|
|
AlfaY_HR = zeros(rX,cX+1); % Angoli
|
|
sommaZ_HR = zeros(rX,cX+1);
|
|
Zlocal_HR = zeros(rX,cX+1);
|
|
X_HR = zeros(rX,cX+1); % cumulata del singolo nodo data per data
|
|
Y_HR = zeros(rX,cX+1); % il primo valore è 0
|
|
Z_HR = zeros(rX,cX+1);
|
|
HShift_HR = zeros(rX,cX+1);
|
|
HShift_local_HR = zeros(rX,cX+1);
|
|
Azimuth_HR = zeros(rX,cX+1);
|
|
azim_HR = zeros(rX,cX+1); % matrice di appoggio per il calcolo dell'azimuth
|
|
Speed_HR = zeros(rTLHR,cX+1); % Velocità 2D Cumulata
|
|
Speed_local_HR = zeros(rTLHR,cX+1); % Velocità 2D locale
|
|
Acceleration_HR = zeros(rTLHR,cX+1); % Accelerazione 2D Cumulata
|
|
Acceleration_local_HR = zeros(rTLHR,cX+1); % Accelerazione 2D Locale
|
|
if yesTL == 1
|
|
if yesTLHR3D == 1
|
|
SpeTLHR = SpeTLHR(2:end); % correzione che salta l'ancora
|
|
else
|
|
% Correzione che salta l'ancora e il primo nodo Tilt Link (se
|
|
% presente)
|
|
SpeTLHR = SpeTLHR(3:end);
|
|
end
|
|
else
|
|
SpeTLHR = SpeTLHR(2:end); % correzione che salta l'ancora
|
|
end
|
|
% Recupero i dati già elaborati
|
|
if NuovoZeroTLHR == 1
|
|
[rE,cE] = size(DatiElabTiltLinkHR);
|
|
cont = 3;
|
|
n = 1;
|
|
while cont<=cE
|
|
sommaX_HR(n,1) = cell2mat(DatiElabTiltLinkHR(1,cont))';
|
|
Xlocal_HR(n,1) = sommaX_HR(n,1);
|
|
X_HR(n,1) = cell2mat(DatiElabTiltLinkHR(1,cont+3))';
|
|
sommaY_HR(n,1) = cell2mat(DatiElabTiltLinkHR(1,cont+1))';
|
|
Ylocal_HR(n,1) = sommaY_HR(n,1);
|
|
Y_HR(n,1) = cell2mat(DatiElabTiltLinkHR(1,cont+4))';
|
|
for j = 1:rTLHR
|
|
AlfaX_HR(j,1) = asind(Xlocal_HR(j,1)/SpeTLHR(j));
|
|
AlfaY_HR(j,1) = asind(Ylocal_HR(j,1)/SpeTLHR(j));
|
|
end
|
|
Zlocal_HR(n,1) = cell2mat(DatiElabTiltLinkHR(1,cont+2))';
|
|
sommaZ_HR(n,1) = SpeTLHR(n,1)-Zlocal_HR(n,1);
|
|
Z_HR(n,1) = cell2mat(DatiElabTiltLinkHR(1,cont+5))';
|
|
HShift_HR(n,1) = cell2mat(DatiElabTiltLinkHR(1,cont+6))';
|
|
HShift_local_HR(n,1) = cell2mat(DatiElabTiltLinkHR(1,cont+7))';
|
|
Azimuth_HR(n,1) = cell2mat(DatiElabTiltLinkHR(1,cont+8))';
|
|
Speed_HR(n,1:rE) = cell2mat(DatiElabTiltLinkHR(:,cont+10))';
|
|
Speed_local_HR(n,1:rE) = cell2mat(DatiElabTiltLinkHR(:,cont+11))';
|
|
Acceleration_HR(n,1:rE) = cell2mat(DatiElabTiltLinkHR(:,cont+12))';
|
|
Acceleration_local_HR(n,1:rE) = cell2mat(DatiElabTiltLinkHR(:,cont+13))';
|
|
cont=cont+16;
|
|
n = n+1;
|
|
end
|
|
else
|
|
Zlocal_HR(:,1) = SpeTLHR;
|
|
Z_HR(:,1) = PsTLHR(2:end);
|
|
end
|
|
|
|
% elaboro i dati nuovi
|
|
for iii = 1:cX
|
|
Xlocal_HR(:,iii+1) = sum(dsX(:,1:iii),2)+sommaX_HR(:,1);
|
|
Ylocal_HR(:,iii+1) = sum(dsY(:,1:iii),2)+sommaY_HR(:,1);
|
|
for j = 1:rTLHR
|
|
AlfaX_HR(j,iii+1) = asind(Xlocal_HR(j,iii+1)/SpeTLHR(j));
|
|
AlfaY_HR(j,iii+1) = asind(Ylocal_HR(j,iii+1)/SpeTLHR(j));
|
|
end
|
|
sommaZ_HR(:,iii+1) = sum(dsZ(:,1:iii),2);
|
|
X_HR(:,iii+1) = cumsum(Xlocal_HR(:,iii+1));
|
|
Y_HR(:,iii+1) = cumsum(Ylocal_HR(:,iii+1));
|
|
Z_HR(:,iii+1) = Z_HR(:,1) - cumsum(sommaZ_HR(:,iii+1));
|
|
HShift_HR(:,iii+1) = (X_HR(:,iii+1).^2+Y_HR(:,iii+1).^2).^0.5;
|
|
HShift_local_HR(:,iii+1) = (Xlocal_HR(:,iii+1).^2+Ylocal_HR(:,iii+1).^2).^0.5;
|
|
Zlocal_HR(:,iii+1) = SpeTLHR - sommaZ_HR(:,iii+1); % Zeta è il singolo abbassamento di quel nodo
|
|
for rr = 1:rTLHR
|
|
azim_HR(rr,iii) = (acos(abs(X_HR(rr,iii))/HShift_HR(rr,iii)))*180/3.141592654; % Angolo Teta in gradi 0° - 90°
|
|
segnoNS = sign(X_HR(rr,iii));
|
|
segnoEO = sign(Y_HR(rr,iii));
|
|
% L'azimuth si calcola con NS = 0, positivo in senso orario
|
|
% (90° = Est)
|
|
if segnoNS == 1 && segnoEO == 1 % quadrante 1
|
|
Azimuth_HR(rr,iii+1) = azim_HR(rr,iii); % Teta lo tengo come è (1 quadrante)
|
|
elseif segnoNS == -1 && segnoEO == 1 % quadrante 2
|
|
Azimuth_HR(rr,iii+1) = 180 - azim_HR(rr,iii); % 180-teta
|
|
elseif segnoNS == -1 && segnoEO == -1 % quadrante 3
|
|
Azimuth_HR(rr,iii+1) = 180 + azim_HR(rr,iii); % 180+teta
|
|
elseif segnoNS == 1 && segnoEO == -1 % quadrante 4
|
|
Azimuth_HR(rr,iii+1) = 360 - azim_HR(rr,iii); % 360-teta
|
|
elseif segnoNS == 0 && segnoEO == -1 % 270°
|
|
Azimuth_HR(rr,iii+1) = 270;
|
|
elseif segnoNS == -1 && segnoEO == 0 % 180°
|
|
Azimuth_HR(rr,iii+1) = 180;
|
|
end
|
|
end
|
|
end
|
|
Azimuth_HR = real(Azimuth_HR);
|
|
|
|
%% Calcolo velocità di spostamento giornaliera
|
|
[numDate,~] = size(ARRAYdateTLHR); % numero di date
|
|
d = 1;
|
|
p = 1;
|
|
diffDate = 0;
|
|
n = 1;
|
|
period = 1; % calcolo giornaliero
|
|
ContSUP = [];
|
|
for dd = 1:numDate
|
|
while diffDate < period
|
|
d = d+1;
|
|
if d > numDate % Se d supera le date disponibili, esco dal ciclo while
|
|
break
|
|
end
|
|
diffDate = ARRAYdateTLHR(d) - ARRAYdateTLHR(p);
|
|
end
|
|
if d >numDate
|
|
break
|
|
end
|
|
ContSUP(n,1) = d; % Creo matrice indici dell'estremo superiore della differenza
|
|
ContINF(n,1) = p; % Creo matrice indici dell'estremo inferiore della differenza
|
|
p = p+1; % passo alla data di partenza successiva
|
|
d = p; % resetto il conto di d
|
|
n = n+1;
|
|
diffDate = 0;
|
|
end
|
|
|
|
check = isempty(ContSUP);
|
|
if check == 0
|
|
[nDate,~] = size(ContSUP);
|
|
for s = 1:rTLHR
|
|
N = 1;
|
|
for dd = 1:nDate
|
|
Speed_HR(s,ContSUP(N,1)) = (HShift_HR(s,ContSUP(N,1))-HShift_HR(s,ContINF(N,1)))/(ARRAYdateTLHR(ContSUP(N,1))-ARRAYdateTLHR(ContINF(N,1)));
|
|
Speed_local_HR(s,ContSUP(N,1)) = (HShift_local_HR(s,ContSUP(N,1))-HShift_local_HR(s,ContINF(N,1)))/(ARRAYdateTLHR(ContSUP(N,1))-ARRAYdateTLHR(ContINF(N,1)));
|
|
Acceleration_HR(s,ContSUP(N,1)) = (Speed_HR(s,ContSUP(N,1))-Speed_HR(s,ContINF(N,1)))/(ARRAYdateTLHR(ContSUP(N,1))-ARRAYdateTLHR(ContINF(N,1)));
|
|
Acceleration_local_HR(s,ContSUP(N,1)) = (Speed_local_HR(s,ContSUP(N,1))-Speed_local_HR(s,ContINF(N,1)))/(ARRAYdateTLHR(ContSUP(N,1))-ARRAYdateTLHR(ContINF(N,1)));
|
|
N = N+1;
|
|
end
|
|
end
|
|
end
|
|
|
|
% Approssimo i dati con il corretto numero di cifre decimali
|
|
[X_HR,Y_HR,Z_HR,Xlocal_HR,Ylocal_HR,Zlocal_HR,HShift_HR,...
|
|
HShift_local_HR,Azimuth_HR,Speed_HR,Speed_local_HR,Acceleration_HR,...
|
|
Acceleration_local_HR,TempDef_TLHR] = approx_TLHR(X_HR,Y_HR,Z_HR,...
|
|
Xlocal_HR,Ylocal_HR,Zlocal_HR,HShift_HR,HShift_local_HR,Azimuth_HR,...
|
|
Speed_HR,Speed_local_HR,Acceleration_HR,Acceleration_local_HR,TempDef_TLHR,FileName);
|
|
|
|
% Matrice errori
|
|
[r,~] = size(ErrTiltLinkHR);
|
|
Matrice_err = zeros(r,rTLHR);
|
|
for i = 1:r % date
|
|
d = 1;
|
|
for n = 1:rTLHR % nodi
|
|
j = 1;
|
|
err = ErrTiltLinkHR(i,d:d+5);
|
|
while j <= 6
|
|
if err(1,j) == 1
|
|
Matrice_err(i,n) = 1;
|
|
break
|
|
end
|
|
if err(1,j) == 0.5
|
|
Matrice_err(i,n) = 0.5;
|
|
end
|
|
j = j+1;
|
|
end
|
|
d = d+6;
|
|
end
|
|
end
|
|
ErrTiltLinkHR = Matrice_err';
|
|
|
|
text = 'Tilt Link HR V calculation executed correctly';
|
|
fileID = fopen(FileName,'a');
|
|
fmt = '%s \r';
|
|
fprintf(fileID,fmt,text);
|
|
fclose(fileID);
|
|
|
|
end |