void apprentissageAleatoire(fonction& g, bool first_pass, bool record){
BaseEtats baseEtats;
Thetas thetarandom;
Thetas dtheta;
Thetas dthetamin;
Rayon rmin;
Rayon r;
std::list<gaml::libsvm::Predictor<Entree,double>> predictors;
std::array<std::string,4> filenames = {{std::string("theta1.pred"),"theta2.pred","theta3.pred","theta4.pred"}};
for (int j=0;j< NB_TESTS_PAR_PHASE;j++){
std::cout<<"Nouvelle boucle mise a jour de f"<<std::endl;
std::cout<<"____________________"<< std::endl;
std::cout<<"Nouvel essai random n°"<<j<<std::endl;
r = {0,0,0};
while(r[0] == 0 && r[1] == 0 && r[2] == 0){
thetarandom = creationThetaRandom();
moveArm(thetarandom);
r = vecteur_kinnect_objet();
}
if(first_pass){
dtheta = {.0,.0,.0,.0};
}else{
auto res = g({r[0],r[1],r[2],thetarandom[0],thetarandom[1],thetarandom[2],thetarandom[3]});
dtheta = {
res.theta1,
res.theta2,
res.theta3,
res.theta4
};
}
moveArm(thetarandom+dtheta);
rmin = vecteur_kinnect_objet();
std::cout<<"Thetas :"<<thetarandom<<" | Rayon :"<<r<< " | Distance :"<<norme(r)<<" | dthetas :"<<dtheta<<std::endl;
dthetamin = oscillations(r,thetarandom,rmin,dtheta);
Etat etat (r,thetarandom,dthetamin);
baseEtats.push_back(etat);
std::cout<<"Amelioration dthetas : "<<dthetamin<<std::endl;
}
std::cout<<"mise a jour de f"<<std::endl;
g = calcul_f(baseEtats,record);
}
Probleme::Probleme(Maillage monMaillage, int rang)
{
Set_maillage(&monMaillage);
uexa = new VectorXd;
uexa->resize(maillage->Get_n_nodes(),1);
g = new VectorXd;
g->resize(maillage->Get_n_nodes(),1);
u = new VectorXd;
u->resize(maillage->Get_n_nodes(),1);
felim = new VectorXd(maillage->Get_n_nodes());
for (int i=0;i<maillage->Get_n_nodes();i++)
{
double x=maillage->Get_nodes_coords()[3*i+0];
double y=maillage->Get_nodes_coords()[3*i+1];
double addedCoeff = calcul_f(x,y);
felim->coeffRef(i,0)=addedCoeff;
}
p_K = new Eigen::SparseMatrix<double> (maillage->Get_n_nodes(),maillage->Get_n_nodes());
p_M = new Eigen::SparseMatrix<double> (maillage->Get_n_nodes(),maillage->Get_n_nodes());
diag = new Eigen::SparseMatrix<double> (maillage->Get_n_nodes(),maillage->Get_n_nodes());
partition_noeud = new int[maillage->Get_n_nodes()];
for (int i=0;i<maillage->Get_n_nodes();i++)
{
partition_noeud[i]=-1;
}
for (int i = 0; i < maillage->Get_nb_partitions(); i++)
{
voisins_interface.push_back(vector<int>());
}
for (int i = 0; i < maillage->Get_nb_partitions(); i++)
{
voisins_partition.push_back(vector<int>());
}
for (int ind_triangle=0;ind_triangle<maillage->Get_n_triangles();ind_triangle++)
{
int ind_pt1=(maillage->Get_triangles_sommets())[3*ind_triangle]-1;
int ind_pt2=maillage->Get_triangles_sommets()[3*ind_triangle+1]-1;
int ind_pt3=maillage->Get_triangles_sommets()[3*ind_triangle+2]-1;
int numero_partition_triangle=maillage->Get_partition_ref()[maillage->Get_n_elems()-maillage->Get_n_triangles()+ind_triangle];
/* Un noeud à l'interface est reconnu par son appartenance à deux partitions distinctes. */
if (partition_noeud[ind_pt1]==-1)
{
partition_noeud[ind_pt1]=numero_partition_triangle;
}
else if(partition_noeud[ind_pt1]==numero_partition_triangle)
{
}
else
{
partition_noeud[ind_pt1]=0;
}
if (partition_noeud[ind_pt2]==-1)
{
partition_noeud[ind_pt2]=numero_partition_triangle;
}
else if(partition_noeud[ind_pt2]==numero_partition_triangle)
{
}
else
{
partition_noeud[ind_pt2]=0;
}
if (partition_noeud[ind_pt3]==-1)
{
partition_noeud[ind_pt3]=numero_partition_triangle;
}
else if(partition_noeud[ind_pt3]==numero_partition_triangle)
{
}
else
{
partition_noeud[ind_pt3]=0;
}
}
/* On sait maintenant quel noeud appartient à quel triangle. En parcourant à nouveau les triangles,
* en s'arretant sur ceux qui sont au contact de l'interface sans y etre totalement inclus, on peut
* donc déterminer les vecteurs voisins_interface et voisins_partition
*/
for (int ind_triangle=0;ind_triangle<maillage->Get_n_triangles();ind_triangle++)
{
int ind_pt1=maillage->Get_triangles_sommets()[3*ind_triangle]-1;
int ind_pt2=maillage->Get_triangles_sommets()[3*ind_triangle+1]-1;
int ind_pt3=maillage->Get_triangles_sommets()[3*ind_triangle+2]-1;
int numero_partition_triangle=maillage->Get_partition_ref()[maillage->Get_n_elems()-maillage->Get_n_triangles()+ind_triangle];
if ((partition_noeud[ind_pt1]==0 || partition_noeud[ind_pt2]==0 || partition_noeud[ind_pt3]==0) &&
(!(partition_noeud[ind_pt1]==0 && partition_noeud[ind_pt2]==0 && partition_noeud[ind_pt3]==0)))
{
if (partition_noeud[ind_pt2]!=0)
{
/* Si le noeud n'est pas sur l'interface, il en est voisin */
voisins_interface[partition_noeud[ind_pt2]-1].push_back(ind_pt2+1);
}
else
{
/* Si le noeud est sur l'interface, il est voisin de la partition du triangle auquel il appartient */
voisins_partition[numero_partition_triangle-1].push_back(ind_pt2+1);
}
if (partition_noeud[ind_pt3]!=0)
{
voisins_interface[partition_noeud[ind_pt3]-1].push_back(ind_pt3+1);
}
else
{
voisins_partition[numero_partition_triangle-1].push_back(ind_pt3+1);
}
if (partition_noeud[ind_pt1]!=0)
{
voisins_interface[partition_noeud[ind_pt1]-1].push_back(ind_pt1+1);
}
else
{
voisins_partition[numero_partition_triangle-1].push_back(ind_pt1+1);
}
}
else
{
}
}
/* On trie chaque liste de noeuds des vecteurs voisins_partition et voisins_interface par ordre
* croissant afin de pouvoir les utiliser dans les communications
* */
vector<vector<int> >::iterator vect_it;
for (vect_it=voisins_partition.begin();vect_it!=voisins_partition.end();vect_it++)
{
std::sort((*vect_it).begin(),(*vect_it).end());
vector<int>::iterator it;
it = std::unique((*vect_it).begin(),(*vect_it).end());
(*vect_it).resize(std::distance((*vect_it).begin(),it));
}
for (vect_it=voisins_interface.begin();vect_it!=voisins_interface.end();vect_it++)
{
std::sort((*vect_it).begin(),(*vect_it).end());
vector<int>::iterator it;
it = std::unique((*vect_it).begin(),(*vect_it).end());
(*vect_it).resize(std::distance((*vect_it).begin(),it));
}
/* Calcul de la solution exacte */
for(int ind_node=0;ind_node<maillage->Get_n_nodes();ind_node++)
{
uexa->coeffRef(ind_node,0)=calcul_uexa(maillage->Get_nodes_coords()[3*ind_node],maillage->Get_nodes_coords()[3*ind_node+1]);
}
/* Initialisation des conditions au bord, dans un premier temps a une constante*/
for(int ind_node=0;ind_node<maillage->Get_n_nodes();ind_node++)
{
if (maillage->Get_nodes_ref()[ind_node]!=0)
{
double x=maillage->Get_nodes_coords()[3*ind_node+0];
double y=maillage->Get_nodes_coords()[3*ind_node+1];
double addedCoeff = calcul_g(x,y);
g->coeffRef(ind_node,0)=addedCoeff;
}
}
for(int ind_node=0;ind_node<maillage->Get_n_nodes();ind_node++)
{
u->coeffRef(ind_node,0)=1;
}
/* Assemblage de la matrice de rigidité par parcours de tous les triangles */
assemblage(rang);
/* Calcul du second membre avant pseudo élimination par l'intermédiaire de la matrice de masse */
*felim = (*p_M)*(*felim);
/* Second membre prenant en compte les conditions aux bords */
*felim=*felim-(*p_K) * (*g);
/* Mise en oeuvre de la pseudo elimination */
for(int i=0;i<maillage->Get_n_nodes();i++)
{
if (maillage->Get_nodes_ref()[i]==1)
{
double nouvCoeff = p_K->coeffRef(i,i)*g->coeffRef(i,0);
felim->coeffRef(i,0)=nouvCoeff;
for(int j=0;j<maillage->Get_n_nodes();j++)
{
if (j!=i)
{
p_K->coeffRef(i,j)=0;
p_K->coeffRef(j,i)=0;
}
}
}
}
/* On sotcke la diagonale de la matrice de rigidité pour les itérations */
for (int i=0;i<maillage->Get_n_nodes();i++)
{
diag->coeffRef(i,i)=p_K->coeffRef(i,i);
}
/* On retire cette diagonale de la matrice de rigidité car le produit matriciel au cours
* des itérations ne les fait pas intervenir ; une boucle pourrait etre évitée en utilisant
* les fonctions diagonal de eigen mais la version installee empeche d'ajouter des matrices creuses
* et des matrices denses
* */
for (int i=0;i<maillage->Get_n_nodes();i++)
{
p_K->coeffRef(i,i)=0;
}
}
