static unsigned char * rasterize( VoxelsIOPlugin * plugin, MeshModel & m )
{
size_t voxels_num = voxmap_size.X() * voxmap_size.Y() * voxmap_size.Z();
unsigned char * voxels = new unsigned char[ voxels_num * voxel_size ];
if( !voxels )
return NULL;
memset( voxels, 0, voxels_num * voxel_size );
vcg::Point3f
diff( vcg::Point3f( voxmap_size.X() / 2.f,
voxmap_size.Y() / 2.f,
voxmap_size.Z() / 2.f ) - m.cm.bbox.Center() ),
min( floorf( m.cm.bbox.min.X() ),
floorf( m.cm.bbox.min.Y() ),
floorf( m.cm.bbox.min.Z() ) ),
max( ceilf( m.cm.bbox.max.X() ),
ceilf( m.cm.bbox.max.Y() ),
ceilf( m.cm.bbox.max.Z() ) );
MeshEP mesh;
make_mesh( m, &mesh );
TriMeshGrid grid;
grid.Set( mesh.face.begin(), mesh.face.end() );
int slice_size = voxmap_size.Y() * voxmap_size.X();
TriMeshGrid::CoordType xyz;
for( xyz.Z() = min.Z() + .5f; xyz.Z() < max.Z(); xyz.Z() += 1.f )
{
for( xyz.Y() = min.Y() + .5f; xyz.Y() < max.Y(); xyz.Y() += 1.f )
for( xyz.X() = min.X() + .5f; xyz.X() < max.X(); xyz.X() += 1.f )
if( vcg::tri::Inside< TriMeshGrid, MeshEP >::Is_Inside( mesh,
grid,
xyz ) )
{
qint64 i =
static_cast<int>(xyz.Z() + diff.Z()) * slice_size +
static_cast<int>(xyz.Y() + diff.Y()) * voxmap_size.X() +
static_cast<int>(xyz.X() + diff.X());
memset( voxels + i * voxel_size, UCHAR_MAX, voxel_size );
}
std::cout << xyz.Z() << "/" << max.Z() << std::endl;
plugin->Log( "%f/%f", xyz.Z(), max.Z() );
}
return voxels;
}
int main(int argc, char** argv)
{
GLFWwindow window;
int ch, iter;
double dt;
double last_update_time;
int frame;
float f;
GLint uloc_modelview;
GLint uloc_project;
char* vertex_shader_path = NULL;
char* fragment_shader_path = NULL;
char* vertex_shader_src = NULL;
char* fragment_shader_src = NULL;
GLuint shader_program;
while ((ch = getopt(argc, argv, "f:v:h")) != -1)
{
switch (ch)
{
case 'f':
fragment_shader_path = optarg;
break;
case 'v':
vertex_shader_path = optarg;
break;
case 'h':
usage();
exit(EXIT_SUCCESS);
default:
usage();
exit(EXIT_FAILURE);
}
}
if (fragment_shader_path)
{
vertex_shader_src = read_file_content(fragment_shader_path);
if (!fragment_shader_src)
{
fprintf(stderr,
"ERROR: unable to load fragment shader from '%s'\n",
fragment_shader_path);
exit(EXIT_FAILURE);
}
}
if (vertex_shader_path)
{
vertex_shader_src = read_file_content(vertex_shader_path);
if (!vertex_shader_src)
{
fprintf(stderr,
"ERROR: unable to load vertex shader from '%s'\n",
fragment_shader_path);
exit(EXIT_FAILURE);
}
}
if (!glfwInit())
{
fprintf(stderr, "ERROR: Unable to initialize GLFW\n");
usage();
free(vertex_shader_src);
free(fragment_shader_src);
exit(EXIT_FAILURE);
}
glfwOpenWindowHint(GLFW_WINDOW_RESIZABLE, GL_FALSE);
glfwOpenWindowHint(GLFW_OPENGL_VERSION_MAJOR, 3);
glfwOpenWindowHint(GLFW_OPENGL_VERSION_MINOR, 2);
glfwOpenWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
glfwOpenWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_FALSE);
window = glfwOpenWindow(800, 600, GLFW_WINDOWED, "GLFW OpenGL3 Heightmap demo", NULL);
if (! window )
{
fprintf(stderr, "ERROR: Unable to create the OpenGL context and associated window\n");
usage();
free(vertex_shader_src);
free(fragment_shader_src);
exit(EXIT_FAILURE);
}
glfwSetWindowCloseCallback(window_close_callback);
glfwSetKeyCallback(key_callback);
/* Register events callback */
if (GL_TRUE != init_opengl())
{
fprintf(stderr, "ERROR: unable to resolve OpenGL function pointers\n");
free(vertex_shader_src);
free(fragment_shader_src);
exit(EXIT_FAILURE);
}
/* Prepare opengl resources for rendering */
shader_program = make_shader_program(vertex_shader_src , fragment_shader_src);
free(vertex_shader_src);
free(fragment_shader_src);
if (shader_program == 0u)
{
fprintf(stderr, "ERROR: during creation of the shader program\n");
usage();
exit(EXIT_FAILURE);
}
pglUseProgram(shader_program);
uloc_project = pglGetUniformLocation(shader_program, "project");
uloc_modelview = pglGetUniformLocation(shader_program, "modelview");
/* Compute the projection matrix */
f = 1.0f / tanf(view_angle / 2.0f);
projection_matrix[0] = f / aspect_ratio;
projection_matrix[5] = f;
projection_matrix[10] = (z_far + z_near)/ (z_near - z_far);
projection_matrix[11] = -1.0f;
projection_matrix[14] = 2.0f * (z_far * z_near) / (z_near - z_far);
pglUniformMatrix4fv(uloc_project, 1, GL_FALSE, projection_matrix);
/* Set the camera position */
modelview_matrix[12] = -5.0f;
modelview_matrix[13] = -5.0f;
modelview_matrix[14] = -20.0f;
pglUniformMatrix4fv(uloc_modelview, 1, GL_FALSE, modelview_matrix);
/* Create mesh data */
init_map();
make_mesh(shader_program);
/* Create vao + vbo to store the mesh */
/* Create the vbo to store all the information for the grid and the height */
/* setup the scene ready for rendering */
glViewport(0, 0, 800, 600);
glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
/* main loop */
frame = 0;
iter = 0;
dt = last_update_time = glfwGetTime();
while (running)
{
++frame;
/* render the next frame */
glClear(GL_COLOR_BUFFER_BIT);
glDrawElements(GL_LINES, 2* MAP_NUM_LINES , GL_UNSIGNED_INT, 0);
/* display and process events through callbacks */
glfwSwapBuffers();
glfwPollEvents();
/* Check the frame rate and update the heightmap if needed */
dt = glfwGetTime();
if ((dt - last_update_time) > 0.2)
{
/* generate the next iteration of the heightmap */
if (iter < MAX_ITER)
{
update_map(NUM_ITER_AT_A_TIME);
update_mesh();
iter += NUM_ITER_AT_A_TIME;
}
last_update_time = dt;
frame = 0;
}
}
exit(EXIT_SUCCESS);
}
int main()
{
make_mesh();
return 0;
}
{.pos={-1.0, -1.0, 1.0, 1.0}, .normal={0.0, 0.0, 1.0, 0.0}, .color={0.0, 0.0, 0.0, 1.0}, .uv={0.0, 0.0}},
{.pos={-1.0, 1.0, 1.0, 1.0}, .normal={0.0, 0.0, 1.0, 0.0}, .color={0.0, 0.0, 0.0, 1.0}, .uv={0.0, 1.0}},
{.pos={1.0, 1.0, 1.0, 1.0}, .normal={0.0, 0.0, 1.0, 0.0}, .color={0.0, 0.0, 0.0, 1.0}, .uv={1.0, 1.0}},
{.pos={1.0, -1.0, 1.0, 1.0}, .normal={0.0, 0.0, 1.0, 0.0}, .color={0.0, 0.0, 0.0, 1.0}, .uv={1.0, 0.0}},
};
GLuint index[] = {
// front
0, 1, 2,
2, 3, 0,
};
// make black sqare
int n_verts = sizeof(square) / sizeof(Vertex);
int n_indices = sizeof(index) / sizeof(GLuint);
xSquare_black = make_mesh(square, n_verts, index, n_indices);
// set colors to blue to make blue square
vec4 blue_color = {0.0, 0.0, 1.0, 0.0};
for (int i = 0; i < n_verts; ++i) {
float *c = square[i].color;
memcpy(c, blue_color, sizeof(vec4));
}
xSquare_blue = make_mesh(square, n_verts, index, n_indices);
// assign the black square a slightly larger scale to
// create an outline
mat4x4 tmp = {};
mat4x4 mul = {};
mat4x4_identity(tmp);
int main(int argc, char *argv[])
{
INT *connect;
int debug = EX_FALSE; /* EX_TRUE, display debug information; EX_FALSE */
/* otherwise. */
static char device_name[MAX_STRING_LEN];
static char file_name[MAX_STRING_LEN] = DEFAULT_FILE_NAME;
int exodus = EX_TRUE;
INT map_origin = DEFAULT_MAP_ORIGIN;
INT num_domains = DEFAULT_NUM_DOMAINS;
INT num_elements_1d;
INT num_elements = DEFAULT_NUM_ELEMENTS;
INT num_nodal_fields = DEFAULT_NUM_FIELDS;
INT num_global_fields = DEFAULT_NUM_FIELDS;
INT num_element_fields = DEFAULT_NUM_FIELDS;
INT num_timesteps = DEFAULT_NUM_TIMESTEPS;
INT num_nodes;
int compression_level = 0;
int shuffle = 0;
int int64bit = 0;
size_t size;
realtyp *x;
realtyp *y;
realtyp *z;
ex_opts(EX_VERBOSE | EX_ABORT);
/* Parse Input */
parse_input(argc, argv, &debug, &map_origin, &num_elements, &num_domains, &num_nodal_fields,
&num_global_fields, &num_element_fields, &num_timesteps, device_name, file_name,
&exodus, &compression_level, &shuffle, &int64bit);
/* Create Coordinates and Connectivity Array */
num_elements_1d = icbrt(num_elements);
num_nodes = (num_elements_1d + 1) * (num_elements_1d + 1) * (num_elements_1d + 1);
x = malloc(num_nodes * sizeof(realtyp));
y = malloc(num_nodes * sizeof(realtyp));
z = malloc(num_nodes * sizeof(realtyp));
assert(x != NULL && y != NULL && z != NULL);
num_elements = num_elements_1d * num_elements_1d * num_elements_1d;
size = (size_t)NUM_NODES_PER_ELEM * num_elements * sizeof(INT);
assert(size > 0);
connect = malloc(size);
assert(connect != NULL);
fprintf(stderr, "Creating a 3D mesh of %" PRId64 " hex elements and %" PRId64 " nodes.\n",
num_elements, num_nodes);
make_mesh(x, y, z, connect, map_origin, num_elements_1d);
fprintf(stderr, "\t...Mesh topology created.\n");
/*
* Write Out Mesh
*/
if (exodus) {
write_exo_mesh(debug, file_name, map_origin, num_nodes, num_elements, num_domains,
num_nodal_fields, num_global_fields, num_element_fields, num_timesteps, x, y, z,
connect, compression_level, shuffle, int64bit);
}
free(x);
free(y);
free(z);
free(connect);
return 0;
} /* end of main() */
int main(int argc, char** argv)
{
GLFWwindow* window;
int iter;
double dt;
double last_update_time;
int frame;
float f;
GLint uloc_modelview;
GLint uloc_project;
GLuint shader_program;
glfwSetErrorCallback(error_callback);
if (!glfwInit())
exit(EXIT_FAILURE);
glfwWindowHint(GLFW_RESIZABLE, GL_FALSE);
glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 2);
glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE);
window = glfwCreateWindow(800, 600, "GLFW OpenGL3 Heightmap demo", NULL, NULL);
if (! window )
{
glfwTerminate();
exit(EXIT_FAILURE);
}
/* Register events callback */
glfwSetKeyCallback(window, key_callback);
glfwMakeContextCurrent(window);
gladLoadGLLoader((GLADloadproc) glfwGetProcAddress);
/* Prepare opengl resources for rendering */
shader_program = make_shader_program(vertex_shader_text, fragment_shader_text);
if (shader_program == 0u)
{
glfwTerminate();
exit(EXIT_FAILURE);
}
glUseProgram(shader_program);
uloc_project = glGetUniformLocation(shader_program, "project");
uloc_modelview = glGetUniformLocation(shader_program, "modelview");
/* Compute the projection matrix */
f = 1.0f / tanf(view_angle / 2.0f);
projection_matrix[0] = f / aspect_ratio;
projection_matrix[5] = f;
projection_matrix[10] = (z_far + z_near)/ (z_near - z_far);
projection_matrix[11] = -1.0f;
projection_matrix[14] = 2.0f * (z_far * z_near) / (z_near - z_far);
glUniformMatrix4fv(uloc_project, 1, GL_FALSE, projection_matrix);
/* Set the camera position */
modelview_matrix[12] = -5.0f;
modelview_matrix[13] = -5.0f;
modelview_matrix[14] = -20.0f;
glUniformMatrix4fv(uloc_modelview, 1, GL_FALSE, modelview_matrix);
/* Create mesh data */
init_map();
make_mesh(shader_program);
/* Create vao + vbo to store the mesh */
/* Create the vbo to store all the information for the grid and the height */
/* setup the scene ready for rendering */
glViewport(0, 0, 800, 600);
glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
/* main loop */
frame = 0;
iter = 0;
last_update_time = glfwGetTime();
while (!glfwWindowShouldClose(window))
{
++frame;
/* render the next frame */
glClear(GL_COLOR_BUFFER_BIT);
glDrawElements(GL_LINES, 2* MAP_NUM_LINES , GL_UNSIGNED_INT, 0);
/* display and process events through callbacks */
glfwSwapBuffers(window);
glfwPollEvents();
/* Check the frame rate and update the heightmap if needed */
dt = glfwGetTime();
if ((dt - last_update_time) > 0.2)
{
/* generate the next iteration of the heightmap */
if (iter < MAX_ITER)
{
update_map(NUM_ITER_AT_A_TIME);
update_mesh();
iter += NUM_ITER_AT_A_TIME;
}
last_update_time = dt;
frame = 0;
}
}
glfwTerminate();
exit(EXIT_SUCCESS);
}
void intro_csv()
{
int i;
int sn;
int r, g, b;
/* define those as static, or the compiler optimizes the stack a bit too much */
static struct tmu_td tmu_task;
static struct tmu_vertex src_vertices[TMU_MESH_MAXSIZE][TMU_MESH_MAXSIZE];
static struct tmu_vertex dst_vertices[TMU_MESH_MAXSIZE][TMU_MESH_MAXSIZE];
tmu_task.flags = 0;
tmu_task.hmeshlast = HMESHLAST;
tmu_task.vmeshlast = VMESHLAST;
tmu_task.brightness = 62;
tmu_task.chromakey = 0;
tmu_task.srcmesh = &src_vertices[0][0];
tmu_task.srchres = vga_hres;
tmu_task.srcvres = vga_vres;
tmu_task.dstmesh = &dst_vertices[0][0];
tmu_task.dsthres = vga_hres;
tmu_task.dstvres = vga_vres;
tmu_task.profile = 0;
tmu_task.callback = tmu_complete;
tmu_task.user = NULL;
make_mesh(&src_vertices[0][0], &dst_vertices[0][0], 100000);
sn = 0;
for(i=0;i<DURATION;i++) {
tmu_task.srcfbuf = vga_frontbuffer;
tmu_task.dstfbuf = vga_backbuffer;
if(i > (DURATION/3))
make_mesh(&src_vertices[0][0], &dst_vertices[0][0], 100000-(4000*(i-DURATION/3)/DURATION));
if(i > (DURATION/2)) {
r = 2*(DURATION-(i-DURATION/2))/DURATION;
g = 63*(DURATION-(i-DURATION/2))/DURATION;
b = 0;
} else {
r = 2;
g = 63;
b = 0;
}
tmu_wait = 0;
tmu_submit_task(&tmu_task);
while(!tmu_wait);
if((rand() % 4) == 0) {
draw_text((rand() % vga_hres) + 1 , (rand() % vga_vres) + 2, MAKERGB565(r, g, b), csv_strings[sn]);
sn++;
if(sn == NSTRINGS) sn = 0;
flush_bridge_cache();
}
vga_swap_buffers();
}
for(i=0;i<POST;i++) {
tmu_task.srcfbuf = vga_frontbuffer;
tmu_task.dstfbuf = vga_backbuffer;
tmu_wait = 0;
tmu_submit_task(&tmu_task);
while(!tmu_wait);
vga_swap_buffers();
}
}
int main(int argc, char *argv[])
{
struct sparse_matrix_t *sparseA = NULL;
struct vector_t *b = NULL;
struct vector_t *x;
struct mesh_t *mesh;
char *xml_output;
long int *compress2fat = NULL;
struct vector_t *solution;
struct vector_t *std_error_sol;
long int fat_sol_nb_col;
lsqr_input *input;
lsqr_output *output;
lsqr_work *work; /* zone temoraire de travail */
lsqr_func *func; /* func->mat_vec_prod -> APROD */
/* cmd line arg */
char *mesh_filename = NULL;
char *importfilename = NULL;
char *output_filename = NULL;
char *sol_error_filename = NULL;
char *log_filename = NULL;
char *output_type = NULL;
int max_iter;
double damping, grad_damping;
int use_ach = 0; /* ACH : tele-seismic inversion tomography */
int check_sparse = 0; /* check sparse matrix disable by default */
/* velocity model */
char *vmodel = NULL;
struct velocity_model_t *vm = NULL;
struct mesh_t **imported_mesh = NULL;
char **xmlfilelist = NULL;
int nb_xmlfile = 0;
int i, j;
int nb_irm = 0;
struct irm_t **irm = NULL;
int *nb_metacell = NULL;
FILE *logfd;
/*************************************************************/
parse_command_line(argc, argv,
&mesh_filename,
&vmodel,
&importfilename,
&log_filename,
&output_filename, &output_type,
&max_iter,
&damping, &grad_damping, &use_ach, &check_sparse);
if (use_ach) {
fprintf(stderr, "Using ACH tomographic inversion\n");
} else {
fprintf(stderr, "Using STANDARD tomographic inversion\n");
}
/* load the velocity model */
if (vmodel) {
char *myfile;
vm = load_velocity_model(vmodel);
if (!vm) {
fprintf(stderr, "Can not initialize velocity model '%s'\n",
vmodel);
exit(1);
}
myfile = strdup(vmodel);
fprintf(stderr, "Velocity model '%s' loaded\n", basename(myfile));
free(myfile);
} else {
vm = NULL;
}
/* Open log file */
if (!log_filename) {
logfd = stdout;
} else {
if (!(logfd = fopen(log_filename, "w"))) {
perror(log_filename);
exit(1);
}
}
/*check_write_access (output_filename); */
/**************************************/
/* test if we can open file to import */
/**************************************/
if (importfilename) {
xmlfilelist = parse_separated_list(importfilename, ",");
nb_xmlfile = 0;
while (xmlfilelist[nb_xmlfile]) {
if (access(xmlfilelist[nb_xmlfile], R_OK) == -1) {
perror(xmlfilelist[nb_xmlfile]);
exit(1);
}
nb_xmlfile++;
}
} else {
fprintf(stderr, "No file to import ... exiting\n");
exit(0);
}
/****************************/
/* main mesh initialization */
/****************************/
mesh = mesh_init_from_file(mesh_filename);
if (!mesh) {
fprintf(stderr, "Error decoding %s.\n", mesh_filename);
exit(1);
}
fprintf(stderr, "read %s ok\n", mesh_filename);
/*****************************************/
/* check and initialize slice xml files */
/*****************************************/
if (nb_xmlfile) {
int nb_sparse = 0;
int nb_res = 0;
int f;
imported_mesh =
(struct mesh_t **) malloc(sizeof(struct mesh_t *) *
nb_xmlfile);
assert(imported_mesh);
for (i = 0; i < nb_xmlfile; i++) {
imported_mesh[i] = mesh_init_from_file(xmlfilelist[i]);
if (!imported_mesh[i]) {
fprintf(stderr, "Error decoding %s.\n", mesh_filename);
exit(1);
}
for (f = 0; f < NB_MESH_FILE_FORMAT; f++) {
/* mandatory field : res, sparse, and irm if provided */
if (f == RES || f == SPARSE || f == IRM) {
check_files_access(f, imported_mesh[i]->data[f],
xmlfilelist[i]);
}
}
if (imported_mesh[i]->data[SPARSE]) {
nb_sparse += imported_mesh[i]->data[SPARSE]->ndatafile;
}
if (imported_mesh[i]->data[RES]) {
nb_res += imported_mesh[i]->data[RES]->ndatafile;
}
if (imported_mesh[i]->data[IRM]) {
nb_irm += imported_mesh[i]->data[IRM]->ndatafile;
}
}
if (!nb_sparse || !nb_res) {
fprintf(stderr, "Error no sparse or res file available !\n");
exit(0);
}
}
/*********************************************/
/* read and import the sparse(s) matrix(ces) */
/*********************************************/
for (i = 0; i < nb_xmlfile; i++) {
if (!imported_mesh[i]->data[SPARSE]) {
continue;
}
for (j = 0; j < imported_mesh[i]->data[SPARSE]->ndatafile; j++) {
sparseA = import_sparse_matrix(sparseA,
imported_mesh[i]->data[SPARSE]->
filename[j]);
}
}
if (check_sparse) {
if (check_sparse_matrix(sparseA)) {
exit(1);
}
}
/*sparse_compute_length(sparseA, "length1.txt"); */
fat_sol_nb_col = sparseA->nb_col;
show_sparse_stats(sparseA);
/*********************************************/
/* read and import the residual time vector */
/*********************************************/
for (i = 0; i < nb_xmlfile; i++) {
if (!imported_mesh[i]->data[RES]) {
continue;
}
for (j = 0; j < imported_mesh[i]->data[RES]->ndatafile; j++) {
b = import_vector(b, imported_mesh[i]->data[RES]->filename[j]);
}
}
/*************************************************/
/* check compatibility between matrix and vector */
/*************************************************/
if (sparseA->nb_line != b->length) {
fprintf(stderr,
"Error, check your matrix/vector sizes (%ld/%ld)\n",
sparseA->nb_line, b->length);
exit(1);
}
/********************/
/* show memory used */
/********************/
#ifdef __APPLE__
{
struct mstats memusage;
memusage = mstats();
fprintf(stderr, "Memory used: %.2f MBytes\n",
(float) (memusage.bytes_used) / (1024. * 1024));
}
#else
{
struct mallinfo m_info;
m_info = mallinfo();
fprintf(stderr, "Memory used: %.2f MBytes\n",
(float) (m_info.uordblks +
m_info.usmblks) / (1024. * 1024.));
}
#endif
/**************************************/
/* relative traveltime mode */
/**************************************/
if (use_ach) {
int nb_evt_imported = 0;
for (i = 0; i < nb_xmlfile; i++) {
if (!imported_mesh[i]->data[EVT]) {
continue;
}
for (j = 0; j < imported_mesh[i]->data[EVT]->ndatafile; j++) {
relative_tt(sparseA, b,
imported_mesh[i]->data[EVT]->filename[j]);
nb_evt_imported++;
}
}
if (!nb_evt_imported) {
fprintf(stderr,
"Error in ACH mode, can not import any .evt file !\n");
exit(1);
}
}
/************************************************/
/* read the irregular mesh definition if needed */
/* one by layer */
/************************************************/
if (nb_irm) {
int cpt = 0;
struct mesh_offset_t **offset;
int l;
irm = (struct irm_t **) malloc(nb_irm * sizeof(struct irm_t *));
assert(irm);
nb_metacell = (int *) calloc(nb_irm, sizeof(int));
assert(nb_metacell);
make_mesh(mesh);
for (i = 0; i < nb_xmlfile; i++) {
if (!imported_mesh[i]->data[IRM]) {
continue;
}
/* offset between meshes */
offset = compute_mesh_offset(mesh, imported_mesh[i]);
for (l = 0; l < mesh->nlayers; l++) {
if (!offset[l])
continue;
fprintf(stderr,
"\t%s, [%s] offset[layer=%d] : lat=%d lon=%d z=%d\n",
xmlfilelist[i], MESH_FILE_FORMAT[IRM], l,
offset[l]->lat, offset[l]->lon, offset[l]->z);
}
for (j = 0; j < imported_mesh[i]->data[IRM]->ndatafile; j++) {
/* FIXME: read only once the irm file */
irm[cpt] =
read_irm(imported_mesh[i]->data[IRM]->filename[j],
&(nb_metacell[cpt]));
import2mesh_irm_file(mesh,
imported_mesh[i]->data[IRM]->
filename[j], offset);
cpt++;
}
for (l = 0; l < mesh->nlayers; l++) {
if (offset[l])
free(offset[l]);
}
free(offset);
}
metacell_find_neighbourhood(mesh);
}
/*sparse_compute_length(sparseA, "length1.txt"); */
fat_sol_nb_col = sparseA->nb_col;
show_sparse_stats(sparseA);
/***********************/
/* remove empty column */
/***********************/
fprintf(stderr, "starting compression ...\n");
sparse_compress_column(mesh, sparseA, &compress2fat);
if (check_sparse) {
if (check_sparse_matrix(sparseA)) {
exit(1);
}
}
show_sparse_stats(sparseA);
/***************************************/
/* add gradient damping regularisation */
/***************************************/
if (fabs(grad_damping) > 1.e-6) {
int nb_faces = 6; /* 1 cell may have 6 neighbours */
long int nb_lines = 0;
char *regul_name;
fprintf(stdout, "using gradient damping : %f\n", grad_damping);
/* tmp file name */
regul_name = tempnam("/tmp", "regul");
if (!regul_name) {
perror("lsqrsolve: ");
exit(1);
}
if (nb_irm) {
create_regul_DtD_irm(sparseA, compress2fat,
mesh, regul_name, nb_faces,
grad_damping, &nb_lines);
} else {
create_regul_DtD(sparseA, compress2fat,
mesh, regul_name, nb_faces,
grad_damping, &nb_lines);
}
sparse_matrix_resize(sparseA,
sparseA->nb_line + sparseA->nb_col,
sparseA->nb_col);
sparseA = import_sparse_matrix(sparseA, regul_name);
if (check_sparse) {
if (check_sparse_matrix(sparseA)) {
exit(1);
}
}
vector_resize(b, sparseA->nb_line);
unlink(regul_name);
show_sparse_stats(sparseA);
}
/*********************************/
/* the real mesh is no more used */
/* keep only the light mesh */
/*********************************/
fprintf(stdout,
"Time to free the real mesh and keep only the light structure\n");
free_mesh(mesh);
mesh = mesh_init_from_file(mesh_filename);
if (!mesh) {
fprintf(stderr, "Error decoding %s.\n", mesh_filename);
exit(1);
}
fprintf(stderr, "read %s ok\n", mesh_filename);
/********************************/
/* init vector solution to zero */
/********************************/
x = new_vector(sparseA->nb_col);
/*************************************************************/
/* solve A.x = B */
/* A = ray length in the cells */
/* B = residual travel time observed - computed */
/* x solution to satisfy the lsqr problem */
/*************************************************************/
/* LSQR alloc */
alloc_lsqr_mem(&input, &output, &work, &func, sparseA->nb_line,
sparseA->nb_col);
fprintf(stderr, "alloc_lsqr_mem : ok\n");
/* defines the routine Mat.Vect to use */
func->mat_vec_prod = sparseMATRIXxVECTOR;
/* Set the input parameters for LSQR */
input->num_rows = sparseA->nb_line;
input->num_cols = sparseA->nb_col;
input->rel_mat_err = 1.0e-3; /* in km */
input->rel_rhs_err = 1.0e-2; /* in seconde */
/*input->rel_mat_err = 0.;
input->rel_rhs_err = 0.; */
input->cond_lim = .0;
input->lsqr_fp_out = logfd;
/* input->rhs_vec = (dvec *) b; */
dvec_copy((dvec *) b, input->rhs_vec);
input->sol_vec = (dvec *) x; /* initial guess */
input->damp_val = damping;
if (max_iter == -1) {
input->max_iter = 4 * (sparseA->nb_col);
} else {
input->max_iter = max_iter;
}
/* catch Ctrl-C signal */
signal(SIGINT, emergency_halt);
/******************************/
/* resolution du systeme Ax=b */
/******************************/
lsqr(input, output, work, func, sparseA);
fprintf(stderr, "*** lsqr ended (%ld iter) : %s\n",
output->num_iters, lsqr_msg[output->term_flag]);
if (output->term_flag == 0) { /* solution x=x0 */
exit(0);
}
/* uncompress the solution */
solution = uncompress_column((struct vector_t *) output->sol_vec,
compress2fat, fat_sol_nb_col);
/* uncompress the standard error on solution */
std_error_sol =
uncompress_column((struct vector_t *) output->std_err_vec,
compress2fat, fat_sol_nb_col);
/* if irm file was provided, set the right value to each cell
* from a given metacell
*/
if (irm) {
irm_update(solution, irm, nb_metacell, nb_irm, mesh);
free_irm(irm, nb_irm);
free(nb_metacell);
}
/* write solution */
if (strchr(output_type, 'm')) {
export2matlab(solution, output_filename, mesh, vm,
output->num_iters,
input->damp_val, grad_damping, use_ach);
}
if (strchr(output_type, 's')) {
export2sco(solution, output_filename, mesh, vm,
output->num_iters,
input->damp_val, grad_damping, use_ach);
}
if (strchr(output_type, 'g')) {
/* solution */
export2gmt(solution, output_filename, mesh, vm,
output->num_iters,
input->damp_val, grad_damping, use_ach);
/* error on solution */
sol_error_filename = (char *)
malloc(sizeof(char) *
(strlen(output_filename) + strlen(".err") + 1));
sprintf(sol_error_filename, "%s.err", output_filename);
export2gmt(std_error_sol, sol_error_filename, mesh, vm,
output->num_iters,
input->damp_val, grad_damping, use_ach);
free(sol_error_filename);
}
/* save the xml enrichied with sections */
xml_output = (char *)
malloc((strlen(output_filename) + strlen(".xml") +
1) * sizeof(char));
assert(xml_output);
sprintf(xml_output, "%s.xml", output_filename);
mesh2xml(mesh, xml_output);
free(xml_output);
/******************************************************/
/* variance reduction, ie how the model fits the data */
/* X = the final solution */
/* */
/* ||b-AX||² */
/* VR= 1 - -------- */
/* ||b||² */
/* */
/******************************************************/
{
double norm_b;
double norm_b_AX;
double VR; /* variance reduction */
struct vector_t *rhs; /* right hand side */
rhs = new_vector(sparseA->nb_line);
/* use copy */
dvec_copy((dvec *) b, (dvec *) rhs);
norm_b = dvec_norm2((dvec *) rhs);
/* does rhs = rhs + sparseA . output->sol_vec */
/* here rhs is overwritten */
dvec_scale((-1.0), (dvec *) rhs);
sparseMATRIXxVECTOR(0, output->sol_vec, (dvec *) rhs, sparseA);
dvec_scale((-1.0), (dvec *) rhs);
norm_b_AX = dvec_norm2((dvec *) rhs);
VR = 1 - (norm_b_AX * norm_b_AX) / (norm_b * norm_b);
fprintf(stdout, "Variance reduction = %.2f%%\n", VR * 100);
free_vector(rhs);
}
/********/
/* free */
/********/
if (vm) {
free_velocity_model(vm);
}
free_mesh(mesh);
free_sparse_matrix(sparseA);
free_lsqr_mem(input, output, work, func);
free_vector(solution);
free_vector(std_error_sol);
free(compress2fat);
for (i = 0; i < nb_xmlfile; i++) {
free(xmlfilelist[i]);
free_mesh(imported_mesh[i]);
}
free(xmlfilelist);
free(imported_mesh);
return (0);
}
static gf_t make_gf(double beta, statistic_enum S, tqa::mini_vector<size_t,2> shape) {
return make_gf(make_mesh(beta,S,1025,mesh_t::half_bins), shape, local::tail(shape));
}
static gf_t make_gf(double beta, statistic_enum S, tqa::mini_vector<size_t,2> shape, size_t Nmax, mesh_t::mesh_kind mk, local::tail_view const & t) {
return make_gf(make_mesh(beta,S,Nmax,mk), shape, t);
}