void rungerKuttaMagnetico(float *x, float *y, float *z, float *velI, float *t, int n_points, float energia, float alpha,float gamma) {
int i,j;
float paso;
paso=2*pi*gamma*masa/(50.0*e*b0);
float *velActual;
velActual = crear_matriz(3,1);
velActual[0] = velI[0];
velActual[1] = velI[1];
velActual[2] = velI[2];
for(i=0; i<n_points; i++) {
int k;
k=i+1;
float *posActual;
posActual = crear_matriz(3,1);
posActual[0] = x[i];
posActual[1] = y[i];
posActual[2] = z[i];
float *temp;
temp = pasoRungerKutta4(paso, posActual,velActual,gamma);
x[k] = temp[0];
y[k] = temp[1];
z[k] = temp[2];
for(j=0; j<3; j++) {
velActual[j]=temp[j+3];
}
}
escribirArreglos(t,x,y,z,n_points,energia,alpha);
}
///////////////////////////////MAIN///////////////////////7/////////////77777
int main(int argc, char **argv){
FILE *in;
int filas;
int filas2;
int columnas=3;
int columnas2=3;
char *filename=argv[1];
char *filename2=argv[2];
float *vector_datos;
float *vector_datos2;
float *vector_x;
if(argc!=2){
printf("USAGE: %s\n", USAGE);
exit(1);
}
load_file(filename);
filas=contar_filas(filename,0);
gsl_matrix *transpuesta = gsl_matrix_alloc (columnas, filas);
gsl_matrix *matriz = gsl_matrix_alloc (filas, columnas);
gsl_matrix *multiplicacion = gsl_matrix_alloc (filas, filas);
gsl_matrix *vector = gsl_matrix_alloc (filas, 1);
gsl_matrix *inversa = gsl_matrix_alloc (filas, filas);
gsl_matrix *multiplicacion2 = gsl_matrix_alloc (columnas, 1);
gsl_matrix *multiplicacion3 = gsl_matrix_alloc (columnas, 1);
vector_datos=malloc(2*filas*sizeof(float));
guardar_datos(vector_datos,filename,filas);
crear_matriz(matriz,vector_datos,filas,columnas,0);
crear_matriz(vector,vector_datos,filas,1,1);
transpuesta=transpose(matriz,columnas,filas);
multiplicacion=multiply(transpuesta,matriz,columnas,columnas);
inversa=inverse(multiplicacion,columnas);
multiplicacion2=multiply(transpuesta,vector,columnas,1);
multiplicacion3=multiply(inversa,multiplicacion2,columnas,1);
crearArchivo(multiplicacion3);
}
void dif_divididas(double *m,double *r,int n, double d, double *yint, double *ea)
{
double **fdd,xterm,yint2;
int order,i,j;
fdd=crear_matriz(n,n);
for(i=0;i<n;i++)
{
fdd[i][0]=r[i];
}
for(j=1;j<n;j++)
{
for(i=0;i<n-j;i++)
{
fdd[i][j]=(fdd[i+1][j-1]-fdd[i][j-1])/(m[i+j]-m[i]);
}
}
xterm=1;
yint[0]=fdd[0][0];
for(order=1;order<=n;order++)
{
xterm=xterm*(d-m[order-1]);
yint2=yint[order-1]+(fdd[0][order]*xterm);
ea[order-1]=yint2-yint[order-1];
yint[order]=yint2;
}
}
//Metodo que me da el arreglo de las posiciones iniciales
float *posicionesIniciales() {
float *posiciones;
posiciones = crear_matriz(3,1);
posiciones[0] = 2.0*rT;
posiciones[1] = 0.0;
posiciones[2] = 0.0;
return posiciones;
}
int main(int argc, char **argv){
FILE *in;
int filas;
int filas2;
int columnas2=3;
char *filename2=argv[1];
float *vector_datos;
float *vector_datos2;
float *vector_x;
float norm1=0;
float norm2=0;
float norm3=0;
if(argc!=2){
printf("USAGE: %s\n", USAGE);
exit(1);
}
load_file(filename2);
filas2=contar_filas(filename2,0);
vector_datos2=malloc(3*filas2*sizeof(float));
guardar_datos2(vector_datos2,filename2,filas2);
gsl_matrix *matriz2 = gsl_matrix_alloc (filas2, columnas2);
gsl_matrix *covarianza = gsl_matrix_alloc (columnas2, columnas2);
gsl_vector *eigenvals= gsl_vector_alloc(columnas2);
gsl_matrix *eigenvecs= gsl_matrix_alloc(columnas2, columnas2);
gsl_matrix *transpuesta2 = gsl_matrix_alloc (columnas2, filas2);
crear_matriz(matriz2,vector_datos2,filas2,columnas2,2);
covarianza = cov_calculate2(matriz2);
find_eigens2(covarianza, eigenvals, eigenvecs);
norm1=calcular_norma(eigenvecs,0);
norm2=calcular_norma(eigenvecs,1);
norm3=calcular_norma(eigenvecs,2);
crearArchivo2(eigenvecs,norm1,norm2,norm3);
}
//Devuelve el vector de velocidadesInicialese la velocidad de acuerdo a la energia cinetica entrada por parametro
float *velocidadesIniciales(float energia, float alpha) {
float *velocidades;
float magnitud;
magnitud = magnitudVelocidadInicial(energia);
velocidades = crear_matriz(3,1);
velocidades[0]=0.0;
velocidades[1]=magnitud*sin(alpha);
velocidades[2]=magnitud*cos(alpha);
return velocidades;
}
//Funcion que calcula las aceleraciones del sistema en el tiempo t dadas las posiciones y las velocidades en el mismo tiempo t
//Esta es la funcion que realiza el analisis matricial.
float *calcularAceleraciones(float *pos,float *vel,float gamma) {
float Constante,r,ax,ay,az;
float *acc=crear_matriz(3,1);
r=magnitudVector(pos,3);
Constante=-(b0*rT*rT*rT*e)/(gamma*masa);
ax = Constante*((2.0*pos[2]*pos[2]-pos[0]*pos[0]-pos[1]*pos[1])*vel[1]-(3.0*pos[1]*pos[2])*vel[2])/(pow(r,5));
ay = Constante*((3.0*pos[0]*pos[2])*vel[2]-(2.0*pos[2]*pos[2]-pos[0]*pos[0]-pos[1]*pos[1])*vel[0])/(pow(r,5));
az = Constante*((3.0*pos[1]*pos[2])*vel[0]-(3.0*pos[0]*pos[2])*vel[1])/(pow(r,5));
acc[0]=ax;
acc[1]=ay;
acc[2]=az;
return acc;
}
float *pasoRungerKutta4(float paso,float *posiciones, float *velocidades, float gamma) {
float k1,k2,k3,k4,kF; //Para x
float kv1,kv2,kv3,kv4,kvF; //Para vx
float ka1,ka2,ka3,ka4; //Para ax
float m1,m2,m3,m4,mF; //Para y
float mv1,mv2,mv3,mv4,mvF; //Para vy
float ma1,ma2,ma3,ma4; //Para ay
float n1,n2,n3,n4,nF; //Para z
float nv1,nv2,nv3,nv4,nvF; //Para vz
float na1,na2,na3,na4; //Para az
float *pos2,*pos3,*pos4,*posF;
float *vel2,*vel3,*vel4,*velF;
float *acc1,*acc2,*acc3,*acc4,*retorno;
int i,j;
//Primero - Comienzo Intervalo
k1 = posiciones[0];
m1 = posiciones[1];
n1 = posiciones[2];
kv1 = velocidades[0];
mv1 = velocidades[1];
nv1 = velocidades[2];
acc1 = calcularAceleraciones(posiciones,velocidades,gamma);
ka1 = acc1[0];
ma1 = acc1[1];
na1 = acc1[2];
//Segundo - Mitad Intervalo
k2 = posiciones[0]+paso*0.5*kv1;
m2 = posiciones[1]+paso*0.5*mv1;
n2 = posiciones[2]+paso*0.5*nv1;
kv2 = velocidades[0]+paso*0.5*ka1;
mv2 = velocidades[1]+paso*0.5*ma1;
nv2 = velocidades[2]+paso*0.5*na1;
pos2 = crear_matriz(3,1);
vel2 = crear_matriz(3,1);
pos2[0] = k2;
pos2[1] = m2;
pos2[2] = n2;
vel2[0] = kv2;
vel2[1] = mv2;
vel2[2] = nv2;
acc2 = calcularAceleraciones(pos2,vel2,gamma);
ka2 = acc2[0];
ma2 = acc2[1];
na2 = acc2[2];
//Tercero - Mitad Intervalo
k3 = posiciones[0]+paso*0.5*kv2;
m3 = posiciones[1]+paso*0.5*mv2;
n3 = posiciones[2]+paso*0.5*nv2;
kv3 = velocidades[0]+paso*0.5*ka2;
mv3 = velocidades[1]+paso*0.5*ma2;
nv3 = velocidades[2]+paso*0.5*na2;
pos3 = crear_matriz(3,1);
vel3 = crear_matriz(3,1);
pos3[0] = k3;
pos3[1] = m3;
pos3[2] = n3;
vel3[0] = kv3;
vel3[1] = mv3;
vel3[2] = nv3;
acc3 = calcularAceleraciones(pos3,vel3,gamma);
ka3 = acc3[0];
ma3 = acc3[1];
na3 = acc3[2];
//Cuarto - Final Intervalo
k4 = posiciones[0]+paso*kv3;
m4 = posiciones[1]+paso*mv3;
n4 = posiciones[2]+paso*nv3;
kv4 = velocidades[0]+paso*ka3;
mv4 = velocidades[1]+paso*ma3;
nv4 = velocidades[2]+paso*na3;
pos4 = crear_matriz(3,1);
vel4 = crear_matriz(3,1);
pos4[0] = k4;
pos4[1] = m4;
pos4[2] = n4;
vel4[0] = kv4;
vel4[1] = mv4;
vel4[2] = nv4;
acc4 = calcularAceleraciones(pos4,vel4,gamma);
ka4 = acc4[0];
ma4 = acc4[1];
na4 = acc4[2];
//Final - Promedio
kF = posiciones[0]+paso*(kv1+2.0*kv2+2.0*kv3+kv4)/6.0;
mF = posiciones[1]+paso*(mv1+2.0*mv2+2.0*mv3+nv4)/6.0;
nF = posiciones[2]+paso*(nv1+2.0*nv2+2.0*nv3+mv4)/6.0;
kvF = velocidades[0]+paso*(ka1+2.0*ka2+2.0*ka3+ka4)/6.0;
mvF = velocidades[1]+paso*(ma1+2.0*ma2+2.0*ma3+na4)/6.0;
nvF = velocidades[2]+paso*(na1+2.0*na2+2.0*na3+ma4)/6.0;
posF = crear_matriz(3,1);
velF = crear_matriz(3,1);
posF[0] = kF;
posF[1] = mF;
posF[2] = nF;
velF[0] = kvF;
velF[1] = mvF;
velF[2] = nvF;
retorno = crear_matriz(6,1);
for(i=0; i<3; i++) {
retorno[i] = posF[i];
retorno[i+3] = velF[i];
}
return retorno;
}
