00001 #include "elemswitch.h"
00002 #include "genfile.h"
00003 #include "global.h"
00004 #include "elemhead.h"
00005 #include "node.h"
00006 #include "element.h"
00007 #include "intpoints.h"
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028 void compute_ipstrains (long lcid)
00029 {
00030 long i,j,ne,te;
00031
00032
00033 Mm->cleanstrain ();
00034
00035
00036 ne=Mt->ne;
00037 for (i=0;i<ne;i++){
00038 if (Gtm->leso[i]==1){
00039
00040
00041
00042 te = Mt->give_elem_type (i);
00043
00044 switch (te){
00045
00046 case bar2d:{
00047 Bar2d->res_ip_strains (lcid,i);
00048 break;
00049 }
00050 case bar3d:{
00051 Bar3d->res_ip_strains (lcid,i);
00052 break;
00053 }
00054 case barq2d:{
00055 Barq2d->res_mainip_strains (lcid,i);
00056 break;
00057 }
00058 case barq3d:{
00059 Barq3d->res_mainip_strains (lcid,i);
00060 break;
00061 }
00062
00063 case beam2d:{
00064 Beam2d->nodal_displ (lcid,i);
00065 break;
00066 }
00067 case beam3d:{
00068 Beam3d->nodal_displ (lcid,i);
00069 break;
00070 }
00071 case beamg3d:{
00072 Beam3dg->nodal_displ (i,lcid);
00073 break;
00074 }
00075 case subsoilbeam:{
00076 Sbeam->strains (lcid, i, 0, 0);
00077 break;
00078 }
00079
00080 case spring_1:{
00081 Spring->strains(i, lcid);
00082 break;
00083 }
00084 case spring_2:{
00085 Spring->strains(i, lcid);
00086 break;
00087 }
00088 case spring_3:{
00089 Spring->strains(i, lcid);
00090 break;
00091 }
00092 case spring_4:{
00093 Spring->strains(i, lcid);
00094 break;
00095 }
00096 case spring_5:{
00097 Spring->strains(i, lcid);
00098 break;
00099 }
00100 case spring_6:{
00101 Spring->strains(i, lcid);
00102 break;
00103 }
00104
00105
00106 case planeelementlt:{
00107 Pelt->res_ip_strains (lcid,i);
00108 break;
00109 }
00110 case planeelementqt:{
00111 Peqt->res_mainip_strains (lcid,i);
00112 break;
00113 }
00114
00115 case planeelementrotlt:{
00116 Perlt->res_ip_strains (lcid,i);
00117 break;
00118 }
00119
00120 case planeelementlq:{
00121 Pelq->res_ip_strains (lcid,i);
00122 break;
00123 }
00124 case planeelementqq:{
00125 Peqq->res_ip_strains (lcid,i);
00126 break;
00127 }
00128 case planeelementrotlq:{
00129 Perlq->res_ip_strains (lcid,i);
00130 break;
00131 }
00132
00133 case planeelementsubqt:{
00134 Pesqt->res_mainip_strains (lcid,i);
00135 break;
00136 }
00137 case planequadcontact:{
00138 Pqcon->res_mainip_strains (lcid,i);
00139 break;
00140 }
00141
00142 case cctel:{
00143 Cct->res_ip_strains (lcid,i);
00144 break;
00145 }
00146 case dktel:{
00147
00148 Dkt->res_ip_strains (lcid,i);
00149 break;
00150 }
00151 case dstel:{
00152 Dst->res_ip_strains (lcid,i);
00153 break;
00154 }
00155 case q4plateel:{
00156 Q4pl->res_ip_strains (lcid,i);
00157 break;
00158 }
00159
00160 case subsoilplatetr:{
00161 Spltr->res_mainip_strains (lcid,i);
00162 break;
00163 }
00164
00165 case subsoilplateq:{
00166 Splq->res_mainip_strains (lcid,i);
00167 break;
00168 }
00169
00170
00171 case shelltrelem:{
00172 Shtr->res_ip_strains (lcid,i);
00173 break;
00174 }
00175 case shellqelem:{
00176 Shq->res_ip_strains (lcid,i);
00177 break;
00178 }
00179
00180
00181 case axisymmlt:{
00182 Asymlt->res_mainip_strains (lcid,i);
00183 break;
00184 }
00185 case axisymmlq:{
00186 Asymlq->res_allip_strains (lcid,i);
00187 break;
00188 }
00189 case axisymmqq:{
00190 Asymqq->res_allip_strains (lcid,i);
00191 break;
00192 }
00193
00194
00195 case lineartet:{
00196 Ltet->res_ip_strains (lcid,i);
00197 break;
00198 }
00199 case quadrtet:{
00200 Qtet->res_ip_strains (lcid,i);
00201 break;
00202 }
00203 case linearhex:{
00204 Lhex->res_ip_strains (lcid,i);
00205 break;
00206 }
00207 case quadrhex:{
00208 Qhex->res_ip_strains (lcid,i);
00209 break;
00210 }
00211 case lineartetrot:{
00212 Ltetrot->res_ip_strains (lcid,i);
00213 break;
00214 }
00215 case linearhexrot:{
00216 Lhexrot->res_ip_strains (lcid,i);
00217 break;
00218 }
00219
00220 case particleelem:{
00221 break;
00222 }
00223 default:{
00224 print_err("unknown element type is required", __FILE__, __LINE__, __func__);
00225 }
00226 }
00227
00228 }
00229 }
00230
00231
00232
00233
00234 Mm->eigstrmod ();
00235
00236 if (Mp->homog == 3){
00237
00238
00239
00240
00241 long ncomp;
00242 double *lhs = Lsrs->give_lhs (0);
00243 ncomp = Mt->give_ncomp (0,0);
00244 vector macrostrains (ncomp);
00245 j=Ndofm-ncomp;
00246 for (i=0;i<ncomp;i++){
00247 macrostrains[i]=lhs[j];
00248 j++;
00249 }
00250 Mm->add_macro_strains (macrostrains);
00251 }
00252
00253 }
00254
00255
00256
00257
00258
00259
00260
00261
00262
00263
00264
00265
00266
00267
00268 void compute_nodestrains (long lcid)
00269 {
00270 long i;
00271 elemtype te;
00272
00273
00274 Mp->detnodstrain = 1;
00275
00276 for (i=0;i<Mt->nn;i++){
00277 Mt->nodes[i].nullstrain (lcid);
00278 }
00279
00280 for (i=0;i<Mt->ne;i++){
00281 if (Gtm->leso[i]==1){
00282
00283 te = Mt->give_elem_type (i);
00284
00285 switch (te){
00286
00287 case bar2d:{
00288 Bar2d->nod_strains_ip (lcid, i, 0, 0);
00289 break;
00290 }
00291 case barq2d:{
00292 Barq2d->nod_strains_ip (lcid,i,0,0);
00293 break;
00294 }
00295 case bar3d:{
00296
00297 break;
00298 }
00299 case barq3d:{
00300
00301 break;
00302 }
00303
00304 case beam2d:{
00305 Beam2d->nodal_displ (lcid,i);
00306 break;
00307 }
00308 case beam3d:{
00309 Beam3d->nodal_displ (lcid,i);
00310 break;
00311 }
00312
00313 case spring_1:
00314 case spring_2:
00315 case spring_3:
00316 case spring_4:
00317 case spring_5:
00318 case spring_6:
00319 break;
00320
00321 case planeelementlt:{
00322 Pelt->nod_strains_ip (lcid,i,0,0);
00323 break;
00324 }
00325 case planeelementqt:{
00326 Peqt->nod_strains (lcid,i,0,0);
00327 break;
00328 }
00329 case planeelementrotlt:{
00330 Perlt->nod_strains_ip (lcid,i,0,0);
00331 break;
00332 }
00333
00334 case planeelementlq:{
00335 Pelq->nod_strains_ip (lcid,i,0,0);
00336 break;
00337 }
00338 case planeelementqq:{
00339 Peqq->nod_strains_ip (lcid,i,0,0);
00340 break;
00341 }
00342 case planeelementrotlq:{
00343
00344 break;
00345 }
00346
00347 case planeelementsubqt:{
00348 Pesqt->nod_strains (lcid,i,0,0);
00349 break;
00350 }
00351
00352 case cctel:{
00353 Cct->nod_strains_ip (lcid,i,0,0);
00354 break;
00355 }
00356 case dktel:{
00357
00358 break;
00359 }
00360 case dstel:{
00361
00362 break;
00363 }
00364 case q4plateel:{
00365
00366 break;
00367 }
00368
00369 case subsoilplatetr:{
00370 break;
00371 }
00372
00373 case subsoilplateq:{
00374
00375 break;
00376 }
00377
00378 case axisymmlt:{
00379 Asymlt->nod_strains_ip (lcid,i);
00380 break;
00381 }
00382 case axisymmlq:{
00383 Asymlq->nod_strains_ip (lcid,i,0,0);
00384 break;
00385 }
00386 case axisymmqq:{
00387 Asymqq->nod_strains_ip (lcid,i);
00388 break;
00389 }
00390
00391 case shelltrelem:{
00392 Shtr->nod_strains_ip (lcid,i);
00393 break;
00394 }
00395 case shellqelem:{
00396 Shq->nod_strains_ip (lcid,i);
00397 break;
00398 }
00399
00400 case lineartet:{
00401 Ltet->nod_strains_ip (lcid,i,0,0);
00402 break;
00403 }
00404 case quadrtet:{
00405 Qtet->nod_strains_ip (lcid,i,0,0);
00406 break;
00407 }
00408 case linearhex:{
00409 Lhex->nod_strains_ip (lcid,i,0,0);
00410 break;
00411 }
00412 case quadrhex:{
00413 Qhex->nod_strains_ip (lcid,i,0,0);
00414 break;
00415 }
00416 case lineartetrot:{
00417 Ltetrot->nod_strains_ip (lcid,i,0,0);
00418 break;
00419 }
00420 case linearhexrot:{
00421 Lhexrot->nod_strains_ip (lcid,i,0,0);
00422 break;
00423 }
00424
00425 case particleelem:{
00426 break;
00427 }
00428 default:{
00429 print_err("unknown element type is required", __FILE__, __LINE__, __func__);
00430 }
00431 }
00432 }
00433 }
00434
00435
00436 for (i=0;i<Mt->nn;i++){
00437
00438 Mt->nodes[i].strain_averageval (lcid);
00439
00440 }
00441 }
00442
00443
00444
00445
00446
00447
00448
00449
00450
00451
00452
00453
00454
00455
00456 void nodestrains_comp (long lcid)
00457 {
00458 long i;
00459 elemtype te;
00460
00461 for (i=0;i<Mt->nn;i++)
00462 Mt->nodes[i].nullstrain(lcid);
00463
00464 for (i=0;i<Mt->ne;i++)
00465 {
00466 if (Gtm->leso[i]==1)
00467 {
00468 te = Mt->give_elem_type (i);
00469
00470 switch (te)
00471 {
00472 case bar2d:
00473 Bar2d->nod_strains_comp(lcid, i);
00474 break;
00475 case barq2d:
00476
00477 break;
00478 case bar3d:
00479
00480 break;
00481 case barq3d:
00482
00483 break;
00484 case spring_1:
00485 case spring_2:
00486 case spring_3:
00487 case spring_4:
00488 case spring_5:
00489 case spring_6:
00490 break;
00491
00492 case planeelementlt:
00493
00494 break;
00495 case planeelementqt:
00496
00497 break;
00498
00499 case planeelementlq:
00500
00501 break;
00502 case planeelementqq:
00503
00504 break;
00505
00506 case axisymmlt:
00507
00508 break;
00509 case axisymmlq:
00510
00511 break;
00512 case axisymmqq:
00513
00514 break;
00515
00516 case lineartet:
00517
00518 break;
00519 case quadrtet:
00520
00521 break;
00522
00523 case linearhex:
00524
00525 break;
00526
00527 case quadrhex:
00528
00529 break;
00530 default:
00531 print_err("unknown element type is required", __FILE__, __LINE__, __func__);
00532 }
00533 }
00534 }
00535
00536
00537 for (i=0;i<Mt->nn;i++)
00538 {
00539 if (Gtm->lnso[i]==1)
00540 Mt->nodes[i].strain_averageval (lcid);
00541 }
00542 }
00543
00544
00545
00546
00547
00548
00549
00550
00551
00552
00553
00554
00555 void computestrains (long lcid)
00556 {
00557
00558
00559 compute_ipstrains (lcid);
00560
00561
00562
00563
00564
00565
00566
00567
00568
00569
00570
00571
00572
00573
00574
00575
00576
00577
00578
00579
00580
00581
00582
00583
00584
00585
00586
00587
00588
00589
00590
00591
00592
00593
00594
00595
00596
00597
00598
00599
00600
00601
00602
00603
00604
00605
00606
00607
00608
00609
00610
00611
00612
00613
00614
00615
00616
00617
00618
00619
00620
00621
00622
00623
00624
00625
00626
00627
00628
00629
00630
00631
00632
00633
00634
00635
00636
00637
00638
00639
00640
00641
00642
00643
00644
00645
00646
00647
00648
00649
00650
00651
00652
00653
00654
00655
00656
00657
00658
00659
00660
00661
00662
00663
00664
00665
00666
00667
00668
00669
00670
00671
00672
00673
00674
00675
00676
00677
00678
00679
00680
00681
00682
00683
00684
00685
00686
00687
00688
00689
00690
00691
00692
00693
00694
00695
00696
00697
00698
00699
00700
00701
00702
00703
00704
00705
00706
00707
00708
00709
00710
00711
00712
00713
00714
00715
00716
00717
00718
00719
00720
00721
00722
00723
00724
00725
00726
00727
00728
00729
00730
00731 }
00732
00733
00734
00735
00736
00737
00738
00739
00740
00741
00742
00743
00744
00745
00746
00747
00748
00749
00750
00751
00752
00753 void compute_ipstresses (long lcid)
00754 {
00755 long i,ne;
00756 elemtype te;
00757
00758
00759 ne=Mt->ne;
00760 for (i=0;i<ne;i++){
00761 if (Gtm->leso[i]==1){
00762
00763
00764 te = Mt->give_elem_type (i);
00765
00766 switch (te){
00767
00768 case bar2d:{
00769 Bar2d->res_ip_stresses (lcid,i);
00770 break;
00771 }
00772 case bar3d:{
00773 Bar3d->res_ip_stresses (lcid,i);
00774 break;
00775 }
00776 case barq2d:{
00777 Barq2d->res_mainip_stresses (lcid,i);
00778 break;
00779 }
00780 case barq3d:{
00781 Barq3d->res_mainip_stresses (lcid,i);
00782 break;
00783 }
00784
00785 case beam2d:{
00786 Beam2d->nodal_forces (lcid,i);
00787 break;
00788 }
00789
00790
00791 case beam3d:{
00792 Beam3d->nodal_forces (lcid,i);
00793 break;
00794 }
00795 case beamg3d:{
00796 Beam3dg->nodal_forces (lcid,i);
00797 break;
00798 }
00799
00800
00801
00802
00803
00804
00805
00806
00807 case spring_1:{
00808 Spring->stresses(i, lcid);
00809 break;
00810 }
00811 case spring_2:{
00812 Spring->stresses(i, lcid);
00813 break;
00814 }
00815 case spring_3:{
00816 Spring->stresses(i, lcid);
00817 break;
00818 }
00819 case spring_4:{
00820 Spring->stresses(i, lcid);
00821 break;
00822 }
00823 case spring_5:{
00824 Spring->stresses(i, lcid);
00825 break;
00826 }
00827 case spring_6:{
00828 Spring->stresses(i, lcid);
00829 break;
00830 }
00831
00832 case planeelementlt:{
00833 Pelt->res_ip_stresses (lcid,i);
00834 break;
00835 }
00836
00837
00838
00839
00840
00841
00842
00843
00844 case planeelementrotlt:{
00845 Perlt->res_ip_stresses (lcid,i);
00846 break;
00847 }
00848
00849 case planeelementlq:{
00850 Pelq->res_ip_stresses (lcid,i);
00851 break;
00852 }
00853
00854 case planeelementqq:{
00855 Peqq->res_ip_stresses (lcid,i);
00856 break;
00857 }
00858
00859
00860
00861
00862
00863
00864
00865
00866
00867
00868
00869
00870 case planequadcontact:
00871 Pqcon->res_mainip_stresses(lcid,i);
00872 break;
00873 case cctel:{
00874 Cct->res_ip_stresses (lcid,i);
00875 break;
00876 }
00877
00878 case dktel:{
00879 Dkt->res_ip_stresses (lcid,i);
00880 break;
00881 }
00882 case dstel:{
00883 Dst->res_ip_stresses (lcid,i);
00884 break;
00885 }
00886 case q4plateel:{
00887 Q4pl->res_ip_stresses (lcid,i);
00888 break;
00889 }
00890
00891 case subsoilplatetr:{
00892 break;
00893 }
00894
00895 case subsoilplateq:{
00896
00897 break;
00898 }
00899
00900
00901 case shelltrelem:{
00902 Shtr->res_ip_stresses (lcid,i);
00903 break;
00904 }
00905 case shellqelem:{
00906 Shq->res_ip_stresses (lcid,i);
00907 break;
00908 }
00909
00910 case axisymmlt:{
00911 Asymlt->res_mainip_stresses (lcid,i);
00912 break;
00913 }
00914 case axisymmlq:{
00915 Asymlq->res_allip_stresses (lcid,i);
00916 break;
00917 }
00918 case axisymmqq:{
00919 Asymqq->res_allip_stresses (lcid,i);
00920 break;
00921 }
00922
00923 case lineartet:{
00924 Ltet->res_ip_stresses (lcid,i);
00925 break;
00926 }
00927 case quadrtet:{
00928 Qtet->res_ip_stresses (lcid,i);
00929 break;
00930 }
00931 case linearhex:{
00932 Lhex->res_ip_stresses (lcid,i);
00933 break;
00934 }
00935 case quadrhex:{
00936 Qhex->res_ip_stresses (lcid,i);
00937 break;
00938 }
00939 case lineartetrot:{
00940 Ltetrot->res_ip_stresses (lcid,i);
00941 break;
00942 }
00943 case linearhexrot:{
00944 Lhexrot->res_ip_stresses (lcid,i);
00945 break;
00946 }
00947
00948 case particleelem:{
00949 break;
00950 }
00951
00952 default:{
00953 print_err("unknown element type is required", __FILE__, __LINE__, __func__);
00954 }
00955 }
00956 }
00957 }
00958
00959
00960 }
00961
00962
00963
00964
00965
00966
00967
00968
00969
00970
00971 void find_extreme_ipstresses (long lcid)
00972 {
00973 long i,ne;
00974 long nebar2d,nebar3d,nelinhex;
00975 vector minbar2d,minbar3d,minlinhex;
00976 vector maxbar2d,maxbar3d,maxlinhex;
00977
00978 if (Bar2d != NULL){
00979 allocv (Bar2d->tncomp,minbar2d);
00980 fillv (1.0e80,minbar2d);
00981 vector maxbar2d(Bar2d->tncomp);
00982 fillv (-1.0e80,maxbar2d);
00983 }
00984 if (Bar3d != NULL){
00985 allocv (Bar3d->tncomp,minbar3d);
00986 fillv (1.0e80,minbar3d);
00987 allocv (Bar3d->tncomp,maxbar3d);
00988 fillv (-1.0e80,maxbar3d);
00989 }
00990 if (Lhex != NULL){
00991 allocv (Lhex->tncomp,minlinhex);
00992 fillv (1.0e80,minlinhex);
00993 allocv (Lhex->tncomp,maxlinhex);
00994 fillv (-1.0e80,maxlinhex);
00995 }
00996
00997 elemtype te;
00998
00999 nebar2d=0;
01000 nebar3d=0;
01001 nelinhex=0;
01002
01003
01004
01005 ne=Mt->ne;
01006
01007
01008 for (i=0;i<ne;i++){
01009 if (Gtm->leso[i]==1){
01010
01011
01012 te = Mt->give_elem_type (i);
01013
01014 switch (te){
01015
01016
01017
01018
01019
01020
01021
01022
01023 case bar3d:{
01024 Bar3d->find_extreme_stresses (minbar3d,maxbar3d,lcid,i);
01025 nebar3d++;
01026 break;
01027 }
01028
01029
01030
01031
01032
01033
01034
01035
01036
01037
01038
01039
01040
01041
01042
01043
01044
01045
01046
01047
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
01074
01075
01076
01077
01078
01079
01080
01081
01082
01083
01084
01085
01086
01087
01088
01089
01090
01091
01092
01093
01094
01095
01096
01097
01098
01099
01100
01101
01102
01103
01104
01105
01106
01107
01108
01109
01110
01111
01112
01113
01114
01115
01116
01117
01118
01119
01120
01121
01122
01123
01124
01125
01126
01127
01128
01129
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
01155
01156
01157
01158
01159
01160
01161
01162
01163
01164
01165
01166
01167
01168
01169
01170
01171
01172
01173
01174
01175
01176
01177
01178
01179
01180
01181
01182
01183
01184
01185 case linearhex:{
01186 Lhex->find_extreme_stresses (minlinhex,maxlinhex,lcid,i);
01187 nelinhex++;
01188 break;
01189 }
01190
01191
01192
01193
01194
01195
01196
01197
01198
01199
01200
01201
01202
01203
01204
01205
01206
01207
01208 default:{
01209 print_err("unknown element type is required", __FILE__, __LINE__, __func__);
01210 }
01211 }
01212 }
01213 }
01214
01215 fprintf (stdout,"\n\n\n");
01216 if (Bar3d != NULL)
01217 fprintf (stdout,"\n linbar3d %6ld % le % le",nebar3d,minbar3d[0],maxbar3d[0]);
01218 if (Lhex != NULL){
01219 fprintf (stdout,"\n linhex %6ld % le % le % le % le % le % le\n",nelinhex,minlinhex[0],minlinhex[1],minlinhex[2],minlinhex[3],minlinhex[4],minlinhex[5]);
01220 fprintf (stdout," % le % le % le % le % le % le",maxlinhex[0],maxlinhex[1],maxlinhex[2],maxlinhex[3],maxlinhex[4],maxlinhex[5]);
01221 }
01222
01223 fprintf (stdout,"\n\n\n");
01224
01225 destrv (minbar2d);
01226 destrv (minbar3d);
01227 destrv (minlinhex);
01228
01229 destrv (maxbar2d);
01230 destrv (maxbar3d);
01231 destrv (maxlinhex);
01232 }
01233
01234
01235
01236
01237
01238
01239
01240
01241
01242
01243
01244
01245
01246 void compute_nodestresses (long lcid)
01247 {
01248 long i;
01249 elemtype te;
01250
01251 for (i=0;i<Mt->nn;i++){
01252 Mt->nodes[i].nullstress (lcid);
01253 }
01254
01255 for (i=0;i<Mt->ne;i++){
01256 if (Gtm->leso[i]==1){
01257
01258 te = Mt->give_elem_type (i);
01259
01260 switch (te){
01261
01262 case bar2d:{
01263 Bar2d->nod_stresses_ip (lcid, i, 0, 0);
01264 break;
01265 }
01266 case barq2d:{
01267 Barq2d->nod_stresses_ip (lcid,i,0,0);
01268 break;
01269 }
01270 case bar3d:{
01271
01272 break;
01273 }
01274 case barq3d:{
01275
01276 break;
01277 }
01278
01279 case beam2d:{
01280 Beam2d->nodal_forces (lcid,i);
01281 break;
01282 }
01283 case beam3d:{
01284 Beam3d->nodal_forces (lcid,i);
01285 break;
01286 }
01287 case beamg3d:{
01288 Beam3dg->nodal_forces (lcid,i);
01289 break;
01290 }
01291
01292
01293
01294 case spring_1:
01295 case spring_2:
01296 case spring_3:
01297 case spring_4:
01298 case spring_5:
01299 case spring_6:
01300 break;
01301 case planeelementlt:{
01302 Pelt->nod_stresses_ip (lcid,i,0,0);
01303 break;
01304 }
01305 case planeelementqt:{
01306 Peqt->nod_stresses (lcid,i,0,0);
01307 break;
01308 }
01309 case planeelementrotlt:{
01310 Perlt->nod_stresses_ip (lcid,i,0,0);
01311 break;
01312 }
01313
01314 case planeelementlq:{
01315 Pelq->nod_stresses_ip (lcid,i,0,0);
01316 break;
01317 }
01318 case planeelementqq:{
01319 Peqq->nod_stresses_ip (lcid,i,0,0);
01320 break;
01321 }
01322 case planeelementrotlq:{
01323
01324 break;
01325 }
01326
01327 case planeelementsubqt:{
01328 Pesqt->nod_stresses (lcid,i,0,0);
01329 break;
01330 }
01331
01332 case cctel:{
01333 Cct->nod_stresses_ip (lcid,i,0,0);
01334 break;
01335 }
01336 case dktel:{
01337
01338 break;
01339 }
01340 case dstel:{
01341
01342 break;
01343 }
01344 case q4plateel:{
01345
01346 break;
01347 }
01348
01349 case subsoilplatetr:{
01350 break;
01351 }
01352 case subsoilplateq:{
01353 break;
01354 }
01355
01356 case axisymmlt:{
01357 Asymlt->nod_stresses_ip (lcid,i);
01358 break;
01359 }
01360 case axisymmlq:{
01361 Asymlq->nod_stresses_ip (lcid,i,0,0);
01362 break;
01363 }
01364 case axisymmqq:{
01365 Asymqq->nod_stresses_ip (lcid,i);
01366 break;
01367 }
01368
01369 case shelltrelem:{
01370 Shtr->nod_stresses_ip (lcid,i);
01371 break;
01372 }
01373 case shellqelem:{
01374 Shq->nod_stresses_ip (lcid,i);
01375 break;
01376 }
01377
01378 case lineartet:{
01379 Ltet->nod_stresses_ip (lcid,i,0,0);
01380 break;
01381 }
01382 case quadrtet:{
01383 Qtet->nod_stresses_ip (lcid,i,0,0);
01384 break;
01385 }
01386 case linearhex:{
01387 Lhex->nod_stresses_ip (lcid,i,0,0);
01388 break;
01389 }
01390 case quadrhex:{
01391 Qhex->nod_stresses_ip (lcid,i,0,0);
01392 break;
01393 }
01394 case lineartetrot:{
01395 Ltetrot->nod_stresses_ip (lcid,i,0,0);
01396 break;
01397 }
01398 case linearhexrot:{
01399 Lhexrot->nod_stresses_ip (lcid,i,0,0);
01400 break;
01401 }
01402 case particleelem:{
01403 break;
01404 }
01405
01406 default:{
01407 print_err("unknown element type is required", __FILE__, __LINE__, __func__);
01408 }
01409 }
01410
01411 }
01412 }
01413
01414 for (i=0;i<Mt->nn;i++){
01415
01416 Mt->nodes[i].stress_averageval (lcid);
01417 }
01418
01419 }
01420
01421
01422
01423
01424
01425
01426
01427
01428
01429
01430
01431
01432 void computestresses (long lcid)
01433 {
01434 long i,ne,te;
01435
01436
01437 compute_ipstresses (lcid);
01438
01439
01440 ne=Mt->ne;
01441 for (i=0;i<ne;i++){
01442 if (Gtm->leso[i]==1){
01443
01444 te = Mt->give_elem_type (i);
01445
01446 switch (te){
01447
01448 case bar2d:{
01449 Bar2d->stresses (lcid,i,0,0);
01450 break;
01451 }
01452 case bar3d:{
01453 Bar3d->stresses (lcid,i,0,0);
01454 break;
01455 }
01456 case barq2d:{
01457 Barq2d->stresses (lcid,i,0,0);
01458 break;
01459 }
01460 case barq3d:{
01461 Barq3d->stresses (lcid,i,0,0);
01462 break;
01463 }
01464
01465 case beam2d:{
01466 Beam2d->nodal_forces (lcid,i);
01467 break;
01468 }
01469
01470 case beam3d:{
01471 Beam3d->nodal_forces (lcid,i);
01472 break;
01473 }
01474
01475 case spring_1:
01476 case spring_2:
01477 case spring_3:
01478 case spring_4:
01479 case spring_5:
01480 case spring_6:
01481 Spring->stresses(i, lcid);
01482 break;
01483 case planeelementlt:{
01484 Pelt->stresses (lcid,i,0,0);
01485 break;
01486 }
01487 case planeelementqt:{
01488 Peqt->stresses (lcid,i,0,0);
01489 break;
01490 }
01491 case planeelementrotlt:{
01492 Perlt->stresses (lcid,i,0,0);
01493 break;
01494 }
01495
01496 case planeelementlq:{
01497 Pelq->stresses (lcid,i,0,0);
01498 break;
01499 }
01500 case planeelementqq:{
01501 Peqq->stresses (lcid,i,0,0);
01502 break;
01503 }
01504 case planeelementrotlq:{
01505 Perlq->stresses (lcid,i,0,0);
01506 break;
01507 }
01508
01509 case planeelementsubqt:{
01510 Pesqt->stresses (lcid,i,0,0);
01511 break;
01512 }
01513
01514 case cctel:{
01515 Cct->stresses (lcid,i,0,0);
01516 break;
01517 }
01518 case dktel:{
01519 Dkt->stresses (lcid,i,0,0);
01520 break;
01521 }
01522
01523 case dstel:{
01524 Dst->stresses (lcid,i,0,0);
01525 break;
01526 }
01527
01528 case q4plateel:{
01529 Q4pl->stresses (lcid,i,0,0);
01530 break;
01531 }
01532
01533 case axisymmlt:{
01534 Asymlt->stresses (lcid,i,0,0);
01535 break;
01536 }
01537 case axisymmlq:{
01538 Asymlq->stresses (lcid,i,0,0);
01539 break;
01540 }
01541 case axisymmqq:{
01542 Asymqq->stresses (lcid,i,0,0);
01543 break;
01544 }
01545
01546 case shelltrelem:{
01547 Shtr->stresses (lcid,i);
01548 break;
01549 }
01550 case shellqelem:{
01551 Shq->stresses (lcid,i);
01552 break;
01553 }
01554
01555 case lineartet:{
01556 Ltet->stresses (lcid,i,0,0);
01557 break;
01558 }
01559 case quadrtet:{
01560 Qtet->stresses (lcid,i,0,0);
01561 break;
01562 }
01563 case linearhex:{
01564 Lhex->stresses (lcid,i,0,0);
01565 break;
01566 }
01567 case quadrhex:{
01568 Qhex->stresses (lcid,i,0,0);
01569 break;
01570 }
01571 case lineartetrot:{
01572 Ltetrot->stresses (lcid,i,0,0);
01573 break;
01574 }
01575 case linearhexrot:{
01576 Lhexrot->stresses (lcid,i,0,0);
01577 break;
01578 }
01579 case particleelem:{
01580 break;
01581 }
01582 default:{
01583 print_err("unknown element type is required", __FILE__, __LINE__, __func__);
01584 }
01585 }
01586 }
01587 }
01588 }
01589
01590
01591
01592
01593
01594
01595
01596
01597
01598
01599
01600
01601 void compute_nodeothers ()
01602 {
01603 long i;
01604 elemtype te;
01605
01606 for (i=0;i<Mt->nn;i++){
01607 Mt->nodes[i].nullother ();
01608 }
01609
01610 for (i=0;i<Mt->ne;i++){
01611 if (Gtm->leso[i]==1){
01612
01613 te = Mt->give_elem_type (i);
01614
01615 switch (te){
01616
01617 case bar2d:{
01618 Bar2d->nod_eqother_ip (i, 0, 0);
01619 break;
01620 }
01621 case bar3d:{
01622
01623 break;
01624 }
01625 case barq2d:{
01626 Barq2d->nod_eqother_ip (i, 0, 0);
01627 break;
01628 }
01629 case barq3d:{
01630
01631 break;
01632 }
01633
01634
01635
01636
01637
01638
01639
01640
01641
01642
01643
01644
01645
01646 case spring_1:
01647 case spring_2:
01648 case spring_3:
01649 case spring_4:
01650 case spring_5:
01651 case spring_6:
01652 break;
01653
01654 case planeelementlt:{
01655 Pelt->nod_others (i,0,0);
01656 break;
01657 }
01658
01659
01660
01661
01662
01663
01664
01665
01666 case planeelementlq:{
01667 Pelq->nod_eqother_ip (i,0,0);
01668 break;
01669 }
01670
01671 case planeelementqq:{
01672 Peqq->nod_eqother_ip (i,0,0);
01673 break;
01674 }
01675
01676
01677
01678
01679
01680
01681
01682
01683
01684
01685
01686
01687
01688
01689
01690
01691
01692
01693
01694
01695
01696
01697
01698
01699
01700
01701
01702
01703 case axisymmlt:{
01704 Asymlt->nod_eqother_ip (i);
01705 break;
01706 }
01707 case axisymmlq:{
01708 Asymlq->nod_eqother_ip (i);
01709 break;
01710 }
01711 case axisymmqq:{
01712 Asymqq->nod_eqother_ip (i);
01713 break;
01714 }
01715
01716
01717
01718
01719
01720
01721
01722
01723 case lineartet:{
01724 Ltet->nod_eqother_ip (i);
01725 break;
01726 }
01727 case quadrtet:{
01728 Qtet->nod_eqother_ip (i,0,0);
01729 break;
01730 }
01731 case linearhex:{
01732 Lhex->nod_eqother_ip (i,0,0);
01733 break;
01734 }
01735 case quadrhex:{
01736 Qhex->nod_eqother_ip (i,0,0);
01737 break;
01738 }
01739
01740 default:{
01741 print_err("unknown element type is required", __FILE__, __LINE__, __func__);
01742 }
01743 }
01744 }
01745 }
01746
01747 for (i=0;i<Mt->nn;i++){
01748 Mt->nodes[i].other_averageval ();
01749 }
01750 }
01751
01752
01753
01754
01755
01756
01757
01758
01759
01760
01761
01762
01763
01764
01765 void elem_intpointval (long eid,vector &nodval,vector &ipval)
01766 {
01767 elemtype te;
01768
01769 te = Mt->give_elem_type (eid);
01770
01771 switch (te){
01772 case bar2d:{
01773 Bar2d->intpointval (eid,nodval,ipval);
01774 break;
01775 }
01776 case bar3d:{
01777 Bar3d->intpointval (eid,nodval,ipval);
01778 break;
01779 }
01780 case barq2d:{
01781 Barq2d->intpointval (eid,nodval,ipval);
01782 break;
01783 }
01784 case barq3d:{
01785 Barq3d->intpointval (eid,nodval,ipval);
01786 break;
01787 }
01788
01789 case spring_1:{
01790 Spring->intpointval (eid,nodval,ipval);
01791 break;
01792 }
01793 case spring_2:{
01794 Spring->intpointval (eid,nodval,ipval);
01795 break;
01796 }
01797 case spring_3:{
01798 Spring->intpointval (eid,nodval,ipval);
01799 break;
01800 }
01801 case spring_4:{
01802 Spring->intpointval (eid,nodval,ipval);
01803 break;
01804 }
01805 case spring_5:{
01806 Spring->intpointval (eid,nodval,ipval);
01807 break;
01808 }
01809 case spring_6:{
01810 Spring->intpointval (eid,nodval,ipval);
01811 break;
01812 }
01813
01814 case planeelementlt:{
01815 Pelt->intpointval (eid,nodval,ipval);
01816 break;
01817 }
01818
01819 case planeelementlq:{
01820 Pelq->intpointval (eid,nodval,ipval);
01821 break;
01822 }
01823 case planeelementqq:{
01824 Peqq->intpointval (eid,nodval,ipval);
01825 break;
01826 }
01827
01828 case axisymmlq:{
01829 Asymlq->intpointval (eid,nodval,ipval);
01830 break;
01831 }
01832 case axisymmqq:{
01833 Asymqq->intpointval (eid,nodval,ipval);
01834 break;
01835 }
01836
01837 case lineartet:{
01838 Ltet->intpointval (eid,nodval,ipval);
01839 break;
01840 }
01841 case quadrtet:{
01842 Qtet->intpointval (eid,nodval,ipval);
01843 break;
01844 }
01845 case linearhex:{
01846 Lhex->intpointval (eid,nodval,ipval);
01847 break;
01848 }
01849 case quadrhex:{
01850 Qhex->intpointval (eid,nodval,ipval);
01851 break;
01852 }
01853 case lineartetrot:{
01854 Ltetrot->intpointval (eid,nodval,ipval);
01855 break;
01856 }
01857 case linearhexrot:{
01858 Lhexrot->intpointval (eid,nodval,ipval);
01859 break;
01860 }
01861
01862 default:{
01863 print_err("unknown element type is required", __FILE__, __LINE__, __func__);
01864 }
01865 }
01866
01867 }
01868
01869
01870
01871
01872
01873
01874
01875
01876
01877
01878
01879
01880
01881
01882 void intpointval (double *gv,nonmechquant nmq,double scale)
01883 {
01884 long i,j,nne,nip,ipid;
01885 ivector nodes;
01886 vector nodval,ipval;
01887
01888 for (i=0;i<Mt->ne;i++){
01889 if (Gtm->leso[i]==1){
01890
01891 nne = Mt->give_nne (i);
01892 nip = Mt->give_tnip (i);
01893
01894 reallocv (nne,nodes);
01895 reallocv (nne,nodval);
01896 reallocv (nip,ipval);
01897
01898 Mt->give_elemnodes (i,nodes);
01899
01900 for (j=0;j<nne;j++){
01901 nodval[j]=gv[nodes[j]]*scale;
01902 }
01903
01904 elem_intpointval (i,nodval,ipval);
01905
01906
01907 ipid=Mt->elements[i].ipp[0][0];
01908
01909 for (j=0;j<nip;j++)
01910 {
01911 Mm->storenonmechq(nmq, ipid, ipval[j]);
01912 ipid++;
01913 }
01914 }
01915 }
01916 }
01917
01918
01919
01920
01921
01922
01923
01924
01925
01926
01927
01928
01929
01930
01931 void intpointval2 (double *gv,nonmechquant nmq)
01932 {
01933 long i,j,nne,nip,ipp;
01934 ivector nodes;
01935 vector nodval,ipval;
01936
01937 for (i=0;i<Mt->ne;i++){
01938 if (Gtm->leso[i]==1){
01939 nne = Mt->give_nne (i);
01940 nip = Mt->give_tnip (i);
01941
01942 reallocv (nne,nodes);
01943 reallocv (nne,nodval);
01944 reallocv (nip,ipval);
01945
01946 Mt->give_elemnodes (i,nodes);
01947
01948 for (j=0;j<nne;j++){
01949 nodval[j]=gv[nodes[j]];
01950 }
01951
01952 elem_intpointval2(i, nodval, ipval);
01953
01954
01955 ipp=Mt->elements[i].ipp[0][0];
01956
01957 for (j=0;j<nip;j++)
01958 {
01959 Mm->storenonmechq(nmq, ipp, ipval[j]);
01960 ipp++;
01961 }
01962 }
01963 }
01964 }
01965
01966
01967
01968
01969
01970
01971
01972
01973
01974
01975
01976
01977
01978
01979
01980 void elem_intpointval2 (long eid, vector &nodval, vector &ipval)
01981 {
01982 elemtype te;
01983
01984 te = Mt->give_elem_type (eid);
01985
01986 switch (te)
01987 {
01988 case bar2d:
01989 Bar2d->intpointval (eid,nodval,ipval);
01990 break;
01991
01992 case barq2d:
01993 Barq2d->intpointval2 (eid,nodval,ipval);
01994 break;
01995
01996 case barq3d:
01997 Barq3d->intpointval2 (eid,nodval,ipval);
01998 break;
01999
02000 case spring_1:
02001 Spring->intpointval (eid,nodval,ipval);
02002 break;
02003
02004 case spring_2:
02005 Spring->intpointval (eid,nodval,ipval);
02006 break;
02007
02008 case spring_3:
02009 Spring->intpointval (eid,nodval,ipval);
02010 break;
02011
02012 case spring_4:
02013 Spring->intpointval (eid,nodval,ipval);
02014 break;
02015
02016 case spring_5:
02017 Spring->intpointval (eid,nodval,ipval);
02018 break;
02019
02020 case spring_6:
02021 Spring->intpointval (eid,nodval,ipval);
02022 break;
02023
02024 case planeelementqq:
02025 Peqq->intpointval2 (eid,nodval,ipval);
02026 break;
02027
02028 case axisymmqq:
02029 Asymqq->intpointval2 (eid,nodval,ipval);
02030 break;
02031
02032 case quadrtet:
02033 Qtet->intpointval2 (eid,nodval,ipval);
02034 break;
02035
02036 case quadrhex:
02037 Qhex->intpointval2 (eid,nodval,ipval);
02038 break;
02039
02040 default:
02041 print_err("unknown element type is required", __FILE__, __LINE__, __func__);
02042 }
02043 }
02044
02045
02046
02047
02048
02049
02050
02051
02052
02053
02054
02055
02056
02057
02058
02059 double interpolate (long eid,double *nodval,double *coord)
02060 {
02061 long i,nne;
02062 double val;
02063 elemtype te;
02064 vector areacoord(3),volcoord(4),nv;
02065
02066 te = Mt->give_elem_type (eid);
02067 nne = Mt->give_nne (eid);
02068 allocv (nne,nv);
02069 for (i=0;i<nne;i++){
02070 nv[i]=nodval[i];
02071 }
02072
02073 switch (te){
02074 case planeelementlt:{
02075 areacoord[0]=coord[0]; areacoord[1]=coord[1]; areacoord[2]=1.0-areacoord[0]-areacoord[1];
02076 val=Pelt->approx (areacoord,nv);
02077 break;
02078 }
02079 case planeelementqt:{
02080 areacoord[0]=coord[0]; areacoord[1]=coord[1]; areacoord[2]=1.0-areacoord[0]-areacoord[1];
02081 val=Peqt->approx (areacoord[0],areacoord[1],nv);
02082 break;
02083 }
02084 case planeelementrotlt:{
02085 areacoord[0]=coord[0]; areacoord[1]=coord[1]; areacoord[2]=1.0-areacoord[0]-areacoord[1];
02086 val=Perlt->approx (areacoord,nv);
02087 break;
02088 }
02089 case planeelementlq:{
02090 val=Pelq->approx (coord[0],coord[1],nv);
02091 break;
02092 }
02093 case planeelementqq:{
02094 val=Peqq->approx (coord[0],coord[1],nv);
02095 break;
02096 }
02097 case planeelementrotlq:{
02098 val=Perlq->approx (coord[0],coord[1],nv);
02099 break;
02100 }
02101 case lineartet:{
02102 volcoord[0]=coord[0]; volcoord[1]=coord[1]; volcoord[2]=coord[2]; volcoord[3]=1.0-volcoord[0]-volcoord[1]-volcoord[2];
02103 val=Ltet->approx (volcoord,nv);
02104 break;
02105 }
02106 case quadrtet:{
02107 val=Qtet->approx (coord[0],coord[1],coord[2],nv);
02108 break;
02109 }
02110 case linearhex:{
02111 val=Lhex->approx (coord[0],coord[1],coord[2],nv);
02112 break;
02113 }
02114 case quadrhex:{
02115 val=Qhex->approx (coord[0],coord[1],coord[2],nv);
02116 break;
02117 }
02118 default:{
02119 print_err("unknown element type is required", __FILE__, __LINE__, __func__);
02120 }
02121 }
02122 destrv (nv);
02123
02124 return val;
02125 }
02126
02127
02128
02129
02130
02131
02132
02133
02134
02135
02136 void ipvolume ()
02137 {
02138 long i;
02139 elemtype te;
02140
02141 if (Mm->ipv == NULL)
02142 delete [] Mm->ipv;
02143
02144 Mm->ipv = new double [Mm->tnip];
02145
02146 for (i=0;i<Mt->ne;i++){
02147 if (Gtm->leso[i]==1){
02148
02149 te = Mt->give_elem_type (i);
02150
02151 switch (te){
02152 case bar2d:{
02153
02154 break;
02155 }
02156 case bar3d:{
02157
02158 break;
02159 }
02160 case planeelementlt:{
02161 Pelt->ipvolume (i,0,0);
02162 break;
02163 }
02164 case planeelementqt:{
02165 Peqt->ipvolume (i,0,0);
02166 break;
02167 }
02168 case planeelementrotlt:{
02169 Perlt->ipvolume (i,0,0);
02170 break;
02171 }
02172 case planeelementlq:{
02173 Pelq->ipvolume (i,0,0);
02174 break;
02175 }
02176 case planeelementqq:{
02177 Peqq->ipvolume (i,0,0);
02178 break;
02179 }
02180 case planeelementrotlq:{
02181 Perlq->ipvolume (i,0,0);
02182 break;
02183 }
02184
02185 case lineartet:{
02186 Ltet->ipvolume (i,0,0);
02187 break;
02188 }
02189 case quadrtet:{
02190 Qtet->ipvolume (i,0,0);
02191 break;
02192 }
02193 case linearhex:{
02194 Lhex->ipvolume (i,0,0);
02195 break;
02196 }
02197 case quadrhex:{
02198 Qhex->ipvolume (i,0,0);
02199 break;
02200 }
02201 case lineartetrot:{
02202 Ltetrot->ipvolume (i,0,0);
02203 break;
02204 }
02205 case linearhexrot:{
02206 Lhexrot->ipvolume (i,0,0);
02207 break;
02208 }
02209
02210 default:
02211 print_err("unknown element type is required", __FILE__, __LINE__, __func__);
02212 }
02213 }
02214 }
02215 }
02216
02217
02218
02219
02220
02221
02222
02223
02224
02225
02226
02227
02228
02229
02230 void elem_internal_forces (long i,long lcid,vector &ifor)
02231 {
02232 elemtype te;
02233 te = Mt->give_elem_type (i);
02234
02235 switch (te){
02236
02237 case bar2d:{
02238 Bar2d->res_internal_forces (lcid,i,ifor);
02239 break;
02240 }
02241 case bar3d:{
02242 Bar3d->res_internal_forces (lcid,i,ifor);
02243 break;
02244 }
02245 case barq2d:{
02246 Barq2d->res_internal_forces (lcid,i,ifor);
02247 break;
02248 }
02249 case barq3d:{
02250 Barq3d->res_internal_forces (lcid,i,ifor);
02251 break;
02252 }
02253 case beam2d:{
02254 Beam2d->res_internal_forces (lcid,i,ifor);
02255 break;
02256 }
02257 case beam3d:{
02258 Beam3d->res_internal_forces (lcid,i,ifor);
02259 break;
02260 }
02261 case subsoilbeam:{
02262 Sbeam->res_internal_forces (lcid,i,ifor);
02263 break;
02264 }
02265
02266 case spring_1:{
02267 Spring->res_internal_forces (lcid,i,ifor);
02268 break;
02269 }
02270 case spring_2:{
02271 Spring->res_internal_forces (lcid,i,ifor);
02272 break;
02273 }
02274 case spring_3:{
02275 Spring->res_internal_forces (lcid,i,ifor);
02276 break;
02277 }
02278 case spring_4:{
02279 Spring->res_internal_forces (lcid,i,ifor);
02280 break;
02281 }
02282 case spring_5:{
02283 Spring->res_internal_forces (lcid,i,ifor);
02284 break;
02285 }
02286 case spring_6:{
02287 Spring->res_internal_forces (lcid,i,ifor);
02288 break;
02289 }
02290
02291 case planeelementlt:{
02292 Pelt->res_internal_forces (lcid,i,ifor);
02293 break;
02294 }
02295 case planeelementqt:{
02296 Peqt->res_internal_forces (lcid,i,ifor);
02297 break;
02298 }
02299 case planeelementrotlt:{
02300 Perlt->res_internal_forces (lcid,i,ifor);
02301 break;
02302 }
02303
02304 case planeelementlq:{
02305 Pelq->res_internal_forces (lcid,i,ifor);
02306 break;
02307 }
02308 case planeelementqq:{
02309 Peqq->res_internal_forces (lcid,i,ifor);
02310 break;
02311 }
02312 case planeelementrotlq:{
02313 Perlq->res_internal_forces (lcid,i,ifor);
02314 break;
02315 }
02316
02317 case planeelementsubqt:{
02318 Pesqt->res_internal_forces (lcid,i,ifor);
02319 break;
02320 }
02321
02322 case planequadcontact:{
02323 Pqcon->res_internal_forces (lcid,i,ifor);
02324 break;
02325 }
02326
02327
02328 case cctel:{
02329 Cct->res_internal_forces (lcid,i,ifor);
02330 break;
02331 }
02332 case dktel:{
02333 Dkt->res_internal_forces (lcid,i,ifor);
02334 break;
02335 }
02336 case dstel:{
02337 Dst->res_internal_forces (lcid,i,ifor);
02338 break;
02339 }
02340
02341 case q4plateel:{
02342 Q4pl->res_internal_forces (lcid,i,ifor);
02343 break;
02344 }
02345 case subsoilplateq:{
02346 Splq->res_internal_forces (lcid,i,ifor);
02347 break;
02348 }
02349
02350 case subsoilplatetr:{
02351 Spltr->res_internal_forces (lcid,i,ifor);
02352 break;
02353 }
02354
02355 case axisymmlt:{
02356 Asymlt->res_internal_forces (lcid,i,ifor);
02357 break;
02358 }
02359 case axisymmlq:{
02360 Asymlq->res_internal_forces (lcid,i,ifor);
02361 break;
02362 }
02363 case axisymmqq:{
02364 Asymqq->res_internal_forces (lcid,i,ifor);
02365 break;
02366 }
02367
02368 case shelltrelem:{
02369 Shtr->res_internal_forces (lcid,i,ifor);
02370 break;
02371 }
02372
02373
02374
02375
02376
02377
02378 case lineartet:{
02379 Ltet->res_internal_forces (lcid,i,ifor);
02380 break;
02381 }
02382 case quadrtet:{
02383 Qtet->res_internal_forces (lcid,i,ifor);
02384 break;
02385 }
02386 case linearhex:{
02387 Lhex->res_internal_forces (lcid,i,ifor);
02388 break;
02389 }
02390 case quadrhex:{
02391 Qhex->res_internal_forces (lcid,i,ifor);
02392 break;
02393 }
02394 case lineartetrot:{
02395 Ltetrot->res_internal_forces (lcid,i,ifor);
02396 break;
02397 }
02398 case linearhexrot:{
02399 Lhexrot->res_internal_forces (lcid,i,ifor);
02400 break;
02401 }
02402
02403
02404 case particleelem:{
02405 Pelem->res_internal_forces (i,ifor);
02406 break;
02407 }
02408
02409 default:{
02410 print_err("unknown element type is required", __FILE__, __LINE__, __func__);
02411 }
02412 }
02413
02414 }
02415
02416
02417
02418
02419
02420
02421
02422
02423
02424
02425
02426
02427
02428
02429
02430
02431
02432
02433 void elem_integration_quant(long eid, integratedquant iq, long lcid, vector &nv)
02434 {
02435 elemtype te;
02436 te = Mt->give_elem_type (eid);
02437
02438 switch (te)
02439 {
02440 case lineartet:
02441 Ltet->elem_integration_quant(eid, iq, lcid, nv);
02442 break;
02443 default:
02444 print_err("unknown element type is required", __FILE__, __LINE__, __func__);
02445 }
02446 }
02447
02448
02449
02450
02451
02452
02453
02454
02455
02456
02457
02458
02459
02460
02461 void elem_nlstresses(long i,long lcid)
02462 {
02463 elemtype te;
02464 te = Mt->give_elem_type (i);
02465
02466 switch (te){
02467
02468 case bar2d:{
02469 Bar2d->compute_nlstress(lcid, i, 0, 0);
02470 break;
02471 }
02472 case bar3d:{
02473 Bar3d->compute_nlstress(lcid, i, 0, 0);
02474 break;
02475 }
02476 case barq2d:{
02477 Barq2d->compute_nlstress(lcid, i, 0, 0);
02478 break;
02479 }
02480 case barq3d:{
02481 Barq3d->compute_nlstress(lcid, i, 0, 0);
02482 break;
02483 }
02484 case beam2d:
02485 case beam3d:
02486 case subsoilbeam:
02487 case spring_1:
02488 case spring_2:
02489 case spring_3:
02490 case spring_4:
02491 case spring_5:
02492 case spring_6:
02493 break;
02494 case planeelementlt:{
02495 Pelt->compute_nlstress(lcid, i, 0, 0);
02496 break;
02497 }
02498 case planeelementqt:{
02499 Peqt->compute_nlstress(lcid, i, 0, 0);
02500 break;
02501 }
02502 case planeelementrotlt:{
02503 Perlt->compute_nlstress(lcid, i, 0, 0);
02504 break;
02505 }
02506 case planeelementlq:{
02507 Pelq->compute_nlstress (lcid,i,0,0);
02508 break;
02509 }
02510 case planeelementqq:{
02511 Peqq->compute_nlstress(lcid, i, 0, 0);
02512 break;
02513 }
02514 case planeelementrotlq:{
02515 Perlq->compute_nlstress(lcid, i, 0, 0);
02516 break;
02517 }
02518 case planeelementsubqt:{
02519 Pesqt->compute_nlstress(lcid, i, 0, 0);
02520 break;
02521 }
02522 case planequadcontact:{
02523 break;
02524 }
02525 case cctel:{
02526 Cct->compute_nlstress(lcid, i, 0, 0);
02527 break;
02528 }
02529 case q4plateel:{
02530 Q4pl->compute_nlstress(lcid, i, 0, 0);
02531 break;
02532 }
02533 case subsoilplateq:{
02534 Splq->compute_nlstress(lcid, i, 0, 0);
02535 break;
02536 }
02537
02538
02539
02540
02541
02542
02543
02544
02545
02546
02547
02548
02549
02550
02551 case axisymmlt:{
02552 Asymlt->compute_nlstress(lcid, i, 0, 0);
02553 break;
02554 }
02555 case axisymmlq:{
02556 Asymlq->compute_nlstress(lcid, i, 0, 0);
02557 break;
02558 }
02559 case axisymmqq:{
02560 Asymqq->compute_nlstress(lcid, i, 0, 0);
02561 break;
02562 }
02563
02564 case lineartet:{
02565 Ltet->compute_nlstress(lcid, i, 0, 0);
02566 break;
02567 }
02568 case quadrtet:{
02569 Qtet->compute_nlstress(lcid, i, 0, 0);
02570 break;
02571 }
02572 case linearhex:{
02573 Lhex->compute_nlstress(lcid, i, 0, 0);
02574 break;
02575 }
02576 case quadrhex:{
02577 Qhex->compute_nlstress(lcid, i, 0, 0);
02578 break;
02579 }
02580 case lineartetrot:{
02581 Ltetrot->compute_nlstress(lcid, i, 0, 0);
02582 break;
02583 }
02584 case linearhexrot:{
02585 Lhexrot->compute_nlstress(lcid, i, 0, 0);
02586 break;
02587 }
02588
02589 case particleelem:
02590 break;
02591 default:
02592 print_err("unknown element type is required", __FILE__, __LINE__, __func__);
02593 }
02594 }
02595
02596
02597
02598
02599
02600
02601
02602
02603
02604
02605
02606
02607
02608
02609 void elem_local_values (long i,long lcid)
02610 {
02611 elemtype te;
02612 te = Mt->give_elem_type (i);
02613
02614 switch (te){
02615
02616 case bar2d:{
02617 Bar2d->local_values(lcid, i, 0, 0);
02618 break;
02619 }
02620 case bar3d:{
02621 Bar3d->local_values(lcid, i, 0, 0);
02622 break;
02623 }
02624 case barq2d:{
02625 Barq2d->local_values(lcid, i, 0, 0);
02626 break;
02627 }
02628 case barq3d:{
02629 Barq3d->local_values(lcid, i, 0, 0);
02630 break;
02631 }
02632 case beam2d:
02633 case beam3d:
02634 case subsoilbeam:
02635 case spring_1:
02636 case spring_2:
02637 case spring_3:
02638 case spring_4:
02639 case spring_5:
02640 case spring_6:
02641 break;
02642 case planeelementlt:{
02643 Pelt->local_values(lcid, i, 0, 0);
02644 break;
02645 }
02646 case planeelementqt:{
02647 Peqt->local_values(lcid, i, 0, 0);
02648 break;
02649 }
02650 case planeelementrotlt:{
02651 Perlt->local_values(lcid, i, 0, 0);
02652 break;
02653 }
02654 case planeelementlq:{
02655 Pelq->local_values (lcid,i,0,0);
02656 break;
02657 }
02658 case planeelementqq:{
02659 Peqq->local_values(lcid, i, 0, 0);
02660 break;
02661 }
02662 case planeelementrotlq:{
02663 Perlq->local_values(lcid, i, 0, 0);
02664 break;
02665 }
02666 case planeelementsubqt:{
02667 Pesqt->local_values(lcid, i, 0, 0);
02668 break;
02669 }
02670 case planequadcontact:{
02671 break;
02672 }
02673 case cctel:{
02674 Cct->local_values(lcid, i, 0, 0);
02675 break;
02676 }
02677 case q4plateel:{
02678 Q4pl->local_values(lcid, i, 0, 0);
02679 break;
02680 }
02681 case subsoilplateq:{
02682 Splq->local_values(lcid, i, 0, 0);
02683 break;
02684 }
02685
02686
02687
02688
02689
02690
02691
02692
02693
02694
02695
02696
02697
02698
02699 case axisymmlt:{
02700 Asymlt->local_values(lcid, i, 0, 0);
02701 break;
02702 }
02703 case axisymmlq:{
02704 Asymlq->local_values(lcid, i, 0, 0);
02705 break;
02706 }
02707 case axisymmqq:{
02708 Asymqq->local_values(lcid, i, 0, 0);
02709 break;
02710 }
02711
02712 case lineartet:{
02713 Ltet->local_values(lcid, i, 0, 0);
02714 break;
02715 }
02716 case quadrtet:{
02717 Qtet->local_values(lcid, i, 0, 0);
02718 break;
02719 }
02720 case linearhex:{
02721 Lhex->local_values(lcid, i, 0, 0);
02722 break;
02723 }
02724 case quadrhex:{
02725 Qhex->local_values(lcid, i, 0, 0);
02726 break;
02727 }
02728 case lineartetrot:{
02729 Ltetrot->local_values(lcid, i, 0, 0);
02730 break;
02731 }
02732 case linearhexrot:{
02733 Lhexrot->local_values(lcid, i, 0, 0);
02734 break;
02735 }
02736
02737 case particleelem:
02738 break;
02739 default:
02740 print_err("unknown element type is required", __FILE__, __LINE__, __func__);
02741 }
02742 }
02743
02744
02745
02746
02747
02748
02749
02750
02751
02752
02753
02754
02755
02756
02757
02758 void elem_nonloc_internal_forces (long i,long lcid,vector &ifor)
02759 {
02760 elemtype te;
02761 te = Mt->give_elem_type (i);
02762
02763 switch (te){
02764
02765 case bar2d:{
02766 Bar2d->res_nonloc_internal_forces (lcid,i,ifor);
02767 break;
02768 }
02769 case bar3d:{
02770 Bar3d->res_nonloc_internal_forces (lcid,i,ifor);
02771 break;
02772 }
02773 case barq2d:{
02774 Barq2d->res_nonloc_internal_forces (lcid,i,ifor);
02775 break;
02776 }
02777 case barq3d:{
02778 Barq3d->res_nonloc_internal_forces (lcid,i,ifor);
02779 break;
02780 }
02781 case beam2d:{
02782 Beam2d->res_internal_forces (lcid,i,ifor);
02783 break;
02784 }
02785 case beam3d:{
02786 Beam3d->res_internal_forces (lcid,i,ifor);
02787 break;
02788 }
02789 case subsoilbeam:{
02790 Sbeam->res_internal_forces (lcid,i,ifor);
02791 break;
02792 }
02793
02794 case spring_1:{
02795 Spring->res_internal_forces (lcid,i,ifor);
02796 break;
02797 }
02798 case spring_2:{
02799 Spring->res_internal_forces (lcid,i,ifor);
02800 break;
02801 }
02802 case spring_3:{
02803 Spring->res_internal_forces (lcid,i,ifor);
02804 break;
02805 }
02806 case spring_4:{
02807 Spring->res_internal_forces (lcid,i,ifor);
02808 break;
02809 }
02810 case spring_5:{
02811 Spring->res_internal_forces (lcid,i,ifor);
02812 break;
02813 }
02814 case spring_6:{
02815 Spring->res_internal_forces (lcid,i,ifor);
02816 break;
02817 }
02818
02819 case planeelementlt:{
02820 Pelt->res_nonloc_internal_forces (lcid,i,ifor);
02821 break;
02822 }
02823 case planeelementqt:{
02824 Peqt->res_nonloc_internal_forces (lcid,i,ifor);
02825 break;
02826 }
02827 case planeelementrotlt:{
02828 Perlt->res_nonloc_internal_forces (lcid,i,ifor);
02829 break;
02830 }
02831
02832 case planeelementlq:{
02833 Pelq->res_nonloc_internal_forces (lcid,i,ifor);
02834 break;
02835 }
02836 case planeelementqq:{
02837 Peqq->res_nonloc_internal_forces (lcid,i,ifor);
02838 break;
02839 }
02840 case planeelementrotlq:{
02841 Perlq->res_nonloc_internal_forces (lcid,i,ifor);
02842 break;
02843 }
02844
02845 case planeelementsubqt:{
02846 Pesqt->res_nonloc_internal_forces (lcid,i,ifor);
02847 break;
02848 }
02849
02850 case planequadcontact:{
02851 Pqcon->res_internal_forces (lcid,i,ifor);
02852 break;
02853 }
02854
02855 case cctel:{
02856 Cct->res_nonloc_internal_forces (lcid,i,ifor);
02857 break;
02858 }
02859
02860 case q4plateel:{
02861 Q4pl->res_nonloc_internal_forces (lcid,i,ifor);
02862 break;
02863 }
02864 case subsoilplateq:{
02865 Splq->res_nonloc_internal_forces (lcid,i,ifor);
02866 break;
02867 }
02868
02869
02870
02871
02872
02873
02874
02875
02876
02877
02878
02879
02880
02881
02882
02883 case axisymmlt:{
02884 Asymlt->res_nonloc_internal_forces (lcid,i,ifor);
02885 break;
02886 }
02887 case axisymmlq:{
02888 Asymlq->res_nonloc_internal_forces (lcid,i,ifor);
02889 break;
02890 }
02891 case axisymmqq:{
02892 Asymqq->res_nonloc_internal_forces (lcid,i,ifor);
02893 break;
02894 }
02895
02896 case lineartet:{
02897 Ltet->res_nonloc_internal_forces (lcid,i,ifor);
02898 break;
02899 }
02900 case quadrtet:{
02901 Qtet->res_nonloc_internal_forces (lcid,i,ifor);
02902 break;
02903 }
02904 case linearhex:{
02905 Lhex->res_nonloc_internal_forces (lcid,i,ifor);
02906 break;
02907 }
02908 case quadrhex:{
02909 Qhex->res_nonloc_internal_forces (lcid,i,ifor);
02910 break;
02911 }
02912 case lineartetrot:{
02913 Ltetrot->res_nonloc_internal_forces (lcid,i,ifor);
02914 break;
02915 }
02916 case linearhexrot:{
02917 Lhexrot->res_nonloc_internal_forces (lcid,i,ifor);
02918 break;
02919 }
02920
02921 case particleelem:{
02922 break;
02923 }
02924
02925 default:
02926 print_err("unknown element type is required", __FILE__, __LINE__, __func__);
02927 }
02928 }
02929
02930
02931
02932
02933
02934
02935
02936
02937
02938
02939
02940
02941
02942
02943
02944 void elem_incr_internal_forces (long i,long lcid,vector &ifor)
02945 {
02946 elemtype te;
02947 te = Mt->give_elem_type (i);
02948
02949 switch (te){
02950
02951 case bar2d:{
02952 Bar2d->res_incr_internal_forces (lcid,i,ifor);
02953 break;
02954 }
02955 case bar3d:{
02956 Bar3d->res_incr_internal_forces (lcid,i,ifor);
02957 break;
02958 }
02959 case barq2d:{
02960 Barq2d->res_incr_internal_forces (lcid,i,ifor);
02961 break;
02962 }
02963 case barq3d:{
02964 Barq3d->res_incr_internal_forces (lcid,i,ifor);
02965 break;
02966 }
02967
02968
02969
02970
02971
02972
02973
02974
02975
02976
02977
02978
02979
02980
02981
02982
02983 case spring_1:
02984 case spring_2:
02985 case spring_3:
02986 case spring_4:
02987 case spring_5:
02988 case spring_6:
02989 break;
02990
02991 case planeelementlt:{
02992 Pelt->res_incr_internal_forces (lcid,i,ifor);
02993 break;
02994 }
02995 case planeelementqt:{
02996 Peqt->res_incr_internal_forces (lcid,i,ifor);
02997 break;
02998 }
02999 case planeelementrotlt:{
03000 Perlt->res_incr_internal_forces (lcid,i,ifor);
03001 break;
03002 }
03003
03004 case planeelementlq:{
03005 Pelq->res_incr_internal_forces (lcid,i,ifor);
03006 break;
03007 }
03008 case planeelementqq:{
03009 Peqq->res_incr_internal_forces (lcid,i,ifor);
03010 break;
03011 }
03012 case planeelementrotlq:{
03013 Perlq->res_incr_internal_forces (lcid,i,ifor);
03014 break;
03015 }
03016
03017 case planeelementsubqt:{
03018 Pesqt->res_incr_internal_forces (lcid,i,ifor);
03019 break;
03020 }
03021
03022 case planequadcontact:{
03023 break;
03024 }
03025
03026 case cctel:{
03027 Cct->res_incr_internal_forces (lcid,i,ifor);
03028 break;
03029 }
03030
03031 case q4plateel:{
03032 Q4pl->res_incr_internal_forces (lcid,i,ifor);
03033 break;
03034 }
03035 case subsoilplateq:{
03036 Splq->res_incr_internal_forces (lcid,i,ifor);
03037 break;
03038 }
03039
03040 case axisymmlt:{
03041 Asymlt->res_incr_internal_forces (lcid,i,ifor);
03042 break;
03043 }
03044 case axisymmlq:{
03045 Asymlq->res_incr_internal_forces (lcid,i,ifor);
03046 break;
03047 }
03048 case axisymmqq:{
03049 Asymqq->res_incr_internal_forces (lcid,i,ifor);
03050 break;
03051 }
03052
03053
03054
03055
03056
03057
03058
03059
03060 case lineartet:{
03061 Ltet->res_incr_internal_forces (lcid,i,ifor);
03062 break;
03063 }
03064 case quadrtet:{
03065 Qtet->res_incr_internal_forces (lcid,i,ifor);
03066 break;
03067 }
03068 case linearhex:{
03069 Lhex->res_incr_internal_forces (lcid,i,ifor);
03070 break;
03071 }
03072 case quadrhex:{
03073 Qhex->res_incr_internal_forces (lcid,i,ifor);
03074 break;
03075 }
03076 case lineartetrot:{
03077 Ltetrot->res_incr_internal_forces (lcid,i,ifor);
03078 break;
03079 }
03080 case linearhexrot:{
03081 Lhexrot->res_incr_internal_forces (lcid,i,ifor);
03082 break;
03083 }
03084
03085
03086
03087
03088
03089
03090
03091 default:
03092 print_err("unknown element type is required",__FILE__,__LINE__,__func__);
03093 }
03094
03095 }
03096
03097
03098
03099
03100
03101
03102
03103
03104
03105
03106
03107
03108
03109
03110 void elem_eigstrain_forces (long lcid,long eid,vector &nfor)
03111 {
03112 switch (Mt->give_elem_type(eid)){
03113
03114 case bar2d:{
03115 Bar2d->res_eigstrain_forces (lcid,eid,nfor);
03116 break;
03117 }
03118 case bar3d:{
03119 Bar3d->res_eigstrain_forces (lcid,eid,nfor);
03120 break;
03121 }
03122 case barq2d:{
03123 Barq2d->res_eigstrain_forces (lcid,eid,nfor);
03124 break;
03125 }
03126 case barq3d:{
03127 Barq3d->res_eigstrain_forces (lcid,eid,nfor);
03128 break;
03129 }
03130
03131 case planeelementlt:{
03132 Pelt->res_eigstrain_forces (lcid,eid,nfor);
03133 break;
03134 }
03135 case planeelementqt:{
03136 Peqt->res_eigstrain_forces (lcid,eid,nfor);
03137 break;
03138 }
03139 case planeelementrotlt:{
03140 Perlt->res_eigstrain_forces (lcid,eid,nfor);
03141 break;
03142 }
03143
03144 case planeelementlq:{
03145 Pelq->res_eigstrain_forces (lcid,eid,nfor);
03146 break;
03147 }
03148 case planeelementqq:{
03149 Peqq->res_eigstrain_forces (lcid,eid,nfor);
03150 break;
03151 }
03152 case planeelementrotlq:{
03153 Perlq->res_eigstrain_forces (lcid,eid,nfor);
03154 break;
03155 }
03156 case planeelementsubqt:{
03157 Pesqt->res_eigstrain_forces (lcid,eid,nfor);
03158 break;
03159 }
03160 case planequadcontact:{
03161 break;
03162 }
03163
03164 case cctel:{
03165 Cct->res_eigstrain_forces (lcid,eid,nfor);
03166 break;
03167 }
03168 case q4plateel:{
03169 Q4pl->res_eigstrain_forces (lcid,eid,nfor);
03170 break;
03171 }
03172 case subsoilplateq:{
03173 Splq->res_eigstrain_forces (lcid,eid,nfor);
03174 break;
03175 }
03176
03177
03178 case axisymmlt:{
03179 Asymlt->res_eigstrain_forces (lcid,eid,nfor);
03180 break;
03181 }
03182 case axisymmlq:{
03183 Asymlq->res_eigstrain_forces (lcid,eid,nfor);
03184 break;
03185 }
03186 case axisymmqq:{
03187 Asymqq->res_eigstrain_forces (lcid,eid,nfor);
03188 break;
03189 }
03190
03191 case lineartet:{
03192 Ltet->res_eigstrain_forces (lcid,eid,nfor);
03193 break;
03194 }
03195 case quadrtet:{
03196 Qtet->res_eigstrain_forces (lcid,eid,nfor);
03197 break;
03198 }
03199 case linearhex:{
03200 Lhex->res_eigstrain_forces (lcid,eid,nfor);
03201 break;
03202 }
03203 case quadrhex:{
03204 Qhex->res_eigstrain_forces (lcid,eid,nfor);
03205 break;
03206 }
03207 case lineartetrot:{
03208 Ltetrot->res_eigstrain_forces (lcid,eid,nfor);
03209 break;
03210 }
03211 case linearhexrot:{
03212 Lhexrot->res_eigstrain_forces (lcid,eid,nfor);
03213 break;
03214 }
03215 case spring_1:
03216 case spring_2:
03217 case spring_3:
03218 case spring_4:
03219 case spring_5:
03220 case spring_6:
03221 break;
03222
03223 default:
03224 print_err("unknown element type is required", __FILE__, __LINE__, __func__);
03225 }
03226 }
03227
03228
03229
03230
03231
03232
03233
03234
03235
03236
03237
03238
03239
03240
03241 void stiffmat (long lcid,long eid,matrix &sm)
03242 {
03243 elemtype te;
03244
03245 te = Mt->give_elem_type (eid);
03246
03247 switch (te){
03248
03249 case bar2d:{
03250 Bar2d->res_stiffness_matrix (eid,sm);
03251 break;
03252 }
03253 case bar3d:{
03254 Bar3d->res_stiffness_matrix (eid,sm);
03255 break;
03256 }
03257 case barq2d:{
03258 Barq2d->res_stiffness_matrix (eid,sm);
03259 break;
03260 }
03261 case barq3d:{
03262 Barq3d->res_stiffness_matrix (eid,sm);
03263 break;
03264 }
03265 case beam2d:{
03266 Beam2d->res_stiffness_matrix (eid,sm);
03267 break;
03268 }
03269 case beam3d:{
03270 Beam3d->res_stiffness_matrix (eid,sm);
03271 break;
03272 }
03273 case beamg3d:{
03274 Beam3dg->res_stiffness_matrix (eid,sm);
03275 break;
03276 }
03277 case subsoilbeam:{
03278 Sbeam->res_stiffness_matrix (eid,sm);
03279 break;
03280 }
03281
03282 case spring_1:{
03283 Spring->res_stiffness_matrix (eid,sm);
03284 break;
03285 }
03286 case spring_2:{
03287 Spring->res_stiffness_matrix (eid,sm);
03288 break;
03289 }
03290 case spring_3:{
03291 Spring->res_stiffness_matrix (eid,sm);
03292 break;
03293 }
03294 case spring_4:{
03295 Spring->res_stiffness_matrix (eid,sm);
03296 break;
03297 }
03298 case spring_5:{
03299 Spring->res_stiffness_matrix (eid,sm);
03300 break;
03301 }
03302 case spring_6:{
03303 Spring->res_stiffness_matrix (eid,sm);
03304 break;
03305 }
03306
03307 case planeelementlt:{
03308 Pelt->res_stiffness_matrix (eid,sm);
03309 break;
03310 }
03311 case planeelementqt:{
03312 Peqt->res_stiffness_matrix (eid,sm);
03313 break;
03314 }
03315 case planeelementrotlt:{
03316 Perlt->res_stiffness_matrix (eid,sm);
03317 break;
03318 }
03319
03320 case planeelementlq:{
03321 Pelq->res_stiffness_matrix (lcid,eid,sm);
03322 break;
03323 }
03324 case planeelementqq:{
03325 Peqq->res_stiffness_matrix (eid,sm);
03326 break;
03327 }
03328 case planeelementrotlq:{
03329 Perlq->res_stiffness_matrix (eid,sm);
03330 break;
03331 }
03332
03333 case planeelementsubqt:{
03334 Pesqt->res_stiffness_matrix (eid,sm);
03335 break;
03336 }
03337
03338 case planequadcontact:{
03339 Pqcon->res_stiffness_matrix (eid,sm);
03340 break;
03341 }
03342
03343 case cctel:{
03344 Cct->res_stiffness_matrix (eid,sm);
03345 break;
03346 }
03347 case dktel:{
03348 Dkt->res_stiffness_matrix (eid,sm);
03349 break;
03350 }
03351 case dstel:{
03352 Dst->res_stiffness_matrix (eid,sm);
03353 break;
03354 }
03355 case q4plateel:{
03356 Q4pl->res_stiffness_matrix (eid,sm);
03357 break;
03358 }
03359 case argyristr:{
03360
03361 Argtrpl->res_stiffness_matrix (eid,sm);
03362 break;
03363 }
03364
03365 case subsoilplatetr:{
03366 Spltr->res_stiffness_matrix (eid,sm);
03367 break;
03368 }
03369 case subsoilplateq:{
03370 Splq->res_stiffness_matrix (eid,sm);
03371 break;
03372 }
03373
03374 case axisymmlt:{
03375 Asymlt->res_stiffness_matrix (eid,sm);
03376 break;
03377 }
03378 case axisymmlq:{
03379 Asymlq->res_stiffness_matrix (eid,sm);
03380 break;
03381 }
03382 case axisymmqq:{
03383 Asymqq->res_stiffness_matrix (eid,sm);
03384 break;
03385 }
03386
03387 case shelltrelem:{
03388 Shtr->res_stiffness_matrix (eid,sm);
03389 break;
03390 }
03391 case shellqelem:{
03392 Shq->res_stiffness_matrix (eid,sm);
03393 break;
03394 }
03395
03396 case lineartet:{
03397 Ltet->res_stiffness_matrix (eid,sm);
03398 break;
03399 }
03400 case quadrtet:{
03401 Qtet->res_stiffness_matrix (eid,sm);
03402 break;
03403 }
03404 case linearhex:{
03405 Lhex->res_stiffness_matrix (lcid,eid,sm);
03406 break;
03407 }
03408 case quadrhex:{
03409 Qhex->res_stiffness_matrix (eid,sm);
03410 break;
03411 }
03412 case lineartetrot:{
03413 Ltetrot->res_stiffness_matrix (eid,sm);
03414 break;
03415 }
03416 case linearhexrot:{
03417 Lhexrot->res_stiffness_matrix (lcid,eid,sm);
03418 break;
03419 }
03420 case linearwed:{
03421 Lwed->res_stiffness_matrix (eid,sm);
03422 break;
03423 }
03424 case quadrwed:{
03425 Qwed->res_stiffness_matrix (eid,sm);
03426 break;
03427 }
03428
03429 case particleelem:{
03430 Pelem->res_stiffness_matrix (eid,sm);
03431 break;
03432 }
03433 default:
03434 print_err("unknown element type is required", __FILE__, __LINE__, __func__);
03435 }
03436 }
03437
03438
03439
03440
03441
03442
03443
03444
03445
03446
03447
03448
03449
03450
03451 void massmat (long lcid,long eid,matrix &mm)
03452 {
03453 elemtype te;
03454
03455 te = Mt->give_elem_type (eid);
03456
03457 switch (te){
03458
03459 case bar2d:{
03460 Bar2d->mass_matrix (eid,mm);
03461 break;
03462 }
03463
03464
03465
03466
03467
03468
03469 case beam2d:{
03470 Beam2d->res_mass_matrix (eid,mm);
03471 break;
03472 }
03473 case bar3d:{
03474 Bar3d->res_mass_matrix (eid,mm);
03475 break;
03476 }
03477 case beam3d:{
03478 Beam3d->res_mass_matrix (eid,mm);
03479 break;
03480 }
03481
03482 case spring_1:
03483 case spring_2:
03484 case spring_3:
03485 case spring_4:
03486 case spring_5:
03487 case spring_6:
03488 break;
03489
03490 case planeelementlt:{
03491 Pelt->res_mass_matrix (eid,mm);
03492 break;
03493 }
03494 case planeelementqt:{
03495 Peqt->mass_matrix (eid,mm);
03496 break;
03497 }
03498 case planeelementrotlt:{
03499 Perlt->res_mass_matrix (eid,mm);
03500 break;
03501 }
03502 case planeelementlq:{
03503 Pelq->res_mass_matrix (eid,mm);
03504 break;
03505 }
03506 case planeelementqq:{
03507 Peqq->res_mass_matrix (eid,mm);
03508 break;
03509 }
03510 case planeelementrotlq:{
03511 Perlq->res_mass_matrix (eid,mm);
03512 break;
03513 }
03514
03515 case planeelementsubqt:{
03516 Pesqt->res_mass_matrix (eid,mm);
03517 break;
03518 }
03519
03520 case cctel:{
03521 Cct->res_mass_matrix (eid,mm);
03522 break;
03523 }
03524
03525 case axisymmlt:{
03526 Asymlt->mass_matrix (eid,mm);
03527 break;
03528 }
03529 case axisymmlq:{
03530 Asymlq->mass_matrix (eid,mm);
03531 break;
03532 }
03533 case axisymmqq:{
03534 Asymqq->mass_matrix (eid,mm);
03535 break;
03536 }
03537
03538 case lineartet:{
03539 Ltet->mass_matrix (eid,mm);
03540 break;
03541 }
03542 case quadrtet:{
03543 Qtet->mass_matrix (eid,mm);
03544 break;
03545 }
03546 case linearhex:{
03547 Lhex->mass_matrix (eid,mm);
03548 break;
03549 }
03550 case quadrhex:{
03551 Qhex->mass_matrix (eid,mm);
03552 break;
03553 }
03554 case lineartetrot:{
03555 Ltetrot->mass_matrix (eid,mm);
03556 break;
03557 }
03558 case linearhexrot:{
03559 Lhexrot->mass_matrix (eid,mm);
03560 break;
03561 }
03562
03563 default:
03564 print_err("unknown element type is required", __FILE__, __LINE__, __func__);
03565 }
03566 }
03567
03568
03569
03570
03571
03572
03573
03574
03575
03576
03577
03578
03579
03580
03581 void initstiffmat (long lcid,long eid,matrix &sm)
03582 {
03583 elemtype te;
03584
03585 te = Mt->give_elem_type (eid);
03586
03587 switch (te){
03588
03589 case beam2d:{
03590 Beam2d->initstr_matrix_expl (eid,0,0,sm);
03591 break;
03592 }
03593
03594 default:{
03595 print_err("unknown element type is required", __FILE__, __LINE__, __func__);
03596 }
03597 }
03598
03599 }
03600
03601
03602
03603
03604
03605
03606
03607
03608
03609
03610
03611
03612
03613 void loadmat (long eid,matrix &lm)
03614 {
03615 switch (Mt->give_elem_type (eid)){
03616 case bar2d:{
03617 Bar2d->res_load_matrix (eid,lm);
03618 break;
03619 }
03620 case beam3d:{
03621 Beam3d->load_matrix (eid,lm);
03622 break;
03623 }
03624
03625 case planeelementlt:{
03626 Pelt->res_load_matrix (eid,lm);
03627 break;
03628 }
03629 case planeelementqt:{
03630 Peqt->load_matrix (eid,lm);
03631 break;
03632 }
03633 case planeelementlq:{
03634 Pelq->res_load_matrix (eid,lm);
03635 break;
03636 }
03637 case planeelementqq:{
03638 Peqq->res_load_matrix (eid,lm);
03639 break;
03640 }
03641 case planeelementrotlt:{
03642 Perlt->load_matrix (eid,lm);
03643 break;
03644 }
03645
03646 case cctel:{
03647 Cct->load_matrix (eid,lm);
03648 break;
03649 }
03650 case q4plateel:{
03651 Q4pl->load_matrix (eid,lm);
03652 break;
03653 }
03654
03655 case axisymmlt:{
03656 Asymlt->load_matrix (eid,lm);
03657 break;
03658 }
03659 case axisymmlq:{
03660 Asymlq->load_matrix (eid,lm);
03661 break;
03662 }
03663 case axisymmqq:{
03664 Asymqq->load_matrix (eid,lm);
03665 break;
03666 }
03667
03668 case lineartet:{
03669 Ltet->load_matrix (eid,lm);
03670 break;
03671 }
03672 case quadrtet:{
03673 Qtet->load_matrix (eid,lm);
03674 break;
03675 }
03676 case linearhex:{
03677 Lhex->load_matrix (eid,lm);
03678 break;
03679 }
03680 case quadrhex:{
03681 Qhex->load_matrix (eid,lm);
03682 break;
03683 }
03684 default:
03685 print_err("unknown element type is required", __FILE__, __LINE__, __func__);
03686 }
03687 }
03688
03689
03690
03691
03692
03693
03694
03695
03696
03697
03698
03699
03700
03701
03702
03703
03704
03705 void elem_mechq_nodval(long eid, vector &nodval, nontransquant qt)
03706 {
03707 elemtype te;
03708
03709 te = Mt->give_elem_type (eid);
03710
03711 switch (te){
03712 case bar2d:{
03713 Bar2d->mechq_nodval (eid,nodval,qt);
03714 break;
03715 }
03716 case planeelementlq:{
03717 Pelq->mechq_nodval (eid,nodval,qt);
03718 break;
03719 }
03720 default:{
03721 print_err("unknown element type is required", __FILE__, __LINE__, __func__);
03722 }
03723 }
03724 }
03725
03726
03727
03728
03729
03730
03731
03732
03733
03734
03735
03736
03737
03738
03739
03740
03741
03742
03743
03744
03745
03746 void elem_mechq_nodval_comp(long eid, vector &nodval, long ncne, long nq, nontransquant *qt)
03747 {
03748 elemtype te;
03749
03750 te = Mt->give_elem_type (eid);
03751
03752 switch (te){
03753 case bar2d:{
03754 Bar2d->mechq_nodval_comp (eid,nodval,ncne,nq,qt);
03755 break;
03756 }
03757 case planeelementlq:{
03758 Pelq->mechq_nodval_comp (eid,nodval,ncne,nq,qt);
03759 break;
03760 }
03761 default:{
03762 print_err("unknown element type is required", __FILE__, __LINE__, __func__);
03763 }
03764 }
03765 }
03766