00001
00002
00003
00004
00005
00006
00007 #include "globalt.h"
00008 #include "linbart.h"
00009 #include "genfile.h"
00010 #include "globmatt.h"
00011 #include "loadcaset.h"
00012 #include "loadelt.h"
00013 #include "elemswitcht.h"
00014
00015 linbart::linbart (void)
00016 {
00017 long i;
00018
00019
00020 nne=2;
00021
00022 ncomp=1;
00023
00024 nen=2;
00025
00026 ned=1;
00027
00028 nned=0;
00029
00030
00031 ntm=Tp->ntm;
00032
00033
00034 dofe = new long* [ntm];
00035 nip = new long* [ntm];
00036 intordkm = new long* [ntm];
00037 intordcm = new long* [ntm];
00038 ordering = new long* [ntm];
00039 for (i=0;i<ntm;i++){
00040 dofe[i] = new long [ntm];
00041 nip[i] = new long [ntm];
00042 intordkm[i] = new long [ntm];
00043 intordcm[i] = new long [ntm];
00044 ordering[i] = new long [nne];
00045 }
00046
00047
00048 switch (Tp->tmatt){
00049 case onemedium:{
00050 ordering[0][0]=1; ordering[0][1]=2;
00051 dofe[0][0]=2; intordkm[0][0]=3; intordcm[0][0]=3; nip[0][0]=6;
00052 ndofe=2; napfun=1;
00053 break;
00054 }
00055 case twomediacoup:{
00056 ordering[0][0]=1; ordering[0][1]=3;
00057 ordering[1][0]=2; ordering[1][1]=4;
00058
00059 intordkm[0][0]=1; intordkm[0][1]=1; intordkm[1][0]=1; intordkm[1][1]=1;
00060 intordcm[0][0]=2; intordcm[0][1]=2; intordcm[1][0]=2; intordcm[1][1]=2;
00061
00062 if (Tp->savemode==0){
00063 nip[0][0]=3; nip[0][1]=3; nip[1][0]=3; nip[1][1]=3;
00064 }
00065 if (Tp->savemode==1){
00066 nip[0][0]=3; nip[0][1]=0; nip[1][0]=0; nip[1][1]=0;
00067 }
00068
00069 dofe[0][0]=2; dofe[0][1]=2; dofe[1][0]=2; dofe[1][1]=2;
00070 ndofe=4; napfun=2;
00071 break;
00072 }
00073 case threemediacoup:{
00074 ordering[0][0]=1; ordering[0][1]=4;
00075 ordering[1][0]=2; ordering[1][1]=5;
00076 ordering[2][0]=3; ordering[2][1]=6;
00077
00078 intordkm[0][0]=1; intordkm[0][1]=1; intordkm[0][2]=1;
00079 intordkm[1][0]=1; intordkm[1][1]=1; intordkm[1][2]=1;
00080 intordkm[2][0]=1; intordkm[2][1]=1; intordkm[2][2]=1;
00081
00082 intordcm[0][0]=2; intordcm[0][1]=2; intordcm[0][2]=2;
00083 intordcm[1][0]=2; intordcm[1][1]=2; intordcm[1][2]=2;
00084 intordcm[2][0]=2; intordcm[2][1]=2; intordcm[2][2]=2;
00085
00086 if (Tp->savemode==0){
00087 nip[0][0]=3; nip[0][1]=3; nip[0][2]=3;
00088 nip[1][0]=3; nip[1][1]=3; nip[1][2]=3;
00089 nip[2][0]=3; nip[2][1]=3; nip[2][2]=3;
00090 }
00091 if (Tp->savemode==1){
00092 nip[0][0]=3; nip[0][1]=0; nip[0][2]=0;
00093 nip[1][0]=0; nip[1][1]=0; nip[1][2]=0;
00094 nip[2][0]=0; nip[2][1]=0; nip[2][2]=0;
00095 }
00096
00097 dofe[0][0]=2; dofe[0][1]=2; dofe[0][2]=2;
00098 dofe[1][0]=2; dofe[1][1]=2; dofe[1][2]=2;
00099 dofe[2][0]=2; dofe[2][1]=2; dofe[2][2]=2;
00100
00101 ndofe=6; napfun=3;
00102 break;
00103 }
00104 case fourmediacoup:{
00105 ordering[0][0]=1; ordering[0][1]=5;
00106 ordering[1][0]=2; ordering[1][1]=6;
00107 ordering[2][0]=3; ordering[2][1]=7;
00108 ordering[3][0]=4; ordering[3][1]=8;
00109
00110 intordkm[0][0]=1; intordkm[0][1]=1; intordkm[0][2]=1; intordkm[0][3]=1;
00111 intordkm[1][0]=1; intordkm[1][1]=1; intordkm[1][2]=1; intordkm[1][3]=1;
00112 intordkm[2][0]=1; intordkm[2][1]=1; intordkm[2][2]=1; intordkm[2][3]=1;
00113 intordkm[3][0]=1; intordkm[3][1]=1; intordkm[3][2]=1; intordkm[3][3]=1;
00114
00115 intordcm[0][0]=2; intordcm[0][1]=2; intordcm[0][2]=2; intordcm[0][3]=2;
00116 intordcm[1][0]=2; intordcm[1][1]=2; intordcm[1][2]=2; intordcm[1][3]=2;
00117 intordcm[2][0]=2; intordcm[2][1]=2; intordcm[2][2]=2; intordcm[2][3]=2;
00118 intordcm[3][0]=2; intordcm[3][1]=2; intordcm[3][2]=2; intordcm[3][3]=2;
00119
00120 if (Tp->savemode==0){
00121 nip[0][0]=3; nip[0][1]=3; nip[0][2]=3; nip[0][3]=3;
00122 nip[1][0]=3; nip[1][1]=3; nip[1][2]=3; nip[1][3]=3;
00123 nip[2][0]=3; nip[2][1]=3; nip[2][2]=3; nip[2][3]=3;
00124 nip[3][0]=3; nip[3][1]=3; nip[3][2]=3; nip[3][3]=3;
00125 }
00126 if (Tp->savemode==1){
00127 nip[0][0]=3; nip[0][1]=0; nip[0][2]=0; nip[0][3]=0;
00128 nip[1][0]=0; nip[1][1]=0; nip[1][2]=0; nip[1][3]=0;
00129 nip[2][0]=0; nip[2][1]=0; nip[2][2]=0; nip[2][3]=0;
00130 nip[3][0]=0; nip[3][1]=0; nip[3][2]=0; nip[3][3]=0;
00131 }
00132
00133 dofe[0][0]=2; dofe[0][1]=2; dofe[0][2]=2; dofe[0][3]=2;
00134 dofe[1][0]=2; dofe[1][1]=2; dofe[1][2]=2; dofe[1][3]=2;
00135 dofe[2][0]=2; dofe[2][1]=2; dofe[2][2]=2; dofe[2][3]=2;
00136 dofe[3][0]=2; dofe[3][1]=2; dofe[3][2]=2; dofe[3][3]=2;
00137
00138 ndofe=8; napfun=4;
00139 break;
00140 }
00141 default:{
00142 print_err("unknown type of transported matter is required",__FILE__,__LINE__,__func__);
00143 }
00144 }
00145 }
00146
00147 linbart::~linbart (void)
00148 {
00149 long i;
00150
00151 for (i=0;i<ntm;i++){
00152 delete [] dofe[i];
00153 delete [] nip[i];
00154 delete [] intordkm[i];
00155 delete [] intordcm[i];
00156 delete [] ordering[i];
00157 }
00158 delete [] dofe;
00159 delete [] nip;
00160 delete [] intordkm;
00161 delete [] intordcm;
00162 delete [] ordering;
00163 }
00164
00165
00166
00167
00168
00169
00170
00171
00172
00173 void linbart::codnum (long *cn,long ri)
00174 {
00175 long i;
00176 for (i=0;i<nne;i++){
00177 cn[i]=ordering[ri][i];
00178 }
00179 }
00180
00181
00182
00183
00184
00185
00186
00187
00188
00189 double linbart::approx (double xi,vector &nodval)
00190 {
00191 double f;
00192 vector bf(nne);
00193
00194 bf_lin_1d (bf.a,xi);
00195
00196 scprd (bf,nodval,f);
00197
00198 return f;
00199 }
00200
00201
00202
00203
00204
00205
00206
00207
00208 void linbart::intpointval (long eid)
00209 {
00210 long i,k,ii,jj,ipp;
00211 double xi,val;
00212 ivector cn(ndofe);
00213 vector r(ndofe),t(nne),gp,w;
00214
00215 Tt->give_code_numbers (eid,cn.a);
00216 elemvalues (0,eid,r.a,cn.a,ndofe);
00217
00218 for (k=0;k<ntm;k++){
00219
00220
00221 for (i=0;i<dofe[k][k];i++){
00222 t[i]=r[ordering[k][i]-1];
00223 }
00224
00225 for (ii=0;ii<Tp->ntm;ii++){
00226 for (jj=0;jj<Tp->ntm;jj++){
00227
00228
00229
00230 reallocv (intordkm[ii][jj],gp);
00231 reallocv (intordkm[ii][jj],w);
00232 gauss_points (gp.a,w.a,intordkm[ii][jj]);
00233
00234 ipp=Tt->elements[eid].ipp[ii][jj];
00235 for (i=0;i<intordkm[ii][jj];i++){
00236 xi=gp[i];
00237
00238 val = approx (xi,t);
00239 Tm->ip[ipp].av[k]=val;
00240 ipp++;
00241 }
00242
00243
00244
00245 reallocv (intordcm[ii][jj],gp);
00246 reallocv (intordcm[ii][jj],w);
00247 gauss_points (gp.a,w.a,intordcm[ii][jj]);
00248
00249 for (i=0;i<intordcm[ii][jj];i++){
00250 xi=gp[i];
00251
00252 val = approx (xi,t);
00253 Tm->ip[ipp].av[k]=val;
00254 ipp++;
00255 }
00256
00257
00258 if (Tp->savemode==1) break;
00259 }
00260 if (Tp->savemode==1) break;
00261 }
00262 }
00263 }
00264
00265
00266
00267
00268
00269
00270
00271
00272
00273
00274
00275
00276
00277
00278
00279 void linbart::intpointval (long eid,vector &nodval,vector &ipval)
00280 {
00281 long i,kk,ii,jj,ipp;
00282 double xi;
00283 vector gp,w;
00284
00285 kk = 0;
00286
00287 for (ii=0;ii<Tp->ntm;ii++){
00288 for (jj=0;jj<Tp->ntm;jj++){
00289
00290
00291 reallocv (intordkm[ii][jj],gp);
00292 reallocv (intordkm[ii][jj],w);
00293 gauss_points (gp.a,w.a,intordkm[ii][jj]);
00294
00295 ipp=Tt->elements[eid].ipp[ii][jj];
00296 for (i=0;i<intordkm[ii][jj];i++){
00297 xi=gp[i];
00298
00299 ipval[kk] = approx (xi,nodval);
00300
00301 ipp++;
00302 kk++;
00303 }
00304
00305
00306
00307 reallocv (intordcm[ii][jj],gp);
00308 reallocv (intordcm[ii][jj],w);
00309 gauss_points (gp.a,w.a,intordcm[ii][jj]);
00310
00311 for (i=0;i<intordcm[ii][jj];i++){
00312 xi=gp[i];
00313
00314 ipval[kk] = approx (xi,nodval);
00315
00316 ipp++;
00317 kk++;
00318 }
00319
00320
00321 if (Tp->savemode==1) break;
00322 }
00323 if (Tp->savemode==1) break;
00324 }
00325 }
00326
00327
00328
00329
00330
00331
00332
00333
00334
00335 void linbart::intpointgrad (long eid)
00336 {
00337 long i,ii,jj,k,ipp;
00338 double xi,jac;
00339 ivector cn(ndofe);
00340 vector x(nne),y(nne),r(ndofe),t(nne),gp,w,grad(ncomp);
00341 matrix gm(ncomp,nne);
00342
00343 Tt->give_node_coord2d (x,y,eid);
00344 Tt->give_code_numbers (eid,cn.a);
00345 elemvalues (0,eid,r.a,cn.a,ndofe);
00346
00347 for (k=0;k<Tp->ntm;k++){
00348
00349
00350 for (i=0;i<dofe[k][k];i++){
00351 t[i]=r[ordering[k][i]-1];
00352 }
00353
00354 for (ii=0;ii<Tp->ntm;ii++){
00355 for (jj=0;jj<Tp->ntm;jj++){
00356
00357
00358
00359 reallocv (intordkm[ii][jj],gp);
00360 reallocv (intordkm[ii][jj],w);
00361 gauss_points (gp.a,w.a,intordkm[ii][jj]);
00362
00363 ipp=Tt->elements[eid].ipp[ii][jj];
00364 for (i=0;i<intordkm[ii][jj];i++){
00365 xi=gp[i];
00366
00367
00368 grad_matrix (gm,x,xi,jac);
00369 mxv (gm,t,grad);
00370 Tm->storegrad (k,ipp,grad);
00371 ipp++;
00372 }
00373
00374
00375
00376 reallocv (intordcm[ii][jj],gp);
00377 reallocv (intordcm[ii][jj],w);
00378 gauss_points (gp.a,w.a,intordcm[ii][jj]);
00379
00380 for (i=0;i<intordcm[ii][jj];i++){
00381 xi=gp[i];
00382
00383
00384 grad_matrix (gm,x,xi,jac);
00385 mxv (gm,t,grad);
00386 Tm->storegrad (k,ipp,grad);
00387 ipp++;
00388 }
00389
00390 if (Tp->savemode==1) break;
00391 }
00392 if (Tp->savemode==1) break;
00393 }
00394 }
00395 }
00396
00397
00398
00399
00400
00401
00402
00403
00404 void linbart::intpointother (long eid)
00405 {
00406 long i,k,ii,jj,ipp,ncompo,nodid;
00407 double xi,val,*r;
00408 ivector nodes(nne);
00409 vector t(nne),gp,w;
00410
00411
00412 Tt->give_elemnodes (eid,nodes);
00413
00414
00415 nodid=nodes[0];
00416
00417
00418 ncompo=Tt->nodes[nodid].ncompother;
00419 r = new double [ncompo*nne];
00420
00421
00422 nodalotherval (r,nodes);
00423
00424 for (k=0;k<ncompo;k++){
00425
00426
00427 for (i=0;i<nne;i++){
00428 t[i]=r[i*ncompo+k];
00429 }
00430
00431 for (ii=0;ii<Tp->ntm;ii++){
00432 for (jj=0;jj<Tp->ntm;jj++){
00433
00434
00435
00436 reallocv (intordkm[ii][jj],gp);
00437 reallocv (intordkm[ii][jj],w);
00438 gauss_points (gp.a,w.a,intordkm[ii][jj]);
00439
00440 ipp=Tt->elements[eid].ipp[ii][jj];
00441 for (i=0;i<intordkm[ii][jj];i++){
00442 xi=gp[i];
00443
00444 val = approx (xi,t);
00445 Tm->ip[ipp].other[k]=val;
00446 ipp++;
00447 }
00448
00449
00450
00451 reallocv (intordcm[ii][jj],gp);
00452 reallocv (intordcm[ii][jj],w);
00453 gauss_points (gp.a,w.a,intordcm[ii][jj]);
00454
00455 for (i=0;i<intordcm[ii][jj];i++){
00456 xi=gp[i];
00457
00458 val = approx (xi,t);
00459 Tm->ip[ipp].other[k]=val;
00460 ipp++;
00461 }
00462
00463 if (Tp->savemode==1) break;
00464 }
00465 if (Tp->savemode==1) break;
00466 }
00467 }
00468
00469 delete [] r;
00470 }
00471
00472
00473
00474
00475
00476
00477
00478
00479
00480 void linbart::bf_matrix (matrix &n,double xi)
00481 {
00482 fillm (0.0,n);
00483 bf_lin_1d (n.a,xi);
00484 }
00485
00486
00487
00488
00489
00490
00491
00492
00493
00494
00495
00496 void linbart::grad_matrix (matrix &gm,vector &x,double xi,double &jac)
00497 {
00498 long i;
00499 vector dx(nne);
00500 dx_bf_lin_1d (dx.a);
00501 derivatives_1d (dx,jac,x,xi);
00502
00503 for (i=0;i<nne;i++){
00504 gm[0][i]=dx[i];
00505 }
00506 }
00507
00508
00509
00510
00511
00512
00513
00514
00515
00516
00517
00518
00519 void linbart::conductivity_matrix (long lcid,long eid,long ri,long ci,matrix &km)
00520 {
00521 long i,ii;
00522 double area,xi,ww,jac;
00523 ivector nodes(nne);
00524 vector x(nne),w(intordkm[ri][ci]),gp(intordkm[ri][ci]),a(nne);
00525 matrix gm(ncomp,dofe[ri][ci]),d;
00526 matrix n(1,dofe[ri][ci]);
00527
00528
00529 Tt->give_elemnodes (eid,nodes);
00530
00531 Tc->give_area (eid,nodes,a);
00532
00533 Tt->give_node_coord1d (x,eid);
00534
00535 gauss_points (gp.a,w.a,intordkm[ri][ci]);
00536 fillm (0.0,km);
00537
00538 if (Tp->savemode==0)
00539 ii=Tt->elements[eid].ipp[ri][ci];
00540 if (Tp->savemode==1)
00541 ii=Tt->elements[eid].ipp[0][0];
00542
00543 for (i=0;i<intordkm[ri][ci];i++){
00544 xi=gp[i]; ww=w[i];
00545
00546
00547 grad_matrix (gm,x,xi,jac);
00548
00549
00550 reallocm(ncomp,ncomp,d);
00551 Tm->matcond (d,ii,ri,ci);
00552
00553
00554 area = approx (xi,a);
00555
00556 jac*=area*ww;
00557
00558
00559 bdbj (km.a,gm.a,d.a,jac,gm.m,gm.n);
00560
00561
00562 reallocm(1,ncomp,d);
00563 Tm->matcond2(d,ii,ri,ci);
00564 bf_matrix (n, xi);
00565 bdbjac(km, n, d, gm, jac);
00566
00567 ii++;
00568 }
00569
00570 if ((Tt->elements[eid].transi[lcid]==3) || (Tt->elements[eid].transi[lcid]==4)){
00571
00572 transmission_matrix (lcid,eid,ri,ci,km);
00573 }
00574
00575 }
00576
00577
00578
00579
00580
00581
00582
00583
00584
00585
00586
00587 void linbart::capacity_matrix (long eid,long ri,long ci,matrix &cm)
00588 {
00589 long i,ii;
00590 double jac,xi,ww,area,rho,c;
00591 ivector nodes(nne);
00592 vector x(nne),w(intordcm[ri][ci]),gp(intordcm[ri][ci]),a(nne);
00593 matrix n(1,dofe[ri][ci]);
00594
00595
00596 Tt->give_elemnodes (eid,nodes);
00597
00598 Tc->give_area (eid,nodes,a);
00599 Tc->give_densitye (eid,rho);
00600
00601 Tt->give_node_coord1d (x,eid);
00602
00603 gauss_points (gp.a,w.a,intordcm[ri][ci]);
00604
00605 fillm (0.0,cm);
00606
00607 if (Tp->savemode==0)
00608 ii=Tt->elements[eid].ipp[ri][ci]+intordkm[ri][ci];
00609 if (Tp->savemode==1)
00610 ii=Tt->elements[eid].ipp[0][0]+intordkm[0][0];
00611
00612 for (i=0;i<intordcm[ri][ci];i++){
00613 xi=gp[i]; ww=w[i];
00614
00615 bf_matrix (n,xi);
00616
00617
00618 area = approx (xi,a);
00619 c=Tm->capcoeff (ii,ri,ci);
00620 jac_1d (jac,x,xi);
00621 jac*=area*ww*rho*c;
00622
00623 nnj (cm.a,n.a,jac,n.m,n.n);
00624 ii++;
00625 }
00626
00627 }
00628
00629
00630
00631
00632
00633
00634
00635
00636
00637
00638
00639
00640
00641
00642 void linbart::quantity_source_vector (vector &sv,vector &nodval,long eid,long ri,long ci)
00643 {
00644 long i;
00645 double jac,xi,ww,area;
00646 ivector nodes(nne);
00647 vector x(nne),w(intordcm[ri][ci]),gp(intordcm[ri][ci]),v(dofe[ri][ci]),a(nne);
00648 matrix n(1,dofe[ri][ci]),nm(dofe[ri][ci],dofe[ri][ci]);
00649
00650
00651 Tt->give_elemnodes (eid,nodes);
00652
00653 Tc->give_area (eid,nodes,a);
00654
00655 Tt->give_node_coord1d (x,eid);
00656
00657 gauss_points (gp.a,w.a,intordcm[ri][ci]);
00658
00659 fillm (0.0,nm);
00660
00661 for (i=0;i<intordcm[ri][ci];i++){
00662 xi=gp[i]; ww=w[i];
00663
00664 bf_matrix (n,xi);
00665
00666 jac_1d (jac,x,xi);
00667
00668
00669 area = approx (xi,a);
00670
00671 jac*=ww*area;
00672
00673 nnj (nm.a,n.a,jac,n.m,n.n);
00674 }
00675 mxv (nm,nodval,v); addv (sv,v,sv);
00676
00677 }
00678
00679
00680
00681
00682
00683
00684
00685
00686
00687
00688
00689
00690
00691
00692
00693
00694 void linbart::transmission_matrix (long lcid,long eid,long ri,long ci,matrix &km)
00695 {
00696 long i,neleml,ii;
00697 bocontypet bc[2];
00698
00699 double xi,area;
00700 double new_trc;
00701 long nn;
00702
00703 ivector nodes(nne);
00704 vector x(nne),trc(2),a(nne);
00705 matrix n(1,dofe[ri][ci]);
00706
00707
00708 Tt->give_elemnodes (eid,nodes);
00709
00710 Tc->give_area (eid,nodes,a);
00711
00712 Tt->give_node_coord1d (x,eid);
00713
00714 for (i=0;i<Tb->lc[lcid].neb;i++){
00715 if (Tb->lc[lcid].elemload[i].eid==eid){
00716 neleml=i;
00717 break;
00718 }
00719 }
00720
00721
00722 Tb->lc[lcid].elemload[neleml].give_bc (bc);
00723
00724 Tb->lc[lcid].elemload[neleml].give_trc (lcid,ci,trc);
00725
00726 if (Tp->savemode==0)
00727 ii=Tt->elements[eid].ipp[ri][ci];
00728 if (Tp->savemode==1)
00729 ii=Tt->elements[eid].ipp[0][0];
00730
00731
00732 if (bc[0]==5 || bc[0]>10){
00733 xi=-1.0;
00734
00735 bf_matrix (n,xi);
00736
00737
00738 nn = nodes[0];
00739
00740 Tm->transmission_transcoeff(new_trc,trc[0],ri,ci,nn,bc[0],ii);
00741
00742
00743 trc[0]=new_trc;
00744
00745
00746 area = approx (xi,a);
00747
00748 nnj (km.a,n.a,trc[0]*area,n.m,n.n);
00749 }
00750
00751 if (bc[1]==5 || bc[1]>10){
00752 xi=1.0;
00753
00754 bf_matrix (n,xi);
00755
00756
00757 nn = nodes[1];
00758
00759 Tm->transmission_transcoeff(new_trc,trc[1],ri,ci,nn,bc[1],ii);
00760
00761
00762 trc[1]=new_trc;
00763
00764
00765 area = approx (xi,a);
00766
00767 nnj (km.a,n.a,trc[1]*area,n.m,n.n);
00768 }
00769 }
00770
00771
00772
00773
00774
00775
00776
00777
00778
00779
00780
00781
00782
00783
00784
00785
00786
00787 void linbart::transmission_vector (vector &tmv,long lcid,long eid,long leid,long cid)
00788 {
00789 long ii,nid;
00790 bocontypet bc[2];
00791 double xi,area,new_nodval,tr;
00792 ivector nodes(nne);
00793 vector x(nne),trc(2),trcn(nne),nodval(2),av(dofe[lcid][cid]),v(dofe[lcid][cid]),a(nne);
00794 vector trr(2);
00795 matrix n(1,dofe[lcid][cid]),km(dofe[lcid][cid],dofe[lcid][cid]);
00796
00797
00798 Tt->give_elemnodes (eid,nodes);
00799
00800 Tc->give_area (eid,nodes,a);
00801
00802 Tt->give_node_coord1d (x,eid);
00803
00804
00805 Tb->lc[lcid].elemload[leid].give_bc (bc);
00806
00807 Tb->lc[lcid].elemload[leid].give_external_nodval (lcid,cid,nodval);
00808
00809 Tb->lc[lcid].elemload[leid].give_trc (lcid,cid,trc);
00810
00811 Tb->lc[lcid].elemload[leid].give_trr (lcid,trr);
00812
00813
00814 if (Tp->savemode==0)
00815 ii=Tt->elements[eid].ipp[lcid][cid];
00816 if (Tp->savemode==1)
00817 ii=Tt->elements[eid].ipp[0][0];
00818
00819 if (bc[0]==5 || bc[0]>10){
00820 fillm (0.0,km);
00821 xi=-1.0;
00822
00823 bf_matrix (n,xi);
00824
00825
00826 nid = nodes[0];
00827 tr = 0.0;
00828 if(bc[0] == 90)
00829 tr = trr[0]/trc[0];
00830
00831
00832 Tm->transmission_nodval (new_nodval,nodval[0],tr,lcid,cid,nid,bc[0],ii);
00833
00834 av[0]=new_nodval; av[1]=0.0;
00835
00836
00837 area = approx (xi,a);
00838
00839 fprintf (stdout,"\n linbart trc[0] %le",trc[0]);
00840 fprintf (stdout,"\n linbart val[0] %le",av[0]);
00841
00842 nnj (km.a,n.a,trc[0]*area,n.m,n.n);
00843
00844 mxv (km,av,v); addv (tmv,v,tmv);
00845 }
00846 if (bc[1]==5 || bc[1]>10){
00847 fillm (0.0,km);
00848 xi=1.0;
00849
00850 bf_matrix (n,xi);
00851
00852
00853 nid = nodes[1];
00854 tr = 0.0;
00855 if(bc[0] == 90)
00856 tr = trr[1]/trc[1];
00857
00858 Tm->transmission_nodval(new_nodval,nodval[1],tr,lcid,cid,nid,bc[1],ii);
00859
00860 av[0]=0.0; av[1]=new_nodval;
00861
00862
00863 area = approx (xi,a);
00864
00865 fprintf (stdout,"\n linbart trc[1] %le",trc[1]);
00866 fprintf (stdout,"\n linbart val[1] %le",av[1]);
00867 nnj (km.a,n.a,trc[1]*area,n.m,n.n);
00868
00869 mxv (km,av,v); addv (tmv,v,tmv);
00870 }
00871 }
00872
00873
00874
00875
00876
00877
00878
00879
00880
00881
00882
00883
00884
00885
00886
00887
00888 void linbart::convection_vector (vector &f,long lcid,long eid,long leid,long ri,long ci)
00889 {
00890 bocontypet bc[2];
00891 double xi,area;
00892 ivector nodes(nne);
00893 vector x(nne),nodval(2),av(dofe[ri][ci]),v(dofe[ri][ci]),a(nne);
00894 matrix n(1,dofe[ri][ci]),km(dofe[ri][ci],dofe[ri][ci]);
00895
00896
00897 Tt->give_elemnodes (eid,nodes);
00898
00899 Tc->give_area (eid,nodes,a);
00900
00901 Tt->give_node_coord1d (x,eid);
00902
00903
00904 Tb->lc[lcid].elemload[leid].give_bc (bc);
00905
00906 Tb->lc[lcid].elemload[leid].give_nodval (lcid,nodval);
00907
00908
00909 if (bc[0]==2 || bc[0]==3 || bc[0]==5){
00910 fillm (0.0,km);
00911 xi=-1.0;
00912
00913 bf_matrix (n,xi);
00914
00915 area = approx (xi,a);
00916 nnj (km.a,n.a,area,n.m,n.n);
00917
00918 av[0]=nodval[0]; av[1]=0.0;
00919 mxv (km,av,v); addv (f,v,f);
00920 }
00921 if (bc[1]==2 || bc[1]==3 || bc[1]==5){
00922 fillm (0.0,km);
00923 xi=1.0;
00924 bf_matrix (n,xi);
00925
00926 area = approx (xi,a);
00927 nnj (km.a,n.a,area,n.m,n.n);
00928
00929 av[0]=0.0; av[1]=nodval[1];
00930 mxv (km,av,v); addv (f,v,f);
00931 }
00932 }
00933
00934
00935
00936
00937
00938
00939
00940
00941
00942
00943
00944 void linbart::internal_fluxes (long lcid,long eid,vector &ifl)
00945 {
00946 long i,ipp;
00947 double jac,area,xi;
00948 ivector nodes(nne);
00949 vector x(nne),w(intordkm[lcid][lcid]),gp(intordkm[lcid][lcid]),fl(ncomp),contr(dofe[lcid][lcid]),a(nne);
00950 matrix gm(ncomp,dofe[lcid][lcid]),d(ncomp,ncomp);
00951
00952
00953 Tt->give_elemnodes (eid,nodes);
00954
00955 Tc->give_area (eid,nodes,a);
00956
00957 Tt->give_node_coord1d (x,eid);
00958
00959 gauss_points (gp.a,w.a,intordkm[lcid][lcid]);
00960
00961 if (Tp->savemode==0)
00962 ipp=Tt->elements[eid].ipp[lcid][lcid];
00963 if (Tp->savemode==1)
00964 ipp=Tt->elements[eid].ipp[0][0];
00965
00966
00967 for (i=0;i<intordkm[lcid][lcid];i++){
00968 xi=gp[i];
00969
00970 Tm->computenlfluxes (lcid,ipp);
00971
00972 Tm->givefluxes (lcid,ipp,fl);
00973
00974 grad_matrix (gm,x,gp[i],jac);
00975
00976 mtxv (gm,fl,contr);
00977
00978
00979 area = approx (xi,a);
00980 cmulv (area*jac*w[i],contr);
00981
00982 addv (contr,ifl,ifl);
00983
00984 ipp++;
00985 }
00986 }
00987
00988
00989
00990
00991
00992
00993
00994
00995
00996
00997 void linbart::res_conductivity_matrix (long eid,long lcid,matrix &km)
00998 {
00999 long i,j,*rcn,*ccn;
01000 matrix lkm;
01001
01002 for (i=0;i<ntm;i++){
01003 for (j=0;j<ntm;j++){
01004 rcn = new long [dofe[i][j]];
01005 ccn = new long [dofe[i][j]];
01006 reallocm (dofe[i][j],dofe[i][j],lkm);
01007 conductivity_matrix (i,eid,i,j,lkm);
01008 codnum (rcn,i);
01009 codnum (ccn,j);
01010 mat_localize (km,lkm,rcn,ccn);
01011 delete [] rcn; delete [] ccn;
01012 }
01013 }
01014 }
01015
01016
01017
01018
01019
01020
01021
01022
01023
01024
01025
01026
01027
01028
01029
01030 void linbart::volume_rhs_vector (long lcid,long eid,long ri,long ci,vector &vrhs)
01031 {
01032 long i,ii;
01033 double area,xi,ww,jac;
01034 ivector nodes(nne);
01035 vector x(nne),w(intordkm[ri][ci]),gp(intordkm[ri][ci]),a(nne);
01036 matrix gm(ncomp,dofe[ri][ci]),d;
01037 matrix km(dofe[ri][ci],1);
01038
01039
01040 Tt->give_elemnodes (eid,nodes);
01041
01042 Tc->give_area (eid,nodes,a);
01043
01044 Tt->give_node_coord1d (x,eid);
01045
01046 gauss_points (gp.a,w.a,intordkm[ri][ci]);
01047 fillm (0.0,km);
01048
01049 if (Tp->savemode==0)
01050 ii=Tt->elements[eid].ipp[ri][ci];
01051 if (Tp->savemode==1)
01052 ii=Tt->elements[eid].ipp[0][0];
01053
01054 for (i=0;i<intordkm[ri][ci];i++){
01055 xi=gp[i]; ww=w[i];
01056
01057
01058 grad_matrix (gm,x,xi,jac);
01059
01060
01061 reallocm(ncomp,1,d);
01062
01063 Tm->volume_rhs (d,ii,ri,ci,ncomp);
01064
01065
01066 area = approx (xi,a);
01067
01068 jac*=area*ww;
01069
01070
01071 nnjac (km,gm,d,jac);
01072
01073 ii++;
01074 }
01075
01076 for (i=0;i<vrhs.n;i++){
01077 vrhs[i] = km[i][0];
01078 }
01079
01080 }
01081
01082
01083
01084
01085
01086
01087
01088
01089
01090
01091
01092
01093 void linbart::res_volume_rhs_vector (vector &f,long eid,long lcid)
01094 {
01095 long i,*cn;
01096 vector lf;
01097
01098 for (i=0;i<ntm;i++){
01099 cn = new long [dofe[i][i]];
01100 reallocv (dofe[i][i],lf);
01101 codnum (cn,i);
01102 volume_rhs_vector (i,eid,i,i,lf);
01103 locglob (f.a,lf.a,cn,dofe[i][i]);
01104 delete [] cn;
01105 }
01106 }
01107
01108
01109
01110
01111
01112
01113
01114
01115
01116
01117
01118 void linbart::res_capacity_matrix (long eid,matrix &cm)
01119 {
01120 long i,j,*rcn,*ccn,k,l;
01121 double s;
01122 matrix lcm;
01123
01124 for (i=0;i<ntm;i++){
01125 for (j=0;j<ntm;j++){
01126 rcn = new long [dofe[i][j]];
01127 ccn = new long [dofe[i][j]];
01128 reallocm (dofe[i][j],dofe[i][j],lcm);
01129 capacity_matrix (eid,i,j,lcm);
01130
01131
01132 if (Tp->diagcap == 1){
01133 for (k=0;k<dofe[i][j];k++){
01134 s=0.0;
01135 for (l=0;l<dofe[i][j];l++){
01136 s+=lcm[k][l];
01137 lcm[k][l]=0.0;
01138 }
01139 lcm[k][k]=s;
01140 }
01141 }
01142
01143 codnum (rcn,i);
01144 codnum (ccn,j);
01145 mat_localize (cm,lcm,rcn,ccn);
01146 delete [] rcn; delete [] ccn;
01147 }
01148 }
01149 }
01150
01151
01152
01153
01154
01155
01156
01157
01158
01159
01160
01161 void linbart::res_convection_vector (vector &f,long lcid,long eid,long leid)
01162 {
01163 long *cn;
01164 vector lf;
01165
01166
01167
01168 if ((Tt->elements[eid].transi[lcid]==2)||(Tt->elements[eid].transi[lcid]==4)){
01169
01170 cn = new long [dofe[lcid][lcid]];
01171
01172 reallocv (dofe[lcid][lcid],lf);
01173
01174 convection_vector (lf,lcid,eid,leid,lcid,lcid);
01175
01176
01177 codnum (cn,lcid);
01178
01179 locglob (f.a,lf.a,cn,dofe[lcid][lcid]);
01180 delete [] cn;
01181
01182 cmulv (-1.0,f,f);
01183 }
01184 }
01185
01186
01187
01188
01189
01190
01191
01192
01193
01194
01195
01196 void linbart::res_transmission_vector (vector &f,long lcid,long eid,long leid)
01197 {
01198 long *cn,i;
01199 vector lf;
01200
01201 cn = new long [dofe[lcid][lcid]];
01202
01203 codnum (cn,lcid);
01204 reallocv (dofe[lcid][lcid],lf);
01205
01206
01207
01208 if ((Tt->elements[eid].transi[lcid]==3)||(Tt->elements[eid].transi[lcid]==4)){
01209
01210 for (i=0;i<ntm;i++){
01211 nullv (lf.a,lf.n);
01212
01213 transmission_vector (lf,lcid,eid,leid,i);
01214
01215 locglob (f.a,lf.a,cn,dofe[lcid][lcid]);
01216 }
01217 }
01218
01219 delete [] cn;
01220 }
01221
01222
01223
01224
01225
01226
01227
01228
01229
01230
01231 void linbart::res_quantity_source_vector (vector &sv,vector &nodval,long lcid,long eid)
01232 {
01233 long *cn;
01234 vector lsv;
01235
01236 cn = new long [dofe[lcid][lcid]];
01237 reallocv (dofe[lcid][lcid],lsv);
01238 codnum (cn,lcid);
01239
01240 quantity_source_vector (lsv,nodval,eid,lcid,lcid);
01241 locglob (sv.a,lsv.a,cn,dofe[lcid][lcid]);
01242
01243 delete [] cn;
01244 }
01245
01246
01247
01248
01249
01250
01251
01252
01253
01254 void linbart::res_internal_fluxes (long eid,vector &elemif)
01255 {
01256 long i,*cn;
01257 vector lif,tdnv,nodval;
01258 matrix cm;
01259
01260
01261 for (i=0;i<ntm;i++){
01262 cn = new long [dofe[i][i]];
01263 reallocv (dofe[i][i],lif);
01264 codnum (cn,i);
01265 internal_fluxes (i,eid,lif);
01266 locglob (elemif.a,lif.a,cn,dofe[i][i]);
01267 delete [] cn;
01268 }
01269
01270 cn = new long [ndofe];
01271 Gtt->give_code_numbers (eid,cn);
01272 reallocv (ndofe,tdnv);
01273 reallocv (ndofe,lif);
01274 reallocm (ndofe,ndofe,cm);
01275
01276 nodalderivatives (tdnv.a,cn,ndofe);
01277 res_capacity_matrix (eid,cm);
01278 mxv (cm,tdnv,lif);
01279
01280
01281 subv (lif,elemif,elemif);
01282
01283
01284 if (Tt->elements[eid].source==1){
01285 reallocv (nne,nodval);
01286 fillv (0.0,nodval);
01287 fillv (0.0, lif);
01288
01289 Tb->lc[0].sourcenodalvalues (eid,nodval);
01290
01291 source_vector (0,eid,nodval,lif);
01292
01293
01294
01295
01296
01297
01298
01299
01300 addv (elemif,lif,elemif);
01301
01302
01303
01304
01305
01306
01307
01308
01309 }
01310
01311
01312 fprintf (Outt,"\n Kr+Cr+s\n");
01313 for (i=0;i<elemif.n;i++){
01314 fprintf (Outt," %le",elemif[i]);
01315 }
01316
01317 }
01318
01319
01320
01321
01322
01323
01324
01325
01326
01327
01328
01329
01330
01331 double linbart::total_integral (long eid,vector &nodval)
01332 {
01333 long i;
01334 double area,xi,ww,jac,value,f;
01335 ivector nodes(nne);
01336 vector x(nne),w(2),gp(2),a(nne);
01337
01338
01339 Tt->give_elemnodes (eid,nodes);
01340
01341 Tc->give_area (eid,nodes,a);
01342
01343 Tt->give_node_coord1d (x,eid);
01344
01345 gauss_points (gp.a,w.a,2);
01346
01347 f = 0.0;
01348
01349 for (i=0;i<2;i++){
01350 xi=gp[i]; ww=w[i];
01351
01352 jac_1d (jac,x,xi);
01353
01354 value = approx (xi,nodval);
01355
01356
01357 area = approx (xi,a);
01358
01359 jac*=area*ww*value;
01360
01361 f = f + jac;
01362 }
01363 return(f);
01364 }
01365
01366
01367
01368
01369
01370
01371
01372
01373
01374
01375
01376
01377 double linbart::total_integral_ip (long eid,long varid)
01378 {
01379 long i,ii;
01380 double area,xi,ww,jac,value,f;
01381 ivector nodes(nne);
01382 vector x(nne),w(2),gp(2),a(nne);
01383
01384
01385 Tt->give_elemnodes (eid,nodes);
01386
01387 Tc->give_area (eid,nodes,a);
01388
01389 Tt->give_node_coord1d (x,eid);
01390
01391 gauss_points (gp.a,w.a,2);
01392
01393 f = 0.0;
01394
01395 long ri=0;
01396 long ci=0;
01397 if (Tp->savemode==0)
01398 ii=Tt->elements[eid].ipp[ri][ci];
01399 if (Tp->savemode==1)
01400 ii=Tt->elements[eid].ipp[0][0];
01401
01402 for (i=0;i<2;i++){
01403 xi=gp[i]; ww=w[i];
01404
01405 jac_1d (jac,x,xi);
01406
01407 value = Tm->ip[ii].eqother[varid];
01408
01409
01410 area = approx (xi,a);
01411
01412 jac*=area*ww*value;
01413
01414 f = f + jac;
01415 }
01416 return f;
01417 }
01418
01419
01420
01421
01422
01423
01424
01425
01426
01427
01428
01429
01430
01431
01432
01433 void linbart::boundary_flux (vector &tmv,long lcid,long eid,long leid,long ri,long ci)
01434 {
01435 long ii;
01436 double xi,area;
01437 double new_nodval,tr;
01438 long nn;
01439 bocontypet bc[2];
01440
01441 ivector nodes(nne);
01442 vector x(nne),trc(2),trcn(nne),nodval(2),av(dofe[ri][ci]),v(dofe[ri][ci]),a(nne);
01443 vector trr(2);
01444 matrix n(1,dofe[ri][ci]),km(dofe[ri][ci],dofe[ri][ci]);
01445
01446
01447 Tt->give_elemnodes (eid,nodes);
01448
01449 Tt->give_node_coord1d (x,eid);
01450
01451 Tc->give_area (eid,nodes,a);
01452
01453
01454 Tb->lc[lcid].elemload[leid].give_bc (bc);
01455
01456 Tb->lc[lcid].elemload[leid].give_nodval (lcid,nodval);
01457
01458 Tb->lc[lcid].elemload[leid].give_trc (lcid,ci,trc);
01459
01460 Tb->lc[lcid].elemload[leid].give_trr (lcid,trr);
01461
01462 if (Tp->savemode==0)
01463 ii=Tt->elements[eid].ipp[ri][ci];
01464 if (Tp->savemode==1)
01465 ii=Tt->elements[eid].ipp[0][0];
01466
01467 if (bc[0]==5 || bc[0]>10){
01468 fillm (0.0,km);
01469 xi=-1.0;
01470
01471 bf_matrix (n,xi);
01472
01473 nn = nodes[0];
01474 tr = 0.0;
01475 if(bc[0] == 90)
01476 tr = trr[0]/trc[0];
01477
01478 Tm->transmission_flux(new_nodval,nodval[0],tr,ri,ci,nn,bc[0],ii);
01479
01480 av[0]=new_nodval; av[1]=0.0;
01481
01482
01483 area = approx (xi,a);
01484 nnj (km.a,n.a,trc[0]*area,n.m,n.n);
01485
01486 mxv (km,av,v); addv (tmv,v,tmv);
01487 }
01488 if (bc[1]==5 || bc[1]>10){
01489 fillm (0.0,km);
01490 xi=1.0;
01491
01492 bf_matrix (n,xi);
01493
01494 nn = nodes[1];
01495 tr = 0.0;
01496 if(bc[0] == 90)
01497 tr = trr[1]/trc[1];
01498
01499 Tm->transmission_flux(new_nodval,nodval[1],tr,ri,ci,nn,bc[1],ii);
01500
01501 av[0]=0.0; av[1]=new_nodval;
01502
01503
01504 area = approx (xi,a);
01505 nnj (km.a,n.a,trc[1]*area,n.m,n.n);
01506
01507 mxv (km,av,v); addv (tmv,v,tmv);
01508 }
01509 }
01510
01511
01512
01513
01514
01515
01516
01517
01518
01519
01520
01521
01522
01523 void linbart::res_boundary_flux (vector &f,long lcid,long eid,long leid)
01524 {
01525 long *cn,i;
01526 vector lf;
01527
01528 cn = new long [dofe[lcid][lcid]];
01529 codnum (cn,lcid);
01530
01531
01532 for (i=0;i<ntm;i++){
01533 reallocv (dofe[lcid][lcid],lf);
01534
01535 if ((Tt->elements[eid].transi[i]==3)||(Tt->elements[eid].transi[i]==4))
01536 boundary_flux (lf,i,eid,leid,lcid,i);
01537
01538 locglob (f.a,lf.a,cn,dofe[lcid][lcid]);
01539 }
01540
01541 delete [] cn;
01542 }
01543
01544
01545
01546
01547
01548
01549
01550
01551
01552 void linbart::intpointflux (long eid)
01553 {
01554 long i,ii,jj,k,ipp;
01555
01556 for (k=0;k<Tp->ntm;k++){
01557
01558 for (ii=0;ii<Tp->ntm;ii++){
01559 for (jj=0;jj<Tp->ntm;jj++){
01560
01561 ipp=Tt->elements[eid].ipp[ii][jj];
01562
01563 for (i=0;i<intordkm[ii][jj];i++){
01564
01565 if (Tp->fluxcomp==1)
01566 Tm->computenlfluxes (k,ipp);
01567
01568 ipp++;
01569 }
01570
01571 for (i=0;i<intordcm[ii][jj];i++){
01572
01573 if (Tp->fluxcomp==1)
01574 Tm->computenlfluxes (k,ipp);
01575
01576 ipp++;
01577 }
01578 if (Tp->savemode==1) break;
01579 }
01580 if (Tp->savemode==1) break;
01581 }
01582 }
01583 }
01584
01585
01586
01587
01588
01589
01590
01591
01592
01593 void linbart::nod_grads_ip (long eid)
01594 {
01595 long i,j,k,ipp;
01596 ivector ipnum(nne),nod(nne);
01597 vector grad(ncomp);
01598
01599
01600
01601 ipp=Tt->elements[eid].ipp[0][0];
01602 nodip_bar (ipp,intordkm[0][0],ipnum);
01603
01604
01605 Tt->give_elemnodes (eid,nod);
01606
01607 for (i=0;i<nne;i++){
01608 for (k=0;k<Tp->ntm;k++){
01609
01610 Tm->givegrad (k,ipnum[i],grad);
01611
01612
01613 j=nod[i];
01614 Tt->nodes[j].storegrad (k,grad);
01615 }
01616 }
01617
01618 }
01619
01620
01621
01622
01623
01624
01625
01626
01627
01628 void linbart::nod_fluxes_ip (long eid)
01629 {
01630 long i,j,k,ipp;
01631 ivector ipnum(nne),nod(nne);
01632 vector flux(ncomp);
01633
01634
01635
01636 ipp=Tt->elements[eid].ipp[0][0];
01637 nodip_bar (ipp,intordkm[0][0],ipnum);
01638
01639
01640 Tt->give_elemnodes (eid,nod);
01641
01642 intpointflux (eid);
01643
01644 for (i=0;i<nne;i++){
01645 for (k=0;k<Tp->ntm;k++){
01646
01647 Tm->givefluxes (k,ipnum[i],flux);
01648
01649
01650 j=nod[i];
01651 Tt->nodes[j].storeflux (k,flux);
01652 }
01653 }
01654
01655 }
01656
01657
01658
01659
01660
01661
01662
01663
01664
01665
01666
01667
01668
01669 void linbart::nod_others_comp (long lcid,long eid,long ri,long ci)
01670 {
01671 long i,j,k,ipp,ncompother,ii;
01672 vector h,r(ndofe);
01673 ivector nod(nne),cn(ndofe);
01674 double other;
01675
01676 Tt->give_elemnodes (eid,nod);
01677 Tt->give_code_numbers (eid,cn.a);
01678 elemvalues (lcid,eid,r.a,cn.a,ndofe);
01679 ncompother = Tm->givencompother();
01680 reallocv (ntm,h);
01681
01682 ii = 0;
01683 for (i=0;i<nne;i++){
01684 if (Tp->savemode==0)
01685 ipp=Tt->elements[eid].ipp[ri][ci];
01686 if (Tp->savemode==1)
01687 ipp=Tt->elements[eid].ipp[0][0];
01688
01689 for (j=0;j<ntm;j++){
01690 h[j] = r[ii];
01691 ii++;
01692 }
01693
01694 for(k=0;k<ncompother;k++){
01695 other = Tm->givecompother(k,ipp,h.a);
01696 Tt->nodes[nod[i]].storeother (k,other);
01697 }
01698 }
01699
01700 }
01701
01702
01703
01704
01705
01706
01707
01708
01709
01710
01711
01712
01713
01714
01715
01716
01717
01718 void linbart::transq_nodval (long eid,vector &nodval,nonmechquant nmq)
01719 {
01720 long i,ipid;
01721 ivector ipnum(nne);
01722
01723
01724
01725 ipid=Tt->elements[eid].ipp[0][0];
01726 nodip_bar (ipid,intordkm[0][0],ipnum);
01727
01728 for (i=0;i<nne;i++)
01729 {
01730
01731 nodval[i] = Tm->givetransq(nmq, ipnum[i]);
01732 }
01733 }
01734
01735
01736
01737
01738
01739
01740
01741
01742
01743
01744
01745
01746
01747
01748
01749
01750
01751
01752 void linbart::transq_nodval_comp (long eid,vector &nodval, long ncne, long nq, nonmechquant *qt)
01753 {
01754 long i,j,ipid;
01755 long ncompo;
01756 ivector ipnum(nne), enod(nne);
01757 intpointst ipb;
01758
01759
01760
01761 ipid=Tt->elements[eid].ipp[0][0];
01762
01763
01764 Tt->give_elemnodes(eid, enod);
01765
01766
01767
01768 nodip_bar (ipid,intordkm[0][0],ipnum);
01769
01770
01771
01772
01773
01774
01775 ipb.copy(Tm->ip[ipid], ntm);
01776
01777
01778
01779 for (i=0;i<ncne;i++)
01780 {
01781
01782 nodalval (0, Tm->ip[ipid].av, enod[i]);
01783
01784
01785
01786
01787 ncompo = Tm->ip[ipnum[i]].ncompeqother;
01788 if (ncompo){
01789
01790 Tm->storeeqother(ipid, ncompo, Tm->ip[ipnum[i]].eqother);
01791 }
01792 ncompo = Tm->ip[ipnum[i]].ncompother;
01793 if (ncompo){
01794
01795 Tm->storeother(ipid, ncompo, Tm->ip[ipnum[i]].other);
01796 }
01797
01798 Tm->mat_aux_values(ipid);
01799
01800
01801 for (j=0; j<nq; j++)
01802 nodval[j*ncne+i] = Tm->givetransq(qt[j], ipid);
01803 }
01804
01805 Tm->ip[ipid].copy(ipb, ntm);
01806 }