anexar novas variáveis em uma struct

[patbuzzatto]

Boa noite,

eu estou utilizando um integrador de n-corpos todo escrito em C que é o pacote chamado Rebound. 

Para o meu projeto o ideal seria adicionar novas variáveis em uma das estruturas do Rebound. A estrutura que o pacote vem é:

struct reb_particle {
    double x;           ///< x-position of the particle. 
    double y;           ///< y-position of the particle. 
    double z;           ///< z-position of the particle. 
    double vx;          ///< x-velocity of the particle. 
    double vy;          ///< y-velocity of the particle. 
    double vz;          ///< z-velocity of the particle. 
    double ax;          ///< x-acceleration of the particle. 
    double ay;          ///< y-acceleration of the particle. 
    double az;          ///< z-acceleration of the particle. 
    double m;           ///< Mass of the particle. 
    double r;           ///< Radius of the particle. 
    double lastcollision;       ///< Last time the particle had a physical collision.
    struct reb_treecell* c;     ///< Pointer to the cell the particle is currently in.
    uint32_t hash;      ///< hash to identify particle.
    void* ap;           ///< Functionality for externally adding additional properties to particles.
    struct reb_simulation* sim; ///< Pointer to the parent simulation.
};

Eu gostaria de adicionar, dado a seguir, as variáveis externamente, sem alterar o código fonte do pacote. 

double J2;		//coeficiente J2 de achatamento planetário
double J4;		//coeficiente J4 de achatamento planetário
double beta; 	//relação adimensional da força gravitacional e de radiação solar 

Eu realmente não sei qual seria a maneira ideal de fazer isso, eu sei que ele tem isso:

void* ap;           ///< Functionality for externally adding additional properties to particles.

Mas eu nunca trabalhei com algo do gênero e nem sei se realmente serve para o que eu estou querendo.

Não sei se consegui explicar direito o que eu preciso, só tentei ser o mais direta possível, mas se alguém puder dar alguma luz, ficarei muito grata.

 

Editado Dezembro 28, 2016 por patbuzzatto

[vangodp]

void* é um ponteiro genérico o que quer dizer que praticamente pode apontar a qualquer tipo de dado.
Coisa que você poderia fazer é:

#include<stdio.h>
#include <stdlib.h>

// eliminei todos os dados que não serão uteis para o exemplo
struct reb_particle {
    void* ap; //ponteiro generico, aponta a qualquer tipo de dado, incluindo outras struturas

};

//Dados que serão apontados por ap
typedef struct Dados{	
    double beta; 	
}Dados;

int main(){
    struct reb_particle obj; // 1º criamos um objeto normal da estrutura, vamos a chamar obj
    
    Dados *dados = ( Dados* ) malloc ( sizeof( Dados ) ); // Criamos dinamicamente os dados que expandirão a estrutura reb_particle
    
    obj.ap = (void*)dados; // Fazemos que o ponteiro generico ap aponte aos dados que queremos adicionar a reb_particle
    
    ((Dados *)obj.ap)->beta = 3.14; // Agora para entender essa linha leia abaixo:
    
    //1º Como ap é um ponteiro a void, cada vez que vamos usar precisamos fazer o cast ao tipo de dados que ap aponta:
    //  (Dados *)obj.ap
    //2º Alem disso devemos resaltar a prioridade do cast antes de acessar a qualquer membro de "Dados"
    //  ((Dados *)obj.ap)  
    //3º Agora sim podemos acessar aos membros. Isso sim... lembrando que ap aponta a uma estrutura que foi criada dinamicamente, então devemos usar ->
    //  ((Dados *)obj.ap)->beta
    
    // Com isso podemos alterar os membros de dados apontados por ap tal como: 
    ((Dados *)obj.ap)->beta = 10.90;
    
    // Imprimir 
    printf("%lf", ((Dados *)obj.ap)->beta);

    
    
    
    return 0;
}

De uma boa repassada e se não entender pergunte.


 

[patbuzzatto]

Oie, acho que entendi. Fiz um teste básico e deu certo, então tentei implementar no meu programa da seguinte maneira:

 

typedef struct Dados{	
    double beta; 	
}Forcas_inf;

int main(int argc, char* argv[]){
...
Forcas_inf *dados = ( Forcas_inf* ) malloc ( sizeof( Forcas_inf ) ); // Criamos dinamicamente os dados que expandirão a estrutura reb_particle    

	int pi = 0;
	while(r->N<2){
		struct reb_particle p = {0}; 
		p.hash = pi;
		
		double ratio = 1;				//[micrometro]
		double densityP = 1;				//[g.cm^-3]
		betaparticles = 0.6/(ratio * densityP);
		
		p.ap = (void*)dados; // Fazemos que o ponteiro generico ap aponte aos dados que queremos adicionar a reb_particle
		((Forcas_inf *)p.ap)->beta = betaparticles; // Agora para entender essa linha leia abaixo:
		printf("\n\n%lf\n\n", ((Forcas_inf *)p.ap)->beta);

		double a = 97700e3;				// pico do anel mu
		double e = 0;//0.01;					//excentricidade 
		double inc = 0;					//inclinação da particula no plano
		double Omega = 0;				//Longitude do nó ascendente
		double omega = 0;				//pericentro
		//double f =  reb_random_uniform(0,2.*M_PI);	//verdadeira anomalia
		double f =  0;					//verdadeira anomalia
		double m = 0;					//massa 

		//Retorna uma estrutura da partícula com os parâmetros orbitais
		p = reb_tools_orbit_to_particle(r->G,planet,m,a,e,inc,Omega,omega,f);
		p.r = ratio*1e-6;
		reb_add(r, p); 
		pi++;
	}
	
	for (int i=1;i<r->N;i++){
        struct reb_particle p = r->particles[i];
        printf("\n\n%lf\n\n", ((Forcas_inf *)p.ap)->beta);
    }
      
 ...
 }

 

É ai que ocorre o problema, aquele printf dentro do while funciona, agora o fora que esta dentro do for esta dando erro:

/opt/torque/mom_priv/jobs/175884.saturn.cluster.loc.SC: line 7: 13004 Segmentation fault      (core dumped) nice -n 19 ./rebound
 

Já garanti no for que nenhuma partícula que não tenha o beta esteja sendo utilizada ali.

[patbuzzatto]

Já descobri o erro, eu precisava adicionar o dados a outra estrutura de partículas.

	for (int i=1;i<r->N;i++){
		struct reb_particle p = r->particles[i];
		p.ap = (void*)dados;       
        printf("\n\n%lf\n\n", ((Forcas_inf *)p.ap)->beta);
    }

Existe uma maneira te adicionar a estrutura de uma maneira geral? Sem precisar adicionar a cada vez que criar um objeto?

[vangodp]

Na verdade eu nem sei o que é o que faz seu programa. Vejo como umas "tropecentas" variáveis por todas as partes mas não sei qual o objetivo do seu programa. Talvez se vc descrever um pouco o que anda buscando lhe serei de maior ajuda.