hwgm_node_t* read_node(context_t* context, const reader_node_t* node)
{
hwgm_node_t* out = NULL;
hwgm_mesh_t* mesh = NULL;
hwgm_node_t* node = NULL;
hwu32 size = 0;
range_t radius;
hwu32 i;
out = (hwgm_node_t*)(context->nodes + context->node_pos);
hwgm_node_initialize(out);
for(i = 0; i < node->mesh_count; ++i) {
mesh = read_mesh(context, node->meshes + i);
out->meshes[i] = mesh;
}
for(i = 0; i < node->child_count; ++i) {
node = read_node(context, node->childs + i);
out->children[i] = node;
}
out->mesh_count = node->mesh_count;
out->child_count = node->child_count;
context->node_pos += calc_size_node(node);
return out;
}
void FBXSceneImporter::read_node(FbxNode* pNode)
{
for (int i = 0; i < pNode->GetNodeAttributeCount(); i++)
{
FbxNodeAttribute* pAttribute = pNode->GetNodeAttributeByIndex(i);
FbxNodeAttribute::EType attribute_type = pAttribute->GetAttributeType();
if (attribute_type == FbxNodeAttribute::eMesh)
{
FbxMesh* pMesh = (FbxMesh*)pAttribute;
read_mesh(pNode, pMesh);
}
else if (attribute_type == FbxNodeAttribute::eLight)
{
FbxLight* pLight = (FbxLight*)pAttribute;
read_light(pNode, pLight);
}
else if (attribute_type == FbxNodeAttribute::eCamera)
{
FbxCamera* pCamera = (FbxCamera*)pAttribute;
read_camera(pNode, pCamera);
}
}
int materialCount = pNode->GetSrcObjectCount<FbxSurfaceMaterial>();
// Recursively print the children.
for (int j = 0; j < pNode->GetChildCount(); j++)
{
read_node(pNode->GetChild(j));
}
}
TEST(ReplaceBulkData, read_replace_write)
{
stk::ParallelMachine pm = MPI_COMM_WORLD;
const int p_size = stk::parallel_machine_size(pm);
if (p_size > 1) {
return;
}
// const unsigned spatialDim = 3;
stk::mesh::MetaData* meta = new stk::mesh::MetaData;
stk::mesh::BulkData* bulk = new stk::mesh::BulkData(*meta, pm);
std::string filename("generated:1x1x1");
read_mesh(filename, *bulk);
//replace BulkData:
delete bulk;
bulk = new stk::mesh::BulkData(*meta, pm);
create_1_hex_element(*bulk);
//write out to exodus file
std::string out_filename("replace_out.exo");
write_mesh(out_filename, *bulk);
delete bulk;
delete meta;
unlink(out_filename.c_str());
}
int init( )
{
// charge 12 triangles, soit un cube...
Mesh cube= read_mesh("data/flat_bbox.obj");
printf(" %u positions\n", (unsigned int) cube.positions.size());
// compile le shader program, le program est selectionne
program= read_program("tutos/tuto3GL.glsl");
// transfere les 36 positions dans le tableau declare par le vertex shader
// etape 1 : recuperer l'identifiant de l'uniform
GLint location= glGetUniformLocation(program, "positions"); // uniform vec3 positions[36];
// etape 2 : modifier sa valeur
glUniform3fv(location, cube.positions.size(), &cube.positions.front().x);
// mesh n'est plus necessaire
release_mesh(cube);
// creer un vertex array object
glGenVertexArrays(1, &vao);
// etat openGL par defaut
glClearColor(0.2, 0.2, 0.2, 1); // definir la couleur par defaut
glClearDepth(1.f); // profondeur par defaut
glDepthFunc(GL_LESS); // ztest, conserver l'intersection la plus proche de la camera
glEnable(GL_DEPTH_TEST); // activer le ztest
return 0;
}
void read_mesh_gambitfast_c(int rank, const char* meshfile, const char* partitionfile, bool hasFault)
{
logInfo(rank) << "Reading Gambit mesh using fast reader";
logInfo(rank) << "Parsing mesh and partition file:" << meshfile << ';' << partitionfile;
seissol::SeisSol::main.setMeshReader(new GambitReader(rank, meshfile, partitionfile));
read_mesh(rank, seissol::SeisSol::main.meshReader(), hasFault);
}
void read_mesh_netcdf_c(int rank, int nProcs, const char* meshfile, bool hasFault)
{
#ifdef USE_NETCDF
logInfo(rank) << "Reading netCDF mesh" << meshfile;
seissol::SeisSol::main.setMeshReader(new NetcdfReader(rank, nProcs, meshfile));
read_mesh(rank, seissol::SeisSol::main.meshReader(), hasFault);
#else // USE_NETCDF
logError() << "netCDF not supported";
#endif // USE_NETCDF
}
int main (int argc,
char** argv)
/* ------------------------------------------------------------------------- *
* Driver.
* ------------------------------------------------------------------------- */
{
char fname[STR_MAX];
char buf [STR_MAX];
FILE *fp, *fp_tec;
fp_msh = stdin;
strcpy(fname, "tmp.XXXXXX");
if ((fp = fdopen(mkstemp(fname), "w+")) == (FILE *) NULL) {
fprintf (stderr, "sem2vtk: unable to open a temporary file\n");
exit (EXIT_FAILURE);
}
parse_args (argc, argv);
read_mesh (fp_msh);
while (dump--) read_data (fp_fld);
interpolate ();
wrap ();
write_vtk (fp);
if (preplot_it) {
sprintf (buf, "preplot %s %s > /dev/null", fname, vtkfile);
system (buf);
remove (fname);
} else {
rewind (fp);
fp_tec = fopen (vtkfile, "w");
while (fgets(buf, STR_MAX, fp)) fputs(buf, fp_tec);
fclose (fp_tec);
fclose (fp);
}
return EXIT_SUCCESS;
}
int run_dgcuda(int argc, char *argv[]) {
int local_num_elem, local_num_sides;
int n_threads, n_blocks_elem, n_blocks_sides;
int i, n, local_n_p, total_timesteps, local_n_quad, local_n_quad1d;
int verbose, convergence, video, eval_error, benchmark;
double endtime, t;
double tol, total_error, max_error;
double *min_radius;
double min_r;
double *V1x, *V1y, *V2x, *V2y, *V3x, *V3y;
double *sides_x1, *sides_x2;
double *sides_y1, *sides_y2;
double *r1_local, *r2_local, *w_local;
double *s_r, *oned_w_local;
int *left_elem, *right_elem;
int *elem_s1, *elem_s2, *elem_s3;
int *left_side_number, *right_side_number;
FILE *mesh_file, *out_file;
char out_filename[100];
char *mesh_filename;
double *Uv1, *Uv2, *Uv3;
double *error;
clock_t start, end;
double elapsed;
// get input
endtime = -1;
if (get_input(argc, argv, &n, &total_timesteps, &endtime,
&verbose, &video, &convergence, &tol,
&benchmark, &eval_error,
&mesh_filename)) {
return 1;
}
// set the order of the approximation & timestep
local_n_p = (n + 1) * (n + 2) / 2;
// sanity check on limiter
if (limiter && n != 1) {
printf("Error: limiter only enabled for p = 1\n");
exit(0);
}
// open the mesh to get local_num_elem for allocations
mesh_file = fopen(mesh_filename, "r");
if (!mesh_file) {
printf("\nERROR: mesh file not found.\n");
return 1;
}
// read in the mesh and make all the mappings
read_mesh(mesh_file, &local_num_sides, &local_num_elem,
&V1x, &V1y, &V2x, &V2y, &V3x, &V3y,
&left_side_number, &right_side_number,
&sides_x1, &sides_y1,
&sides_x2, &sides_y2,
&elem_s1, &elem_s2, &elem_s3,
&left_elem, &right_elem);
// close the file
fclose(mesh_file);
// initialize the gpu
init_cpu(local_num_elem, local_num_sides, local_n_p,
V1x, V1y, V2x, V2y, V3x, V3y,
left_side_number, right_side_number,
sides_x1, sides_y1,
sides_x2, sides_y2,
elem_s1, elem_s2, elem_s3,
left_elem, right_elem,
convergence, eval_error);
// get the correct quadrature rules for this scheme
set_quadrature(n, &r1_local, &r2_local, &w_local,
&s_r, &oned_w_local, &local_n_quad, &local_n_quad1d);
// set constant data
set_N(local_N);
set_n_p(local_n_p);
set_num_elem(local_num_elem);
set_num_sides(local_num_sides);
set_n_quad(local_n_quad);
set_n_quad1d(local_n_quad1d);
// find the min inscribed circle
preval_inscribed_circles(d_J, d_V1x, d_V1y, d_V2x, d_V2y, d_V3x, d_V3y);
min_radius = (double *) malloc(local_num_elem * sizeof(double));
memcpy(min_radius, d_J, local_num_elem * sizeof(double));
min_r = min_radius[0];
for (i = 1; i < local_num_elem; i++) {
min_r = (min_radius[i] < min_r) ? min_radius[i] : min_r;
// report problem
if (min_radius[i] == 0) {
printf("%i\n", i);
printf("%.015lf, %.015lf, %.015lf, %.015lf, %.015lf, %.015lf\n",
V1x[i], V1y[i],
V2x[i], V2y[i],
V3x[i], V3y[i]);
}
}
free(min_radius);
// pre computations
preval_jacobian(d_J, d_V1x, d_V1y, d_V2x, d_V2y, d_V3x, d_V3y);
preval_side_length(d_s_length, d_s_V1x, d_s_V1y, d_s_V2x, d_s_V2y);
preval_normals(d_Nx, d_Ny,
d_s_V1x, d_s_V1y, d_s_V2x, d_s_V2y,
d_V1x, d_V1y,
d_V2x, d_V2y,
d_V3x, d_V3y,
d_left_side_number);
preval_normals_direction(d_Nx, d_Ny,
d_V1x, d_V1y,
d_V2x, d_V2y,
d_V3x, d_V3y,
d_left_elem, d_left_side_number);
preval_partials(d_V1x, d_V1y,
d_V2x, d_V2y,
d_V3x, d_V3y,
d_xr, d_yr,
d_xs, d_ys);
// evaluate the basis functions at those points and store on GPU
preval_basis(r1_local, r2_local, s_r, w_local, oned_w_local, local_n_quad, local_n_quad1d, local_n_p);
// no longer need any of these CPU variables
free(elem_s1);
free(elem_s2);
free(elem_s3);
free(sides_x1);
free(sides_x2);
free(sides_y1);
free(sides_y2);
free(left_elem);
free(right_elem);
free(left_side_number);
free(right_side_number);
free(r1_local);
free(r2_local);
free(w_local);
free(s_r);
free(oned_w_local);
// initial conditions
init_conditions(d_c, d_J, d_V1x, d_V1y, d_V2x, d_V2y, d_V3x, d_V3y);
printf(" ? %i degree polynomial interpolation (local_n_p = %i)\n", n, local_n_p);
printf(" ? %i precomputed basis points\n", local_n_quad * local_n_p);
printf(" ? %i elements\n", local_num_elem);
printf(" ? %i sides\n", local_num_sides);
printf(" ? min radius = %.015lf\n", min_r);
if (endtime == -1 && convergence != 1) {
printf(" ? total_timesteps = %i\n", total_timesteps);
} else if (endtime != -1 && convergence != 1) {
printf(" ? endtime = %lf\n", endtime);
}
if (benchmark) {
start = clock();
}
t = time_integrate_rk4(local_num_elem, local_num_sides,
n, local_n_p,
endtime, total_timesteps, min_r,
verbose, convergence, video, tol);
if (benchmark) {
end = clock();
elapsed = ((double)(end - start)) / CLOCKS_PER_SEC;
printf("Runtime: %lf seconds\n", elapsed);
}
// evaluate and write U to file
write_U(local_num_elem, total_timesteps, total_timesteps);
// free everything else
free(d_s_V1x);
free(d_s_V2x);
free(d_s_V1y);
free(d_s_V2y);
free(d_s_length);
free(d_lambda);
free(d_k1);
free(d_k2);
free(d_k3);
free(d_k4);
free(d_rhs_volume);
free(d_rhs_surface_left);
free(d_rhs_surface_right);
free(d_elem_s1);
free(d_elem_s2);
free(d_elem_s3);
free(d_xr);
free(d_yr);
free(d_xs);
free(d_ys);
free(d_left_side_number);
free(d_right_side_number);
free(d_Nx);
free(d_Ny);
free(d_right_elem);
free(d_left_elem);
free(d_c);
free(d_J);
free(d_Uv1);
free(d_Uv2);
free(d_Uv3);
free(d_V1x);
free(d_V1y);
free(d_V2x);
free(d_V2y);
free(d_V3x);
free(d_V3y);
// free CPU variables
free(V1x);
free(V1y);
free(V2x);
free(V2y);
free(V3x);
free(V3y);
return 0;
}
bool
Surface_mesh::
read(const std::string& filename)
{
return read_mesh(*this, filename);
}
int main(int argc, char *argv[]) {
int num_elem, num_sides;
int n_threads, n_blocks_elem, n_blocks_reduction, n_blocks_sides;
int i, n, n_p, timesteps, n_quad, n_quad1d;
double dt, t, endtime;
double *min_radius;
double min_r;
double *V1x, *V1y, *V2x, *V2y, *V3x, *V3y;
double *sides_x1, *sides_x2;
double *sides_y1, *sides_y2;
double *r1_local, *r2_local, *w_local;
double *s_r, *oned_w_local;
int *left_elem, *right_elem;
int *elem_s1, *elem_s2, *elem_s3;
int *left_side_number, *right_side_number;
FILE *mesh_file, *out_file;
char line[100];
char *mesh_filename;
char *out_filename;
char *rho_out_filename;
char *u_out_filename;
char *v_out_filename;
char *E_out_filename;
char *outfile_base;
int outfile_len;
double *Uu1, *Uu2, *Uu3;
double *Uv1, *Uv2, *Uv3;
// get input
endtime = -1;
if (get_input(argc, argv, &n, ×teps, &endtime, &mesh_filename, &out_filename)) {
return 1;
}
// TODO: this should be cleaner, obviously
rho_out_filename = "output/uniform_rho.out";
u_out_filename = "output/uniform_u.out";
v_out_filename = "output/uniform_v.out";
E_out_filename = "output/uniform_E.out";
// set the order of the approximation & timestep
n_p = (n + 1) * (n + 2) / 2;
// open the mesh to get num_elem for allocations
mesh_file = fopen(mesh_filename, "r");
if (!mesh_file) {
printf("\nERROR: mesh file not found.\n");
return 1;
}
fgets(line, 100, mesh_file);
sscanf(line, "%i", &num_elem);
// allocate vertex points
V1x = (double *) malloc(num_elem * sizeof(double));
V1y = (double *) malloc(num_elem * sizeof(double));
V2x = (double *) malloc(num_elem * sizeof(double));
V2y = (double *) malloc(num_elem * sizeof(double));
V3x = (double *) malloc(num_elem * sizeof(double));
V3y = (double *) malloc(num_elem * sizeof(double));
elem_s1 = (int *) malloc(num_elem * sizeof(int));
elem_s2 = (int *) malloc(num_elem * sizeof(int));
elem_s3 = (int *) malloc(num_elem * sizeof(int));
// TODO: these are too big; should be a way to figure out how many we actually need
left_side_number = (int *) malloc(3*num_elem * sizeof(int));
right_side_number = (int *) malloc(3*num_elem * sizeof(int));
sides_x1 = (double *) malloc(3*num_elem * sizeof(double));
sides_x2 = (double *) malloc(3*num_elem * sizeof(double));
sides_y1 = (double *) malloc(3*num_elem * sizeof(double));
sides_y2 = (double *) malloc(3*num_elem * sizeof(double));
left_elem = (int *) malloc(3*num_elem * sizeof(int));
right_elem = (int *) malloc(3*num_elem * sizeof(int));
for (i = 0; i < 3*num_elem; i++) {
right_elem[i] = -1;
}
// read in the mesh and make all the mappings
read_mesh(mesh_file, &num_sides, num_elem,
V1x, V1y, V2x, V2y, V3x, V3y,
left_side_number, right_side_number,
sides_x1, sides_y1,
sides_x2, sides_y2,
elem_s1, elem_s2, elem_s3,
left_elem, right_elem);
// close the file
fclose(mesh_file);
// initialize the gpu
init_gpu(num_elem, num_sides, n_p,
V1x, V1y, V2x, V2y, V3x, V3y,
left_side_number, right_side_number,
sides_x1, sides_y1,
sides_x2, sides_y2,
elem_s1, elem_s2, elem_s3,
left_elem, right_elem);
n_threads = 256;
n_blocks_elem = (num_elem / n_threads) + ((num_elem % n_threads) ? 1 : 0);
n_blocks_sides = (num_sides / n_threads) + ((num_sides % n_threads) ? 1 : 0);
n_blocks_reduction = (num_elem / 256) + ((num_elem % 256) ? 1 : 0);
// find the min inscribed circle
preval_inscribed_circles(d_J, d_V1x, d_V1y, d_V2x, d_V2y, d_V3x, d_V3y, num_elem);
min_radius = (double *) malloc(num_elem * sizeof(double));
/*
// find the min inscribed circle. do it on the gpu if there are at least 256 elements
if (num_elem >= 256) {
//min_reduction<<<n_blocks_reduction, 256>>>(d_J, d_reduction, num_elem);
cudaThreadSynchronize();
checkCudaError("error after min_jacobian.");
// each block finds the smallest value, so need to sort through n_blocks_reduction
min_radius = (double *) malloc(n_blocks_reduction * sizeof(double));
cudaMemcpy(min_radius, d_reduction, n_blocks_reduction * sizeof(double), cudaMemcpyDeviceToHost);
min_r = min_radius[0];
for (i = 1; i < n_blocks_reduction; i++) {
min_r = (min_radius[i] < min_r) ? min_radius[i] : min_r;
}
free(min_radius);
} else {
*/
// just grab all the radii and sort them since there are so few of them
min_radius = (double *) malloc(num_elem * sizeof(double));
memcpy(min_radius, d_J, num_elem * sizeof(double));
min_r = min_radius[0];
for (i = 1; i < num_elem; i++) {
min_r = (min_radius[i] < min_r) ? min_radius[i] : min_r;
}
free(min_radius);
//}
// pre computations
preval_jacobian(d_J, d_V1x, d_V1y, d_V2x, d_V2y, d_V3x, d_V3y, num_elem);
preval_side_length(d_s_length, d_s_V1x, d_s_V1y, d_s_V2x, d_s_V2y,
num_sides);
//cudaThreadSynchronize();
preval_normals(d_Nx, d_Ny,
d_s_V1x, d_s_V1y, d_s_V2x, d_s_V2y,
d_V1x, d_V1y,
d_V2x, d_V2y,
d_V3x, d_V3y,
d_left_side_number, num_sides);
preval_normals_direction(d_Nx, d_Ny,
d_V1x, d_V1y,
d_V2x, d_V2y,
d_V3x, d_V3y,
d_left_elem, d_left_side_number, num_sides);
preval_partials(d_V1x, d_V1y,
d_V2x, d_V2y,
d_V3x, d_V3y,
d_xr, d_yr,
d_xs, d_ys, num_elem);
// get the correct quadrature rules for this scheme
set_quadrature(n, &r1_local, &r2_local, &w_local,
&s_r, &oned_w_local, &n_quad, &n_quad1d);
// evaluate the basis functions at those points and store on GPU
preval_basis(r1_local, r2_local, s_r, w_local, oned_w_local, n_quad, n_quad1d, n_p);
// initial conditions
init_conditions(d_c, d_J, d_V1x, d_V1y, d_V2x, d_V2y, d_V3x, d_V3y,
n_quad, n_p, num_elem);
printf("Computing...\n");
printf(" ? %i degree polynomial interpolation (n_p = %i)\n", n, n_p);
printf(" ? %i precomputed basis points\n", n_quad * n_p);
printf(" ? %i elements\n", num_elem);
printf(" ? %i sides\n", num_sides);
printf(" ? min radius = %lf\n", min_r);
printf(" ? endtime = %lf\n", endtime);
time_integrate_rk4(n_quad, n_quad1d, n_p, n, num_elem, num_sides, endtime, min_r);
// evaluate at the vertex points and copy over data
Uu1 = (double *) malloc(num_elem * sizeof(double));
Uu2 = (double *) malloc(num_elem * sizeof(double));
Uu3 = (double *) malloc(num_elem * sizeof(double));
Uv1 = (double *) malloc(num_elem * sizeof(double));
Uv2 = (double *) malloc(num_elem * sizeof(double));
Uv3 = (double *) malloc(num_elem * sizeof(double));
// evaluate rho and write to file
eval_u(d_c, d_Uv1, d_Uv2, d_Uv3, num_elem, n_p, 0);
memcpy(Uv1, d_Uv1, num_elem * sizeof(double));
memcpy(Uv2, d_Uv2, num_elem * sizeof(double));
memcpy(Uv3, d_Uv3, num_elem * sizeof(double));
out_file = fopen(rho_out_filename , "w");
fprintf(out_file, "View \"Density \" {\n");
for (i = 0; i < num_elem; i++) {
fprintf(out_file, "ST (%lf,%lf,0,%lf,%lf,0,%lf,%lf,0) {%lf,%lf,%lf};\n",
V1x[i], V1y[i], V2x[i], V2y[i], V3x[i], V3y[i],
d_Uv1[i], d_Uv2[i], d_Uv3[i]);
}
fprintf(out_file,"};");
fclose(out_file);
// evaluate the u and v vectors and write to file
eval_u_velocity(d_c, d_Uv1, d_Uv2, d_Uv3, num_elem, n_p, 1);
memcpy(Uu1, d_Uv1, num_elem * sizeof(double));
memcpy(Uu2, d_Uv2, num_elem * sizeof(double));
memcpy(Uu3, d_Uv3, num_elem * sizeof(double));
eval_u_velocity(d_c, d_Uv1, d_Uv2, d_Uv3, num_elem, n_p, 2);
memcpy(Uv1, d_Uv1, num_elem * sizeof(double));
memcpy(Uv2, d_Uv2, num_elem * sizeof(double));
memcpy(Uv3, d_Uv3, num_elem * sizeof(double));
out_file = fopen(u_out_filename , "w");
fprintf(out_file, "View \"u \" {\n");
for (i = 0; i < num_elem; i++) {
fprintf(out_file, "VT (%lf,%lf,0,%lf,%lf,0,%lf,%lf,0) {%lf,%lf,0,%lf,%lf,0,%lf,%lf,0};\n",
V1x[i], V1y[i], V2x[i], V2y[i], V3x[i], V3y[i],
Uu1[i], Uv1[i], Uu2[i], Uv2[i], Uu3[i], Uv3[i]);
}
fprintf(out_file,"};");
fclose(out_file);
// evaluate E and write to file
eval_u(d_c, d_Uv1, d_Uv2, d_Uv3, num_elem, n_p, 3);
memcpy(Uv1, d_Uv1, num_elem * sizeof(double));
memcpy(Uv2, d_Uv2, num_elem * sizeof(double));
memcpy(Uv3, d_Uv3, num_elem * sizeof(double));
out_file = fopen(E_out_filename , "w");
fprintf(out_file, "View \"E \" {\n");
for (i = 0; i < num_elem; i++) {
fprintf(out_file, "ST (%lf,%lf,0,%lf,%lf,0,%lf,%lf,0) {%lf,%lf,%lf};\n",
V1x[i], V1y[i], V2x[i], V2y[i], V3x[i], V3y[i],
Uv1[i], Uv2[i], Uv3[i]);
}
fprintf(out_file,"};");
fclose(out_file);
// plot pressure
eval_p(d_c, d_Uv1, d_Uv2, d_Uv3, num_elem, n_p, 3);
memcpy(Uv1, d_Uv1, num_elem * sizeof(double));
memcpy(Uv2, d_Uv2, num_elem * sizeof(double));
memcpy(Uv3, d_Uv3, num_elem * sizeof(double));
out_file = fopen("output/p.out" , "w");
fprintf(out_file, "View \"E \" {\n");
for (i = 0; i < num_elem; i++) {
fprintf(out_file, "ST (%lf,%lf,0,%lf,%lf,0,%lf,%lf,0) {%lf,%lf,%lf};\n",
V1x[i], V1y[i], V2x[i], V2y[i], V3x[i], V3y[i],
Uv1[i], Uv2[i], Uv3[i]);
}
fprintf(out_file,"};");
fclose(out_file);
measure_error(d_c, d_Uv1, d_Uv2, d_Uv3,
d_V1x, d_V1y, d_V2x, d_V2y, d_V3x, d_V3y,
num_elem, n_p);
memcpy(Uv1, d_Uv1, num_elem * sizeof(double));
memcpy(Uv2, d_Uv2, num_elem * sizeof(double));
memcpy(Uv3, d_Uv3, num_elem * sizeof(double));
out_file = fopen("output/p_error.out" , "w");
fprintf(out_file, "View \"p \" {\n");
for (i = 0; i < num_elem; i++) {
fprintf(out_file, "ST (%lf,%lf,0,%lf,%lf,0,%lf,%lf,0) {%lf,%lf,%lf};\n",
V1x[i], V1y[i], V2x[i], V2y[i], V3x[i], V3y[i],
Uv1[i], Uv2[i], Uv3[i]);
}
fprintf(out_file,"};");
fclose(out_file);
// free variables
free_gpu();
free(Uu1);
free(Uu2);
free(Uu3);
free(Uv1);
free(Uv2);
free(Uv3);
free(V1x);
free(V1y);
free(V2x);
free(V2y);
free(V3x);
free(V3y);
free(elem_s1);
free(elem_s2);
free(elem_s3);
free(sides_x1);
free(sides_x2);
free(sides_y1);
free(sides_y2);
free(left_elem);
free(right_elem);
free(left_side_number);
free(right_side_number);
free(r1_local);
free(r2_local);
free(w_local);
free(s_r);
free(oned_w_local);
return 0;
}
//! compile les shaders et construit le programme + les buffers + le vertex array.
//! renvoie -1 en cas d'erreur.
int init( std::vector<const char *>& options )
{
widgets= create_widgets();
camera= make_orbiter();
program= 0;
const char *option;
option= option_find(options, ".glsl");
if(option != NULL)
{
program_filename= Filename(option);
reload_program();
}
glGenVertexArrays(1, &vao);
vertex_count= 3;
option= option_find(options, ".obj");
if(option != NULL)
{
mesh= read_mesh(option);
if(mesh.positions.size() > 0)
{
mesh_filename= Filename(option);
vao= make_mesh_vertex_format(mesh);
vertex_count= (unsigned int) mesh.positions.size();
Point pmin, pmax;
mesh_bounds(mesh, pmin, pmax);
orbiter_lookat(camera, center(pmin, pmax), distance(pmin, pmax));
}
}
// charge les textures, si necessaire
for(unsigned int i= 0; i < (unsigned int) options.size(); i++)
{
GLuint texture= read_texture(0, options[i]);
if(texture > 0)
{
texture_filenames.push_back(Filename(options[i]));
textures.push_back(texture);
}
}
// nettoyage
glUseProgram(0);
glBindTexture(GL_TEXTURE_2D, 0);
glBindVertexArray(0);
glBindBuffer(GL_ARRAY_BUFFER, 0);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
// etat openGL par defaut
glClearColor(0.2f, 0.2f, 0.2f, 1.f);
glClearDepth(1.f);
glCullFace(GL_BACK);
glFrontFace(GL_CCW);
//~ glEnable(GL_CULL_FACE); // n'affiche que les faces correctement orientees...
glDisable(GL_CULL_FACE); // les faces mal orientees sont affichees avec des hachures oranges...
glDepthFunc(GL_LESS);
glEnable(GL_DEPTH_TEST);
return 0;
}
int main(int argc, char *argv[])
{
/* Local declarations. */
struct Zoltan_Struct *zz = NULL;
char *cmd_file;
char cmesg[256]; /* for error messages */
float version;
int Proc, Num_Proc;
int iteration;
int error, gerror;
int print_output = 1;
MESH_INFO mesh; /* mesh information struct */
PARIO_INFO pio_info;
PROB_INFO prob;
/***************************** BEGIN EXECUTION ******************************/
/* initialize MPI */
MPI_Init(&argc, &argv);
#ifdef VAMPIR
VT_initialize(&argc, &argv);
#endif
/* get some machine information */
MPI_Comm_rank(MPI_COMM_WORLD, &Proc);
MPI_Comm_size(MPI_COMM_WORLD, &Num_Proc);
my_rank = Proc;
#ifdef HOST_LINUX
signal(SIGSEGV, meminfo_signal_handler);
signal(SIGINT, meminfo_signal_handler);
signal(SIGTERM, meminfo_signal_handler);
signal(SIGABRT, meminfo_signal_handler);
signal(SIGFPE, meminfo_signal_handler);
#endif
#ifdef ZOLTAN_PURIFY
printf("%d of %d ZDRIVE LAUNCH pid = %d file = %s\n",
Proc, Num_Proc, getpid(), argv[1]);
#endif
/* Initialize flags */
Test.DDirectory = 0;
Test.Local_Parts = 0;
Test.Fixed_Objects = 0;
Test.Drops = 0;
Test.RCB_Box = 0;
Test.Multi_Callbacks = 0;
Test.Graph_Callbacks = 1;
Test.Hypergraph_Callbacks = 1;
Test.Gen_Files = 0;
Test.Null_Lists = NO_NULL_LISTS;
Test.Dynamic_Weights = .0;
Test.Dynamic_Graph = .0;
Test.Vtx_Inc = 0;
Output.Text = 1;
Output.Gnuplot = 0;
Output.Nemesis = 0;
Output.Plot_Partition = 0;
Output.Mesh_Info_File = 0;
/* Interpret the command line */
switch(argc)
{
case 1:
cmd_file = "zdrive.inp";
break;
case 2:
cmd_file = argv[1];
break;
default:
fprintf(stderr, "MAIN: ERROR in command line,");
if(Proc == 0)
{
fprintf(stderr, " usage:\n");
fprintf(stderr, "\t%s [command file]", DRIVER_NAME);
}
exit(1);
break;
}
/* initialize Zoltan */
if ((error = Zoltan_Initialize(argc, argv, &version)) != ZOLTAN_OK) {
sprintf(cmesg, "fatal: Zoltan_Initialize returned error code, %d", error);
Gen_Error(0, cmesg);
error_report(Proc);
print_output = 0;
goto End;
}
/* initialize some variables */
initialize_mesh(&mesh, Proc);
pio_info.dsk_list_cnt = -1;
pio_info.file_comp = STANDARD;
pio_info.num_dsk_ctrlrs = -1;
pio_info.pdsk_add_fact = -1;
pio_info.zeros = -1;
pio_info.file_type = -1;
pio_info.chunk_reader = 0;
pio_info.init_dist_type = -1;
pio_info.init_size = ZOLTAN_ID_INVALID;
pio_info.init_dim = -1;
pio_info.init_vwgt_dim = -1;
pio_info.init_dist_pins = -1;
pio_info.pdsk_root[0] = '\0';
pio_info.pdsk_subdir[0] = '\0';
pio_info.pexo_fname[0] = '\0';
prob.method[0] = '\0';
prob.num_params = 0;
prob.params = NULL;
/* Read in the ascii input file */
error = gerror = 0;
if (Proc == 0) {
printf("\n\nReading the command file, %s\n", cmd_file);
if (!read_cmd_file(cmd_file, &prob, &pio_info, NULL)) {
sprintf(cmesg,"fatal: Could not read in the command file"
" \"%s\"!\n", cmd_file);
Gen_Error(0, cmesg);
error_report(Proc);
print_output = 0;
error = 1;
}
if (!check_inp(&prob, &pio_info)) {
Gen_Error(0, "fatal: Error in user specified parameters.\n");
error_report(Proc);
print_output = 0;
error = 1;
}
print_input_info(stdout, Num_Proc, &prob, &pio_info, version);
}
MPI_Allreduce(&error, &gerror, 1, MPI_INT, MPI_MAX, MPI_COMM_WORLD);
if (gerror) goto End;
/* broadcast the command info to all of the processor */
brdcst_cmd_info(Proc, &prob, &pio_info, &mesh);
Zoltan_Set_Param(NULL, "DEBUG_MEMORY", "1");
print_output = Output.Text;
/*
* Create a Zoltan structure.
*/
if ((zz = Zoltan_Create(MPI_COMM_WORLD)) == NULL) {
Gen_Error(0, "fatal: NULL returned from Zoltan_Create()\n");
return 0;
}
if (!setup_zoltan(zz, Proc, &prob, &mesh, &pio_info)) {
Gen_Error(0, "fatal: Error returned from setup_zoltan\n");
error_report(Proc);
print_output = 0;
goto End;
}
/* srand(Proc); Different seeds on different procs. */
srand(1); /* Same seed everywhere. */
if (Test.Dynamic_Weights){
/* Set obj weight dim to 1; can be overridden by user parameter */
Zoltan_Set_Param(zz, "OBJ_WEIGHT_DIM", "1");
}
/* Loop over read and balance for a number of iterations */
/* (Useful for testing REUSE parameters in Zoltan.) */
for (iteration = 1; iteration <= Number_Iterations; iteration++) {
if (Proc == 0) {
printf("Starting iteration %d\n", iteration);
fflush(stdout);
}
/*
* now read in the mesh and element information.
* This is the only function call to do this. Upon return,
* the mesh struct and the elements array should be filled.
*/
if (iteration == 1) {
if (!read_mesh(Proc, Num_Proc, &prob, &pio_info, &mesh)) {
Gen_Error(0, "fatal: Error returned from read_mesh\n");
error_report(Proc);
print_output = 0;
goto End;
}
/*
* Create a Zoltan DD for tracking elements during repartitioning.
*/
if (mesh.data_type == ZOLTAN_HYPERGRAPH && !build_elem_dd(&mesh)) {
Gen_Error(0, "fatal: Error returned from build_elem_dd\n");
error_report(Proc);
print_output = 0;
goto End;
}
}
#ifdef KDDKDD_COOL_TEST
/* KDD Cool test of changing number of partitions */
sprintf(cmesg, "%d", Num_Proc * iteration);
Zoltan_Set_Param(zz, "NUM_GLOBAL_PARTS", cmesg);
#endif
/*
* Produce files to verify input.
*/
if (iteration == 1) {
if (Debug_Driver > 2) {
if (!output_results(cmd_file,"in",Proc,Num_Proc,&prob,&pio_info,&mesh)){
Gen_Error(0, "fatal: Error returned from output_results\n");
error_report(Proc);
}
if (Output.Gnuplot)
if (!output_gnu(cmd_file,"in",Proc,Num_Proc,&prob,&pio_info,&mesh)) {
Gen_Error(0, "warning: Error returned from output_gnu\n");
error_report(Proc);
}
}
if (Test.Vtx_Inc<0){
/* Read Citeseer data from file */
FILE *fp;
int i=0;
if (Proc==0){
fp = fopen("months.txt", "r");
if (!fp)
printf("ERROR: Couldn't open file months.txt\n");
while (fscanf(fp, "%d", &CITESEER[i])==1){
++i;
}
fclose(fp);
}
MPI_Bcast (CITESEER, 200, MPI_INT, 0, MPI_COMM_WORLD);
}
}
if (Test.Dynamic_Graph > 0.0){
if (mesh.data_type == ZOLTAN_GRAPH) {
remove_random_vertices(&mesh, iteration, Test.Dynamic_Graph);
}
else{
Gen_Error(0, "fatal: \"test dynamic graph\" only works on graphs, not hypergraphs\n");
error_report(Proc);
print_output = 0;
goto End;
}
}
if (Test.Vtx_Inc){
if (mesh.data_type == ZOLTAN_HYPERGRAPH ) {
if (Test.Vtx_Inc>0)
mesh.visible_nvtx += Test.Vtx_Inc; /* Increment uniformly */
else
mesh.visible_nvtx = CITESEER[iteration-1]; /* Citeseer document matrix. */
}
else{
Gen_Error(0, "fatal: \"vertex increment\" only works on hypergraphs\n");
error_report(Proc);
print_output = 0;
goto End;
}
}
/*
* now run Zoltan to get a new load balance and perform
* the migration
*/
#ifdef IGNORE_FIRST_ITERATION_STATS
if (iteration == 1) {
/* Exercise partitioner once on Tbird because first run is slow. */
/* Lee Ann suspects Tbird is loading shared libraries. */
struct Zoltan_Struct *zzcopy;
zzcopy = Zoltan_Copy(zz);
/* Don't do any migration or accumulate any stats. */
if (Proc == 0) printf("%d KDDKDD IGNORING FIRST ITERATION STATS\n", Proc);
Zoltan_Set_Param(zzcopy, "RETURN_LISTS", "NONE");
Zoltan_Set_Param(zzcopy, "FINAL_OUTPUT", "0");
Zoltan_Set_Param(zzcopy, "USE_TIMERS", "0");
if (!run_zoltan(zzcopy, Proc, &prob, &mesh, &pio_info)) {
Gen_Error(0, "fatal: Error returned from run_zoltan\n");
error_report(Proc);
print_output = 0;
goto End;
}
Zoltan_Destroy(&zzcopy);
}
#endif /* IGNORE_FIRST_ITERATION_STATS */
#ifdef RANDOM_DIST
if (iteration % 2 == 0) {
char LB_METHOD[1024];
if (Proc == 0) printf("%d CCCC Randomizing the input\n", Proc);
strcpy(LB_METHOD, prob.method);
strcpy(prob.method, "RANDOM");
Zoltan_Set_Param(zz, "LB_METHOD", "RANDOM");
Zoltan_Set_Param(zz, "RETURN_LISTS", "ALL");
if (!run_zoltan(zz, Proc, &prob, &mesh, &pio_info)) {
Gen_Error(0, "fatal: Error returned from run_zoltan\n");
error_report(Proc);
print_output = 0;
goto End;
}
Zoltan_Set_Param(zz, "RETURN_LISTS", "NONE");
Zoltan_Set_Param(zz, "LB_METHOD", LB_METHOD);
strcpy(prob.method, LB_METHOD);
if (Proc == 0) printf("%d CCCC Randomizing the input -- END\n", Proc);
}
#endif /* RANDOM_DIST */
if (!run_zoltan(zz, Proc, &prob, &mesh, &pio_info)) {
Gen_Error(0, "fatal: Error returned from run_zoltan\n");
error_report(Proc);
print_output = 0;
goto End;
}
/* Reset the mesh data structure for next iteration. */
if (iteration < Number_Iterations) {
int i, j;
float tmp;
float twiddle = 0.01;
char str[4];
/* Perturb coordinates of mesh */
if (mesh.data_type == ZOLTAN_GRAPH){
for (i = 0; i < mesh.num_elems; i++) {
for (j = 0; j < mesh.num_dims; j++) {
/* tmp = ((float) rand())/RAND_MAX; *//* Equiv. to sjplimp's test */
tmp = (float) (i % 10) / 10.;
mesh.elements[i].coord[0][j] += twiddle * (2.0*tmp-1.0);
mesh.elements[i].avg_coord[j] = mesh.elements[i].coord[0][j];
}
}
/* Increase weights in some parts */
if (Test.Dynamic_Weights){
/* Randomly pick 10% of parts to "refine" */
/* Note: Assumes at least 10 parts! */
/* Increase vertex weight, and also edge weights? TODO */
j = (int) ((10.0*rand())/RAND_MAX + .5);
for (i = 0; i < mesh.num_elems; i++) {
if ((mesh.elements[i].my_part%10) == j){
mesh.elements[i].cpu_wgt[0] = Test.Dynamic_Weights*(1+rand()%5);
}
}
}
}
/* change the ParMETIS Seed */
sprintf(str, "%d", iteration);
#ifdef ZOLTAN_PARMETIS
Zoltan_Set_Param(zz, "PARMETIS_SEED", str);
#endif
}
} /* End of loop over read and balance */
if (Proc == 0) {
printf("FILE %s: Total: %e seconds in Partitioning\n",
cmd_file, Total_Partition_Time);
printf("FILE %s: Average: %e seconds per Iteration\n",
cmd_file, Total_Partition_Time/Number_Iterations);
}
End:
Zoltan_Destroy(&zz);
if (mesh.dd) Zoltan_DD_Destroy(&(mesh.dd));
Zoltan_Memory_Stats();
/*
* output the results
*/
if (print_output) {
if (!output_results(cmd_file,"out",Proc,Num_Proc,&prob,&pio_info,&mesh)) {
Gen_Error(0, "fatal: Error returned from output_results\n");
error_report(Proc);
}
if (Output.Gnuplot) {
if (!output_gnu(cmd_file,"out",Proc,Num_Proc,&prob,&pio_info,&mesh)) {
Gen_Error(0, "warning: Error returned from output_gnu\n");
error_report(Proc);
}
}
}
free_mesh_arrays(&mesh);
if (prob.params != NULL) free(prob.params);
MPI_Finalize();
#ifdef VAMPIR
VT_finalize();
#endif
return 0;
}
/**
* \brief Construct a mesh from the given filename.
* \param fname The name of the file to construct the mesh from.
*/
mesh (const char* fname)
{ read_mesh (fname); }