void attach_view_and_controller(popup_t& control,
const dictionary_t& parameters,
const factory_token_t& token,
adobe::name_t,
adobe::name_t,
adobe::name_t)
{
sheet_t& layout_sheet(token.client_holder_m.layout_sheet_m);
assemblage_t& assemblage(token.client_holder_m.assemblage_m);
if (parameters.count(key_bind) != 0)
{
name_t cell(get_value(parameters, key_bind).cast<name_t>());
attach_view_and_controller_direct(control, parameters, token, cell);
}
if (parameters.count(key_items) &&
get_value(parameters, key_items).type_info() == typeid(name_t))
{
// dynamically bind to the cell instead of getting a static list of popup items
name_t cell(get_value(parameters, key_items).cast<name_t>());
if (layout_sheet.count_interface(cell))
attach_popup_menu_item_set(control, cell, layout_sheet, assemblage, token.client_holder_m);
else
attach_popup_menu_item_set(control, cell, token.sheet_m, assemblage, token.client_holder_m);
}
}
void attach_view_and_controller(listbox_t& control,
const dictionary_t& parameters,
const factory_token_t& token,
adobe::name_t,
adobe::name_t,
adobe::name_t)
{
basic_sheet_t& layout_sheet(token.client_holder_m.layout_sheet_m);
assemblage_t& assemblage(token.client_holder_m.assemblage_m);
if (parameters.count(key_bind) != 0) {
name_t cell(get_value(parameters, key_bind).cast<name_t>());
attach_view_and_controller_direct(control, parameters, token, cell);
}
control.row_factory_m = token.row_factory_m;
if (parameters.count(key_items) &&
get_value(parameters, key_items).type_info() == type_info<name_t>()) {
name_t cell(get_value(parameters, key_items).cast<name_t>());
listbox_t::item_set_view_controller_t& tmp = control.item_set_view_controller_m;
if (layout_sheet.count_interface(cell)) {
attach_view(assemblage, cell, tmp, layout_sheet);
attach_controller_direct(tmp, parameters, token, cell);
} else {
attach_view(assemblage, cell, tmp, token.sheet_m);
attach_controller_direct(tmp, parameters, token, cell);
}
}
{
any_regular_t selection_changed_binding;
name_t cell;
array_t expression;
if (get_value(parameters, static_name_t("bind_selection_changed_signal"), selection_changed_binding))
implementation::cell_and_expression(selection_changed_binding, cell, expression);
control.selection_changed_proc_m =
boost::bind(&handle_selection_changed_signal,
_1,
token.signal_notifier_m,
static_name_t("selection_changed"),
control.signal_id_m,
boost::ref(token.sheet_m),
cell,
expression,
_2);
}
{
any_regular_t dropped_binding;
name_t cell;
array_t expression;
if (get_value(parameters, static_name_t("bind_dropped_signal"), dropped_binding))
implementation::cell_and_expression(dropped_binding, cell, expression);
control.dropped_proc_m =
boost::bind(&handle_row_signal,
_1,
token.signal_notifier_m,
static_name_t("dropped"),
control.signal_id_m,
boost::ref(token.sheet_m),
cell,
expression,
_2);
}
{
any_regular_t drop_acceptable_binding;
name_t cell;
array_t expression;
if (get_value(parameters, static_name_t("bind_drop_acceptable_signal"), drop_acceptable_binding))
implementation::cell_and_expression(drop_acceptable_binding, cell, expression);
control.drop_acceptable_proc_m =
boost::bind(&handle_drop_acceptable_signal,
_1,
token.signal_notifier_m,
static_name_t("drop_acceptable"),
control.signal_id_m,
boost::ref(token.sheet_m),
cell,
expression,
_2,
_3);
}
{
any_regular_t left_clicked_binding;
name_t cell;
array_t expression;
if (get_value(parameters, static_name_t("bind_left_clicked_signal"), left_clicked_binding))
implementation::cell_and_expression(left_clicked_binding, cell, expression);
control.left_clicked_proc_m =
boost::bind(&handle_row_click_signal,
_1,
token.signal_notifier_m,
static_name_t("left_clicked"),
control.signal_id_m,
boost::ref(token.sheet_m),
cell,
expression,
_2,
_3);
}
{
any_regular_t right_clicked_binding;
name_t cell;
array_t expression;
if (get_value(parameters, static_name_t("bind_right_clicked_signal"), right_clicked_binding))
implementation::cell_and_expression(right_clicked_binding, cell, expression);
control.right_clicked_proc_m =
boost::bind(&handle_row_click_signal,
_1,
token.signal_notifier_m,
static_name_t("right_clicked"),
control.signal_id_m,
boost::ref(token.sheet_m),
cell,
expression,
_2,
_3);
}
{
any_regular_t double_clicked_binding;
name_t cell;
array_t expression;
if (get_value(parameters, static_name_t("bind_double_clicked_signal"), double_clicked_binding))
implementation::cell_and_expression(double_clicked_binding, cell, expression);
control.double_clicked_proc_m =
boost::bind(&handle_row_signal,
_1,
token.signal_notifier_m,
static_name_t("double_clicked"),
control.signal_id_m,
boost::ref(token.sheet_m),
cell,
expression,
_2);
}
{
any_regular_t erased_binding;
name_t cell;
array_t expression;
if (get_value(parameters, static_name_t("bind_erased_signal"), erased_binding))
implementation::cell_and_expression(erased_binding, cell, expression);
control.erased_proc_m =
boost::bind(&handle_row_signal,
_1,
token.signal_notifier_m,
static_name_t("erased"),
control.signal_id_m,
boost::ref(token.sheet_m),
cell,
expression,
_2);
}
{
any_regular_t browsed_binding;
name_t cell;
array_t expression;
if (get_value(parameters, static_name_t("bind_browsed_signal"), browsed_binding))
implementation::cell_and_expression(browsed_binding, cell, expression);
control.browsed_proc_m =
boost::bind(&handle_row_signal,
_1,
token.signal_notifier_m,
static_name_t("browsed"),
control.signal_id_m,
boost::ref(token.sheet_m),
cell,
expression,
_2);
}
adobe::attach_view(control.name_m.color_proxy_m, parameters, token, adobe::static_name_t("bind_label_color"));
#define BIND_COLOR(name) \
adobe::attach_view(control.name##_proxy_m, parameters, token, adobe::static_name_t("bind_" #name))
BIND_COLOR(color);
BIND_COLOR(interior_color);
BIND_COLOR(hilite_color);
BIND_COLOR(item_text_color);
#undef BIND_COLOR
}
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;
}
}
