void Agenda::cerca(int posizione)
{
/** Avendo la posizione scorre il file bst trovando tutti eventi di un giorno*/
albero bst;
ifstream readBst("bst.txt");
ifstream readCalendar("calendar.txt");
bool trovato = false;
readBst.seekg((posizione*(sizeAlbero)),ios_base::beg); // va sulla riga dove punta SX o DX
readBst.read((char*)&bst,sizeAlbero);
if(!readBst.eof())
{
if(!bst.cancellato)
{
if(bst.anno == y)
{
if(bst.mese == m)
{
if(bst.giorno == d)
{
readCalendar.seekg((bst.pos*sizeRecord),ios_base::beg);
readCalendar.read((char*)&rec,sizeRecord);
ui->listWidget->addItem(rec.descrizone);
vetPosizioni->posizione = posizione;
vetPosizioni->next = new struct vet;
trovato = true;
if(bst.dx != -1)
{
cerca(bst.dx);
}
if(bst.sx != -1)
{
cerca(bst.sx);
}
}
}
}
if(!trovato)
{ // controllo se la data che ha selezionato, e' > di data sul file;
if(confronto(bst) > 0) // se 1 a destra , se -1 a sinistra
{ // se e' > va a destra
if(bst.dx != -1)
{
cerca(bst.dx);
}
}
else
{ // se e' < vado a sinistra;
if(bst.sx != -1)
{
cerca(bst.sx);
}
}
}
}
}
}
void calendar::inserimentoBST()
{ /* Controlla se c'e' un evento cancellato nel file BST se c'e' prende quella posizione
* se non c'e' prende quella in fondo del file.Poi controlla se e' primo o no
* se primo evento del file lo aggiunge e basta, se non e' il primo, scorre
* usando SX o DX trovando un posto vuoto.*/
ofstream bst("bst.txt",ios::binary | ios::in | ios::out);
albero lettura; //struct per caricare data dal bst;
bool trovato = false;
bool primoEvento = true;
int posizione; // posizione dentro il file del BST
ifstream readbst("bst.txt",ios_base::app | ios_base::binary);
readbst.seekg(0,ios_base::beg);
while(!readbst.eof() && trovato==false) // con questo ciclo trovo se c'e' un evento cancellato per recuperare lo spazio
{
readbst.clear();
readbst.read((char*)&lettura,sizeAlbero);
if(!readbst.eof()) // perche' c'e' il problema che viene letto 2 volte ultimo elem
{
readbst.clear();
primoEvento = false;
if(lettura.cancellato)
{
trovato = true;
posizione = (readbst.tellg()/sizeAlbero);
}
}
}
if(trovato) // se trova evento cancellato salva - la posizione in una variabile, altrimenti salva alla fine del file
{
bst.seekp(posizione*(sizeAlbero),ios_base::beg);
}
else
{
bst.seekp(0,ios_base::end);
posizione = (bst.tellp()/sizeAlbero);
}
bst.write((const char*)&albero1,sizeAlbero); // salva nel file
if(!primoEvento)
{
int puntatorePosizione(0);
trovato = false;
while(trovato == false)
{
readbst.clear(); // cancella gli errori;
readbst.seekg((puntatorePosizione*sizeAlbero),ios::beg);
readbst.read((char*)&lettura,sizeAlbero);
if(!lettura.cancellato) // serve per il primo elemento
{
if(confronto(lettura) > 0)
{ // a destra
if(lettura.dx != -1)
{
puntatorePosizione = lettura.dx;
}
else
{
lettura.dx = posizione;
trovato = true;
}
}
else
{ // a sinistra
if(lettura.sx != -1)
{
puntatorePosizione = lettura.sx;
}
else
{
lettura.sx = posizione;
trovato = true;
}
}
}
else
{
trovato = true;
}
}
readbst.close();
bst.seekp((puntatorePosizione)*sizeAlbero,ios_base::beg);
bst.write((const char*)&lettura,sizeAlbero);
bst.close();
}
}
int main(int argc, char *argv[])
{
#ifdef __linux
feenableexcept(2);
feenableexcept(3);
#endif
FILE * matrici_iniziali=fopen("Matrici_Iniziali.txt","w");
FILE * posizionePart=fopen("Posizione_Particelle.txt","w");
FILE * ellissi=fopen("Parametri_Ellissi_Funz_Ottiche.txt","w");
FILE * funzioni_ottiche=fopen("Funzioni_Ottiche.txt","w");
FILE * confronti=fopen("Math_rilevati.txt","w");
#ifdef TEST_OPTICAL_FUNCTIONS
FILE * funzioni_ottiche_t=fopen("Funzioni_Ottiche_T.txt","w");
FILE * ellissi_t=fopen("Parametri_Ellissi_Funz_Ottiche_T.txt","w");
FILE * confronti_t=fopen("Math_rilevati_T.txt","w");
#endif
#ifdef DEBUG
FILE * outputDEBUG=fopen("DEBUG.txt","w");
#endif
bool fallita_lettura_parametri = true;
bool fallita_lettura_inputdistr = true;
bool do_transport = false;
bool do_optics = false;
bool posso_fare_funzioni_ottiche = false;
ifstream parametri;
ifstream inputdistr;
int nstep = 1;
double gnuplot_ymax_opt=0.;
bool calcola_ymax_opt = true;
#ifdef TEST_OPTICAL_FUNCTIONS
double gnuplot_ymax_opt_T=0.;
bool calcola_ymax_opt_T = true;
#endif
double gnuplot_ymax_pos=0.;
bool calcola_ymax_pos = true;
double gnuplot_xmax_opt=0.;
double gnuplot_xmax_pos=0.;
bool calcola_ymax_ell = true;
double gnuplot_ymax_ell=0.;
double percentuale=0.03;
int conto_per_confronto=0;
double *compare_x=new double[2];
double *compare_y=new double[2];
bool confronto_pos_x=false;
bool confronto_pos_y=false;
double *paramIniz_X=new double[2];
double *paramIniz_Y=new double[2];
#ifdef TEST_OPTICAL_FUNCTIONS
int conto_per_confronto_t_x=0;
int conto_per_confronto_t_y=0;
bool confronto_pos_t_y=false;
bool confronto_pos_t_x=false;
bool fai_da_te_x=false;
bool fai_da_te_y=false;
#endif
for (int i = 1; i < argc; i++)
{
if (string(argv[i]) == "-p")
{
parametri.open(argv[i+1]);
fallita_lettura_parametri=parametri.fail();
i++;
}
else if (string(argv[i]) == "-i")
{
inputdistr.open(argv[i+1]);
fallita_lettura_inputdistr=inputdistr.fail();
i++;
}
else if (string(argv[i]) == "-transport")
{
do_transport=true;
}
else if (string(argv[i]) == "-xmax_opt")
{
gnuplot_xmax_opt=atof(argv[i+1]);
i++;
}
else if (string(argv[i]) == "-xmax_pos")
{
gnuplot_xmax_pos=atof(argv[i+1]);
i++;
}
else if (string(argv[i]) == "-ymax_opt")
{
gnuplot_ymax_opt=atof(argv[i+1]);
calcola_ymax_opt = false;
i++;
}
#ifdef TEST_OPTICAL_FUNCTIONS
else if (string(argv[i]) == "-ymax_opt_T")
{
gnuplot_ymax_opt_T=atof(argv[i+1]);
calcola_ymax_opt_T = false;
i++;
}
#endif
else if (string(argv[i]) == "-ymax_pos")
{
gnuplot_ymax_pos=atof(argv[i+1]);
calcola_ymax_pos = false;
i++;
}
else if (string(argv[i]) == "-ymax_ell")
{
gnuplot_ymax_ell=atof(argv[i+1]);
calcola_ymax_ell = false;
i++;
}
else if (string(argv[i]) == "-compare_X")
{
compare_x[0]=atof(argv[i+1]);
compare_x[1]=atof(argv[i+2]);
i+=2;
}
else if (string(argv[i]) == "-compare_Y")
{
compare_y[0]=atof(argv[i+1]);
compare_y[1]=atof(argv[i+2]);
i+=2;
}
else if (string(argv[i]) == "-perc")
{
percentuale=atof(argv[i+1]);
fprintf(matrici_iniziali,"\n%f\n",percentuale);
i++;
}
else if (string(argv[i]) == "-optics")
{
do_optics=true;
}
else if (string(argv[i]) == "-nstep")
{
nstep = atoi(argv[i+1]);
i++;
}
#ifdef TEST_OPTICAL_FUNCTIONS
else if (string(argv[i]) == "-paramIniz_X")
{
paramIniz_X[0] = atoi(argv[i+1]);
paramIniz_X[1] = atoi(argv[i+2]);
fai_da_te_x=true;
i+=2;
}
else if (string(argv[i]) == "-paramIniz_Y")
{
paramIniz_Y[0] = atoi(argv[i+1]);
paramIniz_Y[1] = atoi(argv[i+2]);
fai_da_te_y=true;
i+=2;
}
#endif
else
{
printf("Impossibile riconoscere il parametro %s\n",argv[i]);
}
}
string utile_per_contare;
int conta_righe_parametri = 0;
if (fallita_lettura_parametri || fallita_lettura_inputdistr)
{
printf("Impossibile aprire (o non definito) il file contenente i parametri\no il file contenente la distribuzione/particella iniziale\n");
exit(204);
}
double * dati_iniziali = new double[6]; // emittanza, energia, x, y, px, py
for (int i = 0; i < 6; i++)
{
if(inputdistr.eof())
{
printf("Mancano dei dati iniziali!\n");
exit(123);
}
inputdistr >> dati_iniziali[i];
}
inputdistr.clear();
inputdistr.seekg(0,std::ios::beg);
double emittanza = dati_iniziali[0];
double energia = dati_iniziali[1];
double *vett_i=new double[4];
vett_i[0]=dati_iniziali[2];
vett_i[1]=dati_iniziali[4];
vett_i[2]=dati_iniziali[3];
vett_i[3]=dati_iniziali[5];
do
{
parametri >> utile_per_contare;
if(parametri.eof()) break;
parametri.ignore(1000, '\n');
conta_righe_parametri++;
}
while(!parametri.eof());
parametri.clear();
parametri.seekg(0,std::ios::beg);
// qui di leggono tutti i dati
// char *elemento=new char[conta_righe_parametri];
string *elemento=new string[conta_righe_parametri];
double * lunghezza= new double[conta_righe_parametri];
double * gradiente= new double[conta_righe_parametri];
int contatore=0;
for (int i = 0; i < conta_righe_parametri; i++)
{
parametri >> elemento[i];
parametri >> gradiente[i];
parametri >> lunghezza[i];
#ifdef DEBUG
cout << "Tipo elemento: " << elemento[i] << ", gradiente: " << gradiente[i] << ", lunghezza: " << lunghezza[i] << endl;
#endif
contatore++;
}
#ifdef DEBUG
printf("contatore: %d",contatore);
#endif
vector <vector <double> > I(4,vector<double>(4,0.0));
vector <vector <double> > K(4,vector<double>(4,0.0));
vector <vector <double> > F(4,vector<double>(4,0.0));
vector <vector <vector <double> > > Fx(contatore,vector <vector <double> > (4, vector <double> (4,0.0)));
vector <vector <vector <double> > > Dx(contatore,vector <vector <double> > (4, vector <double> (4,0.0)));
vector <vector <vector <double> > > OI(contatore,vector <vector <double> > (4, vector <double> (4,0.0)));
vector <vector <vector <double> > > FxI(contatore,vector <vector <double> > (4, vector <double> (4,0.0)));
vector <vector <vector <double> > > DxI(contatore,vector <vector <double> > (4, vector <double> (4,0.0)));
vector <vector <vector <double> > > O(contatore,vector <vector <double> > (4, vector <double> (4,0.0)));
double *alpha = new double[2];
double *beta = new double[2];
double *aminmax = new double[2];
double *bminmax = new double[2];
bool alpha_calcolato_con_successo=false;
bool beta_calcolato_con_successo=false;
#ifdef TEST_OPTICAL_FUNCTIONS
double *ottiche_x_t = new double[2];
double *ottiche_y_t = new double[2];
double *aminmax_x_t = new double[2];
double *bminmax_y_t = new double[2];
for (int i = 0; i < 2; i++) ottiche_x_t[i] = ottiche_y_t[i] = aminmax_x_t[i] = bminmax_y_t[i] = 0.;
#endif
double gamma_beta=sqrt(2.0*energia/MP_MEV);
double gamma_v=gamma_beta*SPEED_OF_LIGHT;
double *f1 =new double [contatore];
double *d1 =new double [contatore];
for (int i=0;i<contatore;i++)
{
if (elemento[i]=="F")
f1[i]=sqrt(gradiente[i]*CHARGE/(MP_KG*gamma_v));
if (elemento[i]=="D")
d1[i]=sqrt(gradiente[i]*CHARGE/(MP_KG*gamma_v));
}
#ifdef DEBUG
for (int i=0;i<contatore;i++)
{
fprintf(outputDEBUG,"\ngrad. foc. %+20.10f ", f1[i]*f1[i]);
fprintf(outputDEBUG,"\ngrad. defoc. %+20.10f ", d1[i]*d1[i]);
}
#endif
for (int i=0;i<contatore;i++)
{
#ifdef DEBUG
if (elemento[i]=="F")
Fx[i]=focusing(Fx[i],f1[i],lunghezza[i],matrici_iniziali,i);
else if (elemento[i]=="D")
Dx[i]=defocusing(Dx[i],d1[i],lunghezza[i],matrici_iniziali,i);
else if (elemento[i]=="O")
O[i]=drift(O[i],lunghezza[i],matrici_iniziali,i);
else
fprintf(outputDEBUG,"Elemento[%d] non riconosciuto\n", i);
#else
if (elemento[i]=="F")
Fx[i]=focusing(Fx[i],f1[i],lunghezza[i]);
else if (elemento[i]=="D")
Dx[i]=defocusing(Dx[i],d1[i],lunghezza[i]);
else if (elemento[i]=="O")
O[i]=drift(O[i],lunghezza[i]);
#endif
}
#ifdef DEBUG
for (int i=0;i<contatore;i++)
{
if (elemento[i]=="O")
{
// if (O[i][0][0] == 0.0) continue;
fprintf(matrici_iniziali,"\nMATRICE DRIFT");
scrivimatr2D(O[i],matrici_iniziali);
fprintf(matrici_iniziali,"\n");
}
else if (elemento[i]=="F")
{
// if (Fx[i][0][0] == 0.0) continue;
fprintf(matrici_iniziali,"\nMATRICE FOC.");
scrivimatr2D(Fx[i],matrici_iniziali);
fprintf(matrici_iniziali,"\n");
}
else if (elemento[i]=="D")
{
// if (Dx[i][0][0] == 0.0) continue;
fprintf(matrici_iniziali,"\nMATRICE DEFOC.");
scrivimatr2D(Dx[i],matrici_iniziali);
fprintf(matrici_iniziali,"\n");
}
}
#endif
/************************************************************************/
if (do_optics)
{
vector <vector <double> > compos(4,vector<double>(4,0));
if (elemento[0]=="O")
{
for (int k=0; k<4; k++)
for (int j=0; j<4; j++)
compos[k][j]=O[0][k][j];
}
else if (elemento[0]=="F")
{
for (int k=0; k<4; k++)
for (int j=0; j<4; j++)
compos[k][j]=Fx[0][k][j];
}
else if (elemento[0]=="D")
{
for (int k=0; k<4; k++)
for (int j=0; j<4; j++)
compos[k][j]=Dx[0][k][j];
}
for (int i=1;i<contatore;i++)
{
if (elemento[i]=="O")
compos=prodo(O[i],compos,4);
else if (elemento[i]=="F")
compos=prodo(Fx[i],compos,4);
else if (elemento[i]=="D")
compos=prodo(Dx[i],compos,4);
}
for (int i=0;i<4;i++)
for(int a=0;a<4;a++)
F[i][a]=compos[i][a];
// Calcolo Funzioni OTTICHE
for (int i = 0; i < 2; i++) alpha[i] = beta[i] = aminmax[i] = bminmax[i] = 0.;
if ( (fabs((F[FOC][FOC]+F[FOC+1][FOC+1])*0.5) <= 1.) && (fabs((F[DEFOC][DEFOC]+F[DEFOC+1][DEFOC+1])*0.5) <= 1.))
posso_fare_funzioni_ottiche = true;
else cout << "Impossibile calcolare le funzioni ottiche!" << endl;
//cout << "posso_fare_funzioni_ottiche="<<posso_fare_funzioni_ottiche<<endl;
//if ((((F[FOC][FOC]+F[FOC+1][FOC+1])*(F[FOC][FOC]+F[FOC+1][FOC+1])-4)<=0) && (((F[DEFOC][DEFOC]+F[DEFOC+1][DEFOC+1])*(F[DEFOC][DEFOC]+F[DEFOC+1][DEFOC+1])-4)<=0) )
// posso_fare_funzioni_ottiche = true;
//else cout << "Impossibile calcolare le funzioni ottiche!" << endl;
if (posso_fare_funzioni_ottiche)
{
alpha=optics(F,FOC,&alpha_calcolato_con_successo);
beta=optics(F,DEFOC,&beta_calcolato_con_successo);
aminmax = assi_ellissi(alpha, emittanza);
bminmax = assi_ellissi(beta, emittanza);
if (calcola_ymax_opt) massimo_opt(alpha,beta,&gnuplot_ymax_opt);
if (calcola_ymax_pos) massimo_pos(vett_i,&gnuplot_ymax_pos);
if (calcola_ymax_ell) massimo_opt(aminmax,bminmax,&gnuplot_ymax_ell);
fprintf(funzioni_ottiche,"# alpha_successo %d beta_successo %d\n",(int)(alpha_calcolato_con_successo),(int)(beta_calcolato_con_successo));
if (alpha_calcolato_con_successo&&beta_calcolato_con_successo)
{
fprintf(funzioni_ottiche,"\n#%7c",'S');
fprintf(funzioni_ottiche,"%10.8s","Alpha x");
fprintf(funzioni_ottiche,"%10.7s","Beta x");
fprintf(funzioni_ottiche,"%12.8s","Alpha y");
fprintf(funzioni_ottiche,"%10.7s","Beta y");
fprintf(ellissi,"%10s","x");
fprintf(ellissi,"%11s","p_x");
fprintf(ellissi,"%11s","y");
fprintf(ellissi,"%11s","p_y");
}
scrividati(0.0,alpha,beta,funzioni_ottiche);
scrividati_ellissi(0.0,aminmax,bminmax,ellissi);
#ifdef TEST_OPTICAL_FUNCTIONS
for (int i=0;i<2;i++)
{
if (fai_da_te_x&&fai_da_te_y)
{
ottiche_x_t[i]=paramIniz_X[i];
ottiche_y_t[i]=paramIniz_Y[i];
}
else if (fai_da_te_x)
{
ottiche_x_t[i]=paramIniz_X[i];
ottiche_y_t[i]=paramIniz_X[i];
}
else if (fai_da_te_y)
{
ottiche_x_t[i]=paramIniz_Y[i];
ottiche_y_t[i]=paramIniz_Y[i];
}
else
{
ottiche_x_t[i]=alpha[i];
ottiche_y_t[i]=beta[i];
}
}
aminmax_x_t = assi_ellissi(ottiche_x_t, emittanza);
bminmax_y_t = assi_ellissi(ottiche_y_t, emittanza);
scrividati(0.0,ottiche_x_t,ottiche_y_t,funzioni_ottiche_t);
scrividati_ellissi(0.0,aminmax_x_t,bminmax_y_t,ellissi_t);
if (calcola_ymax_opt_T) massimo_opt(ottiche_x_t,ottiche_y_t,&gnuplot_ymax_opt_T);
#endif
}
}
if(do_transport)
{
fprintf(posizionePart," %+10.5f",0.0);
fprintf(posizionePart," %+10.5f",vett_i[0]);
fprintf(posizionePart," %+10.5f",vett_i[1]);
fprintf(posizionePart," %+10.5f",vett_i[2]);
fprintf(posizionePart," %+10.5f\n",vett_i[3]);
}
#ifdef DEBUG
fprintf(outputDEBUG, "\nFODO:");
scrivimatr2D(F,outputDEBUG);
#endif
/************************************************************************/
//ora primi dell'iterazione mi calcolo le micromappe Li di lunghezza S=L/n
double lunghezzatotale=0.;
for (int i = 0 ;i < contatore;i++)
lunghezzatotale+=lunghezza[i];
#ifdef DEBUG
for (int i=0; i < contatore; i++)
{
fprintf(outputDEBUG,"\n#step in elemento %d = %d",i, dsMap(lunghezza[i],lunghezzatotale,nstep));
}
fprintf(outputDEBUG,"\n");
#endif
double S = 0.;
//Calcolo MICROMAPPE per il Drift
for (int i=0; i < contatore; i++)
{
S=lunghezza[i]/dsMap(lunghezza[i],lunghezzatotale,nstep);
#ifdef DEBUG
if (elemento[i] == "O")
{
O[i]=drift(O[i],S,matrici_iniziali,i);
OI[i]=drift(OI[i],-S,matrici_iniziali,i);
}
else if (elemento[i] == "F")
{
Fx[i]=focusing(Fx[i],f1[i],S,matrici_iniziali,i);
FxI[i]=focusing(FxI[i],f1[i],-S,matrici_iniziali,i);
}
else if (elemento[i] == "D")
{
Dx[i]=defocusing(Dx[i],d1[i],S,matrici_iniziali,i);
DxI[i]=defocusing(DxI[i],d1[i],-S,matrici_iniziali,i);
}
#else
if (elemento[i] == "O")
{
O[i]=drift(O[i],S);
OI[i]=drift(OI[i],-S);
}
else if (elemento[i] == "F")
{
Fx[i]=focusing(Fx[i],f1[i],S);
FxI[i]=focusing(FxI[i],f1[i],-S);
}
else if (elemento[i] == "D")
{
Dx[i]=defocusing(Dx[i],d1[i],S);
DxI[i]=defocusing(DxI[i],d1[i],-S);
}
#endif
}
/***********************************************************************/
double dl=0.;
double lunghezza_accumulata=0.0;
for (int i=0;i<contatore;i++)
{
dl=lunghezza[i]/dsMap(lunghezza[i],lunghezzatotale,nstep);
if (elemento[i]=="O")
{
fprintf(matrici_iniziali,"\n#Drift #%d, dl = %f",i,dl);
fprintf(funzioni_ottiche,"\n#Drift #%d, dl = %f",i,dl);
while(S<=(lunghezza_accumulata+lunghezza[i]))
{
fprintf(matrici_iniziali,"\n\n Num_Step %f", S);
scrivimatr2D(F,matrici_iniziali);
if (do_transport)
{
#ifdef DEBUG
prod(vett_i,O[i],S);
#else
prod(vett_i,O[i]);
#endif
if (calcola_ymax_pos) massimo_pos(vett_i,&gnuplot_ymax_pos);
scrivi_pos_part(posizionePart,vett_i,S);
}
if (do_optics)
{
F=simil(F,OI[i],O[i]);
if (posso_fare_funzioni_ottiche)
{
alpha=optics(F,FOC,&alpha_calcolato_con_successo);
beta=optics(F,DEFOC,&beta_calcolato_con_successo);
aminmax = assi_ellissi(alpha, emittanza);
bminmax = assi_ellissi(beta, emittanza);
confronto(compare_x,aminmax,S,percentuale,confronti,&confronto_pos_x,&conto_per_confronto);
confronto(compare_y,bminmax,S,percentuale,confronti,&confronto_pos_y,&conto_per_confronto);
scrividati(S,alpha,beta,funzioni_ottiche);
scrividati_ellissi(S,aminmax,bminmax,ellissi);
if (calcola_ymax_ell) massimo_opt(aminmax,bminmax,&gnuplot_ymax_ell);
if (calcola_ymax_opt) massimo_opt(alpha,beta,&gnuplot_ymax_opt);
#ifdef TEST_OPTICAL_FUNCTIONS
ottiche_x_t=optics_T(ottiche_x_t,FOC,O[i]);
ottiche_y_t=optics_T(ottiche_y_t,DEFOC,O[i]);
aminmax_x_t = assi_ellissi(ottiche_x_t, emittanza);
bminmax_y_t = assi_ellissi(ottiche_y_t, emittanza);
confronto(paramIniz_X,aminmax_x_t,S,percentuale,confronti_t,&confronto_pos_t_x,&conto_per_confronto_t_x);
confronto(paramIniz_Y,bminmax_y_t,S,percentuale,confronti_t,&confronto_pos_t_y,&conto_per_confronto_t_y);
scrividati(S,ottiche_x_t,ottiche_y_t,funzioni_ottiche_t);
scrividati_ellissi(S,aminmax_x_t,bminmax_y_t,ellissi_t);
if (calcola_ymax_opt_T) massimo_opt(ottiche_x_t,ottiche_y_t,&gnuplot_ymax_opt_T);
#endif
}
}
S+=dl;
}
lunghezza_accumulata+=lunghezza[i];
}
else if (elemento[i]=="F")
{
fprintf(matrici_iniziali,"\n#Foc. #%d, dl = %f",i,dl);
fprintf(funzioni_ottiche,"\n#Foc. #%d, dl = %f",i,dl);
while(S<=(lunghezza_accumulata+lunghezza[i]))
{
fprintf(matrici_iniziali,"\n\n Num_Step %f", S);
scrivimatr2D(F,matrici_iniziali);
if (do_transport)
{
#ifdef DEBUG
prod(vett_i,Fx[i],S);
#else
prod(vett_i,Fx[i]);
#endif
if (calcola_ymax_pos) massimo_pos(vett_i,&gnuplot_ymax_pos);
scrivi_pos_part(posizionePart,vett_i,S);
}
if (do_optics)
{
if (posso_fare_funzioni_ottiche)
{
F=simil(F,FxI[i],Fx[i]);
alpha=optics(F,FOC,&alpha_calcolato_con_successo);
beta=optics(F,DEFOC,&beta_calcolato_con_successo);
aminmax = assi_ellissi(alpha, emittanza);
bminmax = assi_ellissi(beta, emittanza);
confronto(compare_x,aminmax,S,percentuale,confronti,&confronto_pos_x,&conto_per_confronto);
confronto(compare_y,bminmax,S,percentuale,confronti,&confronto_pos_y,&conto_per_confronto);
scrividati(S,alpha,beta,funzioni_ottiche);
scrividati_ellissi(S,aminmax,bminmax,ellissi);
if (calcola_ymax_ell) massimo_opt(aminmax,bminmax,&gnuplot_ymax_ell);
if (calcola_ymax_opt) massimo_opt(alpha,beta,&gnuplot_ymax_opt);
#ifdef TEST_OPTICAL_FUNCTIONS
ottiche_x_t=optics_T(ottiche_x_t,FOC,Fx[i]);
ottiche_y_t=optics_T(ottiche_y_t,DEFOC,Fx[i]);
aminmax_x_t = assi_ellissi(ottiche_x_t, emittanza);
bminmax_y_t = assi_ellissi(ottiche_y_t, emittanza);
confronto(paramIniz_X,aminmax_x_t,S,percentuale,confronti_t,&confronto_pos_t_x,&conto_per_confronto_t_x);
confronto(paramIniz_Y,bminmax_y_t,S,percentuale,confronti_t,&confronto_pos_t_y,&conto_per_confronto_t_y);
scrividati(S,ottiche_x_t,ottiche_y_t,funzioni_ottiche_t);
scrividati_ellissi(S,aminmax_x_t,bminmax_y_t,ellissi_t);
if (calcola_ymax_opt_T) massimo_opt(ottiche_x_t,ottiche_y_t,&gnuplot_ymax_opt_T);
#endif
}
}
S+=dl;
}
lunghezza_accumulata+=lunghezza[i];
}
else if (elemento[i]=="D")
{
fprintf(matrici_iniziali,"\n#Defoc. #%d, dl = %f",i,dl);
fprintf(funzioni_ottiche,"\n#Defoc. #%d, dl = %f",i,dl);
while (S<=(lunghezza_accumulata+lunghezza[i]))
{
fprintf(matrici_iniziali,"\n\n Num_Step %f", S);
scrivimatr2D(F,matrici_iniziali);
if (do_transport)
{
#ifdef DEBUG
prod(vett_i,Dx[i],S);
#else
prod(vett_i,Dx[i]);
#endif
if (calcola_ymax_pos) massimo_pos(vett_i,&gnuplot_ymax_pos);
scrivi_pos_part(posizionePart,vett_i,S);
}
if (do_optics)
{
if (posso_fare_funzioni_ottiche)
{
F=simil(F,DxI[i],Dx[i]);
alpha=optics(F,FOC,&alpha_calcolato_con_successo);
beta=optics(F,DEFOC,&beta_calcolato_con_successo);
aminmax = assi_ellissi(alpha, emittanza);
bminmax = assi_ellissi(beta, emittanza);
confronto(compare_x,aminmax,S,percentuale,confronti,&confronto_pos_x,&conto_per_confronto);
confronto(compare_y,bminmax,S,percentuale,confronti,&confronto_pos_y,&conto_per_confronto);
scrividati(S,alpha,beta,funzioni_ottiche);
scrividati_ellissi(S,aminmax,bminmax,ellissi);
if (calcola_ymax_ell) massimo_opt(aminmax,bminmax,&gnuplot_ymax_ell);
if (calcola_ymax_opt) massimo_opt(alpha,beta,&gnuplot_ymax_opt);
#ifdef TEST_OPTICAL_FUNCTIONS
ottiche_x_t=optics_T(ottiche_x_t,FOC,Dx[i]);
ottiche_y_t=optics_T(ottiche_y_t,DEFOC,Dx[i]);
aminmax_x_t = assi_ellissi(ottiche_x_t, emittanza);
bminmax_y_t = assi_ellissi(ottiche_y_t, emittanza);
confronto(paramIniz_X,aminmax_x_t,S,percentuale,confronti_t,&confronto_pos_t_x,&conto_per_confronto_t_x);
confronto(paramIniz_Y,bminmax_y_t,S,percentuale,confronti_t,&confronto_pos_t_y,&conto_per_confronto_t_y);
scrividati(S,ottiche_x_t,ottiche_y_t,funzioni_ottiche_t);
scrividati_ellissi(S,aminmax_x_t,bminmax_y_t,ellissi_t);
if (calcola_ymax_opt_T) massimo_opt(ottiche_x_t,ottiche_y_t,&gnuplot_ymax_opt_T);
#endif
}
}
S+=dl;
}
lunghezza_accumulata+=lunghezza[i];
}
}
fclose(funzioni_ottiche);
fclose(matrici_iniziali);
fclose(posizionePart);
fclose(ellissi);
fclose(confronti);
parametri.close();
inputdistr.close();
#ifdef TEST_OPTICAL_FUNCTIONS
fclose(funzioni_ottiche_t);
fclose(ellissi_t);
#endif
string *etichette_posizione = new string[8];
string *etichette_ottiche = new string[8];
string *etichette_ellissi = new string[8];
#ifdef TEST_OPTICAL_FUNCTIONS
string *etichette_ottiche_T = new string[8];
string *etichette_ellissi_T = new string[8];
#endif
etichette_posizione[0] = "Posizione_Particelle";
etichette_posizione[1] = "Posizione Particelle";
etichette_posizione[2] = "z (m)";
etichette_posizione[3] = "x/y (m), p_x/p_y";
etichette_posizione[4] = "x";
etichette_posizione[5] = "y";
etichette_posizione[6] = "p_x";
etichette_posizione[7] = "p_y";
etichette_ottiche[0] = "Funzioni_Ottiche";
etichette_ottiche[1] = "Funzioni Ottiche";
etichette_ottiche[2] = "z (m)";
#if defined (CREATE_EPS)
etichette_ottiche[3] = "{/Symbol a}, {/Symbol b}";
etichette_ottiche[4] = "{/Symbol a}_x";
etichette_ottiche[5] = "{/Symbol a}_y";
etichette_ottiche[6] = "{/Symbol b}_x";
etichette_ottiche[7] = "{/Symbol b}_y";
#else
etichette_ottiche[3] = "Alpha, Beta";
etichette_ottiche[4] = "Alpha_x";
etichette_ottiche[5] = "Alpha_y";
etichette_ottiche[6] = "Beta_x";
etichette_ottiche[7] = "Beta_y";
#endif
etichette_ellissi[0] = "Parametri_Ellissi_Funz_Ottiche";
etichette_ellissi[1] = "Parametri Ellissi Funz Ottiche";
etichette_ellissi[2] = "z (m)";
etichette_ellissi[3] = "X , P";
etichette_ellissi[4] = "Xmax";
etichette_ellissi[5] = "Pmax_x";
etichette_ellissi[6] = "Ymax";
etichette_ellissi[7] = "Pmax_y";
#ifdef TEST_OPTICAL_FUNCTIONS
etichette_ottiche_T[0] = "Funzioni_Ottiche_T";
etichette_ottiche_T[1] = "Funzioni ottiche test";
etichette_ottiche_T[2] = "z (m)";
#if defined (CREATE_EPS)
etichette_ottiche_T[3] = "{/Symbol a}, {/Symbol b}";
etichette_ottiche_T[4] = "{/Symbol a}_x";
etichette_ottiche_T[5] = "{/Symbol a}_y";
etichette_ottiche_T[6] = "{/Symbol b}_x";
etichette_ottiche_T[7] = "{/Symbol b}_y";
#else
etichette_ottiche_T[3] = "Alpha, Beta";
etichette_ottiche_T[4] = "Alpha_x";
etichette_ottiche_T[5] = "Alpha_y";
etichette_ottiche_T[6] = "Beta_x";
etichette_ottiche_T[7] = "Beta_y";
#endif
etichette_ellissi_T[0] = "Parametri_Ellissi_Funz_Ottiche_T";
etichette_ellissi_T[1] = "Parametri Ellissi Funz Ottiche_T";
etichette_ellissi_T[2] = "z (m)";
etichette_ellissi_T[3] = "X , P";
etichette_ellissi_T[4] = "Xmax";
etichette_ellissi_T[5] = "Pmax_x";
etichette_ellissi_T[6] = "Ymax";
etichette_ellissi_T[7] = "Pmax_y";
#endif
/***********************************************************/
//cout << "conto_per_confronto= "<<conto_per_confronto;
double *dati_rilevati=new double [conto_per_confronto];
for (int a=0;a<conto_per_confronto;a++)
dati_rilevati[a]=0.;
if (confronto_pos_x||confronto_pos_y)
{
ifstream confro;
confro.open("Math_rilevati.txt");
for (int i=0;i<conto_per_confronto;i++)
{
confro >> dati_rilevati[i];
}
}
