00001 #include <string.h>
00002 #include "iotools.h"
00003 #include "kwdset.h"
00004 #include "vector.h"
00005 #include "siftop.h"
00006 #include "gfunct.h"
00007 #include "alias.h"
00008 #include "global.h"
00009 #include "inicd.h"
00010 #include "globprep.h"
00011 #include "loadel.h"
00012 #include "prepalias.h"
00013 #include "input.h"
00014 #include "hangnode.h"
00015 #include "bocon.h"
00016 #include "dbcrs.h"
00017 #include "dbmat.h"
00018 #include "entityload.h"
00019 #include "pointset.h"
00020 #include "tempload.h"
00021 #include "aggregator.h"
00022
00023
00024
00025
00026
00027
00028
00029
00030
00031
00032
00033
00034
00035
00036
00037
00038
00039 long input(XFILE *in, descrip *d)
00040 {
00041 long err;
00042 XFILE *itop, *ihn;
00043
00044
00045 err = input_lc(in);
00046 if (err)
00047 return(2);
00048
00049 itop = xfopen(d->topf, "rt");
00050 if (itop == NULL)
00051 return(3);
00052 itop->warning = 1;
00053 itop->kwdmode = ignore;
00054
00055 itop->ignorecase = 1;
00056
00057
00058 if (Mp->ssle->prec.pt==boss){
00059
00060 if (Mp->ssle->prec.agg->impl==2){
00061
00062 d->paral=2;
00063 }
00064 }
00065
00066 if (Mp->ssle->tlinsol==sfeti){
00067
00068 d->paral=2;
00069 }
00070
00071
00072 err = input_siftop(itop, d);
00073 xfclose(itop);
00074 if (err)
00075 return(3);
00076
00077
00078 Numhn = 0;
00079 Nod_hang = NULL;
00080 if (d->hangnf[0])
00081 {
00082 ihn = xfopen(d->hangnf, "rt");
00083 if (ihn == NULL)
00084 return(3);
00085 ihn->warning = 1;
00086 ihn->kwdmode = ignore;
00087
00088 ihn->ignorecase = 1;
00089 err = input_hang_nodes(ihn);
00090 xfclose(ihn);
00091 if (err)
00092 return(3);
00093 }
00094
00095
00096 if (d->matsec == no)
00097 err = input_materials(d->matf, d);
00098 else
00099 err = input_materials(in, d);
00100 if (err)
00101 return(4);
00102
00103
00104 if (d->crssec == no)
00105 err = input_crs(d->crf, d);
00106 else
00107 err = input_crs(in, d);
00108 if (err)
00109 return(5);
00110
00111
00112 err = input_nodprop(in);
00113 switch (err)
00114 {
00115 case 0 :
00116 break;
00117 case 1 :
00118 print_err("reading of number of dofs at nodes failed", __FILE__, __LINE__, __func__);
00119 return(6);
00120 case 2 :
00121 print_err("reading of nodal boundary conditions failed", __FILE__, __LINE__, __func__);
00122 return(6);
00123 case 3 :
00124 print_err("reading of coupled dofs at nodes failed", __FILE__, __LINE__, __func__);
00125 return(6);
00126 case 4 :
00127 print_err("reading of springs at nodes failed", __FILE__, __LINE__, __func__);
00128 return(6);
00129 case 5 :
00130 print_err("reading of dof time functions at nodes failed", __FILE__, __LINE__, __func__);
00131 return(6);
00132 case 6 :
00133 print_err("reading of cross-sections at nodes failed", __FILE__, __LINE__, __func__);
00134 return(6);
00135 case 7 :
00136 print_err("reading of local coordinate systems at nodes failed", __FILE__, __LINE__, __func__);
00137 return(6);
00138 case 8 :
00139 print_err("reading of nodal load failed", __FILE__, __LINE__, __func__);
00140 return(6);
00141 case 9 :
00142 print_err("reading of nodal time dependent load failed", __FILE__, __LINE__, __func__);
00143 return(6);
00144 case 10 :
00145 print_err("reading of nodal initial conditions failed", __FILE__, __LINE__, __func__);
00146 return(6);
00147 case 11 :
00148 print_err("reading of nodal temperature load failed", __FILE__, __LINE__, __func__);
00149 return(6);
00150 default :
00151 print_err("unknown error code in nodal sections", __FILE__, __LINE__, __func__);
00152 return(6);
00153 }
00154
00155 err = input_elemprop(in);
00156 switch (err)
00157 {
00158 case 0 :
00159 break;
00160 case 1 :
00161 print_err("reading of element types failed", __FILE__, __LINE__, __func__);
00162 return(7);
00163 case 2 :
00164 print_err("reading of element material types failed", __FILE__, __LINE__, __func__);
00165 return(7);
00166 case 3 :
00167 print_err("reading of element cross-section failed", __FILE__, __LINE__, __func__);
00168 return(7);
00169 case 4 :
00170 print_err("reading of local coordinate systems at elements failed", __FILE__, __LINE__, __func__);
00171 return(7);
00172 case 5 :
00173 print_err("reading of element load record failed", __FILE__, __LINE__, __func__);
00174 return(7);
00175 case 6 :
00176 print_err("reading of edge load of elements failed", __FILE__, __LINE__, __func__);
00177 case 7 :
00178 print_err("reading of surface load of elements failed", __FILE__, __LINE__, __func__);
00179 return(7);
00180 case 8 :
00181 print_err("reading of volume load of elements failed", __FILE__, __LINE__, __func__);
00182 return(7);
00183 case 9 :
00184 print_err("reading of time functions for elements failed", __FILE__, __LINE__, __func__);
00185 return(7);
00186 default :
00187 print_err("unknown error code in nodal sections", __FILE__, __LINE__, __func__);
00188 return(7);
00189 }
00190 return(0);
00191 }
00192
00193
00194
00195
00196
00197
00198
00199
00200
00201
00202
00203
00204
00205
00206
00207
00208 long input_files(XFILE *in, descrip &d)
00209 {
00210
00211 xfscanf(in, " %a", d.topf);
00212
00213 if (d.matsec == no)
00214 xfscanf(in, " %a", d.matf);
00215
00216 if (d.crssec == no)
00217 xfscanf(in, " %a", d.crf);
00218
00219 xfscanf(in, "%k%m", "mesh_format", &meshform_kwdset, &d.meshfmt);
00220
00221 xfscanf(in, "%k%ld", "edge_numbering", &d.redgn);
00222
00223 d.hangnf[0] = 0;
00224 xfscanf(in, "%+k %a", "hanging_nodes_file", &d.hangnf);
00225
00226 d.matstr = yes;
00227 xfscanf(in, "%+k %m", "read_mat_strings", &answertype_kwdset, &d.matstr);
00228 if (d.matstr == no)
00229 xfscanf(in, "%k %m", "read_mat_kwd", &answertype_kwdset, &d.matkwd);
00230 else
00231 d.matkwd = no;
00232
00233
00234 d.crsstr = yes;
00235 xfscanf(in, "%+k %m", "read_crs_strings", &answertype_kwdset, &d.crsstr);
00236 if (d.crsstr == no)
00237 xfscanf(in, "%k %m", "read_crs_kwd", &answertype_kwdset, &d.crskwd);
00238 else
00239 d.crskwd = no;
00240
00241 return 0;
00242 }
00243
00244
00245
00246
00247
00248
00249
00250
00251
00252
00253
00254
00255
00256
00257
00258
00259
00260
00261
00262 long input_lc(XFILE *in)
00263 {
00264 long i, j, n, check, tnlc;
00265 long lc_id, slc_id, id;
00266 char errmsg[1001];
00267 double tmp;
00268
00269
00270 fprintf(stdout, "\n\nReading of loadcase section . . .");
00271 memset(errmsg, 0, sizeof(*errmsg)*1001);
00272 xf_setsec(in, bsec_str[begsec_loadcase]);
00273 xfscanf(in, "%k%ld", "num_loadcases", &Nlc);
00274 tnlc = Nlc / 2;
00275 Nlay = 0;
00276 Nslc = NULL;
00277 Nslc_cum = NULL;
00278 Tnslc = 0;
00279 Tlt = NULL;
00280 Npd = NULL;
00281 Spd = NULL;
00282 Nmstrc = 0;
00283 Mstrc = NULL;
00284 Nspd = 0;
00285 switch (Mp->tprob)
00286 {
00287 case mat_nonlinear_statics :
00288 {
00289 if (tnlc * 2 != Nlc)
00290 {
00291 sprintf(errmsg, "Wrong number of load cases\n"
00292 " Number of load cases is %ld\n"
00293 " Number of load cases has to be even\n"
00294 " because you request to solve mat_nonlinear statics.", Nlc);
00295 print_err(errmsg, __FILE__, __LINE__, __func__);
00296 return (1);
00297 }
00298
00299 Tlt = new long [Nlc];
00300 memset(Tlt, 0, sizeof(*Tlt)*Nlc);
00301 for(i=0; i<Nlc; i++)
00302 {
00303 xfscanf(in, "%k%ld", "lc_id", &lc_id);
00304 if (lc_id < 1)
00305 {
00306 sprintf(errmsg, "Error : line=%ld, col=%ld, file %s\n"
00307 " load case id %ld is out of range <1,%ld>", in->line, in->col, in->fname, lc_id, tnlc);
00308 print_err(errmsg, __FILE__, __LINE__, __func__);
00309 return 3;
00310 }
00311 lc_id--;
00312 xfscanf(in, "%k%ld", "temp_load_type", Tlt+lc_id);
00313 if ((Tlt[lc_id] < 0) || (Tlt[lc_id] > 3))
00314 {
00315 sprintf(errmsg, "Error : line=%ld, col=%ld, file %s\n"
00316 " temperature load type %ld is out of range <0,3>", in->line, in->col, in->fname, Tlt[lc_id]);
00317 print_err(errmsg, __FILE__, __LINE__, __func__);
00318 return 4;
00319 }
00320
00321 if (Mp->homog == 3)
00322 {
00323 if (Mstrc == NULL)
00324 {
00325 Mstrc = new double*[Nlc];
00326 memset(Mstrc, 0, sizeof(*Mstrc)*Nlc);
00327 }
00328 xfscanf(in, "%k%ld", "num_macro_stress_comp", &Nmstrc);
00329 if (Nmstrc > 0)
00330 {
00331 Mstrc[i] = new double[Nmstrc];
00332 memset(Mstrc[i], 0, sizeof(*Mstrc[i])*Nmstrc);
00333 xfscanf(in, "%k", "macro_stress_comp");
00334 for (j=0; j<Nmstrc; j++)
00335 xfscanf (in, "%lf", Mstrc[i]+j);
00336 }
00337 }
00338
00339 if (Mp->homog == 4)
00340 {
00341 if (Mstrc == NULL)
00342 {
00343 Mstrc = new double*[Nlc];
00344 memset(Mstrc, 0, sizeof(*Mstrc)*Nlc);
00345 }
00346 xfscanf(in, "%k%ld", "num_macro_strain_comp", &Nmstrc);
00347 if (Nmstrc > 0)
00348 {
00349 Mstrc[i] = new double[Nmstrc];
00350 memset(Mstrc[i], 0, sizeof(*Mstrc[i])*Nmstrc);
00351 xfscanf(in, "%k", "macro_strain_comp");
00352 for (j=0; j<Nmstrc; j++)
00353 xfscanf (in, "%lf", Mstrc[i]+j);
00354 }
00355 }
00356 }
00357 break;
00358 }
00359 case eigen_dynamics :
00360 {
00361 if (Nlc > 0)
00362 {
00363 sprintf(errmsg, "Wrong number of load cases\n"
00364 " Number of load cases is %ld\n"
00365 " Number of load cases has to be zero\n"
00366 " you request to solve eigen dynamics.", Nlc);
00367 print_err(errmsg, __FILE__, __LINE__, __func__);
00368 return (1);
00369 }
00370 break;
00371 }
00372 case forced_dynamics :
00373 {
00374 if (tnlc * 2 != Nlc)
00375 {
00376 sprintf(errmsg, "Wrong number of load cases\n"
00377 " Number of load cases is %ld\n"
00378 " Number of load cases has to be odd\n"
00379 " because you request to solve forced dynamics.", Nlc);
00380 print_err(errmsg, __FILE__, __LINE__, __func__);
00381 return (1);
00382 }
00383 xfscanf(in, "%k%m", "dload_type", &dynload_kwdset, &Tdload);
00384 if (Tdload == timeindload)
00385 {
00386 if (tnlc != 1)
00387 {
00388 sprintf(errmsg, "Wrong number of load cases\n"
00389 " Number of load cases is %ld\n"
00390 " Number of load cases has to be 1\n"
00391 " because you request to solve forced dynamics\n"
00392 " with subloadcases.", Nlc);
00393 print_err(errmsg, __FILE__, __LINE__, __func__);
00394 return (1);
00395 }
00396 Nslc = new long[tnlc];
00397 memset(Nslc, 0, sizeof(*Nslc)*tnlc);
00398 Nslc_cum = new long[tnlc];
00399 memset(Nslc_cum, 0, sizeof(*Nslc_cum)*tnlc);
00400
00401 Tnslc = 0;
00402 for (i=0;i<tnlc;i++)
00403 {
00404 xfscanf(in, "%k%ld", "lc_id", &lc_id);
00405 if (lc_id < 1)
00406 {
00407 sprintf(errmsg, "Error : line=%ld, col=%ld, file %s\n"
00408 " load case id %ld is out of range <1,%ld>", in->line, in->col, in->fname, lc_id, tnlc);
00409 print_err(errmsg, __FILE__, __LINE__, __func__);
00410 return 3;
00411 }
00412 lc_id--;
00413 xfscanf(in, "%k%ld", "num_sublc", Nslc+lc_id);
00414 if (Nslc[lc_id] < 1)
00415 {
00416 sprintf(errmsg, "Error : line=%ld, col=%ld, file %s\n"
00417 " number of subload cases is < 0", in->line, in->col, in->fname);
00418 print_err(errmsg, __FILE__, __LINE__, __func__);
00419 return 3;
00420 }
00421 Tnslc+=Nslc[lc_id];
00422 if (i<tnlc-1)
00423 Nslc_cum[i+1] = Tnslc;
00424 }
00425
00426 Tf = new gfunct [Tnslc];
00427 Tlt = new long [Tnslc];
00428 memset(Tlt, 0, sizeof(*Tlt)*Tnslc);
00429 for (i=0; i<Tnslc; i++)
00430 {
00431 xfscanf(in, "%k%ld", "tfunc_lc_id", &lc_id);
00432 if ((lc_id < 1) || (lc_id > Nlc))
00433 {
00434 sprintf(errmsg, "Error : line=%ld, col=%ld, file %s\n"
00435 " load case id %ld is out of range <1,%ld>", in->line, in->col, in->fname, lc_id, Nlc);
00436 print_err(errmsg, __FILE__, __LINE__, __func__);
00437 return 3;
00438 }
00439 lc_id--;
00440 xfscanf(in, "%k%ld", "tfunc_slc_id", &slc_id);
00441 if ((slc_id < 1) || (slc_id > Nslc[lc_id]))
00442 {
00443 sprintf(errmsg, "Error : line=%ld, col=%ld, file %s\n"
00444 " subload case id %ld is out of range <1,%ld>", in->line, in->col, in->fname, slc_id, Nslc[lc_id]);
00445 print_err(errmsg, __FILE__, __LINE__, __func__);
00446 return 3;
00447 }
00448 slc_id--;
00449 Tf[Nslc_cum[lc_id]+slc_id].read(in);
00450 }
00451
00452 Tlt = new long [Tnslc];
00453 memset(Tlt, 0, sizeof(*Tlt)*Tnslc);
00454 for(i=0; i<Tnslc; i++)
00455 {
00456 xfscanf(in, "%k%ld", "tempr_type_lc_id", &lc_id);
00457 if (lc_id < 1)
00458 {
00459 sprintf(errmsg, "Error : line=%ld, col=%ld, file %s\n"
00460 " load case id %ld is out of range <1,%ld>", in->line, in->col, in->fname, lc_id, tnlc);
00461 print_err(errmsg, __FILE__, __LINE__, __func__);
00462 return 3;
00463 }
00464 lc_id--;
00465 xfscanf(in, "%k%ld", "tempr_type_slc_id", &slc_id);
00466 if ((slc_id < 1) || (slc_id > Nslc[lc_id]))
00467 {
00468 sprintf(errmsg, "Error : line=%ld, col=%ld, file %s\n"
00469 " subload case id %ld is out of range <1,%ld>", in->line, in->col, in->fname, slc_id, Nslc[lc_id]);
00470 print_err(errmsg, __FILE__, __LINE__, __func__);
00471 return 3;
00472 }
00473 slc_id--;
00474 xfscanf(in, "%k%le", "temp_load_type", Tlt+Nslc_cum[lc_id]+slc_id);
00475 if ((Tlt[Nslc_cum[lc_id]+slc_id] < 0) || (Tlt[Nslc_cum[lc_id]+slc_id] > 3))
00476 {
00477 sprintf(errmsg, "Error : line=%ld, col=%ld, file %s\n"
00478 " temperature load type %ld is out of range <0,3>", in->line, in->col, in->fname, Tlt[Nslc_cum[lc_id]+slc_id]);
00479 print_err(errmsg, __FILE__, __LINE__, __func__);
00480 return 4;
00481 }
00482 }
00483 }
00484 else
00485 {
00486
00487 Tlt = new long [Nlc];
00488 memset(Tlt, 0, sizeof(*Tlt)*Nlc);
00489 for(i=0; i<Nlc; i++)
00490 {
00491 xfscanf(in, "%k%ld", "lc_id", &lc_id);
00492 if (lc_id < 1)
00493 {
00494 sprintf(errmsg, "Error : line=%ld, col=%ld, file %s\n"
00495 " load case id %ld is out of range <1,%ld>", in->line, in->col, in->fname, lc_id, tnlc);
00496 print_err(errmsg, __FILE__, __LINE__, __func__);
00497 return 3;
00498 }
00499 lc_id--;
00500 xfscanf(in, "%k%le", "temp_load_type", Tlt+lc_id);
00501 if ((Tlt[lc_id] < 0) || (Tlt[lc_id] > 3))
00502 {
00503 sprintf(errmsg, "Error : line=%ld, col=%ld, file %s\n"
00504 " temperature load type %ld is out of range <0,3>", in->line, in->col, in->fname, Tlt[lc_id]);
00505 print_err(errmsg, __FILE__, __LINE__, __func__);
00506 return 4;
00507 }
00508 }
00509 }
00510 break;
00511 }
00512
00513 case growing_mech_structure:
00514 case mech_timedependent_prob:
00515 {
00516 Nslc = new long[Nlc];
00517 memset(Nslc, 0, sizeof(*Nslc)*Nlc);
00518 Nslc_cum = new long[Nlc];
00519 memset(Nslc_cum, 0, sizeof(*Nslc_cum)*Nlc);
00520 Tnslc = 0;
00521 for (i=0;i<Nlc;i++)
00522 {
00523 xfscanf(in, "%k%ld", "lc_id", &lc_id);
00524 if (lc_id < 1)
00525 {
00526 sprintf(errmsg, "Error : line=%ld, col=%ld, file %s\n"
00527 " load case id %ld is out of range <1,%ld>", in->line, in->col, in->fname, lc_id, tnlc);
00528 print_err(errmsg, __FILE__, __LINE__, __func__);
00529 return 3;
00530 }
00531 lc_id--;
00532 xfscanf(in, "%k%ld", "num_sublc", Nslc+lc_id);
00533 if (Nslc[lc_id] < 1)
00534 {
00535 sprintf(errmsg, "Error : line=%ld, col=%ld, file %s\n"
00536 " number of subload cases is < 0", in->line, in->col, in->fname);
00537 print_err(errmsg, __FILE__, __LINE__, __func__);
00538 return 2;
00539 }
00540 Tnslc+=Nslc[lc_id];
00541 if (i<Nlc-1)
00542 Nslc_cum[i+1] = Tnslc;
00543 }
00544
00545 Tf = new gfunct [Tnslc];
00546 for (i=0; i<Tnslc; i++)
00547 {
00548 xfscanf(in, "%k%ld", "tfunc_lc_id", &lc_id);
00549 if ((lc_id < 1) || (lc_id > Nlc))
00550 {
00551 sprintf(errmsg, "Error : line=%ld, col=%ld, file %s\n"
00552 " load case id %ld is out of range <1,%ld>", in->line, in->col, in->fname, lc_id, Nlc);
00553 print_err(errmsg, __FILE__, __LINE__, __func__);
00554 return 3;
00555 }
00556 lc_id--;
00557 xfscanf(in, "%k%ld", "tfunc_slc_id", &slc_id);
00558 if ((slc_id < 1) || (slc_id > Nslc[lc_id]))
00559 {
00560 sprintf(errmsg, "Error : line=%ld, col=%ld, file %s\n"
00561 " subload case id %ld is out of range <1,%ld>", in->line, in->col, in->fname, slc_id, Nslc[lc_id]);
00562 print_err(errmsg, __FILE__, __LINE__, __func__);
00563 return 3;
00564 }
00565 slc_id--;
00566 Tf[Nslc_cum[lc_id]+slc_id].read(in);
00567 }
00568
00569 Tlt = new long [Tnslc];
00570 memset(Tlt, 0, sizeof(*Tlt)*Tnslc);
00571 if (Mp->tprob == growing_mech_structure)
00572 {
00573 Npd = new long [Tnslc];
00574 memset(Npd, 0, sizeof(*Npd)*Tnslc);
00575 Spd = new double*[Tnslc];
00576 memset(Spd, 0, sizeof(*Spd)*Tnslc);
00577 }
00578 for(i=0; i<Tnslc; i++)
00579 {
00580 xfscanf(in, "%k%ld", "tempr_type_lc_id", &lc_id);
00581 if (lc_id < 1)
00582 {
00583 sprintf(errmsg, "Error : line=%ld, col=%ld, file %s\n"
00584 " load case id %ld is out of range <1,%ld>", in->line, in->col, in->fname, lc_id, tnlc);
00585 print_err(errmsg, __FILE__, __LINE__, __func__);
00586 return 3;
00587 }
00588 lc_id--;
00589 xfscanf(in, "%k%ld", "tempr_type_slc_id", &slc_id);
00590 if ((slc_id < 1) || (slc_id > Nslc[lc_id]))
00591 {
00592 sprintf(errmsg, "Error : line=%ld, col=%ld, file %s\n"
00593 " subload case id %ld is out of range <1,%ld>", in->line, in->col, in->fname, slc_id, Nslc[lc_id]);
00594 print_err(errmsg, __FILE__, __LINE__, __func__);
00595 return 3;
00596 }
00597 slc_id--;
00598 xfscanf(in, "%k%ld", "temp_load_type", Tlt+Nslc_cum[lc_id]+slc_id);
00599 if ((Tlt[Nslc_cum[lc_id]+slc_id] < 0) || (Tlt[Nslc_cum[lc_id]+slc_id] > 3))
00600 {
00601 sprintf(errmsg, "Error : line=%ld, col=%ld, file %s\n"
00602 " temperature load type %ld is out of range <0,3>", in->line, in->col, in->fname, Tlt[Nslc_cum[lc_id]+slc_id]);
00603 print_err(errmsg, __FILE__, __LINE__, __func__);
00604 return 4;
00605 }
00606
00607 if (Mp->tprob == growing_mech_structure)
00608 {
00609 xfscanf(in, "%k%ld", "num_pres_displ_lc_id", &lc_id);
00610 if (lc_id < 1)
00611 {
00612 sprintf(errmsg, "Error : line=%ld, col=%ld, file %s\n"
00613 " load case id %ld is out of range <1,%ld>", in->line, in->col, in->fname, lc_id, tnlc);
00614 print_err(errmsg, __FILE__, __LINE__, __func__);
00615 return 3;
00616 }
00617 lc_id--;
00618 xfscanf(in, "%k%ld", "num_pres_displ_slc_id", &slc_id);
00619 if ((slc_id < 1) || (slc_id > Nslc[lc_id]))
00620 {
00621 sprintf(errmsg, "Error : line=%ld, col=%ld, file %s\n"
00622 " subload case id %ld is out of range <1,%ld>", in->line, in->col, in->fname, slc_id, Nslc[lc_id]);
00623 print_err(errmsg, __FILE__, __LINE__, __func__);
00624 return 3;
00625 }
00626 slc_id--;
00627 id = Nslc_cum[lc_id]+slc_id;
00628 xfscanf(in, "%k%ld", "num_presc_displ", &n);
00629 if (n < 0)
00630 {
00631 sprintf(errmsg, "Error : line=%ld, col=%ld, file %s\n"
00632 " number of prescribed displacements < 0", in->line, in->col, in->fname);
00633 print_err(errmsg, __FILE__, __LINE__, __func__);
00634 return 5;
00635 }
00636 if ((Npd[id] != 0) && (Npd[id] != n))
00637 {
00638 sprintf(errmsg, "Error : line=%ld, col=%ld, file %s\n"
00639 " different numbers of prescribed displacements are required", in->line, in->col, in->fname);
00640 print_err(errmsg, __FILE__, __LINE__, __func__);
00641 return 5;
00642 }
00643 Npd[id] = n;
00644 check = 1;
00645 if (Spd[id] == NULL)
00646 {
00647 check = 0;
00648 Spd[id] = new double[Npd[id]];
00649 memset(Spd[id], 0, sizeof(*Spd[id])*Npd[id]);
00650 }
00651 if (Npd[id] > 0)
00652 xfscanf(in, "%k", "presc_displ_val");
00653 for (j=0; j<Npd[id]; j++)
00654 {
00655 xfscanf(in, "%le", &tmp);
00656 if (check)
00657 {
00658 if (Spd[id][j] != tmp)
00659 {
00660 sprintf(errmsg, "Error : line=%ld, col=%ld, file %s\n"
00661 " different values of prescribed displacements have been assigned", in->line, in->col, in->fname);
00662 print_err(errmsg, __FILE__, __LINE__, __func__);
00663 return 6;
00664 }
00665 }
00666 Spd[id][j] = tmp;
00667 }
00668 }
00669 }
00670 break;
00671 }
00672 case layered_linear_statics :
00673 {
00674 xfscanf(in, "%k%ld", "num_layers", &Nlay);
00675 if (Nlay < 1)
00676 {
00677 sprintf(errmsg, "Wrong number of layers (=%ld)", Nlay);
00678 print_err(errmsg, __FILE__, __LINE__, __func__);
00679 return(2);
00680 }
00681
00682 Tlt = new long [Nlc];
00683 memset(Tlt, 0, sizeof(*Tlt)*Nlc);
00684 for(i=0; i<Nlc; i++)
00685 {
00686 xfscanf(in, "%k%ld", "lc_id", &lc_id);
00687 if (lc_id < 1)
00688 {
00689 sprintf(errmsg, "Error : line=%ld, col=%ld, file %s\n"
00690 " load case id %ld is out of range <1,%ld>", in->line, in->col, in->fname, lc_id, tnlc);
00691 print_err(errmsg, __FILE__, __LINE__, __func__);
00692 return 3;
00693 }
00694 lc_id--;
00695 xfscanf(in, "%k%le", "temp_load_type", Tlt+lc_id);
00696 if ((Tlt[lc_id] < 0) || (Tlt[lc_id] > 3))
00697 {
00698 sprintf(errmsg, "Error : line=%ld, col=%ld, file %s\n"
00699 " temperature load type %ld is out of range <0,3>", in->line, in->col, in->fname, Tlt[lc_id]);
00700 print_err(errmsg, __FILE__, __LINE__, __func__);
00701 return 4;
00702 }
00703 }
00704 break;
00705 }
00706 case linear_statics :
00707 {
00708
00709 Tlt = new long [Nlc];
00710 memset(Tlt, 0, sizeof(*Tlt)*Nlc);
00711 for(i=0; i<Nlc; i++)
00712 {
00713 xfscanf(in, "%k%ld", "lc_id", &lc_id);
00714 if (lc_id < 1)
00715 {
00716 sprintf(errmsg, "Error : line=%ld, col=%ld, file %s\n"
00717 " load case id %ld is out of range <1,%ld>", in->line, in->col, in->fname, lc_id, tnlc);
00718 print_err(errmsg, __FILE__, __LINE__, __func__);
00719 return 3;
00720 }
00721 lc_id--;
00722 xfscanf(in, "%k%ld", "temp_load_type", Tlt+lc_id);
00723 if ((Tlt[lc_id] < 0) || (Tlt[lc_id] > 3))
00724 {
00725 sprintf(errmsg, "Error : line=%ld, col=%ld, file %s\n"
00726 " temperature load type %ld is out of range <0,3>", in->line, in->col, in->fname, Tlt[lc_id]);
00727 print_err(errmsg, __FILE__, __LINE__, __func__);
00728 return 4;
00729 }
00730
00731 if (Mp->homog == 3)
00732 {
00733 if (Mstrc == NULL)
00734 {
00735 Mstrc = new double*[Nlc];
00736 memset(Mstrc, 0, sizeof(*Mstrc)*Nlc);
00737 }
00738 xfscanf(in, "%k%ld", "num_macro_stress_comp", &Nmstrc);
00739 if (Nmstrc > 0)
00740 {
00741 Mstrc[i] = new double[Nmstrc];
00742 memset(Mstrc[i], 0, sizeof(*Mstrc[i])*Nmstrc);
00743 xfscanf(in, "%k", "macro_stress_comp");
00744 for (j=0; j<Nmstrc; j++)
00745 xfscanf (in, "%lf", Mstrc[i]+j);
00746 }
00747 }
00748
00749 if (Mp->homog == 4)
00750 {
00751 if (Mstrc == NULL)
00752 {
00753 Mstrc = new double*[Nlc];
00754 memset(Mstrc, 0, sizeof(*Mstrc)*Nlc);
00755 }
00756 xfscanf(in, "%k%ld", "num_macro_strain_comp", &Nmstrc);
00757 if (Nmstrc > 0)
00758 {
00759 Mstrc[i] = new double[Nmstrc];
00760 memset(Mstrc[i], 0, sizeof(*Mstrc[i])*Nmstrc);
00761 xfscanf(in, "%k", "macro_strain_comp");
00762 for (j=0; j<Nmstrc; j++)
00763 xfscanf (in, "%lf", Mstrc[i]+j);
00764 }
00765 }
00766 }
00767 break;
00768 }
00769 default :
00770 break;
00771 }
00772
00773 if (Mp->tprob == growing_mech_structure)
00774 {
00775 fprintf(stdout, "\n\nReading of section with time functions . . .");
00776 xf_setsec(in, bsec_str[begsec_loadcase]);
00777 in->kwdmode = sect_mode_full;
00778 xfscanf(in, "%k", "time_functions");
00779 in->kwdmode = sequent_mode;
00780 Gtm->read_gf (in);
00781 }
00782 return 0;
00783 }
00784
00785
00786
00787
00788
00789
00790
00791
00792
00793
00794
00795
00796
00797
00798
00799
00800
00801
00802
00803 long input_siftop(XFILE *in, descrip *d)
00804 {
00805 long ret;
00806
00807 fprintf(stdout, "\n\nReading of mesh topology . . .");
00808 switch (d->meshfmt)
00809 {
00810 case t3d:
00811 Top->import_t3d(in, d->paral);
00812 break;
00813 case sifel:
00814 ret = Top->read(in, d->paral, d->redgn);
00815 return(ret);
00816 default:
00817 print_err("unknown mesh format is required", __FILE__, __LINE__, __func__);
00818 return(4);
00819 }
00820 return(0);
00821 }
00822
00823
00824
00825
00826
00827
00828
00829
00830
00831
00832
00833
00834
00835
00836 long input_hang_nodes(XFILE *in)
00837 {
00838 long ret;
00839 long i, id;
00840
00841 Numhn = -1;
00842 fprintf(stdout, "\n\nReading of hanging nodes . . .");
00843 xfscanf(in, "%ld", &Numhn);
00844 if ((Numhn < 0) || Numhn > Top->nn)
00845 {
00846 print_err("Wrong number of hanging nodes", __FILE__, __LINE__, __func__);
00847 return 1;
00848 }
00849
00850 Nod_hang = new hangnode*[Top->nn];
00851 memset (Nod_hang, 0, sizeof(*Nod_hang)*Top->nn);
00852 for (i=0; i<Numhn; i++)
00853 {
00854 xfscanf(in, "%ld", &id);
00855 if ((id < 1) || Numhn > Top->nn)
00856 {
00857 print_err("Wrong hanging node number", __FILE__, __LINE__, __func__);
00858 return 2;
00859 }
00860 id--;
00861 Nod_hang[id] = new hangnode;
00862 ret = Nod_hang[id]->read(in);
00863 if (ret)
00864 return 3;
00865 }
00866 return(0);
00867 }
00868
00869
00870
00871
00872
00873
00874
00875
00876
00877
00878
00879
00880
00881
00882 long input_materials(char *fname, descrip *d)
00883 {
00884 long ret;
00885 long mpb = Mespr;
00886 XFILE *in = NULL;
00887
00888 fprintf(stdout, "\n\nReading of material database . . .");
00889 in = xfopen(fname, "rt");
00890 if (in == NULL)
00891 return(1);
00892
00893 in->warning = 1;
00894 in->kwdmode = sequent_mode;
00895 in->ignorecase = 1;
00896 Dbmat = new dbmat;
00897 if (d->matstr == yes)
00898
00899 ret = Dbmat->read(in);
00900 else
00901 {
00902
00903 Mespr = 0;
00904 ret = Dbmat->readmm(in, Mm, d);
00905 Mespr = mpb;
00906 }
00907 xfclose(in);
00908 if (ret)
00909 return(2);
00910
00911 return(0);
00912 }
00913
00914
00915
00916
00917
00918
00919
00920
00921
00922
00923
00924
00925
00926
00927
00928
00929 long input_materials(XFILE *in, descrip *d)
00930 {
00931 long ret = 0;
00932 long mpb = Mespr;
00933
00934 fprintf(stdout, "\n\nReading of material database . . .");
00935 if (xf_setsec(in, bsec_str[begsec_mater]))
00936 return(1);
00937
00938 in->warning = 1;
00939 in->ignorecase = 1;
00940 in->kwdmode = sect_mode_seq;
00941 Dbmat = new dbmat;
00942 if (d->matstr == yes)
00943
00944 ret = Dbmat->read(in);
00945 else
00946 {
00947
00948 Mespr = 0;
00949 Dbmat->readmm(in, Mm, d);
00950 Mespr = mpb;
00951 }
00952
00953 if (ret)
00954 return(2);
00955
00956 return(0);
00957 }
00958
00959
00960
00961
00962
00963
00964
00965
00966
00967
00968
00969
00970
00971
00972
00973
00974 long input_crs(char *fname, descrip *d)
00975 {
00976 long ret;
00977 long mpb = Mespr;
00978 XFILE *in = NULL;
00979
00980 fprintf(stdout, "\n\nReading of cross-section database . . .");
00981 in = xfopen(fname, "rt");
00982 if (in == NULL)
00983 return(1);
00984
00985 in->warning = 1;
00986 in->ignorecase = 1;
00987 in->kwdmode = sequent_mode;
00988 Dbcrs = new dbcrs;
00989 if (d->crsstr == yes)
00990
00991 ret = Dbcrs->read(in);
00992 else
00993 {
00994
00995 Mespr = 0;
00996 ret = Dbcrs->readmc(in, Mc, d);
00997 Mespr = mpb;
00998 }
00999 xfclose(in);
01000 if (ret)
01001 return(2);
01002
01003 return(0);
01004 }
01005
01006
01007
01008
01009
01010
01011
01012
01013
01014
01015
01016
01017
01018
01019
01020
01021 long input_crs(XFILE *in, descrip *d)
01022 {
01023 long ret;
01024 long mpb = Mespr;
01025
01026 fprintf(stdout, "\n\nReading of cross-section database . . .");
01027 if (xf_setsec(in, bsec_str[begsec_crsec]))
01028 return(1);
01029
01030 in->warning = 1;
01031 in->kwdmode = sect_mode_seq;
01032 in->ignorecase = 1;
01033 Dbcrs = new dbcrs;
01034 if (d->crsstr == yes)
01035
01036 ret = Dbcrs->read(in);
01037 else
01038 {
01039
01040 Mespr = 0;
01041 Dbcrs->readmc(in, Mc, d);
01042 Mespr = mpb;
01043 }
01044 if (ret)
01045 return(2);
01046
01047 return(0);
01048 }
01049
01050
01051
01052
01053
01054
01055
01056
01057
01058
01059
01060
01061
01062
01063
01064
01065
01066
01067
01068
01069
01070
01071
01072
01073 long input_nodprop(XFILE *in)
01074 {
01075 long err;
01076 const enumstr nodsects[] = {{"begsec_nodvertpr",3}, {"begsec_nodedgpr",4},
01077 {"begsec_nodsurfpr", 5}, {"begsec_nodvolpr",6}};
01078 long nsect = sizeof(nodsects)/sizeof(*nodsects);
01079
01080 Nod_ccn = NULL;
01081
01082 fprintf(stdout, "\n\nReading of nodal properties . . .");
01083 in->kwdmode = sequent_mode;
01084
01085 err = input_nod_ndof(in, nodsects, nsect);
01086 if (err)
01087 return 1;
01088
01089
01090 err = input_nod_bocon(in, nodsects, nsect);
01091 if (err)
01092 return 2;
01093
01094 err = input_nod_coupl_dofs(in, nodsects, nsect);
01095 if (err)
01096 return 3;
01097
01098 err = input_nod_springs(in, nodsects, nsect);
01099 if (err)
01100 return 4;
01101
01102 err = input_nod_dof_tfunc(in, nodsects, nsect);
01103 if (err)
01104 return 5;
01105
01106 err = input_nod_crsec(in, nodsects, nsect);
01107 if (err)
01108 return 6;
01109
01110 err = input_nod_lcs(in, nodsects, nsect);
01111 if (err)
01112 return 7;
01113
01114 err = input_nod_load(in, nodsects, nsect);
01115 if (err)
01116 return 8;
01117
01118 err = input_nod_tdload(in, nodsects, nsect);
01119 if (err)
01120 return 9;
01121
01122 err = input_nod_initcond(in, nodsects, nsect);
01123 if (err)
01124 return 10;
01125
01126 err = input_nod_temper(in, nodsects, nsect);
01127 if (err)
01128 return 11;
01129 return 0;
01130 }
01131
01132
01133
01134
01135
01136
01137
01138
01139
01140
01141
01142
01143
01144
01145
01146
01147
01148
01149
01150
01151
01152
01153
01154 long input_elemprop(XFILE *in)
01155 {
01156 long err;
01157
01158
01159 const enumstr elemsects[] = {{bsec_str[begsec_eledgpr].alias, bsec_str[begsec_eledgpr].id},
01160 {bsec_str[begsec_elsurfpr].alias, bsec_str[begsec_elsurfpr].id},
01161 {bsec_str[begsec_elvolpr].alias, bsec_str[begsec_elvolpr].id}};
01162 long nsect = sizeof(elemsects)/sizeof(*elemsects);
01163
01164
01165 const enumstr edgesect[] = {{bsec_str[begsec_eledgpr].alias, bsec_str[begsec_eledgpr].id}};
01166 long nedgesect = sizeof(edgesect)/sizeof(*edgesect);
01167
01168
01169 const enumstr surfsect[] = {{bsec_str[begsec_elsurfpr].alias, bsec_str[begsec_elsurfpr].id}};
01170 long nsurfsect = sizeof(surfsect)/sizeof(*surfsect);
01171
01172
01173 const enumstr volsect[] = {{bsec_str[begsec_elvolpr].alias, bsec_str[begsec_elvolpr].id}};
01174 long nvolsect = sizeof(volsect)/sizeof(*volsect);
01175
01176 fprintf(stdout, "\n\nReading of element properties . . .");
01177 in->kwdmode = sequent_mode;
01178
01179 err = input_elem_type(in, elemsects, nsect);
01180 if (err)
01181 return 1;
01182 Mt->alloc_prep(Top->nn, Top->ne, El_type);
01183
01184 err = input_elem_mat(in, elemsects, nsect);
01185 if (err)
01186 return 2;
01187
01188 err = input_elem_crsec(in, elemsects, nsect);
01189 if (err)
01190 return 3;
01191
01192 err = input_elem_lcs(in, elemsects, nsect);
01193 if (err)
01194 return 4;
01195
01196 err = input_elem_load(in, elemsects, nsect);
01197 if (err)
01198 return 5;
01199
01200 err = input_elem_loadedge(in, edgesect, nedgesect);
01201 if (err)
01202 return 6;
01203
01204 err = input_elem_loadsurf(in, surfsect, nsurfsect);
01205 if (err)
01206 return 7;
01207
01208 err = input_elem_loadvol(in, volsect, nvolsect);
01209 if (err)
01210 return 8;
01211
01212 err = input_elem_eigstr(in, elemsects, nsect);
01213 if (err)
01214 return 9;
01215
01216 err = input_elem_eltimefunc(in, elemsects, nsect);
01217 if (err)
01218 return 10;
01219
01220
01221
01222
01223
01224
01225 return 0;
01226 }
01227
01228
01229
01230
01231
01232
01233
01234
01235
01236
01237
01238
01239
01240
01241
01242
01243
01244
01245
01246
01247
01248
01249
01250
01251
01252
01253
01254 long input_nod_ndof(XFILE *in, const enumstr nodsects[], long nsect)
01255 {
01256 char *aptr;
01257 long nkwd;
01258 char errmsg[1001];
01259 long *line;
01260 long *col;
01261 long aline, acol;
01262 long prop, ndof;
01263 gentity ent;
01264 kwd_handling bkwdmode;
01265 long i, j, k;
01266 long prop_used;
01267
01268 fprintf(stdout, "\n reading of number of dofs at nodes");
01269 Nod_ndof = new long[Top->nn];
01270 memset(Nod_ndof, 0, sizeof(*Nod_ndof)*Top->nn);
01271 line = new long[Top->nn];
01272 memset(line, 0, sizeof(*line)*Top->nn);
01273 col = new long[Top->nn];
01274 memset(col, 0, sizeof(*col)*Top->nn);
01275
01276 bkwdmode = in->kwdmode;
01277 in->ignorecase = 1;
01278
01279 for (i=nsect-1, ent=gregion; i>=0; i--, ent--)
01280 {
01281
01282 if (xf_setsec(in, nodsects[i]) == 1)
01283 continue;
01284
01285 in->kwdmode = sect_mode_full;
01286 nkwd = getkwd_sect(in, NULL, aptr, "ndofn", 1);
01287 in->kwdmode = bkwdmode;
01288
01289 for(j=0; j < nkwd; j++)
01290 {
01291
01292 in->kwdmode = sect_mode_fwd;
01293 getkwd_sect(in, NULL, aptr, "ndofn", 0);
01294 in->kwdmode = bkwdmode;
01295
01296 aline = in->line;
01297 acol = in->col;
01298 in->kwdmode = sect_mode_seq;
01299
01300 xfscanf(in, "%k%ld%k%ld", "ndofn", &ndof, "propid", &prop);
01301 in->kwdmode = bkwdmode;
01302 if (ndof < 1)
01303 {
01304 sprintf(errmsg, "Number of assigned dof at node should be > 0\n"
01305 "see input file %s, line %ld, column %ld", in->fname, aline, acol);
01306 print_err(errmsg, __FILE__, __LINE__, __func__);
01307 delete [] line;
01308 delete [] col;
01309 return 1;
01310 }
01311 prop_used = 0;
01312
01313 for(k=0; k<Top->nn; k++)
01314 {
01315 if (Top->nodes[k].searchprop(prop, ent, k, Top->edges, Top->surfaces))
01316 {
01317 if (Nod_ndof[k] != 0)
01318 fprintf(Log, "Line %ld, col %ld, file %s: Node %ld has already assigned ndofn at line %ld, col %ld, file: %s\n", aline, acol, in->fname, k+1, line[k], col[k], in->fname);
01319 if ((Nod_ndof[k] != 0) && (Nod_ndof[k] != ndof))
01320 {
01321 sprintf(errmsg, "Different number of dofs is assigned at node %ld\n"
01322 "see input file %s, line %ld, column %ld", k+1, in->fname, aline, acol);
01323 print_err(errmsg, __FILE__, __LINE__, __func__);
01324 delete [] line;
01325 delete [] col;
01326 return 2;
01327 }
01328 Nod_ndof[k] = ndof;
01329 prop_used = 1;
01330
01331 line[k] = aline;
01332 col[k] = acol;
01333 }
01334 }
01335 if (Check_unused_prop && (prop_used == 0))
01336 {
01337
01338 sprintf(errmsg, "Nodes with property %ld belonging to entity %s have not been found.\n"
01339 " Number of nodal dofs (line %ld, column %ld, file %s) cannot be assigned correctly.",
01340 prop, entitypstr[ent-1].alias, aline, acol, in->fname);
01341 print_err(errmsg, __FILE__, __LINE__, __func__);
01342 delete [] line;
01343 delete [] col;
01344 return 4;
01345 }
01346 }
01347 }
01348
01349
01350 for(i=0; i<Top->nn; i++)
01351 {
01352 if (Nod_ndof[i] == 0)
01353 {
01354 sprintf(errmsg, "Node %ld has not assigned number of dof", i+1);
01355 print_err(errmsg, __FILE__, __LINE__, __func__);
01356 delete [] line;
01357 delete [] col;
01358 return 3;
01359 }
01360 }
01361 delete [] line;
01362 delete [] col;
01363
01364 return 0;
01365 }
01366
01367
01368
01369
01370
01371
01372
01373
01374
01375
01376
01377
01378
01379
01380
01381
01382
01383
01384
01385
01386
01387
01388
01389
01390
01391
01392
01393 long input_nod_bocon(XFILE *in, const enumstr nodsects[], long nsect)
01394 {
01395 char *aptr;
01396 long nkwd;
01397 char errmsg[1001];
01398 long *line;
01399 long *col;
01400 long aline, acol;
01401 gentity ent;
01402 kwd_handling bkwdmode;
01403 long *setnodes;
01404 bocon tbc, *aux;
01405 long i, j, k;
01406 long prop, ndof;
01407 long errcode;
01408
01409 Nod_bocon = new bocon*[Top->nn];
01410 memset(Nod_bocon, 0, sizeof(*Nod_bocon)*Top->nn);
01411 setnodes = new long[Top->nn];
01412 memset(setnodes, 0, sizeof(*setnodes)*Top->nn);
01413 line = new long[Top->nn];
01414 memset(line, 0, sizeof(*line)*Top->nn);
01415 col = new long[Top->nn];
01416 memset(col, 0, sizeof(*col)*Top->nn);
01417
01418 bkwdmode = in->kwdmode;
01419 in->ignorecase = 1;
01420
01421 fprintf(stdout, "\n reading of nodal boundary conditions");
01422 for (i=nsect-1, ent=gregion; i>=0; i--, ent--)
01423 {
01424
01425 if (xf_setsec(in, nodsects[i]) == 1)
01426 continue;
01427
01428 in->kwdmode = sect_mode_full;
01429 nkwd = getkwd_sect(in, NULL, aptr, "bocon", 1);
01430 if (nkwd && (Mp->tprob == growing_mech_structure))
01431 {
01432 sprintf(errmsg, "Problem type 'growing_mech_structure' is required.\n"
01433 " Nodal dofs have to be controlled by time functions.\n"
01434 " Use 'nod_tfunc' preprocessor keyword for dof control.\n"
01435 " Invalid keyword 'bocon' found at line %ld, column %ld, file %s",
01436 in->line, in->col, in->fname);
01437 print_err(errmsg, __FILE__, __LINE__, __func__);
01438 delete [] setnodes;
01439 delete [] line;
01440 delete [] col;
01441 return 4;
01442 }
01443 in->kwdmode = bkwdmode;
01444
01445 for(j=0; j < nkwd; j++)
01446 {
01447
01448 in->kwdmode = sect_mode_fwd;
01449 getkwd_sect(in, NULL, aptr, "bocon", 0);
01450 in->kwdmode = bkwdmode;
01451
01452 aline = in->line;
01453 acol = in->col;
01454 in->kwdmode = sect_mode_seq;
01455
01456 xfscanf(in, "%k%k%ld", "bocon", "propid", &prop);
01457 in->kwdmode = bkwdmode;
01458
01459 ndof = Top->get_ndofn(prop, ent, Nod_ndof, setnodes);
01460 if (ndof == 0)
01461 {
01462 sprintf(errmsg, "Nodes with property %ld belonging to entity %s\n"
01463 " have different number of dofs. Boundary condition\n"
01464 " (line %ld, column %ld, file %s) cannot be assigned correctly.",
01465 prop, entitypstr[ent-1].alias, aline, acol, in->fname);
01466 print_err(errmsg, __FILE__, __LINE__, __func__);
01467 delete [] setnodes;
01468 delete [] line;
01469 delete [] col;
01470 return 1;
01471 }
01472 if (ndof == -1)
01473 {
01474 if (Check_unused_prop == 0)
01475
01476 continue;
01477 sprintf(errmsg, "Nodes with property %ld belonging to entity %s have not been found.\n"
01478 " Boundary condition (line %ld, column %ld, file %s) cannot be assigned correctly.",
01479 prop, entitypstr[ent-1].alias, aline, acol, in->fname);
01480 print_err(errmsg, __FILE__, __LINE__, __func__);
01481 delete [] setnodes;
01482 delete [] line;
01483 delete [] col;
01484 return 5;
01485 }
01486
01487 errcode = tbc.read(in, ndof);
01488 if (errcode)
01489 {
01490 if (errcode < 2)
01491 {
01492 sprintf(errmsg, "Boundary condition or direction is invalid\n"
01493 " in file %s, line %ld, col %ld", in->fname, aline, acol);
01494 }
01495 else
01496 {
01497 if (errcode < 5)
01498 {
01499 sprintf(errmsg, "Wrong (sub)load case id\n"
01500 " in file %s, line %ld, col %ld", in->fname, aline, acol);
01501 }
01502 else
01503 sprintf(errmsg, "Expression for boundary condition could not be parsed\n"
01504 " in file %s, line %ld, col %ld", in->fname, aline, acol);
01505 }
01506 print_err(errmsg, __FILE__, __LINE__, __func__);
01507 delete [] setnodes;
01508 delete [] line;
01509 delete [] col;
01510 return 2;
01511 }
01512
01513 for (k=0; k<Top->nn; k++)
01514 {
01515 if (setnodes[k] < 0)
01516 continue;
01517 if (Nod_bocon[k])
01518 {
01519 fprintf(Log, "Line %ld, col %ld, file %s: Node %ld has already assigned boundary condition at line %ld, col %ld, file: %s\n",
01520 aline, acol, in->fname, k+1, line[k], col[k], in->fname);
01521 aux = Nod_bocon[k];
01522 Nod_bocon[k] = tbc.merge(Nod_bocon[k]);
01523 delete aux;
01524 if (Nod_bocon[k] == NULL)
01525 {
01526 sprintf(errmsg, "Conflict in merging of boundary condition at line %ld, col %ld\n"
01527 "with previous boundary condition at line %ld, col %ld in file %s", aline, acol, line[k], col[k], in->fname);
01528 print_err(errmsg, __FILE__, __LINE__, __func__);
01529 delete [] setnodes;
01530 delete [] line;
01531 delete [] col;
01532 return 3;
01533 }
01534 }
01535 else
01536 Nod_bocon[k] = tbc.copy();
01537
01538
01539 line[k] = aline;
01540 col[k] = acol;
01541 }
01542 }
01543 }
01544 delete [] setnodes;
01545 delete [] line;
01546 delete [] col;
01547 return 0;
01548 }
01549
01550
01551
01552
01553
01554
01555
01556
01557
01558
01559
01560
01561
01562
01563
01564
01565
01566
01567
01568
01569
01570
01571
01572
01573
01574
01575
01576 long input_nod_coupl_dofs(XFILE *in, const enumstr nodsects[], long nsect)
01577 {
01578 char *aptr;
01579 long nkwd;
01580 char errmsg[1001];
01581 long *line;
01582 long *col;
01583 long aline, acol;
01584 gentity ent;
01585 kwd_handling bkwdmode;
01586 long *setnodes;
01587 long i, j, k, l;
01588 long prop, ndof, dir, ndir;
01589 long ccn, accn;
01590
01591 Nod_ccn = NULL;
01592 setnodes = new long[Top->nn];
01593 memset(setnodes, 0, sizeof(*setnodes)*Top->nn);
01594 line = new long[Top->nn];
01595 memset(line, 0, sizeof(*line)*Top->nn);
01596 col = new long[Top->nn];
01597 memset(col, 0, sizeof(*col)*Top->nn);
01598 ccn = accn = 1;
01599
01600 bkwdmode = in->kwdmode;
01601 in->ignorecase = 1;
01602 fprintf(stdout, "\n reading of coupled dofs at nodes");
01603
01604 for (i=nsect-1, ent=gregion; i>=0; i--, ent--)
01605 {
01606
01607 if (xf_setsec(in, nodsects[i]) == 1)
01608 continue;
01609
01610 in->kwdmode = sect_mode_full;
01611 nkwd = getkwd_sect(in, NULL, aptr, "dof_coupl", 1);
01612 if (nkwd && (Mp->tprob == growing_mech_structure))
01613 {
01614 sprintf(errmsg, "Problem type 'growing_mech_structure' is required.\n"
01615 " Nodal dofs have to be controlled by time functions.\n"
01616 " Use 'nod_tfunc' preprocessor keyword for dof control.\n"
01617 " Invalid keyword 'dof_coupl' found at line %ld, column %ld, file %s",
01618 in->line, in->col, in->fname);
01619 print_err(errmsg, __FILE__, __LINE__, __func__);
01620 delete [] setnodes;
01621 delete [] line;
01622 delete [] col;
01623 return 4;
01624 }
01625 if (Nod_ccn == NULL)
01626 {
01627 Nod_ccn = new long*[Top->nn];
01628 memset(Nod_ccn, 0, sizeof(*Nod_ccn)*Top->nn);
01629 }
01630 in->kwdmode = bkwdmode;
01631
01632 for(j=0; j < nkwd; j++)
01633 {
01634
01635 in->kwdmode = sect_mode_fwd;
01636 getkwd_sect(in, NULL, aptr, "dof_coupl", 0);
01637 in->kwdmode = bkwdmode;
01638
01639 aline = in->line;
01640 acol = in->col;
01641 in->kwdmode = sect_mode_seq;
01642
01643 xfscanf(in, "%k%k%ld", "dof_coupl", "propid", &prop);
01644 in->kwdmode = bkwdmode;
01645
01646 ndof = Top->get_ndofn(prop, ent, Nod_ndof, setnodes);
01647 if (ndof == 0)
01648 {
01649 sprintf(errmsg, "Nodes with property %ld belonging to entity %s\n"
01650 " have different number of dofs. Coupled dofs \n"
01651 " (line %ld, column %ld, file %s) cannot be assigned correctly.",
01652 prop, entitypstr[ent-1].alias, aline, acol, in->fname);
01653 print_err(errmsg, __FILE__, __LINE__, __func__);
01654 delete [] setnodes;
01655 delete [] line;
01656 delete [] col;
01657 return 1;
01658 }
01659 if (ndof == -1)
01660 {
01661 if (Check_unused_prop == 0)
01662
01663 continue;
01664 sprintf(errmsg, "Nodes with property %ld belonging to entity %s have not been found.\n"
01665 " Coupled dofs (line %ld, column %ld, file %s) cannot be assigned correctly.",
01666 prop, entitypstr[ent-1].alias, aline, acol, in->fname);
01667 print_err(errmsg, __FILE__, __LINE__, __func__);
01668 delete [] setnodes;
01669 delete [] line;
01670 delete [] col;
01671 return 5;
01672 }
01673 xfscanf(in, "%k%ld", "ndir", &ndir);
01674 if ((ndir < 1) || (ndir > ndof))
01675 {
01676 sprintf(errmsg, "Nodes with property %ld belonging to entity %s\n"
01677 " have number of coupled dof dircetions out of range <1,%ld>"
01678 " (line %ld, column %ld, file %s)",
01679 prop, entitypstr[ent-1].alias, ndof, aline, acol, in->fname);
01680 print_err(errmsg, __FILE__, __LINE__, __func__);
01681 delete [] setnodes;
01682 delete [] line;
01683 delete [] col;
01684 return 2;
01685 }
01686 for (k = 0; k < ndir; k++)
01687 {
01688 xfscanf(in, "%k%ld", "dir", &dir);
01689 if ((dir < 1) || (dir > ndof))
01690 {
01691 sprintf(errmsg, "Nodes with property %ld belonging to entity %s\n"
01692 " have coupled dof number out of range <1,%ld>"
01693 " (line %ld, column %ld, file %s)",
01694 prop, entitypstr[ent-1].alias, ndof, aline, acol, in->fname);
01695 print_err(errmsg, __FILE__, __LINE__, __func__);
01696 delete [] setnodes;
01697 delete [] line;
01698 delete [] col;
01699 return 3;
01700 }
01701 ccn++;
01702 accn = ccn;
01703
01704 for (l=0; l<Top->nn; l++)
01705 {
01706
01707 if (setnodes[l] < 0)
01708 continue;
01709 if (Nod_ccn[l] == NULL)
01710 continue;
01711 if (Nod_ccn[l][dir-1] != 0)
01712 {
01713 accn = Nod_ccn[l][dir-1];
01714 ccn--;
01715 fprintf(Log, "Line %ld, col %ld, file %s: Node %ld has already had coupled dofs at line %ld, col %ld, file: %s\n", aline, acol, in->fname, l+1, line[l], col[l], in->fname);
01716 break;
01717 }
01718 }
01719 for (l=0; l<Top->nn; l++)
01720 {
01721 if (setnodes[l] < 0)
01722 continue;
01723 if (Nod_ccn[l] == NULL)
01724 {
01725 Nod_ccn[l] = new long[ndof];
01726 memset(Nod_ccn[l], 0, sizeof(*Nod_ccn[l])*ndof);
01727
01728 line[l] = aline;
01729 col[l] = acol;
01730 }
01731 Nod_ccn[l][dir-1] = accn;
01732 }
01733 }
01734 }
01735 }
01736 delete [] setnodes;
01737 delete [] line;
01738 delete [] col;
01739 return 0;
01740 }
01741
01742
01743
01744
01745
01746
01747
01748
01749
01750
01751
01752
01753
01754
01755
01756
01757
01758
01759
01760
01761
01762
01763
01764
01765
01766
01767
01768 long input_nod_dof_tfunc(XFILE *in, const enumstr nodsects[], long nsect)
01769 {
01770 char *aptr;
01771 long nkwd;
01772 char errmsg[1001];
01773 long *line;
01774 long *col;
01775 long aline, acol;
01776 gentity ent;
01777 kwd_handling bkwdmode;
01778 long *setnodes;
01779 long tf_id;
01780 long i, j, k, l;
01781 long prop, ndof, ndir, dir;
01782
01783 if (Nod_ccn == NULL)
01784 {
01785 Nod_ccn = new long*[Top->nn];
01786 memset(Nod_ccn, 0, sizeof(*Nod_ccn)*Top->nn);
01787 }
01788 setnodes = new long[Top->nn];
01789 memset(setnodes, 0, sizeof(*setnodes)*Top->nn);
01790 line = new long[Top->nn];
01791 memset(line, 0, sizeof(*line)*Top->nn);
01792 col = new long[Top->nn];
01793 memset(col, 0, sizeof(*col)*Top->nn);
01794
01795 bkwdmode = in->kwdmode;
01796 in->ignorecase = 1;
01797
01798 fprintf(stdout, "\n reading of dof time functions at nodes");
01799
01800 for (i=nsect-1, ent=gregion; i>=0; i--, ent--)
01801 {
01802
01803 if (xf_setsec(in, nodsects[i]) == 1)
01804 continue;
01805
01806 in->kwdmode = sect_mode_full;
01807 nkwd = getkwd_sect(in, NULL, aptr, "nod_tfunc", 1);
01808 in->kwdmode = bkwdmode;
01809
01810 for(j=0; j < nkwd; j++)
01811 {
01812
01813 in->kwdmode = sect_mode_fwd;
01814 getkwd_sect(in, NULL, aptr, "nod_tfunc", 0);
01815 in->kwdmode = bkwdmode;
01816
01817 aline = in->line;
01818 acol = in->col;
01819 in->kwdmode = sect_mode_seq;
01820
01821 xfscanf(in, "%k%k%ld", "nod_tfunc", "propid", &prop);
01822 in->kwdmode = bkwdmode;
01823
01824 ndof = Top->get_ndofn(prop, ent, Nod_ndof, setnodes);
01825 if (ndof == 0)
01826 {
01827 sprintf(errmsg, "Nodes with property %ld belonging to entity %s\n"
01828 " have different number of dofs. Nodal time functions \n"
01829 " (line %ld, column %ld, file %s) cannot be assigned correctly.",
01830 prop, entitypstr[ent-1].alias, aline, acol, in->fname);
01831 print_err(errmsg, __FILE__, __LINE__, __func__);
01832 delete [] setnodes;
01833 delete [] line;
01834 delete [] col;
01835 return 1;
01836 }
01837 if (ndof == -1)
01838 {
01839 if (Check_unused_prop == 0)
01840
01841 continue;
01842 sprintf(errmsg, "Nodes with property %ld belonging to entity %s have not been found.\n"
01843 " Nodal time functions (line %ld, column %ld, file %s) cannot be assigned correctly.",
01844 prop, entitypstr[ent-1].alias, aline, acol, in->fname);
01845 print_err(errmsg, __FILE__, __LINE__, __func__);
01846 delete [] setnodes;
01847 delete [] line;
01848 delete [] col;
01849 return 4;
01850 }
01851 xfscanf(in, "%k%ld", "ndir", &ndir);
01852 if ((ndir < 1) || (ndir > ndof))
01853 {
01854 sprintf(errmsg, "Nodes with property %ld belonging to entity %s\n"
01855 " have number of dof dircetions out of range <1,%ld>"
01856 " (line %ld, column %ld, file %s)",
01857 prop, entitypstr[ent-1].alias, ndof, aline, acol, in->fname);
01858 print_err(errmsg, __FILE__, __LINE__, __func__);
01859 delete [] setnodes;
01860 delete [] line;
01861 delete [] col;
01862 return 2;
01863 }
01864 for (k = 0; k < ndir; k++)
01865 {
01866 xfscanf(in, "%k%ld", "dir", &dir);
01867 if ((dir < 1) || (dir > ndof))
01868 {
01869 sprintf(errmsg, "Nodes with property %ld belonging to entity %s\n"
01870 " have time function dof number out of range <1,%ld>"
01871 " (line %ld, column %ld, file %s)",
01872 prop, entitypstr[ent-1].alias, ndof, aline, acol, in->fname);
01873 print_err(errmsg, __FILE__, __LINE__, __func__);
01874 delete [] setnodes;
01875 delete [] line;
01876 delete [] col;
01877 return 3;
01878 }
01879 xfscanf(in, "%k%ld", "tfunc_id", &tf_id);
01880 if (tf_id < 1)
01881 {
01882 sprintf(errmsg, "Invalid time function index");
01883 print_err(errmsg, __FILE__, __LINE__, __func__);
01884 delete [] line;
01885 delete [] col;
01886 return 5;
01887 }
01888
01889 for (l=0; l<Top->nn; l++)
01890 {
01891 if (setnodes[l] < 0)
01892 continue;
01893 if (Nod_ccn[l] == NULL)
01894 {
01895 Nod_ccn[l] = new long[ndof];
01896 memset(Nod_ccn[l], 0, sizeof(*Nod_ccn[l])*ndof);
01897 Nod_ccn[l][dir-1] = tf_id;
01898
01899 line[l] = aline;
01900 col[l] = acol;
01901 }
01902 else
01903 {
01904
01905
01906 if ((Nod_ccn[l][k] != 0) && (Nod_ccn[l][k] != tf_id))
01907 {
01908 fprintf(Log, "Line %ld, col %ld, file %s: Node %ld has already had assigned different "
01909 "time function at line %ld, col %ld, file: %s\n", aline, acol, in->fname,
01910 l+1, line[l], col[l], in->fname);
01911 }
01912 Nod_ccn[l][dir-1] = tf_id;
01913 }
01914 }
01915 }
01916 }
01917 }
01918 delete [] setnodes;
01919 delete [] line;
01920 delete [] col;
01921 return 0;
01922 }
01923
01924
01925
01926
01927
01928
01929
01930
01931
01932
01933
01934
01935
01936
01937
01938
01939
01940
01941
01942
01943
01944
01945
01946 long input_nod_crsec(XFILE *in, const enumstr nodsects[], long nsect)
01947 {
01948 char *aptr;
01949 long nkwd;
01950 char errmsg[1001];
01951 long *line;
01952 long *col;
01953 long aline, acol;
01954 gentity ent;
01955 kwd_handling bkwdmode;
01956 long *setnodes;
01957 crsectype cst;
01958 long csti;
01959 long i, j, k, ic;
01960 long prop;
01961 long prop_used;
01962
01963 Nod_cst = new crsectype[Top->nn];
01964 memset(Nod_cst, 0, sizeof(*Nod_cst)*Top->nn);
01965 Nod_csti = new long[Top->nn];
01966 memset(Nod_csti, 0, sizeof(*Nod_csti)*Top->nn);
01967 Nod_cstdbi = new long[Top->nn];
01968 memset(Nod_cstdbi, 0, sizeof(*Nod_cstdbi)*Top->nn);
01969 setnodes = new long[Top->nn];
01970 memset(setnodes, 0, sizeof(*setnodes)*Top->nn);
01971 line = new long[Top->nn];
01972 memset(line, 0, sizeof(*line)*Top->nn);
01973 col = new long[Top->nn];
01974 memset(col, 0, sizeof(*col)*Top->nn);
01975
01976 bkwdmode = in->kwdmode;
01977 in->ignorecase = 1;
01978
01979 fprintf(stdout, "\n reading of cross-sections at nodes");
01980
01981 for (i=nsect-1, ent=gregion; i>=0; i--, ent--)
01982 {
01983
01984 if (xf_setsec(in, nodsects[i]) == 1)
01985 continue;
01986
01987 in->kwdmode = sect_mode_full;
01988 nkwd = getkwd_sect(in, NULL, aptr, "nod_crsec", 1);
01989 in->kwdmode = bkwdmode;
01990
01991 for(j=0; j < nkwd; j++)
01992 {
01993
01994 in->kwdmode = sect_mode_fwd;
01995 getkwd_sect(in, NULL, aptr, "nod_crsec", 0);
01996 in->kwdmode = bkwdmode;
01997
01998 aline = in->line;
01999 acol = in->col;
02000
02001 cst = csplanestr;
02002 csti = 2;
02003 in->kwdmode = sect_mode_seq;
02004 xfscanf(in, "%k%k%ld", "nod_crsec", "propid", &prop);
02005 xfscanf(in, "%k%m%k%ld", "type", &crsectype_kwdset, &cst, "type_id", &csti);
02006 in->kwdmode = bkwdmode;
02007
02008 ic = Dbcrs->search_crs(cst, csti-1);
02009 if (ic < 0)
02010 {
02011 sprintf(errmsg, "Line %ld, col %ld, file %s: cannot find required cross-section in the database", in->line, in->col, in->fname);
02012 print_err(errmsg, __FILE__, __LINE__, __func__);
02013 delete [] setnodes;
02014 delete [] line;
02015 delete [] col;
02016 return 1;
02017 }
02018 else
02019 Dbcrs->mark_used(ic, csti-1);
02020
02021 Top->get_propent_nodes(prop, ent, setnodes);
02022 prop_used = 0;
02023
02024 for (k=0; k<Top->nn; k++)
02025 {
02026 if (setnodes[k] < 0)
02027 continue;
02028 if ((Nod_cst[k] != nocrosssection) && ((Nod_cst[k] != cst) || (Nod_csti[k] != csti)))
02029 {
02030 sprintf(errmsg, "Line %ld, col %ld, file %s: Node %ld has already had assigned different"
02031 "cross-section type at line %ld, col %ld, file: %s\n", aline, acol, in->fname,
02032 k+1, line[k], col[k], in->fname);
02033 print_err(errmsg, __FILE__, __LINE__, __func__);
02034 delete [] setnodes;
02035 delete [] line;
02036 delete [] col;
02037 return 2;
02038 }
02039 Nod_cst[k] = cst;
02040 Nod_csti[k] = csti;
02041 Nod_cstdbi[k] = ic;
02042 prop_used = 1;
02043
02044 line[k] = aline;
02045 col[k] = acol;
02046 }
02047 if (Check_unused_prop && (prop_used == 0))
02048 {
02049
02050 sprintf(errmsg, "Nodes with property %ld belonging to entity %s have not been found.\n"
02051 " Nodal cross-section type (line %ld, column %ld, file %s) cannot be assigned correctly.",
02052 prop, entitypstr[ent-1].alias, aline, acol, in->fname);
02053 print_err(errmsg, __FILE__, __LINE__, __func__);
02054 delete [] line;
02055 delete [] col;
02056 return 3;
02057 }
02058 }
02059 }
02060 delete [] setnodes;
02061 delete [] line;
02062 delete [] col;
02063 return 0;
02064 }
02065
02066
02067
02068
02069
02070
02071
02072
02073
02074
02075
02076
02077
02078
02079
02080
02081
02082
02083
02084
02085
02086
02087
02088
02089
02090 long input_nod_springs(XFILE *in, const enumstr nodsects[], long nsect)
02091 {
02092 char *aptr;
02093 long nkwd;
02094 char errmsg[1001];
02095 long *line;
02096 long *col;
02097 long aline, acol;
02098 gentity ent;
02099 kwd_handling bkwdmode;
02100 long *setnodes;
02101 long i, j, k, l;
02102 mattype *tmp_type;
02103 long *tmp_id, *ic;
02104 long prop, dir, nmat, ndof, err;
02105 long prop_used;
02106
02107 Nod_nsprmat = new long*[Top->nn];
02108 memset(Nod_nsprmat, 0, sizeof(*Nod_nsprmat)*Top->nn);
02109 Nod_sprmattype = new mattype**[Top->nn];
02110 memset(Nod_sprmattype, 0, sizeof(*Nod_sprmattype)*Top->nn);
02111 Nod_sprmatid = new long**[Top->nn];
02112 memset(Nod_sprmatid, 0, sizeof(*Nod_sprmatid)*Top->nn);
02113 Nod_sprmatdbi = new long**[Top->nn];
02114 memset(Nod_sprmatdbi, 0, sizeof(*Nod_sprmatdbi)*Top->nn);
02115
02116 setnodes = new long[Top->nn];
02117 memset(setnodes, 0, sizeof(*setnodes)*Top->nn);
02118 line = new long[Top->nn];
02119 memset(line, 0, sizeof(*line)*Top->nn);
02120 col = new long[Top->nn];
02121 memset(col, 0, sizeof(*col)*Top->nn);
02122
02123 bkwdmode = in->kwdmode;
02124 in->ignorecase = 1;
02125
02126 fprintf(stdout, "\n reading of springs at nodes");
02127
02128 for (i=nsect-1, ent=gregion; i>=0; i--, ent--)
02129 {
02130
02131 if (xf_setsec(in, nodsects[i]) == 1)
02132 continue;
02133
02134 in->kwdmode = sect_mode_full;
02135 nkwd = getkwd_sect(in, NULL, aptr, "nod_spring", 1);
02136 in->kwdmode = bkwdmode;
02137
02138 for(j=0; j < nkwd; j++)
02139 {
02140
02141 in->kwdmode = sect_mode_fwd;
02142 getkwd_sect(in, NULL, aptr, "nod_spring", 0);
02143 in->kwdmode = bkwdmode;
02144
02145 aline = in->line;
02146 acol = in->col;
02147 in->kwdmode = sect_mode_seq;
02148
02149 xfscanf(in, "%k%k%ld%k%ld%k%ld", "nod_spring", "propid", &prop, "dir", &dir, "num_mat", &nmat);
02150 dir--;
02151
02152 if (nmat<=0)
02153 {
02154 print_err("number of material types is <= 0", __FILE__, __LINE__, __func__);
02155 delete [] line;
02156 delete [] col;
02157 return 1;
02158 }
02159 if ((dir < 0) || (dir > 5))
02160 {
02161 print_err("direction of spring is out of range <1,6>", __FILE__, __LINE__, __func__);
02162 delete [] line;
02163 delete [] col;
02164 return 4;
02165 }
02166
02167 tmp_type = new mattype[nmat];
02168 memset(tmp_type, 0, sizeof(*tmp_type)*nmat);
02169 tmp_id = new long[nmat];
02170 memset(tmp_id, 0, sizeof(*tmp_id)*nmat);
02171 ic = new long[nmat];
02172 memset(ic, 0, sizeof(*ic)*nmat);
02173
02174 for (k=0; k<nmat; k++)
02175 {
02176 xfscanf(in, "%k%m%k%ld", "type", &mattype_kwdset, tmp_type+k, "type_id", tmp_id+k);
02177
02178 ic[k] = Dbmat->search_mat(tmp_type[k], tmp_id[k]-1);
02179 if (ic[k] < 0)
02180 {
02181 sprintf(errmsg, "Line %ld, col %ld, file %s: cannot find %ld. required material in the database", in->line, in->col, in->fname, k+1);
02182 print_err(errmsg, __FILE__, __LINE__, __func__);
02183 delete [] tmp_type;
02184 delete [] tmp_id;
02185 delete [] ic;
02186 delete [] line;
02187 delete [] col;
02188 return 1;
02189 }
02190 else
02191 Dbmat->mark_used(ic[k], tmp_id[k]-1);
02192 }
02193 in->kwdmode = bkwdmode;
02194
02195 Top->get_propent_nodes(prop, ent, setnodes);
02196 prop_used = 0;
02197
02198 for (k=0; k<Top->nn; k++)
02199 {
02200 if (setnodes[k] < 0)
02201 continue;
02202
02203 ndof = Top->get_ndofn(prop, ent, Nod_ndof, setnodes);
02204 if (ndof == 0)
02205 {
02206 sprintf(errmsg, "Nodes with property %ld belonging to entity %s\n"
02207 " have different number of dofs. Nodal spring \n"
02208 " (line %ld, column %ld, file %s) cannot be assigned correctly.",
02209 prop, entitypstr[ent-1].alias, aline, acol, in->fname);
02210 print_err(errmsg, __FILE__, __LINE__, __func__);
02211 delete [] setnodes;
02212 delete [] line;
02213 delete [] col;
02214 return 5;
02215 }
02216
02217 if (Nod_nsprmat[k] == NULL)
02218
02219 {
02220 Nod_nsprmat[k] = new long[ndof];
02221 memset(Nod_nsprmat[k], 0, sizeof(*Nod_nsprmat[k])*ndof);
02222 Nod_sprmattype[k] = new mattype*[ndof];
02223 memset(Nod_sprmattype[k], 0, sizeof(*Nod_sprmattype[k])*ndof);
02224 Nod_sprmatid[k] = new long*[ndof];
02225 memset(Nod_sprmatid[k], 0, sizeof(*Nod_sprmatid[k])*ndof);
02226 Nod_sprmatdbi[k] = new long*[ndof];
02227 memset(Nod_sprmatdbi[k], 0, sizeof(*Nod_sprmatdbi[k])*ndof);
02228 }
02229
02230
02231 prop_used = 1;
02232 if (Nod_nsprmat[k][dir] != 0)
02233 {
02234 err = 0;
02235 if (nmat != Nod_nsprmat[k][dir])
02236 err = 1;
02237 for (l=0; (l<nmat) && (err==0); l++)
02238 {
02239 if ((tmp_type[l] != Nod_sprmattype[k][dir][l]) || (tmp_id[l] != Nod_sprmatid[k][dir][l]))
02240 err = 1;
02241 }
02242 if (err)
02243 {
02244 sprintf(errmsg, "Different material types have been assigned to spring at node %ld\n"
02245 "see input file %s, line %ld, column %ld", k+1, in->fname, aline, acol);
02246 print_err(errmsg, __FILE__, __LINE__, __func__);
02247 delete [] tmp_type;
02248 delete [] tmp_id;
02249 delete [] ic;
02250 delete [] line;
02251 delete [] col;
02252 return 2;
02253 }
02254 else
02255 fprintf(Log, "Line %ld, col %ld, file %s: Spring at node %ld has already assigned material type at line %ld, col %ld, file: %s\n", aline, acol, in->fname, k+1, line[k], col[k], in->fname);
02256 }
02257 else
02258 {
02259 Nod_sprmattype[k][dir] = new mattype[nmat];
02260 Nod_sprmatid[k][dir] = new long[nmat];
02261 Nod_sprmatdbi[k][dir] = new long[nmat];
02262 Nod_nsprmat[k][dir] = nmat;
02263 for(l=0; l<nmat; l++)
02264 {
02265 Nod_sprmattype[k][dir][l] = tmp_type[l];
02266 Nod_sprmatid[k][dir][l] = tmp_id[l];
02267 Nod_sprmatdbi[k][dir][l] = ic[l];
02268 }
02269
02270 line[k] = aline;
02271 col[k] = acol;
02272 }
02273 }
02274
02275 delete [] tmp_type;
02276 delete [] tmp_id;
02277 delete [] ic;
02278
02279 if (Check_unused_prop && (prop_used == 0))
02280 {
02281
02282 sprintf(errmsg, "Nodes with property %ld belonging to entity %s have not been found.\n"
02283 " Nodal spring (line %ld, column %ld, file %s) cannot be assigned correctly.",
02284 prop, entitypstr[ent-1].alias, aline, acol, in->fname);
02285 print_err(errmsg, __FILE__, __LINE__, __func__);
02286 delete [] line;
02287 delete [] col;
02288 return 3;
02289 }
02290 }
02291 }
02292 delete [] setnodes;
02293 delete [] line;
02294 delete [] col;
02295 return 0;
02296 }
02297
02298
02299
02300
02301
02302
02303
02304
02305
02306
02307
02308
02309
02310
02311
02312
02313
02314
02315
02316
02317
02318
02319 long input_nod_lcs(XFILE *in, const enumstr nodsects[], long nsect)
02320 {
02321 char *aptr;
02322 long nkwd;
02323 char errmsg[1001];
02324 long *line;
02325 long *col;
02326 long aline, acol;
02327 gentity ent;
02328 kwd_handling bkwdmode;
02329 long *setnodes;
02330 long dim;
02331 long i, j, k, l, m;
02332 long prop, check;
02333 vector *basev;
02334 long prop_used;
02335
02336 Nod_lcs = new vector*[Top->nn];
02337 memset(Nod_lcs, 0, sizeof(*Nod_lcs)*Top->nn);
02338 setnodes = new long[Top->nn];
02339 memset(setnodes, 0, sizeof(*setnodes)*Top->nn);
02340 line = new long[Top->nn];
02341 memset(line, 0, sizeof(*line)*Top->nn);
02342 col = new long[Top->nn];
02343 memset(col, 0, sizeof(*col)*Top->nn);
02344
02345 bkwdmode = in->kwdmode;
02346 in->ignorecase = 1;
02347
02348 fprintf(stdout, "\n reading of nodal local coordinate systems");
02349
02350 for (i=nsect-1, ent=gregion; i>=0; i--, ent--)
02351 {
02352
02353 if (xf_setsec(in, nodsects[i]) == 1)
02354 continue;
02355
02356 in->kwdmode = sect_mode_full;
02357 nkwd = getkwd_sect(in, NULL, aptr, "nod_lcs", 1);
02358 in->kwdmode = bkwdmode;
02359
02360 for(j=0; j < nkwd; j++)
02361 {
02362
02363 in->kwdmode = sect_mode_fwd;
02364 getkwd_sect(in, NULL, aptr, "nod_lcs", 0);
02365 in->kwdmode = bkwdmode;
02366
02367 aline = in->line;
02368 acol = in->col;
02369 in->kwdmode = sect_mode_seq;
02370
02371 xfscanf(in, "%k%k%ld", "nod_lcs", "propid", &prop);
02372 xfscanf(in, "%k%ld", "dim", &dim);
02373 if ((dim < 2) || (dim > 3))
02374 {
02375 sprintf(errmsg, "Line %ld, col %ld, file %s: Wrong dimension of base vectors (%ld)\n"
02376 "Dimension has to be in range <2,3>\n",
02377 aline, acol, in->fname, dim);
02378 print_err(errmsg, __FILE__, __LINE__, __func__);
02379 delete [] basev;
02380 delete [] setnodes;
02381 delete [] line;
02382 delete [] col;
02383 return 1;
02384 }
02385
02386 basev = new vector[dim];
02387 for (k=0; k<dim; k++)
02388 {
02389 allocv(dim, basev[k]);
02390 xfscanf(in, "%k", "basevec");
02391 readv(in, basev[k]);
02392 }
02393 in->kwdmode = bkwdmode;
02394
02395
02396 Top->get_propent_nodes(prop, ent, setnodes);
02397 prop_used = 0;
02398 for (k=0; k<Top->nn; k++)
02399 {
02400 if (setnodes[k] < 0)
02401 continue;
02402 if (Nod_lcs[k] != NULL)
02403 {
02404 check = 1;
02405 for (l=0; l<dim; l++)
02406 {
02407 for(m=0; m<dim; m++)
02408 {
02409 if (Nod_lcs[k][l][m] != basev[l][m])
02410 {
02411 check = 0;
02412 l = dim;
02413 break;
02414 }
02415 }
02416 }
02417 if (check == 0)
02418 {
02419
02420 sprintf(errmsg, "Line %ld, col %ld, file %s: Node %ld has already had assigned different"
02421 "local coordinate system at line %ld, col %ld, file: %s\n", aline, acol, in->fname,
02422 k+1, line[k], col[k], in->fname);
02423 print_err(errmsg, __FILE__, __LINE__, __func__);
02424 delete [] basev;
02425 delete [] setnodes;
02426 delete [] line;
02427 delete [] col;
02428 return 1;
02429 }
02430 }
02431 Nod_lcs[k] = new vector[dim];
02432 for (l=0; l<dim; l++)
02433 {
02434 allocv(dim, Nod_lcs[k][l]);
02435 copyv(basev[l], Nod_lcs[k][l]);
02436 }
02437 prop_used = 1;
02438
02439 line[k] = aline;
02440 col[k] = acol;
02441 }
02442 delete [] basev;
02443 if (Check_unused_prop && (prop_used == 0))
02444 {
02445
02446 sprintf(errmsg, "Nodes with property %ld belonging to entity %s have not been found.\n"
02447 " Nodal lcs (line %ld, column %ld, file %s) cannot be assigned correctly.",
02448 prop, entitypstr[ent-1].alias, aline, acol, in->fname);
02449 print_err(errmsg, __FILE__, __LINE__, __func__);
02450 delete [] line;
02451 delete [] col;
02452 return 2;
02453 }
02454 }
02455 }
02456 delete [] setnodes;
02457 delete [] line;
02458 delete [] col;
02459 return 0;
02460 }
02461
02462
02463
02464
02465
02466
02467
02468
02469
02470
02471
02472
02473
02474
02475
02476
02477
02478
02479
02480
02481
02482
02483
02484
02485 long input_nod_load(XFILE *in, const enumstr nodsects[], long nsect)
02486 {
02487 char *aptr;
02488 long nkwd;
02489 char errmsg[1001];
02490 long *line;
02491 long *col;
02492 long aline, acol;
02493 gentity ent;
02494 kwd_handling bkwdmode;
02495 long *setnodes;
02496 double *force;
02497 long i, j, k, l;
02498 long prop, ndof, lcid;
02499 long tnlc, slcid=0;
02500
02501 tnlc = Nlc;
02502 if (Tnslc)
02503 tnlc = Tnslc;
02504
02505 Nod_load = new double**[Top->nn];
02506 memset(Nod_load, 0, sizeof(*Nod_load)*Top->nn);
02507 for(i=0; i<Top->nn; i++)
02508 {
02509 Nod_load[i] = new double*[tnlc];
02510 memset(Nod_load[i], 0, sizeof(*Nod_load[i])*tnlc);
02511 }
02512 setnodes = new long[Top->nn];
02513 memset(setnodes, 0, sizeof(*setnodes)*Top->nn);
02514 line = new long[Top->nn];
02515 memset(line, 0, sizeof(*line)*Top->nn);
02516 col = new long[Top->nn];
02517 memset(col, 0, sizeof(*col)*Top->nn);
02518
02519 bkwdmode = in->kwdmode;
02520 in->ignorecase = 1;
02521
02522 fprintf(stdout, "\n reading of nodal load");
02523
02524 for (i=nsect-1, ent=gregion; i>=0; i--, ent--)
02525 {
02526
02527 if (xf_setsec(in, nodsects[i]) == 1)
02528 continue;
02529
02530 in->kwdmode = sect_mode_full;
02531 nkwd = getkwd_sect(in, NULL, aptr, "nod_load", 1);
02532 in->kwdmode = bkwdmode;
02533
02534 for(j=0; j < nkwd; j++)
02535 {
02536
02537 in->kwdmode = sect_mode_fwd;
02538 getkwd_sect(in, NULL, aptr, "nod_load", 0);
02539 in->kwdmode = bkwdmode;
02540
02541 aline = in->line;
02542 acol = in->col;
02543 in->kwdmode = sect_mode_seq;
02544
02545 xfscanf(in, "%k%k%ld", "nod_load", "propid", &prop);
02546 xfscanf(in, "%k%ld", "lc_id", &lcid);
02547 if ((lcid < 1) || (lcid > Nlc))
02548 {
02549 sprintf(errmsg, "Line %ld, col %ld, file %s: loadcase index out of range <1,%ld>", in->line, in->col, in->fname, Nlc);
02550 print_err(errmsg, __FILE__, __LINE__, __func__);
02551 delete [] setnodes;
02552 delete [] line;
02553 delete [] col;
02554 return 1;
02555 }
02556 lcid--;
02557 if (Tnslc)
02558 {
02559 xfscanf(in, "%k%ld", "slc_id", &slcid);
02560 if ((slcid < 1) || (slcid > Nslc[lcid]))
02561 {
02562 sprintf(errmsg, "Line %ld, col %ld, file %s: subloadcase index out of range <1,%ld>", in->line, in->col, in->fname, Nslc[lcid]);
02563 print_err(errmsg, __FILE__, __LINE__, __func__);
02564 delete [] setnodes;
02565 delete [] line;
02566 delete [] col;
02567 return 1;
02568 }
02569 slcid--;
02570 lcid = Nslc_cum[lcid]+slcid;
02571 }
02572 xfscanf(in, "%k", "load_comp");
02573
02574 ndof = Top->get_ndofn(prop, ent, Nod_ndof, setnodes);
02575 if (ndof == 0)
02576 {
02577 sprintf(errmsg, "Nodes with property %ld belonging to entity %s\n"
02578 " have different number of dofs. Nodal load \n"
02579 " (line %ld, column %ld, file %s) cannot be assigned correctly.",
02580 prop, entitypstr[ent-1].alias, aline, acol, in->fname);
02581 print_err(errmsg, __FILE__, __LINE__, __func__);
02582 delete [] setnodes;
02583 delete [] line;
02584 delete [] col;
02585 return 2;
02586 }
02587 if (ndof == -1)
02588 {
02589 if (Check_unused_prop == 0)
02590
02591 continue;
02592 sprintf(errmsg, "Nodes with property %ld belonging to entity %s have not been found.\n"
02593 " Nodal load (line %ld, column %ld, file %s) cannot be assigned correctly.",
02594 prop, entitypstr[ent-1].alias, aline, acol, in->fname);
02595 print_err(errmsg, __FILE__, __LINE__, __func__);
02596 delete [] setnodes;
02597 delete [] line;
02598 delete [] col;
02599 return 3;
02600 }
02601 force = new double[ndof];
02602 for (k = 0; k < ndof; k++)
02603 xfscanf(in, "%le", force+k);
02604
02605 in->kwdmode = bkwdmode;
02606
02607 for (k=0; k<Top->nn; k++)
02608 {
02609 if (setnodes[k] < 0)
02610 continue;
02611 if (Nod_load[k][lcid] == NULL)
02612 {
02613 Nod_load[k][lcid] = new double[ndof];
02614 memset(Nod_load[k][lcid], 0, sizeof(*Nod_load[k][lcid])*ndof);
02615 for(l=0; l<ndof; l++)
02616 Nod_load[k][lcid][l] += force[l];
02617
02618 line[k] = aline;
02619 col[k] = acol;
02620 }
02621 else
02622 {
02623 fprintf(Log, "Line %ld, col %ld, file %s: Node %ld has already had assigned load at line %ld, col %ld, file: %s\n", aline, acol, in->fname, k+1, line[k], col[k], in->fname);
02624 for(l=0; l<ndof; l++)
02625 Nod_load[k][lcid][l] += force[l];
02626 }
02627 }
02628 delete [] force;
02629 }
02630 }
02631 delete [] setnodes;
02632 delete [] line;
02633 delete [] col;
02634 return 0;
02635 }
02636
02637
02638
02639
02640
02641
02642
02643
02644
02645
02646
02647
02648
02649
02650
02651
02652
02653
02654
02655
02656
02657
02658
02659
02660
02661 long input_nod_tdload(XFILE *in, const enumstr nodsects[], long nsect)
02662 {
02663 char *aptr;
02664 long nkwd;
02665 char errmsg[1001];
02666 long *line;
02667 long *col;
02668 long aline, acol;
02669 gentity ent;
02670 kwd_handling bkwdmode;
02671 long *setnodes;
02672 gfunct *force;
02673 long i, j, k, l;
02674 long prop, ndof, lcid;
02675
02676 Nod_tdload = new gfunct**[Top->nn];
02677 memset(Nod_tdload, 0, sizeof(*Nod_tdload)*Top->nn);
02678 for(i=0; i<Top->nn; i++)
02679 {
02680 Nod_tdload[i] = new gfunct*[Nlc];
02681 memset(Nod_tdload[i], 0, sizeof(*Nod_tdload[i])*Nlc);
02682 }
02683 setnodes = new long[Top->nn];
02684 memset(setnodes, 0, sizeof(*setnodes)*Top->nn);
02685 line = new long[Top->nn];
02686 memset(line, 0, sizeof(*line)*Top->nn);
02687 col = new long[Top->nn];
02688 memset(col, 0, sizeof(*col)*Top->nn);
02689
02690 bkwdmode = in->kwdmode;
02691 in->ignorecase = 1;
02692
02693 fprintf(stdout, "\n reading of time dependent nodal load");
02694
02695 for (i=nsect-1, ent=gregion; i>=0; i--, ent--)
02696 {
02697
02698 if (xf_setsec(in, nodsects[i]) == 1)
02699 continue;
02700
02701 in->kwdmode = sect_mode_full;
02702 nkwd = getkwd_sect(in, NULL, aptr, "nod_tdload", 1);
02703 if (nkwd && Tnslc)
02704 {
02705 xfscanf(in,"%k", "nod_tdload");
02706 sprintf(errmsg, "Line %ld, col %ld, file %s: invalid type of load is required in case of subloadcases", in->line, in->col, in->fname);
02707 print_err(errmsg, __FILE__, __LINE__, __func__);
02708 delete [] setnodes;
02709 delete [] line;
02710 delete [] col;
02711 return 1;
02712 }
02713 in->kwdmode = bkwdmode;
02714
02715 for(j=0; j < nkwd; j++)
02716 {
02717
02718 in->kwdmode = sect_mode_fwd;
02719 getkwd_sect(in, NULL, aptr, "nod_tdload", 0);
02720 in->kwdmode = bkwdmode;
02721
02722 aline = in->line;
02723 acol = in->col;
02724 in->kwdmode = sect_mode_seq;
02725
02726 xfscanf(in, "%k%k%ld", "nod_tdload", "propid", &prop);
02727 xfscanf(in, "%k%ld", "lc_id", &lcid);
02728 if ((lcid < 1) || (lcid > Nlc))
02729 {
02730 sprintf(errmsg, "Line %ld, col %ld, file %s: loadcase index out of range <1,%ld>", in->line, in->col, in->fname, Nlc);
02731 print_err(errmsg, __FILE__, __LINE__, __func__);
02732 delete [] setnodes;
02733 delete [] line;
02734 delete [] col;
02735 return 2;
02736 }
02737 lcid--;
02738 xfscanf(in, "%k", "load_comp");
02739
02740 ndof = Top->get_ndofn(prop, ent, Nod_ndof, setnodes);
02741 if (ndof == 0)
02742 {
02743 sprintf(errmsg, "Nodes with property %ld belonging to entity %s\n"
02744 " have different number of dofs. Nodal time dependent load \n"
02745 " (line %ld, column %ld, file %s) cannot be assigned correctly.",
02746 prop, entitypstr[ent-1].alias, aline, acol, in->fname);
02747 print_err(errmsg, __FILE__, __LINE__, __func__);
02748 delete [] setnodes;
02749 delete [] line;
02750 delete [] col;
02751 return 3;
02752 }
02753 if (ndof == -1)
02754 {
02755 if (Check_unused_prop == 0)
02756
02757 continue;
02758 sprintf(errmsg, "Nodes with property %ld belonging to entity %s have not been found.\n"
02759 " Nodal time dependent load (line %ld, column %ld, file %s) cannot be assigned correctly.",
02760 prop, entitypstr[ent-1].alias, aline, acol, in->fname);
02761 print_err(errmsg, __FILE__, __LINE__, __func__);
02762 delete [] setnodes;
02763 delete [] line;
02764 delete [] col;
02765 return 4;
02766 }
02767 force = new gfunct[ndof];
02768 for (k = 0; k < ndof; k++)
02769 force[k].read(in);
02770
02771 in->kwdmode = bkwdmode;
02772
02773 for (k=0; k<Top->nn; k++)
02774 {
02775 if (setnodes[k] < 0)
02776 continue;
02777 if (Nod_tdload[k][lcid] == NULL)
02778 {
02779 Nod_tdload[k][lcid] = new gfunct[ndof];
02780 for(l=0; l<ndof; l++)
02781 Nod_tdload[k][lcid][l].copy(force[k]);
02782
02783 line[k] = aline;
02784 col[k] = acol;
02785 }
02786 else
02787 {
02788 fprintf(Log, "Line %ld, col %ld, file %s: Node %ld has already had assigned load at line %ld, col %ld, file: %s\n", aline, acol, in->fname, k+1, line[k], col[k], in->fname);
02789 for(l=0; l<ndof; l++)
02790 Nod_tdload[k][lcid][l].merge(force[k]);
02791 }
02792 }
02793 delete [] force;
02794 }
02795 }
02796 delete [] setnodes;
02797 delete [] line;
02798 delete [] col;
02799 return 0;
02800 }
02801
02802
02803
02804
02805
02806
02807
02808
02809
02810
02811
02812
02813
02814
02815
02816
02817
02818
02819
02820
02821
02822
02823
02824
02825 long input_nod_initcond(XFILE *in, const enumstr nodsects[], long nsect)
02826 {
02827 char *aptr;
02828 long nkwd;
02829 char emsg[1001];
02830 long *line;
02831 long *col;
02832 long aline, acol;
02833 gentity ent;
02834 kwd_handling bkwdmode;
02835 long *setnodes;
02836 inicd *tic;
02837 long check;
02838 long i, j, k, lcid, prop;
02839 long nini;
02840 long prop_used;
02841
02842 Nod_inicd = new inicd**[Top->nn];
02843 memset(Nod_inicd, 0, sizeof(*Nod_inicd)*Top->nn);
02844 for(i=0; i<Top->nn; i++)
02845 {
02846 Nod_inicd[i] = new inicd*[Nlc];
02847 memset(Nod_inicd[i], 0, sizeof(*Nod_inicd[i])*Nlc);
02848 }
02849 setnodes = new long[Top->nn];
02850 memset(setnodes, 0, sizeof(*setnodes)*Top->nn);
02851 line = new long[Top->nn];
02852 memset(line, 0, sizeof(*line)*Top->nn);
02853 col = new long[Top->nn];
02854 memset(col, 0, sizeof(*col)*Top->nn);
02855
02856 bkwdmode = in->kwdmode;
02857 in->ignorecase = 1;
02858
02859 fprintf(stdout, "\n reading of nodal initial conditions");
02860
02861 for (i=nsect-1, ent=gregion; i>=0; i--, ent--)
02862 {
02863
02864 if (xf_setsec(in, nodsects[i]) == 1)
02865 continue;
02866
02867 in->kwdmode = sect_mode_full;
02868 nkwd = getkwd_sect(in, NULL, aptr, "nod_inicond", 1);
02869 in->kwdmode = bkwdmode;
02870
02871 for(j=0; j < nkwd; j++)
02872 {
02873
02874 in->kwdmode = sect_mode_fwd;
02875 getkwd_sect(in, NULL, aptr, "nod_inicond", 0);
02876 in->kwdmode = bkwdmode;
02877
02878 aline = in->line;
02879 acol = in->col;
02880 in->kwdmode = sect_mode_seq;
02881
02882 xfscanf(in, "%k%k%ld%k%ld", "nod_inicond", "propid", &prop, "lc_id", &lcid);
02883 if ((lcid < 1) || (lcid > Nlc))
02884 {
02885 sprintf(emsg, "Line %ld, col %ld, file %s: loadcase index out of range <1,%ld>", in->line, in->col, in->fname, Nlc);
02886 print_err(emsg, __FILE__, __LINE__, __func__);
02887 delete [] setnodes;
02888 delete [] line;
02889 delete [] col;
02890 return 1;
02891 }
02892 lcid--;
02893 xfscanf(in, "%k", "cond");
02894 tic = new inicd;
02895 tic->read(in);
02896
02897 in->kwdmode = bkwdmode;
02898
02899
02900 Top->get_propent_nodes(prop, ent, setnodes);
02901 prop_used = 0;
02902 for (k=0; k<Top->nn; k++)
02903 {
02904 if (setnodes[k] < 0)
02905 continue;
02906 if (Nod_inicd[k][lcid] == NULL)
02907 {
02908 Nod_inicd[k][lcid] = new inicd;
02909 Nod_inicd[k][lcid]->copy(*tic);
02910
02911 line[k] = aline;
02912 col[k] = acol;
02913 }
02914 else
02915 {
02916 check = Nod_inicd[k][lcid]->merge(*tic);
02917 if (check)
02918 {
02919 sprintf(emsg, "Line %ld, col %ld, file %s: Node %ld has assigned two different types of "
02920 "initial condition at line %ld, col %ld, file: %s\n", aline, acol, in->fname, k+1, line[k], col[k], in->fname);
02921 print_err(emsg, __FILE__, __LINE__, __func__);
02922 delete [] setnodes;
02923 delete [] line;
02924 delete [] col;
02925 return 2;
02926 }
02927 else
02928 fprintf(Log, "Line %ld, col %ld, file %s: Node %ld has already had assigned initial condition at line %ld, col %ld, file: %s\n", aline, acol, in->fname, k+1, line[k], col[k], in->fname);
02929 }
02930 prop_used = 1;
02931 }
02932 delete tic;
02933 if (Check_unused_prop && (prop_used == 0))
02934 {
02935
02936 sprintf(emsg, "Nodes with property %ld belonging to entity %s have not been found.\n"
02937 " Nodal intial conditions (line %ld, column %ld, file %s) cannot be assigned correctly.",
02938 prop, entitypstr[ent-1].alias, aline, acol, in->fname);
02939 print_err(emsg, __FILE__, __LINE__, __func__);
02940 delete [] line;
02941 delete [] col;
02942 return 3;
02943 }
02944 }
02945 }
02946
02947
02948
02949 for (i=0; i<Nlc; i++)
02950 {
02951 nini = 0;
02952 for (j=0; j<Top->nn; j++)
02953 {
02954 if (Nod_inicd[j][i])
02955 nini++;
02956 }
02957 if ((nini > 0) && (nini < Top->nn))
02958 {
02959 sprintf(emsg, "number of initial conditions for loadcase %ld is less then number of nodes", i+1);
02960 print_err(emsg, __FILE__, __LINE__, __func__);
02961 delete [] setnodes;
02962 delete [] line;
02963 delete [] col;
02964 return 3;
02965 }
02966 }
02967 delete [] setnodes;
02968 delete [] line;
02969 delete [] col;
02970 return 0;
02971 }
02972
02973
02974
02975
02976
02977
02978
02979
02980
02981
02982
02983
02984
02985
02986
02987
02988
02989
02990
02991
02992
02993
02994
02995
02996 long input_nod_temper(XFILE *in, const enumstr nodsects[], long nsect)
02997 {
02998 char *aptr;
02999 char emsg[1001];
03000 long nkwd;
03001 long *line;
03002 long *col;
03003 long aline, acol;
03004 gentity ent;
03005 kwd_handling bkwdmode;
03006 long *setnodes;
03007 tempload *tl;
03008 long prop;
03009 long check, tnlc;
03010 long i, j, k, id;
03011 long prop_used;
03012
03013 tnlc = Nlc;
03014 if (Tnslc)
03015 tnlc = Tnslc;
03016
03017 Ntempl = 0;
03018 Nod_temper = new tempload**[Top->nn];
03019 memset(Nod_temper, 0, sizeof(*Nod_temper)*Top->nn);
03020 for(i=0; i<Top->nn; i++)
03021 {
03022 Nod_temper[i] = new tempload*[tnlc];
03023 memset(Nod_temper[i], 0, sizeof(*Nod_temper[i])*tnlc);
03024 }
03025 setnodes = new long[Top->nn];
03026 memset(setnodes, 0, sizeof(*setnodes)*Top->nn);
03027 line = new long[Top->nn];
03028 memset(line, 0, sizeof(*line)*Top->nn);
03029 col = new long[Top->nn];
03030 memset(col, 0, sizeof(*col)*Top->nn);
03031
03032 bkwdmode = in->kwdmode;
03033 in->ignorecase = 1;
03034
03035 fprintf(stdout, "\n reading temperature load at nodes");
03036
03037 for (i=nsect-1, ent=gregion; i>=0; i--, ent--)
03038 {
03039
03040 if (xf_setsec(in, nodsects[i]) == 1)
03041 continue;
03042
03043 in->kwdmode = sect_mode_full;
03044 nkwd = getkwd_sect(in, NULL, aptr, "nod_temper", 1);
03045 in->kwdmode = bkwdmode;
03046 if (nkwd)
03047 Ntempl = 1;
03048
03049 for(j=0; j < nkwd; j++)
03050 {
03051
03052 in->kwdmode = sect_mode_fwd;
03053 getkwd_sect(in, NULL, aptr, "nod_temper", 0);
03054 in->kwdmode = bkwdmode;
03055
03056 aline = in->line;
03057 acol = in->col;
03058 in->kwdmode = sect_mode_seq;
03059
03060 xfscanf(in, "%k%k%ld", "nod_temper", "propid", &prop);
03061 tl = new tempload;
03062 check = tl->read(in, Nlc, Nslc);
03063 if (check)
03064 {
03065 sprintf(emsg, "Line %ld, col %ld, file %s: wrong loadcase/subloadcase index", in->line, in->col, in->fname);
03066 print_err(emsg, __FILE__, __LINE__, __func__);
03067 delete [] setnodes;
03068 delete [] line;
03069 delete [] col;
03070 return 1;
03071 }
03072
03073 id = tl->nlc-1;
03074 if (Tnslc)
03075 id = Nslc_cum[tl->nlc-1]+tl->nslc-1;
03076
03077 if ((Tlt[id] < 1) || (Tlt[id] > 2))
03078 {
03079 sprintf(emsg, "Line %ld, col %ld, file %s: wrong temperature load type (%ld) is required\n for load case %ld", in->line, in->col, in->fname, Tlt[id], tl->nlc);
03080 if (Nslc[tl->nlc-1])
03081 sprintf(emsg+strlen(emsg), ", subloadcase %ld (it should be 1 or 2)", tl->nslc);
03082 print_err(emsg, __FILE__, __LINE__, __func__);
03083 delete [] setnodes;
03084 delete [] line;
03085 delete [] col;
03086 return 2;
03087 }
03088
03089 in->kwdmode = bkwdmode;
03090
03091
03092 Top->get_propent_nodes(prop, ent, setnodes);
03093 prop_used = 0;
03094 for (k=0; k<Top->nn; k++)
03095 {
03096 if (setnodes[k] < 0)
03097 continue;
03098 if (Nod_temper[k][Nslc_cum[tl->nlc-1]+tl->nslc-1] == NULL)
03099 {
03100 Nod_temper[k][Nslc_cum[tl->nlc-1]+tl->nslc-1] = new tempload;
03101 Nod_temper[k][Nslc_cum[tl->nlc-1]+tl->nslc-1]->copy(*tl);
03102 prop_used = 1;
03103
03104 line[k] = aline;
03105 col[k] = acol;
03106 }
03107 else
03108 {
03109 Nod_temper[k][Nslc_cum[tl->nlc-1]+tl->nslc-1]->copy(*tl);
03110 fprintf(Log, "Line %ld, col %ld, file %s: Node %ld has already had assigned temperature at line %ld, col %ld, file: %s\n", aline, acol, in->fname, k+1, line[k], col[k], in->fname);
03111 }
03112 }
03113 delete tl;
03114 if (Check_unused_prop && (prop_used == 0))
03115 {
03116
03117 sprintf(emsg, "Nodes with property %ld belonging to entity %s have not been found.\n"
03118 " Nodal temperatures (line %ld, column %ld, file %s) cannot be assigned correctly.",
03119 prop, entitypstr[ent-1].alias, aline, acol, in->fname);
03120 print_err(emsg, __FILE__, __LINE__, __func__);
03121 delete [] line;
03122 delete [] col;
03123 return 3;
03124 }
03125 }
03126 }
03127 delete [] setnodes;
03128 delete [] line;
03129 delete [] col;
03130 return 0;
03131 }
03132
03133
03134
03135
03136
03137
03138
03139
03140
03141
03142
03143
03144
03145
03146
03147
03148
03149
03150
03151
03152
03153
03154
03155
03156
03157
03158
03159 long input_elem_type(XFILE *in, const enumstr elemsects[], long nsect)
03160 {
03161 char *aptr;
03162 long nkwd;
03163 char errmsg[1001];
03164 long *line;
03165 long *col;
03166 long aline, acol;
03167 gentity ent;
03168 kwd_handling bkwdmode;
03169 long i, j, k;
03170 elemtype tmp_type;
03171 strastrestate tmp_ssst;
03172 long prop;
03173 long sres;
03174 long prop_used;
03175 long *entid;
03176 long nentid;
03177
03178 fprintf(stdout, "\n reading of element types");
03179 El_type = new elemtype[Top->ne];
03180 memset(El_type, 0, sizeof(*El_type)*Top->ne);
03181 El_ssst = new strastrestate[Top->ne];
03182 memset(El_ssst, 0, sizeof(*El_ssst)*Top->ne);
03183 line = new long[Top->ne];
03184 memset(line, 0, sizeof(*line)*Top->ne);
03185 col = new long[Top->ne];
03186 memset(col, 0, sizeof(*col)*Top->ne);
03187
03188 bkwdmode = in->kwdmode;
03189 in->ignorecase = 1;
03190
03191 for (i=nsect-1, ent=gregion; i>=0; i--, ent--)
03192 {
03193
03194 if (xf_setsec(in, elemsects[i]) == 1)
03195 continue;
03196
03197 in->kwdmode = sect_mode_full;
03198 nkwd = getkwd_sect(in, NULL, aptr, "el_type", 1);
03199 in->kwdmode = bkwdmode;
03200
03201 for(j=0; j < nkwd; j++)
03202 {
03203
03204 in->kwdmode = sect_mode_fwd;
03205 getkwd_sect(in, NULL, aptr, "el_type", 0);
03206 in->kwdmode = bkwdmode;
03207
03208 aline = in->line;
03209 acol = in->col;
03210 in->kwdmode = sect_mode_seq;
03211
03212 xfscanf(in, "%k%k%ld%m", "el_type", "propid", &prop, &elemtype_kwdset, &tmp_type);
03213 if ((tmp_type >= planeelementlt) && (tmp_type <= planequadcontact))
03214 xfscanf(in, "%k%m", "strastrestate", &strastrestate_kwdset, &tmp_ssst);
03215
03216 in->kwdmode = bkwdmode;
03217
03218 prop_used = 0;
03219
03220 for(k=0; k<Top->ne; k++)
03221 {
03222 entid = NULL;
03223 nentid = 0;
03224 sres = Top->elements[k].searchprop(prop, ent, NULL, k, Top->edges, Top->surfaces, entid, nentid);
03225 if (sres > 0)
03226 {
03227 if ((El_type[k] != 0) && (El_type[k] != tmp_type))
03228 {
03229 sprintf(errmsg, "Different types have been assigned at element %ld\n"
03230 "see input file %s, line %ld, column %ld", k+1, in->fname, aline, acol);
03231 print_err(errmsg, __FILE__, __LINE__, __func__);
03232 delete [] line;
03233 delete [] col;
03234 return 1;
03235 }
03236 if (El_type[k] == tmp_type)
03237 fprintf(Log, "Line %ld, col %ld, file %s: Element %ld has already assigned type at line %ld, col %ld, file: %s\n", aline, acol, in->fname, k+1, line[k], col[k], in->fname);
03238 El_type[k] = tmp_type;
03239 prop_used = 1;
03240 if ((tmp_type >= planeelementlt) && (tmp_type <= planequadcontact))
03241 {
03242 if ((El_ssst[k] != 0) && (El_ssst[k] != tmp_ssst))
03243 {
03244 sprintf(errmsg, "Different strain/stress states have been assigned at element %ld\n"
03245 "see input file %s, line %ld, column %ld", k+1, in->fname, aline, acol);
03246 print_err(errmsg, __FILE__, __LINE__, __func__);
03247 delete [] line;
03248 delete [] col;
03249 return 2;
03250 }
03251 if (El_ssst[k] == tmp_ssst)
03252 fprintf(Log, "Line %ld, col %ld, file %s: Element %ld has already assigned ssst at line %ld, col %ld, file: %s\n", aline, acol, in->fname, k+1, line[k], col[k], in->fname);
03253 El_ssst[k] = tmp_ssst;
03254
03255 line[k] = aline;
03256 col[k] = acol;
03257 }
03258 }
03259 if (sres < 0)
03260 {
03261 sprintf(errmsg, "Element %ld has not read property numbers of %s,\n"
03262 " required property cannot be assigned.\n"
03263 " see input file %s, line %ld, column %ld", k+1, entitypstr[ent-1].alias, in->fname, aline, acol);
03264 print_err(errmsg, __FILE__, __LINE__, __func__);
03265 delete [] line;
03266 delete [] col;
03267 return 4;
03268 }
03269 }
03270 if (Check_unused_prop && (prop_used == 0))
03271 {
03272
03273 sprintf(errmsg, "Elements with property %ld belonging to entity %s have not been found.\n"
03274 " Element type (line %ld, column %ld, file %s) cannot be assigned correctly.",
03275 prop, entitypstr[ent-1].alias, aline, acol, in->fname);
03276 print_err(errmsg, __FILE__, __LINE__, __func__);
03277 delete [] line;
03278 delete [] col;
03279 return 5;
03280 }
03281 }
03282 }
03283
03284
03285 for(i=0; i<Top->ne; i++)
03286 {
03287 if (El_type[i] == 0)
03288 {
03289 sprintf(errmsg, "Element %ld has not assigned a type", i+1);
03290 print_err(errmsg, __FILE__, __LINE__, __func__);
03291 delete [] line;
03292 delete [] col;
03293 return 3;
03294 }
03295 }
03296 delete [] line;
03297 delete [] col;
03298
03299 return 0;
03300 }
03301
03302
03303
03304
03305
03306
03307
03308
03309
03310
03311
03312
03313
03314
03315
03316
03317
03318
03319
03320
03321
03322
03323
03324
03325
03326
03327 long input_elem_mat(XFILE *in, const enumstr elemsects[], long nsect)
03328 {
03329 char *aptr;
03330 long nkwd;
03331 char errmsg[1001];
03332 long *line;
03333 long *col;
03334 long aline, acol;
03335 gentity ent;
03336 kwd_handling bkwdmode;
03337 long i, j, k, l, err;
03338 mattype *tmp_type;
03339 long *tmp_id, *ic;
03340 long prop, nmat;
03341 long sres;
03342 long prop_used;
03343 long *entid;
03344 long nentid;
03345
03346 fprintf(stdout, "\n reading of element material types");
03347 El_nmat = new long[Top->ne];
03348 memset(El_nmat, 0, sizeof(*El_nmat)*Top->ne);
03349 El_mattype = new mattype*[Top->ne];
03350 memset(El_mattype, 0, sizeof(*El_mattype)*Top->ne);
03351 El_matid = new long*[Top->ne];
03352 memset(El_matid, 0, sizeof(*El_matid)*Top->ne);
03353 El_matdbi = new long*[Top->ne];
03354 memset(El_matdbi, 0, sizeof(*El_matdbi)*Top->ne);
03355 line = new long[Top->ne];
03356 memset(line, 0, sizeof(*line)*Top->ne);
03357 col = new long[Top->ne];
03358 memset(col, 0, sizeof(*col)*Top->ne);
03359
03360 bkwdmode = in->kwdmode;
03361 in->ignorecase = 1;
03362
03363 for (i=nsect-1, ent=gregion; i>=0; i--, ent--)
03364 {
03365
03366 if (xf_setsec(in, elemsects[i]) == 1)
03367 continue;
03368
03369 in->kwdmode = sect_mode_full;
03370 nkwd = getkwd_sect(in, NULL, aptr, "el_mat", 1);
03371 in->kwdmode = bkwdmode;
03372
03373 for(j=0; j < nkwd; j++)
03374 {
03375
03376 in->kwdmode = sect_mode_fwd;
03377 getkwd_sect(in, NULL, aptr, "el_mat", 0);
03378 in->kwdmode = bkwdmode;
03379
03380 aline = in->line;
03381 acol = in->col;
03382 in->kwdmode = sect_mode_seq;
03383
03384 xfscanf(in, "%k%k%ld%k%ld", "el_mat", "propid", &prop, "num_mat", &nmat);
03385 if (nmat<=0)
03386 {
03387 print_err("number of material types is <= 0", __FILE__, __LINE__, __func__);
03388 delete [] line;
03389 delete [] col;
03390 return 1;
03391 }
03392 else
03393 {
03394 tmp_type = new mattype[nmat];
03395 memset(tmp_type, 0, sizeof(*tmp_type)*nmat);
03396 tmp_id = new long[nmat];
03397 memset(tmp_id, 0, sizeof(*tmp_id)*nmat);
03398 ic = new long[nmat];
03399 memset(ic, 0, sizeof(*ic)*nmat);
03400 }
03401 for (k=0; k<nmat; k++)
03402 {
03403 xfscanf(in, "%k%m%k%ld", "type", &mattype_kwdset, tmp_type+k, "type_id", tmp_id+k);
03404
03405 ic[k] = Dbmat->search_mat(tmp_type[k], tmp_id[k]-1);
03406 if (ic[k] < 0)
03407 {
03408 sprintf(errmsg, "Line %ld, col %ld, file %s: cannot find %ld. required material in the database", in->line, in->col, in->fname, k+1);
03409 print_err(errmsg, __FILE__, __LINE__, __func__);
03410 delete [] tmp_type;
03411 delete [] tmp_id;
03412 delete [] ic;
03413 delete [] line;
03414 delete [] col;
03415 return 1;
03416 }
03417 else
03418 Dbmat->mark_used(ic[k], tmp_id[k]-1);
03419 }
03420
03421 in->kwdmode = bkwdmode;
03422
03423 prop_used = 0;
03424
03425 for(k=0; k<Top->ne; k++)
03426 {
03427 entid = NULL;
03428 nentid = 0;
03429 sres = Top->elements[k].searchprop(prop, ent, NULL, k, Top->edges, Top->surfaces, entid, nentid);
03430 if (sres > 0)
03431 {
03432 prop_used = 1;
03433 if (El_nmat[k] != 0)
03434 {
03435 err = 0;
03436 if (nmat != El_nmat[k])
03437 err = 1;
03438 for (l=0; (l<nmat) && (err==0); l++)
03439 {
03440 if ((tmp_type[l] != El_mattype[k][l]) || (tmp_id[l] != El_matid[k][l]))
03441 err = 1;
03442 }
03443 if (err)
03444 {
03445 sprintf(errmsg, "Different material types have been assigned at element %ld\n"
03446 "see input file %s, line %ld, column %ld", k+1, in->fname, aline, acol);
03447 print_err(errmsg, __FILE__, __LINE__, __func__);
03448 delete [] tmp_type;
03449 delete [] tmp_id;
03450 delete [] ic;
03451 delete [] line;
03452 delete [] col;
03453 return 2;
03454 }
03455 else
03456 fprintf(Log, "Line %ld, col %ld, file %s: Element %ld has already assigned material type at line %ld, col %ld, file: %s\n", aline, acol, in->fname, k+1, line[k], col[k], in->fname);
03457 }
03458 else
03459 {
03460 El_mattype[k] = new mattype[nmat];
03461 El_matid[k] = new long[nmat];
03462 El_matdbi[k] = new long[nmat];
03463 El_nmat[k] = nmat;
03464 for(l=0; l<nmat; l++)
03465 {
03466 El_mattype[k][l] = tmp_type[l];
03467 El_matid[k][l] = tmp_id[l];
03468 El_matdbi[k][l] = ic[l];
03469 }
03470
03471 line[k] = aline;
03472 col[k] = acol;
03473 }
03474 }
03475 if (sres < 0)
03476 {
03477 sprintf(errmsg, "Element %ld has not read property numbers of %s,\n"
03478 " required property cannot be assigned.\n"
03479 " see input file %s, line %ld, column %ld", k+1, entitypstr[ent-1].alias, in->fname, aline, acol);
03480 print_err(errmsg, __FILE__, __LINE__, __func__);
03481 delete [] tmp_type;
03482 delete [] tmp_id;
03483 delete [] ic;
03484 delete [] line;
03485 delete [] col;
03486 return 3;
03487 }
03488 }
03489 delete [] tmp_type;
03490 delete [] tmp_id;
03491 delete [] ic;
03492 if (Check_unused_prop && (prop_used == 0))
03493 {
03494
03495 sprintf(errmsg, "Elements with property %ld belonging to entity %s have not been found.\n"
03496 " Element material type (line %ld, column %ld, file %s) cannot be assigned correctly.",
03497 prop, entitypstr[ent-1].alias, aline, acol, in->fname);
03498 print_err(errmsg, __FILE__, __LINE__, __func__);
03499 delete [] line;
03500 delete [] col;
03501 return 4;
03502 }
03503 }
03504 }
03505
03506
03507 for(i=0; i<Top->ne; i++)
03508 {
03509 if (El_mattype[i] == NULL)
03510 {
03511 sprintf(errmsg, "Element %ld has not assigned a material type", i+1);
03512 print_err(errmsg, __FILE__, __LINE__, __func__);
03513 delete [] line;
03514 delete [] col;
03515 return 2;
03516 }
03517 }
03518 delete [] line;
03519 delete [] col;
03520
03521 return 0;
03522 }
03523
03524
03525
03526
03527
03528
03529
03530
03531
03532
03533
03534
03535
03536
03537
03538
03539
03540
03541
03542
03543
03544
03545
03546
03547
03548 long input_elem_crsec(XFILE *in, const enumstr elemsects[], long nsect)
03549 {
03550 char *aptr;
03551 long nkwd;
03552 char errmsg[1001];
03553 long *line;
03554 long *col;
03555 long aline, acol;
03556 gentity ent;
03557 kwd_handling bkwdmode;
03558 long i, j, k, ic;
03559 crsectype tmp_type;
03560 long prop, tmp_id;
03561 long sres;
03562 long prop_used;
03563 long *entid;
03564 long nentid;
03565
03566 fprintf(stdout, "\n reading of element cross-section types");
03567 El_cst = new crsectype[Top->ne];
03568 memset(El_cst, 0, sizeof(*El_cst)*Top->ne);
03569 El_csti = new long[Top->ne];
03570 memset(El_csti, 0, sizeof(*El_csti)*Top->ne);
03571 El_cstdbi = new long[Top->ne];
03572 memset(El_cstdbi, 0, sizeof(*El_cstdbi)*Top->ne);
03573 line = new long[Top->ne];
03574 memset(line, 0, sizeof(*line)*Top->ne);
03575 col = new long[Top->ne];
03576 memset(col, 0, sizeof(*col)*Top->ne);
03577
03578 bkwdmode = in->kwdmode;
03579 in->ignorecase = 1;
03580
03581 for (i=nsect-1, ent=gregion; i>=0; i--, ent--)
03582 {
03583
03584 if (xf_setsec(in, elemsects[i]) == 1)
03585 continue;
03586
03587 in->kwdmode = sect_mode_full;
03588 nkwd = getkwd_sect(in, NULL, aptr, "el_crsec", 1);
03589 in->kwdmode = bkwdmode;
03590
03591 for(j=0; j < nkwd; j++)
03592 {
03593
03594 in->kwdmode = sect_mode_fwd;
03595 getkwd_sect(in, NULL, aptr, "el_crsec", 0);
03596 in->kwdmode = bkwdmode;
03597
03598 aline = in->line;
03599 acol = in->col;
03600 in->kwdmode = sect_mode_seq;
03601
03602 xfscanf(in, "%k%k%ld%k%m%k%ld", "el_crsec", "propid", &prop, "type", &crsectype_kwdset, &tmp_type, "type_id", &tmp_id);
03603
03604 ic = Dbcrs->search_crs(tmp_type, tmp_id-1);
03605 if (ic < 0)
03606 {
03607 sprintf(errmsg, "Line %ld, col %ld, file %s: cannot find required cross-section in the database", in->line, in->col, in->fname);
03608 print_err(errmsg, __FILE__, __LINE__, __func__);
03609 delete [] line;
03610 delete [] col;
03611 return 1;
03612 }
03613 else
03614 Dbcrs->mark_used(ic, tmp_id-1);
03615
03616 in->kwdmode = bkwdmode;
03617
03618 prop_used = 0;
03619
03620 for(k=0; k<Top->ne; k++)
03621 {
03622 entid = NULL;
03623 nentid = 0;
03624 sres = Top->elements[k].searchprop(prop, ent, NULL, k, Top->edges, Top->surfaces, entid, nentid);
03625 if (sres > 0)
03626 {
03627 if ((El_cst[k] != 0) && ((El_cst[k] != tmp_type) || (El_csti[k] != tmp_id)))
03628 {
03629 sprintf(errmsg, "Different cross-section types have been assigned at element %ld\n"
03630 "see input file %s, line %ld, column %ld", k+1, in->fname, aline, acol);
03631 print_err(errmsg, __FILE__, __LINE__, __func__);
03632 delete [] line;
03633 delete [] col;
03634 return 2;
03635 }
03636 prop_used = 1;
03637 if (El_cst[k] == tmp_type)
03638 fprintf(Log, "Line %ld, col %ld, file %s: Element %ld has already assigned cross-section type at line %ld, col %ld, file: %s\n", aline, acol, in->fname, k+1, line[k], col[k], in->fname);
03639 else
03640 {
03641 El_cst[k] = tmp_type;
03642 El_csti[k] = tmp_id;
03643 El_cstdbi[k] = ic;
03644
03645 line[k] = aline;
03646 col[k] = acol;
03647 }
03648 }
03649 if (sres < 0)
03650 {
03651 sprintf(errmsg, "Element %ld has not read property numbers of %s,\n"
03652 " required property cannot be assigned.\n"
03653 " see input file %s, line %ld, column %ld", k+1, entitypstr[ent-1].alias, in->fname, aline, acol);
03654 print_err(errmsg, __FILE__, __LINE__, __func__);
03655 delete [] line;
03656 delete [] col;
03657 return 3;
03658 }
03659
03660 }
03661 if (Check_unused_prop && (prop_used == 0))
03662 {
03663
03664 sprintf(errmsg, "Elements with property %ld belonging to entity %s have not been found.\n"
03665 " Element cross-section type (line %ld, column %ld, file %s) cannot be assigned correctly.",
03666 prop, entitypstr[ent-1].alias, aline, acol, in->fname);
03667 print_err(errmsg, __FILE__, __LINE__, __func__);
03668 delete [] line;
03669 delete [] col;
03670 return 4;
03671 }
03672 }
03673 }
03674 delete [] line;
03675 delete [] col;
03676
03677 return 0;
03678 }
03679
03680
03681
03682
03683
03684
03685
03686
03687
03688
03689
03690
03691
03692
03693
03694
03695
03696
03697
03698
03699
03700
03701
03702 long input_elem_lcs(XFILE *in, const enumstr elemsects[], long nsect)
03703 {
03704 char *aptr;
03705 long nkwd;
03706 char errmsg[1001];
03707 long *line;
03708 long *col;
03709 long aline, acol;
03710 gentity ent;
03711 kwd_handling bkwdmode;
03712 long dim;
03713 long i, j, k, l, m;
03714 long check, prop;
03715 vector *basev;
03716 long sres;
03717 long prop_used;
03718 long *entid;
03719 long nentid;
03720
03721 El_lcs = new vector*[Top->ne];
03722 memset(El_lcs, 0, sizeof(*El_lcs)*Top->ne);
03723 line = new long[Top->ne];
03724 memset(line, 0, sizeof(*line)*Top->ne);
03725 col = new long[Top->ne];
03726 memset(col, 0, sizeof(*col)*Top->ne);
03727
03728 bkwdmode = in->kwdmode;
03729 in->ignorecase = 1;
03730
03731 fprintf(stdout, "\n reading of local coordinate systems at elements");
03732
03733 for (i=nsect-1, ent=gregion; i>=0; i--, ent--)
03734 {
03735
03736 if (xf_setsec(in, elemsects[i]) == 1)
03737 continue;
03738
03739 in->kwdmode = sect_mode_full;
03740 nkwd = getkwd_sect(in, NULL, aptr, "el_lcs", 1);
03741 in->kwdmode = bkwdmode;
03742
03743 for(j=0; j < nkwd; j++)
03744 {
03745
03746 in->kwdmode = sect_mode_fwd;
03747 getkwd_sect(in, NULL, aptr, "el_lcs", 0);
03748 in->kwdmode = bkwdmode;
03749
03750 aline = in->line;
03751 acol = in->col;
03752 in->kwdmode = sect_mode_seq;
03753
03754 xfscanf(in, "%k%k%ld", "el_lcs", "propid", &prop);
03755 xfscanf(in, "%k%ld", "dim", &dim);
03756 if ((dim < 2) || (dim > 3))
03757 {
03758 sprintf(errmsg, "Line %ld, col %ld, file %s: Wrong dimension of base vectors (%ld)\n"
03759 "Dimension has to be in range <2,3>\n",
03760 aline, acol, in->fname, dim);
03761 print_err(errmsg, __FILE__, __LINE__, __func__);
03762 delete [] basev;
03763 delete [] line;
03764 delete [] col;
03765 return 1;
03766 }
03767
03768 basev = new vector[dim];
03769 for (k=0; k<dim; k++)
03770 {
03771 allocv(dim, basev[k]);
03772 xfscanf(in, "%k", "basevec");
03773 readv(in, basev[k]);
03774 }
03775
03776 in->kwdmode = bkwdmode;
03777
03778 prop_used = 0;
03779
03780 for (k=0; k<Top->ne; k++)
03781 {
03782 entid = NULL;
03783 nentid = 0;
03784 sres = Top->elements[k].searchprop(prop, ent, NULL, k, Top->edges, Top->surfaces, entid, nentid);
03785 if (sres > 0)
03786 {
03787 prop_used = 1;
03788
03789 if (El_lcs[k] != NULL)
03790 {
03791 check = 1;
03792 for (l=0; l<dim; l++)
03793 {
03794 for(m=0; m<dim; m++)
03795 {
03796 if (El_lcs[k][l][m] != basev[l][m])
03797 {
03798 check = 0;
03799 l = dim;
03800 break;
03801 }
03802 }
03803 }
03804 if (check == 0)
03805 {
03806
03807 sprintf(errmsg, "Line %ld, col %ld, file %s: Element %ld has already had assigned different"
03808 "local coordinate system at line %ld, col %ld, file: %s\n", aline, acol, in->fname,
03809 k+1, line[k], col[k], in->fname);
03810 print_err(errmsg, __FILE__, __LINE__, __func__);
03811 delete [] basev;
03812 delete [] line;
03813 delete [] col;
03814 return 1;
03815 }
03816 }
03817 else
03818 {
03819 El_lcs[k] = new vector[dim];
03820 for (l=0; l<dim; l++)
03821 {
03822 allocv(dim, El_lcs[k][l]);
03823 copyv(basev[l], El_lcs[k][l]);
03824 }
03825
03826 line[k] = aline;
03827 col[k] = acol;
03828 }
03829 }
03830 if (sres < 0)
03831 {
03832 sprintf(errmsg, "Element %ld has not read property numbers of %s,\n"
03833 " required property cannot be assigned.\n"
03834 " see input file %s, line %ld, column %ld", k+1, entitypstr[ent-1].alias, in->fname, aline, acol);
03835 print_err(errmsg, __FILE__, __LINE__, __func__);
03836 delete [] line;
03837 delete [] col;
03838 return 2;
03839 }
03840 }
03841 if (Check_unused_prop && (prop_used == 0))
03842 {
03843
03844 sprintf(errmsg, "Elements with property %ld belonging to entity %s have not been found.\n"
03845 " Element lcs (line %ld, column %ld, file %s) cannot be assigned correctly.",
03846 prop, entitypstr[ent-1].alias, aline, acol, in->fname);
03847 print_err(errmsg, __FILE__, __LINE__, __func__);
03848 delete [] line;
03849 delete [] col;
03850 return 3;
03851 }
03852 delete [] basev;
03853 }
03854 }
03855 delete [] line;
03856 delete [] col;
03857 return 0;
03858 }
03859
03860
03861
03862
03863
03864
03865
03866
03867
03868
03869
03870
03871
03872
03873
03874
03875
03876
03877
03878
03879
03880
03881
03882
03883
03884
03885
03886 long input_elem_load(XFILE *in, const enumstr elemsects[], long nsect)
03887 {
03888 char *aptr;
03889 long nkwd;
03890 char errmsg[1001];
03891 long aline, acol;
03892 gentity ent;
03893 kwd_handling bkwdmode;
03894 long i, j, k;
03895 loadel *tmp;
03896 long lt_id;
03897 long check;
03898 long prop, lcid;
03899 long sres, tnlc;
03900 long prop_used;
03901 long *entid;
03902 long nentid;
03903
03904 fprintf(stdout, "\n reading of element load");
03905 tnlc = Nlc;
03906 if (Tnslc)
03907 tnlc = Tnslc;
03908 El_load = new loadel**[Top->ne];
03909 memset(El_load, 0, sizeof(*El_load)*Top->ne);
03910 El_loadln = new long **[Top->ne];
03911 memset(El_loadln, 0, sizeof(*El_loadln)*Top->ne);
03912 El_loadcol = new long **[Top->ne];
03913 memset(El_loadcol, 0, sizeof(*El_loadcol)*Top->ne);
03914 for(i=0; i<Top->ne; i++)
03915 {
03916 El_load[i] = new loadel*[tnlc];
03917 memset(El_load[i], 0, sizeof(*El_load[i])*tnlc);
03918 El_loadln[i] = new long*[tnlc];
03919 memset(El_loadln[i], 0, sizeof(*El_loadln[i])*tnlc);
03920 El_loadcol[i] = new long*[tnlc];
03921 memset(El_loadcol[i], 0, sizeof(*El_loadcol[i])*tnlc);
03922 }
03923
03924 bkwdmode = in->kwdmode;
03925 in->ignorecase = 1;
03926
03927 for (i=nsect-1, ent=gregion; i>=0; i--, ent--)
03928 {
03929
03930 if (xf_setsec(in, elemsects[i]) == 1)
03931 continue;
03932
03933 in->kwdmode = sect_mode_full;
03934 nkwd = getkwd_sect(in, NULL, aptr, "el_load", 1);
03935 in->kwdmode = bkwdmode;
03936
03937 for(j=0; j < nkwd; j++)
03938 {
03939
03940 in->kwdmode = sect_mode_fwd;
03941 getkwd_sect(in, NULL, aptr, "el_load", 0);
03942 in->kwdmode = bkwdmode;
03943
03944 aline = in->line;
03945 acol = in->col;
03946 in->kwdmode = sect_mode_seq;
03947
03948 xfscanf(in, "%k%k%ld", "el_load", "propid", &prop);
03949 tmp = new loadel;
03950 check = tmp->read_prep(in, Nlc, Nslc);
03951 switch(check)
03952 {
03953 case 0:
03954 break;
03955 case 1:
03956
03957 sprintf(errmsg, "Line %ld, col %ld, file %s: (sub)load case id is out of range", aline, acol, in->fname);
03958 print_err(errmsg, __FILE__, __LINE__, __func__);
03959 return 1;
03960 case 2:
03961
03962 sprintf(errmsg, "Line %ld, col %ld, file %s: unknown type of element load is required", aline, acol, in->fname);
03963 print_err(errmsg, __FILE__, __LINE__, __func__);
03964 delete [] tmp;
03965 return 2;
03966 default:
03967
03968 sprintf(errmsg, "Line %ld, col %ld, file %s: cannot read element load", aline, acol, in->fname);
03969 print_err(errmsg, __FILE__, __LINE__, __func__);
03970 delete [] tmp;
03971 return 2;
03972 }
03973 lt_id = give_lt_id(tmp->tel);
03974 if (lt_id < 0)
03975 {
03976
03977 sprintf(errmsg, "Line %ld, col %ld, file %s: unknown type of element load is required", aline, acol, in->fname);
03978 print_err(errmsg, __FILE__, __LINE__, __func__);
03979 delete [] tmp;
03980 return 2;
03981 }
03982 lcid = tmp->nlc-1;
03983 if (Tnslc)
03984 lcid = Nslc_cum[lcid]+tmp->nslc-1;
03985
03986 in->kwdmode = bkwdmode;
03987
03988 prop_used = 0;
03989
03990 for(k=0; k<Top->ne; k++)
03991 {
03992 entid = NULL;
03993 nentid = 0;
03994 sres = Top->elements[k].searchprop(prop, ent, NULL, k, Top->edges, Top->surfaces, entid, nentid);
03995 if (sres > 0)
03996 {
03997 if (El_load[k][lcid])
03998 {
03999 if (El_loadln[k][lcid][lt_id])
04000 fprintf(Log, "Line %ld, col %ld, file %s: Element %ld has already assigned load at line %ld, col %ld, file: %s\n", aline, acol, in->fname, k+1, El_loadln[k][lcid][lt_id], El_loadcol[k][lcid][lt_id], in->fname);
04001 else
04002 {
04003 El_loadln[k][lcid][lt_id] = aline;
04004 El_loadcol[k][lcid][lt_id] = acol;
04005 }
04006 }
04007 else
04008 {
04009 El_load[k][lcid] = new loadel;
04010
04011 El_loadln[k][lcid] = new long[3];
04012 memset(El_loadln[k][lcid], 0, sizeof(*El_loadln[k][lcid])*3);
04013 El_loadcol[k][lcid] = new long[3];
04014 memset(El_loadcol[k][lcid], 0, sizeof(*El_loadcol[k][lcid])*3);
04015 El_loadln[k][lcid][lt_id] = aline;
04016 El_loadcol[k][lcid][lt_id] = acol;
04017 }
04018 check = El_load[k][lcid]->merge(*tmp);
04019 prop_used = 1;
04020 switch(check)
04021 {
04022 case 0:
04023 break;
04024 case 1:
04025
04026 sprintf(errmsg, "Line %ld, col %ld, file %s:\n Element %ld has already had assigned load "
04027 "with incompatible number of components at line %ld, col %ld, file: %s\n",
04028 aline, acol, in->fname, k+1, El_loadln[k][lcid][lt_id], El_loadcol[k][lcid][lt_id], in->fname);
04029 print_err(errmsg, __FILE__, __LINE__, __func__);
04030 return 3;
04031 case 2:
04032
04033 sprintf(errmsg, "Line %ld, col %ld, file %s:\n Element %ld has already had assigned different "
04034 "type of load at line %ld, col %ld, file: %s\n", aline, acol, in->fname,
04035 k+1, El_loadln[k][lcid][lt_id], El_loadcol[k][lcid][lt_id], in->fname);
04036 print_err(errmsg, __FILE__, __LINE__, __func__);
04037 delete [] tmp;
04038 return 3;
04039 default:
04040
04041 sprintf(errmsg, "Line %ld, col %ld, file %s:\n Element %ld has already had assigned load "
04042 "which cannot be merged at line %ld, col %ld, file: %s\n", aline, acol, in->fname,
04043 k+1, El_loadln[k][lcid][lt_id], El_loadcol[k][lcid][lt_id], in->fname);
04044 print_err(errmsg, __FILE__, __LINE__, __func__);
04045 delete tmp;
04046 return 3;
04047 }
04048 }
04049 if (sres < 0)
04050 {
04051 sprintf(errmsg, "Element %ld has not read property numbers of %s,\n"
04052 " required property cannot be assigned.\n"
04053 " see input file %s, line %ld, column %ld", k+1, entitypstr[ent-1].alias, in->fname, aline, acol);
04054 print_err(errmsg, __FILE__, __LINE__, __func__);
04055 return 4;
04056 }
04057 }
04058 delete tmp;
04059 if (Check_unused_prop && (prop_used == 0))
04060 {
04061
04062 sprintf(errmsg, "Elements with property %ld belonging to entity %s have not been found.\n"
04063 " Element general load (line %ld, column %ld, file %s) cannot be assigned correctly.",
04064 prop, entitypstr[ent-1].alias, aline, acol, in->fname);
04065 print_err(errmsg, __FILE__, __LINE__, __func__);
04066 return 5;
04067 }
04068 }
04069 }
04070
04071 return 0;
04072 }
04073
04074
04075
04076
04077
04078
04079
04080
04081
04082
04083
04084
04085
04086
04087
04088
04089
04090
04091
04092
04093
04094
04095
04096
04097 long input_elem_loadedge(XFILE *in, const enumstr elemsects[], long nsect)
04098 {
04099 char *aptr;
04100 long nkwd;
04101 char errmsg[1001];
04102 long aline, acol;
04103 gentity ent;
04104 kwd_handling bkwdmode;
04105 long i, j, k;
04106 entityload *tmp;
04107 loadel *tmp2;
04108 long lt_id=0;
04109 long check;
04110 long prop, lcid;
04111 long sres, tnlc;
04112 long prop_used;
04113 long *entid;
04114 long nentid;
04115
04116 fprintf(stdout, "\n reading of edge load applied on elements");
04117 tnlc = Nlc;
04118 if (Tnslc)
04119 tnlc = Tnslc;
04120 if (El_load == NULL)
04121 {
04122 El_load = new loadel**[Top->ne];
04123 memset(El_load, 0, sizeof(*El_load)*Top->ne);
04124 El_loadln = new long **[Top->ne];
04125 memset(El_loadln, 0, sizeof(*El_loadln)*Top->ne);
04126 El_loadcol = new long **[Top->ne];
04127 memset(El_loadcol, 0, sizeof(*El_loadcol)*Top->ne);
04128 for(i=0; i<Top->ne; i++)
04129 {
04130 El_load[i] = new loadel*[tnlc];
04131 memset(El_load[i], 0, sizeof(*El_load[i])*tnlc);
04132 El_loadln[i] = new long*[tnlc];
04133 memset(El_loadln[i], 0, sizeof(*El_loadln[i])*tnlc);
04134 El_loadcol[i] = new long*[tnlc];
04135 memset(El_loadcol[i], 0, sizeof(*El_loadcol[i])*tnlc);
04136 }
04137 }
04138
04139 bkwdmode = in->kwdmode;
04140 in->ignorecase = 1;
04141
04142 for (i=nsect-1, ent=gcurve; i>=0; i--, ent--)
04143 {
04144
04145 if (xf_setsec(in, elemsects[i]) == 1)
04146 continue;
04147
04148 in->kwdmode = sect_mode_full;
04149 nkwd = getkwd_sect(in, NULL, aptr, "edge_load", 1);
04150 in->kwdmode = bkwdmode;
04151
04152 for(j=0; j < nkwd; j++)
04153 {
04154
04155 in->kwdmode = sect_mode_fwd;
04156 getkwd_sect(in, NULL, aptr, "edge_load", 0);
04157 in->kwdmode = bkwdmode;
04158
04159 aline = in->line;
04160 acol = in->col;
04161 in->kwdmode = sect_mode_seq;
04162
04163 xfscanf(in, "%k%k%ld", "edge_load", "propid", &prop);
04164 tmp = new entityload;
04165
04166 check = tmp->read(in, Nlc, Nslc);
04167 switch(check)
04168 {
04169 case 0:
04170 break;
04171 case 1:
04172 print_err("invalid load case index", __FILE__, __LINE__, __func__);
04173 delete tmp;
04174 return 1;
04175 case 2:
04176 print_err("unknown type of load direction", __FILE__, __LINE__, __func__);
04177 delete tmp;
04178 return 1;
04179 case 3:
04180 print_err("wrong number of parameters of load distribution function", __FILE__, __LINE__, __func__);
04181 delete tmp;
04182 return 1;
04183 case 4:
04184 print_err("wrong names of parameters of load distribution function", __FILE__, __LINE__, __func__);
04185 delete tmp;
04186 return 1;
04187 case 5:
04188 print_err("unknown type of load distribution function", __FILE__, __LINE__, __func__);
04189 delete tmp;
04190 return 1;
04191 }
04192 lcid = tmp->nlc-1;
04193 if (Tnslc)
04194 lcid = Nslc_cum[lcid]+tmp->nslc-1;
04195
04196 in->kwdmode = bkwdmode;
04197
04198 prop_used = 0;
04199
04200 for(k=0; k<Top->ne; k++)
04201 {
04202 entid = NULL;
04203 nentid = 0;
04204 sres = Top->elements[k].searchprop(prop, ent, NULL, k, Top->edges, Top->surfaces, entid, nentid);
04205 if (sres > 0)
04206 {
04207 if (El_load[k][lcid])
04208 {
04209 if (El_loadln[k][lcid][0])
04210 fprintf(Log, "Line %ld, col %ld, file %s: Element %ld has already assigned load at line %ld, col %ld, file: %s\n", aline, acol, in->fname, k+1, El_loadln[k][lcid][lt_id], El_loadcol[k][lcid][lt_id], in->fname);
04211 else
04212 {
04213 El_loadln[k][lcid][lt_id] = aline;
04214 El_loadcol[k][lcid][lt_id] = acol;
04215 }
04216 }
04217 else
04218 {
04219 El_load[k][lcid] = new loadel;
04220
04221 El_loadln[k][lcid] = new long[3];
04222 memset(El_loadln[k][lcid], 0, sizeof(*El_loadln[k][lcid])*3);
04223 El_loadcol[k][lcid] = new long[3];
04224 memset(El_loadcol[k][lcid], 0, sizeof(*El_loadcol[k][lcid])*3);
04225 El_loadln[k][lcid][lt_id] = aline;
04226 El_loadcol[k][lcid][lt_id] = acol;
04227 }
04228 tmp2 = tmp->edge2loadel(Top->elements[k], prop, Top->nodes, entid, nentid);
04229 if (tmp2 == NULL)
04230 {
04231 print_err("unknown type of load function is required", __FILE__, __LINE__, __func__);
04232 delete tmp;
04233 return 1;
04234 }
04235
04236 check = El_load[k][lcid]->merge(*tmp2);
04237 prop_used = 1;
04238 switch(check)
04239 {
04240 case 0:
04241 break;
04242 case 1:
04243
04244 sprintf(errmsg, "Line %ld, col %ld, file %s:\n Element %ld has already had assigned load "
04245 "with incompatible number of components at line %ld, col %ld, file: %s\n",
04246 aline, acol, in->fname, k+1, El_loadln[k][lcid][lt_id], El_loadcol[k][lcid][lt_id], in->fname);
04247 print_err(errmsg, __FILE__, __LINE__, __func__);
04248 delete tmp;
04249 delete tmp2;
04250 return 1;
04251 case 2:
04252
04253 sprintf(errmsg, "Line %ld, col %ld, file %s:\n Element %ld has already had assigned different "
04254 "type of load at line %ld, col %ld, file: %s\n", aline, acol, in->fname,
04255 k+1, El_loadln[k][lcid][lt_id], El_loadcol[k][lcid][lt_id], in->fname);
04256 print_err(errmsg, __FILE__, __LINE__, __func__);
04257 delete tmp;
04258 delete tmp2;
04259 return 1;
04260 default:
04261
04262 sprintf(errmsg, "Line %ld, col %ld, file %s:\n Element %ld has already had assigned load "
04263 "which cannot be merged at line %ld, col %ld, file: %s\n", aline, acol, in->fname,
04264 k+1, El_loadln[k][lcid][lt_id], El_loadcol[k][lcid][lt_id], in->fname);
04265 print_err(errmsg, __FILE__, __LINE__, __func__);
04266 delete tmp;
04267 delete tmp2;
04268 return 1;
04269 }
04270 delete tmp2;
04271 }
04272 if (sres < 0)
04273 {
04274 sprintf(errmsg, "Element %ld has not read property numbers of %s,\n"
04275 " required property cannot be assigned.\n"
04276 " see input file %s, line %ld, column %ld", k+1, entitypstr[ent-1].alias, in->fname, aline, acol);
04277 print_err(errmsg, __FILE__, __LINE__, __func__);
04278 return 3;
04279 }
04280 }
04281 delete tmp;
04282 if (Check_unused_prop && (prop_used == 0))
04283 {
04284
04285 sprintf(errmsg, "Elements with property %ld belonging to entity %s have not been found.\n"
04286 " Element edge load (line %ld, column %ld, file %s) cannot be assigned correctly.",
04287 prop, entitypstr[ent-1].alias, aline, acol, in->fname);
04288 print_err(errmsg, __FILE__, __LINE__, __func__);
04289 return 4;
04290 }
04291 }
04292 }
04293
04294 return 0;
04295 }
04296
04297
04298
04299
04300
04301
04302
04303
04304
04305
04306
04307
04308
04309
04310
04311
04312
04313
04314
04315
04316
04317
04318
04319
04320 long input_elem_loadsurf(XFILE *in, const enumstr elemsects[], long nsect)
04321 {
04322 char *aptr;
04323 long nkwd;
04324 char errmsg[1001];
04325 long aline, acol;
04326 gentity ent;
04327 kwd_handling bkwdmode;
04328 long i, j, k;
04329 entityload *tmp;
04330 loadel *tmp2;
04331 long lt_id=1;
04332 long check;
04333 long prop, lcid;
04334 long sres, tnlc;
04335 long prop_used;
04336 long *entid;
04337 long nentid;
04338
04339 fprintf(stdout, "\n reading of surface load applied on elements");
04340 tnlc = Nlc;
04341 if (Tnslc)
04342 tnlc = Tnslc;
04343 if (El_load == NULL)
04344 {
04345 El_load = new loadel**[Top->ne];
04346 memset(El_load, 0, sizeof(*El_load)*Top->ne);
04347 El_loadln = new long **[Top->ne];
04348 memset(El_loadln, 0, sizeof(*El_loadln)*Top->ne);
04349 El_loadcol = new long **[Top->ne];
04350 memset(El_loadcol, 0, sizeof(*El_loadcol)*Top->ne);
04351 for(i=0; i<Top->ne; i++)
04352 {
04353 El_load[i] = new loadel*[tnlc];
04354 memset(El_load[i], 0, sizeof(*El_load[i])*tnlc);
04355 El_loadln[i] = new long*[tnlc];
04356 memset(El_loadln[i], 0, sizeof(*El_loadln[i])*tnlc);
04357 El_loadcol[i] = new long*[tnlc];
04358 memset(El_loadcol[i], 0, sizeof(*El_loadcol[i])*tnlc);
04359 }
04360 }
04361
04362 bkwdmode = in->kwdmode;
04363 in->ignorecase = 1;
04364
04365 for (i=nsect-1, ent=gsurface; i>=0; i--, ent--)
04366 {
04367
04368 if (xf_setsec(in, elemsects[i]) == 1)
04369 continue;
04370
04371 in->kwdmode = sect_mode_full;
04372 nkwd = getkwd_sect(in, NULL, aptr, "surf_load", 1);
04373 in->kwdmode = bkwdmode;
04374
04375 for(j=0; j < nkwd; j++)
04376 {
04377
04378 in->kwdmode = sect_mode_fwd;
04379 getkwd_sect(in, NULL, aptr, "surf_load", 0);
04380 in->kwdmode = bkwdmode;
04381
04382 aline = in->line;
04383 acol = in->col;
04384 in->kwdmode = sect_mode_seq;
04385
04386 xfscanf(in, "%k%k%ld", "surf_load", "propid", &prop);
04387 tmp = new entityload;
04388
04389 check = tmp->read(in, Nlc, Nslc);
04390 switch(check)
04391 {
04392 case 0:
04393 break;
04394 case 1:
04395 print_err("invalid load case index", __FILE__, __LINE__, __func__);
04396 delete tmp;
04397 return 1;
04398 case 2:
04399 print_err("unknown type of load direction", __FILE__, __LINE__, __func__);
04400 delete tmp;
04401 return 1;
04402 case 3:
04403 print_err("wrong number of parameters of load distribution function", __FILE__, __LINE__, __func__);
04404 delete tmp;
04405 return 1;
04406 case 4:
04407 print_err("wrong names of parameters of load distribution function", __FILE__, __LINE__, __func__);
04408 delete tmp;
04409 return 1;
04410 case 5:
04411 print_err("unknown type of load distribution function", __FILE__, __LINE__, __func__);
04412 delete tmp;
04413 return 1;
04414 default:
04415 break;
04416 }
04417 lcid = tmp->nlc-1;
04418 if (Tnslc)
04419 lcid = Nslc_cum[lcid]+tmp->nslc-1;
04420
04421 in->kwdmode = bkwdmode;
04422
04423 prop_used = 0;
04424
04425 for(k=0; k<Top->ne; k++)
04426 {
04427 entid = NULL;
04428 nentid = 0;
04429 sres = Top->elements[k].searchprop(prop, ent, NULL, k, Top->edges, Top->surfaces, entid, nentid);
04430 if (sres > 0)
04431 {
04432 if (El_load[k][lcid])
04433 {
04434 if (El_loadln[k][lcid][1])
04435 fprintf(Log, "Line %ld, col %ld, file %s: Element %ld has already assigned load at line %ld, col %ld, file: %s\n", aline, acol, in->fname, k+1, El_loadln[k][lcid][lt_id], El_loadcol[k][lcid][lt_id], in->fname);
04436 else
04437 {
04438 El_loadln[k][lcid][lt_id] = aline;
04439 El_loadcol[k][lcid][lt_id] = acol;
04440 }
04441 }
04442 else
04443 {
04444 El_load[k][lcid] = new loadel;
04445
04446 El_loadln[k][lcid] = new long[3];
04447 memset(El_loadln[k][lcid], 0, sizeof(*El_loadln[k][lcid])*3);
04448 El_loadcol[k][lcid] = new long[3];
04449 memset(El_loadcol[k][lcid], 0, sizeof(*El_loadcol[k][lcid])*3);
04450 El_loadln[k][lcid][lt_id] = aline;
04451 El_loadcol[k][lcid][lt_id] = acol;
04452 }
04453 tmp2 = tmp->surface2loadel(Top->elements[k], prop, Top->nodes, entid, nentid);
04454 if (tmp2 == NULL)
04455 {
04456 print_err("unknown type of load function is required", __FILE__, __LINE__, __func__);
04457 delete tmp;
04458 return 1;
04459 }
04460
04461 check = El_load[k][lcid]->merge(*tmp2);
04462 prop_used = 1;
04463 switch(check)
04464 {
04465 case 0:
04466 break;
04467 case 1:
04468
04469 sprintf(errmsg, "Line %ld, col %ld, file %s:\n Element %ld has already had assigned load "
04470 "with incompatible number of components at line %ld, col %ld, file: %s\n",
04471 aline, acol, in->fname, k+1, El_loadln[k][lcid][lt_id], El_loadcol[k][lcid][lt_id], in->fname);
04472 print_err(errmsg, __FILE__, __LINE__, __func__);
04473 delete tmp;
04474 delete tmp2;
04475 return 1;
04476 case 2:
04477
04478 sprintf(errmsg, "Line %ld, col %ld, file %s:\n Element %ld has already had assigned different "
04479 "type of load at line %ld, col %ld, file: %s\n", aline, acol, in->fname,
04480 k+1, El_loadln[k][lcid][lt_id], El_loadcol[k][lcid][lt_id], in->fname);
04481 print_err(errmsg, __FILE__, __LINE__, __func__);
04482 delete tmp;
04483 delete tmp2;
04484 return 1;
04485 default:
04486
04487 sprintf(errmsg, "Line %ld, col %ld, file %s:\n Element %ld has already had assigned load "
04488 "which cannot be merged at line %ld, col %ld, file: %s\n", aline, acol, in->fname,
04489 k+1, El_loadln[k][lcid][lt_id], El_loadcol[k][lcid][lt_id], in->fname);
04490 print_err(errmsg, __FILE__, __LINE__, __func__);
04491 delete tmp;
04492 delete tmp2;
04493 return 1;
04494 }
04495 delete tmp2;
04496 }
04497 if (sres < 0)
04498 {
04499 sprintf(errmsg, "Element %ld has not read property numbers of %s,\n"
04500 " required property cannot be assigned.\n"
04501 " see input file %s, line %ld, column %ld", k+1, entitypstr[ent-1].alias, in->fname, aline, acol);
04502 print_err(errmsg, __FILE__, __LINE__, __func__);
04503 return 3;
04504 }
04505 }
04506 delete tmp;
04507 if (Check_unused_prop && (prop_used == 0))
04508 {
04509
04510 sprintf(errmsg, "Elements with property %ld belonging to entity %s have not been found.\n"
04511 " Element surface load (line %ld, column %ld, file %s) cannot be assigned correctly.",
04512 prop, entitypstr[ent-1].alias, aline, acol, in->fname);
04513 print_err(errmsg, __FILE__, __LINE__, __func__);
04514 return 4;
04515 }
04516 }
04517 }
04518
04519 return 0;
04520 }
04521
04522
04523
04524
04525
04526
04527
04528
04529
04530
04531
04532
04533
04534
04535
04536
04537
04538
04539
04540
04541
04542
04543
04544
04545 long input_elem_loadvol(XFILE *in, const enumstr elemsects[], long nsect)
04546 {
04547 char *aptr;
04548 long nkwd;
04549 char errmsg[1001];
04550 long aline, acol;
04551 gentity ent;
04552 kwd_handling bkwdmode;
04553 long i, j, k;
04554 entityload *tmp;
04555 loadel *tmp2;
04556 long check;
04557 long lt_id = 2;
04558 long prop, lcid;
04559 long sres, tnlc;
04560 long prop_used;
04561 long *entid;
04562 long nentid;
04563
04564 fprintf(stdout, "\n reading of volume load applied on elements");
04565 tnlc = Nlc;
04566 if (Tnslc)
04567 tnlc = Tnslc;
04568 if (El_load == NULL)
04569 {
04570 El_load = new loadel**[Top->ne];
04571 memset(El_load, 0, sizeof(*El_load)*Top->ne);
04572 El_loadln = new long **[Top->ne];
04573 memset(El_loadln, 0, sizeof(*El_loadln)*Top->ne);
04574 El_loadcol = new long **[Top->ne];
04575 memset(El_loadcol, 0, sizeof(*El_loadcol)*Top->ne);
04576 for(i=0; i<Top->ne; i++)
04577 {
04578 El_load[i] = new loadel*[Nlc];
04579 memset(El_load[i], 0, sizeof(*El_load[i])*Nlc);
04580 El_loadln[i] = new long*[tnlc];
04581 memset(El_loadln[i], 0, sizeof(*El_loadln[i])*tnlc);
04582 El_loadcol[i] = new long*[tnlc];
04583 memset(El_loadcol[i], 0, sizeof(*El_loadcol[i])*tnlc);
04584 }
04585 }
04586
04587 bkwdmode = in->kwdmode;
04588 in->ignorecase = 1;
04589
04590 for (i=nsect-1, ent=gregion; i>=0; i--, ent--)
04591 {
04592
04593 if (xf_setsec(in, elemsects[i]) == 1)
04594 continue;
04595
04596 in->kwdmode = sect_mode_full;
04597 nkwd = getkwd_sect(in, NULL, aptr, "volume_load", 1);
04598 in->kwdmode = bkwdmode;
04599
04600 for(j=0; j < nkwd; j++)
04601 {
04602
04603 in->kwdmode = sect_mode_fwd;
04604 getkwd_sect(in, NULL, aptr, "volume_load", 0);
04605 in->kwdmode = bkwdmode;
04606
04607 aline = in->line;
04608 acol = in->col;
04609 in->kwdmode = sect_mode_seq;
04610
04611 xfscanf(in, "%k%k%ld", "volume_load", "propid", &prop);
04612 tmp = new entityload;
04613
04614 check = tmp->read(in, Nlc, Nslc);
04615 switch(check)
04616 {
04617 case 0:
04618 break;
04619 case 1:
04620 print_err("invalid load case index", __FILE__, __LINE__, __func__);
04621 delete tmp;
04622 return 1;
04623 case 2:
04624 print_err("unknown type of load direction", __FILE__, __LINE__, __func__);
04625 delete tmp;
04626 return 1;
04627 case 3:
04628 print_err("wrong number of parameters of load distribution function", __FILE__, __LINE__, __func__);
04629 delete tmp;
04630 return 1;
04631 case 4:
04632 print_err("wrong names of parameters of load distribution function", __FILE__, __LINE__, __func__);
04633 delete tmp;
04634 return 1;
04635 case 5:
04636 print_err("unknown type of load distribution function", __FILE__, __LINE__, __func__);
04637 delete tmp;
04638 return 1;
04639 }
04640 lcid = tmp->nlc-1;
04641 if (Tnslc)
04642 lcid = Nslc_cum[lcid]+tmp->nslc-1;
04643
04644 in->kwdmode = bkwdmode;
04645
04646 prop_used = 0;
04647
04648 for(k=0; k<Top->ne; k++)
04649 {
04650 entid = NULL;
04651 nentid = 0;
04652 sres = Top->elements[k].searchprop(prop, ent, NULL, k, Top->edges, Top->surfaces, entid, nentid);
04653 if (sres > 0)
04654 {
04655 if (El_load[k][lcid])
04656 {
04657 if (El_loadln[k][lcid][2])
04658 fprintf(Log, "Line %ld, col %ld, file %s: Element %ld has already assigned load at line %ld, col %ld, file: %s\n", aline, acol, in->fname, k+1, El_loadln[k][lcid][lt_id], El_loadcol[k][lcid][lt_id], in->fname);
04659 else
04660 {
04661 El_loadln[k][lcid][lt_id] = aline;
04662 El_loadcol[k][lcid][lt_id] = acol;
04663 }
04664 }
04665 else
04666 {
04667 El_load[k][lcid] = new loadel;
04668
04669 El_loadln[k][lcid] = new long[3];
04670 memset(El_loadln[k][lcid], 0, sizeof(*El_loadln[k][lcid])*3);
04671 El_loadcol[k][lcid] = new long[3];
04672 memset(El_loadcol[k][lcid], 0, sizeof(*El_loadcol[k][lcid])*3);
04673 El_loadln[k][lcid][lt_id] = aline;
04674 El_loadcol[k][lcid][lt_id] = acol;
04675 }
04676 tmp2 = tmp->vol2loadel(Top->elements[k], prop, Top->nodes);
04677 if (tmp2 == NULL)
04678 {
04679 print_err("unknown type of load function is required", __FILE__, __LINE__, __func__);
04680 delete tmp;
04681 return 1;
04682 }
04683
04684 check = El_load[k][lcid]->merge(*tmp2);
04685 prop_used = 1;
04686 switch(check)
04687 {
04688 case 0:
04689 break;
04690 case 1:
04691
04692 sprintf(errmsg, "Line %ld, col %ld, file %s:\n Element %ld has already had assigned load "
04693 "with incompatible number of components at line %ld, col %ld, file: %s\n",
04694 aline, acol, in->fname, k+1, El_loadln[k][lcid][lt_id], El_loadcol[k][lcid][lt_id], in->fname);
04695 print_err(errmsg, __FILE__, __LINE__, __func__);
04696 delete tmp;
04697 delete tmp2;
04698 return 1;
04699 case 2:
04700
04701 sprintf(errmsg, "Line %ld, col %ld, file %s:\n Element %ld has already had assigned different "
04702 "type of load at line %ld, col %ld, file: %s\n", aline, acol, in->fname,
04703 k+1, El_loadln[k][lcid][lt_id], El_loadcol[k][lcid][lt_id], in->fname);
04704 print_err(errmsg, __FILE__, __LINE__, __func__);
04705 delete tmp;
04706 delete tmp2;
04707 return 1;
04708 default:
04709
04710 sprintf(errmsg, "Line %ld, col %ld, file %s:\n Element %ld has already had assigned load "
04711 "which cannot be merged at line %ld, col %ld, file: %s\n", aline, acol, in->fname,
04712 k+1, El_loadln[k][lcid][lt_id], El_loadcol[k][lcid][lt_id], in->fname);
04713 print_err(errmsg, __FILE__, __LINE__, __func__);
04714 delete tmp;
04715 delete tmp2;
04716 return 1;
04717 }
04718 delete tmp2;
04719 }
04720 if (sres < 0)
04721 {
04722 sprintf(errmsg, "Element %ld has not read property numbers of %s,\n"
04723 " required property cannot be assigned.\n"
04724 " see input file %s, line %ld, column %ld", k+1, entitypstr[ent-1].alias, in->fname, aline, acol);
04725 print_err(errmsg, __FILE__, __LINE__, __func__);
04726 return 3;
04727 }
04728 }
04729 delete tmp;
04730 if (Check_unused_prop && (prop_used == 0))
04731 {
04732
04733 sprintf(errmsg, "Elements with property %ld belonging to entity %s have not been found.\n"
04734 " Element volume load (line %ld, column %ld, file %s) cannot be assigned correctly.",
04735 prop, entitypstr[ent-1].alias, aline, acol, in->fname);
04736 print_err(errmsg, __FILE__, __LINE__, __func__);
04737 return 4;
04738 }
04739 }
04740 }
04741
04742 return 0;
04743 }
04744
04745
04746
04747
04748
04749
04750
04751
04752
04753
04754
04755
04756
04757
04758
04759
04760
04761
04762
04763
04764
04765
04766
04767
04768
04769 long input_elem_eigstr(XFILE *in, const enumstr elemsects[], long nsect)
04770 {
04771 char *aptr;
04772 long nkwd;
04773 long aline, acol;
04774 gentity ent;
04775 kwd_handling bkwdmode;
04776 long i, j, k, l;
04777 gfunct *tmp;
04778 gfunct *tmp2;
04779 long ncomp;
04780 long check;
04781 long *eigstrgf_id;
04782 long prop;
04783 long sres;
04784 long prop_used;
04785 long *entid;
04786 long nentid;
04787 long *line;
04788 long *col;
04789
04790 fprintf(stdout, "\n reading of eigenstrains applied on elements");
04791
04792 line = new long[Top->ne];
04793 memset(line, 0, sizeof(*line)*Top->ne);
04794 col = new long[Top->ne];
04795 memset(col, 0, sizeof(*col)*Top->ne);
04796
04797 bkwdmode = in->kwdmode;
04798 in->ignorecase = 1;
04799 El_eigstr = NULL;
04800
04801 for (i=nsect-1, ent=gregion; i>=0; i--, ent--)
04802 {
04803
04804 if (xf_setsec(in, elemsects[i]) == 1)
04805 continue;
04806
04807 in->kwdmode = sect_mode_full;
04808 nkwd = getkwd_sect(in, NULL, aptr, "el_eigstr", 1);
04809 in->kwdmode = bkwdmode;
04810
04811 for(j=0; j < nkwd; j++)
04812 {
04813 if (El_eigstr == NULL)
04814 {
04815 El_eigstr = new long*[Top->ne];
04816 memset(El_eigstr, 0, sizeof(*El_eigstr)*Top->ne);
04817 }
04818
04819 in->kwdmode = sect_mode_fwd;
04820 getkwd_sect(in, NULL, aptr, "el_eigstr", 0);
04821 in->kwdmode = bkwdmode;
04822
04823 aline = in->line;
04824 acol = in->col;
04825 in->kwdmode = sect_mode_seq;
04826
04827 xfscanf(in, "%k%k%ld%k%ld%k", "el_eigstr", "propid", &prop, "ncomp", &ncomp, "eigstr_comp");
04828
04829 eigstrgf_id = new long[ncomp];
04830 memset(eigstrgf_id, 0, sizeof(*eigstrgf_id)*ncomp);
04831 for (k=0; k<ncomp; k++)
04832 {
04833 tmp = new gfunct;
04834 check = tmp->read(in);
04835 if (check != 0)
04836 {
04837 delete tmp;
04838 return 1;
04839 }
04840 eigstrgf_id[k] = El_eigstrgf_lst.count();
04841 El_eigstrgf_lst.append(tmp);
04842 }
04843
04844 in->kwdmode = bkwdmode;
04845
04846 prop_used = 0;
04847
04848 for(k=0; k<Top->ne; k++)
04849 {
04850 entid = NULL;
04851 nentid = 0;
04852 sres = Top->elements[k].searchprop(prop, ent, NULL, k, Top->edges, Top->surfaces, entid, nentid);
04853 if (sres > 0)
04854 {
04855 if (El_eigstr[k])
04856 {
04857 fprintf(Log, "Line %ld, col %ld, file %s: Element %ld has already assigned the same eigenstrains"
04858 "at line %ld, col %ld, file: %s\n",
04859 aline, acol, in->fname, k+1, line[k], col[k], in->fname);
04860
04861
04862 for(l=0; l<ncomp; l++)
04863 {
04864 tmp = (gfunct *)El_eigstrgf_lst.at(l);
04865 tmp2 = (gfunct *)El_eigstrgf_lst.at(eigstrgf_id[l]);
04866
04867 if (tmp->compare(*tmp2))
04868 {
04869 print_err("Multiple assignment of nonidentical eigenstrain component %ld for element %ld\n"
04870 "at line %ld, col %ld of file '%s' (original component assigned at line %ld, col %ld)",
04871 __FILE__, __LINE__, __func__, l+1, k+1, aline, acol, in->fname, line[k], col[k]);
04872 delete [] line;
04873 delete [] col;
04874 return 2;
04875 }
04876 }
04877 }
04878 else
04879 {
04880
04881
04882 if (Mt->give_tncomp(k) != ncomp)
04883 {
04884 print_err("Element %ld has different number of strain components (%ld)\n"
04885 " than the specified at line %ld, col %ld of file '%s'",
04886 __FILE__, __LINE__, __func__, k+1, Mt->give_tncomp(k), aline, acol, in->fname);
04887 delete [] line;
04888 delete [] col;
04889 return 3;
04890 }
04891
04892 El_eigstr[k] = new long[ncomp];
04893 memcpy(El_eigstr[k], eigstrgf_id, sizeof(*El_eigstr[k])*ncomp);
04894 line[k] = aline;
04895 col[k] = acol;
04896 prop_used = 1;
04897 }
04898 }
04899 if (sres < 0)
04900 {
04901 print_err("Element %ld has not read property numbers of %s,\n"
04902 " required property cannot be assigned.\n"
04903 " see input file %s, line %ld, column %ld",
04904 __FILE__, __LINE__, __func__, k+1, entitypstr[ent-1].alias, in->fname, aline, acol);
04905 delete [] line;
04906 delete [] col;
04907 return 4;
04908 }
04909 }
04910 delete [] eigstrgf_id;
04911 if (Check_unused_prop && (prop_used == 0))
04912 {
04913
04914 print_err("Elements with property %ld belonging to entity %s have not been found.\n"
04915 " Element eigenstrains (line %ld, column %ld, file %s) cannot be assigned correctly.",
04916 __FILE__, __LINE__, __func__, prop, entitypstr[ent-1].alias, aline, acol, in->fname);
04917 delete [] line;
04918 delete [] col;
04919 return 5;
04920 }
04921 }
04922 }
04923 delete [] line;
04924 delete [] col;
04925 return 0;
04926 }
04927
04928
04929
04930
04931
04932
04933
04934
04935
04936
04937
04938
04939
04940
04941
04942
04943
04944
04945
04946
04947
04948
04949
04950
04951
04952 long input_elem_eltimefunc(XFILE *in, const enumstr elemsects[], long nsect)
04953 {
04954 char *aptr;
04955 long nkwd;
04956 char errmsg[1001];
04957 long *line;
04958 long *col;
04959 long aline, acol;
04960 gentity ent;
04961 kwd_handling bkwdmode;
04962 long tf_id, prop;
04963 long i, j, k;
04964 long sres;
04965 long prop_used;
04966 long *entid;
04967 long nentid;
04968
04969 El_tfunc = new long[Top->ne];
04970 memset(El_tfunc, 0, sizeof(*El_tfunc)*Top->ne);
04971 line = new long[Top->ne];
04972 memset(line, 0, sizeof(*line)*Top->ne);
04973 col = new long[Top->ne];
04974 memset(col, 0, sizeof(*col)*Top->ne);
04975
04976 bkwdmode = in->kwdmode;
04977 in->ignorecase = 1;
04978
04979 fprintf(stdout, "\n reading of dof time functions at elements");
04980
04981 for (i=nsect-1, ent=gregion; i>=0; i--, ent--)
04982 {
04983
04984 if (xf_setsec(in, elemsects[i]) == 1)
04985 continue;
04986
04987 in->kwdmode = sect_mode_full;
04988 nkwd = getkwd_sect(in, NULL, aptr, "el_tfunc", 1);
04989 in->kwdmode = bkwdmode;
04990
04991 for(j=0; j < nkwd; j++)
04992 {
04993
04994 in->kwdmode = sect_mode_fwd;
04995 getkwd_sect(in, NULL, aptr, "el_tfunc", 0);
04996 in->kwdmode = bkwdmode;
04997
04998 aline = in->line;
04999 acol = in->col;
05000 in->kwdmode = sect_mode_seq;
05001
05002 xfscanf(in, "%k%k%ld", "el_tfunc", "propid", &prop);
05003 xfscanf(in, "%k%ld", "tfunc_id", &tf_id);
05004 if ((tf_id <= 0) || (tf_id > Gtm->ngf))
05005 {
05006 sprintf(errmsg, "Line %ld, col %ld, file %s:\n Time function index has to be in range <1,%ld>"
05007 "time function at line %ld, col %ld, file: %s\n", aline, acol, in->fname, Gtm->ngf,
05008 line[k], col[k], in->fname);
05009 print_err(errmsg, __FILE__, __LINE__, __func__);
05010 delete [] line;
05011 delete [] col;
05012 return 3;
05013 }
05014 in->kwdmode = bkwdmode;
05015
05016 prop_used = 0;
05017
05018 for(k=0; k<Top->ne; k++)
05019 {
05020 entid = NULL;
05021 nentid = 0;
05022 sres = Top->elements[k].searchprop(prop, ent, NULL, k, Top->edges, Top->surfaces, entid, nentid);
05023 if (sres > 0)
05024 {
05025 if (El_tfunc[k] && (El_tfunc[k]!=tf_id))
05026 {
05027 sprintf(errmsg, "Line %ld, col %ld, file %s:\n Element %ld has already had assigned different"
05028 "time function at line %ld, col %ld, file: %s\n", aline, acol, in->fname,
05029 k+1, line[k], col[k], in->fname);
05030 print_err(errmsg, __FILE__, __LINE__, __func__);
05031 delete [] line;
05032 delete [] col;
05033 return 1;
05034 }
05035 else
05036 {
05037 El_tfunc[k] = tf_id;
05038 prop_used = 1;
05039
05040 line[k] = aline;
05041 col[k] = acol;
05042 }
05043 }
05044 if (sres < 0)
05045 {
05046 sprintf(errmsg, "Element %ld has not read property numbers of %s,\n"
05047 " required property cannot be assigned.\n"
05048 " see input file %s, line %ld, column %ld", k+1, entitypstr[ent-1].alias, in->fname, aline, acol);
05049 print_err(errmsg, __FILE__, __LINE__, __func__);
05050 delete [] line;
05051 delete [] col;
05052 return 2;
05053 }
05054 }
05055 if (Check_unused_prop && (prop_used == 0))
05056 {
05057
05058 sprintf(errmsg, "Elements with property %ld belonging to entity %s have not been found.\n"
05059 " Element time function (line %ld, column %ld, file %s) cannot be assigned correctly.",
05060 prop, entitypstr[ent-1].alias, aline, acol, in->fname);
05061 print_err(errmsg, __FILE__, __LINE__, __func__);
05062 delete [] line;
05063 delete [] col;
05064 return 4;
05065 }
05066 }
05067 }
05068
05069
05070 if (Mp->tprob == growing_mech_structure)
05071 {
05072 for (i=0; i< Top->ne; i++)
05073 {
05074 if (El_tfunc[i] < 1)
05075 {
05076 sprintf(errmsg, "Element %ld has not assigned a time function.\n"
05077 "All elements have to have assigned some time function\n"
05078 "in case of growing mechanical problem", i+1);
05079 print_err(errmsg, __FILE__, __LINE__, __func__);
05080 delete [] line;
05081 delete [] col;
05082 return 3;
05083 }
05084 }
05085 }
05086 delete [] line;
05087 delete [] col;
05088 return 0;
05089 }
05090
05091
05092
05093
05094
05095
05096
05097
05098 const gentity operator --(gentity &a, int)
05099 {
05100 gentity old;
05101 switch (a)
05102 {
05103 case gvertex:
05104 old = a;
05105 a = gregion;
05106 return old;
05107 case gcurve:
05108 old = a;
05109 a = gvertex;
05110 return old;
05111 case gsurface:
05112 old = a;
05113 a = gcurve;
05114 return old;
05115 case gregion:
05116 old = a;
05117 a = gsurface;
05118 return old;
05119 default:
05120 print_err("decreasing of invalid gentity value is required", __FILE__, __LINE__, __func__);
05121 }
05122 return gentity(0);
05123 }
05124
05125
05126
05127
05128
05129
05130
05131
05132
05133
05134
05135
05136
05137
05138
05139
05140
05141
05142 long give_lt_id(elloadtype tel)
05143 {
05144 long ret;
05145 switch(tel)
05146 {
05147 case edge:
05148 ret = 0;
05149 break;
05150 case surface:
05151 ret = 1;
05152 break;
05153 case volume:
05154 ret = 2;
05155 break;
05156 default:
05157 ret = -1;
05158 }
05159 return ret;
05160 }