Sans titre

/* 
 *
 * 
 *
 * Auteur : Sébastien Testeau
 * date   : 20 septembre 2006
 *
 */

#include <fstream>
#include <iostream>
#include <sstream>
#include <math.h>
#include <string>
#include <vector>
#include "vecteur.hpp"

using namespace std;


////////////////////////////////////////////////////////////////////////////////////////////////
// Constantes globales

const double GRAVITY = 0.667 * pow(10.00, -10.00); //0.667 * 10^-10
const char delimiteur = ' ';
const char nomFichier[50]  = "vecteurs.txt"; //nom du fichier à lire


////////////////////////////////////////////////////////////////////////////////////////////////
// variables globales
int secondes;
int nbVecteurs;
vecteur vectMobile;
vector<vecteur> vectFixe;


////////////////////////////////////////////////////////////////////////////////////////////////
// fonctions
void lireFichier(const char nomFichier[25], vector<string> &fichier);
void validerFichier(const vector<string> &fichier);
void tokenize(const char &delim, const string &str, vector<string> &tokens);
double toDouble(const string &str);
float toFloat(const string &str);
int toInt(const string &str);
vecteur acceleration_totale(const vecteur &p, const vecteur &pi);


////////////////////////////////////////////////////////////////////////////////////////////////
//Main
void main() {

	vector<string> fichier; // données du fichier	

	//lire le fichier et le valider
	lireFichier(nomFichier, fichier); 
	validerFichier(fichier);

	//fichier correct, on peut commencer les calculs


	vecteur v(0,0,0,0); // v = v + a_t;
	vecteur p = vectMobile;
	//algorithme de simulation gravitationnelle.
	for (int j = 1; j <= secondes; j++) {
		//calculer accélération totale a_t;
		vecteur a_t(0,0,0,0); //at = a_1 + ... + a_n;
		for (int i = 0; i < nbVecteurs; i++) {			
			a_t = a_t + acceleration_totale(p, vectFixe.at(i));
		}
		//calculer le changement de vitesse v = v + a_t;
		v = v + a_t;
		//calculer nouvelle position
		p = p + v;
		//afficher nouvelle position
		cout << "Secondes : " << j << " Position : ";
		cout << p.getX()<< '\t' << p.getY() << '\t' << p.getZ() << endl;
	}
}


////////////////////////////////////////////////////////////////////////////////////////////////
//lireFichier
void lireFichier(const char nomFichier[50], vector<string> &fichier) {

	char str[2000];			// ligne du fichier

	//Lire le fichier et le mettre dans un vector (ligne par ligne)
	fstream file_op(nomFichier,ios::in);
	if (!file_op) 
	{
		cerr << "Erreur : Incapable d'ouvrir " << nomFichier;
		exit(1);   // arret du système
	}
	while(!file_op.eof())     
	{             
		file_op.getline(str,2000);       
		fichier.push_back(str);
	}    
	file_op.close();
}


////////////////////////////////////////////////////////////////////////////////////////////////
//validerFichier
void validerFichier(const vector<string> &fichier) {

	// taille minimal du fichier
	if (fichier.size() < 4) {
		cerr << "Erreur : le fichier ne comporte pas les éléments nécessaire au calcul. \n";
		exit(1);
	}

	//le nombre de vecteurs fixe
	nbVecteurs = toInt(fichier.at(0));
	if (nbVecteurs <= 0) {
		cerr << "Erreur : Nombre de vecteurs fixes est insuffisant. \n"; 
		exit(1);
	} else if (fichier.size() - 3 != nbVecteurs) {
		cerr << "Erreur : Nombre de vecteur fixe est inexacte. \n"; 
		exit(1);
	}

	//le nombre de secondes
	secondes = toInt(fichier.at(1));
	if (secondes <= 0) {
		cerr << "Erreur : Nombre de secondes est insuffisant. \n"; 
		exit(1);
	}

	//décomposer vecteur mobile en tokens
	vector<string> vectorMobile;
	tokenize(delimiteur, fichier.at(2), vectorMobile);

	//créer le vecteur vectMobile
	if (vectorMobile.size() < 4) { 
		cerr << "Erreur : Nombre de d'éléments insuffisant : (x,y,z),masse \n " << vectorMobile.at(2).size(); 
		exit(1); 
	} else {
		vectMobile = vecteur(toFloat(vectorMobile.at(0)),toDouble(vectorMobile.at(1)),
		toFloat(vectorMobile.at(2)),toFloat(vectorMobile.at(3)));	
	}
	
	
	/* décomposer les vecteurs fixe et les ajouter
	 * dans un vector<vecteur> */	
	vector<string> fixeTemp; //
	for (int i = 3; i < (nbVecteurs + 3); i++) {
		//tokenise le str en 4 valeurs
		tokenize(delimiteur, fichier.at(i), fixeTemp);
		if (fixeTemp.size() < 4) { 
			cerr << "Erreur : Nombre de d'éléments insuffisant : (x,y,z),masse (VECTEURS FIXES \n " << fixeTemp.size(); 
			exit(1); 
		} else {
		//créer le vector de vecteurs fixes
			vectFixe.push_back(vecteur(toFloat(fixeTemp.at(0)),toDouble(fixeTemp.at(1)),
										toFloat(fixeTemp.at(2)),toFloat(fixeTemp.at(3))));	
		}
	}
}


////////////////////////////////////////////////////////////////////////////////////////////////
//tokenize
void tokenize(const char &delim, const string &str, vector<string> &tokens) {
	string t;
	istringstream is(str);
	while(getline(is, t, delim)) {
		tokens.push_back(t);		
	}
}


////////////////////////////////////////////////////////////////////////////////////////////////
//toDouble
double toDouble(const string &str) {
	stringstream stream;
	double toDouble;
	stream << str;
	if (!(stream >> toDouble)) {
		cerr << "Erreur : Changement de type invalide (string -> double)  \n";
		exit(1);
	}
	return toDouble;
}

////////////////////////////////////////////////////////////////////////////////////////////////
//toInt
int toInt(const string &str) {
	stringstream stream;
	int toInt;
	stream << str;
	if (!(stream >> toInt)) {
		cerr << "Erreur : Changement de type invalide (string -> int)  \n";
		exit(1);
	}
	return toInt;
}



////////////////////////////////////////////////////////////////////////////////////////////////
//toFloat
float toFloat(const string &str) {
	stringstream stream;
	float toFloat;
	stream << str;
	if (!(stream >> toFloat)) {
		cerr << "Erreur : Changement de type invalide (string -> float)  \n";
		exit(1);
	}
	return toFloat;
}


////////////////////////////////////////////////////////////////////////////////////////////////
//acceleration_totale
vecteur acceleration_totale(const vecteur &p, const vecteur &pi) {
	//(g * m_i) / |d|³
	// ou d = p - p_i; |d|³ = d.size()^3
	// et m_i = masse du vecteur fixe, p = vecteur mobile et p_i = vecteur fixe
	vecteur d = (pi - p);
	cout<< " d :: " << d.getX()<< '\t' << d.getY() << '\t' << d.getZ() << endl;
	double d_normalised = d.getSize();
	return ( ((GRAVITY * pi.getMasse()) / pow(d_normalised, 3)) * d );
}