summaryrefslogtreecommitdiff
path: root/src/fracture.h
blob: b1114fb4dde456ffe4ea1f5e83d436e2199bafb3 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123

#pragma once

#include <assert.h>
#include <cholmod.h>
#include <float.h>
#include <getopt.h>
#include <gsl/gsl_math.h>
#include <gsl/gsl_randist.h>
#include <gsl/gsl_rng.h>
#include <gsl/gsl_sf_erf.h>
#include <gsl/gsl_sf_exp.h>
#include <gsl/gsl_sf_log.h>
#include <inttypes.h>
#include <math.h>
#include <omp.h>
#include <stdbool.h>
#include <stdint.h>
#include <stdio.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <unistd.h>

#include <jst/graph.h>
#include <jst/rand.h>


// these defs allow me to switch to long int cholmod in a sitch
#define int_t int
#define uint_t unsigned int
#define CINT_MAX INT_MAX
#define CHOL_F(x) cholmod_##x

#define GSL_RAND_GEN gsl_rng_mt19937

typedef struct {
	const graph_t *graph;
	bool *fuses;
	long double *thres;
	double inf;
	cholmod_dense *boundary_cond;
	cholmod_factor *factor;
	bool voltage_bound;
	uint_t num_broken;
	uint_t dim;
	uint_t nep;
	uint_t *evp;
	cholmod_sparse *voltcurmat;
} net_t;

typedef struct {
	uint_t num_broken;
	uint_t *break_list;
	double *conductivity;
	long double *extern_field;
} data_t;

intptr_t *run_voronoi(uint_t num_coords, double *coords, bool periodic, double xmin, double xmax, double ymin, double ymax);

cholmod_sparse *gen_adjacency(const net_t *net, bool dual, bool use_gp, bool symmetric, cholmod_common *c);

cholmod_sparse *gen_laplacian(const net_t *net, cholmod_common *c);

int edge_to_verts(uint_t width, bool periodic, uint_t edge,
									bool index);

int dual_edge_to_verts(uint_t width, bool periodic, uint_t edge,
											 bool index);

double dual_vert_to_coord(uint_t width, bool periodic, uint_t vert,
													bool index);

void factor_update(cholmod_factor *factor, uint_t v1, uint_t v2, cholmod_common *c);
void factor_update2(cholmod_factor *factor, uint_t v1, cholmod_common *c);

void net_notch(net_t *net, double notch_len, cholmod_common *c);
data_t *net_fracture(net_t *net, cholmod_common *c, double cutoff);
double *net_voltages(const net_t *net, cholmod_common *c);
double *net_currents(const net_t *net, const double *voltages, cholmod_common *c);
double net_conductivity(const net_t *net, const double *voltages);

void update_boundary(net_t *instance, const double *avg_field);

FILE *get_file(const char *prefix, uint_t width, uint_t crack,
							 double beta, uint_t iter, uint_t num_iter,
							 uint_t num, bool read);

double update_beta(double beta, uint_t width, const double *stress,
									 const double *damage, double bound_total);

cholmod_sparse *gen_voltcurmat(uint_t num_edges, uint_t num_verts,
															 uint_t *edges_to_verts, cholmod_common *c);

net_t *net_copy(const net_t *net, cholmod_common *c);

void net_free(net_t *instance, cholmod_common *c);

net_t *net_create(const graph_t *g, double inf, double beta, double notch_len, bool vb, cholmod_common *c);

bool break_edge(net_t *instance, uint_t edge, cholmod_common *c);

components_t *get_clusters(net_t *instance);

uint_t *get_cluster_dist(net_t *instance);

void randfunc_flat(gsl_rng *r, double *x, double *y);
void randfunc_gaus(gsl_rng *r, double *x, double *y);

double *get_corr(net_t *instance, uint_t **dists, cholmod_common *c);

double *bin_values(graph_t *network, uint_t width, double *values);

cholmod_dense *bound_set(const graph_t *g, bool vb, double notch_len, cholmod_common *c);

data_t *data_create(uint_t num_edges);
void data_free(data_t *data);
void data_update(data_t *data, uint_t last_broke, long double strength, double conductivity);

long double rand_dist_pow(const gsl_rng *r, double beta);

bool is_in(uint_t len, uint_t *list, uint_t element);