//**STIMA DEL RITARDO**//

Codice scritto e redatto da:  __Campa Luca__

Il codice che segue è scritto in **C++**. Esso ci permette di calcolare la **convoluzione circolare** dei dati proveniente dai due strumenti, ed in particolare **dopo quanti intervalli si ottiene il valore maggiore di convoluzione delle coordinate y**: il programma restituisce anche dopo quanti slittamenti si ottiene il suddetto valore permettendoci quindi di scoprire il ritardo tra i due segnali e di conseguenza sovrapporre i grafici dei due strumenti (che prima erano sfalsati).
Come spiegato **[[http://www.cloc3.net/dokuwiki/doku.php/distanza_tra_i_due_segnali | qui]]** essa consiste nel:

  Legenda: 	A: primo segnale
     		B: secondo segnale
                  n: è un n° intero che indica il numero dei valori

1) moltiplicare le coordinate y del primo segnale con le coordinate y del secondo e sommare i dati ottenuti:
 y1A * y1B + y2A * y2B + …. + ynA * ynB;

2) Successivamente slittare di un intervallo di tempo (0,003 milli secondi) e ripetere la stessa operazione, sommando i risultati ottenuti:
y1A * y2B + … + y(n-1)A * ynB + ynA * y1B;

3) Continuare a slittare ogni volta di un intervallo e ripetere le stesse operazioni fino a questa:
y1A * ynB + y2A * y1B + … + ynA * y(n-1)B;

Ma..cosa dobbiamo ricavare da queste somme?
**Tra le somme ottenute si ricerca quella massima. Attraverso un'algoritmo si ricava poi dopo quanti slittamenti (o meglio traslazioni) si ha tale somma massima: questo risultato moltiplicato per il tempo di ogni traslazione (0,003 millisecondi) ci fornisce il ritardo tra i due segnali!!**

Prima di scrivere il codice del programma è opportuno richiamare alcune librerie atte a permetterci di svolgere alcune operazioni sui file:
<code cpp>
#include <iostream>
#include <fstream>
#include <stdio.h>
#include <stdlib.h>
</code>  
Il programma si avvale di alcune **funzioni** create da me appositamente per velocizzare il programma (in modo tale da non riscrivere tante volte le stesse operazioni caricando il file):

1) per trovare il valore massimo:
<code cpp>  
int max(int a[], int dim)                //inizio funzione per calcolare il valore massimo
 {
    int max=0;
    int i;
  for (i=0; i<dim; i++) {
      if (max<a[i]) 
      {
          max=a[i];
      }
   }
return max;                             
}                                        //fine funzione per calcolare il valore massimo
</code>  
2) per contare le righe del file dati:
<code cpp>
int contarighe(FILE *fp) {                                  //funzione per contare le righe del file
int i=0;
char buffer;
while(true) {
fread((void*)&buffer, sizeof(char),1,fp);
if(feof(fp))
break;
if(buffer=='\n')
i++;
}
return i;
}                                                           //fine funzione per contare le righe del file
</code>  
3) per calcolare la media:
<code cpp>
int media(int array[],int linee) {      //funzione per il calcolo della media
int somma=0;
for(int i=0; i<linee; i++) {
somma = somma + array[i];
}
int media = somma/linee;
return media;
}                                        //fine funzione per il calcolo della media
</code>  
4) per effettuare la convoluzione e trovare la distanza tra i due segnali (cioè il numero di traslazioni):
<code cpp>
int convoluzione(int ordinate1[] , int ordinate2[] , int linee, int valoremedio1, int valoremedio2 ) {      //inizio funzione per la convoluzione dei valori
int SOMMA[linee];                                                                                                  
for(int N=0; N<linee; N++) {
int k = 0;
SOMMA[N]=0;
for(int i = 0; i<linee; i++) {
if(i+N>linee-1) 
k = -((ordinate1[i+N-(linee)])-valoremedio1)*((ordinate2[i])-valoremedio2);                   //si sottrae il valore medio delle coordinate y di un segnale 
else                                                                                         //e dell'altro per effettuare una traslazione verticale: 
k = -((ordinate1[i+N])-valoremedio1)*((ordinate2[i])-valoremedio2);                             //i segnali, infatti, inizialmente sono sfalsati.
SOMMA[N] = SOMMA[N] + k;
}
}
int massimo = max(SOMMA, linee);
cout<<massimo<<"\n";

bool x = true;                                                                              //inizio del ciclo per il calcolo delle traslazioni
int w=0;
while(x) {
if(SOMMA[w]!=massimo) {
w++;
}
else {
cout<<"L'intervallo avviene dopo "<<linee-w<<" traslazioni"<<"\n";                    
x = false;                                                                                  //fine del ciclo per il calcolo delle traslazioni
}
}
}                                                                                           //fine funzione per la convoluzione dei valori
</code>  

Ora il **main()**, cioè il programma vero e proprio dove vengono richiamate le funzioni appena presentate:
1) Si richiede all’utente di inserire il nome del file o il suo percorso (se si trova in un altra cartella);
2) Si scopre di quante righe è composto tale file;
3) Si memorizzano i dati contenuti nel file all’interno di una matrice bidimensionale (matrice[][]);
4) Si dichiarano altri array utili a contenere i dati delle coordinate;
5) Si calcola la media delle coordinate;
6) Si calcola la convoluzione e il numero di slittamenti.
<code cpp>
main()
{
char nome[20];
cout<<"Inserisci il nome del file (se serve anche il suo percorso): ";
gets(nome);
FILE *file;
file = fopen(nome,"r");

if(file == NULL)
printf("Nessun file \n");
int linee = contarighe(file);
fclose(file);
printf("Numero di righe:%i\n",linee);

int colonne=7;               
ifstream matfile;                                   //inizio lettura dei dati dal file
int matrice[linee][colonne];
int j,k;
matfile.open(nome);                        
for(int i=0; i<linee; i++)
 {
   for(int j=0; j<colonne; j++)
    {
      matfile >> matrice[i][j];
      if (matfile.eof())
        {
           cout<<"dati insufficienti"<<endl;
           matfile.close();
                 }
    }
 }
matfile.close();                                    //fine lettura dati da file e archiviazione dati nell'array matrice[][]


int ascisse1[linee];                       //dichiarazione degli array utili alla convoluzione
int ascisse2[linee];
int ordinate1[linee];
int ordinate2[linee];
int quote1[linee];
int quote2[linee];

for(int i=0; i<linee;i++) {                             
ascisse1[i]=matrice[i][1];
}                                            //fine ciclo per inserire le ascisse 1 in array
for(int i=0; i<linee;i++) {
ascisse2[i]=matrice[i][4];
}                                            //fine ciclo per inserire le ascisse 2 in array
for(int i=0; i<linee;i++) {
ordinate1[i]=matrice[i][2];
}                                            //fine ciclo per inserire le ordinate 1 in array
for(int i=0; i<linee;i++) {
ordinate2[i]=matrice[i][5];
}                                            //fine ciclo per inserire le ordinate 2 in array
for(int i=0; i<linee;i++) {
quote1[i]=matrice[i][3];
}                                            //fine ciclo per inserire le quote 1 in array
for(int i=0; i<linee;i++) {
quote2[i]=matrice[i][6];
}                                            //fine ciclo per inserire le quote 2 in array
  
int media_ascisse1 = media(ascisse1, linee);                                //calcolo delle medie
int media_ascisse2 = media(ascisse2, linee); 
int media_ordinate1 = media(ordinate1, linee); 
int media_ordinate2 = media(ordinate2, linee); 
int media_quote1 = media(quote1, linee); 
int media_quote2 = media(quote2, linee); 
  
cout<<"Il valore massimo delle X è: ";                                      //tutti gli output 
convoluzione(ascisse1,ascisse2,linee,media_ascisse1,media_ascisse2);
cout<<"Il valore massimo delle Y è: ";
convoluzione(ordinate1,ordinate2,linee,media_ordinate1,media_ordinate2);
cout<<"Il valore massimo delle Z è: ";
convoluzione(quote1,quote2,linee,media_quote1,media_quote2);
}
</code>

Dopo aver compilato il file in C++ (c++ nomefile.cpp da terminale) è possibile avviarlo e analizzare finalmente la prima serie di dati!!
Analizzando lo stesso file di dati utilizzato dal Prof. Marco Clocchiatti per elaborare il grafico di convoluzione, attraverso il programma qui presentato si nota come si ottengono gli stessi risultati:

{{ :img_stima_ritardo.png |}}

Si osserva, infatti, come il massimo valore del grafico coincida con il massimo valore y elaborato dal programma e che tale dato si ritrova dopo 3 intervalli (come indicato dalla figura e calcolato dal programma).