Salve sono uno studente di Fisica e mi sono appena iscritto a questo forum,
colgo l'occasione per rigraziarvi della cortese attenzione.
Ho scritto un algoritmo di calcolo scientifico in c. Non sono molto pratico di programmazione, per cui ho preferito usare una logica top-down. Il massimo della programmazione modulare da me usata, è stata definire qualche funzione che alleggerisse il codice pricipale.
Il codice da me scritto è molto oneroso dal punto di vista della memoria, oltre che del tempo di calcolo. Giusto per far capire di cosa si tratta, ho implementato l'algoritmo Runge-Kutta per un sistema fisico a molti corpi di N (27) particelle, soggette ad un potenziale radiale.
Capita che ad un certo punto del programma (al primo passo dell'algoritmo), un array si annulli senza alcuna apparente spiegazione . Credo che ciò sia dovuto ad un'errata allocazione della memoria. Potete consigliarmi come definire in modo più efficiente le variabili, per piacere?
È consigliabile usare una logica di programmazione orientata agli oggetti ? non sono molto pratico con le struct...
posto la parte di codice in cui definisco le variabili:
#include <stdio.h>
#include <math.h>
#include <stdlib.h>
#include <malloc.h>
#define N 8 //lato del cubo
#define l 0.9 //coefficiente distanza relativa posizioni iniziali
double r0=5.336; //i valori dei parametri si riferscono all'atomo di sodio
double D=-0.06334;
double a=0.58993;
double m=23;
double t=0.001;//unità temporale
double gx[N],gy[N],gz[N];
double acc(double, double, double);//questa funzione calcola l'accelerazione tra due punti
double potenziale(double);//questa funzione calcola il potenziale tra due punti
void sum_acc(double x[] , double y[], double z[],double gx[],double gy[], double gz[]);
//la funzione predendente calcola l'accelerazione gz, gy, gz per tutti i punti.
void main(void)
{
int i=0,j=0,p=0;
double ii,dummy,r,b;
for (i=0;i<N;i++)
{
gx[i]=0;
gy[i]=0;
gz[i]=0;
}
const int M=0.001*pow(t,-1);////////////////////////////////////////////////////////////////////////////////////////////////////
//condizioni iniziali: costruisco il reticolo cubico di lato N
//l'ordine con cui sono costruiti i punti del cubo rispetta l'ordine con cui vengono costruite le matrici in matlab
//in questo modo è possibile utilizzare i dati ottenuti dal programma in c in una matrice matlab per graficarli.
double x[N],y[N],z[N],xp[N],yp[N],zp[N];
double **X,**Y,**Z; //matrici NxM, create per registrare le posizioni degli N atomi in tutti gli M passi
double vx[N],vy[N],vz[N];
double **Vx,**Vy,**Vz;
//allocazione dinamica della memoria
X=(double **)malloc(N * sizeof(double *));
Y=(double **)malloc(N * sizeof(double *));
Z=(double **)malloc(N * sizeof(double *));
Vx=(double **)malloc(N * sizeof(double *));
Vy=(double **)malloc(N * sizeof(double *));
Vz=(double **)malloc(N * sizeof(double *));
for(i=0;i<N;i++)
{
X[i]=(double *)malloc(M * sizeof(double));
Y[i]=(double *)malloc(M * sizeof(double));
Z[i]=(double *)malloc(M * sizeof(double));
Vx[i]=(double *)malloc(M * sizeof(double));
Vy[i]=(double *)malloc(M * sizeof(double));
Vz[i]=(double *)malloc(M * sizeof(double));
}
for(i=0;i<N;i++)
{
ii=i+1;
z[i]=ceil(ii/pow(N,0.666666667));
dummy=ii-(z[i]-1)*pow(N,0.666666667);
x[i]=round(dummy-floor(dummy/pow(N,0.333333333))*pow(N,0.333333333));
b=(int)x[i];
if(b==0)
{
x[i]=pow(N,0.333333333);
y[i]=dummy/pow(N,0.333333333);
}
else
{
y[i]=floor(dummy/pow(N,0.333333333))+1;
}
x[i]=l*r0*x[i];
y[i]=l*r0*y[i];
z[i]=l*r0*z[i];
vx[i]=0;
vy[i]=0;
vz[i]=0;
X[i][0]=x[i];
Y[i][0]=y[i];
Z[i][0]=z[i];
Vx[i][0]=vx[i];
Vy[i][0]=vy[i];
Vz[i][0]=vz[i];
}
//inizializzo l'energia potenziale, cinetica e meccanica
double V[M],Ec[M],E[M],rg[M];
//utilizzo file per registrare dati, necessari alla rappresentazione grafica del risultato
FILE *fileX,*fileY,*fileZ,*fileVx,*fileVy,*fileVz, *fileE,*fileEc,*fileV;
fileX = fopen("RKdatiX.txt","wt");
fileY = fopen("RKdatiY.txt","wt");
fileZ = fopen("RKdatiZ.txt","wt");
fileVx = fopen("RKdatiVx.txt","wt");
fileVy = fopen("RKdatiVy.txt","wt");
fileVz = fopen("RKdatiVz.txt","wt");
fileE = fopen("RKdatiE.txt","wt");
fileEc = fopen("RKdatiEc.txt","wt");
fileV = fopen("RKdatiV.txt","wt");
//algoritmo Runge-kutta
double cx[4][2][N],cy[4][2][N],cz[4][2][N];