muMECH  1.0
meso3d.cpp
Go to the documentation of this file.
1 //********************************************************************************************************
2 // code: # # ###### ##### ##### ##### ######
3 // ## ## # # # # # # # # #
4 // # # # # # # # # # # #
5 // # # # ##### ##### # # #### # #
6 // # # # # # # # # #
7 // # # # # # # # # # # #
8 // # # ###### ##### ##### ##### ######
9 //
10 // name: meso3d.h
11 // Copyright: Daniel Rypl
12 // Czech Technical University in Prague,
13 // Faculty of Civil Engineering, Department of Structural Mechanics,
14 // Thakurova 7, 166 29 Prague, Czech Republic,
15 // email: drypl@fsv.cvut.cz
16 //
17 // language: C, C++
18 // license: This program is free software; you can redistribute it and/or modify
19 // it under the terms of the GNU Lesser General Public License as published by
20 // the Free Software Foundation; either version 2 of the License, or
21 // (at your option) any later version.
22 //
23 // This program is distributed in the hope that it will be useful,
24 // but WITHOUT ANY WARRANTY; without even the implied warranty of
25 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
26 // GNU Lesser General Public License for more details.
27 //
28 // You should have received a copy of the GNU Lesser General Public License
29 // along with this program; if not, write to the Free Software
30 // Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
31 //********************************************************************************************************
32 
33 #include "meso3d.h"
34 
35 #include <stdio.h>
36 #include <stdlib.h>
37 //#include <string.h>
38 //#include <ctype.h>
39 #include <math.h>
40 #include <stdarg.h>
41 
42 /* TODO: complete interface for T3d, ctrl file for Oofem, mirroring between master and slave, mirorring accross interface
43 
44  current version relies on coincidation (and topological identity) of entities that should be meshed identically;
45  this may fail especially between master-slave pairs of entities as the master is bounding region and degeneracy
46  of that region may be (probably mistakenously) identified;
47  degeneracy is then fixed only on master entity (not on slave entity) */
48 
49 
50 namespace meso3d {
51 
52 // ******************************************************************************************
53 // *************************************** DEFINE ***************************************
54 // ******************************************************************************************
55 
56 
57 // #ifndef ELIXIR
58 // /* #define ELIXIR */
59 // #endif
60 //
61 // //#define DEBUG
62 //
63 // //#define MERLIN /* merlin topology used */
64 //
65 // // #ifdef ELIXIR
66 // // #include "Esimple.h"
67 // // #undef NO
68 // // #undef YES
69 // // #endif
70 //
71 // #define BUFFER_SIZE 1024
72 //
73 // #define REMARK '#'
74 // #define NEWLINE '\n'
75 // #define SPACE ' '
76 //
77 #define NO_ERROR -1
78 #define WARNING 0
79 #define GENERAL_ERROR 1
80 // #define FILE_OPEN_ERROR 2
81 // #define FILE_READ_ERROR 3
82 // #define FILE_WRITE_ERROR 4
83 // #define MEMORY_ERROR 5
84 #define INPUT_ERROR 6
85 //
86 //
87 #define EPSILON 1.0e-10
88 
89 #define EPSILON_T 1.0e-5
90 #define EPSILON_U 1.0e-5
91 #define EPSILON_V 1.0e-5
92 //
93 // #define ANGLE 0.001 /* cos(89.94 degs) */
94 //
95 #define MAX_ITER 100
96 //
97 //
98 //
99 #define B_0(T) (1.0-2.0*(T)+(T)*(T))
100 #define B_1(T) (2.0*(1.0-(T))*(T))
101 #define B_2(T) ((T)*(T))
102 
103 #define dB_0(T) (-2.0+2.0*(T))
104 #define dB_1(T) (2.0-4.0*(T))
105 #define dB_2(T) (2.0*(T))
106 
107 #define swap(VAL1, VAL2, TMP) {(TMP) = (VAL1); (VAL1) = (VAL2); (VAL2) = (TMP);}
108 
109 #define copy_vec(DEST, SRC) {(DEST).x = (SRC).x; (DEST).y = (SRC).y; (DEST).z = (SRC).z;}
110 #define size_vec(VEC) ((VEC).x * (VEC).x + (VEC).y * (VEC).y + (VEC).z * (VEC).z)
111 
112 #define dist_point(PNT1, PNT2) (((PNT1).x - (PNT2).x) * ((PNT1).x - (PNT2).x) + \
113  ((PNT1).y - (PNT2).y) * ((PNT1).y - (PNT2).y) + \
114  ((PNT1).z - (PNT2).z) * ((PNT1).z - (PNT2).z))
115 #define aver_point(RES, PNT1, PNT2) {(RES).x = ((PNT1).x + (PNT2).x) / 2.0; \
116  (RES).y = ((PNT1).y + (PNT2).y) / 2.0; \
117  (RES).z = ((PNT1).z + (PNT2).z) / 2.0;}
118 
119 #define mul_vec(VEC, VALUE) {(VEC).x *= (VALUE); (VEC).y *= (VALUE); (VEC).z *= (VALUE);}
120 
121 #define div_vec(VEC, VALUE) {(VEC).x /= (VALUE); (VEC).y /= (VALUE); (VEC).z /= (VALUE);}
122 
123 #define add_vec(RES, VEC1, VEC2) {(RES).x = (VEC1).x + (VEC2).x; \
124  (RES).y = (VEC1).y + (VEC2).y; \
125  (RES).z = (VEC1).z + (VEC2).z;}
126 
127 #define sub_vec(RES, VEC1, VEC2) {(RES).x = (VEC1).x - (VEC2).x; \
128  (RES).y = (VEC1).y - (VEC2).y; \
129  (RES).z = (VEC1).z - (VEC2).z;}
130 
131 
132 #define dot_product(VEC1, VEC2) ((VEC1).x * (VEC2).x + (VEC1).y * (VEC2).y + (VEC1).z * (VEC2).z)
133 
134 #define cross_product(RES, VEC1, VEC2) {(RES).x = (VEC1).y * (VEC2).z - (VEC1).z * (VEC2).y; \
135  (RES).y = (VEC1).z * (VEC2).x - (VEC1).x * (VEC2).z; \
136  (RES).z = (VEC1).x * (VEC2).y - (VEC1).y * (VEC2).x;}
137 
138 
139 #define array(MAT,ROWS,COLS,ROW,COL) MAT[(ROW)*(COLS)+(COL)]
140 
141 
142 
143 #define expand_ellipsoid(ELLIPSOID) {(ELLIPSOID).max += epsilon; \
144  (ELLIPSOID).min += epsilon; \
145  (ELLIPSOID).mid += epsilon;}
146 #define shrink_ellipsoid(ELLIPSOID) {(ELLIPSOID).max -= epsilon; \
147  (ELLIPSOID).min -= epsilon; \
148  (ELLIPSOID).mid -= epsilon;}
149 
150 #define expand_ellipse(ELLIPSE) {(ELLIPSE).max += epsilon; \
151  (ELLIPSE).min += epsilon;}
152 #define shrink_ellipse(ELLIPSE) {(ELLIPSE).max -= epsilon; \
153  (ELLIPSE).min -= epsilon;}
154 
155 
156 // ******************************************************************************************
157 // ************************************** TYPEDEF ***************************************
158 // ******************************************************************************************
159 
160 
161 // typedef enum logic logic;
162 // typedef enum geometry geometry;
163 //
164 // typedef struct point_rec point_rec;
165 //
166 // typedef struct ellipsoid_rec ellipsoid_rec;
167 // typedef struct ellipse_rec ellipse_rec;
168 // typedef struct cylinder_rec cylinder_rec;
169 // typedef struct block_rec block_rec;
170 // typedef struct crack_rec crack_rec;
171 //
172 // typedef struct trans_matrix trans_matrix;
173 //
174 //
175 enum logic { NO = 0, YES = 1 };
176 //
177 // enum geometry { CYLINDER = 1, BLOCK = 2 };
178 //
179 //
180 //
181 //
182 //
183 // struct ellipse_rec{
184 // point_rec center;
185 // point_rec major, minor, normal; /* must be righthanded Cartesian coordinate system */
186 // double max, min;
187 // point_rec pnt0, pnt1, pnt2;
188 // };
189 //
190 //
191 // struct cylinder_rec{
192 // point_rec lower_center, upper_center;
193 // double radius, height;
194 // double internal_msz, boundary_msz;
195 // int property;
196 // logic periodic;
197 // };
198 //
199 //
200 // struct block_rec{
201 // point_rec ll_corner, ur_corner;
202 // double size_x, size_y, size_z;
203 // double internal_msz, boundary_msz;
204 // int property;
205 // logic periodic;
206 // };
207 //
208 //
209 // struct crack_rec{
210 // int id;
211 // ellipsoid_rec *ellipsoid;
212 // ellipse_rec crack; /* q1, t1 --> q2, t2 */
213 // ellipse_rec contact; /* qa, ta --> qb, tb */
214 // point_rec pnt1, pnt2; /* crack elliptic arc goes ccw from pnt1 to pnt2 */
215 // double t1, t2, ta, tb;
216 // int q1, q2, qa, qb;
217 // int interface, bc;
218 // logic segment;
219 // double crack_msz, tip_msz;
220 // int patch;
221 // char bc_spec[128];
222 // };
223 //
224 //
225 
226 // ******************************************************************************************
227 // *************************************** STATIC ***************************************
228 // ******************************************************************************************
229 
230 // static char *geom_file_name = NULL;
231 // static char *t3d_in_file_name = NULL;
232 // static char *ctrl_file_name = NULL;
233 //
234 // static FILE *geom_file = NULL;
235 // static FILE *t3d_in_file = NULL;
236 // static FILE *ctrl_file = NULL;
237 //
238 static double epsilon = EPSILON;
239 //
240 // static double gmsz = 0.0;
241 // static int prop = 0;
242 //
243 // static char line_buffer[BUFFER_SIZE];
244 //
245 // static int vertex_id = 0;
246 // static int curve_id = 0;
247 // static int surface_id = 0;
248 // static int region_id = 0;
249 // static int patch_id = 0;
250 // static int shell_id = 0;
251 //
252 //
253 // static logic default_msz = NO;
254 // static logic bc = NO;
255 //
256 // // #ifdef ELIXIR
257 // //
258 // // #define FONT "-adobe-courier-bold-r-normal--*-120-*-*-m-*-iso8859-1"
259 // //
260 // // static EPixel green, red, yellow, blue, magenta, black;
261 // // static Font font;
262 // // static logic draw = NO;
263 // //
264 // // static void
265 // // draw_number(point_rec *pnt, EPixel color, int number, char *prefix);
266 // // static void
267 // // draw_point(point_rec *pnt, EPixel color);
268 // // static void
269 // // draw_line(point_rec *pnt1, point_rec *pnt2, EPixel color);
270 // // static void
271 // // draw_elliptic_arc(point_rec *pnt1, point_rec *pnt2, point_rec *pnt3, double w1, double w2, double w3, EPixel color);
272 // //
273 // // static void
274 // // draw_elliptic_arc_segment(ellipse_rec *ellipse, int q, double ta, double tb, point_rec *pointa, point_rec *pointb,
275 // // trans_matrix *trans, EPixel color);
276 // // static void
277 // // draw_elliptic_arc_start_segment(ellipse_rec *ellipse, int q, double t, point_rec *point, trans_matrix *trans, EPixel color);
278 // // static void
279 // // draw_elliptic_arc_end_segment(ellipse_rec *ellipse, int q, double t, point_rec *point, trans_matrix *trans, EPixel color);
280 // //
281 // // static void
282 // // draw_cylinder(cylinder_rec *cylinder, EPixel color);
283 // // static void
284 // // draw_block(block_rec *block, EPixel color);
285 // // static void
286 // // draw_ellipsoid(ellipsoid_rec *ellipsoid, EPixel color);
287 // // static void
288 // // draw_ellipse(ellipse_rec *ellipse, EPixel color);
289 // // static void
290 // // draw_crack(crack_rec *crack, EPixel color);
291 // // #endif
292 //
293 //
294 // static void write_ellipsoid(ellipsoid_rec *ellipsoid);
295 // static void write_crack(crack_rec *crack);
296 // static void write_cylinder(cylinder_rec *cylinder, ellipsoid_rec *ellipsoid_array, crack_rec *crack_array, int ellipsoids, int cracks);
297 // static void write_block(block_rec *block, ellipsoid_rec *ellipsoid_array, crack_rec *crack_array, int ellipsoids, int cracks);
298 // static void write_super_block(block_rec *block);
299 //
300 // static logic check_ellipsoid_inside_cylinder(ellipsoid_rec *ellipsoid, cylinder_rec *cylinder);
301 // static logic check_ellipsoid_inside_block(ellipsoid_rec *ellipsoid, block_rec *block);
302 
303 // static logic check_crack_cylinder_intersection(crack_rec *crack, cylinder_rec *cylinder);
304 // static logic check_crack_block_intersection(crack_rec *crack, block_rec *block);
305 // static logic check_crack_ellipsoid_intersection(crack_rec *crack, ellipsoid_rec *ellipsoid);
306 // static logic check_crack_crack_intersection(crack_rec *crack1, crack_rec *crack2);
307 //
308 // /* 3D functions */
309 //
311 static bool check_point_inside_ellipsoid (point_rec *point, ellipsoid_rec *ellipsoid);
312 //
313 // static logic get_ellipsoid_plane_intersection(ellipsoid_rec *ellipsoid, point_rec *center, point_rec *normal, ellipse_rec *ellipse);
314 // static void get_ellipsoid_line_center_intersection(ellipsoid_rec *ellipsoid, point_rec *dir, point_rec *pnt1, point_rec *pnt2);
315 // static logic get_cylinder_plane_intersection(cylinder_rec *cylinder, point_rec *point, point_rec *normal, ellipse_rec *ellipse);
316 // static logic get_plane_plane_intersection(point_rec *center1, point_rec *normal1, point_rec *center2, point_rec *normal2,
317 // point_rec *point, point_rec *dir);
318 // static logic get_plane_line_intersection(point_rec *point, point_rec *normal, point_rec *pnt, point_rec *dir, point_rec *intersection);
319 //
320 // static double project_point_to_plane(point_rec *pnt, point_rec *point, point_rec *normal, point_rec *projection);
321 //
322 
324 static int project_point_to_ellipsoid (point_rec *point, ellipsoid_rec *ellipsoid, point_rec *pnt, double *u_par, double *v_par);
325 
327 static void get_ellipsoid_point_octant(ellipsoid_rec *ellipsoid, int octant, double u, double v, point_rec *pnt);
328 //
329 // static void get_ellipsoid_normal_octant(ellipsoid_rec *ellipsoid, int octant, double u, double v, point_rec *normal);
330 //
331 static void get_ellipsoid_point (ellipsoid_rec *ellipsoid, double u, double v, point_rec *pnt);
332 static double get_ellipsoid_u_gradient(ellipsoid_rec *ellipsoid, double u, double v, point_rec *u_grad);
333 static double get_ellipsoid_v_gradient(ellipsoid_rec *ellipsoid, double u, double v, point_rec *v_grad);
334 // static void get_ellipsoid_normal(ellipsoid_rec *ellipsoid, double u, double v, point_rec *normal);
335 //
336 // /* 2D functions */
337 //
338 // static logic check_point_inside_ellipse(point_rec *point, ellipse_rec *ellipse, double *value);
339 //
340 // static int get_ellipse_line_intersection(ellipse_rec *ellipse, point_rec *point, point_rec *dir, point_rec *intersection);
341 // static void get_ellipse_line_center_intersection(ellipse_rec *ellipse, point_rec *dir, point_rec *pnt1, point_rec *pnt2);
342 // static int get_ellipse_ellipse_intersection(ellipse_rec *ellipse1, ellipse_rec *ellipse2, point_rec *intersection);
343 //
344 // static void get_ellipse_ellipse_interval_intersection(ellipse_rec *ellipse1, ellipse_rec *ellipse2, int q, double t, double val, double dt,
345 // point_rec *point);
346 //
347 // static int project_point_to_ellipse(point_rec *point, ellipse_rec *ellipse, point_rec *pnt, double *t_par);
348 //
349 // static void get_ellipse_point_quadrant(ellipse_rec *ellipse, int quadrant, double t, point_rec *pnt);
350 // static double get_ellipse_gradient_quadrant(ellipse_rec *ellipse, int quadrant, double t, point_rec *grad);
351 // static void get_ellipse_normal_quadrant(ellipse_rec *ellipse, int quadrant, double t, point_rec *normal);
352 //
353 // static void get_ellipse_point(ellipse_rec *ellipse, double t, point_rec *pnt);
354 // static double get_ellipse_gradient(ellipse_rec *ellipse, double t, point_rec *grad);
355 // static void get_ellipse_normal(ellipse_rec *ellipse, double t, point_rec *normal);
356 //
357 //
358 // static logic check_point_on_crack_tip(point_rec *point, crack_rec *crack);
359 // static logic check_point_on_ellipse_interval(int q, double t, int q1, double t1, int q2, double t2);
360 //
361 
362 static void transform_from_global_to_local(point_rec *global, point_rec *local, point_rec *origin, trans_matrix *trans);
363 static void transform_from_local_to_global(point_rec *global, point_rec *local, point_rec *origin, trans_matrix *trans);
364 static void invert_transformation (trans_matrix *trans);
365 
366 //
367 //
368 // static char * get_next_record(FILE *file, char *file_name, char *err_msg);
369 // static char * get_next_relevant_record(FILE *file, char *file_name, char *err_msg);
370 //
371 // static void write_record(FILE *file, char *file_name, char *buffer);
372 //
373 static void error_message (int exit_code, const char *format, ...);
374 //
375 // logic solve_full_system(double *a, double *x, double *y, long n, long m);
376 
377 
378 // ******************************************************************************************
379 // **************************************** MAIN ****************************************
380 // ******************************************************************************************
381 // ///
382 // int main(int argc, char** argv)
383 // {
384 // cylinder_rec cylinder;
385 // block_rec block, super_block;
386 // ellipsoid_rec *ellipsoid_array = NULL, *ellipsoid = NULL, *el = NULL;
387 // crack_rec *crack_array = NULL, *crack = NULL, *cr = NULL;
388 // ellipse_rec *contact = NULL, *ellipse = NULL;
389 // point_rec point, pnt[4], p, ctrl_pnt;
390 // trans_matrix trans;
391 // double msz, size, value, val, t, tt[4], ttt, t1, t2;
392 // int i, j, k, ellipsoid_id, ellipsoids, cracks, points, count, q, qq[4], qqq, q1, q2, incr = 0;
393 // int vertices, curves, surfaces, patches, shells, regions, interfaces = 0;
394 // char buffer[1024], text[1024];
395 // logic selected, super = NO;
396 // int type = 0, periodic, output;
397 
398 // ***********************************************************
399 // *** *** *** COMMAND LINE PARAMETERS *** *** ***
400 // ***********************************************************
401 
402 // // #ifdef ELIXIR
403 // // EView *view;
404 // // BOOLEAN success;
405 // // #endif
406 //
407 // if(argc > 1){
408 // if(strcmp(argv[1], "-X") == 0){
409 // incr = 1;
410 //
411 // // #ifdef ELIXIR
412 // // draw = YES;
413 // // #endif
414 //
415 // argc--;
416 // }
417 // }
418 //
419 // if(argc < 4){
420 // fprintf(stderr, "\n");
421 // //#ifdef ELIXIR
422 // // fprintf(stderr, "Usage: %s [-X] geom_file t3d_file ctrl_file [epsilon]\n\n", argv[0]);
423 // //#else
424 // fprintf(stderr, "Usage: %s geom_file t3d_file ctrl_file [epsilon]\n\n", argv[0]);
425 // //#endif
426 // fprintf(stderr, " geom_file: description of geometry - input file\n");
427 // fprintf(stderr, " t3d_file : description of t3d model - output file\n");
428 // fprintf(stderr, " ctrl_file: t3d2merlin ctrl file (fragment) - output file\n\n");
429 // fprintf(stderr, " gtype (cylinder [-]%d or block [-]%d [in super block])\n", CYLINDER, BLOCK);
430 // fprintf(stderr, " llcorner urcorner msz bmsz material periodic (for super block)\n");
431 // fprintf(stderr, " center radius height msz bmsz material periodic (for cylinder)\n");
432 // fprintf(stderr, " llcorner urcorner msz bmsz material periodic (for block)\n");
433 // fprintf(stderr, " # of inclusions\n");
434 // fprintf(stderr, " center point pnt max min mid msz bmsz material interface bc\n");
435 // fprintf(stderr, " # of cracks\n");
436 // fprintf(stderr, " inclusion [pnt] center normal point max min msz tipmsz interface bc\n");
437 // fprintf(stderr, " # of ctrl points\n");
438 // fprintf(stderr, " point msz\n\n");
439 // exit(1);
440 // }
441 //
442 // geom_file_name = argv[incr + 1];
443 // t3d_in_file_name = argv[incr + 2];
444 // ctrl_file_name = argv[incr + 3];
445 //
446 // if(argc > 4)epsilon = atof(argv[incr + 4]);
447 // if(epsilon < 0.0){
448 // error_message(WARNING, "Positive epsilon required ==> zero used by default");
449 // epsilon = 0.0;
450 // }
451 
452 
453 // ******************************************************
454 // *** *** *** INPUT FILE READING *** *** ***
455 // ******************************************************
456 
457 // if((geom_file = fopen(geom_file_name, "r")) == NULL)error_message(FILE_OPEN_ERROR, "File %s opening error", geom_file_name);
458 // if((t3d_in_file = fopen(t3d_in_file_name, "w")) == NULL)error_message(FILE_OPEN_ERROR, "File %s opening error", t3d_in_file_name);
459 // if((ctrl_file = fopen(ctrl_file_name, "w")) == NULL)error_message(FILE_OPEN_ERROR, "File %s opening error", ctrl_file_name);
460 //
461 // //#ifdef ELIXIR
462 // // if(draw == YES){
463 // // if(ESIBuildInterface(ESI_GRAPHIC_EDITOR_MASK, 1, argv) != 0){
464 // // fprintf(stderr, "Graphic interface error\n");
465 // // exit(1);
466 // // }
467 // // ESIPopup();
468 // // view = ElixirNewView("Meso3D", "Meso3D", "midnightblue", "white", 400, 400);
469 // // EMAttachView(ESIModel(), view);
470 // // EVSetViewOrientation(view, VIEW_ORIENT_ISO);
471 // // EVShowAxes(view, YES);
472 // // ESIHandleCmd("render ambient 0.1");
473 // // EVSetRenderMode(view, NORMAL_RENDERING);
474 // //
475 // // green = ColorGetPixelFromString("green", &success);
476 // // red = ColorGetPixelFromString("red", &success);
477 // // yellow = ColorGetPixelFromString("yellow", &success);
478 // // blue = ColorGetPixelFromString("blue", &success);
479 // // magenta = ColorGetPixelFromString("magenta", &success);
480 // // black = ColorGetPixelFromString("black", &success);
481 // //
482 // // font = FontGetFontFromString(FONT, &success);
483 // // if(success == NO)font = FontDefaultFont();
484 // // }
485 // //#endif
486 //
487 // get_next_relevant_record(geom_file, geom_file_name, "Missing problem description");
488 // strcpy(text, line_buffer);
489 //
490 // get_next_relevant_record(geom_file, geom_file_name, "Missing geometry type");
491 // if(sscanf(line_buffer, "%d", &type) != 1)
492 // error_message(INPUT_ERROR, "Invalid record - geometry type");
493 //
494 // if(type < 0){
495 // get_next_relevant_record(geom_file, geom_file_name, "Missing super block description");
496 // if(sscanf(line_buffer, "%lf %lf %lf %lf %lf %lf %lf %lf %d %d",
497 // &(super_block.ll_corner.x), &(super_block.ll_corner.y), &(super_block.ll_corner.z),
498 // &(super_block.ur_corner.x), &(super_block.ur_corner.y), &(super_block.ur_corner.z),
499 // &(super_block.internal_msz), &(super_block.boundary_msz), &(super_block.property), &periodic) != 10)
500 // error_message(INPUT_ERROR, "Invalid record - super block description");
501 //
502 // super_block.size_x = super_block.ur_corner.x - super_block.ll_corner.x;
503 // super_block.size_y = super_block.ur_corner.y - super_block.ll_corner.y;
504 // super_block.size_z = super_block.ur_corner.z - super_block.ll_corner.z;
505 // if(super_block.size_x <= 0 || super_block.size_y <= 0 || super_block.size_z <= 0)
506 // error_message(INPUT_ERROR, "Invalid super block corners");
507 // if(super_block.internal_msz < 0.0)
508 // error_message(INPUT_ERROR, "Positive internal super block mesh size required");
509 // if(super_block.boundary_msz < 0.0)
510 // error_message(INPUT_ERROR, "Positive boundary super block mesh size required");
511 // if(super_block.property <= 0)
512 // error_message(INPUT_ERROR, "Positive super block material required");
513 // switch(periodic){
514 // case 0:
515 // super_block.periodic = NO;
516 // break;
517 // case 1:
518 // super_block.periodic = YES;
519 // break;
520 // default:
521 // error_message(INPUT_ERROR, "Invalid super block periodicity");
522 // break;
523 // }
524 //
525 // //#ifdef ELIXIR
526 // // if(draw == YES){
527 // // draw_block(&super_block, green);
528 // // EVFitAllIntoView(view);
529 // //
530 // //#ifdef DEBUG
531 // // ESIEventLoop(YES, "Super block");
532 // //#endif
533 // //
534 // // }
535 // //#endif
536 //
537 // type = -type;
538 // super = YES;
539 // }
540 
541 // *************************************************************
542 // *** *** *** CYLINDER OR BLOCK READING *** *** ***
543 // *************************************************************
544 
545 // switch(type){
546 // case CYLINDER:
547 // get_next_relevant_record(geom_file, geom_file_name, "Missing cylinder description");
548 // if(sscanf(line_buffer, "%lf %lf %lf %lf %lf %lf %lf %d %d",
549 // &(cylinder.lower_center.x), &(cylinder.lower_center.y), &(cylinder.lower_center.z),
550 // &(cylinder.radius), &(cylinder.height),
551 // &(cylinder.internal_msz), &(cylinder.boundary_msz), &(cylinder.property), &periodic) != 9)
552 // error_message(INPUT_ERROR, "Invalid record - cylinder description");
553 //
554 // if(cylinder.radius <= 0)
555 // error_message(INPUT_ERROR, "Positive cylinder radius required");
556 // if(cylinder.height <= 0)
557 // error_message(INPUT_ERROR, "Positive cylinder height required");
558 //
559 // copy_vec(cylinder.upper_center, cylinder.lower_center);
560 // cylinder.upper_center.z += cylinder.height;
561 //
562 // if(super == YES){
563 // if(cylinder.lower_center.x - cylinder.radius <= super_block.ll_corner.x || cylinder.lower_center.x + cylinder.radius >= super_block.ur_corner.x ||
564 // cylinder.lower_center.y - cylinder.radius <= super_block.ll_corner.y || cylinder.lower_center.y + cylinder.radius >= super_block.ur_corner.y ||
565 // cylinder.lower_center.z <= super_block.ll_corner.z || cylinder.upper_center.z >= super_block.ur_corner.z)
566 // error_message(INPUT_ERROR, "Cylinder is not inside super block");
567 // }
568 //
569 // if(cylinder.internal_msz < 0.0)
570 // error_message(INPUT_ERROR, "Positive internal cylinder mesh size required");
571 // if(cylinder.boundary_msz < 0.0)
572 // error_message(INPUT_ERROR, "Positive boundary cylinder mesh size required");
573 // if(cylinder.property <= 0)
574 // error_message(INPUT_ERROR, "Positive cylinder material required");
575 // switch(periodic){
576 // case 0:
577 // cylinder.periodic = NO;
578 // break;
579 // case 1:
580 // cylinder.periodic = YES;
581 // break;
582 // default:
583 // error_message(INPUT_ERROR, "Invalid cylinder periodicity");
584 // break;
585 // }
586 //
587 // gmsz = cylinder.internal_msz;
588 // prop = cylinder.property;
589 //
590 // //#ifdef ELIXIR
591 // // if(draw == YES){
592 // // draw_cylinder(&cylinder, green);
593 // // EVFitAllIntoView(view);
594 // //
595 // //#ifdef DEBUG
596 // // ESIEventLoop(YES, "Matrix");
597 // //#endif
598 // //
599 // // }
600 // //#endif
601 //
602 // break;
603 // case BLOCK:
604 // get_next_relevant_record(geom_file, geom_file_name, "Missing block description");
605 // if(sscanf(line_buffer, "%lf %lf %lf %lf %lf %lf %lf %lf %d %d",
606 // &(block.ll_corner.x), &(block.ll_corner.y), &(block.ll_corner.z),
607 // &(block.ur_corner.x), &(block.ur_corner.y), &(block.ur_corner.z),
608 // &(block.internal_msz), &(block.boundary_msz), &(block.property), &periodic) != 10)
609 // error_message(INPUT_ERROR, "Invalid record - block description");
610 //
611 // block.size_x = block.ur_corner.x - block.ll_corner.x;
612 // block.size_y = block.ur_corner.y - block.ll_corner.y;
613 // block.size_z = block.ur_corner.z - block.ll_corner.z;
614 // if(block.size_x <= 0 || block.size_y <= 0 || block.size_z <= 0)
615 // error_message(INPUT_ERROR, "Invalid block corners");
616 //
617 // if(super == YES){
618 // if(block.ll_corner.x <= super_block.ll_corner.x || block.ll_corner.y <= super_block.ll_corner.y || block.ll_corner.z <= super_block.ll_corner.z ||
619 // block.ur_corner.x >= super_block.ur_corner.x || block.ur_corner.y >= super_block.ur_corner.y || block.ur_corner.z >= super_block.ur_corner.z)
620 // error_message(INPUT_ERROR, "Block is not inside super block");
621 // }
622 //
623 // if(block.internal_msz < 0.0)
624 // error_message(INPUT_ERROR, "Positive internal block mesh size required");
625 // if(block.boundary_msz < 0.0)
626 // error_message(INPUT_ERROR, "Positive boundary block mesh size required");
627 // if(block.property <= 0)
628 // error_message(INPUT_ERROR, "Positive block material required");
629 // switch(periodic){
630 // case 0:
631 // block.periodic = NO;
632 // break;
633 // case 1:
634 // block.periodic = YES;
635 // break;
636 // default:
637 // error_message(INPUT_ERROR, "Invalid block periodicity");
638 // break;
639 // }
640 //
641 // gmsz = block.internal_msz;
642 // prop = block.property;
643 //
644 // //#ifdef ELIXIR
645 // // if(draw == YES){
646 // // draw_block(&block, green);
647 // // EVFitAllIntoView(view);
648 // //
649 // //#ifdef DEBUG
650 // // ESIEventLoop(YES, "Matrix");
651 // //#endif
652 // //
653 // // }
654 // //#endif
655 //
656 // break;
657 // default:
658 // error_message(INPUT_ERROR, "Unsupported geometry type");
659 // }
660 
661 // ****************************************************
662 // *** *** *** INPUT INCLUSIONS *** *** ***
663 // ****************************************************
664 
665 
666 // get_next_relevant_record(geom_file, geom_file_name, "Missing number of inclusions");
667 // if(sscanf(line_buffer, "%d", &ellipsoids) != 1)
668 // error_message(INPUT_ERROR, "Invalid record - number of inclusions");
669 //
670 // if(ellipsoids < 0)error_message(INPUT_ERROR, "Non-negative number of inclusions required");
671 //
672 // if(ellipsoids != 0){
673 // if((ellipsoid_array = calloc(ellipsoids, sizeof(ellipsoid_rec))) == NULL)
674 // error_message(MEMORY_ERROR, "Memory allocation error");
675 //
676 // for(i = 0; i < ellipsoids; i++){
677 // ellipsoid = &(ellipsoid_array[i]);
678 // ellipsoid -> id = i + 1;
679 //
680 // get_next_relevant_record(geom_file, geom_file_name, "Missing inclusion description");
681 // if(sscanf(line_buffer, "%lf %lf %lf %lf %lf %lf %lf %lf %lf %lf %lf %lf %lf %lf %d %d %d",
682 // &(ellipsoid -> center.x), &(ellipsoid -> center.y), &(ellipsoid -> center.z),
683 // &(ellipsoid -> major.x), &(ellipsoid -> major.y), &(ellipsoid -> major.z),
684 // &(ellipsoid -> minor.x), &(ellipsoid -> minor.y), &(ellipsoid -> minor.z),
685 // &(ellipsoid -> max), &(ellipsoid -> min), &(ellipsoid -> mid),
686 // &(ellipsoid -> internal_msz), &(ellipsoid -> boundary_msz),
687 // &(ellipsoid -> property), &(ellipsoid -> interface), &(ellipsoid -> bc)) != 17)
688 // error_message(INPUT_ERROR, "Invalid record - inclusion %d description", i + 1);
689 //
690 // if(ellipsoid -> max <= 0.0)
691 // error_message(INPUT_ERROR, "Positive major half-axis size of inclusion %d required", i + 1);
692 // if(ellipsoid -> min <= 0.0)
693 // error_message(INPUT_ERROR, "Positive minor half-axis size of inclusion %d required", i + 1);
694 // if(ellipsoid -> min > ellipsoid -> max || ellipsoid -> mid < ellipsoid -> min || ellipsoid -> mid > ellipsoid -> max)
695 // error_message(INPUT_ERROR, "Invalid half-axis ordering of inclusion %d", i + 1);
696 // if(ellipsoid -> internal_msz < 0.0)
697 // error_message(INPUT_ERROR, "Positive internal mesh size of inclusion %d required", i + 1);
698 // if(ellipsoid -> boundary_msz < 0.0)
699 // error_message(INPUT_ERROR, "Positive boundary mesh size of inclusion %d required", i + 1);
700 // if(ellipsoid -> property < 0)
701 // error_message(INPUT_ERROR, "Non-negative material of inclusion %d required", i + 1);
702 // if(ellipsoid -> interface < 0)
703 // error_message(INPUT_ERROR, "Non-negative interface of inclusion %d required", i + 1);
704 // if(ellipsoid -> bc < 0)
705 // error_message(INPUT_ERROR, "Non-negative boundary condition of inclusion %d required", i + 1);
706 //
707 // if(ellipsoid -> property == 0 && ellipsoid -> interface != 0){
708 // error_message(WARNING, "Empty inclusion %d cannot have interface ==> interface ignored", i + 1);
709 // ellipsoid -> interface = 0;
710 // }
711 // if(ellipsoid -> interface == 0 && ellipsoid -> bc != 0){
712 // error_message(WARNING, "Inclusion without interface cannot be subjected to bc ==> bc ignored", i + 1);
713 // ellipsoid -> bc = 0;
714 // }
715 //
716 // sub_vec(ellipsoid -> major, ellipsoid -> major, ellipsoid -> center);
717 // size = sqrt(size_vec(ellipsoid -> major));
718 // if(size < EPSILON)
719 // error_message(INPUT_ERROR, "Zero major axis of inclusion %d", i + 1);
720 // div_vec(ellipsoid -> major, size);
721 // sub_vec(ellipsoid -> minor, ellipsoid -> minor, ellipsoid -> center);
722 // size = sqrt(size_vec(ellipsoid -> minor));
723 // if(size < EPSILON)
724 // error_message(INPUT_ERROR, "Zero minor axis of inclusion %d", i + 1);
725 // div_vec(ellipsoid -> minor, size);
726 // cross_product(ellipsoid -> middle, ellipsoid -> major, ellipsoid -> minor);
727 // size = sqrt(size_vec(ellipsoid -> middle));
728 // if(size < EPSILON)
729 // error_message(INPUT_ERROR, "Colinear major and minor axes of inclusion %d", i + 1);
730 // div_vec(ellipsoid -> middle, size);
731 // cross_product(ellipsoid -> minor, ellipsoid -> middle, ellipsoid -> major);
732 //
733 // ellipsoid -> crack = NULL;
734 // ellipsoid -> region = 0;
735 //
736 // copy_vec(trans.x, ellipsoid -> major);
737 // copy_vec(trans.y, ellipsoid -> minor);
738 // copy_vec(trans.z, ellipsoid -> middle);
739 //
740 // invert_transformation(&trans);
741 //
742 // point.x = ellipsoid -> max;
743 // point.y = 0.0;
744 // point.z = 0.0;
745 // transform_from_local_to_global(&(ellipsoid -> pnt00), &point, &(ellipsoid -> center), &trans);
746 //
747 // copy_vec(ellipsoid -> pnt01, ellipsoid -> pnt00);
748 // copy_vec(ellipsoid -> pnt02, ellipsoid -> pnt00);
749 //
750 // point.x = ellipsoid -> max;
751 // point.y = ellipsoid -> min;
752 // point.z = 0.0;
753 // transform_from_local_to_global(&(ellipsoid -> pnt10), &point, &(ellipsoid -> center), &trans);
754 //
755 // point.x = ellipsoid -> max;
756 // point.y = ellipsoid -> min;
757 // point.z = ellipsoid -> mid;
758 // transform_from_local_to_global(&(ellipsoid -> pnt11), &point, &(ellipsoid -> center), &trans);
759 //
760 // point.x = ellipsoid -> max;
761 // point.y = 0.0;
762 // point.z = ellipsoid -> mid;
763 // transform_from_local_to_global(&(ellipsoid -> pnt12), &point, &(ellipsoid -> center), &trans);
764 //
765 // point.x = 0.0;
766 // point.y = ellipsoid -> min;
767 // point.z = 0.0;
768 // transform_from_local_to_global(&(ellipsoid -> pnt20), &point, &(ellipsoid -> center), &trans);
769 //
770 // point.x = 0.0;
771 // point.y = ellipsoid -> min;
772 // point.z = ellipsoid -> mid;
773 // transform_from_local_to_global(&(ellipsoid -> pnt21), &point, &(ellipsoid -> center), &trans);
774 //
775 // point.x = 0.0;
776 // point.y = 0.0;
777 // point.z = ellipsoid -> mid;
778 // transform_from_local_to_global(&(ellipsoid -> pnt22), &point, &(ellipsoid -> center), &trans);
779 //
780 // switch(type){
781 // case CYLINDER:
782 // #ifdef DEBUG
783 // fprintf(stderr, "intersection %d x cylinder\n", ellipsoid -> id);
784 // #endif
785 //
786 // if(check_ellipsoid_inside_cylinder(ellipsoid, &cylinder) == NO){
787 // error_message(WARNING, "Inclusion %d intersects cylinder ==> inclusion %d ignored", i + 1, i + 1);
788 // ellipsoid -> id = -ellipsoid -> id;
789 //
790 // //#ifdef ELIXIR
791 // // if(draw == YES){
792 // // draw_ellipsoid(ellipsoid, blue);
793 // //
794 // //#ifdef DEBUG
795 // // ESIEventLoop(YES, "Inclusion");
796 // //#endif
797 // //
798 // // }
799 // //#endif
800 //
801 // continue;
802 // }
803 // break;
804 // case BLOCK:
805 // #ifdef DEBUG
806 // fprintf(stderr, "intersection %d x block\n", ellipsoid -> id);
807 // #endif
808 //
809 // if(check_ellipsoid_inside_block(ellipsoid, &block) == NO){
810 // error_message(WARNING, "Inclusion %d intersects block ==> inclusion %d ignored", i + 1, i + 1);
811 // ellipsoid -> id = -ellipsoid -> id;
812 //
813 // //#ifdef ELIXIR
814 // // if(draw == YES){
815 // // draw_ellipsoid(ellipsoid, blue);
816 // //
817 // //#ifdef DEBUG
818 // // ESIEventLoop(YES, "Inclusion");
819 // //#endif
820 // //
821 // // }
822 // //#endif
823 //
824 // continue;
825 // }
826 // break;
827 // default:
828 // break;
829 // }
830 //
831 // for(j = 0; j < i; j++){
832 // el = &(ellipsoid_array[j]);
833 // if(el -> id < 0)continue;
834 //
835 // #ifdef DEBUG
836 // fprintf(stderr, "intersection %d x %d\n", ellipsoid -> id, el -> id);
837 // #endif
838 //
839 // if(check_ellipsoid_ellipsoid_overlap(ellipsoid, el) == YES){
840 // error_message(WARNING, "Inclusion %d intersects inclusion %d ==> inclusion %d ignored", i + 1, j + 1, i + 1);
841 // ellipsoid -> id = -ellipsoid -> id;
842 //
843 // //#ifdef ELIXIR
844 // // if(draw == YES){
845 // // draw_ellipsoid(ellipsoid, blue);
846 // //
847 // //#ifdef DEBUG
848 // // ESIEventLoop(YES, "Inclusion");
849 // //#endif
850 // //
851 // // }
852 // //#endif
853 //
854 // break;
855 // }
856 // }
857 // if(ellipsoid -> id < 0)continue;
858 //
859 // //#ifdef ELIXIR
860 // // if(draw == YES){
861 // // if(ellipsoid -> interface == 0)
862 // // draw_ellipsoid(ellipsoid, red);
863 // // else
864 // // draw_ellipsoid(ellipsoid, magenta);
865 // //
866 // //#ifdef DEBUG
867 // // ESIEventLoop(YES, "Inclusion");
868 // //#endif
869 // //
870 // // }
871 // //#endif
872 //
873 // }
874 // } // end of inclusion loop
875 
876 bool isZero (double zero, double a)
877 {
878  if (a == 0.0) return true;
879  if (-zero<a && a<zero) return true;
880  else return false;
881 }
882 
884 void check_ellipsoid_rec_consistency (meso3d::ellipsoid_rec & L)
885 {
886  if (L.max <= 0.0) meso3d::error_message (INPUT_ERROR, "Positive major half-axis size of inclusion %d required", L.id + 1);
887  if (L.min <= 0.0) meso3d::error_message (INPUT_ERROR, "Positive minor half-axis size of inclusion %d required", L.id + 1);
888 
889  if (L.min > L.max || L.mid < L.min || L.mid > L.max)
890  meso3d::error_message (INPUT_ERROR, "Invalid half-axis ordering of inclusion %d", L.id + 1);
891 
892  if (L.internal_msz < 0.0) meso3d::error_message (INPUT_ERROR, "Positive internal mesh size of inclusion %d required", L.id + 1);
893  if (L.boundary_msz < 0.0) meso3d::error_message (INPUT_ERROR, "Positive boundary mesh size of inclusion %d required", L.id + 1);
894  if (L.property < 0) meso3d::error_message (INPUT_ERROR, "Non-negative material of inclusion %d required", L.id + 1);
895  if (L.interface < 0) meso3d::error_message (INPUT_ERROR, "Non-negative interface of inclusion %d required", L.id + 1);
896  if (L.bc < 0) meso3d::error_message (INPUT_ERROR, "Non-negative boundary condition of inclusion %d required", L.id + 1);
897 
898  if (L.property == 0 && L.interface != 0) {
899  meso3d::error_message (WARNING, "Empty inclusion %d cannot have interface ==> interface ignored", L.id + 1);
900  L.interface = 0;
901  }
902  if (L.interface == 0 && L.bc != 0) {
903  meso3d::error_message (WARNING, "Inclusion without interface cannot be subjected to bc ==> bc ignored", L.id + 1);
904  L.bc = 0;
905  }
906 
907  double size;
908 
909  // TOTO tady nemusi byt, pac to je zarizeny pro vytvoreni normalovych vektoru, ktere pak tvori rotacni matici
910  // my ale uz z rotacni matice de fakto vychazime, takze major, minor a middle muzeme primo nakrmit, jsou to radky matice T na inkluzi
911  sub_vec (L.major, L.major, L.center);
912  size = sqrt (size_vec (L.major));
913  if (size < EPSILON)
914  meso3d::error_message (INPUT_ERROR, "Zero major axis of inclusion %d", L.id + 1);
915 
916  div_vec (L.major, size);
917  sub_vec (L.minor, L.minor, L.center);
918  size = sqrt (size_vec (L.minor));
919  if (size < EPSILON)
920  meso3d::error_message (INPUT_ERROR, "Zero minor axis of inclusion %d", L.id + 1);
921 
922  div_vec (L.minor, size);
923  cross_product (L.middle, L.major, L.minor);
924  size = sqrt (size_vec (L.middle));
925  if (size < EPSILON)
926  meso3d::error_message (INPUT_ERROR, "Colinear major and minor axes of inclusion %d", L.id + 1);
927 
928  div_vec (L.middle, size);
929  cross_product (L.minor, L.middle, L.major);
930  // TOTO
931 
932  double d = 0.0;
933  double zer = 1.e-6;
934  for (int i=0; i<3; i++) {
935  if (i==0) d = -1.0;
936  if (i==1) d = 0.0;
937  if (i==2) d = 1.0;
938 
939  if (isZero(zer, L.major.x - d)) L.major.x = d; if (isZero(zer, L.major.y - d)) L.major.y = d; if (isZero(zer, L.major.z - d)) L.major.z = d;
940  if (isZero(zer, L.middle.x - d)) L.middle.x = d; if (isZero(zer, L.middle.y - d)) L.middle.y = d; if (isZero(zer, L.middle.z - d)) L.middle.z = d;
941  if (isZero(zer, L.minor.x - d)) L.minor.x = d; if (isZero(zer, L.minor.y - d)) L.minor.y = d; if (isZero(zer, L.minor.z - d)) L.minor.z = d;
942  }
943 
944  return;
945 }
946 
948 void transfom_ellipsoid_rec (meso3d::ellipsoid_rec & L)
949 {
950  meso3d::trans_matrix trans;
951  meso3d::point_rec point;
952 
953  copy_vec (trans.x, L.major); copy_vec (trans.y, L.minor); copy_vec (trans.z, L.middle);
954  meso3d::invert_transformation (&trans);
955 
956  point.x = L.max; point.y = 0.0; point.z = 0.0;
957  meso3d::transform_from_local_to_global (&(L.pnt00), &point, &(L.center), &trans);
958  copy_vec (L.pnt01, L.pnt00); copy_vec (L.pnt02, L.pnt00);
959 
960  point.x = L.max; point.y = L.min; point.z = 0.0;
961  meso3d::transform_from_local_to_global (&(L.pnt10), &point, &(L.center), &trans);
962 
963  point.x = L.max; point.y = L.min; point.z = L.mid;
964  meso3d::transform_from_local_to_global (&(L.pnt11), &point, &(L.center), &trans);
965 
966  point.x = L.max; point.y = 0.0; point.z = L.mid;
967  meso3d::transform_from_local_to_global (&(L.pnt12), &point, &(L.center), &trans);
968 
969  point.x = 0.0; point.y = L.min; point.z = 0.0;
970  meso3d::transform_from_local_to_global (&(L.pnt20), &point, &(L.center), &trans);
971 
972  point.x = 0.0; point.y = L.min; point.z = L.mid;
973  meso3d::transform_from_local_to_global (&(L.pnt21), &point, &(L.center), &trans);
974 
975  point.x = 0.0; point.y = 0.0; point.z = L.mid;
976  meso3d::transform_from_local_to_global (&(L.pnt22), &point, &(L.center), &trans);
977 
978  return;
979 }
980 
981 
982 // ************************************************
983 // *** *** *** INPUT CRACKS *** *** ***
984 // ************************************************
985 
986 // get_next_relevant_record(geom_file, geom_file_name, "Missing number of cracks");
987 // if(sscanf(line_buffer, "%d", &cracks) != 1)
988 // error_message(INPUT_ERROR, "Invalid record - number of cracks");
989 //
990 // if(cracks < 0)error_message(INPUT_ERROR, "Non-negative number of cracks required");
991 //
992 // if(cracks != 0){
993 // if((crack_array = calloc(cracks, sizeof(crack_rec))) == NULL)
994 // error_message(MEMORY_ERROR, "Memory allocation error");
995 //
996 // for(i = 0; i < cracks; i++){
997 // crack = &(crack_array[i]);
998 // crack -> id = i + 1;
999 //
1000 // ellipse = &(crack -> crack);
1001 //
1002 // get_next_relevant_record(geom_file, geom_file_name, "Missing crack description");
1003 // if(sscanf(line_buffer, "%d", &ellipsoid_id) != 1)
1004 // error_message(INPUT_ERROR, "Invalid record - crack %d description", i + 1);
1005 //
1006 // if(ellipsoid_id != 0){
1007 // if(sscanf(line_buffer, "%d %lf %lf %lf %lf %lf %lf %lf %lf %lf %lf %lf %lf %lf %lf %lf %lf %d %d", &ellipsoid_id,
1008 // &(ctrl_pnt.x), &(ctrl_pnt.y), &(ctrl_pnt.z),
1009 // &(ellipse -> center.x), &(ellipse -> center.y), &(ellipse -> center.z),
1010 // &(ellipse -> normal.x), &(ellipse -> normal.y), &(ellipse -> normal.z),
1011 // &(ellipse -> major.x), &(ellipse -> major.y), &(ellipse -> major.z),
1012 // &(ellipse -> max), &(ellipse -> min), &(crack -> crack_msz), &(crack -> tip_msz),
1013 // &(crack -> interface), &(crack -> bc)) != 19)
1014 // error_message(INPUT_ERROR, "Invalid record - crack %d description", i + 1);
1015 // }
1016 // else{
1017 // if(sscanf(line_buffer, "%d %lf %lf %lf %lf %lf %lf %lf %lf %lf %lf %lf %lf %lf %d %d", &ellipsoid_id,
1018 // &(ellipse -> center.x), &(ellipse -> center.y), &(ellipse -> center.z),
1019 // &(ellipse -> normal.x), &(ellipse -> normal.y), &(ellipse -> normal.z),
1020 // &(ellipse -> major.x), &(ellipse -> major.y), &(ellipse -> major.z),
1021 // &(ellipse -> max), &(ellipse -> min), &(crack -> crack_msz), &(crack -> tip_msz),
1022 // &(crack -> interface), &(crack -> bc)) != 16)
1023 // error_message(INPUT_ERROR, "Invalid record - crack %d description", i + 1);
1024 // }
1025 //
1026 // if(ellipsoid_id < 0 || ellipsoid_id > ellipsoids)
1027 // error_message(INPUT_ERROR, "Invalid inclusion number for crack %d", i + 1);
1028 // if(ellipse -> max <= 0.0)
1029 // error_message(INPUT_ERROR, "Positive major half-axis size of crack %d required", i + 1);
1030 // if(ellipse -> min <= 0.0)
1031 // error_message(INPUT_ERROR, "Positive minor half-axis size of crack %d required", i + 1);
1032 // if(ellipse -> min > ellipse -> max)
1033 // error_message(INPUT_ERROR, "Invalid half-axis ordering of crack %d", i + 1);
1034 // if(crack -> crack_msz < 0.0)
1035 // error_message(INPUT_ERROR, "Positive mesh size of crack %d required", i + 1);
1036 // if(crack -> tip_msz < 0.0)
1037 // error_message(INPUT_ERROR, "Positive tip mesh size of crack %d required", i + 1);
1038 // if(crack -> interface < 0)
1039 // error_message(INPUT_ERROR, "Positive interface of crack %d required", i + 1);
1040 // if(crack -> bc < 0)
1041 // error_message(INPUT_ERROR, "Non-negative boundary condition of crack %d required", i + 1);
1042 //
1043 // size = sqrt(size_vec(ellipse -> normal));
1044 // if(size < EPSILON)
1045 // error_message(INPUT_ERROR, "Zero normal of crack %d", i + 1);
1046 // div_vec(ellipse -> normal, size);
1047 //
1048 // project_point_to_plane(&(ellipse -> major), &(ellipse -> center), &(ellipse -> normal), &point);
1049 // sub_vec(ellipse -> major, point, ellipse -> center);
1050 // size = sqrt(size_vec(ellipse -> major));
1051 // if(size < EPSILON)
1052 // error_message(INPUT_ERROR, "Zero major axis of crack %d", i + 1);
1053 // div_vec(ellipse -> major, size);
1054 // cross_product(ellipse -> minor, ellipse -> normal, ellipse -> major);
1055 //
1056 // crack -> ellipsoid = NULL;
1057 // crack -> patch = 0;
1058 // crack -> segment = NO;
1059 //
1060 // copy_vec(trans.x, ellipse -> major);
1061 // copy_vec(trans.y, ellipse -> minor);
1062 // copy_vec(trans.z, ellipse -> normal);
1063 //
1064 // invert_transformation(&trans);
1065 //
1066 // point.x = ellipse -> max;
1067 // point.y = 0.0;
1068 // point.z = 0.0;
1069 // transform_from_local_to_global(&(ellipse -> pnt0), &point, &(ellipse -> center), &trans);
1070 //
1071 // point.x = ellipse -> max;
1072 // point.y = ellipse -> min;
1073 // point.z = 0.0;
1074 // transform_from_local_to_global(&(ellipse -> pnt1), &point, &(ellipse -> center), &trans);
1075 //
1076 // point.x = 0.0;
1077 // point.y = ellipse -> min;
1078 // point.z = 0.0;
1079 // transform_from_local_to_global(&(ellipse -> pnt2), &point, &(ellipse -> center), &trans);
1080 //
1081 // if(ellipsoid_id == 0){
1082 // ellipsoid = NULL;
1083 //
1084 // for(j = 0; j < ellipsoids; j++){
1085 // el = &(ellipsoid_array[j]);
1086 // if(el -> id < 0)continue;
1087 // if(check_crack_ellipsoid_intersection(crack, el) == YES){
1088 // error_message(WARNING, "Crack %d intersects inclusion %d ==> crack %d ignored", i + 1, j + 1, i + 1);
1089 // crack -> id = -crack -> id;
1090 //
1091 // //#ifdef ELIXIR
1092 // // if(draw == YES){
1093 // // draw_crack(crack, blue);
1094 // //
1095 // //#ifdef DEBUG
1096 // // ESIEventLoop(YES, "Crack");
1097 // //#endif
1098 // //
1099 // // }
1100 // //#endif
1101 //
1102 // break;
1103 // }
1104 // }
1105 // if(crack -> id < 0)continue;
1106 // }
1107 // else{
1108 // ellipsoid = &(ellipsoid_array[ellipsoid_id - 1]);
1109 // contact = &(crack -> contact);
1110 //
1111 // if(get_ellipsoid_plane_intersection(ellipsoid, &(ellipse -> center), &(ellipse -> normal), contact) == NO){
1112 // error_message(WARNING, "Crack %d does not intersect inclusion %d ==> crack %d ignored", i + 1, ellipsoid_id, i + 1);
1113 // crack -> id = -crack -> id;
1114 //
1115 // //#ifdef ELIXIR
1116 // // if(draw == YES){
1117 // // draw_crack(crack, blue);
1118 // //
1119 // //#ifdef DEBUG
1120 // // ESIEventLoop(YES, "Crack");
1121 // //#endif
1122 // //
1123 // // }
1124 // //#endif
1125 //
1126 // continue;
1127 // }
1128 //
1129 // project_point_to_plane(&ctrl_pnt, &(ellipse -> center), &(ellipse -> normal), &point);
1130 //
1131 // /* crack control point must be outside inclusion and inside crack */
1132 // check_point_inside_ellipse(&point, contact, &value);
1133 // check_point_inside_ellipse(&point, ellipse, &val);
1134 //
1135 // if(value < -EPSILON || val > EPSILON || (value < 0.0 && val > -EPSILON)){
1136 // error_message(WARNING, "Invalid control point of crack %d ==> crack %d ignored", i + 1, i + 1);
1137 // crack -> id = -crack -> id;
1138 //
1139 // //#ifdef ELIXIR
1140 // // if(draw == YES){
1141 // // draw_crack(crack, blue);
1142 // //
1143 // //#ifdef DEBUG
1144 // // ESIEventLoop(YES, "Crack");
1145 // //#endif
1146 // //
1147 // // }
1148 // //#endif
1149 //
1150 // continue;
1151 // }
1152 //
1153 // count = get_ellipse_ellipse_intersection(contact, ellipse, pnt);
1154 // if(count == 1 || count == 3){
1155 // error_message(WARNING, "Crack %d is touching inclusion %d ==> crack %d ignored", i + 1, ellipsoid_id, i + 1);
1156 // crack -> id = -crack -> id;
1157 //
1158 // //#ifdef ELIXIR
1159 // // if(draw == YES){
1160 // // draw_crack(crack, blue);
1161 // //
1162 // //#ifdef DEBUG
1163 // // ESIEventLoop(YES, "Crack");
1164 // //#endif
1165 // //
1166 // // }
1167 // //#endif
1168 //
1169 // continue;
1170 // }
1171 //
1172 // if(count == 0){
1173 // if(check_point_inside_ellipse(&(contact -> pnt0), ellipse, &value) == NO){
1174 // error_message(WARNING, "Crack %d does not intersect inclusion %d ==> crack %d ignored", i + 1, ellipsoid_id, i + 1);
1175 // crack -> id = -crack -> id;
1176 //
1177 // //#ifdef ELIXIR
1178 // // if(draw == YES){
1179 // // draw_crack(crack, blue);
1180 // //
1181 // //#ifdef DEBUG
1182 // // ESIEventLoop(YES, "Crack");
1183 // //#endif
1184 // //
1185 // // }
1186 // //#endif
1187 //
1188 // continue;
1189 // }
1190 //
1191 // point.x = ellipse -> max;
1192 // point.y = 0.0;
1193 // point.z = 0.0;
1194 // transform_from_local_to_global(&(crack -> pnt1), &point, &(ellipse -> center), &trans);
1195 //
1196 // point.x = -ellipse -> max;
1197 // point.y = 0.0;
1198 // point.z = 0.0;
1199 // transform_from_local_to_global(&(crack -> pnt2), &point, &(ellipse -> center), &trans);
1200 // }
1201 // else{
1202 //
1203 // /* note: this algorihm may select improper part of the crack for count == 3
1204 // if the crack is touching ellipsoid from outside;
1205 // then there are two consequent intervals on contact ellipse inside crack ellipse;
1206 // thus if the control point is projected very close to the interface of these
1207 // two intervals, the improper interval may be selected;
1208 // therefore the odd count was eliminated */
1209 //
1210 // q = project_point_to_ellipse(&point, contact, &p, &t);
1211 // if(check_point_inside_ellipse(&p, ellipse, &val) == YES){
1212 // for(j = 0; j < count; j++){
1213 // qq[j] = project_point_to_ellipse(&pnt[j], contact, &p, &tt[j]);
1214 // }
1215 //
1216 // selected = NO;
1217 // for(j = 0; j < count; j++){
1218 // if((k = j + 1) == count)k = 0;
1219 // if(check_point_on_ellipse_interval(q, t, q1 = qq[j], t1 = tt[j], q2 = qq[k], t2 = tt[k]) == YES){
1220 //
1221 // /* check whether this interval (point in the middle of the interval) is inside crack */
1222 // if(q1 == q2){
1223 // if(q1 == 1 || q1 == 3){
1224 // if(t1 < t2){
1225 // qqq = q1;
1226 // ttt = (t1 + t2) / 2.0;
1227 // }
1228 // else{
1229 // qqq = q1 + 2;
1230 // ttt = 0.5;
1231 // }
1232 // }
1233 // else{
1234 // if(t1 > t2){
1235 // qqq = q1;
1236 // ttt = (t1 + t2) / 2.0;
1237 // }
1238 // else{
1239 // qqq = q1 + 2;
1240 // ttt = 0.5;
1241 // }
1242 // }
1243 // }
1244 // else{
1245 // if(q2 < q1)q2 += 4;
1246 //
1247 // if(q2 > q1 + 1){
1248 // qqq = q1 + 1;
1249 // ttt = 0.5;
1250 // }
1251 // else{
1252 // qqq = q1;
1253 // if(q1 == 1 || q1 == 3){
1254 // ttt = (t1 - t2 + 2.0) / 2.0;
1255 // if(ttt > 1.0){
1256 // ttt = 2.0 - ttt;
1257 // qqq++;
1258 // }
1259 // }
1260 // else{
1261 // ttt = (t1 - t2) / 2.0;
1262 // if(ttt < 0.0){
1263 // ttt = -ttt;
1264 // qqq++;
1265 // }
1266 // }
1267 // }
1268 //
1269 // if(q2 > 4)q2 -= 4;
1270 // }
1271 // if(qqq > 4)qqq -= 4;
1272 //
1273 // get_ellipse_point_quadrant(contact, qqq, ttt, &point);
1274 // if(check_point_inside_ellipse(&point, ellipse, &val) == YES){
1275 // copy_vec(crack -> pnt1, pnt[j]);
1276 // copy_vec(crack -> pnt2, pnt[k]);
1277 //
1278 // crack -> q1 = project_point_to_ellipse(&(crack -> pnt1), ellipse, &p, &(crack -> t1));
1279 // crack -> q2 = project_point_to_ellipse(&(crack -> pnt2), ellipse, &p, &(crack -> t2));
1280 //
1281 // crack -> qa = q1;
1282 // crack -> ta = t1;
1283 // crack -> qb = q2;
1284 // crack -> tb = t2;
1285 //
1286 // selected = YES;
1287 // break;
1288 // }
1289 // }
1290 // }
1291 // }
1292 // else{
1293 // q = project_point_to_ellipse(&p, ellipse, &point, &t);
1294 // for(j = 0; j < count; j++){
1295 // qq[j] = project_point_to_ellipse(&pnt[j], ellipse, &point, &tt[j]);
1296 // }
1297 //
1298 // selected = NO;
1299 // for(j = 0; j < count; j++){
1300 // if((k = j + 1) == count)k = 0;
1301 // if(check_point_on_ellipse_interval(q, t, q1 = qq[j], t1 = tt[j], q2 = qq[k], t2 = tt[k]) == YES){
1302 //
1303 // /* check whether this interval (point in the middle of the interval) is outside inclusion */
1304 // if(q1 == q2){
1305 // qqq = q1;
1306 // ttt = (t1 + t2) / 2.0;
1307 // }
1308 // else{
1309 // if(q2 < q1)q2 += 4;
1310 //
1311 // if(q2 > q1 + 1){
1312 // qqq = q1 + 1;
1313 // ttt = 0.5;
1314 // }
1315 // else{
1316 // qqq = q1;
1317 // if(q1 == 1 || q1 == 3){
1318 // ttt = (t1 - t2 + 2.0) / 2.0;
1319 // if(ttt > 1.0){
1320 // ttt = 2.0 - ttt;
1321 // qqq++;
1322 // }
1323 // }
1324 // else{
1325 // ttt = (t1 - t2) / 2.0;
1326 // if(ttt < 0.0){
1327 // ttt = -ttt;
1328 // qqq++;
1329 // }
1330 // }
1331 // }
1332 //
1333 // if(q2 > 4)q2 -= 4;
1334 // if(qqq > 4)qqq -= 4;
1335 // get_ellipse_point_quadrant(ellipse, qqq, ttt, &point);
1336 // if(check_point_inside_ellipse(&point, contact, &val) == NO){
1337 // copy_vec(crack -> pnt1, pnt[j]);
1338 // copy_vec(crack -> pnt2, pnt[k]);
1339 //
1340 // crack -> q1 = q1;
1341 // crack -> t1 = t1;
1342 // crack -> q2 = q2;
1343 // crack -> t2 = t2;
1344 //
1345 // crack -> qa = project_point_to_ellipse(&(crack -> pnt1), contact, &p, &(crack -> ta));
1346 // crack -> qb = project_point_to_ellipse(&(crack -> pnt2), contact, &p, &(crack -> tb));
1347 //
1348 // selected = YES;
1349 // break;
1350 // }
1351 // }
1352 // }
1353 // }
1354 // }
1355 //
1356 // crack -> segment = YES;
1357 // if(selected == NO)error_message(GENERAL_ERROR, "Crack %d identification failure", i + 1);
1358 // }
1359 //
1360 // if(ellipsoid -> id < 0){
1361 // error_message(WARNING, "Crack %d is on rejected inclusion ==> crack %d ignored", i + 1, i + 1);
1362 // crack -> id = -crack -> id;
1363 //
1364 // //#ifdef ELIXIR
1365 // // if(draw == YES){
1366 // // draw_crack(crack, blue);
1367 // //
1368 // //#ifdef DEBUG
1369 // // ESIEventLoop(YES, "Crack");
1370 // //#endif
1371 // //
1372 // // }
1373 // //#endif
1374 //
1375 // continue;
1376 // }
1377 //
1378 // if(ellipsoid -> crack != NULL){
1379 // if(ellipsoid -> crack -> id > 0){
1380 // error_message(WARNING, "Inclusion %d associated with crack %d ==> crack %d ignored",
1381 // ellipsoid -> id, ellipsoid -> crack -> id, i + 1);
1382 // crack -> id = -crack -> id;
1383 //
1384 // //#ifdef ELIXIR
1385 // // if(draw == YES){
1386 // // draw_crack(crack, blue);
1387 // //
1388 // //#ifdef DEBUG
1389 // // ESIEventLoop(YES, "Crack");
1390 // //#endif
1391 // //
1392 // // }
1393 // //#endif
1394 //
1395 // continue;
1396 // }
1397 // }
1398 // }
1399 //
1400 // switch(type){
1401 // case CYLINDER:
1402 // if(check_crack_cylinder_intersection(crack, &cylinder) == YES){
1403 // error_message(WARNING, "Crack %d intersects cylinder ==> crack %d ignored", i + 1, i + 1);
1404 // crack -> id = -crack -> id;
1405 //
1406 // //#ifdef ELIXIR
1407 // // if(draw == YES){
1408 // // draw_crack(crack, blue);
1409 // //
1410 // //#ifdef DEBUG
1411 // // ESIEventLoop(YES, "Crack");
1412 // //#endif
1413 // //
1414 // // }
1415 // //#endif
1416 //
1417 // continue;
1418 // }
1419 // break;
1420 // case BLOCK:
1421 // if(check_crack_block_intersection(crack, &block) == YES){
1422 // error_message(WARNING, "Crack %d intersects block ==> crack %d ignored", i + 1, i + 1);
1423 // crack -> id = -crack -> id;
1424 //
1425 // //#ifdef ELIXIR
1426 // // if(draw == YES){
1427 // // draw_crack(crack, blue);
1428 // //
1429 // //#ifdef DEBUG
1430 // // ESIEventLoop(YES, "Crack");
1431 // //#endif
1432 // //
1433 // // }
1434 // //#endif
1435 //
1436 // continue;
1437 // }
1438 // break;
1439 // default:
1440 // break;
1441 // }
1442 //
1443 // for(j = 0; j < i; j++){
1444 // cr = &(crack_array[j]);
1445 // if(cr -> id < 0)continue;
1446 // if(check_crack_crack_intersection(crack, cr) == YES){
1447 // error_message(WARNING, "Crack %d intersects crack %d ==> crack %d ignored", i + 1, j + 1, i + 1);
1448 // crack -> id = -crack -> id;
1449 //
1450 // //#ifdef ELIXIR
1451 // // if(draw == YES){
1452 // // draw_crack(crack, blue);
1453 // //
1454 // //#ifdef DEBUG
1455 // // ESIEventLoop(YES, "Crack");
1456 // //#endif
1457 // //
1458 // // }
1459 // //#endif
1460 //
1461 // break;
1462 // }
1463 // }
1464 // if(crack -> id < 0)continue;
1465 //
1466 // for(j = 0; j < ellipsoids; j++){
1467 // el = &(ellipsoid_array[j]);
1468 // if(el -> id < 0)continue;
1469 // if(el == ellipsoid)continue;
1470 // if(check_crack_ellipsoid_intersection(crack, el) == YES){
1471 // error_message(WARNING, "Crack %d intersects inclusion %d ==> crack %d ignored", i + 1, j + 1, i + 1);
1472 // crack -> id = -crack -> id;
1473 //
1474 // //#ifdef ELIXIR
1475 // // if(draw == YES){
1476 // // draw_crack(crack, blue);
1477 // //
1478 // //#ifdef DEBUG
1479 // // ESIEventLoop(YES, "Crack");
1480 // //#endif
1481 // //
1482 // // }
1483 // //#endif
1484 //
1485 // break;
1486 // }
1487 // }
1488 // if(crack -> id < 0)continue;
1489 //
1490 // //#ifdef ELIXIR
1491 // // if(draw == YES){
1492 // // draw_crack(crack, yellow);
1493 // //
1494 // //#ifdef DEBUG
1495 // // ESIEventLoop(YES, "Crack");
1496 // //#endif
1497 // //
1498 // // }
1499 // //#endif
1500 //
1501 // if(ellipsoid != NULL){
1502 // crack -> ellipsoid = ellipsoid;
1503 // ellipsoid -> crack = crack;
1504 // }
1505 // }
1506 // } // end of crack loop
1507 
1508 // ************************************************
1509 // *** *** *** WRITE OUTPUT *** *** ***
1510 // ************************************************
1511 
1512 // /* note: text contains \n */
1513 // sprintf(buffer, "#\n# %s#\n\n", text);
1514 // write_record(t3d_in_file, t3d_in_file_name, buffer);
1515 //
1516 // sprintf(buffer, "StartMesh\n");
1517 // write_record(ctrl_file, ctrl_file_name, buffer);
1518 //
1519 // /* note: text contains \n */
1520 // sprintf(buffer, "\n#\n# %s#\n\n", text);
1521 // write_record(ctrl_file, ctrl_file_name, buffer);
1522 //
1523 // switch(type){
1524 // case CYLINDER:
1525 // vertex_id = 10;
1526 // curve_id = 10;
1527 // surface_id = 10;
1528 // patch_id = 10;
1529 // shell_id = 10;
1530 // region_id = 10;
1531 // break;
1532 // case BLOCK:
1533 // vertex_id = 100;
1534 // curve_id = 100;
1535 // surface_id = 100;
1536 // patch_id = 100;
1537 // shell_id = 100;
1538 // region_id = 100;
1539 // break;
1540 // default:
1541 // break;
1542 // }
1543 //
1544 // for(j = 0; j < ellipsoids; j++){
1545 // ellipsoid = &(ellipsoid_array[j]);
1546 // write_ellipsoid(ellipsoid);
1547 // }
1548 //
1549 // for(j = 0; j < cracks; j++){
1550 // crack = &(crack_array[j]);
1551 // write_crack(crack);
1552 // }
1553 //
1554 // vertices = vertex_id;
1555 // curves = curve_id;
1556 // surfaces = surface_id;
1557 // patches = patch_id;
1558 // shells = shell_id;
1559 // regions = region_id;
1560 //
1561 // vertex_id = 0;
1562 // curve_id = 0;
1563 // surface_id = 0;
1564 // patch_id = 0;
1565 // shell_id = 0;
1566 // region_id = 0;
1567 //
1568 // switch(type){
1569 // case CYLINDER:
1570 // write_cylinder(&cylinder, ellipsoid_array, crack_array, ellipsoids, cracks);
1571 // break;
1572 // case BLOCK:
1573 // write_block(&block, ellipsoid_array, crack_array, ellipsoids, cracks);
1574 // break;
1575 // default:
1576 // break;
1577 // }
1578 //
1579 // if(super == YES)write_super_block(&super_block);
1580 //
1581 // sprintf(buffer, "EndMesh\n");
1582 // write_record(ctrl_file, ctrl_file_name, buffer);
1583 //
1584 // if(bc == YES){
1585 // sprintf(buffer, "\n#StartIncrement\n");
1586 // write_record(ctrl_file, ctrl_file_name, buffer);
1587 //
1588 // for(j = 0; j < ellipsoids; j++){
1589 // ellipsoid = &(ellipsoid_array[j]);
1590 // if(ellipsoid -> id < 0)continue;
1591 // if(ellipsoid -> bc != 0){
1592 // sprintf(buffer, "\n## inclusion no %d (inclusion and matrix surface)\n\n", ellipsoid -> id);
1593 // write_record(ctrl_file, ctrl_file_name, buffer);
1594 // write_record(ctrl_file, ctrl_file_name, ellipsoid -> bc_ellipsoid_spec);
1595 // write_record(ctrl_file, ctrl_file_name, ellipsoid -> bc_matrix_spec);
1596 // sprintf(buffer, "#Tractions 0.0 0.0 0.0 1.0 1.0 1.0\n");
1597 // write_record(ctrl_file, ctrl_file_name, buffer);
1598 // }
1599 // }
1600 //
1601 // for(j = 0; j < cracks; j++){
1602 // crack = &(crack_array[j]);
1603 // if(crack -> id < 0)continue;
1604 // if(crack -> bc != 0){
1605 // sprintf(buffer, "\n## crack no %d\n\n", crack -> id);
1606 // write_record(ctrl_file, ctrl_file_name, buffer);
1607 // write_record(ctrl_file, ctrl_file_name, crack -> bc_spec);
1608 // sprintf(buffer, "#Tractions 0.0 0.0 0.0 1.0 1.0 1.0\n");
1609 // write_record(ctrl_file, ctrl_file_name, buffer);
1610 // }
1611 // }
1612 //
1613 // sprintf(buffer, "\n#EndIncrement\n");
1614 // write_record(ctrl_file, ctrl_file_name, buffer);
1615 // }
1616 //
1617 // get_next_relevant_record(geom_file, geom_file_name, "Missing number of ctrl points");
1618 // if(sscanf(line_buffer, "%d", &points) != 1)
1619 // error_message(INPUT_ERROR, "Invalid record - number of ctrl points");
1620 //
1621 // if(points < 0)error_message(INPUT_ERROR, "Non-negative number of ctrl points required");
1622 //
1623 // if(points != 0){
1624 // vertex_id = vertices;
1625 //
1626 // sprintf(buffer, "\n\n# control points\n\n");
1627 // write_record(t3d_in_file, t3d_in_file_name, buffer);
1628 //
1629 // for(i = 0; i < points; i++){
1630 // get_next_relevant_record(geom_file, geom_file_name, "Missing ctrl point description");
1631 // if(sscanf(line_buffer, "%lf %lf %lf %lf", &(point.x), &(point.y), &(point.z), &msz) != 4)
1632 // error_message(INPUT_ERROR, "Invalid record - ctrl point %d description", i + 1);
1633 //
1634 // if(msz < 0.0)
1635 // error_message(INPUT_ERROR, "Positive mesh size of ctrl point %d required", i + 1);
1636 //
1637 // //#ifdef ELIXIR
1638 // // if(draw == YES){
1639 // // draw_point(&point, green);
1640 // //
1641 // //#ifdef DEBUG
1642 // // ESIEventLoop(YES, "Point");
1643 // //#endif
1644 // //
1645 // // }
1646 // //#endif
1647 //
1648 // vertex_id++;
1649 // vertices++;
1650 // if(msz == 0.0)
1651 // sprintf(buffer, "vertex %d virtual xyz %e %e %e\n", vertex_id, point.x, point.y, point.z);
1652 // else
1653 // sprintf(buffer, "vertex %d virtual xyz %e %e %e size %e\n", vertex_id, point.x, point.y, point.z, msz);
1654 // write_record(t3d_in_file, t3d_in_file_name, buffer);
1655 // }
1656 // }
1657 //
1658 // if(ellipsoid_array != NULL)free(ellipsoid_array);
1659 // if(crack_array != NULL)free(crack_array);
1660 //
1661 // #ifdef MERLIN
1662 // output = 24;
1663 // #else
1664 // output = 520;
1665 // #endif
1666 //
1667 // if(default_msz == YES){
1668 // /*
1669 // error_message(WARNING, "Default mesh size (option -d) must be used");
1670 // error_message(NO_ERROR, " when running t3d with %s", t3d_in_file_name);
1671 // */
1672 // sprintf(buffer, "\n\n#\n# t3d -i %s -o %s.out -p %d -n %d %d %d %d %d %d %d -d ???\n#\n\n",
1673 // t3d_in_file_name, t3d_in_file_name, output, vertices, curves, surfaces, patches, shells, regions, interfaces);
1674 // }
1675 // else
1676 // sprintf(buffer, "\n\n#\n# t3d -i %s -o %s.out -p %d -n %d %d %d %d %d %d %d \n#\n\n",
1677 // t3d_in_file_name, t3d_in_file_name, output, vertices, curves, surfaces, patches, shells, regions, interfaces);
1678 // write_record(t3d_in_file, t3d_in_file_name, buffer);
1679 //
1680 // fclose(geom_file);
1681 // fclose(t3d_in_file);
1682 // fclose(ctrl_file);
1683 //
1684 // //#ifdef ELIXIR
1685 // // if(draw == YES){
1686 // // // EVFitAllIntoView(view); /* only if geometry is not drawn */
1687 // // ESIEventLoop(YES, "Completed");
1688 // // }
1689 // //#endif
1690 
1691 // return(0);
1692 // }
1693 // // end of main
1694 
1695 
1696 // ***************************************************
1697 // *** *** *** FUNCTIONS *** *** ***
1698 // ***************************************************
1699 
1700 // static void
1701 // write_ellipsoid(ellipsoid_rec *ellipsoid)
1702 // {
1703 // crack_rec *crack = NULL;
1704 // ellipse_rec *ellipse = NULL, *contact = NULL, base;
1705 // trans_matrix trans, base_trans, contact_trans, crack_trans;
1706 // point_rec glob_point[2], loc_point[2], glob_pnt[4], loc_pnt[4], glob_p[8], loc_p[8];
1707 // point_rec crack_glob_point[4], crack_loc_point[4], crack_glob_pnt[4], crack_loc_pnt[4];
1708 // point_rec contact_glob_point[4], contact_loc_point[4], contact_glob_pnt[4], contact_loc_pnt[4];
1709 // point_rec vec, normal, dir, normal1, normal2, pnt1, pnt2, pnt, point[2];
1710 // double weight_q = 0.707106781, weight_h = 0.3333333333, weight_o = 0.1111111111, delta_t;
1711 // double bmsz, imsz, cmsz, tmsz, min_msz, dist1, dist2, dist, angle1, angle2, tmp, t, u, v, norm, product;
1712 // logic skip, fixed_a, fixed_b, fixed_1, fixed_2, virtual, first_curve;
1713 // int i, j, k, m, n, j1, j2, count, oct, quad, vertices, curves, surfaces, patches, shells, intersect = 0;
1714 // int contact_case, crack_case, base_ver_id1, base_ver_id2, base_cur_id1, base_cur_id2, crack_patch_id;
1715 // int cross_ver_id1, cross_ver_id2, base_cur_id1a, base_cur_id1b, base_cur_id2a,base_cur_id2b;
1716 // int crack_ver_id1, crack_ver_id2, iface_crack_ver_id1, iface_crack_ver_id2, crack_vertex_id1, crack_vertex_id2;
1717 // int crack_cur_id1, crack_cur_id2, crack_cur_id3, iface_crack_cur_id1, iface_crack_cur_id2, iface_crack_cur_id3;
1718 // int crack_cur_id1a, crack_cur_id1b, crack_cur_id2a, crack_cur_id2b, crack_cur_id3a, crack_cur_id3b;
1719 // int iface_crack_cur_id1a, iface_crack_cur_id1b, iface_crack_cur_id2a, iface_crack_cur_id2b, iface_crack_cur_id3a, iface_crack_cur_id3b;
1720 // char buffer[1024], tmp_buffer[1024], contact_cur_list1[512], contact_cur_list2[512], crack_cur_list[512];
1721 // char crack_tip_ver_list[512], crack_tip_cur_list[512];
1722 //
1723 // /* vertex 0 - x+
1724 // vertex 1 - y+
1725 // vertex 2 - z+
1726 // vertex 3 - z-
1727 // vertex 4 - y-
1728 // vertex 5 - x- */
1729 //
1730 // /* octant 0 - x+ y+ z+
1731 // octant 1 - x- y+ z+
1732 // octant 2 - x+ y- z+
1733 // octant 3 - x- y- z+ note: this octant classification is different
1734 // octant 4 - x+ y+ z- from that used in projection and serves
1735 // octant 5 - x- y+ z- only for output
1736 // octant 6 - x+ y- z-
1737 // octant 7 - x- y- z- */
1738 //
1739 // static int sign_qx[4] = {1, -1, -1, 1};
1740 // static int sign_qy[4] = {1, 1, -1, -1};
1741 //
1742 // static int sign_ox[8] = {1, -1, 1, -1, 1, -1, 1, -1};
1743 // static int sign_oy[8] = {1, 1, -1, -1, 1, 1, -1, -1};
1744 // static int sign_oz[8] = {1, 1, 1, 1, -1, -1, -1, -1};
1745 //
1746 // if(ellipsoid -> id < 0){
1747 // sprintf(buffer, "# inclusion no %d (ignored)\n\n", -ellipsoid -> id);
1748 // write_record(t3d_in_file, t3d_in_file_name, buffer);
1749 // return;
1750 // }
1751 //
1752 // if(ellipsoid -> property == 0)ellipsoid -> interface = 0;
1753 //
1754 // sprintf(buffer, "\n# inclusion no %d ", ellipsoid -> id);
1755 // if(ellipsoid -> property == 0)
1756 // strcat(buffer, "(hole)");
1757 // else{
1758 // if(ellipsoid -> interface == 0)
1759 // sprintf(tmp_buffer, "(material %d)", ellipsoid -> property);
1760 // else
1761 // sprintf(tmp_buffer, "(material %d, interface %d)", ellipsoid -> property, ellipsoid -> interface);
1762 // strcat(buffer, tmp_buffer);
1763 // }
1764 //
1765 // bmsz = ellipsoid -> boundary_msz;
1766 // imsz = ellipsoid -> internal_msz;
1767 //
1768 // crack = ellipsoid -> crack;
1769 // if(crack != NULL){
1770 // if(crack -> interface == 0)
1771 // sprintf(tmp_buffer, " + crack no %d\n\n", crack -> id);
1772 // else
1773 // sprintf(tmp_buffer, " + crack no %d (interface %d)\n\n", crack -> id, crack -> interface);
1774 // strcat(buffer, tmp_buffer);
1775 //
1776 // write_record(t3d_in_file, t3d_in_file_name, buffer);
1777 // write_record(ctrl_file, ctrl_file_name, buffer);
1778 //
1779 // ellipse = &(crack -> crack);
1780 // contact = &(crack -> contact);
1781 //
1782 // cmsz = crack -> crack_msz;
1783 // tmsz = crack -> tip_msz;
1784 //
1785 // min_msz = contact -> min / 2.0;
1786 // if(gmsz < min_msz && gmsz != 0.0)min_msz = gmsz;
1787 // if(imsz < min_msz && imsz != 0.0)min_msz = imsz;
1788 // if(bmsz < min_msz && bmsz != 0.0)min_msz = bmsz;
1789 //
1790 // min_msz /= 2.0;
1791 //
1792 // if(crack -> segment == YES){
1793 //
1794 // /* contact_case, crack_case
1795 // 0 = no segment
1796 // 1 = segment in one quadrant
1797 // 2 = segment in two quadrants
1798 // 3 = segment in three quadrants
1799 // 4 = segment in four quadrants
1800 // 5 = segment in five quadrants */
1801 //
1802 // /* contact */
1803 // if(crack -> qa == crack -> qb){
1804 // if(crack -> qa == 1 || crack -> qa == 3){
1805 // if(crack -> ta < crack -> tb)
1806 // contact_case = 1;
1807 // else
1808 // contact_case = 5;
1809 // }
1810 // else{
1811 // if(crack -> ta > crack -> tb)
1812 // contact_case = 1;
1813 // else
1814 // contact_case = 5;
1815 // }
1816 // }
1817 // else{
1818 // if(crack -> qa + crack -> qb == 4 || crack -> qa + crack -> qb == 6)
1819 // contact_case = 3;
1820 // else{
1821 // if(crack -> qb == crack -> qa + 1 || (crack -> qa == 4 && crack -> qb == 1))
1822 // contact_case = 2;
1823 // else
1824 // contact_case = 4;
1825 // }
1826 // }
1827 //
1828 // /* crack */
1829 // if(crack -> q1 == crack -> q2){
1830 // if(crack -> q1 == 1 || crack -> q1 == 3){
1831 // if(crack -> t1 < crack -> t2)
1832 // crack_case = 1;
1833 // else
1834 // crack_case = 5;
1835 // }
1836 // else{
1837 // if(crack -> t1 >crack -> t2)
1838 // crack_case = 1;
1839 // else
1840 // crack_case = 5;
1841 // }
1842 // }
1843 // else{
1844 // if(crack -> q1 + crack -> q2 == 4 || crack -> q1 + crack -> q2 == 6)
1845 // crack_case = 3;
1846 // else{
1847 // if(crack -> q2 == crack -> q1 + 1 || (crack -> q1 == 4 && crack -> q2 == 1))
1848 // crack_case = 2;
1849 // else
1850 // crack_case = 4;
1851 // }
1852 // }
1853 // }
1854 //
1855 // /* note: if intersect == 0 then normal points towards half-ellipsoid with the crack !!!
1856 // if intersect != 0 then normal points towards crack start (pnt1) !!! (relevant only for segment = YES);
1857 // major axes of base ellipse points opposite to crack normal (this ensures that
1858 // the first crack patch has normal pointing into crack while the second out of crack) */
1859 // intersect = 0;
1860 // sub_vec(vec, contact -> center, ellipsoid -> center);
1861 // dist = dot_product(vec, contact -> normal);
1862 // if(fabs(dist) > min_msz){ /* to enforce intersect use min_msz * 1000.0 */
1863 // copy_vec(normal, contact -> normal);
1864 // if(dist < 0.0)mul_vec(normal, -1.0);
1865 // }
1866 // else{
1867 // if(crack -> segment == NO){
1868 //
1869 // /* note: use major axes of contact ellipse as the half ellipsoid base normal to ensure
1870 // that the building nodes of contact ellipse are far enought from base ellipse */
1871 //
1872 // copy_vec(normal, contact -> major);
1873 // intersect = 2;
1874 // }
1875 // else{
1876 //
1877 // /* enforce intersection_case 0 for contact_case 1
1878 // 1 2 3 (they are handled together)
1879 // 2 5
1880 // 1 or 2 4 */
1881 //
1882 // if(contact_case == 1 || contact_case == 3 || contact_case == 5){
1883 // get_ellipse_point_quadrant(contact, crack -> qa, 0.0, &pnt1);
1884 // get_ellipse_point_quadrant(contact, crack -> qa, 1.0, &pnt2);
1885 // sub_vec(dir, pnt2, pnt1);
1886 // norm = sqrt(size_vec(dir));
1887 // div_vec(dir, norm);
1888 // cross_product(normal, dir, contact -> normal);
1889 //
1890 // if(crack -> qa == 2 || crack -> qa == 4)mul_vec(normal, -1.0);
1891 // if(contact_case == 5)intersect = 2;
1892 // if(contact_case == 3)intersect = 1;
1893 //
1894 // /* to enforce intersect = 1 for testing of contact_case == 1 */
1895 // /*
1896 // if(contact_case == 1){
1897 // intersect = 1;
1898 // copy_vec(normal, dir);
1899 // }
1900 // */
1901 // }
1902 // else{
1903 // sub_vec(dir, crack -> pnt2, crack -> pnt1);
1904 // norm = sqrt(size_vec(dir));
1905 // div_vec(dir, norm);
1906 // cross_product(normal, dir, contact -> normal);
1907 //
1908 // sub_vec(vec, crack -> pnt1, contact -> center);
1909 // dist1 = dot_product(vec, normal);
1910 // sub_vec(vec, crack -> pnt2, contact -> center);
1911 // dist2 = dot_product(vec, normal);
1912 //
1913 // if(fabs(dist1) > min_msz && fabs(dist2) > min_msz){ /* to enforce intersect = 1 for contact_case == 2 */
1914 // if(dist1 < 0.0){ /* use min_msz * 100.0 */
1915 // intersect = 2;
1916 // mul_vec(normal, -1.0);
1917 // }
1918 // }
1919 // else{
1920 // if(contact_case == 4){
1921 //
1922 // /* avoid coincidation of intersection with contact half-ellipse building point */
1923 // if(crack -> qa == 1 || crack -> qa == 3)
1924 // get_ellipse_point_quadrant(contact, crack -> qa, 0.0, &pnt);
1925 // else
1926 // get_ellipse_point_quadrant(contact, crack -> qa, 1.0, &pnt);
1927 //
1928 // dist1 = dist_point(pnt, crack -> pnt1);
1929 // dist2 = dist_point(pnt, crack -> pnt2);
1930 //
1931 // /* ensure that dir still points from pnt1 to pnt2 */
1932 // if(dist1 > dist2){
1933 // first_curve = NO;
1934 // sub_vec(dir, pnt, crack -> pnt1);
1935 // }
1936 // else{
1937 // first_curve = YES;
1938 // sub_vec(dir, crack -> pnt2, pnt);
1939 // }
1940 // }
1941 //
1942 // get_ellipse_line_center_intersection(contact, &dir, &pnt1, &pnt2);
1943 // quad = project_point_to_ellipse(&pnt1, contact, &pnt, &t);
1944 // get_ellipse_normal_quadrant(contact, quad, t, &normal);
1945 //
1946 // product = dot_product(normal, dir);
1947 // if(product > 0.0)mul_vec(normal, -1.0);
1948 // intersect = 1;
1949 // }
1950 // }
1951 // }
1952 // }
1953 //
1954 // get_ellipsoid_plane_intersection(ellipsoid, &(ellipsoid -> center), &normal, &base);
1955 //
1956 // if(intersect != 0){
1957 //
1958 // /* IMPORTANT: since base major half-axes end nodes are used as building nodes for half-ellipsoids
1959 // it is necessary to ensure that they are not in or close to plane of the crack */
1960 // angle1 = dot_product(base.major, contact -> normal);
1961 // angle2 = dot_product(base.minor, contact -> normal);
1962 //
1963 // if(fabs(angle1) < fabs(angle2)){
1964 // swap(base.max, base.min, tmp);
1965 // swap(base.major.x, base.minor.x, tmp);
1966 // swap(base.major.y, base.minor.y, tmp);
1967 // swap(base.major.z, base.minor.z, tmp);
1968 // mul_vec(base.minor, -1.0);
1969 // }
1970 //
1971 // /* ensure that base ellipse major axes has opposite direction than crack normal */
1972 // product = dot_product(base.major, contact -> normal);
1973 // if(product > 0.0){
1974 // mul_vec(base.major, -1.0);
1975 // mul_vec(base.minor, -1.0);
1976 // }
1977 //
1978 // get_plane_plane_intersection(&(base.center), &(base.normal), &(contact -> center), &(contact -> normal), &pnt, &dir);
1979 // count = get_ellipse_line_intersection(&base, &pnt, &dir, point); /* there must be two intersections */
1980 //
1981 // if(intersect == 1){
1982 // quad = project_point_to_ellipse(&point[0], contact, &pnt, &t);
1983 // if(check_point_on_ellipse_interval(quad, t, crack -> qa, crack -> ta, crack -> qb, crack -> tb) == NO){
1984 // quad = project_point_to_ellipse(&point[1], contact, &pnt, &t);
1985 // if(check_point_on_ellipse_interval(quad, t, crack -> qa, crack -> ta, crack -> qb, crack -> tb) == NO)
1986 // error_message(GENERAL_ERROR, "Unexpected situation");
1987 // else{
1988 // copy_vec(point[0], point[1]);
1989 // }
1990 // }
1991 // }
1992 // else{
1993 //
1994 // /* ensure that the first intersection point falls on the first curve of the base ellipse */
1995 // sub_vec(vec, point[1], point[0]);
1996 // product = dot_product(base.minor, vec);
1997 // if(product > 0.0){
1998 // swap(point[0].x, point[1].x , tmp);
1999 // swap(point[0].y, point[1].y , tmp);
2000 // swap(point[0].z, point[1].z , tmp);
2001 // }
2002 // }
2003 // }
2004 //
2005 // copy_vec(base_trans.x, base.major);
2006 // copy_vec(base_trans.y, base.minor);
2007 // copy_vec(base_trans.z, base.normal);
2008 //
2009 // oct = project_point_to_ellipsoid(&(base.pnt0), ellipsoid, &pnt, &u, &v);
2010 // get_ellipsoid_normal_octant(ellipsoid, oct, u, v, &normal1);
2011 //
2012 // oct = project_point_to_ellipsoid(&(base.pnt2), ellipsoid, &pnt, &u, &v);
2013 // get_ellipsoid_normal_octant(ellipsoid, oct, u, v, &normal2);
2014 //
2015 // cross_product(dir, normal1, normal2);
2016 // norm = sqrt(size_vec(dir));
2017 // div_vec(dir, norm);
2018 // get_ellipsoid_line_center_intersection(ellipsoid, &dir, &pnt1, &pnt2);
2019 //
2020 // dist = sqrt(dist_point(pnt1, pnt2)) * 2.0;
2021 // mul_vec(dir, dist);
2022 //
2023 // loc_point[0].x = base.max;
2024 // loc_point[0].y = 0.0;
2025 // loc_point[0].z = 0.0;
2026 //
2027 // loc_point[1].x = -base.max;
2028 // loc_point[1].y = 0.0;
2029 // loc_point[1].z = 0.0;
2030 //
2031 // loc_pnt[0].x = base.max;
2032 // loc_pnt[0].y = 2.0 * base.min;
2033 // loc_pnt[0].z = 0.0;
2034 //
2035 // for(i = 1; i < 4; i++){
2036 // loc_pnt[i].x = loc_pnt[0].x * sign_qx[i];
2037 // loc_pnt[i].y = loc_pnt[0].y * sign_qy[i];
2038 // loc_pnt[i].z = 0.0;
2039 // }
2040 //
2041 // invert_transformation(&base_trans);
2042 //
2043 // for(i = 0; i < 2; i++)transform_from_local_to_global(&(glob_point[i]), &(loc_point[i]), &(base.center), &base_trans);
2044 // for(i = 0; i < 4; i++)transform_from_local_to_global(&(glob_pnt[i]), &(loc_pnt[i]), &(base.center), &base_trans);
2045 //
2046 // /* swap last two glob_pnt before glob_p building
2047 // (to make quadrants compatible with octants) */
2048 // swap(glob_pnt[2].x, glob_pnt[3].x, tmp);
2049 // swap(glob_pnt[2].y, glob_pnt[3].y, tmp);
2050 // swap(glob_pnt[2].z, glob_pnt[3].z, tmp);
2051 //
2052 // for(i = 0; i < 4; i++){
2053 // add_vec(glob_p[i], glob_pnt[i], dir);
2054 // sub_vec(glob_p[i + 4], glob_pnt[i], dir);
2055 // }
2056 //
2057 // /* swap them back */
2058 // swap(glob_pnt[2].x, glob_pnt[3].x, tmp);
2059 // swap(glob_pnt[2].y, glob_pnt[3].y, tmp);
2060 // swap(glob_pnt[2].z, glob_pnt[3].z, tmp);
2061 //
2062 // /* contact vertices */
2063 // contact_loc_point[0].x = contact -> max;
2064 // contact_loc_point[0].y = 0.0;
2065 // contact_loc_point[0].z = 0.0;
2066 //
2067 // contact_loc_point[1].x = 0.0;
2068 // contact_loc_point[1].y = contact -> min;
2069 // contact_loc_point[1].z = 0.0;
2070 //
2071 // /* contact ctrl polygon */
2072 // contact_loc_pnt[0].x = contact -> max;
2073 // contact_loc_pnt[0].y = contact -> min;
2074 // contact_loc_pnt[0].z = 0.0;
2075 //
2076 // /* crack vertices */
2077 // crack_loc_point[0].x = ellipse -> max;
2078 // crack_loc_point[0].y = 0.0;
2079 // crack_loc_point[0].z = 0.0;
2080 //
2081 // crack_loc_point[1].x = 0.0;
2082 // crack_loc_point[1].y = ellipse -> min;
2083 // crack_loc_point[1].z = 0.0;
2084 //
2085 // /* crack ctrl polygon */
2086 // crack_loc_pnt[0].x = ellipse -> max;
2087 // crack_loc_pnt[0].y = ellipse -> min;
2088 // crack_loc_pnt[0].z = 0.0;
2089 //
2090 // for(i = 0; i < 2; i++){
2091 // contact_loc_point[i + 2].x = -contact_loc_point[i].x;
2092 // contact_loc_point[i + 2].y = -contact_loc_point[i].y;
2093 // contact_loc_point[i + 2].z = 0.0;
2094 //
2095 // crack_loc_point[i + 2].x = -crack_loc_point[i].x;
2096 // crack_loc_point[i + 2].y = -crack_loc_point[i].y;
2097 // crack_loc_point[i + 2].z = 0.0;
2098 // }
2099 //
2100 // for(i = 1; i < 4; i++){
2101 // contact_loc_pnt[i].x = contact_loc_pnt[0].x * sign_qx[i];
2102 // contact_loc_pnt[i].y = contact_loc_pnt[0].y * sign_qy[i];
2103 // contact_loc_pnt[i].z = 0.0;
2104 //
2105 // crack_loc_pnt[i].x = crack_loc_pnt[0].x * sign_qx[i];
2106 // crack_loc_pnt[i].y = crack_loc_pnt[0].y * sign_qy[i];
2107 // crack_loc_pnt[i].z = 0.0;
2108 // }
2109 //
2110 // if(crack -> segment == YES){
2111 // if(contact_case == 2){
2112 // if(crack -> qa + crack -> qb == 5){
2113 // for(i = 0; i < 4; i++)contact_loc_pnt[i].x *= 2.0;
2114 // }
2115 // else{
2116 // for(i = 0; i < 4; i++)contact_loc_pnt[i].y *= 2.0;
2117 // }
2118 // }
2119 // if(contact_case == 4){
2120 // if(crack -> qa + crack -> qb != 5){
2121 // for(i = 0; i < 4; i++)contact_loc_pnt[i].x *= 2.0;
2122 // }
2123 // else{
2124 // for(i = 0; i < 4; i++)contact_loc_pnt[i].y *= 2.0;
2125 // }
2126 // }
2127 //
2128 // if(crack_case == 2){
2129 // if(crack -> q1 + crack -> q2 == 5){
2130 // for(i = 0; i < 4; i++)crack_loc_pnt[i].x *= 2.0;
2131 // }
2132 // else{
2133 // for(i = 0; i < 4; i++)crack_loc_pnt[i].y *= 2.0;
2134 // }
2135 // }
2136 // if(crack_case == 4){
2137 // if(crack -> q1 + crack -> q2 != 5){
2138 // for(i = 0; i < 4; i++)crack_loc_pnt[i].x *= 2.0;
2139 // }
2140 // else{
2141 // for(i = 0; i < 4; i++)crack_loc_pnt[i].y *= 2.0;
2142 // }
2143 // }
2144 // }
2145 //
2146 // /* ellipsoid */
2147 // vertices = 2;
2148 // curves = 2 + 2; /* 2 collapsed */
2149 // surfaces = 2;
2150 // shells = 1;
2151 //
2152 // if(intersect != 0){
2153 // shells++;
2154 // vertices += intersect * 2;
2155 // curves += intersect * 2;
2156 // }
2157 //
2158 // /* crack */
2159 // patches = 2;
2160 //
2161 // if(crack -> segment == NO){
2162 // contact_case = 0;
2163 // crack_case = 0;
2164 //
2165 // vertices += 4;
2166 // curves += 4;
2167 //
2168 // if(intersect != 0){
2169 // vertices += 8;
2170 // curves += 8;
2171 // }
2172 //
2173 // for(i = 0; i < 4; i++){
2174 // contact_loc_pnt[i].y *= 2.0;
2175 // crack_loc_pnt[i].y *= 2.0;
2176 // }
2177 // }
2178 // else{
2179 // if(intersect != 0){
2180 // vertices += 4 * intersect;
2181 // curves += 2 * intersect;
2182 // }
2183 //
2184 // switch(contact_case){
2185 // case 1:
2186 // case 2:
2187 // case 3:
2188 // vertices += 6;
2189 // curves += 3;
2190 // break;
2191 // case 4:
2192 // case 5:
2193 // vertices += 10;
2194 // curves += 8;
2195 // break;
2196 // }
2197 // }
2198 //
2199 // copy_vec(contact_trans.x, contact -> major);
2200 // copy_vec(contact_trans.y, contact -> minor);
2201 // copy_vec(contact_trans.z, contact -> normal);
2202 //
2203 // copy_vec(crack_trans.x, ellipse -> major);
2204 // copy_vec(crack_trans.y, ellipse -> minor);
2205 // copy_vec(crack_trans.z, ellipse -> normal);
2206 //
2207 // invert_transformation(&contact_trans);
2208 // invert_transformation(&crack_trans);
2209 //
2210 // for(i = 0; i < 4; i++){
2211 // transform_from_local_to_global(&(contact_glob_point[i]), &(contact_loc_point[i]), &(contact-> center), &contact_trans);
2212 // transform_from_local_to_global(&(contact_glob_pnt[i]), &(contact_loc_pnt[i]), &(contact-> center), &contact_trans);
2213 // transform_from_local_to_global(&(crack_glob_point[i]), &(crack_loc_point[i]), &(ellipse -> center), &crack_trans);
2214 // transform_from_local_to_global(&(crack_glob_pnt[i]), &(crack_loc_pnt[i]), &(ellipse -> center), &crack_trans);
2215 // }
2216 //
2217 // if(crack -> segment == YES){
2218 //
2219 // /* it would be desirable to calculate user_eps */
2220 //
2221 // delta_t = EPSILON_T / 100.0;
2222 // fixed_a = fixed_b = NO;
2223 // if(crack -> qa == 1 || crack -> qa == 3){
2224 // if(crack -> ta < delta_t)fixed_a = YES;
2225 // }
2226 // else{
2227 // if(crack -> ta > 1.0 - delta_t)fixed_a = YES;
2228 // }
2229 // if(crack -> qb == 2 || crack -> qb == 4){
2230 // if(crack -> tb < delta_t)fixed_b = YES;
2231 // }
2232 // else{
2233 // if(crack -> tb > 1.0 - delta_t)fixed_b = YES;
2234 // }
2235 //
2236 // #ifdef DEBUG
2237 // fprintf(stderr, "intersect %d\ncontact case %d fixed start %d fixed end %d\n", intersect, contact_case, fixed_a, fixed_b);
2238 // #endif
2239 //
2240 // }
2241 //
2242 // #ifdef DEBUG
2243 // else{
2244 // fprintf(stderr, "intersect %d\ncontact case %d\n", intersect, contact_case);
2245 // }
2246 // #endif
2247 //
2248 // if(intersect == 0){
2249 // for(k = 0; k < 4; k++){
2250 //
2251 // /* k = 0 inclusion boundary
2252 // k = 1 matrix boundary
2253 // k = 2 inclusion interface
2254 // k = 3 matrix interface */
2255 //
2256 // if(k == 1){
2257 // sprintf(buffer, "MasterSlave");
2258 // write_record(ctrl_file, ctrl_file_name, buffer);
2259 // }
2260 // if(k == 2){
2261 // sprintf(buffer, "Interface %d", ellipsoid -> interface);
2262 // write_record(ctrl_file, ctrl_file_name, buffer);
2263 // }
2264 //
2265 // switch(k){
2266 // case 0:
2267 // sprintf(buffer, "# inclusion boundary\n\n");
2268 // break;
2269 // case 1:
2270 // sprintf(buffer, "# matrix boundary\n\n");
2271 // break;
2272 // case 2:
2273 // sprintf(buffer, "# inclusion interface\n\n");
2274 // break;
2275 // case 3:
2276 // sprintf(buffer, "# matrix interface\n\n");
2277 // break;
2278 // }
2279 //
2280 // write_record(t3d_in_file, t3d_in_file_name, buffer);
2281 //
2282 // for(i = 0; i < 2; i++){
2283 // vertex_id++;
2284 // if(bmsz == 0.0){
2285 // default_msz = YES;
2286 // sprintf(buffer, "vertex %d xyz %e %e %e\n", vertex_id,
2287 // glob_point[i].x, glob_point[i].y, glob_point[i].z);
2288 // }
2289 // else
2290 // sprintf(buffer, "vertex %d xyz %e %e %e size %e\n", vertex_id,
2291 // glob_point[i].x, glob_point[i].y, glob_point[i].z, bmsz);
2292 // write_record(t3d_in_file, t3d_in_file_name, buffer);
2293 //
2294 // if(k == 1){
2295 // if(ellipsoid -> interface == 0)
2296 // sprintf(buffer, " Vertex %d %d", vertex_id - vertices, vertex_id);
2297 // else
2298 // sprintf(buffer, " Vertex %d %d Vertex %d %d",
2299 // vertex_id - vertices, vertex_id + vertices, vertex_id, vertex_id + 2 * vertices);
2300 // write_record(ctrl_file, ctrl_file_name, buffer);
2301 // }
2302 // }
2303 //
2304 // write_record(t3d_in_file, t3d_in_file_name, "\n");
2305 //
2306 // for(i = 0; i < 2; i++){
2307 // curve_id++;
2308 // sprintf(buffer, "curve %d order 4 vertex %d %d\n", curve_id,
2309 // vertex_id - 1 + i, vertex_id - i);
2310 // write_record(t3d_in_file, t3d_in_file_name, buffer);
2311 //
2312 // for(j = 0; j < 2; j++){
2313 // m = 2 * i + j;
2314 // if(bmsz == 0.0){
2315 // default_msz = YES;
2316 // sprintf(buffer, "polygon %d xyz %e %e %e weight %e\n", j + 1,
2317 // glob_pnt[m].x, glob_pnt[m].y, glob_pnt[m].z, weight_h);
2318 // }
2319 // else
2320 // sprintf(buffer, "polygon %d xyz %e %e %e weight %e size %e\n", j + 1,
2321 // glob_pnt[m].x, glob_pnt[m].y, glob_pnt[m].z, weight_h, bmsz);
2322 // write_record(t3d_in_file, t3d_in_file_name, buffer);
2323 // }
2324 //
2325 // if(k == 1){
2326 // if(ellipsoid -> interface == 0)
2327 // sprintf(buffer, " Curve %d %d", curve_id - curves, curve_id);
2328 // else
2329 // sprintf(buffer, " Curve %d %d Curve %d %d",
2330 // curve_id - curves, curve_id + curves, curve_id, curve_id + 2 * curves);
2331 // write_record(ctrl_file, ctrl_file_name, buffer);
2332 // }
2333 //
2334 // if(i == 0)base_cur_id1 = curve_id;
2335 // if(i == 1)base_cur_id2 = curve_id;
2336 // }
2337 //
2338 // write_record(t3d_in_file, t3d_in_file_name, "\n");
2339 //
2340 // for(i = 0; i < 2; i++){
2341 // curve_id++;
2342 // sprintf(buffer, "curve %d order 4 vertex %d %d\n", curve_id,
2343 // vertex_id - 1 + i, vertex_id - 1 + i);
2344 // write_record(t3d_in_file, t3d_in_file_name, buffer);
2345 //
2346 // for(j = 0; j < 2; j++){
2347 // if(bmsz == 0.0){
2348 // default_msz = YES;
2349 // sprintf(buffer, "polygon %d xyz %e %e %e weight %e\n", j + 1,
2350 // glob_point[i].x, glob_point[i].y, glob_point[i].z, weight_h);
2351 // }
2352 // else
2353 // sprintf(buffer, "polygon %d xyz %e %e %e weight %e size %e\n", j + 1,
2354 // glob_point[i].x, glob_point[i].y, glob_point[i].z, weight_h, bmsz);
2355 // write_record(t3d_in_file, t3d_in_file_name, buffer);
2356 // }
2357 // }
2358 //
2359 // write_record(t3d_in_file, t3d_in_file_name, "\n");
2360 //
2361 // for(i = 0; i < 2; i++){
2362 // surface_id++;
2363 // if(i == 0)
2364 // sprintf(buffer, "surface %d curve %d %d %d %d virtual\n", surface_id,
2365 // curve_id - 3, curve_id - 1, curve_id - 2, curve_id);
2366 // else
2367 // sprintf(buffer, "surface %d curve %d %d %d %d\n", surface_id,
2368 // curve_id - 3, curve_id - 1, curve_id - 2, curve_id);
2369 // write_record(t3d_in_file, t3d_in_file_name, buffer);
2370 //
2371 // for(j2 = 0; j2 < 2; j2++){
2372 // for(j1 = 0; j1 < 2; j1++){
2373 // m = i * 4 + j2 * 2 + j1;
2374 // if(bmsz == 0.0){
2375 // default_msz = YES;
2376 // sprintf(buffer, "polygon %d %d xyz %e %e %e weight %e\n", j1 + 1, j2 + 1,
2377 // glob_p[m].x, glob_p[m].y, glob_p[m].z, weight_o);
2378 // }
2379 // else
2380 // sprintf(buffer, "polygon %d %d xyz %e %e %e weight %e size %e\n", j1 + 1, j2 + 1,
2381 // glob_p[m].x, glob_p[m].y, glob_p[m].z, weight_o, bmsz);
2382 // write_record(t3d_in_file, t3d_in_file_name, buffer);
2383 // }
2384 // }
2385 //
2386 // if(i != 0){
2387 // if(k == 1){
2388 // if(ellipsoid -> interface == 0)
2389 // sprintf(buffer, " Surface %d %d", surface_id - surfaces, surface_id);
2390 // else
2391 // sprintf(buffer, " Surface %d %d Surface %d %d",
2392 // surface_id - surfaces, surface_id + surfaces, surface_id, surface_id + 2 * surfaces);
2393 // write_record(ctrl_file, ctrl_file_name, buffer);
2394 // }
2395 // if(k == 2){
2396 // sprintf(buffer, " Surface %d %d", surface_id + surfaces, surface_id);
2397 // write_record(ctrl_file, ctrl_file_name, buffer);
2398 // }
2399 // }
2400 // }
2401 //
2402 // write_record(t3d_in_file, t3d_in_file_name, "\n");
2403 //
2404 // if(crack -> segment == NO){
2405 // for(m = 0; m < 2; m++){
2406 // skip = NO;
2407 // if(m == 1){
2408 // if((k == 0 || k == 2) && ellipsoid -> property != 0)skip = YES;
2409 // }
2410 //
2411 // for(i = 0; i < 2; i++){
2412 // vertex_id++;
2413 // if(skip == NO){
2414 // j = 2 * i;
2415 // if(cmsz == 0.0){
2416 // default_msz = YES;
2417 // if(m == 1)
2418 // sprintf(buffer, "vertex %d xyz %e %e %e coincide vertex %d\n", vertex_id,
2419 // contact_glob_point[j].x, contact_glob_point[j].y, contact_glob_point[j].z, vertex_id - 2);
2420 // else
2421 // sprintf(buffer, "vertex %d xyz %e %e %e\n", vertex_id,
2422 // contact_glob_point[j].x, contact_glob_point[j].y, contact_glob_point[j].z);
2423 // }
2424 // else{
2425 // if(m == 1)
2426 // sprintf(buffer, "vertex %d xyz %e %e %e size %e coincide vertex %d\n", vertex_id,
2427 // contact_glob_point[j].x, contact_glob_point[j].y, contact_glob_point[j].z, cmsz, vertex_id - 2);
2428 // else
2429 // sprintf(buffer, "vertex %d xyz %e %e %e size %e\n", vertex_id,
2430 // contact_glob_point[j].x, contact_glob_point[j].y, contact_glob_point[j].z, cmsz);
2431 // }
2432 // write_record(t3d_in_file, t3d_in_file_name, buffer);
2433 // }
2434 //
2435 // if(k == 1){
2436 // if(ellipsoid -> interface == 0){
2437 // if(m == 0)
2438 // sprintf(buffer, " Vertex %d %d", vertex_id - vertices, vertex_id);
2439 // else
2440 // sprintf(buffer, " Vertex %d %d", vertex_id - vertices - 2, vertex_id);
2441 // }
2442 // else{
2443 // if(m == 0 || ellipsoid -> property == 0)
2444 // sprintf(buffer, " Vertex %d %d Vertex %d %d",
2445 // vertex_id - vertices, vertex_id + vertices, vertex_id, vertex_id + 2 * vertices);
2446 // else
2447 // sprintf(buffer, " Vertex %d %d", vertex_id, vertex_id + 2 * vertices);
2448 // }
2449 // write_record(ctrl_file, ctrl_file_name, buffer);
2450 // }
2451 // }
2452 //
2453 // if(skip == NO)write_record(t3d_in_file, t3d_in_file_name, "\n");
2454 //
2455 // for(i = 0; i < 2; i++){
2456 // curve_id++;
2457 // if(skip == NO){
2458 // if(m == 1)
2459 // sprintf(buffer, "curve %d order 4 vertex %d %d coincide curve %d\n", curve_id,
2460 // vertex_id - 1 + i, vertex_id - i, curve_id - 2);
2461 // else
2462 // sprintf(buffer, "curve %d order 4 vertex %d %d\n", curve_id,
2463 // vertex_id - 1 + i, vertex_id - i);
2464 // write_record(t3d_in_file, t3d_in_file_name, buffer);
2465 //
2466 // for(j = 0; j < 2; j++){
2467 // n = 2 * i + j;
2468 // if(cmsz == 0.0){
2469 // default_msz = YES;
2470 // sprintf(buffer, "polygon %d xyz %e %e %e weight %e\n", j + 1,
2471 // contact_glob_pnt[n].x, contact_glob_pnt[n].y, contact_glob_pnt[n].z, weight_h);
2472 // }
2473 // else
2474 // sprintf(buffer, "polygon %d xyz %e %e %e weight %e size %e\n", j + 1,
2475 // contact_glob_pnt[n].x, contact_glob_pnt[n].y, contact_glob_pnt[n].z, weight_h, cmsz);
2476 // write_record(t3d_in_file, t3d_in_file_name, buffer);
2477 // }
2478 // }
2479 //
2480 // if(k == 1){
2481 // if(ellipsoid -> interface == 0){
2482 // if(m == 0)
2483 // sprintf(buffer, " Curve %d %d", curve_id - curves, curve_id);
2484 // else
2485 // sprintf(buffer, " Curve %d %d", curve_id - curves - 2, curve_id);
2486 // }
2487 // else{
2488 // if(m == 0 || ellipsoid -> property == 0)
2489 // sprintf(buffer, " Curve %d %d Curve %d %d",
2490 // curve_id - curves, curve_id + curves, curve_id, curve_id + 2 * curves);
2491 // else
2492 // sprintf(buffer, " Curve %d %d", curve_id, curve_id + 2 * curves);
2493 // }
2494 // write_record(ctrl_file, ctrl_file_name, buffer);
2495 // }
2496 //
2497 // if(m == 0){
2498 // if(k == 0 || k == 1){
2499 // if(i == 0)crack_cur_id1 = curve_id;
2500 // if(i == 1)crack_cur_id2 = curve_id;
2501 // }
2502 // }
2503 // }
2504 //
2505 // if(skip == NO)write_record(t3d_in_file, t3d_in_file_name, "\n");
2506 // }
2507 // }
2508 // else{
2509 // if(k == 1 || k == 3 || ellipsoid -> interface == 0){
2510 // vertex_id++;
2511 // if(tmsz == 0.0){
2512 // default_msz = YES;
2513 // sprintf(buffer, "vertex %d xyz %e %e %e\n", vertex_id,
2514 // crack -> pnt1.x, crack -> pnt1.y, crack -> pnt1.z);
2515 // }
2516 // else
2517 // sprintf(buffer, "vertex %d xyz %e %e %e size %e\n", vertex_id,
2518 // crack -> pnt1.x, crack -> pnt1.y, crack -> pnt1.z, tmsz);
2519 // write_record(t3d_in_file, t3d_in_file_name, buffer);
2520 // crack_ver_id1 = vertex_id;
2521 //
2522 // vertex_id++;
2523 // if(tmsz == 0.0){
2524 // default_msz = YES;
2525 // sprintf(buffer, "vertex %d xyz %e %e %e\n", vertex_id,
2526 // crack -> pnt2.x, crack -> pnt2.y, crack -> pnt2.z);
2527 // }
2528 // else
2529 // sprintf(buffer, "vertex %d xyz %e %e %e size %e\n", vertex_id,
2530 // crack -> pnt2.x, crack -> pnt2.y, crack -> pnt2.z, tmsz);
2531 // write_record(t3d_in_file, t3d_in_file_name, buffer);
2532 // crack_ver_id2 = vertex_id;
2533 //
2534 // write_record(t3d_in_file, t3d_in_file_name, "\n");
2535 // }
2536 // else{
2537 // vertex_id += 2;
2538 // }
2539 //
2540 // switch(contact_case){
2541 // case 1:
2542 // vertex_id++;
2543 // if(fixed_a == NO || (k != 1 && k != 3 && ellipsoid -> interface != 0)){
2544 // j = crack -> qa - 1;
2545 // if(bmsz == 0.0){
2546 // default_msz = YES;
2547 // sprintf(buffer, "vertex %d xyz %e %e %e virtual\n", vertex_id,
2548 // contact_glob_point[j].x, contact_glob_point[j].y, contact_glob_point[j].z);
2549 // }
2550 // else
2551 // sprintf(buffer, "vertex %d xyz %e %e %e size %e virtual\n", vertex_id,
2552 // contact_glob_point[j].x, contact_glob_point[j].y, contact_glob_point[j].z, bmsz);
2553 // }
2554 // else{
2555 // if(bmsz == 0.0){
2556 // default_msz = YES;
2557 // sprintf(buffer, "vertex %d fixed vertex %d size def\n", vertex_id, crack_ver_id1);
2558 // }
2559 // else
2560 // sprintf(buffer, "vertex %d fixed vertex %d size %e\n", vertex_id, crack_ver_id1, bmsz);
2561 // }
2562 // write_record(t3d_in_file, t3d_in_file_name, buffer);
2563 //
2564 // vertex_id++;
2565 // if(fixed_b == NO || (k != 1 && k != 3 && ellipsoid -> interface != 0)){
2566 // if((j = crack -> qa) >= 4)j -= 4;
2567 // if(bmsz == 0.0){
2568 // default_msz = YES;
2569 // sprintf(buffer, "vertex %d xyz %e %e %e virtual\n", vertex_id,
2570 // contact_glob_point[j].x, contact_glob_point[j].y, contact_glob_point[j].z);
2571 // }
2572 // else
2573 // sprintf(buffer, "vertex %d xyz %e %e %e size %e virtual\n", vertex_id,
2574 // contact_glob_point[j].x, contact_glob_point[j].y, contact_glob_point[j].z, bmsz);
2575 // }
2576 // else{
2577 // if(bmsz == 0.0){
2578 // default_msz = YES;
2579 // sprintf(buffer, "vertex %d fixed vertex %d size def\n", vertex_id, crack_ver_id2);
2580 // }
2581 // else
2582 // sprintf(buffer, "vertex %d fixed vertex %d size %e\n", vertex_id, crack_ver_id2, bmsz);
2583 // }
2584 // write_record(t3d_in_file, t3d_in_file_name, buffer);
2585 //
2586 // write_record(t3d_in_file, t3d_in_file_name, "\n");
2587 //
2588 // j = crack -> qa - 1;
2589 // curve_id++;
2590 // sprintf(buffer, "curve %d order 3 vertex %d %d virtual\n", curve_id, vertex_id - 1, vertex_id);
2591 // write_record(t3d_in_file, t3d_in_file_name, buffer);
2592 // if(bmsz == 0.0){
2593 // default_msz = YES;
2594 // sprintf(buffer, "polygon 1 xyz %e %e %e weight %e\n",
2595 // contact_glob_pnt[j].x, contact_glob_pnt[j].y, contact_glob_pnt[j].z, weight_q);
2596 // }
2597 // else
2598 // sprintf(buffer, "polygon 1 xyz %e %e %e weight %e size %e\n",
2599 // contact_glob_pnt[j].x, contact_glob_pnt[j].y, contact_glob_pnt[j].z, weight_q, bmsz);
2600 // write_record(t3d_in_file, t3d_in_file_name, buffer);
2601 //
2602 // write_record(t3d_in_file, t3d_in_file_name, "\n");
2603 //
2604 // vertex_id++;
2605 // if(fixed_a == NO){
2606 // if(k == 1 || k == 3 || ellipsoid -> interface == 0)
2607 // sprintf(buffer, "vertex %d xyz %e %e %e fixed curve %d fixed vertex %d\n", vertex_id,
2608 // crack -> pnt1.x, crack -> pnt1.y, crack -> pnt1.z, curve_id, crack_ver_id1);
2609 // else
2610 // sprintf(buffer, "vertex %d xyz %e %e %e fixed curve %d\n", vertex_id,
2611 // crack -> pnt1.x, crack -> pnt1.y, crack -> pnt1.z, curve_id);
2612 // }
2613 // else
2614 // sprintf(buffer, "vertex %d fixed vertex %d\n", vertex_id, vertex_id - 2);
2615 // write_record(t3d_in_file, t3d_in_file_name, buffer);
2616 //
2617 // if(k == 1){
2618 // if(ellipsoid -> interface == 0)
2619 // sprintf(buffer, " Vertex %d %d", crack_ver_id1 - vertices, crack_ver_id1);
2620 // else
2621 // sprintf(buffer, " Vertex %d %d Vertex %d %d",
2622 // vertex_id - vertices, vertex_id + vertices, crack_ver_id1, crack_ver_id1 + 2 * vertices);
2623 // write_record(ctrl_file, ctrl_file_name, buffer);
2624 // }
2625 //
2626 // vertex_id++;
2627 // if(fixed_b == NO){
2628 // if(k == 1 || k == 3 || ellipsoid -> interface == 0)
2629 // sprintf(buffer, "vertex %d xyz %e %e %e fixed curve %d fixed vertex %d\n", vertex_id,
2630 // crack -> pnt2.x, crack -> pnt2.y, crack -> pnt2.z, curve_id, crack_ver_id2);
2631 // else
2632 // sprintf(buffer, "vertex %d xyz %e %e %e fixed curve %d\n", vertex_id,
2633 // crack -> pnt2.x, crack -> pnt2.y, crack -> pnt2.z, curve_id);
2634 // }
2635 // else
2636 // sprintf(buffer, "vertex %d fixed vertex %d\n", vertex_id, vertex_id - 2);
2637 // write_record(t3d_in_file, t3d_in_file_name, buffer);
2638 //
2639 // if(k == 1){
2640 // if(ellipsoid -> interface == 0)
2641 // sprintf(buffer, " Vertex %d %d", crack_ver_id2 - vertices, crack_ver_id2);
2642 // else
2643 // sprintf(buffer, " Vertex %d %d Vertex %d %d",
2644 // vertex_id - vertices, vertex_id + vertices, crack_ver_id2, crack_ver_id2 + 2 * vertices);
2645 // write_record(ctrl_file, ctrl_file_name, buffer);
2646 // }
2647 //
2648 // write_record(t3d_in_file, t3d_in_file_name, "\n");
2649 //
2650 // curve_id++;
2651 // sprintf(buffer, "curve %d vertex %d %d fixed curve %d\n", curve_id,
2652 // vertex_id - 1, vertex_id, curve_id - 1);
2653 // write_record(t3d_in_file, t3d_in_file_name, buffer);
2654 //
2655 // if(k == 1){
2656 // if(ellipsoid -> interface == 0)
2657 // sprintf(buffer, " Curve %d %d", curve_id - curves, curve_id);
2658 // else
2659 // sprintf(buffer, " Curve %d %d Curve %d %d",
2660 // curve_id - curves, curve_id + curves, curve_id, curve_id + 2 * curves);
2661 // write_record(ctrl_file, ctrl_file_name, buffer);
2662 // }
2663 //
2664 // if(k == 0 || k == 1)crack_cur_id1 = curve_id;
2665 //
2666 // curve_id++;
2667 // if((k != 0 && k != 2) || ellipsoid -> property == 0){
2668 // sprintf(buffer, "curve %d vertex %d %d fixed curve %d coincide curve %d\n", curve_id,
2669 // vertex_id - 1, vertex_id, curve_id - 2, curve_id - 1);
2670 // write_record(t3d_in_file, t3d_in_file_name, buffer);
2671 // }
2672 //
2673 // if(k == 1){
2674 // if(ellipsoid -> interface == 0)
2675 // sprintf(buffer, " Curve %d %d", curve_id - curves - 1, curve_id);
2676 // else{
2677 // if(ellipsoid -> property == 0)
2678 // sprintf(buffer, " Curve %d %d Curve %d %d",
2679 // curve_id - curves, curve_id + curves, curve_id, curve_id + 2 * curves);
2680 // else
2681 // sprintf(buffer, " Curve %d %d", curve_id, curve_id + 2 * curves);
2682 // }
2683 // write_record(ctrl_file, ctrl_file_name, buffer);
2684 // }
2685 //
2686 // write_record(t3d_in_file, t3d_in_file_name, "\n");
2687 // break;
2688 //
2689 // case 2:
2690 // vertex_id++;
2691 // if(fixed_a == NO || (k != 1 && k != 3 && ellipsoid -> interface != 0)){
2692 // j = crack -> qa - 1;
2693 // if(bmsz == 0.0){
2694 // default_msz = YES;
2695 // sprintf(buffer, "vertex %d xyz %e %e %e virtual\n", vertex_id,
2696 // contact_glob_point[j].x, contact_glob_point[j].y, contact_glob_point[j].z);
2697 // }
2698 // else
2699 // sprintf(buffer, "vertex %d xyz %e %e %e size %e virtual\n", vertex_id,
2700 // contact_glob_point[j].x, contact_glob_point[j].y, contact_glob_point[j].z, bmsz);
2701 // }
2702 // else{
2703 // if(bmsz == 0.0){
2704 // default_msz = YES;
2705 // sprintf(buffer, "vertex %d fixed vertex %d size def\n", vertex_id, crack_ver_id1);
2706 // }
2707 // else
2708 // sprintf(buffer, "vertex %d fixed vertex %d size %e\n", vertex_id, crack_ver_id1, bmsz);
2709 // }
2710 // write_record(t3d_in_file, t3d_in_file_name, buffer);
2711 //
2712 // vertex_id++;
2713 // if(fixed_b == NO || (k != 1 && k != 3 && ellipsoid -> interface != 0)){
2714 // if((j = crack -> qa + 1) >= 4)j -= 4;
2715 // if(bmsz == 0.0){
2716 // default_msz = YES;
2717 // sprintf(buffer, "vertex %d xyz %e %e %e virtual\n", vertex_id,
2718 // contact_glob_point[j].x, contact_glob_point[j].y, contact_glob_point[j].z);
2719 // }
2720 // else
2721 // sprintf(buffer, "vertex %d xyz %e %e %e size %e virtual\n", vertex_id,
2722 // contact_glob_point[j].x, contact_glob_point[j].y, contact_glob_point[j].z, bmsz);
2723 // }
2724 // else{
2725 // if(bmsz == 0.0){
2726 // default_msz = YES;
2727 // sprintf(buffer, "vertex %d fixed vertex %d size def\n", vertex_id, crack_ver_id2);
2728 // }
2729 // else
2730 // sprintf(buffer, "vertex %d fixed vertex %d size %e\n", vertex_id, crack_ver_id2, bmsz);
2731 // }
2732 // write_record(t3d_in_file, t3d_in_file_name, buffer);
2733 //
2734 // write_record(t3d_in_file, t3d_in_file_name, "\n");
2735 //
2736 // curve_id++;
2737 // sprintf(buffer, "curve %d order 4 vertex %d %d virtual\n", curve_id, vertex_id - 1, vertex_id);
2738 // write_record(t3d_in_file, t3d_in_file_name, buffer);
2739 // for(i = 0; i < 2; i++){
2740 // if((j = crack -> qa - 1 + i) >= 4)j -= 4;
2741 // if(bmsz == 0.0){
2742 // default_msz = YES;
2743 // sprintf(buffer, "polygon %d xyz %e %e %e weight %e\n", i + 1,
2744 // contact_glob_pnt[j].x, contact_glob_pnt[j].y, contact_glob_pnt[j].z, weight_h);
2745 // }
2746 // else
2747 // sprintf(buffer, "polygon %d xyz %e %e %e weight %e size %e\n", i + 1,
2748 // contact_glob_pnt[j].x, contact_glob_pnt[j].y, contact_glob_pnt[j].z, weight_h, bmsz);
2749 // write_record(t3d_in_file, t3d_in_file_name, buffer);
2750 // }
2751 //
2752 // write_record(t3d_in_file, t3d_in_file_name, "\n");
2753 //
2754 // vertex_id++;
2755 // if(fixed_a == NO){
2756 // if(k == 1 || k == 3 || ellipsoid -> interface == 0)
2757 // sprintf(buffer, "vertex %d xyz %e %e %e fixed curve %d fixed vertex %d\n", vertex_id,
2758 // crack -> pnt1.x, crack -> pnt1.y, crack -> pnt1.z, curve_id, crack_ver_id1);
2759 // else
2760 // sprintf(buffer, "vertex %d xyz %e %e %e fixed curve %d\n", vertex_id,
2761 // crack -> pnt1.x, crack -> pnt1.y, crack -> pnt1.z, curve_id);
2762 // }
2763 // else
2764 // sprintf(buffer, "vertex %d fixed vertex %d\n", vertex_id, vertex_id - 2);
2765 // write_record(t3d_in_file, t3d_in_file_name, buffer);
2766 //
2767 // if(k == 1){
2768 // if(ellipsoid -> interface == 0)
2769 // sprintf(buffer, " Vertex %d %d", crack_ver_id1 - vertices, crack_ver_id1);
2770 // else
2771 // sprintf(buffer, " Vertex %d %d Vertex %d %d",
2772 // vertex_id - vertices, vertex_id + vertices, crack_ver_id1, crack_ver_id1 + 2 * vertices);
2773 // write_record(ctrl_file, ctrl_file_name, buffer);
2774 // }
2775 //
2776 // vertex_id++;
2777 // if(fixed_b == NO){
2778 // if(k == 1 || k == 3 || ellipsoid -> interface == 0)
2779 // sprintf(buffer, "vertex %d xyz %e %e %e fixed curve %d fixed vertex %d\n", vertex_id,
2780 // crack -> pnt2.x, crack -> pnt2.y, crack -> pnt2.z, curve_id, crack_ver_id2);
2781 // else
2782 // sprintf(buffer, "vertex %d xyz %e %e %e fixed curve %d\n", vertex_id,
2783 // crack -> pnt2.x, crack -> pnt2.y, crack -> pnt2.z, curve_id);
2784 // }
2785 // else
2786 // sprintf(buffer, "vertex %d fixed vertex %d\n", vertex_id, vertex_id - 2);
2787 // write_record(t3d_in_file, t3d_in_file_name, buffer);
2788 //
2789 // if(k == 1){
2790 // if(ellipsoid -> interface == 0)
2791 // sprintf(buffer, " Vertex %d %d", crack_ver_id2 - vertices, crack_ver_id2);
2792 // else
2793 // sprintf(buffer, " Vertex %d %d Vertex %d %d",
2794 // vertex_id - vertices, vertex_id + vertices, crack_ver_id2, crack_ver_id2 + 2 * vertices);
2795 // write_record(ctrl_file, ctrl_file_name, buffer);
2796 // }
2797 //
2798 // write_record(t3d_in_file, t3d_in_file_name, "\n");
2799 //
2800 // curve_id++;
2801 // sprintf(buffer, "curve %d vertex %d %d fixed curve %d\n", curve_id,
2802 // vertex_id - 1, vertex_id, curve_id - 1);
2803 // write_record(t3d_in_file, t3d_in_file_name, buffer);
2804 //
2805 // if(k == 1){
2806 // if(ellipsoid -> interface == 0)
2807 // sprintf(buffer, " Curve %d %d", curve_id - curves, curve_id);
2808 // else
2809 // sprintf(buffer, " Curve %d %d Curve %d %d",
2810 // curve_id - curves, curve_id + curves, curve_id, curve_id + 2 * curves);
2811 // write_record(ctrl_file, ctrl_file_name, buffer);
2812 // }
2813 //
2814 // if(k == 0 || k == 1)crack_cur_id1 = curve_id;
2815 //
2816 // curve_id++;
2817 // if((k != 0 && k != 2) || ellipsoid -> property == 0){
2818 // sprintf(buffer, "curve %d vertex %d %d fixed curve %d coincide curve %d\n", curve_id,
2819 // vertex_id - 1, vertex_id, curve_id - 2, curve_id - 1);
2820 // write_record(t3d_in_file, t3d_in_file_name, buffer);
2821 // }
2822 //
2823 // if(k == 1){
2824 // if(ellipsoid -> interface == 0)
2825 // sprintf(buffer, " Curve %d %d", curve_id - curves - 1, curve_id);
2826 // else{
2827 // if(ellipsoid -> property == 0)
2828 // sprintf(buffer, " Curve %d %d Curve %d %d",
2829 // curve_id - curves, curve_id + curves, curve_id, curve_id + 2 * curves);
2830 // else
2831 // sprintf(buffer, " Curve %d %d", curve_id, curve_id + 2 * curves);
2832 // }
2833 // write_record(ctrl_file, ctrl_file_name, buffer);
2834 // }
2835 //
2836 // write_record(t3d_in_file, t3d_in_file_name, "\n");
2837 // break;
2838 //
2839 // case 3:
2840 // vertex_id++;
2841 // if(fixed_a == NO || (k != 1 && k != 3 && ellipsoid -> interface != 0)){
2842 // j = crack -> qa - 1;
2843 // if(bmsz == 0.0){
2844 // default_msz = YES;
2845 // sprintf(buffer, "vertex %d xyz %e %e %e virtual\n", vertex_id,
2846 // contact_glob_point[j].x, contact_glob_point[j].y, contact_glob_point[j].z);
2847 // }
2848 // else
2849 // sprintf(buffer, "vertex %d xyz %e %e %e size %e virtual\n", vertex_id,
2850 // contact_glob_point[j].x, contact_glob_point[j].y, contact_glob_point[j].z, bmsz);
2851 // }
2852 // else{
2853 // if(bmsz == 0.0){
2854 // default_msz = YES;
2855 // sprintf(buffer, "vertex %d fixed vertex %d size def\n", vertex_id, crack_ver_id1);
2856 // }
2857 // else
2858 // sprintf(buffer, "vertex %d fixed vertex %d size %e\n", vertex_id, crack_ver_id1, bmsz);
2859 // }
2860 // write_record(t3d_in_file, t3d_in_file_name, buffer);
2861 //
2862 // vertex_id++;
2863 // if(fixed_b == NO || (k != 1 && k != 3 && ellipsoid -> interface != 0)){
2864 // if((j = crack -> qa + 2) >= 4)j -= 4;
2865 // if(bmsz == 0.0){
2866 // default_msz = YES;
2867 // sprintf(buffer, "vertex %d xyz %e %e %e virtual\n", vertex_id,
2868 // contact_glob_point[j].x, contact_glob_point[j].y, contact_glob_point[j].z);
2869 // }
2870 // else
2871 // sprintf(buffer, "vertex %d xyz %e %e %e size %e virtual\n", vertex_id,
2872 // contact_glob_point[j].x, contact_glob_point[j].y, contact_glob_point[j].z, bmsz);
2873 // }
2874 // else{
2875 // if(bmsz == 0.0){
2876 // default_msz = YES;
2877 // sprintf(buffer, "vertex %d fixed vertex %d size def\n", vertex_id, crack_ver_id2);
2878 // }
2879 // else
2880 // sprintf(buffer, "vertex %d fixed vertex %d size %e\n", vertex_id, crack_ver_id2, bmsz);
2881 // }
2882 // write_record(t3d_in_file, t3d_in_file_name, buffer);
2883 //
2884 // write_record(t3d_in_file, t3d_in_file_name, "\n");
2885 //
2886 // if((j = crack -> qa + 2) >= 4)j -= 4;
2887 // curve_id++;
2888 // sprintf(buffer, "curve %d order 3 vertex %d %d virtual\n", curve_id, vertex_id - 1, vertex_id);
2889 // write_record(t3d_in_file, t3d_in_file_name, buffer);
2890 // if(bmsz == 0.0){
2891 // default_msz = YES;
2892 // sprintf(buffer, "polygon 1 xyz %e %e %e weight %e\n",
2893 // contact_glob_pnt[j].x, contact_glob_pnt[j].y, contact_glob_pnt[j].z, -weight_q);
2894 // }
2895 // else
2896 // sprintf(buffer, "polygon 1 xyz %e %e %e weight %e size %e\n",
2897 // contact_glob_pnt[j].x, contact_glob_pnt[j].y, contact_glob_pnt[j].z, -weight_q, bmsz);
2898 // write_record(t3d_in_file, t3d_in_file_name, buffer);
2899 //
2900 // write_record(t3d_in_file, t3d_in_file_name, "\n");
2901 //
2902 // vertex_id++;
2903 // if(fixed_a == NO){
2904 // if(k == 1 || k == 3 || ellipsoid -> interface == 0)
2905 // sprintf(buffer, "vertex %d xyz %e %e %e fixed curve %d fixed vertex %d\n", vertex_id,
2906 // crack -> pnt1.x, crack -> pnt1.y, crack -> pnt1.z, curve_id, crack_ver_id1);
2907 // else
2908 // sprintf(buffer, "vertex %d xyz %e %e %e fixed curve %d\n", vertex_id,
2909 // crack -> pnt1.x, crack -> pnt1.y, crack -> pnt1.z, curve_id);
2910 // }
2911 // else
2912 // sprintf(buffer, "vertex %d fixed vertex %d\n", vertex_id, vertex_id - 2);
2913 // write_record(t3d_in_file, t3d_in_file_name, buffer);
2914 //
2915 // if(k == 1){
2916 // if(ellipsoid -> interface == 0)
2917 // sprintf(buffer, " Vertex %d %d", crack_ver_id1 - vertices, crack_ver_id1);
2918 // else
2919 // sprintf(buffer, " Vertex %d %d Vertex %d %d",
2920 // vertex_id - vertices, vertex_id + vertices, crack_ver_id1, crack_ver_id1 + 2 * vertices);
2921 // write_record(ctrl_file, ctrl_file_name, buffer);
2922 // }
2923 //
2924 // vertex_id++;
2925 // if(fixed_b == NO){
2926 // if(k == 1 || k == 3 || ellipsoid -> interface == 0)
2927 // sprintf(buffer, "vertex %d xyz %e %e %e fixed curve %d fixed vertex %d\n", vertex_id,
2928 // crack -> pnt2.x, crack -> pnt2.y, crack -> pnt2.z, curve_id, crack_ver_id2);
2929 // else
2930 // sprintf(buffer, "vertex %d xyz %e %e %e fixed curve %d\n", vertex_id,
2931 // crack -> pnt2.x, crack -> pnt2.y, crack -> pnt2.z, curve_id);
2932 // }
2933 // else
2934 // sprintf(buffer, "vertex %d fixed vertex %d\n", vertex_id, vertex_id - 2);
2935 // write_record(t3d_in_file, t3d_in_file_name, buffer);
2936 //
2937 // if(k == 1){
2938 // if(ellipsoid -> interface == 0)
2939 // sprintf(buffer, " Vertex %d %d", crack_ver_id2 - vertices, crack_ver_id2);
2940 // else
2941 // sprintf(buffer, " Vertex %d %d Vertex %d %d",
2942 // vertex_id - vertices, vertex_id + vertices, crack_ver_id2, crack_ver_id2 + 2 * vertices);
2943 // write_record(ctrl_file, ctrl_file_name, buffer);
2944 // }
2945 //
2946 // write_record(t3d_in_file, t3d_in_file_name, "\n");
2947 //
2948 // curve_id++;
2949 // sprintf(buffer, "curve %d vertex %d %d fixed curve %d\n", curve_id,
2950 // vertex_id - 1, vertex_id, curve_id - 1);
2951 // write_record(t3d_in_file, t3d_in_file_name, buffer);
2952 //
2953 // if(k == 1){
2954 // if(ellipsoid -> interface == 0)
2955 // sprintf(buffer, " Curve %d %d", curve_id - curves, curve_id);
2956 // else
2957 // sprintf(buffer, " Curve %d %d Curve %d %d",
2958 // curve_id - curves, curve_id + curves, curve_id, curve_id + 2 * curves);
2959 // write_record(ctrl_file, ctrl_file_name, buffer);
2960 // }
2961 //
2962 // if(k == 0 || k == 1)crack_cur_id1 = curve_id;
2963 //
2964 // curve_id++;
2965 // if((k != 0 && k != 2) || ellipsoid -> property == 0){
2966 // sprintf(buffer, "curve %d vertex %d %d fixed curve %d coincide curve %d\n", curve_id,
2967 // vertex_id - 1, vertex_id, curve_id - 2, curve_id - 1);
2968 // write_record(t3d_in_file, t3d_in_file_name, buffer);
2969 // }
2970 //
2971 // if(k == 1){
2972 // if(ellipsoid -> interface == 0)
2973 // sprintf(buffer, " Curve %d %d", curve_id - curves - 1, curve_id);
2974 // else{
2975 // if(ellipsoid -> property == 0)
2976 // sprintf(buffer, " Curve %d %d Curve %d %d",
2977 // curve_id - curves, curve_id + curves, curve_id, curve_id + 2 * curves);
2978 // else
2979 // sprintf(buffer, " Curve %d %d", curve_id, curve_id + 2 * curves);
2980 // }
2981 // write_record(ctrl_file, ctrl_file_name, buffer);
2982 // }
2983 //
2984 // write_record(t3d_in_file, t3d_in_file_name, "\n");
2985 // break;
2986 //
2987 // case 4:
2988 // if(fixed_a == YES && fixed_b == YES)
2989 // error_message(GENERAL_ERROR, "Unimplemented situation");
2990 //
2991 // for(m = 0; m < 2; m++){
2992 // skip = NO;
2993 // if(m == 1){
2994 // if((k == 0 || k == 2) && ellipsoid -> property != 0)skip = YES;
2995 // }
2996 //
2997 // vertex_id++;
2998 // if(skip == NO){
2999 // if((fixed_a == NO && fixed_b == NO) || (k != 1 && k != 3 && ellipsoid -> interface != 0)){
3000 // j = crack -> qa - 1;
3001 // if(bmsz == 0.0){
3002 // default_msz = YES;
3003 // sprintf(buffer, "vertex %d xyz %e %e %e virtual\n", vertex_id,
3004 // contact_glob_point[j].x, contact_glob_point[j].y, contact_glob_point[j].z);
3005 // }
3006 // else
3007 // sprintf(buffer, "vertex %d xyz %e %e %e size %e virtual\n", vertex_id,
3008 // contact_glob_point[j].x, contact_glob_point[j].y, contact_glob_point[j].z, bmsz);
3009 // }
3010 // else{
3011 // if(fixed_a == YES){
3012 // if(bmsz == 0.0){
3013 // default_msz = YES;
3014 // sprintf(buffer, "vertex %d fixed vertex %d size def\n", vertex_id, crack_ver_id1);
3015 // }
3016 // else
3017 // sprintf(buffer, "vertex %d fixed vertex %d size %e\n", vertex_id, crack_ver_id1, bmsz);
3018 // }
3019 // if(fixed_b == YES){
3020 // if(bmsz == 0.0){
3021 // default_msz = YES;
3022 // sprintf(buffer, "vertex %d fixed vertex %d size def\n", vertex_id, crack_ver_id2);
3023 // }
3024 // else
3025 // sprintf(buffer, "vertex %d fixed vertex %d size %e\n", vertex_id, crack_ver_id2, bmsz);
3026 // }
3027 // }
3028 // write_record(t3d_in_file, t3d_in_file_name, buffer);
3029 // }
3030 //
3031 // if((j = crack -> qa + 1) >= 4)j -= 4;
3032 // vertex_id++;
3033 // if(skip == NO){
3034 // if(bmsz == 0.0){
3035 // default_msz = YES;
3036 // if(m == 1)
3037 // sprintf(buffer, "vertex %d xyz %e %e %e coincide vertex %d\n", vertex_id,
3038 // contact_glob_point[j].x, contact_glob_point[j].y, contact_glob_point[j].z, vertex_id - 4);
3039 // else
3040 // sprintf(buffer, "vertex %d xyz %e %e %e\n", vertex_id,
3041 // contact_glob_point[j].x, contact_glob_point[j].y, contact_glob_point[j].z);
3042 // }
3043 // else{
3044 // if(m == 1)
3045 // sprintf(buffer, "vertex %d xyz %e %e %e size %e coincide vertex %d\n", vertex_id,
3046 // contact_glob_point[j].x, contact_glob_point[j].y, contact_glob_point[j].z, bmsz, vertex_id - 4);
3047 // else
3048 // sprintf(buffer, "vertex %d xyz %e %e %e size %e\n", vertex_id,
3049 // contact_glob_point[j].x, contact_glob_point[j].y, contact_glob_point[j].z, bmsz);
3050 // }
3051 // write_record(t3d_in_file, t3d_in_file_name, buffer);
3052 // }
3053 //
3054 // if(k == 1){
3055 // if(ellipsoid -> interface == 0){
3056 // if(m == 0)
3057 // sprintf(buffer, " Vertex %d %d", vertex_id - vertices, vertex_id);
3058 // else
3059 // sprintf(buffer, " Vertex %d %d", vertex_id - vertices - 4, vertex_id);
3060 // }
3061 // else{
3062 // if(m == 0 || ellipsoid -> property == 0)
3063 // sprintf(buffer, " Vertex %d %d Vertex %d %d",
3064 // vertex_id - vertices, vertex_id + vertices, vertex_id, vertex_id + 2 * vertices);
3065 // else
3066 // sprintf(buffer, " Vertex %d %d", vertex_id, vertex_id + 2 * vertices);
3067 // }
3068 // write_record(ctrl_file, ctrl_file_name, buffer);
3069 // }
3070 //
3071 // if(skip == NO)write_record(t3d_in_file, t3d_in_file_name, "\n");
3072 //
3073 // curve_id++;
3074 // if(skip == NO){
3075 // sprintf(buffer, "curve %d order 4 vertex %d %d virtual\n", curve_id, vertex_id - 1, vertex_id);
3076 // write_record(t3d_in_file, t3d_in_file_name, buffer);
3077 // for(i = 0; i < 2; i++){
3078 // if((j = crack -> qa - 1 + i) >= 4)j -= 4;
3079 // if(bmsz == 0.0){
3080 // default_msz = YES;
3081 // sprintf(buffer, "polygon %d xyz %e %e %e weight %e\n", i + 1,
3082 // contact_glob_pnt[j].x, contact_glob_pnt[j].y, contact_glob_pnt[j].z, weight_h);
3083 // }
3084 // else
3085 // sprintf(buffer, "polygon %d xyz %e %e %e weight %e size %e\n", i + 1,
3086 // contact_glob_pnt[j].x, contact_glob_pnt[j].y, contact_glob_pnt[j].z, weight_h, bmsz);
3087 // write_record(t3d_in_file, t3d_in_file_name, buffer);
3088 // }
3089 // }
3090 //
3091 // curve_id++;
3092 // if(skip == NO){
3093 // sprintf(buffer, "curve %d order 4 vertex %d %d virtual\n", curve_id, vertex_id, vertex_id - 1);
3094 // write_record(t3d_in_file, t3d_in_file_name, buffer);
3095 // for(i = 0; i < 2; i++){
3096 // if((j = crack -> qa + 1 + i) >= 4)j -= 4;
3097 // if(bmsz == 0.0){
3098 // default_msz = YES;
3099 // sprintf(buffer, "polygon %d xyz %e %e %e weight %e\n", i + 1,
3100 // contact_glob_pnt[j].x, contact_glob_pnt[j].y, contact_glob_pnt[j].z, weight_h);
3101 // }
3102 // else
3103 // sprintf(buffer, "polygon %d xyz %e %e %e weight %e size %e\n", i + 1,
3104 // contact_glob_pnt[j].x, contact_glob_pnt[j].y, contact_glob_pnt[j].z, weight_h, bmsz);
3105 // write_record(t3d_in_file, t3d_in_file_name, buffer);
3106 // }
3107 // }
3108 //
3109 // if(skip == NO)write_record(t3d_in_file, t3d_in_file_name, "\n");
3110 //
3111 // vertex_id++;
3112 // if(skip == NO){
3113 // if(fixed_a == NO){
3114 // if(k == 1 || k == 3 || ellipsoid -> interface == 0)
3115 // sprintf(buffer, "vertex %d xyz %e %e %e fixed curve %d fixed vertex %d\n", vertex_id,
3116 // crack -> pnt1.x, crack -> pnt1.y, crack -> pnt1.z, curve_id - 1, crack_ver_id1);
3117 // else{
3118 // if(m == 1)
3119 // sprintf(buffer, "vertex %d xyz %e %e %e fixed curve %d fixed vertex %d\n", vertex_id,
3120 // crack -> pnt1.x, crack -> pnt1.y, crack -> pnt1.z, curve_id - 1, vertex_id - 4);
3121 // else
3122 // sprintf(buffer, "vertex %d xyz %e %e %e fixed curve %d\n", vertex_id,
3123 // crack -> pnt1.x, crack -> pnt1.y, crack -> pnt1.z, curve_id - 1);
3124 // }
3125 // }
3126 // else
3127 // sprintf(buffer, "vertex %d fixed vertex %d\n", vertex_id, vertex_id - 2);
3128 // write_record(t3d_in_file, t3d_in_file_name, buffer);
3129 // }
3130 //
3131 // if(k == 1 && m == 0){
3132 // if(ellipsoid -> interface == 0)
3133 // sprintf(buffer, " Vertex %d %d", crack_ver_id1 - vertices, crack_ver_id1);
3134 // else
3135 // sprintf(buffer, " Vertex %d %d Vertex %d %d",
3136 // vertex_id - vertices, vertex_id + vertices, crack_ver_id1, crack_ver_id1 + 2 * vertices);
3137 // write_record(ctrl_file, ctrl_file_name, buffer);
3138 // }
3139 //
3140 // vertex_id++;
3141 // if(skip == NO){
3142 // if(fixed_b == NO){
3143 // if(k == 1 || k == 3 || ellipsoid -> interface == 0)
3144 // sprintf(buffer, "vertex %d xyz %e %e %e fixed curve %d fixed vertex %d\n", vertex_id,
3145 // crack -> pnt2.x, crack -> pnt2.y, crack -> pnt2.z, curve_id, crack_ver_id2);
3146 // else{
3147 // if(m == 1)
3148 // sprintf(buffer, "vertex %d xyz %e %e %e fixed curve %d fixed vertex %d\n", vertex_id,
3149 // crack -> pnt2.x, crack -> pnt2.y, crack -> pnt2.z, curve_id, vertex_id - 4);
3150 // else
3151 // sprintf(buffer, "vertex %d xyz %e %e %e fixed curve %d\n", vertex_id,
3152 // crack -> pnt2.x, crack -> pnt2.y, crack -> pnt2.z, curve_id);
3153 // }
3154 // }
3155 // else
3156 // sprintf(buffer, "vertex %d fixed vertex %d\n", vertex_id, vertex_id - 3);
3157 // write_record(t3d_in_file, t3d_in_file_name, buffer);
3158 // }
3159 //
3160 // if(k == 1 && m == 0){
3161 // if(ellipsoid -> interface == 0)
3162 // sprintf(buffer, " Vertex %d %d", crack_ver_id2 - vertices, crack_ver_id2);
3163 // else
3164 // sprintf(buffer, " Vertex %d %d Vertex %d %d",
3165 // vertex_id - vertices, vertex_id + vertices, crack_ver_id2, crack_ver_id2 + 2 * vertices);
3166 // write_record(ctrl_file, ctrl_file_name, buffer);
3167 // }
3168 //
3169 // if(skip == NO)write_record(t3d_in_file, t3d_in_file_name, "\n");
3170 //
3171 // curve_id++;
3172 // if(skip == NO){
3173 // if(m == 1)
3174 // sprintf(buffer, "curve %d vertex %d %d fixed curve %d coincide curve %d\n", curve_id,
3175 // vertex_id - 1, vertex_id - 2, curve_id - 2, curve_id - 4);
3176 // else
3177 // sprintf(buffer, "curve %d vertex %d %d fixed curve %d\n", curve_id,
3178 // vertex_id - 1, vertex_id - 2, curve_id - 2);
3179 // write_record(t3d_in_file, t3d_in_file_name, buffer);
3180 // }
3181 //
3182 // if(k == 1){
3183 // if(ellipsoid -> interface == 0){
3184 // if(m == 0)
3185 // sprintf(buffer, " Curve %d %d", curve_id - curves, curve_id);
3186 // else
3187 // sprintf(buffer, " Curve %d %d", curve_id - curves - 4, curve_id);
3188 // }
3189 // else{
3190 // if(m == 0 || ellipsoid -> property == 0)
3191 // sprintf(buffer, " Curve %d %d Curve %d %d",
3192 // curve_id - curves, curve_id + curves, curve_id, curve_id + 2 * curves);
3193 // else
3194 // sprintf(buffer, " Curve %d %d", curve_id, curve_id + 2 * curves);
3195 // }
3196 // write_record(ctrl_file, ctrl_file_name, buffer);
3197 // }
3198 //
3199 // if(m == 0){
3200 // if(k == 0 || k == 1)crack_cur_id1 = curve_id;
3201 // }
3202 //
3203 // curve_id++;
3204 // if(skip == NO){
3205 // if(m == 1)
3206 // sprintf(buffer, "curve %d vertex %d %d fixed curve %d coincide curve %d\n", curve_id,
3207 // vertex_id - 2, vertex_id, curve_id - 2, curve_id - 4);
3208 // else
3209 // sprintf(buffer, "curve %d vertex %d %d fixed curve %d\n", curve_id,
3210 // vertex_id - 2, vertex_id, curve_id - 2);
3211 // write_record(t3d_in_file, t3d_in_file_name, buffer);
3212 // }
3213 //
3214 // if(k == 1){
3215 // if(ellipsoid -> interface == 0){
3216 // if(m == 0)
3217 // sprintf(buffer, " Curve %d %d", curve_id - curves, curve_id);
3218 // else
3219 // sprintf(buffer, " Curve %d %d", curve_id - curves - 4, curve_id);
3220 // }
3221 // else{
3222 // if(m == 0 || ellipsoid -> property == 0)
3223 // sprintf(buffer, " Curve %d %d Curve %d %d",
3224 // curve_id - curves, curve_id + curves, curve_id, curve_id + 2 * curves);
3225 // else
3226 // sprintf(buffer, " Curve %d %d", curve_id, curve_id + 2 * curves);
3227 // }
3228 // write_record(ctrl_file, ctrl_file_name, buffer);
3229 // }
3230 //
3231 // if(m == 0){
3232 // if(k == 0 || k == 1)crack_cur_id2 = curve_id;
3233 // }
3234 //
3235 // if(skip == NO)write_record(t3d_in_file, t3d_in_file_name, "\n");
3236 // }
3237 // break;
3238 //
3239 // case 5:
3240 // for(m = 0; m < 2; m++){
3241 // skip = NO;
3242 // if(m == 1){
3243 // if((k == 0 || k == 2) && ellipsoid -> property != 0)skip = YES;
3244 // }
3245 //
3246 // vertex_id++;
3247 // if(skip == NO){
3248 // if((j = crack -> qa + 1) >= 4)j -= 4;
3249 // if(bmsz == 0.0){
3250 // default_msz = YES;
3251 // if(m == 1)
3252 // sprintf(buffer, "vertex %d xyz %e %e %e coincide vertex %d\n", vertex_id,
3253 // contact_glob_point[j].x, contact_glob_point[j].y, contact_glob_point[j].z, vertex_id - 4);
3254 // else
3255 // sprintf(buffer, "vertex %d xyz %e %e %e\n", vertex_id,
3256 // contact_glob_point[j].x, contact_glob_point[j].y, contact_glob_point[j].z);
3257 // }
3258 // else{
3259 // if(m == 1)
3260 // sprintf(buffer, "vertex %d xyz %e %e %e size %e coincide vertex %d\n", vertex_id,
3261 // contact_glob_point[j].x, contact_glob_point[j].y, contact_glob_point[j].z, bmsz, vertex_id - 4);
3262 // else
3263 // sprintf(buffer, "vertex %d xyz %e %e %e size %e\n", vertex_id,
3264 // contact_glob_point[j].x, contact_glob_point[j].y, contact_glob_point[j].z, bmsz);
3265 // }
3266 // write_record(t3d_in_file, t3d_in_file_name, buffer);
3267 // }
3268 //
3269 // if(k == 1){
3270 // if(ellipsoid -> interface == 0){
3271 // if(m == 0)
3272 // sprintf(buffer, " Vertex %d %d", vertex_id - vertices, vertex_id);
3273 // else
3274 // sprintf(buffer, " Vertex %d %d", vertex_id - vertices - 4, vertex_id);
3275 // }
3276 // else{
3277 // if(m == 0 || ellipsoid -> property == 0)
3278 // sprintf(buffer, " Vertex %d %d Vertex %d %d",
3279 // vertex_id - vertices, vertex_id + vertices, vertex_id, vertex_id + 2 * vertices);
3280 // else
3281 // sprintf(buffer, " Vertex %d %d", vertex_id, vertex_id + 2 * vertices);
3282 // }
3283 // write_record(ctrl_file, ctrl_file_name, buffer);
3284 // }
3285 //
3286 // vertex_id++;
3287 // if(skip == NO){
3288 // if((j = crack -> qa + 2) >= 4)j -= 4;
3289 // if(bmsz == 0.0){
3290 // default_msz = YES;
3291 // if(m == 1)
3292 // sprintf(buffer, "vertex %d xyz %e %e %e coincide vertex %d\n", vertex_id,
3293 // contact_glob_point[j].x, contact_glob_point[j].y, contact_glob_point[j].z, vertex_id - 4);
3294 // else
3295 // sprintf(buffer, "vertex %d xyz %e %e %e\n", vertex_id,
3296 // contact_glob_point[j].x, contact_glob_point[j].y, contact_glob_point[j].z);
3297 // }
3298 // else{
3299 // if(m == 1)
3300 // sprintf(buffer, "vertex %d xyz %e %e %e size %e coincide vertex %d\n", vertex_id,
3301 // contact_glob_point[j].x, contact_glob_point[j].y, contact_glob_point[j].z, bmsz, vertex_id - 4);
3302 // else
3303 // sprintf(buffer, "vertex %d xyz %e %e %e size %e\n", vertex_id,
3304 // contact_glob_point[j].x, contact_glob_point[j].y, contact_glob_point[j].z, bmsz);
3305 // }
3306 // write_record(t3d_in_file, t3d_in_file_name, buffer);
3307 // }
3308 //
3309 // if(k == 1){
3310 // if(ellipsoid -> interface == 0){
3311 // if(m == 0)
3312 // sprintf(buffer, " Vertex %d %d", vertex_id - vertices, vertex_id);
3313 // else
3314 // sprintf(buffer, " Vertex %d %d", vertex_id - vertices - 4, vertex_id);
3315 // }
3316 // else{
3317 // if(m == 0 || ellipsoid -> property == 0)
3318 // sprintf(buffer, " Vertex %d %d Vertex %d %d",
3319 // vertex_id - vertices, vertex_id + vertices, vertex_id, vertex_id + 2 * vertices);
3320 // else
3321 // sprintf(buffer, " Vertex %d %d", vertex_id, vertex_id + 2 * vertices);
3322 // }
3323 // write_record(ctrl_file, ctrl_file_name, buffer);
3324 // }
3325 //
3326 // if(skip == NO)write_record(t3d_in_file, t3d_in_file_name, "\n");
3327 //
3328 // curve_id++;
3329 // if(skip == NO){
3330 // if((j = crack -> qa + 1) >= 4)j -= 4;
3331 // if(m == 1)
3332 // sprintf(buffer, "curve %d order 3 vertex %d %d coincide curve %d\n", curve_id,
3333 // vertex_id - 1, vertex_id, curve_id - 4);
3334 // else
3335 // sprintf(buffer, "curve %d order 3 vertex %d %d\n", curve_id, vertex_id - 1, vertex_id);
3336 // write_record(t3d_in_file, t3d_in_file_name, buffer);
3337 // if(bmsz == 0.0){
3338 // default_msz = YES;
3339 // sprintf(buffer, "polygon 1 xyz %e %e %e weight %e\n",
3340 // contact_glob_pnt[j].x, contact_glob_pnt[j].y, contact_glob_pnt[j].z, weight_q);
3341 // }
3342 // else
3343 // sprintf(buffer, "polygon 1 xyz %e %e %e weight %e size %e\n",
3344 // contact_glob_pnt[j].x, contact_glob_pnt[j].y, contact_glob_pnt[j].z, weight_q, bmsz);
3345 // write_record(t3d_in_file, t3d_in_file_name, buffer);
3346 // }
3347 //
3348 // if(k == 1){
3349 // if(ellipsoid -> interface == 0){
3350 // if(m == 0)
3351 // sprintf(buffer, " Curve %d %d", curve_id - curves, curve_id);
3352 // else
3353 // sprintf(buffer, " Curve %d %d", curve_id - curves - 4, curve_id);
3354 // }
3355 // else{
3356 // if(m == 0 || ellipsoid -> property == 0)
3357 // sprintf(buffer, " Curve %d %d Curve %d %d",
3358 // curve_id - curves, curve_id + curves, curve_id, curve_id + 2 * curves);
3359 // else
3360 // sprintf(buffer, " Curve %d %d", curve_id, curve_id + 2 * curves);
3361 // }
3362 // write_record(ctrl_file, ctrl_file_name, buffer);
3363 // }
3364 //
3365 // if(m == 0){
3366 // if(k == 0 || k == 1)crack_cur_id2 = curve_id;
3367 // }
3368 //
3369 // curve_id++;
3370 // if(skip == NO){
3371 // sprintf(buffer, "curve %d order 3 vertex %d %d virtual\n", curve_id, vertex_id, vertex_id - 1);
3372 // write_record(t3d_in_file, t3d_in_file_name, buffer);
3373 // if(bmsz == 0.0){
3374 // default_msz = YES;
3375 // sprintf(buffer, "polygon 1 xyz %e %e %e weight %e\n",
3376 // contact_glob_pnt[j].x, contact_glob_pnt[j].y, contact_glob_pnt[j].z, -weight_q);
3377 // }
3378 // else
3379 // sprintf(buffer, "polygon 1 xyz %e %e %e weight %e size %e\n",
3380 // contact_glob_pnt[j].x, contact_glob_pnt[j].y, contact_glob_pnt[j].z, -weight_q, bmsz);
3381 // write_record(t3d_in_file, t3d_in_file_name, buffer);
3382 // }
3383 //
3384 // if(skip == NO)write_record(t3d_in_file, t3d_in_file_name, "\n");
3385 //
3386 // vertex_id++;
3387 // if(skip == NO){
3388 // if(k == 1 || k == 3 || ellipsoid -> interface == 0)
3389 // sprintf(buffer, "vertex %d xyz %e %e %e fixed curve %d fixed vertex %d\n", vertex_id,
3390 // crack -> pnt1.x, crack -> pnt1.y, crack -> pnt1.z, curve_id, crack_ver_id1);
3391 // else{
3392 // if(m == 1)
3393 // sprintf(buffer, "vertex %d xyz %e %e %e fixed curve %d fixed vertex %d\n", vertex_id,
3394 // crack -> pnt1.x, crack -> pnt1.y, crack -> pnt1.z, curve_id, vertex_id - 4);
3395 // else
3396 // sprintf(buffer, "vertex %d xyz %e %e %e fixed curve %d\n", vertex_id,
3397 // crack -> pnt1.x, crack -> pnt1.y, crack -> pnt1.z, curve_id);
3398 // }
3399 // write_record(t3d_in_file, t3d_in_file_name, buffer);
3400 // }
3401 //
3402 // if(k == 1 && m == 0){
3403 // if(ellipsoid -> interface == 0)
3404 // sprintf(buffer, " Vertex %d %d", crack_ver_id1 - vertices, crack_ver_id1);
3405 // else
3406 // sprintf(buffer, " Vertex %d %d Vertex %d %d",
3407 // vertex_id - vertices, vertex_id + vertices, crack_ver_id1, crack_ver_id1 + 2 * vertices);
3408 // write_record(ctrl_file, ctrl_file_name, buffer);
3409 // }
3410 //
3411 // vertex_id++;
3412 // if(skip == NO){
3413 // if(k == 1 || k == 3 || ellipsoid -> interface == 0)
3414 // sprintf(buffer, "vertex %d xyz %e %e %e fixed curve %d fixed vertex %d\n", vertex_id,
3415 // crack -> pnt2.x, crack -> pnt2.y, crack -> pnt2.z, curve_id, crack_ver_id2);
3416 // else{
3417 // if(m == 1)
3418 // sprintf(buffer, "vertex %d xyz %e %e %e fixed curve %d fixed vertex %d\n", vertex_id,
3419 // crack -> pnt2.x, crack -> pnt2.y, crack -> pnt2.z, curve_id, vertex_id - 4);
3420 // else
3421 // sprintf(buffer, "vertex %d xyz %e %e %e fixed curve %d\n", vertex_id,
3422 // crack -> pnt2.x, crack -> pnt2.y, crack -> pnt2.z, curve_id);
3423 // }
3424 // write_record(t3d_in_file, t3d_in_file_name, buffer);
3425 // }
3426 //
3427 // if(k == 1 && m == 0){
3428 // if(ellipsoid -> interface == 0)
3429 // sprintf(buffer, " Vertex %d %d", crack_ver_id2 - vertices, crack_ver_id2);
3430 // else
3431 // sprintf(buffer, " Vertex %d %d Vertex %d %d",
3432 // vertex_id - vertices, vertex_id + vertices, crack_ver_id2, crack_ver_id2 + 2 * vertices);
3433 // write_record(ctrl_file, ctrl_file_name, buffer);
3434 // }
3435 //
3436 // if(skip == NO)write_record(t3d_in_file, t3d_in_file_name, "\n");
3437 //
3438 // curve_id++;
3439 // if(skip == NO){
3440 // if(m == 1)
3441 // sprintf(buffer, "curve %d vertex %d %d fixed curve %d coincide curve %d\n", curve_id,
3442 // vertex_id - 1, vertex_id - 3, curve_id - 1, curve_id - 4);
3443 // else
3444 // sprintf(buffer, "curve %d vertex %d %d fixed curve %d\n", curve_id,
3445 // vertex_id - 1, vertex_id - 3, curve_id - 1);
3446 // write_record(t3d_in_file, t3d_in_file_name, buffer);
3447 // }
3448 //
3449 // if(k == 1){
3450 // if(ellipsoid -> interface == 0){
3451 // if(m == 0)
3452 // sprintf(buffer, " Curve %d %d", curve_id - curves, curve_id);
3453 // else
3454 // sprintf(buffer, " Curve %d %d", curve_id - curves - 4, curve_id);
3455 // }
3456 // else{
3457 // if(m == 0 || ellipsoid -> property == 0)
3458 // sprintf(buffer, " Curve %d %d Curve %d %d",
3459 // curve_id - curves, curve_id + curves, curve_id, curve_id + 2 * curves);
3460 // else
3461 // sprintf(buffer, " Curve %d %d", curve_id, curve_id + 2 * curves);
3462 // }
3463 // write_record(ctrl_file, ctrl_file_name, buffer);
3464 // }
3465 //
3466 // if(m == 0){
3467 // if(k == 0 || k == 1)crack_cur_id1 = curve_id;
3468 // }
3469 //
3470 // curve_id++;
3471 // if(skip == NO){
3472 // if(m == 1)
3473 // sprintf(buffer, "curve %d vertex %d %d fixed curve %d coincide curve %d\n", curve_id,
3474 // vertex_id - 2, vertex_id, curve_id - 2, curve_id - 4);
3475 // else
3476 // sprintf(buffer, "curve %d vertex %d %d fixed curve %d\n", curve_id,
3477 // vertex_id - 2, vertex_id, curve_id - 2);
3478 // write_record(t3d_in_file, t3d_in_file_name, buffer);
3479 // }
3480 //
3481 // if(k == 1){
3482 // if(ellipsoid -> interface == 0){
3483 // if(m == 0)
3484 // sprintf(buffer, " Curve %d %d", curve_id - curves, curve_id);
3485 // else
3486 // sprintf(buffer, " Curve %d %d", curve_id - curves - 4, curve_id);
3487 // }
3488 // else{
3489 // if(m == 0 || ellipsoid -> property == 0)
3490 // sprintf(buffer, " Curve %d %d Curve %d %d",
3491 // curve_id - curves, curve_id + curves, curve_id, curve_id + 2 * curves);
3492 // else
3493 // sprintf(buffer, " Curve %d %d", curve_id, curve_id + 2 * curves);
3494 // }
3495 // write_record(ctrl_file, ctrl_file_name, buffer);
3496 // }
3497 //
3498 // if(m == 0){
3499 // if(k == 0 || k == 1)crack_cur_id3 = curve_id;
3500 // }
3501 //
3502 // write_record(t3d_in_file, t3d_in_file_name, "\n");
3503 // }
3504 // break;
3505 // }
3506 // }
3507 //
3508 // /* note: it is essential to make all the shells (inclusion, matrix, inrerfaces) topologically identical !!!
3509 // since on non-empty inclusion shell curves must be fixed to the shell, it is necessary to
3510 // ensure the identity (in terms of mesh generation process) by carefull ordering of boundary curves
3511 // on remaining shells;
3512 // the other way would be to split the shell into two shells but that would make additional mesh constraint */
3513 //
3514 // shell_id++;
3515 // if((k == 0 || k == 2) && ellipsoid -> property != 0){
3516 // switch(contact_case){
3517 // case 0:
3518 // sprintf(buffer, "shell %d bgsurface %d boundary curve %d %d fixed curve %d %d\n", shell_id, surface_id - 1,
3519 // base_cur_id1, base_cur_id2, curve_id - 3, curve_id - 2);
3520 // break;
3521 // case 1:
3522 // case 2:
3523 // case 3:
3524 // sprintf(buffer, "shell %d bgsurface %d boundary curve %d %d fixed curve %d\n", shell_id, surface_id - 1,
3525 // base_cur_id1, base_cur_id2, curve_id - 1);
3526 // break;
3527 // case 4:
3528 // sprintf(buffer, "shell %d bgsurface %d boundary curve %d %d fixed curve %d %d\n", shell_id, surface_id - 1,
3529 // base_cur_id1, base_cur_id2, curve_id - 5, curve_id - 4);
3530 // break;
3531 // case 5:
3532 // sprintf(buffer, "shell %d bgsurface %d boundary curve %d %d fixed curve %d %d %d\n", shell_id, surface_id - 1,
3533 // base_cur_id1, base_cur_id2, curve_id - 5, curve_id - 7, curve_id - 4);
3534 // break;
3535 // }
3536 // }
3537 // else{
3538 // switch(contact_case){
3539 // case 0:
3540 // sprintf(buffer, "shell %d bgsurface %d boundary curve %d %d %d %d %d %d\n", shell_id, surface_id - 1,
3541 // base_cur_id1, base_cur_id2, -(curve_id - 3), -(curve_id - 2), curve_id - 1, curve_id);
3542 // break;
3543 // case 1:
3544 // case 2:
3545 // case 3:
3546 // sprintf(buffer, "shell %d bgsurface %d boundary curve %d %d %d %d\n", shell_id, surface_id - 1,
3547 // base_cur_id1, base_cur_id2, -(curve_id - 1), curve_id);
3548 // break;
3549 // case 4:
3550 // sprintf(buffer, "shell %d bgsurface %d boundary curve %d %d %d %d %d %d\n", shell_id, surface_id - 1,
3551 // base_cur_id1, base_cur_id2, -(curve_id - 5), -(curve_id - 4), curve_id - 1, curve_id);
3552 // break;
3553 // case 5:
3554 // sprintf(buffer, "shell %d bgsurface %d boundary curve %d %d %d %d %d %d %d %d\n", shell_id, surface_id - 1,
3555 // base_cur_id1, base_cur_id2, -(curve_id - 5), -(curve_id - 7), -(curve_id - 4), curve_id - 1, curve_id - 3,
3556 // curve_id);
3557 // break;
3558 // }
3559 // }
3560 // write_record(t3d_in_file, t3d_in_file_name, buffer);
3561 //
3562 // if(k == 1){
3563 // if(ellipsoid -> interface == 0)
3564 // sprintf(buffer, " Shell %d %d", shell_id - shells, shell_id);
3565 // else
3566 // sprintf(buffer, " Shell %d %d Shell %d %d",
3567 // shell_id - shells, shell_id + shells, shell_id, shell_id + 2 * shells);
3568 // write_record(ctrl_file, ctrl_file_name, buffer);
3569 // }
3570 // if(k == 2){
3571 // sprintf(buffer, " Shell %d %d", shell_id, shell_id + shells);
3572 // write_record(ctrl_file, ctrl_file_name, buffer);
3573 // }
3574 //
3575 // write_record(t3d_in_file, t3d_in_file_name, "\n");
3576 //
3577 // if(k == 0){
3578 // region_id++;
3579 // if(ellipsoid -> property == 0)
3580 // sprintf(tmp_buffer, "region %d boundary surface %d boundary shell %d", region_id, -surface_id, shell_id);
3581 // else{
3582 // /* sprintf(buffer, "Region %d\nElemType %d\n", region_id, ellipsoid -> property); */
3583 // sprintf(buffer, "Region %d\nTetraType %d\n", region_id, ellipsoid -> property);
3584 // write_record(ctrl_file, ctrl_file_name, buffer);
3585 //
3586 // if(imsz == 0.0){
3587 // default_msz = YES;
3588 // sprintf(buffer, "region %d boundary surface %d boundary shell %d size def property %d\n\n", region_id,
3589 // -surface_id, shell_id, ellipsoid -> property);
3590 // }
3591 // else
3592 // sprintf(buffer, "region %d boundary surface %d boundary shell %d size %e property %d\n\n", region_id,
3593 // -surface_id, shell_id, imsz, ellipsoid -> property);
3594 // write_record(t3d_in_file, t3d_in_file_name, buffer);
3595 // }
3596 //
3597 // if(ellipsoid -> interface == 0){
3598 //
3599 // #ifdef MERLIN
3600 // if(ellipsoid -> property == prop || ellipsoid -> property == 0){
3601 // ellipsoid -> region = region_id;
3602 // break;
3603 // }
3604 // #else
3605 // ellipsoid -> region = region_id;
3606 // break;
3607 // #endif
3608 //
3609 // }
3610 // else{
3611 // if(ellipsoid -> bc != 0){
3612 // bc = YES;
3613 // sprintf(ellipsoid -> bc_ellipsoid_spec, "#Surface %d Shell %d\n", surface_id, shell_id);
3614 // sprintf(ellipsoid -> bc_matrix_spec, "#Surface %d Shell %d\n", surface_id + surfaces, shell_id + shells);
3615 // }
3616 // }
3617 // }
3618 //
3619 // if(k == 1){
3620 // region_id++;
3621 // sprintf(tmp_buffer, "region %d boundary surface %d boundary shell %d", region_id, -surface_id, shell_id);
3622 // ellipsoid -> region = region_id;
3623 // }
3624 //
3625 // if(k == 1 || k == 2)write_record(ctrl_file, ctrl_file_name, "\n");
3626 //
3627 // #ifdef MERLIN
3628 // if(k == 1 && ellipsoid -> interface == 0)break;
3629 // #else
3630 // if(k == 1)break;
3631 // #endif
3632 //
3633 // }
3634 //
3635 // if(ellipsoid -> interface != 0){
3636 // if(crack -> segment == YES){
3637 // iface_crack_ver_id1 = crack_ver_id1;
3638 // iface_crack_ver_id2 = crack_ver_id2;
3639 //
3640 // crack_ver_id1 -= 2 * vertices;
3641 // crack_ver_id2 -= 2 * vertices;
3642 // }
3643 //
3644 // switch(contact_case){
3645 // case 5:
3646 // iface_crack_cur_id3 = crack_cur_id3 + 2 * curves;
3647 // case 4:
3648 // case 0:
3649 // iface_crack_cur_id2 = crack_cur_id2 + 2 * curves;
3650 // case 3:
3651 // case 2:
3652 // case 1:
3653 // iface_crack_cur_id1 = crack_cur_id1 + 2 * curves;
3654 // }
3655 // }
3656 //
3657 // if(ellipsoid -> interface == 0 && crack -> interface != 0){
3658 //
3659 // /* make contact for crack interface;
3660 // this is always modelled by pair(s) of curves to prevent high degeneration of crack interface elements */
3661 //
3662 // sprintf(buffer, "# crack contact interface\n\n");
3663 // write_record(t3d_in_file, t3d_in_file_name, buffer);
3664 //
3665 // sprintf(buffer, "MasterSlave");
3666 // write_record(ctrl_file, ctrl_file_name, buffer);
3667 //
3668 // if(crack -> segment == NO){
3669 // for(m = 0; m < 2; m++){
3670 // for(i = 0; i < 2; i++){
3671 // vertex_id++;
3672 // j = 2 * i;
3673 // if(cmsz == 0.0){
3674 // default_msz = YES;
3675 // sprintf(buffer, "vertex %d xyz %e %e %e\n", vertex_id,
3676 // contact_glob_point[j].x, contact_glob_point[j].y, contact_glob_point[j].z);
3677 // }
3678 // else
3679 // sprintf(buffer, "vertex %d xyz %e %e %e size %e\n", vertex_id,
3680 // contact_glob_point[j].x, contact_glob_point[j].y, contact_glob_point[j].z, cmsz);
3681 // write_record(t3d_in_file, t3d_in_file_name, buffer);
3682 //
3683 // if(ellipsoid -> property != 0 && ellipsoid -> property != prop){
3684 // if(m == 0)
3685 // sprintf(buffer, " Vertex %d %d", vertex_id - 2 * vertices + 2, vertex_id);
3686 // else
3687 // sprintf(buffer, " Vertex %d %d", vertex_id - 2 * vertices, vertex_id);
3688 // }
3689 // else{
3690 // if(m == 0 || ellipsoid -> property == 0)
3691 // sprintf(buffer, " Vertex %d %d", vertex_id - vertices + 2, vertex_id);
3692 // else
3693 // sprintf(buffer, " Vertex %d %d", vertex_id - vertices, vertex_id);
3694 // }
3695 // write_record(ctrl_file, ctrl_file_name, buffer);
3696 //
3697 // if(m == 0){
3698 // if(i == 0)iface_crack_ver_id1 = vertex_id;
3699 // if(i == 1)iface_crack_ver_id2 = vertex_id;
3700 // }
3701 // }
3702 //
3703 // write_record(t3d_in_file, t3d_in_file_name, "\n");
3704 //
3705 // for(i = 0; i < 2; i++){
3706 // curve_id++;
3707 // sprintf(buffer, "curve %d order 4 vertex %d %d\n", curve_id, vertex_id - 1 + i, vertex_id - i);
3708 // write_record(t3d_in_file, t3d_in_file_name, buffer);
3709 //
3710 // for(j = 0; j < 2; j++){
3711 // n = 2 * i + j;
3712 // if(cmsz == 0.0){
3713 // default_msz = YES;
3714 // sprintf(buffer, "polygon %d xyz %e %e %e weight %e\n", j + 1,
3715 // contact_glob_pnt[n].x, contact_glob_pnt[n].y, contact_glob_pnt[n].z, weight_h);
3716 // }
3717 // else
3718 // sprintf(buffer, "polygon %d xyz %e %e %e weight %e size %e\n", j + 1,
3719 // contact_glob_pnt[n].x, contact_glob_pnt[n].y, contact_glob_pnt[n].z, weight_h, cmsz);
3720 // write_record(t3d_in_file, t3d_in_file_name, buffer);
3721 // }
3722 //
3723 // if(ellipsoid -> property != 0 && ellipsoid -> property != prop){
3724 //
3725 // /* use curve on inclusion boundary as master */
3726 // if(m == 0)
3727 // sprintf(buffer, " Curve %d %d", curve_id - 2 * curves + 4, curve_id);
3728 // else
3729 // sprintf(buffer, " Curve %d %d", curve_id - 2 * curves + 2, curve_id);
3730 // }
3731 // else{
3732 // if(m == 0 || ellipsoid -> property == 0)
3733 // sprintf(buffer, " Curve %d %d", curve_id - curves + 4, curve_id);
3734 // else
3735 // sprintf(buffer, " Curve %d %d", curve_id - curves + 2, curve_id);
3736 // }
3737 // write_record(ctrl_file, ctrl_file_name, buffer);
3738 //
3739 // if(m == 0){
3740 // if(i == 0)iface_crack_cur_id1 = curve_id;
3741 // if(i == 1)iface_crack_cur_id2 = curve_id;
3742 // }
3743 // }
3744 //
3745 // write_record(t3d_in_file, t3d_in_file_name, "\n");
3746 // }
3747 // }
3748 // else{
3749 // vertex_id++;
3750 // if(tmsz == 0.0){
3751 // default_msz = YES;
3752 // sprintf(buffer, "vertex %d xyz %e %e %e\n", vertex_id,
3753 // crack -> pnt1.x, crack -> pnt1.y, crack -> pnt1.z);
3754 // }
3755 // else
3756 // sprintf(buffer, "vertex %d xyz %e %e %e size %e\n", vertex_id,
3757 // crack -> pnt1.x, crack -> pnt1.y, crack -> pnt1.z, tmsz);
3758 // write_record(t3d_in_file, t3d_in_file_name, buffer);
3759 // iface_crack_ver_id1 = vertex_id;
3760 //
3761 // if(ellipsoid -> property != 0 && ellipsoid -> property != prop)
3762 // sprintf(buffer, " Vertex %d %d", crack_ver_id1 - vertices, iface_crack_ver_id1);
3763 // else
3764 // sprintf(buffer, " Vertex %d %d", crack_ver_id1, iface_crack_ver_id1);
3765 // write_record(ctrl_file, ctrl_file_name, buffer);
3766 //
3767 // vertex_id++;
3768 // if(tmsz == 0.0){
3769 // default_msz = YES;
3770 // sprintf(buffer, "vertex %d xyz %e %e %e\n", vertex_id,
3771 // crack -> pnt2.x, crack -> pnt2.y, crack -> pnt2.z);
3772 // }
3773 // else
3774 // sprintf(buffer, "vertex %d xyz %e %e %e size %e\n", vertex_id,
3775 // crack -> pnt2.x, crack -> pnt2.y, crack -> pnt2.z, tmsz);
3776 // write_record(t3d_in_file, t3d_in_file_name, buffer);
3777 // iface_crack_ver_id2 = vertex_id;
3778 //
3779 // if(ellipsoid -> property != 0 && ellipsoid -> property != prop)
3780 // sprintf(buffer, " Vertex %d %d", crack_ver_id2 - vertices, iface_crack_ver_id2);
3781 // else
3782 // sprintf(buffer, " Vertex %d %d", crack_ver_id2, iface_crack_ver_id2);
3783 // write_record(ctrl_file, ctrl_file_name, buffer);
3784 //
3785 // write_record(t3d_in_file, t3d_in_file_name, "\n");
3786 //
3787 // switch(contact_case){
3788 // case 1:
3789 // vertex_id++;
3790 // if(fixed_a == NO){
3791 // j = crack -> qa - 1;
3792 // if(bmsz == 0.0){
3793 // default_msz = YES;
3794 // sprintf(buffer, "vertex %d xyz %e %e %e virtual\n", vertex_id,
3795 // contact_glob_point[j].x, contact_glob_point[j].y, contact_glob_point[j].z);
3796 // }
3797 // else
3798 // sprintf(buffer, "vertex %d xyz %e %e %e size %e virtual\n", vertex_id,
3799 // contact_glob_point[j].x, contact_glob_point[j].y, contact_glob_point[j].z, bmsz);
3800 // }
3801 // else{
3802 // if(bmsz == 0.0){
3803 // default_msz = YES;
3804 // sprintf(buffer, "vertex %d fixed vertex %d size def\n", vertex_id, iface_crack_ver_id1);
3805 // }
3806 // else
3807 // sprintf(buffer, "vertex %d fixed vertex %d size %e\n", vertex_id, iface_crack_ver_id1, bmsz);
3808 // }
3809 // write_record(t3d_in_file, t3d_in_file_name, buffer);
3810 //
3811 // vertex_id++;
3812 // if(fixed_b == NO){
3813 // if((j = crack -> qa) >= 4)j -= 4;
3814 // if(bmsz == 0.0){
3815 // default_msz = YES;
3816 // sprintf(buffer, "vertex %d xyz %e %e %e virtual\n", vertex_id,
3817 // contact_glob_point[j].x, contact_glob_point[j].y, contact_glob_point[j].z);
3818 // }
3819 // else
3820 // sprintf(buffer, "vertex %d xyz %e %e %e size %e virtual\n", vertex_id,
3821 // contact_glob_point[j].x, contact_glob_point[j].y, contact_glob_point[j].z, bmsz);
3822 // }
3823 // else{
3824 // if(bmsz == 0.0){
3825 // default_msz = YES;
3826 // sprintf(buffer, "vertex %d fixed vertex %d size def\n", vertex_id, iface_crack_ver_id2);
3827 // }
3828 // else
3829 // sprintf(buffer, "vertex %d fixed vertex %d size %e\n", vertex_id, iface_crack_ver_id2, bmsz);
3830 // }
3831 // write_record(t3d_in_file, t3d_in_file_name, buffer);
3832 //
3833 // write_record(t3d_in_file, t3d_in_file_name, "\n");
3834 //
3835 // j = crack -> qa - 1;
3836 // curve_id++;
3837 // sprintf(buffer, "curve %d order 3 vertex %d %d virtual\n", curve_id, vertex_id - 1, vertex_id);
3838 // write_record(t3d_in_file, t3d_in_file_name, buffer);
3839 // if(bmsz == 0.0){
3840 // default_msz = YES;
3841 // sprintf(buffer, "polygon 1 xyz %e %e %e weight %e\n",
3842 // contact_glob_pnt[j].x, contact_glob_pnt[j].y, contact_glob_pnt[j].z, weight_q);
3843 // }
3844 // else
3845 // sprintf(buffer, "polygon 1 xyz %e %e %e weight %e size %e\n",
3846 // contact_glob_pnt[j].x, contact_glob_pnt[j].y, contact_glob_pnt[j].z, weight_q, bmsz);
3847 // write_record(t3d_in_file, t3d_in_file_name, buffer);
3848 //
3849 // write_record(t3d_in_file, t3d_in_file_name, "\n");
3850 //
3851 // vertex_id++;
3852 // if(fixed_a == NO)
3853 // sprintf(buffer, "vertex %d xyz %e %e %e fixed curve %d fixed vertex %d\n", vertex_id,
3854 // crack -> pnt1.x, crack -> pnt1.y, crack -> pnt1.z, curve_id, iface_crack_ver_id1);
3855 // else
3856 // sprintf(buffer, "vertex %d fixed vertex %d\n", vertex_id, vertex_id - 2);
3857 // write_record(t3d_in_file, t3d_in_file_name, buffer);
3858 //
3859 // vertex_id++;
3860 // if(fixed_b == NO)
3861 // sprintf(buffer, "vertex %d xyz %e %e %e fixed curve %d fixed vertex %d\n", vertex_id,
3862 // crack -> pnt2.x, crack -> pnt2.y, crack -> pnt2.z, curve_id, iface_crack_ver_id2);
3863 // else
3864 // sprintf(buffer, "vertex %d fixed vertex %d\n", vertex_id, vertex_id - 2);
3865 // write_record(t3d_in_file, t3d_in_file_name, buffer);
3866 //
3867 // write_record(t3d_in_file, t3d_in_file_name, "\n");
3868 //
3869 // curve_id++;
3870 // sprintf(buffer, "curve %d vertex %d %d fixed curve %d\n", curve_id,
3871 // vertex_id - 1, vertex_id, curve_id - 1);
3872 // write_record(t3d_in_file, t3d_in_file_name, buffer);
3873 // iface_crack_cur_id1 = curve_id;
3874 //
3875 // if(ellipsoid -> property != 0 && ellipsoid -> property != prop)
3876 // sprintf(buffer, " Curve %d %d", curve_id - 2 * curves + 4, curve_id);
3877 // else
3878 // sprintf(buffer, " Curve %d %d", curve_id - curves + 4, curve_id);
3879 // write_record(ctrl_file, ctrl_file_name, buffer);
3880 //
3881 // curve_id++;
3882 // sprintf(buffer, "curve %d vertex %d %d fixed curve %d\n", curve_id,
3883 // vertex_id - 1, vertex_id, curve_id - 2);
3884 // write_record(t3d_in_file, t3d_in_file_name, buffer);
3885 //
3886 // if(ellipsoid -> property == 0)
3887 // sprintf(buffer, " Curve %d %d", curve_id - curves + 4, curve_id);
3888 // else{
3889 // if(ellipsoid -> property != 0 && ellipsoid -> property != prop)
3890 // sprintf(buffer, " Curve %d %d", curve_id - 2 * curves + 3, curve_id);
3891 // else
3892 // sprintf(buffer, " Curve %d %d", curve_id - curves + 3, curve_id);
3893 // }
3894 // write_record(ctrl_file, ctrl_file_name, buffer);
3895 //
3896 // write_record(t3d_in_file, t3d_in_file_name, "\n");
3897 // break;
3898 //
3899 // case 2:
3900 // vertex_id++;
3901 // if(fixed_a == NO){
3902 // j = crack -> qa - 1;
3903 // if(bmsz == 0.0){
3904 // default_msz = YES;
3905 // sprintf(buffer, "vertex %d xyz %e %e %e virtual\n", vertex_id,
3906 // contact_glob_point[j].x, contact_glob_point[j].y, contact_glob_point[j].z);
3907 // }
3908 // else
3909 // sprintf(buffer, "vertex %d xyz %e %e %e size %e virtual\n", vertex_id,
3910 // contact_glob_point[j].x, contact_glob_point[j].y, contact_glob_point[j].z, bmsz);
3911 // }
3912 // else{
3913 // if(bmsz == 0.0){
3914 // default_msz = YES;
3915 // sprintf(buffer, "vertex %d fixed vertex %d size def\n", vertex_id, iface_crack_ver_id1);
3916 // }
3917 // else
3918 // sprintf(buffer, "vertex %d fixed vertex %d size %e\n", vertex_id, iface_crack_ver_id1, bmsz);
3919 // }
3920 // write_record(t3d_in_file, t3d_in_file_name, buffer);
3921 //
3922 // vertex_id++;
3923 // if(fixed_b == NO){
3924 // if((j = crack -> qa + 1) >= 4)j -= 4;
3925 // if(bmsz == 0.0){
3926 // default_msz = YES;
3927 // sprintf(buffer, "vertex %d xyz %e %e %e virtual\n", vertex_id,
3928 // contact_glob_point[j].x, contact_glob_point[j].y, contact_glob_point[j].z);
3929 // }
3930 // else
3931 // sprintf(buffer, "vertex %d xyz %e %e %e size %e virtual\n", vertex_id,
3932 // contact_glob_point[j].x, contact_glob_point[j].y, contact_glob_point[j].z, bmsz);
3933 // }
3934 // else{
3935 // if(bmsz == 0.0){
3936 // default_msz = YES;
3937 // sprintf(buffer, "vertex %d fixed vertex %d size def\n", vertex_id, iface_crack_ver_id2);
3938 // }
3939 // else
3940 // sprintf(buffer, "vertex %d fixed vertex %d size %e\n", vertex_id, iface_crack_ver_id2, bmsz);
3941 // }
3942 // write_record(t3d_in_file, t3d_in_file_name, buffer);
3943 //
3944 // write_record(t3d_in_file, t3d_in_file_name, "\n");
3945 //
3946 // curve_id++;
3947 // sprintf(buffer, "curve %d order 4 vertex %d %d virtual\n", curve_id, vertex_id - 1, vertex_id);
3948 // write_record(t3d_in_file, t3d_in_file_name, buffer);
3949 // for(i = 0; i < 2; i++){
3950 // if((j = crack -> qa - 1 + i) >= 4)j -= 4;
3951 // if(bmsz == 0.0){
3952 // default_msz = YES;
3953 // sprintf(buffer, "polygon %d xyz %e %e %e weight %e\n", i + 1,
3954 // contact_glob_pnt[j].x, contact_glob_pnt[j].y, contact_glob_pnt[j].z, weight_h);
3955 // }
3956 // else
3957 // sprintf(buffer, "polygon %d xyz %e %e %e weight %e size %e\n", i + 1,
3958 // contact_glob_pnt[j].x, contact_glob_pnt[j].y, contact_glob_pnt[j].z, weight_h, bmsz);
3959 // write_record(t3d_in_file, t3d_in_file_name, buffer);
3960 // }
3961 //
3962 // write_record(t3d_in_file, t3d_in_file_name, "\n");
3963 //
3964 // vertex_id++;
3965 // if(fixed_a == NO)
3966 // sprintf(buffer, "vertex %d xyz %e %e %e fixed curve %d fixed vertex %d\n", vertex_id,
3967 // crack -> pnt1.x, crack -> pnt1.y, crack -> pnt1.z, curve_id, iface_crack_ver_id1);
3968 // else
3969 // sprintf(buffer, "vertex %d fixed vertex %d\n", vertex_id, vertex_id - 2);
3970 // write_record(t3d_in_file, t3d_in_file_name, buffer);
3971 //
3972 // vertex_id++;
3973 // if(fixed_b == NO)
3974 // sprintf(buffer, "vertex %d xyz %e %e %e fixed curve %d fixed vertex %d\n", vertex_id,
3975 // crack -> pnt2.x, crack -> pnt2.y, crack -> pnt2.z, curve_id, iface_crack_ver_id2);
3976 // else
3977 // sprintf(buffer, "vertex %d fixed vertex %d\n", vertex_id, vertex_id - 2);
3978 // write_record(t3d_in_file, t3d_in_file_name, buffer);
3979 //
3980 // write_record(t3d_in_file, t3d_in_file_name, "\n");
3981 //
3982 // curve_id++;
3983 // sprintf(buffer, "curve %d vertex %d %d fixed curve %d\n", curve_id,
3984 // vertex_id - 1, vertex_id, curve_id - 1);
3985 // write_record(t3d_in_file, t3d_in_file_name, buffer);
3986 // iface_crack_cur_id1 = curve_id;
3987 //
3988 // if(ellipsoid -> property != 0 && ellipsoid -> property != prop)
3989 // sprintf(buffer, " Curve %d %d", curve_id - 2 * curves + 4, curve_id);
3990 // else
3991 // sprintf(buffer, " Curve %d %d", curve_id - curves + 4, curve_id);
3992 // write_record(ctrl_file, ctrl_file_name, buffer);
3993 //
3994 // curve_id++;
3995 // sprintf(buffer, "curve %d vertex %d %d fixed curve %d\n", curve_id,
3996 // vertex_id - 1, vertex_id, curve_id - 2);
3997 // write_record(t3d_in_file, t3d_in_file_name, buffer);
3998 //
3999 // if(ellipsoid -> property == 0)
4000 // sprintf(buffer, " Curve %d %d", curve_id - curves + 4, curve_id);
4001 // else{
4002 // if(ellipsoid -> property != 0 && ellipsoid -> property != prop)
4003 // sprintf(buffer, " Curve %d %d", curve_id - 2 * curves + 3, curve_id);
4004 // else
4005 // sprintf(buffer, " Curve %d %d", curve_id - curves + 3, curve_id);
4006 // }
4007 // write_record(ctrl_file, ctrl_file_name, buffer);
4008 //
4009 // write_record(t3d_in_file, t3d_in_file_name, "\n");
4010 // break;
4011 //
4012 // case 3:
4013 // vertex_id++;
4014 // if(fixed_a == NO){
4015 // j = crack -> qa - 1;
4016 // if(bmsz == 0.0){
4017 // default_msz = YES;
4018 // sprintf(buffer, "vertex %d xyz %e %e %e virtual\n", vertex_id,
4019 // contact_glob_point[j].x, contact_glob_point[j].y, contact_glob_point[j].z);
4020 // }
4021 // else
4022 // sprintf(buffer, "vertex %d xyz %e %e %e size %e virtual\n", vertex_id,
4023 // contact_glob_point[j].x, contact_glob_point[j].y, contact_glob_point[j].z, bmsz);
4024 // }
4025 // else{
4026 // if(bmsz == 0.0){
4027 // default_msz = YES;
4028 // sprintf(buffer, "vertex %d fixed vertex %d size def\n", vertex_id, iface_crack_ver_id1);
4029 // }
4030 // else
4031 // sprintf(buffer, "vertex %d fixed vertex %d size %e\n", vertex_id, iface_crack_ver_id1, bmsz);
4032 // }
4033 // write_record(t3d_in_file, t3d_in_file_name, buffer);
4034 //
4035 // vertex_id++;
4036 // if(fixed_b == NO){
4037 // if((j = crack -> qa + 2) >= 4)j -= 4;
4038 // if(bmsz == 0.0){
4039 // default_msz = YES;
4040 // sprintf(buffer, "vertex %d xyz %e %e %e virtual\n", vertex_id,
4041 // contact_glob_point[j].x, contact_glob_point[j].y, contact_glob_point[j].z);
4042 // }
4043 // else
4044 // sprintf(buffer, "vertex %d xyz %e %e %e size %e virtual\n", vertex_id,
4045 // contact_glob_point[j].x, contact_glob_point[j].y, contact_glob_point[j].z, bmsz);
4046 // }
4047 // else{
4048 // if(bmsz == 0.0){
4049 // default_msz = YES;
4050 // sprintf(buffer, "vertex %d fixed vertex %d size def\n", vertex_id, iface_crack_ver_id2);
4051 // }
4052 // else
4053 // sprintf(buffer, "vertex %d fixed vertex %d size %e\n", vertex_id, iface_crack_ver_id2, bmsz);
4054 // }
4055 // write_record(t3d_in_file, t3d_in_file_name, buffer);
4056 //
4057 // write_record(t3d_in_file, t3d_in_file_name, "\n");
4058 //
4059 // if((j = crack -> qa + 2) >= 4)j -= 4;
4060 // curve_id++;
4061 // sprintf(buffer, "curve %d order 3 vertex %d %d virtual\n", curve_id, vertex_id - 1, vertex_id);
4062 // write_record(t3d_in_file, t3d_in_file_name, buffer);
4063 // if(bmsz == 0.0){
4064 // default_msz = YES;
4065 // sprintf(buffer, "polygon 1 xyz %e %e %e weight %e\n",
4066 // contact_glob_pnt[j].x, contact_glob_pnt[j].y, contact_glob_pnt[j].z, -weight_q);
4067 // }
4068 // else
4069 // sprintf(buffer, "polygon 1 xyz %e %e %e weight %e size %e\n",
4070 // contact_glob_pnt[j].x, contact_glob_pnt[j].y, contact_glob_pnt[j].z, -weight_q, bmsz);
4071 // write_record(t3d_in_file, t3d_in_file_name, buffer);
4072 //
4073 // write_record(t3d_in_file, t3d_in_file_name, "\n");
4074 //
4075 // vertex_id++;
4076 // if(fixed_a == NO)
4077 // sprintf(buffer, "vertex %d xyz %e %e %e fixed curve %d fixed vertex %d\n", vertex_id,
4078 // crack -> pnt1.x, crack -> pnt1.y, crack -> pnt1.z, curve_id, iface_crack_ver_id1);
4079 // else
4080 // sprintf(buffer, "vertex %d fixed vertex %d\n", vertex_id, vertex_id - 2);
4081 // write_record(t3d_in_file, t3d_in_file_name, buffer);
4082 //
4083 // vertex_id++;
4084 // if(fixed_b == NO)
4085 // sprintf(buffer, "vertex %d xyz %e %e %e fixed curve %d fixed vertex %d\n", vertex_id,
4086 // crack -> pnt2.x, crack -> pnt2.y, crack -> pnt2.z, curve_id, iface_crack_ver_id2);
4087 // else
4088 // sprintf(buffer, "vertex %d fixed vertex %d\n", vertex_id, vertex_id - 2);
4089 // write_record(t3d_in_file, t3d_in_file_name, buffer);
4090 //
4091 // write_record(t3d_in_file, t3d_in_file_name, "\n");
4092 //
4093 // curve_id++;
4094 // sprintf(buffer, "curve %d vertex %d %d fixed curve %d\n", curve_id,
4095 // vertex_id - 1, vertex_id, curve_id - 1);
4096 // write_record(t3d_in_file, t3d_in_file_name, buffer);
4097 // iface_crack_cur_id1 = curve_id;
4098 //
4099 // if(ellipsoid -> property != 0 && ellipsoid -> property != prop)
4100 // sprintf(buffer, " Curve %d %d", curve_id - 2 * curves + 4, curve_id);
4101 // else
4102 // sprintf(buffer, " Curve %d %d", curve_id - curves + 4, curve_id);
4103 // write_record(ctrl_file, ctrl_file_name, buffer);
4104 //
4105 // curve_id++;
4106 // sprintf(buffer, "curve %d vertex %d %d fixed curve %d\n", curve_id,
4107 // vertex_id - 1, vertex_id, curve_id - 2);
4108 // write_record(t3d_in_file, t3d_in_file_name, buffer);
4109 //
4110 // if(ellipsoid -> property == 0)
4111 // sprintf(buffer, " Curve %d %d", curve_id - curves + 4, curve_id);
4112 // else{
4113 // if(ellipsoid -> property != 0 && ellipsoid -> property != prop)
4114 // sprintf(buffer, " Curve %d %d", curve_id - 2 * curves + 3, curve_id);
4115 // else
4116 // sprintf(buffer, " Curve %d %d", curve_id - curves + 3, curve_id);
4117 // }
4118 // write_record(ctrl_file, ctrl_file_name, buffer);
4119 //
4120 // write_record(t3d_in_file, t3d_in_file_name, "\n");
4121 // break;
4122 //
4123 // case 4:
4124 // if(fixed_a == YES && fixed_b == YES)
4125 // error_message(GENERAL_ERROR, "Unimplemented situation");
4126 //
4127 // for(m = 0; m < 2; m++){
4128 // vertex_id++;
4129 // if(fixed_a == NO && fixed_b == NO){
4130 // j = crack -> qa - 1;
4131 // if(bmsz == 0.0){
4132 // default_msz = YES;
4133 // sprintf(buffer, "vertex %d xyz %e %e %e virtual\n", vertex_id,
4134 // contact_glob_point[j].x, contact_glob_point[j].y, contact_glob_point[j].z);
4135 // }
4136 // else
4137 // sprintf(buffer, "vertex %d xyz %e %e %e size %e virtual\n", vertex_id,
4138 // contact_glob_point[j].x, contact_glob_point[j].y, contact_glob_point[j].z, bmsz);
4139 // }
4140 // else{
4141 // if(fixed_a == YES){
4142 // if(bmsz == 0.0){
4143 // default_msz = YES;
4144 // sprintf(buffer, "vertex %d fixed vertex %d size def\n", vertex_id, iface_crack_ver_id1);
4145 // }
4146 // else
4147 // sprintf(buffer, "vertex %d fixed vertex %d size %e\n", vertex_id, iface_crack_ver_id1, bmsz);
4148 // }
4149 // if(fixed_b == YES){
4150 // if(bmsz == 0.0){
4151 // default_msz = YES;
4152 // sprintf(buffer, "vertex %d fixed vertex %d size def\n", vertex_id, iface_crack_ver_id2);
4153 // }
4154 // else
4155 // sprintf(buffer, "vertex %d fixed vertex %d size %e\n", vertex_id, iface_crack_ver_id2, bmsz);
4156 // }
4157 // }
4158 // write_record(t3d_in_file, t3d_in_file_name, buffer);
4159 //
4160 // if((j = crack -> qa + 1) >= 4)j -= 4;
4161 // vertex_id++;
4162 // if(bmsz == 0.0){
4163 // default_msz = YES;
4164 // sprintf(buffer, "vertex %d xyz %e %e %e\n", vertex_id,
4165 // contact_glob_point[j].x, contact_glob_point[j].y, contact_glob_point[j].z);
4166 // }
4167 // else
4168 // sprintf(buffer, "vertex %d xyz %e %e %e size %e\n", vertex_id,
4169 // contact_glob_point[j].x, contact_glob_point[j].y, contact_glob_point[j].z, bmsz);
4170 // write_record(t3d_in_file, t3d_in_file_name, buffer);
4171 //
4172 // if(ellipsoid -> property != 0 && ellipsoid -> property != prop){
4173 // if(m == 0)
4174 // sprintf(buffer, " Vertex %d %d", vertex_id - 2 * vertices + 2, vertex_id);
4175 // else
4176 // sprintf(buffer, " Vertex %d %d", vertex_id - 2 * vertices - 2, vertex_id);
4177 // }
4178 // else{
4179 // if(m == 0 || ellipsoid -> property == 0)
4180 // sprintf(buffer, " Vertex %d %d", vertex_id - vertices + 2, vertex_id);
4181 // else
4182 // sprintf(buffer, " Vertex %d %d", vertex_id - vertices - 2, vertex_id);
4183 // }
4184 // write_record(ctrl_file, ctrl_file_name, buffer);
4185 //
4186 // write_record(t3d_in_file, t3d_in_file_name, "\n");
4187 //
4188 // curve_id++;
4189 // sprintf(buffer, "curve %d order 4 vertex %d %d virtual\n", curve_id, vertex_id - 1, vertex_id);
4190 // write_record(t3d_in_file, t3d_in_file_name, buffer);
4191 // for(i = 0; i < 2; i++){
4192 // if((j = crack -> qa - 1 + i) >= 4)j -= 4;
4193 // if(bmsz == 0.0){
4194 // default_msz = YES;
4195 // sprintf(buffer, "polygon %d xyz %e %e %e weight %e\n", i + 1,
4196 // contact_glob_pnt[j].x, contact_glob_pnt[j].y, contact_glob_pnt[j].z, weight_h);
4197 // }
4198 // else
4199 // sprintf(buffer, "polygon %d xyz %e %e %e weight %e size %e\n", i + 1,
4200 // contact_glob_pnt[j].x, contact_glob_pnt[j].y, contact_glob_pnt[j].z, weight_h, bmsz);
4201 // write_record(t3d_in_file, t3d_in_file_name, buffer);
4202 // }
4203 //
4204 // curve_id++;
4205 // sprintf(buffer, "curve %d order 4 vertex %d %d virtual\n", curve_id, vertex_id, vertex_id - 1);
4206 // write_record(t3d_in_file, t3d_in_file_name, buffer);
4207 // for(i = 0; i < 2; i++){
4208 // if((j = crack -> qa + 1 + i) >= 4)j -= 4;
4209 // if(bmsz == 0.0){
4210 // default_msz = YES;
4211 // sprintf(buffer, "polygon %d xyz %e %e %e weight %e\n", i + 1,
4212 // contact_glob_pnt[j].x, contact_glob_pnt[j].y, contact_glob_pnt[j].z, weight_h);
4213 // }
4214 // else
4215 // sprintf(buffer, "polygon %d xyz %e %e %e weight %e size %e\n", i + 1,
4216 // contact_glob_pnt[j].x, contact_glob_pnt[j].y, contact_glob_pnt[j].z, weight_h, bmsz);
4217 // write_record(t3d_in_file, t3d_in_file_name, buffer);
4218 // }
4219 //
4220 // write_record(t3d_in_file, t3d_in_file_name, "\n");
4221 //
4222 // vertex_id++;
4223 // if(fixed_a == NO)
4224 // sprintf(buffer, "vertex %d xyz %e %e %e fixed curve %d fixed vertex %d\n", vertex_id,
4225 // crack -> pnt1.x, crack -> pnt1.y, crack -> pnt1.z, curve_id - 1, iface_crack_ver_id1);
4226 // else
4227 // sprintf(buffer, "vertex %d fixed vertex %d\n", vertex_id, vertex_id - 2);
4228 // write_record(t3d_in_file, t3d_in_file_name, buffer);
4229 //
4230 // vertex_id++;
4231 // if(fixed_b == NO)
4232 // sprintf(buffer, "vertex %d xyz %e %e %e fixed curve %d fixed vertex %d\n", vertex_id,
4233 // crack -> pnt2.x, crack -> pnt2.y, crack -> pnt2.z, curve_id, iface_crack_ver_id2);
4234 // else
4235 // sprintf(buffer, "vertex %d fixed vertex %d\n", vertex_id, vertex_id - 2);
4236 // write_record(t3d_in_file, t3d_in_file_name, buffer);
4237 //
4238 // write_record(t3d_in_file, t3d_in_file_name, "\n");
4239 //
4240 // curve_id++;
4241 // sprintf(buffer, "curve %d vertex %d %d fixed curve %d\n", curve_id,
4242 // vertex_id - 1, vertex_id - 2, curve_id - 2);
4243 // write_record(t3d_in_file, t3d_in_file_name, buffer);
4244 // if(m == 0)iface_crack_cur_id1 = curve_id;
4245 //
4246 // if(ellipsoid -> property != 0 && ellipsoid -> property != prop){
4247 // if(m == 0)
4248 // sprintf(buffer, " Curve %d %d", curve_id - 2 * curves + 4, curve_id);
4249 // else
4250 // sprintf(buffer, " Curve %d %d", curve_id - 2 * curves, curve_id);
4251 // }
4252 // else{
4253 // if(m == 0 || ellipsoid -> property == 0)
4254 // sprintf(buffer, " Curve %d %d", curve_id - curves + 4, curve_id);
4255 // else
4256 // sprintf(buffer, " Curve %d %d", curve_id - curves, curve_id);
4257 // }
4258 // write_record(ctrl_file, ctrl_file_name, buffer);
4259 //
4260 // curve_id++;
4261 // sprintf(buffer, "curve %d vertex %d %d fixed curve %d\n", curve_id,
4262 // vertex_id - 2, vertex_id, curve_id - 2);
4263 // write_record(t3d_in_file, t3d_in_file_name, buffer);
4264 // if(m == 0)iface_crack_cur_id2 = curve_id;
4265 //
4266 // if(ellipsoid -> property != 0 && ellipsoid -> property != prop){
4267 // if(m == 0)
4268 // sprintf(buffer, " Curve %d %d", curve_id - 2 * curves + 4, curve_id);
4269 // else
4270 // sprintf(buffer, " Curve %d %d", curve_id - 2 * curves, curve_id);
4271 // }
4272 // else{
4273 // if(m == 0 || ellipsoid -> property == 0)
4274 // sprintf(buffer, " Curve %d %d", curve_id - curves + 4, curve_id);
4275 // else
4276 // sprintf(buffer, " Curve %d %d", curve_id - curves, curve_id);
4277 // }
4278 // write_record(ctrl_file, ctrl_file_name, buffer);
4279 //
4280 // write_record(t3d_in_file, t3d_in_file_name, "\n");
4281 // }
4282 // break;
4283 //
4284 // case 5:
4285 // for(m = 0; m < 2; m++){
4286 // vertex_id++;
4287 // if((j = crack -> qa + 1) >= 4)j -= 4;
4288 // if(bmsz == 0.0){
4289 // default_msz = YES;
4290 // sprintf(buffer, "vertex %d xyz %e %e %e\n", vertex_id,
4291 // contact_glob_point[j].x, contact_glob_point[j].y, contact_glob_point[j].z);
4292 // }
4293 // else
4294 // sprintf(buffer, "vertex %d xyz %e %e %e size %e\n", vertex_id,
4295 // contact_glob_point[j].x, contact_glob_point[j].y, contact_glob_point[j].z, bmsz);
4296 // write_record(t3d_in_file, t3d_in_file_name, buffer);
4297 //
4298 // if(ellipsoid -> property != 0 && ellipsoid -> property != prop){
4299 // if(m == 0)
4300 // sprintf(buffer, " Vertex %d %d", vertex_id - 2 * vertices + 2, vertex_id);
4301 // else
4302 // sprintf(buffer, " Vertex %d %d", vertex_id - 2 * vertices - 2, vertex_id);
4303 // }
4304 // else{
4305 // if(m == 0 || ellipsoid -> property == 0)
4306 // sprintf(buffer, " Vertex %d %d", vertex_id - vertices + 2, vertex_id);
4307 // else
4308 // sprintf(buffer, " Vertex %d %d", vertex_id - vertices - 2, vertex_id);
4309 // }
4310 // write_record(ctrl_file, ctrl_file_name, buffer);
4311 //
4312 // vertex_id++;
4313 // if((j = crack -> qa + 2) >= 4)j -= 4;
4314 // if(bmsz == 0.0){
4315 // default_msz = YES;
4316 // sprintf(buffer, "vertex %d xyz %e %e %e\n", vertex_id,
4317 // contact_glob_point[j].x, contact_glob_point[j].y, contact_glob_point[j].z);
4318 // }
4319 // else
4320 // sprintf(buffer, "vertex %d xyz %e %e %e size %e\n", vertex_id,
4321 // contact_glob_point[j].x, contact_glob_point[j].y, contact_glob_point[j].z, bmsz);
4322 // write_record(t3d_in_file, t3d_in_file_name, buffer);
4323 //
4324 // if(ellipsoid -> property != 0 && ellipsoid -> property != prop){
4325 // if(m == 0)
4326 // sprintf(buffer, " Vertex %d %d", vertex_id - 2 * vertices + 2, vertex_id);
4327 // else
4328 // sprintf(buffer, " Vertex %d %d", vertex_id - 2 * vertices - 2, vertex_id);
4329 // }
4330 // else{
4331 // if(m == 0 || ellipsoid -> property == 0)
4332 // sprintf(buffer, " Vertex %d %d", vertex_id - vertices + 2, vertex_id);
4333 // else
4334 // sprintf(buffer, " Vertex %d %d", vertex_id - vertices - 2, vertex_id);
4335 // }
4336 // write_record(ctrl_file, ctrl_file_name, buffer);
4337 //
4338 // write_record(t3d_in_file, t3d_in_file_name, "\n");
4339 //
4340 // curve_id++;
4341 // if((j = crack -> qa + 1) >= 4)j -= 4;
4342 // sprintf(buffer, "curve %d order 3 vertex %d %d\n", curve_id, vertex_id - 1, vertex_id);
4343 // write_record(t3d_in_file, t3d_in_file_name, buffer);
4344 // if(bmsz == 0.0){
4345 // default_msz = YES;
4346 // sprintf(buffer, "polygon 1 xyz %e %e %e weight %e\n",
4347 // contact_glob_pnt[j].x, contact_glob_pnt[j].y, contact_glob_pnt[j].z, weight_q);
4348 // }
4349 // else
4350 // sprintf(buffer, "polygon 1 xyz %e %e %e weight %e size %e\n",
4351 // contact_glob_pnt[j].x, contact_glob_pnt[j].y, contact_glob_pnt[j].z, weight_q, bmsz);
4352 // write_record(t3d_in_file, t3d_in_file_name, buffer);
4353 // if(m == 0)iface_crack_cur_id2 = curve_id;
4354 //
4355 // if(ellipsoid -> property != 0 && ellipsoid -> property != prop){
4356 // if(m == 0)
4357 // sprintf(buffer, " Curve %d %d", curve_id - 2 * curves + 4, curve_id);
4358 // else
4359 // sprintf(buffer, " Curve %d %d", curve_id - 2 * curves, curve_id);
4360 // }
4361 // else{
4362 // if(m == 0 || ellipsoid -> property == 0)
4363 // sprintf(buffer, " Curve %d %d", curve_id - curves + 4, curve_id);
4364 // else
4365 // sprintf(buffer, " Curve %d %d", curve_id - curves, curve_id);
4366 // }
4367 // write_record(ctrl_file, ctrl_file_name, buffer);
4368 //
4369 // curve_id++;
4370 // sprintf(buffer, "curve %d order 3 vertex %d %d virtual\n", curve_id, vertex_id, vertex_id - 1);
4371 // write_record(t3d_in_file, t3d_in_file_name, buffer);
4372 // if(bmsz == 0.0){
4373 // default_msz = YES;
4374 // sprintf(buffer, "polygon 1 xyz %e %e %e weight %e\n",
4375 // contact_glob_pnt[j].x, contact_glob_pnt[j].y, contact_glob_pnt[j].z, -weight_q);
4376 // }
4377 // else
4378 // sprintf(buffer, "polygon 1 xyz %e %e %e weight %e size %e\n",
4379 // contact_glob_pnt[j].x, contact_glob_pnt[j].y, contact_glob_pnt[j].z, -weight_q, bmsz);
4380 // write_record(t3d_in_file, t3d_in_file_name, buffer);
4381 //
4382 // write_record(t3d_in_file, t3d_in_file_name, "\n");
4383 //
4384 // vertex_id++;
4385 // sprintf(buffer, "vertex %d xyz %e %e %e fixed curve %d fixed vertex %d\n", vertex_id,
4386 // crack -> pnt1.x, crack -> pnt1.y, crack -> pnt1.z, curve_id, iface_crack_ver_id1);
4387 // write_record(t3d_in_file, t3d_in_file_name, buffer);
4388 //
4389 // vertex_id++;
4390 // sprintf(buffer, "vertex %d xyz %e %e %e fixed curve %d fixed vertex %d\n", vertex_id,
4391 // crack -> pnt2.x, crack -> pnt2.y, crack -> pnt2.z, curve_id, iface_crack_ver_id2);
4392 // write_record(t3d_in_file, t3d_in_file_name, buffer);
4393 //
4394 // write_record(t3d_in_file, t3d_in_file_name, "\n");
4395 //
4396 // curve_id++;
4397 // sprintf(buffer, "curve %d vertex %d %d fixed curve %d\n", curve_id,
4398 // vertex_id - 1, vertex_id - 3, curve_id - 1);
4399 // write_record(t3d_in_file, t3d_in_file_name, buffer);
4400 // if(m == 0)iface_crack_cur_id1 = curve_id;
4401 //
4402 // if(ellipsoid -> property != 0 && ellipsoid -> property != prop){
4403 // if(m == 0)
4404 // sprintf(buffer, " Curve %d %d", curve_id - 2 * curves + 4, curve_id);
4405 // else
4406 // sprintf(buffer, " Curve %d %d", curve_id - 2 * curves, curve_id);
4407 // }
4408 // else{
4409 // if(m == 0 || ellipsoid -> property == 0)
4410 // sprintf(buffer, " Curve %d %d", curve_id - curves + 4, curve_id);
4411 // else
4412 // sprintf(buffer, " Curve %d %d", curve_id - curves, curve_id);
4413 // }
4414 // write_record(ctrl_file, ctrl_file_name, buffer);
4415 //
4416 // curve_id++;
4417 // sprintf(buffer, "curve %d vertex %d %d fixed curve %d\n", curve_id,
4418 // vertex_id - 2, vertex_id, curve_id - 2);
4419 // write_record(t3d_in_file, t3d_in_file_name, buffer);
4420 // if(m == 0)iface_crack_cur_id3 = curve_id;
4421 //
4422 // if(ellipsoid -> property != 0 && ellipsoid -> property != prop){
4423 // if(m == 0)
4424 // sprintf(buffer, " Curve %d %d", curve_id - 2 * curves + 4, curve_id);
4425 // else
4426 // sprintf(buffer, " Curve %d %d", curve_id - 2 * curves, curve_id);
4427 // }
4428 // else{
4429 // if(m == 0 || ellipsoid -> property == 0)
4430 // sprintf(buffer, " Curve %d %d", curve_id - curves + 4, curve_id);
4431 // else
4432 // sprintf(buffer, " Curve %d %d", curve_id - curves, curve_id);
4433 // }
4434 // write_record(ctrl_file, ctrl_file_name, buffer);
4435 //
4436 // write_record(t3d_in_file, t3d_in_file_name, "\n");
4437 // }
4438 // break;
4439 // }
4440 // }
4441 //
4442 // write_record(ctrl_file, ctrl_file_name, "\n");
4443 // }
4444 // }
4445 // else{
4446 //
4447 // /* INTERSECT */
4448 //
4449 // for(k = 0; k < 4; k++){
4450 //
4451 // /* k = 0 inclusion boundary
4452 // k = 1 matrix boundary
4453 // k = 2 inclusion interface
4454 // k = 3 matrix interface */
4455 //
4456 // if(k == 1){
4457 // sprintf(buffer, "MasterSlave");
4458 // write_record(ctrl_file, ctrl_file_name, buffer);
4459 // }
4460 // if(k == 2){
4461 // sprintf(buffer, "Interface %d", ellipsoid -> interface);
4462 // write_record(ctrl_file, ctrl_file_name, buffer);
4463 // }
4464 //
4465 // switch(k){
4466 // case 0:
4467 // sprintf(buffer, "# inclusion boundary\n\n");
4468 // break;
4469 // case 1:
4470 // sprintf(buffer, "# matrix boundary\n\n");
4471 // break;
4472 // case 2:
4473 // sprintf(buffer, "# inclusion interface\n\n");
4474 // break;
4475 // case 3:
4476 // sprintf(buffer, "# matrix interface\n\n");
4477 // break;
4478 // }
4479 //
4480 // write_record(t3d_in_file, t3d_in_file_name, buffer);
4481 //
4482 // for(i = 0; i < intersect; i++){
4483 // for(m = 0; m < 2; m++){
4484 // skip = NO;
4485 // if(m == 1){
4486 // if((k == 0 || k == 2) && ellipsoid -> property != 0)skip = YES;
4487 // }
4488 // vertex_id++;
4489 // if(skip == NO){
4490 // if(bmsz == 0.0){
4491 // default_msz = YES;
4492 // if(m == 1)
4493 // sprintf(buffer, "vertex %d xyz %e %e %e coincide vertex %d\n", vertex_id,
4494 // point[i].x, point[i].y, point[i].z, vertex_id - 1);
4495 // else
4496 // sprintf(buffer, "vertex %d xyz %e %e %e\n", vertex_id,
4497 // point[i].x, point[i].y, point[i].z);
4498 // }
4499 // else{
4500 // if(m == 1)
4501 // sprintf(buffer, "vertex %d xyz %e %e %e size %e coincide vertex %d\n", vertex_id,
4502 // point[i].x, point[i].y, point[i].z, bmsz, vertex_id - 1);
4503 // else
4504 // sprintf(buffer, "vertex %d xyz %e %e %e size %e\n", vertex_id,
4505 // point[i].x, point[i].y, point[i].z, bmsz);
4506 // }
4507 // write_record(t3d_in_file, t3d_in_file_name, buffer);
4508 // }
4509 //
4510 // if(m == 0){
4511 // if(i == 0)cross_ver_id1 = vertex_id;
4512 // if(i == 1)cross_ver_id2 = vertex_id;
4513 // }
4514 //
4515 // if(k == 1){
4516 // if(ellipsoid -> interface == 0){
4517 // if(m == 0)
4518 // sprintf(buffer, " Vertex %d %d", vertex_id - vertices, vertex_id);
4519 // else
4520 // sprintf(buffer, " Vertex %d %d", vertex_id - vertices - 1, vertex_id);
4521 // }
4522 // else{
4523 // if(m == 0 || ellipsoid -> property == 0)
4524 // sprintf(buffer, " Vertex %d %d Vertex %d %d",
4525 // vertex_id - vertices, vertex_id + vertices, vertex_id, vertex_id + 2 * vertices);
4526 // else
4527 // sprintf(buffer, " Vertex %d %d", vertex_id, vertex_id + 2 * vertices);
4528 // }
4529 // write_record(ctrl_file, ctrl_file_name, buffer);
4530 // }
4531 // }
4532 //
4533 // write_record(t3d_in_file, t3d_in_file_name, "\n");
4534 // }
4535 //
4536 // for(i = 0; i < 2; i++){
4537 // vertex_id++;
4538 // if(bmsz == 0.0){
4539 // default_msz = YES;
4540 // sprintf(buffer, "vertex %d xyz %e %e %e\n", vertex_id,
4541 // glob_point[i].x, glob_point[i].y, glob_point[i].z);
4542 // }
4543 // else
4544 // sprintf(buffer, "vertex %d xyz %e %e %e size %e\n", vertex_id,
4545 // glob_point[i].x, glob_point[i].y, glob_point[i].z, bmsz);
4546 // write_record(t3d_in_file, t3d_in_file_name, buffer);
4547 //
4548 // if(k == 1){
4549 // if(ellipsoid -> interface == 0)
4550 // sprintf(buffer, " Vertex %d %d", vertex_id - vertices, vertex_id);
4551 // else
4552 // sprintf(buffer, " Vertex %d %d Vertex %d %d",
4553 // vertex_id - vertices, vertex_id + vertices, vertex_id, vertex_id + 2 * vertices);
4554 // write_record(ctrl_file, ctrl_file_name, buffer);
4555 // }
4556 //
4557 // if(i == 0)base_ver_id1 = vertex_id;
4558 // if(i == 1)base_ver_id2 = vertex_id;
4559 // }
4560 //
4561 // write_record(t3d_in_file, t3d_in_file_name, "\n");
4562 //
4563 // for(i = 0; i < 2; i++){
4564 // curve_id++;
4565 //
4566 // /* note: the first curve is always intersected (virtual)
4567 // the second curve is intersected (virtual) only if intersect == 2 */
4568 //
4569 // if(i == 1 && intersect != 2){
4570 // virtual = NO;
4571 // sprintf(buffer, "curve %d order 4 vertex %d %d\n", curve_id, vertex_id - 1 + i, vertex_id - i);
4572 // }
4573 // else{
4574 // virtual = YES;
4575 // sprintf(buffer, "curve %d order 4 vertex %d %d virtual\n", curve_id, vertex_id - 1 + i, vertex_id - i);
4576 // }
4577 // write_record(t3d_in_file, t3d_in_file_name, buffer);
4578 //
4579 // for(j = 0; j < 2; j++){
4580 // m = 2 * i + j;
4581 // if(bmsz == 0.0){
4582 // default_msz = YES;
4583 // sprintf(buffer, "polygon %d xyz %e %e %e weight %e\n", j + 1,
4584 // glob_pnt[m].x, glob_pnt[m].y, glob_pnt[m].z, weight_h);
4585 // }
4586 // else
4587 // sprintf(buffer, "polygon %d xyz %e %e %e weight %e size %e\n", j + 1,
4588 // glob_pnt[m].x, glob_pnt[m].y, glob_pnt[m].z, weight_h, bmsz);
4589 // write_record(t3d_in_file, t3d_in_file_name, buffer);
4590 // }
4591 //
4592 // if(k == 1 && virtual == NO){
4593 // if(ellipsoid -> interface == 0)
4594 // sprintf(buffer, " Curve %d %d", curve_id - curves, curve_id);
4595 // else
4596 // sprintf(buffer, " Curve %d %d Curve %d %d",
4597 // curve_id - curves, curve_id + curves, curve_id, curve_id + 2 * curves);
4598 // write_record(ctrl_file, ctrl_file_name, buffer);
4599 // }
4600 //
4601 // if(i == 0)base_cur_id1 = curve_id;
4602 // if(i == 1)base_cur_id2 = curve_id;
4603 // }
4604 //
4605 // write_record(t3d_in_file, t3d_in_file_name, "\n");
4606 //
4607 // for(i = 0; i < 2; i++){
4608 // curve_id++;
4609 // sprintf(buffer, "curve %d order 4 vertex %d %d virtual\n", curve_id, vertex_id - 1 + i, vertex_id - 1 + i);
4610 // write_record(t3d_in_file, t3d_in_file_name, buffer);
4611 //
4612 // for(j = 0; j < 2; j++){
4613 // if(bmsz == 0.0){
4614 // default_msz = YES;
4615 // sprintf(buffer, "polygon %d xyz %e %e %e weight %e\n", j + 1,
4616 // glob_point[i].x, glob_point[i].y, glob_point[i].z, weight_h);
4617 // }
4618 // else
4619 // sprintf(buffer, "polygon %d xyz %e %e %e weight %e size %e\n", j + 1,
4620 // glob_point[i].x, glob_point[i].y, glob_point[i].z, weight_h, bmsz);
4621 // write_record(t3d_in_file, t3d_in_file_name, buffer);
4622 // }
4623 // }
4624 //
4625 // write_record(t3d_in_file, t3d_in_file_name, "\n");
4626 //
4627 // for(i = 0; i < 2; i++){
4628 // surface_id++;
4629 // sprintf(buffer, "surface %d curve %d %d %d %d virtual\n", surface_id,
4630 // curve_id - 3, curve_id - 1, curve_id - 2, curve_id);
4631 // write_record(t3d_in_file, t3d_in_file_name, buffer);
4632 //
4633 // for(j2 = 0; j2 < 2; j2++){
4634 // for(j1 = 0; j1 < 2; j1++){
4635 // m = i * 4 + j2 * 2 + j1;
4636 // if(bmsz == 0.0){
4637 // default_msz = YES;
4638 // sprintf(buffer, "polygon %d %d xyz %e %e %e weight %e\n", j1 + 1, j2 + 1,
4639 // glob_p[m].x, glob_p[m].y, glob_p[m].z, weight_o);
4640 // }
4641 // else
4642 // sprintf(buffer, "polygon %d %d xyz %e %e %e weight %e size %e\n", j1 + 1, j2 + 1,
4643 // glob_p[m].x, glob_p[m].y, glob_p[m].z, weight_o, bmsz);
4644 // write_record(t3d_in_file, t3d_in_file_name, buffer);
4645 // }
4646 // }
4647 // }
4648 //
4649 // write_record(t3d_in_file, t3d_in_file_name, "\n");
4650 //
4651 // for(i = 0; i < intersect; i++){
4652 // for(m = 0; m < 2; m++){
4653 // skip = NO;
4654 // if(m == 1){
4655 // if((k == 0 || k == 2) && ellipsoid -> property != 0)skip = YES;
4656 // }
4657 //
4658 // vertex_id++;
4659 // if(skip == NO){
4660 // sprintf(buffer, "vertex %d xyz %e %e %e fixed curve %d fixed vertex %d\n", vertex_id,
4661 // point[i].x, point[i].y, point[i].z, base_cur_id1 + i, cross_ver_id1 + 2 * i + m);
4662 // write_record(t3d_in_file, t3d_in_file_name, buffer);
4663 // }
4664 // }
4665 //
4666 // write_record(t3d_in_file, t3d_in_file_name, "\n");
4667 //
4668 // curve_id++;
4669 // if((k == 0 || k == 2) && ellipsoid -> property != 0)
4670 // sprintf(buffer, "curve %d vertex %d %d fixed curve %d\n", curve_id,
4671 // base_ver_id1 + i, vertex_id - 1, base_cur_id1 + i);
4672 // else
4673 // sprintf(buffer, "curve %d vertex %d %d fixed curve %d\n", curve_id,
4674 // base_ver_id1 + i, vertex_id - 1 + i, base_cur_id1 + i);
4675 // write_record(t3d_in_file, t3d_in_file_name, buffer);
4676 //
4677 // if(k == 1){
4678 // if(ellipsoid -> interface == 0)
4679 // sprintf(buffer, " Curve %d %d", curve_id - curves, curve_id);
4680 // else
4681 // sprintf(buffer, " Curve %d %d Curve %d %d",
4682 // curve_id - curves, curve_id + curves, curve_id, curve_id + 2 * curves);
4683 // write_record(ctrl_file, ctrl_file_name, buffer);
4684 // }
4685 //
4686 // if(i == 0)base_cur_id1a = curve_id;
4687 // if(i == 1)base_cur_id2a = curve_id;
4688 //
4689 // curve_id++;
4690 // if((k == 0 || k == 2) && ellipsoid -> property != 0)
4691 // sprintf(buffer, "curve %d vertex %d %d fixed curve %d\n", curve_id,
4692 // vertex_id - 1, base_ver_id2 - i, base_cur_id1 + i);
4693 // else
4694 // sprintf(buffer, "curve %d vertex %d %d fixed curve %d\n", curve_id,
4695 // vertex_id - i, base_ver_id2 - i, base_cur_id1 + i);
4696 // write_record(t3d_in_file, t3d_in_file_name, buffer);
4697 //
4698 // if(k == 1){
4699 // if(ellipsoid -> interface == 0)
4700 // sprintf(buffer, " Curve %d %d", curve_id - curves, curve_id);
4701 // else
4702 // sprintf(buffer, " Curve %d %d Curve %d %d",
4703 // curve_id - curves, curve_id + curves, curve_id, curve_id + 2 * curves);
4704 // write_record(ctrl_file, ctrl_file_name, buffer);
4705 // }
4706 //
4707 // if(i == 0)base_cur_id1b = curve_id;
4708 // if(i == 1)base_cur_id2b = curve_id;
4709 //
4710 // write_record(t3d_in_file, t3d_in_file_name, "\n");
4711 // }
4712 //
4713 // if(crack -> segment == NO){
4714 // for(m = 0; m < 2; m++){
4715 // skip = NO;
4716 // if(m == 1){
4717 // if((k == 0 || k == 2) && ellipsoid -> property != 0)skip = YES;
4718 // }
4719 //
4720 // for(i = 0; i < 2; i++){
4721 // vertex_id++;
4722 // if(skip == NO){
4723 // j = 2 * i;
4724 // if(cmsz == 0.0){
4725 // default_msz = YES;
4726 // if(m == 1)
4727 // sprintf(buffer, "vertex %d xyz %e %e %e coincide vertex %d\n", vertex_id,
4728 // contact_glob_point[j].x, contact_glob_point[j].y, contact_glob_point[j].z, vertex_id - 2);
4729 // else
4730 // sprintf(buffer, "vertex %d xyz %e %e %e\n", vertex_id,
4731 // contact_glob_point[j].x, contact_glob_point[j].y, contact_glob_point[j].z);
4732 // }
4733 // else{
4734 // if(m == 1)
4735 // sprintf(buffer, "vertex %d xyz %e %e %e size %e coincide vertex %d\n", vertex_id,
4736 // contact_glob_point[j].x, contact_glob_point[j].y, contact_glob_point[j].z, cmsz, vertex_id - 2);
4737 // else
4738 // sprintf(buffer, "vertex %d xyz %e %e %e size %e\n", vertex_id,
4739 // contact_glob_point[j].x, contact_glob_point[j].y, contact_glob_point[j].z, cmsz);
4740 // }
4741 // write_record(t3d_in_file, t3d_in_file_name, buffer);
4742 // }
4743 //
4744 // if(k == 1){
4745 // if(ellipsoid -> interface == 0){
4746 // if(m == 0)
4747 // sprintf(buffer, " Vertex %d %d", vertex_id - vertices, vertex_id);
4748 // else
4749 // sprintf(buffer, " Vertex %d %d", vertex_id - vertices - 2, vertex_id);
4750 // }
4751 // else{
4752 // if(m == 0 || ellipsoid -> property == 0)
4753 // sprintf(buffer, " Vertex %d %d Vertex %d %d",
4754 // vertex_id - vertices, vertex_id + vertices, vertex_id, vertex_id + 2 * vertices);
4755 // else
4756 // sprintf(buffer, " Vertex %d %d", vertex_id, vertex_id + 2 * vertices);
4757 // }
4758 // write_record(ctrl_file, ctrl_file_name, buffer);
4759 // }
4760 //
4761 // if(m == 0){
4762 // if(i == 0)crack_ver_id1 = vertex_id;
4763 // if(i == 1)crack_ver_id2 = vertex_id;
4764 // }
4765 // }
4766 //
4767 // if(skip == NO)write_record(t3d_in_file, t3d_in_file_name, "\n");
4768 //
4769 // for(i = 0; i < 2; i++){
4770 // curve_id++;
4771 // if(skip == NO){
4772 // sprintf(buffer, "curve %d order 4 vertex %d %d virtual\n", curve_id, vertex_id - 1 + i, vertex_id - i);
4773 // write_record(t3d_in_file, t3d_in_file_name, buffer);
4774 //
4775 // for(j = 0; j < 2; j++){
4776 // n = 2 * i + j;
4777 // if(cmsz == 0.0){
4778 // default_msz = YES;
4779 // sprintf(buffer, "polygon %d xyz %e %e %e weight %e\n", j + 1,
4780 // contact_glob_pnt[n].x, contact_glob_pnt[n].y, contact_glob_pnt[n].z, weight_h);
4781 // }
4782 // else
4783 // sprintf(buffer, "polygon %d xyz %e %e %e weight %e size %e\n", j + 1,
4784 // contact_glob_pnt[n].x, contact_glob_pnt[n].y, contact_glob_pnt[n].z, weight_h, cmsz);
4785 // write_record(t3d_in_file, t3d_in_file_name, buffer);
4786 // }
4787 // }
4788 //
4789 // if(m == 0){
4790 // if(i == 0)crack_cur_id1 = -curve_id;
4791 // if(i == 1)crack_cur_id2 = -curve_id;
4792 // }
4793 // }
4794 //
4795 // if(skip == NO)write_record(t3d_in_file, t3d_in_file_name, "\n");
4796 // }
4797 //
4798 // for(i = 0; i < intersect; i++){
4799 // for(m = 0; m < 2; m++){
4800 // skip = NO;
4801 // if(m == 1){
4802 // if((k == 0 || k == 2) && ellipsoid -> property != 0)skip = YES;
4803 // }
4804 // vertex_id++;
4805 // if(skip == NO){
4806 // sprintf(buffer, "vertex %d xyz %e %e %e fixed curve %d fixed vertex %d\n", vertex_id,
4807 // point[i].x, point[i].y, point[i].z, -crack_cur_id1 + i + 2 * m, cross_ver_id1 + 2 * i + m);
4808 // write_record(t3d_in_file, t3d_in_file_name, buffer);
4809 // }
4810 //
4811 // if(skip == NO)write_record(t3d_in_file, t3d_in_file_name, "\n");
4812 //
4813 // curve_id++;
4814 // if(skip == NO){
4815 // if(m == 1)
4816 // sprintf(buffer, "curve %d vertex %d %d fixed curve %d coincide curve %d\n", curve_id,
4817 // crack_ver_id1 + i + 2 * m, vertex_id, -crack_cur_id1 + i + 2 * m, curve_id - 2);
4818 // else
4819 // sprintf(buffer, "curve %d vertex %d %d fixed curve %d\n",
4820 // curve_id, crack_ver_id1 + i + 2 * m, vertex_id, -crack_cur_id1 + i + 2 * m);
4821 // write_record(t3d_in_file, t3d_in_file_name, buffer);
4822 // }
4823 //
4824 // if(k == 1){
4825 // if(ellipsoid -> interface == 0){
4826 // if(m == 0)
4827 // sprintf(buffer, " Curve %d %d", curve_id - curves, curve_id);
4828 // else
4829 // sprintf(buffer, " Curve %d %d", curve_id - curves - 2, curve_id);
4830 // }
4831 // else{
4832 // if(m == 0 || ellipsoid -> property == 0)
4833 // sprintf(buffer, " Curve %d %d Curve %d %d",
4834 // curve_id - curves, curve_id + curves, curve_id, curve_id + 2 * curves);
4835 // else
4836 // sprintf(buffer, " Curve %d %d", curve_id, curve_id + 2 * curves);
4837 // }
4838 // write_record(ctrl_file, ctrl_file_name, buffer);
4839 // }
4840 //
4841 // if(m == 0){
4842 // if(k == 0 || k == 1){
4843 // if(i == 0)crack_cur_id1a = curve_id;
4844 // if(i == 1)crack_cur_id2a = curve_id;
4845 // }
4846 // }
4847 //
4848 // curve_id++;
4849 // if(skip == NO){
4850 // if(m == 1)
4851 // sprintf(buffer, "curve %d vertex %d %d fixed curve %d coincide curve %d\n", curve_id,
4852 // vertex_id, crack_ver_id2 - i + 2 * m, -crack_cur_id1 + i + 2 * m, curve_id - 2);
4853 // else
4854 // sprintf(buffer, "curve %d vertex %d %d fixed curve %d\n", curve_id,
4855 // vertex_id, crack_ver_id2 - i + 2 * m, -crack_cur_id1 + i + 2 * m);
4856 // write_record(t3d_in_file, t3d_in_file_name, buffer);
4857 // }
4858 //
4859 // if(k == 1){
4860 // if(ellipsoid -> interface == 0){
4861 // if(m == 0)
4862 // sprintf(buffer, " Curve %d %d", curve_id - curves, curve_id);
4863 // else
4864 // sprintf(buffer, " Curve %d %d", curve_id - curves - 2, curve_id);
4865 // }
4866 // else{
4867 // if(m == 0 || ellipsoid -> property == 0)
4868 // sprintf(buffer, " Curve %d %d Curve %d %d",
4869 // curve_id - curves, curve_id + curves, curve_id, curve_id + 2 * curves);
4870 // else
4871 // sprintf(buffer, " Curve %d %d", curve_id, curve_id + 2 * curves);
4872 // }
4873 // write_record(ctrl_file, ctrl_file_name, buffer);
4874 // }
4875 //
4876 // if(m == 0){
4877 // if(k == 0 || k == 1){
4878 // if(i == 0)crack_cur_id1b = curve_id;
4879 // if(i == 1)crack_cur_id2b = curve_id;
4880 // }
4881 // }
4882 //
4883 // if(skip == NO)write_record(t3d_in_file, t3d_in_file_name, "\n");
4884 // }
4885 // }
4886 // }
4887 // else{
4888 //
4889 // /* note: it should not happen that the intersection coincides with any physical vertex
4890 // on the contact ellipse */
4891 //
4892 // if(k == 1 || k == 3 || ellipsoid -> interface == 0){
4893 // vertex_id++;
4894 // if(tmsz == 0.0){
4895 // default_msz = YES;
4896 // sprintf(buffer, "vertex %d xyz %e %e %e\n", vertex_id,
4897 // crack -> pnt1.x, crack -> pnt1.y, crack -> pnt1.z);
4898 // }
4899 // else
4900 // sprintf(buffer, "vertex %d xyz %e %e %e size %e\n", vertex_id,
4901 // crack -> pnt1.x, crack -> pnt1.y, crack -> pnt1.z, tmsz);
4902 // write_record(t3d_in_file, t3d_in_file_name, buffer);
4903 // crack_ver_id1 = vertex_id;
4904 //
4905 // vertex_id++;
4906 // if(tmsz == 0.0){
4907 // default_msz = YES;
4908 // sprintf(buffer, "vertex %d xyz %e %e %e\n", vertex_id,
4909 // crack -> pnt2.x, crack -> pnt2.y, crack -> pnt2.z);
4910 // }
4911 // else
4912 // sprintf(buffer, "vertex %d xyz %e %e %e size %e\n", vertex_id,
4913 // crack -> pnt2.x, crack -> pnt2.y, crack -> pnt2.z, tmsz);
4914 // write_record(t3d_in_file, t3d_in_file_name, buffer);
4915 // crack_ver_id2 = vertex_id;
4916 //
4917 // write_record(t3d_in_file, t3d_in_file_name, "\n");
4918 // }
4919 // else{
4920 // vertex_id += 2;
4921 // }
4922 //
4923 // switch(contact_case){
4924 // case 1:
4925 // if(intersect == 2)error_message(GENERAL_ERROR, "Unimplemented situation");
4926 //
4927 // vertex_id++;
4928 // if(fixed_a == NO || (k != 1 && k != 3 && ellipsoid -> interface != 0)){
4929 // j = crack -> qa - 1;
4930 // if(bmsz == 0.0){
4931 // default_msz = YES;
4932 // sprintf(buffer, "vertex %d xyz %e %e %e virtual\n", vertex_id,
4933 // contact_glob_point[j].x, contact_glob_point[j].y, contact_glob_point[j].z);
4934 // }
4935 // else
4936 // sprintf(buffer, "vertex %d xyz %e %e %e size %e virtual\n", vertex_id,
4937 // contact_glob_point[j].x, contact_glob_point[j].y, contact_glob_point[j].z, bmsz);
4938 // }
4939 // else{
4940 // if(bmsz == 0.0){
4941 // default_msz = YES;
4942 // sprintf(buffer, "vertex %d fixed vertex %d size def\n", vertex_id, crack_ver_id1);
4943 // }
4944 // else
4945 // sprintf(buffer, "vertex %d fixed vertex %d size %e\n", vertex_id, crack_ver_id1, bmsz);
4946 // }
4947 // write_record(t3d_in_file, t3d_in_file_name, buffer);
4948 //
4949 // vertex_id++;
4950 // if(fixed_b == NO || (k != 1 && k != 3 && ellipsoid -> interface != 0)){
4951 // if((j = crack -> qa) >= 4)j -= 4;
4952 // if(bmsz == 0.0){
4953 // default_msz = YES;
4954 // sprintf(buffer, "vertex %d xyz %e %e %e virtual\n", vertex_id,
4955 // contact_glob_point[j].x, contact_glob_point[j].y, contact_glob_point[j].z);
4956 // }
4957 // else
4958 // sprintf(buffer, "vertex %d xyz %e %e %e size %e virtual\n", vertex_id,
4959 // contact_glob_point[j].x, contact_glob_point[j].y, contact_glob_point[j].z, bmsz);
4960 // }
4961 // else{
4962 // if(bmsz == 0.0){
4963 // default_msz = YES;
4964 // sprintf(buffer, "vertex %d fixed vertex %d size def\n", vertex_id, crack_ver_id2);
4965 // }
4966 // else
4967 // sprintf(buffer, "vertex %d fixed vertex %d size %e\n", vertex_id, crack_ver_id2, bmsz);
4968 // }
4969 // write_record(t3d_in_file, t3d_in_file_name, buffer);
4970 //
4971 // write_record(t3d_in_file, t3d_in_file_name, "\n");
4972 //
4973 // j = crack -> qa - 1;
4974 // curve_id++;
4975 // sprintf(buffer, "curve %d order 3 vertex %d %d virtual\n", curve_id, vertex_id - 1, vertex_id);
4976 // write_record(t3d_in_file, t3d_in_file_name, buffer);
4977 // if(bmsz == 0.0){
4978 // default_msz = YES;
4979 // sprintf(buffer, "polygon 1 xyz %e %e %e weight %e\n",
4980 // contact_glob_pnt[j].x, contact_glob_pnt[j].y, contact_glob_pnt[j].z, weight_q);
4981 // }
4982 // else
4983 // sprintf(buffer, "polygon 1 xyz %e %e %e weight %e size %e\n",
4984 // contact_glob_pnt[j].x, contact_glob_pnt[j].y, contact_glob_pnt[j].z, weight_q, bmsz);
4985 // write_record(t3d_in_file, t3d_in_file_name, buffer);
4986 // crack_cur_id1 = -curve_id;
4987 //
4988 // write_record(t3d_in_file, t3d_in_file_name, "\n");
4989 //
4990 // vertex_id++;
4991 // if(fixed_a == NO){
4992 // if(k == 1 || k == 3 || ellipsoid -> interface == 0)
4993 // sprintf(buffer, "vertex %d xyz %e %e %e fixed curve %d fixed vertex %d\n", vertex_id,
4994 // crack -> pnt1.x, crack -> pnt1.y, crack -> pnt1.z, curve_id, crack_ver_id1);
4995 // else
4996 // sprintf(buffer, "vertex %d xyz %e %e %e fixed curve %d\n", vertex_id,
4997 // crack -> pnt1.x, crack -> pnt1.y, crack -> pnt1.z, curve_id);
4998 // }
4999 // else
5000 // sprintf(buffer, "vertex %d fixed vertex %d\n", vertex_id, vertex_id - 2);
5001 // write_record(t3d_in_file, t3d_in_file_name, buffer);
5002 //
5003 // if(k == 1){
5004 // if(ellipsoid -> interface == 0)
5005 // sprintf(buffer, " Vertex %d %d", crack_ver_id1 - vertices, crack_ver_id1);
5006 // else
5007 // sprintf(buffer, " Vertex %d %d Vertex %d %d",
5008 // vertex_id - vertices, vertex_id + vertices, crack_ver_id1, crack_ver_id1 + 2 * vertices);
5009 // write_record(ctrl_file, ctrl_file_name, buffer);
5010 // }
5011 //
5012 // vertex_id++;
5013 // if(fixed_b == NO){
5014 // if(k == 1 || k == 3 || ellipsoid -> interface == 0)
5015 // sprintf(buffer, "vertex %d xyz %e %e %e fixed curve %d fixed vertex %d\n", vertex_id,
5016 // crack -> pnt2.x, crack -> pnt2.y, crack -> pnt2.z, curve_id, crack_ver_id2);
5017 // else
5018 // sprintf(buffer, "vertex %d xyz %e %e %e fixed curve %d\n", vertex_id,
5019 // crack -> pnt2.x, crack -> pnt2.y, crack -> pnt2.z, curve_id);
5020 // }
5021 // else
5022 // sprintf(buffer, "vertex %d fixed vertex %d\n", vertex_id, vertex_id - 2);
5023 // write_record(t3d_in_file, t3d_in_file_name, buffer);
5024 //
5025 // if(k == 1){
5026 // if(ellipsoid -> interface == 0)
5027 // sprintf(buffer, " Vertex %d %d", crack_ver_id2 - vertices, crack_ver_id2);
5028 // else
5029 // sprintf(buffer, " Vertex %d %d Vertex %d %d",
5030 // vertex_id - vertices, vertex_id + vertices, crack_ver_id2, crack_ver_id2 + 2 * vertices);
5031 // write_record(ctrl_file, ctrl_file_name, buffer);
5032 // }
5033 //
5034 // vertex_id++;
5035 // sprintf(buffer, "vertex %d xyz %e %e %e fixed curve %d fixed vertex %d\n", vertex_id,
5036 // point[0].x, point[0].y, point[0].z, curve_id, cross_ver_id1);
5037 // write_record(t3d_in_file, t3d_in_file_name, buffer);
5038 //
5039 // vertex_id++;
5040 // if((k != 0 && k != 2) || ellipsoid -> property == 0){
5041 // sprintf(buffer, "vertex %d xyz %e %e %e fixed curve %d fixed vertex %d\n", vertex_id,
5042 // point[0].x, point[0].y, point[0].z, curve_id, cross_ver_id1 + 1);
5043 // write_record(t3d_in_file, t3d_in_file_name, buffer);
5044 // }
5045 //
5046 // write_record(t3d_in_file, t3d_in_file_name, "\n");
5047 //
5048 // curve_id++;
5049 // sprintf(buffer, "curve %d vertex %d %d fixed curve %d\n", curve_id,
5050 // vertex_id - 3, vertex_id - 1, -crack_cur_id1);
5051 // write_record(t3d_in_file, t3d_in_file_name, buffer);
5052 //
5053 // if(k == 1){
5054 // if(ellipsoid -> interface == 0)
5055 // sprintf(buffer, " Curve %d %d", curve_id - curves, curve_id);
5056 // else
5057 // sprintf(buffer, " Curve %d %d Curve %d %d",
5058 // curve_id - curves, curve_id + curves, curve_id, curve_id + 2 * curves);
5059 // write_record(ctrl_file, ctrl_file_name, buffer);
5060 // }
5061 //
5062 // if(k == 0 || k == 1)crack_cur_id1a = curve_id;
5063 //
5064 // curve_id++;
5065 // sprintf(buffer, "curve %d vertex %d %d fixed curve %d\n", curve_id,
5066 // vertex_id - 1, vertex_id - 2, -crack_cur_id1);
5067 // write_record(t3d_in_file, t3d_in_file_name, buffer);
5068 //
5069 // if(k == 1){
5070 // if(ellipsoid -> interface == 0)
5071 // sprintf(buffer, " Curve %d %d", curve_id - curves, curve_id);
5072 // else
5073 // sprintf(buffer, " Curve %d %d Curve %d %d",
5074 // curve_id - curves, curve_id + curves, curve_id, curve_id + 2 * curves);
5075 // write_record(ctrl_file, ctrl_file_name, buffer);
5076 // }
5077 //
5078 // if(k == 0 || k == 1)crack_cur_id1b = curve_id;
5079 //
5080 // curve_id++;
5081 // if((k != 0 && k != 2) || ellipsoid -> property == 0){
5082 // sprintf(buffer, "curve %d vertex %d %d fixed curve %d coincide curve %d\n", curve_id,
5083 // vertex_id - 3, vertex_id, -crack_cur_id1, curve_id - 2);
5084 // write_record(t3d_in_file, t3d_in_file_name, buffer);
5085 // }
5086 //
5087 // if(k == 1){
5088 // if(ellipsoid -> interface == 0)
5089 // sprintf(buffer, " Curve %d %d", curve_id - curves - 2, curve_id);
5090 // else{
5091 // if(ellipsoid -> property == 0)
5092 // sprintf(buffer, " Curve %d %d Curve %d %d",
5093 // curve_id - curves, curve_id + curves, curve_id, curve_id + 2 * curves);
5094 // else
5095 // sprintf(buffer, " Curve %d %d", curve_id, curve_id + 2 * curves);
5096 // }
5097 // write_record(ctrl_file, ctrl_file_name, buffer);
5098 // }
5099 //
5100 // curve_id++;
5101 // if((k != 0 && k != 2) || ellipsoid -> property == 0){
5102 // sprintf(buffer, "curve %d vertex %d %d fixed curve %d coincide curve %d\n", curve_id,
5103 // vertex_id, vertex_id - 2, -crack_cur_id1, curve_id - 2);
5104 // write_record(t3d_in_file, t3d_in_file_name, buffer);
5105 // }
5106 //
5107 // if(k == 1){
5108 // if(ellipsoid -> interface == 0)
5109 // sprintf(buffer, " Curve %d %d", curve_id - curves - 2, curve_id);
5110 // else{
5111 // if(ellipsoid -> property == 0)
5112 // sprintf(buffer, " Curve %d %d Curve %d %d",
5113 // curve_id - curves, curve_id + curves, curve_id, curve_id + 2 * curves);
5114 // else
5115 // sprintf(buffer, " Curve %d %d", curve_id, curve_id + 2 * curves);
5116 // }
5117 // write_record(ctrl_file, ctrl_file_name, buffer);
5118 // }
5119 //
5120 // write_record(t3d_in_file, t3d_in_file_name, "\n");
5121 // break;
5122 //
5123 // case 2:
5124 // if(intersect == 2)error_message(GENERAL_ERROR, "Unimplemented situation");
5125 //
5126 // vertex_id++;
5127 // if(fixed_a == NO || (k != 1 && k != 3 && ellipsoid -> interface != 0)){
5128 // j = crack -> qa - 1;
5129 // if(bmsz == 0.0){
5130 // default_msz = YES;
5131 // sprintf(buffer, "vertex %d xyz %e %e %e virtual\n", vertex_id,
5132 // contact_glob_point[j].x, contact_glob_point[j].y, contact_glob_point[j].z);
5133 // }
5134 // else
5135 // sprintf(buffer, "vertex %d xyz %e %e %e size %e virtual\n", vertex_id,
5136 // contact_glob_point[j].x, contact_glob_point[j].y, contact_glob_point[j].z, bmsz);
5137 // }
5138 // else{
5139 // if(bmsz == 0.0){
5140 // default_msz = YES;
5141 // sprintf(buffer, "vertex %d fixed vertex %d size def\n", vertex_id, crack_ver_id1);
5142 // }
5143 // else
5144 // sprintf(buffer, "vertex %d fixed vertex %d size %e\n", vertex_id, crack_ver_id1, bmsz);
5145 // }
5146 // write_record(t3d_in_file, t3d_in_file_name, buffer);
5147 //
5148 // vertex_id++;
5149 // if(fixed_b == NO || (k != 1 && k != 3 && ellipsoid -> interface != 0)){
5150 // if((j = crack -> qa + 1) >= 4)j -= 4;
5151 // if(bmsz == 0.0){
5152 // default_msz = YES;
5153 // sprintf(buffer, "vertex %d xyz %e %e %e virtual\n", vertex_id,
5154 // contact_glob_point[j].x, contact_glob_point[j].y, contact_glob_point[j].z);
5155 // }
5156 // else
5157 // sprintf(buffer, "vertex %d xyz %e %e %e size %e virtual\n", vertex_id,
5158 // contact_glob_point[j].x, contact_glob_point[j].y, contact_glob_point[j].z, bmsz);
5159 // }
5160 // else{
5161 // if(bmsz == 0.0){
5162 // default_msz = YES;
5163 // sprintf(buffer, "vertex %d fixed vertex %d size def\n", vertex_id, crack_ver_id2);
5164 // }
5165 // else
5166 // sprintf(buffer, "vertex %d fixed vertex %d size %e\n", vertex_id, crack_ver_id2, bmsz);
5167 // }
5168 // write_record(t3d_in_file, t3d_in_file_name, buffer);
5169 //
5170 // write_record(t3d_in_file, t3d_in_file_name, "\n");
5171 //
5172 // curve_id++;
5173 // sprintf(buffer, "curve %d order 4 vertex %d %d virtual\n", curve_id, vertex_id - 1, vertex_id);
5174 // write_record(t3d_in_file, t3d_in_file_name, buffer);
5175 // for(i = 0; i < 2; i++){
5176 // if((j = crack -> qa - 1 + i) >= 4)j -= 4;
5177 // if(bmsz == 0.0){
5178 // default_msz = YES;
5179 // sprintf(buffer, "polygon %d xyz %e %e %e weight %e\n", i + 1,
5180 // contact_glob_pnt[j].x, contact_glob_pnt[j].y, contact_glob_pnt[j].z, weight_h);
5181 // }
5182 // else
5183 // sprintf(buffer, "polygon %d xyz %e %e %e weight %e size %e\n", i + 1,
5184 // contact_glob_pnt[j].x, contact_glob_pnt[j].y, contact_glob_pnt[j].z, weight_h, bmsz);
5185 // write_record(t3d_in_file, t3d_in_file_name, buffer);
5186 // }
5187 // crack_cur_id1 = -curve_id;
5188 //
5189 // write_record(t3d_in_file, t3d_in_file_name, "\n");
5190 //
5191 // vertex_id++;
5192 // if(fixed_a == NO){
5193 // if(k == 1 || k == 3 || ellipsoid -> interface == 0)
5194 // sprintf(buffer, "vertex %d xyz %e %e %e fixed curve %d fixed vertex %d\n", vertex_id,
5195 // crack -> pnt1.x, crack -> pnt1.y, crack -> pnt1.z, curve_id, crack_ver_id1);
5196 // else
5197 // sprintf(buffer, "vertex %d xyz %e %e %e fixed curve %d\n", vertex_id,
5198 // crack -> pnt1.x, crack -> pnt1.y, crack -> pnt1.z, curve_id);
5199 // }
5200 // else
5201 // sprintf(buffer, "vertex %d fixed vertex %d\n", vertex_id, vertex_id - 2);
5202 // write_record(t3d_in_file, t3d_in_file_name, buffer);
5203 //
5204 // if(k == 1){
5205 // if(ellipsoid -> interface == 0)
5206 // sprintf(buffer, " Vertex %d %d", crack_ver_id1 - vertices, crack_ver_id1);
5207 // else
5208 // sprintf(buffer, " Vertex %d %d Vertex %d %d",
5209 // vertex_id - vertices, vertex_id + vertices, crack_ver_id1, crack_ver_id1 + 2 * vertices);
5210 // write_record(ctrl_file, ctrl_file_name, buffer);
5211 // }
5212 //
5213 // vertex_id++;
5214 // if(fixed_b == NO){
5215 // if(k == 1 || k == 3 || ellipsoid -> interface == 0)
5216 // sprintf(buffer, "vertex %d xyz %e %e %e fixed curve %d fixed vertex %d\n", vertex_id,
5217 // crack -> pnt2.x, crack -> pnt2.y, crack -> pnt2.z, curve_id, crack_ver_id2);
5218 // else
5219 // sprintf(buffer, "vertex %d xyz %e %e %e fixed curve %d\n", vertex_id,
5220 // crack -> pnt2.x, crack -> pnt2.y, crack -> pnt2.z, curve_id);
5221 // }
5222 // else
5223 // sprintf(buffer, "vertex %d fixed vertex %d\n", vertex_id, vertex_id - 2);
5224 // write_record(t3d_in_file, t3d_in_file_name, buffer);
5225 //
5226 // if(k == 1){
5227 // if(ellipsoid -> interface == 0)
5228 // sprintf(buffer, " Vertex %d %d", crack_ver_id2 - vertices, crack_ver_id2);
5229 // else
5230 // sprintf(buffer, " Vertex %d %d Vertex %d %d",
5231 // vertex_id - vertices, vertex_id + vertices, crack_ver_id2, crack_ver_id2 + 2 * vertices);
5232 // write_record(ctrl_file, ctrl_file_name, buffer);
5233 // }
5234 //
5235 // write_record(t3d_in_file, t3d_in_file_name, "\n");
5236 //
5237 // vertex_id++;
5238 // sprintf(buffer, "vertex %d xyz %e %e %e fixed curve %d fixed vertex %d\n", vertex_id,
5239 // point[0].x, point[0].y, point[0].z, curve_id, cross_ver_id1);
5240 // write_record(t3d_in_file, t3d_in_file_name, buffer);
5241 //
5242 // vertex_id++;
5243 // if((k != 0 && k != 2) || ellipsoid -> property == 0){
5244 // sprintf(buffer, "vertex %d xyz %e %e %e fixed curve %d fixed vertex %d\n", vertex_id,
5245 // point[0].x, point[0].y, point[0].z, curve_id, cross_ver_id1 + 1);
5246 // write_record(t3d_in_file, t3d_in_file_name, buffer);
5247 // }
5248 //
5249 // write_record(t3d_in_file, t3d_in_file_name, "\n");
5250 //
5251 // curve_id++;
5252 // sprintf(buffer, "curve %d vertex %d %d fixed curve %d\n", curve_id,
5253 // vertex_id - 3, vertex_id - 1, -crack_cur_id1);
5254 // write_record(t3d_in_file, t3d_in_file_name, buffer);
5255 //
5256 // if(k == 1){
5257 // if(ellipsoid -> interface == 0)
5258 // sprintf(buffer, " Curve %d %d", curve_id - curves, curve_id);
5259 // else
5260 // sprintf(buffer, " Curve %d %d Curve %d %d",
5261 // curve_id - curves, curve_id + curves, curve_id, curve_id + 2 * curves);
5262 // write_record(ctrl_file, ctrl_file_name, buffer);
5263 // }
5264 //
5265 // if(k == 0 || k == 1)crack_cur_id1a = curve_id;
5266 //
5267 // curve_id++;
5268 // sprintf(buffer, "curve %d vertex %d %d fixed curve %d\n", curve_id,
5269 // vertex_id - 1, vertex_id - 2, -crack_cur_id1);
5270 // write_record(t3d_in_file, t3d_in_file_name, buffer);
5271 //
5272 // if(k == 1){
5273 // if(ellipsoid -> interface == 0)
5274 // sprintf(buffer, " Curve %d %d", curve_id - curves, curve_id);
5275 // else
5276 // sprintf(buffer, " Curve %d %d Curve %d %d",
5277 // curve_id - curves, curve_id + curves, curve_id, curve_id + 2 * curves);
5278 // write_record(ctrl_file, ctrl_file_name, buffer);
5279 // }
5280 //
5281 // if(k == 0 || k == 1)crack_cur_id1b = curve_id;
5282 //
5283 // curve_id++;
5284 // if((k != 0 && k != 2) || ellipsoid -> property == 0){
5285 // sprintf(buffer, "curve %d vertex %d %d fixed curve %d coincide curve %d\n", curve_id,
5286 // vertex_id - 3, vertex_id, -crack_cur_id1, curve_id - 2);
5287 // write_record(t3d_in_file, t3d_in_file_name, buffer);
5288 // }
5289 //
5290 // if(k == 1){
5291 // if(ellipsoid -> interface == 0)
5292 // sprintf(buffer, " Curve %d %d", curve_id - curves - 2, curve_id);
5293 // else{
5294 // if(ellipsoid -> property == 0)
5295 // sprintf(buffer, " Curve %d %d Curve %d %d",
5296 // curve_id - curves, curve_id + curves, curve_id, curve_id + 2 * curves);
5297 // else
5298 // sprintf(buffer, " Curve %d %d", curve_id, curve_id + 2 * curves);
5299 // }
5300 // write_record(ctrl_file, ctrl_file_name, buffer);
5301 // }
5302 //
5303 // curve_id++;
5304 // if((k != 0 && k != 2) || ellipsoid -> property == 0){
5305 // sprintf(buffer, "curve %d vertex %d %d fixed curve %d coincide curve %d\n", curve_id,
5306 // vertex_id, vertex_id - 2, -crack_cur_id1, curve_id - 2);
5307 // write_record(t3d_in_file, t3d_in_file_name, buffer);
5308 // }
5309 //
5310 // if(k == 1){
5311 // if(ellipsoid -> interface == 0)
5312 // sprintf(buffer, " Curve %d %d", curve_id - curves - 2, curve_id);
5313 // else{
5314 // if(ellipsoid -> property == 0)
5315 // sprintf(buffer, " Curve %d %d Curve %d %d",
5316 // curve_id - curves, curve_id + curves, curve_id, curve_id + 2 * curves);
5317 // else
5318 // sprintf(buffer, " Curve %d %d", curve_id, curve_id + 2 * curves);
5319 // }
5320 // write_record(ctrl_file, ctrl_file_name, buffer);
5321 // }
5322 //
5323 // write_record(t3d_in_file, t3d_in_file_name, "\n");
5324 // break;
5325 //
5326 // case 3:
5327 // if(intersect == 2)error_message(GENERAL_ERROR, "Unimplemented situation");
5328 //
5329 // vertex_id++;
5330 // if(fixed_a == NO || (k != 1 && k != 3 && ellipsoid -> interface != 0)){
5331 // j = crack -> qa - 1;
5332 // if(bmsz == 0.0){
5333 // default_msz = YES;
5334 // sprintf(buffer, "vertex %d xyz %e %e %e virtual\n", vertex_id,
5335 // contact_glob_point[j].x, contact_glob_point[j].y, contact_glob_point[j].z);
5336 // }
5337 // else
5338 // sprintf(buffer, "vertex %d xyz %e %e %e size %e virtual\n", vertex_id,
5339 // contact_glob_point[j].x, contact_glob_point[j].y, contact_glob_point[j].z, bmsz);
5340 // }
5341 // else{
5342 // if(bmsz == 0.0){
5343 // default_msz = YES;
5344 // sprintf(buffer, "vertex %d fixed vertex %d size def\n", vertex_id, crack_ver_id1);
5345 // }
5346 // else
5347 // sprintf(buffer, "vertex %d fixed vertex %d size %e\n", vertex_id, crack_ver_id1, bmsz);
5348 // }
5349 // write_record(t3d_in_file, t3d_in_file_name, buffer);
5350 //
5351 // vertex_id++;
5352 // if(fixed_b == NO || (k != 1 && k != 3 && ellipsoid -> interface != 0)){
5353 // if((j = crack -> qa + 2) >= 4)j -= 4;
5354 // if(bmsz == 0.0){
5355 // default_msz = YES;
5356 // sprintf(buffer, "vertex %d xyz %e %e %e virtual\n", vertex_id,
5357 // contact_glob_point[j].x, contact_glob_point[j].y, contact_glob_point[j].z);
5358 // }
5359 // else
5360 // sprintf(buffer, "vertex %d xyz %e %e %e size %e virtual\n", vertex_id,
5361 // contact_glob_point[j].x, contact_glob_point[j].y, contact_glob_point[j].z, bmsz);
5362 // }
5363 // else{
5364 // if(bmsz == 0.0){
5365 // default_msz = YES;
5366 // sprintf(buffer, "vertex %d fixed vertex %d size def\n", vertex_id, crack_ver_id2);
5367 // }
5368 // else
5369 // sprintf(buffer, "vertex %d fixed vertex %d size %e\n", vertex_id, crack_ver_id2, bmsz);
5370 // }
5371 // write_record(t3d_in_file, t3d_in_file_name, buffer);
5372 //
5373 // write_record(t3d_in_file, t3d_in_file_name, "\n");
5374 //
5375 // if((j = crack -> qa + 2) >= 4)j -= 4;
5376 // curve_id++;
5377 // sprintf(buffer, "curve %d order 3 vertex %d %d virtual\n", curve_id, vertex_id - 1, vertex_id);
5378 // write_record(t3d_in_file, t3d_in_file_name, buffer);
5379 // if(bmsz == 0.0){
5380 // default_msz = YES;
5381 // sprintf(buffer, "polygon 1 xyz %e %e %e weight %e\n",
5382 // contact_glob_pnt[j].x, contact_glob_pnt[j].y, contact_glob_pnt[j].z, -weight_q);
5383 // }
5384 // else
5385 // sprintf(buffer, "polygon 1 xyz %e %e %e weight %e size %e\n",
5386 // contact_glob_pnt[j].x, contact_glob_pnt[j].y, contact_glob_pnt[j].z, -weight_q, bmsz);
5387 // write_record(t3d_in_file, t3d_in_file_name, buffer);
5388 // crack_cur_id1 = -curve_id;
5389 //
5390 // write_record(t3d_in_file, t3d_in_file_name, "\n");
5391 //
5392 // vertex_id++;
5393 // if(fixed_a == NO){
5394 // if(k == 1 || k == 3 || ellipsoid -> interface == 0)
5395 // sprintf(buffer, "vertex %d xyz %e %e %e fixed curve %d fixed vertex %d\n", vertex_id,
5396 // crack -> pnt1.x, crack -> pnt1.y, crack -> pnt1.z, curve_id, crack_ver_id1);
5397 // else
5398 // sprintf(buffer, "vertex %d xyz %e %e %e fixed curve %d\n", vertex_id,
5399 // crack -> pnt1.x, crack -> pnt1.y, crack -> pnt1.z, curve_id);
5400 // }
5401 // else
5402 // sprintf(buffer, "vertex %d fixed vertex %d\n", vertex_id, vertex_id - 2);
5403 // write_record(t3d_in_file, t3d_in_file_name, buffer);
5404 //
5405 // if(k == 1){
5406 // if(ellipsoid -> interface == 0)
5407 // sprintf(buffer, " Vertex %d %d", crack_ver_id1 - vertices, crack_ver_id1);
5408 // else
5409 // sprintf(buffer, " Vertex %d %d Vertex %d %d",
5410 // vertex_id - vertices, vertex_id + vertices, crack_ver_id1, crack_ver_id1 + 2 * vertices);
5411 // write_record(ctrl_file, ctrl_file_name, buffer);
5412 // }
5413 //
5414 // vertex_id++;
5415 // if(fixed_b == NO){
5416 // if(k == 1 || k == 3 || ellipsoid -> interface == 0)
5417 // sprintf(buffer, "vertex %d xyz %e %e %e fixed curve %d fixed vertex %d\n", vertex_id,
5418 // crack -> pnt2.x, crack -> pnt2.y, crack -> pnt2.z, curve_id, crack_ver_id2);
5419 // else
5420 // sprintf(buffer, "vertex %d xyz %e %e %e fixed curve %d\n", vertex_id,
5421 // crack -> pnt2.x, crack -> pnt2.y, crack -> pnt2.z, curve_id);
5422 // }
5423 // else
5424 // sprintf(buffer, "vertex %d fixed vertex %d\n", vertex_id, vertex_id - 2);
5425 // write_record(t3d_in_file, t3d_in_file_name, buffer);
5426 //
5427 // if(k == 1){
5428 // if(ellipsoid -> interface == 0)
5429 // sprintf(buffer, " Vertex %d %d", crack_ver_id2 - vertices, crack_ver_id2);
5430 // else
5431 // sprintf(buffer, " Vertex %d %d Vertex %d %d",
5432 // vertex_id - vertices, vertex_id + vertices, crack_ver_id2, crack_ver_id2 + 2 * vertices);
5433 // write_record(ctrl_file, ctrl_file_name, buffer);
5434 // }
5435 //
5436 // write_record(t3d_in_file, t3d_in_file_name, "\n");
5437 //
5438 // vertex_id++;
5439 // sprintf(buffer, "vertex %d xyz %e %e %e fixed curve %d fixed vertex %d\n", vertex_id,
5440 // point[0].x, point[0].y, point[0].z, curve_id, cross_ver_id1);
5441 // write_record(t3d_in_file, t3d_in_file_name, buffer);
5442 //
5443 // vertex_id++;
5444 // if((k != 0 && k != 2) || ellipsoid -> property == 0){
5445 // sprintf(buffer, "vertex %d xyz %e %e %e fixed curve %d fixed vertex %d\n", vertex_id,
5446 // point[0].x, point[0].y, point[0].z, curve_id, cross_ver_id1 + 1);
5447 // write_record(t3d_in_file, t3d_in_file_name, buffer);
5448 // }
5449 //
5450 // write_record(t3d_in_file, t3d_in_file_name, "\n");
5451 //
5452 // curve_id++;
5453 // sprintf(buffer, "curve %d vertex %d %d fixed curve %d\n", curve_id,
5454 // vertex_id - 3, vertex_id - 1, -crack_cur_id1);
5455 // write_record(t3d_in_file, t3d_in_file_name, buffer);
5456 //
5457 // if(k == 1){
5458 // if(ellipsoid -> interface == 0)
5459 // sprintf(buffer, " Curve %d %d", curve_id - curves, curve_id);
5460 // else
5461 // sprintf(buffer, " Curve %d %d Curve %d %d",
5462 // curve_id - curves, curve_id + curves, curve_id, curve_id + 2 * curves);
5463 // write_record(ctrl_file, ctrl_file_name, buffer);
5464 // }
5465 //
5466 // if(k == 0 || k == 1)crack_cur_id1a = curve_id;
5467 //
5468 // curve_id++;
5469 // sprintf(buffer, "curve %d vertex %d %d fixed curve %d\n", curve_id,
5470 // vertex_id - 1, vertex_id - 2, -crack_cur_id1);
5471 // write_record(t3d_in_file, t3d_in_file_name, buffer);
5472 //
5473 // if(k == 1){
5474 // if(ellipsoid -> interface == 0)
5475 // sprintf(buffer, " Curve %d %d", curve_id - curves, curve_id);
5476 // else
5477 // sprintf(buffer, " Curve %d %d Curve %d %d",
5478 // curve_id - curves, curve_id + curves, curve_id, curve_id + 2 * curves);
5479 // write_record(ctrl_file, ctrl_file_name, buffer);
5480 // }
5481 //
5482 // if(k == 0 || k == 1)crack_cur_id1b = curve_id;
5483 //
5484 // curve_id++;
5485 // if((k != 0 && k != 2) || ellipsoid -> property == 0){
5486 // sprintf(buffer, "curve %d vertex %d %d fixed curve %d coincide curve %d\n", curve_id,
5487 // vertex_id - 3, vertex_id, -crack_cur_id1, curve_id - 2);
5488 // write_record(t3d_in_file, t3d_in_file_name, buffer);
5489 // }
5490 //
5491 // if(k == 1){
5492 // if(ellipsoid -> interface == 0)
5493 // sprintf(buffer, " Curve %d %d", curve_id - curves - 2, curve_id);
5494 // else{
5495 // if(ellipsoid -> property == 0)
5496 // sprintf(buffer, " Curve %d %d Curve %d %d",
5497 // curve_id - curves, curve_id + curves, curve_id, curve_id + 2 * curves);
5498 // else
5499 // sprintf(buffer, " Curve %d %d", curve_id, curve_id + 2 * curves);
5500 // }
5501 // write_record(ctrl_file, ctrl_file_name, buffer);
5502 // }
5503 //
5504 // curve_id++;
5505 // if((k != 0 && k != 2) || ellipsoid -> property == 0){
5506 // sprintf(buffer, "curve %d vertex %d %d fixed curve %d coincide curve %d\n", curve_id,
5507 // vertex_id, vertex_id - 2, -crack_cur_id1, curve_id - 2);
5508 // write_record(t3d_in_file, t3d_in_file_name, buffer);
5509 // }
5510 //
5511 // if(k == 1){
5512 // if(ellipsoid -> interface == 0)
5513 // sprintf(buffer, " Curve %d %d", curve_id - curves - 2, curve_id);
5514 // else{
5515 // if(ellipsoid -> property == 0)
5516 // sprintf(buffer, " Curve %d %d Curve %d %d",
5517 // curve_id - curves, curve_id + curves, curve_id, curve_id + 2 * curves);
5518 // else
5519 // sprintf(buffer, " Curve %d %d", curve_id, curve_id + 2 * curves);
5520 // }
5521 // write_record(ctrl_file, ctrl_file_name, buffer);
5522 // }
5523 //
5524 // write_record(t3d_in_file, t3d_in_file_name, "\n");
5525 // break;
5526 //
5527 // case 4:
5528 // if(fixed_a == YES && fixed_b == YES)error_message(GENERAL_ERROR, "Unimplemented situation");
5529 // if(intersect == 0)error_message(GENERAL_ERROR, "Unexpected situation");
5530 //
5531 // for(m = 0; m < 2; m++){
5532 // skip = NO;
5533 // if(m == 1){
5534 // if((k == 0 || k == 2) && ellipsoid -> property != 0)skip = YES;
5535 // }
5536 //
5537 // vertex_id++;
5538 // if(skip == NO){
5539 // if((fixed_a == NO && fixed_b == NO) || (k != 1 && k != 3 && ellipsoid -> interface != 0)){
5540 // j = crack -> qa - 1;
5541 // if(bmsz == 0.0){
5542 // default_msz = YES;
5543 // sprintf(buffer, "vertex %d xyz %e %e %e virtual\n", vertex_id,
5544 // contact_glob_point[j].x, contact_glob_point[j].y, contact_glob_point[j].z);
5545 // }
5546 // else
5547 // sprintf(buffer, "vertex %d xyz %e %e %e size %e virtual\n", vertex_id,
5548 // contact_glob_point[j].x, contact_glob_point[j].y, contact_glob_point[j].z, bmsz);
5549 // }
5550 // else{
5551 // if(fixed_a == YES){
5552 // if(bmsz == 0.0){
5553 // default_msz = YES;
5554 // sprintf(buffer, "vertex %d fixed vertex %d size def\n", vertex_id, crack_ver_id1);
5555 // }
5556 // else
5557 // sprintf(buffer, "vertex %d fixed vertex %d size %e\n", vertex_id, crack_ver_id1, bmsz);
5558 // }
5559 // if(fixed_b == YES){
5560 // if(bmsz == 0.0){
5561 // default_msz = YES;
5562 // sprintf(buffer, "vertex %d fixed vertex %d size def\n", vertex_id, crack_ver_id2);
5563 // }
5564 // else
5565 // sprintf(buffer, "vertex %d fixed vertex %d size %e\n", vertex_id, crack_ver_id2, bmsz);
5566 // }
5567 // }
5568 // write_record(t3d_in_file, t3d_in_file_name, buffer);
5569 // }
5570 //
5571 // if((j = crack -> qa + 1) >= 4)j -= 4;
5572 // vertex_id++;
5573 // if(skip == NO){
5574 // if(bmsz == 0.0){
5575 // default_msz = YES;
5576 // if(m == 1){
5577 // if(intersect == 1)
5578 // sprintf(buffer, "vertex %d xyz %e %e %e coincide vertex %d\n", vertex_id,
5579 // contact_glob_point[j].x, contact_glob_point[j].y, contact_glob_point[j].z, vertex_id - 5);
5580 // else
5581 // sprintf(buffer, "vertex %d xyz %e %e %e coincide vertex %d\n", vertex_id,
5582 // contact_glob_point[j].x, contact_glob_point[j].y, contact_glob_point[j].z, vertex_id - 6);
5583 // }
5584 // else
5585 // sprintf(buffer, "vertex %d xyz %e %e %e\n", vertex_id,
5586 // contact_glob_point[j].x, contact_glob_point[j].y, contact_glob_point[j].z);
5587 // }
5588 // else{
5589 // if(m == 1){
5590 // if(intersect == 1)
5591 // sprintf(buffer, "vertex %d xyz %e %e %e size %e coincide vertex %d\n", vertex_id,
5592 // contact_glob_point[j].x, contact_glob_point[j].y, contact_glob_point[j].z, bmsz, vertex_id - 5);
5593 // else
5594 // sprintf(buffer, "vertex %d xyz %e %e %e size %e coincide vertex %d\n", vertex_id,
5595 // contact_glob_point[j].x, contact_glob_point[j].y, contact_glob_point[j].z, bmsz, vertex_id - 6);
5596 // }
5597 // else
5598 // sprintf(buffer, "vertex %d xyz %e %e %e size %e\n", vertex_id,
5599 // contact_glob_point[j].x, contact_glob_point[j].y, contact_glob_point[j].z, bmsz);
5600 // }
5601 // write_record(t3d_in_file, t3d_in_file_name, buffer);
5602 // }
5603 //
5604 // if(k == 1){
5605 // if(ellipsoid -> interface == 0){
5606 // if(m == 0)
5607 // sprintf(buffer, " Vertex %d %d", vertex_id - vertices, vertex_id);
5608 // else{
5609 // if(intersect == 1)
5610 // sprintf(buffer, " Vertex %d %d", vertex_id - vertices - 5, vertex_id);
5611 // else
5612 // sprintf(buffer, " Vertex %d %d", vertex_id - vertices - 6, vertex_id);
5613 // }
5614 // }
5615 // else{
5616 // if(m == 0 || ellipsoid -> property == 0)
5617 // sprintf(buffer, " Vertex %d %d Vertex %d %d",
5618 // vertex_id - vertices, vertex_id + vertices, vertex_id, vertex_id + 2 * vertices);
5619 // else
5620 // sprintf(buffer, " Vertex %d %d", vertex_id, vertex_id + 2 * vertices);
5621 // }
5622 // write_record(ctrl_file, ctrl_file_name, buffer);
5623 // }
5624 //
5625 // if(skip == NO)write_record(t3d_in_file, t3d_in_file_name, "\n");
5626 //
5627 // curve_id++;
5628 // if(skip == NO){
5629 // sprintf(buffer, "curve %d order 4 vertex %d %d virtual\n", curve_id, vertex_id - 1, vertex_id);
5630 // write_record(t3d_in_file, t3d_in_file_name, buffer);
5631 // for(i = 0; i < 2; i++){
5632 // if((j = crack -> qa - 1 + i) >= 4)j -= 4;
5633 // if(bmsz == 0.0){
5634 // default_msz = YES;
5635 // sprintf(buffer, "polygon %d xyz %e %e %e weight %e\n", i + 1,
5636 // contact_glob_pnt[j].x, contact_glob_pnt[j].y, contact_glob_pnt[j].z, weight_h);
5637 // }
5638 // else
5639 // sprintf(buffer, "polygon %d xyz %e %e %e weight %e size %e\n", i + 1,
5640 // contact_glob_pnt[j].x, contact_glob_pnt[j].y, contact_glob_pnt[j].z, weight_h, bmsz);
5641 // write_record(t3d_in_file, t3d_in_file_name, buffer);
5642 // }
5643 // }
5644 //
5645 // curve_id++;
5646 // if(skip == NO){
5647 // sprintf(buffer, "curve %d order 4 vertex %d %d virtual\n", curve_id, vertex_id, vertex_id - 1);
5648 // write_record(t3d_in_file, t3d_in_file_name, buffer);
5649 // for(i = 0; i < 2; i++){
5650 // if((j = crack -> qa + 1 + i) >= 4)j -= 4;
5651 // if(bmsz == 0.0){
5652 // default_msz = YES;
5653 // sprintf(buffer, "polygon %d xyz %e %e %e weight %e\n", i + 1,
5654 // contact_glob_pnt[j].x, contact_glob_pnt[j].y, contact_glob_pnt[j].z, weight_h);
5655 // }
5656 // else
5657 // sprintf(buffer, "polygon %d xyz %e %e %e weight %e size %e\n", i + 1,
5658 // contact_glob_pnt[j].x, contact_glob_pnt[j].y, contact_glob_pnt[j].z, weight_h, bmsz);
5659 // write_record(t3d_in_file, t3d_in_file_name, buffer);
5660 // }
5661 // }
5662 //
5663 // if(skip == NO)write_record(t3d_in_file, t3d_in_file_name, "\n");
5664 //
5665 // vertex_id++;
5666 // if(skip == NO){
5667 // if(fixed_a == NO){
5668 // if(k == 1 || k == 3 || ellipsoid -> interface == 0)
5669 // sprintf(buffer, "vertex %d xyz %e %e %e fixed curve %d fixed vertex %d\n", vertex_id,
5670 // crack -> pnt1.x, crack -> pnt1.y, crack -> pnt1.z, curve_id - 1, crack_ver_id1);
5671 // else{
5672 // if(m == 1){
5673 // if(intersect == 1)
5674 // sprintf(buffer, "vertex %d xyz %e %e %e fixed curve %d fixed vertex %d\n", vertex_id,
5675 // crack -> pnt1.x, crack -> pnt1.y, crack -> pnt1.z, curve_id - 1, vertex_id - 5);
5676 // else
5677 // sprintf(buffer, "vertex %d xyz %e %e %e fixed curve %d fixed vertex %d\n", vertex_id,
5678 // crack -> pnt1.x, crack -> pnt1.y, crack -> pnt1.z, curve_id - 1, vertex_id - 6);
5679 // }
5680 // else
5681 // sprintf(buffer, "vertex %d xyz %e %e %e fixed curve %d\n", vertex_id,
5682 // crack -> pnt1.x, crack -> pnt1.y, crack -> pnt1.z, curve_id - 1);
5683 // }
5684 // }
5685 // else
5686 // sprintf(buffer, "vertex %d fixed vertex %d\n", vertex_id, vertex_id - 2);
5687 // write_record(t3d_in_file, t3d_in_file_name, buffer);
5688 // }
5689 //
5690 // if(k == 1 && m == 0){
5691 // if(ellipsoid -> interface == 0)
5692 // sprintf(buffer, " Vertex %d %d", crack_ver_id1 - vertices, crack_ver_id1);
5693 // else
5694 // sprintf(buffer, " Vertex %d %d Vertex %d %d",
5695 // vertex_id - vertices, vertex_id + vertices, crack_ver_id1, crack_ver_id1 + 2 * vertices);
5696 // write_record(ctrl_file, ctrl_file_name, buffer);
5697 // }
5698 //
5699 // vertex_id++;
5700 // if(skip == NO){
5701 // if(fixed_b == NO){
5702 // if(k == 1 || k == 3 || ellipsoid -> interface == 0)
5703 // sprintf(buffer, "vertex %d xyz %e %e %e fixed curve %d fixed vertex %d\n", vertex_id,
5704 // crack -> pnt2.x, crack -> pnt2.y, crack -> pnt2.z, curve_id, crack_ver_id2);
5705 // else{
5706 // if(m == 1){
5707 // if(intersect == 1)
5708 // sprintf(buffer, "vertex %d xyz %e %e %e fixed curve %d fixed vertex %d\n", vertex_id,
5709 // crack -> pnt2.x, crack -> pnt2.y, crack -> pnt2.z, curve_id, vertex_id - 5);
5710 // else
5711 // sprintf(buffer, "vertex %d xyz %e %e %e fixed curve %d fixed vertex %d\n", vertex_id,
5712 // crack -> pnt2.x, crack -> pnt2.y, crack -> pnt2.z, curve_id, vertex_id - 6);
5713 // }
5714 // else
5715 // sprintf(buffer, "vertex %d xyz %e %e %e fixed curve %d\n", vertex_id,
5716 // crack -> pnt2.x, crack -> pnt2.y, crack -> pnt2.z, curve_id);
5717 // }
5718 // }
5719 // else
5720 // sprintf(buffer, "vertex %d fixed vertex %d\n", vertex_id, vertex_id - 2);
5721 // write_record(t3d_in_file, t3d_in_file_name, buffer);
5722 //
5723 // if(k == 1 && m == 0){
5724 // if(ellipsoid -> interface == 0)
5725 // sprintf(buffer, " Vertex %d %d", crack_ver_id2 - vertices, crack_ver_id2);
5726 // else
5727 // sprintf(buffer, " Vertex %d %d Vertex %d %d",
5728 // vertex_id - vertices, vertex_id + vertices, crack_ver_id2, crack_ver_id2 + 2 * vertices);
5729 // write_record(ctrl_file, ctrl_file_name, buffer);
5730 // }
5731 // }
5732 //
5733 // if(skip == NO)write_record(t3d_in_file, t3d_in_file_name, "\n");
5734 //
5735 // if(intersect == 1){
5736 // if(first_curve == YES){
5737 // vertex_id++;
5738 // if(skip == NO){
5739 // crack_cur_id1 = -(curve_id - 1);
5740 // sprintf(buffer, "vertex %d xyz %e %e %e fixed curve %d fixed vertex %d\n", vertex_id,
5741 // point[0].x, point[0].y, point[0].z, -crack_cur_id1, cross_ver_id1 + m);
5742 // write_record(t3d_in_file, t3d_in_file_name, buffer);
5743 // }
5744 //
5745 // if(skip == NO)write_record(t3d_in_file, t3d_in_file_name, "\n");
5746 //
5747 // curve_id++;
5748 // if(skip == NO){
5749 // if(m == 1)
5750 // sprintf(buffer, "curve %d vertex %d %d fixed curve %d coincide curve %d\n", curve_id,
5751 // vertex_id - 2, vertex_id, -crack_cur_id1, curve_id - 5);
5752 // else
5753 // sprintf(buffer, "curve %d vertex %d %d fixed curve %d\n", curve_id,
5754 // vertex_id - 2, vertex_id, -crack_cur_id1);
5755 // write_record(t3d_in_file, t3d_in_file_name, buffer);
5756 // }
5757 //
5758 // if(k == 1){
5759 // if(ellipsoid -> interface == 0){
5760 // if(m == 0)
5761 // sprintf(buffer, " Curve %d %d", curve_id - curves, curve_id);
5762 // else
5763 // sprintf(buffer, " Curve %d %d", curve_id - curves - 5, curve_id);
5764 // }
5765 // else{
5766 // if(m == 0 || ellipsoid -> property == 0)
5767 // sprintf(buffer, " Curve %d %d Curve %d %d",
5768 // curve_id - curves, curve_id + curves, curve_id, curve_id + 2 * curves);
5769 // else
5770 // sprintf(buffer, " Curve %d %d", curve_id, curve_id + 2 * curves);
5771 // }
5772 // write_record(ctrl_file, ctrl_file_name, buffer);
5773 // }
5774 //
5775 // if(m == 0){
5776 // if(k == 0 || k == 1)crack_cur_id1a = curve_id;
5777 // }
5778 //
5779 // curve_id++;
5780 // if(skip == NO){
5781 // if(m == 1)
5782 // sprintf(buffer, "curve %d vertex %d %d fixed curve %d coincide curve %d\n", curve_id,
5783 // vertex_id, vertex_id - 3, -crack_cur_id1, curve_id - 5);
5784 // else
5785 // sprintf(buffer, "curve %d vertex %d %d fixed curve %d\n", curve_id,
5786 // vertex_id, vertex_id - 3, -crack_cur_id1);
5787 // write_record(t3d_in_file, t3d_in_file_name, buffer);
5788 // }
5789 //
5790 // if(k == 1){
5791 // if(ellipsoid -> interface == 0){
5792 // if(m == 0)
5793 // sprintf(buffer, " Curve %d %d", curve_id - curves, curve_id);
5794 // else
5795 // sprintf(buffer, " Curve %d %d", curve_id - curves - 5, curve_id);
5796 // }
5797 // else{
5798 // if(m == 0 || ellipsoid -> property == 0)
5799 // sprintf(buffer, " Curve %d %d Curve %d %d",
5800 // curve_id - curves, curve_id + curves, curve_id, curve_id + 2 * curves);
5801 // else
5802 // sprintf(buffer, " Curve %d %d", curve_id, curve_id + 2 * curves);
5803 // }
5804 // write_record(ctrl_file, ctrl_file_name, buffer);
5805 // }
5806 //
5807 // if(m == 0){
5808 // if(k == 0 || k == 1)crack_cur_id1b = curve_id;
5809 // }
5810 //
5811 // curve_id++;
5812 // if(skip == NO){
5813 // if(m == 1)
5814 // sprintf(buffer, "curve %d vertex %d %d fixed curve %d coincide curve %d\n", curve_id,
5815 // vertex_id - 3, vertex_id - 1, curve_id - 3, curve_id - 5);
5816 // else
5817 // sprintf(buffer, "curve %d vertex %d %d fixed curve %d\n", curve_id,
5818 // vertex_id - 3, vertex_id - 1, curve_id - 3);
5819 // write_record(t3d_in_file, t3d_in_file_name, buffer);
5820 // }
5821 //
5822 // if(k == 1){
5823 // if(ellipsoid -> interface == 0){
5824 // if(m == 0)
5825 // sprintf(buffer, " Curve %d %d", curve_id - curves, curve_id);
5826 // else
5827 // sprintf(buffer, " Curve %d %d", curve_id - curves - 5, curve_id);
5828 // }
5829 // else{
5830 // if(m == 0 || ellipsoid -> property == 0)
5831 // sprintf(buffer, " Curve %d %d Curve %d %d",
5832 // curve_id - curves, curve_id + curves, curve_id, curve_id + 2 * curves);
5833 // else
5834 // sprintf(buffer, " Curve %d %d", curve_id, curve_id + 2 * curves);
5835 // }
5836 // write_record(ctrl_file, ctrl_file_name, buffer);
5837 // }
5838 //
5839 // if(m == 0){
5840 // if(k == 0 || k == 1)crack_cur_id2 = curve_id;
5841 // }
5842 // }
5843 // else{
5844 // vertex_id++;
5845 // if(skip == NO){
5846 // crack_cur_id2 = -curve_id;
5847 // sprintf(buffer, "vertex %d xyz %e %e %e fixed curve %d fixed vertex %d\n", vertex_id,
5848 // point[0].x, point[0].y, point[0].z, -crack_cur_id2, cross_ver_id1 + m);
5849 // write_record(t3d_in_file, t3d_in_file_name, buffer);
5850 // }
5851 //
5852 // if(skip == NO)write_record(t3d_in_file, t3d_in_file_name, "\n");
5853 //
5854 // curve_id++;
5855 // if(skip == NO){
5856 // if(m == 1)
5857 // sprintf(buffer, "curve %d vertex %d %d fixed curve %d coincide curve %d\n", curve_id,
5858 // vertex_id - 2, vertex_id - 3, curve_id - 2, curve_id - 5);
5859 // else
5860 // sprintf(buffer, "curve %d vertex %d %d fixed curve %d\n", curve_id,
5861 // vertex_id - 2, vertex_id - 3, curve_id - 2);
5862 // write_record(t3d_in_file, t3d_in_file_name, buffer);
5863 // }
5864 //
5865 // if(k == 1){
5866 // if(ellipsoid -> interface == 0){
5867 // if(m == 0)
5868 // sprintf(buffer, " Curve %d %d", curve_id - curves, curve_id);
5869 // else
5870 // sprintf(buffer, " Curve %d %d", curve_id - curves - 5, curve_id);
5871 // }
5872 // else{
5873 // if(m == 0 || ellipsoid -> property == 0)
5874 // sprintf(buffer, " Curve %d %d Curve %d %d",
5875 // curve_id - curves, curve_id + curves, curve_id, curve_id + 2 * curves);
5876 // else
5877 // sprintf(buffer, " Curve %d %d", curve_id, curve_id + 2 * curves);
5878 // }
5879 // write_record(ctrl_file, ctrl_file_name, buffer);
5880 // }
5881 //
5882 // if(m == 0){
5883 // if(k == 0 || k == 1)crack_cur_id1 = curve_id;
5884 // }
5885 //
5886 // curve_id++;
5887 // if(skip == NO){
5888 // if(m == 1)
5889 // sprintf(buffer, "curve %d vertex %d %d fixed curve %d coincide curve %d\n", curve_id,
5890 // vertex_id - 3, vertex_id, -crack_cur_id2, curve_id - 5);
5891 // else
5892 // sprintf(buffer, "curve %d vertex %d %d fixed curve %d\n", curve_id,
5893 // vertex_id - 3, vertex_id, -crack_cur_id2);
5894 // write_record(t3d_in_file, t3d_in_file_name, buffer);
5895 // }
5896 //
5897 // if(k == 1){
5898 // if(ellipsoid -> interface == 0){
5899 // if(m == 0)
5900 // sprintf(buffer, " Curve %d %d", curve_id - curves, curve_id);
5901 // else
5902 // sprintf(buffer, " Curve %d %d", curve_id - curves - 5, curve_id);
5903 // }
5904 // else{
5905 // if(m == 0 || ellipsoid -> property == 0)
5906 // sprintf(buffer, " Curve %d %d Curve %d %d",
5907 // curve_id - curves, curve_id + curves, curve_id, curve_id + 2 * curves);
5908 // else
5909 // sprintf(buffer, " Curve %d %d", curve_id, curve_id + 2 * curves);
5910 // }
5911 // write_record(ctrl_file, ctrl_file_name, buffer);
5912 // }
5913 //
5914 // if(m == 0){
5915 // if(k == 0 || k == 1)crack_cur_id2a = curve_id;
5916 // }
5917 //
5918 // curve_id++;
5919 // if(skip == NO){
5920 // if(m == 1)
5921 // sprintf(buffer, "curve %d vertex %d %d fixed curve %d coincide curve %d\n", curve_id,
5922 // vertex_id, vertex_id - 1, -crack_cur_id2, curve_id - 5);
5923 // else
5924 // sprintf(buffer, "curve %d vertex %d %d fixed curve %d\n", curve_id,
5925 // vertex_id, vertex_id - 1, -crack_cur_id2);
5926 // write_record(t3d_in_file, t3d_in_file_name, buffer);
5927 // }
5928 //
5929 // if(k == 1){
5930 // if(ellipsoid -> interface == 0){
5931 // if(m == 0)
5932 // sprintf(buffer, " Curve %d %d", curve_id - curves, curve_id);
5933 // else
5934 // sprintf(buffer, " Curve %d %d", curve_id - curves - 5, curve_id);
5935 // }
5936 // else{
5937 // if(m == 0 || ellipsoid -> property == 0)
5938 // sprintf(buffer, " Curve %d %d Curve %d %d",
5939 // curve_id - curves, curve_id + curves, curve_id, curve_id + 2 * curves);
5940 // else
5941 // sprintf(buffer, " Curve %d %d", curve_id, curve_id + 2 * curves);
5942 // }
5943 // write_record(ctrl_file, ctrl_file_name, buffer);
5944 // }
5945 //
5946 // if(m == 0){
5947 // if(k == 0 || k == 1)crack_cur_id2b = curve_id;
5948 // }
5949 // }
5950 // }
5951 // else{
5952 // crack_cur_id1 = -(curve_id - 1);
5953 // crack_cur_id2 = -curve_id;
5954 //
5955 // vertex_id++;
5956 // if(skip == NO){
5957 // sprintf(buffer, "vertex %d xyz %e %e %e fixed curve %d fixed vertex %d\n", vertex_id,
5958 // point[0].x, point[0].y, point[0].z, -crack_cur_id1, cross_ver_id1 + m);
5959 // write_record(t3d_in_file, t3d_in_file_name, buffer);
5960 // }
5961 //
5962 // vertex_id++;
5963 // if(skip == NO){
5964 // sprintf(buffer, "vertex %d xyz %e %e %e fixed curve %d fixed vertex %d\n", vertex_id,
5965 // point[1].x, point[1].y, point[1].z, -crack_cur_id2, cross_ver_id2 + m);
5966 // write_record(t3d_in_file, t3d_in_file_name, buffer);
5967 // }
5968 //
5969 // if(skip == NO)write_record(t3d_in_file, t3d_in_file_name, "\n");
5970 //
5971 // curve_id++;
5972 // if(skip == NO){
5973 // if(m == 1)
5974 // sprintf(buffer, "curve %d vertex %d %d fixed curve %d coincide curve %d\n", curve_id,
5975 // vertex_id - 3, vertex_id - 1, -crack_cur_id1, curve_id - 6);
5976 // else
5977 // sprintf(buffer, "curve %d vertex %d %d fixed curve %d\n", curve_id,
5978 // vertex_id - 3, vertex_id - 1, -crack_cur_id1);
5979 // write_record(t3d_in_file, t3d_in_file_name, buffer);
5980 // }
5981 //
5982 // if(k == 1){
5983 // if(ellipsoid -> interface == 0){
5984 // if(m == 0)
5985 // sprintf(buffer, " Curve %d %d", curve_id - curves, curve_id);
5986 // else
5987 // sprintf(buffer, " Curve %d %d", curve_id - curves - 6, curve_id);
5988 // }
5989 // else{
5990 // if(m == 0 || ellipsoid -> property == 0)
5991 // sprintf(buffer, " Curve %d %d Curve %d %d",
5992 // curve_id - curves, curve_id + curves, curve_id, curve_id + 2 * curves);
5993 // else
5994 // sprintf(buffer, " Curve %d %d", curve_id, curve_id + 2 * curves);
5995 // }
5996 // write_record(ctrl_file, ctrl_file_name, buffer);
5997 // }
5998 //
5999 // if(m == 0){
6000 // if(k == 0 || k == 1)crack_cur_id1a = curve_id;
6001 // }
6002 //
6003 // curve_id++;
6004 // if(skip == NO){
6005 // if(m == 1)
6006 // sprintf(buffer, "curve %d vertex %d %d fixed curve %d coincide curve %d\n", curve_id,
6007 // vertex_id - 1, vertex_id - 4, -crack_cur_id1, curve_id - 6);
6008 // else
6009 // sprintf(buffer, "curve %d vertex %d %d fixed curve %d\n", curve_id,
6010 // vertex_id - 1, vertex_id - 4, -crack_cur_id1);
6011 // write_record(t3d_in_file, t3d_in_file_name, buffer);
6012 // }
6013 //
6014 // if(k == 1){
6015 // if(ellipsoid -> interface == 0){
6016 // if(m == 0)
6017 // sprintf(buffer, " Curve %d %d", curve_id - curves, curve_id);
6018 // else
6019 // sprintf(buffer, " Curve %d %d", curve_id - curves - 6, curve_id);
6020 // }
6021 // else{
6022 // if(m == 0 || ellipsoid -> property == 0)
6023 // sprintf(buffer, " Curve %d %d Curve %d %d",
6024 // curve_id - curves, curve_id + curves, curve_id, curve_id + 2 * curves);
6025 // else
6026 // sprintf(buffer, " Curve %d %d", curve_id, curve_id + 2 * curves);
6027 // }
6028 // write_record(ctrl_file, ctrl_file_name, buffer);
6029 // }
6030 //
6031 // if(m == 0){
6032 // if(k == 0 || k == 1)crack_cur_id1b = curve_id;
6033 // }
6034 //
6035 // curve_id++;
6036 // if(skip == NO){
6037 // if(m == 1)
6038 // sprintf(buffer, "curve %d vertex %d %d fixed curve %d coincide curve %d\n", curve_id,
6039 // vertex_id - 4, vertex_id, -crack_cur_id2, curve_id - 6);
6040 // else
6041 // sprintf(buffer, "curve %d vertex %d %d fixed curve %d\n", curve_id,
6042 // vertex_id - 4, vertex_id, -crack_cur_id2);
6043 // write_record(t3d_in_file, t3d_in_file_name, buffer);
6044 // }
6045 //
6046 // if(k == 1){
6047 // if(ellipsoid -> interface == 0){
6048 // if(m == 0)
6049 // sprintf(buffer, " Curve %d %d", curve_id - curves, curve_id);
6050 // else
6051 // sprintf(buffer, " Curve %d %d", curve_id - curves - 6, curve_id);
6052 // }
6053 // else{
6054 // if(m == 0 || ellipsoid -> property == 0)
6055 // sprintf(buffer, " Curve %d %d Curve %d %d",
6056 // curve_id - curves, curve_id + curves, curve_id, curve_id + 2 * curves);
6057 // else
6058 // sprintf(buffer, " Curve %d %d", curve_id, curve_id + 2 * curves);
6059 // }
6060 // write_record(ctrl_file, ctrl_file_name, buffer);
6061 // }
6062 //
6063 // if(m == 0){
6064 // if(k == 0 || k == 1)crack_cur_id2a = curve_id;
6065 // }
6066 //
6067 // curve_id++;
6068 // if(skip == NO){
6069 // if(m == 1)
6070 // sprintf(buffer, "curve %d vertex %d %d fixed curve %d coincide curve %d\n", curve_id,
6071 // vertex_id, vertex_id - 2, -crack_cur_id2, curve_id - 6);
6072 // else
6073 // sprintf(buffer, "curve %d vertex %d %d fixed curve %d\n", curve_id,
6074 // vertex_id, vertex_id - 2, -crack_cur_id2);
6075 // write_record(t3d_in_file, t3d_in_file_name, buffer);
6076 // }
6077 //
6078 // if(k == 1){
6079 // if(ellipsoid -> interface == 0){
6080 // if(m == 0)
6081 // sprintf(buffer, " Curve %d %d", curve_id - curves, curve_id);
6082 // else
6083 // sprintf(buffer, " Curve %d %d", curve_id - curves - 6, curve_id);
6084 // }
6085 // else{
6086 // if(m == 0 || ellipsoid -> property == 0)
6087 // sprintf(buffer, " Curve %d %d Curve %d %d",
6088 // curve_id - curves, curve_id + curves, curve_id, curve_id + 2 * curves);
6089 // else
6090 // sprintf(buffer, " Curve %d %d", curve_id, curve_id + 2 * curves);
6091 // }
6092 // write_record(ctrl_file, ctrl_file_name, buffer);
6093 // }
6094 //
6095 // if(m == 0){
6096 // if(k == 0 || k == 1)crack_cur_id2b = curve_id;
6097 // }
6098 // }
6099 //
6100 // if(skip == NO)write_record(t3d_in_file, t3d_in_file_name, "\n");
6101 // }
6102 // break;
6103 //
6104 // case 5:
6105 // for(m = 0; m < 2; m++){
6106 // skip = NO;
6107 // if(m == 1){
6108 // if((k == 0 || k == 2) && ellipsoid -> property != 0)skip = YES;
6109 // }
6110 //
6111 // vertex_id++;
6112 // if(skip == NO){
6113 // if((j = crack -> qa + 1) >= 4)j -= 4;
6114 // if(bmsz == 0.0){
6115 // default_msz = YES;
6116 // if(m == 1)
6117 // sprintf(buffer, "vertex %d xyz %e %e %e coincide vertex %d\n", vertex_id,
6118 // contact_glob_point[j].x, contact_glob_point[j].y, contact_glob_point[j].z, vertex_id - 6);
6119 // else
6120 // sprintf(buffer, "vertex %d xyz %e %e %e\n", vertex_id,
6121 // contact_glob_point[j].x, contact_glob_point[j].y, contact_glob_point[j].z);
6122 // }
6123 // else{
6124 // if(m == 1)
6125 // sprintf(buffer, "vertex %d xyz %e %e %e size %e coincide vertex %d\n", vertex_id,
6126 // contact_glob_point[j].x, contact_glob_point[j].y, contact_glob_point[j].z, bmsz, vertex_id - 6);
6127 // else
6128 // sprintf(buffer, "vertex %d xyz %e %e %e size %e\n", vertex_id,
6129 // contact_glob_point[j].x, contact_glob_point[j].y, contact_glob_point[j].z, bmsz);
6130 // }
6131 // write_record(t3d_in_file, t3d_in_file_name, buffer);
6132 // }
6133 //
6134 // if(k == 1){
6135 // if(ellipsoid -> interface == 0){
6136 // if(m == 0)
6137 // sprintf(buffer, " Vertex %d %d", vertex_id - vertices, vertex_id);
6138 // else
6139 // sprintf(buffer, " Vertex %d %d", vertex_id - vertices - 6, vertex_id);
6140 // }
6141 // else{
6142 // if(m == 0 || ellipsoid -> property == 0)
6143 // sprintf(buffer, " Vertex %d %d Vertex %d %d",
6144 // vertex_id - vertices, vertex_id + vertices, vertex_id, vertex_id + 2 * vertices);
6145 // else
6146 // sprintf(buffer, " Vertex %d %d", vertex_id, vertex_id + 2 * vertices);
6147 // }
6148 // write_record(ctrl_file, ctrl_file_name, buffer);
6149 // }
6150 //
6151 // vertex_id++;
6152 // if(skip == NO){
6153 // if((j = crack -> qa + 2) >= 4)j -= 4;
6154 // if(bmsz == 0.0){
6155 // default_msz = YES;
6156 // if(m == 1)
6157 // sprintf(buffer, "vertex %d xyz %e %e %e coincide vertex %d\n", vertex_id,
6158 // contact_glob_point[j].x, contact_glob_point[j].y, contact_glob_point[j].z, vertex_id - 6);
6159 // else
6160 // sprintf(buffer, "vertex %d xyz %e %e %e\n", vertex_id,
6161 // contact_glob_point[j].x, contact_glob_point[j].y, contact_glob_point[j].z);
6162 // }
6163 // else{
6164 // if(m == 1)
6165 // sprintf(buffer, "vertex %d xyz %e %e %e size %e coincide vertex %d\n", vertex_id,
6166 // contact_glob_point[j].x, contact_glob_point[j].y, contact_glob_point[j].z, bmsz, vertex_id - 6);
6167 // else
6168 // sprintf(buffer, "vertex %d xyz %e %e %e size %e\n", vertex_id,
6169 // contact_glob_point[j].x, contact_glob_point[j].y, contact_glob_point[j].z, bmsz);
6170 // }
6171 // write_record(t3d_in_file, t3d_in_file_name, buffer);
6172 // }
6173 //
6174 // if(k == 1){
6175 // if(ellipsoid -> interface == 0){
6176 // if(m == 0)
6177 // sprintf(buffer, " Vertex %d %d", vertex_id - vertices, vertex_id);
6178 // else
6179 // sprintf(buffer, " Vertex %d %d", vertex_id - vertices - 6, vertex_id);
6180 // }
6181 // else{
6182 // if(m == 0 || ellipsoid -> property == 0)
6183 // sprintf(buffer, " Vertex %d %d Vertex %d %d",
6184 // vertex_id - vertices, vertex_id + vertices, vertex_id, vertex_id + 2 * vertices);
6185 // else
6186 // sprintf(buffer, " Vertex %d %d", vertex_id, vertex_id + 2 * vertices);
6187 // }
6188 // write_record(ctrl_file, ctrl_file_name, buffer);
6189 // }
6190 //
6191 // if(skip == NO)write_record(t3d_in_file, t3d_in_file_name, "\n");
6192 //
6193 // curve_id++;
6194 // if(skip == NO){
6195 // if((j = crack -> qa + 1) >= 4)j -= 4;
6196 // if(m == 1)
6197 // sprintf(buffer, "curve %d order 3 vertex %d %d coincide curve %d\n", curve_id,
6198 // vertex_id - 1, vertex_id, curve_id - 6);
6199 // else
6200 // sprintf(buffer, "curve %d order 3 vertex %d %d\n", curve_id, vertex_id - 1, vertex_id);
6201 // write_record(t3d_in_file, t3d_in_file_name, buffer);
6202 // if(bmsz == 0.0){
6203 // default_msz = YES;
6204 // sprintf(buffer, "polygon 1 xyz %e %e %e weight %e\n",
6205 // contact_glob_pnt[j].x, contact_glob_pnt[j].y, contact_glob_pnt[j].z, weight_q);
6206 // }
6207 // else
6208 // sprintf(buffer, "polygon 1 xyz %e %e %e weight %e size %e\n",
6209 // contact_glob_pnt[j].x, contact_glob_pnt[j].y, contact_glob_pnt[j].z, weight_q, bmsz);
6210 // write_record(t3d_in_file, t3d_in_file_name, buffer);
6211 // }
6212 //
6213 // if(k == 1){
6214 // if(ellipsoid -> interface == 0){
6215 // if(m == 0)
6216 // sprintf(buffer, " Curve %d %d", curve_id - curves, curve_id);
6217 // else
6218 // sprintf(buffer, " Curve %d %d", curve_id - curves - 6, curve_id);
6219 // }
6220 // else{
6221 // if(m == 0 || ellipsoid -> property == 0)
6222 // sprintf(buffer, " Curve %d %d Curve %d %d",
6223 // curve_id - curves, curve_id + curves, curve_id, curve_id + 2 * curves);
6224 // else
6225 // sprintf(buffer, " Curve %d %d", curve_id, curve_id + 2 * curves);
6226 // }
6227 // write_record(ctrl_file, ctrl_file_name, buffer);
6228 // }
6229 //
6230 // if(m == 0){
6231 // if(k == 0 || k == 1)crack_cur_id2 = curve_id;
6232 // }
6233 //
6234 // curve_id++;
6235 // if(skip == NO){
6236 // sprintf(buffer, "curve %d order 3 vertex %d %d virtual\n", curve_id, vertex_id, vertex_id - 1);
6237 // write_record(t3d_in_file, t3d_in_file_name, buffer);
6238 // if(bmsz == 0.0){
6239 // default_msz = YES;
6240 // sprintf(buffer, "polygon 1 xyz %e %e %e weight %e\n",
6241 // contact_glob_pnt[j].x, contact_glob_pnt[j].y, contact_glob_pnt[j].z, -weight_q);
6242 // }
6243 // else
6244 // sprintf(buffer, "polygon 1 xyz %e %e %e weight %e size %e\n",
6245 // contact_glob_pnt[j].x, contact_glob_pnt[j].y, contact_glob_pnt[j].z, -weight_q, bmsz);
6246 // write_record(t3d_in_file, t3d_in_file_name, buffer);
6247 // crack_cur_id1 = crack_cur_id3 = -curve_id;
6248 // }
6249 //
6250 // if(skip == NO)write_record(t3d_in_file, t3d_in_file_name, "\n");
6251 //
6252 // vertex_id++;
6253 // if(skip == NO){
6254 // if(k == 1 || k == 3 || ellipsoid -> interface == 0)
6255 // sprintf(buffer, "vertex %d xyz %e %e %e fixed curve %d fixed vertex %d\n", vertex_id,
6256 // crack -> pnt1.x, crack -> pnt1.y, crack -> pnt1.z, curve_id, crack_ver_id1);
6257 // else{
6258 // if(m == 1)
6259 // sprintf(buffer, "vertex %d xyz %e %e %e fixed curve %d fixed vertex %d\n", vertex_id,
6260 // crack -> pnt1.x, crack -> pnt1.y, crack -> pnt1.z, curve_id, vertex_id - 6);
6261 // else
6262 // sprintf(buffer, "vertex %d xyz %e %e %e fixed curve %d\n", vertex_id,
6263 // crack -> pnt1.x, crack -> pnt1.y, crack -> pnt1.z, curve_id);
6264 // }
6265 // write_record(t3d_in_file, t3d_in_file_name, buffer);
6266 // }
6267 //
6268 // if(k == 1 && m == 0){
6269 // if(ellipsoid -> interface == 0)
6270 // sprintf(buffer, " Vertex %d %d", crack_ver_id1 - vertices, crack_ver_id1);
6271 // else
6272 // sprintf(buffer, " Vertex %d %d Vertex %d %d",
6273 // vertex_id - vertices, vertex_id + vertices, crack_ver_id1, crack_ver_id1 + 2 * vertices);
6274 // write_record(ctrl_file, ctrl_file_name, buffer);
6275 // }
6276 //
6277 // vertex_id++;
6278 // if(skip == NO){
6279 // if(k == 1 || k == 3 || ellipsoid -> interface == 0)
6280 // sprintf(buffer, "vertex %d xyz %e %e %e fixed curve %d fixed vertex %d\n", vertex_id,
6281 // crack -> pnt2.x, crack -> pnt2.y, crack -> pnt2.z, curve_id, crack_ver_id2);
6282 // else{
6283 // if(m == 1)
6284 // sprintf(buffer, "vertex %d xyz %e %e %e fixed curve %d fixed vertex %d\n", vertex_id,
6285 // crack -> pnt2.x, crack -> pnt2.y, crack -> pnt2.z, curve_id, vertex_id - 6);
6286 // else
6287 // sprintf(buffer, "vertex %d xyz %e %e %e fixed curve %d\n", vertex_id,
6288 // crack -> pnt2.x, crack -> pnt2.y, crack -> pnt2.z, curve_id);
6289 // }
6290 // write_record(t3d_in_file, t3d_in_file_name, buffer);
6291 // }
6292 //
6293 // if(k == 1 && m == 0){
6294 // if(ellipsoid -> interface == 0)
6295 // sprintf(buffer, " Vertex %d %d", crack_ver_id2 - vertices, crack_ver_id2);
6296 // else
6297 // sprintf(buffer, " Vertex %d %d Vertex %d %d",
6298 // vertex_id - vertices, vertex_id + vertices, crack_ver_id2, crack_ver_id2 + 2 * vertices);
6299 // write_record(ctrl_file, ctrl_file_name, buffer);
6300 // }
6301 //
6302 // if(skip == NO)write_record(t3d_in_file, t3d_in_file_name, "\n");
6303 //
6304 // vertex_id++;
6305 // if(skip == NO){
6306 // sprintf(buffer, "vertex %d xyz %e %e %e fixed curve %d fixed vertex %d\n", vertex_id,
6307 // point[0].x, point[0].y, point[0].z, -crack_cur_id1, cross_ver_id1 + m);
6308 // write_record(t3d_in_file, t3d_in_file_name, buffer);
6309 // }
6310 //
6311 // vertex_id++;
6312 // if(skip == NO){
6313 // sprintf(buffer, "vertex %d xyz %e %e %e fixed curve %d fixed vertex %d\n", vertex_id,
6314 // point[1].x, point[1].y, point[1].z, -crack_cur_id3, cross_ver_id2 + m);
6315 // write_record(t3d_in_file, t3d_in_file_name, buffer);
6316 // }
6317 //
6318 // if(skip == NO)write_record(t3d_in_file, t3d_in_file_name, "\n");
6319 //
6320 // curve_id++;
6321 // if(skip == NO){
6322 // if(m == 1)
6323 // sprintf(buffer, "curve %d vertex %d %d fixed curve %d coincide curve %d\n", curve_id,
6324 // vertex_id - 3, vertex_id - 1, -crack_cur_id1, curve_id - 6);
6325 // else
6326 // sprintf(buffer, "curve %d vertex %d %d fixed curve %d\n", curve_id,
6327 // vertex_id - 3, vertex_id - 1, -crack_cur_id1);
6328 // write_record(t3d_in_file, t3d_in_file_name, buffer);
6329 // }
6330 //
6331 // if(k == 1){
6332 // if(ellipsoid -> interface == 0){
6333 // if(m == 0)
6334 // sprintf(buffer, " Curve %d %d", curve_id - curves, curve_id);
6335 // else
6336 // sprintf(buffer, " Curve %d %d", curve_id - curves - 6, curve_id);
6337 // }
6338 // else{
6339 // if(m == 0 || ellipsoid -> property == 0)
6340 // sprintf(buffer, " Curve %d %d Curve %d %d",
6341 // curve_id - curves, curve_id + curves, curve_id, curve_id + 2 * curves);
6342 // else
6343 // sprintf(buffer, " Curve %d %d", curve_id, curve_id + 2 * curves);
6344 // }
6345 // write_record(ctrl_file, ctrl_file_name, buffer);
6346 // }
6347 //
6348 // if(m == 0){
6349 // if(k == 0 || k == 1)crack_cur_id1a = curve_id;
6350 // }
6351 //
6352 // curve_id++;
6353 // if(skip == NO){
6354 // if(m == 1)
6355 // sprintf(buffer, "curve %d vertex %d %d fixed curve %d coincide curve %d\n", curve_id,
6356 // vertex_id - 1, vertex_id - 5, -crack_cur_id1, curve_id - 6);
6357 // else
6358 // sprintf(buffer, "curve %d vertex %d %d fixed curve %d\n", curve_id,
6359 // vertex_id - 1, vertex_id - 5, -crack_cur_id1);
6360 // write_record(t3d_in_file, t3d_in_file_name, buffer);
6361 // }
6362 //
6363 // if(k == 1){
6364 // if(ellipsoid -> interface == 0){
6365 // if(m == 0)
6366 // sprintf(buffer, " Curve %d %d", curve_id - curves, curve_id);
6367 // else
6368 // sprintf(buffer, " Curve %d %d", curve_id - curves - 6, curve_id);
6369 // }
6370 // else{
6371 // if(m == 0 || ellipsoid -> property == 0)
6372 // sprintf(buffer, " Curve %d %d Curve %d %d",
6373 // curve_id - curves, curve_id + curves, curve_id, curve_id + 2 * curves);
6374 // else
6375 // sprintf(buffer, " Curve %d %d", curve_id, curve_id + 2 * curves);
6376 // }
6377 // write_record(ctrl_file, ctrl_file_name, buffer);
6378 // }
6379 //
6380 // if(m == 0){
6381 // if(k == 0 || k == 1)crack_cur_id1b = curve_id;
6382 // }
6383 //
6384 // curve_id++;
6385 // if(skip == NO){
6386 // if(m == 1)
6387 // sprintf(buffer, "curve %d vertex %d %d fixed curve %d coincide curve %d\n", curve_id,
6388 // vertex_id - 4, vertex_id, -crack_cur_id3, curve_id - 6);
6389 // else
6390 // sprintf(buffer, "curve %d vertex %d %d fixed curve %d\n", curve_id,
6391 // vertex_id - 4, vertex_id, -crack_cur_id3);
6392 // write_record(t3d_in_file, t3d_in_file_name, buffer);
6393 // }
6394 //
6395 // if(k == 1){
6396 // if(ellipsoid -> interface == 0){
6397 // if(m == 0)
6398 // sprintf(buffer, " Curve %d %d", curve_id - curves, curve_id);
6399 // else
6400 // sprintf(buffer, " Curve %d %d", curve_id - curves - 6, curve_id);
6401 // }
6402 // else{
6403 // if(m == 0 || ellipsoid -> property == 0)
6404 // sprintf(buffer, " Curve %d %d Curve %d %d",
6405 // curve_id - curves, curve_id + curves, curve_id, curve_id + 2 * curves);
6406 // else
6407 // sprintf(buffer, " Curve %d %d", curve_id, curve_id + 2 * curves);
6408 // }
6409 // write_record(ctrl_file, ctrl_file_name, buffer);
6410 // }
6411 //
6412 // if(m == 0){
6413 // if(k == 0 || k == 1)crack_cur_id3a = curve_id;
6414 // }
6415 //
6416 // curve_id++;
6417 // if(skip == NO){
6418 // if(m == 1)
6419 // sprintf(buffer, "curve %d vertex %d %d fixed curve %d coincide curve %d\n", curve_id,
6420 // vertex_id, vertex_id - 2, -crack_cur_id3, curve_id - 6);
6421 // else
6422 // sprintf(buffer, "curve %d vertex %d %d fixed curve %d\n", curve_id,
6423 // vertex_id, vertex_id - 2, -crack_cur_id3);
6424 // write_record(t3d_in_file, t3d_in_file_name, buffer);
6425 // }
6426 //
6427 // if(k == 1){
6428 // if(ellipsoid -> interface == 0){
6429 // if(m == 0)
6430 // sprintf(buffer, " Curve %d %d", curve_id - curves, curve_id);
6431 // else
6432 // sprintf(buffer, " Curve %d %d", curve_id - curves - 6, curve_id);
6433 // }
6434 // else{
6435 // if(m == 0 || ellipsoid -> property == 0)
6436 // sprintf(buffer, " Curve %d %d Curve %d %d",
6437 // curve_id - curves, curve_id + curves, curve_id, curve_id + 2 * curves);
6438 // else
6439 // sprintf(buffer, " Curve %d %d", curve_id, curve_id + 2 * curves);
6440 // }
6441 // write_record(ctrl_file, ctrl_file_name, buffer);
6442 // }
6443 //
6444 // if(m == 0){
6445 // if(k == 0 || k == 1)crack_cur_id3b = curve_id;
6446 // }
6447 //
6448 // write_record(t3d_in_file, t3d_in_file_name, "\n");
6449 // }
6450 // break;
6451 // }
6452 // }
6453 //
6454 // /* note: it is essential to make all the shells (inclusion, matrix, inrerfaces) topologically identical !!!
6455 // since on non-empty inclusion shell curves must be fixed to the shell, it is necessary to
6456 // ensure the identity (in terms of mesh generation process) by carefull ordering of boundary curves
6457 // on remaining shells;
6458 // the other way would be to split the shell into two shells but that would make additional mesh constraint */
6459 //
6460 // shell_id++;
6461 // if((k == 0 || k == 2) && ellipsoid -> property != 0){
6462 // switch(contact_case){
6463 // case 0:
6464 // sprintf(buffer, "shell %d bgsurface %d boundary curve %d %d %d %d fixed curve %d %d\n", shell_id, surface_id - 1,
6465 // base_cur_id2b, base_cur_id1a, base_cur_id1b, base_cur_id2a, curve_id - 2, curve_id - 7);
6466 // break;
6467 // case 1:
6468 // case 2:
6469 // case 3:
6470 // sprintf(buffer, "shell %d bgsurface %d boundary curve %d %d %d fixed curve %d\n", shell_id, surface_id - 1,
6471 // base_cur_id1b, base_cur_id2, base_cur_id1a, curve_id - 3);
6472 // break;
6473 // case 4:
6474 // if(intersect == 1){
6475 // if(first_curve == YES)
6476 // sprintf(buffer, "shell %d bgsurface %d boundary curve %d %d %d fixed curve %d\n", shell_id, surface_id - 1,
6477 // base_cur_id1b, base_cur_id2, base_cur_id1a, curve_id - 7);
6478 // else
6479 // sprintf(buffer, "shell %d bgsurface %d boundary curve %d %d %d fixed curve %d %d\n", shell_id, surface_id - 1,
6480 // base_cur_id1b, base_cur_id2, base_cur_id1a, curve_id - 7, curve_id - 6);
6481 // }
6482 // else
6483 // sprintf(buffer, "shell %d bgsurface %d boundary curve %d %d %d %d fixed curve %d %d\n", shell_id, surface_id - 1,
6484 // base_cur_id2b, base_cur_id1a, base_cur_id1b, base_cur_id2a, curve_id - 6, curve_id - 9);
6485 // break;
6486 // case 5:
6487 // sprintf(buffer, "shell %d bgsurface %d boundary curve %d %d %d %d fixed curve %d %d\n", shell_id, surface_id - 1,
6488 // base_cur_id2b, base_cur_id1a, base_cur_id1b, base_cur_id2a, curve_id - 6, curve_id - 9);
6489 // break;
6490 // }
6491 // }
6492 // else{
6493 // switch(contact_case){
6494 // case 0:
6495 // sprintf(buffer, "shell %d bgsurface %d boundary curve %d %d %d %d %d %d %d %d\n", shell_id, surface_id - 1,
6496 // base_cur_id2b, base_cur_id1a, base_cur_id1b, base_cur_id2a, curve_id, curve_id - 5, -(curve_id - 2),
6497 // -(curve_id - 7));
6498 // break;
6499 // case 1:
6500 // case 2:
6501 // case 3:
6502 // sprintf(buffer, "shell %d bgsurface %d boundary curve %d %d %d %d %d\n", shell_id, surface_id - 1,
6503 // base_cur_id1b, base_cur_id2, base_cur_id1a, -(curve_id - 3), curve_id - 1);
6504 // break;
6505 // case 4:
6506 // if(intersect == 1){
6507 // if(first_curve == YES)
6508 // sprintf(buffer, "shell %d bgsurface %d boundary curve %d %d %d %d %d\n", shell_id, surface_id - 1,
6509 // base_cur_id1b, base_cur_id2, base_cur_id1a, -(curve_id - 7), curve_id - 2);
6510 // else
6511 // sprintf(buffer, "shell %d bgsurface %d boundary curve %d %d %d %d %d %d %d\n", shell_id, surface_id - 1,
6512 // base_cur_id1b, base_cur_id2, base_cur_id1a, -(curve_id - 7), -(curve_id - 6), curve_id - 2, curve_id - 1);
6513 // }
6514 // else
6515 // sprintf(buffer, "shell %d bgsurface %d boundary curve %d %d %d %d %d %d %d %d\n", shell_id, surface_id - 1,
6516 // base_cur_id2b, base_cur_id1a, base_cur_id1b, base_cur_id2a, -(curve_id - 6), -(curve_id - 9),
6517 // curve_id, curve_id - 3);
6518 // break;
6519 // case 5:
6520 // sprintf(buffer, "shell %d bgsurface %d boundary curve %d %d %d %d %d %d %d %d\n", shell_id, surface_id - 1,
6521 // base_cur_id2b, base_cur_id1a, base_cur_id1b, base_cur_id2a, -(curve_id - 6), -(curve_id - 9),
6522 // curve_id, curve_id - 3);
6523 // break;
6524 // }
6525 // }
6526 // write_record(t3d_in_file, t3d_in_file_name, buffer);
6527 //
6528 // if(k == 1){
6529 // if(ellipsoid -> interface == 0)
6530 // sprintf(buffer, " Shell %d %d", shell_id - shells, shell_id);
6531 // else
6532 // sprintf(buffer, " Shell %d %d Shell %d %d",
6533 // shell_id - shells, shell_id + shells, shell_id, shell_id + 2 * shells);
6534 // write_record(ctrl_file, ctrl_file_name, buffer);
6535 // }
6536 // if(k == 2){
6537 // sprintf(buffer, " Shell %d %d", shell_id + shells, shell_id);
6538 // write_record(ctrl_file, ctrl_file_name, buffer);
6539 // }
6540 //
6541 // shell_id++;
6542 // if((k == 0 || k == 2) && ellipsoid -> property != 0){
6543 // switch(contact_case){
6544 // case 0:
6545 // sprintf(buffer, "shell %d bgsurface %d boundary curve %d %d %d %d fixed curve %d %d\n", shell_id, surface_id,
6546 // base_cur_id1b, base_cur_id2a, base_cur_id2b, base_cur_id1a, curve_id - 6, curve_id - 3);
6547 // break;
6548 // case 1:
6549 // case 2:
6550 // case 3:
6551 // sprintf(buffer, "shell %d bgsurface %d boundary curve %d %d %d fixed curve %d\n", shell_id, surface_id,
6552 // base_cur_id1b, base_cur_id2, base_cur_id1a, curve_id - 2);
6553 // break;
6554 // case 4:
6555 // if(intersect == 1){
6556 // if(first_curve == YES)
6557 // sprintf(buffer, "shell %d bgsurface %d boundary curve %d %d %d fixed curve %d %d\n", shell_id, surface_id,
6558 // base_cur_id1b, base_cur_id2, base_cur_id1a, curve_id - 6, curve_id - 5);
6559 // else
6560 // sprintf(buffer, "shell %d bgsurface %d boundary curve %d %d %d fixed curve %d\n", shell_id, surface_id,
6561 // base_cur_id1b, base_cur_id2, base_cur_id1a, curve_id - 5);
6562 // }
6563 // else
6564 // sprintf(buffer, "shell %d bgsurface %d boundary curve %d %d %d %d fixed curve %d %d\n", shell_id, surface_id,
6565 // base_cur_id1b, base_cur_id2a, base_cur_id2b, base_cur_id1a, curve_id - 8, curve_id - 7);
6566 // break;
6567 // case 5:
6568 // sprintf(buffer, "shell %d bgsurface %d boundary curve %d %d %d %d fixed curve %d %d %d\n", shell_id, surface_id,
6569 // base_cur_id1b, base_cur_id2a, base_cur_id2b, base_cur_id1a, curve_id - 8, curve_id - 11, curve_id - 7);
6570 // break;
6571 // }
6572 // }
6573 // else{
6574 // switch(contact_case){
6575 // case 0:
6576 // sprintf(buffer, "shell %d bgsurface %d boundary curve %d %d %d %d %d %d %d %d\n", shell_id, surface_id,
6577 // base_cur_id1b, base_cur_id2a, base_cur_id2b, base_cur_id1a, curve_id - 6, curve_id - 3, -(curve_id - 4),
6578 // -(curve_id - 1));
6579 // break;
6580 // case 1:
6581 // case 2:
6582 // case 3:
6583 // sprintf(buffer, "shell %d bgsurface %d boundary curve %d %d %d %d %d\n", shell_id, surface_id,
6584 // base_cur_id1b, base_cur_id2, base_cur_id1a, curve_id - 2, -curve_id);
6585 // break;
6586 // case 4:
6587 // if(intersect == 1){
6588 // if(first_curve == YES)
6589 // sprintf(buffer, "shell %d bgsurface %d boundary curve %d %d %d %d %d %d %d\n", shell_id, surface_id,
6590 // base_cur_id1b, base_cur_id2, base_cur_id1a, curve_id - 6, curve_id - 5, -(curve_id - 1), -curve_id);
6591 // else
6592 // sprintf(buffer, "shell %d bgsurface %d boundary curve %d %d %d %d %d\n", shell_id, surface_id,
6593 // base_cur_id1b, base_cur_id2, base_cur_id1a, curve_id - 5, -curve_id);
6594 // }
6595 // else
6596 // sprintf(buffer, "shell %d bgsurface %d boundary curve %d %d %d %d %d %d %d %d\n", shell_id, surface_id,
6597 // base_cur_id1b, base_cur_id2a, base_cur_id2b, base_cur_id1a, curve_id - 8, curve_id - 7, -(curve_id - 2),
6598 // -(curve_id - 1));
6599 // break;
6600 // case 5:
6601 // sprintf(buffer, "shell %d bgsurface %d boundary curve %d %d %d %d %d %d %d %d %d %d\n", shell_id, surface_id,
6602 // base_cur_id1b, base_cur_id2a, base_cur_id2b, base_cur_id1a, curve_id - 8, curve_id - 11, curve_id - 7,
6603 // -(curve_id - 2), -(curve_id - 5), -(curve_id - 1));
6604 // break;
6605 // }
6606 // }
6607 // write_record(t3d_in_file, t3d_in_file_name, buffer);
6608 //
6609 // if(k == 1){
6610 // if(ellipsoid -> interface == 0)
6611 // sprintf(buffer, " Shell %d %d", shell_id - shells, shell_id);
6612 // else
6613 // sprintf(buffer, " Shell %d %d Shell %d %d",
6614 // shell_id - shells, shell_id + shells, shell_id, shell_id + 2 * shells);
6615 // write_record(ctrl_file, ctrl_file_name, buffer);
6616 // }
6617 // if(k == 2){
6618 // sprintf(buffer, " Shell %d %d", shell_id, shell_id + shells);
6619 // write_record(ctrl_file, ctrl_file_name, buffer);
6620 // }
6621 //
6622 // write_record(t3d_in_file, t3d_in_file_name, "\n");
6623 //
6624 // if(k == 0){
6625 // region_id++;
6626 // if(ellipsoid -> property == 0)
6627 // sprintf(tmp_buffer, "region %d boundary shell %d %d", region_id, shell_id - 1, -shell_id);
6628 // else{
6629 // /* sprintf(buffer, "Region %d\nElemType %d\n", region_id, ellipsoid -> property); */
6630 // sprintf(buffer, "Region %d\nTetraType %d\n", region_id, ellipsoid -> property);
6631 // write_record(ctrl_file, ctrl_file_name, buffer);
6632 //
6633 // if(imsz == 0.0){
6634 // default_msz = YES;
6635 // sprintf(buffer, "region %d boundary shell %d %d size def property %d\n\n", region_id,
6636 // shell_id - 1, -shell_id, ellipsoid -> property);
6637 // }
6638 // else
6639 // sprintf(buffer, "region %d boundary shell %d %d size %e property %d\n\n", region_id,
6640 // shell_id - 1, -shell_id, imsz, ellipsoid -> property);
6641 // write_record(t3d_in_file, t3d_in_file_name, buffer);
6642 // }
6643 //
6644 // if(ellipsoid -> interface == 0){
6645 //
6646 // #ifdef MERLIN
6647 // if(ellipsoid -> property == prop || ellipsoid -> property == 0){
6648 // ellipsoid -> region = region_id;
6649 // break;
6650 // }
6651 // #else
6652 // ellipsoid -> region = region_id;
6653 // break;
6654 // #endif
6655 //
6656 // }
6657 // else{
6658 // if(ellipsoid -> bc != 0){
6659 // bc = YES;
6660 // sprintf(ellipsoid -> bc_ellipsoid_spec, "#Shell %d %d\n", shell_id - 1, shell_id);
6661 // sprintf(ellipsoid -> bc_matrix_spec, "#Shell %d %d\n", shell_id - 1 + shells, shell_id + shells);
6662 // }
6663 // }
6664 // }
6665 //
6666 // if(k == 1){
6667 // region_id++;
6668 // sprintf(tmp_buffer, "region %d boundary shell %d %d", region_id, shell_id - 1, -shell_id);
6669 // ellipsoid -> region = region_id;
6670 // }
6671 //
6672 // if(k == 1 || k == 2)write_record(ctrl_file, ctrl_file_name, "\n");
6673 //
6674 // #ifdef MERLIN
6675 // if(k == 1 && ellipsoid -> interface == 0)break;
6676 // #else
6677 // if(k == 1)break;
6678 // #endif
6679 //
6680 // }
6681 //
6682 // if(ellipsoid -> interface != 0){
6683 // if(crack -> segment == YES){
6684 // iface_crack_ver_id1 = crack_ver_id1;
6685 // iface_crack_ver_id2 = crack_ver_id2;
6686 //
6687 // crack_ver_id1 -= 2 * vertices;
6688 // crack_ver_id2 -= 2 * vertices;
6689 // }
6690 //
6691 // switch(contact_case){
6692 // case 5:
6693 // if(crack_cur_id3 > 0)
6694 // iface_crack_cur_id3 = crack_cur_id3 + 2 * curves;
6695 // else{
6696 // iface_crack_cur_id3a = crack_cur_id3a + 2 * curves;
6697 // iface_crack_cur_id3b = crack_cur_id3b + 2 * curves;
6698 // }
6699 // case 4:
6700 // case 0:
6701 // if(crack_cur_id2 > 0)
6702 // iface_crack_cur_id2 = crack_cur_id2 + 2 * curves;
6703 // else{
6704 // iface_crack_cur_id2a = crack_cur_id2a + 2 * curves;
6705 // iface_crack_cur_id2b = crack_cur_id2b + 2 * curves;
6706 // }
6707 // case 3:
6708 // case 2:
6709 // case 1:
6710 // if(crack_cur_id1 > 0)
6711 // iface_crack_cur_id1 = crack_cur_id1 + 2 * curves;
6712 // else{
6713 // iface_crack_cur_id1a = crack_cur_id1a + 2 * curves;
6714 // iface_crack_cur_id1b = crack_cur_id1b + 2 * curves;
6715 // }
6716 // }
6717 // }
6718 // else{
6719 // if(ellipsoid -> property != 0 && ellipsoid -> property != prop){
6720 // cross_ver_id1 -= vertices;
6721 // cross_ver_id2 -= vertices;
6722 // }
6723 // }
6724 //
6725 // if(ellipsoid -> interface == 0 && crack -> interface != 0){
6726 //
6727 // /* make contact for crack interface;
6728 // this is always modelled by pair(s) of curves to prevent high degeneration of crack
6729 // interface elements */
6730 //
6731 // sprintf(buffer, "# crack contact interface\n\n");
6732 // write_record(t3d_in_file, t3d_in_file_name, buffer);
6733 //
6734 // sprintf(buffer, "MasterSlave");
6735 // write_record(ctrl_file, ctrl_file_name, buffer);
6736 //
6737 // if(crack -> segment == NO){
6738 // for(m = 0; m < 2; m++){
6739 // for(i = 0; i < 2; i++){
6740 // vertex_id++;
6741 // j = 2 * i;
6742 // if(cmsz == 0.0){
6743 // default_msz = YES;
6744 // sprintf(buffer, "vertex %d xyz %e %e %e\n", vertex_id,
6745 // contact_glob_point[j].x, contact_glob_point[j].y, contact_glob_point[j].z);
6746 // }
6747 // else
6748 // sprintf(buffer, "vertex %d xyz %e %e %e size %e\n", vertex_id,
6749 // contact_glob_point[j].x, contact_glob_point[j].y, contact_glob_point[j].z, cmsz);
6750 // write_record(t3d_in_file, t3d_in_file_name, buffer);
6751 //
6752 // if(ellipsoid -> property != 0 && ellipsoid -> property != prop){
6753 // if(m == 0)
6754 // sprintf(buffer, " Vertex %d %d", vertex_id - 2 * vertices + 10, vertex_id);
6755 // else
6756 // sprintf(buffer, " Vertex %d %d", vertex_id - 2 * vertices + 8, vertex_id);
6757 // }
6758 // else{
6759 // if(m == 0 || ellipsoid -> property == 0)
6760 // sprintf(buffer, " Vertex %d %d", vertex_id - vertices + 10, vertex_id);
6761 // else
6762 // sprintf(buffer, " Vertex %d %d", vertex_id - vertices + 8, vertex_id);
6763 // }
6764 // write_record(ctrl_file, ctrl_file_name, buffer);
6765 //
6766 // if(m == 0){
6767 // if(i == 0)iface_crack_ver_id1 = vertex_id;
6768 // if(i == 1)iface_crack_ver_id2 = vertex_id;
6769 // }
6770 // }
6771 //
6772 // write_record(t3d_in_file, t3d_in_file_name, "\n");
6773 //
6774 // for(i = 0; i < 2; i++){
6775 // curve_id++;
6776 // sprintf(buffer, "curve %d order 4 vertex %d %d virtual\n", curve_id, vertex_id - 1 + i, vertex_id - i);
6777 // write_record(t3d_in_file, t3d_in_file_name, buffer);
6778 //
6779 // for(j = 0; j < 2; j++){
6780 // n = 2 * i + j;
6781 // if(cmsz == 0.0){
6782 // default_msz = YES;
6783 // sprintf(buffer, "polygon %d xyz %e %e %e weight %e\n", j + 1,
6784 // contact_glob_pnt[n].x, contact_glob_pnt[n].y, contact_glob_pnt[n].z, weight_h);
6785 // }
6786 // else
6787 // sprintf(buffer, "polygon %d xyz %e %e %e weight %e size %e\n", j + 1,
6788 // contact_glob_pnt[n].x, contact_glob_pnt[n].y, contact_glob_pnt[n].z, weight_h, cmsz);
6789 // write_record(t3d_in_file, t3d_in_file_name, buffer);
6790 // }
6791 //
6792 // if(m == 0){
6793 // if(i == 0)iface_crack_cur_id1 = -curve_id;
6794 // if(i == 1)iface_crack_cur_id2 = -curve_id;
6795 // }
6796 // }
6797 //
6798 // write_record(t3d_in_file, t3d_in_file_name, "\n");
6799 // }
6800 //
6801 // for(i = 0; i < intersect; i++){
6802 // for(m = 0; m < 2; m++){
6803 // vertex_id++;
6804 // sprintf(buffer, "vertex %d xyz %e %e %e fixed curve %d\n", vertex_id,
6805 // point[i].x, point[i].y, point[i].z, -iface_crack_cur_id1 + i + 2 * m);
6806 // write_record(t3d_in_file, t3d_in_file_name, buffer);
6807 //
6808 // if(i == 0){
6809 // if(m == 0 || ellipsoid -> property == 0)
6810 // sprintf(buffer, " Vertex %d %d", cross_ver_id1 + m, vertex_id);
6811 // else
6812 // sprintf(buffer, " Vertex %d %d", cross_ver_id1, vertex_id);
6813 // }
6814 // else{
6815 // if(m == 0 || ellipsoid -> property == 0)
6816 // sprintf(buffer, " Vertex %d %d", cross_ver_id2 + m, vertex_id);
6817 // else
6818 // sprintf(buffer, " Vertex %d %d", cross_ver_id2, vertex_id);
6819 // }
6820 // write_record(ctrl_file, ctrl_file_name, buffer);
6821 //
6822 // write_record(t3d_in_file, t3d_in_file_name, "\n");
6823 //
6824 // curve_id++;
6825 // sprintf(buffer, "curve %d vertex %d %d fixed curve %d\n", curve_id,
6826 // iface_crack_ver_id1 + i + 2 * m, vertex_id, -iface_crack_cur_id1 + i + 2 * m);
6827 // write_record(t3d_in_file, t3d_in_file_name, buffer);
6828 //
6829 // if(ellipsoid -> property != 0 && ellipsoid -> property != prop){
6830 // if(m == 0)
6831 // sprintf(buffer, " Curve %d %d", curve_id - 2 * curves + 8, curve_id);
6832 // else
6833 // sprintf(buffer, " Curve %d %d", curve_id - 2 * curves + 6, curve_id);
6834 // }
6835 // else{
6836 // if(m == 0 || ellipsoid -> property == 0)
6837 // sprintf(buffer, " Curve %d %d", curve_id - curves + 8, curve_id);
6838 // else
6839 // sprintf(buffer, " Curve %d %d", curve_id - curves + 6, curve_id);
6840 // }
6841 // write_record(ctrl_file, ctrl_file_name, buffer);
6842 //
6843 // if(m == 0){
6844 // if(i == 0)iface_crack_cur_id1a = curve_id;
6845 // if(i == 1)iface_crack_cur_id2a = curve_id;
6846 // }
6847 //
6848 // curve_id++;
6849 // sprintf(buffer, "curve %d vertex %d %d fixed curve %d\n", curve_id,
6850 // vertex_id, iface_crack_ver_id2 - i + 2 * m, -iface_crack_cur_id1 + i + 2 * m);
6851 // write_record(t3d_in_file, t3d_in_file_name, buffer);
6852 //
6853 // if(ellipsoid -> property != 0 && ellipsoid -> property != prop){
6854 // if(m == 0)
6855 // sprintf(buffer, " Curve %d %d", curve_id - 2 * curves + 8, curve_id);
6856 // else
6857 // sprintf(buffer, " Curve %d %d", curve_id - 2 * curves + 6, curve_id);
6858 // }
6859 // else{
6860 // if(m == 0 || ellipsoid -> property == 0)
6861 // sprintf(buffer, " Curve %d %d", curve_id - curves + 8, curve_id);
6862 // else
6863 // sprintf(buffer, " Curve %d %d", curve_id - curves + 6, curve_id);
6864 // }
6865 // write_record(ctrl_file, ctrl_file_name, buffer);
6866 //
6867 // if(m == 0){
6868 // if(i == 0)iface_crack_cur_id1b = curve_id;
6869 // if(i == 1)iface_crack_cur_id2b = curve_id;
6870 // }
6871 //
6872 // write_record(t3d_in_file, t3d_in_file_name, "\n");
6873 // }
6874 // }
6875 // }
6876 // else{
6877 // vertex_id++;
6878 // if(tmsz == 0.0){
6879 // default_msz = YES;
6880 // sprintf(buffer, "vertex %d xyz %e %e %e\n", vertex_id,
6881 // crack -> pnt1.x, crack -> pnt1.y, crack -> pnt1.z);
6882 // }
6883 // else
6884 // sprintf(buffer, "vertex %d xyz %e %e %e size %e\n", vertex_id,
6885 // crack -> pnt1.x, crack -> pnt1.y, crack -> pnt1.z, tmsz);
6886 // write_record(t3d_in_file, t3d_in_file_name, buffer);
6887 // iface_crack_ver_id1 = vertex_id;
6888 //
6889 // if(ellipsoid -> property != 0 && ellipsoid -> property != prop)
6890 // sprintf(buffer, " Vertex %d %d", crack_ver_id1 - vertices, iface_crack_ver_id1);
6891 // else
6892 // sprintf(buffer, " Vertex %d %d", crack_ver_id1, iface_crack_ver_id1);
6893 // write_record(ctrl_file, ctrl_file_name, buffer);
6894 //
6895 // vertex_id++;
6896 // if(tmsz == 0.0){
6897 // default_msz = YES;
6898 // sprintf(buffer, "vertex %d xyz %e %e %e\n", vertex_id,
6899 // crack -> pnt2.x, crack -> pnt2.y, crack -> pnt2.z);
6900 // }
6901 // else
6902 // sprintf(buffer, "vertex %d xyz %e %e %e size %e\n", vertex_id,
6903 // crack -> pnt2.x, crack -> pnt2.y, crack -> pnt2.z, tmsz);
6904 // write_record(t3d_in_file, t3d_in_file_name, buffer);
6905 // iface_crack_ver_id2 = vertex_id;
6906 //
6907 // if(ellipsoid -> property != 0 && ellipsoid -> property != prop)
6908 // sprintf(buffer, " Vertex %d %d", crack_ver_id2 - vertices, iface_crack_ver_id2);
6909 // else
6910 // sprintf(buffer, " Vertex %d %d", crack_ver_id2, iface_crack_ver_id2);
6911 // write_record(ctrl_file, ctrl_file_name, buffer);
6912 //
6913 // write_record(t3d_in_file, t3d_in_file_name, "\n");
6914 //
6915 // switch(contact_case){
6916 // case 1:
6917 // vertex_id++;
6918 // if(fixed_a == NO){
6919 // j = crack -> qa - 1;
6920 // if(bmsz == 0.0){
6921 // default_msz = YES;
6922 // sprintf(buffer, "vertex %d xyz %e %e %e virtual\n", vertex_id,
6923 // contact_glob_point[j].x, contact_glob_point[j].y, contact_glob_point[j].z);
6924 // }
6925 // else
6926 // sprintf(buffer, "vertex %d xyz %e %e %e size %e virtual\n", vertex_id,
6927 // contact_glob_point[j].x, contact_glob_point[j].y, contact_glob_point[j].z, bmsz);
6928 // }
6929 // else{
6930 // if(bmsz == 0.0){
6931 // default_msz = YES;
6932 // sprintf(buffer, "vertex %d fixed vertex %d size def\n", vertex_id, iface_crack_ver_id1);
6933 // }
6934 // else
6935 // sprintf(buffer, "vertex %d fixed vertex %d size %e\n", vertex_id, iface_crack_ver_id1, bmsz);
6936 // }
6937 // write_record(t3d_in_file, t3d_in_file_name, buffer);
6938 //
6939 // vertex_id++;
6940 // if(fixed_b == NO){
6941 // if((j = crack -> qa) >= 4)j -= 4;
6942 // if(bmsz == 0.0){
6943 // default_msz = YES;
6944 // sprintf(buffer, "vertex %d xyz %e %e %e virtual\n", vertex_id,
6945 // contact_glob_point[j].x, contact_glob_point[j].y, contact_glob_point[j].z);
6946 // }
6947 // else
6948 // sprintf(buffer, "vertex %d xyz %e %e %e size %e virtual\n", vertex_id,
6949 // contact_glob_point[j].x, contact_glob_point[j].y, contact_glob_point[j].z, bmsz);
6950 // }
6951 // else{
6952 // if(bmsz == 0.0){
6953 // default_msz = YES;
6954 // sprintf(buffer, "vertex %d fixed vertex %d size def\n", vertex_id, iface_crack_ver_id2);
6955 // }
6956 // else
6957 // sprintf(buffer, "vertex %d fixed vertex %d size %e\n", vertex_id, iface_crack_ver_id2, bmsz);
6958 // }
6959 // write_record(t3d_in_file, t3d_in_file_name, buffer);
6960 //
6961 // write_record(t3d_in_file, t3d_in_file_name, "\n");
6962 //
6963 // j = crack -> qa - 1;
6964 // curve_id++;
6965 // sprintf(buffer, "curve %d order 3 vertex %d %d virtual\n", curve_id, vertex_id - 1, vertex_id);
6966 // write_record(t3d_in_file, t3d_in_file_name, buffer);
6967 // if(bmsz == 0.0){
6968 // default_msz = YES;
6969 // sprintf(buffer, "polygon 1 xyz %e %e %e weight %e\n",
6970 // contact_glob_pnt[j].x, contact_glob_pnt[j].y, contact_glob_pnt[j].z, weight_q);
6971 // }
6972 // else
6973 // sprintf(buffer, "polygon 1 xyz %e %e %e weight %e size %e\n",
6974 // contact_glob_pnt[j].x, contact_glob_pnt[j].y, contact_glob_pnt[j].z, weight_q, bmsz);
6975 // write_record(t3d_in_file, t3d_in_file_name, buffer);
6976 // iface_crack_cur_id1 = -curve_id;
6977 //
6978 // write_record(t3d_in_file, t3d_in_file_name, "\n");
6979 //
6980 // vertex_id++;
6981 // if(fixed_a == NO)
6982 // sprintf(buffer, "vertex %d xyz %e %e %e fixed curve %d fixed vertex %d\n", vertex_id,
6983 // crack -> pnt1.x, crack -> pnt1.y, crack -> pnt1.z, curve_id, iface_crack_ver_id1);
6984 // else
6985 // sprintf(buffer, "vertex %d fixed vertex %d\n", vertex_id, vertex_id - 2);
6986 // write_record(t3d_in_file, t3d_in_file_name, buffer);
6987 //
6988 // vertex_id++;
6989 // if(fixed_b == NO)
6990 // sprintf(buffer, "vertex %d xyz %e %e %e fixed curve %d fixed vertex %d\n", vertex_id,
6991 // crack -> pnt2.x, crack -> pnt2.y, crack -> pnt2.z, curve_id, iface_crack_ver_id2);
6992 // else
6993 // sprintf(buffer, "vertex %d fixed vertex %d\n", vertex_id, vertex_id - 2);
6994 // write_record(t3d_in_file, t3d_in_file_name, buffer);
6995 //
6996 // write_record(t3d_in_file, t3d_in_file_name, "\n");
6997 //
6998 // vertex_id++;
6999 // sprintf(buffer, "vertex %d xyz %e %e %e fixed curve %d\n", vertex_id,
7000 // point[0].x, point[0].y, point[0].z, curve_id);
7001 // write_record(t3d_in_file, t3d_in_file_name, buffer);
7002 //
7003 // sprintf(buffer, " Vertex %d %d", cross_ver_id1, vertex_id);
7004 // write_record(ctrl_file, ctrl_file_name, buffer);
7005 //
7006 // vertex_id++;
7007 // sprintf(buffer, "vertex %d xyz %e %e %e fixed curve %d\n", vertex_id,
7008 // point[0].x, point[0].y, point[0].z, curve_id);
7009 // write_record(t3d_in_file, t3d_in_file_name, buffer);
7010 //
7011 // if(ellipsoid -> property == 0)
7012 // sprintf(buffer, " Vertex %d %d", cross_ver_id1 + 1, vertex_id);
7013 // else
7014 // sprintf(buffer, " Vertex %d %d", cross_ver_id1, vertex_id);
7015 // write_record(ctrl_file, ctrl_file_name, buffer);
7016 //
7017 // write_record(t3d_in_file, t3d_in_file_name, "\n");
7018 //
7019 // curve_id++;
7020 // sprintf(buffer, "curve %d vertex %d %d fixed curve %d\n", curve_id,
7021 // vertex_id - 3, vertex_id - 1, -iface_crack_cur_id1);
7022 // write_record(t3d_in_file, t3d_in_file_name, buffer);
7023 // iface_crack_cur_id1a = curve_id;
7024 //
7025 // if(ellipsoid -> property != 0 && ellipsoid -> property != prop)
7026 // sprintf(buffer, " Curve %d %d", curve_id - 2 * curves + 6, curve_id);
7027 // else
7028 // sprintf(buffer, " Curve %d %d", curve_id - curves + 6, curve_id);
7029 // write_record(ctrl_file, ctrl_file_name, buffer);
7030 //
7031 // curve_id++;
7032 // sprintf(buffer, "curve %d vertex %d %d fixed curve %d\n", curve_id,
7033 // vertex_id - 1, vertex_id - 2, -iface_crack_cur_id1);
7034 // write_record(t3d_in_file, t3d_in_file_name, buffer);
7035 // iface_crack_cur_id1b = curve_id;
7036 //
7037 // if(ellipsoid -> property != 0 && ellipsoid -> property != prop)
7038 // sprintf(buffer, " Curve %d %d", curve_id - 2 * curves + 6, curve_id);
7039 // else
7040 // sprintf(buffer, " Curve %d %d", curve_id - curves + 6, curve_id);
7041 // write_record(ctrl_file, ctrl_file_name, buffer);
7042 //
7043 // curve_id++;
7044 // sprintf(buffer, "curve %d vertex %d %d fixed curve %d\n", curve_id,
7045 // vertex_id - 3, vertex_id, -iface_crack_cur_id1);
7046 // write_record(t3d_in_file, t3d_in_file_name, buffer);
7047 //
7048 // if(ellipsoid -> property == 0)
7049 // sprintf(buffer, " Curve %d %d", curve_id - curves + 6, curve_id);
7050 // else{
7051 // if(ellipsoid -> property != 0 && ellipsoid -> property != prop)
7052 // sprintf(buffer, " Curve %d %d", curve_id - 2 * curves + 4, curve_id);
7053 // else
7054 // sprintf(buffer, " Curve %d %d", curve_id - curves + 4, curve_id);
7055 // }
7056 // write_record(ctrl_file, ctrl_file_name, buffer);
7057 //
7058 // curve_id++;
7059 // sprintf(buffer, "curve %d vertex %d %d fixed curve %d\n", curve_id,
7060 // vertex_id, vertex_id - 2, -iface_crack_cur_id1);
7061 // write_record(t3d_in_file, t3d_in_file_name, buffer);
7062 //
7063 // if(ellipsoid -> property == 0)
7064 // sprintf(buffer, " Curve %d %d", curve_id - curves + 6, curve_id);
7065 // else{
7066 // if(ellipsoid -> property != 0 && ellipsoid -> property != prop)
7067 // sprintf(buffer, " Curve %d %d", curve_id - 2 * curves + 4, curve_id);
7068 // else
7069 // sprintf(buffer, " Curve %d %d", curve_id - curves + 4, curve_id);
7070 // }
7071 // write_record(ctrl_file, ctrl_file_name, buffer);
7072 //
7073 // write_record(t3d_in_file, t3d_in_file_name, "\n");
7074 // break;
7075 //
7076 // case 2:
7077 // vertex_id++;
7078 // if(fixed_a == NO){
7079 // j = crack -> qa - 1;
7080 // if(bmsz == 0.0){
7081 // default_msz = YES;
7082 // sprintf(buffer, "vertex %d xyz %e %e %e virtual\n", vertex_id,
7083 // contact_glob_point[j].x, contact_glob_point[j].y, contact_glob_point[j].z);
7084 // }
7085 // else
7086 // sprintf(buffer, "vertex %d xyz %e %e %e size %e virtual\n", vertex_id,
7087 // contact_glob_point[j].x, contact_glob_point[j].y, contact_glob_point[j].z, bmsz);
7088 // }
7089 // else{
7090 // if(bmsz == 0.0){
7091 // default_msz = YES;
7092 // sprintf(buffer, "vertex %d fixed vertex %d size def\n", vertex_id, iface_crack_ver_id1);
7093 // }
7094 // else
7095 // sprintf(buffer, "vertex %d fixed vertex %d size %e\n", vertex_id, iface_crack_ver_id1, bmsz);
7096 // }
7097 // write_record(t3d_in_file, t3d_in_file_name, buffer);
7098 //
7099 // vertex_id++;
7100 // if(fixed_b == NO){
7101 // if((j = crack -> qa + 1) >= 4)j -= 4;
7102 // if(bmsz == 0.0){
7103 // default_msz = YES;
7104 // sprintf(buffer, "vertex %d xyz %e %e %e virtual\n", vertex_id,
7105 // contact_glob_point[j].x, contact_glob_point[j].y, contact_glob_point[j].z);
7106 // }
7107 // else
7108 // sprintf(buffer, "vertex %d xyz %e %e %e size %e virtual\n", vertex_id,
7109 // contact_glob_point[j].x, contact_glob_point[j].y, contact_glob_point[j].z, bmsz);
7110 // }
7111 // else{
7112 // if(bmsz == 0.0){
7113 // default_msz = YES;
7114 // sprintf(buffer, "vertex %d fixed vertex %d size def\n", vertex_id, iface_crack_ver_id2);
7115 // }
7116 // else
7117 // sprintf(buffer, "vertex %d fixed vertex %d size %e\n", vertex_id, iface_crack_ver_id2, bmsz);
7118 // }
7119 // write_record(t3d_in_file, t3d_in_file_name, buffer);
7120 //
7121 // write_record(t3d_in_file, t3d_in_file_name, "\n");
7122 //
7123 // curve_id++;
7124 // sprintf(buffer, "curve %d order 4 vertex %d %d virtual\n", curve_id, vertex_id - 1, vertex_id);
7125 // write_record(t3d_in_file, t3d_in_file_name, buffer);
7126 // for(i = 0; i < 2; i++){
7127 // if((j = crack -> qa - 1 + i) >= 4)j -= 4;
7128 // if(bmsz == 0.0){
7129 // default_msz = YES;
7130 // sprintf(buffer, "polygon %d xyz %e %e %e weight %e\n", i + 1,
7131 // contact_glob_pnt[j].x, contact_glob_pnt[j].y, contact_glob_pnt[j].z, weight_h);
7132 // }
7133 // else
7134 // sprintf(buffer, "polygon %d xyz %e %e %e weight %e size %e\n", i + 1,
7135 // contact_glob_pnt[j].x, contact_glob_pnt[j].y, contact_glob_pnt[j].z, weight_h, bmsz);
7136 // write_record(t3d_in_file, t3d_in_file_name, buffer);
7137 // }
7138 // iface_crack_cur_id1 = -curve_id;
7139 //
7140 // write_record(t3d_in_file, t3d_in_file_name, "\n");
7141 //
7142 // vertex_id++;
7143 // if(fixed_a == NO)
7144 // sprintf(buffer, "vertex %d xyz %e %e %e fixed curve %d fixed vertex %d\n", vertex_id,
7145 // crack -> pnt1.x, crack -> pnt1.y, crack -> pnt1.z, curve_id, iface_crack_ver_id1);
7146 // else
7147 // sprintf(buffer, "vertex %d fixed vertex %d\n", vertex_id, vertex_id - 2);
7148 // write_record(t3d_in_file, t3d_in_file_name, buffer);
7149 //
7150 // vertex_id++;
7151 // if(fixed_b == NO)
7152 // sprintf(buffer, "vertex %d xyz %e %e %e fixed curve %d fixed vertex %d\n", vertex_id,
7153 // crack -> pnt2.x, crack -> pnt2.y, crack -> pnt2.z, curve_id, iface_crack_ver_id2);
7154 // else
7155 // sprintf(buffer, "vertex %d fixed vertex %d\n", vertex_id, vertex_id - 2);
7156 // write_record(t3d_in_file, t3d_in_file_name, buffer);
7157 //
7158 // write_record(t3d_in_file, t3d_in_file_name, "\n");
7159 //
7160 // vertex_id++;
7161 // sprintf(buffer, "vertex %d xyz %e %e %e fixed curve %d\n", vertex_id,
7162 // point[0].x, point[0].y, point[0].z, curve_id);
7163 // write_record(t3d_in_file, t3d_in_file_name, buffer);
7164 //
7165 // sprintf(buffer, " Vertex %d %d", cross_ver_id1, vertex_id);
7166 // write_record(ctrl_file, ctrl_file_name, buffer);
7167 //
7168 // vertex_id++;
7169 // sprintf(buffer, "vertex %d xyz %e %e %e fixed curve %d\n", vertex_id,
7170 // point[0].x, point[0].y, point[0].z, curve_id);
7171 // write_record(t3d_in_file, t3d_in_file_name, buffer);
7172 //
7173 // if(ellipsoid -> property == 0)
7174 // sprintf(buffer, " Vertex %d %d", cross_ver_id1 + 1, vertex_id);
7175 // else
7176 // sprintf(buffer, " Vertex %d %d", cross_ver_id1, vertex_id);
7177 // write_record(ctrl_file, ctrl_file_name, buffer);
7178 //
7179 // write_record(t3d_in_file, t3d_in_file_name, "\n");
7180 //
7181 // curve_id++;
7182 // sprintf(buffer, "curve %d vertex %d %d fixed curve %d\n", curve_id,
7183 // vertex_id - 3, vertex_id - 1, -iface_crack_cur_id1);
7184 // write_record(t3d_in_file, t3d_in_file_name, buffer);
7185 // iface_crack_cur_id1a = curve_id;
7186 //
7187 // if(ellipsoid -> property != 0 && ellipsoid -> property != prop)
7188 // sprintf(buffer, " Curve %d %d", curve_id - 2 * curves + 6, curve_id);
7189 // else
7190 // sprintf(buffer, " Curve %d %d", curve_id - curves + 6, curve_id);
7191 // write_record(ctrl_file, ctrl_file_name, buffer);
7192 //
7193 // curve_id++;
7194 // sprintf(buffer, "curve %d vertex %d %d fixed curve %d\n", curve_id,
7195 // vertex_id - 1, vertex_id - 2, -iface_crack_cur_id1);
7196 // write_record(t3d_in_file, t3d_in_file_name, buffer);
7197 // iface_crack_cur_id1b = curve_id;
7198 //
7199 // if(ellipsoid -> property != 0 && ellipsoid -> property != prop)
7200 // sprintf(buffer, " Curve %d %d", curve_id - 2 * curves + 6, curve_id);
7201 // else
7202 // sprintf(buffer, " Curve %d %d", curve_id - curves + 6, curve_id);
7203 // write_record(ctrl_file, ctrl_file_name, buffer);
7204 //
7205 // curve_id++;
7206 // sprintf(buffer, "curve %d vertex %d %d fixed curve %d\n", curve_id,
7207 // vertex_id - 3, vertex_id, -iface_crack_cur_id1);
7208 // write_record(t3d_in_file, t3d_in_file_name, buffer);
7209 //
7210 // if(ellipsoid -> property == 0)
7211 // sprintf(buffer, " Curve %d %d", curve_id - curves + 6, curve_id);
7212 // else{
7213 // if(ellipsoid -> property != 0 && ellipsoid -> property != prop)
7214 // sprintf(buffer, " Curve %d %d", curve_id - 2 * curves + 4, curve_id);
7215 // else
7216 // sprintf(buffer, " Curve %d %d", curve_id - curves + 4, curve_id);
7217 // }
7218 // write_record(ctrl_file, ctrl_file_name, buffer);
7219 //
7220 // curve_id++;
7221 // sprintf(buffer, "curve %d vertex %d %d fixed curve %d\n", curve_id,
7222 // vertex_id, vertex_id - 2, -iface_crack_cur_id1);
7223 // write_record(t3d_in_file, t3d_in_file_name, buffer);
7224 //
7225 // if(ellipsoid -> property == 0)
7226 // sprintf(buffer, " Curve %d %d", curve_id - curves + 6, curve_id);
7227 // else{
7228 // if(ellipsoid -> property != 0 && ellipsoid -> property != prop)
7229 // sprintf(buffer, " Curve %d %d", curve_id - 2 * curves + 4, curve_id);
7230 // else
7231 // sprintf(buffer, " Curve %d %d", curve_id - curves + 4, curve_id);
7232 // }
7233 // write_record(ctrl_file, ctrl_file_name, buffer);
7234 //
7235 // write_record(t3d_in_file, t3d_in_file_name, "\n");
7236 // break;
7237 //
7238 // case 3:
7239 // if(intersect != 1)error_message(GENERAL_ERROR, "Unexpected situation");
7240 //
7241 // vertex_id++;
7242 // if(fixed_a == NO){
7243 // j = crack -> qa - 1;
7244 // if(bmsz == 0.0){
7245 // default_msz = YES;
7246 // sprintf(buffer, "vertex %d xyz %e %e %e virtual\n", vertex_id,
7247 // contact_glob_point[j].x, contact_glob_point[j].y, contact_glob_point[j].z);
7248 // }
7249 // else
7250 // sprintf(buffer, "vertex %d xyz %e %e %e size %e virtual\n", vertex_id,
7251 // contact_glob_point[j].x, contact_glob_point[j].y, contact_glob_point[j].z, bmsz);
7252 // }
7253 // else{
7254 // if(bmsz == 0.0){
7255 // default_msz = YES;
7256 // sprintf(buffer, "vertex %d fixed vertex %d size def\n", vertex_id, iface_crack_ver_id1);
7257 // }
7258 // else
7259 // sprintf(buffer, "vertex %d fixed vertex %d size %e\n", vertex_id, iface_crack_ver_id1, bmsz);
7260 // }
7261 // write_record(t3d_in_file, t3d_in_file_name, buffer);
7262 //
7263 // vertex_id++;
7264 // if(fixed_b == NO){
7265 // if((j = crack -> qa + 2) >= 4)j -= 4;
7266 // if(bmsz == 0.0){
7267 // default_msz = YES;
7268 // sprintf(buffer, "vertex %d xyz %e %e %e virtual\n", vertex_id,
7269 // contact_glob_point[j].x, contact_glob_point[j].y, contact_glob_point[j].z);
7270 // }
7271 // else
7272 // sprintf(buffer, "vertex %d xyz %e %e %e size %e virtual\n", vertex_id,
7273 // contact_glob_point[j].x, contact_glob_point[j].y, contact_glob_point[j].z, bmsz);
7274 // }
7275 // else{
7276 // if(bmsz == 0.0){
7277 // default_msz = YES;
7278 // sprintf(buffer, "vertex %d fixed vertex %d size def\n", vertex_id, iface_crack_ver_id2);
7279 // }
7280 // else
7281 // sprintf(buffer, "vertex %d fixed vertex %d size %e\n", vertex_id, iface_crack_ver_id2, bmsz);
7282 // }
7283 // write_record(t3d_in_file, t3d_in_file_name, buffer);
7284 //
7285 // write_record(t3d_in_file, t3d_in_file_name, "\n");
7286 //
7287 // if((j = crack -> qa + 2) >= 4)j -= 4;
7288 // curve_id++;
7289 // sprintf(buffer, "curve %d order 3 vertex %d %d virtual\n", curve_id, vertex_id - 1, vertex_id);
7290 // write_record(t3d_in_file, t3d_in_file_name, buffer);
7291 // if(bmsz == 0.0){
7292 // default_msz = YES;
7293 // sprintf(buffer, "polygon 1 xyz %e %e %e weight %e\n",
7294 // contact_glob_pnt[j].x, contact_glob_pnt[j].y, contact_glob_pnt[j].z, -weight_q);
7295 // }
7296 // else
7297 // sprintf(buffer, "polygon 1 xyz %e %e %e weight %e size %e\n",
7298 // contact_glob_pnt[j].x, contact_glob_pnt[j].y, contact_glob_pnt[j].z, -weight_q, bmsz);
7299 // write_record(t3d_in_file, t3d_in_file_name, buffer);
7300 // iface_crack_cur_id1 = -curve_id;
7301 //
7302 // write_record(t3d_in_file, t3d_in_file_name, "\n");
7303 //
7304 // vertex_id++;
7305 // if(fixed_a == NO)
7306 // sprintf(buffer, "vertex %d xyz %e %e %e fixed curve %d fixed vertex %d\n", vertex_id,
7307 // crack -> pnt1.x, crack -> pnt1.y, crack -> pnt1.z, curve_id, iface_crack_ver_id1);
7308 // else
7309 // sprintf(buffer, "vertex %d fixed vertex %d\n", vertex_id, vertex_id - 2);
7310 // write_record(t3d_in_file, t3d_in_file_name, buffer);
7311 //
7312 // vertex_id++;
7313 // if(fixed_b == NO)
7314 // sprintf(buffer, "vertex %d xyz %e %e %e fixed curve %d fixed vertex %d\n", vertex_id,
7315 // crack -> pnt2.x, crack -> pnt2.y, crack -> pnt2.z, curve_id, iface_crack_ver_id2);
7316 // else
7317 // sprintf(buffer, "vertex %d fixed vertex %d\n", vertex_id, vertex_id - 2);
7318 // write_record(t3d_in_file, t3d_in_file_name, buffer);
7319 //
7320 // write_record(t3d_in_file, t3d_in_file_name, "\n");
7321 //
7322 // vertex_id++;
7323 // sprintf(buffer, "vertex %d xyz %e %e %e fixed curve %d\n", vertex_id,
7324 // point[0].x, point[0].y, point[0].z, curve_id);
7325 // write_record(t3d_in_file, t3d_in_file_name, buffer);
7326 //
7327 // sprintf(buffer, " Vertex %d %d", cross_ver_id1, vertex_id);
7328 // write_record(ctrl_file, ctrl_file_name, buffer);
7329 //
7330 // vertex_id++;
7331 // sprintf(buffer, "vertex %d xyz %e %e %e fixed curve %d\n", vertex_id,
7332 // point[0].x, point[0].y, point[0].z, curve_id);
7333 // write_record(t3d_in_file, t3d_in_file_name, buffer);
7334 //
7335 // if(ellipsoid -> property == 0)
7336 // sprintf(buffer, " Vertex %d %d", cross_ver_id1 + 1, vertex_id);
7337 // else
7338 // sprintf(buffer, " Vertex %d %d", cross_ver_id1, vertex_id);
7339 // write_record(ctrl_file, ctrl_file_name, buffer);
7340 //
7341 // write_record(t3d_in_file, t3d_in_file_name, "\n");
7342 //
7343 // curve_id++;
7344 // sprintf(buffer, "curve %d vertex %d %d fixed curve %d\n", curve_id,
7345 // vertex_id - 3, vertex_id - 1, -iface_crack_cur_id1);
7346 // write_record(t3d_in_file, t3d_in_file_name, buffer);
7347 // iface_crack_cur_id1a = curve_id;
7348 //
7349 // if(ellipsoid -> property != 0 && ellipsoid -> property != prop)
7350 // sprintf(buffer, " Curve %d %d", curve_id - 2 * curves + 6, curve_id);
7351 // else
7352 // sprintf(buffer, " Curve %d %d", curve_id - curves + 6, curve_id);
7353 // write_record(ctrl_file, ctrl_file_name, buffer);
7354 //
7355 // curve_id++;
7356 // sprintf(buffer, "curve %d vertex %d %d fixed curve %d\n", curve_id,
7357 // vertex_id - 1, vertex_id - 2, -iface_crack_cur_id1);
7358 // write_record(t3d_in_file, t3d_in_file_name, buffer);
7359 // iface_crack_cur_id1b = curve_id;
7360 //
7361 // if(ellipsoid -> property != 0 && ellipsoid -> property != prop)
7362 // sprintf(buffer, " Curve %d %d", curve_id - 2 * curves + 6, curve_id);
7363 // else
7364 // sprintf(buffer, " Curve %d %d", curve_id - curves + 6, curve_id);
7365 // write_record(ctrl_file, ctrl_file_name, buffer);
7366 //
7367 // curve_id++;
7368 // sprintf(buffer, "curve %d vertex %d %d fixed curve %d\n", curve_id,
7369 // vertex_id - 3, vertex_id, -iface_crack_cur_id1);
7370 // write_record(t3d_in_file, t3d_in_file_name, buffer);
7371 //
7372 // if(ellipsoid -> property == 0)
7373 // sprintf(buffer, " Curve %d %d", curve_id - curves + 6, curve_id);
7374 // else{
7375 // if(ellipsoid -> property != 0 && ellipsoid -> property != prop)
7376 // sprintf(buffer, " Curve %d %d", curve_id - 2 * curves + 4, curve_id);
7377 // else
7378 // sprintf(buffer, " Curve %d %d", curve_id - curves + 4, curve_id);
7379 // }
7380 // write_record(ctrl_file, ctrl_file_name, buffer);
7381 //
7382 // curve_id++;
7383 // sprintf(buffer, "curve %d vertex %d %d fixed curve %d\n", curve_id,
7384 // vertex_id, vertex_id - 2, -iface_crack_cur_id1);
7385 // write_record(t3d_in_file, t3d_in_file_name, buffer);
7386 //
7387 // if(ellipsoid -> property == 0)
7388 // sprintf(buffer, " Curve %d %d", curve_id - curves + 6, curve_id);
7389 // else{
7390 // if(ellipsoid -> property != 0 && ellipsoid -> property != prop)
7391 // sprintf(buffer, " Curve %d %d", curve_id - 2 * curves + 4, curve_id);
7392 // else
7393 // sprintf(buffer, " Curve %d %d", curve_id - curves + 4, curve_id);
7394 // }
7395 // write_record(ctrl_file, ctrl_file_name, buffer);
7396 //
7397 // write_record(t3d_in_file, t3d_in_file_name, "\n");
7398 // break;
7399 //
7400 // case 4:
7401 // if(fixed_a == YES && fixed_b == YES)error_message(GENERAL_ERROR, "Unimplemented situation");
7402 // if(intersect == 0)error_message(GENERAL_ERROR, "Unexpected situation");
7403 //
7404 // for(m = 0; m < 2; m++){
7405 // vertex_id++;
7406 // if(fixed_a == NO && fixed_b == NO){
7407 // j = crack -> qa - 1;
7408 // if(bmsz == 0.0){
7409 // default_msz = YES;
7410 // sprintf(buffer, "vertex %d xyz %e %e %e virtual\n", vertex_id,
7411 // contact_glob_point[j].x, contact_glob_point[j].y, contact_glob_point[j].z);
7412 // }
7413 // else
7414 // sprintf(buffer, "vertex %d xyz %e %e %e size %e virtual\n", vertex_id,
7415 // contact_glob_point[j].x, contact_glob_point[j].y, contact_glob_point[j].z, bmsz);
7416 // }
7417 // else{
7418 // if(fixed_a == YES){
7419 // if(bmsz == 0.0){
7420 // default_msz = YES;
7421 // sprintf(buffer, "vertex %d fixed vertex %d size def\n", vertex_id, iface_crack_ver_id1);
7422 // }
7423 // else
7424 // sprintf(buffer, "vertex %d fixed vertex %d size %e\n", vertex_id, iface_crack_ver_id1, bmsz);
7425 // }
7426 // if(fixed_b == YES){
7427 // if(bmsz == 0.0){
7428 // default_msz = YES;
7429 // sprintf(buffer, "vertex %d fixed vertex %d size def\n", vertex_id, iface_crack_ver_id2);
7430 // }
7431 // else
7432 // sprintf(buffer, "vertex %d fixed vertex %d size %e\n", vertex_id, iface_crack_ver_id2, bmsz);
7433 // }
7434 // }
7435 // write_record(t3d_in_file, t3d_in_file_name, buffer);
7436 //
7437 // if((j = crack -> qa + 1) >= 4)j -= 4;
7438 // vertex_id++;
7439 // if(bmsz == 0.0){
7440 // default_msz = YES;
7441 // sprintf(buffer, "vertex %d xyz %e %e %e\n", vertex_id,
7442 // contact_glob_point[j].x, contact_glob_point[j].y, contact_glob_point[j].z);
7443 // }
7444 // else
7445 // sprintf(buffer, "vertex %d xyz %e %e %e size %e\n", vertex_id,
7446 // contact_glob_point[j].x, contact_glob_point[j].y, contact_glob_point[j].z, bmsz);
7447 // write_record(t3d_in_file, t3d_in_file_name, buffer);
7448 //
7449 // if(intersect == 1){
7450 // if(ellipsoid -> property != 0 && ellipsoid -> property != prop){
7451 // if(m == 0)
7452 // sprintf(buffer, " Vertex %d %d", vertex_id - 2 * vertices + 6, vertex_id);
7453 // else
7454 // sprintf(buffer, " Vertex %d %d", vertex_id - 2 * vertices + 1, vertex_id);
7455 // }
7456 // else{
7457 // if(m == 0 || ellipsoid -> property == 0)
7458 // sprintf(buffer, " Vertex %d %d", vertex_id - vertices + 6, vertex_id);
7459 // else
7460 // sprintf(buffer, " Vertex %d %d", vertex_id - vertices + 1, vertex_id);
7461 // }
7462 // write_record(ctrl_file, ctrl_file_name, buffer);
7463 // }
7464 // else{
7465 // if(ellipsoid -> property != 0 && ellipsoid -> property != prop){
7466 // if(m == 0)
7467 // sprintf(buffer, " Vertex %d %d", vertex_id - 2 * vertices + 10, vertex_id);
7468 // else
7469 // sprintf(buffer, " Vertex %d %d", vertex_id - 2 * vertices + 4, vertex_id);
7470 // }
7471 // else{
7472 // if(m == 0 || ellipsoid -> property == 0)
7473 // sprintf(buffer, " Vertex %d %d", vertex_id - vertices + 10, vertex_id);
7474 // else
7475 // sprintf(buffer, " Vertex %d %d", vertex_id - vertices + 4, vertex_id);
7476 // }
7477 // write_record(ctrl_file, ctrl_file_name, buffer);
7478 // }
7479 //
7480 // write_record(t3d_in_file, t3d_in_file_name, "\n");
7481 //
7482 // curve_id++;
7483 // sprintf(buffer, "curve %d order 4 vertex %d %d virtual\n", curve_id, vertex_id - 1, vertex_id);
7484 // write_record(t3d_in_file, t3d_in_file_name, buffer);
7485 //
7486 // for(i = 0; i < 2; i++){
7487 // if((j = crack -> qa - 1 + i) >= 4)j -= 4;
7488 // if(bmsz == 0.0){
7489 // default_msz = YES;
7490 // sprintf(buffer, "polygon %d xyz %e %e %e weight %e\n", i + 1,
7491 // contact_glob_pnt[j].x, contact_glob_pnt[j].y, contact_glob_pnt[j].z, weight_h);
7492 // }
7493 // else
7494 // sprintf(buffer, "polygon %d xyz %e %e %e weight %e size %e\n", i + 1,
7495 // contact_glob_pnt[j].x, contact_glob_pnt[j].y, contact_glob_pnt[j].z, weight_h, bmsz);
7496 // write_record(t3d_in_file, t3d_in_file_name, buffer);
7497 // }
7498 //
7499 // curve_id++;
7500 // sprintf(buffer, "curve %d order 4 vertex %d %d virtual\n", curve_id, vertex_id, vertex_id - 1);
7501 // write_record(t3d_in_file, t3d_in_file_name, buffer);
7502 //
7503 // for(i = 0; i < 2; i++){
7504 // if((j = crack -> qa + 1 + i) >= 4)j -= 4;
7505 // if(bmsz == 0.0){
7506 // default_msz = YES;
7507 // sprintf(buffer, "polygon %d xyz %e %e %e weight %e\n", i + 1,
7508 // contact_glob_pnt[j].x, contact_glob_pnt[j].y, contact_glob_pnt[j].z, weight_h);
7509 // }
7510 // else
7511 // sprintf(buffer, "polygon %d xyz %e %e %e weight %e size %e\n", i + 1,
7512 // contact_glob_pnt[j].x, contact_glob_pnt[j].y, contact_glob_pnt[j].z, weight_h, bmsz);
7513 // write_record(t3d_in_file, t3d_in_file_name, buffer);
7514 // }
7515 //
7516 // write_record(t3d_in_file, t3d_in_file_name, "\n");
7517 //
7518 // vertex_id++;
7519 // if(fixed_a == NO)
7520 // sprintf(buffer, "vertex %d xyz %e %e %e fixed curve %d fixed vertex %d\n", vertex_id,
7521 // crack -> pnt1.x, crack -> pnt1.y, crack -> pnt1.z, curve_id - 1, iface_crack_ver_id1);
7522 // else
7523 // sprintf(buffer, "vertex %d fixed vertex %d\n", vertex_id, vertex_id - 2);
7524 // write_record(t3d_in_file, t3d_in_file_name, buffer);
7525 //
7526 // vertex_id++;
7527 // if(fixed_b == NO)
7528 // sprintf(buffer, "vertex %d xyz %e %e %e fixed curve %d fixed vertex %d\n", vertex_id,
7529 // crack -> pnt2.x, crack -> pnt2.y, crack -> pnt2.z, curve_id, iface_crack_ver_id2);
7530 // else
7531 // sprintf(buffer, "vertex %d fixed vertex %d\n", vertex_id, vertex_id - 2);
7532 // write_record(t3d_in_file, t3d_in_file_name, buffer);
7533 //
7534 // write_record(t3d_in_file, t3d_in_file_name, "\n");
7535 //
7536 // if(intersect == 1){
7537 // if(first_curve == YES){
7538 // vertex_id++;
7539 // iface_crack_cur_id1 = -(curve_id - 1);
7540 // sprintf(buffer, "vertex %d xyz %e %e %e fixed curve %d\n", vertex_id,
7541 // point[0].x, point[0].y, point[0].z, -iface_crack_cur_id1);
7542 // write_record(t3d_in_file, t3d_in_file_name, buffer);
7543 //
7544 // if(m == 0 || ellipsoid -> property == 0)
7545 // sprintf(buffer, " Vertex %d %d", cross_ver_id1 + m, vertex_id);
7546 // else
7547 // sprintf(buffer, " Vertex %d %d", cross_ver_id1, vertex_id);
7548 // write_record(ctrl_file, ctrl_file_name, buffer);
7549 //
7550 // write_record(t3d_in_file, t3d_in_file_name, "\n");
7551 //
7552 // curve_id++;
7553 // sprintf(buffer, "curve %d vertex %d %d fixed curve %d\n", curve_id,
7554 // vertex_id - 2, vertex_id, -iface_crack_cur_id1);
7555 // write_record(t3d_in_file, t3d_in_file_name, buffer);
7556 // if(m == 0)iface_crack_cur_id1a = curve_id;
7557 //
7558 // if(ellipsoid -> property != 0 && ellipsoid -> property != prop){
7559 // if(m == 00)
7560 // sprintf(buffer, " Curve %d %d", curve_id - 2 * curves + 6, curve_id);
7561 // else
7562 // sprintf(buffer, " Curve %d %d", curve_id - 2 * curves + 1, curve_id);
7563 // }
7564 // else{
7565 // if(m == 0 || ellipsoid -> property == 0)
7566 // sprintf(buffer, " Curve %d %d", curve_id - curves + 6, curve_id);
7567 // else
7568 // sprintf(buffer, " Curve %d %d", curve_id - curves + 1, curve_id);
7569 // }
7570 // write_record(ctrl_file, ctrl_file_name, buffer);
7571 //
7572 // curve_id++;
7573 // sprintf(buffer, "curve %d vertex %d %d fixed curve %d\n", curve_id,
7574 // vertex_id, vertex_id - 3, -iface_crack_cur_id1);
7575 // write_record(t3d_in_file, t3d_in_file_name, buffer);
7576 // if(m == 0)iface_crack_cur_id1b = curve_id;
7577 //
7578 // if(ellipsoid -> property != 0 && ellipsoid -> property != prop){
7579 // if(m == 0)
7580 // sprintf(buffer, " Curve %d %d", curve_id - 2 * curves + 6, curve_id);
7581 // else
7582 // sprintf(buffer, " Curve %d %d", curve_id - 2 * curves + 1, curve_id);
7583 // }
7584 // else{
7585 // if(m == 0 || ellipsoid -> property == 0)
7586 // sprintf(buffer, " Curve %d %d", curve_id - curves + 6, curve_id);
7587 // else
7588 // sprintf(buffer, " Curve %d %d", curve_id - curves + 1, curve_id);
7589 // }
7590 // write_record(ctrl_file, ctrl_file_name, buffer);
7591 //
7592 // curve_id++;
7593 // sprintf(buffer, "curve %d vertex %d %d fixed curve %d\n", curve_id,
7594 // vertex_id - 3, vertex_id - 1, curve_id - 3);
7595 // write_record(t3d_in_file, t3d_in_file_name, buffer);
7596 // if(m == 0)iface_crack_cur_id2 = curve_id;
7597 //
7598 // if(ellipsoid -> property != 0 && ellipsoid -> property != prop){
7599 // if(m == 0)
7600 // sprintf(buffer, " Curve %d %d", curve_id - 2 * curves + 6, curve_id);
7601 // else
7602 // sprintf(buffer, " Curve %d %d", curve_id - 2 * curves + 1, curve_id);
7603 // }
7604 // else{
7605 // if(m == 0 || ellipsoid -> property == 0)
7606 // sprintf(buffer, " Curve %d %d", curve_id - curves + 6, curve_id);
7607 // else
7608 // sprintf(buffer, " Curve %d %d", curve_id - curves + 1, curve_id);
7609 // }
7610 // write_record(ctrl_file, ctrl_file_name, buffer);
7611 // }
7612 // else{
7613 // vertex_id++;
7614 // iface_crack_cur_id2 = -curve_id;
7615 // sprintf(buffer, "vertex %d xyz %e %e %e fixed curve %d\n", vertex_id,
7616 // point[0].x, point[0].y, point[0].z, -iface_crack_cur_id2);
7617 // write_record(t3d_in_file, t3d_in_file_name, buffer);
7618 //
7619 // if(m == 0 || ellipsoid -> property == 0)
7620 // sprintf(buffer, " Vertex %d %d", cross_ver_id1 + m, vertex_id);
7621 // else
7622 // sprintf(buffer, " Vertex %d %d", cross_ver_id1, vertex_id);
7623 // write_record(ctrl_file, ctrl_file_name, buffer);
7624 //
7625 // write_record(t3d_in_file, t3d_in_file_name, "\n");
7626 //
7627 // curve_id++;
7628 // sprintf(buffer, "curve %d vertex %d %d fixed curve %d\n", curve_id,
7629 // vertex_id - 2, vertex_id - 3, curve_id - 2);
7630 // write_record(t3d_in_file, t3d_in_file_name, buffer);
7631 // if(m == 0)iface_crack_cur_id1 = curve_id;
7632 //
7633 // if(ellipsoid -> property != 0 && ellipsoid -> property != prop){
7634 // if(m == 0)
7635 // sprintf(buffer, " Curve %d %d", curve_id - 2 * curves + 6, curve_id);
7636 // else
7637 // sprintf(buffer, " Curve %d %d", curve_id - 2 * curves + 1, curve_id);
7638 // }
7639 // else{
7640 // if(m == 0 || ellipsoid -> property == 0)
7641 // sprintf(buffer, " Curve %d %d", curve_id - curves + 6, curve_id);
7642 // else
7643 // sprintf(buffer, " Curve %d %d", curve_id - curves + 1, curve_id);
7644 // }
7645 // write_record(ctrl_file, ctrl_file_name, buffer);
7646 //
7647 // curve_id++;
7648 // sprintf(buffer, "curve %d vertex %d %d fixed curve %d\n", curve_id,
7649 // vertex_id - 3, vertex_id, -iface_crack_cur_id2);
7650 // write_record(t3d_in_file, t3d_in_file_name, buffer);
7651 // if(m == 0)iface_crack_cur_id2a = curve_id;
7652 //
7653 // if(ellipsoid -> property != 0 && ellipsoid -> property != prop){
7654 // if(m == 0)
7655 // sprintf(buffer, " Curve %d %d", curve_id - 2 * curves + 6, curve_id);
7656 // else
7657 // sprintf(buffer, " Curve %d %d", curve_id - 2 * curves + 1, curve_id);
7658 // }
7659 // else{
7660 // if(m == 0 || ellipsoid -> property == 0)
7661 // sprintf(buffer, " Curve %d %d", curve_id - curves + 6, curve_id);
7662 // else
7663 // sprintf(buffer, " Curve %d %d", curve_id - curves + 1, curve_id);
7664 // }
7665 // write_record(ctrl_file, ctrl_file_name, buffer);
7666 //
7667 // curve_id++;
7668 // sprintf(buffer, "curve %d vertex %d %d fixed curve %d\n", curve_id,
7669 // vertex_id, vertex_id - 1, -iface_crack_cur_id2);
7670 // write_record(t3d_in_file, t3d_in_file_name, buffer);
7671 // if(m == 0)iface_crack_cur_id2b = curve_id;
7672 //
7673 // if(ellipsoid -> property != 0 && ellipsoid -> property != prop){
7674 // if(m == 0)
7675 // sprintf(buffer, " Curve %d %d", curve_id - 2 * curves + 6, curve_id);
7676 // else
7677 // sprintf(buffer, " Curve %d %d", curve_id - 2 * curves + 1, curve_id);
7678 // }
7679 // else{
7680 // if(m == 0 || ellipsoid -> property == 0)
7681 // sprintf(buffer, " Curve %d %d", curve_id - curves + 6, curve_id);
7682 // else
7683 // sprintf(buffer, " Curve %d %d", curve_id - curves + 1, curve_id);
7684 // }
7685 // write_record(ctrl_file, ctrl_file_name, buffer);
7686 // }
7687 // }
7688 // else{
7689 // iface_crack_cur_id1 = -(curve_id - 1);
7690 // iface_crack_cur_id2 = -curve_id;
7691 //
7692 // vertex_id++;
7693 // sprintf(buffer, "vertex %d xyz %e %e %e fixed curve %d\n", vertex_id,
7694 // point[0].x, point[0].y, point[0].z, -iface_crack_cur_id1);
7695 // write_record(t3d_in_file, t3d_in_file_name, buffer);
7696 //
7697 // if(m == 0 || ellipsoid -> property == 0)
7698 // sprintf(buffer, " Vertex %d %d", cross_ver_id1 + m, vertex_id);
7699 // else
7700 // sprintf(buffer, " Vertex %d %d", cross_ver_id1, vertex_id);
7701 // write_record(ctrl_file, ctrl_file_name, buffer);
7702 //
7703 // vertex_id++;
7704 // sprintf(buffer, "vertex %d xyz %e %e %e fixed curve %d\n", vertex_id,
7705 // point[1].x, point[1].y, point[1].z, -iface_crack_cur_id2);
7706 // write_record(t3d_in_file, t3d_in_file_name, buffer);
7707 //
7708 // write_record(t3d_in_file, t3d_in_file_name, "\n");
7709 //
7710 // if(m == 0 || ellipsoid -> property == 0)
7711 // sprintf(buffer, " Vertex %d %d", cross_ver_id2 + m, vertex_id);
7712 // else
7713 // sprintf(buffer, " Vertex %d %d", cross_ver_id2, vertex_id);
7714 // write_record(ctrl_file, ctrl_file_name, buffer);
7715 //
7716 // curve_id++;
7717 // sprintf(buffer, "curve %d vertex %d %d fixed curve %d\n", curve_id,
7718 // vertex_id - 3, vertex_id - 1, -iface_crack_cur_id1);
7719 // write_record(t3d_in_file, t3d_in_file_name, buffer);
7720 // if(m == 0)iface_crack_cur_id1a = curve_id;
7721 //
7722 // if(ellipsoid -> property != 0 && ellipsoid -> property != prop){
7723 // if(m == 0)
7724 // sprintf(buffer, " Curve %d %d", curve_id - 2 * curves + 8, curve_id);
7725 // else
7726 // sprintf(buffer, " Curve %d %d", curve_id - 2 * curves + 2, curve_id);
7727 // }
7728 // else{
7729 // if(m == 0 || ellipsoid -> property == 0)
7730 // sprintf(buffer, " Curve %d %d", curve_id - curves + 8, curve_id);
7731 // else
7732 // sprintf(buffer, " Curve %d %d", curve_id - curves + 2, curve_id);
7733 // }
7734 // write_record(ctrl_file, ctrl_file_name, buffer);
7735 //
7736 // curve_id++;
7737 // sprintf(buffer, "curve %d vertex %d %d fixed curve %d\n", curve_id,
7738 // vertex_id - 1, vertex_id - 4, -iface_crack_cur_id1);
7739 // write_record(t3d_in_file, t3d_in_file_name, buffer);
7740 // if(m == 0)iface_crack_cur_id1b = curve_id;
7741 //
7742 // if(ellipsoid -> property != 0 && ellipsoid -> property != prop){
7743 // if(m == 0)
7744 // sprintf(buffer, " Curve %d %d", curve_id - 2 * curves + 8, curve_id);
7745 // else
7746 // sprintf(buffer, " Curve %d %d", curve_id - 2 * curves + 2, curve_id);
7747 // }
7748 // else{
7749 // if(m == 0 || ellipsoid -> property == 0)
7750 // sprintf(buffer, " Curve %d %d", curve_id - curves + 8, curve_id);
7751 // else
7752 // sprintf(buffer, " Curve %d %d", curve_id - curves + 2, curve_id);
7753 // }
7754 // write_record(ctrl_file, ctrl_file_name, buffer);
7755 //
7756 // curve_id++;
7757 // sprintf(buffer, "curve %d vertex %d %d fixed curve %d\n", curve_id,
7758 // vertex_id - 4, vertex_id, -iface_crack_cur_id2);
7759 // write_record(t3d_in_file, t3d_in_file_name, buffer);
7760 // if(m == 0)iface_crack_cur_id2a = curve_id;
7761 //
7762 // if(ellipsoid -> property != 0 && ellipsoid -> property != prop){
7763 // if(m == 0)
7764 // sprintf(buffer, " Curve %d %d", curve_id - 2 * curves + 8, curve_id);
7765 // else
7766 // sprintf(buffer, " Curve %d %d", curve_id - 2 * curves + 2, curve_id);
7767 // }
7768 // else{
7769 // if(m == 0 || ellipsoid -> property == 0)
7770 // sprintf(buffer, " Curve %d %d", curve_id - curves + 8, curve_id);
7771 // else
7772 // sprintf(buffer, " Curve %d %d", curve_id - curves + 2, curve_id);
7773 // }
7774 // write_record(ctrl_file, ctrl_file_name, buffer);
7775 //
7776 // curve_id++;
7777 // sprintf(buffer, "curve %d vertex %d %d fixed curve %d\n", curve_id,
7778 // vertex_id, vertex_id - 2, -iface_crack_cur_id2);
7779 // write_record(t3d_in_file, t3d_in_file_name, buffer);
7780 // if(m == 0)iface_crack_cur_id2b = curve_id;
7781 //
7782 // if(ellipsoid -> property != 0 && ellipsoid -> property != prop){
7783 // if(m == 0)
7784 // sprintf(buffer, " Curve %d %d", curve_id - 2 * curves + 8, curve_id);
7785 // else
7786 // sprintf(buffer, " Curve %d %d", curve_id - 2 * curves + 2, curve_id);
7787 // }
7788 // else{
7789 // if(m == 0 || ellipsoid -> property == 0)
7790 // sprintf(buffer, " Curve %d %d", curve_id - curves + 8, curve_id);
7791 // else
7792 // sprintf(buffer, " Curve %d %d", curve_id - curves + 2, curve_id);
7793 // }
7794 // write_record(ctrl_file, ctrl_file_name, buffer);
7795 // }
7796 //
7797 // write_record(t3d_in_file, t3d_in_file_name, "\n");
7798 // }
7799 // break;
7800 //
7801 // case 5:
7802 // if(intersect != 2)error_message(GENERAL_ERROR, "Unexpected situation");
7803 //
7804 // for(m = 0; m < 2; m++){
7805 // vertex_id++;
7806 // if((j = crack -> qa + 1) >= 4)j -= 4;
7807 // if(bmsz == 0.0){
7808 // default_msz = YES;
7809 // sprintf(buffer, "vertex %d xyz %e %e %e\n", vertex_id,
7810 // contact_glob_point[j].x, contact_glob_point[j].y, contact_glob_point[j].z);
7811 // }
7812 // else
7813 // sprintf(buffer, "vertex %d xyz %e %e %e size %e\n", vertex_id,
7814 // contact_glob_point[j].x, contact_glob_point[j].y, contact_glob_point[j].z, bmsz);
7815 // write_record(t3d_in_file, t3d_in_file_name, buffer);
7816 //
7817 // if(ellipsoid -> property != 0 && ellipsoid -> property != prop){
7818 // if(m == 0)
7819 // sprintf(buffer, " Vertex %d %d", vertex_id - 2 * vertices + 10, vertex_id);
7820 // else
7821 // sprintf(buffer, " Vertex %d %d", vertex_id - 2 * vertices + 4, vertex_id);
7822 // }
7823 // else{
7824 // if(m == 0 || ellipsoid -> property == 0)
7825 // sprintf(buffer, " Vertex %d %d", vertex_id - vertices + 10, vertex_id);
7826 // else
7827 // sprintf(buffer, " Vertex %d %d", vertex_id - vertices + 4, vertex_id);
7828 // }
7829 // write_record(ctrl_file, ctrl_file_name, buffer);
7830 //
7831 // vertex_id++;
7832 // if((j = crack -> qa + 2) >= 4)j -= 4;
7833 // if(bmsz == 0.0){
7834 // default_msz = YES;
7835 // sprintf(buffer, "vertex %d xyz %e %e %e\n", vertex_id,
7836 // contact_glob_point[j].x, contact_glob_point[j].y, contact_glob_point[j].z);
7837 // }
7838 // else
7839 // sprintf(buffer, "vertex %d xyz %e %e %e size %e\n", vertex_id,
7840 // contact_glob_point[j].x, contact_glob_point[j].y, contact_glob_point[j].z, bmsz);
7841 // write_record(t3d_in_file, t3d_in_file_name, buffer);
7842 //
7843 // if(ellipsoid -> property != 0 && ellipsoid -> property != prop){
7844 // if(m == 0)
7845 // sprintf(buffer, " Vertex %d %d", vertex_id - 2 * vertices + 10, vertex_id);
7846 // else
7847 // sprintf(buffer, " Vertex %d %d", vertex_id - 2 * vertices + 4, vertex_id);
7848 // }
7849 // else{
7850 // if(m == 0 || ellipsoid -> property == 0)
7851 // sprintf(buffer, " Vertex %d %d", vertex_id - vertices + 10, vertex_id);
7852 // else
7853 // sprintf(buffer, " Vertex %d %d", vertex_id - vertices + 4, vertex_id);
7854 // }
7855 // write_record(ctrl_file, ctrl_file_name, buffer);
7856 //
7857 // write_record(t3d_in_file, t3d_in_file_name, "\n");
7858 //
7859 // curve_id++;
7860 // if((j = crack -> qa + 1) >= 4)j -= 4;
7861 // sprintf(buffer, "curve %d order 3 vertex %d %d\n", curve_id, vertex_id - 1, vertex_id);
7862 // write_record(t3d_in_file, t3d_in_file_name, buffer);
7863 // if(bmsz == 0.0){
7864 // default_msz = YES;
7865 // sprintf(buffer, "polygon 1 xyz %e %e %e weight %e\n",
7866 // contact_glob_pnt[j].x, contact_glob_pnt[j].y, contact_glob_pnt[j].z, weight_q);
7867 // }
7868 // else
7869 // sprintf(buffer, "polygon 1 xyz %e %e %e weight %e size %e\n",
7870 // contact_glob_pnt[j].x, contact_glob_pnt[j].y, contact_glob_pnt[j].z, weight_q, bmsz);
7871 // write_record(t3d_in_file, t3d_in_file_name, buffer);
7872 // if(m == 0)iface_crack_cur_id2 = curve_id;
7873 //
7874 // if(ellipsoid -> property != 0 && ellipsoid -> property != prop){
7875 // if(m == 0)
7876 // sprintf(buffer, " Curve %d %d", curve_id - 2 * curves + 8, curve_id);
7877 // else
7878 // sprintf(buffer, " Curve %d %d", curve_id - 2 * curves + 2, curve_id);
7879 // }
7880 // else{
7881 // if(m == 0 || ellipsoid -> property == 0)
7882 // sprintf(buffer, " Curve %d %d", curve_id - curves + 8, curve_id);
7883 // else
7884 // sprintf(buffer, " Curve %d %d", curve_id - curves + 2, curve_id);
7885 // }
7886 // write_record(ctrl_file, ctrl_file_name, buffer);
7887 //
7888 // curve_id++;
7889 // sprintf(buffer, "curve %d order 3 vertex %d %d virtual\n", curve_id, vertex_id, vertex_id - 1);
7890 // write_record(t3d_in_file, t3d_in_file_name, buffer);
7891 // if(bmsz == 0.0){
7892 // default_msz = YES;
7893 // sprintf(buffer, "polygon 1 xyz %e %e %e weight %e\n",
7894 // contact_glob_pnt[j].x, contact_glob_pnt[j].y, contact_glob_pnt[j].z, -weight_q);
7895 // }
7896 // else
7897 // sprintf(buffer, "polygon 1 xyz %e %e %e weight %e size %e\n",
7898 // contact_glob_pnt[j].x, contact_glob_pnt[j].y, contact_glob_pnt[j].z, -weight_q, bmsz);
7899 // write_record(t3d_in_file, t3d_in_file_name, buffer);
7900 // iface_crack_cur_id1 = iface_crack_cur_id3 = -curve_id;
7901 //
7902 // write_record(t3d_in_file, t3d_in_file_name, "\n");
7903 //
7904 // vertex_id++;
7905 // sprintf(buffer, "vertex %d xyz %e %e %e fixed curve %d fixed vertex %d\n", vertex_id,
7906 // crack -> pnt1.x, crack -> pnt1.y, crack -> pnt1.z, curve_id, iface_crack_ver_id1);
7907 // write_record(t3d_in_file, t3d_in_file_name, buffer);
7908 //
7909 // vertex_id++;
7910 // sprintf(buffer, "vertex %d xyz %e %e %e fixed curve %d fixed vertex %d\n", vertex_id,
7911 // crack -> pnt2.x, crack -> pnt2.y, crack -> pnt2.z, curve_id, iface_crack_ver_id2);
7912 // write_record(t3d_in_file, t3d_in_file_name, buffer);
7913 //
7914 // write_record(t3d_in_file, t3d_in_file_name, "\n");
7915 //
7916 // vertex_id++;
7917 // sprintf(buffer, "vertex %d xyz %e %e %e fixed curve %d\n", vertex_id,
7918 // point[0].x, point[0].y, point[0].z, -iface_crack_cur_id1);
7919 // write_record(t3d_in_file, t3d_in_file_name, buffer);
7920 //
7921 // if(m == 0 || ellipsoid -> property == 0)
7922 // sprintf(buffer, " Vertex %d %d", cross_ver_id1 + m, vertex_id);
7923 // else
7924 // sprintf(buffer, " Vertex %d %d", cross_ver_id1, vertex_id);
7925 // write_record(ctrl_file, ctrl_file_name, buffer);
7926 //
7927 // vertex_id++;
7928 // sprintf(buffer, "vertex %d xyz %e %e %e fixed curve %d\n", vertex_id,
7929 // point[1].x, point[1].y, point[1].z, -iface_crack_cur_id3);
7930 // write_record(t3d_in_file, t3d_in_file_name, buffer);
7931 //
7932 // write_record(t3d_in_file, t3d_in_file_name, "\n");
7933 //
7934 // if(m == 0 || ellipsoid -> property == 0)
7935 // sprintf(buffer, " Vertex %d %d", cross_ver_id2 + m, vertex_id);
7936 // else
7937 // sprintf(buffer, " Vertex %d %d", cross_ver_id2, vertex_id);
7938 // write_record(ctrl_file, ctrl_file_name, buffer);
7939 //
7940 // curve_id++;
7941 // sprintf(buffer, "curve %d vertex %d %d fixed curve %d\n", curve_id,
7942 // vertex_id - 3, vertex_id - 1, -iface_crack_cur_id1);
7943 // write_record(t3d_in_file, t3d_in_file_name, buffer);
7944 // if(m == 0)iface_crack_cur_id1a = curve_id;
7945 //
7946 // if(ellipsoid -> property != 0 && ellipsoid -> property != prop){
7947 // if(m == 0)
7948 // sprintf(buffer, " Curve %d %d", curve_id - 2 * curves + 8, curve_id);
7949 // else
7950 // sprintf(buffer, " Curve %d %d", curve_id - 2 * curves + 2, curve_id);
7951 // }
7952 // else{
7953 // if(m == 0 || ellipsoid -> property == 0)
7954 // sprintf(buffer, " Curve %d %d", curve_id - curves + 8, curve_id);
7955 // else
7956 // sprintf(buffer, " Curve %d %d", curve_id - curves + 2, curve_id);
7957 // }
7958 // write_record(ctrl_file, ctrl_file_name, buffer);
7959 //
7960 // curve_id++;
7961 // sprintf(buffer, "curve %d vertex %d %d fixed curve %d\n", curve_id,
7962 // vertex_id - 1, vertex_id - 5, -iface_crack_cur_id1);
7963 // write_record(t3d_in_file, t3d_in_file_name, buffer);
7964 // if(m == 0)iface_crack_cur_id1b = curve_id;
7965 //
7966 // if(ellipsoid -> property != 0 && ellipsoid -> property != prop){
7967 // if(m == 0)
7968 // sprintf(buffer, " Curve %d %d", curve_id - 2 * curves + 8, curve_id);
7969 // else
7970 // sprintf(buffer, " Curve %d %d", curve_id - 2 * curves + 2, curve_id);
7971 // }
7972 // else{
7973 // if(m == 0 || ellipsoid -> property == 0)
7974 // sprintf(buffer, " Curve %d %d", curve_id - curves + 8, curve_id);
7975 // else
7976 // sprintf(buffer, " Curve %d %d", curve_id - curves + 2, curve_id);
7977 // }
7978 // write_record(ctrl_file, ctrl_file_name, buffer);
7979 //
7980 // curve_id++;
7981 // sprintf(buffer, "curve %d vertex %d %d fixed curve %d\n", curve_id,
7982 // vertex_id - 4, vertex_id, -iface_crack_cur_id3);
7983 // write_record(t3d_in_file, t3d_in_file_name, buffer);
7984 // if(m == 0)iface_crack_cur_id3a = curve_id;
7985 //
7986 // if(ellipsoid -> property != 0 && ellipsoid -> property != prop){
7987 // if(m == 0)
7988 // sprintf(buffer, " Curve %d %d", curve_id - 2 * curves + 8, curve_id);
7989 // else
7990 // sprintf(buffer, " Curve %d %d", curve_id - 2 * curves + 2, curve_id);
7991 // }
7992 // else{
7993 // if(m == 0 || ellipsoid -> property == 0)
7994 // sprintf(buffer, " Curve %d %d", curve_id - curves + 8, curve_id);
7995 // else
7996 // sprintf(buffer, " Curve %d %d", curve_id - curves + 2, curve_id);
7997 // }
7998 // write_record(ctrl_file, ctrl_file_name, buffer);
7999 //
8000 // curve_id++;
8001 // sprintf(buffer, "curve %d vertex %d %d fixed curve %d\n", curve_id,
8002 // vertex_id, vertex_id - 2, -iface_crack_cur_id3);
8003 // write_record(t3d_in_file, t3d_in_file_name, buffer);
8004 // if(m == 0)iface_crack_cur_id3b = curve_id;
8005 //
8006 // if(ellipsoid -> property != 0 && ellipsoid -> property != prop){
8007 // if(m == 0)
8008 // sprintf(buffer, " Curve %d %d", curve_id - 2 * curves + 8, curve_id);
8009 // else
8010 // sprintf(buffer, " Curve %d %d", curve_id - 2 * curves + 2, curve_id);
8011 // }
8012 // else{
8013 // if(m == 0 || ellipsoid -> property == 0)
8014 // sprintf(buffer, " Curve %d %d", curve_id - curves + 8, curve_id);
8015 // else
8016 // sprintf(buffer, " Curve %d %d", curve_id - curves + 2, curve_id);
8017 // }
8018 // write_record(ctrl_file, ctrl_file_name, buffer);
8019 //
8020 // write_record(t3d_in_file, t3d_in_file_name, "\n");
8021 // }
8022 // break;
8023 // }
8024 // }
8025 //
8026 // write_record(ctrl_file, ctrl_file_name, "\n");
8027 // }
8028 // }
8029 //
8030 // /* make crack */
8031 //
8032 // if(crack -> segment == YES){
8033 //
8034 // /* it would be desirable to calculate user_eps */
8035 //
8036 // delta_t = EPSILON_T / 100.0;
8037 // fixed_1 = fixed_2 = NO;
8038 // if(crack -> q1 == 1 || crack -> q1 == 3){
8039 // if(crack -> t1 < delta_t)fixed_1 = YES;
8040 // }
8041 // else{
8042 // if(crack -> t1 > 1.0 - delta_t)fixed_1 = YES;
8043 // }
8044 // if(crack -> q2 == 2 || crack -> q2 == 4){
8045 // if(crack -> t2 < delta_t)fixed_2 = YES;
8046 // }
8047 // else{
8048 // if(crack -> t2 > 1.0 - delta_t)fixed_2 = YES;
8049 // }
8050 //
8051 // #ifdef DEBUG
8052 // fprintf(stderr, "crack case %d fixed start %d fixed end %d\n", crack_case, fixed_1, fixed_2);
8053 // #endif
8054 //
8055 // }
8056 //
8057 // #ifdef DEBUG
8058 // else{
8059 // fprintf(stderr, "crack case %d\n", crack_case);
8060 // }
8061 // #endif
8062 //
8063 // if(crack -> segment == NO){
8064 // for(k = 0; k < 2; k++){
8065 //
8066 // /* k = 0 crack boundary
8067 // k = 1 crack interface */
8068 //
8069 // switch(k){
8070 // case 0:
8071 // sprintf(buffer, "# crack boundary\n\n");
8072 // break;
8073 // case 1:
8074 // sprintf(buffer, "# crack interface\n\n");
8075 // break;
8076 // }
8077 //
8078 // write_record(t3d_in_file, t3d_in_file_name, buffer);
8079 //
8080 // if(k == 0){
8081 // if(intersect == 0){
8082 // sprintf(contact_cur_list1, "%d %d", -crack_cur_id1, -crack_cur_id2);
8083 // if(ellipsoid -> interface == 0 && ellipsoid -> property != 0 && ellipsoid -> property == prop)
8084 // sprintf(contact_cur_list2, "%d %d", -crack_cur_id1, -crack_cur_id2);
8085 // else
8086 // sprintf(contact_cur_list2, "%d %d", -(crack_cur_id1 + 2), -(crack_cur_id2 + 2));
8087 // }
8088 // else{
8089 // sprintf(contact_cur_list1, "%d %d %d %d", -crack_cur_id1a, -crack_cur_id1b, -crack_cur_id2a, -crack_cur_id2b);
8090 // if(ellipsoid -> interface == 0 && ellipsoid -> property != 0 && ellipsoid -> property == prop)
8091 // sprintf(contact_cur_list2, "%d %d %d %d", -crack_cur_id1a, -crack_cur_id1b, -crack_cur_id2a, -crack_cur_id2b);
8092 // else
8093 // sprintf(contact_cur_list2, "%d %d %d %d", -(crack_cur_id1a + 2), -(crack_cur_id1b + 2), -(crack_cur_id2a + 2),
8094 // -(crack_cur_id2b + 2));
8095 // }
8096 // }
8097 // else{
8098 //
8099 // /* note: contact of crack interface is always made by pair(s) of curves
8100 // to prevent too high degeneration of crack interface elements */
8101 //
8102 // if(intersect == 0){
8103 // sprintf(contact_cur_list1, "%d %d", -iface_crack_cur_id1, -iface_crack_cur_id2);
8104 // sprintf(contact_cur_list2, "%d %d", -(iface_crack_cur_id1 + 2), -(iface_crack_cur_id2 + 2));
8105 // }
8106 // else{
8107 // sprintf(contact_cur_list1, "%d %d %d %d", -iface_crack_cur_id1a, -iface_crack_cur_id1b, -iface_crack_cur_id2a,
8108 // -iface_crack_cur_id2b);
8109 // sprintf(contact_cur_list2, "%d %d %d %d", -(iface_crack_cur_id1a + 2), -(iface_crack_cur_id1b + 2),
8110 // -(iface_crack_cur_id2a + 2), -(iface_crack_cur_id2b + 2));
8111 // }
8112 //
8113 // sprintf(buffer, "MasterSlave");
8114 // write_record(ctrl_file, ctrl_file_name, buffer);
8115 // }
8116 //
8117 // for(i = 0; i < 2; i++){
8118 // vertex_id++;
8119 // j = 2 * i;
8120 // if(tmsz == 0.0){
8121 // default_msz = YES;
8122 // sprintf(buffer, "vertex %d xyz %e %e %e\n", vertex_id,
8123 // crack_glob_point[j].x, crack_glob_point[j].y, crack_glob_point[j].z);
8124 // }
8125 // else
8126 // sprintf(buffer, "vertex %d xyz %e %e %e size %e\n", vertex_id,
8127 // crack_glob_point[j].x, crack_glob_point[j].y, crack_glob_point[j].z, tmsz);
8128 // write_record(t3d_in_file, t3d_in_file_name, buffer);
8129 //
8130 // if(k == 1){
8131 // sprintf(buffer, " Vertex %d %d", vertex_id - 2, vertex_id);
8132 // write_record(ctrl_file, ctrl_file_name, buffer);
8133 // }
8134 // }
8135 //
8136 // write_record(t3d_in_file, t3d_in_file_name, "\n");
8137 //
8138 // for(i = 0; i < 2; i++){
8139 // curve_id++;
8140 // sprintf(buffer, "curve %d order 4 vertex %d %d\n", curve_id, vertex_id - 1 + i, vertex_id - i);
8141 // write_record(t3d_in_file, t3d_in_file_name, buffer);
8142 //
8143 // for(j = 0; j < 2; j++){
8144 // n = 2 * i + j;
8145 // if(tmsz == 0.0){
8146 // default_msz = YES;
8147 // sprintf(buffer, "polygon %d xyz %e %e %e weight %e\n", j + 1,
8148 // crack_glob_pnt[n].x, crack_glob_pnt[n].y, crack_glob_pnt[n].z, weight_h);
8149 // }
8150 // else
8151 // sprintf(buffer, "polygon %d xyz %e %e %e weight %e size %e\n", j + 1,
8152 // crack_glob_pnt[n].x, crack_glob_pnt[n].y, crack_glob_pnt[n].z, weight_h, tmsz);
8153 // write_record(t3d_in_file, t3d_in_file_name, buffer);
8154 // }
8155 //
8156 // if(k == 1){
8157 // sprintf(buffer, " Curve %d %d", curve_id - 2, curve_id);
8158 // write_record(ctrl_file, ctrl_file_name, buffer);
8159 // }
8160 // }
8161 //
8162 // write_record(t3d_in_file, t3d_in_file_name, "\n");
8163 //
8164 // if(k == 0){
8165 // sprintf(crack_tip_ver_list, "%d %d", vertex_id - 1, vertex_id);
8166 // sprintf(crack_tip_cur_list, "%d %d", curve_id - 1, curve_id);
8167 // }
8168 //
8169 // patch_id++;
8170 // if(cmsz == 0.0){
8171 // default_msz = YES;
8172 // sprintf(buffer, "patch %d normal %e %e %e boundary curve %d %d %s size def\n", patch_id,
8173 // contact -> normal.x, contact -> normal.y, contact -> normal.z, curve_id - 1, curve_id, contact_cur_list1);
8174 // }
8175 // else
8176 // sprintf(buffer, "patch %d normal %e %e %e boundary curve %d %d %s size %e\n", patch_id,
8177 // contact -> normal.x, contact -> normal.y, contact -> normal.z, curve_id - 1, curve_id, contact_cur_list1, cmsz);
8178 // write_record(t3d_in_file, t3d_in_file_name, buffer);
8179 // if(k == 0)crack_patch_id = patch_id;
8180 //
8181 // if(k == 1){
8182 // sprintf(buffer, " Patch %d %d", crack_patch_id, patch_id);
8183 // write_record(ctrl_file, ctrl_file_name, buffer);
8184 // }
8185 //
8186 // patch_id++;
8187 // if(cmsz == 0.0){
8188 // default_msz = YES;
8189 // sprintf(buffer, "patch %d normal %e %e %e boundary curve %d %d %s size def coincide patch %d\n", patch_id,
8190 // contact -> normal.x, contact -> normal.y, contact -> normal.z, curve_id - 1, curve_id,
8191 // contact_cur_list2, patch_id - 1);
8192 // }
8193 // else
8194 // sprintf(buffer, "patch %d normal %e %e %e boundary curve %d %d %s size %e coincide patch %d\n", patch_id,
8195 // contact -> normal.x, contact -> normal.y, contact -> normal.z, curve_id - 1, curve_id,
8196 // contact_cur_list2, cmsz, patch_id - 1);
8197 // write_record(t3d_in_file, t3d_in_file_name, buffer);
8198 //
8199 // if(k == 1){
8200 // sprintf(buffer, " Patch %d %d", crack_patch_id + 1, patch_id);
8201 // write_record(ctrl_file, ctrl_file_name, buffer);
8202 // }
8203 //
8204 // write_record(t3d_in_file, t3d_in_file_name, "\n");
8205 //
8206 // #ifdef MERLIN
8207 // if(crack -> interface == 0)break;
8208 // #else
8209 // break;
8210 // #endif
8211 //
8212 // if(k == 1){
8213 // write_record(ctrl_file, ctrl_file_name, "\n");
8214 //
8215 // /* the patches forming crack surface are created in the direction of the (common) outer normal
8216 // this determines the order of patches in Interface statement
8217 //
8218 // <--------------------- outer normal
8219 // patch 12 | | patch 11 (patch 12 is closer than patch 11 when viewing against outer normal) */
8220 //
8221 // sprintf(buffer, "Interface %d Patch %d %d\n", crack -> interface, patch_id - 1, patch_id);
8222 // write_record(ctrl_file, ctrl_file_name, buffer);
8223 // }
8224 // }
8225 // }
8226 // else{
8227 // for(k = 0; k < 2; k++){
8228 //
8229 // /* k = 0 crack boundary
8230 // k = 1 crack interface */
8231 //
8232 // switch(k){
8233 // case 0:
8234 // sprintf(buffer, "# crack boundary\n\n");
8235 // break;
8236 // case 1:
8237 // sprintf(buffer, "# crack interface\n\n");
8238 // break;
8239 // }
8240 //
8241 // write_record(t3d_in_file, t3d_in_file_name, buffer);
8242 //
8243 // if(k == 0){
8244 // crack_vertex_id1 = crack_ver_id1;
8245 // crack_vertex_id2 = crack_ver_id2;
8246 //
8247 // switch(contact_case){
8248 // case 1:
8249 // case 2:
8250 // case 3:
8251 // if(crack_cur_id1 > 0){
8252 // sprintf(contact_cur_list1, "%d", -crack_cur_id1);
8253 // if(ellipsoid -> interface == 0 && ellipsoid -> property != 0 && ellipsoid -> property == prop)
8254 // sprintf(contact_cur_list2, "%d", -crack_cur_id1);
8255 // else
8256 // sprintf(contact_cur_list2, "%d", -(crack_cur_id1 + 1));
8257 // }
8258 // else{
8259 // sprintf(contact_cur_list1, "%d %d", -crack_cur_id1a, -crack_cur_id1b);
8260 // if(ellipsoid -> interface == 0 && ellipsoid -> property != 0 && ellipsoid -> property == prop)
8261 // sprintf(contact_cur_list2, "%d %d", -crack_cur_id1a, -crack_cur_id1b);
8262 // else
8263 // sprintf(contact_cur_list2, "%d %d", -(crack_cur_id1a + 2), -(crack_cur_id1b + 2));
8264 // }
8265 // break;
8266 // case 4:
8267 // switch(intersect){
8268 // case 0:
8269 // sprintf(contact_cur_list1, "%d %d", -crack_cur_id1, -crack_cur_id2);
8270 // if(ellipsoid -> interface == 0 && ellipsoid -> property != 0 && ellipsoid -> property == prop)
8271 // sprintf(contact_cur_list2, "%d %d", -crack_cur_id1, -crack_cur_id2);
8272 // else
8273 // sprintf(contact_cur_list2, "%d %d", -(crack_cur_id1 + 4), -(crack_cur_id2 + 4));
8274 // break;
8275 // case 1:
8276 // if(first_curve == YES){
8277 // sprintf(contact_cur_list1, "%d %d %d", -crack_cur_id1a, -crack_cur_id1b, -crack_cur_id2);
8278 // if(ellipsoid -> interface == 0 && ellipsoid -> property != 0 && ellipsoid -> property == prop)
8279 // sprintf(contact_cur_list2, "%d %d %d", -crack_cur_id1a, -crack_cur_id1b, -crack_cur_id2);
8280 // else
8281 // sprintf(contact_cur_list2, "%d %d %d", -(crack_cur_id1a + 5), -(crack_cur_id1b + 5), -(crack_cur_id2 + 5));
8282 // }
8283 // else{
8284 // sprintf(contact_cur_list1, "%d %d %d", -crack_cur_id1, -crack_cur_id2a, -crack_cur_id2b);
8285 // if(ellipsoid -> interface == 0 && ellipsoid -> property != 0 && ellipsoid -> property == prop)
8286 // sprintf(contact_cur_list2, "%d %d %d", -crack_cur_id1, -crack_cur_id2a, -crack_cur_id2b);
8287 // else
8288 // sprintf(contact_cur_list2, "%d %d %d", -(crack_cur_id1 + 5), -(crack_cur_id2a + 5), -(crack_cur_id2b + 5));
8289 // }
8290 // break;
8291 // case 2:
8292 // sprintf(contact_cur_list1, "%d %d %d %d", -crack_cur_id1a, -crack_cur_id1b, -crack_cur_id2a, -crack_cur_id2b);
8293 // if(ellipsoid -> interface == 0 && ellipsoid -> property != 0 && ellipsoid -> property == prop)
8294 // sprintf(contact_cur_list2, "%d %d %d %d", -crack_cur_id1a, -crack_cur_id1b, -crack_cur_id2a, -crack_cur_id2b);
8295 // else
8296 // sprintf(contact_cur_list2, "%d %d %d %d", -(crack_cur_id1a + 6), -(crack_cur_id1b + 6), -(crack_cur_id2a + 6),
8297 // -(crack_cur_id2b + 6));
8298 // break;
8299 // }
8300 // break;
8301 // case 5:
8302 // if(intersect == 0){
8303 // sprintf(contact_cur_list1, "%d %d %d", -crack_cur_id1, -crack_cur_id2, -crack_cur_id3);
8304 // if(ellipsoid -> interface == 0 && ellipsoid -> property != 0 && ellipsoid -> property == prop)
8305 // sprintf(contact_cur_list2, "%d %d %d", -crack_cur_id1, -crack_cur_id2, -crack_cur_id3);
8306 // else
8307 // sprintf(contact_cur_list2, "%d %d %d", -(crack_cur_id1 + 4), -(crack_cur_id2 + 4), -(crack_cur_id3 + 4));
8308 // }
8309 // else{
8310 // sprintf(contact_cur_list1, "%d %d %d %d %d", -crack_cur_id1a, -crack_cur_id1b, -crack_cur_id2, -crack_cur_id3a,
8311 // -crack_cur_id3b);
8312 // if(ellipsoid -> interface == 0 && ellipsoid -> property != 0 && ellipsoid -> property == prop)
8313 // sprintf(contact_cur_list2, "%d %d %d %d %d", -crack_cur_id1a, -crack_cur_id1b, -crack_cur_id2, -crack_cur_id3a,
8314 // -crack_cur_id3b);
8315 // else
8316 // sprintf(contact_cur_list2, "%d %d %d %d %d", -(crack_cur_id1a + 6), -(crack_cur_id1b + 6), -(crack_cur_id2 + 6),
8317 // -(crack_cur_id3a + 6), -(crack_cur_id3b + 6));
8318 // }
8319 // break;
8320 // }
8321 // }
8322 // else{
8323 // crack_vertex_id1 = iface_crack_ver_id1;
8324 // crack_vertex_id2 = iface_crack_ver_id2;
8325 //
8326 // /* note: contact of crack interface is always made by pair(s) of curves
8327 // to prevent too high degeneration of crack interface elements */
8328 //
8329 // switch(contact_case){
8330 // case 1:
8331 // case 2:
8332 // case 3:
8333 // if(crack_cur_id1 > 0){
8334 // sprintf(contact_cur_list1, "%d", -iface_crack_cur_id1);
8335 // sprintf(contact_cur_list2, "%d", -(iface_crack_cur_id1 + 1));
8336 // }
8337 // else{
8338 // sprintf(contact_cur_list1, "%d %d", -iface_crack_cur_id1a, -iface_crack_cur_id1b);
8339 // sprintf(contact_cur_list2, "%d %d", -(iface_crack_cur_id1a + 2), -(iface_crack_cur_id1b + 2));
8340 // }
8341 // break;
8342 // case 4:
8343 // switch(intersect){
8344 // case 0:
8345 // sprintf(contact_cur_list1, "%d %d", -iface_crack_cur_id1, -iface_crack_cur_id2);
8346 // sprintf(contact_cur_list2, "%d %d", -(iface_crack_cur_id1 + 4), -(iface_crack_cur_id2 + 4));
8347 // break;
8348 // case 1:
8349 // if(first_curve == YES){
8350 // sprintf(contact_cur_list1, "%d %d %d", -iface_crack_cur_id1a, -iface_crack_cur_id1b, -iface_crack_cur_id2);
8351 // sprintf(contact_cur_list2, "%d %d %d", -(iface_crack_cur_id1a + 5), -(iface_crack_cur_id1b + 5),
8352 // -(iface_crack_cur_id2 + 5));
8353 // }
8354 // else{
8355 // sprintf(contact_cur_list1, "%d %d %d", -iface_crack_cur_id1, -iface_crack_cur_id2a, -iface_crack_cur_id2b);
8356 // sprintf(contact_cur_list2, "%d %d %d", -(iface_crack_cur_id1 + 5), -(iface_crack_cur_id2a + 5),
8357 // -(iface_crack_cur_id2b + 5));
8358 // }
8359 // break;
8360 // case 2:
8361 // sprintf(contact_cur_list1, "%d %d %d %d", -iface_crack_cur_id1a, -iface_crack_cur_id1b, -iface_crack_cur_id2a,
8362 // -iface_crack_cur_id2b);
8363 // sprintf(contact_cur_list2, "%d %d %d %d", -(iface_crack_cur_id1a + 6), -(iface_crack_cur_id1b + 6),
8364 // -(iface_crack_cur_id2a + 6), -(iface_crack_cur_id2b + 6));
8365 // break;
8366 // }
8367 // break;
8368 // case 5:
8369 // if(intersect == 0){
8370 // sprintf(contact_cur_list1, "%d %d %d", -iface_crack_cur_id1, -iface_crack_cur_id2, -iface_crack_cur_id3);
8371 // sprintf(contact_cur_list2, "%d %d %d", -(iface_crack_cur_id1 + 4), -(iface_crack_cur_id2 + 4),
8372 // -(iface_crack_cur_id3 + 4));
8373 // }
8374 // else{
8375 // sprintf(contact_cur_list1, "%d %d %d %d %d", -iface_crack_cur_id1a, -iface_crack_cur_id1b, -iface_crack_cur_id2,
8376 // -iface_crack_cur_id3a, -iface_crack_cur_id3b);
8377 // sprintf(contact_cur_list2, "%d %d %d %d %d", -(iface_crack_cur_id1a + 6), -(iface_crack_cur_id1b + 6),
8378 // -(iface_crack_cur_id2 + 6), -(iface_crack_cur_id3a + 6), -(iface_crack_cur_id3b + 6));
8379 // }
8380 // break;
8381 // }
8382 //
8383 // sprintf(buffer, "MasterSlave");
8384 // write_record(ctrl_file, ctrl_file_name, buffer);
8385 // }
8386 //
8387 // switch(crack_case){
8388 // case 1:
8389 // vertex_id++;
8390 // if(fixed_1 == NO){
8391 // j = crack -> q1 - 1;
8392 // if(bmsz == 0.0){
8393 // default_msz = YES;
8394 // sprintf(buffer, "vertex %d xyz %e %e %e virtual\n", vertex_id,
8395 // crack_glob_point[j].x, crack_glob_point[j].y, crack_glob_point[j].z);
8396 // }
8397 // else
8398 // sprintf(buffer, "vertex %d xyz %e %e %e size %e virtual\n", vertex_id,
8399 // crack_glob_point[j].x, crack_glob_point[j].y, crack_glob_point[j].z, bmsz);
8400 // }
8401 // else{
8402 // if(bmsz == 0.0){
8403 // default_msz = YES;
8404 // sprintf(buffer, "vertex %d fixed vertex %d size def\n", vertex_id, crack_vertex_id1);
8405 // }
8406 // else
8407 // sprintf(buffer, "vertex %d fixed vertex %d size %e\n", vertex_id, crack_vertex_id1, bmsz);
8408 // }
8409 // write_record(t3d_in_file, t3d_in_file_name, buffer);
8410 //
8411 // vertex_id++;
8412 // if(fixed_2 == NO){
8413 // if((j = crack -> q1) >= 4)j -= 4;
8414 // if(bmsz == 0.0){
8415 // default_msz = YES;
8416 // sprintf(buffer, "vertex %d xyz %e %e %e virtual\n", vertex_id,
8417 // crack_glob_point[j].x, crack_glob_point[j].y, crack_glob_point[j].z);
8418 // }
8419 // else
8420 // sprintf(buffer, "vertex %d xyz %e %e %e size %e virtual\n", vertex_id,
8421 // crack_glob_point[j].x, crack_glob_point[j].y, crack_glob_point[j].z, bmsz);
8422 // }
8423 // else{
8424 // if(bmsz == 0.0){
8425 // default_msz = YES;
8426 // sprintf(buffer, "vertex %d fixed vertex %d size def\n", vertex_id, crack_vertex_id2);
8427 // }
8428 // else
8429 // sprintf(buffer, "vertex %d fixed vertex %d size %e\n", vertex_id, crack_vertex_id2, bmsz);
8430 // }
8431 // write_record(t3d_in_file, t3d_in_file_name, buffer);
8432 //
8433 // write_record(t3d_in_file, t3d_in_file_name, "\n");
8434 //
8435 // j = crack -> q1 - 1;
8436 // curve_id++;
8437 // sprintf(buffer, "curve %d order 3 vertex %d %d virtual\n", curve_id, vertex_id - 1, vertex_id);
8438 // write_record(t3d_in_file, t3d_in_file_name, buffer);
8439 // if(bmsz == 0.0){
8440 // default_msz = YES;
8441 // sprintf(buffer, "polygon 1 xyz %e %e %e weight %e\n",
8442 // crack_glob_pnt[j].x, crack_glob_pnt[j].y, crack_glob_pnt[j].z, weight_q);
8443 // }
8444 // else
8445 // sprintf(buffer, "polygon 1 xyz %e %e %e weight %e size %e\n",
8446 // crack_glob_pnt[j].x, crack_glob_pnt[j].y, crack_glob_pnt[j].z, weight_q, bmsz);
8447 // write_record(t3d_in_file, t3d_in_file_name, buffer);
8448 //
8449 // write_record(t3d_in_file, t3d_in_file_name, "\n");
8450 //
8451 // vertex_id++;
8452 // if(fixed_1 == NO)
8453 // sprintf(buffer, "vertex %d xyz %e %e %e fixed curve %d fixed vertex %d\n", vertex_id,
8454 // crack -> pnt1.x, crack -> pnt1.y, crack -> pnt1.z, curve_id, crack_vertex_id1);
8455 // else
8456 // sprintf(buffer, "vertex %d fixed vertex %d\n", vertex_id, vertex_id - 2);
8457 // write_record(t3d_in_file, t3d_in_file_name, buffer);
8458 //
8459 // vertex_id++;
8460 // if(fixed_2 == NO)
8461 // sprintf(buffer, "vertex %d xyz %e %e %e fixed curve %d fixed vertex %d\n", vertex_id,
8462 // crack -> pnt2.x, crack -> pnt2.y, crack -> pnt2.z, curve_id, crack_vertex_id2);
8463 // else
8464 // sprintf(buffer, "vertex %d fixed vertex %d\n", vertex_id, vertex_id - 2);
8465 // write_record(t3d_in_file, t3d_in_file_name, buffer);
8466 //
8467 // write_record(t3d_in_file, t3d_in_file_name, "\n");
8468 //
8469 // curve_id++;
8470 // sprintf(buffer, "curve %d vertex %d %d fixed curve %d\n", curve_id,
8471 // vertex_id - 1, vertex_id, curve_id - 1);
8472 // write_record(t3d_in_file, t3d_in_file_name, buffer);
8473 //
8474 // write_record(t3d_in_file, t3d_in_file_name, "\n");
8475 //
8476 // if(k == 1){
8477 // sprintf(buffer, " Curve %d %d", curve_id - 2, curve_id);
8478 // write_record(ctrl_file, ctrl_file_name, buffer);
8479 // }
8480 //
8481 // sprintf(crack_cur_list, "%d", curve_id);
8482 // if(k == 0){
8483 // *crack_tip_ver_list = '\0';
8484 // sprintf(crack_tip_cur_list, "%d", curve_id);
8485 // }
8486 // break;
8487 //
8488 // case 2:
8489 // vertex_id++;
8490 // if(fixed_1 == NO){
8491 // j = crack -> q1 - 1;
8492 // if(bmsz == 0.0){
8493 // default_msz = YES;
8494 // sprintf(buffer, "vertex %d xyz %e %e %e virtual\n", vertex_id,
8495 // crack_glob_point[j].x, crack_glob_point[j].y, crack_glob_point[j].z);
8496 // }
8497 // else
8498 // sprintf(buffer, "vertex %d xyz %e %e %e size %e virtual\n", vertex_id,
8499 // crack_glob_point[j].x, crack_glob_point[j].y, crack_glob_point[j].z, bmsz);
8500 // }
8501 // else{
8502 // if(bmsz == 0.0){
8503 // default_msz = YES;
8504 // sprintf(buffer, "vertex %d fixed vertex %d size def\n", vertex_id, crack_vertex_id1);
8505 // }
8506 // else
8507 // sprintf(buffer, "vertex %d fixed vertex %d size %e\n", vertex_id, crack_vertex_id1, bmsz);
8508 // }
8509 // write_record(t3d_in_file, t3d_in_file_name, buffer);
8510 //
8511 // vertex_id++;
8512 // if(fixed_2 == NO){
8513 // if((j = crack -> q1 + 1) >= 4)j -= 4;
8514 // if(bmsz == 0.0){
8515 // default_msz = YES;
8516 // sprintf(buffer, "vertex %d xyz %e %e %e virtual\n", vertex_id,
8517 // crack_glob_point[j].x, crack_glob_point[j].y, crack_glob_point[j].z);
8518 // }
8519 // else
8520 // sprintf(buffer, "vertex %d xyz %e %e %e size %e virtual\n", vertex_id,
8521 // crack_glob_point[j].x, crack_glob_point[j].y, crack_glob_point[j].z, bmsz);
8522 // }
8523 // else{
8524 // if(bmsz == 0.0){
8525 // default_msz = YES;
8526 // sprintf(buffer, "vertex %d fixed vertex %d size def\n", vertex_id, crack_vertex_id2);
8527 // }
8528 // else
8529 // sprintf(buffer, "vertex %d fixed vertex %d size %e\n", vertex_id, crack_vertex_id2, bmsz);
8530 // }
8531 // write_record(t3d_in_file, t3d_in_file_name, buffer);
8532 //
8533 // write_record(t3d_in_file, t3d_in_file_name, "\n");
8534 //
8535 // curve_id++;
8536 // sprintf(buffer, "curve %d order 4 vertex %d %d virtual\n", curve_id, vertex_id - 1, vertex_id);
8537 // write_record(t3d_in_file, t3d_in_file_name, buffer);
8538 // for(i = 0; i < 2; i++){
8539 // if((j = crack -> q1 - 1 + i) >= 4)j -= 4;
8540 // if(bmsz == 0.0){
8541 // default_msz = YES;
8542 // sprintf(buffer, "polygon %d xyz %e %e %e weight %e\n", i + 1,
8543 // crack_glob_pnt[j].x, crack_glob_pnt[j].y, crack_glob_pnt[j].z, weight_h);
8544 // }
8545 // else
8546 // sprintf(buffer, "polygon %d xyz %e %e %e weight %e size %e\n", i + 1,
8547 // crack_glob_pnt[j].x, crack_glob_pnt[j].y, crack_glob_pnt[j].z, weight_h, bmsz);
8548 // write_record(t3d_in_file, t3d_in_file_name, buffer);
8549 // }
8550 //
8551 // write_record(t3d_in_file, t3d_in_file_name, "\n");
8552 //
8553 // vertex_id++;
8554 // if(fixed_1 == NO)
8555 // sprintf(buffer, "vertex %d xyz %e %e %e fixed curve %d fixed vertex %d\n", vertex_id,
8556 // crack -> pnt1.x, crack -> pnt1.y, crack -> pnt1.z, curve_id, crack_vertex_id1);
8557 // else
8558 // sprintf(buffer, "vertex %d fixed vertex %d\n", vertex_id, vertex_id - 2);
8559 // write_record(t3d_in_file, t3d_in_file_name, buffer);
8560 //
8561 // vertex_id++;
8562 // if(fixed_2 == NO)
8563 // sprintf(buffer, "vertex %d xyz %e %e %e fixed curve %d fixed vertex %d\n", vertex_id,
8564 // crack -> pnt2.x, crack -> pnt2.y, crack -> pnt2.z, curve_id, crack_vertex_id2);
8565 // else
8566 // sprintf(buffer, "vertex %d fixed vertex %d\n", vertex_id, vertex_id - 2);
8567 // write_record(t3d_in_file, t3d_in_file_name, buffer);
8568 //
8569 // write_record(t3d_in_file, t3d_in_file_name, "\n");
8570 //
8571 // curve_id++;
8572 // sprintf(buffer, "curve %d vertex %d %d fixed curve %d\n", curve_id,
8573 // vertex_id - 1, vertex_id, curve_id - 1);
8574 // write_record(t3d_in_file, t3d_in_file_name, buffer);
8575 //
8576 // write_record(t3d_in_file, t3d_in_file_name, "\n");
8577 //
8578 // if(k == 1){
8579 // sprintf(buffer, " Curve %d %d", curve_id - 2, curve_id);
8580 // write_record(ctrl_file, ctrl_file_name, buffer);
8581 // }
8582 //
8583 // sprintf(crack_cur_list, "%d", curve_id);
8584 // if(k == 0){
8585 // *crack_tip_ver_list = '\0';
8586 // sprintf(crack_tip_cur_list, "%d", curve_id);
8587 // }
8588 // break;
8589 //
8590 // case 3:
8591 // vertex_id++;
8592 // if(fixed_1 == NO){
8593 // j = crack -> q1 - 1;
8594 // if(bmsz == 0.0){
8595 // default_msz = YES;
8596 // sprintf(buffer, "vertex %d xyz %e %e %e virtual\n", vertex_id,
8597 // crack_glob_point[j].x, crack_glob_point[j].y, crack_glob_point[j].z);
8598 // }
8599 // else
8600 // sprintf(buffer, "vertex %d xyz %e %e %e size %e virtual\n", vertex_id,
8601 // crack_glob_point[j].x, crack_glob_point[j].y, crack_glob_point[j].z, bmsz);
8602 // }
8603 // else{
8604 // if(bmsz == 0.0){
8605 // default_msz = YES;
8606 // sprintf(buffer, "vertex %d fixed vertex %d size def\n", vertex_id, crack_vertex_id1);
8607 // }
8608 // else
8609 // sprintf(buffer, "vertex %d fixed vertex %d size %e\n", vertex_id, crack_vertex_id1, bmsz);
8610 // }
8611 // write_record(t3d_in_file, t3d_in_file_name, buffer);
8612 //
8613 // vertex_id++;
8614 // if(fixed_2 == NO){
8615 // if((j = crack -> q1 + 2) >= 4)j -= 4;
8616 // if(bmsz == 0.0){
8617 // default_msz = YES;
8618 // sprintf(buffer, "vertex %d xyz %e %e %e virtual\n", vertex_id,
8619 // crack_glob_point[j].x, crack_glob_point[j].y, crack_glob_point[j].z);
8620 // }
8621 // else
8622 // sprintf(buffer, "vertex %d xyz %e %e %e size %e virtual\n", vertex_id,
8623 // crack_glob_point[j].x, crack_glob_point[j].y, crack_glob_point[j].z, bmsz);
8624 // }
8625 // else{
8626 // if(bmsz == 0.0){
8627 // default_msz = YES;
8628 // sprintf(buffer, "vertex %d fixed vertex %d size def\n", vertex_id, crack_vertex_id2);
8629 // }
8630 // else
8631 // sprintf(buffer, "vertex %d fixed vertex %d size %e\n", vertex_id, crack_vertex_id2, bmsz);
8632 // }
8633 // write_record(t3d_in_file, t3d_in_file_name, buffer);
8634 //
8635 // write_record(t3d_in_file, t3d_in_file_name, "\n");
8636 //
8637 // if((j = crack -> q1 + 2) >= 4)j -= 4;
8638 // curve_id++;
8639 // sprintf(buffer, "curve %d order 3 vertex %d %d virtual\n", curve_id, vertex_id - 1, vertex_id);
8640 // write_record(t3d_in_file, t3d_in_file_name, buffer);
8641 // if(bmsz == 0.0){
8642 // default_msz = YES;
8643 // sprintf(buffer, "polygon 1 xyz %e %e %e weight %e\n",
8644 // crack_glob_pnt[j].x, crack_glob_pnt[j].y, crack_glob_pnt[j].z, -weight_q);
8645 // }
8646 // else
8647 // sprintf(buffer, "polygon 1 xyz %e %e %e weight %e size %e\n",
8648 // crack_glob_pnt[j].x, crack_glob_pnt[j].y, crack_glob_pnt[j].z, -weight_q, bmsz);
8649 // write_record(t3d_in_file, t3d_in_file_name, buffer);
8650 //
8651 // write_record(t3d_in_file, t3d_in_file_name, "\n");
8652 //
8653 // vertex_id++;
8654 // if(fixed_1 == NO)
8655 // sprintf(buffer, "vertex %d xyz %e %e %e fixed curve %d fixed vertex %d\n", vertex_id,
8656 // crack -> pnt1.x, crack -> pnt1.y, crack -> pnt1.z, curve_id, crack_vertex_id1);
8657 // else
8658 // sprintf(buffer, "vertex %d fixed vertex %d\n", vertex_id, vertex_id - 2);
8659 // write_record(t3d_in_file, t3d_in_file_name, buffer);
8660 //
8661 // vertex_id++;
8662 // if(fixed_2 == NO)
8663 // sprintf(buffer, "vertex %d xyz %e %e %e fixed curve %d fixed vertex %d\n", vertex_id,
8664 // crack -> pnt2.x, crack -> pnt2.y, crack -> pnt2.z, curve_id, crack_vertex_id2);
8665 // else
8666 // sprintf(buffer, "vertex %d fixed vertex %d\n", vertex_id, vertex_id - 2);
8667 // write_record(t3d_in_file, t3d_in_file_name, buffer);
8668 //
8669 // write_record(t3d_in_file, t3d_in_file_name, "\n");
8670 //
8671 // curve_id++;
8672 // sprintf(buffer, "curve %d vertex %d %d fixed curve %d\n", curve_id,
8673 // vertex_id - 1, vertex_id, curve_id - 1);
8674 // write_record(t3d_in_file, t3d_in_file_name, buffer);
8675 //
8676 // write_record(t3d_in_file, t3d_in_file_name, "\n");
8677 //
8678 // if(k == 1){
8679 // sprintf(buffer, " Curve %d %d", curve_id - 2, curve_id);
8680 // write_record(ctrl_file, ctrl_file_name, buffer);
8681 // }
8682 //
8683 // sprintf(crack_cur_list, "%d", curve_id);
8684 // if(k == 0){
8685 // *crack_tip_ver_list = '\0';
8686 // sprintf(crack_tip_cur_list, "%d", curve_id);
8687 // }
8688 // break;
8689 //
8690 // case 4:
8691 // if(fixed_1 == YES && fixed_2 == YES)
8692 // error_message(GENERAL_ERROR, "Unimplemented situation");
8693 //
8694 // vertex_id++;
8695 // if(fixed_1 == NO && fixed_2 == NO){
8696 // j = crack -> q1 - 1;
8697 // if(bmsz == 0.0){
8698 // default_msz = YES;
8699 // sprintf(buffer, "vertex %d xyz %e %e %e virtual\n", vertex_id,
8700 // crack_glob_point[j].x, crack_glob_point[j].y, crack_glob_point[j].z);
8701 // }
8702 // else
8703 // sprintf(buffer, "vertex %d xyz %e %e %e size %e virtual\n", vertex_id,
8704 // crack_glob_point[j].x, crack_glob_point[j].y, crack_glob_point[j].z, bmsz);
8705 // }
8706 // else{
8707 // if(fixed_1 == YES){
8708 // if(bmsz == 0.0){
8709 // default_msz = YES;
8710 // sprintf(buffer, "vertex %d fixed vertex %d size def\n", vertex_id, crack_vertex_id1);
8711 // }
8712 // else
8713 // sprintf(buffer, "vertex %d fixed vertex %d size %e\n", vertex_id, crack_vertex_id1, bmsz);
8714 // }
8715 // if(fixed_2 == YES){
8716 // if(bmsz == 0.0){
8717 // default_msz = YES;
8718 // sprintf(buffer, "vertex %d fixed vertex %d size def\n", vertex_id, crack_vertex_id2);
8719 // }
8720 // else
8721 // sprintf(buffer, "vertex %d fixed vertex %d size %e\n", vertex_id, crack_vertex_id2, bmsz);
8722 // }
8723 // }
8724 // write_record(t3d_in_file, t3d_in_file_name, buffer);
8725 //
8726 // if((j = crack -> q1 + 1) >= 4)j -= 4;
8727 // vertex_id++;
8728 // if(bmsz == 0.0){
8729 // default_msz = YES;
8730 // sprintf(buffer, "vertex %d xyz %e %e %e\n", vertex_id,
8731 // crack_glob_point[j].x, crack_glob_point[j].y, crack_glob_point[j].z);
8732 // }
8733 // else
8734 // sprintf(buffer, "vertex %d xyz %e %e %e size %e\n", vertex_id,
8735 // crack_glob_point[j].x, crack_glob_point[j].y, crack_glob_point[j].z, bmsz);
8736 // write_record(t3d_in_file, t3d_in_file_name, buffer);
8737 //
8738 // if(k == 1){
8739 // sprintf(buffer, " Vertex %d %d", vertex_id - 4, vertex_id);
8740 // write_record(ctrl_file, ctrl_file_name, buffer);
8741 // }
8742 //
8743 // if(k == 0)sprintf(crack_tip_ver_list, "%d", vertex_id);
8744 //
8745 // write_record(t3d_in_file, t3d_in_file_name, "\n");
8746 //
8747 // curve_id++;
8748 // sprintf(buffer, "curve %d order 4 vertex %d %d virtual\n", curve_id, vertex_id - 1, vertex_id);
8749 // write_record(t3d_in_file, t3d_in_file_name, buffer);
8750 // for(i = 0; i < 2; i++){
8751 // if((j = crack -> q1 - 1 + i) >= 4)j -= 4;
8752 // if(bmsz == 0.0){
8753 // default_msz = YES;
8754 // sprintf(buffer, "polygon %d xyz %e %e %e weight %e\n", i + 1,
8755 // crack_glob_pnt[j].x, crack_glob_pnt[j].y, crack_glob_pnt[j].z, weight_h);
8756 // }
8757 // else
8758 // sprintf(buffer, "polygon %d xyz %e %e %e weight %e size %e\n", i + 1,
8759 // crack_glob_pnt[j].x, crack_glob_pnt[j].y, crack_glob_pnt[j].z, weight_h, bmsz);
8760 // write_record(t3d_in_file, t3d_in_file_name, buffer);
8761 // }
8762 //
8763 // curve_id++;
8764 // sprintf(buffer, "curve %d order 4 vertex %d %d virtual\n", curve_id, vertex_id, vertex_id - 1);
8765 // write_record(t3d_in_file, t3d_in_file_name, buffer);
8766 // for(i = 0; i < 2; i++){
8767 // if((j = crack -> q1 + 1 + i) >= 4)j -= 4;
8768 // if(bmsz == 0.0){
8769 // default_msz = YES;
8770 // sprintf(buffer, "polygon %d xyz %e %e %e weight %e\n", i + 1,
8771 // crack_glob_pnt[j].x, crack_glob_pnt[j].y, crack_glob_pnt[j].z, weight_h);
8772 // }
8773 // else
8774 // sprintf(buffer, "polygon %d xyz %e %e %e weight %e size %e\n", i + 1,
8775 // crack_glob_pnt[j].x, crack_glob_pnt[j].y, crack_glob_pnt[j].z, weight_h, bmsz);
8776 // write_record(t3d_in_file, t3d_in_file_name, buffer);
8777 // }
8778 //
8779 // write_record(t3d_in_file, t3d_in_file_name, "\n");
8780 //
8781 // vertex_id++;
8782 // if(fixed_1 == NO)
8783 // sprintf(buffer, "vertex %d xyz %e %e %e fixed curve %d fixed vertex %d\n", vertex_id,
8784 // crack -> pnt1.x, crack -> pnt1.y, crack -> pnt1.z, curve_id - 1, crack_vertex_id1);
8785 // else
8786 // sprintf(buffer, "vertex %d fixed vertex %d\n", vertex_id, vertex_id - 2);
8787 // write_record(t3d_in_file, t3d_in_file_name, buffer);
8788 //
8789 // vertex_id++;
8790 // if(fixed_2 == NO)
8791 // sprintf(buffer, "vertex %d xyz %e %e %e fixed curve %d fixed vertex %d\n", vertex_id,
8792 // crack -> pnt2.x, crack -> pnt2.y, crack -> pnt2.z, curve_id, crack_vertex_id2);
8793 // else
8794 // sprintf(buffer, "vertex %d fixed vertex %d\n", vertex_id, vertex_id - 3);
8795 // write_record(t3d_in_file, t3d_in_file_name, buffer);
8796 //
8797 // write_record(t3d_in_file, t3d_in_file_name, "\n");
8798 //
8799 // curve_id++;
8800 // sprintf(buffer, "curve %d vertex %d %d fixed curve %d\n", curve_id,
8801 // vertex_id - 1, vertex_id - 2, curve_id - 2);
8802 // write_record(t3d_in_file, t3d_in_file_name, buffer);
8803 //
8804 // if(k == 1){
8805 // sprintf(buffer, " Curve %d %d", curve_id - 4, curve_id);
8806 // write_record(ctrl_file, ctrl_file_name, buffer);
8807 // }
8808 //
8809 // curve_id++;
8810 // sprintf(buffer, "curve %d vertex %d %d fixed curve %d\n", curve_id,
8811 // vertex_id - 2, vertex_id, curve_id - 2);
8812 // write_record(t3d_in_file, t3d_in_file_name, buffer);
8813 //
8814 // if(k == 1){
8815 // sprintf(buffer, " Curve %d %d", curve_id - 4, curve_id);
8816 // write_record(ctrl_file, ctrl_file_name, buffer);
8817 // }
8818 //
8819 // write_record(t3d_in_file, t3d_in_file_name, "\n");
8820 //
8821 // sprintf(crack_cur_list, "%d %d", curve_id - 1, curve_id);
8822 // if(k == 0)sprintf(crack_tip_cur_list, "%d %d", curve_id - 1, curve_id);
8823 // break;
8824 //
8825 // case 5:
8826 // vertex_id++;
8827 // if((j = crack -> q1 + 1) >= 4)j -= 4;
8828 // if(bmsz == 0.0){
8829 // default_msz = YES;
8830 // sprintf(buffer, "vertex %d xyz %e %e %e\n", vertex_id,
8831 // crack_glob_point[j].x, crack_glob_point[j].y, crack_glob_point[j].z);
8832 // }
8833 // else
8834 // sprintf(buffer, "vertex %d xyz %e %e %e size %e\n", vertex_id,
8835 // crack_glob_point[j].x, crack_glob_point[j].y, crack_glob_point[j].z, bmsz);
8836 // write_record(t3d_in_file, t3d_in_file_name, buffer);
8837 //
8838 // if(k == 1){
8839 // sprintf(buffer, " Vertex %d %d", vertex_id - 4, vertex_id);
8840 // write_record(ctrl_file, ctrl_file_name, buffer);
8841 // }
8842 //
8843 // vertex_id++;
8844 // if((j = crack -> q1 + 2) >= 4)j -= 4;
8845 // if(bmsz == 0.0){
8846 // default_msz = YES;
8847 // sprintf(buffer, "vertex %d xyz %e %e %e\n", vertex_id,
8848 // crack_glob_point[j].x, crack_glob_point[j].y, crack_glob_point[j].z);
8849 // }
8850 // else
8851 // sprintf(buffer, "vertex %d xyz %e %e %e size %e\n", vertex_id,
8852 // crack_glob_point[j].x, crack_glob_point[j].y, crack_glob_point[j].z, bmsz);
8853 // write_record(t3d_in_file, t3d_in_file_name, buffer);
8854 //
8855 // if(k == 1){
8856 // sprintf(buffer, " Vertex %d %d", vertex_id - 4, vertex_id);
8857 // write_record(ctrl_file, ctrl_file_name, buffer);
8858 // }
8859 //
8860 // if(k == 0)sprintf(crack_tip_ver_list, "%d %d", vertex_id - 1, vertex_id);
8861 //
8862 // write_record(t3d_in_file, t3d_in_file_name, "\n");
8863 //
8864 // curve_id++;
8865 // if((j = crack -> q1 + 1) >= 4)j -= 4;
8866 // sprintf(buffer, "curve %d order 3 vertex %d %d\n", curve_id, vertex_id - 1, vertex_id);
8867 // write_record(t3d_in_file, t3d_in_file_name, buffer);
8868 // if(bmsz == 0.0){
8869 // default_msz = YES;
8870 // sprintf(buffer, "polygon 1 xyz %e %e %e weight %e\n",
8871 // crack_glob_pnt[j].x, crack_glob_pnt[j].y, crack_glob_pnt[j].z, weight_q);
8872 // }
8873 // else
8874 // sprintf(buffer, "polygon 1 xyz %e %e %e weight %e size %e\n",
8875 // crack_glob_pnt[j].x, crack_glob_pnt[j].y, crack_glob_pnt[j].z, weight_q, bmsz);
8876 // write_record(t3d_in_file, t3d_in_file_name, buffer);
8877 //
8878 // if(k == 1){
8879 // sprintf(buffer, " Curve %d %d", curve_id - 4, curve_id);
8880 // write_record(ctrl_file, ctrl_file_name, buffer);
8881 // }
8882 //
8883 // curve_id++;
8884 // sprintf(buffer, "curve %d order 3 vertex %d %d virtual\n", curve_id, vertex_id, vertex_id - 1);
8885 // write_record(t3d_in_file, t3d_in_file_name, buffer);
8886 // if(bmsz == 0.0){
8887 // default_msz = YES;
8888 // sprintf(buffer, "polygon 1 xyz %e %e %e weight %e\n",
8889 // crack_glob_pnt[j].x, crack_glob_pnt[j].y, crack_glob_pnt[j].z, -weight_q);
8890 // }
8891 // else
8892 // sprintf(buffer, "polygon 1 xyz %e %e %e weight %e size %e\n",
8893 // crack_glob_pnt[j].x, crack_glob_pnt[j].y, crack_glob_pnt[j].z, -weight_q, bmsz);
8894 // write_record(t3d_in_file, t3d_in_file_name, buffer);
8895 //
8896 // write_record(t3d_in_file, t3d_in_file_name, "\n");
8897 //
8898 // vertex_id++;
8899 // sprintf(buffer, "vertex %d xyz %e %e %e fixed curve %d fixed vertex %d\n", vertex_id,
8900 // crack -> pnt1.x, crack -> pnt1.y, crack -> pnt1.z, curve_id, crack_vertex_id1);
8901 // write_record(t3d_in_file, t3d_in_file_name, buffer);
8902 //
8903 // vertex_id++;
8904 // sprintf(buffer, "vertex %d xyz %e %e %e fixed curve %d fixed vertex %d\n", vertex_id,
8905 // crack -> pnt2.x, crack -> pnt2.y, crack -> pnt2.z, curve_id, crack_vertex_id2);
8906 // write_record(t3d_in_file, t3d_in_file_name, buffer);
8907 //
8908 // write_record(t3d_in_file, t3d_in_file_name, "\n");
8909 //
8910 // curve_id++;
8911 // sprintf(buffer, "curve %d vertex %d %d fixed curve %d\n", curve_id,
8912 // vertex_id - 1, vertex_id - 3, curve_id - 1);
8913 // write_record(t3d_in_file, t3d_in_file_name, buffer);
8914 //
8915 // if(k == 1){
8916 // sprintf(buffer, " Curve %d %d", curve_id - 4, curve_id);
8917 // write_record(ctrl_file, ctrl_file_name, buffer);
8918 // }
8919 //
8920 // curve_id++;
8921 // sprintf(buffer, "curve %d vertex %d %d fixed curve %d\n", curve_id,
8922 // vertex_id - 2, vertex_id, curve_id - 2);
8923 // write_record(t3d_in_file, t3d_in_file_name, buffer);
8924 //
8925 // if(k == 1){
8926 // sprintf(buffer, " Curve %d %d", curve_id - 4, curve_id);
8927 // write_record(ctrl_file, ctrl_file_name, buffer);
8928 // }
8929 //
8930 // write_record(t3d_in_file, t3d_in_file_name, "\n");
8931 //
8932 // sprintf(crack_cur_list, "%d %d %d", curve_id - 1, curve_id - 3, curve_id);
8933 // if(k == 0)sprintf(crack_tip_cur_list, "%d %d %d", curve_id - 1, curve_id - 3, curve_id);
8934 // break;
8935 // }
8936 //
8937 // patch_id++;
8938 // if(cmsz == 0.0){
8939 // default_msz = YES;
8940 // sprintf(buffer, "patch %d normal %e %e %e boundary curve %s %s size def\n", patch_id,
8941 // contact -> normal.x, contact -> normal.y, contact -> normal.z, crack_cur_list, contact_cur_list1);
8942 // }
8943 // else
8944 // sprintf(buffer, "patch %d normal %e %e %e boundary curve %s %s size %e\n", patch_id,
8945 // contact -> normal.x, contact -> normal.y, contact -> normal.z, crack_cur_list, contact_cur_list1, cmsz);
8946 // write_record(t3d_in_file, t3d_in_file_name, buffer);
8947 // if(k == 0)crack_patch_id = patch_id;
8948 //
8949 // if(k == 1){
8950 // sprintf(buffer, " Patch %d %d", crack_patch_id, patch_id);
8951 // write_record(ctrl_file, ctrl_file_name, buffer);
8952 // }
8953 //
8954 // patch_id++;
8955 // if(cmsz == 0.0){
8956 // default_msz = YES;
8957 // sprintf(buffer, "patch %d normal %e %e %e boundary curve %s %s size def coincide patch %d\n", patch_id,
8958 // contact -> normal.x, contact -> normal.y, contact -> normal.z, crack_cur_list, contact_cur_list2,
8959 // patch_id - 1);
8960 // }
8961 // else
8962 // sprintf(buffer, "patch %d normal %e %e %e boundary curve %s %s size %e coincide patch %d\n", patch_id,
8963 // contact -> normal.x, contact -> normal.y, contact -> normal.z, crack_cur_list, contact_cur_list2,
8964 // cmsz, patch_id - 1);
8965 // write_record(t3d_in_file, t3d_in_file_name, buffer);
8966 // if(k == 1){
8967 // sprintf(buffer, " Patch %d %d", crack_patch_id + 1, patch_id);
8968 // write_record(ctrl_file, ctrl_file_name, buffer);
8969 // }
8970 //
8971 // write_record(t3d_in_file, t3d_in_file_name, "\n");
8972 //
8973 // #ifdef MERLIN
8974 // if(crack -> interface == 0)break;
8975 // #else
8976 // break;
8977 // #endif
8978 //
8979 // crack -> patch = crack_patch_id;
8980 //
8981 // if(k == 1){
8982 // write_record(ctrl_file, ctrl_file_name, "\n");
8983 //
8984 // /* the patches forming crack surface are created in the direction of the (common) outer normal
8985 // this determines the order of patches in Interface statement
8986 //
8987 // <--------------------- outer normal
8988 // patch 12 | | patch 11 (patch 12 is closer than patch 11 when viewing against outer normal) */
8989 //
8990 // sprintf(buffer, "Interface %d Patch %d %d\n", crack -> interface, patch_id - 1, patch_id);
8991 // write_record(ctrl_file, ctrl_file_name, buffer);
8992 // }
8993 // }
8994 // }
8995 //
8996 // sprintf(buffer, "CrackSurface %d Patch %d %d\n", crack -> id, crack_patch_id, crack_patch_id + 1);
8997 // write_record(ctrl_file, ctrl_file_name, buffer);
8998 //
8999 // if(crack -> bc != 0){
9000 // bc = YES;
9001 // sprintf(crack -> bc_spec, "#Patch %d %d\n", crack_patch_id, crack_patch_id + 1);
9002 // }
9003 //
9004 // if(crack -> segment == NO)
9005 // sprintf(buffer, "Vertex %s\nCurve %s\nCrackFronts %d\n", crack_tip_ver_list, crack_tip_cur_list, crack -> id);
9006 // else
9007 // sprintf(buffer, "Vertex %d %d %s\nCurve %s\nCrackFronts %d\n", crack_ver_id1, crack_ver_id2,
9008 // crack_tip_ver_list, crack_tip_cur_list, crack -> id);
9009 // write_record(ctrl_file, ctrl_file_name, buffer);
9010 //
9011 // if(ellipsoid -> property == 0 || ellipsoid -> interface != 0 || ellipsoid -> property != prop){
9012 // sprintf(buffer, "%s boundary patch %d %d hole\n\n", tmp_buffer, -crack_patch_id, crack_patch_id + 1);
9013 // write_record(t3d_in_file, t3d_in_file_name, buffer);
9014 // }
9015 // else
9016 // crack -> patch = crack_patch_id;
9017 // }
9018 // else{
9019 // strcat(buffer, "\n\n");
9020 //
9021 // write_record(t3d_in_file, t3d_in_file_name, buffer);
9022 // write_record(ctrl_file, ctrl_file_name, buffer);
9023 //
9024 // /* ellipsoid without crack is written as 2 half-ellipsoid with base in plane xy */
9025 //
9026 // /* vertices */
9027 // loc_point[0].x = ellipsoid -> max;
9028 // loc_point[0].y = 0.0;
9029 // loc_point[0].z = 0.0;
9030 //
9031 // loc_point[1].x = -ellipsoid -> max;
9032 // loc_point[1].y = 0.0;
9033 // loc_point[1].z = 0.0;
9034 //
9035 // /* curve ctrl polygon */
9036 // loc_pnt[0].x = ellipsoid -> max;
9037 // loc_pnt[0].y = 2.0 * ellipsoid -> min;
9038 // loc_pnt[0].z = 0.0;
9039 //
9040 // /* surface ctrl polygon */
9041 // loc_p[0].x = ellipsoid -> max;
9042 // loc_p[0].y = 2.0 * ellipsoid -> min;
9043 // loc_p[0].z = 4.0 * ellipsoid -> mid;
9044 //
9045 // for(i = 1; i < 4; i++){
9046 // loc_pnt[i].x = loc_pnt[0].x * sign_qx[i];
9047 // loc_pnt[i].y = loc_pnt[0].y * sign_qy[i];
9048 // loc_pnt[i].z = 0.0;
9049 // }
9050 //
9051 // for(i = 1; i < 8; i++){
9052 // loc_p[i].x = loc_p[0].x * sign_ox[i];
9053 // loc_p[i].y = loc_p[0].y * sign_oy[i];
9054 // loc_p[i].z = loc_p[0].z * sign_oz[i];
9055 // }
9056 //
9057 // copy_vec(trans.x, ellipsoid -> major);
9058 // copy_vec(trans.y, ellipsoid -> minor);
9059 // copy_vec(trans.z, ellipsoid -> middle);
9060 //
9061 // invert_transformation(&trans);
9062 //
9063 // for(i = 0; i < 2; i++)transform_from_local_to_global(&(glob_point[i]), &(loc_point[i]), &(ellipsoid -> center), &trans);
9064 // for(i = 0; i < 4; i++)transform_from_local_to_global(&(glob_pnt[i]), &(loc_pnt[i]), &(ellipsoid -> center), &trans);
9065 // for(i = 0; i < 8; i++)transform_from_local_to_global(&(glob_p[i]), &(loc_p[i]), &(ellipsoid -> center), &trans);
9066 //
9067 // vertices = 2;
9068 // curves = 2 + 2;
9069 // surfaces = 2;
9070 //
9071 // for(k = 0; k < 4; k++){
9072 //
9073 // /* k = 0 inclusion boundary
9074 // k = 1 matrix boundary
9075 // k = 2 inclusion interface
9076 // k = 3 matrix interface */
9077 //
9078 // if(k == 1){
9079 // sprintf(buffer, "MasterSlave");
9080 // write_record(ctrl_file, ctrl_file_name, buffer);
9081 // }
9082 // if(k == 2){
9083 // sprintf(buffer, "Interface %d", ellipsoid -> interface);
9084 // write_record(ctrl_file, ctrl_file_name, buffer);
9085 // }
9086 //
9087 // switch(k){
9088 // case 0:
9089 // sprintf(buffer, "# inclusion boundary\n\n");
9090 // break;
9091 // case 1:
9092 // sprintf(buffer, "# matrix boundary\n\n");
9093 // break;
9094 // case 2:
9095 // sprintf(buffer, "# inclusion interface\n\n");
9096 // break;
9097 // case 3:
9098 // sprintf(buffer, "# matrix interface\n\n");
9099 // break;
9100 // }
9101 //
9102 // write_record(t3d_in_file, t3d_in_file_name, buffer);
9103 //
9104 // for(i = 0; i < 2; i++){
9105 // vertex_id++;
9106 // if(bmsz == 0.0){
9107 // default_msz = YES;
9108 // sprintf(buffer, "vertex %d xyz %e %e %e\n", vertex_id,
9109 // glob_point[i].x, glob_point[i].y, glob_point[i].z);
9110 // }
9111 // else
9112 // sprintf(buffer, "vertex %d xyz %e %e %e size %e\n", vertex_id,
9113 // glob_point[i].x, glob_point[i].y, glob_point[i].z, bmsz);
9114 // write_record(t3d_in_file, t3d_in_file_name, buffer);
9115 //
9116 // if(k == 1){
9117 // if(ellipsoid -> interface == 0)
9118 // sprintf(buffer, " Vertex %d %d", vertex_id - vertices, vertex_id);
9119 // else
9120 // sprintf(buffer, " Vertex %d %d Vertex %d %d",
9121 // vertex_id - vertices, vertex_id + vertices, vertex_id, vertex_id + 2 * vertices);
9122 // write_record(ctrl_file, ctrl_file_name, buffer);
9123 // }
9124 // }
9125 //
9126 // write_record(t3d_in_file, t3d_in_file_name, "\n");
9127 //
9128 // for(i = 0; i < 2; i++){
9129 // curve_id++;
9130 // sprintf(buffer, "curve %d order 4 vertex %d %d\n", curve_id, vertex_id - 1 + i, vertex_id - i);
9131 // write_record(t3d_in_file, t3d_in_file_name, buffer);
9132 //
9133 // for(j = 0; j < 2; j++){
9134 // m = 2 * i + j;
9135 // if(bmsz == 0.0){
9136 // default_msz = YES;
9137 // sprintf(buffer, "polygon %d xyz %e %e %e weight %e\n", j + 1,
9138 // glob_pnt[m].x, glob_pnt[m].y, glob_pnt[m].z, weight_h);
9139 // }
9140 // else
9141 // sprintf(buffer, "polygon %d xyz %e %e %e weight %e size %e\n", j + 1,
9142 // glob_pnt[m].x, glob_pnt[m].y, glob_pnt[m].z, weight_h, bmsz);
9143 // write_record(t3d_in_file, t3d_in_file_name, buffer);
9144 // }
9145 //
9146 // if(k == 1){
9147 // if(ellipsoid -> interface == 0)
9148 // sprintf(buffer, " Curve %d %d", curve_id - curves, curve_id);
9149 // else
9150 // sprintf(buffer, " Curve %d %d Curve %d %d",
9151 // curve_id - curves, curve_id + curves, curve_id, curve_id + 2 * curves);
9152 // write_record(ctrl_file, ctrl_file_name, buffer);
9153 // }
9154 // }
9155 //
9156 // write_record(t3d_in_file, t3d_in_file_name, "\n");
9157 //
9158 // for(i = 0; i < 2; i++){
9159 // curve_id++;
9160 // sprintf(buffer, "curve %d order 4 vertex %d %d\n", curve_id, vertex_id - 1 + i, vertex_id - 1 + i);
9161 // write_record(t3d_in_file, t3d_in_file_name, buffer);
9162 //
9163 // for(j = 0; j < 2; j++){
9164 // if(bmsz == 0.0){
9165 // default_msz = YES;
9166 // sprintf(buffer, "polygon %d xyz %e %e %e weight %e\n", j + 1,
9167 // glob_point[i].x, glob_point[i].y, glob_point[i].z, weight_h);
9168 // }
9169 // else
9170 // sprintf(buffer, "polygon %d xyz %e %e %e weight %e size %e\n", j + 1,
9171 // glob_point[i].x, glob_point[i].y, glob_point[i].z, weight_h, bmsz);
9172 // write_record(t3d_in_file, t3d_in_file_name, buffer);
9173 // }
9174 // }
9175 //
9176 // write_record(t3d_in_file, t3d_in_file_name, "\n");
9177 //
9178 // for(i = 0; i < 2; i++){
9179 // surface_id++;
9180 // sprintf(buffer, "surface %d curve %d %d %d %d\n", surface_id,
9181 // curve_id - 3, curve_id - 1, curve_id - 2, curve_id);
9182 // write_record(t3d_in_file, t3d_in_file_name, buffer);
9183 //
9184 // for(j1 = 0; j1 < 2; j1++){
9185 // for(j2 = 0; j2 < 2; j2++){
9186 // m = i * 4 + j2 * 2 + j1;
9187 // if(bmsz == 0.0){
9188 // default_msz = YES;
9189 // sprintf(buffer, "polygon %d %d xyz %e %e %e weight %e\n", j1 + 1, j2 + 1,
9190 // glob_p[m].x, glob_p[m].y, glob_p[m].z, weight_o);
9191 // }
9192 // else
9193 // sprintf(buffer, "polygon %d %d xyz %e %e %e weight %e size %e\n", j1 + 1, j2 + 1,
9194 // glob_p[m].x, glob_p[m].y, glob_p[m].z, weight_o, bmsz);
9195 // write_record(t3d_in_file, t3d_in_file_name, buffer);
9196 // }
9197 // }
9198 //
9199 // if(k == 1){
9200 // if(ellipsoid -> interface == 0)
9201 // sprintf(buffer, " Surface %d %d", surface_id - surfaces, surface_id);
9202 // else
9203 // sprintf(buffer, " Surface %d %d Surface %d %d",
9204 // surface_id - surfaces, surface_id + surfaces, surface_id, surface_id + 2 * surfaces);
9205 // write_record(ctrl_file, ctrl_file_name, buffer);
9206 // }
9207 // if(k == 2){
9208 // if(i == 0)
9209 // sprintf(buffer, " Surface %d %d", surface_id, surface_id + surfaces);
9210 // else
9211 // sprintf(buffer, " Surface %d %d", surface_id + surfaces, surface_id);
9212 // write_record(ctrl_file, ctrl_file_name, buffer);
9213 // }
9214 // }
9215 //
9216 // write_record(t3d_in_file, t3d_in_file_name, "\n");
9217 //
9218 // if(k == 0){
9219 // region_id++;
9220 // if(ellipsoid -> property == 0)
9221 // sprintf(buffer, "region %d boundary surface %d %d hole\n\n", region_id, surface_id - 1, -surface_id);
9222 // else{
9223 // /* sprintf(buffer, "Region %d\nElemType %d\n", region_id, ellipsoid -> property); */
9224 // sprintf(buffer, "Region %d\nTetraType %d\n", region_id, ellipsoid -> property);
9225 // write_record(ctrl_file, ctrl_file_name, buffer);
9226 //
9227 // if(imsz == 0.0){
9228 // default_msz = YES;
9229 // sprintf(buffer, "region %d boundary surface %d %d size def property %d\n\n", region_id,
9230 // surface_id - 1, -surface_id, ellipsoid -> property);
9231 // }
9232 // else
9233 // sprintf(buffer, "region %d boundary surface %d %d size %e property %d\n\n", region_id,
9234 // surface_id - 1, -surface_id, imsz, ellipsoid -> property);
9235 // }
9236 // write_record(t3d_in_file, t3d_in_file_name, buffer);
9237 //
9238 // if(ellipsoid -> interface == 0){
9239 //
9240 // #ifdef MERLIN
9241 // if(ellipsoid -> property == prop || ellipsoid -> property == 0){
9242 // ellipsoid -> region = region_id;
9243 // break;
9244 // }
9245 // #else
9246 // ellipsoid -> region = region_id;
9247 // break;
9248 // #endif
9249 //
9250 // }
9251 // else{
9252 // if(ellipsoid -> bc != 0){
9253 // bc = YES;
9254 // sprintf(ellipsoid -> bc_ellipsoid_spec, "#Surface %d %d\n", surface_id - 1, surface_id);
9255 // sprintf(ellipsoid -> bc_matrix_spec, "#Surface %d %d\n", surface_id - 1 + surfaces, surface_id + surfaces);
9256 // }
9257 // }
9258 // }
9259 //
9260 // if(k == 1){
9261 // region_id++;
9262 // sprintf(buffer, "region %d boundary surface %d %d hole\n\n", region_id, surface_id - 1, -surface_id);
9263 // write_record(t3d_in_file, t3d_in_file_name, buffer);
9264 // ellipsoid -> region = region_id;
9265 // }
9266 //
9267 // if(k == 1 || k == 2)write_record(ctrl_file, ctrl_file_name, "\n");
9268 //
9269 // #ifdef MERLIN
9270 // if(k == 1 && ellipsoid -> interface == 0)break;
9271 // #else
9272 // if(k == 1)break;
9273 // #endif
9274 //
9275 // }
9276 // }
9277 // }
9278 //
9279 //
9280 //
9281 // static void
9282 // write_crack(crack_rec *crack)
9283 // {
9284 // ellipse_rec *ellipse = NULL;
9285 // trans_matrix trans;
9286 // point_rec glob_point[2], loc_point[2], glob_pnt[4], loc_pnt[4];
9287 // double cmsz, tmsz, weight_h = 0.333333333333;
9288 // int i, j, k, n, crack_ver_id1, crack_ver_id2, crack_cur_id1, crack_cur_id2, crack_patch_id1, crack_patch_id2;
9289 // char buffer[1024];
9290 //
9291 // static int sign_qx[4] = {1, -1, -1, 1};
9292 // static int sign_qy[4] = {1, 1, -1, -1};
9293 //
9294 // if(crack -> id < 0)return;
9295 // if(crack -> ellipsoid != NULL)return;
9296 //
9297 // sprintf(buffer, "\n# crack no %d\n\n", crack -> id);
9298 // write_record(t3d_in_file, t3d_in_file_name, buffer);
9299 // write_record(ctrl_file, ctrl_file_name, buffer);
9300 //
9301 // cmsz = crack -> crack_msz;
9302 // tmsz = crack -> tip_msz;
9303 //
9304 // ellipse = &(crack -> crack);
9305 //
9306 // /* crack vertices */
9307 // loc_point[0].x = ellipse -> max;
9308 // loc_point[0].y = 0.0;
9309 // loc_point[0].z = 0.0;
9310 //
9311 // loc_point[1].x = -ellipse -> max;
9312 // loc_point[1].y = 0.0;
9313 // loc_point[1].z = 0.0;
9314 //
9315 // /* crack ctrl polygon */
9316 // loc_pnt[0].x = ellipse -> max;
9317 // loc_pnt[0].y = 2.0 * ellipse -> min;
9318 // loc_pnt[0].z = 0.0;
9319 //
9320 // for(i = 1; i < 4; i++){
9321 // loc_pnt[i].x = loc_pnt[0].x * sign_qx[i];
9322 // loc_pnt[i].y = loc_pnt[0].y * sign_qy[i];
9323 // loc_pnt[i].z = 0.0;
9324 // }
9325 //
9326 // copy_vec(trans.x, ellipse -> major);
9327 // copy_vec(trans.y, ellipse -> minor);
9328 // copy_vec(trans.z, ellipse -> normal);
9329 //
9330 // invert_transformation(&trans);
9331 //
9332 // for(i = 0; i < 2; i++)transform_from_local_to_global(&(glob_point[i]), &(loc_point[i]), &(ellipse -> center), &trans);
9333 // for(i = 0; i < 4; i++)transform_from_local_to_global(&(glob_pnt[i]), &(loc_pnt[i]), &(ellipse -> center), &trans);
9334 //
9335 // /* make crack */
9336 //
9337 // sprintf(buffer, "# crack boundary\n\n");
9338 // write_record(t3d_in_file, t3d_in_file_name, buffer);
9339 //
9340 // for(i = 0; i < 2; i++){
9341 // vertex_id++;
9342 // if(tmsz == 0.0){
9343 // default_msz = YES;
9344 // sprintf(buffer, "vertex %d xyz %e %e %e\n", vertex_id,
9345 // glob_point[i].x, glob_point[i].y, glob_point[i].z);
9346 // }
9347 // else
9348 // sprintf(buffer, "vertex %d xyz %e %e %e size %e\n", vertex_id,
9349 // glob_point[i].x, glob_point[i].y, glob_point[i].z, tmsz);
9350 // write_record(t3d_in_file, t3d_in_file_name, buffer);
9351 //
9352 // if(i == 0)crack_ver_id1 = vertex_id;
9353 // if(i == 1)crack_ver_id2 = vertex_id;
9354 // }
9355 //
9356 // write_record(t3d_in_file, t3d_in_file_name, "\n");
9357 //
9358 // for(i = 0; i < 2; i++){
9359 // curve_id++;
9360 // sprintf(buffer, "curve %d order 4 vertex %d %d\n", curve_id, vertex_id - 1 + i, vertex_id - i);
9361 // write_record(t3d_in_file, t3d_in_file_name, buffer);
9362 //
9363 // for(j = 0; j < 2; j++){
9364 // n = 2 * i + j;
9365 // if(tmsz == 0.0){
9366 // default_msz = YES;
9367 // sprintf(buffer, "polygon %d xyz %e %e %e weight %e\n", j + 1,
9368 // glob_pnt[n].x, glob_pnt[n].y, glob_pnt[n].z, weight_h);
9369 // }
9370 // else
9371 // sprintf(buffer, "polygon %d xyz %e %e %e weight %e size %e\n", j + 1,
9372 // glob_pnt[n].x, glob_pnt[n].y, glob_pnt[n].z, weight_h, tmsz);
9373 // write_record(t3d_in_file, t3d_in_file_name, buffer);
9374 // }
9375 //
9376 // if(i == 0)crack_cur_id1 = curve_id;
9377 // if(i == 1)crack_cur_id2 = curve_id;
9378 // }
9379 //
9380 // write_record(t3d_in_file, t3d_in_file_name, "\n");
9381 //
9382 // patch_id++;
9383 // if(cmsz == 0.0){
9384 // default_msz = YES;
9385 // sprintf(buffer, "patch %d normal %e %e %e boundary curve %d %d size def\n", patch_id,
9386 // ellipse -> normal.x, ellipse -> normal.y, ellipse -> normal.z, curve_id - 1, curve_id);
9387 // }
9388 // else
9389 // sprintf(buffer, "patch %d normal %e %e %e boundary curve %d %d size %e\n", patch_id,
9390 // ellipse -> normal.x, ellipse -> normal.y, ellipse -> normal.z, curve_id - 1, curve_id, cmsz);
9391 // write_record(t3d_in_file, t3d_in_file_name, buffer);
9392 // crack_patch_id1 = patch_id;
9393 //
9394 // patch_id++;
9395 // if(cmsz == 0.0){
9396 // default_msz = YES;
9397 // sprintf(buffer, "patch %d normal %e %e %e boundary curve %d %d size def coincide patch %d\n", patch_id,
9398 // ellipse -> normal.x, ellipse -> normal.y, ellipse -> normal.z, curve_id - 1, curve_id, patch_id - 1);
9399 // }
9400 // else
9401 // sprintf(buffer, "patch %d normal %e %e %e boundary curve %d %d size %e coincide patch %d\n", patch_id,
9402 // ellipse -> normal.x, ellipse -> normal.y, ellipse -> normal.z, curve_id - 1, curve_id, cmsz, patch_id - 1);
9403 // write_record(t3d_in_file, t3d_in_file_name, buffer);
9404 // crack_patch_id2 = patch_id;
9405 //
9406 // write_record(t3d_in_file, t3d_in_file_name, "\n");
9407 //
9408 // if(crack -> interface != 0){
9409 //
9410 // /* make crack interface */
9411 //
9412 // sprintf(buffer, "# crack interface\n\n");
9413 // write_record(t3d_in_file, t3d_in_file_name, buffer);
9414 //
9415 // sprintf(buffer, "MasterSlave");
9416 // write_record(ctrl_file, ctrl_file_name, buffer);
9417 //
9418 // for(k = 0; k < 2; k++){
9419 // for(i = 0; i < 2; i++){
9420 // vertex_id++;
9421 // if(tmsz == 0.0){
9422 // default_msz = YES;
9423 // sprintf(buffer, "vertex %d xyz %e %e %e\n", vertex_id,
9424 // glob_point[i].x, glob_point[i].y, glob_point[i].z);
9425 // }
9426 // else
9427 // sprintf(buffer, "vertex %d xyz %e %e %e size %e\n", vertex_id,
9428 // glob_point[i].x, glob_point[i].y, glob_point[i].z, tmsz);
9429 // write_record(t3d_in_file, t3d_in_file_name, buffer);
9430 //
9431 // sprintf(buffer, " Vertex %d %d", vertex_id - (k + 1) * 2, vertex_id);
9432 // write_record(ctrl_file, ctrl_file_name, buffer);
9433 // }
9434 //
9435 // write_record(t3d_in_file, t3d_in_file_name, "\n");
9436 //
9437 // for(i = 0; i < 2; i++){
9438 // curve_id++;
9439 // sprintf(buffer, "curve %d order 4 vertex %d %d\n", curve_id, vertex_id - 1 + i, vertex_id - i);
9440 // write_record(t3d_in_file, t3d_in_file_name, buffer);
9441 //
9442 // for(j = 0; j < 2; j++){
9443 // n = 2 * i + j;
9444 // if(tmsz == 0.0){
9445 // default_msz = YES;
9446 // sprintf(buffer, "polygon %d xyz %e %e %e weight %e\n", j + 1,
9447 // glob_pnt[n].x, glob_pnt[n].y, glob_pnt[n].z, weight_h);
9448 // }
9449 // else
9450 // sprintf(buffer, "polygon %d xyz %e %e %e weight %e size %e\n", j + 1,
9451 // glob_pnt[n].x, glob_pnt[n].y, glob_pnt[n].z, weight_h, tmsz);
9452 // write_record(t3d_in_file, t3d_in_file_name, buffer);
9453 // }
9454 //
9455 // sprintf(buffer, " Curve %d %d", curve_id - (k + 1) * 2, curve_id);
9456 // write_record(ctrl_file, ctrl_file_name, buffer);
9457 // }
9458 //
9459 // write_record(t3d_in_file, t3d_in_file_name, "\n");
9460 //
9461 // patch_id++;
9462 // if(cmsz == 0.0){
9463 // default_msz = YES;
9464 // sprintf(buffer, "patch %d normal %e %e %e boundary curve %d %d size def\n", patch_id,
9465 // ellipse -> normal.x, ellipse -> normal.y, ellipse -> normal.z, curve_id - 1, curve_id);
9466 // }
9467 // else
9468 // sprintf(buffer, "patch %d normal %e %e %e boundary curve %d %d size %e\n", patch_id,
9469 // ellipse -> normal.x, ellipse -> normal.y, ellipse -> normal.z, curve_id - 1, curve_id, cmsz);
9470 // write_record(t3d_in_file, t3d_in_file_name, buffer);
9471 //
9472 // sprintf(buffer, " Patch %d %d", patch_id - 2, patch_id);
9473 // write_record(ctrl_file, ctrl_file_name, buffer);
9474 //
9475 // write_record(t3d_in_file, t3d_in_file_name, "\n");
9476 // }
9477 //
9478 // write_record(ctrl_file, ctrl_file_name, "\n");
9479 //
9480 // /* the patches forming crack surface are created in the direction of the (common) outer normal
9481 // this determines the order of patches in Interface statement
9482 //
9483 // <--------------------- outer normal
9484 // patch 12 | | patch 11 (patch 12 is closer than patch 11 when viewing against outer normal) */
9485 //
9486 // sprintf(buffer, "Interface %d Patch %d %d\n", crack -> interface, patch_id - 1, patch_id);
9487 // write_record(ctrl_file, ctrl_file_name, buffer);
9488 // }
9489 //
9490 // sprintf(buffer, "CrackSurface %d Patch %d %d\n", crack -> id, crack_patch_id1, crack_patch_id2);
9491 // write_record(ctrl_file, ctrl_file_name, buffer);
9492 // sprintf(buffer, "Vertex %d %d\nCurve %d %d\nCrackFronts %d\n",
9493 // crack_ver_id1, crack_ver_id2, crack_cur_id1, crack_cur_id2, crack -> id);
9494 // write_record(ctrl_file, ctrl_file_name, buffer);
9495 //
9496 // if(crack -> bc != 0){
9497 // bc = YES;
9498 // sprintf(crack -> bc_spec, "#Patch %d %d\n", crack_patch_id1, crack_patch_id2);
9499 // }
9500 //
9501 // crack -> patch = crack_patch_id1;
9502 // }
9503 //
9504 //
9505 //
9506 // static void
9507 // write_cylinder(cylinder_rec *cylinder, ellipsoid_rec *ellipsoid_array, crack_rec *crack_array, int ellipsoids, int cracks)
9508 // {
9509 // point_rec point[2], pnt[4];
9510 // ellipsoid_rec *ellipsoid = NULL;
9511 // crack_rec *crack = NULL;
9512 // double bmsz, imsz, radius, height, weight = 0.33333333333;
9513 // int i, j, k, m, ellipsoid_count, crack_count, num;
9514 // char buffer[1024];
9515 //
9516 // radius = cylinder -> radius;
9517 // height = cylinder -> height;
9518 //
9519 // bmsz = cylinder -> boundary_msz;
9520 // imsz = cylinder -> internal_msz;
9521 //
9522 // sprintf(buffer, "\n# matrix\n\n");
9523 // write_record(t3d_in_file, t3d_in_file_name, buffer);
9524 // write_record(ctrl_file, ctrl_file_name, buffer);
9525 //
9526 // for(i = 0; i < 2; i++){
9527 // copy_vec(point[i], cylinder -> lower_center);
9528 // }
9529 //
9530 // point[0].y -= radius;
9531 // point[1].y += radius;
9532 //
9533 // for(i = 0; i < 2; i++){
9534 // copy_vec(pnt[i], point[i]);
9535 // copy_vec(pnt[3 - i], point[i]);
9536 //
9537 // pnt[i].x += 2.0 * radius;
9538 // pnt[3 - i].x -= 2.0 * radius;
9539 // }
9540 //
9541 // for(m = 0; m < 2; m++){
9542 //
9543 // /* m = 0 lower base
9544 // m = 1 upper base */
9545 //
9546 // for(i = 0; i < 2; i++){
9547 // vertex_id++;
9548 // if(bmsz == 0.0){
9549 // default_msz = YES;
9550 // sprintf(buffer, "vertex %d xyz %e %e %e\n", vertex_id, point[i].x, point[i].y, point[i].z);
9551 // }
9552 // else
9553 // sprintf(buffer, "vertex %d xyz %e %e %e size %e\n", vertex_id, point[i].x, point[i].y, point[i].z, bmsz);
9554 // write_record(t3d_in_file, t3d_in_file_name, buffer);
9555 // }
9556 //
9557 // write_record(t3d_in_file, t3d_in_file_name, "\n");
9558 //
9559 // for(i = 0; i < 2; i++){
9560 // curve_id++;
9561 // sprintf(buffer, "curve %d order 4 vertex %d %d\n", curve_id, vertex_id - 1 + i, vertex_id - i);
9562 // write_record(t3d_in_file, t3d_in_file_name, buffer);
9563 //
9564 // for(j = 0; j < 2; j++){
9565 // k = i * 2 + j;
9566 // if(bmsz == 0.0){
9567 // default_msz = YES;
9568 // sprintf(buffer, "polygon %d xyz %e %e %e weight %e\n", j + 1, pnt[k].x, pnt[k].y, pnt[k].z, weight);
9569 // }
9570 // else
9571 // sprintf(buffer, "polygon %d xyz %e %e %e weight %e size %e\n", j + 1, pnt[k].x, pnt[k].y, pnt[k].z, weight, bmsz);
9572 // write_record(t3d_in_file, t3d_in_file_name, buffer);
9573 // }
9574 // }
9575 //
9576 // write_record(t3d_in_file, t3d_in_file_name, "\n");
9577 //
9578 // patch_id++;
9579 // if(bmsz == 0.0){
9580 // default_msz = YES;
9581 // sprintf(buffer, "patch %d normal 0.0 0.0 1.0 boundary curve %d %d size def", patch_id, curve_id - 1, curve_id);
9582 // }
9583 // else
9584 // sprintf(buffer, "patch %d normal 0.0 0.0 1.0 boundary curve %d %d size %e", patch_id, curve_id - 1, curve_id, bmsz);
9585 // write_record(t3d_in_file, t3d_in_file_name, buffer);
9586 //
9587 // if(m == 1 && cylinder -> periodic == YES)sprintf(buffer, " mirror %d", patch_id - 1);
9588 //
9589 // write_record(t3d_in_file, t3d_in_file_name, "\n\n");
9590 //
9591 // for(i = 0; i < 2; i++){
9592 // point[i].z += height;
9593 // pnt[i].z += height;
9594 // pnt[i + 2].z += height;
9595 // }
9596 // }
9597 //
9598 // for(i = 0; i < 2; i++){
9599 // curve_id++;
9600 // sprintf(buffer, "curve %d vertex %d %d\n", curve_id, vertex_id - 3 + i, vertex_id - 3 + i + 2);
9601 // write_record(t3d_in_file, t3d_in_file_name, buffer);
9602 // }
9603 //
9604 // write_record(t3d_in_file, t3d_in_file_name, "\n");
9605 //
9606 // for(i = 0; i < 2; i++){
9607 // surface_id++;
9608 // sprintf(buffer, "surface %d curve %d %d %d %d\n", surface_id, curve_id - 5 + i, curve_id - 1 + i, curve_id - 3 + i, curve_id - i);
9609 // write_record(t3d_in_file, t3d_in_file_name, buffer);
9610 // }
9611 //
9612 // write_record(t3d_in_file, t3d_in_file_name, "\n");
9613 //
9614 // region_id++;
9615 // if(imsz == 0.0){
9616 // default_msz = YES;
9617 // sprintf(buffer, "region %d boundary patch %d %d boundary surface %d %d size def property %d", region_id,
9618 // -(patch_id - 1), patch_id, surface_id - 1, surface_id, cylinder -> property);
9619 // }
9620 // else
9621 // sprintf(buffer, "region %d boundary patch %d %d boundary surface %d %d size %e property %d", region_id,
9622 // -(patch_id - 1), patch_id, surface_id - 1, surface_id, imsz, cylinder -> property);
9623 // write_record(t3d_in_file, t3d_in_file_name, buffer);
9624 //
9625 // /* sprintf(buffer, "Region %d\nElemType %d\n", region_id, cylinder -> property); */
9626 // sprintf(buffer, "Region %d\nTetraType %d\n", region_id, cylinder -> property);
9627 // write_record(ctrl_file, ctrl_file_name, buffer);
9628 //
9629 // ellipsoid_count = 0;
9630 // for(i = 0; i < ellipsoids; i++){
9631 // ellipsoid = &(ellipsoid_array[i]);
9632 // if(ellipsoid -> region == 0)continue;
9633 // ellipsoid_count++;
9634 // }
9635 //
9636 // if(ellipsoid_count != 0){
9637 // write_record(t3d_in_file, t3d_in_file_name, " \\\nsubregion");
9638 //
9639 // num = 0;
9640 // for(i = 0; i < ellipsoids; i++){
9641 // ellipsoid = &(ellipsoid_array[i]);
9642 // if(ellipsoid -> region == 0)continue;
9643 // num++;
9644 //
9645 // sprintf(buffer, " %d", ellipsoid -> region);
9646 // write_record(t3d_in_file, t3d_in_file_name, buffer);
9647 //
9648 // if(num % 30 == 0 && ellipsoid_count - num > 5)
9649 // write_record(t3d_in_file, t3d_in_file_name, " \\\n ");
9650 // }
9651 // }
9652 //
9653 // crack_count = 0;
9654 // for(i = 0; i < cracks; i++){
9655 // crack = &(crack_array[i]);
9656 // if(crack -> patch == 0)continue;
9657 // crack_count += 2;
9658 // }
9659 //
9660 // if(crack_count != 0){
9661 // write_record(t3d_in_file, t3d_in_file_name, " \\\nboundary patch");
9662 //
9663 // num = 0;
9664 // for(i = 0; i < cracks; i++){
9665 // crack = &(crack_array[i]);
9666 // if(crack -> patch == 0)continue;
9667 // num++;
9668 //
9669 // sprintf(buffer, " %d %d", crack -> patch, -(crack -> patch + 1));
9670 // write_record(t3d_in_file, t3d_in_file_name, buffer);
9671 //
9672 // if(num % 10 == 0 && crack_count - num > 2)
9673 // write_record(t3d_in_file, t3d_in_file_name, " \\\n ");
9674 // }
9675 // }
9676 //
9677 // write_record(t3d_in_file, t3d_in_file_name, "\n");
9678 //
9679 // sprintf(buffer, "\n# Patch %d (lower base) %d (upper base) - normal up\n", patch_id - 1, patch_id);
9680 // write_record(ctrl_file, ctrl_file_name, buffer);
9681 // sprintf(buffer, "# Surface %d %d (face) - normal out\n\n", surface_id - 1, surface_id);
9682 // write_record(ctrl_file, ctrl_file_name, buffer);
9683 // }
9684 //
9685 //
9686 // static void
9687 // write_block(block_rec *block, ellipsoid_rec *ellipsoid_array, crack_rec *crack_array, int ellipsoids, int cracks)
9688 // {
9689 // point_rec point, center;
9690 // ellipsoid_rec *ellipsoid = NULL;
9691 // crack_rec *crack = NULL;
9692 // double bmsz, imsz, sz_x, sz_y, sz_z;
9693 // int i, ellipsoid_count, crack_count, num;
9694 // int sign_x[8] = {-1, 1, 1, -1, -1, 1, 1, -1};
9695 // int sign_y[8] = {-1, -1, 1, 1, -1, -1, 1, 1};
9696 // int sign_z[8] = {-1, -1, -1, -1, 1, 1, 1, 1};
9697 // char buffer[1024];
9698 //
9699 // aver_point(center, block -> ll_corner, block -> ur_corner);
9700 //
9701 // sz_x = block -> size_x / 2.0;
9702 // sz_y = block -> size_y / 2.0;
9703 // sz_z = block -> size_z / 2.0;
9704 //
9705 // bmsz = block -> boundary_msz;
9706 // imsz = block -> internal_msz;
9707 //
9708 // sprintf(buffer, "\n# matrix\n\n");
9709 // write_record(t3d_in_file, t3d_in_file_name, buffer);
9710 // write_record(ctrl_file, ctrl_file_name, buffer);
9711 //
9712 // for(i = 0; i < 8; i++){
9713 // point.x = center.x + sign_x[i] * sz_x;
9714 // point.y = center.y + sign_y[i] * sz_y;
9715 // point.z = center.z + sign_z[i] * sz_z;
9716 //
9717 // vertex_id++;
9718 // if(bmsz == 0.0){
9719 // default_msz = YES;
9720 // sprintf(buffer, "vertex %d xyz %e %e %e\n", vertex_id, point.x, point.y, point.z);
9721 // }
9722 // else
9723 // sprintf(buffer, "vertex %d xyz %e %e %e size %e\n", vertex_id, point.x, point.y, point.z, bmsz);
9724 // write_record(t3d_in_file, t3d_in_file_name, buffer);
9725 // }
9726 //
9727 // write_record(t3d_in_file, t3d_in_file_name, "\n");
9728 //
9729 // curve_id++;
9730 // sprintf(buffer, "curve %d vertex %d %d\n", curve_id, vertex_id - 7, vertex_id - 6);
9731 // write_record(t3d_in_file, t3d_in_file_name, buffer);
9732 // curve_id++;
9733 // sprintf(buffer, "curve %d vertex %d %d\n", curve_id, vertex_id - 6, vertex_id - 5);
9734 // write_record(t3d_in_file, t3d_in_file_name, buffer);
9735 // curve_id++;
9736 // sprintf(buffer, "curve %d vertex %d %d\n", curve_id, vertex_id - 4, vertex_id - 5);
9737 // write_record(t3d_in_file, t3d_in_file_name, buffer);
9738 // curve_id++;
9739 // sprintf(buffer, "curve %d vertex %d %d\n", curve_id, vertex_id - 7, vertex_id - 4);
9740 // write_record(t3d_in_file, t3d_in_file_name, buffer);
9741 //
9742 // curve_id++;
9743 // sprintf(buffer, "curve %d vertex %d %d\n", curve_id, vertex_id - 3, vertex_id - 2);
9744 // write_record(t3d_in_file, t3d_in_file_name, buffer);
9745 // curve_id++;
9746 // sprintf(buffer, "curve %d vertex %d %d\n", curve_id, vertex_id - 2, vertex_id - 1);
9747 // write_record(t3d_in_file, t3d_in_file_name, buffer);
9748 // curve_id++;
9749 // sprintf(buffer, "curve %d vertex %d %d\n", curve_id, vertex_id - 0, vertex_id - 1);
9750 // write_record(t3d_in_file, t3d_in_file_name, buffer);
9751 // curve_id++;
9752 // sprintf(buffer, "curve %d vertex %d %d\n", curve_id, vertex_id - 3, vertex_id - 0);
9753 // write_record(t3d_in_file, t3d_in_file_name, buffer);
9754 //
9755 // curve_id++;
9756 // sprintf(buffer, "curve %d vertex %d %d\n", curve_id, vertex_id - 7, vertex_id - 3);
9757 // write_record(t3d_in_file, t3d_in_file_name, buffer);
9758 // curve_id++;
9759 // sprintf(buffer, "curve %d vertex %d %d\n", curve_id, vertex_id - 6, vertex_id - 2);
9760 // write_record(t3d_in_file, t3d_in_file_name, buffer);
9761 // curve_id++;
9762 // sprintf(buffer, "curve %d vertex %d %d\n", curve_id, vertex_id - 5, vertex_id - 1);
9763 // write_record(t3d_in_file, t3d_in_file_name, buffer);
9764 // curve_id++;
9765 // sprintf(buffer, "curve %d vertex %d %d\n", curve_id, vertex_id - 4, vertex_id - 0);
9766 // write_record(t3d_in_file, t3d_in_file_name, buffer);
9767 //
9768 // write_record(t3d_in_file, t3d_in_file_name, "\n");
9769 //
9770 // surface_id++;
9771 // sprintf(buffer, "surface %d curve %d %d %d %d\n", surface_id, curve_id - 11, curve_id - 8, curve_id - 9, curve_id - 10);
9772 // write_record(t3d_in_file, t3d_in_file_name, buffer);
9773 // surface_id++;
9774 // if(block -> periodic == NO)
9775 // sprintf(buffer, "surface %d curve %d %d %d %d\n", surface_id, curve_id - 7, curve_id - 4, curve_id - 5, curve_id - 6);
9776 // else
9777 // sprintf(buffer, "surface %d curve %d %d %d %d mirror %d\n", surface_id, curve_id - 7, curve_id - 4, curve_id - 5, curve_id - 6, surface_id - 1);
9778 // write_record(t3d_in_file, t3d_in_file_name, buffer);
9779 //
9780 // surface_id++;
9781 // sprintf(buffer, "surface %d curve %d %d %d %d\n", surface_id, curve_id - 11, curve_id - 2, curve_id - 7, curve_id - 3);
9782 // write_record(t3d_in_file, t3d_in_file_name, buffer);
9783 // surface_id++;
9784 // if(block -> periodic == NO)
9785 // sprintf(buffer, "surface %d curve %d %d %d %d\n", surface_id, curve_id - 9, curve_id - 1, curve_id - 5, curve_id - 0);
9786 // else
9787 // sprintf(buffer, "surface %d curve %d %d %d %d mirror %d\n", surface_id, curve_id - 9, curve_id - 1, curve_id - 5, curve_id - 0, surface_id - 1);
9788 // write_record(t3d_in_file, t3d_in_file_name, buffer);
9789 //
9790 // surface_id++;
9791 // sprintf(buffer, "surface %d curve %d %d %d %d\n", surface_id, curve_id - 8, curve_id - 3, curve_id - 4, curve_id - 0);
9792 // write_record(t3d_in_file, t3d_in_file_name, buffer);
9793 // surface_id++;
9794 // if(block -> periodic == NO)
9795 // sprintf(buffer, "surface %d curve %d %d %d %d\n", surface_id, curve_id - 10, curve_id - 2, curve_id - 6, curve_id - 1);
9796 // else
9797 // sprintf(buffer, "surface %d curve %d %d %d %d mirror %d\n", surface_id, curve_id - 10, curve_id - 2, curve_id - 6, curve_id - 1, surface_id - 1);
9798 // write_record(t3d_in_file, t3d_in_file_name, buffer);
9799 //
9800 // write_record(t3d_in_file, t3d_in_file_name, "\n");
9801 //
9802 // region_id++;
9803 // if(imsz == 0.0){
9804 // default_msz = YES;
9805 // sprintf(buffer, "region %d boundary surface %d %d %d %d %d %d size def property %d", region_id,
9806 // -(surface_id - 5), surface_id - 4, -(surface_id - 3), surface_id - 2, -(surface_id - 1), surface_id, block -> property);
9807 // }
9808 // else
9809 // sprintf(buffer, "region %d boundary surface %d %d %d %d %d %d size %e property %d", region_id,
9810 // -(surface_id - 5), surface_id - 4, -(surface_id - 3), surface_id - 2, -(surface_id - 1), surface_id, imsz, block -> property);
9811 // write_record(t3d_in_file, t3d_in_file_name, buffer);
9812 //
9813 // /* sprintf(buffer, "Region %d\nElemType %d\n", region_id, block -> property); */
9814 // sprintf(buffer, "Region %d\nTetraType %d\n", region_id, block -> property);
9815 // write_record(ctrl_file, ctrl_file_name, buffer);
9816 //
9817 // ellipsoid_count = 0;
9818 // for(i = 0; i < ellipsoids; i++){
9819 // ellipsoid = &(ellipsoid_array[i]);
9820 // if(ellipsoid -> region == 0)continue;
9821 // ellipsoid_count++;
9822 // }
9823 //
9824 // if(ellipsoid_count != 0){
9825 // write_record(t3d_in_file, t3d_in_file_name, " \\\nsubregion");
9826 //
9827 // num = 0;
9828 // for(i = 0; i < ellipsoids; i++){
9829 // ellipsoid = &(ellipsoid_array[i]);
9830 // if(ellipsoid -> region == 0)continue;
9831 // num++;
9832 //
9833 // sprintf(buffer, " %d", ellipsoid -> region);
9834 // write_record(t3d_in_file, t3d_in_file_name, buffer);
9835 //
9836 // if(num % 30 == 0 && ellipsoid_count - num > 5)
9837 // write_record(t3d_in_file, t3d_in_file_name, " \\\n ");
9838 // }
9839 // }
9840 //
9841 // crack_count = 0;
9842 // for(i = 0; i < cracks; i++){
9843 // crack = &(crack_array[i]);
9844 // if(crack -> patch == 0)continue;
9845 // crack_count += 2;
9846 // }
9847 //
9848 // if(crack_count != 0){
9849 // write_record(t3d_in_file, t3d_in_file_name, " \\\nboundary patch");
9850 //
9851 // num = 0;
9852 // for(i = 0; i < cracks; i++){
9853 // crack = &(crack_array[i]);
9854 // if(crack -> patch == 0)continue;
9855 // num++;
9856 //
9857 // sprintf(buffer, " %d %d", crack -> patch, -(crack -> patch + 1));
9858 // write_record(t3d_in_file, t3d_in_file_name, buffer);
9859 //
9860 // if(num % 10 == 0 && crack_count - num > 2)
9861 // write_record(t3d_in_file, t3d_in_file_name, " \\\n ");
9862 // }
9863 // }
9864 //
9865 // write_record(t3d_in_file, t3d_in_file_name, "\n");
9866 //
9867 // sprintf(buffer, "# Surface %d (bottom face, normal in) %d (top face, normal out)\n\n", surface_id - 5, surface_id - 4);
9868 // write_record(ctrl_file, ctrl_file_name, buffer);
9869 // sprintf(buffer, "# Surface %d (left face, normal in) %d (right face, normal out)\n\n", surface_id - 3, surface_id - 2);
9870 // write_record(ctrl_file, ctrl_file_name, buffer);
9871 // sprintf(buffer, "# Surface %d (back face, normal in) %d (front face, normal out)\n\n", surface_id - 1, surface_id - 0);
9872 // write_record(ctrl_file, ctrl_file_name, buffer);
9873 // }
9874 //
9875 //
9876 // static void
9877 // write_super_block(block_rec *block)
9878 // {
9879 // point_rec point, center;
9880 // double bmsz, imsz, sz_x, sz_y, sz_z;
9881 // int i;
9882 // int sign_x[8] = {-1, 1, 1, -1, -1, 1, 1, -1};
9883 // int sign_y[8] = {-1, -1, 1, 1, -1, -1, 1, 1};
9884 // int sign_z[8] = {-1, -1, -1, -1, 1, 1, 1, 1};
9885 // char buffer[1024];
9886 //
9887 // aver_point(center, block -> ll_corner, block -> ur_corner);
9888 //
9889 // sz_x = block -> size_x / 2.0;
9890 // sz_y = block -> size_y / 2.0;
9891 // sz_z = block -> size_z / 2.0;
9892 //
9893 // bmsz = block -> boundary_msz;
9894 // imsz = block -> internal_msz;
9895 //
9896 // sprintf(buffer, "\n# super block\n\n");
9897 // write_record(t3d_in_file, t3d_in_file_name, buffer);
9898 // write_record(ctrl_file, ctrl_file_name, buffer);
9899 //
9900 // for(i = 0; i < 8; i++){
9901 // point.x = center.x + sign_x[i] * sz_x;
9902 // point.y = center.y + sign_y[i] * sz_y;
9903 // point.z = center.z + sign_z[i] * sz_z;
9904 //
9905 // vertex_id++;
9906 // if(bmsz == 0.0){
9907 // default_msz = YES;
9908 // sprintf(buffer, "vertex %d xyz %e %e %e\n", vertex_id, point.x, point.y, point.z);
9909 // }
9910 // else
9911 // sprintf(buffer, "vertex %d xyz %e %e %e size %e\n", vertex_id, point.x, point.y, point.z, bmsz);
9912 // write_record(t3d_in_file, t3d_in_file_name, buffer);
9913 // }
9914 //
9915 // write_record(t3d_in_file, t3d_in_file_name, "\n");
9916 //
9917 // curve_id++;
9918 // sprintf(buffer, "curve %d vertex %d %d\n", curve_id, vertex_id - 7, vertex_id - 6);
9919 // write_record(t3d_in_file, t3d_in_file_name, buffer);
9920 // curve_id++;
9921 // sprintf(buffer, "curve %d vertex %d %d\n", curve_id, vertex_id - 6, vertex_id - 5);
9922 // write_record(t3d_in_file, t3d_in_file_name, buffer);
9923 // curve_id++;
9924 // sprintf(buffer, "curve %d vertex %d %d\n", curve_id, vertex_id - 4, vertex_id - 5);
9925 // write_record(t3d_in_file, t3d_in_file_name, buffer);
9926 // curve_id++;
9927 // sprintf(buffer, "curve %d vertex %d %d\n", curve_id, vertex_id - 7, vertex_id - 4);
9928 // write_record(t3d_in_file, t3d_in_file_name, buffer);
9929 //
9930 // curve_id++;
9931 // sprintf(buffer, "curve %d vertex %d %d\n", curve_id, vertex_id - 3, vertex_id - 2);
9932 // write_record(t3d_in_file, t3d_in_file_name, buffer);
9933 // curve_id++;
9934 // sprintf(buffer, "curve %d vertex %d %d\n", curve_id, vertex_id - 2, vertex_id - 1);
9935 // write_record(t3d_in_file, t3d_in_file_name, buffer);
9936 // curve_id++;
9937 // sprintf(buffer, "curve %d vertex %d %d\n", curve_id, vertex_id - 0, vertex_id - 1);
9938 // write_record(t3d_in_file, t3d_in_file_name, buffer);
9939 // curve_id++;
9940 // sprintf(buffer, "curve %d vertex %d %d\n", curve_id, vertex_id - 3, vertex_id - 0);
9941 // write_record(t3d_in_file, t3d_in_file_name, buffer);
9942 //
9943 // curve_id++;
9944 // sprintf(buffer, "curve %d vertex %d %d\n", curve_id, vertex_id - 7, vertex_id - 3);
9945 // write_record(t3d_in_file, t3d_in_file_name, buffer);
9946 // curve_id++;
9947 // sprintf(buffer, "curve %d vertex %d %d\n", curve_id, vertex_id - 6, vertex_id - 2);
9948 // write_record(t3d_in_file, t3d_in_file_name, buffer);
9949 // curve_id++;
9950 // sprintf(buffer, "curve %d vertex %d %d\n", curve_id, vertex_id - 5, vertex_id - 1);
9951 // write_record(t3d_in_file, t3d_in_file_name, buffer);
9952 // curve_id++;
9953 // sprintf(buffer, "curve %d vertex %d %d\n", curve_id, vertex_id - 4, vertex_id - 0);
9954 // write_record(t3d_in_file, t3d_in_file_name, buffer);
9955 //
9956 // write_record(t3d_in_file, t3d_in_file_name, "\n");
9957 //
9958 // surface_id++;
9959 // sprintf(buffer, "surface %d curve %d %d %d %d\n", surface_id, curve_id - 11, curve_id - 8, curve_id - 9, curve_id - 10);
9960 // write_record(t3d_in_file, t3d_in_file_name, buffer);
9961 // surface_id++;
9962 // if(block -> periodic == NO)
9963 // sprintf(buffer, "surface %d curve %d %d %d %d\n", surface_id, curve_id - 7, curve_id - 4, curve_id - 5, curve_id - 6);
9964 // else
9965 // sprintf(buffer, "surface %d curve %d %d %d %d mirror %d\n", surface_id, curve_id - 7, curve_id - 4, curve_id - 5, curve_id - 6, surface_id - 1);
9966 // write_record(t3d_in_file, t3d_in_file_name, buffer);
9967 //
9968 // surface_id++;
9969 // sprintf(buffer, "surface %d curve %d %d %d %d\n", surface_id, curve_id - 11, curve_id - 2, curve_id - 7, curve_id - 3);
9970 // write_record(t3d_in_file, t3d_in_file_name, buffer);
9971 // surface_id++;
9972 // if(block -> periodic == NO)
9973 // sprintf(buffer, "surface %d curve %d %d %d %d\n", surface_id, curve_id - 9, curve_id - 1, curve_id - 5, curve_id - 0);
9974 // else
9975 // sprintf(buffer, "surface %d curve %d %d %d %d mirror %d\n", surface_id, curve_id - 9, curve_id - 1, curve_id - 5, curve_id - 0, surface_id - 1);
9976 // write_record(t3d_in_file, t3d_in_file_name, buffer);
9977 //
9978 // surface_id++;
9979 // sprintf(buffer, "surface %d curve %d %d %d %d\n", surface_id, curve_id - 8, curve_id - 3, curve_id - 4, curve_id - 0);
9980 // write_record(t3d_in_file, t3d_in_file_name, buffer);
9981 // surface_id++;
9982 // if(block -> periodic == NO)
9983 // sprintf(buffer, "surface %d curve %d %d %d %d\n", surface_id, curve_id - 10, curve_id - 2, curve_id - 6, curve_id - 1);
9984 // else
9985 // sprintf(buffer, "surface %d curve %d %d %d %d mirror %d\n", surface_id, curve_id - 10, curve_id - 2, curve_id - 6, curve_id - 1, surface_id - 1);
9986 // write_record(t3d_in_file, t3d_in_file_name, buffer);
9987 //
9988 // write_record(t3d_in_file, t3d_in_file_name, "\n");
9989 //
9990 // region_id++;
9991 // if(imsz == 0.0){
9992 // default_msz = YES;
9993 // sprintf(buffer, "region %d boundary surface %d %d %d %d %d %d size def property %d subregion 1", region_id,
9994 // -(surface_id - 5), surface_id - 4, -(surface_id - 3), surface_id - 2, -(surface_id - 1), surface_id, block -> property);
9995 // }
9996 // else
9997 // sprintf(buffer, "region %d boundary surface %d %d %d %d %d %d size %e property %d subregion 1", region_id,
9998 // -(surface_id - 5), surface_id - 4, -(surface_id - 3), surface_id - 2, -(surface_id - 1), surface_id, imsz, block -> property);
9999 // write_record(t3d_in_file, t3d_in_file_name, buffer);
10000 //
10001 // /* sprintf(buffer, "Region %d\nElemType %d\n", region_id, block -> property); */
10002 // sprintf(buffer, "Region %d\nTetraType %d\n", region_id, block -> property);
10003 // write_record(ctrl_file, ctrl_file_name, buffer);
10004 //
10005 // sprintf(buffer, "# Surface %d (bottom face, normal in) %d (top face, normal out)\n\n", surface_id - 5, surface_id - 4);
10006 // write_record(ctrl_file, ctrl_file_name, buffer);
10007 // sprintf(buffer, "# Surface %d (left face, normal in) %d (right face, normal out)\n\n", surface_id - 3, surface_id - 2);
10008 // write_record(ctrl_file, ctrl_file_name, buffer);
10009 // sprintf(buffer, "# Surface %d (back face, normal in) %d (front face, normal out)\n\n", surface_id - 1, surface_id - 0);
10010 // write_record(ctrl_file, ctrl_file_name, buffer);
10011 // }
10012 //
10013 //
10014 //
10015 // /* cylinder smaller by epsilon */
10016 //
10017 // static logic
10018 // check_ellipsoid_inside_cylinder(ellipsoid_rec *ellipsoid, cylinder_rec *cylinder)
10019 // {
10020 // point_rec dir, normal, pnt1, pnt2, pnt, direction, grad, point[4];
10021 // ellipse_rec ellipse, ellipse1, ellipse2;
10022 // double t, u, v, radius, dist;
10023 // int oct, quad, count;
10024 //
10025 // radius = cylinder -> radius - epsilon;
10026 // copy_vec(pnt, cylinder -> lower_center);
10027 // pnt.z = ellipsoid -> center.z;
10028 // dist = dist_point(pnt, ellipsoid -> center);
10029 // if(dist >= radius * radius)return(NO);
10030 //
10031 // /* check intersection with lower and upper bases */
10032 //
10033 // dir.x = 1.0;
10034 // dir.y = 0.0;
10035 // dir.z = 0.0;
10036 //
10037 // get_ellipsoid_line_center_intersection(ellipsoid, &dir, &pnt1, &pnt2);
10038 // oct = project_point_to_ellipsoid(&pnt1, ellipsoid, &pnt, &u, &v);
10039 // get_ellipsoid_normal_octant(ellipsoid, oct, u, v, &normal);
10040 // get_ellipsoid_plane_intersection(ellipsoid, &(ellipsoid -> center), &normal, &ellipse);
10041 //
10042 // dir.x = 0.0;
10043 // dir.y = 0.0;
10044 // dir.z = 1.0;
10045 //
10046 // get_plane_plane_intersection(&(ellipsoid -> center), &normal, &(ellipsoid -> center), &dir, &pnt, &direction);
10047 // get_ellipse_line_center_intersection(&ellipse, &direction, &pnt1, &pnt2);
10048 // quad = project_point_to_ellipse(&pnt1, &ellipse, &pnt, &t);
10049 // get_ellipse_gradient_quadrant(&ellipse, quad, t, &grad);
10050 // get_ellipse_line_center_intersection(&ellipse, &grad, &pnt1, &pnt2);
10051 //
10052 // if(pnt1.z <= cylinder -> lower_center.z + epsilon || pnt1.z >= cylinder -> upper_center.z - epsilon)return(NO);
10053 // if(pnt2.z <= cylinder -> lower_center.z + epsilon || pnt2.z >= cylinder -> upper_center.z - epsilon)return(NO);
10054 //
10055 // /* check intersection with circumferential face */
10056 //
10057 // get_ellipsoid_line_center_intersection(ellipsoid, &dir, &pnt1, &pnt2);
10058 // oct = project_point_to_ellipsoid(&pnt1, ellipsoid, &pnt, &u, &v);
10059 // get_ellipsoid_normal_octant(ellipsoid, oct, u, v, &normal);
10060 // get_ellipsoid_plane_intersection(ellipsoid, &(ellipsoid -> center), &normal, &ellipse1);
10061 //
10062 // cylinder -> radius -= epsilon;
10063 // get_cylinder_plane_intersection(cylinder, &(ellipse1.center), &normal, &ellipse2);
10064 // cylinder -> radius += epsilon;
10065 //
10066 // count = get_ellipse_ellipse_intersection(&ellipse1, &ellipse2, point);
10067 // if(count == 0)return(YES);
10068 //
10069 // return(NO);
10070 // }
10071 //
10072 //
10073 //
10074 // /* block smaller by epsilon */
10075 //
10076 // static logic
10077 // check_ellipsoid_inside_block(ellipsoid_rec *ellipsoid, block_rec *block)
10078 // {
10079 // point_rec dir, normal, pnt1, pnt2, pnt, direction, grad;
10080 // ellipse_rec ellipse;
10081 // double t, u, v;
10082 // int oct, quad;
10083 //
10084 // /* check intersection with lower and upper bases */
10085 //
10086 // dir.x = 1.0;
10087 // dir.y = 0.0;
10088 // dir.z = 0.0;
10089 //
10090 // get_ellipsoid_line_center_intersection(ellipsoid, &dir, &pnt1, &pnt2);
10091 // oct = project_point_to_ellipsoid(&pnt1, ellipsoid, &pnt, &u, &v);
10092 // get_ellipsoid_normal_octant(ellipsoid, oct, u, v, &normal);
10093 // get_ellipsoid_plane_intersection(ellipsoid, &(ellipsoid -> center), &normal, &ellipse);
10094 //
10095 // dir.x = 0.0;
10096 // dir.y = 0.0;
10097 // dir.z = 1.0;
10098 //
10099 // get_plane_plane_intersection(&(ellipsoid -> center), &normal, &(ellipsoid -> center), &dir, &pnt, &direction);
10100 // get_ellipse_line_center_intersection(&ellipse, &direction, &pnt1, &pnt2);
10101 // quad = project_point_to_ellipse(&pnt1, &ellipse, &pnt, &t);
10102 // get_ellipse_gradient_quadrant(&ellipse, quad, t, &grad);
10103 // get_ellipse_line_center_intersection(&ellipse, &grad, &pnt1, &pnt2);
10104 //
10105 // if(pnt1.z <= block -> ll_corner.z + epsilon || pnt1.z >= block -> ur_corner.z - epsilon)return(NO);
10106 // if(pnt2.z <= block -> ll_corner.z + epsilon || pnt2.z >= block -> ur_corner.z - epsilon)return(NO);
10107 //
10108 // /* check intersection with front and back sides */
10109 //
10110 // dir.x = 0.0;
10111 // dir.y = 0.0;
10112 // dir.z = 1.0;
10113 //
10114 // get_ellipsoid_line_center_intersection(ellipsoid, &dir, &pnt1, &pnt2);
10115 // oct = project_point_to_ellipsoid(&pnt1, ellipsoid, &pnt, &u, &v);
10116 // get_ellipsoid_normal_octant(ellipsoid, oct, u, v, &normal);
10117 // get_ellipsoid_plane_intersection(ellipsoid, &(ellipsoid -> center), &normal, &ellipse);
10118 //
10119 // dir.x = 1.0;
10120 // dir.y = 0.0;
10121 // dir.z = 0.0;
10122 //
10123 // get_plane_plane_intersection(&(ellipsoid -> center), &normal, &(ellipsoid -> center), &dir, &pnt, &direction);
10124 // get_ellipse_line_center_intersection(&ellipse, &direction, &pnt1, &pnt2);
10125 // quad = project_point_to_ellipse(&pnt1, &ellipse, &pnt, &t);
10126 // get_ellipse_gradient_quadrant(&ellipse, quad, t, &grad);
10127 // get_ellipse_line_center_intersection(&ellipse, &grad, &pnt1, &pnt2);
10128 //
10129 // if(pnt1.x <= block -> ll_corner.x + epsilon || pnt1.x >= block -> ur_corner.x - epsilon)return(NO);
10130 // if(pnt2.x <= block -> ll_corner.x + epsilon || pnt2.x >= block -> ur_corner.x - epsilon)return(NO);
10131 //
10132 // /* check intersection with left and right sides */
10133 //
10134 // dir.x = 0.0;
10135 // dir.y = 0.0;
10136 // dir.z = 1.0;
10137 //
10138 // get_ellipsoid_line_center_intersection(ellipsoid, &dir, &pnt1, &pnt2);
10139 // oct = project_point_to_ellipsoid(&pnt1, ellipsoid, &pnt, &u, &v);
10140 // get_ellipsoid_normal_octant(ellipsoid, oct, u, v, &normal);
10141 // get_ellipsoid_plane_intersection(ellipsoid, &(ellipsoid -> center), &normal, &ellipse);
10142 //
10143 // dir.x = 0.0;
10144 // dir.y = 1.0;
10145 // dir.z = 0.0;
10146 //
10147 // get_plane_plane_intersection(&(ellipsoid -> center), &normal, &(ellipsoid -> center), &dir, &pnt, &direction);
10148 // get_ellipse_line_center_intersection(&ellipse, &direction, &pnt1, &pnt2);
10149 // quad = project_point_to_ellipse(&pnt1, &ellipse, &pnt, &t);
10150 // get_ellipse_gradient_quadrant(&ellipse, quad, t, &grad);
10151 // get_ellipse_line_center_intersection(&ellipse, &grad, &pnt1, &pnt2);
10152 //
10153 // if(pnt1.y <= block -> ll_corner.y + epsilon || pnt1.y >= block -> ur_corner.y - epsilon)return(NO);
10154 // if(pnt2.y <= block -> ll_corner.y + epsilon || pnt2.y >= block -> ur_corner.y - epsilon)return(NO);
10155 //
10156 // return(YES);
10157 // }
10158 //
10159 //
10160 // /* ellipsoids greater by epsilon */
10161 //
10162 
10163 // XXerror - bool -> int
10164 int check_ellipsoid_ellipsoid_overlap (ellipsoid_rec *ellipsoid1, ellipsoid_rec *ellipsoid2)
10165 {
10166  point_rec pnt1, pnt2, p1, p2;
10167  double max, max1, max2;
10168  double dist, dist1, dist2;
10169  double u1, uu1, uuu1, u2, uu2, uuu2, delta_u = EPSILON_U;
10170  double v1, vv1, vvv1, v2, vv2, vvv2, delta_v = EPSILON_V;
10171  int oo1, ooo1, oo2, ooo2;
10172  int o1, o2; // XXerror
10173 
10174  if(ellipsoid1 -> id == ellipsoid2 -> id) return false;
10175 
10176  max1 = ellipsoid1 -> max + epsilon;
10177  max2 = ellipsoid2 -> max + epsilon;
10178  max = max1 + max2;
10179 
10180  /* intersection of circumsribed spheres */
10181  dist = dist_point(ellipsoid1 -> center, ellipsoid2 -> center);
10182  if (dist > max * max) return false;
10183 
10184  /* center of ellipsoid2 inside ellipsoid1 */
10185  if(check_point_inside_ellipsoid(&(ellipsoid2 -> center), ellipsoid1) == YES) return true;
10186 
10187  /* center of ellipsoid1 inside ellipsoid2 */
10188  if(check_point_inside_ellipsoid(&(ellipsoid1 -> center), ellipsoid2) == YES) return true;
10189 
10190  /* intersection of sphere circumscribed to ellipsoid1 with ellipsoid2 */
10191  o2 = project_point_to_ellipsoid(&(ellipsoid1 -> center), ellipsoid2, &pnt2, &u2, &v2); if (o2 == -1) return -1; // XXerror
10192  dist1 = dist_point(ellipsoid1 -> center, pnt2);
10193  if(dist1 > max1 * max1) return false;
10194 
10195  /* closest point on ellipsoid2 to center of ellipsoid1 inside ellipsoid1 */
10196  if(check_point_inside_ellipsoid(&pnt2, ellipsoid1) == YES) return true;
10197 
10198  /* intersection of sphere circumscribed to ellipsoid2 with ellipsoid1 */
10199  o1 = project_point_to_ellipsoid(&(ellipsoid2 -> center), ellipsoid1, &pnt1, &u1, &v1); if (o1 == -1) return -1; // XXerror
10200  dist2 = dist_point(ellipsoid2 -> center, pnt1);
10201  if(dist2 > max2 * max2) return false;
10202 
10203  /* closest point on ellipsoid1 to center of ellipsoid2 inside ellipsoid2 */
10204  if(check_point_inside_ellipsoid(&pnt1, ellipsoid2) == YES) return true;
10205 
10206  /* the iterations should not oscillate between octants because the sphere tests have been already done */
10207 
10208  /* find closest points starting from pnt1 */
10209  while(YES){
10210  ooo2 = project_point_to_ellipsoid(&pnt1, ellipsoid2, &p2, &uuu2, &vvv2); if (ooo2 == -1) return -1; // XXerror
10211  oo1 = project_point_to_ellipsoid(&p2, ellipsoid1, &pnt1, &uu1, &vv1); if (oo1 == -1) return -1; // XXerror
10212  if(fabs(u1 - uu1) < delta_u && fabs(v1 - vv1) < delta_v)break;
10213  u1 = uu1;
10214  v1 = vv1;
10215  }
10216 
10217  /* find closest points starting from pnt2 */
10218  while(YES){
10219  ooo1 = project_point_to_ellipsoid(&pnt2, ellipsoid1, &p1, &uuu1, &vvv1); if (ooo1 == -1) return -1; // XXerror
10220  oo2 = project_point_to_ellipsoid(&p1, ellipsoid2, &pnt2, &uu2, &vv2); if (oo2 == -1) return -1; // XXerror
10221  if(fabs(u2 - uu2) < delta_u && fabs(v2 - vv2) < delta_v)break;
10222  u2 = uu2;
10223  v2 = vv2;
10224  }
10225 
10226  /* there is a problem that intersections of ellipsoids may be in different octants;
10227  in this case averaging of parameters makes no sense but it is clear that ellipsoids do intersect */
10228 
10229  if(oo1 != ooo1 || oo2 != ooo2) return true;
10230 
10231  u1 = (uu1 + uuu1) / 2.0;
10232  v1 = (vv1 + vvv1) / 2.0;
10233  u2 = (uu2 + uuu2) / 2.0;
10234  v2 = (vv2 + vvv2) / 2.0;
10235  get_ellipsoid_point_octant(ellipsoid1, oo1, u1, v1, &pnt1);
10236  get_ellipsoid_point_octant(ellipsoid2, oo2, u2, v2, &pnt2);
10237 
10238  /* check pnt1 inside ellipsoid2 */
10239  if(check_point_inside_ellipsoid(&pnt1, ellipsoid2) == YES) return true;
10240 
10241  /* check pnt2 inside ellipsoid1 */
10242  if(check_point_inside_ellipsoid(&pnt2, ellipsoid1) == YES) return true;
10243 
10244  return false;
10245 }
10246 
10247 
10248 
10249 // /* cylinder smaller by epsilon */
10250 //
10251 // static logic
10252 // check_crack_cylinder_intersection(crack_rec *crack, cylinder_rec *cylinder)
10253 // {
10254 // point_rec dir, normal, pnt[4], point, grad;
10255 // ellipse_rec ellipse;
10256 // double radius, dist, t;
10257 // int i, q, count;
10258 // logic not_vertical;
10259 //
10260 // /* check intersection with lower and upper bases */
10261 //
10262 // normal.x = 0.0;
10263 // normal.y = 0.0;
10264 // normal.z = 1.0;
10265 //
10266 // if(get_plane_plane_intersection(&(crack -> crack.center), &(crack -> crack.normal),
10267 // &(crack -> crack.center), &normal, &point, &dir) == YES){
10268 // get_ellipse_line_center_intersection(&(crack -> crack), &dir, &pnt[0], &pnt[1]);
10269 // q = project_point_to_ellipse(&pnt[0], &(crack -> crack), &point, &t);
10270 // get_ellipse_gradient_quadrant(&(crack -> crack), q, t, &grad);
10271 // get_ellipse_line_center_intersection(&(crack -> crack), &grad, &pnt[0], &pnt[1]);
10272 //
10273 // for(i = 0; i < 2; i++){
10274 // if(pnt[i].z <= cylinder -> lower_center.z + epsilon || pnt[i].z >= cylinder -> upper_center.z - epsilon){
10275 // if(check_point_on_crack_tip(&pnt[i], crack) == YES)return(YES);
10276 // }
10277 // }
10278 // }
10279 //
10280 // /* check intersection with circumferential face */
10281 //
10282 // cylinder -> radius -= epsilon;
10283 // not_vertical = get_cylinder_plane_intersection(cylinder, &(crack -> crack.center), &(crack -> crack.normal), &ellipse);
10284 // cylinder -> radius += epsilon;
10285 //
10286 // if(not_vertical == YES){
10287 // count = get_ellipse_ellipse_intersection(&ellipse, &(crack -> crack), pnt);
10288 // for(i = 0; i < count; i++){
10289 // if(check_point_on_crack_tip(&pnt[i], crack) == YES)return(YES);
10290 // }
10291 // }
10292 // else{
10293 //
10294 // /* ellipse is vertical */
10295 //
10296 // get_ellipse_line_center_intersection(&(crack -> crack), &normal, &pnt[0], &pnt[1]);
10297 // q = project_point_to_ellipse(&pnt[0], &(crack -> crack), &point, &t);
10298 // get_ellipse_gradient_quadrant(&(crack -> crack), q, t, &grad);
10299 // get_ellipse_line_center_intersection(&(crack -> crack), &grad, &pnt[0], &pnt[1]);
10300 //
10301 // radius = cylinder -> radius - epsilon;
10302 // copy_vec(point, cylinder -> lower_center);
10303 //
10304 // for(i = 0; i < 2; i++){
10305 // point.z = pnt[i].z;
10306 // dist = dist_point(point, pnt[i]);
10307 // if(dist >= radius * radius){
10308 // if(check_point_on_crack_tip(&pnt[i], crack) == YES)return(YES);
10309 // }
10310 // }
10311 // }
10312 //
10313 // return(NO);
10314 // }
10315 //
10316 //
10317 // /* block smaller by epsilon */
10318 //
10319 // static logic
10320 // check_crack_block_intersection(crack_rec *crack, block_rec *block)
10321 // {
10322 // point_rec dir, normal, pnt[4], point, grad;
10323 // double t;
10324 // int i, q;
10325 //
10326 // /* check intersection with lower and upper bases */
10327 //
10328 // normal.x = 0.0;
10329 // normal.y = 0.0;
10330 // normal.z = 1.0;
10331 //
10332 // if(get_plane_plane_intersection(&(crack -> crack.center), &(crack -> crack.normal),
10333 // &(crack -> crack.center), &normal, &point, &dir) == YES){
10334 // get_ellipse_line_center_intersection(&(crack -> crack), &dir, &pnt[0], &pnt[1]);
10335 // q = project_point_to_ellipse(&pnt[0], &(crack -> crack), &point, &t);
10336 // get_ellipse_gradient_quadrant(&(crack -> crack), q, t, &grad);
10337 // get_ellipse_line_center_intersection(&(crack -> crack), &grad, &pnt[0], &pnt[1]);
10338 //
10339 // for(i = 0; i < 2; i++){
10340 // if(pnt[i].z <= block -> ll_corner.z + epsilon || pnt[i].z >= block -> ur_corner.z - epsilon){
10341 // if(check_point_on_crack_tip(&pnt[i], crack) == YES)return(YES);
10342 // }
10343 // }
10344 // }
10345 //
10346 // /* check intersection with front and back sides */
10347 //
10348 // normal.x = 1.0;
10349 // normal.y = 0.0;
10350 // normal.z = 0.0;
10351 //
10352 // if(get_plane_plane_intersection(&(crack -> crack.center), &(crack -> crack.normal),
10353 // &(crack -> crack.center), &normal, &point, &dir) == YES){
10354 // get_ellipse_line_center_intersection(&(crack -> crack), &dir, &pnt[0], &pnt[1]);
10355 // q = project_point_to_ellipse(&pnt[0], &(crack -> crack), &point, &t);
10356 // get_ellipse_gradient_quadrant(&(crack -> crack), q, t, &grad);
10357 // get_ellipse_line_center_intersection(&(crack -> crack), &grad, &pnt[0], &pnt[1]);
10358 //
10359 // for(i = 0; i < 2; i++){
10360 // if(pnt[i].x <= block -> ll_corner.x + epsilon || pnt[i].x >= block -> ur_corner.x - epsilon){
10361 // if(check_point_on_crack_tip(&pnt[i], crack) == YES)return(YES);
10362 // }
10363 // }
10364 // }
10365 //
10366 // /* check intersection with left and right sides */
10367 //
10368 // normal.x = 0.0;
10369 // normal.y = 1.0;
10370 // normal.z = 0.0;
10371 //
10372 // if(get_plane_plane_intersection(&(crack -> crack.center), &(crack -> crack.normal),
10373 // &(crack -> crack.center), &normal, &point, &dir) == YES){
10374 // get_ellipse_line_center_intersection(&(crack -> crack), &dir, &pnt[0], &pnt[1]);
10375 // q = project_point_to_ellipse(&pnt[0], &(crack -> crack), &point, &t);
10376 // get_ellipse_gradient_quadrant(&(crack -> crack), q, t, &grad);
10377 // get_ellipse_line_center_intersection(&(crack -> crack), &grad, &pnt[0], &pnt[1]);
10378 //
10379 // for(i = 0; i < 2; i++){
10380 // if(pnt[i].y <= block -> ll_corner.y + epsilon || pnt[i].y >= block -> ur_corner.y - epsilon){
10381 // if(check_point_on_crack_tip(&pnt[i], crack) == YES)return(YES);
10382 // }
10383 // }
10384 // }
10385 //
10386 // return(NO);
10387 // }
10388 //
10389 //
10390 //
10391 // /* ellipsoid greater by epsilon */
10392 //
10393 // static logic
10394 // check_crack_ellipsoid_intersection(crack_rec *crack, ellipsoid_rec *ellipsoid)
10395 // {
10396 // ellipse_rec ellipse;
10397 // point_rec pnt[4], point, p;
10398 // double value, t;
10399 // int i, count, q;
10400 // logic intersect = NO;
10401 //
10402 // expand_ellipsoid(*ellipsoid);
10403 // intersect = get_ellipsoid_plane_intersection(ellipsoid, &(crack -> crack.center), &(crack -> crack.normal), &ellipse);
10404 // shrink_ellipsoid(*ellipsoid);
10405 //
10406 // if(intersect == NO)return(NO);
10407 //
10408 // count = get_ellipse_ellipse_intersection(&ellipse, &(crack -> crack), pnt);
10409 // if(count == 0){
10410 // if(check_point_inside_ellipse(&(crack -> crack.center), &ellipse, &value) == YES)return(YES);
10411 // if(check_point_inside_ellipse(&(ellipse.center), &(crack -> crack), &value) == NO)return(NO);
10412 //
10413 // if(crack -> segment == NO)return(YES);
10414 //
10415 // q = project_point_to_ellipse(&(ellipse.center), &(crack -> contact), &point, &t);
10416 // if(check_point_inside_ellipse(&point, &(crack -> crack), &value) == YES){
10417 // return(check_point_on_ellipse_interval(q, t, crack -> qa, crack -> ta, crack -> qb, crack -> tb));
10418 // }
10419 //
10420 // q = project_point_to_ellipse(&point, &(crack -> crack), &p, &t);
10421 // return(check_point_on_ellipse_interval(q, t, crack -> q1, crack -> t1, crack -> q2, crack -> t2));
10422 // }
10423 //
10424 // for(i = 0; i < count; i++){
10425 // if(check_point_on_crack_tip(&pnt[i], crack) == YES)return(YES);
10426 // }
10427 //
10428 // return(NO);
10429 // }
10430 //
10431 //
10432 //
10433 // /* epsilon */
10434 //
10435 // static logic
10436 // check_crack_crack_intersection(crack_rec *crack1, crack_rec *crack2)
10437 // {
10438 // point_rec pnt[4], pnt1[2], pnt2[2], point, dir, vec;
10439 // double t1[2], t2[2], dist, tmp;
10440 // int i, count, count1, count2;
10441 //
10442 // if(get_plane_plane_intersection(&(crack1 -> crack.center), &(crack1 -> crack.normal),
10443 // &(crack2 -> crack.center), &(crack2 -> crack.normal),
10444 // &point, &dir) == YES){
10445 // count1 = get_ellipse_line_intersection(&(crack1 -> crack), &point, &dir, pnt1);
10446 // if(count1 != 0){
10447 // count2 = get_ellipse_line_intersection(&(crack2 -> crack), &point, &dir, pnt2);
10448 // if(count2 != 0){
10449 // for(i = 0; i < count1; i++){
10450 // sub_vec(vec, point, pnt1[i]);
10451 // t1[i] = dot_product(vec, dir);
10452 // }
10453 // for(i = 0; i < count2; i++){
10454 // sub_vec(vec, point, pnt2[i]);
10455 // t2[i] = dot_product(vec, dir);
10456 // }
10457 //
10458 // if(count1 == 1)
10459 // t1[1] = t1[0];
10460 // else{
10461 // if(t1[0] > t1[1])swap(t1[0], t1[1], tmp);
10462 // }
10463 // if(count2 == 1)
10464 // t2[1] = t2[0];
10465 // else{
10466 // if(t2[0] > t2[1])swap(t2[0], t2[1], tmp);
10467 // }
10468 //
10469 // if(t2[0] > t1[1] + epsilon)return(NO);
10470 // if(t2[1] < t1[0] - epsilon)return(NO);
10471 //
10472 // for(i = 0; i < count1; i++){
10473 // if(check_point_on_crack_tip(&pnt1[i], crack1) == YES)return(YES);
10474 // }
10475 // for(i = 0; i < count2; i++){
10476 // if(check_point_on_crack_tip(&pnt2[i], crack2) == YES)return(YES);
10477 // }
10478 // }
10479 // }
10480 // return(NO);
10481 // }
10482 //
10483 // sub_vec(vec, crack1 -> crack.center, crack2 -> crack.center);
10484 // dist = fabs(dot_product(vec, crack1 -> crack.normal));
10485 //
10486 // if(dist > epsilon && dist > EPSILON)return(NO);
10487 //
10488 // expand_ellipse(crack1 -> crack);
10489 // count = get_ellipse_ellipse_intersection(&(crack1 -> crack), &(crack2 -> crack), pnt);
10490 // shrink_ellipse(crack1 -> crack);
10491 //
10492 // for(i = 0; i < count; i++){
10493 // if(check_point_on_crack_tip(&pnt[i], crack1) == YES)return(YES);
10494 // }
10495 //
10496 // return(NO);
10497 // }
10498 //
10499 //
10500 //
10501 
10503 static bool check_point_inside_ellipsoid (point_rec *point, ellipsoid_rec *ellipsoid)
10504 {
10505  point_rec pnt;
10506  trans_matrix trans;
10507  double x_rate, y_rate, z_rate, value;
10508 
10509  copy_vec(trans.x, ellipsoid -> major);
10510  copy_vec(trans.y, ellipsoid -> minor);
10511  copy_vec(trans.z, ellipsoid -> middle);
10512 
10513  transform_from_global_to_local(point, &pnt, &(ellipsoid -> center), &trans);
10514 
10515  x_rate = pnt.x / (ellipsoid -> max + epsilon);
10516  y_rate = pnt.y / (ellipsoid -> min + epsilon);
10517  z_rate = pnt.z / (ellipsoid -> mid + epsilon);
10518 
10519  value = x_rate * x_rate + y_rate * y_rate + z_rate * z_rate - 1.0;
10520  if (value <= 0.0) return true;
10521 
10522  return false;
10523 }
10524 
10525 
10526 
10527 // /* exact */
10528 //
10529 // static logic
10530 // get_ellipsoid_plane_intersection(ellipsoid_rec *ellipsoid, point_rec *center, point_rec *normal, ellipse_rec *ellipse)
10531 // {
10532 // point_rec cos_xg, cos_yg, cos_zg, vec, orig, point, pnt;
10533 // trans_matrix trans, t;
10534 // double x1, y1, z1, x2, y2, xg, yg, zg, max, min, a, b, c, norm, coeff, diff, dif2, tmp;
10535 // double mat[36], inv[36], rhs[36], res[6], dif[6];
10536 // int i, j;
10537 //
10538 // /* cos_xg.x = cos(xg,xl), cos_yg.x = cos(yg,xl), cos_zg.x = cos(zg,xl)
10539 // cos_xg.y = cos(xg,yl), cos_yg.y = cos(yg,yl), cos_zg.y = cos(zg,yl)
10540 // cos_xg.z = cos(xg,zl), cos_yg.z = cos(yg,zl), cos_zg.z = cos(zg,zl) */
10541 //
10542 // /* equation ordering:
10543 // 1: cos_xg . cos_zg = 0
10544 // 2: (cos_xg . cos_xg - 1) / 2 = 0
10545 // 3: cos_xg . cos_yg = 0
10546 // 4: cos_yg . cos_zg = 0
10547 // 5: (cos_yg .cos_yg - 1) / 2 = 0
10548 // 6: mixed_term = 0 */
10549 //
10550 // /* unknown ordering:
10551 // 1 - 3: cos_xg
10552 // 4 - 6: cos_yg */
10553 //
10554 // /* matrix profile corresponding to equation and unknown ordering:
10555 // x x x 0 0 0
10556 // x x x 0 0 0
10557 // x x x x x x
10558 // 0 0 0 x x x
10559 // 0 0 0 x x x
10560 // x x x x x x */
10561 //
10562 // orig.x = orig.y = orig.z = 0.0;
10563 //
10564 // copy_vec(trans.x, ellipsoid -> major);
10565 // copy_vec(trans.y, ellipsoid -> minor);
10566 // copy_vec(trans.z, ellipsoid -> middle);
10567 //
10568 // norm = sqrt(size_vec(*normal));
10569 // if(norm < EPSILON)error_message(GENERAL_ERROR, "Zero normal plane");
10570 // div_vec(*normal, norm);
10571 //
10572 // transform_from_global_to_local(normal, &cos_zg, &orig, &trans);
10573 //
10574 // sub_vec(vec, *center, ellipsoid -> center);
10575 // zg = dot_product(vec, *normal);
10576 //
10577 // a = ellipsoid -> max;
10578 // b = ellipsoid -> min;
10579 // c = ellipsoid -> mid;
10580 //
10581 // /* initiate solution that satisfies first 5 equations */
10582 //
10583 // x1 = fabs(cos_zg.x);
10584 // y1 = fabs(cos_zg.y);
10585 // z1 = fabs(cos_zg.z);
10586 //
10587 // if(x1 >= ((y1 > z1) ? y1 : z1)){
10588 // cos_xg.y = 0.0;
10589 // cos_xg.z = sqrt(1.0 / (1.0 + z1 * z1 / x1 / x1));
10590 // cos_xg.x = -cos_xg.z * cos_zg.z / cos_zg.x;
10591 // }
10592 // else{
10593 // if(y1 >= ((x1 > z1) ? x1 : z1)){
10594 // cos_xg.z = 0.0;
10595 // cos_xg.x = sqrt(1.0 / (1.0 + x1 * x1 / y1 / y1));
10596 // cos_xg.y = -cos_xg.x * cos_zg.x / cos_zg.y;
10597 // }
10598 // else{
10599 // cos_xg.x = 0.0;
10600 // cos_xg.y = sqrt(1.0 / (1.0 + y1 * y1 / z1 / z1));
10601 // cos_xg.z = -cos_xg.y * cos_zg.y / cos_zg.z;
10602 // }
10603 // }
10604 //
10605 // cross_product(cos_yg, cos_zg, cos_xg);
10606 //
10607 // if(fabs(a - b) < EPSILON && fabs(b - c) < EPSILON && fabs(c - a) < EPSILON){
10608 //
10609 // /* sphere */
10610 //
10611 // max = min = sqrt(a * a - zg * zg);
10612 // xg = yg = 0.0;
10613 // }
10614 // else{
10615 // a *= a;
10616 // b *= b;
10617 // c *= c;
10618 //
10619 // while(YES){
10620 // array(mat, 6, 6, 0, 0) = cos_zg.x;
10621 // array(mat, 6, 6, 0, 1) = cos_zg.y;
10622 // array(mat, 6, 6, 0, 2) = cos_zg.z;
10623 // array(mat, 6, 6, 0, 3) = 0.0;
10624 // array(mat, 6, 6, 0, 4) = 0.0;
10625 // array(mat, 6, 6, 0, 5) = 0.0;
10626 //
10627 // array(mat, 6, 6, 1, 0) = cos_xg.x;
10628 // array(mat, 6, 6, 1, 1) = cos_xg.y;
10629 // array(mat, 6, 6, 1, 2) = cos_xg.z;
10630 // array(mat, 6, 6, 1, 3) = 0.0;
10631 // array(mat, 6, 6, 1, 4) = 0.0;
10632 // array(mat, 6, 6, 1, 5) = 0.0;
10633 //
10634 // array(mat, 6, 6, 2, 0) = cos_yg.x;
10635 // array(mat, 6, 6, 2, 1) = cos_yg.y;
10636 // array(mat, 6, 6, 2, 2) = cos_yg.z;
10637 // array(mat, 6, 6, 2, 3) = cos_xg.x;
10638 // array(mat, 6, 6, 2, 4) = cos_xg.y;
10639 // array(mat, 6, 6, 2, 5) = cos_xg.z;
10640 //
10641 // array(mat, 6, 6, 3, 0) = 0.0;
10642 // array(mat, 6, 6, 3, 1) = 0.0;
10643 // array(mat, 6, 6, 3, 2) = 0.0;
10644 // array(mat, 6, 6, 3, 3) = cos_zg.x;
10645 // array(mat, 6, 6, 3, 4) = cos_zg.y;
10646 // array(mat, 6, 6, 3, 5) = cos_zg.z;
10647 //
10648 // array(mat, 6, 6, 4, 0) = 0.0;
10649 // array(mat, 6, 6, 4, 1) = 0.0;
10650 // array(mat, 6, 6, 4, 2) = 0.0;
10651 // array(mat, 6, 6, 4, 3) = cos_yg.x;
10652 // array(mat, 6, 6, 4, 4) = cos_yg.y;
10653 // array(mat, 6, 6, 4, 5) = cos_yg.z;
10654 //
10655 // array(mat, 6, 6, 5, 0) = cos_yg.x / a;
10656 // array(mat, 6, 6, 5, 1) = cos_yg.y / b;
10657 // array(mat, 6, 6, 5, 2) = cos_yg.z / c;
10658 // array(mat, 6, 6, 5, 3) = cos_xg.x / a;
10659 // array(mat, 6, 6, 5, 4) = cos_xg.y / b;
10660 // array(mat, 6, 6, 5, 5) = cos_xg.z / c;
10661 //
10662 // for(i = 0; i < 36; i++)rhs[i] = 0.0;
10663 // for(i = 0; i < 6; i++)array(rhs, 6, 6, i, i) = 1.0;
10664 //
10665 // solve_full_system(mat, inv, rhs, 6, 6);
10666 //
10667 // res[0] = dot_product(cos_xg, cos_zg);
10668 // res[1] = (size_vec(cos_xg) - 1.0) / 2.0;
10669 // res[2] = dot_product(cos_xg, cos_yg);
10670 // res[3] = dot_product(cos_yg, cos_zg);
10671 // res[4] = (size_vec(cos_yg) - 1.0) / 2.0;
10672 // res[5] = cos_xg.x * cos_yg.x / a + cos_xg.y * cos_yg.y / b + cos_xg.z * cos_yg.z / c;
10673 //
10674 // dif2 = 0.0;
10675 // for(i = 0; i < 6; i++){
10676 // diff = 0.0;
10677 // for(j = 0; j < 6; j++)diff += array(inv, 6, 6, i, j) * res[j];
10678 // dif[i] = diff;
10679 // dif2 += diff * diff;
10680 // }
10681 //
10682 // cos_xg.x -= dif[0];
10683 // cos_xg.y -= dif[1];
10684 // cos_xg.z -= dif[2];
10685 // cos_yg.x -= dif[3];
10686 // cos_yg.y -= dif[4];
10687 // cos_yg.z -= dif[5];
10688 //
10689 // if(dif2 < EPSILON * EPSILON)break;
10690 // }
10691 //
10692 // /* equation of ellipsoid in local coordinate system (variables are in ())
10693 // (x)^2 / a + (y)^2 / b + (z)^2 / c = 1;
10694 // substituting coordinate transformation yields equation of ellipsoid in global (plane) coordinate system
10695 // substituting zg yields equation of intersecting ellipse in global (plane) coordinate system and alligned
10696 // with that system (mixed term (x)*(y) equals zero)
10697 // x2 * (x)^2 + 2.0 * x1 * (x) + y2 * (y)^2 + 2.0 * y1 * (y) + z1 = 1;
10698 // that must be compatible with following equation
10699 // ((x) - xg)^2 / max^2 + ((y) - yg)^2 / min^2 = 1; */
10700 //
10701 // x1 = zg * (cos_xg.x * cos_zg.x / a + cos_xg.y * cos_zg.y / b + cos_xg.z * cos_zg.z / c);
10702 // y1 = zg * (cos_yg.x * cos_zg.x / a + cos_yg.y * cos_zg.y / b + cos_yg.z * cos_zg.z / c);
10703 // z1 = zg * zg * (cos_zg.x * cos_zg.x / a + cos_zg.y * cos_zg.y / b + cos_zg.z * cos_zg.z / c);
10704 //
10705 // x2 = cos_xg.x * cos_xg.x / a + cos_xg.y * cos_xg.y / b + cos_xg.z * cos_xg.z / c;
10706 // y2 = cos_yg.x * cos_yg.x / a + cos_yg.y * cos_yg.y / b + cos_yg.z * cos_yg.z / c;
10707 //
10708 // coeff = 1.0 - z1 + x1 * x1 / x2 + y1 * y1 / y2;
10709 // if(coeff < EPSILON)return(NO);
10710 //
10711 // max = sqrt(coeff / x2);
10712 // min = sqrt(coeff / y2);
10713 //
10714 // xg = -x1 / x2;
10715 // yg = -y1 / y2;
10716 //
10717 // if(max < min){
10718 // swap(max, min, tmp);
10719 // swap(cos_xg.x, cos_yg.x, tmp);
10720 // swap(cos_xg.y, cos_yg.y, tmp);
10721 // swap(cos_xg.z, cos_yg.z, tmp);
10722 // mul_vec(cos_yg, -1.0);
10723 // swap(xg, yg, tmp);
10724 // yg *= -1.0;
10725 // }
10726 // }
10727 //
10728 // invert_transformation(&trans);
10729 //
10730 // ellipse -> max = max;
10731 // ellipse -> min = min;
10732 //
10733 // copy_vec(t.x, cos_xg);
10734 // copy_vec(t.y, cos_yg);
10735 // copy_vec(t.z, cos_zg);
10736 //
10737 // invert_transformation(&t);
10738 //
10739 // point.x = xg;
10740 // point.y = yg;
10741 // point.z = zg;
10742 // transform_from_global_to_local(&point, &pnt, &orig, &t);
10743 // transform_from_local_to_global(&(ellipse -> center), &pnt, &(ellipsoid -> center), &trans);
10744 //
10745 // point.x = xg + max;
10746 // point.y = yg;
10747 // point.z = zg;
10748 // transform_from_global_to_local(&point, &pnt, &orig, &t);
10749 // transform_from_local_to_global(&(ellipse -> pnt0), &pnt, &(ellipsoid -> center), &trans);
10750 //
10751 // point.x = xg + max;
10752 // point.y = yg + min;
10753 // point.z = zg;
10754 // transform_from_global_to_local(&point, &pnt, &orig, &t);
10755 // transform_from_local_to_global(&(ellipse -> pnt1), &pnt, &(ellipsoid -> center), &trans);
10756 //
10757 // point.x = xg;
10758 // point.y = yg + min;
10759 // point.z = zg;
10760 // transform_from_global_to_local(&point, &pnt, &orig, &t);
10761 // transform_from_local_to_global(&(ellipse -> pnt2), &pnt, &(ellipsoid -> center), &trans);
10762 //
10763 // copy_vec(ellipse -> normal, *normal);
10764 // transform_from_local_to_global(&(ellipse -> major), &cos_xg, &orig, &trans);
10765 // transform_from_local_to_global(&(ellipse -> minor), &cos_yg, &orig, &trans);
10766 //
10767 // return(YES);
10768 // }
10769 //
10770 //
10771 //
10772 //
10773 // /* exact */
10774 //
10775 // static void
10776 // get_ellipsoid_line_center_intersection(ellipsoid_rec *ellipsoid, point_rec *dir, point_rec *pnt1, point_rec *pnt2)
10777 // {
10778 // trans_matrix trans;
10779 // point_rec direction, orig;
10780 // double a, b, c, t, norm;
10781 //
10782 // norm = size_vec(*dir);
10783 // if(norm < EPSILON * EPSILON)error_message(GENERAL_ERROR, "Zero length direction");
10784 //
10785 // copy_vec(trans.x, ellipsoid -> major);
10786 // copy_vec(trans.y, ellipsoid -> minor);
10787 // copy_vec(trans.z, ellipsoid -> middle);
10788 //
10789 // orig.x = orig.y = orig.z = 0.0;
10790 //
10791 // transform_from_global_to_local(dir, &direction, &orig, &trans);
10792 //
10793 // a = direction.x / ellipsoid -> max;
10794 // b = direction.y / ellipsoid -> min;
10795 // c = direction.z / ellipsoid -> mid;
10796 //
10797 // t = sqrt(1.0 / (a * a + b * b + c * c));
10798 //
10799 // invert_transformation(&trans);
10800 //
10801 // mul_vec(direction, t);
10802 // transform_from_local_to_global(pnt1, &direction, &(ellipsoid -> center), &trans);
10803 //
10804 // mul_vec(direction, -1.0);
10805 // transform_from_local_to_global(pnt2, &direction, &(ellipsoid -> center), &trans);
10806 // }
10807 //
10808 //
10809 //
10810 //
10811 // /* exact */
10812 //
10813 // static logic
10814 // get_cylinder_plane_intersection(cylinder_rec *cylinder, point_rec *point, point_rec *normal, ellipse_rec *ellipse)
10815 // {
10816 // point_rec vertical, pnt, dir;
10817 // trans_matrix trans;
10818 // double cosine, norm;
10819 //
10820 // vertical.x = 0.0;
10821 // vertical.y = 0.0;
10822 // vertical.z = 1.0;
10823 //
10824 // norm = sqrt(size_vec(*normal));
10825 // if(norm < EPSILON)error_message(GENERAL_ERROR, "Zero normal plane");
10826 // div_vec(*normal, norm);
10827 //
10828 // cosine = dot_product(*normal, vertical);
10829 // if(fabs(cosine) < EPSILON)return(NO);
10830 //
10831 // if(get_plane_plane_intersection(point, normal, point, &vertical, &pnt, &dir) == YES){
10832 // copy_vec(ellipse -> minor, dir);
10833 // }
10834 // else{
10835 // ellipse -> minor.x = 0.0;
10836 // ellipse -> minor.y = 1.0;
10837 // ellipse -> minor.z = 0.0;
10838 // }
10839 // copy_vec(ellipse -> normal, *normal);
10840 // cross_product(ellipse -> major, ellipse -> minor, ellipse -> normal);
10841 //
10842 // ellipse -> max = cylinder -> radius / fabs(cosine);
10843 // ellipse -> min = cylinder -> radius;
10844 //
10845 // ellipse -> center.x = cylinder -> lower_center.x;
10846 // ellipse -> center.y = cylinder -> lower_center.y;
10847 // ellipse -> center.z = 0.0;
10848 //
10849 // ellipse -> center.z = (dot_product(*normal, *point) - dot_product(*normal, ellipse -> center)) / normal -> z;
10850 //
10851 // copy_vec(trans.x, ellipse -> major);
10852 // copy_vec(trans.y, ellipse -> minor);
10853 // copy_vec(trans.z, ellipse -> normal);
10854 //
10855 // invert_transformation(&trans);
10856 //
10857 // pnt.x = ellipse -> max;
10858 // pnt.y = 0.0;
10859 // pnt.z = 0.0;
10860 // transform_from_local_to_global(&(ellipse -> pnt0), &pnt, &(ellipse -> center), &trans);
10861 //
10862 // pnt.x = ellipse -> max;
10863 // pnt.y = ellipse -> min;
10864 // pnt.z = 0.0;
10865 // transform_from_local_to_global(&(ellipse -> pnt1), &pnt, &(ellipse -> center), &trans);
10866 //
10867 // pnt.x = 0.0;
10868 // pnt.y = ellipse -> min;
10869 // pnt.z = 0.0;
10870 // transform_from_local_to_global(&(ellipse -> pnt2), &pnt, &(ellipse -> center), &trans);
10871 //
10872 // return(YES);
10873 // }
10874 //
10875 //
10876 //
10877 //
10878 // /* exact */
10879 //
10880 // static logic
10881 // get_plane_plane_intersection(point_rec *pnt1, point_rec *normal1, point_rec *pnt2, point_rec *normal2,
10882 // point_rec *point, point_rec *dir)
10883 // {
10884 // point_rec vec2;
10885 // double product, norm;
10886 //
10887 // product = dot_product(*normal1, *normal2);
10888 // if(fabs(fabs(product) - 1.0) < EPSILON)return(NO);
10889 //
10890 // cross_product(*dir, *normal1, *normal2);
10891 // norm = sqrt(size_vec(*dir));
10892 // div_vec(*dir, norm);
10893 //
10894 // cross_product(vec2, *normal2, *dir);
10895 // get_plane_line_intersection(pnt1, normal1, pnt2, &vec2, point);
10896 //
10897 // return(YES);
10898 // }
10899 //
10900 //
10901 //
10902 //
10903 // /* exact */
10904 //
10905 // static logic
10906 // get_plane_line_intersection(point_rec *point, point_rec *normal, point_rec *pnt, point_rec *dir, point_rec *intersection)
10907 // {
10908 // double product, t;
10909 //
10910 // product = dot_product(*normal, *dir);
10911 // if(fabs(product) < EPSILON)return(NO);
10912 //
10913 // t = (dot_product(*normal, *point) - dot_product(*normal, *pnt)) / product;
10914 //
10915 // intersection -> x = pnt -> x + t * dir -> x;
10916 // intersection -> y = pnt -> y + t * dir -> y;
10917 // intersection -> z = pnt -> z + t * dir -> z;
10918 //
10919 // return(YES);
10920 // }
10921 //
10922 //
10923 //
10924 //
10925 // static double
10926 // project_point_to_plane(point_rec *pnt, point_rec *point, point_rec *normal, point_rec *projection)
10927 // {
10928 // point_rec vec;
10929 // double product;
10930 //
10931 // sub_vec(vec, *point, *pnt);
10932 // product = dot_product(*normal, vec);
10933 //
10934 // projection -> x = pnt -> x + product * normal -> x;
10935 // projection -> y = pnt -> y + product * normal -> y;
10936 // projection -> z = pnt -> z + product * normal -> z;
10937 //
10938 // return(product);
10939 // }
10940 //
10941 //
10942 //
10943 //
10944 
10946 static int project_point_to_ellipsoid (point_rec *point, ellipsoid_rec *ellipsoid, point_rec *pnt, double *u_par, double *v_par)
10947 {
10948  point_rec grad_u, grad_v, vec, point_spec, pnt_spec, normal, p;
10949  trans_matrix trans;
10950  double xx, yy, zz, dist, norm, rate, rate1 = 0.25, rate2 = 1.5, delta_u = EPSILON_U, delta_v = EPSILON_V;
10951  double u = 0.5, v = 0.5, du, dv, duu, dvv, ddu, ddv, duv, dvu, d_u = 0.0, d_v = 0.0, max_du = 0.25, max_dv = 0.25;
10952  double norm_u, norm_v, det_x, det_y, det_z, abs_det_x, abs_det_y, abs_det_z, delta_x, delta_y, delta_z, dd;
10953  int sign = 0, sign_x = 0, sign_y = 0, sign_z = 0, iter = 0, octant = 0;
10954 
10955  copy_vec(trans.x, ellipsoid -> major);
10956  copy_vec(trans.y, ellipsoid -> minor);
10957  copy_vec(trans.z, ellipsoid -> middle);
10958 
10959  /* move point to the first octant */
10960  transform_from_global_to_local(point, &p, &(ellipsoid -> center), &trans);
10961 
10962  xx = p.x;
10963  yy = p.y;
10964  zz = p.z;
10965 
10966  if(xx == 0.0 && yy == 0.0 && zz == 0.0)
10967  error_message (GENERAL_ERROR, "Point is in center of inclusion %d", ellipsoid -> id);
10968 
10969  if(ellipsoid -> max != ellipsoid -> min && ellipsoid -> max != ellipsoid -> mid){
10970  if(yy == 0.0 && zz == 0.0){
10971  rate = ellipsoid -> min / ellipsoid -> max;
10972  if(fabs(xx) < ellipsoid -> max * (1.0 - rate * rate))
10973  error_message(GENERAL_ERROR, "Point lies on major axis of inclusion %d", ellipsoid -> id);
10974  }
10975  if(yy == 0.0 && xx == 0.0){
10976  rate = ellipsoid -> min / ellipsoid -> mid;
10977  if(fabs(zz) < ellipsoid -> mid * (1.0 - rate * rate))
10978  error_message(GENERAL_ERROR, "Point lies on middle axis of inclusion %d", ellipsoid -> id);
10979  }
10980  }
10981 
10982  p.x = fabs(xx);
10983  p.y = fabs(yy);
10984  p.z = fabs(zz);
10985 
10986  if(xx != 0.0)sign_x = (xx > 0.0) ? 1 : -1;
10987  if(yy != 0.0)sign_y = (yy > 0.0) ? 1 : -1;
10988  if(zz != 0.0)sign_z = (zz > 0.0) ? 1 : -1;
10989 
10990  if(sign_x > 0){
10991  if(sign_y > 0){
10992  if(sign_z > 0)
10993  octant = 1;
10994  else
10995  octant = 5;
10996  }
10997  else{
10998  if(sign_z > 0)
10999  octant = 4;
11000  else
11001  octant = 8;
11002  }
11003  }
11004  else{
11005  if(sign_y > 0){
11006  if(sign_z > 0)
11007  octant = 2;
11008  else
11009  octant = 6;
11010  }
11011  else{
11012  if(sign_z > 0)
11013  octant = 3;
11014  else
11015  octant = 7;
11016  }
11017  }
11018 
11019  if(sign_y == 0 && sign_z == 0)sign = sign_x;
11020  if(sign_z == 0 && sign_x == 0)sign = sign_y;
11021  if(sign_x == 0 && sign_y == 0)sign = sign_z;
11022 
11023  if(sign != 0){
11024  if(sign > 0)
11025  octant = 1;
11026  else
11027  octant = 7;
11028  }
11029 
11030  invert_transformation(&trans);
11031  transform_from_local_to_global(&point_spec, &p, &(ellipsoid -> center), &trans);
11032 
11033  /* make projection (in the first octant) */
11034  while(YES){
11035  get_ellipsoid_point(ellipsoid, u, v, &pnt_spec);
11036 
11037  norm_u = sqrt(get_ellipsoid_u_gradient(ellipsoid, u, v, &grad_u));
11038  norm_v = sqrt(get_ellipsoid_v_gradient(ellipsoid, u, v, &grad_v));
11039  if (norm_u) ;
11040 
11041  if(norm_v < EPSILON && u < delta_u / 2.0){
11042  if(d_u < delta_u)break;
11043 
11044  d_u -= (delta_u / 2.0 - u);
11045  u = delta_u / 2.0;
11046 
11047  norm_u = sqrt(get_ellipsoid_u_gradient(ellipsoid, u, v, &grad_u));
11048  norm_v = sqrt(get_ellipsoid_v_gradient(ellipsoid, u, v, &grad_v));
11049  }
11050 
11051  cross_product(normal, grad_u, grad_v);
11052 
11053  abs_det_x = fabs(det_x = normal.x);
11054  abs_det_y = fabs(det_y = normal.y);
11055  abs_det_z = fabs(det_z = normal.z);
11056 
11057  norm = det_x * det_x + det_y * det_y + det_z * det_z;
11058 
11059  sub_vec(vec, point_spec, pnt_spec);
11060  dist = dot_product(vec, normal) / norm;
11061 
11062  delta_x = point_spec.x - dist * normal.x - pnt_spec.x;
11063  delta_y = point_spec.y - dist * normal.y - pnt_spec.y;
11064  delta_z = point_spec.z - dist * normal.z - pnt_spec.z;
11065 
11066  if(abs_det_x > abs_det_y && abs_det_x > abs_det_z){
11067  du = (+ grad_v.z * delta_y - grad_v.y * delta_z) / det_x;
11068  dv = (- grad_u.z * delta_y + grad_u.y * delta_z) / det_x;
11069  }
11070  else{
11071  if(abs_det_y > abs_det_z){
11072  du = (+ grad_v.x * delta_z - grad_v.z * delta_x) / det_y;
11073  dv = (- grad_u.x * delta_z + grad_u.z * delta_x) / det_y;
11074  }
11075  else{
11076  du = (+ grad_v.y * delta_x - grad_v.x * delta_y) / det_z;
11077  dv = (- grad_u.y * delta_x + grad_u.x * delta_y) / det_z;
11078  }
11079  }
11080 
11081  if(fabs(du) < delta_u && fabs(dv) < delta_v)break;
11082 
11083  ddu = fabs(du);
11084  ddv = fabs(dv);
11085 
11086  if(ddu > max_du || ddv > max_dv){
11087  ddu /= max_du;
11088  ddv /= max_dv;
11089  dd = (ddu > ddv) ? ddu : ddv;
11090  du /= dd;
11091  dv /= dd;
11092  }
11093 
11094  if(iter != 0){
11095  dd = du * d_u + dv * d_v;
11096  if(dd < 0.0){
11097  ddu = du + rate1 * d_u;
11098  ddv = dv + rate1 * d_v;
11099  if(d_u * ddu + d_v * ddv < 0.0){
11100  dd = -dd / rate1 / (d_u * d_u + d_v * d_v);
11101  du /= dd;
11102  dv /= dd;
11103  }
11104  }
11105  else{
11106  ddu = du - rate2 * d_u;
11107  ddv = dv - rate2 * d_v;
11108  if(d_u * ddu + d_v * ddv > 0.0){
11109  dd = dd / rate2 / (d_u * d_u + d_v * d_v);
11110  du /= dd;
11111  dv /= dd;
11112  }
11113  }
11114  }
11115 
11116  duu = dvu = d_u = du;
11117  dvv = duv = d_v = dv;
11118 
11119  if(du < 0.0){
11120  if(u + du < 0.0){
11121  duu = (0.0 - u) / 2.0;
11122  if(du < -delta_u)duv = duu / du * dv;
11123  }
11124  }
11125  if(du > 0.0){
11126  if(u + du > 1.0){
11127  duu = (1.0 - u) / 2.0;
11128  if(du > delta_v)duv = duu / du * dv;
11129  }
11130  }
11131 
11132  if(dv < 0.0){
11133  if(v + dv < 0.0){
11134  dvv = (0.0 - v) / 2.0;
11135  if(dv < -delta_v)dvu = dvv / dv * du;
11136  }
11137  }
11138  if(dv > 0.0){
11139  if(v + dv > 1.0){
11140  dvv = (1.0 - v) / 2.0;
11141  if(dv > delta_v)dvu = dvv / dv * du;
11142  }
11143  }
11144 
11145  iter++;
11146  if(iter == MAX_ITER)
11147  return -1; // XXerror
11148  //error_message(GENERAL_ERROR, "Projection to ellipsoid does not converge");
11149 
11150  u += (d_u = (fabs(duu) < fabs(dvu)) ? duu : dvu);
11151  v += (d_v = (fabs(dvv) < fabs(duv)) ? dvv : duv);
11152 
11153  if(u < 0.0)u = 0.0;
11154  if(v < 0.0)v = 0.0;
11155  if(u > 1.0)u = 1.0;
11156  if(v > 1.0)v = 1.0;
11157  }
11158 
11159  /* move projection to original octant */
11160  invert_transformation(&trans);
11161  transform_from_global_to_local(&pnt_spec, &p, &(ellipsoid -> center), &trans);
11162  p.x *= sign_x;
11163  p.y *= sign_y;
11164  p.z *= sign_z;
11165  invert_transformation(&trans);
11166  transform_from_local_to_global(pnt, &p, &(ellipsoid -> center), &trans);
11167 
11168  /* note: u and v are continuous (but not monotonic)
11169  u = 0 for y = 0, z = 0 v = <0-1> singular point
11170  v = 0 for z = 0
11171  u = 1 for x = 0
11172  v = 1 for y = 0
11173  to prevent confusion, octant is returned
11174  x+,y+,z+ 1
11175  x-,y+,z+ 2
11176  x-,y-,z+ 3
11177  x+,y-,z+ 4
11178  x+,y+,z- 5
11179  x-,y+,z- 6
11180  x-,y-,z- 7
11181  x+,y-,z- 8
11182  zeros are included into octants 1 and 7 */
11183 
11184  *u_par = u;
11185  *v_par = v;
11186  return(octant);
11187 }
11188 
11189 
11191 static void get_ellipsoid_point_octant (ellipsoid_rec *ellipsoid, int octant, double u, double v, point_rec *pnt)
11192 {
11193  point_rec p;
11194  trans_matrix trans;
11195 
11196  get_ellipsoid_point(ellipsoid, u, v, pnt);
11197 
11198  /* move point to octant */
11199  if(octant != 1){
11200  copy_vec(trans.x, ellipsoid -> major);
11201  copy_vec(trans.y, ellipsoid -> minor);
11202  copy_vec(trans.z, ellipsoid -> middle);
11203 
11204  transform_from_global_to_local(pnt, &p, &(ellipsoid -> center), &trans);
11205  if(octant == 2 || octant == 3 || octant == 6 || octant == 7)p.x *= -1.0;
11206  if(octant == 4 || octant == 3 || octant == 8 || octant == 7)p.y *= -1.0;
11207  if(octant == 5 || octant == 6 || octant == 7 || octant == 8)p.z *= -1.0;
11208 
11209  invert_transformation(&trans);
11210  transform_from_local_to_global(pnt, &p, &(ellipsoid -> center), &trans);
11211  }
11212 }
11213 
11214 
11215 // static void
11216 // get_ellipsoid_normal_octant(ellipsoid_rec *ellipsoid, int octant, double u, double v, point_rec *normal)
11217 // {
11218 // point_rec pnt, n;
11219 // trans_matrix trans;
11220 //
11221 // get_ellipsoid_normal(ellipsoid, u, v, normal);
11222 //
11223 // /* move normal to octant */
11224 // if(octant != 1){
11225 // copy_vec(trans.x, ellipsoid -> major);
11226 // copy_vec(trans.y, ellipsoid -> minor);
11227 // copy_vec(trans.z, ellipsoid -> middle);
11228 //
11229 // pnt.x = pnt.y = pnt.z = 0.0;
11230 // transform_from_global_to_local(normal, &n, &pnt, &trans);
11231 // if(octant == 2 || octant == 3 || octant == 6 || octant == 7)n.x *= -1.0;
11232 // if(octant == 4 || octant == 3 || octant == 8 || octant == 7)n.y *= -1.0;
11233 // if(octant == 5 || octant == 6 || octant == 7 || octant == 8)n.z *= -1.0;
11234 //
11235 // invert_transformation(&trans);
11236 // transform_from_local_to_global(normal, &n, &pnt, &trans);
11237 // }
11238 // }
11239 //
11240 
11242 static void get_ellipsoid_point (ellipsoid_rec *ellipsoid, double u, double v, point_rec *pnt)
11243 {
11244  double weight = 0.707106781;
11245  double B0u, B1u, B2u, B0v, B1v, B2v, Bx, By, Bz;
11246  double B00, B10, B20, B01, B11, B21, B02, B12, B22;
11247  double sum_B;
11248 
11249  B0u = B_0(u);
11250  B1u = B_1(u) * weight;
11251  B2u = B_2(u);
11252 
11253  B0v = B_0(v);
11254  B1v = B_1(v) * weight;
11255  B2v = B_2(v);
11256 
11257  B00 = B0u * B0v;
11258  B10 = B1u * B0v;
11259  B20 = B2u * B0v;
11260 
11261  B01 = B0u * B1v;
11262  B11 = B1u * B1v;
11263  B21 = B2u * B1v;
11264 
11265  B02 = B0u * B2v;
11266  B12 = B1u * B2v;
11267  B22 = B2u * B2v;
11268 
11269  sum_B = B00 + B10 + B20 + B01 + B11 + B21 + B02 + B12 + B22;
11270 
11271  Bx = B00 * ellipsoid -> pnt00.x + B10 * ellipsoid -> pnt10.x + B20 * ellipsoid -> pnt20.x
11272  + B01 * ellipsoid -> pnt01.x + B11 * ellipsoid -> pnt11.x + B21 * ellipsoid -> pnt21.x
11273  + B02 * ellipsoid -> pnt02.x + B12 * ellipsoid -> pnt12.x + B22 * ellipsoid -> pnt22.x;
11274  By = B00 * ellipsoid -> pnt00.y + B10 * ellipsoid -> pnt10.y + B20 * ellipsoid -> pnt20.y
11275  + B01 * ellipsoid -> pnt01.y + B11 * ellipsoid -> pnt11.y + B21 * ellipsoid -> pnt21.y
11276  + B02 * ellipsoid -> pnt02.y + B12 * ellipsoid -> pnt12.y + B22 * ellipsoid -> pnt22.y;
11277  Bz = B00 * ellipsoid -> pnt00.z + B10 * ellipsoid -> pnt10.z + B20 * ellipsoid -> pnt20.z
11278  + B01 * ellipsoid -> pnt01.z + B11 * ellipsoid -> pnt11.z + B21 * ellipsoid -> pnt21.z
11279  + B02 * ellipsoid -> pnt02.z + B12 * ellipsoid -> pnt12.z + B22 * ellipsoid -> pnt22.z;
11280 
11281  pnt -> x = Bx / sum_B;
11282  pnt -> y = By / sum_B;
11283  pnt -> z = Bz / sum_B;
11284 }
11285 
11287 static double
11288 get_ellipsoid_u_gradient(ellipsoid_rec *ellipsoid, double u, double v, point_rec *grad)
11289 {
11290  double weight = 0.707106781;
11291  double B0u, B1u, B2u, B0v, B1v, B2v, dB0u, dB1u, dB2u;
11292  double B00, B10, B20, B01, B11, B21, B02, B12, B22;
11293  double dB00, dB10, dB20, dB01, dB11, dB21, dB02, dB12, dB22;
11294  double sum_B, sum_dB, sum_B2, Bx, By, Bz, dBx, dBy, dBz;
11295 
11296  B0u = B_0(u);
11297  B1u = B_1(u) * weight;
11298  B2u = B_2(u);
11299 
11300  B0v = B_0(v);
11301  B1v = B_1(v) * weight;
11302  B2v = B_2(v);
11303 
11304  dB0u = dB_0(u);
11305  dB1u = dB_1(u) * weight;
11306  dB2u = dB_2(u);
11307 
11308  B00 = B0u * B0v;
11309  B10 = B1u * B0v;
11310  B20 = B2u * B0v;
11311 
11312  B01 = B0u * B1v;
11313  B11 = B1u * B1v;
11314  B21 = B2u * B1v;
11315 
11316  B02 = B0u * B2v;
11317  B12 = B1u * B2v;
11318  B22 = B2u * B2v;
11319 
11320  dB00 = dB0u * B0v;
11321  dB10 = dB1u * B0v;
11322  dB20 = dB2u * B0v;
11323 
11324  dB01 = dB0u * B1v;
11325  dB11 = dB1u * B1v;
11326  dB21 = dB2u * B1v;
11327 
11328  dB02 = dB0u * B2v;
11329  dB12 = dB1u * B2v;
11330  dB22 = dB2u * B2v;
11331 
11332  sum_B = B00 + B10 + B20 + B01 + B11 + B21 + B02 + B12 + B22;
11333  sum_dB = dB00 + dB10 + dB20 + dB01 + dB11 + dB21 + dB02 + dB12 + dB22;
11334 
11335  sum_B2 = sum_B * sum_B;
11336 
11337  Bx = B00 * ellipsoid -> pnt00.x + B10 * ellipsoid -> pnt10.x + B20 * ellipsoid -> pnt20.x
11338  + B01 * ellipsoid -> pnt01.x + B11 * ellipsoid -> pnt11.x + B21 * ellipsoid -> pnt21.x
11339  + B02 * ellipsoid -> pnt02.x + B12 * ellipsoid -> pnt12.x + B22 * ellipsoid -> pnt22.x;
11340  By = B00 * ellipsoid -> pnt00.y + B10 * ellipsoid -> pnt10.y + B20 * ellipsoid -> pnt20.y
11341  + B01 * ellipsoid -> pnt01.y + B11 * ellipsoid -> pnt11.y + B21 * ellipsoid -> pnt21.y
11342  + B02 * ellipsoid -> pnt02.y + B12 * ellipsoid -> pnt12.y + B22 * ellipsoid -> pnt22.y;
11343  Bz = B00 * ellipsoid -> pnt00.z + B10 * ellipsoid -> pnt10.z + B20 * ellipsoid -> pnt20.z
11344  + B01 * ellipsoid -> pnt01.z + B11 * ellipsoid -> pnt11.z + B21 * ellipsoid -> pnt21.z
11345  + B02 * ellipsoid -> pnt02.z + B12 * ellipsoid -> pnt12.z + B22 * ellipsoid -> pnt22.z;
11346 
11347  dBx = dB00 * ellipsoid -> pnt00.x + dB10 * ellipsoid -> pnt10.x + dB20 * ellipsoid -> pnt20.x
11348  + dB01 * ellipsoid -> pnt01.x + dB11 * ellipsoid -> pnt11.x + dB21 * ellipsoid -> pnt21.x
11349  + dB02 * ellipsoid -> pnt02.x + dB12 * ellipsoid -> pnt12.x + dB22 * ellipsoid -> pnt22.x;
11350  dBy = dB00 * ellipsoid -> pnt00.y + dB10 * ellipsoid -> pnt10.y + dB20 * ellipsoid -> pnt20.y
11351  + dB01 * ellipsoid -> pnt01.y + dB11 * ellipsoid -> pnt11.y + dB21 * ellipsoid -> pnt21.y
11352  + dB02 * ellipsoid -> pnt02.y + dB12 * ellipsoid -> pnt12.y + dB22 * ellipsoid -> pnt22.y;
11353  dBz = dB00 * ellipsoid -> pnt00.z + dB10 * ellipsoid -> pnt10.z + dB20 * ellipsoid -> pnt20.z
11354  + dB01 * ellipsoid -> pnt01.z + dB11 * ellipsoid -> pnt11.z + dB21 * ellipsoid -> pnt21.z
11355  + dB02 * ellipsoid -> pnt02.z + dB12 * ellipsoid -> pnt12.z + dB22 * ellipsoid -> pnt22.z;
11356 
11357  grad -> x = (dBx * sum_B - Bx * sum_dB) / sum_B2;
11358  grad -> y = (dBy * sum_B - By * sum_dB) / sum_B2;
11359  grad -> z = (dBz * sum_B - Bz * sum_dB) / sum_B2;
11360 
11361  return(size_vec(*grad));
11362 }
11363 
11365 static double
11366 get_ellipsoid_v_gradient(ellipsoid_rec *ellipsoid, double u, double v, point_rec *grad)
11367 {
11368  double weight = 0.707106781;
11369  double B0u, B1u, B2u, B0v, B1v, B2v, dB0v, dB1v, dB2v;
11370  double B00, B10, B20, B01, B11, B21, B02, B12, B22;
11371  double dB00, dB10, dB20, dB01, dB11, dB21, dB02, dB12, dB22;
11372  double sum_B, sum_dB, sum_B2, Bx, By, Bz, dBx, dBy, dBz;
11373 
11374  B0u = B_0(u);
11375  B1u = B_1(u) * weight;
11376  B2u = B_2(u);
11377 
11378  B0v = B_0(v);
11379  B1v = B_1(v) * weight;
11380  B2v = B_2(v);
11381 
11382  dB0v = dB_0(v);
11383  dB1v = dB_1(v) * weight;
11384  dB2v = dB_2(v);
11385 
11386  B00 = B0u * B0v;
11387  B10 = B1u * B0v;
11388  B20 = B2u * B0v;
11389 
11390  B01 = B0u * B1v;
11391  B11 = B1u * B1v;
11392  B21 = B2u * B1v;
11393 
11394  B02 = B0u * B2v;
11395  B12 = B1u * B2v;
11396  B22 = B2u * B2v;
11397 
11398  dB00 = B0u * dB0v;
11399  dB10 = B1u * dB0v;
11400  dB20 = B2u * dB0v;
11401 
11402  dB01 = B0u * dB1v;
11403  dB11 = B1u * dB1v;
11404  dB21 = B2u * dB1v;
11405 
11406  dB02 = B0u * dB2v;
11407  dB12 = B1u * dB2v;
11408  dB22 = B2u * dB2v;
11409 
11410  sum_B = B00 + B10 + B20 + B01 + B11 + B21 + B02 + B12 + B22;
11411  sum_dB = dB00 + dB10 + dB20 + dB01 + dB11 + dB21 + dB02 + dB12 + dB22;
11412 
11413  sum_B2 = sum_B * sum_B;
11414 
11415  Bx = B00 * ellipsoid -> pnt00.x + B10 * ellipsoid -> pnt10.x + B20 * ellipsoid -> pnt20.x
11416  + B01 * ellipsoid -> pnt01.x + B11 * ellipsoid -> pnt11.x + B21 * ellipsoid -> pnt21.x
11417  + B02 * ellipsoid -> pnt02.x + B12 * ellipsoid -> pnt12.x + B22 * ellipsoid -> pnt22.x;
11418  By = B00 * ellipsoid -> pnt00.y + B10 * ellipsoid -> pnt10.y + B20 * ellipsoid -> pnt20.y
11419  + B01 * ellipsoid -> pnt01.y + B11 * ellipsoid -> pnt11.y + B21 * ellipsoid -> pnt21.y
11420  + B02 * ellipsoid -> pnt02.y + B12 * ellipsoid -> pnt12.y + B22 * ellipsoid -> pnt22.y;
11421  Bz = B00 * ellipsoid -> pnt00.z + B10 * ellipsoid -> pnt10.z + B20 * ellipsoid -> pnt20.z
11422  + B01 * ellipsoid -> pnt01.z + B11 * ellipsoid -> pnt11.z + B21 * ellipsoid -> pnt21.z
11423  + B02 * ellipsoid -> pnt02.z + B12 * ellipsoid -> pnt12.z + B22 * ellipsoid -> pnt22.z;
11424 
11425  dBx = dB00 * ellipsoid -> pnt00.x + dB10 * ellipsoid -> pnt10.x + dB20 * ellipsoid -> pnt20.x
11426  + dB01 * ellipsoid -> pnt01.x + dB11 * ellipsoid -> pnt11.x + dB21 * ellipsoid -> pnt21.x
11427  + dB02 * ellipsoid -> pnt02.x + dB12 * ellipsoid -> pnt12.x + dB22 * ellipsoid -> pnt22.x;
11428  dBy = dB00 * ellipsoid -> pnt00.y + dB10 * ellipsoid -> pnt10.y + dB20 * ellipsoid -> pnt20.y
11429  + dB01 * ellipsoid -> pnt01.y + dB11 * ellipsoid -> pnt11.y + dB21 * ellipsoid -> pnt21.y
11430  + dB02 * ellipsoid -> pnt02.y + dB12 * ellipsoid -> pnt12.y + dB22 * ellipsoid -> pnt22.y;
11431  dBz = dB00 * ellipsoid -> pnt00.z + dB10 * ellipsoid -> pnt10.z + dB20 * ellipsoid -> pnt20.z
11432  + dB01 * ellipsoid -> pnt01.z + dB11 * ellipsoid -> pnt11.z + dB21 * ellipsoid -> pnt21.z
11433  + dB02 * ellipsoid -> pnt02.z + dB12 * ellipsoid -> pnt12.z + dB22 * ellipsoid -> pnt22.z;
11434 
11435  grad -> x = (dBx * sum_B - Bx * sum_dB) / sum_B2;
11436  grad -> y = (dBy * sum_B - By * sum_dB) / sum_B2;
11437  grad -> z = (dBz * sum_B - Bz * sum_dB) / sum_B2;
11438 
11439  return(size_vec(*grad));
11440 }
11441 
11442 
11443 //
11444 // static void
11445 // get_ellipsoid_normal(ellipsoid_rec *ellipsoid, double u, double v, point_rec *normal)
11446 // {
11447 // point_rec u_grad, v_grad;
11448 // double norm;
11449 //
11450 // get_ellipsoid_u_gradient(ellipsoid, u, v, &u_grad);
11451 // get_ellipsoid_v_gradient(ellipsoid, u, v, &v_grad);
11452 //
11453 // cross_product(*normal, u_grad, v_grad);
11454 // norm = sqrt(size_vec(*normal));
11455 // div_vec(*normal, norm);
11456 // }
11457 //
11458 //
11459 //
11460 //
11461 // /* exact */
11462 //
11463 // static logic
11464 // check_point_inside_ellipse(point_rec *point, ellipse_rec *ellipse, double *value)
11465 // {
11466 // point_rec pnt;
11467 // trans_matrix trans;
11468 // double x_rate, y_rate;
11469 //
11470 // copy_vec(trans.x, ellipse -> major);
11471 // copy_vec(trans.y, ellipse -> minor);
11472 // copy_vec(trans.z, ellipse -> normal);
11473 //
11474 // transform_from_global_to_local(point, &pnt, &(ellipse -> center), &trans);
11475 //
11476 // if(fabs(pnt.z) > EPSILON)error_message(GENERAL_ERROR, "Point is not in plane of ellipse");
11477 //
11478 // x_rate = pnt.x / ellipse -> max;
11479 // y_rate = pnt.y / ellipse -> min;
11480 //
11481 // *value = x_rate * x_rate + y_rate * y_rate - 1.0;
11482 // if(*value <= 0.0)return(YES);
11483 //
11484 // return(NO);
11485 // }
11486 //
11487 //
11488 //
11489 //
11490 // /* exact */
11491 //
11492 // static int
11493 // get_ellipse_line_intersection(ellipse_rec *ellipse, point_rec *point, point_rec *dir, point_rec *intersection)
11494 // {
11495 // point_rec pnt, pnt1, pnt2, direction, orig;
11496 // trans_matrix trans;
11497 // double a0, a1, a2, a0x, a0y, a1x, a1y, a2x, a2y;
11498 // double D, max, min, t, t1, t2, norm;
11499 //
11500 // max = ellipse -> max;
11501 // min = ellipse -> min;
11502 //
11503 // norm = size_vec(*dir);
11504 // if(norm < EPSILON * EPSILON)error_message(GENERAL_ERROR, "Zero length direction");
11505 //
11506 // copy_vec(trans.x, ellipse -> major);
11507 // copy_vec(trans.y, ellipse -> minor);
11508 // copy_vec(trans.z, ellipse -> normal);
11509 //
11510 // orig.x = orig.y = orig.z = 0.0;
11511 //
11512 // transform_from_global_to_local(point, &pnt, &(ellipse -> center), &trans);
11513 // if(fabs(pnt.z) > EPSILON)error_message(GENERAL_ERROR, "Point is not in ellipse plane");
11514 // transform_from_global_to_local(dir, &direction, &orig, &trans);
11515 // if(fabs(direction.z) > EPSILON)error_message(GENERAL_ERROR, "Direction is not in ellipse plane");
11516 //
11517 // a2x = direction.x / max;
11518 // a2y = direction.y / min;
11519 // a2 = a2x * a2x + a2y * a2y;
11520 //
11521 // a0x = pnt.x / max;
11522 // a0y = pnt.y / min;
11523 // a0 = a0x * a0x + a0y *a0y - 1.0;
11524 //
11525 // a1x = a2x * a0x;
11526 // a1y = a2y * a0y;
11527 // a1 = a1x + a1y;
11528 //
11529 // D = a1 * a1 - a0 * a2;
11530 //
11531 // if(D < 0.0)return(0);
11532 //
11533 // invert_transformation(&trans);
11534 //
11535 // if(D == 0.0){
11536 // t = -a1 / a2;
11537 //
11538 // pnt.x += t * direction.x;
11539 // pnt.y += t * direction.y;
11540 // pnt.z = 0.0;
11541 //
11542 // transform_from_local_to_global(&intersection[0], &pnt, &(ellipse -> center), &trans);
11543 // return(1);
11544 // }
11545 //
11546 // D = sqrt(D);
11547 //
11548 // t1 = -(a1 - D) / a2;
11549 // t2 = -(a1 + D) / a2;
11550 //
11551 // pnt1.x = pnt.x + t1 * direction.x;
11552 // pnt1.y = pnt.y + t1 * direction.y;
11553 // pnt1.z = 0.0;
11554 //
11555 // transform_from_local_to_global(&intersection[0], &pnt1, &(ellipse -> center), &trans);
11556 //
11557 // pnt2.x = pnt.x + t2 * direction.x;
11558 // pnt2.y = pnt.y + t2 * direction.y;
11559 // pnt2.z = 0.0;
11560 //
11561 // transform_from_local_to_global(&intersection[1], &pnt2, &(ellipse -> center), &trans);
11562 //
11563 // return(2);
11564 // }
11565 //
11566 //
11567 //
11568 //
11569 //
11570 // /* exact */
11571 //
11572 // static void
11573 // get_ellipse_line_center_intersection(ellipse_rec *ellipse, point_rec *dir, point_rec *pnt1, point_rec *pnt2)
11574 // {
11575 // point_rec direction, orig;
11576 // trans_matrix trans;
11577 // double a, b, t, norm;
11578 //
11579 // norm = size_vec(*dir);
11580 // if(norm < EPSILON * EPSILON)error_message(GENERAL_ERROR, "Zero length direction");
11581 //
11582 // copy_vec(trans.x, ellipse -> major);
11583 // copy_vec(trans.y, ellipse -> minor);
11584 // copy_vec(trans.z, ellipse -> normal);
11585 //
11586 // orig.x = orig.y = orig.z = 0.0;
11587 //
11588 // transform_from_global_to_local(dir, &direction, &orig, &trans);
11589 // if(fabs(direction.z) > EPSILON)error_message(GENERAL_ERROR, "Line is not in plane of ellipse");
11590 //
11591 // a = direction.x / (ellipse -> max);
11592 // b = direction.y / (ellipse -> min);
11593 //
11594 // t = sqrt(1.0 / (a * a + b * b));
11595 //
11596 // invert_transformation(&trans);
11597 //
11598 // mul_vec(direction, t);
11599 // transform_from_local_to_global(pnt1, &direction, &(ellipse -> center), &trans);
11600 //
11601 // mul_vec(direction, -1.0);
11602 // transform_from_local_to_global(pnt2, &direction, &(ellipse -> center), &trans);
11603 // }
11604 //
11605 //
11606 //
11607 //
11608 //
11609 // /* exact */
11610 //
11611 // static int
11612 // get_ellipse_ellipse_intersection(ellipse_rec *ellipse1, ellipse_rec *ellipse2, point_rec *intersection)
11613 // {
11614 // point_rec point, pnt;
11615 // trans_matrix trans;
11616 // double product, t, tt, dt, ddt, delta_t = EPSILON_T;
11617 // double prev_t, next_t, prev_val, next_val, tn, tp, tpp, tnn, expand = 1.2;
11618 // double max1, max2, max, dist, val, value, value_p, value_n, value_pp, value_nn;
11619 // int q, prev_q, next_q, count, qq, qp, qn, qpp, qnn;
11620 // logic found, last;
11621 //
11622 // product = dot_product(ellipse1 -> normal, ellipse2 -> normal);
11623 // if(fabs(fabs(product) - 1.0) > EPSILON)error_message(GENERAL_ERROR, "Ellipses are not coplanar");
11624 //
11625 // copy_vec(trans.x, ellipse1 -> major);
11626 // copy_vec(trans.y, ellipse1 -> minor);
11627 // copy_vec(trans.z, ellipse1 -> normal);
11628 //
11629 // transform_from_global_to_local(&(ellipse2 -> center), &point, &(ellipse1 -> center), &trans);
11630 // if(fabs(point.z) > EPSILON)error_message(GENERAL_ERROR, "Ellipses are not in the same plane");
11631 //
11632 // max1 = ellipse1 -> max;
11633 // max2 = ellipse2 -> max;
11634 // max = max1 + max2;
11635 //
11636 // /* intersection of circumsribed circles */
11637 // dist = dist_point(ellipse1 -> center, ellipse2 -> center);
11638 // if(dist > max * max)return(0);
11639 //
11640 // /* ellipse1 and ellipse2 are affine */
11641 // if(fabs(point.x) < EPSILON && fabs(point.y) < EPSILON){
11642 // product = dot_product(ellipse1 -> major, ellipse2 -> minor);
11643 // if(fabs(product) < EPSILON){
11644 // if(fabs(max1 / ellipse1 -> min - max2 / ellipse2 -> min) < EPSILON){
11645 // if(fabs(max1 / max2 - 1.0) < EPSILON)return(-1); /* coinciding ellipses */
11646 // return(0);
11647 // }
11648 // }
11649 // }
11650 //
11651 // /* intersection of circle circumscribed to ellipse2 with ellipse1 */
11652 // if(check_point_inside_ellipse(&(ellipse2 -> center), ellipse1, &val) == YES){
11653 // if(fabs(point.x) > EPSILON && fabs(point.y) > EPSILON){
11654 // project_point_to_ellipse(&(ellipse2 -> center), ellipse1, &pnt, &t);
11655 // dist = dist_point(ellipse2 -> center, pnt);
11656 // if(dist > max2 * max2)return(0);
11657 // }
11658 // }
11659 //
11660 // /* intersection of circle circumscribed to ellipse1 with ellipse2 */
11661 // if(check_point_inside_ellipse(&(ellipse1 -> center), ellipse2, &val) == YES){
11662 // copy_vec(trans.x, ellipse2 -> major);
11663 // copy_vec(trans.y, ellipse2 -> minor);
11664 // copy_vec(trans.z, ellipse2 -> normal);
11665 //
11666 // transform_from_global_to_local(&(ellipse1 -> center), &point, &(ellipse2 -> center), &trans);
11667 //
11668 // if(fabs(point.x) > EPSILON && fabs(point.y) > EPSILON){
11669 // project_point_to_ellipse(&(ellipse1 -> center), ellipse2, &pnt, &t);
11670 // dist = dist_point(ellipse1 -> center, pnt);
11671 // if(dist > max1 * max1)return(0);
11672 // }
11673 // }
11674 //
11675 // dt = 1.0 / 10;
11676 //
11677 // prev_q = 4;
11678 // prev_t = dt / 2.0;
11679 //
11680 // get_ellipse_point_quadrant(ellipse1, prev_q, prev_t, &pnt);
11681 // check_point_inside_ellipse(&pnt, ellipse2, &prev_val);
11682 // while(fabs(prev_val) < EPSILON){
11683 // prev_t -= delta_t;
11684 // get_ellipse_point_quadrant(ellipse1, prev_q, prev_t, &pnt);
11685 // check_point_inside_ellipse(&pnt, ellipse2, &prev_val);
11686 // }
11687 //
11688 // next_q = q = 1;
11689 // next_t = t = dt / 2.0;
11690 //
11691 // get_ellipse_point_quadrant(ellipse1, q, t, &pnt);
11692 // check_point_inside_ellipse(&pnt, ellipse2, &val);
11693 // while(fabs(val) < EPSILON){
11694 // t += delta_t;
11695 // get_ellipse_point_quadrant(ellipse1, q, t, &pnt);
11696 // check_point_inside_ellipse(&pnt, ellipse2, &val);
11697 // }
11698 //
11699 // count = 0;
11700 // last = NO;
11701 // while(YES){
11702 // if(next_q == 1 || next_q == 3){
11703 // next_t += dt;
11704 // if(next_t > 1.0){
11705 // ++next_q;
11706 // next_t = 2.0 - next_t;
11707 // }
11708 // }
11709 // else{
11710 // next_t -= dt;
11711 // if(next_t < 0.0){
11712 // if(++next_q == 5){
11713 // next_q = 1;
11714 // last = YES;
11715 // }
11716 // next_t = -next_t;
11717 // }
11718 // }
11719 //
11720 // get_ellipse_point_quadrant(ellipse1, next_q, next_t, &pnt);
11721 // check_point_inside_ellipse(&pnt, ellipse2, &next_val);
11722 // while(fabs(next_val) < EPSILON){
11723 //
11724 // /* note: in(de)crementing by delta_t I can never cross quadrant boundary because I did not
11725 // start at the beginning of quadrant and because there may be at most four intersections */
11726 //
11727 // if(next_q == 1 || next_q == 3)
11728 // next_t += delta_t;
11729 // else
11730 // next_t -= delta_t;
11731 // get_ellipse_point_quadrant(ellipse1, next_q, next_t, &pnt);
11732 // check_point_inside_ellipse(&pnt, ellipse2, &next_val);
11733 // }
11734 //
11735 // if(next_val * val < 0.0){
11736 //
11737 // /* intersection in the last interval */
11738 //
11739 // get_ellipse_ellipse_interval_intersection(ellipse1, ellipse2, q, t, val, dt, &intersection[count++]);
11740 // }
11741 // else{
11742 //
11743 // /* note: check the equality only in the prev interval */
11744 // if((prev_val <= val && next_val < val) || (prev_val >= val && next_val > val)){
11745 // if(prev_val * val > 0.0){
11746 // if(val + 1.0 < expand && val + 1.0 > 1.0 / expand){
11747 //
11748 // /* extreme in the last two intervals */
11749 //
11750 // tt = t;
11751 // qq = q;
11752 // value = val;
11753 //
11754 // tpp = prev_t;
11755 // qpp = prev_q;
11756 //
11757 // tnn = next_t;
11758 // qnn = next_q;
11759 //
11760 // value_pp = prev_val;
11761 // value_nn = next_val;
11762 //
11763 // ddt = dt / 2;
11764 //
11765 // while(YES){
11766 // tn = tp = tt;
11767 // qn = qp = qq;
11768 //
11769 // if(qq == 1 || qq == 3){
11770 // tn += ddt;
11771 // if(tn > 1.0){
11772 // ++qn;
11773 // tn = 2.0 - tn;
11774 // }
11775 // }
11776 // else{
11777 // tn -= ddt;
11778 // if(tn < 0.0){
11779 // if(++qn == 5)qn = 1;
11780 // tn = -tn;
11781 // }
11782 // }
11783 //
11784 // if(q == 2 || q == 4){
11785 // tp += ddt;
11786 // if(tp > 1.0){
11787 // --qp;
11788 // tp = 2.0 - tp;
11789 // }
11790 // }
11791 // else{
11792 // tp -= ddt;
11793 // if(tp < 0.0){
11794 // if(--qp == 0)qp = 4;
11795 // tp = -tp;
11796 // }
11797 // }
11798 //
11799 // get_ellipse_point_quadrant(ellipse1, qp, tp, &pnt);
11800 // check_point_inside_ellipse(&pnt, ellipse2, &value_p);
11801 // while(fabs(value_p) < EPSILON){
11802 // if(qp == 1 || qp == 3){
11803 // tp += delta_t;
11804 // if(tp > 1.0){
11805 // ++qp;
11806 // tp = 2.0 - tp;
11807 // }
11808 // }
11809 // else{
11810 // tp -= delta_t;
11811 // if(tp < 0.0){
11812 // if(++qp == 5)qp = 1;
11813 // tp = -tp;
11814 // }
11815 // }
11816 // ddt += 2.0 * delta_t;
11817 // get_ellipse_point_quadrant(ellipse1, qp, tp, &pnt);
11818 // check_point_inside_ellipse(&pnt, ellipse2, &value_p);
11819 // }
11820 //
11821 // get_ellipse_point_quadrant(ellipse1, qn, tn, &pnt);
11822 // check_point_inside_ellipse(&pnt, ellipse2, &value_n);
11823 // while(fabs(value_n) < EPSILON){
11824 // if(qn == 1 || qn == 3){
11825 // tn += delta_t;
11826 // if(tn > 1.0){
11827 // ++qn;
11828 // tn = 2.0 - tn;
11829 // }
11830 // }
11831 // else{
11832 // tn -= delta_t;
11833 // if(tn < 0.0){
11834 // if(++qn == 5)qn = 1;
11835 // tn = -tn;
11836 // }
11837 // }
11838 // ddt += 2.0 * delta_t;
11839 // get_ellipse_point_quadrant(ellipse1, qn, tn, &pnt);
11840 // check_point_inside_ellipse(&pnt, ellipse2, &value_n);
11841 // }
11842 //
11843 // found = NO;
11844 // if(value_pp * value_p < 0.0){
11845 // found = YES;
11846 // get_ellipse_ellipse_interval_intersection(ellipse1, ellipse2, qpp, tpp, value_pp, ddt, &intersection[count++]);
11847 // }
11848 // if(value * value_p < 0.0){
11849 // found = YES;
11850 // get_ellipse_ellipse_interval_intersection(ellipse1, ellipse2, qp, tp, value_p, ddt, &intersection[count++]);
11851 // }
11852 // if(value * value_n < 0.0){
11853 // found = YES;
11854 // get_ellipse_ellipse_interval_intersection(ellipse1, ellipse2, qq, tt, value, ddt, &intersection[count++]);
11855 // }
11856 // if(value_nn * value_n < 0.0){
11857 // found = YES;
11858 // get_ellipse_ellipse_interval_intersection(ellipse1, ellipse2, qn, tn, value_n, ddt, &intersection[count++]);
11859 // }
11860 //
11861 // if(found == YES)break;
11862 //
11863 // ddt /= 2.0;
11864 // if(ddt < delta_t)break;
11865 //
11866 // if((value <= value_p && value_pp <= value_p) || (value >= value_p && value_pp >= value_p)){
11867 // tnn = tt;
11868 // qnn = qq;
11869 // value_nn = value;
11870 // tt = tp;
11871 // qq = qp;
11872 // value = value_p;
11873 // continue;
11874 // }
11875 // if((value <= value_n && value_nn <= value_n) || (value >= value_n && value_nn >= value_n)){
11876 // tpp = tt;
11877 // qpp = qq;
11878 // value_pp = value;
11879 // tt = tn;
11880 // qq = qn;
11881 // value = value_n;
11882 // continue;
11883 // }
11884 // tpp = tp;
11885 // qpp = qp;
11886 // value_pp = value_p;
11887 // tnn = tn;
11888 // qnn = qn;
11889 // value_nn = value_n;
11890 // }
11891 // }
11892 // }
11893 // }
11894 // }
11895 //
11896 // if(last == YES)break;
11897 //
11898 // prev_q = q;
11899 // prev_t = t;
11900 // prev_val = val;
11901 //
11902 // q = next_q;
11903 // t = next_t;
11904 // val = next_val;
11905 // }
11906 //
11907 // return(count);
11908 // }
11909 //
11910 //
11911 //
11912 //
11913 // static void
11914 // get_ellipse_ellipse_interval_intersection(ellipse_rec *ellipse1, ellipse_rec *ellipse2, int q, double t, double val, double dt,
11915 // point_rec *point)
11916 // {
11917 // point_rec pnt;
11918 // int qq, qqq;
11919 // double tt, ttt, value, delta_t = EPSILON_T;
11920 //
11921 // qq = qqq = q;
11922 // tt = ttt = t;
11923 //
11924 // dt /= 2.0;
11925 // while(YES){
11926 // if(qq == 1 || qq == 3){
11927 // tt += dt;
11928 // if(tt > 1.0){
11929 // ++qq;
11930 // tt = 2.0 - tt;
11931 // }
11932 // }
11933 // else{
11934 // tt -= dt;
11935 // if(tt < 0.0){
11936 // if(++qq == 5)qq = 1;
11937 // tt = -tt;
11938 // }
11939 // }
11940 //
11941 // get_ellipse_point_quadrant(ellipse1, qq, tt, &pnt);
11942 // check_point_inside_ellipse(&pnt, ellipse2, &value);
11943 //
11944 // if(fabs(value) < EPSILON || dt < delta_t){
11945 // if(fabs(value) > EPSILON){
11946 // if(qq == qqq){
11947 // tt = ttt + (tt - ttt) * val / (val - value);
11948 // if(tt >= 0.0 && tt <= 1.0){
11949 // get_ellipse_point_quadrant(ellipse1, qq, tt, &pnt);
11950 // check_point_inside_ellipse(&pnt, ellipse2, &value);
11951 // }
11952 // }
11953 // }
11954 //
11955 // copy_vec(*point, pnt);
11956 // return;
11957 // }
11958 //
11959 // if(value * val > 0.0){
11960 // qqq = qq;
11961 // ttt = tt;
11962 // val = value;
11963 // }
11964 // else{
11965 // qq = qqq;
11966 // tt = ttt;
11967 // dt /= 2.0;
11968 // }
11969 // }
11970 // }
11971 //
11972 //
11973 //
11974 //
11975 // /* exact */
11976 //
11977 // static int
11978 // project_point_to_ellipse(point_rec *point, ellipse_rec *ellipse, point_rec *pnt, double *t_par)
11979 // {
11980 // point_rec grad, vec, point_spec, pnt_spec, p;
11981 // trans_matrix trans;
11982 // double xx, yy, dist, norm, rate1 = 0.25, rate2 = 1.5, delta_t = EPSILON_T;
11983 // double t = 0.5, dt, dtt, ddt, d_t = 0.0, max_dt = 0.25, rate;
11984 // int sign = 0, sign_x = 0, sign_y = 0, iter = 0, quadrant = 0;
11985 //
11986 // copy_vec(trans.x, ellipse -> major);
11987 // copy_vec(trans.y, ellipse -> minor);
11988 // copy_vec(trans.z, ellipse -> normal);
11989 //
11990 // /* move point to the first quadrant */
11991 // transform_from_global_to_local(point, &p, &(ellipse -> center), &trans);
11992 //
11993 // if(fabs(p.z) > EPSILON)error_message(GENERAL_ERROR, "Point is not in plane of ellipse");
11994 //
11995 // xx = p.x;
11996 // yy = p.y;
11997 //
11998 // if(xx == 0.0 && yy == 0.0)error_message(GENERAL_ERROR, "Point is in center of ellipse");
11999 // if(ellipse -> max != ellipse -> min){
12000 // if(yy == 0.0){
12001 // rate = ellipse -> min / ellipse -> max;
12002 // if(fabs(xx) < ellipse -> max * (1.0 - rate * rate))
12003 // error_message(GENERAL_ERROR, "Point lies on major axis of ellipse");
12004 // }
12005 // }
12006 //
12007 // p.x = fabs(xx);
12008 // p.y = fabs(yy);
12009 //
12010 // if(xx != 0.0)sign_x = (xx > 0.0) ? 1 : -1;
12011 // if(yy != 0.0)sign_y = (yy > 0.0) ? 1 : -1;
12012 //
12013 // if(sign_x > 0){
12014 // if(sign_y > 0)
12015 // quadrant = 1;
12016 // else
12017 // quadrant = 4;
12018 // }
12019 // else{
12020 // if(sign_y > 0)
12021 // quadrant = 2;
12022 // else
12023 // quadrant = 3;
12024 // }
12025 //
12026 // if(sign_y == 0)sign = sign_x;
12027 // if(sign_x == 0)sign = sign_y;
12028 //
12029 // if(sign != 0){
12030 // if(sign > 0)
12031 // quadrant = 1;
12032 // else
12033 // quadrant = 3;
12034 // }
12035 //
12036 // invert_transformation(&trans);
12037 // transform_from_local_to_global(&point_spec, &p, &(ellipse -> center), &trans);
12038 //
12039 // /* make projection (in the first quadrant) */
12040 // while(YES){
12041 // get_ellipse_point(ellipse, t, &pnt_spec);
12042 // norm = sqrt(get_ellipse_gradient(ellipse, t, &grad));
12043 // sub_vec(vec, point_spec, pnt_spec);
12044 // dist = dot_product(vec, grad) / norm;
12045 //
12046 // dt = dist / norm;
12047 // if(fabs(dt) < delta_t)break;
12048 //
12049 // if((ddt = fabs(dt)) > max_dt)dt /= ddt / max_dt;
12050 //
12051 // if(iter != 0){
12052 // if(dt * d_t < 0.0){
12053 // if(fabs(dt) > rate1 * fabs(d_t))dt = -d_t * rate1;
12054 // }
12055 // else{
12056 // if(fabs(dt) > rate2 * fabs(d_t))dt = d_t * rate2;
12057 // }
12058 // }
12059 //
12060 // dtt = d_t = dt;
12061 //
12062 // if(dt < 0.0){
12063 // if(t + dt < 0.0)dtt = (0.0 - t) / 2.0;
12064 // }
12065 // if(dt > 0.0){
12066 // if(t + dt > 1.0)dtt = (1.0 - t) / 2.0;
12067 // }
12068 //
12069 // iter++;
12070 // if(iter == MAX_ITER)
12071 // error_message(GENERAL_ERROR, "Projection to ellipse does not converge");
12072 //
12073 // t += (d_t = dtt);
12074 // }
12075 //
12076 // /* move projection to original quadrant */
12077 // invert_transformation(&trans);
12078 // transform_from_global_to_local(&pnt_spec, &p, &(ellipse -> center), &trans);
12079 // p.x *= sign_x;
12080 // p.y *= sign_y;
12081 // invert_transformation(&trans);
12082 // transform_from_local_to_global(pnt, &p, &(ellipse -> center), &trans);
12083 //
12084 // /* note: t is continuous (but not monotonic)
12085 // t = 0 on major axis
12086 // t = 1 on minor axis
12087 // to prevent confusion, quadrant is returned
12088 // x+,y+ 1
12089 // x-,y+ 2
12090 // x-,y- 3
12091 // x+,y- 4
12092 // zeros are included into quadrants 1 and 3 */
12093 //
12094 // *t_par = t;
12095 // return(quadrant);
12096 // }
12097 //
12098 //
12099 //
12100 //
12101 // static void
12102 // get_ellipse_point_quadrant(ellipse_rec *ellipse, int quadrant, double t, point_rec *pnt)
12103 // {
12104 // point_rec p;
12105 // trans_matrix trans;
12106 //
12107 // get_ellipse_point(ellipse, t, pnt);
12108 //
12109 // /* move point to quadrant */
12110 // if(quadrant != 1){
12111 // copy_vec(trans.x, ellipse -> major);
12112 // copy_vec(trans.y, ellipse -> minor);
12113 // copy_vec(trans.z, ellipse -> normal);
12114 //
12115 // transform_from_global_to_local(pnt, &p, &(ellipse -> center), &trans);
12116 // if(quadrant == 2 || quadrant == 3)p.x *= -1.0;
12117 // if(quadrant == 4 || quadrant == 3)p.y *= -1.0;
12118 //
12119 // invert_transformation(&trans);
12120 // transform_from_local_to_global(pnt, &p, &(ellipse -> center), &trans);
12121 // }
12122 // }
12123 //
12124 //
12125 //
12126 // static double
12127 // get_ellipse_gradient_quadrant(ellipse_rec *ellipse, int quadrant, double t, point_rec *grad)
12128 // {
12129 // point_rec pnt, g;
12130 // trans_matrix trans;
12131 // double norm;
12132 //
12133 // norm = get_ellipse_gradient(ellipse, t, grad);
12134 //
12135 // /* move grad to quadrant */
12136 // if(quadrant != 1){
12137 // copy_vec(trans.x, ellipse -> major);
12138 // copy_vec(trans.y, ellipse -> minor);
12139 // copy_vec(trans.z, ellipse -> normal);
12140 //
12141 // pnt.x = pnt.y = pnt.z = 0.0;
12142 // transform_from_global_to_local(grad, &g, &pnt, &trans);
12143 // if(quadrant == 2 || quadrant == 3)g.x *= -1.0;
12144 // if(quadrant == 4 || quadrant == 3)g.y *= -1.0;
12145 //
12146 // invert_transformation(&trans);
12147 // transform_from_local_to_global(grad, &g, &pnt, &trans);
12148 // }
12149 //
12150 // return(norm);
12151 // }
12152 //
12153 //
12154 //
12155 // static void
12156 // get_ellipse_normal_quadrant(ellipse_rec *ellipse, int quadrant, double t, point_rec *normal)
12157 // {
12158 // point_rec pnt, n;
12159 // trans_matrix trans;
12160 //
12161 // get_ellipse_normal(ellipse, t, normal);
12162 //
12163 // /* move normal to quadrant */
12164 // if(quadrant != 1){
12165 // copy_vec(trans.x, ellipse -> major);
12166 // copy_vec(trans.y, ellipse -> minor);
12167 // copy_vec(trans.z, ellipse -> normal);
12168 //
12169 // pnt.x = pnt.y = pnt.z = 0.0;
12170 // transform_from_global_to_local(normal, &n, &pnt, &trans);
12171 // if(quadrant == 2 || quadrant == 3)n.x *= -1.0;
12172 // if(quadrant == 4 || quadrant == 3)n.y *= -1.0;
12173 //
12174 // invert_transformation(&trans);
12175 // transform_from_local_to_global(normal, &n, &pnt, &trans);
12176 // }
12177 // }
12178 //
12179 //
12180 //
12181 // static void
12182 // get_ellipse_point(ellipse_rec *ellipse, double t, point_rec *pnt)
12183 // {
12184 // double weight = 0.707106781;
12185 // double B0, B1, B2, Bx, By, Bz;
12186 // double sum_B;
12187 //
12188 // B0 = B_0(t);
12189 // B1 = B_1(t) * weight;
12190 // B2 = B_2(t);
12191 //
12192 // sum_B = B0 + B1 + B2;
12193 //
12194 // Bx = B0 * ellipse -> pnt0.x + B1 * ellipse -> pnt1.x + B2 * ellipse -> pnt2.x;
12195 // By = B0 * ellipse -> pnt0.y + B1 * ellipse -> pnt1.y + B2 * ellipse -> pnt2.y;
12196 // Bz = B0 * ellipse -> pnt0.z + B1 * ellipse -> pnt1.z + B2 * ellipse -> pnt2.z;
12197 //
12198 // pnt -> x = Bx / sum_B;
12199 // pnt -> y = By / sum_B;
12200 // pnt -> z = Bz / sum_B;
12201 // }
12202 //
12203 //
12204 //
12205 // static double
12206 // get_ellipse_gradient(ellipse_rec *ellipse, double t, point_rec *grad)
12207 // {
12208 // double weight = 0.707106781;
12209 // double B0, B1, B2, dB0, dB1, dB2;
12210 // double sum_B, sum_dB, sum_B2, Bx, By, Bz, dBx, dBy, dBz;
12211 //
12212 // B0 = B_0(t);
12213 // B1 = B_1(t) * weight;
12214 // B2 = B_2(t);
12215 //
12216 // dB0 = dB_0(t);
12217 // dB1 = dB_1(t) * weight;
12218 // dB2 = dB_2(t);
12219 //
12220 // sum_B = B0 + B1 + B2;
12221 // sum_dB = dB0 + dB1 + dB2;
12222 //
12223 // sum_B2 = sum_B * sum_B;
12224 //
12225 // Bx = B0 * ellipse -> pnt0.x + B1 * ellipse -> pnt1.x + B2 * ellipse -> pnt2.x;
12226 // By = B0 * ellipse -> pnt0.y + B1 * ellipse -> pnt1.y + B2 * ellipse -> pnt2.y;
12227 // Bz = B0 * ellipse -> pnt0.z + B1 * ellipse -> pnt1.z + B2 * ellipse -> pnt2.z;
12228 //
12229 // dBx = dB0 * ellipse -> pnt0.x + dB1 * ellipse -> pnt1.x + dB2 * ellipse -> pnt2.x;
12230 // dBy = dB0 * ellipse -> pnt0.y + dB1 * ellipse -> pnt1.y + dB2 * ellipse -> pnt2.y;
12231 // dBz = dB0 * ellipse -> pnt0.z + dB1 * ellipse -> pnt1.z + dB2 * ellipse -> pnt2.z;
12232 //
12233 // grad -> x = (dBx * sum_B - Bx * sum_dB) / sum_B2;
12234 // grad -> y = (dBy * sum_B - By * sum_dB) / sum_B2;
12235 // grad -> z = (dBz * sum_B - Bz * sum_dB) / sum_B2;
12236 //
12237 // return(size_vec(*grad));
12238 // }
12239 //
12240 //
12241 //
12242 // static void
12243 // get_ellipse_normal(ellipse_rec *ellipse, double t, point_rec *normal)
12244 // {
12245 // point_rec grad;
12246 // double norm;
12247 //
12248 // norm = get_ellipse_gradient(ellipse, t, &grad);
12249 // norm = sqrt(norm);
12250 // div_vec(grad, norm);
12251 //
12252 // cross_product(*normal, grad, ellipse -> normal);
12253 // }
12254 //
12255 //
12256 //
12257 // static logic
12258 // check_point_on_crack_tip(point_rec *point, crack_rec *crack)
12259 // {
12260 // point_rec pnt;
12261 // double t;
12262 // int q;
12263 //
12264 // if(crack -> ellipsoid == NULL)return(YES);
12265 //
12266 // q = project_point_to_ellipse(point, &(crack -> crack), &pnt, &t);
12267 // return(check_point_on_ellipse_interval(q, t, crack -> q1, crack -> t1, crack -> q2, crack -> t2));
12268 // }
12269 //
12270 //
12271 //
12272 // /* delta_t */
12273 //
12274 // static logic
12275 // check_point_on_ellipse_interval(int q, double t, int q1, double t1, int q2, double t2)
12276 // {
12277 // double delta_t = EPSILON_T;
12278 //
12279 // if(q <= 0 || q > 4 || q1 <= 0 || q1 > 4 || q2 <= 0 || q2 > 4)error_message(GENERAL_ERROR, "Ivalid quadrant");
12280 //
12281 // if(q != q1 && q != q2){
12282 // if(q1 == q2){
12283 // if(q1 == 1 || q1 == 3){
12284 // if(t1 < t2)return(NO);
12285 // }
12286 // else{
12287 // if(t1 > t2)return(NO);
12288 // }
12289 // }
12290 // else{
12291 // if(q1 < q2){
12292 // if(q < q1 || q > q2)return(NO);
12293 // }
12294 // else{
12295 // if(q < q1){
12296 // if(q > q2)return(NO);
12297 // }
12298 // if(q > q2){
12299 // if(q < q1)return(NO);
12300 // }
12301 // }
12302 // }
12303 //
12304 // return(YES);
12305 // }
12306 //
12307 // if(q == q1){
12308 // if(q == 1 || q == 3){
12309 // if(t < t1 - delta_t)return(NO);
12310 // }
12311 // else{
12312 // if(t > t1 + delta_t)return(NO);
12313 // }
12314 // }
12315 // if(q == q2){
12316 // if(q == 1 || q == 3){
12317 // if(t > t2 + delta_t)return(NO);
12318 // }
12319 // else{
12320 // if(t < t2 - delta_t)return(NO);
12321 // }
12322 // }
12323 //
12324 // return(YES);
12325 // }
12326 //
12327 //
12328 //
12329 static void transform_from_global_to_local (point_rec *global, point_rec *local, point_rec *origin, trans_matrix *trans)
12330 {
12331  point_rec delta;
12332 
12333  delta.x = global -> x - origin -> x;
12334  delta.y = global -> y - origin -> y;
12335  delta.z = global -> z - origin -> z;
12336 
12337  local -> x = dot_product(delta, trans -> x);
12338  local -> y = dot_product(delta, trans -> y);
12339  local -> z = dot_product(delta, trans -> z);
12340 }
12341 
12342 void transform_from_local_to_global (point_rec *global, point_rec *local, point_rec *origin, trans_matrix *trans)
12343 {
12344  global -> x = dot_product(*local, trans -> x) + origin -> x;
12345  global -> y = dot_product(*local, trans -> y) + origin -> y;
12346  global -> z = dot_product(*local, trans -> z) + origin -> z;
12347 }
12348 
12349 void invert_transformation (trans_matrix *trans)
12350 {
12351  double tmp;
12352 
12353  swap(trans -> x.y, trans -> y.x, tmp);
12354  swap(trans -> x.z, trans -> z.x, tmp);
12355  swap(trans -> y.z, trans -> z.y, tmp);
12356 }
12357 
12358 // static char *
12359 // get_next_record(FILE *file, char *file_name, char *err_msg)
12360 // {
12361 // char *buf = NULL;
12362 //
12363 // if((buf = fgets(line_buffer, BUFFER_SIZE, file)) == NULL){
12364 // if(!feof(file))error_message(FILE_READ_ERROR, "File %s reading error", file_name);
12365 // if(err_msg == NULL)return(NULL);
12366 // error_message(INPUT_ERROR, "%s", err_msg);
12367 // }
12368 // return(buf);
12369 // }
12370 //
12371 //
12372 //
12373 // static char *
12374 // get_next_relevant_record(FILE *file, char *file_name, char *err_msg)
12375 // {
12376 // char *buf = NULL, *character = NULL;
12377 //
12378 // do{
12379 // if((buf = get_next_record(file, file_name, err_msg)) == NULL)return(NULL);
12380 // character = line_buffer;
12381 // while(*character == SPACE)character++;
12382 // }while(*character == NEWLINE || *character == REMARK);
12383 // return(buf);
12384 // }
12385 //
12386 //
12387 //
12388 // static void
12389 // write_record(FILE *file, char *file_name, char *buffer)
12390 // {
12391 // if(fprintf(file, "%s", buffer) < 0)
12392 // error_message(FILE_WRITE_ERROR, "File %s writing error", file_name);
12393 // }
12394 //
12395 //
12396 
12397 void error_message (int exit_code, const char *format, ...)
12398 {
12399  char buffer[1024];
12400  va_list args;
12401 
12402  va_start(args, format);
12403  vsprintf(buffer, format, args);
12404  va_end(args);
12405 
12406  if(exit_code != WARNING && exit_code != NO_ERROR){
12407  fprintf(stderr, "\nError: %s\n\n", buffer);
12408 
12409 //#ifdef ELIXIR
12410 // if(draw == YES){
12411 // if(ElixirInitialized() == YES){
12412 // strcat(buffer, "\n\n");
12413 // ESIEventLoop(YES, buffer);
12414 // }
12415 // }
12416 //#endif
12417 
12418  exit(exit_code);
12419  }
12420 
12421  if(exit_code == WARNING)
12422  fprintf(stderr, "Warning: %s\n", buffer);
12423  else
12424  fprintf(stderr, "%s\n", buffer);
12425 }
12426 
12427 
12428 //
12429 // /* solution of A.X=Y;
12430 // matrix A is full;
12431 // A(n,n),X(n,m),Y(n,m) */
12432 //
12433 // logic
12434 // solve_full_system(double *a, double *x, double *y, long n, long m)
12435 // {
12436 // long i, j, k, ac, acr, acc, aca, aca1, acx, acy, acy1, aci, acj;
12437 // long *av;
12438 // double s, g;
12439 //
12440 // av = (long *)calloc(n, sizeof(long));
12441 //
12442 // /* set vector of unknown ordering */
12443 //
12444 // for(i = 0; i < n; i++)av[i] = i;
12445 //
12446 // for(i = 0; i < n; i++){
12447 // acr = i;
12448 // acc = i;
12449 //
12450 // /* search for pivot */
12451 //
12452 // s = 0.0;
12453 // for(j = i; j < n; j++){ /* loop over rows */
12454 // aca = j * n + i;
12455 // for(k = i; k < n; k++){ /* loop over columns */
12456 // if(s < fabs(a[aca])){
12457 // s = fabs(a[aca]);
12458 // acr = j;
12459 // acc = k;
12460 // }
12461 // aca++;
12462 // }
12463 // }
12464 // if(s < 1.0e-10)return(NO);
12465 //
12466 // /* swap rows */
12467 //
12468 // if(acr != i){
12469 // aca = i * n + i;
12470 // aca1 = acr * n + i;
12471 // for(j = i; j < n; j++){
12472 // s = a[aca];
12473 // a[aca] = a[aca1];
12474 // a[aca1] = s;
12475 // aca++;
12476 // aca1++;
12477 // }
12478 // acy = i * m;
12479 // acy1 = acr * m;
12480 // for(j = 0; j < m; j++){
12481 // s = y[acy];
12482 // y[acy] = y[acy1];
12483 // y[acy1] = s;
12484 // acy++;
12485 // acy1++;
12486 // }
12487 // }
12488 //
12489 // /* swap columns */
12490 //
12491 // if(acc != i){
12492 // ac = av[i];
12493 // av[i] = av[acc];
12494 // av[acc] = ac;
12495 //
12496 // aca = i;
12497 // aca1 = acc;
12498 // for(j = 0; j < n; j++){
12499 // s = a[aca];
12500 // a[aca] = a[aca1];
12501 // a[aca1] = s;
12502 // aca += n;
12503 // aca1 += n;
12504 // }
12505 // }
12506 //
12507 // /* elimination */
12508 //
12509 // for(j = i + 1; j < n; j++){
12510 // acj = j * n + i;
12511 // aci= i * n + i;
12512 // s = a[acj] / a[aci];
12513 // for(k = i; k < n; k++){ /* modification of matrix */
12514 // a[acj] -= s * a[aci];
12515 // acj++;
12516 // aci++;
12517 // }
12518 // acj = j * m;
12519 // aci = i * m;
12520 // for(k = 0; k < m; k++){ /* modification of rhs */
12521 // y[acj] -= s * y[aci];
12522 // acj++;
12523 // aci++;
12524 // }
12525 // }
12526 // }
12527 //
12528 // /* back reduction */
12529 //
12530 // for(i = n - 1; i > -1; i--){
12531 // g = a[i * n + i];
12532 // acx = i * m;
12533 // for(j = 0; j < m; j++){
12534 // s = 0.0;
12535 // aca = i * n + i + 1;
12536 // acy = (i + 1) * m + j;
12537 // for(k = i + 1; k < n; k++){
12538 // s += a[aca] * x[acy];
12539 // aca++;
12540 // acy += m;
12541 // }
12542 // x[acx] = (y[acx] - s) / g;
12543 // acx++;
12544 // }
12545 // }
12546 //
12547 // /* reordering to initial state */
12548 //
12549 // for(i = 0; i < n; i++){
12550 // if(av[i] != i){
12551 // for(j = i; j < n; j++){
12552 // if(av[j] == i){
12553 // acc = j;
12554 // break;
12555 // }
12556 // }
12557 //
12558 // ac = av[i];
12559 // av[i] = av[acc];
12560 // av[acc] = ac;
12561 //
12562 // aca = i * m;
12563 // aca1 = acc * m;
12564 // for(j = 0; j < m; j++){
12565 // s = x[aca];
12566 // x[aca] = x[aca1];
12567 // x[aca1] = s;
12568 // aca++;
12569 // aca1++;
12570 // }
12571 // }
12572 // }
12573 //
12574 // free(av);
12575 //
12576 // return(YES);
12577 // }
12578 
12579 
12580 
12581 //#ifdef ELIXIR
12582 //
12583 //static void
12584 //draw_number(point_rec *pnt, EPixel color, int number, char *prefix)
12585 //{
12586 // WCRec point;
12587 // GraphicObj *gr_obj;
12588 // unsigned long mask = 0L;
12589 // char string[16];
12590 //
12591 // sprintf(string, "%s%d", prefix, number);
12592 //
12593 // mask |= LAYER_MASK;
12594 // mask |= COLOR_MASK;
12595 // mask |= FONT_MASK;
12596 //
12597 // EASValsSetLayer(0);
12598 // EASValsSetColor(color);
12599 // EASValsSetFontId(font);
12600 //
12601 // copy_vec(point, *pnt);
12602 //
12603 // if((gr_obj = CreateAnnText3D(&point, string)) == NULL){
12604 // ERptErrMessage(ELIXIR_ERROR_CLASS, 2, "Failure of graphics creation", ERROR_GRADE);
12605 // exit(ESISetExitCode(2));
12606 // }
12607 //
12608 // EGWithMaskChangeAttributes(mask, gr_obj);
12609 // EMAddGraphicsToModel(ESIModel(), gr_obj);
12610 //}
12611 //
12612 //
12613 //static void
12614 //draw_point(point_rec *pnt, EPixel color)
12615 //{
12616 // WCRec point[1];
12617 // GraphicObj *gr_obj = NULL;
12618 // unsigned long mask = 0L;
12619 //
12620 // mask |= LAYER_MASK;
12621 // mask |= COLOR_MASK;
12622 // mask |= MTYPE_MASK;
12623 // mask |= MSIZE_MASK;
12624 //
12625 // EASValsSetLayer(0);
12626 // EASValsSetColor(color);
12627 // EASValsSetMType(FILLED_CIRCLE_MARKER);
12628 // EASValsSetMSize(6);
12629 //
12630 // copy_vec(point[0], *pnt);
12631 //
12632 // if((gr_obj = CreateMarker3D(point)) == NULL){
12633 // ERptErrMessage(ELIXIR_ERROR_CLASS, 2, "Failure of graphics creation", ERROR_GRADE);
12634 // exit(ESISetExitCode(2));
12635 // }
12636 //
12637 // EGWithMaskChangeAttributes(mask, gr_obj);
12638 // EMAddGraphicsToModel(ESIModel(), gr_obj);
12639 //}
12640 //
12641 //
12642 //
12643 //static void
12644 //draw_line(point_rec *pnt1, point_rec *pnt2, EPixel color)
12645 //{
12646 // WCRec point[2];
12647 // GraphicObj *gr_obj = NULL;
12648 // unsigned long mask = 0L;
12649 //
12650 // mask |= LAYER_MASK;
12651 // mask |= COLOR_MASK;
12652 // mask |= STYLE_MASK;
12653 // mask |= SHRINK_MASK;
12654 //
12655 // EASValsSetLayer(0);
12656 // EASValsSetColor(color);
12657 // EASValsSetFillStyle(SOLID_STYLE);
12658 // EASValsSetShrink(1.0);
12659 //
12660 // copy_vec(point[0], *pnt1);
12661 // copy_vec(point[1], *pnt2);
12662 //
12663 // if((gr_obj = CreateLine3D(point)) == NULL){
12664 // ERptErrMessage(ELIXIR_ERROR_CLASS, 2, "Failure of graphics creation", ERROR_GRADE);
12665 // exit(ESISetExitCode(2));
12666 // }
12667 //
12668 // EGWithMaskChangeAttributes(mask, gr_obj);
12669 // EMAddGraphicsToModel(ESIModel(), gr_obj);
12670 //}
12671 //
12672 //
12673 //int ver_id = 1000;
12674 //int cur_id = 1000;
12675 //
12676 //
12677 //
12678 //static void
12679 //draw_elliptic_arc(point_rec *pnt1, point_rec *pnt2, point_rec *pnt3, double w1, double w2, double w3, EPixel color)
12680 //{
12681 // WCRec point[3];
12682 // float weight[3];
12683 // GraphicObj *gr_obj = NULL;
12684 // unsigned long mask = 0L;
12685 //
12686 // mask |= LAYER_MASK;
12687 // mask |= COLOR_MASK;
12688 // mask |= STYLE_MASK;
12689 // mask |= WIDTH_MASK;
12690 // mask |= SHOW_POLY_MASK;
12691 // mask |= TESSEL_INTERVALS_MASK;
12692 //
12693 // EASValsSetLayer(0);
12694 // EASValsSetColor(color);
12695 // EASValsSetFillStyle(SOLID_STYLE);
12696 // EASValsSetLineWidth(0);
12697 // EASValsSetShowPoly(NO);
12698 // EASValsSetTesselIntervals(32);
12699 //
12700 // copy_vec(point[0], *pnt1);
12701 // copy_vec(point[1], *pnt2);
12702 // copy_vec(point[2], *pnt3);
12703 //
12704 // weight[0] = w1;
12705 // weight[1] = w2;
12706 // weight[2] = w3;
12707 //
12708 // if((gr_obj = CreateRBezC3D(3, point, weight)) == NULL){
12709 // ERptErrMessage(ELIXIR_ERROR_CLASS, 2, "Failure of graphics creation", ERROR_GRADE);
12710 // exit(ESISetExitCode(2));
12711 // }
12712 //
12713 // EGWithMaskChangeAttributes(mask, gr_obj);
12714 // EMAddGraphicsToModel(ESIModel(), gr_obj);
12715 //}
12716 //
12717 //
12718 //
12719 //
12720 //static void
12721 //draw_cylinder(cylinder_rec *cylinder, EPixel color)
12722 //{
12723 // ellipse_rec ellipse;
12724 //
12725 // ellipse.max = ellipse.min = cylinder -> radius;
12726 //
12727 // ellipse.normal.x = ellipse.normal.y = 0.0;
12728 // ellipse.normal.z = 1.0;
12729 //
12730 // ellipse.major.x = 1.0;
12731 // ellipse.major.y = ellipse.major.z = 0.0;
12732 //
12733 // ellipse.minor.y = 1.0;
12734 // ellipse.minor.x = ellipse.minor.z = 0.0;
12735 //
12736 // copy_vec(ellipse.center, cylinder -> lower_center);
12737 //
12738 // draw_ellipse(&ellipse, color);
12739 //
12740 // ellipse.center.z += cylinder -> height;
12741 //
12742 // draw_ellipse(&ellipse, color);
12743 //}
12744 //
12745 //
12746 //static void
12747 //draw_block(block_rec *block, EPixel color)
12748 //{
12749 // point_rec pnt[8], center;
12750 // double sz_x, sz_y, sz_z;
12751 // int sign_x[8] = {1, -1, -1, 1, 1, -1, -1, 1};
12752 // int sign_y[8] = {1, 1, -1, -1, 1, 1, -1, -1};
12753 // int sign_z[8] = {-1, -1, -1, -1, 1, 1, 1, 1};
12754 // int i;
12755 //
12756 // aver_point(center, block -> ll_corner, block -> ur_corner);
12757 //
12758 // sz_x = block -> size_x / 2.0;
12759 // sz_y = block -> size_y / 2.0;
12760 // sz_z = block -> size_z / 2.0;
12761 //
12762 // for(i = 0; i < 8; i++){
12763 // pnt[i].x = center.x + sign_x[i] * sz_x;
12764 // pnt[i].y = center.y + sign_y[i] * sz_y;
12765 // pnt[i].z = center.z + sign_z[i] * sz_z;
12766 // }
12767 //
12768 // draw_line(&pnt[0], &pnt[1], color);
12769 // draw_line(&pnt[2], &pnt[3], color);
12770 // draw_line(&pnt[4], &pnt[5], color);
12771 // draw_line(&pnt[6], &pnt[7], color);
12772 //
12773 // draw_line(&pnt[0], &pnt[3], color);
12774 // draw_line(&pnt[1], &pnt[2], color);
12775 // draw_line(&pnt[5], &pnt[6], color);
12776 // draw_line(&pnt[4], &pnt[7], color);
12777 //
12778 // draw_line(&pnt[0], &pnt[4], color);
12779 // draw_line(&pnt[1], &pnt[5], color);
12780 // draw_line(&pnt[2], &pnt[6], color);
12781 // draw_line(&pnt[3], &pnt[7], color);
12782 //}
12783 //
12784 //
12785 //static void
12786 //draw_ellipsoid(ellipsoid_rec *ellipsoid, EPixel color)
12787 //{
12788 // ellipse_rec ellipse;
12789 //
12790 // copy_vec(ellipse.center, ellipsoid -> center);
12791 //
12792 // copy_vec(ellipse.major, ellipsoid -> major);
12793 // copy_vec(ellipse.minor, ellipsoid -> minor);
12794 // copy_vec(ellipse.normal, ellipsoid -> middle);
12795 //
12796 // ellipse.max = ellipsoid -> max;
12797 // ellipse.min = ellipsoid -> min;
12798 //
12799 // draw_ellipse(&ellipse, color);
12800 //
12801 // copy_vec(ellipse.major, ellipsoid -> minor);
12802 // copy_vec(ellipse.minor, ellipsoid -> middle);
12803 // copy_vec(ellipse.normal, ellipsoid -> major);
12804 //
12805 // ellipse.max = ellipsoid -> min;
12806 // ellipse.min = ellipsoid -> mid;
12807 //
12808 // draw_ellipse(&ellipse, color);
12809 //
12810 // copy_vec(ellipse.major, ellipsoid -> middle);
12811 // copy_vec(ellipse.minor, ellipsoid -> major);
12812 // copy_vec(ellipse.normal, ellipsoid -> minor);
12813 //
12814 // ellipse.max = ellipsoid -> mid;
12815 // ellipse.min = ellipsoid -> max;
12816 //
12817 // draw_ellipse(&ellipse, color);
12818 //
12819 // draw_number(&(ellipsoid -> center), color, ellipsoid -> id, "");
12820 //}
12821 //
12822 //
12823 //
12824 //
12825 //static void
12826 //draw_ellipse(ellipse_rec *ellipse, EPixel color)
12827 //{
12828 // point_rec point_loc[3], point_glob[3];
12829 // trans_matrix trans;
12830 // int i, signx[4] = {1, -1, -1, 1}, signy[4] = {1, 1, -1, -1};
12831 //
12832 // copy_vec(trans.x, ellipse -> major);
12833 // copy_vec(trans.y, ellipse -> minor);
12834 // copy_vec(trans.z, ellipse -> normal);
12835 //
12836 // invert_transformation(&trans);
12837 //
12838 // point_loc[0].z = point_loc[1].z = point_loc[2].z = 0.0;
12839 // point_loc[2].x = point_loc[0].y = 0.0;
12840 //
12841 // for(i = 0; i < 4; i++){
12842 // point_loc[0].x = point_loc[1].x = ellipse -> max * signx[i];
12843 // point_loc[1].y = point_loc[2].y = ellipse -> min * signy[i];
12844 //
12845 // transform_from_local_to_global(&(point_glob[0]), &(point_loc[0]), &(ellipse -> center), &trans);
12846 // transform_from_local_to_global(&(point_glob[1]), &(point_loc[1]), &(ellipse -> center), &trans);
12847 // transform_from_local_to_global(&(point_glob[2]), &(point_loc[2]), &(ellipse -> center), &trans);
12848 //
12849 // draw_elliptic_arc(&(point_glob[0]), &(point_glob[1]), &(point_glob[2]), 1.0, 0.707106781, 1.0, color);
12850 // }
12851 //}
12852 //
12853 //
12854 //
12855 //static void
12856 //draw_crack(crack_rec *crack, EPixel color)
12857 //{
12858 // ellipse_rec *ellipse = NULL;
12859 // trans_matrix trans;
12860 // point_rec point_loc[3], point_glob[3];
12861 // logic single;
12862 // int i, quad, signx[4] = {1, -1, -1, 1}, signy[4] = {1, 1, -1, -1};
12863 //
12864 // if(crack -> segment == NO){
12865 // draw_ellipse(&(crack -> crack), color);
12866 // }
12867 // else{
12868 // ellipse = &(crack -> crack);
12869 //
12870 // copy_vec(trans.x, ellipse -> major);
12871 // copy_vec(trans.y, ellipse -> minor);
12872 // copy_vec(trans.z, ellipse -> normal);
12873 //
12874 // invert_transformation(&trans);
12875 //
12876 // point_loc[0].z = point_loc[1].z = point_loc[2].z = 0.0;
12877 // point_loc[2].x = point_loc[0].y = 0.0;
12878 //
12879 // single = NO;
12880 // if(crack -> q1 == crack -> q2){
12881 // if(crack -> q1 == 1 || crack -> q1 == 3){
12882 // if(crack -> t1 < crack -> t2)single = YES;
12883 // }
12884 // else{
12885 // if(crack -> t1 > crack -> t2)single = YES;
12886 // }
12887 // }
12888 //
12889 // if(single == YES){
12890 // if(crack -> t1 < crack -> t2)
12891 // draw_elliptic_arc_segment(ellipse, crack -> q1, crack -> t1, crack -> t2, &(crack -> pnt1), &(crack -> pnt2), &trans, color);
12892 // else
12893 // draw_elliptic_arc_segment(ellipse, crack -> q1, crack -> t2, crack -> t1, &(crack -> pnt2), &(crack -> pnt1), &trans, color);
12894 // }
12895 // else{
12896 // if(crack -> q1 == 1 || crack -> q1 == 3)
12897 // draw_elliptic_arc_end_segment(ellipse, crack -> q1, crack -> t1, &(crack -> pnt1), &trans, color);
12898 // else
12899 // draw_elliptic_arc_start_segment(ellipse, crack -> q1, crack -> t1, &(crack -> pnt1), &trans, color);
12900 //
12901 // if(crack -> q2 == 2 || crack -> q2 == 4)
12902 // draw_elliptic_arc_end_segment(ellipse, crack -> q2, crack -> t2, &(crack -> pnt2), &trans, color);
12903 // else
12904 // draw_elliptic_arc_start_segment(ellipse, crack -> q2, crack -> t2, &(crack -> pnt2), &trans, color);
12905 //
12906 // for(i = 0; i < 4; i++){
12907 // quad = i + 1;
12908 // if(quad == crack -> q1)continue;
12909 // if(quad == crack -> q2)continue;
12910 //
12911 // if(crack -> q1 < crack -> q2){
12912 // if(quad < crack -> q1 || quad > crack -> q2)continue;
12913 // }
12914 // else{
12915 // if(quad < crack -> q1){
12916 // if(quad > crack -> q2)continue;
12917 // }
12918 // if(quad > crack -> q2){
12919 // if(quad < crack -> q1)continue;
12920 // }
12921 // }
12922 //
12923 // point_loc[0].x = point_loc[1].x = ellipse -> max * signx[i];
12924 // point_loc[1].y = point_loc[2].y = ellipse -> min * signy[i];
12925 //
12926 // transform_from_local_to_global(&(point_glob[0]), &(point_loc[0]), &(ellipse -> center), &trans);
12927 // transform_from_local_to_global(&(point_glob[1]), &(point_loc[1]), &(ellipse -> center), &trans);
12928 // transform_from_local_to_global(&(point_glob[2]), &(point_loc[2]), &(ellipse -> center), &trans);
12929 //
12930 // draw_elliptic_arc(&(point_glob[0]), &(point_glob[1]), &(point_glob[2]), 1.0, 0.707106781, 1.0, color);
12931 // }
12932 // }
12933 //
12934 // ellipse = &(crack -> contact);
12935 //
12936 // copy_vec(trans.x, ellipse -> major);
12937 // copy_vec(trans.y, ellipse -> minor);
12938 // copy_vec(trans.z, ellipse -> normal);
12939 //
12940 // invert_transformation(&trans);
12941 //
12942 // single = NO;
12943 // if(crack -> qa == crack -> qb){
12944 // if(crack -> qa == 1 || crack -> qb == 3){
12945 // if(crack -> ta < crack -> tb)single = YES;
12946 // }
12947 // else{
12948 // if(crack -> ta > crack -> tb)single = YES;
12949 // }
12950 // }
12951 //
12952 // if(single == YES){
12953 // if(crack -> ta < crack -> tb)
12954 // draw_elliptic_arc_segment(ellipse, crack -> qa, crack -> ta, crack -> tb, &(crack -> pnt1), &(crack -> pnt2), &trans, color);
12955 // else
12956 // draw_elliptic_arc_segment(ellipse, crack -> qa, crack -> tb, crack -> ta, &(crack -> pnt2), &(crack -> pnt1), &trans, color);
12957 // }
12958 // else{
12959 // if(crack -> qa == 1 || crack -> qa == 3)
12960 // draw_elliptic_arc_end_segment(ellipse, crack -> qa, crack -> ta, &(crack -> pnt1), &trans, color);
12961 // else
12962 // draw_elliptic_arc_start_segment(ellipse, crack -> qa, crack -> ta, &(crack -> pnt1), &trans, color);
12963 //
12964 // if(crack -> qb == 2 || crack -> qb == 4)
12965 // draw_elliptic_arc_end_segment(ellipse, crack -> qb, crack -> tb, &(crack -> pnt2), &trans, color);
12966 // else
12967 // draw_elliptic_arc_start_segment(ellipse, crack -> qb, crack -> tb, &(crack -> pnt2), &trans, color);
12968 //
12969 // for(i = 0; i < 4; i++){
12970 // quad = i + 1;
12971 // if(quad == crack -> qa)continue;
12972 // if(quad == crack -> qb)continue;
12973 //
12974 // if(crack -> qa < crack -> qb){
12975 // if(quad < crack -> qa || quad > crack -> qb)continue;
12976 // }
12977 // else{
12978 // if(quad < crack -> qa){
12979 // if(quad > crack -> qb)continue;
12980 // }
12981 // if(quad > crack -> qb){
12982 // if(quad < crack -> qa)continue;
12983 // }
12984 // }
12985 //
12986 // point_loc[0].x = point_loc[1].x = ellipse -> max * signx[i];
12987 // point_loc[1].y = point_loc[2].y = ellipse -> min * signy[i];
12988 //
12989 // transform_from_local_to_global(&(point_glob[0]), &(point_loc[0]), &(ellipse -> center), &trans);
12990 // transform_from_local_to_global(&(point_glob[1]), &(point_loc[1]), &(ellipse -> center), &trans);
12991 // transform_from_local_to_global(&(point_glob[2]), &(point_loc[2]), &(ellipse -> center), &trans);
12992 //
12993 // draw_elliptic_arc(&(point_glob[0]), &(point_glob[1]), &(point_glob[2]), 1.0, 0.707106781, 1.0, color);
12994 // }
12995 // }
12996 // }
12997 //}
12998 //
12999 //
13000 //
13001 //static void
13002 //draw_elliptic_arc_segment(ellipse_rec *ellipse, int q, double ta, double tb, point_rec *pointa, point_rec *pointb,
13003 // trans_matrix *trans, EPixel color)
13004 //{
13005 // point_rec pnt_loc, pnt_glob, point;
13006 // double w0, w1, w2, w01a, w12a, wa, w01b, w12b, wb;
13007 // int signx[4] = {1, -1, -1, 1}, signy[4] = {1, 1, -1, -1};
13008 //
13009 // w0 = 1.0;
13010 // w1 = 0.707106781;
13011 // w2 = 1.0;
13012 //
13013 // tb = (tb - ta) / (1.0 - ta);
13014 //
13015 // w01a = (1.0 - ta) * w0 + ta * w1;
13016 // w12a = (1.0 - ta) * w1 + ta * w2;
13017 // wa = (1.0 - ta) * w01a + ta * w12a;
13018 //
13019 // w01b = (1.0 - tb) * wa + tb * w12a;
13020 // w12b = (1.0 - tb) * w12a + tb * w2;
13021 // wb = (1.0 - tb) * w01b + tb * w12b;
13022 //
13023 // pnt_loc.x = ellipse -> max * signx[q - 1] * (1.0 - ta) * w1 / ((1.0 - ta) * w1 + ta * w2);
13024 // pnt_loc.y = ellipse -> min * signy[q - 1];
13025 // pnt_loc.z = 0.0;
13026 //
13027 // transform_from_local_to_global(&pnt_glob, &pnt_loc, &(ellipse -> center), trans);
13028 //
13029 // point.x = ((1.0 - tb) * wa * pointa -> x + tb * w12a * pnt_glob.x) / ((1.0 - tb) * wa + tb * w12a);
13030 // point.y = ((1.0 - tb) * wa * pointa -> y + tb * w12a * pnt_glob.y) / ((1.0 - tb) * wa + tb * w12a);
13031 // point.z = ((1.0 - tb) * wa * pointa -> z + tb * w12a * pnt_glob.z) / ((1.0 - tb) * wa + tb * w12a);
13032 //
13033 // draw_elliptic_arc(pointa, &point, pointb, wa, w01b, wb, color);
13034 //}
13035 //
13036 //
13037 //
13038 //static void
13039 //draw_elliptic_arc_start_segment(ellipse_rec *ellipse, int q, double t, point_rec *point, trans_matrix *trans, EPixel color)
13040 //{
13041 // point_rec pnt_loc, pnt_glob, point_loc, point_glob;
13042 // double w0, w1, w2, w01, w12, w;
13043 // int signx[4] = {1, -1, -1, 1}, signy[4] = {1, 1, -1, -1};
13044 //
13045 // w0 = 1.0;
13046 // w1 = 0.707106781;
13047 // w2 = 1.0;
13048 //
13049 // w01 = (1.0 - t) * w0 + t * w1;
13050 // w12 = (1.0 - t) * w1 + t * w2;
13051 // w = (1.0 - t) * w01 + t * w12;
13052 //
13053 // point_loc.x = ellipse -> max * signx[q - 1];
13054 // point_loc.y = 0.0;
13055 // point_loc.z = 0.0;
13056 //
13057 // pnt_loc.x = ellipse -> max * signx[q - 1];
13058 // pnt_loc.y = ellipse -> min * signy[q - 1] * t * w1 / ((1.0 - t) * w0 + t * w1);
13059 // pnt_loc.z = 0.0;
13060 //
13061 // transform_from_local_to_global(&pnt_glob, &pnt_loc, &(ellipse -> center), trans);
13062 // transform_from_local_to_global(&point_glob, &point_loc, &(ellipse -> center), trans);
13063 //
13064 // draw_elliptic_arc(&point_glob, &pnt_glob, point, w0, w01, w, color);
13065 //}
13066 //
13067 //
13068 //
13069 //
13070 //static void
13071 //draw_elliptic_arc_end_segment(ellipse_rec *ellipse, int q, double t, point_rec *point, trans_matrix *trans, EPixel color)
13072 //{
13073 // point_rec pnt_loc, pnt_glob, point_loc, point_glob;
13074 // double w0, w1, w2, w01, w12, w;
13075 // int signx[4] = {1, -1, -1, 1}, signy[4] = {1, 1, -1, -1};
13076 //
13077 // w0 = 1.0;
13078 // w1 = 0.707106781;
13079 // w2 = 1.0;
13080 //
13081 // w01 = (1.0 - t) * w0 + t * w1;
13082 // w12 = (1.0 - t) * w1 + t * w2;
13083 // w = (1.0 - t) * w01 + t * w12;
13084 //
13085 // point_loc.x = 0.0;
13086 // point_loc.y = ellipse -> min * signy[q - 1];
13087 // point_loc.z = 0.0;
13088 //
13089 // pnt_loc.x = ellipse -> max * signx[q - 1] * (1.0 - t) * w1 / ((1.0 - t) * w1 + t * w2);
13090 // pnt_loc.y = ellipse -> min * signy[q - 1];
13091 // pnt_loc.z = 0.0;
13092 //
13093 // transform_from_local_to_global(&pnt_glob, &pnt_loc, &(ellipse -> center), trans);
13094 // transform_from_local_to_global(&point_glob, &point_loc, &(ellipse -> center), trans);
13095 //
13096 // draw_elliptic_arc(point, &pnt_glob, &point_glob, w, w12, w2, color);
13097 //}
13098 //
13099 //
13100 //
13101 //void
13102 //ESICustomize(Widget parent_pane)
13103 //{
13104 //}
13105 //
13106 //#endif
13107 
13108 } // end of namespace meso3d
meso3d::check_ellipsoid_rec_consistency
void check_ellipsoid_rec_consistency(meso3d::ellipsoid_rec &L)
ADDED for muMech needs.
Definition: meso3d.cpp:884
meso3d::trans_matrix
Definition: meso3d.h:57
dist_point
#define dist_point(PNT1, PNT2)
Definition: meso3d.cpp:112
dB_2
#define dB_2(T)
Definition: meso3d.cpp:105
B_1
#define B_1(T)
Definition: meso3d.cpp:100
meso3d::trans_matrix::y
point_rec y
Definition: meso3d.h:60
dot_product
#define dot_product(VEC1, VEC2)
Definition: meso3d.cpp:132
meso3d::check_ellipsoid_ellipsoid_overlap
int check_ellipsoid_ellipsoid_overlap(ellipsoid_rec *ellipsoid1, ellipsoid_rec *ellipsoid2)
Definition: meso3d.cpp:10164
meso3d::ellipsoid_rec
Ellipsoid record.
Definition: meso3d.h:65
meso3d::epsilon
static double epsilon
Definition: meso3d.cpp:238
meso3d::error_message
static void error_message(int exit_code, const char *format,...)
Definition: meso3d.cpp:12397
meso3d::transfom_ellipsoid_rec
void transfom_ellipsoid_rec(meso3d::ellipsoid_rec &L)
ADDED for muMech needs.
Definition: meso3d.cpp:948
meso3d::ellipsoid_rec::mid
double mid
Definition: meso3d.h:71
meso3d::ellipsoid_rec::boundary_msz
double boundary_msz
Definition: meso3d.h:72
meso3d::get_ellipsoid_point
static void get_ellipsoid_point(ellipsoid_rec *ellipsoid, double u, double v, point_rec *pnt)
Definition: meso3d.cpp:11242
meso3d::ellipsoid_rec::minor
point_rec minor
Definition: meso3d.h:70
meso3d::check_point_inside_ellipsoid
static bool check_point_inside_ellipsoid(point_rec *point, ellipsoid_rec *ellipsoid)
(ellipsoid greater by epsilon)
Definition: meso3d.cpp:10503
meso3d::ellipsoid_rec::bc
int bc
Definition: meso3d.h:73
meso3d::trans_matrix::x
point_rec x
Definition: meso3d.h:59
B_2
#define B_2(T)
Definition: meso3d.cpp:101
meso3d::ellipsoid_rec::pnt01
point_rec pnt01
Definition: meso3d.h:74
meso3d::ellipsoid_rec::max
double max
Definition: meso3d.h:71
meso3d::ellipsoid_rec::pnt02
point_rec pnt02
Definition: meso3d.h:74
meso3d::invert_transformation
static void invert_transformation(trans_matrix *trans)
Definition: meso3d.cpp:12349
meso3d::transform_from_local_to_global
static void transform_from_local_to_global(point_rec *global, point_rec *local, point_rec *origin, trans_matrix *trans)
Definition: meso3d.cpp:12342
meso3d::ellipsoid_rec::min
double min
Definition: meso3d.h:71
meso3d::ellipsoid_rec::pnt00
point_rec pnt00
Definition: meso3d.h:74
NO_ERROR
#define NO_ERROR
Definition: meso3d.cpp:77
meso3d::ellipsoid_rec::middle
point_rec middle
Semiaxes. (must be righthanded Cartesian coordinate system)
Definition: meso3d.h:70
meso3d::isZero
bool isZero(double zero, double a)
Definition: meso3d.cpp:876
meso3d::ellipsoid_rec::pnt20
point_rec pnt20
Definition: meso3d.h:76
meso3d::ellipsoid_rec::pnt11
point_rec pnt11
Definition: meso3d.h:75
EPSILON_V
#define EPSILON_V
Definition: meso3d.cpp:91
meso3d::get_ellipsoid_point_octant
static void get_ellipsoid_point_octant(ellipsoid_rec *ellipsoid, int octant, double u, double v, point_rec *pnt)
Definition: meso3d.cpp:11191
meso3d::ellipsoid_rec::id
int id
Definition: meso3d.h:67
meso3d::ellipsoid_rec::center
point_rec center
Definition: meso3d.h:69
meso3d::transform_from_global_to_local
static void transform_from_global_to_local(point_rec *global, point_rec *local, point_rec *origin, trans_matrix *trans)
Definition: meso3d.cpp:12329
WARNING
#define WARNING
Definition: meso3d.cpp:78
meso3d::ellipsoid_rec::pnt22
point_rec pnt22
Definition: meso3d.h:76
EPSILON
#define EPSILON
Definition: meso3d.cpp:87
size_vec
#define size_vec(VEC)
Definition: meso3d.cpp:110
meso3d::point_rec::y
double y
Definition: meso3d.h:53
dB_0
#define dB_0(T)
Definition: meso3d.cpp:103
meso3d::project_point_to_ellipsoid
static int project_point_to_ellipsoid(point_rec *point, ellipsoid_rec *ellipsoid, point_rec *pnt, double *u_par, double *v_par)
(exact)
Definition: meso3d.cpp:10946
meso3d::ellipsoid_rec::major
point_rec major
Definition: meso3d.h:70
meso3d::ellipsoid_rec::pnt10
point_rec pnt10
Definition: meso3d.h:75
meso3d::get_ellipsoid_v_gradient
static double get_ellipsoid_v_gradient(ellipsoid_rec *ellipsoid, double u, double v, point_rec *v_grad)
Definition: meso3d.cpp:11366
div_vec
#define div_vec(VEC, VALUE)
Definition: meso3d.cpp:121
GENERAL_ERROR
#define GENERAL_ERROR
Definition: meso3d.cpp:79
meso3d::ellipsoid_rec::interface
int interface
Definition: meso3d.h:73
dB_1
#define dB_1(T)
Definition: meso3d.cpp:104
meso3d::ellipsoid_rec::property
int property
Definition: meso3d.h:73
INPUT_ERROR
#define INPUT_ERROR
Definition: meso3d.cpp:84
meso3d::ellipsoid_rec::pnt21
point_rec pnt21
Definition: meso3d.h:76
meso3d::point_rec::x
double x
Definition: meso3d.h:52
meso3d::ellipsoid_rec::internal_msz
double internal_msz
Definition: meso3d.h:72
swap
#define swap(VAL1, VAL2, TMP)
Definition: meso3d.cpp:107
meso3d.h
MESO3d - library of functions for geometry analysis of ellipsoids and preprocesor for T3d...
copy_vec
#define copy_vec(DEST, SRC)
Definition: meso3d.cpp:109
sub_vec
#define sub_vec(RES, VEC1, VEC2)
Definition: meso3d.cpp:127
meso3d::point_rec
Point record.
Definition: meso3d.h:50
delta
#define delta(i, j)
Definition: macros.h:187
meso3d::point_rec::z
double z
Definition: meso3d.h:54
MAX_ITER
#define MAX_ITER
Definition: meso3d.cpp:95
B_0
#define B_0(T)
Definition: meso3d.cpp:99
cross_product
#define cross_product(RES, VEC1, VEC2)
Definition: meso3d.cpp:134
meso3d::get_ellipsoid_u_gradient
static double get_ellipsoid_u_gradient(ellipsoid_rec *ellipsoid, double u, double v, point_rec *u_grad)
Definition: meso3d.cpp:11288
EPSILON_U
#define EPSILON_U
Definition: meso3d.cpp:90
meso3d::trans_matrix::z
point_rec z
Definition: meso3d.h:61
meso3d::ellipsoid_rec::pnt12
point_rec pnt12
Definition: meso3d.h:75
This reference manual is part of the muMECH documentation. Generated on Wed Feb 24 2016 22:50:07 for muMECH by doxygen 1.8.11.