Distance3i distance_geom3(
const int3 p, global const int* geometry, global const int3* verts) {
// Distance3i best = { INT_MAX, (int3)(0, 0, 0) };
Distance3i best = { INT_MAX, make_int3(0, 0, 0) };
const int num_tris = geometry[1];
const Triangle* tris = (Triangle*)(geometry+2);
for (int j = 0; j < num_tris; ++j) {
Triangle t = tris[j];
const int3 tri_verts[3] =
{ (verts[t.s[0]]),
(verts[t.s[1]]),
(verts[t.s[2]]) };
int3 set_verts[3];
const int num_unique = find_unique(tri_verts, set_verts);
if (num_unique == 3) {
best = min_pair3i(best, distance_trianglei(p, tri_verts));
} else {
// Degenerate triangle
if (num_unique == 1) {
// Degenerate to a point
int3 closest = tri_verts[0];
float3 closest_d = convert_float3(closest);
float3 p_d = convert_float3(p);
int dist = (int)(fast_length(p_d-closest_d)+0.5f);
best = min_pair3i(best, make_dist3(dist, closest));
} else {
// Degenerate to a line
int3 a = set_verts[0];
int3 b = set_verts[1];
Distance3f dist = distance_line3(convert_float3(p),
convert_float3(a),
convert_float3(b));
Distance3i disti = make_dist3(
// convert_int_rte(dist.d),
// convert_int3_rte(dist.p));
convert_int(dist.d),
convert_int3(dist.p));
best = min_pair3i(best, disti);
}
}
}
return best;
}
void build_from_elems2verts(
Mesh* mesh, CommPtr comm, Int edim, LOs ev2v, Read<GO> vert_globals) {
mesh->set_comm(comm);
mesh->set_parting(OMEGA_H_ELEM_BASED);
mesh->set_dim(edim);
auto nverts = vert_globals.size();
mesh->set_verts(nverts);
mesh->add_tag(
VERT, "global", 1, OMEGA_H_GLOBAL, OMEGA_H_DO_OUTPUT, vert_globals);
if (comm->size() > 1) {
mesh->set_owners(
VERT, owners_from_globals(comm, vert_globals, Read<I32>()));
}
for (Int mdim = 1; mdim < edim; ++mdim) {
auto mv2v = find_unique(ev2v, edim, mdim);
add_ents2verts(mesh, mdim, mv2v, vert_globals);
}
add_ents2verts(mesh, edim, ev2v, vert_globals);
}
void delete_commit(struct model_pak *data)
{
gint flag1=FALSE, flag2=FALSE;
gpointer m;
GSList *list1, *list2;
struct core_pak *core;
struct shel_pak *shell;
struct bond_pak *bond;
g_assert(data != NULL);
/* delete flaged cores in list */
list1 = data->cores;
while (list1)
{
core = list1->data;
list1 = g_slist_next(list1);
if (core->status & DELETED)
{
#if DEBUG_DELETE_COMMIT
printf("Deleting %s core [%p] ...\n", core->label, core);
#endif
flag1 = TRUE;
/* flag assoc. shell */
if (core->shell)
{
shell = core->shell;
shell->status |= DELETED;
}
/* update connectivity */
connect_atom_clear(core, data);
list2 = data->ubonds;
while (list2)
{
bond = list2->data;
list2 = g_slist_next(list2);
if (bond->atom1 == core || bond->atom2 == core)
{
data->ubonds = g_slist_remove(data->ubonds, bond);
g_free(bond);
}
}
/* update selection */
data->selection = g_slist_remove(data->selection, core);
/* delete any labels that reference the deleted core */
list2 = data->measure_list;
while (list2)
{
m = list2->data;
list2 = g_slist_next(list2);
if (measure_has_core(core, m))
measure_free(m, data);
}
/* update main list */
data->cores = g_slist_remove(data->cores, core);
g_free(core);
}
}
/* delete flaged shells in list */
list1 = data->shels;
while (list1)
{
shell = list1->data;
list1 = g_slist_next(list1);
if (shell->status & DELETED)
{
flag2 = TRUE;
/* update main list */
data->shels = g_slist_remove(data->shels, shell);
g_free(shell);
}
}
/* refresh totals */
data->num_atoms = g_slist_length(data->cores);
data->num_shells = g_slist_length(data->shels);
/* refresh spatial partitioning */
/* it's probably best to refresh the partitioning here, rather than */
/* incrementally as it's speedups for large models we're targeting */
zone_init(data);
/* cope with deleted bonds - expensive, so only do if required */
if (flag1)
{
connect_bonds(data);
connect_molecules(data);
}
/* refresh net charge calc */
calc_emp(data);
/* refresh unique atom list */
g_slist_free(data->unique_atom_list);
data->unique_atom_list = find_unique(ELEMENT, data);
/* refresh widgets */
meas_graft_model(data);
gui_refresh(GUI_MODEL_PROPERTIES);
/* reset functions with static pointers to cores */
data->state = 0;
}
inline
void
interp1_helper(const Mat<eT>& X, const Mat<eT>& Y, const Mat<eT>& XI, Mat<eT>& YI, const uword sig, const eT extrap_val)
{
arma_extra_debug_sigprint();
arma_debug_check( ((X.is_vec() == false) || (Y.is_vec() == false) || (XI.is_vec() == false)), "interp1(): currently only vectors are supported" );
arma_debug_check( (X.n_elem != Y.n_elem), "interp1(): X and Y must have the same number of elements" );
arma_debug_check( (X.n_elem < 2), "interp1(): X must have at least two unique elements" );
// sig = 10: nearest neighbour
// sig = 11: nearest neighbour, assume monotonic increase in X and XI
//
// sig = 20: linear
// sig = 21: linear, assume monotonic increase in X and XI
if(sig == 11) { interp1_helper_nearest(X, Y, XI, YI, extrap_val); return; }
if(sig == 21) { interp1_helper_linear (X, Y, XI, YI, extrap_val); return; }
uvec X_indices;
try { X_indices = find_unique(X,false); } catch(...) { }
// NOTE: find_unique(X,false) provides indices of elements sorted in ascending order
// NOTE: find_unique(X,false) will reset X_indices if X has NaN
const uword N_subset = X_indices.n_elem;
arma_debug_check( (N_subset < 2), "interp1(): X must have at least two unique elements" );
Mat<eT> X_sanitised(N_subset,1);
Mat<eT> Y_sanitised(N_subset,1);
eT* X_sanitised_mem = X_sanitised.memptr();
eT* Y_sanitised_mem = Y_sanitised.memptr();
const eT* X_mem = X.memptr();
const eT* Y_mem = Y.memptr();
const uword* X_indices_mem = X_indices.memptr();
for(uword i=0; i<N_subset; ++i)
{
const uword j = X_indices_mem[i];
X_sanitised_mem[i] = X_mem[j];
Y_sanitised_mem[i] = Y_mem[j];
}
Mat<eT> XI_tmp;
uvec XI_indices;
const bool XI_is_sorted = XI.is_sorted();
if(XI_is_sorted == false)
{
XI_indices = sort_index(XI);
const uword N = XI.n_elem;
XI_tmp.copy_size(XI);
const uword* XI_indices_mem = XI_indices.memptr();
const eT* XI_mem = XI.memptr();
eT* XI_tmp_mem = XI_tmp.memptr();
for(uword i=0; i<N; ++i)
{
XI_tmp_mem[i] = XI_mem[ XI_indices_mem[i] ];
}
}
const Mat<eT>& XI_sorted = (XI_is_sorted) ? XI : XI_tmp;
if(sig == 10) { interp1_helper_nearest(X_sanitised, Y_sanitised, XI_sorted, YI, extrap_val); }
else if(sig == 20) { interp1_helper_linear (X_sanitised, Y_sanitised, XI_sorted, YI, extrap_val); }
if( (XI_is_sorted == false) && (YI.n_elem > 0) )
{
Mat<eT> YI_unsorted;
YI_unsorted.copy_size(YI);
const eT* YI_mem = YI.memptr();
eT* YI_unsorted_mem = YI_unsorted.memptr();
const uword N = XI_sorted.n_elem;
const uword* XI_indices_mem = XI_indices.memptr();
for(uword i=0; i<N; ++i)
{
YI_unsorted_mem[ XI_indices_mem[i] ] = YI_mem[i];
}
YI.steal_mem(YI_unsorted);
}
}
void gui_analysis_dialog(void)
{
gpointer dialog;
GtkWidget *window, *combo, *label;
GtkWidget *frame, *main_hbox, *main_vbox, *hbox, *vbox;
GtkWidget *gui_menu_calc, *gui_vbox_rdf;
GSList *list, *item;
GList *match_list=NULL, *calc_list=NULL;
struct model_pak *model;
struct analysis_pak *analysis;
/* checks and setup */
model = sysenv.active_model;
if (!model)
return;
if (!model->animation)
return;
if (analysis_init(model))
return;
analysis = model->analysis;
/* create new dialog */
dialog = dialog_request(MD_ANALYSIS, "MD analysis", NULL, NULL, model);
if (!dialog)
return;
window = dialog_window(dialog);
/* --- main box */
main_hbox = gtk_hbox_new(TRUE, 0);
gtk_box_pack_start(GTK_BOX(GTK_DIALOG(window)->vbox), main_hbox, TRUE, TRUE, 0);
/* --- left pane */
main_vbox = gtk_vbox_new(FALSE, 0);
gtk_box_pack_start(GTK_BOX(main_hbox), main_vbox, TRUE, TRUE, 0);
/* --- analysis dialogs are specific to the active model when initiated */
frame = gtk_frame_new("Model");
gtk_box_pack_start(GTK_BOX(main_vbox), frame, FALSE, FALSE, 0);
gtk_container_set_border_width(GTK_CONTAINER(frame), PANEL_SPACING);
hbox = gtk_hbox_new(TRUE, PANEL_SPACING);
gtk_container_add(GTK_CONTAINER(frame), hbox);
label = gtk_label_new(model->basename);
gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 0);
/* --- calculation menu */
frame = gtk_frame_new("Calculate");
gtk_box_pack_start(GTK_BOX(main_vbox), frame, FALSE, FALSE, 0);
gtk_container_set_border_width(GTK_CONTAINER(frame), PANEL_SPACING);
vbox = gtk_vbox_new(TRUE, PANEL_SPACING);
gtk_container_add(GTK_CONTAINER(frame), vbox);
/* --- menu items */
if (g_file_test(model->gulp.trj_file, G_FILE_TEST_EXISTS))
{
calc_list = g_list_prepend(calc_list, "Potential E");
calc_list = g_list_prepend(calc_list, "Kinetic E");
calc_list = g_list_prepend(calc_list, "Temperature");
calc_list = g_list_prepend(calc_list, "VACF");
}
else
{
calc_list = g_list_prepend(calc_list, "Measurements");
}
calc_list = g_list_prepend(calc_list, "RDF");
calc_list = g_list_prepend(calc_list, "Pair count");
gui_menu_calc = gui_pulldown_new("Perform ", calc_list, FALSE, vbox);
dialog_child_set(dialog, "gui_menu_calc", gui_menu_calc);
/* --- right pane */
gui_vbox_rdf = gtk_vbox_new(FALSE, 0);
dialog_child_set(dialog, "gui_vbox_rdf", gui_vbox_rdf);
gtk_box_pack_start(GTK_BOX(main_hbox), gui_vbox_rdf, TRUE, TRUE, 0);
/* --- interval setup */
frame = gtk_frame_new("Analysis Interval");
gtk_box_pack_start(GTK_BOX(gui_vbox_rdf), frame, FALSE, FALSE, 0);
gtk_container_set_border_width(GTK_CONTAINER(frame), PANEL_SPACING);
vbox = gtk_vbox_new(TRUE, PANEL_SPACING);
gtk_container_add(GTK_CONTAINER(frame), vbox);
/* TODO - some warning about the RDF being valid only for < L/2? */
/* see Allan & Tildesley pg 199 */
gui_direct_spin("Start", &analysis->start, 0.0, 10.0*model->rmax, 0.1, NULL, NULL, vbox);
gui_direct_spin("Stop", &analysis->stop, 0.1, 10.0*model->rmax, 0.1, NULL, NULL, vbox);
gui_direct_spin("Step", &analysis->step, 0.1, model->rmax, 0.1, NULL, NULL, vbox);
/* --- RDF atom setup */
frame = gtk_frame_new("Analysis Atoms");
gtk_box_pack_start(GTK_BOX(gui_vbox_rdf), frame, FALSE, FALSE, 0);
gtk_container_set_border_width(GTK_CONTAINER(frame), PANEL_SPACING);
vbox = gtk_vbox_new(TRUE, PANEL_SPACING);
gtk_container_add(GTK_CONTAINER(frame), vbox);
/* setup unique element label list */
list = find_unique(LABEL, model);
match_list = g_list_append(match_list, "Any");
for (item=list ; item ; item=g_slist_next(item))
{
match_list = g_list_append(match_list, item->data);
}
g_slist_free(list);
/* match 1 */
combo = gtk_combo_new();
gtk_combo_set_popdown_strings(GTK_COMBO(combo), match_list);
gtk_entry_set_editable(GTK_ENTRY(GTK_COMBO(combo)->entry), TRUE);
gtk_box_pack_start(GTK_BOX(vbox), combo, TRUE, TRUE, 0);
g_signal_connect(GTK_OBJECT(GTK_COMBO(combo)->entry), "changed",
GTK_SIGNAL_FUNC(md_atom_changed), (gpointer) &analysis->atom1);
/* match 2 */
combo = gtk_combo_new();
gtk_combo_set_popdown_strings(GTK_COMBO(combo), match_list);
gtk_entry_set_editable(GTK_ENTRY(GTK_COMBO(combo)->entry), TRUE);
gtk_box_pack_start(GTK_BOX(vbox), combo, TRUE, TRUE, 0);
g_signal_connect(GTK_OBJECT(GTK_COMBO(combo)->entry), "changed",
GTK_SIGNAL_FUNC(md_atom_changed), (gpointer) &analysis->atom2);
/* terminating buttons */
gui_stock_button(GTK_STOCK_EXECUTE, exec_analysis_task, dialog,
GTK_DIALOG(window)->action_area);
gui_stock_button(GTK_STOCK_CLOSE, dialog_destroy, dialog,
GTK_DIALOG(window)->action_area);
gtk_widget_show_all(window);
}
