00001 #include "elemswitcht.h"
00002 #include "globalt.h"
00003 #include "globmatt.h"
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013 void conductmat (long eid,long lcid,matrix &km)
00014 {
00015 elemtypet te;
00016
00017 te=Tt->give_elem_type (eid);
00018
00019 switch (te){
00020 case barlint:{
00021 Lbt->res_conductivity_matrix (eid,lcid,km);
00022 break;
00023 }
00024 case barlintax:{
00025 Lbat->res_conductivity_matrix (eid,lcid,km);
00026 break;
00027 }
00028 case barquadt:{
00029 Qbt->res_conductivity_matrix (eid,lcid,km);
00030 break;
00031 }
00032 case barquadtax:{
00033 Qbat->res_conductivity_matrix (eid,lcid,km);
00034 break;
00035 }
00036 case trlint:{
00037 Ltt->res_conductivity_matrix (eid,lcid,km);
00038 break;
00039 }
00040 case trlaxisym:{
00041 Ltat->res_conductivity_matrix (eid,lcid,km);
00042 break;
00043 }
00044 case quadlint:{
00045 Lqt->res_conductivity_matrix (eid,lcid,km);
00046 break;
00047 }
00048 case quadquadt:{
00049 Qqt->res_conductivity_matrix (eid,lcid,km);
00050 break;
00051 }
00052 case quadquadtax:{
00053 Qqat->res_conductivity_matrix (eid,lcid,km);
00054 break;
00055 }
00056 case quadlaxisym:{
00057 Lqat->res_conductivity_matrix (eid,lcid,km);
00058 break;
00059 }
00060 case lineartett:{
00061 Ltett->res_conductivity_matrix (eid,lcid,km);
00062 break;
00063 }
00064 case linearhext:{
00065 Lht->res_conductivity_matrix (eid,lcid,km);
00066 break;
00067 }
00068 case quadratichext:{
00069 Qht->res_conductivity_matrix (eid,lcid,km);
00070 break;
00071 }
00072 default:{
00073 print_err("unknown element type is required", __FILE__, __LINE__, __func__);
00074 }
00075 }
00076
00077 }
00078
00079
00080
00081
00082
00083
00084
00085
00086
00087 void capacmat (long eid,long lcid,matrix &cm)
00088 {
00089 elemtypet te;
00090
00091 te=Tt->give_elem_type (eid);
00092
00093 switch (te){
00094 case barlint:{
00095 Lbt->res_capacity_matrix (eid,cm);
00096 break;
00097 }
00098 case barlintax:{
00099 Lbat->res_capacity_matrix (eid,cm);
00100 break;
00101 }
00102 case barquadt:{
00103 Qbt->res_capacity_matrix (eid,cm);
00104 break;
00105 }
00106 case barquadtax:{
00107 Qbat->res_capacity_matrix (eid,cm);
00108 break;
00109 }
00110 case trlint:{
00111 Ltt->res_capacity_matrix (eid,cm);
00112 break;
00113 }
00114 case trlaxisym:{
00115 Ltat->res_capacity_matrix (eid,cm);
00116 break;
00117 }
00118 case quadlint:{
00119 Lqt->res_capacity_matrix (eid,cm);
00120 break;
00121 }
00122 case quadquadt:{
00123 Qqt->res_capacity_matrix (eid,cm);
00124 break;
00125 }
00126 case quadquadtax:{
00127 Qqat->res_capacity_matrix (eid,cm);
00128 break;
00129 }
00130 case quadlaxisym:{
00131 Lqat->res_capacity_matrix (eid,cm);
00132 break;
00133 }
00134 case lineartett:{
00135 Ltett->res_capacity_matrix (eid,cm);
00136 break;
00137 }
00138 case linearhext:{
00139 Lht->res_capacity_matrix (eid,cm);
00140 break;
00141 }
00142 case quadratichext:{
00143 Qht->res_capacity_matrix (eid,cm);
00144 break;
00145 }
00146 default:{
00147 print_err("unknown element type is required", __FILE__, __LINE__, __func__);
00148 }
00149 }
00150 }
00151
00152
00153
00154
00155
00156
00157
00158
00159
00160
00161 void intpointvalues (long eid)
00162 {
00163 elemtypet te;
00164
00165 te=Tt->give_elem_type (eid);
00166
00167 switch (te){
00168 case barlint:{
00169 Lbt->intpointval (eid);
00170 break;
00171 }
00172 case barlintax:{
00173 Lbat->intpointval (eid);
00174 break;
00175 }
00176 case barquadt:{
00177 Qbt->intpointval (eid);
00178 break;
00179 }
00180 case barquadtax:{
00181 Qbat->intpointval (eid);
00182 break;
00183 }
00184 case trlint:{
00185 Ltt->intpointval (eid);
00186 break;
00187 }
00188 case trlaxisym:{
00189 Ltat->intpointval (eid);
00190 break;
00191 }
00192 case quadlint:{
00193 Lqt->intpointval (eid);
00194 break;
00195 }
00196 case quadquadt:{
00197 Qqt->intpointval (eid);
00198 break;
00199 }
00200 case quadquadtax:{
00201 Qqat->intpointval (eid);
00202 break;
00203 }
00204 case quadlaxisym:{
00205 Lqat->intpointval (eid);
00206 break;
00207 }
00208 case lineartett:{
00209 Ltett->intpointval (eid);
00210 break;
00211 }
00212 case linearhext:{
00213 Lht->intpointval (eid);
00214 break;
00215 }
00216 case quadratichext:{
00217 Qht->intpointval (eid);
00218 break;
00219 }
00220 default:{
00221 print_err("unknown element type is required",__FILE__,__LINE__,__func__);
00222 }
00223 }
00224
00225 }
00226
00227
00228
00229
00230
00231
00232
00233
00234
00235
00236 void intpointvalues_puc (long eid)
00237 {
00238 elemtypet te;
00239
00240 te=Tt->give_elem_type (eid);
00241
00242 switch (te){
00243 case trlint:{
00244 Ltt->intpointval_puc (eid);
00245 break;
00246 }
00247 case quadlint:{
00248 Lqt->intpointval_puc (eid);
00249 break;
00250 }
00251 case lineartett:{
00252 Ltett->intpointval_puc (eid);
00253 break;
00254 }
00255 case linearhext:{
00256 Lht->intpointval_puc (eid);
00257 break;
00258 }
00259 default:{
00260 print_err("unknown element type is required",__FILE__,__LINE__,__func__);
00261 }
00262 }
00263
00264 }
00265
00266
00267
00268
00269
00270
00271
00272
00273
00274 void intpointgradients (long eid)
00275 {
00276 elemtypet te;
00277
00278 te=Tt->give_elem_type (eid);
00279
00280 switch (te){
00281 case barlint:{
00282 Lbt->intpointgrad (eid);
00283 break;
00284 }
00285 case barlintax:{
00286 Lbat->intpointgrad (eid);
00287 break;
00288 }
00289 case barquadt:{
00290 Qbt->intpointgrad (eid);
00291 break;
00292 }
00293 case barquadtax:{
00294 Qbat->intpointgrad (eid);
00295 break;
00296 }
00297 case trlint:{
00298 Ltt->intpointgrad (eid);
00299 break;
00300 }
00301 case trlaxisym:{
00302 Ltat->intpointgrad (eid);
00303 break;
00304 }
00305 case quadlint:{
00306 Lqt->intpointgrad (eid);
00307 break;
00308 }
00309 case quadquadt:{
00310 Qqt->intpointgrad (eid);
00311 break;
00312 }
00313 case quadquadtax:{
00314 Qqat->intpointgrad (eid);
00315 break;
00316 }
00317 case quadlaxisym:{
00318 Lqat->intpointgrad (eid);
00319 break;
00320 }
00321 case lineartett:{
00322 Ltett->intpointgrad (eid);
00323 break;
00324 }
00325 case linearhext:{
00326 Lht->intpointgrad (eid);
00327 break;
00328 }
00329 case quadratichext:{
00330 Qht->intpointgrad (eid);
00331 break;
00332 }
00333 default:{
00334 print_err("unknown element type is required",__FILE__,__LINE__,__func__);
00335 }
00336 }
00337
00338 }
00339
00340
00341
00342
00343
00344
00345
00346
00347
00348 void intpointfluxes (long eid)
00349 {
00350 elemtypet te;
00351
00352 te=Tt->give_elem_type (eid);
00353
00354 switch (te){
00355 case barlint:{
00356 Lbt->intpointflux (eid);
00357 break;
00358 }
00359 case barlintax:{
00360
00361 break;
00362 }
00363 case barquadt:{
00364
00365 break;
00366 }
00367 case barquadtax:{
00368
00369 break;
00370 }
00371 case trlint:{
00372
00373 break;
00374 }
00375 case trlaxisym:{
00376
00377 break;
00378 }
00379 case quadlint:{
00380 Lqt->intpointflux (eid);
00381 break;
00382 }
00383 case quadquadt:{
00384 Qqt->intpointflux (eid);
00385 break;
00386 }
00387 case quadquadtax:{
00388
00389 break;
00390 }
00391 case quadlaxisym:{
00392
00393 break;
00394 }
00395 case lineartett:{
00396
00397 break;
00398 }
00399 case linearhext:{
00400 Lht->intpointflux (eid);
00401 break;
00402 }
00403 case quadratichext:{
00404
00405 break;
00406 }
00407 default:{
00408 print_err("unknown element type is required",__FILE__,__LINE__,__func__);
00409 }
00410 }
00411
00412 }
00413
00414
00415
00416
00417
00418
00419
00420
00421
00422
00423 void averageflux (long lcid,long eid,vector &fl)
00424 {
00425 elemtypet te;
00426
00427 te=Tt->give_elem_type (eid);
00428
00429 switch (te){
00430 case barlint:{
00431
00432 break;
00433 }
00434 case barlintax:{
00435
00436 break;
00437 }
00438 case barquadt:{
00439
00440 break;
00441 }
00442 case barquadtax:{
00443
00444 break;
00445 }
00446 case trlint:{
00447
00448 break;
00449 }
00450 case trlaxisym:{
00451
00452 break;
00453 }
00454 case quadlint:{
00455
00456 break;
00457 }
00458 case quadquadt:{
00459
00460 break;
00461 }
00462 case quadquadtax:{
00463
00464 break;
00465 }
00466 case quadlaxisym:{
00467
00468 break;
00469 }
00470 case lineartett:{
00471
00472 break;
00473 }
00474 case linearhext:{
00475 Lht->average_flux (lcid,eid,fl);
00476 break;
00477 }
00478 case quadratichext:{
00479
00480 break;
00481 }
00482 default:{
00483 print_err("unknown element type is required",__FILE__,__LINE__,__func__);
00484 }
00485 }
00486
00487 }
00488
00489
00490
00491
00492
00493
00494
00495
00496
00497 void intpointothers (long eid)
00498 {
00499 elemtypet te;
00500
00501 te=Tt->give_elem_type (eid);
00502
00503 switch (te){
00504 case barlint:{
00505 Lbt->intpointother (eid);
00506 break;
00507 }
00508 case barlintax:{
00509 Lbat->intpointother (eid);
00510 break;
00511 }
00512 case barquadt:{
00513 Qbt->intpointother (eid);
00514 break;
00515 }
00516 case barquadtax:{
00517 Qbat->intpointother (eid);
00518 break;
00519 }
00520 case trlint:{
00521 Ltt->intpointother (eid);
00522 break;
00523 }
00524 case trlaxisym:{
00525 Ltat->intpointother (eid);
00526 break;
00527 }
00528 case quadlint:{
00529 Lqt->intpointother (eid);
00530 break;
00531 }
00532 case quadquadt:{
00533 Qqt->intpointother (eid);
00534 break;
00535 }
00536 case quadquadtax:{
00537 Qqat->intpointother (eid);
00538 break;
00539 }
00540 case quadlaxisym:{
00541 Lqat->intpointother (eid);
00542 break;
00543 }
00544 case lineartett:{
00545 Ltett->intpointother (eid);
00546 break;
00547 }
00548 case linearhext:{
00549 Lht->intpointother (eid);
00550 break;
00551 }
00552 case quadratichext:{
00553 Qht->intpointother (eid);
00554 break;
00555 }
00556 default:{
00557 print_err("unknown element type is required",__FILE__,__LINE__,__func__);
00558 }
00559 }
00560
00561 }
00562
00563
00564
00565
00566
00567
00568
00569
00570 void intpointeqothers (long eid)
00571 {
00572 elemtypet te;
00573
00574 te=Tt->give_elem_type (eid);
00575
00576 switch (te){
00577 case barlint:{
00578
00579 break;
00580 }
00581 case barlintax:{
00582
00583 break;
00584 }
00585 case barquadt:{
00586
00587 break;
00588 }
00589 case barquadtax:{
00590
00591 break;
00592 }
00593 case trlint:{
00594
00595 break;
00596 }
00597 case trlaxisym:{
00598
00599 break;
00600 }
00601 case quadlint:{
00602
00603 break;
00604 }
00605 case quadquadt:{
00606
00607 break;
00608 }
00609 case quadquadtax:{
00610
00611 break;
00612 }
00613 case quadlaxisym:{
00614
00615 break;
00616 }
00617 case lineartett:{
00618
00619 break;
00620 }
00621 case linearhext:{
00622
00623 break;
00624 }
00625 case quadratichext:{
00626
00627 break;
00628 }
00629 default:{
00630 print_err("unknown element type is required",__FILE__,__LINE__,__func__);
00631 }
00632 }
00633
00634 }
00635
00636
00637
00638
00639
00640
00641
00642
00643
00644
00645
00646
00647 void source_vector (long lcid,long eid,vector &nodval,vector &lv)
00648 {
00649 elemtypet te;
00650
00651
00652 te=Tt->elements[eid].te;
00653
00654 switch (te){
00655 case barlint:{
00656 Lbt->res_quantity_source_vector (lv,nodval,lcid,eid);
00657 break;
00658 }
00659 case barlintax:{
00660 Lbat->res_quantity_source_vector (lv,nodval,lcid,eid);
00661 break;
00662 }
00663 case trlint:{
00664 Ltt->res_quantity_source_vector (lv,nodval,lcid,eid);
00665 break;
00666 }
00667 case trlaxisym:{
00668 Ltat->res_quantity_source_vector (lv,nodval,lcid,eid);
00669 break;
00670 }
00671 case quadlint:{
00672 Lqt->res_quantity_source_vector (lv,nodval,lcid,eid);
00673 break;
00674 }
00675 case quadlaxisym:{
00676 Lqat->res_quantity_source_vector (lv,nodval,lcid,eid);
00677 break;
00678 }
00679 case quadquadt:{
00680 Qqt->res_quantity_source_vector (lv,nodval,lcid,eid);
00681 break;
00682 }
00683 case quadquadtax:{
00684 Qqat->res_quantity_source_vector (lv,nodval,lcid,eid);
00685 break;
00686 }
00687 case lineartett:{
00688 Ltett->res_quantity_source_vector (lv,nodval,lcid,eid);
00689 break;
00690 }
00691 case linearhext:{
00692 Lht->res_quantity_source_vector (lv,nodval,lcid,eid);
00693 break;
00694 }
00695 case quadratichext:{
00696 Qht->res_quantity_source_vector (lv,nodval,lcid,eid);
00697 break;
00698 }
00699 default:{
00700 print_err("unknown element type is required", __FILE__, __LINE__, __func__);
00701 }
00702 }
00703
00704 }
00705
00706
00707
00708
00709
00710
00711
00712
00713
00714
00715
00716
00717
00718 void compute_ipfluxes ()
00719 {
00720 long i,ne;
00721
00722
00723 ne=Tt->ne;
00724
00725 for (i=0;i<ne;i++){
00726 if (Gtt->leso[i]==1){
00727
00728 intpointfluxes (i);
00729 }
00730 }
00731 }
00732
00733
00734
00735
00736
00737
00738
00739
00740
00741
00742
00743
00744 void compute_average_fluxes (long lcid, vector &fl)
00745 {
00746 long i,ne;
00747
00748
00749 ne=Tt->ne;
00750
00751 nullv (fl.a,fl.n);
00752
00753 for (i=0;i<ne;i++){
00754 if (Gtt->leso[i]==1){
00755
00756 averageflux (lcid,i,fl);
00757 }
00758 }
00759 }
00760
00761
00762
00763
00764
00765
00766
00767
00768
00769
00770
00771
00772 void compute_ipgrads ()
00773 {
00774
00775 for (long i=0; i<Gtt->ne; i++)
00776 if (Gtt->leso[i])
00777
00778 intpointgradients (i);
00779
00780 }
00781
00782
00783
00784
00785
00786
00787
00788
00789
00790
00791
00792
00793 void compute_ipotherst ()
00794 {
00795 long i,ne;
00796
00797
00798 ne=Tt->ne;
00799
00800 for (i=0;i<ne;i++){
00801 if (Gtt->leso[i]==1){
00802
00803 intpointothers (i);
00804 }
00805 }
00806
00807 }
00808
00809
00810
00811
00812
00813
00814
00815
00816
00817
00818
00819
00820 void compute_ipeqotherst ()
00821 {
00822 long i,ne;
00823
00824
00825 ne=Tt->ne;
00826
00827 for (i=0;i<ne;i++){
00828 if (Gtt->leso[i]==1){
00829
00830 intpointeqothers (i);
00831 }
00832 }
00833
00834 }
00835
00836
00837
00838
00839
00840
00841
00842
00843
00844
00845
00846
00847
00848 void compute_nodegrads ()
00849 {
00850 long i;
00851 elemtypet te;
00852
00853 for (i=0;i<Tt->nn;i++){
00854 Tt->nodes[i].nullgrad();
00855 }
00856
00857 for (i=0;i<Tt->ne;i++){
00858 if (Gtt->leso[i]==1){
00859
00860 te = Tt->give_elem_type (i);
00861
00862 switch (te){
00863 case barlint:{
00864 Lbt->nod_grads_ip (i);
00865 break;
00866 }
00867 case barlintax:{
00868
00869 break;
00870 }
00871 case barquadt:{
00872
00873 break;
00874 }
00875 case barquadtax:{
00876
00877 break;
00878 }
00879 case quadlint:{
00880 Lqt->nod_grads_ip (i);
00881 break;
00882 }
00883 case trlint:{
00884
00885 break;
00886 }
00887 case trlaxisym:{
00888
00889 break;
00890 }
00891 case quadquadt:{
00892
00893 break;
00894 }
00895 case quadquadtax:{
00896
00897 break;
00898 }
00899 case quadlaxisym:{
00900
00901 break;
00902 }
00903 case lineartett:{
00904
00905 break;
00906 }
00907 case linearhext:{
00908
00909 break;
00910 }
00911 case quadratichext:{
00912
00913 break;
00914 }
00915 default:{
00916 print_err("unknown element type is required",__FILE__,__LINE__,__func__);
00917 }
00918 }
00919 }
00920 }
00921
00922 for (i=0;i<Tt->nn;i++){
00923 Tt->nodes[i].grad_averageval ();
00924 }
00925 }
00926
00927
00928
00929
00930
00931
00932
00933
00934
00935
00936
00937
00938
00939 void compute_nodefluxes ()
00940 {
00941 long i;
00942 elemtypet te;
00943
00944 for (i=0;i<Tt->nn;i++){
00945 Tt->nodes[i].nullflux();
00946 }
00947
00948 for (i=0;i<Tt->ne;i++){
00949 if (Gtt->leso[i]==1){
00950
00951 te = Tt->give_elem_type (i);
00952
00953 switch (te){
00954 case barlint:{
00955 Lbt->nod_fluxes_ip (i);
00956 break;
00957 }
00958 case barlintax:{
00959
00960 break;
00961 }
00962 case barquadt:{
00963
00964 break;
00965 }
00966 case barquadtax:{
00967
00968 break;
00969 }
00970 case quadlint:{
00971 Lqt->nod_fluxes_ip (i);
00972 break;
00973 }
00974 case trlint:{
00975
00976 break;
00977 }
00978 case trlaxisym:{
00979
00980 break;
00981 }
00982 case quadquadt:{
00983
00984 break;
00985 }
00986 case quadquadtax:{
00987
00988 break;
00989 }
00990 case quadlaxisym:{
00991
00992 break;
00993 }
00994 case lineartett:{
00995
00996 break;
00997 }
00998 case linearhext:{
00999
01000 break;
01001 }
01002 case quadratichext:{
01003
01004 break;
01005 }
01006 default:{
01007 print_err("unknown element type is required",__FILE__,__LINE__,__func__);
01008 }
01009 }
01010 }
01011 }
01012
01013 for (i=0;i<Tt->nn;i++){
01014 Tt->nodes[i].flux_averageval ();
01015 }
01016 }
01017
01018
01019
01020
01021
01022
01023
01024
01025
01026
01027
01028
01029
01030 void compute_nodeotherst ()
01031 {
01032 long i;
01033 elemtypet te;
01034
01035 for (i=0;i<Tt->nn;i++){
01036 Tt->nodes[i].nullother();
01037 }
01038
01039 for (i=0;i<Tt->ne;i++){
01040 if (Gtt->leso[i]==1){
01041
01042 te = Tt->give_elem_type (i);
01043
01044 switch (te){
01045 case barlint:{
01046
01047 break;
01048 }
01049 case barlintax:{
01050
01051 break;
01052 }
01053 case barquadt:{
01054
01055 break;
01056 }
01057 case barquadtax:{
01058
01059 break;
01060 }
01061 case quadlint:{
01062
01063 break;
01064 }
01065 case trlint:{
01066
01067 break;
01068 }
01069 case trlaxisym:{
01070
01071 break;
01072 }
01073 case quadquadt:{
01074
01075 break;
01076 }
01077 case quadquadtax:{
01078
01079 break;
01080 }
01081 case quadlaxisym:{
01082
01083 break;
01084 }
01085 case lineartett:{
01086
01087 break;
01088 }
01089 case linearhext:{
01090
01091 break;
01092 }
01093 case quadratichext:{
01094
01095 break;
01096 }
01097 default:{
01098 print_err("unknown element type is required",__FILE__,__LINE__,__func__);
01099 }
01100 }
01101 }
01102 }
01103
01104 for (i=0;i<Tt->nn;i++){
01105 Tt->nodes[i].other_averageval ();
01106 }
01107 }
01108
01109
01110
01111
01112
01113
01114
01115
01116
01117
01118
01119
01120
01121
01122 void compute_nodeotherst_comp ()
01123 {
01124 long i;
01125 elemtypet te;
01126
01127 for (i=0;i<Tt->nn;i++){
01128 Tt->nodes[i].nullother();
01129 }
01130
01131 for (i=0;i<Tt->ne;i++){
01132 if (Gtt->leso[i]==1){
01133
01134 te = Tt->give_elem_type (i);
01135
01136 switch (te){
01137 case barlint:{
01138 Lbt->nod_others_comp (0,i,0,0);
01139 break;
01140 }
01141 case barlintax:{
01142
01143 break;
01144 }
01145 case barquadt:{
01146 Qbt->nod_others_comp (0,i,0,0);
01147 break;
01148 }
01149 case barquadtax:{
01150
01151 break;
01152 }
01153 case quadlint:{
01154 Lqt->nod_others_comp (0,i,0,0);
01155 break;
01156 }
01157 case trlint:{
01158
01159 break;
01160 }
01161 case trlaxisym:{
01162
01163 break;
01164 }
01165 case quadquadt:{
01166 Qqt->nod_others_comp (0,i,0,0);
01167 break;
01168 }
01169 case quadquadtax:{
01170
01171 break;
01172 }
01173 case quadlaxisym:{
01174
01175 break;
01176 }
01177 case lineartett:{
01178
01179 break;
01180 }
01181 case linearhext:{
01182 Lht->nod_others_comp (0,i,0,0);
01183 break;
01184 }
01185 case quadratichext:{
01186
01187 break;
01188 }
01189 default:{
01190 print_err("unknown element type is required",__FILE__,__LINE__,__func__);
01191 }
01192 }
01193 }
01194 }
01195
01196 for (i=0;i<Tt->nn;i++){
01197 Tt->nodes[i].other_averageval ();
01198 }
01199 }
01200
01201
01202
01203
01204
01205
01206
01207
01208
01209
01210
01211
01212
01213 void compute_nodeeqotherst ()
01214 {
01215 long i;
01216 elemtypet te;
01217
01218 for (i=0;i<Tt->nn;i++){
01219 Tt->nodes[i].nulleqother();
01220 }
01221
01222 for (i=0;i<Tt->ne;i++){
01223 if (Gtt->leso[i]==1){
01224
01225 te = Tt->give_elem_type (i);
01226
01227 switch (te){
01228 case barlint:{
01229
01230 break;
01231 }
01232 case barlintax:{
01233
01234 break;
01235 }
01236 case barquadt:{
01237
01238 break;
01239 }
01240 case barquadtax:{
01241
01242 break;
01243 }
01244 case quadlint:{
01245 Lqt->nod_eqother_ip (i);
01246 break;
01247 }
01248 case trlint:{
01249
01250 break;
01251 }
01252 case trlaxisym:{
01253
01254 break;
01255 }
01256 case quadquadt:{
01257
01258 break;
01259 }
01260 case quadquadtax:{
01261
01262 break;
01263 }
01264 case quadlaxisym:{
01265
01266 break;
01267 }
01268 case lineartett:{
01269
01270 break;
01271 }
01272 case linearhext:{
01273
01274 break;
01275 }
01276 case quadratichext:{
01277
01278 break;
01279 }
01280 default:{
01281 print_err("unknown element type is required",__FILE__,__LINE__,__func__);
01282 }
01283 }
01284 }
01285 }
01286
01287 for (i=0;i<Tt->nn;i++){
01288 Tt->nodes[i].eqother_averageval ();
01289 }
01290 }
01291
01292
01293
01294
01295
01296
01297
01298
01299 void internal_fluxes (double *intflux,long n)
01300 {
01301 long i,ne,ndofe,*cn;
01302 elemtypet te;
01303 vector lif;
01304
01305 ne = Tt->ne;
01306 nullv (intflux,n);
01307
01308 for (i=0;i<ne;i++){
01309 if (Gtt->leso[i]==1){
01310
01311 te = Tt->give_elem_type (i);
01312 ndofe = Gtt->give_ndofe (i);
01313 allocv (ndofe,lif);
01314 fillv (0.0,lif);
01315
01316 cn = new long [ndofe];
01317 Gtt->give_code_numbers (i,cn);
01318
01319 switch (te){
01320 case barlint:{
01321 Lbt->res_internal_fluxes (i,lif);
01322 break;
01323 }
01324 case barlintax:{
01325 Lbat->res_internal_fluxes (i,lif);
01326 break;
01327 }
01328 case barquadt:{
01329 Qbt->res_internal_fluxes (i,lif);
01330 break;
01331 }
01332 case barquadtax:{
01333 Qbat->res_internal_fluxes (i,lif);
01334 break;
01335 }
01336 case trlint:{
01337 Ltt->res_internal_fluxes (i,lif);
01338 break;
01339 }
01340 case trlaxisym:{
01341 Ltat->res_internal_fluxes (i,lif);
01342 break;
01343 }
01344 case quadlint:{
01345 Lqt->res_internal_fluxes (i,lif);
01346 break;
01347 }
01348 case quadquadt:{
01349 Qqt->res_internal_fluxes (i,lif);
01350 break;
01351 }
01352 case quadquadtax:{
01353 Qqat->res_internal_fluxes (i,lif);
01354 break;
01355 }
01356 case quadlaxisym:{
01357 Lqat->res_internal_fluxes (i,lif);
01358 break;
01359 }
01360 case lineartett:{
01361 Ltett->res_internal_fluxes (i,lif);
01362 break;
01363 }
01364 case linearhext:{
01365 Lht->res_internal_fluxes (i,lif);
01366 break;
01367 }
01368 case quadratichext:{
01369 Qht->res_internal_fluxes (i,lif);
01370 break;
01371 }
01372 default:{
01373 print_err("unknown element type is required",__FILE__,__LINE__,__func__);
01374 abort ();
01375 }
01376 }
01377
01378 locglob (intflux,lif.a,cn,ndofe);
01379 destrv (lif);
01380 delete [] cn;
01381 }
01382 }
01383
01384 trfel_bound_flux (0,intflux,n);
01385
01386 }
01387
01388
01389
01390
01391
01392
01393
01394
01395
01396
01397
01398
01399 void elem_neumann_vector (vector &lv,long lcid,long eid,long i)
01400 {
01401 elemtypet te;
01402
01403 te=Tt->elements[eid].te;
01404
01405 switch (te){
01406 case barlint:{
01407 Lbt->res_convection_vector (lv,lcid,eid,i);
01408 break;
01409 }
01410 case barlintax:{
01411 Lbat->res_convection_vector (lv,lcid,eid,i);
01412 break;
01413 }
01414 case barquadt:{
01415 Qbt->res_convection_vector (lv,lcid,eid,i);
01416 break;
01417 }
01418 case barquadtax:{
01419 Qbat->res_convection_vector (lv,lcid,eid,i);
01420 break;
01421 }
01422 case trlint:{
01423 Ltt->res_convection_vector (lv,lcid,eid,i);
01424 break;
01425 }
01426 case trlaxisym:{
01427 Ltat->res_convection_vector (lv,lcid,eid,i);
01428 break;
01429 }
01430 case quadlint:{
01431 Lqt->res_convection_vector (lv,lcid,eid,i);
01432 break;
01433 }
01434 case quadlaxisym:{
01435 Lqat->res_convection_vector (lv,lcid,eid,i);
01436 break;
01437 }
01438 case quadquadt:{
01439 Qqt->res_convection_vector (lv,lcid,eid,i);
01440 break;
01441 }
01442 case quadquadtax:{
01443 Qqat->res_convection_vector (lv,lcid,eid,i);
01444 break;
01445 }
01446 case lineartett:{
01447 Ltett->res_convection_vector (lv,lcid,eid,i);
01448 break;
01449 }
01450 case linearhext:{
01451 Lht->res_convection_vector (lv,lcid,eid,i);
01452 break;
01453 }
01454 case quadratichext:{
01455 Qht->res_convection_vector (lv,lcid,eid,i);
01456 break;
01457 }
01458 default:{
01459 print_err("unknown element type is required",__FILE__,__LINE__,__func__);
01460 }
01461 }
01462
01463 }
01464
01465
01466
01467
01468
01469
01470
01471
01472
01473
01474
01475
01476
01477
01478
01479 void elem_newton_vector (vector &lv,long lcid,long eid,long i)
01480 {
01481 elemtypet te;
01482
01483 te=Tt->elements[eid].te;
01484
01485 switch (te){
01486 case barlint:{
01487 Lbt->res_transmission_vector (lv,lcid,eid,i);
01488 break;
01489 }
01490 case barlintax:{
01491 Lbat->res_transmission_vector (lv,lcid,eid,i);
01492 break;
01493 }
01494 case barquadt:{
01495 Qbt->res_transmission_vector (lv,lcid,eid,i);
01496 break;
01497 }
01498 case barquadtax:{
01499 Qbat->res_transmission_vector (lv,lcid,eid,i);
01500 break;
01501 }
01502 case trlint:{
01503 Ltt->res_transmission_vector (lv,lcid,eid,i);
01504 break;
01505 }
01506 case trlaxisym:{
01507 Ltat->res_transmission_vector (lv,lcid,eid,i);
01508 break;
01509 }
01510 case quadlint:{
01511 Lqt->res_transmission_vector (lv,lcid,eid,i);
01512 break;
01513 }
01514 case quadlaxisym:{
01515 Lqat->res_transmission_vector (lv,lcid,eid,i);
01516 break;
01517 }
01518 case quadquadt:{
01519 Qqt->res_transmission_vector (lv,lcid,eid,i);
01520 break;
01521 }
01522 case quadquadtax:{
01523 Qqat->res_transmission_vector (lv,lcid,eid,i);
01524 break;
01525 }
01526 case lineartett:{
01527 Ltett->res_transmission_vector (lv,lcid,eid,i);
01528 break;
01529 }
01530 case linearhext:{
01531 Lht->res_transmission_vector (lv,lcid,eid,i);
01532 break;
01533 }
01534 case quadratichext:{
01535 Qht->res_transmission_vector (lv,lcid,eid,i);
01536 break;
01537 }
01538 default:{
01539 print_err("unknown element type is required",__FILE__,__LINE__,__func__);
01540 }
01541 }
01542
01543 }
01544
01545
01546
01547
01548
01549
01550
01551
01552
01553
01554
01555
01556
01557
01558
01559
01560
01561
01562
01563 void elem_transmission_flux (vector &lv,long lcid,long eid,long i)
01564 {
01565 elemtypet te;
01566
01567
01568 te=Tt->elements[eid].te;
01569
01570 switch (te){
01571 case barlint:{
01572 Lbt->res_boundary_flux (lv,lcid,eid,i);
01573 break;
01574 }
01575 case barlintax:{
01576 Lbat->res_boundary_flux (lv,lcid,eid,i);
01577 break;
01578 }
01579 case barquadt:{
01580 Qbt->res_boundary_flux (lv,lcid,eid,i);
01581 break;
01582 }
01583 case barquadtax:{
01584 Qbat->res_boundary_flux (lv,lcid,eid,i);
01585 break;
01586 }
01587 case trlint:{
01588 Ltt->res_boundary_flux (lv,lcid,eid,i);
01589 break;
01590 }
01591 case trlaxisym:{
01592 Ltat->res_boundary_flux (lv,lcid,eid,i);
01593 break;
01594 }
01595 case quadlint:{
01596 Lqt->res_boundary_flux (lv,lcid,eid,i);
01597 break;
01598 }
01599 case quadlaxisym:{
01600 Lqat->res_boundary_flux (lv,lcid,eid,i);
01601 break;
01602 }
01603 case quadquadt:{
01604 Qqt->res_boundary_flux (lv,lcid,eid,i);
01605 break;
01606 }
01607 case quadquadtax:{
01608 Qqat->res_boundary_flux (lv,lcid,eid,i);
01609 break;
01610 }
01611 case lineartett:{
01612 Ltett->res_boundary_flux (lv,lcid,eid,i);
01613 break;
01614 }
01615 case linearhext:{
01616 Lht->res_boundary_flux (lv,lcid,eid,i);
01617 break;
01618 }
01619 case quadratichext:{
01620 Qht->res_boundary_flux (lv,lcid,eid,i);
01621 break;
01622 }
01623 default:{
01624 print_err("unknown element type is required",__FILE__,__LINE__,__func__);
01625 }
01626 }
01627
01628 }
01629
01630
01631
01632
01633
01634
01635
01636
01637
01638
01639 void volume_rhs_vector (vector &lv,long lcid,long eid)
01640 {
01641 elemtypet te;
01642
01643 te=Tt->elements[eid].te;
01644
01645 switch (te){
01646 case barlint:{
01647 Lbt->res_volume_rhs_vector (lv,eid,lcid);
01648 break;
01649 }
01650 case barquadt:{
01651 Qbt->res_volume_rhs_vector (lv,eid,lcid);
01652 break;
01653 }
01654
01655
01656
01657
01658
01659
01660
01661
01662
01663
01664
01665 case trlint:{
01666 break;
01667 }
01668
01669 case quadlint:{
01670 Lqt->res_volume_rhs_vector (lv,eid,lcid);
01671 break;
01672 }
01673 case quadlaxisym:{
01674 Lqat->res_volume_rhs_vector (lv,eid,lcid);
01675 break;
01676 }
01677
01678
01679
01680
01681 case linearhext:{
01682 Lht->res_volume_rhs_vector (lv,eid,lcid);
01683 break;
01684 }
01685 case lineartett:{
01686 break;
01687 }
01688
01689
01690
01691
01692
01693
01694
01695
01696
01697 default:{
01698 print_err("unknown element type is required",__FILE__,__LINE__,__func__);
01699 }
01700 }
01701
01702 }
01703
01704
01705
01706
01707
01708
01709
01710
01711
01712
01713 void lmat (long eid,long lcid,matrix &lm)
01714 {
01715 elemtypet te;
01716
01717 te=Tt->give_elem_type (eid);
01718
01719 switch (te){
01720 case trlint:{
01721 Ltt->res_l_matrix (eid,lcid,lm);
01722 break;
01723 }
01724 case quadlint:{
01725 Lqt->res_l_matrix (eid,lcid,lm);
01726 break;
01727 }
01728 case lineartett:{
01729 Ltett->res_l_matrix (eid,lcid,lm);
01730 break;
01731 }
01732 case linearhext:{
01733 Lht->res_l_matrix (eid,lcid,lm);
01734 break;
01735 }
01736
01737 default:{
01738 print_err("unknown element type is required", __FILE__, __LINE__, __func__);
01739 }
01740 }
01741
01742 }
01743
01744
01745
01746
01747
01748
01749
01750
01751
01752
01753 void ltmat (long eid,long lcid,matrix &lm)
01754 {
01755 elemtypet te;
01756
01757 te=Tt->give_elem_type (eid);
01758
01759 switch (te){
01760 case trlint:{
01761 Ltt->res_l_t_matrix (eid,lcid,lm);
01762 break;
01763 }
01764 case quadlint:{
01765 Lqt->res_l_t_matrix (eid,lcid,lm);
01766 break;
01767 }
01768 case lineartett:{
01769 Ltett->res_l_t_matrix (eid,lcid,lm);
01770 break;
01771 }
01772 case linearhext:{
01773 Lht->res_l_t_matrix (eid,lcid,lm);
01774 break;
01775 }
01776
01777 default:{
01778 print_err("unknown element type is required", __FILE__, __LINE__, __func__);
01779 }
01780 }
01781
01782 }
01783
01784
01785
01786
01787
01788
01789
01790
01791
01792 void averdmat (long eid,double &elemarea,matrix &km)
01793 {
01794 elemtypet te;
01795
01796 te=Tt->give_elem_type (eid);
01797
01798 switch (te){
01799 case trlint:{
01800 Ltt->averd_matrix (eid,km);
01801 elemarea = Ltt->elem_area(eid);
01802 break;
01803 }
01804 case quadlint:{
01805 Lqt->averd_matrix (eid,km);
01806 elemarea = Lqt->elem_area(eid);
01807 break;
01808 }
01809 case lineartett:{
01810 Ltett->averd_matrix (eid,km);
01811 elemarea = Ltett->elem_volume(eid);
01812 break;
01813 }
01814 case linearhext:{
01815 Lht->averd_matrix (eid,km);
01816 elemarea = Lht->elem_volume(eid);
01817 break;
01818 }
01819
01820 default:{
01821 print_err("unknown element type is required", __FILE__, __LINE__, __func__);
01822 }
01823 }
01824 }
01825
01826
01827
01828
01829
01830
01831
01832
01833
01834 void avercmat (long eid,double &elemarea,matrix &cm)
01835 {
01836 elemtypet te;
01837
01838 te=Tt->give_elem_type (eid);
01839
01840 switch (te){
01841 case trlint:{
01842 Ltt->averc_matrix (eid,cm);
01843 elemarea = Ltt->elem_area(eid);
01844 break;
01845 }
01846 case quadlint:{
01847 Lqt->averc_matrix (eid,cm);
01848 elemarea = Lqt->elem_area(eid);
01849 break;
01850 }
01851 case lineartett:{
01852 Ltett->averc_matrix (eid,cm);
01853 elemarea = Ltett->elem_volume(eid);
01854 break;
01855 }
01856 case linearhext:{
01857 Lht->averc_matrix (eid,cm);
01858 elemarea = Lht->elem_volume(eid);
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 void higher_to_lower_level_elem (long eid,long *counter,double *buff)
01878 {
01879 elemtypet te;
01880
01881
01882 te=Tt->give_elem_type (eid);
01883
01884 switch (te){
01885 case trlint:{
01886 Ltt->higher_to_lower_level (eid,counter,buff);
01887 break;
01888 }
01889 case quadlint:{
01890 Lqt->higher_to_lower_level (eid,counter,buff);
01891 break;
01892 }
01893 case lineartett:{
01894 Ltett->higher_to_lower_level (eid,counter,buff);
01895 break;
01896 }
01897 case linearhext:{
01898 Lht->higher_to_lower_level (eid,counter,buff);
01899 break;
01900 }
01901
01902 default:{
01903 print_err("unknown element type is required", __FILE__, __LINE__, __func__);
01904 }
01905 }
01906
01907 }
01908
01909
01910
01911
01912
01913
01914
01915
01916
01917
01918
01919
01920
01921
01922 void intpointvalt (double *gv, nontransquant ntq, double scale)
01923 {
01924 long i,j,nne,nip,ipid;
01925 ivector nodes;
01926 vector nodval,ipval;
01927
01928 for (i=0;i<Tt->ne;i++){
01929 if (Gtt->leso[i]==1){
01930
01931 nne = Tt->give_nne (i);
01932 nip = Tt->give_tnip (i);
01933
01934 reallocv (nne,nodes);
01935 reallocv (nne,nodval);
01936 reallocv (nip,ipval);
01937
01938
01939 Tt->give_elemnodes (i,nodes);
01940
01941
01942 for (j=0;j<nne;j++){
01943 nodval[j]=gv[nodes[j]]*scale;
01944 }
01945
01946
01947 elem_intpointvalt (i,nodval,ipval);
01948
01949
01950 ipid=Tt->elements[i].ipp[0][0];
01951
01952 for (j=0;j<nip;j++){
01953 Tm->storenontransq(ntq, ipid, ipval[j]);
01954 ipid++;
01955 }
01956 }
01957 }
01958 }
01959
01960
01961
01962
01963
01964
01965
01966
01967
01968
01969 void elem_intpointvalt (long eid,vector &nodval,vector &ipval)
01970 {
01971 elemtypet te;
01972
01973 te=Tt->give_elem_type (eid);
01974
01975 switch (te){
01976 case barlint:{
01977 Lbt->intpointval (eid,nodval,ipval);
01978 break;
01979 }
01980 case quadlint:{
01981 Lqt->intpointval (eid,nodval,ipval);
01982 break;
01983 }
01984 default:{
01985 print_err("unknown element type is required",__FILE__,__LINE__,__func__);
01986 }
01987 }
01988
01989 }
01990
01991
01992
01993
01994
01995
01996
01997
01998
01999
02000
02001
02002 void give_transq_nodval (double *gv,long mnt,nonmechquant nmq)
02003 {
02004 long i,j,nne;
02005 ivector nodes;
02006 vector nodval;
02007
02008 for (i=0;i<Tt->ne;i++){
02009 if (Gtt->leso[i]==1){
02010
02011 nne = Tt->give_nne (i);
02012
02013 reallocv (nne,nodes);
02014 reallocv (nne,nodval);
02015
02016
02017 Tt->give_elemnodes (i,nodes);
02018
02019
02020 elem_transq_nodval (i, nodval, nmq);
02021
02022 for (j=0;j<nne;j++){
02023 gv[nodes[j]] = nodval[j];
02024 }
02025 }
02026 }
02027 }
02028
02029
02030
02031
02032
02033
02034
02035
02036
02037
02038
02039
02040
02041
02042
02043
02044 void elem_transq_nodval (long eid,vector &nodval,nonmechquant nmq)
02045 {
02046 elemtypet te;
02047
02048 te = Tt->give_elem_type (eid);
02049
02050 switch (te){
02051 case barlint:{
02052 Lbt->transq_nodval (eid,nodval,nmq);
02053 break;
02054 }
02055 case quadlint:{
02056 Lqt->transq_nodval (eid,nodval,nmq);
02057 break;
02058 }
02059 default:{
02060 print_err("unknown element type is required", __FILE__, __LINE__, __func__);
02061 }
02062 }
02063 }
02064
02065
02066
02067
02068
02069
02070
02071
02072
02073
02074
02075
02076
02077
02078
02079
02080
02081
02082 void elem_transq_nodval_comp (long eid,vector &nodval, long ncne, long nq, nonmechquant *qt)
02083 {
02084 elemtypet te;
02085
02086 te = Tt->give_elem_type (eid);
02087
02088 switch (te){
02089 case barlint:{
02090 Lbt->transq_nodval_comp (eid, nodval, ncne, nq, qt);
02091 break;
02092 }
02093 case quadlint:{
02094 Lqt->transq_nodval_comp (eid, nodval, ncne, nq, qt);
02095 break;
02096 }
02097 default:{
02098 print_err("unknown element type is required", __FILE__, __LINE__, __func__);
02099 }
02100 }
02101 }
02102
02103
02104
02105
02106
02107
02108
02109
02110
02111
02112
02113
02114 double elem_total_integral (long eid,vector &nodval)
02115 {
02116 double value;
02117 elemtypet te;
02118
02119
02120 te = Tt->give_elem_type (eid);
02121
02122 switch (te){
02123 case barlint:{ value = Lbt->total_integral (eid,nodval); break;}
02124 case barlintax:{ value = Lbat->total_integral (eid,nodval); break;}
02125 case barquadt:{ value = Qbt->total_integral (eid,nodval); break;}
02126 case barquadtax:{ value = Qbat->total_integral (eid,nodval); break;}
02127 case quadlint:{ value = Lqt->total_integral (eid,nodval); break;}
02128 case quadquadt:{ value = Qqt->total_integral (eid,nodval); break;}
02129 case quadquadtax:{ value = Qqat->total_integral (eid,nodval); break;}
02130 case lineartett:{ value = Ltett->total_integral (eid,nodval); break;}
02131 case linearhext:{ value = Lht->total_integral (eid,nodval); break;}
02132 default:{
02133 print_err("unknown element type is required",__FILE__,__LINE__,__func__);
02134 }
02135 }
02136 return value;
02137 }
02138
02139
02140
02141
02142
02143
02144
02145
02146
02147
02148 double elem_total_integral_ip (long eid,long varid)
02149 {
02150 double value;
02151 elemtypet te;
02152
02153
02154 te = Tt->give_elem_type (eid);
02155
02156 switch (te){
02157 case barlint:{ value = Lbt->total_integral_ip (eid,varid); break;}
02158
02159
02160
02161
02162
02163
02164
02165
02166 default:{
02167 print_err("unknown element type is required",__FILE__,__LINE__,__func__);
02168 }
02169 }
02170
02171 return value;
02172 }
02173