From 4c4ebb87ead363d6d6e11a8b95b07a0f93af5c88 Mon Sep 17 00:00:00 2001 From: pants Date: Tue, 6 Sep 2016 15:05:27 -0400 Subject: finished implementing embedded systems, refactored a bunch --- src/bin_values.c | 4 +- src/break_data.c | 8 +- src/break_edge.c | 34 ++++---- src/compare_voronoi_fracture.c | 34 ++++---- src/corr_test.c | 8 +- src/correlations.c | 34 ++++---- src/course_grain_square.c | 28 +++--- src/coursegrain.c | 8 +- src/cracked_voronoi_fracture.c | 163 +++++++++++++++++++++++++--------- src/cracking_ini.c | 22 ++--- src/current_scaling.c | 48 +++++------ src/fracture.c | 46 +++++----- src/fracture.h | 102 +++++++++++----------- src/fracture_network.c | 16 ++-- src/free_network.c | 18 ++-- src/gen_laplacian.c | 48 +++++------ src/get_conductivity.c | 16 ++-- src/get_current.c | 26 +++--- src/get_dual_clusters.c | 8 +- src/homo_square_fracture.c | 50 +++++------ src/homo_voronoi_fracture.c | 42 ++++----- src/ini_network.c | 192 ++++++++++++++++++++--------------------- src/instance.c | 42 ++++----- src/update_boundary.c | 6 +- src/voronoi_bound_ini.c | 2 +- 25 files changed, 541 insertions(+), 464 deletions(-) (limited to 'src') diff --git a/src/bin_values.c b/src/bin_values.c index 2cb9cf6..8cde548 100644 --- a/src/bin_values.c +++ b/src/bin_values.c @@ -1,10 +1,10 @@ #include "fracture.h" -double *bin_values(fnet *network, unsigned int width, double *values) { +double *bin_values(graph_t *network, unsigned int width, double *values) { double *binned = calloc(pow(width, 2), sizeof(double)); unsigned int *num_binned = calloc(pow(width, 2), sizeof(unsigned int)); - for (unsigned int i = 0; i < network->num_edges; i++) { + for (unsigned int i = 0; i < network->ne; i++) { if (values[i] != 0) { unsigned int x = ((int)(network->edge_coords[2 * i] * width)) % width; unsigned int y = ((int)(network->edge_coords[2 * i + 1] * width)) % width; diff --git a/src/break_data.c b/src/break_data.c index 0ce6730..5c922f3 100644 --- a/src/break_data.c +++ b/src/break_data.c @@ -1,8 +1,8 @@ #include "fracture.h" -break_data *alloc_break_data(unsigned int num_edges) { - break_data *data = malloc(1 * sizeof(break_data)); assert(data != NULL); +data_t *alloc_break_data(unsigned int num_edges) { + data_t *data = malloc(1 * sizeof(data_t)); assert(data != NULL); data->num_broken = 0; @@ -18,14 +18,14 @@ break_data *alloc_break_data(unsigned int num_edges) { return data; } -void free_break_data(break_data *data) { +void free_break_data(data_t *data) { free(data->break_list); free(data->extern_field); free(data->conductivity); free(data); } -void update_break_data(break_data *data, unsigned int last_broke, double strength, double conductivity) { +void update_break_data(data_t *data, unsigned int last_broke, double strength, double conductivity) { data->break_list[data->num_broken] = last_broke; data->extern_field[data->num_broken] = strength; data->conductivity[data->num_broken] = conductivity; diff --git a/src/break_edge.c b/src/break_edge.c index 72ccf3e..7b94160 100644 --- a/src/break_edge.c +++ b/src/break_edge.c @@ -1,18 +1,18 @@ #include "fracture.h" -bool break_edge(finst *instance, unsigned int edge, cholmod_common *c) { +bool break_edge(net_t *instance, unsigned int edge, cholmod_common *c) { instance->fuses[edge] = true; instance->num_remaining_edges--; - unsigned int v1 = instance->network->edges_to_verts_break[2 * edge]; - unsigned int v2 = instance->network->edges_to_verts_break[2 * edge + 1]; + unsigned int v1 = instance->graph->ev_break[2 * edge]; + unsigned int v2 = instance->graph->ev_break[2 * edge + 1]; if (instance->factor != NULL) update_factor(instance->factor, v1, v2, c); - if (instance->network->boundary != TORUS_BOUND) { - unsigned int w1 = instance->network->edges_to_verts[2 * edge]; - unsigned int w2 = instance->network->edges_to_verts[2 * edge + 1]; + if (instance->graph->boundary != TORUS_BOUND) { + unsigned int w1 = instance->graph->ev[2 * edge]; + unsigned int w2 = instance->graph->ev[2 * edge + 1]; unsigned int tw1 = w1 > w2 ? w1 : w2; unsigned int tw2 = w1 > w2 ? w2 : w1; @@ -37,13 +37,13 @@ bool break_edge(finst *instance, unsigned int edge, cholmod_common *c) { (int)tw2, 0); } - if (instance->network->boundary == TORUS_BOUND) { - unsigned int dw1 = instance->network->dual_edges_to_verts[2 * edge]; - unsigned int dw2 = instance->network->dual_edges_to_verts[2 * edge + 1]; + if (instance->graph->boundary == TORUS_BOUND) { + unsigned int dw1 = instance->graph->dev[2 * edge]; + unsigned int dw2 = instance->graph->dev[2 * edge + 1]; if (instance->dual_marks[dw1] == instance->dual_marks[dw2]) { - int **cycles = (int **)malloc(2*instance->network->num_edges * sizeof(int *)); - unsigned int num_cycles = find_cycles(instance->network->num_edges, instance->fuses, instance->network->dual_edges_to_verts, instance->network->dual_verts_to_edges_ind, instance->network->dual_verts_to_edges, cycles); + int **cycles = (int **)malloc(2*instance->graph->ne * sizeof(int *)); + unsigned int num_cycles = find_cycles(instance->graph->ne, instance->fuses, instance->graph->dev, instance->graph->dvei, instance->graph->dve, cycles); for (unsigned int i = 0; i < num_cycles; i++) { int x_num_crossings = 0; @@ -54,12 +54,12 @@ bool break_edge(finst *instance, unsigned int edge, cholmod_common *c) { j++; unsigned int v1, v2; double v1x, v1y, v2x, v2y; - v1 = instance->network->dual_edges_to_verts[2 * ee + !side]; - v2 = instance->network->dual_edges_to_verts[2 * ee + side]; - v1x = instance->network->dual_vert_coords[2 * v1]; - v1y = instance->network->dual_vert_coords[2 * v1 + 1]; - v2x = instance->network->dual_vert_coords[2 * v2]; - v2y = instance->network->dual_vert_coords[2 * v2 + 1]; + v1 = instance->graph->dev[2 * ee + !side]; + v2 = instance->graph->dev[2 * ee + side]; + v1x = instance->graph->dual_vert_coords[2 * v1]; + v1y = instance->graph->dual_vert_coords[2 * v1 + 1]; + v2x = instance->graph->dual_vert_coords[2 * v2]; + v2y = instance->graph->dual_vert_coords[2 * v2 + 1]; double dx = v1x - v2x; double dy = v1y - v2y; if (((v1x > 0.5 && v2x < 0.5) || (v1x < 0.5 && v2x > 0.5)) && fabs(dx) < 0.5) { diff --git a/src/compare_voronoi_fracture.c b/src/compare_voronoi_fracture.c index bdb9423..2edcae2 100644 --- a/src/compare_voronoi_fracture.c +++ b/src/compare_voronoi_fracture.c @@ -66,14 +66,14 @@ int main(int argc, char *argv[]) { (&c)->supernodal = CHOLMOD_SIMPLICIAL; - fnet *network = ini_voronoi_network(L, false, boundary, genfunc_hyperuniform, &c); - finst *perm_voltage_instance = create_instance(network, inf, true, true, &c); - finst *perm_current_instance = create_instance(network, inf, false, true, &c); - double *fuse_thres = gen_fuse_thres(network->num_edges, network->edge_coords, beta, beta_scaling_flat); - finst *voltage_instance = copy_instance(perm_voltage_instance, &c); - finst *current_instance = copy_instance(perm_current_instance, &c); - break_data *breaking_data_voltage = fracture_network(voltage_instance, fuse_thres, &c, cutoff); - break_data *breaking_data_current = fracture_network(current_instance, fuse_thres, &c, cutoff); + graph_t *network = ini_voronoi_network(L, false, boundary, genfunc_hyperuniform, &c); + net_t *perm_voltage_instance = create_instance(network, inf, true, true, &c); + net_t *perm_current_instance = create_instance(network, inf, false, true, &c); + double *fuse_thres = gen_fuse_thres(network->ne, network->edge_coords, beta, beta_scaling_flat); + net_t *voltage_instance = copy_instance(perm_voltage_instance, &c); + net_t *current_instance = copy_instance(perm_current_instance, &c); + data_t *breaking_data_voltage = fracture_network(voltage_instance, fuse_thres, &c, cutoff); + data_t *breaking_data_current = fracture_network(current_instance, fuse_thres, &c, cutoff); free_instance(voltage_instance, &c); free_instance(current_instance, &c); free_instance(perm_voltage_instance, &c); @@ -81,27 +81,27 @@ int main(int argc, char *argv[]) { free(fuse_thres); FILE *net_out = fopen("network.txt", "w"); - for (unsigned int j = 0; j < network->num_verts; j++) { + for (unsigned int j = 0; j < network->nv; j++) { fprintf(net_out, "%f %f ", network->vert_coords[2 * j], network->vert_coords[2 * j + 1]); } fprintf(net_out, "\n"); - for (unsigned int j = 0; j < network->num_edges; j++) { - fprintf(net_out, "%u %u ", network->edges_to_verts[2 * j], - network->edges_to_verts[2 * j + 1]); + for (unsigned int j = 0; j < network->ne; j++) { + fprintf(net_out, "%u %u ", network->ev[2 * j], + network->ev[2 * j + 1]); } fprintf(net_out, "\n"); - for (unsigned int j = 0; j < network->num_dual_verts; j++) { + for (unsigned int j = 0; j < network->dnv; j++) { fprintf(net_out, "%f %f ", network->dual_vert_coords[2 * j], network->dual_vert_coords[2 * j + 1]); } fprintf(net_out, "\n"); - for (unsigned int j = 0; j < network->num_edges; j++) { - fprintf(net_out, "%u %u ", network->dual_edges_to_verts[2 * j], - network->dual_edges_to_verts[2 * j + 1]); + for (unsigned int j = 0; j < network->ne; j++) { + fprintf(net_out, "%u %u ", network->dev[2 * j], + network->dev[2 * j + 1]); } - free_fnet(network, &c); + free_net(network, &c); for (unsigned int j = 0; j < breaking_data_voltage->num_broken; j++) { fprintf(break_out, "%u %g %g ", breaking_data_voltage->break_list[j], diff --git a/src/corr_test.c b/src/corr_test.c index 2c93b8e..e0de2d8 100644 --- a/src/corr_test.c +++ b/src/corr_test.c @@ -8,9 +8,9 @@ int main() { unsigned int width = 64; unsigned int n = pow(width / 2 + 1, 2) + pow((width + 1) / 2, 2); - fnet *network = ini_square_network(width, true, false, &c); - finst *instance = create_instance(network, 1e-14, true, true, &c); - double *fuse_thres = gen_fuse_thres(network->num_edges, network->edge_coords, + graph_t *network = ini_square_network(width, true, false, &c); + net_t *instance = create_instance(network, 1e-14, true, true, &c); + double *fuse_thres = gen_fuse_thres(network->ne, network->edge_coords, 0.001, beta_scaling_flat); fracture_network(instance, fuse_thres, &c, 1e-10); @@ -22,7 +22,7 @@ int main() { printf("\n"); free_instance(instance, &c); - free_fnet(network, &c); + free_net(network, &c); CHOL_F(finish)(&c); diff --git a/src/correlations.c b/src/correlations.c index bd05daf..4fc44ac 100644 --- a/src/correlations.c +++ b/src/correlations.c @@ -197,11 +197,11 @@ void fib_decreasekey(fibh *heap, unsigned int value, } } -unsigned int *dijkstra(fnet *network, unsigned int source) { - unsigned int nv = network->num_dual_verts; - unsigned int *vei = network->dual_verts_to_edges_ind; - unsigned int *ve = network->dual_verts_to_edges; - unsigned int *ev = network->dual_edges_to_verts; +unsigned int *dijkstra(graph_t *network, unsigned int source) { + unsigned int nv = network->dnv; + unsigned int *vei = network->dvei; + unsigned int *ve = network->dve; + unsigned int *ev = network->dev; unsigned int *dist = (unsigned int *)calloc(nv, sizeof(unsigned int)); fibh *Q = (fibh *)calloc(1, sizeof(fibh)); @@ -236,8 +236,8 @@ unsigned int *dijkstra(fnet *network, unsigned int source) { return dist; } -unsigned int **get_dists(fnet *network) { - unsigned int nv = network->num_dual_verts; +unsigned int **get_dists(graph_t *network) { + unsigned int nv = network->dnv; unsigned int **dists = (unsigned int **)malloc(nv * sizeof(unsigned int *)); #pragma omp parallel for @@ -248,13 +248,13 @@ unsigned int **get_dists(fnet *network) { return dists; } -double *get_corr(finst *instance, unsigned int **dists, cholmod_common *c) { - unsigned int nv = instance->network->num_dual_verts; - unsigned int ne = instance->network->num_edges; - unsigned int *ev = instance->network->dual_edges_to_verts; +double *get_corr(net_t *instance, unsigned int **dists, cholmod_common *c) { + unsigned int nv = instance->graph->dnv; + unsigned int ne = instance->graph->ne; + unsigned int *ev = instance->graph->dev; bool nulldists = false; if (dists == NULL) { - dists = get_dists(instance->network); + dists = get_dists(instance->graph); nulldists = true; } double *corr = calloc(nv, sizeof(double)); @@ -296,11 +296,11 @@ double *get_corr(finst *instance, unsigned int **dists, cholmod_common *c) { } /* -double *get_space_corr(finst *instance, cholmod_common *c) { - unsigned int nv = instance->network->num_dual_verts; - double *vc = instance->network->dual_vert_coords; - unsigned int ne = instance->network->num_edges; - unsigned int *ev = instance->network->dual_edges_to_verts; +double *get_space_corr(net_t *instance, cholmod_common *c) { + unsigned int nv = instance->graph->dnv; + double *vc = instance->graph->dual_vert_coords; + unsigned int ne = instance->graph->ne; + unsigned int *ev = instance->graph->dev; double *corr = calloc(nv, sizeof(unsigned int)); unsigned int *numat = calloc(nv, sizeof(unsigned int)); diff --git a/src/course_grain_square.c b/src/course_grain_square.c index 9035cf7..9c9ca6e 100644 --- a/src/course_grain_square.c +++ b/src/course_grain_square.c @@ -63,11 +63,11 @@ int main(int argc, char *argv[]) { (&c)->supernodal = CHOLMOD_SIMPLICIAL; } - fnet *network = ini_square_network(width, periodic, false, &c); - fnet *network_p = ini_square_network(width / 2, periodic, false, &c); - finst *perm_instance = create_instance(network, inf, voltage_bound, true, &c); - unsigned int c_dist_size = network->num_dual_verts; - unsigned int c_p_dist_size = network_p->num_dual_verts; + graph_t *network = ini_square_network(width, periodic, false, &c); + graph_t *network_p = ini_square_network(width / 2, periodic, false, &c); + net_t *perm_instance = create_instance(network, inf, voltage_bound, true, &c); + unsigned int c_dist_size = network->dnv; + unsigned int c_p_dist_size = network_p->dnv; // define arrays for saving cluster and avalanche distributions unsigned int *cluster_size_dist = @@ -80,11 +80,11 @@ int main(int argc, char *argv[]) { printf("\033[F\033[JCOURSEGRAIN_SQUARE: %0*d / %d\n", (int)log10(num) + 1, DUMB + 1, num); - break_data *breaking_data = NULL; - finst *instance = NULL; + data_t *breaking_data = NULL; + net_t *instance = NULL; while (breaking_data == NULL) { double *fuse_thres = gen_fuse_thres( - network->num_edges, network->edge_coords, beta, beta_scaling_flat); + network->ne, network->edge_coords, beta, beta_scaling_flat); instance = copy_instance(perm_instance, &c); breaking_data = fracture_network(instance, fuse_thres, &c, cutoff); free_instance(instance, &c); @@ -104,22 +104,22 @@ int main(int argc, char *argv[]) { break; } - finst *tmp_instance = copy_instance(perm_instance, &c); + net_t *tmp_instance = copy_instance(perm_instance, &c); for (unsigned int i = 0; i < breaking_data->num_broken; i++) { break_edge(tmp_instance, breaking_data->break_list[i], &c); } unsigned int *tmp_cluster_dist = get_cluster_dist(tmp_instance, &c); - for (unsigned int i = 0; i < network->num_dual_verts; i++) { + for (unsigned int i = 0; i < network->dnv; i++) { cluster_size_dist[i] += tmp_cluster_dist[i]; } free(tmp_cluster_dist); - finst *instance_p = coursegrain_square(tmp_instance, network_p, &c); + net_t *instance_p = coursegrain_square(tmp_instance, network_p, &c); unsigned int *tmp_cluster_p_dist = get_cluster_dist(instance_p, &c); - for (unsigned int i = 0; i < network_p->num_dual_verts; i++) { + for (unsigned int i = 0; i < network_p->dnv; i++) { cluster_p_size_dist[i] += tmp_cluster_p_dist[i]; } free(tmp_cluster_p_dist); @@ -159,8 +159,8 @@ int main(int argc, char *argv[]) { free(cluster_size_dist); free(cluster_p_size_dist); free_instance(perm_instance, &c); - free_fnet(network, &c); - free_fnet(network_p, &c); + free_net(network, &c); + free_net(network_p, &c); CHOL_F(finish)(&c); diff --git a/src/coursegrain.c b/src/coursegrain.c index bd84e1c..1e0d5a7 100644 --- a/src/coursegrain.c +++ b/src/coursegrain.c @@ -1,17 +1,17 @@ #include "fracture.h" -finst *coursegrain_square(finst *instance, fnet *network_p, cholmod_common *c) { - unsigned int width = sqrt(instance->network->num_edges); +net_t *coursegrain_square(net_t *instance, graph_t *network_p, cholmod_common *c) { + unsigned int width = sqrt(instance->graph->ne); assert(width % 4 == 0); - finst *instance_p = create_instance(network_p, instance->inf, + net_t *instance_p = create_instance(network_p, instance->inf, instance->voltage_bound, true, c); unsigned int width_p = width / 2; bool *fuses = instance->fuses; - for (unsigned int i = 0; i < network_p->num_edges; i++) { + for (unsigned int i = 0; i < network_p->ne; i++) { int xp = i / width_p; int yp = i % width_p; unsigned int x1 = 2 * xp; diff --git a/src/cracked_voronoi_fracture.c b/src/cracked_voronoi_fracture.c index 532c3c3..93eb112 100644 --- a/src/cracked_voronoi_fracture.c +++ b/src/cracked_voronoi_fracture.c @@ -15,8 +15,14 @@ int main(int argc, char *argv[]) { save_damage, save_damage_field; bound_t boundary; + + // assume filenames will be less than 100 characters + filename_len = 100; + + // set default values + N = 100; L = 16; crack_len = 0.; @@ -37,9 +43,13 @@ int main(int argc, char *argv[]) { save_conductivity = false; save_toughness = false; + uint8_t bound_i; char boundc2 = 'f'; + + // get commandline options + while ((opt = getopt(argc, argv, "n:L:b:B:dVcoNsCrtDSvel:")) != -1) { switch (opt) { case 'n': @@ -123,6 +133,7 @@ int main(int argc, char *argv[]) { } } + char boundc; if (use_voltage_boundaries) boundc = 'v'; else boundc = 'c'; @@ -130,7 +141,7 @@ int main(int argc, char *argv[]) { FILE *break_out; if (include_breaking) { char *break_filename = (char *)malloc(filename_len * sizeof(char)); - snprintf(break_filename, filename_len, "breaks_v_%c_%c_%u_%g.txt", boundc, boundc2, L, beta); + snprintf(break_filename, filename_len, "breaks_v_%c_%c_%u_%g_%g.txt", boundc, boundc2, L, beta, crack_len); break_out = fopen(break_filename, "a"); free(break_filename); } @@ -158,8 +169,8 @@ int main(int argc, char *argv[]) { c_filename = (char *)malloc(filename_len * sizeof(char)); a_filename = (char *)malloc(filename_len * sizeof(char)); - snprintf(c_filename, filename_len, "cstr_v_%c_%c_%d_%g.dat", boundc, boundc2, L, beta); - snprintf(a_filename, filename_len, "avln_v_%c_%c_%d_%g.dat", boundc, boundc2, L, beta); + snprintf(c_filename, filename_len, "cstr_v_%c_%c_%d_%g_%g.dat", boundc, boundc2, L, beta, crack_len); + snprintf(a_filename, filename_len, "avln_v_%c_%c_%d_%g_%g.dat", boundc, boundc2, L, beta, crack_len); FILE *cluster_out = fopen(c_filename, "rb"); FILE *avalanche_out = fopen(a_filename, "rb"); @@ -179,6 +190,24 @@ int main(int argc, char *argv[]) { crit_stress = (double *)malloc(N * sizeof(double)); } + double *stress_field; + unsigned int stress_pos = 0; + if (save_stress_field) { + stress_field = (double *)malloc(3 * N * voronoi_max_verts * sizeof(double)); + } + + double *voltage_field; + unsigned int voltage_pos = 0; + if (save_voltage_field) { + voltage_field = (double *)malloc(3 * N * voronoi_max_verts * sizeof(double)); + } + + double *damage_field; + unsigned int damage_pos = 0; + if (save_damage_field) { + damage_field = (double *)malloc(2 * N * voronoi_max_verts * sizeof(double)); + } + double *conductivity; if (save_conductivity) { conductivity = (double *)malloc(N * sizeof(double)); @@ -192,7 +221,7 @@ int main(int argc, char *argv[]) { (uint32_t *)malloc(a_dist_size * sizeof(uint32_t)); d_filename = (char *)malloc(filename_len * sizeof(char)); - snprintf(d_filename, filename_len, "damg_v_%c_%c_%d_%g.dat", boundc, boundc2, L, beta); + snprintf(d_filename, filename_len, "damg_v_%c_%c_%d_%g_%g.dat", boundc, boundc2, L, beta, crack_len); FILE *damage_out = fopen(d_filename, "rb"); @@ -228,16 +257,16 @@ int main(int argc, char *argv[]) { for (uint32_t i = 0; i < N; i++) { printf("\033[F\033[JFRACTURE: %0*d / %d\n", (uint8_t)log10(N) + 1, i + 1, N); - fnet *network = ini_voronoi_network(L, boundary, use_dual, genfunc_hyperuniform, &c); - finst *perm_instance = create_instance(network, inf, use_voltage_boundaries, false, &c); + graph_t *graph = ini_voronoi_network(L, boundary, use_dual, genfunc_hyperuniform, &c); + net_t *perm_instance = create_instance(graph, inf, use_voltage_boundaries, false, &c); if (boundary == EMBEDDED_BOUND) { voronoi_bound_ini(perm_instance, L, crack_len); } gen_voro_crack(perm_instance, crack_len, &c); finish_instance(perm_instance, &c); - double *fuse_thres = gen_fuse_thres(network->num_edges, network->edge_coords, beta, beta_scaling_flat); - finst *instance = copy_instance(perm_instance, &c); - break_data *breaking_data = fracture_network(instance, fuse_thres, &c, cutoff); + double *fuse_thres = gen_fuse_thres(graph->ne, graph->edge_coords, beta, beta_scaling_flat); + net_t *instance = copy_instance(perm_instance, &c); + data_t *breaking_data = fracture_network(instance, fuse_thres, &c, cutoff); free_instance(instance, &c); free(fuse_thres); @@ -253,12 +282,13 @@ int main(int argc, char *argv[]) { } } - if (save_crit_stress) { - crit_stress[i] = - breaking_data->extern_field[max_pos]; - } + if (save_crit_stress) crit_stress[i] = breaking_data->extern_field[max_pos]; + + if (save_conductivity) conductivity[i] = breaking_data->conductivity[max_pos]; - finst *tmp_instance = copy_instance(perm_instance, &c); + if (save_damage) damage[max_pos]++; + + net_t *tmp_instance = copy_instance(perm_instance, &c); uint_t av_size = 0; double cur_val = 0; @@ -279,13 +309,34 @@ int main(int argc, char *argv[]) { } } - if (save_conductivity) { - if (!use_voltage_boundaries) { - double *tmp_voltage = get_voltage(tmp_instance, &c); - conductivity[i] = 1/fabs(tmp_voltage[tmp_instance->network->num_verts + 1] - tmp_voltage[tmp_instance->network->num_verts]); - free(tmp_voltage); - } else { - conductivity[i] = breaking_data->conductivity[max_pos]; + if (save_stress_field || save_voltage_field) { + double *tmp_voltages = get_voltage(tmp_instance, &c); + if (save_voltage_field) { + for (uint_t j = 0; j < tmp_instance->graph->nv; j++) { + voltage_field[3 * voltage_pos] = tmp_instance->graph->vert_coords[2 * j]; + voltage_field[3 * voltage_pos + 1] = tmp_instance->graph->vert_coords[2 * j + 1]; + voltage_field[3 * voltage_pos + 2] = tmp_voltages[j]; + voltage_pos++; + } + } + if (save_stress_field) { + double *tmp_currents = get_current_v(tmp_instance, tmp_voltages, &c); + for (uint_t j = 0; j < tmp_instance->graph->ne; j++) { + stress_field[3 * stress_pos] = tmp_instance->graph->edge_coords[2 * j]; + stress_field[3 * stress_pos + 1] = tmp_instance->graph->edge_coords[2 * j + 1]; + stress_field[3 * stress_pos + 2] = tmp_currents[j]; + stress_pos++; + } + free(tmp_currents); + } + free(tmp_voltages); + } + + if (save_damage_field) { + for (uint_t j = 0; j < max_pos; j++) { + damage_field[2 * damage_pos] = tmp_instance->graph->edge_coords[2 * breaking_data->break_list[j]]; + damage_field[2 * damage_pos + 1] = tmp_instance->graph->edge_coords[2 * breaking_data->break_list[j] + 1]; + damage_pos++; } } @@ -306,13 +357,9 @@ int main(int argc, char *argv[]) { toughness[i] = tmp_toughness; } - if (save_damage) { - damage[max_pos]++; - } - if (save_cluster_dist) { uint_t *tmp_cluster_dist = get_cluster_dist(tmp_instance, &c); - for (uint_t j = 0; j < tmp_instance->network->num_dual_verts; j++) { + for (uint_t j = 0; j < tmp_instance->graph->dnv; j++) { cluster_size_dist[j] += tmp_cluster_dist[j]; } free(tmp_cluster_dist); @@ -320,27 +367,27 @@ int main(int argc, char *argv[]) { if (save_network) { FILE *net_out = fopen("network.txt", "w"); - for (uint_t j = 0; j < network->num_verts; j++) { - fprintf(net_out, "%f %f ", network->vert_coords[2 * j], - tmp_instance->network->vert_coords[2 * j + 1]); + for (uint_t j = 0; j < graph->nv; j++) { + fprintf(net_out, "%f %f ", graph->vert_coords[2 * j], + tmp_instance->graph->vert_coords[2 * j + 1]); } fprintf(net_out, "\n"); - for (uint_t j = 0; j < tmp_instance->network->num_edges; j++) { - fprintf(net_out, "%u %u ", tmp_instance->network->edges_to_verts[2 * j], - tmp_instance->network->edges_to_verts[2 * j + 1]); + for (uint_t j = 0; j < tmp_instance->graph->ne; j++) { + fprintf(net_out, "%u %u ", tmp_instance->graph->ev[2 * j], + tmp_instance->graph->ev[2 * j + 1]); } fprintf(net_out, "\n"); - for (uint_t j = 0; j < tmp_instance->network->num_dual_verts; j++) { - fprintf(net_out, "%f %f ", tmp_instance->network->dual_vert_coords[2 * j], - tmp_instance->network->dual_vert_coords[2 * j + 1]); + for (uint_t j = 0; j < tmp_instance->graph->dnv; j++) { + fprintf(net_out, "%f %f ", tmp_instance->graph->dual_vert_coords[2 * j], + tmp_instance->graph->dual_vert_coords[2 * j + 1]); } fprintf(net_out, "\n"); - for (uint_t j = 0; j < tmp_instance->network->num_edges; j++) { - fprintf(net_out, "%u %u ", tmp_instance->network->dual_edges_to_verts[2 * j], - tmp_instance->network->dual_edges_to_verts[2 * j + 1]); + for (uint_t j = 0; j < tmp_instance->graph->ne; j++) { + fprintf(net_out, "%u %u ", tmp_instance->graph->dev[2 * j], + tmp_instance->graph->dev[2 * j + 1]); } fprintf(net_out, "\n"); - for (uint_t j = 0; j < tmp_instance->network->num_edges; j++) { + for (uint_t j = 0; j < tmp_instance->graph->ne; j++) { fprintf(net_out, "%d ", tmp_instance->fuses[j]); } fclose(net_out); @@ -348,7 +395,7 @@ int main(int argc, char *argv[]) { free_instance(tmp_instance, &c); free_instance(perm_instance, &c); - free_fnet(network, &c); + free_net(graph, &c); if (include_breaking) { for (uint_t j = 0; j < breaking_data->num_broken; j++) { @@ -379,9 +426,39 @@ int main(int argc, char *argv[]) { free(avalanche_size_dist); } + if (save_voltage_field) { + char *vfld_filename = (char *)malloc(filename_len * sizeof(char)); + snprintf(vfld_filename, filename_len, "vfld_v_%c_%c_%d_%g_%g.dat", boundc, boundc2, L, beta, crack_len); + FILE *vfld_file = fopen(vfld_filename, "ab"); + fwrite(voltage_field, sizeof(double), 3 * voltage_pos, vfld_file); + fclose(vfld_file); + free(vfld_filename); + free(voltage_field); + } + + if (save_stress_field) { + char *cfld_filename = (char *)malloc(filename_len * sizeof(char)); + snprintf(cfld_filename, filename_len, "cfld_v_%c_%c_%d_%g_%g.dat", boundc, boundc2, L, beta, crack_len); + FILE *cfld_file = fopen(cfld_filename, "ab"); + fwrite(stress_field, sizeof(double), 3 * stress_pos, cfld_file); + fclose(cfld_file); + free(cfld_filename); + free(stress_field); + } + + if (save_damage_field) { + char *dfld_filename = (char *)malloc(filename_len * sizeof(char)); + snprintf(dfld_filename, filename_len, "dfld_v_%c_%c_%d_%g_%g.dat", boundc, boundc2, L, beta, crack_len); + FILE *dfld_file = fopen(dfld_filename, "ab"); + fwrite(damage_field, sizeof(double), 2 * damage_pos, dfld_file); + fclose(dfld_file); + free(dfld_filename); + free(damage_field); + } + if (save_conductivity) { char *cond_filename = (char *)malloc(filename_len * sizeof(char)); - snprintf(cond_filename, filename_len, "cond_v_%c_%c_%d_%g.dat", boundc, boundc2, L, beta); + snprintf(cond_filename, filename_len, "cond_v_%c_%c_%d_%g_%g.dat", boundc, boundc2, L, beta, crack_len); FILE *cond_file = fopen(cond_filename, "ab"); fwrite(conductivity, sizeof(double), N, cond_file); fclose(cond_file); @@ -391,7 +468,7 @@ int main(int argc, char *argv[]) { if (save_toughness) { char *tough_filename = (char *)malloc(filename_len * sizeof(char)); - snprintf(tough_filename, filename_len, "tuff_v_%c_%c_%d_%g.dat", boundc, boundc2, L, beta); + snprintf(tough_filename, filename_len, "tuff_v_%c_%c_%d_%g_%g.dat", boundc, boundc2, L, beta, crack_len); FILE *tough_file = fopen(tough_filename, "ab"); fwrite(toughness, sizeof(double), N, tough_file); fclose(tough_file); @@ -413,7 +490,7 @@ int main(int argc, char *argv[]) { if (save_crit_stress) { char *str_filename = (char *)malloc(filename_len * sizeof(char)); - snprintf(str_filename, filename_len, "strs_v_%c_%c_%d_%g.dat", boundc, boundc2, L, beta); + snprintf(str_filename, filename_len, "strs_v_%c_%c_%d_%g_%g.dat", boundc, boundc2, L, beta, crack_len); FILE *str_file = fopen(str_filename, "ab"); fwrite(crit_stress, sizeof(double), N, str_file); fclose(str_file); diff --git a/src/cracking_ini.c b/src/cracking_ini.c index 988af5b..93e5765 100644 --- a/src/cracking_ini.c +++ b/src/cracking_ini.c @@ -31,18 +31,18 @@ double *gen_fuse_thres(unsigned int num_edges, double *edge_coords, double beta, return fuse_thres; } -void gen_voro_crack(finst *instance, double crack_len, cholmod_common *c) { - for (uint_t i = 0; i < instance->network->num_edges; i++) { +void gen_voro_crack(net_t *instance, double crack_len, cholmod_common *c) { + for (uint_t i = 0; i < instance->graph->ne; i++) { uint_t v1, v2; double v1x, v1y, v2x, v2y, dx, dy; - v1 = instance->network->edges_to_verts[2 * i]; - v2 = instance->network->edges_to_verts[2 * i + 1]; + v1 = instance->graph->ev[2 * i]; + v2 = instance->graph->ev[2 * i + 1]; - v1x = instance->network->vert_coords[2 * v1]; - v1y = instance->network->vert_coords[2 * v1 + 1]; - v2x = instance->network->vert_coords[2 * v2]; - v2y = instance->network->vert_coords[2 * v2 + 1]; + v1x = instance->graph->vert_coords[2 * v1]; + v1y = instance->graph->vert_coords[2 * v1 + 1]; + v2x = instance->graph->vert_coords[2 * v2]; + v2y = instance->graph->vert_coords[2 * v2 + 1]; dx = v1x - v2x; dy = v1y - v2y; @@ -55,13 +55,13 @@ void gen_voro_crack(finst *instance, double crack_len, cholmod_common *c) { } } -bool gen_crack(finst *instance, double crack_len, double crack_width, +bool gen_crack(net_t *instance, double crack_len, double crack_width, cholmod_common *c) { assert(instance != NULL); bool *fuses = instance->fuses; assert(fuses != NULL); - const fnet *network = instance->network; - unsigned int num_edges = network->num_edges; + const graph_t *network = instance->graph; + unsigned int num_edges = network->ne; double *edge_coords = network->edge_coords; for (unsigned int j = 0; j < num_edges; j++) { diff --git a/src/current_scaling.c b/src/current_scaling.c index 6837f6b..f750cb1 100644 --- a/src/current_scaling.c +++ b/src/current_scaling.c @@ -87,15 +87,15 @@ int main(int argc, char *argv[]) { (&c)->supernodal = CHOLMOD_SIMPLICIAL; } - fnet *network = ini_square_network(width, false, true, &c); - finst *perm_instance = + graph_t *network = ini_square_network(width, false, true, &c); + net_t *perm_instance = create_instance(network, inf, voltage_bound, false, &c); gen_crack(perm_instance, crack_len, 1, &c); finish_instance(perm_instance, &c); if (voltage_bound) { (&c)->supernodal = CHOLMOD_SIMPLICIAL; - finst *tmp_instance = create_instance(network, inf, false, false, &c); + net_t *tmp_instance = create_instance(network, inf, false, false, &c); gen_crack(tmp_instance, crack_len, 1, &c); finish_instance(tmp_instance, &c); double *voltage = get_voltage(tmp_instance, &c); @@ -113,14 +113,14 @@ int main(int argc, char *argv[]) { if (supplied_bound) { FILE *bound_f = fopen(bound_file, "r"); - for (int i = 0; i < network->num_verts; i++) { + for (int i = 0; i < network->nv; i++) { double tmp; fscanf(bound_f, "%lg ", &tmp); ((double *)perm_instance->boundary_cond->x)[i] = tmp; } - ((double *)perm_instance->boundary_cond->x)[network->num_verts] = 0; - ((double *)perm_instance->boundary_cond->x)[network->num_verts + 1] = 0; + ((double *)perm_instance->boundary_cond->x)[network->nv] = 0; + ((double *)perm_instance->boundary_cond->x)[network->nv + 1] = 0; fclose(bound_f); } @@ -134,25 +134,25 @@ int main(int argc, char *argv[]) { double *damage; if (save_damage) { - damage = (double *)calloc(network->num_edges, sizeof(double)); + damage = (double *)calloc(network->ne, sizeof(double)); } - double *avg_current = (double *)calloc(network->num_edges, sizeof(double)); + double *avg_current = (double *)calloc(network->ne, sizeof(double)); unsigned int *num_current_skipped = - (unsigned int *)calloc(network->num_edges, sizeof(unsigned int)); - double *avg_voltage = (double *)calloc(network->num_verts, sizeof(double)); + (unsigned int *)calloc(network->ne, sizeof(unsigned int)); + double *avg_voltage = (double *)calloc(network->nv, sizeof(double)); unsigned int *num_voltage_skipped = - (unsigned int *)calloc(network->num_verts, sizeof(unsigned int)); + (unsigned int *)calloc(network->nv, sizeof(unsigned int)); for (int DUMB = 0; DUMB < num; DUMB++) { printf("\033[F\033[JCURRENT_SCALING: ITERATION %0*d: %0*d / %d\n", (int)log10(iter) + 1, DUMB2 + 1, (int)log10(num) + 1, DUMB + 1, num); - break_data *breaking_data = NULL; + data_t *breaking_data = NULL; while (breaking_data == NULL) { double *fuse_thres = gen_fuse_thres( - network->num_edges, network->edge_coords, beta, beta_scaling_flat); - finst *instance = copy_instance(perm_instance, &c); + network->ne, network->edge_coords, beta, beta_scaling_flat); + net_t *instance = copy_instance(perm_instance, &c); breaking_data = fracture_network(instance, fuse_thres, &c, cutoff); free_instance(instance, &c); free(fuse_thres); @@ -173,7 +173,7 @@ int main(int argc, char *argv[]) { strength[DUMB] = fabs(breaking_data->extern_field[min_pos]); } - finst *tmp_instance = copy_instance(perm_instance, &c); + net_t *tmp_instance = copy_instance(perm_instance, &c); unsigned int until = min_pos; if (use_first) @@ -188,14 +188,14 @@ int main(int argc, char *argv[]) { double *voltage = get_voltage(tmp_instance, &c); double *current = get_current(tmp_instance, &c); - for (unsigned int i = 0; i < network->num_edges; i++) { + for (unsigned int i = 0; i < network->ne; i++) { avg_current[i] += current[i]; if (current[i] == 0) num_current_skipped[i]++; } - for (unsigned int i = 0; i < network->num_verts; i++) { - if (tmp_instance->marks[i] == tmp_instance->marks[network->num_verts]) { + for (unsigned int i = 0; i < network->nv; i++) { + if (tmp_instance->marks[i] == tmp_instance->marks[network->nv]) { avg_voltage[i] += voltage[i]; } else { num_voltage_skipped[i]++; @@ -210,13 +210,13 @@ int main(int argc, char *argv[]) { free(breaking_data); } - for (int i = 0; i < network->num_edges; i++) { + for (int i = 0; i < network->ne; i++) { if (num_current_skipped[i] < num) { avg_current[i] /= num - num_current_skipped[i]; } } - for (int i = 0; i < network->num_verts; i++) { + for (int i = 0; i < network->nv; i++) { if (num_voltage_skipped[i] < num) { avg_voltage[i] /= num - num_voltage_skipped[i]; } @@ -235,7 +235,7 @@ int main(int argc, char *argv[]) { snprintf(c_filename, 100, "current_%d_%g_%d_%g.txt", width, crack_len, iter, beta); FILE *outfile = fopen(c_filename, "w"); - for (int i = 0; i < network->num_edges; i++) { + for (int i = 0; i < network->ne; i++) { fprintf(outfile, "%g ", avg_current[i]); } fclose(outfile); @@ -247,7 +247,7 @@ int main(int argc, char *argv[]) { snprintf(c_filename, 100, "damage_%d_%g_%d_%g.txt", width, crack_len, iter, beta); FILE *outfile = fopen(c_filename, "w"); - for (int i = 0; i < network->num_edges; i++) { + for (int i = 0; i < network->ne; i++) { fprintf(outfile, "%g ", damage[i]); } fclose(outfile); @@ -270,7 +270,7 @@ int main(int argc, char *argv[]) { snprintf(b_filename, 100, "bounds_%d_%g_%d_%g.txt", width, crack_len, iter, beta); FILE *outfile = fopen(b_filename, "w"); - for (int i = 0; i < network->num_verts; i++) { + for (int i = 0; i < network->nv; i++) { fprintf(outfile, "%g ", ((double *)perm_instance->boundary_cond->x)[i]); } fclose(outfile); @@ -292,7 +292,7 @@ int main(int argc, char *argv[]) { } free_instance(perm_instance, &c); - free_fnet(network, &c); + free_net(network, &c); CHOL_F(finish)(&c); diff --git a/src/fracture.c b/src/fracture.c index 6798231..23bce03 100644 --- a/src/fracture.c +++ b/src/fracture.c @@ -151,7 +151,7 @@ int main(int argc, char *argv[]) { (&c)->supernodal = CHOLMOD_SIMPLICIAL; } - fnet *network; + graph_t *network; finst *perm_instance; unsigned int c_dist_size; unsigned int a_dist_size; @@ -175,8 +175,8 @@ int main(int argc, char *argv[]) { perm_instance = create_instance(network, inf, voltage_bound, false, &c); gen_crack(perm_instance, crack_len, crack_width, &c); finish_instance(perm_instance, &c); - c_dist_size = network->num_dual_verts; - a_dist_size = network->num_verts; + c_dist_size = network->dnv; + a_dist_size = network->nv; } // define arrays for saving cluster and avalanche distributions @@ -279,7 +279,7 @@ int main(int argc, char *argv[]) { printf("\033[F\033[JFRACTURE: %0*d / %d\n", (int)log10(num) + 1, DUMB + 1, num); - break_data *breaking_data = NULL; + data_t *breaking_data = NULL; while (breaking_data == NULL) { if (voronoi && !repeat_voronoi) { while ((network = ini_voronoi_network(width, periodic, @@ -293,7 +293,7 @@ int main(int argc, char *argv[]) { } } double *fuse_thres = gen_fuse_thres( - network->num_edges, network->edge_coords, beta, beta_scaling_flat); + network->ne, network->edge_coords, beta, beta_scaling_flat); finst *instance = copy_instance(perm_instance, &c); breaking_data = fracture_network(instance, fuse_thres, &c, cutoff); free_instance(instance, &c); @@ -350,19 +350,19 @@ int main(int argc, char *argv[]) { if (save_cond) { double *tmp_voltage = get_voltage(tmp_instance, &c); - conductivity[DUMB] = fabs(tmp_voltage[tmp_instance->network->num_verts + 1] - tmp_voltage[tmp_instance->network->num_verts]); + conductivity[DUMB] = fabs(tmp_voltage[tmp_instance->graph->nv + 1] - tmp_voltage[tmp_instance->graph->nv]); free(tmp_voltage); } if (save_homo_damage) { - homo_damage[DUMB] = ((double)min_pos) / tmp_instance->network->num_edges; + homo_damage[DUMB] = ((double)min_pos) / tmp_instance->graph->ne; } if (save_avg_stress || save_avg_ztress) { double *tmp_stress = get_current(tmp_instance, &c); if (voronoi) { double *tmp_stress_2 = - bin_values(tmp_instance->network, width, tmp_stress); + bin_values(tmp_instance->graph, width, tmp_stress); free(tmp_stress); tmp_stress = tmp_stress_2; } @@ -380,12 +380,12 @@ int main(int argc, char *argv[]) { } if (save_damage) { - double *tmp_damage = (double *)calloc(tmp_instance->network->num_edges, sizeof(double)); + double *tmp_damage = (double *)calloc(tmp_instance->graph->ne, sizeof(double)); for (unsigned int i = 0; i < stop_at; i++) { tmp_damage[breaking_data->break_list[i]] += 1; } if (voronoi) { - double *tmp_damage_2 = bin_values(tmp_instance->network, width, tmp_damage); + double *tmp_damage_2 = bin_values(tmp_instance->graph, width, tmp_damage); free(tmp_damage); tmp_damage = tmp_damage_2; } @@ -397,7 +397,7 @@ int main(int argc, char *argv[]) { if (save_clusters) { unsigned int *tmp_cluster_dist = get_cluster_dist(tmp_instance, &c); - for (unsigned int i = 0; i < network->num_dual_verts; i++) { + for (unsigned int i = 0; i < network->dnv; i++) { cluster_size_dist[i] += tmp_cluster_dist[i]; } free(tmp_cluster_dist); @@ -405,7 +405,7 @@ int main(int argc, char *argv[]) { if (save_corr) { double *tmp_corr = get_corr(tmp_instance, dists, &c); - for (unsigned int i = 0; i < tmp_instance->network->num_dual_verts; i++) { + for (unsigned int i = 0; i < tmp_instance->graph->dnv; i++) { avg_corr[i] += tmp_corr[i] / num; } free(tmp_corr); @@ -413,27 +413,27 @@ int main(int argc, char *argv[]) { if (network_out) { FILE *net_out = fopen("network.txt", "w"); - for (unsigned int i = 0; i < network->num_verts; i++) { + for (unsigned int i = 0; i < network->nv; i++) { fprintf(net_out, "%f %f ", network->vert_coords[2 * i], network->vert_coords[2 * i + 1]); } fprintf(net_out, "\n"); - for (unsigned int i = 0; i < network->num_edges; i++) { - fprintf(net_out, "%u %u ", network->edges_to_verts[2 * i], - network->edges_to_verts[2 * i + 1]); + for (unsigned int i = 0; i < network->ne; i++) { + fprintf(net_out, "%u %u ", network->ev[2 * i], + network->ev[2 * i + 1]); } fprintf(net_out, "\n"); - for (unsigned int i = 0; i < network->num_dual_verts; i++) { + for (unsigned int i = 0; i < network->dnv; i++) { fprintf(net_out, "%f %f ", network->dual_vert_coords[2 * i], network->dual_vert_coords[2 * i + 1]); } fprintf(net_out, "\n"); - for (unsigned int i = 0; i < network->num_edges; i++) { - fprintf(net_out, "%u %u ", network->dual_edges_to_verts[2 * i], - network->dual_edges_to_verts[2 * i + 1]); + for (unsigned int i = 0; i < network->ne; i++) { + fprintf(net_out, "%u %u ", network->dev[2 * i], + network->dev[2 * i + 1]); } fprintf(net_out, "\n"); - for (unsigned int i = 0; i < network->num_edges; i++) { + for (unsigned int i = 0; i < network->ne; i++) { fprintf(net_out, "%d ", tmp_instance->fuses[i]); } fclose(net_out); @@ -441,7 +441,7 @@ int main(int argc, char *argv[]) { free_instance(tmp_instance, &c); if (voronoi && !repeat_voronoi) { - free_fnet(network, &c); + free_net(network, &c); free_instance(perm_instance, &c); } if (include_breaking) { @@ -510,7 +510,7 @@ int main(int argc, char *argv[]) { if (!voronoi || repeat_voronoi) { free_instance(perm_instance, &c); - //free_fnet(network, &c); + //free_net(network, &c); } if (include_breaking) { diff --git a/src/fracture.h b/src/fracture.h index 93e2ed1..349e59e 100644 --- a/src/fracture.h +++ b/src/fracture.h @@ -37,33 +37,33 @@ typedef enum bound_t { } bound_t; typedef struct { - unsigned int num_edges; - unsigned int num_verts; - unsigned int num_verts_break; - unsigned int num_bounds; - unsigned int *edges_to_verts; - unsigned int *edges_to_verts_break; - unsigned int *verts_to_edges_ind; - unsigned int *verts_to_edges; - unsigned int *bound_inds; - unsigned int *bound_verts; + uint_t ne; + uint_t nv; + uint_t dnv; + uint_t nv_break; + uint_t num_bounds; + uint_t *ev; + uint_t *ev_break; + uint_t *vei; + uint_t *ve; + uint_t *bound_inds; + uint_t *bound_verts; double *vert_coords; double *edge_coords; - unsigned int *dual_edges_to_verts; - unsigned int *dual_verts_to_edges_ind; - unsigned int *dual_verts_to_edges; + uint_t *dev; + uint_t *dvei; + uint_t *dve; double *dual_vert_coords; - unsigned int num_spanning_edges; - unsigned int *spanning_edges; + uint_t num_spanning_edges; + uint_t *spanning_edges; double L; - unsigned int num_dual_verts; - unsigned int break_dim; + uint_t break_dim; cholmod_sparse *voltcurmat; bound_t boundary; -} fnet; +} graph_t; typedef struct { - fnet *network; + graph_t *graph; unsigned int num_remaining_edges; bool *fuses; double inf; @@ -75,14 +75,14 @@ typedef struct { unsigned int num_components; cholmod_sparse *adjacency; bool debug_stop; -} finst; +} net_t; typedef struct { unsigned int num_broken; unsigned int *break_list; double *conductivity; double *extern_field; -} break_data; +} data_t; intptr_t *run_voronoi(unsigned int num_coords, double *coords, bool periodic, double xmin, double xmax, double ymin, double ymax); @@ -91,10 +91,10 @@ int update_components(const cholmod_sparse *laplacian, unsigned int *marks, unsigned int *find_components(const cholmod_sparse *laplacian, unsigned int skip); -cholmod_sparse *gen_adjacency(const finst *instance, bool dual, bool breakv, +cholmod_sparse *gen_adjacency(const net_t *instance, bool dual, bool breakv, unsigned int pad, cholmod_common *c); -cholmod_sparse *gen_laplacian(const finst *instance, cholmod_common *c, +cholmod_sparse *gen_laplacian(const net_t *instance, cholmod_common *c, bool symmetric); int edge_to_verts(unsigned int width, bool periodic, unsigned int edge, @@ -109,20 +109,20 @@ double dual_vert_to_coord(unsigned int width, bool periodic, unsigned int vert, bool update_factor(cholmod_factor *factor, unsigned int v1, unsigned int v2, cholmod_common *c); -break_data *fracture_network(finst *instance, double *fuse_thres, +data_t *fracture_network(net_t *instance, double *fuse_thres, cholmod_common *c, double cutoff); -double *get_current(const finst *instance, cholmod_common *c); -double *get_current_v(const finst *instance, double *voltages, cholmod_common *c); -double *get_voltage(const finst *instance, cholmod_common *c); +double *get_current(const net_t *instance, cholmod_common *c); +double *get_current_v(const net_t *instance, double *voltages, cholmod_common *c); +double *get_voltage(const net_t *instance, cholmod_common *c); double *gen_fuse_thres(unsigned int num_edges, double *edge_coords, double beta, double (*beta_scale)(double, double, double)); -bool gen_crack(finst *instance, double crack_len, double crack_width, +bool gen_crack(net_t *instance, double crack_len, double crack_width, cholmod_common *c); -void update_boundary(finst *instance, const double *avg_field); +void update_boundary(net_t *instance, const double *avg_field); FILE *get_file(const char *prefix, unsigned int width, unsigned int crack, double beta, unsigned int iter, unsigned int num_iter, @@ -134,32 +134,32 @@ double update_beta(double beta, unsigned int width, const double *stress, cholmod_sparse *gen_voltcurmat(unsigned int num_edges, unsigned int num_verts, unsigned int *edges_to_verts, cholmod_common *c); -finst *copy_instance(const finst *instance, cholmod_common *c); +net_t *copy_instance(const net_t *instance, cholmod_common *c); -fnet *ini_square_network(unsigned int width, bound_t boundary, bool side_bounds, +graph_t *ini_square_network(unsigned int width, bound_t boundary, bool side_bounds, cholmod_common *c); -void free_fnet(fnet *network, cholmod_common *c); -void free_instance(finst *instance, cholmod_common *c); +void free_net(graph_t *network, cholmod_common *c); +void free_instance(net_t *instance, cholmod_common *c); -finst *create_instance(fnet *network, double inf, bool voltage_bound, +net_t *create_instance(graph_t *network, double inf, bool voltage_bound, bool startnow, cholmod_common *c); -fnet *ini_voronoi_network(unsigned int L, bound_t boundary, bool use_dual, +graph_t *ini_voronoi_network(unsigned int L, bound_t boundary, bool use_dual, double *(*genfunc)(unsigned int, bound_t, gsl_rng *, unsigned int *), cholmod_common *c); -bool check_instance(const finst *instance, cholmod_common *c); +bool check_instance(const net_t *instance, cholmod_common *c); -bool break_edge(finst *instance, unsigned int edge, cholmod_common *c); +bool break_edge(net_t *instance, unsigned int edge, cholmod_common *c); -void finish_instance(finst *instance, cholmod_common *c); +void finish_instance(net_t *instance, cholmod_common *c); -finst *coursegrain_square(finst *instance, fnet *network_p, cholmod_common *c); +net_t *coursegrain_square(net_t *instance, graph_t *network_p, cholmod_common *c); -unsigned int *get_clusters(finst *instance, cholmod_common *c); +unsigned int *get_clusters(net_t *instance, cholmod_common *c); -unsigned int *get_cluster_dist(finst *instance, cholmod_common *c); +unsigned int *get_cluster_dist(net_t *instance, cholmod_common *c); double *genfunc_uniform(unsigned int L, bound_t boundary, gsl_rng *r, unsigned int *num); double *genfunc_hyperuniform(unsigned int L, bound_t boundary, gsl_rng *r, unsigned int *num); @@ -169,18 +169,18 @@ double beta_scaling_flat(double beta, double x, double y); double beta_scaling_gaus(double beta, double x, double y); double beta_mag(double beta); -unsigned int *dijkstra(fnet *network, unsigned int source); -unsigned int **get_dists(fnet *network); -double *get_corr(finst *instance, unsigned int **dists, cholmod_common *c); +unsigned int *dijkstra(graph_t *network, unsigned int source); +unsigned int **get_dists(graph_t *network); +double *get_corr(net_t *instance, unsigned int **dists, cholmod_common *c); -double *bin_values(fnet *network, unsigned int width, double *values); +double *bin_values(graph_t *network, unsigned int width, double *values); -void voronoi_bound_ini(finst *instance, uint_t L, double crack_len); +void voronoi_bound_ini(net_t *instance, uint_t L, double crack_len); -break_data *alloc_break_data(unsigned int num_edges); -void free_break_data(break_data *data); -void update_break_data(break_data *data, unsigned int last_broke, double strength, double conductivity); +data_t *alloc_break_data(unsigned int num_edges); +void free_break_data(data_t *data); +void update_break_data(data_t *data, unsigned int last_broke, double strength, double conductivity); -double get_conductivity(finst *inst, double *current, cholmod_common *c); +double get_conductivity(net_t *inst, double *current, cholmod_common *c); -void gen_voro_crack(finst *instance, double crack_len, cholmod_common *c); +void gen_voro_crack(net_t *instance, double crack_len, cholmod_common *c); diff --git a/src/fracture_network.c b/src/fracture_network.c index 3f06104..428b092 100644 --- a/src/fracture_network.c +++ b/src/fracture_network.c @@ -1,9 +1,9 @@ #include "fracture.h" -int inc_break_fuses(finst *instance, double *thres, double *field, +int inc_break_fuses(net_t *instance, double *thres, double *field, double cutoff) { - unsigned int size = (instance->network)->num_edges; + unsigned int size = (instance->graph)->ne; int min_pos = -1; long double min_val = -1; @@ -20,12 +20,12 @@ int inc_break_fuses(finst *instance, double *thres, double *field, return min_pos; } -break_data *fracture_network(finst *instance, double *fuse_thres, +data_t *fracture_network(net_t *instance, double *fuse_thres, cholmod_common *c, double cutoff) { - unsigned int num_edges = instance->network->num_edges; - unsigned int num_verts = instance->network->num_verts; + unsigned int num_edges = instance->graph->ne; + unsigned int num_verts = instance->graph->nv; - break_data *breaking_data = alloc_break_data(num_edges); + data_t *breaking_data = alloc_break_data(num_edges); while (true) { double *voltages = get_voltage(instance, c); @@ -53,11 +53,11 @@ break_data *fracture_network(finst *instance, double *fuse_thres, break_edge(instance, last_broke, c); - if (instance->num_components > 1 && instance->network->boundary == TORUS_BOUND) { + if (instance->num_components > 1 && instance->graph->boundary == TORUS_BOUND) { break; } - if (instance->marks[num_verts] != instance->marks[num_verts + 1] && instance->network->boundary != TORUS_BOUND) { + if (instance->marks[num_verts] != instance->marks[num_verts + 1] && instance->graph->boundary != TORUS_BOUND) { break; } } diff --git a/src/free_network.c b/src/free_network.c index 651d3ae..5fd3290 100644 --- a/src/free_network.c +++ b/src/free_network.c @@ -1,21 +1,21 @@ #include "fracture.h" -void free_fnet(fnet *network, cholmod_common *c) { - free(network->edges_to_verts); - if (network->edges_to_verts_break != network->edges_to_verts) { - free(network->edges_to_verts_break); +void free_net(graph_t *network, cholmod_common *c) { + free(network->ev); + if (network->ev_break != network->ev) { + free(network->ev_break); } - free(network->verts_to_edges_ind); - free(network->verts_to_edges); + free(network->vei); + free(network->ve); free(network->bound_inds); free(network->bound_verts); free(network->vert_coords); free(network->edge_coords); - free(network->dual_edges_to_verts); + free(network->dev); free(network->dual_vert_coords); - free(network->dual_verts_to_edges_ind); - free(network->dual_verts_to_edges); + free(network->dvei); + free(network->dve); free(network->spanning_edges); CHOL_F(free_sparse)(&(network->voltcurmat), c); free(network); diff --git a/src/gen_laplacian.c b/src/gen_laplacian.c index 97a2c9d..6034a82 100644 --- a/src/gen_laplacian.c +++ b/src/gen_laplacian.c @@ -1,15 +1,15 @@ #include "fracture.h" -cholmod_sparse *gen_adjacency(const finst *instance, bool dual, bool breakv, +cholmod_sparse *gen_adjacency(const net_t *instance, bool dual, bool breakv, unsigned int pad, cholmod_common *c) { unsigned int ne; if (dual) - ne = ((int)instance->network->num_edges); + ne = ((int)instance->graph->ne); else { ne = instance->num_remaining_edges; - if (!breakv && instance->network->boundary != TORUS_BOUND) { - ne += instance->network->bound_inds[2]; + if (!breakv && instance->graph->boundary != TORUS_BOUND) { + ne += instance->graph->bound_inds[2]; } } @@ -17,11 +17,11 @@ cholmod_sparse *gen_adjacency(const finst *instance, bool dual, bool breakv, unsigned int nv; if (dual) - nv = instance->network->num_dual_verts; + nv = instance->graph->dnv; else { - if (breakv) nv = instance->network->num_verts_break; - else nv = instance->network->num_verts; - if (instance->network->boundary != TORUS_BOUND && !breakv) { + if (breakv) nv = instance->graph->nv_break; + else nv = instance->graph->nv; + if (instance->graph->boundary != TORUS_BOUND && !breakv) { nv += 2; } } @@ -36,15 +36,15 @@ cholmod_sparse *gen_adjacency(const finst *instance, bool dual, bool breakv, unsigned int *etv; if (dual) - etv = instance->network->dual_edges_to_verts; + etv = instance->graph->dev; else { - if (breakv) etv = instance->network->edges_to_verts_break; - else etv = instance->network->edges_to_verts; + if (breakv) etv = instance->graph->ev_break; + else etv = instance->graph->ev; } unsigned int count = 0; - for (unsigned int i = 0; i < instance->network->num_edges; i++) { + for (unsigned int i = 0; i < instance->graph->ne; i++) { if ((instance->fuses[i] && dual) || (!instance->fuses[i] && !dual)) { unsigned int v1 = etv[2 * i]; unsigned int v2 = etv[2 * i + 1]; @@ -74,14 +74,14 @@ cholmod_sparse *gen_adjacency(const finst *instance, bool dual, bool breakv, } } - if (!breakv && instance->network->boundary != TORUS_BOUND && !dual) { + if (!breakv && instance->graph->boundary != TORUS_BOUND && !dual) { for (unsigned int i = 0; i < 2; i++) { - for (unsigned int j = 0; j < instance->network->bound_inds[i+1] - instance->network->bound_inds[i]; j++) { - ri[2*count] = instance->network->num_verts + i; - ci[2*count] = instance->network->bound_verts[instance->network->bound_inds[i] + j]; + for (unsigned int j = 0; j < instance->graph->bound_inds[i+1] - instance->graph->bound_inds[i]; j++) { + ri[2*count] = instance->graph->nv + i; + ci[2*count] = instance->graph->bound_verts[instance->graph->bound_inds[i] + j]; ai[2*count] = 1; - ri[2*count+1] = instance->network->bound_verts[instance->network->bound_inds[i] + j]; - ci[2*count+1] = instance->network->num_verts + i; + ri[2*count+1] = instance->graph->bound_verts[instance->graph->bound_inds[i] + j]; + ci[2*count+1] = instance->graph->nv + i; ai[2*count+1] = 1; count++; } @@ -95,10 +95,10 @@ cholmod_sparse *gen_adjacency(const finst *instance, bool dual, bool breakv, return s; } -cholmod_sparse *gen_laplacian(const finst *instance, cholmod_common *c, +cholmod_sparse *gen_laplacian(const net_t *instance, cholmod_common *c, bool symmetric) { - const fnet *network = instance->network; - unsigned int num_verts = network->num_verts_break; + const graph_t *network = instance->graph; + unsigned int num_verts = network->nv_break; double *vert_coords = network->vert_coords; unsigned int num_bounds = network->num_bounds; double inf = instance->inf; @@ -147,13 +147,13 @@ cholmod_sparse *gen_laplacian(const finst *instance, cholmod_common *c, for (unsigned int i = 0; i < network->bound_inds[1]; i++) { unsigned int vv = network->bound_verts[i]; rowind[num_gverts + 2*i] = vv; - colind[num_gverts + 2*i] = network->num_verts + i; + colind[num_gverts + 2*i] = network->nv + i; acoo[num_gverts + 2*i] = -1; - rowind[num_gverts + 2*i+1] = network->num_verts + i; + rowind[num_gverts + 2*i+1] = network->nv + i; colind[num_gverts + 2*i+1] = vv; acoo[num_gverts + 2*i+1] = -1; acoo[vv]++; - acoo[network->num_verts + i]++; + acoo[network->nv + i]++; } acoo[bound_verts[0]]++; } diff --git a/src/get_conductivity.c b/src/get_conductivity.c index 7ef08a8..793987e 100644 --- a/src/get_conductivity.c +++ b/src/get_conductivity.c @@ -1,16 +1,16 @@ #include "fracture.h" -double get_conductivity(finst *inst, double *voltage, cholmod_common *c) { +double get_conductivity(net_t *inst, double *voltage, cholmod_common *c) { if (inst->voltage_bound) { double tot_cur = 0; - for (unsigned int i = 0; i < inst->network->num_spanning_edges; i++) { - unsigned int e = inst->network->spanning_edges[i]; + for (unsigned int i = 0; i < inst->graph->num_spanning_edges; i++) { + unsigned int e = inst->graph->spanning_edges[i]; if (!inst->fuses[e]) { - unsigned int v1 = inst->network->edges_to_verts[2*e]; - unsigned int v2 = inst->network->edges_to_verts[2*e+1]; - double v1y = inst->network->vert_coords[2 * v1 + 1]; - double v2y = inst->network->vert_coords[2 * v2 + 1]; + unsigned int v1 = inst->graph->ev[2*e]; + unsigned int v2 = inst->graph->ev[2*e+1]; + double v1y = inst->graph->vert_coords[2 * v1 + 1]; + double v2y = inst->graph->vert_coords[2 * v2 + 1]; unsigned int s1 = v1y < v2y ? v1 : v2; unsigned int s2 = v1y < v2y ? v2 : v1; tot_cur += voltage[s1] - voltage[s2]; @@ -19,6 +19,6 @@ double get_conductivity(finst *inst, double *voltage, cholmod_common *c) { return fabs(tot_cur); } else { - return 1 / fabs(voltage[inst->network->num_verts] - voltage[inst->network->num_verts + 1]); + return 1 / fabs(voltage[inst->graph->nv] - voltage[inst->graph->nv + 1]); } } diff --git a/src/get_current.c b/src/get_current.c index 5360054..bc786f9 100644 --- a/src/get_current.c +++ b/src/get_current.c @@ -1,7 +1,7 @@ #include "fracture.h" -double *get_voltage(const finst *instance, cholmod_common *c) { +double *get_voltage(const net_t *instance, cholmod_common *c) { cholmod_dense *b = instance->boundary_cond; cholmod_factor *factor = instance->factor; @@ -22,12 +22,12 @@ double *get_voltage(const finst *instance, cholmod_common *c) { return field; } -double *get_current(const finst *instance, cholmod_common *c) { - unsigned int num_edges = instance->network->num_edges; - unsigned int num_verts = instance->network->num_verts_break; - unsigned int num_gverts = instance->network->break_dim; - unsigned int num_bounds = instance->network->num_bounds; - cholmod_sparse *voltcurmat = instance->network->voltcurmat; +double *get_current(const net_t *instance, cholmod_common *c) { + unsigned int num_edges = instance->graph->ne; + unsigned int num_verts = instance->graph->nv_break; + unsigned int num_gverts = instance->graph->break_dim; + unsigned int num_bounds = instance->graph->num_bounds; + cholmod_sparse *voltcurmat = instance->graph->voltcurmat; double *voltages = get_voltage(instance, c); if (voltages == NULL) { @@ -63,12 +63,12 @@ double *get_current(const finst *instance, cholmod_common *c) { } -double *get_current_v(const finst *instance, double *voltages, cholmod_common *c) { - unsigned int num_edges = instance->network->num_edges; - unsigned int num_verts = instance->network->num_verts_break; - unsigned int num_gverts = instance->network->break_dim; - unsigned int num_bounds = instance->network->num_bounds; - cholmod_sparse *voltcurmat = instance->network->voltcurmat; +double *get_current_v(const net_t *instance, double *voltages, cholmod_common *c) { + unsigned int num_edges = instance->graph->ne; + unsigned int num_verts = instance->graph->nv_break; + unsigned int num_gverts = instance->graph->break_dim; + unsigned int num_bounds = instance->graph->num_bounds; + cholmod_sparse *voltcurmat = instance->graph->voltcurmat; cholmod_dense *x = CHOL_F(allocate_dense)( num_gverts, 1, num_gverts, CHOLMOD_REAL, c); diff --git a/src/get_dual_clusters.c b/src/get_dual_clusters.c index 488793f..3a51c38 100644 --- a/src/get_dual_clusters.c +++ b/src/get_dual_clusters.c @@ -1,7 +1,7 @@ #include "fracture.h" -unsigned int *get_clusters(finst *instance, cholmod_common *c) { +unsigned int *get_clusters(net_t *instance, cholmod_common *c) { cholmod_sparse *s_dual = gen_adjacency(instance, true, false, 0, c); unsigned int *dual_marks = find_components(s_dual, 0); @@ -10,16 +10,16 @@ unsigned int *get_clusters(finst *instance, cholmod_common *c) { return dual_marks; } -unsigned int *get_cluster_dist(finst *instance, cholmod_common *c) { +unsigned int *get_cluster_dist(net_t *instance, cholmod_common *c) { unsigned int *clusters = get_clusters(instance, c); unsigned int *cluster_dist = (unsigned int *)calloc( - instance->network->num_dual_verts, sizeof(unsigned int)); + instance->graph->dnv, sizeof(unsigned int)); unsigned int cur_mark = 0; while (true) { cur_mark++; unsigned int num_in_cluster = 0; - for (unsigned int i = 0; i < instance->network->num_dual_verts; i++) { + for (unsigned int i = 0; i < instance->graph->dnv; i++) { if (clusters[i] == cur_mark) num_in_cluster++; } diff --git a/src/homo_square_fracture.c b/src/homo_square_fracture.c index 9103317..e3e8ad3 100644 --- a/src/homo_square_fracture.c +++ b/src/homo_square_fracture.c @@ -126,10 +126,10 @@ int main(int argc, char *argv[]) { } - fnet *network = ini_square_network(L, boundary, false, &c); - finst *perm_instance = create_instance(network, inf, use_voltage_boundaries, true, &c); - unsigned int c_dist_size = network->num_dual_verts; - unsigned int a_dist_size = network->num_verts; + graph_t *network = ini_square_network(L, boundary, false, &c); + net_t *perm_instance = create_instance(network, inf, use_voltage_boundaries, true, &c); + unsigned int c_dist_size = network->dnv; + unsigned int a_dist_size = network->nv; // define arrays for saving cluster and avalanche distributions unsigned int *cluster_size_dist; @@ -193,9 +193,9 @@ int main(int argc, char *argv[]) { for (unsigned int i = 0; i < N; i++) { printf("\033[F\033[JFRACTURE: %0*d / %d\n", (int)log10(N) + 1, i + 1, N); - double *fuse_thres = gen_fuse_thres(network->num_edges, network->edge_coords, beta, beta_scaling_flat); - finst *instance = copy_instance(perm_instance, &c); - break_data *breaking_data = fracture_network(instance, fuse_thres, &c, cutoff); + double *fuse_thres = gen_fuse_thres(network->ne, network->edge_coords, beta, beta_scaling_flat); + net_t *instance = copy_instance(perm_instance, &c); + data_t *breaking_data = fracture_network(instance, fuse_thres, &c, cutoff); free_instance(instance, &c); free(fuse_thres); @@ -216,7 +216,7 @@ int main(int argc, char *argv[]) { breaking_data->extern_field[max_pos]; } - finst *tmp_instance = copy_instance(perm_instance, &c); + net_t *tmp_instance = copy_instance(perm_instance, &c); unsigned int av_size = 0; double cur_val = DBL_MAX; @@ -240,7 +240,7 @@ int main(int argc, char *argv[]) { if (save_conductivity) { if (!use_voltage_boundaries) { double *tmp_voltage = get_voltage(tmp_instance, &c); - conductivity[i] = 1/fabs(tmp_voltage[tmp_instance->network->num_verts + 1] - tmp_voltage[tmp_instance->network->num_verts]); + conductivity[i] = 1/fabs(tmp_voltage[tmp_instance->graph->nv + 1] - tmp_voltage[tmp_instance->graph->nv]); free(tmp_voltage); } else { conductivity[i] = breaking_data->conductivity[max_pos]; @@ -265,12 +265,12 @@ int main(int argc, char *argv[]) { } if (save_damage) { - damage[i] = ((double)max_pos) / tmp_instance->network->num_edges; + damage[i] = ((double)max_pos) / tmp_instance->graph->ne; } if (save_cluster_dist) { unsigned int *tmp_cluster_dist = get_cluster_dist(tmp_instance, &c); - for (unsigned int j = 0; j < tmp_instance->network->num_dual_verts; j++) { + for (unsigned int j = 0; j < tmp_instance->graph->dnv; j++) { cluster_size_dist[j] += tmp_cluster_dist[j]; } free(tmp_cluster_dist); @@ -278,7 +278,7 @@ int main(int argc, char *argv[]) { if (save_corr) { double *tmp_corr = get_corr(tmp_instance, dists, &c); - for (unsigned int j = 0; j < tmp_instance->network->num_dual_verts; j++) { + for (unsigned int j = 0; j < tmp_instance->graph->dnv; j++) { avg_corr[i] += tmp_corr[j] / N; } free(tmp_corr); @@ -286,27 +286,27 @@ int main(int argc, char *argv[]) { if (save_network) { FILE *net_out = fopen("network.txt", "w"); - for (unsigned int j = 0; j < network->num_verts; j++) { + for (unsigned int j = 0; j < network->nv; j++) { fprintf(net_out, "%f %f ", network->vert_coords[2 * j], - tmp_instance->network->vert_coords[2 * j + 1]); + tmp_instance->graph->vert_coords[2 * j + 1]); } fprintf(net_out, "\n"); - for (unsigned int j = 0; j < tmp_instance->network->num_edges; j++) { - fprintf(net_out, "%u %u ", tmp_instance->network->edges_to_verts[2 * j], - tmp_instance->network->edges_to_verts[2 * j + 1]); + for (unsigned int j = 0; j < tmp_instance->graph->ne; j++) { + fprintf(net_out, "%u %u ", tmp_instance->graph->ev[2 * j], + tmp_instance->graph->ev[2 * j + 1]); } fprintf(net_out, "\n"); - for (unsigned int j = 0; j < tmp_instance->network->num_dual_verts; j++) { - fprintf(net_out, "%f %f ", tmp_instance->network->dual_vert_coords[2 * j], - tmp_instance->network->dual_vert_coords[2 * j + 1]); + for (unsigned int j = 0; j < tmp_instance->graph->dnv; j++) { + fprintf(net_out, "%f %f ", tmp_instance->graph->dual_vert_coords[2 * j], + tmp_instance->graph->dual_vert_coords[2 * j + 1]); } fprintf(net_out, "\n"); - for (unsigned int j = 0; j < tmp_instance->network->num_edges; j++) { - fprintf(net_out, "%u %u ", tmp_instance->network->dual_edges_to_verts[2 * j], - tmp_instance->network->dual_edges_to_verts[2 * j + 1]); + for (unsigned int j = 0; j < tmp_instance->graph->ne; j++) { + fprintf(net_out, "%u %u ", tmp_instance->graph->dev[2 * j], + tmp_instance->graph->dev[2 * j + 1]); } fprintf(net_out, "\n"); - for (unsigned int j = 0; j < tmp_instance->network->num_edges; j++) { + for (unsigned int j = 0; j < tmp_instance->graph->ne; j++) { fprintf(net_out, "%d ", tmp_instance->fuses[j]); } fclose(net_out); @@ -328,7 +328,7 @@ int main(int argc, char *argv[]) { printf("\033[F\033[JFRACTURE: COMPLETE\n"); free_instance(perm_instance, &c); - free_fnet(network, &c); + free_net(network, &c); if (save_cluster_dist) { FILE *cluster_out = fopen(c_filename, "w"); diff --git a/src/homo_voronoi_fracture.c b/src/homo_voronoi_fracture.c index 26ceed4..6171480 100644 --- a/src/homo_voronoi_fracture.c +++ b/src/homo_voronoi_fracture.c @@ -211,11 +211,11 @@ int main(int argc, char *argv[]) { for (uint32_t i = 0; i < N; i++) { printf("\033[F\033[JFRACTURE: %0*d / %d\n", (uint8_t)log10(N) + 1, i + 1, N); - fnet *network = ini_voronoi_network(L, boundary, use_dual, genfunc_hyperuniform, &c); - finst *perm_instance = create_instance(network, inf, use_voltage_boundaries, true, &c); - double *fuse_thres = gen_fuse_thres(network->num_edges, network->edge_coords, beta, beta_scaling_flat); - finst *instance = copy_instance(perm_instance, &c); - break_data *breaking_data = fracture_network(instance, fuse_thres, &c, cutoff); + graph_t *network = ini_voronoi_network(L, boundary, use_dual, genfunc_hyperuniform, &c); + net_t *perm_instance = create_instance(network, inf, use_voltage_boundaries, true, &c); + double *fuse_thres = gen_fuse_thres(network->ne, network->edge_coords, beta, beta_scaling_flat); + net_t *instance = copy_instance(perm_instance, &c); + data_t *breaking_data = fracture_network(instance, fuse_thres, &c, cutoff); free_instance(instance, &c); free(fuse_thres); @@ -236,7 +236,7 @@ int main(int argc, char *argv[]) { breaking_data->extern_field[max_pos]; } - finst *tmp_instance = copy_instance(perm_instance, &c); + net_t *tmp_instance = copy_instance(perm_instance, &c); uint_t av_size = 0; double cur_val = 0; @@ -260,7 +260,7 @@ int main(int argc, char *argv[]) { if (save_conductivity) { if (!use_voltage_boundaries) { double *tmp_voltage = get_voltage(tmp_instance, &c); - conductivity[i] = 1/fabs(tmp_voltage[tmp_instance->network->num_verts + 1] - tmp_voltage[tmp_instance->network->num_verts]); + conductivity[i] = 1/fabs(tmp_voltage[tmp_instance->graph->nv + 1] - tmp_voltage[tmp_instance->graph->nv]); free(tmp_voltage); } else { conductivity[i] = breaking_data->conductivity[max_pos]; @@ -290,7 +290,7 @@ int main(int argc, char *argv[]) { if (save_cluster_dist) { uint_t *tmp_cluster_dist = get_cluster_dist(tmp_instance, &c); - for (uint_t j = 0; j < tmp_instance->network->num_dual_verts; j++) { + for (uint_t j = 0; j < tmp_instance->graph->dnv; j++) { cluster_size_dist[j] += tmp_cluster_dist[j]; } free(tmp_cluster_dist); @@ -298,27 +298,27 @@ int main(int argc, char *argv[]) { if (save_network) { FILE *net_out = fopen("network.txt", "w"); - for (uint_t j = 0; j < network->num_verts; j++) { + for (uint_t j = 0; j < network->nv; j++) { fprintf(net_out, "%f %f ", network->vert_coords[2 * j], - tmp_instance->network->vert_coords[2 * j + 1]); + tmp_instance->graph->vert_coords[2 * j + 1]); } fprintf(net_out, "\n"); - for (uint_t j = 0; j < tmp_instance->network->num_edges; j++) { - fprintf(net_out, "%u %u ", tmp_instance->network->edges_to_verts[2 * j], - tmp_instance->network->edges_to_verts[2 * j + 1]); + for (uint_t j = 0; j < tmp_instance->graph->ne; j++) { + fprintf(net_out, "%u %u ", tmp_instance->graph->ev[2 * j], + tmp_instance->graph->ev[2 * j + 1]); } fprintf(net_out, "\n"); - for (uint_t j = 0; j < tmp_instance->network->num_dual_verts; j++) { - fprintf(net_out, "%f %f ", tmp_instance->network->dual_vert_coords[2 * j], - tmp_instance->network->dual_vert_coords[2 * j + 1]); + for (uint_t j = 0; j < tmp_instance->graph->dnv; j++) { + fprintf(net_out, "%f %f ", tmp_instance->graph->dual_vert_coords[2 * j], + tmp_instance->graph->dual_vert_coords[2 * j + 1]); } fprintf(net_out, "\n"); - for (uint_t j = 0; j < tmp_instance->network->num_edges; j++) { - fprintf(net_out, "%u %u ", tmp_instance->network->dual_edges_to_verts[2 * j], - tmp_instance->network->dual_edges_to_verts[2 * j + 1]); + for (uint_t j = 0; j < tmp_instance->graph->ne; j++) { + fprintf(net_out, "%u %u ", tmp_instance->graph->dev[2 * j], + tmp_instance->graph->dev[2 * j + 1]); } fprintf(net_out, "\n"); - for (uint_t j = 0; j < tmp_instance->network->num_edges; j++) { + for (uint_t j = 0; j < tmp_instance->graph->ne; j++) { fprintf(net_out, "%d ", tmp_instance->fuses[j]); } fclose(net_out); @@ -326,7 +326,7 @@ int main(int argc, char *argv[]) { free_instance(tmp_instance, &c); free_instance(perm_instance, &c); - free_fnet(network, &c); + free_net(network, &c); if (include_breaking) { for (uint_t j = 0; j < breaking_data->num_broken; j++) { diff --git a/src/ini_network.c b/src/ini_network.c index d80f43b..ebfea76 100644 --- a/src/ini_network.c +++ b/src/ini_network.c @@ -98,20 +98,20 @@ unsigned int *get_verts_to_edges(unsigned int num_verts, unsigned int num_edges, return output; } -fnet *ini_square_network(unsigned int width, bound_t boundary, bool side_bounds, +graph_t *ini_square_network(unsigned int width, bound_t boundary, bool side_bounds, cholmod_common *c) { - fnet *network = (fnet *)calloc(1, sizeof(fnet)); + graph_t *network = (graph_t *)calloc(1, sizeof(graph_t)); network->boundary = boundary; bool periodic = (boundary == CYLINDER_BOUND) || (boundary == TORUS_BOUND) ? true : false; - network->num_edges = pow(width, 2); + network->ne = pow(width, 2); if (boundary == CYLINDER_BOUND) { assert(width % 2 == 0); assert(!side_bounds); - network->num_verts = (width / 2) * (width + 1); - network->num_verts_break = (width / 2) * (width + 1); - network->num_dual_verts = (width / 2 + 1) * (width / 2) + pow(width / 2, 2); + network->nv = (width / 2) * (width + 1); + network->nv_break = (width / 2) * (width + 1); + network->dnv = (width / 2 + 1) * (width / 2) + pow(width / 2, 2); network->num_bounds = 2; network->bound_inds = (unsigned int *)malloc((network->num_bounds + 1) * sizeof(unsigned int)); @@ -119,11 +119,11 @@ fnet *ini_square_network(unsigned int width, bound_t boundary, bool side_bounds, network->bound_inds[1] = width / 2; network->bound_inds[2] = width; network->bound_verts = (unsigned int *)calloc(width, sizeof(unsigned int)); - network->break_dim = network->num_verts + network->num_bounds; + network->break_dim = network->nv + network->num_bounds; } else if (boundary == FREE_BOUND) { - network->num_verts = 2 * ((width + 1) / 2) * (width / 2 + 1); - network->num_verts_break = 2 * ((width + 1) / 2) * (width / 2 + 1); - network->num_dual_verts = pow(width / 2 + 1, 2) + pow((width + 1) / 2, 2); + network->nv = 2 * ((width + 1) / 2) * (width / 2 + 1); + network->nv_break = 2 * ((width + 1) / 2) * (width / 2 + 1); + network->dnv = pow(width / 2 + 1, 2) + pow((width + 1) / 2, 2); if (side_bounds) network->num_bounds = 4; else @@ -148,44 +148,44 @@ fnet *ini_square_network(unsigned int width, bound_t boundary, bool side_bounds, } } } - network->break_dim = network->num_verts + network->num_bounds; + network->break_dim = network->nv + network->num_bounds; } else if (boundary == TORUS_BOUND) { - network->num_verts = (width / 2) * (width + 1) - (width / 2); - network->num_verts_break = (width / 2) * (width + 1); - network->num_dual_verts = (width / 2 + 1) * (width / 2) + pow(width / 2, 2) - (width / 2); + network->nv = (width / 2) * (width + 1) - (width / 2); + network->nv_break = (width / 2) * (width + 1); + network->dnv = (width / 2 + 1) * (width / 2) + pow(width / 2, 2) - (width / 2); network->num_bounds = 1; network->bound_inds = (unsigned int *)malloc((network->num_bounds + 1) * sizeof(unsigned int)); network->bound_inds[0] = 0; network->bound_inds[1] = width / 2; network->bound_verts = (unsigned int *)calloc(width / 2, sizeof(unsigned int)); - network->break_dim = network->num_verts_break; + network->break_dim = network->nv_break; } if (boundary != TORUS_BOUND) { for (unsigned int i = 0; i < (width + 1) / 2; i++) { network->bound_verts[i] = i; - network->bound_verts[(width + 1) / 2 + i] = network->num_verts - 1 - i; + network->bound_verts[(width + 1) / 2 + i] = network->nv - 1 - i; } } else { for (unsigned int i = 0; i < width / 2; i++) { network->bound_verts[i] = i; } } - network->edges_to_verts_break = - (unsigned int *)calloc(2 * network->num_edges, sizeof(unsigned int)); - network->edges_to_verts = - (unsigned int *)calloc(2 * network->num_edges, sizeof(unsigned int)); - for (unsigned int i = 0; i < network->num_edges; i++) { - network->edges_to_verts_break[2 * i] = edge_to_verts(width, periodic, i, 1); - network->edges_to_verts_break[2 * i + 1] = edge_to_verts(width, periodic, i, 0); - network->edges_to_verts[2 * i] = network->edges_to_verts_break[2 * i] % network->num_verts; - network->edges_to_verts[2 * i + 1] = network->edges_to_verts_break[2 * i + 1] % network->num_verts; + network->ev_break = + (unsigned int *)calloc(2 * network->ne, sizeof(unsigned int)); + network->ev = + (unsigned int *)calloc(2 * network->ne, sizeof(unsigned int)); + for (unsigned int i = 0; i < network->ne; i++) { + network->ev_break[2 * i] = edge_to_verts(width, periodic, i, 1); + network->ev_break[2 * i + 1] = edge_to_verts(width, periodic, i, 0); + network->ev[2 * i] = network->ev_break[2 * i] % network->nv; + network->ev[2 * i + 1] = network->ev_break[2 * i + 1] % network->nv; } - network->verts_to_edges_ind = - (unsigned int *)calloc(network->num_verts + 1, sizeof(unsigned int)); - network->verts_to_edges_ind[0] = 0; + network->vei = + (unsigned int *)calloc(network->nv + 1, sizeof(unsigned int)); + network->vei[0] = 0; unsigned int pos1 = 0; - for (unsigned int i = 0; i < network->num_verts; i++) { + for (unsigned int i = 0; i < network->nv; i++) { bool in_bound = false; for (unsigned int j = 0; j < network->num_bounds; j++) { for (unsigned int k = 0; @@ -201,18 +201,18 @@ fnet *ini_square_network(unsigned int width, bound_t boundary, bool side_bounds, else pos1 += 4; - network->verts_to_edges_ind[i + 1] = pos1; + network->vei[i + 1] = pos1; } - network->verts_to_edges = (unsigned int *)calloc( - network->verts_to_edges_ind[network->num_verts], sizeof(unsigned int)); + network->ve = (unsigned int *)calloc( + network->vei[network->nv], sizeof(unsigned int)); unsigned int *vert_counts = - (unsigned int *)calloc(network->num_verts, sizeof(unsigned int)); - for (unsigned int i = 0; i < network->num_edges; i++) { - unsigned int v0 = network->edges_to_verts[2 * i]; - unsigned int v1 = network->edges_to_verts[2 * i + 1]; - network->verts_to_edges[network->verts_to_edges_ind[v0] + vert_counts[v0]] = + (unsigned int *)calloc(network->nv, sizeof(unsigned int)); + for (unsigned int i = 0; i < network->ne; i++) { + unsigned int v0 = network->ev[2 * i]; + unsigned int v1 = network->ev[2 * i + 1]; + network->ve[network->vei[v0] + vert_counts[v0]] = i; - network->verts_to_edges[network->verts_to_edges_ind[v1] + vert_counts[v1]] = + network->ve[network->vei[v1] + vert_counts[v1]] = i; vert_counts[v0]++; vert_counts[v1]++; @@ -220,8 +220,8 @@ fnet *ini_square_network(unsigned int width, bound_t boundary, bool side_bounds, free(vert_counts); network->vert_coords = - (double *)malloc(2 * network->num_verts * sizeof(double)); - for (unsigned int i = 0; i < network->num_verts; i++) { + (double *)malloc(2 * network->nv * sizeof(double)); + for (unsigned int i = 0; i < network->nv; i++) { if (!periodic) { network->vert_coords[2 * i] = ((double)((2 * i + 1) / (width + 1)))/width; network->vert_coords[2 * i + 1] = ((double)((2 * i + 1) % (width + 1)))/width; @@ -233,36 +233,36 @@ fnet *ini_square_network(unsigned int width, bound_t boundary, bool side_bounds, network->L = width; network->edge_coords = get_edge_coords( - network->num_edges, network->vert_coords, network->edges_to_verts); - - network->dual_edges_to_verts = - (unsigned int *)malloc(2 * network->num_edges * sizeof(unsigned int)); - for (unsigned int i = 0; i < network->num_edges; i++) { - network->dual_edges_to_verts[2 * i] = - dual_edge_to_verts(width, periodic, i, 0) % network->num_dual_verts; - network->dual_edges_to_verts[2 * i + 1] = - dual_edge_to_verts(width, periodic, i, 1) % network->num_dual_verts; + network->ne, network->vert_coords, network->ev); + + network->dev = + (unsigned int *)malloc(2 * network->ne * sizeof(unsigned int)); + for (unsigned int i = 0; i < network->ne; i++) { + network->dev[2 * i] = + dual_edge_to_verts(width, periodic, i, 0) % network->dnv; + network->dev[2 * i + 1] = + dual_edge_to_verts(width, periodic, i, 1) % network->dnv; } network->dual_vert_coords = - (double *)malloc(2 * network->num_dual_verts * sizeof(double)); - for (unsigned int i = 0; i < network->num_dual_verts; i++) { + (double *)malloc(2 * network->dnv * sizeof(double)); + for (unsigned int i = 0; i < network->dnv; i++) { network->dual_vert_coords[2 * i] = 2*dual_vert_to_coord(width, periodic, i, 0); network->dual_vert_coords[2 * i + 1] = 2*dual_vert_to_coord(width, periodic, i, 1); } - network->voltcurmat = gen_voltcurmat(network->num_edges, + network->voltcurmat = gen_voltcurmat(network->ne, network->break_dim, - network->edges_to_verts_break, c); + network->ev_break, c); - network->dual_verts_to_edges_ind = - get_verts_to_edges_ind(network->num_dual_verts, network->num_edges, - network->dual_edges_to_verts); - network->dual_verts_to_edges = get_verts_to_edges( - network->num_dual_verts, network->num_edges, network->dual_edges_to_verts, - network->dual_verts_to_edges_ind); - network->spanning_edges = get_spanning_edges(network->num_edges, network->edges_to_verts_break, network->vert_coords, 0.51, &(network->num_spanning_edges)); + network->dvei = + get_verts_to_edges_ind(network->dnv, network->ne, + network->dev); + network->dve = get_verts_to_edges( + network->dnv, network->ne, network->dev, + network->dvei); + network->spanning_edges = get_spanning_edges(network->ne, network->ev_break, network->vert_coords, 0.51, &(network->num_spanning_edges)); return network; } @@ -304,10 +304,10 @@ unsigned int *get_voro_dual_edges(unsigned int num_edges, return dual_edges; } -fnet *ini_voronoi_network(unsigned int L, bound_t boundary, bool use_dual, +graph_t *ini_voronoi_network(unsigned int L, bound_t boundary, bool use_dual, double *(*genfunc)(unsigned int, bound_t, gsl_rng *, unsigned int *), cholmod_common *c) { - fnet *network = (fnet *)calloc(1, sizeof(fnet)); + graph_t *network = (graph_t *)calloc(1, sizeof(graph_t)); // generate the dual lattice double *lattice; @@ -459,10 +459,10 @@ fnet *ini_voronoi_network(unsigned int L, bound_t boundary, bool use_dual, free(tmp_edges); free(tmp_dual_edges); num_bounds = 2; - network->edges_to_verts_break = edges; - network->edges_to_verts = edges; - network->num_verts_break = num_verts; - network->num_verts = num_verts; + network->ev_break = edges; + network->ev = edges; + network->nv_break = num_verts; + network->nv = num_verts; network->break_dim = num_verts + num_bounds; break; } @@ -526,10 +526,10 @@ fnet *ini_voronoi_network(unsigned int L, bound_t boundary, bool use_dual, free(bound_top); free(bound_b); free(tmp_edges); free(tmp_dual_edges); - network->edges_to_verts_break = edges; - network->edges_to_verts = edges; - network->num_verts_break = num_verts; - network->num_verts = num_verts; + network->ev_break = edges; + network->ev = edges; + network->nv_break = num_verts; + network->nv = num_verts; network->break_dim = num_verts + num_bounds; break; } @@ -596,10 +596,10 @@ fnet *ini_voronoi_network(unsigned int L, bound_t boundary, bool use_dual, free(tmp_vert_coords); free(bound_top); free(edge_change); - network->num_verts_break = num_verts; - network->num_verts = tmp_num_verts; - network->edges_to_verts_break = edges; - network->edges_to_verts = tmp_edges; + network->nv_break = num_verts; + network->nv = tmp_num_verts; + network->ev_break = edges; + network->ev = tmp_edges; network->break_dim = num_verts; break; } @@ -618,10 +618,10 @@ fnet *ini_voronoi_network(unsigned int L, bound_t boundary, bool use_dual, edges = tmp_edges; dual_edges = tmp_dual_edges; vert_coords = tmp_vert_coords; - network->num_verts_break = num_verts; - network->num_verts = num_verts; - network->edges_to_verts_break = edges; - network->edges_to_verts = edges; + network->nv_break = num_verts; + network->nv = num_verts; + network->ev_break = edges; + network->ev = edges; network->break_dim = num_verts + 2; } } @@ -630,38 +630,38 @@ fnet *ini_voronoi_network(unsigned int L, bound_t boundary, bool use_dual, network->num_bounds = num_bounds; network->bound_inds = bound_inds; network->bound_verts = bound_verts; - network->num_edges = num_edges; - network->dual_edges_to_verts = dual_edges; + network->ne = num_edges; + network->dev = dual_edges; network->vert_coords = vert_coords; - network->verts_to_edges_ind = get_verts_to_edges_ind( - network->num_verts, network->num_edges, network->edges_to_verts); - network->verts_to_edges = - get_verts_to_edges(network->num_verts, network->num_edges, - network->edges_to_verts, network->verts_to_edges_ind); + network->vei = get_verts_to_edges_ind( + network->nv, network->ne, network->ev); + network->ve = + get_verts_to_edges(network->nv, network->ne, + network->ev, network->vei); network->L = 1; network->edge_coords = get_edge_coords( - network->num_edges, network->vert_coords, network->edges_to_verts); + network->ne, network->vert_coords, network->ev); free(tmp_tris); network->dual_vert_coords = lattice; - network->num_dual_verts = num; + network->dnv = num; - network->voltcurmat = gen_voltcurmat(network->num_edges, + network->voltcurmat = gen_voltcurmat(network->ne, network->break_dim, - network->edges_to_verts_break, c); + network->ev_break, c); - network->dual_verts_to_edges_ind = - get_verts_to_edges_ind(network->num_dual_verts, network->num_edges, - network->dual_edges_to_verts); - network->dual_verts_to_edges = get_verts_to_edges( - network->num_dual_verts, network->num_edges, network->dual_edges_to_verts, - network->dual_verts_to_edges_ind); + network->dvei = + get_verts_to_edges_ind(network->dnv, network->ne, + network->dev); + network->dve = get_verts_to_edges( + network->dnv, network->ne, network->dev, + network->dvei); - network->spanning_edges = get_spanning_edges(network->num_edges, network->edges_to_verts_break, network->vert_coords, 0.5, &(network->num_spanning_edges)); + network->spanning_edges = get_spanning_edges(network->ne, network->ev_break, network->vert_coords, 0.5, &(network->num_spanning_edges)); return network; } diff --git a/src/instance.c b/src/instance.c index cc33591..bb1ac8c 100644 --- a/src/instance.c +++ b/src/instance.c @@ -1,14 +1,14 @@ #include "fracture.h" -finst *create_instance(fnet *network, double inf, bool voltage_bound, +net_t *create_instance(graph_t *network, double inf, bool voltage_bound, bool startnow, cholmod_common *c) { - finst *instance = (finst *)calloc(1, sizeof(finst)); + net_t *instance = (net_t *)calloc(1, sizeof(net_t)); assert(instance != NULL); - instance->network = network; - instance->num_remaining_edges = network->num_edges; - instance->fuses = (bool *)calloc(network->num_edges, sizeof(bool)); + instance->graph = network; + instance->num_remaining_edges = network->ne; + instance->fuses = (bool *)calloc(network->ne, sizeof(bool)); assert(instance->fuses != NULL); instance->inf = inf; instance->voltage_bound = voltage_bound; @@ -17,7 +17,7 @@ finst *create_instance(fnet *network, double inf, bool voltage_bound, if (network->boundary == TORUS_BOUND) { for (unsigned int i = 0; i < network->bound_inds[1]; i++) { ((double *)instance->boundary_cond->x)[network->bound_verts[i]] = 1; - ((double *)instance->boundary_cond->x)[network->num_verts + i] = -1; + ((double *)instance->boundary_cond->x)[network->nv + i] = -1; } ((double *)instance->boundary_cond->x)[network->bound_verts[0]] = 1; } else if (network->boundary == EMBEDDED_BOUND) { @@ -32,8 +32,8 @@ finst *create_instance(fnet *network, double inf, bool voltage_bound, } } else { ((double *)instance->boundary_cond->x)[0] = 1; - ((double *)instance->boundary_cond->x)[network->num_verts] = 1; - ((double *)instance->boundary_cond->x)[network->num_verts + 1] = -1; + ((double *)instance->boundary_cond->x)[network->nv] = 1; + ((double *)instance->boundary_cond->x)[network->nv + 1] = -1; } } @@ -48,20 +48,20 @@ finst *create_instance(fnet *network, double inf, bool voltage_bound, } instance->marks = (unsigned int *)malloc( - (instance->network->break_dim) * + (instance->graph->break_dim) * sizeof(unsigned int)); instance->dual_marks = (unsigned int *)malloc( - (instance->network->num_dual_verts) * + (instance->graph->dnv) * sizeof(unsigned int)); assert(instance->marks != NULL); for (unsigned int i = 0; - i < (instance->network->break_dim); + i < (instance->graph->break_dim); i++) { instance->marks[i] = 1; } for (unsigned int i = 0; - i < (instance->network->num_dual_verts); + i < (instance->graph->dnv); i++) { instance->dual_marks[i] = i+1; } @@ -70,29 +70,29 @@ finst *create_instance(fnet *network, double inf, bool voltage_bound, return instance; } -void finish_instance(finst *instance, cholmod_common *c) { +void finish_instance(net_t *instance, cholmod_common *c) { cholmod_sparse *laplacian = gen_laplacian(instance, c, true); instance->factor = CHOL_F(analyze)(laplacian, c); CHOL_F(factorize)(laplacian, instance->factor, c); CHOL_F(free_sparse)(&laplacian, c); } -finst *copy_instance(const finst *instance, cholmod_common *c) { - finst *instance_copy = (finst *)calloc(1, sizeof(finst)); - memcpy(instance_copy, instance, sizeof(finst)); +net_t *copy_instance(const net_t *instance, cholmod_common *c) { + net_t *instance_copy = (net_t *)calloc(1, sizeof(net_t)); + memcpy(instance_copy, instance, sizeof(net_t)); - size_t fuses_size = (instance->network)->num_edges * sizeof(bool); + size_t fuses_size = (instance->graph)->ne * sizeof(bool); instance_copy->fuses = (bool *)malloc(fuses_size); memcpy(instance_copy->fuses, instance->fuses, fuses_size); size_t marks_size = - (instance->network->break_dim) * + (instance->graph->break_dim) * sizeof(unsigned int); instance_copy->marks = (unsigned int *)malloc(marks_size); memcpy(instance_copy->marks, instance->marks, marks_size); size_t dual_marks_size = - (instance->network->num_dual_verts) * + (instance->graph->dnv) * sizeof(unsigned int); instance_copy->dual_marks = (unsigned int *)malloc(dual_marks_size); memcpy(instance_copy->dual_marks, instance->dual_marks, dual_marks_size); @@ -104,7 +104,7 @@ finst *copy_instance(const finst *instance, cholmod_common *c) { return instance_copy; } -void free_instance(finst *instance, cholmod_common *c) { +void free_instance(net_t *instance, cholmod_common *c) { free(instance->fuses); CHOL_F(free_dense)(&(instance->boundary_cond), c); CHOL_F(free_sparse)(&(instance->adjacency), c); @@ -114,7 +114,7 @@ void free_instance(finst *instance, cholmod_common *c) { free(instance); } -bool check_instance(const finst *instance, cholmod_common *c) { +bool check_instance(const net_t *instance, cholmod_common *c) { assert(instance != NULL); assert(instance->fuses != NULL); assert(CHOL_F(check_dense)(instance->boundary_cond, c)); diff --git a/src/update_boundary.c b/src/update_boundary.c index 3d2a086..6bc4fca 100644 --- a/src/update_boundary.c +++ b/src/update_boundary.c @@ -1,10 +1,10 @@ #include "fracture.h" -void update_boundary(finst *instance, const double *avg_field) { - int size = instance->network->num_edges; +void update_boundary(net_t *instance, const double *avg_field) { + int size = instance->graph->ne; int width = sqrt(size); - int num_verts = instance->network->num_verts; + int num_verts = instance->graph->nv; double *boundary = (double *)instance->boundary_cond->x; boundary[num_verts] = 0; diff --git a/src/voronoi_bound_ini.c b/src/voronoi_bound_ini.c index d201093..0b65ef5 100644 --- a/src/voronoi_bound_ini.c +++ b/src/voronoi_bound_ini.c @@ -15,7 +15,7 @@ double u_y(double x, double y) { return sqrt(r) * sin(th / 2); } -void voronoi_bound_ini(finst *instance, uint_t L, double crack_len) { +void voronoi_bound_ini(net_t *instance, uint_t L, double crack_len) { double *bound = (double *)instance->boundary_cond->x; for (uint_t i = 0; i < L / 2; i++) { double x1, y1, x2, y2, x3, y3, x4, y4; -- cgit v1.2.3-70-g09d2