00001 #include <stdlib.h>
00002 #include <stdio.h>
00003
00004
00005 #include <math.h>
00006
00007
00008 #include "normmat.h"
00009
00010
00011 #include "mechmat.h"
00012
00013
00014 #include "intpoints.h"
00015
00016
00017 #include "global.h"
00018
00019
00020 #include "matrix.h"
00021
00022
00023
00024
00025
00026
00027
00028
00029 normmat::normmat (void)
00030 {
00031 tcn=NULL;
00032
00033 zero=1.0e-10;
00034
00035 iter=1;
00036
00037 tcn = new double [4];
00038 ki = new double [4];
00039 a1sp = new double [4];
00040 b1sp = new double [4];
00041 allocm (2,2,kn);
00042 allocm (4,4,kp);
00043 allocv (2,fkn);
00044 allocv (4,fkp);
00045 m = new double [4];
00046 mp = new double [4];
00047 mpp = new double [4];
00048 tcv = new double [4];
00049 tcn = new double [4];
00050 epscsp = new double [4];
00051 epss1sp = new double [4];
00052 a1sp = new double [4];
00053 a2spp = new double [4];
00054 a2sp = new double [4];
00055 b1sp = new double [4];
00056 b2spp = new double [4];
00057 b2sp = new double [4];
00058 mr = new double [4];
00059 epscr = new double [4];
00060 epss1r = new double [4];
00061 epss1spp = new double [4];
00062 xr = new double [4];
00063 xsp = new double [4];
00064 ir1 = new double [4];
00065 ims1 = new double [4];
00066 ims2 = new double [4];
00067 ir2 = new double [4];
00068 ir3 = new double [4];
00069 ims3 = new double [4];
00070 ic1 = new double [4];
00071 ic2 = new double [4];
00072 icp = new double [4];
00073 c1 = new double [4];
00074 c2 = new double [4];
00075 c1p = new double [4];
00076 c2p = new double [4];
00077 kih = new double [4];
00078 kid = new double [4];
00079 ki = new double [4];
00080
00081 }
00082
00083
00084
00085
00086
00087 normmat::~normmat (void)
00088
00089
00090 {
00091
00092
00093 delete [] tcn;
00094
00095
00096 }
00097
00098
00099
00100
00101
00102 void normmat::read (XFILE *in)
00103 {
00104 xfscanf (in,"%le %le %le %le %le %le %le %le %le %le %le %le %le %le %le",
00105 &fck,&fy,&ft,&epsc1,&epscm,&epss1lim,&ash,&asd,&ch,&cd,&e0c,&h,&b,&fp,&fn);
00106
00107
00108 compute_fc ();
00109 compute_ecnom ();
00110 compute_epsuk ();
00111 compute_e0cn ();
00112 compute_k ();
00113 compute_a ();
00114 compute_d ();
00115
00116 }
00117
00118
00119
00120
00121
00122
00123
00124
00125
00126
00127 void normmat::compute_fc ()
00128 {
00129 fc=-8000.0 + fck;
00130 }
00131
00132
00133
00134
00135
00136
00137
00138
00139 void normmat::compute_ecnom ()
00140 {
00141 ecnom = (1.6321156877891085*fc)/epsc1;
00142 }
00143
00144
00145
00146
00147
00148
00149
00150
00151 void normmat::compute_epsuk ()
00152 {
00153 epsuk = 0.05;
00154 }
00155
00156
00157
00158
00159
00160
00161 void normmat::compute_e0cn ()
00162 {
00163 e0cn = (ft - fy)/(-(fy/e0c) + epsuk);
00164 }
00165
00166
00167
00168
00169
00170
00171 void normmat::compute_k ()
00172 {
00173 k = (11*ecnom*epsc1)/(10.*fc);
00174 }
00175
00176
00177
00178
00179
00180
00181
00182
00183 void normmat::compute_a ()
00184 {
00185 a = b*h;
00186 }
00187
00188
00189
00190
00191
00192
00193
00194
00195 void normmat::compute_d ()
00196 {
00197 d = h - cd;
00198 }
00199
00200
00201
00202
00203
00204
00205
00206
00207
00208 void normmat::compute_z1 (long ipp,double lp)
00209 {
00210
00211
00212
00213
00214
00215
00216
00217
00218
00219
00220
00221
00222
00223 z1 = Mm->ip[ipp].stress[1];
00224
00225 }
00226
00227
00228
00229
00230
00231
00232 void normmat::compute_z2 (long ipp,double lp)
00233 {
00234
00235
00236
00237
00238
00239
00240
00241
00242
00243
00244
00245
00246
00247 z2 = Mm->ip[ipp].stress[2];
00248
00249 }
00250
00251
00252
00253
00254
00255
00256
00257
00258
00259 void normmat::compute_z3p (long ipp,double lp)
00260 {
00261
00262
00263 z3p = Mm->ip[ipp].stress[0];
00264
00265
00266 }
00267
00268
00269
00270
00271
00272
00273
00274
00275
00276 void normmat::compute_z3 ()
00277 {
00278
00279
00280
00281
00282
00283
00284
00285
00286
00287
00288
00289
00290
00291 if (z3p <= 0.0)
00292
00293 { z3 = 0.1; }
00294
00295 else
00296
00297 { z3 = z3p; }
00298
00299
00300
00301 }
00302
00303
00304
00305
00306
00307
00308
00309
00310
00311 double normmat::compute_as1 (double lp)
00312 {
00313 if (-(fp*pow(lp,2))/8. - (lp*z1)/2. - z2 <= 0){
00314 as1=asd;
00315 }
00316 else {
00317 as1=ash;
00318 }
00319 return as1;
00320 }
00321
00322
00323
00324
00325
00326
00327 double normmat::compute_as2 (double lp)
00328 {
00329 if (-(fp*pow(lp,2))/8. - (lp*z1)/2. - z2 <= 0){
00330 as2=ash;
00331 }
00332 else {
00333 as2=asd;
00334 }
00335
00336 return as2;
00337 }
00338
00339
00340
00341
00342
00343
00344
00345
00346
00347
00348
00349 void normmat::compute_m (double lp)
00350 {
00351
00352 m[0]=-(fp*pow(lp, 2))/128. - (lp*z1)/8. - z2;
00353
00354
00355 m[1]=(-9*fp*pow(lp, 2))/128. - (3*lp*z1)/8. - z2;
00356
00357
00358 m[2]=(-25*fp*pow(lp, 2))/128. - (5*lp*z1)/8. - z2;
00359
00360
00361 m[3]=(-49*fp*pow(lp, 2))/128. - (7*lp*z1)/8. - z2;
00362
00363
00364
00365
00366
00367 }
00368
00369
00370
00371
00372
00373
00374
00375
00376 void normmat::compute_mpp (double lp)
00377 {
00378 if(m[0]==0.0){mpp[0]= 0.01;}
00379 else {mpp[0]= fabs(-(fp*pow(lp, 2))/128. - (lp*z1)/8. - z2);}
00380
00381 if(m[1]==0.0){mpp[1]= 0.01;}
00382 else {mpp[1]= fabs((-9*fp*pow(lp, 2))/128. - (3*lp*z1)/8. - z2);}
00383
00384 if(m[2]==0.0){mpp[2]= 0.01;}
00385 else {mpp[2]= fabs((-25*fp*pow(lp, 2))/128. - (5*lp*z1)/8. - z2);}
00386
00387 if(m[3]==0.0){mpp[3]= 0.01;}
00388 else {mpp[3]= fabs((-49*fp*pow(lp, 2))/128. - (7*lp*z1)/8. - z2);}
00389
00390
00391 }
00392
00393
00394
00395
00396
00397
00398
00399
00400 double normmat::compute_n0 (double lp)
00401
00402
00403 {
00404
00405
00406 double n0;
00407
00408
00409
00410
00411
00412
00413
00414
00415 if (-z3 + fn*lp/2 <= -0.1 ){
00416
00417
00418 n0=-z3 + fn*lp/2;}
00419
00420
00421
00422
00423
00424 else{
00425
00426
00427 n0=-0.1;
00428
00429
00430 }
00431
00432
00433
00434
00435
00436 return n0;
00437
00438
00439 }
00440
00441
00442
00443
00444
00445
00446
00447
00448
00449
00450 long normmat::compute_iter ()
00451
00452
00453 {
00454
00455
00456 long iter;
00457
00458
00459
00460
00461
00462
00463
00464
00465 iter = 1;
00466
00467
00468 return iter;
00469
00470
00471 }
00472
00473
00474
00475
00476
00477
00478
00479
00480
00481
00482 void normmat::compute_tcv ()
00483 {
00484 long i;
00485
00486 for (i=0;i<4;i++){
00487
00488
00489
00490
00491
00492 }
00493
00494
00495
00496
00497
00498
00499
00500
00501
00502
00503
00504
00505
00506
00507
00508
00509
00510
00511
00512
00513
00514
00515
00516
00517
00518
00519
00520
00521
00522
00523
00524
00525
00526
00527
00528
00529
00530
00531 tcv[0]=0.0;
00532
00533
00534 tcv[1]=0.0;
00535
00536
00537 tcv[2]=0.0;
00538
00539
00540 tcv[3]=0.0;
00541
00542
00543
00544
00545
00546 }
00547
00548
00549
00550
00551
00552
00553
00554
00555
00556
00557
00558
00559
00560
00561 double normmat::compute_epsn ()
00562
00563
00564 {
00565
00566
00567 double epsn;
00568
00569
00570
00571
00572
00573 epsn =(-2*a*fc*epsc1 + 3*a*fc*k*epsc1 + as1*e0c*k*pow(epsc1, 2) +
00574
00575
00576 as2*e0c*k*pow(epsc1, 2) -
00577
00578
00579 sqrt(pow(epsc1,
00580
00581
00582 2)*(-8*a*fc*(-1 + k)*k*n0 +
00583
00584
00585 pow(a*fc*(-2 + 3*k) + (as1 + as2)*e0c*k*epsc1, 2))))/(4.*a*
00586
00587
00588 fc*(-1 + k));
00589
00590
00591
00592
00593
00594 return epsn;
00595
00596
00597 }
00598
00599
00600
00601
00602
00603
00604
00605
00606 double normmat::compute_nmax ()
00607
00608
00609 {
00610
00611
00612 double nmax;
00613
00614
00615
00616
00617
00618 nmax =as1*e0c*epsc1 +
00619
00620
00621 as2*e0c*epsc1 + (a*fc*(-2*(-1 + k)*epsc1 + (-2 + 3*k)*epsc1))/(k*epsc1);
00622
00623
00624
00625
00626
00627 return nmax;
00628
00629
00630 }
00631
00632
00633
00634
00635
00636
00637
00638
00639 double normmat::compute_an1 ()
00640
00641
00642 {
00643
00644
00645 double an1;
00646
00647
00648
00649
00650
00651 an1 = sqrt(pow(epsc1,
00652
00653
00654 2)*(-8*a*fc*(-1 + k)*k*n0 +
00655
00656
00657 pow(a*fc*(-2 + 3*k) + (as1 + as2)*e0c*k*epsc1, 2)))/(k*
00658
00659
00660 pow(epsc1, 2));
00661
00662
00663
00664
00665
00666 return an1;
00667
00668
00669 }
00670
00671
00672
00673
00674
00675
00676
00677
00678 double normmat::compute_an2 ()
00679
00680
00681 {
00682
00683
00684 double an2;
00685
00686
00687
00688
00689
00690 an2 = n0 + (sqrt(pow(epsc1,
00691
00692
00693 2)*(-8*a*fc*(-1 + k)*k*n0 +
00694
00695
00696 pow(a*fc*(-2 + 3*k) + (as1 + as2)*e0c*k*epsc1,
00697
00698
00699 2)))*(epsc1*(a*fc*(2 - 3*k) - (as1 + as2)*e0c*k*epsc1) +
00700
00701
00702 sqrt(pow(epsc1,
00703
00704
00705 2)*(-8*a*fc*(-1 + k)*k*n0 +
00706
00707
00708 pow(a*fc*(-2 + 3*k) + (as1 + as2)*e0c*k*epsc1,
00709
00710
00711 2)))))/(4.*a*fc*(-1 + k)*k*pow(epsc1, 2));
00712
00713
00714
00715
00716
00717 return an2;
00718
00719
00720 }
00721
00722
00723
00724
00725
00726
00727
00728
00729 double normmat::compute_in1 (double lp)
00730
00731
00732 {
00733
00734
00735 double in1;
00736
00737
00738
00739
00740
00741
00742
00743
00744 if (fn == 0. && z3>= 0.0){
00745
00746
00747
00748
00749
00750 in1=1/(32.*pow(a, 2)*pow(fc, 2)*pow(-1 + k, 2)*k*pow(epsc1, 2))*(lp*
00751
00752
00753 pow(a*fc*(-2 + 3*k)*epsc1 + (as1 + as2)*e0c*k*pow(epsc1, 2) -
00754
00755
00756 sqrt(pow(epsc1,
00757
00758
00759 2)*(8*a*fc*(-1 + k)*k*z3 +
00760
00761
00762 pow(a*fc*(-2 + 3*k) + (as1 + as2)*e0c*k*epsc1, 2))),
00763
00764
00765 2)*(a*fc*(-2 + 3*k)*epsc1 - (as1 + as2)*e0c*k*pow(epsc1, 2) +
00766
00767
00768 sqrt(pow(epsc1,
00769
00770
00771 2)*(8*a*fc*(-1 + k)*k*z3 +
00772
00773
00774 pow(a*fc*(-2 + 3*k) + (as1 + as2)*e0c*k*epsc1, 2)))));
00775
00776
00777
00778
00779
00780 }
00781
00782
00783 else if (fn != 0. && z3>= 0.0){
00784
00785
00786
00787
00788
00789 in1=-(1/(960.*pow(a, 3)*pow(fc, 3)*fn*pow(-1 + k, 3)*
00790
00791
00792 pow(k, 2)))*(-pow(a, 4)*pow(fc, 4)*
00793
00794
00795 pow(2 - 3*k,
00796
00797
00798 4)*(sqrt(pow(epsc1,
00799
00800
00801 2)*(-8*a*fc*(-1 + k)*k*(fn*lp - z3) +
00802
00803
00804 pow(a*fc*(-2 + 3*k) + (as1 + as2)*e0c*k*epsc1, 2))) -
00805
00806
00807 sqrt(pow(epsc1,
00808
00809
00810 2)*(8*a*fc*(-1 + k)*k*z3 +
00811
00812
00813 pow(a*fc*(-2 + 3*k) + (as1 + as2)*e0c*k*epsc1,
00814
00815
00816 2)))) +
00817
00818
00819 9*pow(as1 + as2, 4)*pow(e0c, 4)*pow(k, 4)*
00820
00821
00822 pow(epsc1,
00823
00824
00825 4)*(sqrt(pow(epsc1,
00826
00827
00828 2)*(-8*a*fc*(-1 + k)*k*(fn*lp - z3) +
00829
00830
00831 pow(a*fc*(-2 + 3*k) + (as1 + as2)*e0c*k*epsc1, 2))) -
00832
00833
00834 sqrt(pow(epsc1,
00835
00836
00837 2)*(8*a*fc*(-1 + k)*k*z3 +
00838
00839
00840 pow(a*fc*(-2 + 3*k) + (as1 + as2)*e0c*k*epsc1,
00841
00842
00843 2)))) +
00844
00845
00846 2*pow(a, 3)*pow(fc, 3)*
00847
00848
00849 k*(-2 + 3*k)*(-60*pow(fn, 2)*pow(-1 + k, 2)*k*pow(lp, 2)*
00850
00851
00852 epsc1 + (-2 + 3*k)*(2*(-1 + k)*z3 +
00853
00854
00855 3*(as1 + as2)*e0c*(-2 + 3*k)*
00856
00857
00858 epsc1)*(sqrt(pow(epsc1,
00859
00860
00861 2)*(-8*a*fc*(-1 + k)*k*(fn*lp - z3) +
00862
00863
00864 pow(a*fc*(-2 + 3*k) + (as1 + as2)*e0c*k*epsc1,
00865
00866
00867 2))) -
00868
00869
00870 sqrt(pow(epsc1,
00871
00872
00873 2)*(8*a*fc*(-1 + k)*k*z3 +
00874
00875
00876 pow(a*fc*(-2 + 3*k) + (as1 + as2)*e0c*k*epsc1,
00877
00878
00879 2))))\
00880
00881
00882 +2*fn*(-1 + k)*
00883
00884
00885 lp*(30*pow(k, 2)*epsc1*(2*z3 + 3*(as1 + as2)*e0c*epsc1) +
00886
00887
00888 2*sqrt(pow(epsc1,
00889
00890
00891 2)*(-8*a*fc*(-1 + k)*k*(fn*lp - z3) +
00892
00893
00894 pow(a*fc*(-2 + 3*k) + (as1 + as2)*e0c*k*epsc1,
00895
00896
00897 2))) -
00898
00899
00900 3*k*(20*z3*epsc1 + 20*as1*e0c*pow(epsc1, 2) +
00901
00902
00903 20*as2*e0c*pow(epsc1, 2) +
00904
00905
00906 sqrt(pow(epsc1,
00907
00908
00909 2)*(-8*a*fc*(-1 + k)*k*(fn*lp - z3) +
00910
00911
00912 pow(a*fc*(-2 + 3*k) + (as1 + as2)*e0c*k*
00913
00914
00915 epsc1, 2)))))) +
00916
00917
00918 2*a*pow(as1 + as2, 2)*pow(e0c, 2)*fc*pow(k, 3)*
00919
00920
00921 pow(epsc1,
00922
00923
00924 2)*(as1*e0c*
00925
00926
00927 epsc1*(60*fn*(-1 + k)*k*lp*epsc1 +
00928
00929
00930 13*(-2 +
00931
00932
00933 3*k)*(sqrt(pow(epsc1,
00934
00935
00936 2)*(-8*a*fc*(-1 + k)*k*(fn*lp - z3) +
00937
00938
00939 pow(a*fc*(-2 + 3*k) + (as1 + as2)*e0c*k*
00940
00941
00942 epsc1, 2))) -
00943
00944
00945 sqrt(pow(epsc1,
00946
00947
00948 2)*(8*a*fc*(-1 + k)*k*z3 +
00949
00950
00951 pow(a*fc*(-2 + 3*k) + (as1 + as2)*e0c*k*
00952
00953
00954 epsc1, 2))))) +
00955
00956
00957 as2*e0c*epsc1*(60*fn*(-1 + k)*k*lp*epsc1 +
00958
00959
00960 13*(-2 +
00961
00962
00963 3*k)*(sqrt(pow(epsc1,
00964
00965
00966 2)*(-8*a*fc*(-1 + k)*k*(fn*lp - z3) +
00967
00968
00969 pow(a*fc*(-2 + 3*k) + (as1 + as2)*e0c*k*
00970
00971
00972 epsc1, 2))) -
00973
00974
00975 sqrt(pow(epsc1,
00976
00977
00978 2)*(8*a*fc*(-1 + k)*k*z3 +
00979
00980
00981 pow(a*fc*(-2 + 3*k) + (as1 + as2)*e0c*k*
00982
00983
00984 epsc1, 2))))) -
00985
00986
00987 42*(-1 +
00988
00989
00990 k)*(fn*lp*
00991
00992
00993 sqrt(pow(epsc1,
00994
00995
00996 2)*(-8*a*fc*(-1 + k)*k*(fn*lp - z3) +
00997
00998
00999 pow(a*fc*(-2 + 3*k) + (as1 + as2)*e0c*k*epsc1,
01000
01001
01002 2))) +
01003
01004
01005 z3*(-sqrt(pow(epsc1,
01006
01007
01008 2)*(-8*a*fc*(-1 + k)*k*(fn*lp - z3) +
01009
01010
01011 pow(a*fc*(-2 + 3*k) + (as1 + as2)*e0c*k*
01012
01013
01014 epsc1, 2))) +
01015
01016
01017 sqrt(pow(epsc1,
01018
01019
01020 2)*(8*a*fc*(-1 + k)*k*z3 +
01021
01022
01023 pow(a*fc*(-2 + 3*k) + (as1 + as2)*e0c*k*
01024
01025
01026 epsc1, 2)))))) +
01027
01028
01029 8*pow(a, 2)*pow(fc, 2)*
01030
01031
01032 pow(k,
01033
01034
01035 2)*(3*pow(as1, 2)*pow(e0c, 2)*(-2 + 3*k)*
01036
01037
01038 pow(epsc1,
01039
01040
01041 2)*(10*fn*(-1 + k)*k*lp*
01042
01043
01044 epsc1 + (-2 +
01045
01046
01047 3*k)*(sqrt(pow(epsc1,
01048
01049
01050 2)*(-8*a*fc*(-1 + k)*k*(fn*lp - z3) +
01051
01052
01053 pow(a*fc*(-2 + 3*k) + (as1 + as2)*e0c*k*
01054
01055
01056 epsc1, 2))) -
01057
01058
01059 sqrt(pow(epsc1,
01060
01061
01062 2)*(8*a*fc*(-1 + k)*k*z3 +
01063
01064
01065 pow(a*fc*(-2 + 3*k) + (as1 + as2)*e0c*k*
01066
01067
01068 epsc1, 2))))) +
01069
01070
01071 3*pow(as2, 2)*pow(e0c, 2)*(-2 + 3*k)*
01072
01073
01074 pow(epsc1,
01075
01076
01077 2)*(10*fn*(-1 + k)*k*lp*
01078
01079
01080 epsc1 + (-2 +
01081
01082
01083 3*k)*(sqrt(pow(epsc1,
01084
01085
01086 2)*(-8*a*fc*(-1 + k)*k*(fn*lp - z3) +
01087
01088
01089 pow(a*fc*(-2 + 3*k) + (as1 + as2)*e0c*k*
01090
01091
01092 epsc1, 2))) -
01093
01094
01095 sqrt(pow(epsc1,
01096
01097
01098 2)*(8*a*fc*(-1 + k)*k*z3 +
01099
01100
01101 pow(a*fc*(-2 + 3*k) + (as1 + as2)*e0c*k*
01102
01103
01104 epsc1, 2))))) -
01105
01106
01107 as2*e0c*(-1 + k)*
01108
01109
01110 epsc1*(45*pow(fn, 2)*(-1 + k)*k*pow(lp, 2)*epsc1 +
01111
01112
01113 fn*lp*(90*k*z3*epsc1 - 90*pow(k, 2)*z3*epsc1 -
01114
01115
01116 22*sqrt(pow(epsc1,
01117
01118
01119 2)*(-8*a*fc*(-1 + k)*k*(fn*lp - z3) +
01120
01121
01122 pow(a*fc*(-2 + 3*k) + (as1 + as2)*e0c*k*
01123
01124
01125 epsc1, 2))) +
01126
01127
01128 33*k*sqrt(pow(epsc1,
01129
01130
01131 2)*(-8*a*fc*(-1 + k)*k*(fn*lp - z3) +
01132
01133
01134 pow(a*fc*(-2 + 3*k) + (as1 + as2)*e0c*k*
01135
01136
01137 epsc1, 2)))) -
01138
01139
01140 11*(-2 + 3*k)*
01141
01142
01143 z3*(sqrt(pow(epsc1,
01144
01145
01146 2)*(-8*a*fc*(-1 + k)*k*(fn*lp - z3) +
01147
01148
01149 pow(a*fc*(-2 + 3*k) + (as1 + as2)*e0c*k*
01150
01151
01152 epsc1, 2))) -
01153
01154
01155 sqrt(pow(epsc1,
01156
01157
01158 2)*(8*a*fc*(-1 + k)*k*z3 +
01159
01160
01161 pow(a*fc*(-2 + 3*k) + (as1 + as2)*e0c*k*
01162
01163
01164 epsc1, 2))))) +
01165
01166
01167 12*pow(-1 + k,
01168
01169
01170 2)*(pow(fn, 2)*pow(lp, 2)*
01171
01172
01173 sqrt(pow(epsc1,
01174
01175
01176 2)*(-8*a*fc*(-1 + k)*k*(fn*lp - z3) +
01177
01178
01179 pow(a*fc*(-2 + 3*k) + (as1 + as2)*e0c*k*epsc1,
01180
01181
01182 2))) -
01183
01184
01185 2*fn*lp*z3*
01186
01187
01188 sqrt(pow(epsc1,
01189
01190
01191 2)*(-8*a*fc*(-1 + k)*k*(fn*lp - z3) +
01192
01193
01194 pow(a*fc*(-2 + 3*k) + (as1 + as2)*e0c*k*epsc1,
01195
01196
01197 2))) +
01198
01199
01200 pow(z3,
01201
01202
01203 2)*(sqrt(pow(epsc1,
01204
01205
01206 2)*(-8*a*fc*(-1 + k)*k*(fn*lp - z3) +
01207
01208
01209 pow(a*fc*(-2 + 3*k) + (as1 + as2)*e0c*k*
01210
01211
01212 epsc1, 2))) -
01213
01214
01215 sqrt(pow(epsc1,
01216
01217
01218 2)*(8*a*fc*(-1 + k)*k*z3 +
01219
01220
01221 pow(a*fc*(-2 + 3*k) + (as1 + as2)*e0c*k*
01222
01223
01224 epsc1, 2))))) +
01225
01226
01227 as1*e0c*epsc1*(-45*pow(fn, 2)*pow(-1 + k, 2)*k*pow(lp, 2)*
01228
01229
01230 epsc1 + (-2 + 3*k)*(11*(-1 + k)*z3 +
01231
01232
01233 6*as2*e0c*(-2 + 3*k)*
01234
01235
01236 epsc1)*(sqrt(pow(epsc1,
01237
01238
01239 2)*(-8*a*fc*(-1 + k)*k*(fn*lp - z3) +
01240
01241
01242 pow(a*fc*(-2 + 3*k) + (as1 + as2)*e0c*k*
01243
01244
01245 epsc1, 2))) -
01246
01247
01248 sqrt(pow(epsc1,
01249
01250
01251 2)*(8*a*fc*(-1 + k)*k*z3 +
01252
01253
01254 pow(a*fc*(-2 + 3*k) + (as1 + as2)*e0c*k*
01255
01256
01257 epsc1, 2)))) +
01258
01259
01260 fn*(-1 + k)*
01261
01262
01263 lp*(90*pow(k, 2)*epsc1*(z3 + 2*as2*e0c*epsc1) +
01264
01265
01266 22*sqrt(pow(epsc1,
01267
01268
01269 2)*(-8*a*fc*(-1 + k)*k*(fn*lp - z3) +
01270
01271
01272 pow(a*fc*(-2 + 3*k) + (as1 + as2)*e0c*k*
01273
01274
01275 epsc1, 2))) -
01276
01277
01278 3*k*(30*z3*epsc1 + 40*as2*e0c*pow(epsc1, 2) +
01279
01280
01281 11*sqrt(pow(epsc1,
01282
01283
01284 2)*(-8*a*fc*(-1 + k)*k*(fn*lp - z3) +
01285
01286
01287 pow(a*fc*(-2 + 3*k) + (as1 + as2)*
01288
01289
01290 e0c*k*epsc1, 2))))))));
01291
01292
01293
01294
01295
01296 }
01297
01298
01299
01300
01301
01302 else{
01303
01304
01305
01306
01307
01308 in1=0.;
01309
01310
01311
01312
01313
01314 }
01315
01316
01317 return in1;
01318
01319
01320 }
01321
01322
01323
01324
01325
01326
01327
01328
01329 double normmat::compute_in2 (double lp)
01330
01331
01332 {
01333
01334
01335 double in2;
01336
01337
01338
01339
01340
01341
01342
01343
01344 if (fn == 0. && z3>= 0.0){
01345
01346
01347
01348
01349
01350 in2=1/(16.*pow(a, 2)*pow(fc, 2)*pow(-1 + k, 2))*((as1 + as2)*e0c*lp*
01351
01352
01353 pow(a*fc*(-2 + 3*k)*epsc1 + (as1 + as2)*e0c*k*pow(epsc1, 2) -
01354
01355
01356 sqrt(pow(epsc1,
01357
01358
01359 2)*(8*a*fc*(-1 + k)*k*z3 +
01360
01361
01362 pow(a*fc*(-2 + 3*k) + (as1 + as2)*e0c*k*epsc1, 2))), 2));
01363
01364
01365
01366
01367
01368 }
01369
01370
01371 else if (fn != 0. && z3>= 0.0){
01372
01373
01374
01375
01376
01377 in2=1/(96.*pow(a, 3)*pow(fc, 3)*fn*pow(-1 + k, 3)*k)*((as1 + as2)*e0c*
01378
01379
01380 epsc1*(pow(as1 + as2, 3)*pow(e0c, 3)*pow(k, 3)*
01381
01382
01383 pow(epsc1,
01384
01385
01386 3)*(sqrt(pow(epsc1,
01387
01388
01389 2)*(-8*a*fc*(-1 + k)*k*(fn*lp - z3) +
01390
01391
01392 pow(a*fc*(-2 + 3*k) + (as1 + as2)*e0c*k*epsc1,
01393
01394
01395 2))) -
01396
01397
01398 sqrt(pow(epsc1,
01399
01400
01401 2)*(8*a*fc*(-1 + k)*k*z3 +
01402
01403
01404 pow(a*fc*(-2 + 3*k) + (as1 + as2)*e0c*k*epsc1,
01405
01406
01407 2)))) +
01408
01409
01410 pow(a, 3)*pow(fc, 3)*
01411
01412
01413 pow(2 - 3*k,
01414
01415
01416 2)*(12*fn*(-1 + k)*k*lp*
01417
01418
01419 epsc1 + (-2 +
01420
01421
01422 3*k)*(sqrt(pow(epsc1,
01423
01424
01425 2)*(-8*a*fc*(-1 + k)*k*(fn*lp - z3) +
01426
01427
01428 pow(a*fc*(-2 + 3*k) + (as1 + as2)*e0c*k*
01429
01430
01431 epsc1, 2))) -
01432
01433
01434 sqrt(pow(epsc1,
01435
01436
01437 2)*(8*a*fc*(-1 + k)*k*z3 +
01438
01439
01440 pow(a*fc*(-2 + 3*k) + (as1 + as2)*e0c*k*
01441
01442
01443 epsc1, 2))))) +
01444
01445
01446 pow(a, 2)*pow(fc, 2)*
01447
01448
01449 k*(-24*pow(fn, 2)*pow(-1 + k, 2)*k*pow(lp, 2)*
01450
01451
01452 epsc1 + (-2 + 3*k)*(8*(-1 + k)*z3 +
01453
01454
01455 3*(as1 + as2)*e0c*(-2 + 3*k)*
01456
01457
01458 epsc1)*(sqrt(pow(epsc1,
01459
01460
01461 2)*(-8*a*fc*(-1 + k)*k*(fn*lp - z3) +
01462
01463
01464 pow(a*fc*(-2 + 3*k) + (as1 + as2)*e0c*k*
01465
01466
01467 epsc1, 2))) -
01468
01469
01470 sqrt(pow(epsc1,
01471
01472
01473 2)*(8*a*fc*(-1 + k)*k*z3 +
01474
01475
01476 pow(a*fc*(-2 + 3*k) + (as1 + as2)*e0c*k*
01477
01478
01479 epsc1, 2)))) +
01480
01481
01482 8*fn*(-1 + k)*
01483
01484
01485 lp*(3*pow(k, 2)*epsc1*(2*z3 + 3*(as1 + as2)*e0c*epsc1) +
01486
01487
01488 2*sqrt(pow(epsc1,
01489
01490
01491 2)*(-8*a*fc*(-1 + k)*k*(fn*lp - z3) +
01492
01493
01494 pow(a*fc*(-2 + 3*k) + (as1 + as2)*e0c*k*
01495
01496
01497 epsc1, 2))) -
01498
01499
01500 3*k*(2*z3*epsc1 + 2*as1*e0c*pow(epsc1, 2) +
01501
01502
01503 2*as2*e0c*pow(epsc1, 2) +
01504
01505
01506 sqrt(pow(epsc1,
01507
01508
01509 2)*(-8*a*fc*(-1 + k)*k*(fn*lp - z3) +
01510
01511
01512 pow(a*fc*(-2 + 3*k) + (as1 + as2)*e0c*
01513
01514
01515 k*epsc1, 2)))))) +
01516
01517
01518 a*(as1 + as2)*e0c*fc*pow(k, 2)*
01519
01520
01521 epsc1*(3*as1*e0c*
01522
01523
01524 epsc1*(4*fn*(-1 + k)*k*lp*
01525
01526
01527 epsc1 + (-2 +
01528
01529
01530 3*k)*(sqrt(pow(epsc1,
01531
01532
01533 2)*(-8*a*fc*(-1 + k)*k*(fn*lp - z3) +
01534
01535
01536 pow(a*fc*(-2 + 3*k) + (as1 + as2)*e0c*
01537
01538
01539 k*epsc1, 2))) -
01540
01541
01542 sqrt(pow(epsc1,
01543
01544
01545 2)*(8*a*fc*(-1 + k)*k*z3 +
01546
01547
01548 pow(a*fc*(-2 + 3*k) + (as1 + as2)*e0c*
01549
01550
01551 k*epsc1, 2))))) +
01552
01553
01554 3*as2*e0c*
01555
01556
01557 epsc1*(4*fn*(-1 + k)*k*lp*
01558
01559
01560 epsc1 + (-2 +
01561
01562
01563 3*k)*(sqrt(pow(epsc1,
01564
01565
01566 2)*(-8*a*fc*(-1 + k)*k*(fn*lp - z3) +
01567
01568
01569 pow(a*fc*(-2 + 3*k) + (as1 + as2)*e0c*
01570
01571
01572 k*epsc1, 2))) -
01573
01574
01575 sqrt(pow(epsc1,
01576
01577
01578 2)*(8*a*fc*(-1 + k)*k*z3 +
01579
01580
01581 pow(a*fc*(-2 + 3*k) + (as1 + as2)*e0c*
01582
01583
01584 k*epsc1, 2))))) -
01585
01586
01587 8*(-1 +
01588
01589
01590 k)*(fn*lp*
01591
01592
01593 sqrt(pow(epsc1,
01594
01595
01596 2)*(-8*a*fc*(-1 + k)*k*(fn*lp - z3) +
01597
01598
01599 pow(a*fc*(-2 + 3*k) + (as1 + as2)*e0c*k*
01600
01601
01602 epsc1, 2))) +
01603
01604
01605 z3*(-sqrt(pow(epsc1,
01606
01607
01608 2)*(-8*a*fc*(-1 + k)*k*(fn*lp - z3) +
01609
01610
01611 pow(a*fc*(-2 + 3*k) + (as1 + as2)*e0c*
01612
01613
01614 k*epsc1, 2))) +
01615
01616
01617 sqrt(pow(epsc1,
01618
01619
01620 2)*(8*a*fc*(-1 + k)*k*z3 +
01621
01622
01623 pow(a*fc*(-2 + 3*k) + (as1 + as2)*e0c*
01624
01625
01626 k*epsc1, 2))))))));
01627
01628
01629
01630
01631
01632 }
01633
01634
01635
01636
01637
01638 else{
01639
01640
01641
01642
01643
01644 in2=0.;
01645
01646
01647
01648
01649
01650 }
01651
01652
01653 return in2;
01654
01655
01656 }
01657
01658
01659
01660
01661
01662
01663
01664
01665 double normmat::compute_kinh ()
01666
01667
01668 {
01669
01670
01671 double kinh;
01672
01673
01674
01675
01676
01677 kinh = in1 + in2;
01678
01679
01680
01681
01682
01683 return kinh;
01684
01685
01686 }
01687
01688
01689
01690
01691
01692
01693
01694
01695 double normmat::compute_kind (double lp)
01696
01697
01698 {
01699
01700
01701
01702
01703
01704 double kind;
01705
01706
01707
01708
01709
01710
01711
01712
01713 if (fn == 0. && z3>= 0.0 ){
01714
01715
01716
01717
01718
01719
01720
01721
01722 kind=1.0/(16.*pow(a, 2)*an1*pow(fc, 2)*pow(-1 + k, 2))*(as1*e0c*lp*(a*fc*(-2 + 3*k)*epsc1 +
01723
01724
01725 (as1 + as2)*e0c*k*pow(epsc1, 2) - sqrt(pow(epsc1,2)*(8*a*fc*(-1 + k)*k*z3 +
01726
01727
01728 pow(a*fc*(-2 + 3*k) + (as1 + as2)*e0c*k*epsc1,2))))*(an1*(as1 + as2)*e0c*k*pow(epsc1, 2) +
01729
01730
01731 a*fc*(4*an2*(-1 + k) + an1*(-2 + 3*k)*epsc1) - an1*sqrt(pow(epsc1,2)*(8*a*fc*(-1 + k)*k*z3 +
01732
01733
01734 pow(a*fc*(-2 + 3*k) + (as1 + as2)*e0c*k*epsc1, 2)))));
01735
01736
01737
01738
01739
01740
01741
01742
01743 }
01744
01745
01746 else if (fn != 0. && z3>= 0.0){
01747
01748
01749
01750
01751
01752
01753
01754
01755 kind=1/(96.*pow(a, 3)*an1*pow(fc, 3)*fn*pow(-1 + k, 3)*k)*(as1*
01756
01757
01758 e0c*(an1*pow(as1 + as2, 3)*pow(e0c, 3)*pow(k, 3)*
01759
01760
01761 pow(epsc1,
01762
01763
01764 4)*(sqrt(pow(epsc1,
01765
01766
01767 2)*(-8*a*fc*(-1 + k)*k*(fn*lp - z3) +
01768
01769
01770 pow(a*fc*(-2 + 3*k) + (as1 + as2)*e0c*k*epsc1,
01771
01772
01773 2))) -
01774
01775
01776 sqrt(pow(epsc1,
01777
01778
01779 2)*(8*a*fc*(-1 + k)*k*z3 +
01780
01781
01782 pow(a*fc*(-2 + 3*k) + (as1 + as2)*e0c*k*epsc1,
01783
01784
01785 2)))) +
01786
01787
01788 pow(a, 3)*
01789
01790
01791 pow(fc,
01792
01793
01794 3)*(-2 + 3*k)*(2*an2*(-1 + k) +
01795
01796
01797 an1*(-2 + 3*k)*epsc1)*(12*fn*(-1 + k)*k*lp*
01798
01799
01800 epsc1 + (-2 +
01801
01802
01803 3*k)*(sqrt(pow(epsc1,
01804
01805
01806 2)*(-8*a*fc*(-1 + k)*k*(fn*lp - z3) +
01807
01808
01809 pow(a*fc*(-2 + 3*k) + (as1 + as2)*e0c*k*
01810
01811
01812 epsc1, 2))) -
01813
01814
01815 sqrt(pow(epsc1,
01816
01817
01818 2)*(8*a*fc*(-1 + k)*k*z3 +
01819
01820
01821 pow(a*fc*(-2 + 3*k) + (as1 + as2)*e0c*k*
01822
01823
01824 epsc1, 2))))) +
01825
01826
01827 a*(as1 + as2)*e0c*fc*pow(k, 2)*
01828
01829
01830 pow(epsc1,
01831
01832
01833 2)*(2*an2*(as1 + as2)*
01834
01835
01836 e0c*(-1 +
01837
01838
01839 k)*(sqrt(pow(epsc1,
01840
01841
01842 2)*(-8*a*fc*(-1 + k)*k*(fn*lp - z3) +
01843
01844
01845 pow(a*fc*(-2 + 3*k) + (as1 + as2)*e0c*k*
01846
01847
01848 epsc1, 2))) -
01849
01850
01851 sqrt(pow(epsc1,
01852
01853
01854 2)*(8*a*fc*(-1 + k)*k*z3 +
01855
01856
01857 pow(a*fc*(-2 + 3*k) + (as1 + as2)*e0c*k*
01858
01859
01860 epsc1, 2)))) +
01861
01862
01863 an1*(3*as1*e0c*
01864
01865
01866 epsc1*(4*fn*(-1 + k)*k*lp*
01867
01868
01869 epsc1 + (-2 +
01870
01871
01872 3*k)*(sqrt(pow(epsc1,
01873
01874
01875 2)*(-8*a*fc*(-1 + k)*k*(fn*lp - z3) +
01876
01877
01878 pow(a*fc*(-2 + 3*k) + (as1 + as2)*
01879
01880
01881 e0c*k*epsc1, 2))) -
01882
01883
01884 sqrt(pow(epsc1,
01885
01886
01887 2)*(8*a*fc*(-1 + k)*k*z3 +
01888
01889
01890 pow(a*fc*(-2 + 3*k) + (as1 + as2)*
01891
01892
01893 e0c*k*epsc1, 2))))) +
01894
01895
01896 3*as2*e0c*
01897
01898
01899 epsc1*(4*fn*(-1 + k)*k*lp*
01900
01901
01902 epsc1 + (-2 +
01903
01904
01905 3*k)*(sqrt(pow(epsc1,
01906
01907
01908 2)*(-8*a*fc*(-1 + k)*k*(fn*lp - z3) +
01909
01910
01911 pow(a*fc*(-2 + 3*k) + (as1 + as2)*
01912
01913
01914 e0c*k*epsc1, 2))) -
01915
01916
01917 sqrt(pow(epsc1,
01918
01919
01920 2)*(8*a*fc*(-1 + k)*k*z3 +
01921
01922
01923 pow(a*fc*(-2 + 3*k) + (as1 + as2)*
01924
01925
01926 e0c*k*epsc1, 2))))) -
01927
01928
01929 8*(-1 + k)*(fn*lp*
01930
01931
01932 sqrt(pow(epsc1,
01933
01934
01935 2)*(-8*a*fc*(-1 + k)*k*(fn*lp - z3) +
01936
01937
01938 pow(a*fc*(-2 + 3*k) + (as1 + as2)*e0c*
01939
01940
01941 k*epsc1, 2)))
01942
01943
01944 +z3*(-sqrt(pow(epsc1,
01945
01946
01947 2)*(-8*a*fc*(-1 + k)*k*(fn*lp - z3) +
01948
01949
01950 pow(a*fc*(-2 + 3*k) + (as1 + as2)*
01951
01952
01953 e0c*k*epsc1, 2))) +
01954
01955
01956 sqrt(pow(epsc1,
01957
01958
01959 2)*(8*a*fc*(-1 + k)*k*z3 +
01960
01961
01962 pow(a*fc*(-2 + 3*k) + (as1 + as2)*
01963
01964
01965 e0c*k*epsc1, 2))))))) +
01966
01967
01968 pow(a, 2)*pow(fc, 2)*
01969
01970
01971 k*(an1*epsc1*(-24*pow(fn, 2)*pow(-1 + k, 2)*k*pow(lp, 2)*
01972
01973
01974 epsc1 + (-2 + 3*k)*(8*(-1 + k)*z3 +
01975
01976
01977 3*(as1 + as2)*e0c*(-2 + 3*k)*
01978
01979
01980 epsc1)*(sqrt(pow(epsc1,
01981
01982
01983 2)*(-8*a*fc*(-1 + k)*k*(fn*lp - z3) +
01984
01985
01986 pow(a*fc*(-2 + 3*k) + (as1 + as2)*e0c*
01987
01988
01989 k*epsc1, 2))) -
01990
01991
01992 sqrt(pow(epsc1,
01993
01994
01995 2)*(8*a*fc*(-1 + k)*k*z3 +
01996
01997
01998 pow(a*fc*(-2 + 3*k) + (as1 + as2)*e0c*
01999
02000
02001 k*epsc1, 2)))) +
02002
02003
02004 8*fn*(-1 + k)*
02005
02006
02007 lp*(3*pow(k, 2)*
02008
02009
02010 epsc1*(2*z3 + 3*(as1 + as2)*e0c*epsc1) +
02011
02012
02013 2*sqrt(pow(epsc1,
02014
02015
02016 2)*(-8*a*fc*(-1 + k)*k*(fn*lp - z3) +
02017
02018
02019 pow(a*fc*(-2 + 3*k) + (as1 + as2)*e0c*
02020
02021
02022 k*epsc1, 2))) -
02023
02024
02025 3*k*(2*z3*epsc1 + 2*as1*e0c*pow(epsc1, 2) +
02026
02027
02028 2*as2*e0c*pow(epsc1, 2) +
02029
02030
02031 sqrt(pow(epsc1,
02032
02033
02034 2)*(-8*a*fc*(-1 + k)*k*(fn*lp - z3) +
02035
02036
02037 pow(a*fc*(-2 + 3*k) + (as1 + as2)*
02038
02039
02040 e0c*k*epsc1, 2)))))) +
02041
02042
02043 4*an2*(-1 +
02044
02045
02046 k)*(as1*e0c*
02047
02048
02049 epsc1*(6*fn*(-1 + k)*k*lp*
02050
02051
02052 epsc1 + (-2 +
02053
02054
02055 3*k)*(sqrt(pow(epsc1,
02056
02057
02058 2)*(-8*a*fc*(-1 + k)*k*(fn*lp - z3) +
02059
02060
02061 pow(a*fc*(-2 + 3*k) + (as1 + as2)*
02062
02063
02064 e0c*k*epsc1, 2))) -
02065
02066
02067 sqrt(pow(epsc1,
02068
02069
02070 2)*(8*a*fc*(-1 + k)*k*z3 +
02071
02072
02073 pow(a*fc*(-2 + 3*k) + (as1 + as2)*
02074
02075
02076 e0c*k*epsc1, 2))))) +
02077
02078
02079 as2*e0c*
02080
02081
02082 epsc1*(6*fn*(-1 + k)*k*lp*
02083
02084
02085 epsc1 + (-2 +
02086
02087
02088 3*k)*(sqrt(pow(epsc1,
02089
02090
02091 2)*(-8*a*fc*(-1 + k)*k*(fn*lp - z3) +
02092
02093
02094 pow(a*fc*(-2 + 3*k) + (as1 + as2)*
02095
02096
02097 e0c*k*epsc1, 2))) -
02098
02099
02100 sqrt(pow(epsc1,
02101
02102
02103 2)*(8*a*fc*(-1 + k)*k*z3 +
02104
02105
02106 pow(a*fc*(-2 + 3*k) + (as1 + as2)*
02107
02108
02109 e0c*k*epsc1, 2))))) -
02110
02111
02112 4*(-1 + k)*(fn*lp*
02113
02114
02115 sqrt(pow(epsc1,
02116
02117
02118 2)*(-8*a*fc*(-1 + k)*k*(fn*lp - z3) +
02119
02120
02121 pow(a*fc*(-2 + 3*k) + (as1 + as2)*e0c*
02122
02123
02124 k*epsc1, 2)))
02125
02126
02127 +z3*(-sqrt(pow(epsc1,
02128
02129
02130 2)*(-8*a*fc*(-1 + k)*k*(fn*lp - z3) +
02131
02132
02133 pow(a*fc*(-2 + 3*k) + (as1 + as2)*
02134
02135
02136 e0c*k*epsc1, 2))) +
02137
02138
02139 sqrt(pow(epsc1,
02140
02141
02142 2)*(8*a*fc*(-1 + k)*k*z3 +
02143
02144
02145 pow(a*fc*(-2 + 3*k) + (as1 + as2)*
02146
02147
02148 e0c*k*epsc1, 2)))))))));
02149
02150
02151
02152
02153
02154
02155
02156
02157 }
02158
02159
02160
02161
02162
02163 else{
02164
02165
02166
02167
02168
02169 kind=1.0;
02170
02171
02172
02173
02174
02175 }
02176
02177
02178 return kind;
02179
02180
02181
02182
02183
02184 }
02185
02186
02187
02188
02189
02190
02191
02192
02193 double normmat::compute_kin ()
02194
02195
02196 {
02197
02198
02199 double kin;
02200
02201
02202
02203
02204
02205 kin = kinh/kind;
02206
02207
02208
02209
02210
02211 return kin;
02212
02213
02214 }
02215
02216
02217
02218
02219
02220
02221
02222
02223
02224
02225
02226
02227
02228
02229 double normmat::compute_epschr1 ()
02230
02231
02232 {
02233
02234
02235 double epsc,disk,pom,epschr1;
02236
02237
02238
02239
02240
02241 disk =pow(6*b*fc*pow(h, 2)*epsc1 - 9*b*fc*pow(h, 2)*k*epsc1 +
02242
02243
02244 6*as2*ch*e0c*k*pow(epsc1, 2) + 6*as1*d*e0c*k*pow(epsc1, 2) -
02245
02246
02247 6*as1*e0c*h*k*pow(epsc1, 2) - 6*as2*e0c*h*k*pow(epsc1, 2) -
02248
02249
02250 8*b*fc*pow(h, 2)*epsn + 8*b*fc*pow(h, 2)*k*epsn, 2) -
02251
02252
02253 4*b*fc*pow(h,
02254
02255
02256 2)*(-4 + 4*k)*(6*h*k*n0*pow(epsc1, 2) + 6*b*fc*pow(h, 2)*epsc1*epsn -
02257
02258
02259 9*b*fc*pow(h, 2)*k*epsc1*epsn + 6*as2*ch*e0c*k*pow(epsc1, 2)*epsn +
02260
02261
02262 6*as1*d*e0c*k*pow(epsc1, 2)*epsn - 6*as1*e0c*h*k*pow(epsc1, 2)*epsn -
02263
02264
02265 6*as2*e0c*h*k*pow(epsc1, 2)*epsn - 4*b*fc*pow(h, 2)*pow(epsn, 2) +
02266
02267
02268 4*b*fc*pow(h, 2)*k*pow(epsn, 2));
02269
02270
02271
02272
02273
02274 if (disk >= 0.0 ){
02275
02276
02277
02278
02279
02280 epsc=1/(2.*b*fc*pow(h, 2)*(-4 + 4*k))*(-6*b*fc*pow(h, 2)*epsc1 +
02281
02282
02283 9*b*fc*pow(h, 2)*k*epsc1 - 6*as2*ch*e0c*k*pow(epsc1, 2) -
02284
02285
02286 6*as1*d*e0c*k*pow(epsc1, 2) + 6*as1*e0c*h*k*pow(epsc1, 2) +
02287
02288
02289 6*as2*e0c*h*k*pow(epsc1, 2) + 8*b*fc*pow(h, 2)*epsn -
02290
02291
02292 8*b*fc*pow(h, 2)*k*epsn -
02293
02294
02295 sqrt(pow(6*b*fc*pow(h, 2)*epsc1 - 9*b*fc*pow(h, 2)*k*epsc1 +
02296
02297
02298 6*as2*ch*e0c*k*pow(epsc1, 2) +
02299
02300
02301 6*as1*d*e0c*k*pow(epsc1, 2) - 6*as1*e0c*h*k*pow(epsc1, 2) -
02302
02303
02304 6*as2*e0c*h*k*pow(epsc1, 2) - 8*b*fc*pow(h, 2)*epsn +
02305
02306
02307 8*b*fc*pow(h, 2)*k*epsn, 2) -
02308
02309
02310 4*b*fc*pow(h,
02311
02312
02313 2)*(-4 + 4*k)*(6*h*k*n0*pow(epsc1, 2) +
02314
02315
02316 6*b*fc*pow(h, 2)*epsc1*epsn -
02317
02318
02319 9*b*fc*pow(h, 2)*k*epsc1*epsn +
02320
02321
02322 6*as2*ch*e0c*k*pow(epsc1, 2)*epsn +
02323
02324
02325 6*as1*d*e0c*k*pow(epsc1, 2)*epsn -
02326
02327
02328 6*as1*e0c*h*k*pow(epsc1, 2)*epsn -
02329
02330
02331 6*as2*e0c*h*k*pow(epsc1, 2)*epsn -
02332
02333
02334 4*b*fc*pow(h, 2)*pow(epsn, 2) +
02335
02336
02337 4*b*fc*pow(h, 2)*k*pow(epsn, 2))));
02338
02339
02340
02341
02342
02343 }
02344
02345
02346 else{
02347
02348
02349 epsc=-1.0;
02350
02351
02352 }
02353
02354
02355 pom =(-(fy/e0c) - epsn)-((-ch + h)*epsc)/h;
02356
02357
02358
02359
02360
02361 if (pom >= 0.0 ){
02362
02363
02364 epschr1=-1.0;
02365
02366
02367 }
02368
02369
02370 else{
02371
02372
02373 epschr1=epsc;
02374
02375
02376 }
02377
02378
02379 return epschr1;
02380
02381
02382 }
02383
02384
02385
02386
02387
02388
02389
02390
02391 double normmat::compute_mhr1 ()
02392
02393
02394 {
02395
02396
02397 double mhr1;
02398
02399
02400
02401
02402
02403 if(epschr1 < 0 && epschr1 != -1)
02404
02405
02406 {
02407
02408
02409 mhr1 = 0.08333333333333333*(6*as1*
02410
02411
02412 e0c*(-2*cd + h)*(epsn +
02413
02414
02415 1/(6.*(as2*ch + as1*d)*e0c*k*pow(epsc1, 2))*(6*as2*ch*e0c*k*
02416
02417
02418 epschr1*pow(epsc1, 2) +
02419
02420
02421 3*d*k*pow(epsc1,
02422
02423
02424 2)*(n0 + as1*e0c*(epschr1 - epsn) -
02425
02426
02427 as2*e0c*(epschr1 + epsn)) +
02428
02429
02430 sqrt(3.)*
02431
02432
02433 sqrt(k*pow(epsc1,
02434
02435
02436 2)*(3*k*pow(epsc1, 2)*
02437
02438
02439 pow(-2*as2*ch*e0c*epschr1 +
02440
02441
02442 d*(-n0 +
02443
02444
02445 e0c*(as1*(-epschr1 + epsn) +
02446
02447
02448 as2*(epschr1 + epsn))), 2) -
02449
02450
02451 2*(as2*ch + as1*d)*
02452
02453
02454 e0c*(b*pow(d, 2)*fc*
02455
02456
02457 pow(epschr1 + epsn,
02458
02459
02460 2)*(4*(-1 + k)*epschr1 + (6 - 9*k)*
02461
02462
02463 epsc1 + 4*(-1 + k)*epsn) +
02464
02465
02466 6*k*epschr1*
02467
02468
02469 pow(epsc1,
02470
02471
02472 2)*(as2*ch*e0c*epschr1 +
02473
02474
02475 d*(n0 -
02476
02477
02478 e0c*(as1*epsn +
02479
02480
02481 as2*(epschr1 + epsn))))))))) -
02482
02483
02484 6*as2*e0c*(-2*ch + h)*(epschr1 - (ch*epschr1)/d +
02485
02486
02487 epsn + (ch*(6*as2*ch*e0c*k*epschr1*pow(epsc1, 2) +
02488
02489
02490 3*d*k*pow(epsc1,
02491
02492
02493 2)*(n0 + as1*e0c*(epschr1 - epsn) -
02494
02495
02496 as2*e0c*(epschr1 + epsn)) +
02497
02498
02499 sqrt(3.)*
02500
02501
02502 sqrt(k*
02503
02504
02505 pow(epsc1,
02506
02507
02508 2)*(3*k*pow(epsc1, 2)*
02509
02510
02511 pow(-2*as2*ch*e0c*epschr1 +
02512
02513
02514 d*(-n0 +
02515
02516
02517 e0c*(as1*(-epschr1 + epsn) +
02518
02519
02520 as2*(epschr1 + epsn))), 2) -
02521
02522
02523 2*(as2*ch + as1*d)*
02524
02525
02526 e0c*(b*pow(d, 2)*fc*
02527
02528
02529 pow(epschr1 + epsn,
02530
02531
02532 2)*(4*(-1 + k)*epschr1 + (6 - 9*k)*
02533
02534
02535 epsc1 + 4*(-1 + k)*epsn) +
02536
02537
02538 6*k*epschr1*
02539
02540
02541 pow(epsc1,
02542
02543
02544 2)*(as2*ch*e0c*epschr1 +
02545
02546
02547 d*(n0 - e0c*(as1*epsn +
02548
02549
02550 as2*(epschr1 + epsn)))))))))/(6.*
02551
02552
02553 d*(as2*ch + as1*d)*e0c*k*pow(epsc1, 2))) - (b*d*fc*
02554
02555
02556 pow(epschr1 + epsn,
02557
02558
02559 2)*(2*d*(epschr1 +
02560
02561
02562 epsn)*((-1 + k)*epschr1 + (2 - 3*k)*epsc1 + (-1 + k)*
02563
02564
02565 epsn) -
02566
02567
02568 h*(4*(-1 + k)*epschr1 + (6 - 9*k)*epsc1 +
02569
02570
02571 4*(-1 + k)*
02572
02573
02574 epsn)*(epschr1 - (6*as2*ch*e0c*k*epschr1*
02575
02576
02577 pow(epsc1, 2) +
02578
02579
02580 3*d*k*pow(epsc1,
02581
02582
02583 2)*(n0 + as1*e0c*(epschr1 - epsn) -
02584
02585
02586 as2*e0c*(epschr1 + epsn)) +
02587
02588
02589 sqrt(3.)*
02590
02591
02592 sqrt(k*
02593
02594
02595 pow(epsc1,
02596
02597
02598 2)*(3*k*pow(epsc1, 2)*
02599
02600
02601 pow(-2*as2*ch*e0c*epschr1 +
02602
02603
02604 d*(-n0 + e0c*(as1*(-epschr1 + epsn) +
02605
02606
02607 as2*(epschr1 + epsn))), 2) -
02608
02609
02610 2*(as2*ch + as1*d)*
02611
02612
02613 e0c*(b*pow(d, 2)*fc*
02614
02615
02616 pow(epschr1 + epsn,
02617
02618
02619 2)*(4*(-1 + k)*epschr1 + (6 - 9*k)*
02620
02621
02622 epsc1 + 4*(-1 + k)*epsn) +
02623
02624
02625 6*k*epschr1*
02626
02627
02628 pow(epsc1,
02629
02630
02631 2)*(as2*ch*e0c*epschr1 +
02632
02633
02634 d*(n0 - e0c*(as1*epsn +
02635
02636
02637 as2*(epschr1 + epsn))))))))/(6.*(as2*
02638
02639
02640 ch + as1*d)*e0c*k*pow(epsc1, 2)))))/(k*
02641
02642
02643 pow(epsc1, 2)*
02644
02645
02646 pow(epschr1 -
02647
02648
02649 1/(6.*(as2*ch + as1*d)*e0c*k*pow(epsc1, 2))*(6*as2*ch*e0c*k*
02650
02651
02652 epschr1*pow(epsc1, 2) +
02653
02654
02655 3*d*k*pow(epsc1,
02656
02657
02658 2)*(n0 + as1*e0c*(epschr1 - epsn) -
02659
02660
02661 as2*e0c*(epschr1 + epsn)) +
02662
02663
02664 sqrt(3.)*
02665
02666
02667 sqrt(k*
02668
02669
02670 pow(epsc1,
02671
02672
02673 2)*(3*k*pow(epsc1, 2)*
02674
02675
02676 pow(-2*as2*ch*e0c*epschr1 +
02677
02678
02679 d*(-n0 +
02680
02681
02682 e0c*(as1*(-epschr1 + epsn) +
02683
02684
02685 as2*(epschr1 + epsn))), 2) -
02686
02687
02688 2*(as2*ch + as1*d)*
02689
02690
02691 e0c*(b*pow(d, 2)*fc*
02692
02693
02694 pow(epschr1 + epsn,
02695
02696
02697 2)*(4*(-1 + k)*epschr1 + (6 - 9*k)*
02698
02699
02700 epsc1 + 4*(-1 + k)*epsn) +
02701
02702
02703 6*k*epschr1*
02704
02705
02706 pow(epsc1,
02707
02708
02709 2)*(as2*ch*e0c*epschr1 +
02710
02711
02712 d*(n0 - e0c*(as1*epsn +
02713
02714
02715 as2*(epschr1 + epsn)))))))), 2))) + e0c*(-(as1*(-cd + h/2.)) + as2*(-ch + h/2.))*epsn;
02716
02717
02718
02719
02720
02721 }
02722
02723
02724 else{
02725
02726
02727 mhr1=1000000000.0;
02728
02729
02730 }
02731
02732
02733 return mhr1;
02734
02735
02736 }
02737
02738
02739
02740
02741
02742
02743
02744
02745
02746
02747
02748
02749
02750
02751 double normmat::compute_epschr2 ()
02752
02753
02754 {
02755
02756
02757 double disk1,epsct,disk2,epschr2;
02758
02759
02760
02761
02762
02763 disk1 =e0c*(3*e0c*
02764
02765
02766 pow(k*pow(epsc1,
02767
02768
02769 2)*(-2*as2*ch*fy - as1*d*fy + as2*d*fy + d*n0 +
02770
02771
02772 2*as2*(ch - d)*e0c*epsn) +
02773
02774
02775 b*pow(d, 2)*
02776
02777
02778 fc*(-2*(-1 + k)*pow(epsc1, 2) + (2 - 3*k)*epsc1*epsn +
02779
02780
02781 2*(-1 + k)*pow(epsn, 2)),
02782
02783
02784 2) - (2*as2*(-ch + d)*e0c*k*pow(epsc1, 2) -
02785
02786
02787 b*pow(d, 2)*fc*((-2 + k)*epsc1 + 4*(-1 + k)*epsn))*(-6*as2*k*
02788
02789
02790 pow(epsc1, 2)*(fy - e0c*epsn)*(ch*fy + (-ch + d)*e0c*epsn) +
02791
02792
02793 d*(6*fy*k*n0*pow(epsc1, 2) -
02794
02795
02796 6*as1*fy*k*pow(epsc1, 2)*(fy - e0c*epsn) +
02797
02798
02799 e0c*(-6*k*n0*pow(epsc1, 2)*epsn +
02800
02801
02802 b*d*fc*(-4*(-1 + k)*pow(epsc1, 3) +
02803
02804
02805 3*(-2 + 3*k)*epsc1*pow(epsn, 2) -
02806
02807
02808 4*(-1 + k)*pow(epsn, 3))))));
02809
02810
02811
02812
02813
02814 if (mhr1 == 1000000000.0 || disk1 < 0.0){
02815
02816
02817
02818
02819
02820 epsct=-1.0;
02821
02822
02823
02824
02825
02826 }
02827
02828
02829
02830
02831
02832 else {
02833
02834
02835
02836
02837
02838 epsct=(-3*e0c*k*pow(epsc1,2) * (-2*as2*ch*fy - as1*d*fy + as2*d*fy + d*n0 + 2*as2*(ch - d)*e0c*epsn) +
02839
02840
02841 3*b*pow(d, 2)*e0c*fc*(2*(-1 + k)*pow(epsc1, 2) + (-2 + 3*k)*epsc1*epsn - 2*(-1 + k)*pow(epsn, 2)) +
02842
02843
02844 sqrt(3.)*sqrt(e0c*(3*e0c*pow(k*pow(epsc1,2)*(-2*as2*ch*fy - as1*d*fy + as2*d*fy + d*n0 +
02845
02846
02847 2*as2*(ch - d)*e0c*epsn) +
02848
02849
02850 b*pow(d, 2)*
02851
02852
02853 fc*(-2*(-1 + k)*pow(epsc1, 2) + (2 - 3*k)*epsc1*
02854
02855
02856 epsn + 2*(-1 + k)*pow(epsn, 2)),
02857
02858
02859 2) - (2*as2*(-ch + d)*e0c*k*pow(epsc1, 2) -
02860
02861
02862 b*pow(d, 2)*
02863
02864
02865 fc*((-2 + k)*epsc1 + 4*(-1 + k)*epsn))*(-6*as2*k*
02866
02867
02868 pow(epsc1,
02869
02870
02871 2)*(fy - e0c*epsn)*(ch*fy + (-ch + d)*e0c*epsn) +
02872
02873
02874 d*(6*fy*k*n0*pow(epsc1, 2) -
02875
02876
02877 6*as1*fy*k*pow(epsc1, 2)*(fy - e0c*epsn) +
02878
02879
02880 e0c*(-6*k*n0*pow(epsc1, 2)*epsn +
02881
02882
02883 b*d*fc*(-4*(-1 + k)*pow(epsc1, 3) +
02884
02885
02886 3*(-2 + 3*k)*epsc1*pow(epsn, 2) -
02887
02888
02889 4*(-1 + k)*pow(epsn, 3))))))))/
02890
02891
02892 (3.*e0c*(2*as2*(ch - d)*e0c*k*pow(epsc1, 2) + b*pow(d, 2)*fc*((-2 + k)*epsc1 + 4*(-1 + k)*epsn)));
02893
02894
02895
02896
02897
02898 }
02899
02900
02901
02902
02903
02904 disk2 =e0c*(3*e0c*
02905
02906
02907 pow(as2*k*
02908
02909
02910 pow(epsc1, 2)*(-2*ch*fy + d*fy + 2*ch*e0c*epsn - 2*d*e0c*epsn) +
02911
02912
02913 d*(-(as1*fy*k*pow(epsc1, 2)) +
02914
02915
02916 2*b*d*fc*(pow(epsct, 2) + (epsc1 - epsn)*epsn) +
02917
02918
02919 k*(n0*pow(epsc1, 2) +
02920
02921
02922 b*d*fc*(-2*pow(epsct, 2) - 3*epsc1*epsn +
02923
02924
02925 2*pow(epsn, 2)))),
02926
02927
02928 2) - (2*as2*(-ch + d)*e0c*k*pow(epsc1, 2) +
02929
02930
02931 b*pow(d, 2)*
02932
02933
02934 fc*((-2 + 3*k)*epsc1 - 4*(-1 + k)*(epsct + epsn)))*(-6*as2*k*
02935
02936
02937 pow(epsc1, 2)*(fy - e0c*epsn)*(ch*fy + (-ch + d)*e0c*epsn) +
02938
02939
02940 d*(6*fy*k*n0*pow(epsc1, 2) -
02941
02942
02943 6*as1*fy*k*pow(epsc1, 2)*(fy - e0c*epsn) +
02944
02945
02946 e0c*(-6*k*n0*pow(epsc1, 2)*epsn +
02947
02948
02949 b*d*fc*(-4*(-1 + k)*pow(epsct, 3) +
02950
02951
02952 3*(-2 + 3*k)*epsc1*pow(epsn, 2) -
02953
02954
02955 4*(-1 + k)*pow(epsn, 3))))));
02956
02957
02958
02959
02960
02961 if (mhr1 == 1000000000.0 || disk2 < 0.0 || epsct == -1.0){
02962
02963
02964
02965
02966
02967 epschr2=-1.0;
02968
02969
02970 }
02971
02972
02973 else{
02974
02975
02976
02977
02978
02979 epschr2=(-3*as2*e0c*k*
02980
02981
02982 pow(epsc1, 2)*(-2*ch*fy + d*fy + 2*ch*e0c*epsn - 2*d*e0c*epsn) +
02983
02984
02985 3*d*e0c*(k*(as1*fy - n0)*pow(epsc1, 2) - 2*b*d*fc*pow(epsct, 2) +
02986
02987
02988 2*b*d*fc*k*pow(epsct, 2) + b*d*fc*(-2 + 3*k)*epsc1*epsn -
02989
02990
02991 2*b*d*fc*(-1 + k)*pow(epsn, 2)) +
02992
02993
02994 sqrt(3.)*sqrt(e0c*(3*e0c*
02995
02996
02997 pow(as2*k*
02998
02999
03000 pow(epsc1,
03001
03002
03003 2)*(-2*ch*fy + d*fy + 2*ch*e0c*epsn -
03004
03005
03006 2*d*e0c*epsn) +
03007
03008
03009 d*(-as1*fy*k*pow(epsc1, 2) +
03010
03011
03012 2*b*d*fc*(pow(epsct, 2) + (epsc1 - epsn)*epsn) +
03013
03014
03015 k*(n0*pow(epsc1, 2) +
03016
03017
03018 b*d*fc*(-2*pow(epsct, 2) - 3*epsc1*epsn +
03019
03020
03021 2*pow(epsn, 2)))),
03022
03023
03024 2) - (2*as2*(-ch + d)*e0c*k*pow(epsc1, 2) +
03025
03026
03027 b*pow(d, 2)*
03028
03029
03030 fc*((-2 + 3*k)*epsc1 -
03031
03032
03033 4*(-1 + k)*(epsct + epsn)))*(-6*as2*k*
03034
03035
03036 pow(epsc1,
03037
03038
03039 2)*(fy - e0c*epsn)*(ch*fy + (-ch + d)*e0c*epsn) +
03040
03041
03042 d*(6*fy*k*n0*pow(epsc1, 2) -
03043
03044
03045 6*as1*fy*k*pow(epsc1, 2)*(fy - e0c*epsn) +
03046
03047
03048 e0c*(-6*k*n0*pow(epsc1, 2)*epsn +
03049
03050
03051 b*d*fc*(-4*(-1 + k)*pow(epsct, 3) +
03052
03053
03054 3*(-2 + 3*k)*epsc1*pow(epsn, 2) -
03055
03056
03057 4*(-1 + k)*pow(epsn, 3))))))))/(3.*
03058
03059
03060 e0c*(2*as2*(ch - d)*e0c*k*pow(epsc1, 2) +
03061
03062
03063 b*pow(d, 2)*fc*((2 - 3*k)*epsc1 + 4*(-1 + k)*(epsct + epsn))));
03064
03065
03066 }
03067
03068
03069 return epschr2;
03070
03071
03072 }
03073
03074
03075
03076
03077
03078
03079
03080
03081
03082
03083
03084 double normmat::compute_mhr2 ()
03085
03086
03087 {
03088
03089
03090 double mhr2;
03091
03092
03093
03094
03095
03096 if (epschr2 < 0.0 && epschr2!=-1.0){
03097
03098
03099
03100
03101
03102 mhr2=0.08333333333333333*(6*as1*
03103
03104
03105 e0c*(-2*cd + h)*(epsn +
03106
03107
03108 1/(6.*(as2*ch + as1*d)*e0c*k*pow(epsc1, 2))*(6*as2*ch*e0c*k*
03109
03110
03111 epschr2*pow(epsc1, 2) +
03112
03113
03114 3*d*k*pow(epsc1,
03115
03116
03117 2)*(n0 + as1*e0c*(epschr2 - epsn) -
03118
03119
03120 as2*e0c*(epschr2 + epsn)) +
03121
03122
03123 sqrt(3.)*
03124
03125
03126 sqrt(k*pow(epsc1,
03127
03128
03129 2)*(3*k*pow(epsc1, 2)*
03130
03131
03132 pow(-2*as2*ch*e0c*epschr2 +
03133
03134
03135 d*(-n0 +
03136
03137
03138 e0c*(as1*(-epschr2 + epsn) +
03139
03140
03141 as2*(epschr2 + epsn))), 2) -
03142
03143
03144 2*(as2*ch + as1*d)*
03145
03146
03147 e0c*(b*pow(d, 2)*fc*
03148
03149
03150 pow(epschr2 + epsn,
03151
03152
03153 2)*(4*(-1 + k)*epschr2 + (6 - 9*k)*
03154
03155
03156 epsc1 + 4*(-1 + k)*epsn) +
03157
03158
03159 6*k*epschr2*
03160
03161
03162 pow(epsc1,
03163
03164
03165 2)*(as2*ch*e0c*epschr2 +
03166
03167
03168 d*(n0 -
03169
03170
03171 e0c*(as1*epsn +
03172
03173
03174 as2*(epschr2 + epsn))))))))) -
03175
03176
03177 6*as2*e0c*(-2*ch + h)*(epschr2 - (ch*epschr2)/d +
03178
03179
03180 epsn + (ch*(6*as2*ch*e0c*k*epschr2*pow(epsc1, 2) +
03181
03182
03183 3*d*k*pow(epsc1,
03184
03185
03186 2)*(n0 + as1*e0c*(epschr2 - epsn) -
03187
03188
03189 as2*e0c*(epschr2 + epsn)) +
03190
03191
03192 sqrt(3.)*
03193
03194
03195 sqrt(k*
03196
03197
03198 pow(epsc1,
03199
03200
03201 2)*(3*k*pow(epsc1, 2)*
03202
03203
03204 pow(-2*as2*ch*e0c*epschr2 +
03205
03206
03207 d*(-n0 +
03208
03209
03210 e0c*(as1*(-epschr2 + epsn) +
03211
03212
03213 as2*(epschr2 + epsn))), 2) -
03214
03215
03216 2*(as2*ch + as1*d)*
03217
03218
03219 e0c*(b*pow(d, 2)*fc*
03220
03221
03222 pow(epschr2 + epsn,
03223
03224
03225 2)*(4*(-1 + k)*epschr2 + (6 - 9*k)*
03226
03227
03228 epsc1 + 4*(-1 + k)*epsn) +
03229
03230
03231 6*k*epschr2*
03232
03233
03234 pow(epsc1,
03235
03236
03237 2)*(as2*ch*e0c*epschr2 +
03238
03239
03240 d*(n0 - e0c*(as1*epsn +
03241
03242
03243 as2*(epschr2 + epsn)))))))))/(6.*
03244
03245
03246 d*(as2*ch + as1*d)*e0c*k*pow(epsc1, 2))) - (b*d*fc*
03247
03248
03249 pow(epschr2 + epsn,
03250
03251
03252 2)*(2*d*(epschr2 +
03253
03254
03255 epsn)*((-1 + k)*epschr2 + (2 - 3*k)*epsc1 + (-1 + k)*
03256
03257
03258 epsn) -
03259
03260
03261 h*(4*(-1 + k)*epschr2 + (6 - 9*k)*epsc1 +
03262
03263
03264 4*(-1 + k)*
03265
03266
03267 epsn)*(epschr2 - (6*as2*ch*e0c*k*epschr2*
03268
03269
03270 pow(epsc1, 2) +
03271
03272
03273 3*d*k*pow(epsc1,
03274
03275
03276 2)*(n0 + as1*e0c*(epschr2 - epsn) -
03277
03278
03279 as2*e0c*(epschr2 + epsn)) +
03280
03281
03282 sqrt(3.)*
03283
03284
03285 sqrt(k*
03286
03287
03288 pow(epsc1,
03289
03290
03291 2)*(3*k*pow(epsc1, 2)*
03292
03293
03294 pow(-2*as2*ch*e0c*epschr2 +
03295
03296
03297 d*(-n0 + e0c*(as1*(-epschr2 + epsn) +
03298
03299
03300 as2*(epschr2 + epsn))), 2) -
03301
03302
03303 2*(as2*ch + as1*d)*
03304
03305
03306 e0c*(b*pow(d, 2)*fc*
03307
03308
03309 pow(epschr2 + epsn,
03310
03311
03312 2)*(4*(-1 + k)*epschr2 + (6 - 9*k)*
03313
03314
03315 epsc1 + 4*(-1 + k)*epsn) +
03316
03317
03318 6*k*epschr2*
03319
03320
03321 pow(epsc1,
03322
03323
03324 2)*(as2*ch*e0c*epschr2 +
03325
03326
03327 d*(n0 - e0c*(as1*epsn +
03328
03329
03330 as2*(epschr2 + epsn))))))))/(6.*(as2*
03331
03332
03333 ch + as1*d)*e0c*k*pow(epsc1, 2)))))/(k*
03334
03335
03336 pow(epsc1, 2)*
03337
03338
03339 pow(epschr2 -
03340
03341
03342 1/(6.*(as2*ch + as1*d)*e0c*k*pow(epsc1, 2))*(6*as2*ch*e0c*k*
03343
03344
03345 epschr2*pow(epsc1, 2) +
03346
03347
03348 3*d*k*pow(epsc1,
03349
03350
03351 2)*(n0 + as1*e0c*(epschr2 - epsn) -
03352
03353
03354 as2*e0c*(epschr2 + epsn)) +
03355
03356
03357 sqrt(3.)*
03358
03359
03360 sqrt(k*
03361
03362
03363 pow(epsc1,
03364
03365
03366 2)*(3*k*pow(epsc1, 2)*
03367
03368
03369 pow(-2*as2*ch*e0c*epschr2 +
03370
03371
03372 d*(-n0 +
03373
03374
03375 e0c*(as1*(-epschr2 + epsn) +
03376
03377
03378 as2*(epschr2 + epsn))), 2) -
03379
03380
03381 2*(as2*ch + as1*d)*
03382
03383
03384 e0c*(b*pow(d, 2)*fc*
03385
03386
03387 pow(epschr2 + epsn,
03388
03389
03390 2)*(4*(-1 + k)*epschr2 + (6 - 9*k)*
03391
03392
03393 epsc1 + 4*(-1 + k)*epsn) +
03394
03395
03396 6*k*epschr2*
03397
03398
03399 pow(epsc1,
03400
03401
03402 2)*(as2*ch*e0c*epschr2 +
03403
03404
03405 d*(n0 - e0c*(as1*epsn +
03406
03407
03408 as2*(epschr2 + epsn)))))))), 2))) + e0c*(-(as1*(-cd + h/2.)) + as2*(-ch + h/2.))*epsn;
03409
03410
03411
03412
03413
03414 }
03415
03416
03417
03418
03419
03420 else{
03421
03422
03423
03424
03425
03426 mhr2=1000000000.0;
03427
03428
03429
03430
03431
03432 }
03433
03434
03435 return mhr2;
03436
03437
03438 }
03439
03440
03441
03442
03443
03444
03445
03446
03447
03448
03449
03450
03451
03452
03453
03454
03455
03456 double normmat::compute_epschr3 ()
03457
03458
03459 {
03460
03461
03462 double ac1,ac2,ac3,epschr3;
03463
03464
03465
03466
03467
03468 ac1 =((12*sqrt(3.)*e0c*((-8*b*(as2*ch + as1*d)*e0c*fc*(epsc1 - epsn)*
03469
03470
03471 pow(epsc1 + 2*epsn, 2) +
03472
03473
03474 k*(12*pow(n0, 2)*pow(epsc1, 2) -
03475
03476
03477 12*(as1 + as2)*e0c*n0*
03478
03479
03480 pow(epsc1, 2)*(epsc1 + 2*epsn) +
03481
03482
03483 e0c*(3*pow(as2, 2)*e0c*pow(epsc1, 2) +
03484
03485
03486 2*as2*(3*as1*e0c*pow(epsc1, 2) +
03487
03488
03489 b*ch*fc*(7*epsc1 - 4*epsn)) +
03490
03491
03492 as1*(3*as1*e0c*pow(epsc1, 2) +
03493
03494
03495 2*b*d*fc*(7*epsc1 - 4*epsn)))*
03496
03497
03498 pow(epsc1 + 2*epsn, 2)))*(pow(as2, 2)*e0c*k*
03499
03500
03501 pow(epsc1, 2) +
03502
03503
03504 2*as2*(as1*e0c*k*pow(epsc1, 2) +
03505
03506
03507 b*ch*fc*(k*epsc1 + 4*epsn - 4*k*epsn)) +
03508
03509
03510 as1*(as1*e0c*k*pow(epsc1, 2) +
03511
03512
03513 2*b*d*fc*(k*epsc1 + 4*epsn - 4*k*epsn))) -
03514
03515
03516 3*e0c*pow(pow(as2, 2)*e0c*k*pow(epsc1, 2)*(epsc1 + 2*epsn) +
03517
03518
03519 as1*(2*b*d*
03520
03521
03522 fc*(epsc1 + 2*epsn)*((-1 + 2*k)*epsc1 -
03523
03524
03525 2*(-1 + k)*epsn) +
03526
03527
03528 k*pow(epsc1,
03529
03530
03531 2)*(-2*n0 + as1*e0c*(epsc1 + 2*epsn))) +
03532
03533
03534 2*as2*(b*ch*
03535
03536
03537 fc*(epsc1 + 2*epsn)*((-1 + 2*k)*epsc1 -
03538
03539
03540 2*(-1 + k)*epsn) +
03541
03542
03543 k*pow(epsc1, 2)*(-n0 + as1*e0c*(epsc1 + 2*epsn))),
03544
03545
03546 2))*sqrt(k*
03547
03548
03549 pow(epsc1,
03550
03551
03552 2)*(3*k*pow(epsc1, 2)*
03553
03554
03555 pow(as2*ch*e0c*
03556
03557
03558 epsc1 + (d*(2*n0 +
03559
03560
03561 e0c*(as1*(epsc1 - 2*epsn) -
03562
03563
03564 as2*(epsc1 + 2*epsn))))/2., 2) -
03565
03566
03567 2*(as2*ch + as1*d)*
03568
03569
03570 e0c*(-(b*pow(d, 2)*fc*
03571
03572
03573 pow(epsc1 + 2*epsn,
03574
03575
03576 2)*((-4 + 7*k)*epsc1 - 4*(-1 + k)*epsn))/
03577
03578
03579 4. + 3*k*
03580
03581
03582 pow(epsc1,
03583
03584
03585 3)*((as2*ch*e0c*epsc1)/2. +
03586
03587
03588 d*(n0 - (e0c*(as2*epsc1 + 2*as1*epsn +
03589
03590
03591 2*as2*epsn))/2.))))))/((as2*ch +
03592
03593
03594 as1*d)*k*
03595
03596
03597 pow(-8*b*(as2*ch + as1*d)*e0c*fc*(epsc1 - epsn)*
03598
03599
03600 pow(epsc1 + 2*epsn, 2) +
03601
03602
03603 k*(12*pow(n0, 2)*pow(epsc1, 2) -
03604
03605
03606 12*(as1 + as2)*e0c*n0*pow(epsc1, 2)*(epsc1 + 2*epsn) +
03607
03608
03609 e0c*(3*pow(as2, 2)*e0c*pow(epsc1, 2) +
03610
03611
03612 2*as2*(3*as1*e0c*pow(epsc1, 2) +
03613
03614
03615 b*ch*fc*(7*epsc1 - 4*epsn)) +
03616
03617
03618 as1*(3*as1*e0c*pow(epsc1, 2) +
03619
03620
03621 2*b*d*fc*(7*epsc1 - 4*epsn)))*
03622
03623
03624 pow(epsc1 + 2*epsn, 2)), 2)) -
03625
03626
03627 4*epsc1*((6*(-ch + d)*e0c)/
03628
03629
03630 ch + (3*e0c*(2*as2*ch*k*pow(epsc1, 2) + (as1 - as2)*d*k*
03631
03632
03633 pow(epsc1,
03634
03635
03636 2) + (2*
03637
03638
03639 sqrt(3.)*(pow(as2, 2)*e0c*k*
03640
03641
03642 pow(epsc1, 2)*(epsc1 + 2*epsn) +
03643
03644
03645 as1*(2*b*d*
03646
03647
03648 fc*(epsc1 +
03649
03650
03651 2*epsn)*((-1 + 2*k)*epsc1 -
03652
03653
03654 2*(-1 + k)*epsn) +
03655
03656
03657 k*pow(epsc1,
03658
03659
03660 2)*(-2*n0 +
03661
03662
03663 as1*e0c*(epsc1 + 2*epsn))) +
03664
03665
03666 2*as2*(b*ch*
03667
03668
03669 fc*(epsc1 +
03670
03671
03672 2*epsn)*((-1 + 2*k)*epsc1 -
03673
03674
03675 2*(-1 + k)*epsn) +
03676
03677
03678 k*pow(epsc1,
03679
03680
03681 2)*(-n0 + as1*e0c*(epsc1 + 2*epsn))))*
03682
03683
03684 sqrt(k*
03685
03686
03687 pow(epsc1,
03688
03689
03690 2)*(3*k*pow(epsc1, 2)*
03691
03692
03693 pow(as2*ch*e0c*
03694
03695
03696 epsc1 + (d*(2*n0 +
03697
03698
03699 e0c*(as1*(epsc1 - 2*epsn) -
03700
03701
03702 as2*(epsc1 + 2*epsn))))/2., 2) -
03703
03704
03705 2*(as2*ch + as1*d)*
03706
03707
03708 e0c*(-(b*pow(d, 2)*fc*
03709
03710
03711 pow(epsc1 + 2*epsn,
03712
03713
03714 2)*((-4 + 7*k)*epsc1 -
03715
03716
03717 4*(-1 + k)*epsn))/4. +
03718
03719
03720 3*k*pow(epsc1,
03721
03722
03723 3)*((as2*ch*e0c*epsc1)/2. +
03724
03725
03726 d*(n0 - (e0c*(as2*epsc1 +
03727
03728
03729 2*as1*epsn + 2*as2*epsn))/
03730
03731
03732 2.))))))/(-8*b*(as2*ch + as1*d)*e0c*
03733
03734
03735 fc*(epsc1 - epsn)*pow(epsc1 + 2*epsn, 2) +
03736
03737
03738 k*(12*pow(n0, 2)*pow(epsc1, 2) -
03739
03740
03741 12*(as1 + as2)*e0c*n0*
03742
03743
03744 pow(epsc1, 2)*(epsc1 + 2*epsn) +
03745
03746
03747 e0c*(3*pow(as2, 2)*e0c*pow(epsc1, 2) +
03748
03749
03750 2*as2*(3*as1*e0c*pow(epsc1, 2) +
03751
03752
03753 b*ch*fc*(7*epsc1 - 4*epsn)) +
03754
03755
03756 as1*(3*as1*e0c*pow(epsc1, 2) +
03757
03758
03759 2*b*d*fc*(7*epsc1 - 4*epsn)))*
03760
03761
03762 pow(epsc1 + 2*epsn, 2)))))/((as2*ch +
03763
03764
03765 as1*d)*k*pow(epsc1, 2))) + (4*(3*as2*ch*d*k*
03766
03767
03768 pow(epsc1, 2)*(4*fy + e0c*(epsc1 + 2*epsn)) +
03769
03770
03771 3*as1*d*k*
03772
03773
03774 pow(epsc1,
03775
03776
03777 2)*(-(ch*e0c*(epsc1 + 2*epsn)) +
03778
03779
03780 2*d*(2*fy + e0c*epsc1 + 2*e0c*epsn)) +
03781
03782
03783 2*ch*(3*d*k*n0*pow(epsc1, 2) +
03784
03785
03786 sqrt(3.)*
03787
03788
03789 sqrt(k*
03790
03791
03792 pow(epsc1,
03793
03794
03795 2)*(3*k*pow(epsc1, 2)*
03796
03797
03798 pow(as2*ch*e0c*
03799
03800
03801 epsc1 + (d*(2*n0 +
03802
03803
03804 e0c*(as1*(epsc1 - 2*epsn) -
03805
03806
03807 as2*(epsc1 + 2*epsn))))/2., 2) -
03808
03809
03810 2*(as2*ch + as1*d)*
03811
03812
03813 e0c*(-(b*pow(d, 2)*fc*
03814
03815
03816 pow(epsc1 + 2*epsn,
03817
03818
03819 2)*(-4*epsc1 + 7*k*epsc1 + 4*epsn -
03820
03821
03822 4*k*epsn))/4. +
03823
03824
03825 3*k*pow(epsc1,
03826
03827
03828 3)*((as2*ch*e0c*epsc1)/2. +
03829
03830
03831 d*(n0 - (e0c*(as2*epsc1 +
03832
03833
03834 2*as1*epsn + 2*as2*epsn))/
03835
03836
03837 2.))))))))/(ch*(as2*ch + as1*d)*k*
03838
03839
03840 pow(epsc1, 2)))/(48.*e0c);
03841
03842
03843
03844
03845
03846 ac2 =(-2 + (2*d)/
03847
03848
03849 ch - (2*sqrt(3.)*((-8*b*(as2*ch + as1*d)*e0c*fc*(epsc1 - epsn)*
03850
03851
03852 pow(epsc1 + 2*epsn, 2) +
03853
03854
03855 k*(12*pow(n0, 2)*pow(epsc1, 2) -
03856
03857
03858 12*(as1 + as2)*e0c*n0*
03859
03860
03861 pow(epsc1, 2)*(epsc1 + 2*epsn) +
03862
03863
03864 e0c*(3*pow(as2, 2)*e0c*pow(epsc1, 2) +
03865
03866
03867 2*as2*(3*as1*e0c*pow(epsc1, 2) +
03868
03869
03870 b*ch*fc*(7*epsc1 - 4*epsn)) +
03871
03872
03873 as1*(3*as1*e0c*pow(epsc1, 2) +
03874
03875
03876 2*b*d*fc*(7*epsc1 - 4*epsn)))*
03877
03878
03879 pow(epsc1 + 2*epsn, 2)))*(pow(as2, 2)*e0c*k*
03880
03881
03882 pow(epsc1, 2) +
03883
03884
03885 2*as2*(as1*e0c*k*pow(epsc1, 2) +
03886
03887
03888 b*ch*fc*(k*epsc1 + 4*epsn - 4*k*epsn)) +
03889
03890
03891 as1*(as1*e0c*k*pow(epsc1, 2) +
03892
03893
03894 2*b*d*fc*(k*epsc1 + 4*epsn - 4*k*epsn))) -
03895
03896
03897 3*e0c*pow(pow(as2, 2)*e0c*k*pow(epsc1, 2)*(epsc1 + 2*epsn) +
03898
03899
03900 as1*(2*b*d*
03901
03902
03903 fc*(epsc1 + 2*epsn)*((-1 + 2*k)*epsc1 -
03904
03905
03906 2*(-1 + k)*epsn) +
03907
03908
03909 k*pow(epsc1,
03910
03911
03912 2)*(-2*n0 + as1*e0c*(epsc1 + 2*epsn))) +
03913
03914
03915 2*as2*(b*ch*
03916
03917
03918 fc*(epsc1 + 2*epsn)*((-1 + 2*k)*epsc1 -
03919
03920
03921 2*(-1 + k)*epsn) +
03922
03923
03924 k*pow(epsc1, 2)*(-n0 + as1*e0c*(epsc1 + 2*epsn))),
03925
03926
03927 2))*sqrt(k*
03928
03929
03930 pow(epsc1,
03931
03932
03933 2)*(3*k*pow(epsc1, 2)*
03934
03935
03936 pow(as2*ch*e0c*
03937
03938
03939 epsc1 + (d*(2*n0 +
03940
03941
03942 e0c*(as1*(epsc1 - 2*epsn) -
03943
03944
03945 as2*(epsc1 + 2*epsn))))/2., 2) -
03946
03947
03948 2*(as2*ch + as1*d)*
03949
03950
03951 e0c*(-(b*pow(d, 2)*fc*
03952
03953
03954 pow(epsc1 + 2*epsn,
03955
03956
03957 2)*((-4 + 7*k)*epsc1 - 4*(-1 + k)*epsn))/
03958
03959
03960 4. + 3*k*
03961
03962
03963 pow(epsc1,
03964
03965
03966 3)*((as2*ch*e0c*epsc1)/2. +
03967
03968
03969 d*(n0 - (e0c*(as2*epsc1 + 2*as1*epsn +
03970
03971
03972 2*as2*epsn))/2.))))))/((as2*ch +
03973
03974
03975 as1*d)*k*epsc1*
03976
03977
03978 pow(-8*b*(as2*ch + as1*d)*e0c*fc*(epsc1 - epsn)*
03979
03980
03981 pow(epsc1 + 2*epsn, 2) +
03982
03983
03984 k*(12*pow(n0, 2)*pow(epsc1, 2) -
03985
03986
03987 12*(as1 + as2)*e0c*n0*pow(epsc1, 2)*(epsc1 + 2*epsn) +
03988
03989
03990 e0c*(3*pow(as2, 2)*e0c*pow(epsc1, 2) +
03991
03992
03993 2*as2*(3*as1*e0c*pow(epsc1, 2) +
03994
03995
03996 b*ch*fc*(7*epsc1 - 4*epsn)) +
03997
03998
03999 as1*(3*as1*e0c*pow(epsc1, 2) +
04000
04001
04002 2*b*d*fc*(7*epsc1 - 4*epsn)))*
04003
04004
04005 pow(epsc1 + 2*epsn, 2)), 2)) + (2*as2*ch*k*
04006
04007
04008 pow(epsc1, 2) + (as1 - as2)*d*k*
04009
04010
04011 pow(epsc1,
04012
04013
04014 2) + (2*
04015
04016
04017 sqrt(3.)*(pow(as2, 2)*e0c*k*pow(epsc1, 2)*(epsc1 + 2*epsn) +
04018
04019
04020 as1*(2*b*d*
04021
04022
04023 fc*(epsc1 + 2*epsn)*((-1 + 2*k)*epsc1 -
04024
04025
04026 2*(-1 + k)*epsn) +
04027
04028
04029 k*pow(epsc1,
04030
04031
04032 2)*(-2*n0 + as1*e0c*(epsc1 + 2*epsn))) +
04033
04034
04035 2*as2*(b*ch*
04036
04037
04038 fc*(epsc1 + 2*epsn)*((-1 + 2*k)*epsc1 -
04039
04040
04041 2*(-1 + k)*epsn) +
04042
04043
04044 k*pow(epsc1,
04045
04046
04047 2)*(-n0 + as1*e0c*(epsc1 + 2*epsn))))*
04048
04049
04050 sqrt(k*pow(epsc1,
04051
04052
04053 2)*(3*k*pow(epsc1, 2)*
04054
04055
04056 pow(as2*ch*e0c*
04057
04058
04059 epsc1 + (d*(2*n0 +
04060
04061
04062 e0c*(as1*(epsc1 - 2*epsn) -
04063
04064
04065 as2*(epsc1 + 2*epsn))))/2., 2) -
04066
04067
04068 2*(as2*ch + as1*d)*
04069
04070
04071 e0c*(-(b*pow(d, 2)*fc*
04072
04073
04074 pow(epsc1 + 2*epsn,
04075
04076
04077 2)*((-4 + 7*k)*epsc1 -
04078
04079
04080 4*(-1 + k)*epsn))/4. +
04081
04082
04083 3*k*pow(epsc1,
04084
04085
04086 3)*((as2*ch*e0c*epsc1)/2. +
04087
04088
04089 d*(n0 - (e0c*(as2*epsc1 + 2*as1*epsn +
04090
04091
04092 2*as2*epsn))/2.))))))/(-8*
04093
04094
04095 b*(as2*ch + as1*d)*e0c*fc*(epsc1 - epsn)*
04096
04097
04098 pow(epsc1 + 2*epsn, 2) +
04099
04100
04101 k*(12*pow(n0, 2)*pow(epsc1, 2) -
04102
04103
04104 12*(as1 + as2)*e0c*n0*pow(epsc1, 2)*(epsc1 + 2*epsn) +
04105
04106
04107 e0c*(3*pow(as2, 2)*e0c*pow(epsc1, 2) +
04108
04109
04110 2*as2*(3*as1*e0c*pow(epsc1, 2) +
04111
04112
04113 b*ch*fc*(7*epsc1 - 4*epsn)) +
04114
04115
04116 as1*(3*as1*e0c*pow(epsc1, 2) +
04117
04118
04119 2*b*d*fc*(7*epsc1 - 4*epsn)))*
04120
04121
04122 pow(epsc1 + 2*epsn, 2))))/((as2*ch + as1*d)*k*
04123
04124
04125 pow(epsc1, 2)))/2.;
04126
04127
04128
04129
04130
04131 ac3 =(sqrt(3.)*((-8*b*(as2*ch + as1*d)*e0c*fc*(epsc1 - epsn)*
04132
04133
04134 pow(epsc1 + 2*epsn, 2) +
04135
04136
04137 k*(12*pow(n0, 2)*pow(epsc1, 2) -
04138
04139
04140 12*(as1 + as2)*e0c*n0*pow(epsc1, 2)*(epsc1 + 2*epsn) +
04141
04142
04143 e0c*(3*pow(as2, 2)*e0c*pow(epsc1, 2) +
04144
04145
04146 2*as2*(3*as1*e0c*pow(epsc1, 2) +
04147
04148
04149 b*ch*fc*(7*epsc1 - 4*epsn)) +
04150
04151
04152 as1*(3*as1*e0c*pow(epsc1, 2) +
04153
04154
04155 2*b*d*fc*(7*epsc1 - 4*epsn)))*
04156
04157
04158 pow(epsc1 + 2*epsn, 2)))*(pow(as2, 2)*e0c*k*
04159
04160
04161 pow(epsc1, 2) +
04162
04163
04164 2*as2*(as1*e0c*k*pow(epsc1, 2) +
04165
04166
04167 b*ch*fc*(k*epsc1 + 4*epsn - 4*k*epsn)) +
04168
04169
04170 as1*(as1*e0c*k*pow(epsc1, 2) +
04171
04172
04173 2*b*d*fc*(k*epsc1 + 4*epsn - 4*k*epsn))) -
04174
04175
04176 3*e0c*pow(pow(as2, 2)*e0c*k*pow(epsc1, 2)*(epsc1 + 2*epsn) +
04177
04178
04179 as1*(2*b*d*
04180
04181
04182 fc*(epsc1 + 2*epsn)*((-1 + 2*k)*epsc1 -
04183
04184
04185 2*(-1 + k)*epsn) +
04186
04187
04188 k*pow(epsc1, 2)*(-2*n0 + as1*e0c*(epsc1 + 2*epsn))) +
04189
04190
04191 2*as2*(b*ch*
04192
04193
04194 fc*(epsc1 + 2*epsn)*((-1 + 2*k)*epsc1 -
04195
04196
04197 2*(-1 + k)*epsn) +
04198
04199
04200 k*pow(epsc1, 2)*(-n0 + as1*e0c*(epsc1 + 2*epsn))), 2))*
04201
04202
04203 sqrt(k*pow(epsc1,
04204
04205
04206 2)*(3*k*pow(epsc1, 2)*
04207
04208
04209 pow(as2*ch*e0c*
04210
04211
04212 epsc1 + (d*(2*n0 +
04213
04214
04215 e0c*(as1*(epsc1 - 2*epsn) -
04216
04217
04218 as2*(epsc1 + 2*epsn))))/2., 2) -
04219
04220
04221 2*(as2*ch + as1*d)*
04222
04223
04224 e0c*(-(b*pow(d, 2)*fc*
04225
04226
04227 pow(epsc1 + 2*epsn,
04228
04229
04230 2)*((-4 + 7*k)*epsc1 - 4*(-1 + k)*epsn))/4. +
04231
04232
04233 3*k*pow(epsc1,
04234
04235
04236 3)*((as2*ch*e0c*epsc1)/2. +
04237
04238
04239 d*(n0 - (e0c*(as2*epsc1 + 2*as1*epsn + 2*as2*epsn))/
04240
04241
04242 2.))))))/((as2*ch + as1*d)*k*pow(epsc1, 2)*
04243
04244
04245 pow(-8*b*(as2*ch + as1*d)*e0c*fc*(epsc1 - epsn)*pow(epsc1 + 2*epsn, 2) +
04246
04247
04248 k*(12*pow(n0, 2)*pow(epsc1, 2) -
04249
04250
04251 12*(as1 + as2)*e0c*n0*pow(epsc1, 2)*(epsc1 + 2*epsn) +
04252
04253
04254 e0c*(3*pow(as2, 2)*e0c*pow(epsc1, 2) +
04255
04256
04257 2*as2*(3*as1*e0c*pow(epsc1, 2) +
04258
04259
04260 b*ch*fc*(7*epsc1 - 4*epsn)) +
04261
04262
04263 as1*(3*as1*e0c*pow(epsc1, 2) +
04264
04265
04266 2*b*d*fc*(7*epsc1 - 4*epsn)))*
04267
04268
04269 pow(epsc1 + 2*epsn, 2)), 2));
04270
04271
04272
04273
04274
04275 epschr3 =(-ac2 + sqrt(pow(ac2, 2) - 4*ac1*ac3))/(2.*ac3);
04276
04277
04278
04279
04280
04281 return epschr3;
04282
04283
04284 }
04285
04286
04287
04288
04289
04290
04291
04292
04293 double normmat::compute_mhr3 ()
04294
04295
04296 {
04297
04298
04299 double mhr3;
04300
04301
04302
04303
04304
04305 mhr3 =(6*as1*e0c*(-2*cd +
04306
04307
04308 h)*(epsn + (6*as2*ch*e0c*k*epschr3*pow(epsc1, 2) +
04309
04310
04311 3*d*k*pow(epsc1,
04312
04313
04314 2)*(n0 + as1*e0c*(epschr3 - epsn) -
04315
04316
04317 as2*e0c*(epschr3 + epsn)) +
04318
04319
04320 sqrt(3.)*
04321
04322
04323 sqrt(k*pow(epsc1,
04324
04325
04326 2)*(3*k*pow(epsc1, 2)*
04327
04328
04329 pow(-2*as2*ch*e0c*epschr3 +
04330
04331
04332 d*(-n0 +
04333
04334
04335 e0c*(as1*(-epschr3 + epsn) +
04336
04337
04338 as2*(epschr3 + epsn))), 2) -
04339
04340
04341 2*(as2*ch + as1*d)*
04342
04343
04344 e0c*(b*pow(d, 2)*fc*
04345
04346
04347 pow(epschr3 + epsn,
04348
04349
04350 2)*(4*(-1 + k)*epschr3 + (6 - 9*k)*
04351
04352
04353 epsc1 + 4*(-1 + k)*epsn) +
04354
04355
04356 6*k*epschr3*
04357
04358
04359 pow(epsc1,
04360
04361
04362 2)*(as2*ch*e0c*epschr3 +
04363
04364
04365 d*(n0 -
04366
04367
04368 e0c*(as1*epsn +
04369
04370
04371 as2*(epschr3 + epsn))))))))/(6.*(as2*
04372
04373
04374 ch + as1*d)*e0c*k*pow(epsc1, 2))) -
04375
04376
04377 6*as2*e0c*(-2*ch + h)*(epschr3 - (ch*epschr3)/d +
04378
04379
04380 epsn + (ch*(6*as2*ch*e0c*k*epschr3*pow(epsc1, 2) +
04381
04382
04383 3*d*k*pow(epsc1,
04384
04385
04386 2)*(n0 + as1*e0c*(epschr3 - epsn) -
04387
04388
04389 as2*e0c*(epschr3 + epsn)) +
04390
04391
04392 sqrt(3.)*
04393
04394
04395 sqrt(k*
04396
04397
04398 pow(epsc1,
04399
04400
04401 2)*(3*k*pow(epsc1, 2)*
04402
04403
04404 pow(-2*as2*ch*e0c*epschr3 +
04405
04406
04407 d*(-n0 +
04408
04409
04410 e0c*(as1*(-epschr3 + epsn) +
04411
04412
04413 as2*(epschr3 + epsn))), 2) -
04414
04415
04416 2*(as2*ch + as1*d)*
04417
04418
04419 e0c*(b*pow(d, 2)*fc*
04420
04421
04422 pow(epschr3 + epsn,
04423
04424
04425 2)*(4*(-1 + k)*epschr3 + (6 - 9*k)*
04426
04427
04428 epsc1 + 4*(-1 + k)*epsn) +
04429
04430
04431 6*k*epschr3*
04432
04433
04434 pow(epsc1,
04435
04436
04437 2)*(as2*ch*e0c*epschr3 +
04438
04439
04440 d*(n0 - e0c*(as1*epsn +
04441
04442
04443 as2*(epschr3 + epsn)))))))))/(6.*
04444
04445
04446 d*(as2*ch + as1*d)*e0c*k*pow(epsc1, 2))) - (b*d*fc*
04447
04448
04449 pow(epschr3 + epsn,
04450
04451
04452 2)*(2*d*(epschr3 +
04453
04454
04455 epsn)*((-1 + k)*epschr3 + (2 - 3*k)*epsc1 + (-1 + k)*
04456
04457
04458 epsn) -
04459
04460
04461 h*(4*(-1 + k)*epschr3 + (6 - 9*k)*epsc1 +
04462
04463
04464 4*(-1 + k)*
04465
04466
04467 epsn)*(epschr3 - (6*as2*ch*e0c*k*epschr3*
04468
04469
04470 pow(epsc1, 2) +
04471
04472
04473 3*d*k*pow(epsc1,
04474
04475
04476 2)*(n0 + as1*e0c*(epschr3 - epsn) -
04477
04478
04479 as2*e0c*(epschr3 + epsn)) +
04480
04481
04482 sqrt(3.)*
04483
04484
04485 sqrt(k*
04486
04487
04488 pow(epsc1,
04489
04490
04491 2)*(3*k*pow(epsc1, 2)*
04492
04493
04494 pow(-2*as2*ch*e0c*epschr3 +
04495
04496
04497 d*(-n0 + e0c*(as1*(-epschr3 + epsn) +
04498
04499
04500 as2*(epschr3 + epsn))), 2) -
04501
04502
04503 2*(as2*ch + as1*d)*
04504
04505
04506 e0c*(b*pow(d, 2)*fc*
04507
04508
04509 pow(epschr3 + epsn,
04510
04511
04512 2)*(4*(-1 + k)*epschr3 + (6 - 9*k)*
04513
04514
04515 epsc1 + 4*(-1 + k)*epsn) +
04516
04517
04518 6*k*epschr3*
04519
04520
04521 pow(epsc1,
04522
04523
04524 2)*(as2*ch*e0c*epschr3 +
04525
04526
04527 d*(n0 - e0c*(as1*epsn +
04528
04529
04530 as2*(epschr3 + epsn))))))))/(6.*(as2*
04531
04532
04533 ch + as1*d)*e0c*k*pow(epsc1, 2)))))/(k*
04534
04535
04536 pow(epsc1, 2)*
04537
04538
04539 pow(epschr3 - (6*as2*ch*e0c*k*epschr3*pow(epsc1, 2) +
04540
04541
04542 3*d*k*pow(epsc1,
04543
04544
04545 2)*(n0 + as1*e0c*(epschr3 - epsn) -
04546
04547
04548 as2*e0c*(epschr3 + epsn)) +
04549
04550
04551 sqrt(3.)*
04552
04553
04554 sqrt(k*
04555
04556
04557 pow(epsc1,
04558
04559
04560 2)*(3*k*pow(epsc1, 2)*
04561
04562
04563 pow(-2*as2*ch*e0c*epschr3 +
04564
04565
04566 d*(-n0 +
04567
04568
04569 e0c*(as1*(-epschr3 + epsn) +
04570
04571
04572 as2*(epschr3 + epsn))), 2) -
04573
04574
04575 2*(as2*ch + as1*d)*
04576
04577
04578 e0c*(b*pow(d, 2)*fc*
04579
04580
04581 pow(epschr3 + epsn,
04582
04583
04584 2)*(4*(-1 + k)*epschr3 + (6 - 9*k)*
04585
04586
04587 epsc1 + 4*(-1 + k)*epsn) +
04588
04589
04590 6*k*epschr3*
04591
04592
04593 pow(epsc1,
04594
04595
04596 2)*(as2*ch*e0c*epschr3 +
04597
04598
04599 d*(n0 - e0c*(as1*epsn +
04600
04601
04602 as2*(epschr3 + epsn))))))))/(6.*(as2*
04603
04604
04605 ch + as1*d)*e0c*k*pow(epsc1, 2)), 2)))/12. + e0c*(-(as1*(-cd + h/2.)) + as2*(-ch + h/2.))*epsn;
04606
04607
04608
04609
04610
04611 return mhr3;
04612
04613
04614 }
04615
04616
04617
04618
04619
04620
04621
04622
04623
04624
04625
04626
04627
04628
04629 double normmat::compute_epschr4 ()
04630
04631
04632 {
04633
04634
04635 double ac1,ac2,ac3,epschr4;
04636
04637
04638
04639
04640
04641 ac1 =(-(ch*e0c*epsc1)/2. + d*(fy + (e0c*epsc1)/2. + e0c*epsn))/(ch*
04642
04643
04644 e0c) + (sqrt(3.)*b*fc*h*(-1 + k)*
04645
04646
04647 pow(epsc1,
04648
04649
04650 4)*(pow(b, 2)*pow(fc, 2)*pow(h, 4)*pow(2 - 3*k, 2) +
04651
04652
04653 4*pow(e0c,
04654
04655
04656 2)*(pow(as2, 2)*(3*pow(ch, 2) - 3*ch*h + pow(h, 2)) +
04657
04658
04659 pow(as1, 2)*(3*pow(d, 2) - 3*d*h + pow(h, 2)) +
04660
04661
04662 as1*as2*(6*ch*d - 3*ch*h - 3*d*h + 2*pow(h, 2)))*
04663
04664
04665 pow(k, 2)*pow(epsc1, 2) -
04666
04667
04668 2*b*fc*pow(h, 3)*
04669
04670
04671 k*(4*(-1 + k)*n0 - (as1 + as2)*e0c*(-2 + 3*k)*epsc1))*
04672
04673
04674 sqrt(pow(d,
04675
04676
04677 2)*(12*pow(as2*ch + as1*d, 2)*pow(e0c, 2)*pow(k, 2)*
04678
04679
04680 pow(epsc1, 4) +
04681
04682
04683 pow(b, 2)*pow(fc, 2)*
04684
04685
04686 pow(h, 4)*((-4 + 7*k)*epsc1 -
04687
04688
04689 4*(-1 + k)*epsn)*((-4 + 5*k)*epsc1 +
04690
04691
04692 4*(-1 + k)*epsn) +
04693
04694
04695 4*b*fc*pow(h, 2)*k*
04696
04697
04698 pow(epsc1,
04699
04700
04701 2)*(3*(as2*ch + as1*d)*
04702
04703
04704 e0c*(k*(epsc1 - 4*epsn) + 4*epsn) +
04705
04706
04707 8*h*(-1 +
04708
04709
04710 k)*(-n0 + (as1 + as2)*
04711
04712
04713 e0c*(epsc1/2. + epsn))))))/
04714
04715
04716 pow(12*pow(as2*ch + as1*d, 2)*pow(e0c, 2)*pow(k, 2)*pow(epsc1, 4) +
04717
04718
04719 pow(b, 2)*pow(fc, 2)*
04720
04721
04722 pow(h, 4)*((16 - 48*k + 35*pow(k, 2))*pow(epsc1, 2) +
04723
04724
04725 8*(-1 + k)*k*epsc1*epsn - 16*pow(-1 + k, 2)*pow(epsn, 2)) +
04726
04727
04728 4*b*fc*pow(h, 2)*k*
04729
04730
04731 pow(epsc1,
04732
04733
04734 2)*(3*(as2*ch + as1*d)*e0c*(k*(epsc1 - 4*epsn) + 4*epsn) -
04735
04736
04737 4*h*(-1 + k)*(2*n0 - (as1 + as2)*e0c*(epsc1 + 2*epsn))),
04738
04739
04740 2) + (6*as2*ch*d*e0c*k*pow(epsc1, 2) +
04741
04742
04743 6*as1*pow(d, 2)*e0c*k*pow(epsc1, 2) +
04744
04745
04746 b*fc*pow(h,
04747
04748
04749 2)*(4*h*(-1 + k)*epsc1 + 3*d*(k*epsc1 + 4*epsn - 4*k*epsn)) -
04750
04751
04752 sqrt(3.)*sqrt(pow(d,
04753
04754
04755 2)*(12*pow(as2*ch + as1*d, 2)*pow(e0c, 2)*pow(k, 2)*
04756
04757
04758 pow(epsc1, 4) +
04759
04760
04761 pow(b, 2)*pow(fc, 2)*
04762
04763
04764 pow(h, 4)*((-4 + 5*k)*epsc1 +
04765
04766
04767 4*(-1 + k)*epsn)*(-4*epsc1 + 7*k*epsc1 + 4*epsn -
04768
04769
04770 4*k*epsn) +
04771
04772
04773 4*b*fc*pow(h, 2)*k*
04774
04775
04776 pow(epsc1,
04777
04778
04779 2)*(3*(as2*ch + as1*d)*
04780
04781
04782 e0c*(k*epsc1 + 4*epsn - 4*k*epsn) +
04783
04784
04785 8*h*(-1 +
04786
04787
04788 k)*(-n0 + (as1 + as2)*
04789
04790
04791 e0c*(epsc1/2. + epsn))))))/(8.*b*fc*
04792
04793
04794 pow(h, 3)*(-1 + k)) - (epsc1*(-1 +
04795
04796
04797 d/ch - (3*d -
04798
04799
04800 2*h + (sqrt(3.)*(2*
04801
04802
04803 e0c*(-3*as2*ch - 3*as1*d + 2*as1*h + 2*as2*h)*k*
04804
04805
04806 pow(epsc1, 2) +
04807
04808
04809 b*fc*pow(h, 2)*(k*(epsc1 - 4*epsn) + 4*epsn))*
04810
04811
04812 sqrt(pow(d,
04813
04814
04815 2)*(12*pow(as2*ch + as1*d, 2)*pow(e0c, 2)*
04816
04817
04818 pow(k, 2)*pow(epsc1, 4) +
04819
04820
04821 pow(b, 2)*pow(fc, 2)*
04822
04823
04824 pow(h,
04825
04826
04827 4)*((-4 + 7*k)*epsc1 -
04828
04829
04830 4*(-1 + k)*epsn)*((-4 + 5*k)*epsc1 +
04831
04832
04833 4*(-1 + k)*epsn) +
04834
04835
04836 4*b*fc*pow(h, 2)*k*
04837
04838
04839 pow(epsc1,
04840
04841
04842 2)*(3*(as2*ch + as1*d)*
04843
04844
04845 e0c*(k*(epsc1 - 4*epsn) + 4*epsn) +
04846
04847
04848 8*h*(-1 +
04849
04850
04851 k)*(-n0 + (as1 + as2)*
04852
04853
04854 e0c*(epsc1/2. + epsn))))))/(12*
04855
04856
04857 pow(as2*ch + as1*d, 2)*pow(e0c, 2)*pow(k, 2)*
04858
04859
04860 pow(epsc1, 4) +
04861
04862
04863 pow(b, 2)*pow(fc, 2)*
04864
04865
04866 pow(h,
04867
04868
04869 4)*((16 - 48*k + 35*pow(k, 2))*pow(epsc1, 2) +
04870
04871
04872 8*(-1 + k)*k*epsc1*epsn -
04873
04874
04875 16*pow(-1 + k, 2)*pow(epsn, 2)) +
04876
04877
04878 4*b*fc*pow(h, 2)*k*
04879
04880
04881 pow(epsc1,
04882
04883
04884 2)*(3*(as2*ch + as1*d)*
04885
04886
04887 e0c*(k*(epsc1 - 4*epsn) + 4*epsn) -
04888
04889
04890 4*h*(-1 +
04891
04892
04893 k)*(2*n0 - (as1 + as2)*
04894
04895
04896 e0c*(epsc1 + 2*epsn)))))/(2.*h)))/2.;
04897
04898
04899
04900
04901
04902 ac2 =-1 + d/ch - (4*sqrt(3.)*b*fc*h*(-1 + k)*
04903
04904
04905 pow(epsc1,
04906
04907
04908 3)*(pow(b, 2)*pow(fc, 2)*pow(h, 4)*pow(2 - 3*k, 2) +
04909
04910
04911 4*pow(e0c,
04912
04913
04914 2)*(pow(as2, 2)*(3*pow(ch, 2) - 3*ch*h + pow(h, 2)) +
04915
04916
04917 pow(as1, 2)*(3*pow(d, 2) - 3*d*h + pow(h, 2)) +
04918
04919
04920 as1*as2*(6*ch*d - 3*ch*h - 3*d*h + 2*pow(h, 2)))*
04921
04922
04923 pow(k, 2)*pow(epsc1, 2) -
04924
04925
04926 2*b*fc*pow(h, 3)*
04927
04928
04929 k*(4*(-1 + k)*n0 - (as1 + as2)*e0c*(-2 + 3*k)*epsc1))*
04930
04931
04932 sqrt(pow(d,
04933
04934
04935 2)*(12*pow(as2*ch + as1*d, 2)*pow(e0c, 2)*pow(k, 2)*
04936
04937
04938 pow(epsc1, 4) +
04939
04940
04941 pow(b, 2)*pow(fc, 2)*
04942
04943
04944 pow(h, 4)*((-4 + 7*k)*epsc1 -
04945
04946
04947 4*(-1 + k)*epsn)*((-4 + 5*k)*epsc1 +
04948
04949
04950 4*(-1 + k)*epsn) +
04951
04952
04953 4*b*fc*pow(h, 2)*k*
04954
04955
04956 pow(epsc1,
04957
04958
04959 2)*(3*(as2*ch + as1*d)*
04960
04961
04962 e0c*(k*(epsc1 - 4*epsn) + 4*epsn) +
04963
04964
04965 8*h*(-1 +
04966
04967
04968 k)*(-n0 + (as1 + as2)*
04969
04970
04971 e0c*(epsc1/2. + epsn))))))/
04972
04973
04974 pow(12*pow(as2*ch + as1*d, 2)*pow(e0c, 2)*pow(k, 2)*pow(epsc1, 4) +
04975
04976
04977 pow(b, 2)*pow(fc, 2)*
04978
04979
04980 pow(h, 4)*((16 - 48*k + 35*pow(k, 2))*pow(epsc1, 2) +
04981
04982
04983 8*(-1 + k)*k*epsc1*epsn - 16*pow(-1 + k, 2)*pow(epsn, 2)) +
04984
04985
04986 4*b*fc*pow(h, 2)*k*
04987
04988
04989 pow(epsc1,
04990
04991
04992 2)*(3*(as2*ch + as1*d)*e0c*(k*(epsc1 - 4*epsn) + 4*epsn) -
04993
04994
04995 4*h*(-1 + k)*(2*n0 - (as1 + as2)*e0c*(epsc1 + 2*epsn))),
04996
04997
04998 2) - (3*d -
04999
05000
05001 2*h + (sqrt(3.)*(2*e0c*(-3*as2*ch - 3*as1*d + 2*as1*h + 2*as2*h)*k*
05002
05003
05004 pow(epsc1, 2) +
05005
05006
05007 b*fc*pow(h, 2)*(k*(epsc1 - 4*epsn) + 4*epsn))*
05008
05009
05010 sqrt(pow(d,
05011
05012
05013 2)*(12*pow(as2*ch + as1*d, 2)*pow(e0c, 2)*pow(k, 2)*
05014
05015
05016 pow(epsc1, 4) +
05017
05018
05019 pow(b, 2)*pow(fc, 2)*
05020
05021
05022 pow(h,
05023
05024
05025 4)*((-4 + 7*k)*epsc1 -
05026
05027
05028 4*(-1 + k)*epsn)*((-4 + 5*k)*epsc1 +
05029
05030
05031 4*(-1 + k)*epsn) +
05032
05033
05034 4*b*fc*pow(h, 2)*k*
05035
05036
05037 pow(epsc1,
05038
05039
05040 2)*(3*(as2*ch + as1*d)*
05041
05042
05043 e0c*(k*(epsc1 - 4*epsn) + 4*epsn) +
05044
05045
05046 8*h*(-1 +
05047
05048
05049 k)*(-n0 + (as1 + as2)*
05050
05051
05052 e0c*(epsc1/2. + epsn))))))/(12*
05053
05054
05055 pow(as2*ch + as1*d, 2)*pow(e0c, 2)*pow(k, 2)*pow(epsc1, 4) +
05056
05057
05058 pow(b, 2)*pow(fc, 2)*
05059
05060
05061 pow(h, 4)*((16 - 48*k + 35*pow(k, 2))*pow(epsc1, 2) +
05062
05063
05064 8*(-1 + k)*k*epsc1*epsn -
05065
05066
05067 16*pow(-1 + k, 2)*pow(epsn, 2)) +
05068
05069
05070 4*b*fc*pow(h, 2)*k*
05071
05072
05073 pow(epsc1,
05074
05075
05076 2)*(3*(as2*ch + as1*d)*e0c*(k*(epsc1 - 4*epsn) + 4*epsn) -
05077
05078
05079 4*h*(-1 +
05080
05081
05082 k)*(2*n0 - (as1 + as2)*e0c*(epsc1 + 2*epsn)))))/(2.*
05083
05084
05085 h);
05086
05087
05088
05089
05090
05091 ac3 =(4*sqrt(3.)*b*fc*h*(-1 + k)*
05092
05093
05094 pow(epsc1,
05095
05096
05097 2)*(pow(b, 2)*pow(fc, 2)*pow(h, 4)*pow(2 - 3*k, 2) +
05098
05099
05100 4*pow(e0c,
05101
05102
05103 2)*(pow(as2, 2)*(3*pow(ch, 2) - 3*ch*h + pow(h, 2)) +
05104
05105
05106 pow(as1, 2)*(3*pow(d, 2) - 3*d*h + pow(h, 2)) +
05107
05108
05109 as1*as2*(6*ch*d - 3*ch*h - 3*d*h + 2*pow(h, 2)))*pow(k, 2)*
05110
05111
05112 pow(epsc1, 2) -
05113
05114
05115 2*b*fc*pow(h, 3)*
05116
05117
05118 k*(4*(-1 + k)*n0 - (as1 + as2)*e0c*(-2 + 3*k)*epsc1))*
05119
05120
05121 sqrt(pow(d,
05122
05123
05124 2)*(12*pow(as2*ch + as1*d, 2)*pow(e0c, 2)*pow(k, 2)*
05125
05126
05127 pow(epsc1, 4) +
05128
05129
05130 pow(b, 2)*pow(fc, 2)*
05131
05132
05133 pow(h, 4)*((-4 + 7*k)*epsc1 -
05134
05135
05136 4*(-1 + k)*epsn)*((-4 + 5*k)*epsc1 + 4*(-1 + k)*epsn) +
05137
05138
05139 4*b*fc*pow(h, 2)*k*
05140
05141
05142 pow(epsc1,
05143
05144
05145 2)*(3*(as2*ch + as1*d)*
05146
05147
05148 e0c*(k*(epsc1 - 4*epsn) + 4*epsn) +
05149
05150
05151 8*h*(-1 +
05152
05153
05154 k)*(-n0 + (as1 + as2)*e0c*(epsc1/2. + epsn))))))/
05155
05156
05157 pow(12*pow(as2*ch + as1*d, 2)*pow(e0c, 2)*pow(k, 2)*pow(epsc1, 4) +
05158
05159
05160 pow(b, 2)*pow(fc, 2)*
05161
05162
05163 pow(h, 4)*((16 - 48*k + 35*pow(k, 2))*pow(epsc1, 2) +
05164
05165
05166 8*(-1 + k)*k*epsc1*epsn - 16*pow(-1 + k, 2)*pow(epsn, 2)) +
05167
05168
05169 4*b*fc*pow(h, 2)*k*
05170
05171
05172 pow(epsc1,
05173
05174
05175 2)*(3*(as2*ch + as1*d)*e0c*(k*(epsc1 - 4*epsn) + 4*epsn) -
05176
05177
05178 4*h*(-1 + k)*(2*n0 - (as1 + as2)*e0c*(epsc1 + 2*epsn))), 2);
05179
05180
05181
05182
05183
05184 epschr4 =(-ac2 + sqrt(pow(ac2, 2) - 4*ac1*ac3))/(2.*ac3);
05185
05186
05187
05188
05189
05190 return epschr4;
05191
05192
05193 }
05194
05195
05196
05197
05198
05199
05200
05201
05202 double normmat::compute_epscmax1 ()
05203
05204
05205 {
05206
05207
05208 double epscmax1;
05209
05210
05211
05212
05213
05214 epscmax1 = epscm - epsn;
05215
05216
05217
05218
05219
05220 return epscmax1;
05221
05222
05223 }
05224
05225
05226
05227
05228
05229
05230
05231
05232 double normmat::compute_epschr4b ()
05233
05234
05235 {
05236
05237
05238 double disk,epschr4b;
05239
05240
05241
05242
05243
05244 disk =(pow(e0c, 2)*
05245
05246
05247 pow(6*b*fc*pow(h, 2)*epsc1 - 9*b*fc*pow(h, 2)*k*epsc1 +
05248
05249
05250 6*as1*d*e0c*k*pow(epsc1, 2) + 6*as2*ch*e0cn*k*pow(epsc1, 2) -
05251
05252
05253 6*as1*e0c*h*k*pow(epsc1, 2) - 6*as2*e0cn*h*k*pow(epsc1, 2) -
05254
05255
05256 8*b*fc*pow(h, 2)*epsn + 8*b*fc*pow(h, 2)*k*epsn, 2) -
05257
05258
05259 4*b*e0c*fc*
05260
05261
05262 pow(h, 2)*(-4 + 4*k)*(6*as2*e0c*fy*h*k*pow(epsc1, 2) -
05263
05264
05265 6*as2*e0cn*fy*h*k*pow(epsc1, 2) + 6*e0c*h*k*n0*pow(epsc1, 2) +
05266
05267
05268 6*b*e0c*fc*pow(h, 2)*epsc1*epsn -
05269
05270
05271 9*b*e0c*fc*pow(h, 2)*k*epsc1*epsn +
05272
05273
05274 6*as1*d*pow(e0c, 2)*k*pow(epsc1, 2)*epsn +
05275
05276
05277 6*as2*ch*e0c*e0cn*k*pow(epsc1, 2)*epsn -
05278
05279
05280 6*as1*pow(e0c, 2)*h*k*pow(epsc1, 2)*epsn -
05281
05282
05283 6*as2*e0c*e0cn*h*k*pow(epsc1, 2)*epsn -
05284
05285
05286 4*b*e0c*fc*pow(h, 2)*pow(epsn, 2) +
05287
05288
05289 4*b*e0c*fc*pow(h, 2)*k*pow(epsn, 2)));
05290
05291
05292
05293
05294
05295 if (disk < 0.0){
05296
05297
05298
05299
05300
05301 epschr4b=-1.0;
05302
05303
05304
05305
05306
05307 }
05308
05309
05310 else{
05311
05312
05313
05314
05315
05316 epschr4b=1/(2.*b*e0c*fc*
05317
05318
05319 pow(h, 2)*(-4 + 4*k))*(-e0c*(6*b*fc*pow(h, 2)*epsc1 -
05320
05321
05322 9*b*fc*pow(h, 2)*k*epsc1 + 6*as1*d*e0c*k*pow(epsc1, 2) +
05323
05324
05325 6*as2*ch*e0cn*k*pow(epsc1, 2) - 6*as1*e0c*h*k*pow(epsc1, 2) -
05326
05327
05328 6*as2*e0cn*h*k*pow(epsc1, 2) - 8*b*fc*pow(h, 2)*epsn +
05329
05330
05331 8*b*fc*pow(h, 2)*k*epsn) -
05332
05333
05334 sqrt(pow(e0c, 2)*
05335
05336
05337 pow(6*b*fc*pow(h, 2)*epsc1 - 9*b*fc*pow(h, 2)*k*epsc1 +
05338
05339
05340 6*as1*d*e0c*k*pow(epsc1, 2) +
05341
05342
05343 6*as2*ch*e0cn*k*pow(epsc1, 2) -
05344
05345
05346 6*as1*e0c*h*k*pow(epsc1, 2) -
05347
05348
05349 6*as2*e0cn*h*k*pow(epsc1, 2) - 8*b*fc*pow(h, 2)*epsn +
05350
05351
05352 8*b*fc*pow(h, 2)*k*epsn, 2) -
05353
05354
05355 4*b*e0c*fc*
05356
05357
05358 pow(h, 2)*(-4 + 4*k)*(6*as2*e0c*fy*h*k*pow(epsc1, 2) -
05359
05360
05361 6*as2*e0cn*fy*h*k*pow(epsc1, 2) +
05362
05363
05364 6*e0c*h*k*n0*pow(epsc1, 2) +
05365
05366
05367 6*b*e0c*fc*pow(h, 2)*epsc1*epsn -
05368
05369
05370 9*b*e0c*fc*pow(h, 2)*k*epsc1*epsn +
05371
05372
05373 6*as1*d*pow(e0c, 2)*k*pow(epsc1, 2)*epsn +
05374
05375
05376 6*as2*ch*e0c*e0cn*k*pow(epsc1, 2)*epsn -
05377
05378
05379 6*as1*pow(e0c, 2)*h*k*pow(epsc1, 2)*epsn -
05380
05381
05382 6*as2*e0c*e0cn*h*k*pow(epsc1, 2)*epsn -
05383
05384
05385 4*b*e0c*fc*pow(h, 2)*pow(epsn, 2) +
05386
05387
05388 4*b*e0c*fc*pow(h, 2)*k*pow(epsn, 2))));
05389
05390
05391
05392
05393
05394 }
05395
05396
05397 return epschr4b;
05398
05399
05400 }
05401
05402
05403
05404
05405
05406
05407
05408
05409 double normmat::compute_epschrk1a ()
05410
05411
05412 {
05413
05414
05415 double epschrk1a;
05416
05417
05418
05419
05420
05421 if ((epscmax1-epschr4b) < 0.0){
05422
05423
05424
05425
05426
05427 epschrk1a=epschr4b;
05428
05429
05430
05431
05432
05433 }
05434
05435
05436 else{
05437
05438
05439
05440
05441
05442 epschrk1a=epscmax1;
05443
05444
05445
05446
05447
05448 }
05449
05450
05451 return epschrk1a;
05452
05453
05454 }
05455
05456
05457
05458
05459
05460
05461
05462
05463 double normmat::compute_mhr4 ()
05464
05465
05466 {
05467
05468
05469 double mhr4;
05470
05471
05472
05473
05474
05475 mhr4 =((12*b*d*fc*pow(h, 2)*epschr4 - 12*b*d*fc*pow(h, 2)*k*epschr4 -
05476
05477
05478 6*b*d*fc*pow(h, 2)*epsc1 + 9*b*d*fc*pow(h, 2)*k*epsc1 +
05479
05480
05481 6*as2*ch*d*e0c*k*pow(epsc1, 2) +
05482
05483
05484 6*as1*pow(d, 2)*e0c*k*pow(epsc1, 2) + 12*b*d*fc*pow(h, 2)*epsn -
05485
05486
05487 12*b*d*fc*pow(h, 2)*k*epsn -
05488
05489
05490 sqrt(3.)*sqrt(pow(d,
05491
05492
05493 2)*(12*pow(as2*ch + as1*d, 2)*pow(e0c, 2)*pow(k, 2)*
05494
05495
05496 pow(epsc1, 4) -
05497
05498
05499 pow(b, 2)*pow(fc, 2)*
05500
05501
05502 pow(h,
05503
05504
05505 4)*(4*(-1 + k)*epschr4 + (6 - 9*k)*epsc1 +
05506
05507
05508 4*(-1 + k)*epsn)*(4*(-1 + k)*epschr4 + (-2 + 3*k)*
05509
05510
05511 epsc1 + 4*(-1 + k)*epsn) +
05512
05513
05514 4*b*fc*pow(h, 2)*k*
05515
05516
05517 pow(epsc1,
05518
05519
05520 2)*(3*(as2*ch + as1*d)*
05521
05522
05523 e0c*(-4*(-1 + k)*epschr4 + (-2 + 3*k)*epsc1 -
05524
05525
05526 4*(-1 + k)*epsn) +
05527
05528
05529 8*h*(-1 +
05530
05531
05532 k)*(-n0 + (as1 + as2)*
05533
05534
05535 e0c*(epschr4 + epsn))))))*(4*b*d*fc*
05536
05537
05538 pow(h, 2)*epschr4 - 4*b*d*fc*pow(h, 2)*k*epschr4 -
05539
05540
05541 2*b*d*fc*pow(h, 2)*epsc1 + 3*b*d*fc*pow(h, 2)*k*epsc1 -
05542
05543
05544 6*as2*ch*d*e0c*k*pow(epsc1, 2) -
05545
05546
05547 6*as1*pow(d, 2)*e0c*k*pow(epsc1, 2) + 4*b*d*fc*pow(h, 2)*epsn -
05548
05549
05550 4*b*d*fc*pow(h, 2)*k*epsn +
05551
05552
05553 sqrt(3.)*sqrt(pow(d,
05554
05555
05556 2)*(12*pow(as2*ch + as1*d, 2)*pow(e0c, 2)*pow(k, 2)*
05557
05558
05559 pow(epsc1, 4) -
05560
05561
05562 pow(b, 2)*pow(fc, 2)*
05563
05564
05565 pow(h,
05566
05567
05568 4)*(4*(-1 + k)*epschr4 + (6 - 9*k)*epsc1 +
05569
05570
05571 4*(-1 + k)*epsn)*(4*(-1 + k)*epschr4 + (-2 + 3*k)*
05572
05573
05574 epsc1 + 4*(-1 + k)*epsn) +
05575
05576
05577 4*b*fc*pow(h, 2)*k*
05578
05579
05580 pow(epsc1,
05581
05582
05583 2)*(3*(as2*ch + as1*d)*
05584
05585
05586 e0c*(-4*(-1 + k)*epschr4 + (-2 + 3*k)*epsc1 -
05587
05588
05589 4*(-1 + k)*epsn) +
05590
05591
05592 8*h*(-1 +
05593
05594
05595 k)*(-n0 + (as1 + as2)*
05596
05597
05598 e0c*(epschr4 + epsn)))))))/(384.*b*
05599
05600
05601 pow(d, 2)*fc*pow(h, 2)*(-1 + k)*k*pow(epsc1, 2)) + (as1*
05602
05603
05604 e0c*(-2*cd +
05605
05606
05607 h)*(epsn + (6*d*(as2*ch + as1*d)*e0c*k*pow(epsc1, 2) +
05608
05609
05610 b*fc*pow(h,
05611
05612
05613 2)*(8*h*(-1 + k)*epschr4 -
05614
05615
05616 3*d*(4*(-1 + k)*epschr4 + (2 - 3*k)*epsc1 +
05617
05618
05619 4*(-1 + k)*epsn)) -
05620
05621
05622 sqrt(3.)*
05623
05624
05625 sqrt(pow(d,
05626
05627
05628 2)*(12*pow(as2*ch + as1*d, 2)*pow(e0c, 2)*pow(k, 2)*
05629
05630
05631 pow(epsc1, 4) -
05632
05633
05634 pow(b, 2)*pow(fc, 2)*
05635
05636
05637 pow(h,
05638
05639
05640 4)*(4*(-1 + k)*epschr4 + (6 - 9*k)*epsc1 +
05641
05642
05643 4*(-1 + k)*epsn)*(4*(-1 + k)*
05644
05645
05646 epschr4 + (-2 + 3*k)*epsc1 +
05647
05648
05649 4*(-1 + k)*epsn) +
05650
05651
05652 4*b*fc*pow(h, 2)*k*
05653
05654
05655 pow(epsc1,
05656
05657
05658 2)*(3*(as2*ch + as1*d)*
05659
05660
05661 e0c*(-4*(-1 + k)*epschr4 + (-2 + 3*k)*
05662
05663
05664 epsc1 - 4*(-1 + k)*epsn) +
05665
05666
05667 8*h*(-1 +
05668
05669
05670 k)*(-n0 + (as1 + as2)*
05671
05672
05673 e0c*(epschr4 + epsn))))))/(8.*b*fc*
05674
05675
05676 pow(h, 3)*(-1 + k))))/
05677
05678
05679 2. - (as2*
05680
05681
05682 e0c*(-2*ch + h)*(epschr4 - (ch*epschr4)/d +
05683
05684
05685 epsn + (ch*(6*d*(as2*ch + as1*d)*e0c*k*pow(epsc1, 2) +
05686
05687
05688 b*fc*pow(h,
05689
05690
05691 2)*(8*h*(-1 + k)*epschr4 -
05692
05693
05694 3*d*(4*(-1 + k)*epschr4 + (2 - 3*k)*epsc1 +
05695
05696
05697 4*(-1 + k)*epsn)) -
05698
05699
05700 sqrt(3.)*
05701
05702
05703 sqrt(pow(d,
05704
05705
05706 2)*(12*pow(as2*ch + as1*d, 2)*pow(e0c, 2)*
05707
05708
05709 pow(k, 2)*pow(epsc1, 4) -
05710
05711
05712 pow(b, 2)*pow(fc, 2)*
05713
05714
05715 pow(h,
05716
05717
05718 4)*(4*(-1 + k)*epschr4 + (6 - 9*k)*
05719
05720
05721 epsc1 +
05722
05723
05724 4*(-1 + k)*epsn)*(4*(-1 + k)*
05725
05726
05727 epschr4 + (-2 + 3*k)*epsc1 +
05728
05729
05730 4*(-1 + k)*epsn) +
05731
05732
05733 4*b*fc*pow(h, 2)*k*
05734
05735
05736 pow(epsc1,
05737
05738
05739 2)*(3*(as2*ch + as1*d)*
05740
05741
05742 e0c*(-4*(-1 + k)*epschr4 + (-2 + 3*k)*
05743
05744
05745 epsc1 - 4*(-1 + k)*epsn) +
05746
05747
05748 8*h*(-1 +
05749
05750
05751 k)*(-n0 + (as1 + as2)*
05752
05753
05754 e0c*(epschr4 + epsn)))))))/(8.*b*d*fc*
05755
05756
05757 pow(h, 3)*(-1 + k))))/2. + e0c*(-(as1*(-cd + h/2.)) + as2*(-ch + h/2.))*epsn;
05758
05759
05760
05761
05762
05763 return mhr4;
05764
05765
05766 }
05767
05768
05769
05770
05771
05772
05773
05774
05775 double normmat::compute_mhr4b ()
05776
05777
05778
05779
05780
05781 {
05782
05783
05784 double mhr4b;
05785
05786
05787
05788
05789
05790
05791
05792
05793 if (epschr4b < 0.0 && epschr4b!=-1.0){
05794
05795
05796
05797
05798
05799 mhr4b=1/(384.*b*pow(d, 2)*pow(e0c, 2)*fc*pow(h, 2)*(-1 + k)*k*
05800
05801
05802 pow(epsc1, 2))*((-6*b*d*e0c*fc*pow(h, 2)*epsc1 +
05803
05804
05805 9*b*d*e0c*fc*pow(h, 2)*k*epsc1 +
05806
05807
05808 6*as1*pow(d, 2)*pow(e0c, 2)*k*pow(epsc1, 2) +
05809
05810
05811 6*as2*ch*d*e0c*e0cn*k*pow(epsc1, 2) +
05812
05813
05814 12*b*d*e0c*fc*pow(h, 2)*epschr4b -
05815
05816
05817 12*b*d*e0c*fc*pow(h, 2)*k*epschr4b +
05818
05819
05820 12*b*d*e0c*fc*pow(h, 2)*epsn - 12*b*d*e0c*fc*pow(h, 2)*k*epsn -
05821
05822
05823 sqrt(e0c*(e0c*
05824
05825
05826 pow(6*d*(as1*d*e0c + as2*ch*e0cn)*k*pow(epsc1, 2) +
05827
05828
05829 b*fc*pow(h,
05830
05831
05832 2)*(8*h*(-1 + k)*epschr4b -
05833
05834
05835 3*d*((2 - 3*k)*epsc1 +
05836
05837
05838 4*(-1 + k)*epschr4b +
05839
05840
05841 4*(-1 + k)*epsn)), 2) +
05842
05843
05844 16*b*fc*
05845
05846
05847 pow(h,
05848
05849
05850 3)*(-1 +
05851
05852
05853 k)*(b*e0c*fc*
05854
05855
05856 h*(-4*pow(h, 2)*(-1 + k)*pow(epschr4b, 2) -
05857
05858
05859 6*pow(d,
05860
05861
05862 2)*(epschr4b + epsn)*((2 - 3*k)*epsc1 +
05863
05864
05865 2*(-1 + k)*epschr4b +
05866
05867
05868 2*(-1 + k)*epsn) +
05869
05870
05871 3*d*h*
05872
05873
05874 epschr4b*((2 - 3*k)*epsc1 +
05875
05876
05877 4*(-1 + k)*epschr4b +
05878
05879
05880 4*(-1 + k)*epsn)) +
05881
05882
05883 6*d*k*pow(epsc1,
05884
05885
05886 2)*(d*e0c*(-n0 + as1*e0c*epsn) +
05887
05888
05889 as2*(-ch*e0c*e0cn*epschr4b +
05890
05891
05892 d*(e0cn*fy +
05893
05894
05895 e0c*(-fy + e0cn*(epschr4b +
05896
05897
05898 epsn)))))))))*(-2*b*d*e0c*fc*
05899
05900
05901 pow(h, 2)*epsc1 + 3*b*d*e0c*fc*pow(h, 2)*k*epsc1 -
05902
05903
05904 6*as1*pow(d, 2)*pow(e0c, 2)*k*pow(epsc1, 2) -
05905
05906
05907 6*as2*ch*d*e0c*e0cn*k*pow(epsc1, 2) +
05908
05909
05910 4*b*d*e0c*fc*pow(h, 2)*epschr4b -
05911
05912
05913 4*b*d*e0c*fc*pow(h, 2)*k*epschr4b + 4*b*d*e0c*fc*pow(h, 2)*epsn -
05914
05915
05916 4*b*d*e0c*fc*pow(h, 2)*k*epsn +
05917
05918
05919 sqrt(e0c*(e0c*
05920
05921
05922 pow(6*d*(as1*d*e0c + as2*ch*e0cn)*k*pow(epsc1, 2) +
05923
05924
05925 b*fc*pow(h,
05926
05927
05928 2)*(8*h*(-1 + k)*epschr4b -
05929
05930
05931 3*d*((2 - 3*k)*epsc1 +
05932
05933
05934 4*(-1 + k)*epschr4b +
05935
05936
05937 4*(-1 + k)*epsn)), 2) +
05938
05939
05940 16*b*fc*
05941
05942
05943 pow(h,
05944
05945
05946 3)*(-1 +
05947
05948
05949 k)*(b*e0c*fc*
05950
05951
05952 h*(-4*pow(h, 2)*(-1 + k)*pow(epschr4b, 2) -
05953
05954
05955 6*pow(d,
05956
05957
05958 2)*(epschr4b + epsn)*((2 - 3*k)*epsc1 +
05959
05960
05961 2*(-1 + k)*epschr4b +
05962
05963
05964 2*(-1 + k)*epsn) +
05965
05966
05967 3*d*h*
05968
05969
05970 epschr4b*((2 - 3*k)*epsc1 +
05971
05972
05973 4*(-1 + k)*epschr4b +
05974
05975
05976 4*(-1 + k)*epsn)) +
05977
05978
05979 6*d*k*pow(epsc1,
05980
05981
05982 2)*(d*e0c*(-n0 + as1*e0c*epsn) +
05983
05984
05985 as2*(-ch*e0c*e0cn*epschr4b +
05986
05987
05988 d*(e0cn*fy +
05989
05990
05991 e0c*(-fy + e0cn*(epschr4b +
05992
05993
05994 epsn)))))))))) +
05995
05996
05997 0.5*as1*e0c*(-2*cd + h)*(epsn +
05998
05999
06000 1/(8.*b*e0c*fc*pow(h, 3)*(-1 + k))*(6*d*e0c*(as1*d*e0c + as2*ch*e0cn)*
06001
06002
06003 k*pow(epsc1, 2) +
06004
06005
06006 b*e0c*fc*
06007
06008
06009 pow(h, 2)*(8*h*(-1 + k)*epschr4b -
06010
06011
06012 3*d*((2 - 3*k)*epsc1 + 4*(-1 + k)*epschr4b +
06013
06014
06015 4*(-1 + k)*epsn)) -
06016
06017
06018 sqrt(e0c*(e0c*
06019
06020
06021 pow(6*d*(as1*d*e0c + as2*ch*e0cn)*k*pow(epsc1, 2) +
06022
06023
06024 b*fc*pow(h,
06025
06026
06027 2)*(8*h*(-1 + k)*epschr4b -
06028
06029
06030 3*d*((2 - 3*k)*epsc1 +
06031
06032
06033 4*(-1 + k)*epschr4b +
06034
06035
06036 4*(-1 + k)*epsn)), 2) +
06037
06038
06039 16*b*fc*
06040
06041
06042 pow(h,
06043
06044
06045 3)*(-1 +
06046
06047
06048 k)*(b*e0c*fc*
06049
06050
06051 h*(-4*pow(h, 2)*(-1 + k)*pow(epschr4b, 2) -
06052
06053
06054 6*pow(d,
06055
06056
06057 2)*(epschr4b +
06058
06059
06060 epsn)*((2 - 3*k)*epsc1 +
06061
06062
06063 2*(-1 + k)*epschr4b +
06064
06065
06066 2*(-1 + k)*epsn) +
06067
06068
06069 3*d*h*
06070
06071
06072 epschr4b*((2 - 3*k)*epsc1 +
06073
06074
06075 4*(-1 + k)*epschr4b +
06076
06077
06078 4*(-1 + k)*epsn)) +
06079
06080
06081 6*d*k*pow(epsc1,
06082
06083
06084 2)*(d*e0c*(-n0 + as1*e0c*epsn) +
06085
06086
06087 as2*(-ch*e0c*e0cn*epschr4b +
06088
06089
06090 d*(e0cn*fy +
06091
06092
06093 e0c*(-fy + e0cn*(epschr4b +
06094
06095
06096 epsn)))))))))) +
06097
06098
06099 0.5*as2*(-2*ch + h)*(fy -
06100
06101
06102 e0cn*(fy/e0c + epschr4b - (ch*epschr4b)/d + epsn +
06103
06104
06105 1/(8.*b*d*e0c*fc*
06106
06107
06108 pow(h, 3)*(-1 + k))*(ch*(6*d*
06109
06110
06111 e0c*(as1*d*e0c + as2*ch*e0cn)*k*pow(epsc1, 2) +
06112
06113
06114 b*e0c*fc*
06115
06116
06117 pow(h,
06118
06119
06120 2)*(8*h*(-1 + k)*epschr4b -
06121
06122
06123 3*d*((2 - 3*k)*epsc1 + 4*(-1 + k)*epschr4b +
06124
06125
06126 4*(-1 + k)*epsn)) -
06127
06128
06129 sqrt(e0c*(e0c*
06130
06131
06132 pow(6*d*(as1*d*e0c + as2*ch*e0cn)*k*
06133
06134
06135 pow(epsc1, 2) +
06136
06137
06138 b*fc*
06139
06140
06141 pow(h,
06142
06143
06144 2)*(8*h*(-1 + k)*epschr4b -
06145
06146
06147 3*d*((2 - 3*k)*epsc1 +
06148
06149
06150 4*(-1 + k)*epschr4b +
06151
06152
06153 4*(-1 + k)*epsn)), 2) +
06154
06155
06156 16*b*fc*
06157
06158
06159 pow(h,
06160
06161
06162 3)*(-1 +
06163
06164
06165 k)*(b*e0c*fc*
06166
06167
06168 h*(-4*pow(h, 2)*(-1 + k)*
06169
06170
06171 pow(epschr4b, 2) -
06172
06173
06174 6*pow(d, 2)*(epschr4b +
06175
06176
06177 epsn)*((2 - 3*k)*epsc1 +
06178
06179
06180 2*(-1 + k)*epschr4b +
06181
06182
06183 2*(-1 + k)*epsn) +
06184
06185
06186 3*d*h*epschr4b*((2 - 3*k)*epsc1 +
06187
06188
06189 4*(-1 + k)*epschr4b +
06190
06191
06192 4*(-1 + k)*epsn)) +
06193
06194
06195 6*d*k*
06196
06197
06198 pow(epsc1,
06199
06200
06201 2)*(d*e0c*(-n0 + as1*e0c*epsn) +
06202
06203
06204 as2*(-ch*e0c*e0cn*epschr4b +
06205
06206
06207 d*(e0cn*fy + e0c*(-fy +
06208
06209
06210 e0cn*(epschr4b + epsn)))))))))))) + e0c*(-(as1*(-cd + h/2.)) + as2*(-ch + h/2.))*epsn;
06211
06212
06213
06214
06215
06216 }
06217
06218
06219 else{
06220
06221
06222 mhr4b=1000000000.0;
06223
06224
06225 }
06226
06227
06228 return mhr4b;
06229
06230
06231 }
06232
06233
06234
06235
06236
06237
06238
06239
06240 double normmat::compute_epscmax1p ()
06241
06242
06243 {
06244
06245
06246 double disk,epscmax1p;
06247
06248
06249
06250
06251
06252 disk =e0c*(e0c*pow(6*d*(as1*d*e0c + as2*ch*e0cn)*k*pow(epsc1, 2) +
06253
06254
06255 b*fc*pow(h,
06256
06257
06258 2)*(8*h*(-1 + k)*epscmax1 -
06259
06260
06261 3*d*((2 - 3*k)*epsc1 + 4*(-1 + k)*epscmax1 +
06262
06263
06264 4*(-1 + k)*epsn)), 2) +
06265
06266
06267 16*b*fc*pow(h,
06268
06269
06270 3)*(-1 +
06271
06272
06273 k)*(b*e0c*fc*
06274
06275
06276 h*(-4*pow(h, 2)*(-1 + k)*pow(epscmax1, 2) -
06277
06278
06279 6*pow(d,
06280
06281
06282 2)*(epscmax1 + epsn)*((2 - 3*k)*epsc1 +
06283
06284
06285 2*(-1 + k)*epscmax1 + 2*(-1 + k)*epsn) +
06286
06287
06288 3*d*h*epscmax1*((2 - 3*k)*epsc1 + 4*(-1 + k)*epscmax1 +
06289
06290
06291 4*(-1 + k)*epsn)) +
06292
06293
06294 6*d*k*pow(epsc1,
06295
06296
06297 2)*(d*e0c*(-n0 + as1*e0c*epsn) +
06298
06299
06300 as2*(-(ch*e0c*e0cn*epscmax1) +
06301
06302
06303 d*(e0cn*fy + e0c*(-fy + e0cn*(epscmax1 + epsn)))))));
06304
06305
06306
06307
06308
06309 if (disk < 0.0){
06310
06311
06312
06313
06314
06315 epscmax1p=1/(4.*b*sqrt(e0c)*fc*pow(h, 2)*(-1 + k))*(-2*epsc1*
06316
06317
06318 sqrt(pow(b, 2)*e0c*pow(fc, 2)*pow(h, 4)*pow(2 - 3*k, 2) +
06319
06320
06321 4*e0c*(3*pow(as1*d*e0c + as2*ch*e0cn, 2) -
06322
06323
06324 3*(as1*e0c + as2*e0cn)*(as1*d*e0c + as2*ch*e0cn)*h +
06325
06326
06327 pow(as1*e0c + as2*e0cn, 2)*pow(h, 2))*pow(k, 2)*
06328
06329
06330 pow(epsc1, 2) +
06331
06332
06333 2*b*fc*pow(h, 3)*
06334
06335
06336 k*(-4*(-1 + k)*(as2*(e0c - e0cn)*fy + e0c*n0) +
06337
06338
06339 e0c*(as1*e0c + as2*e0cn)*(-2 + 3*k)*epsc1)) +
06340
06341
06342 sqrt(e0c)*(2*(-3*as1*d*e0c - 3*as2*ch*e0cn + 2*as1*e0c*h +
06343
06344
06345 2*as2*e0cn*h)*k*pow(epsc1, 2) +
06346
06347
06348 b*fc*pow(h, 2)*((-2 + 3*k)*epsc1 - 4*(-1 + k)*epsn))) + 1.e-6;
06349
06350
06351
06352
06353
06354 }
06355
06356
06357 else{
06358
06359
06360 epscmax1p=epscmax1;
06361
06362
06363 }
06364
06365
06366 return epscmax1p;
06367
06368
06369 }
06370
06371
06372
06373
06374
06375
06376
06377
06378 double normmat::compute_mmax1a ()
06379
06380
06381 {
06382
06383
06384 double mmax1a;
06385
06386
06387
06388
06389
06390 mmax1a =((-6*b*d*e0c*fc*pow(h, 2)*epsc1 + 9*b*d*e0c*fc*pow(h, 2)*k*epsc1 +
06391
06392
06393 6*as1*pow(d, 2)*pow(e0c, 2)*k*pow(epsc1, 2) +
06394
06395
06396 6*as2*ch*d*e0c*e0cn*k*pow(epsc1, 2) +
06397
06398
06399 12*b*d*e0c*fc*pow(h, 2)*epscmax1p -
06400
06401
06402 12*b*d*e0c*fc*pow(h, 2)*k*epscmax1p +
06403
06404
06405 12*b*d*e0c*fc*pow(h, 2)*epsn - 12*b*d*e0c*fc*pow(h, 2)*k*epsn -
06406
06407
06408 sqrt(e0c*(e0c*
06409
06410
06411 pow(6*d*(as1*d*e0c + as2*ch*e0cn)*k*pow(epsc1, 2) +
06412
06413
06414 b*fc*pow(h,
06415
06416
06417 2)*(8*h*(-1 + k)*epscmax1p -
06418
06419
06420 3*d*((2 - 3*k)*epsc1 +
06421
06422
06423 4*(-1 + k)*epscmax1p +
06424
06425
06426 4*(-1 + k)*epsn)), 2) +
06427
06428
06429 16*b*fc*
06430
06431
06432 pow(h,
06433
06434
06435 3)*(-1 +
06436
06437
06438 k)*(b*e0c*fc*
06439
06440
06441 h*(-4*pow(h, 2)*(-1 + k)*pow(epscmax1p, 2) -
06442
06443
06444 6*pow(d,
06445
06446
06447 2)*(epscmax1p +
06448
06449
06450 epsn)*((2 - 3*k)*epsc1 +
06451
06452
06453 2*(-1 + k)*epscmax1p +
06454
06455
06456 2*(-1 + k)*epsn) +
06457
06458
06459 3*d*h*
06460
06461
06462 epscmax1p*((2 - 3*k)*epsc1 +
06463
06464
06465 4*(-1 + k)*epscmax1p +
06466
06467
06468 4*(-1 + k)*epsn)) +
06469
06470
06471 6*d*k*pow(epsc1,
06472
06473
06474 2)*(d*e0c*(-n0 + as1*e0c*epsn) +
06475
06476
06477 as2*(-(ch*e0c*e0cn*epscmax1p) +
06478
06479
06480 d*(e0cn*fy +
06481
06482
06483 e0c*(-fy + e0cn*(epscmax1p +
06484
06485
06486 epsn)))))))))*(-2*b*d*e0c*fc*
06487
06488
06489 pow(h, 2)*epsc1 + 3*b*d*e0c*fc*pow(h, 2)*k*epsc1 -
06490
06491
06492 6*as1*pow(d, 2)*pow(e0c, 2)*k*pow(epsc1, 2) -
06493
06494
06495 6*as2*ch*d*e0c*e0cn*k*pow(epsc1, 2) +
06496
06497
06498 4*b*d*e0c*fc*pow(h, 2)*epscmax1p -
06499
06500
06501 4*b*d*e0c*fc*pow(h, 2)*k*epscmax1p +
06502
06503
06504 4*b*d*e0c*fc*pow(h, 2)*epsn - 4*b*d*e0c*fc*pow(h, 2)*k*epsn +
06505
06506
06507 sqrt(e0c*(e0c*
06508
06509
06510 pow(6*d*(as1*d*e0c + as2*ch*e0cn)*k*pow(epsc1, 2) +
06511
06512
06513 b*fc*pow(h,
06514
06515
06516 2)*(8*h*(-1 + k)*epscmax1p -
06517
06518
06519 3*d*((2 - 3*k)*epsc1 +
06520
06521
06522 4*(-1 + k)*epscmax1p +
06523
06524
06525 4*(-1 + k)*epsn)), 2) +
06526
06527
06528 16*b*fc*
06529
06530
06531 pow(h,
06532
06533
06534 3)*(-1 +
06535
06536
06537 k)*(b*e0c*fc*
06538
06539
06540 h*(-4*pow(h, 2)*(-1 + k)*pow(epscmax1p, 2) -
06541
06542
06543 6*pow(d,
06544
06545
06546 2)*(epscmax1p +
06547
06548
06549 epsn)*((2 - 3*k)*epsc1 +
06550
06551
06552 2*(-1 + k)*epscmax1p +
06553
06554
06555 2*(-1 + k)*epsn) +
06556
06557
06558 3*d*h*
06559
06560
06561 epscmax1p*((2 - 3*k)*epsc1 +
06562
06563
06564 4*(-1 + k)*epscmax1p +
06565
06566
06567 4*(-1 + k)*epsn)) +
06568
06569
06570 6*d*k*pow(epsc1,
06571
06572
06573 2)*(d*e0c*(-n0 + as1*e0c*epsn) +
06574
06575
06576 as2*(-(ch*e0c*e0cn*epscmax1p) +
06577
06578
06579 d*(e0cn*fy +
06580
06581
06582 e0c*(-fy + e0cn*(epscmax1p +
06583
06584
06585 epsn))))))))))/(384.*b*pow(d, 2)*
06586
06587
06588 pow(e0c, 2)*fc*pow(h, 2)*(-1 + k)*k*pow(epsc1, 2)) + (as1*
06589
06590
06591 e0c*(-2*cd +
06592
06593
06594 h)*(epsn + (6*d*e0c*(as1*d*e0c + as2*ch*e0cn)*k*pow(epsc1, 2) +
06595
06596
06597 b*e0c*fc*
06598
06599
06600 pow(h,
06601
06602
06603 2)*(8*h*(-1 + k)*epscmax1p -
06604
06605
06606 3*d*((2 - 3*k)*epsc1 + 4*(-1 + k)*epscmax1p +
06607
06608
06609 4*(-1 + k)*epsn)) -
06610
06611
06612 sqrt(e0c*(e0c*
06613
06614
06615 pow(6*d*(as1*d*e0c + as2*ch*e0cn)*k*
06616
06617
06618 pow(epsc1, 2) +
06619
06620
06621 b*fc*pow(h,
06622
06623
06624 2)*(8*h*(-1 + k)*epscmax1p -
06625
06626
06627 3*d*((2 - 3*k)*epsc1 +
06628
06629
06630 4*(-1 + k)*epscmax1p +
06631
06632
06633 4*(-1 + k)*epsn)), 2) +
06634
06635
06636 16*b*fc*
06637
06638
06639 pow(h,
06640
06641
06642 3)*(-1 +
06643
06644
06645 k)*(b*e0c*fc*
06646
06647
06648 h*(-4*pow(h, 2)*(-1 + k)*
06649
06650
06651 pow(epscmax1p, 2) -
06652
06653
06654 6*pow(d,
06655
06656
06657 2)*(epscmax1p +
06658
06659
06660 epsn)*((2 - 3*k)*epsc1 +
06661
06662
06663 2*(-1 + k)*epscmax1p +
06664
06665
06666 2*(-1 + k)*epsn) +
06667
06668
06669 3*d*h*
06670
06671
06672 epscmax1p*((2 - 3*k)*epsc1 +
06673
06674
06675 4*(-1 + k)*epscmax1p +
06676
06677
06678 4*(-1 + k)*epsn)) +
06679
06680
06681 6*d*k*
06682
06683
06684 pow(epsc1,
06685
06686
06687 2)*(d*e0c*(-n0 + as1*e0c*epsn) +
06688
06689
06690 as2*(-(ch*e0c*e0cn*epscmax1p) +
06691
06692
06693 d*(e0cn*fy +
06694
06695
06696 e0c*(-fy + e0cn*(epscmax1p +
06697
06698
06699 epsn)))))))))/(8.*b*e0c*fc*
06700
06701
06702 pow(h, 3)*(-1 + k))))/
06703
06704
06705 2. + (as2*(-2*ch + h)*(fy -
06706
06707
06708 e0cn*(fy/e0c + epscmax1p - (ch*epscmax1p)/d +
06709
06710
06711 epsn + (ch*(6*d*e0c*(as1*d*e0c + as2*ch*e0cn)*k*
06712
06713
06714 pow(epsc1, 2) +
06715
06716
06717 b*e0c*fc*
06718
06719
06720 pow(h,
06721
06722
06723 2)*(8*h*(-1 + k)*epscmax1p -
06724
06725
06726 3*d*((2 - 3*k)*epsc1 +
06727
06728
06729 4*(-1 + k)*epscmax1p +
06730
06731
06732 4*(-1 + k)*epsn)) -
06733
06734
06735 sqrt(e0c*(e0c*
06736
06737
06738 pow(6*d*(as1*d*e0c + as2*ch*e0cn)*k*
06739
06740
06741 pow(epsc1, 2) +
06742
06743
06744 b*fc*pow(h,
06745
06746
06747 2)*(8*h*(-1 + k)*epscmax1p -
06748
06749
06750 3*d*((2 - 3*k)*epsc1 +
06751
06752
06753 4*(-1 + k)*epscmax1p +
06754
06755
06756 4*(-1 + k)*epsn)), 2) +
06757
06758
06759 16*b*fc*
06760
06761
06762 pow(h,
06763
06764
06765 3)*(-1 +
06766
06767
06768 k)*(b*e0c*fc*
06769
06770
06771 h*(-4*pow(h, 2)*(-1 + k)*
06772
06773
06774 pow(epscmax1p, 2) -
06775
06776
06777 6*pow(d, 2)*(epscmax1p +
06778
06779
06780 epsn)*((2 - 3*k)*epsc1 +
06781
06782
06783 2*(-1 + k)*epscmax1p +
06784
06785
06786 2*(-1 + k)*epsn) +
06787
06788
06789 3*d*h*epscmax1p*((2 - 3*k)*epsc1 +
06790
06791
06792 4*(-1 + k)*epscmax1p +
06793
06794
06795 4*(-1 + k)*epsn)) +
06796
06797
06798 6*d*k*
06799
06800
06801 pow(epsc1,
06802
06803
06804 2)*(d*e0c*(-n0 + as1*e0c*epsn) +
06805
06806
06807 as2*(-(ch*e0c*e0cn*epscmax1p) +
06808
06809
06810 d*(e0cn*fy + e0c*(-fy +
06811
06812
06813 e0cn*(epscmax1p + epsn))))))))))/(8.*
06814
06815
06816 b*d*e0c*fc*pow(h, 3)*(-1 + k)))))/2. + e0c*(-(as1*(-cd + h/2.)) + as2*(-ch + h/2.))*epsn;
06817
06818
06819
06820
06821
06822 return mmax1a;
06823
06824
06825 }
06826
06827
06828
06829
06830
06831
06832
06833
06834 double normmat::compute_mh1 ()
06835
06836
06837 {
06838
06839
06840 double mh1;
06841
06842
06843
06844
06845
06846 if ((mhr1-mhr4) > 0.0){
06847
06848
06849
06850
06851
06852 mh1=mhr4;
06853
06854
06855
06856
06857
06858 }
06859
06860
06861 else{
06862
06863
06864 mh1=mhr1;
06865
06866
06867 }
06868
06869
06870 return mh1;
06871
06872
06873 }
06874
06875
06876
06877
06878
06879
06880
06881
06882 double normmat::compute_epsch1 ()
06883
06884
06885 {
06886
06887
06888 double epsch1;
06889
06890
06891
06892
06893
06894 if ((mhr1-mhr4) > 0.0){
06895
06896
06897
06898
06899
06900 epsch1=epschr4;
06901
06902
06903
06904
06905
06906 }
06907
06908
06909 else{
06910
06911
06912 epsch1=epschr1;
06913
06914
06915 }
06916
06917
06918 return epsch1;
06919
06920
06921 }
06922
06923
06924
06925
06926
06927
06928
06929
06930 double normmat::compute_mh1hrk1a ()
06931
06932
06933 {
06934
06935
06936 double mh1hrk1a;
06937
06938
06939
06940
06941
06942 mh1hrk1a =(-24*as1*(2*cd - h)*(6*as1*pow(d, 2)*pow(e0c, 2)*k*pow(epsc1, 2) +
06943
06944
06945 6*as2*ch*d*e0c*e0cn*k*pow(epsc1, 2) +
06946
06947
06948 b*e0c*fc*
06949
06950
06951 pow(h, 2)*(4*h*(-1 + k)*(epsch1 + epschrk1a + 2*epsn) +
06952
06953
06954 3*d*((-2 + 3*k)*epsc1 -
06955
06956
06957 2*(-1 + k)*(epsch1 + epschrk1a + 2*epsn))) -
06958
06959
06960 sqrt(e0c*(e0c*
06961
06962
06963 pow(6*d*(as1*d*e0c + as2*ch*e0cn)*k*pow(epsc1, 2) +
06964
06965
06966 b*fc*pow(h,
06967
06968
06969 2)*(4*h*(-1 + k)*(epsch1 + epschrk1a) +
06970
06971
06972 3*d*((-2 + 3*k)*epsc1 -
06973
06974
06975 2*(-1 + k)*(epsch1 + epschrk1a +
06976
06977
06978 2*epsn))), 2) +
06979
06980
06981 16*b*fc*
06982
06983
06984 pow(h,
06985
06986
06987 3)*(-1 +
06988
06989
06990 k)*(b*e0c*fc*
06991
06992
06993 h*(-(pow(h, 2)*(-1 + k)*
06994
06995
06996 pow(epsch1 + epschrk1a, 2)) -
06997
06998
06999 3*pow(d,
07000
07001
07002 2)*(epsch1 + epschrk1a +
07003
07004
07005 2*epsn)*((2 - 3*k)*
07006
07007
07008 epsc1 + (-1 + k)*(epsch1 +
07009
07010
07011 epschrk1a + 2*epsn)) + (3*d*
07012
07013
07014 h*(epsch1 +
07015
07016
07017 epschrk1a)*((2 - 3*k)*epsc1 +
07018
07019
07020 2*(-1 + k)*(epsch1 + epschrk1a +
07021
07022
07023 2*epsn)))/2.) +
07024
07025
07026 6*d*k*pow(epsc1,
07027
07028
07029 2)*(d*
07030
07031
07032 e0c*(-n0 +
07033
07034
07035 as1*e0c*
07036
07037
07038 epsn) - (as2*(ch*e0c*
07039
07040
07041 e0cn*(epsch1 + epschrk1a) +
07042
07043
07044 d*(-2*e0cn*fy +
07045
07046
07047 e0c*(2*fy - e0cn*(epsch1 +
07048
07049
07050 epschrk1a + 2*epsn)))))/
07051
07052
07053 2.))))) + (h*(6*as1*pow(d, 2)*pow(e0c, 2)*
07054
07055
07056 k*pow(epsc1, 2) + 6*as2*ch*d*e0c*e0cn*k*pow(epsc1, 2) +
07057
07058
07059 3*b*d*e0c*fc*
07060
07061
07062 pow(h, 2)*((-2 + 3*k)*epsc1 -
07063
07064
07065 2*(-1 + k)*(epsch1 + epschrk1a + 2*epsn)) -
07066
07067
07068 sqrt(e0c*(e0c*
07069
07070
07071 pow(6*d*(as1*d*e0c + as2*ch*e0cn)*k*
07072
07073
07074 pow(epsc1, 2) +
07075
07076
07077 b*fc*pow(h,
07078
07079
07080 2)*(4*h*(-1 + k)*(epsch1 + epschrk1a) +
07081
07082
07083 3*d*((-2 + 3*k)*epsc1 -
07084
07085
07086 2*(-1 + k)*(epsch1 + epschrk1a +
07087
07088
07089 2*epsn))), 2) +
07090
07091
07092 16*b*fc*
07093
07094
07095 pow(h,
07096
07097
07098 3)*(-1 +
07099
07100
07101 k)*(b*e0c*fc*
07102
07103
07104 h*(-(pow(h, 2)*(-1 + k)*
07105
07106
07107 pow(epsch1 + epschrk1a, 2)) -
07108
07109
07110 3*pow(d,
07111
07112
07113 2)*(epsch1 + epschrk1a +
07114
07115
07116 2*epsn)*((2 - 3*k)*
07117
07118
07119 epsc1 + (-1 + k)*(epsch1 +
07120
07121
07122 epschrk1a + 2*epsn)) + (3*d*
07123
07124
07125 h*(epsch1 +
07126
07127
07128 epschrk1a)*((2 - 3*k)*epsc1 +
07129
07130
07131 2*(-1 + k)*(epsch1 + epschrk1a +
07132
07133
07134 2*epsn)))/2.) +
07135
07136
07137 6*d*k*
07138
07139
07140 pow(epsc1,
07141
07142
07143 2)*(d*
07144
07145
07146 e0c*(-n0 +
07147
07148
07149 as1*e0c*
07150
07151
07152 epsn) - (as2*(ch*e0c*
07153
07154
07155 e0cn*(epsch1 + epschrk1a) +
07156
07157
07158 d*(-2*e0cn*fy +
07159
07160
07161 e0c*(2*fy - e0cn*(epsch1 +
07162
07163
07164 epschrk1a + 2*epsn)))))/2.)))))*(-6*
07165
07166
07167 as1*pow(d, 2)*pow(e0c, 2)*k*pow(epsc1, 2) -
07168
07169
07170 6*as2*ch*d*e0c*e0cn*k*pow(epsc1, 2) +
07171
07172
07173 b*d*e0c*fc*
07174
07175
07176 pow(h, 2)*((-2 + 3*k)*epsc1 -
07177
07178
07179 2*(-1 + k)*(epsch1 + epschrk1a + 2*epsn)) +
07180
07181
07182 sqrt(e0c*(e0c*
07183
07184
07185 pow(6*d*(as1*d*e0c + as2*ch*e0cn)*k*
07186
07187
07188 pow(epsc1, 2) +
07189
07190
07191 b*fc*pow(h,
07192
07193
07194 2)*(4*h*(-1 + k)*(epsch1 + epschrk1a) +
07195
07196
07197 3*d*((-2 + 3*k)*epsc1 -
07198
07199
07200 2*(-1 + k)*(epsch1 + epschrk1a +
07201
07202
07203 2*epsn))), 2) +
07204
07205
07206 16*b*fc*
07207
07208
07209 pow(h,
07210
07211
07212 3)*(-1 +
07213
07214
07215 k)*(b*e0c*fc*
07216
07217
07218 h*(-(pow(h, 2)*(-1 + k)*
07219
07220
07221 pow(epsch1 + epschrk1a, 2)) -
07222
07223
07224 3*pow(d,
07225
07226
07227 2)*(epsch1 + epschrk1a +
07228
07229
07230 2*epsn)*((2 - 3*k)*
07231
07232
07233 epsc1 + (-1 + k)*(epsch1 +
07234
07235
07236 epschrk1a + 2*epsn)) + (3*d*
07237
07238
07239 h*(epsch1 +
07240
07241
07242 epschrk1a)*((2 - 3*k)*epsc1 +
07243
07244
07245 2*(-1 + k)*(epsch1 + epschrk1a +
07246
07247
07248 2*epsn)))/2.) +
07249
07250
07251 6*d*k*
07252
07253
07254 pow(epsc1,
07255
07256
07257 2)*(d*
07258
07259
07260 e0c*(-n0 +
07261
07262
07263 as1*e0c*
07264
07265
07266 epsn) - (as2*(ch*e0c*
07267
07268
07269 e0cn*(epsch1 + epschrk1a) +
07270
07271
07272 d*(-2*e0cn*fy +
07273
07274
07275 e0c*(2*fy - e0cn*(epsch1 +
07276
07277
07278 epschrk1a + 2*epsn)))))/
07279
07280
07281 2.))))))/(pow(d, 2)*pow(e0c, 2)*k*
07282
07283
07284 pow(epsc1, 2)) + (24*
07285
07286
07287 as2*(2*ch -
07288
07289
07290 h)*(b*d*fc*
07291
07292
07293 pow(h, 2)*(8*e0cn*fy*h*(-1 + k) +
07294
07295
07296 e0c*(-8*fy*h*(-1 + k) +
07297
07298
07299 e0cn*(4*
07300
07301
07302 h*(-1 + k)*(epsch1 + epschrk1a +
07303
07304
07305 2*epsn) +
07306
07307
07308 3*ch*((-2 + 3*k)*epsc1 -
07309
07310
07311 2*(-1 + k)*(epsch1 + epschrk1a +
07312
07313
07314 2*epsn))))) +
07315
07316
07317 ch*e0cn*(6*as1*pow(d, 2)*pow(e0c, 2)*k*pow(epsc1, 2) +
07318
07319
07320 6*as2*ch*d*e0c*e0cn*k*pow(epsc1, 2) -
07321
07322
07323 sqrt(e0c*(e0c*
07324
07325
07326 pow(6*d*(as1*d*e0c + as2*ch*e0cn)*k*
07327
07328
07329 pow(epsc1, 2) +
07330
07331
07332 b*fc*pow(h,
07333
07334
07335 2)*(4*
07336
07337
07338 h*(-1 + k)*(epsch1 + epschrk1a) +
07339
07340
07341 3*d*((-2 + 3*k)*epsc1 -
07342
07343
07344 2*(-1 + k)*(epsch1 + epschrk1a +
07345
07346
07347 2*epsn))), 2) +
07348
07349
07350 16*b*fc*
07351
07352
07353 pow(h,
07354
07355
07356 3)*(-1 +
07357
07358
07359 k)*(b*e0c*fc*
07360
07361
07362 h*(-(pow(h, 2)*(-1 + k)*
07363
07364
07365 pow(epsch1 + epschrk1a, 2)) -
07366
07367
07368 3*pow(d,
07369
07370
07371 2)*(epsch1 + epschrk1a +
07372
07373
07374 2*epsn)*((2 - 3*k)*
07375
07376
07377 epsc1 + (-1 + k)*(epsch1 +
07378
07379
07380 epschrk1a + 2*epsn)) + (3*d*
07381
07382
07383 h*(epsch1 + epschrk1a)*((2 - 3*k)*
07384
07385
07386 epsc1 + 2*(-1 + k)*(epsch1 +
07387
07388
07389 epschrk1a + 2*epsn)))/2.) +
07390
07391
07392 6*d*k*
07393
07394
07395 pow(epsc1,
07396
07397
07398 2)*(d*
07399
07400
07401 e0c*(-n0 +
07402
07403
07404 as1*e0c*epsn) - (as2*(ch*e0c*
07405
07406
07407 e0cn*(epsch1 + epschrk1a) +
07408
07409
07410 d*(-2*e0cn*fy + e0c*(2*fy -
07411
07412
07413 e0cn*(epsch1 + epschrk1a +
07414
07415
07416 2*epsn)))))/2.)))))))/(d*e0c))/(384.*
07417
07418
07419 b*fc*pow(h, 3)*(-1 + k)) + e0c*(-(as1*(-cd + h/2.)) + as2*(-ch + h/2.))*epsn;
07420
07421
07422
07423
07424
07425 return mh1hrk1a;
07426
07427
07428 }
07429
07430
07431
07432
07433
07434
07435
07436
07437 double normmat::compute_mhrk1a ()
07438
07439
07440 {
07441
07442
07443 double mhrk1a;
07444
07445
07446
07447
07448
07449 if ((epscmax1-epschr4b) < 0.0){
07450
07451
07452
07453
07454
07455 mhrk1a=mhr4b;
07456
07457
07458
07459
07460
07461 }
07462
07463
07464 else{
07465
07466
07467 mhrk1a=mmax1a;
07468
07469
07470 }
07471
07472
07473 return mhrk1a;
07474
07475
07476 }
07477
07478
07479
07480
07481
07482
07483
07484
07485
07486 double normmat::compute_mh3 ()
07487
07488
07489 {
07490
07491
07492 double mh3;
07493
07494
07495
07496
07497
07498 if ((mhr4b-mhr1) < 0.0){
07499
07500
07501
07502
07503
07504 mh3=mhr4b;
07505
07506
07507
07508
07509
07510 }
07511
07512
07513 else{
07514
07515
07516 mh3=mhr3;
07517
07518
07519 }
07520
07521
07522 return mh3;
07523
07524
07525 }
07526
07527
07528
07529
07530
07531
07532
07533
07534
07535 double normmat::compute_epsch3 ()
07536
07537
07538 {
07539
07540
07541 double epsch3;
07542
07543
07544
07545
07546
07547 if ((mhr4b-mhr1) < 0.0){
07548
07549
07550
07551
07552
07553 epsch3=epschr4b;
07554
07555
07556
07557
07558
07559 }
07560
07561
07562 else{
07563
07564
07565 epsch3=epschr3;
07566
07567
07568 }
07569
07570
07571 return epsch3;
07572
07573
07574 }
07575
07576
07577
07578
07579
07580
07581
07582
07583 double normmat::compute_mh2 ()
07584
07585
07586 {
07587
07588
07589 double mh2;
07590
07591
07592
07593
07594
07595 if ((mhr2-mh3) > 0.0){
07596
07597
07598
07599
07600
07601 mh2=mh3;
07602
07603
07604
07605
07606
07607 }
07608
07609
07610 else{
07611
07612
07613 mh2=mhr2;
07614
07615
07616 }
07617
07618
07619 return mh2;
07620
07621
07622 }
07623
07624
07625
07626
07627
07628
07629
07630
07631 double normmat::compute_epsch2 ()
07632
07633
07634 {
07635
07636
07637 double epsch2;
07638
07639
07640
07641
07642
07643 if ((mhr2-mh3) > 0.0){
07644
07645
07646
07647
07648
07649 epsch2=epsch3;
07650
07651
07652 }
07653
07654
07655 else{
07656
07657
07658 epsch2=epschr2;
07659
07660
07661 }
07662
07663
07664 return epsch2;
07665
07666
07667 }
07668
07669
07670
07671
07672
07673
07674
07675
07676 double normmat::compute_epscder2 ()
07677
07678
07679 {
07680
07681
07682 double epscder2;
07683
07684
07685
07686
07687
07688 epscder2 =-(-(mh1*epsch1) + 4*mh1hrk1a*epsch1 - 3*mhrk1a*epsch1 - 3*mh1*epschrk1a +
07689
07690
07691 4*mh1hrk1a*epschrk1a -
07692
07693
07694 mhrk1a*epschrk1a)/(4.*(mh1 - 2*mh1hrk1a + mhrk1a));
07695
07696
07697
07698
07699
07700 return epscder2;
07701
07702
07703 }
07704
07705
07706
07707
07708
07709
07710
07711
07712 double normmat::compute_mmax1 ()
07713
07714
07715 {
07716
07717
07718 double mmax1;
07719
07720
07721
07722
07723
07724 mmax1 =((-6*b*d*e0c*fc*pow(h, 2)*epsc1 + 9*b*d*e0c*fc*pow(h, 2)*k*epsc1 +
07725
07726
07727 6*as1*pow(d, 2)*pow(e0c, 2)*k*pow(epsc1, 2) +
07728
07729
07730 6*as2*ch*d*e0c*e0cn*k*pow(epsc1, 2) +
07731
07732
07733 12*b*d*e0c*fc*pow(h, 2)*epscder2 -
07734
07735
07736 12*b*d*e0c*fc*pow(h, 2)*k*epscder2 +
07737
07738
07739 12*b*d*e0c*fc*pow(h, 2)*epsn - 12*b*d*e0c*fc*pow(h, 2)*k*epsn -
07740
07741
07742 sqrt(e0c*(e0c*
07743
07744
07745 pow(6*d*(as1*d*e0c + as2*ch*e0cn)*k*pow(epsc1, 2) +
07746
07747
07748 b*fc*pow(h,
07749
07750
07751 2)*(8*h*(-1 + k)*epscder2 -
07752
07753
07754 3*d*((2 - 3*k)*epsc1 +
07755
07756
07757 4*(-1 + k)*epscder2 +
07758
07759
07760 4*(-1 + k)*epsn)), 2) +
07761
07762
07763 16*b*fc*
07764
07765
07766 pow(h,
07767
07768
07769 3)*(-1 +
07770
07771
07772 k)*(b*e0c*fc*
07773
07774
07775 h*(-4*pow(h, 2)*(-1 + k)*pow(epscder2, 2) -
07776
07777
07778 6*pow(d,
07779
07780
07781 2)*(epscder2 + epsn)*((2 - 3*k)*epsc1 +
07782
07783
07784 2*(-1 + k)*epscder2 +
07785
07786
07787 2*(-1 + k)*epsn) +
07788
07789
07790 3*d*h*
07791
07792
07793 epscder2*((2 - 3*k)*epsc1 +
07794
07795
07796 4*(-1 + k)*epscder2 +
07797
07798
07799 4*(-1 + k)*epsn)) +
07800
07801
07802 6*d*k*pow(epsc1,
07803
07804
07805 2)*(d*e0c*(-n0 + as1*e0c*epsn) +
07806
07807
07808 as2*(-(ch*e0c*e0cn*epscder2) +
07809
07810
07811 d*(e0cn*fy +
07812
07813
07814 e0c*(-fy + e0cn*(epscder2 +
07815
07816
07817 epsn)))))))))*(-2*b*d*e0c*fc*
07818
07819
07820 pow(h, 2)*epsc1 + 3*b*d*e0c*fc*pow(h, 2)*k*epsc1 -
07821
07822
07823 6*as1*pow(d, 2)*pow(e0c, 2)*k*pow(epsc1, 2) -
07824
07825
07826 6*as2*ch*d*e0c*e0cn*k*pow(epsc1, 2) +
07827
07828
07829 4*b*d*e0c*fc*pow(h, 2)*epscder2 -
07830
07831
07832 4*b*d*e0c*fc*pow(h, 2)*k*epscder2 + 4*b*d*e0c*fc*pow(h, 2)*epsn -
07833
07834
07835 4*b*d*e0c*fc*pow(h, 2)*k*epsn +
07836
07837
07838 sqrt(e0c*(e0c*
07839
07840
07841 pow(6*d*(as1*d*e0c + as2*ch*e0cn)*k*pow(epsc1, 2) +
07842
07843
07844 b*fc*pow(h,
07845
07846
07847 2)*(8*h*(-1 + k)*epscder2 -
07848
07849
07850 3*d*((2 - 3*k)*epsc1 +
07851
07852
07853 4*(-1 + k)*epscder2 +
07854
07855
07856 4*(-1 + k)*epsn)), 2) +
07857
07858
07859 16*b*fc*
07860
07861
07862 pow(h,
07863
07864
07865 3)*(-1 +
07866
07867
07868 k)*(b*e0c*fc*
07869
07870
07871 h*(-4*pow(h, 2)*(-1 + k)*pow(epscder2, 2) -
07872
07873
07874 6*pow(d,
07875
07876
07877 2)*(epscder2 + epsn)*((2 - 3*k)*epsc1 +
07878
07879
07880 2*(-1 + k)*epscder2 +
07881
07882
07883 2*(-1 + k)*epsn) +
07884
07885
07886 3*d*h*
07887
07888
07889 epscder2*((2 - 3*k)*epsc1 +
07890
07891
07892 4*(-1 + k)*epscder2 +
07893
07894
07895 4*(-1 + k)*epsn)) +
07896
07897
07898 6*d*k*pow(epsc1,
07899
07900
07901 2)*(d*e0c*(-n0 + as1*e0c*epsn) +
07902
07903
07904 as2*(-(ch*e0c*e0cn*epscder2) +
07905
07906
07907 d*(e0cn*fy +
07908
07909
07910 e0c*(-fy + e0cn*(epscder2 +
07911
07912
07913 epsn))))))))))/(384.*b*pow(d, 2)*
07914
07915
07916 pow(e0c, 2)*fc*pow(h, 2)*(-1 + k)*k*pow(epsc1, 2)) + (as1*
07917
07918
07919 e0c*(-2*cd +
07920
07921
07922 h)*(epsn + (6*d*e0c*(as1*d*e0c + as2*ch*e0cn)*k*pow(epsc1, 2) +
07923
07924
07925 b*e0c*fc*
07926
07927
07928 pow(h, 2)*(8*h*(-1 + k)*epscder2 -
07929
07930
07931 3*d*((2 - 3*k)*epsc1 + 4*(-1 + k)*epscder2 +
07932
07933
07934 4*(-1 + k)*epsn)) -
07935
07936
07937 sqrt(e0c*(e0c*
07938
07939
07940 pow(6*d*(as1*d*e0c + as2*ch*e0cn)*k*
07941
07942
07943 pow(epsc1, 2) +
07944
07945
07946 b*fc*pow(h,
07947
07948
07949 2)*(8*h*(-1 + k)*epscder2 -
07950
07951
07952 3*d*((2 - 3*k)*epsc1 +
07953
07954
07955 4*(-1 + k)*epscder2 +
07956
07957
07958 4*(-1 + k)*epsn)), 2) +
07959
07960
07961 16*b*fc*
07962
07963
07964 pow(h,
07965
07966
07967 3)*(-1 +
07968
07969
07970 k)*(b*e0c*fc*
07971
07972
07973 h*(-4*pow(h, 2)*(-1 + k)*
07974
07975
07976 pow(epscder2, 2) -
07977
07978
07979 6*pow(d,
07980
07981
07982 2)*(epscder2 +
07983
07984
07985 epsn)*((2 - 3*k)*epsc1 +
07986
07987
07988 2*(-1 + k)*epscder2 +
07989
07990
07991 2*(-1 + k)*epsn) +
07992
07993
07994 3*d*h*
07995
07996
07997 epscder2*((2 - 3*k)*epsc1 +
07998
07999
08000 4*(-1 + k)*epscder2 +
08001
08002
08003 4*(-1 + k)*epsn)) +
08004
08005
08006 6*d*k*
08007
08008
08009 pow(epsc1,
08010
08011
08012 2)*(d*e0c*(-n0 + as1*e0c*epsn) +
08013
08014
08015 as2*(-(ch*e0c*e0cn*epscder2) +
08016
08017
08018 d*(e0cn*fy +
08019
08020
08021 e0c*(-fy + e0cn*(epscder2 +
08022
08023
08024 epsn)))))))))/(8.*b*e0c*fc*
08025
08026
08027 pow(h, 3)*(-1 + k))))/
08028
08029
08030 2. + (as2*(-2*ch + h)*(fy -
08031
08032
08033 e0cn*(fy/e0c + epscder2 - (ch*epscder2)/d +
08034
08035
08036 epsn + (ch*(6*d*e0c*(as1*d*e0c + as2*ch*e0cn)*k*
08037
08038
08039 pow(epsc1, 2) +
08040
08041
08042 b*e0c*fc*
08043
08044
08045 pow(h,
08046
08047
08048 2)*(8*h*(-1 + k)*epscder2 -
08049
08050
08051 3*d*((2 - 3*k)*epsc1 +
08052
08053
08054 4*(-1 + k)*epscder2 +
08055
08056
08057 4*(-1 + k)*epsn)) -
08058
08059
08060 sqrt(e0c*(e0c*
08061
08062
08063 pow(6*d*(as1*d*e0c + as2*ch*e0cn)*k*
08064
08065
08066 pow(epsc1, 2) +
08067
08068
08069 b*fc*pow(h,
08070
08071
08072 2)*(8*h*(-1 + k)*epscder2 -
08073
08074
08075 3*d*((2 - 3*k)*epsc1 +
08076
08077
08078 4*(-1 + k)*epscder2 +
08079
08080
08081 4*(-1 + k)*epsn)), 2) +
08082
08083
08084 16*b*fc*
08085
08086
08087 pow(h,
08088
08089
08090 3)*(-1 +
08091
08092
08093 k)*(b*e0c*fc*
08094
08095
08096 h*(-4*pow(h, 2)*(-1 + k)*
08097
08098
08099 pow(epscder2, 2) -
08100
08101
08102 6*pow(d, 2)*(epscder2 +
08103
08104
08105 epsn)*((2 - 3*k)*epsc1 +
08106
08107
08108 2*(-1 + k)*epscder2 +
08109
08110
08111 2*(-1 + k)*epsn) +
08112
08113
08114 3*d*h*epscder2*((2 - 3*k)*epsc1 +
08115
08116
08117 4*(-1 + k)*epscder2 +
08118
08119
08120 4*(-1 + k)*epsn)) +
08121
08122
08123 6*d*k*
08124
08125
08126 pow(epsc1,
08127
08128
08129 2)*(d*e0c*(-n0 + as1*e0c*epsn) +
08130
08131
08132 as2*(-(ch*e0c*e0cn*epscder2) +
08133
08134
08135 d*(e0cn*fy + e0c*(-fy +
08136
08137
08138 e0cn*(epscder2 + epsn))))))))))/(8.*b*
08139
08140
08141 d*e0c*fc*pow(h, 3)*(-1 + k)))))/2. + e0c*(-(as1*(-cd + h/2.)) + as2*(-ch + h/2.))*epsn;
08142
08143
08144
08145
08146
08147 return mmax1;
08148
08149
08150 }
08151
08152
08153
08154
08155
08156
08157
08158
08159 double normmat::compute_mhrk1 ()
08160
08161
08162 {
08163
08164
08165 double mhrk1;
08166
08167
08168
08169
08170
08171 if ((epscder2-epschr4 < 0.0) && (epscder2-epscmax1 > 0.0) && (epscder2-epschr4b > 0.0)){
08172
08173
08174
08175
08176
08177 mhrk1=mmax1;
08178
08179
08180 }
08181
08182
08183 else{
08184
08185
08186 mhrk1=mhrk1a;
08187
08188
08189 }
08190
08191
08192 return mhrk1;
08193
08194
08195 }
08196
08197
08198
08199
08200
08201
08202
08203
08204 double normmat::compute_epschrk1 ()
08205
08206
08207 {
08208
08209
08210 double epschrk1;
08211
08212
08213
08214
08215
08216 if ((epscder2-epschr4 < 0.0) && (epscder2-epscmax1 > 0.0) && (epscder2-epschr4b > 0.0)){
08217
08218
08219
08220
08221
08222 epschrk1=epscder2;
08223
08224
08225 }
08226
08227
08228 else{
08229
08230
08231 epschrk1=epschrk1a;
08232
08233
08234 }
08235
08236
08237 return epschrk1;
08238
08239
08240 }
08241
08242
08243
08244
08245
08246
08247
08248
08249 double normmat::compute_mh1hrk1 ()
08250
08251
08252 {
08253
08254
08255 double mh1hrk1;
08256
08257
08258
08259
08260
08261 mh1hrk1 =(-24*as1*(2*cd - h)*(6*as1*pow(d, 2)*pow(e0c, 2)*k*pow(epsc1, 2) +
08262
08263
08264 6*as2*ch*d*e0c*e0cn*k*pow(epsc1, 2) +
08265
08266
08267 b*e0c*fc*
08268
08269
08270 pow(h, 2)*(4*h*(-1 + k)*(epsch1 + epschrk1 + 2*epsn) +
08271
08272
08273 3*d*((-2 + 3*k)*epsc1 -
08274
08275
08276 2*(-1 + k)*(epsch1 + epschrk1 + 2*epsn))) -
08277
08278
08279 sqrt(e0c*(e0c*
08280
08281
08282 pow(6*d*(as1*d*e0c + as2*ch*e0cn)*k*pow(epsc1, 2) +
08283
08284
08285 b*fc*pow(h,
08286
08287
08288 2)*(4*h*(-1 + k)*(epsch1 + epschrk1) +
08289
08290
08291 3*d*((-2 + 3*k)*epsc1 -
08292
08293
08294 2*(-1 + k)*(epsch1 + epschrk1 +
08295
08296
08297 2*epsn))), 2) +
08298
08299
08300 16*b*fc*
08301
08302
08303 pow(h,
08304
08305
08306 3)*(-1 +
08307
08308
08309 k)*(b*e0c*fc*
08310
08311
08312 h*(-(pow(h, 2)*(-1 + k)*
08313
08314
08315 pow(epsch1 + epschrk1, 2)) -
08316
08317
08318 3*pow(d,
08319
08320
08321 2)*(epsch1 + epschrk1 +
08322
08323
08324 2*epsn)*((2 - 3*k)*
08325
08326
08327 epsc1 + (-1 + k)*(epsch1 + epschrk1 +
08328
08329
08330 2*epsn)) + (3*d*
08331
08332
08333 h*(epsch1 +
08334
08335
08336 epschrk1)*((2 - 3*k)*epsc1 +
08337
08338
08339 2*(-1 + k)*(epsch1 + epschrk1 +
08340
08341
08342 2*epsn)))/2.) +
08343
08344
08345 6*d*k*pow(epsc1,
08346
08347
08348 2)*(d*
08349
08350
08351 e0c*(-n0 +
08352
08353
08354 as1*e0c*
08355
08356
08357 epsn) - (as2*(ch*e0c*
08358
08359
08360 e0cn*(epsch1 + epschrk1) +
08361
08362
08363 d*(-2*e0cn*fy +
08364
08365
08366 e0c*(2*fy - e0cn*(epsch1 + epschrk1 +
08367
08368
08369 2*epsn)))))/2.))))) + (h*(6*as1*
08370
08371
08372 pow(d, 2)*pow(e0c, 2)*k*pow(epsc1, 2) +
08373
08374
08375 6*as2*ch*d*e0c*e0cn*k*pow(epsc1, 2) +
08376
08377
08378 3*b*d*e0c*fc*
08379
08380
08381 pow(h, 2)*((-2 + 3*k)*epsc1 -
08382
08383
08384 2*(-1 + k)*(epsch1 + epschrk1 + 2*epsn)) -
08385
08386
08387 sqrt(e0c*(e0c*
08388
08389
08390 pow(6*d*(as1*d*e0c + as2*ch*e0cn)*k*
08391
08392
08393 pow(epsc1, 2) +
08394
08395
08396 b*fc*pow(h,
08397
08398
08399 2)*(4*h*(-1 + k)*(epsch1 + epschrk1) +
08400
08401
08402 3*d*((-2 + 3*k)*epsc1 -
08403
08404
08405 2*(-1 + k)*(epsch1 + epschrk1 +
08406
08407
08408 2*epsn))), 2) +
08409
08410
08411 16*b*fc*
08412
08413
08414 pow(h,
08415
08416
08417 3)*(-1 +
08418
08419
08420 k)*(b*e0c*fc*
08421
08422
08423 h*(-(pow(h, 2)*(-1 + k)*
08424
08425
08426 pow(epsch1 + epschrk1, 2)) -
08427
08428
08429 3*pow(d,
08430
08431
08432 2)*(epsch1 + epschrk1 +
08433
08434
08435 2*epsn)*((2 - 3*k)*
08436
08437
08438 epsc1 + (-1 + k)*(epsch1 + epschrk1 +
08439
08440
08441 2*epsn)) + (3*d*
08442
08443
08444 h*(epsch1 +
08445
08446
08447 epschrk1)*((2 - 3*k)*epsc1 +
08448
08449
08450 2*(-1 + k)*(epsch1 + epschrk1 +
08451
08452
08453 2*epsn)))/2.) +
08454
08455
08456 6*d*k*
08457
08458
08459 pow(epsc1,
08460
08461
08462 2)*(d*
08463
08464
08465 e0c*(-n0 +
08466
08467
08468 as1*e0c*
08469
08470
08471 epsn) - (as2*(ch*e0c*
08472
08473
08474 e0cn*(epsch1 + epschrk1) +
08475
08476
08477 d*(-2*e0cn*fy +
08478
08479
08480 e0c*(2*fy - e0cn*(epsch1 + epschrk1 +
08481
08482
08483 2*epsn)))))/2.)))))*(-6*as1*pow(d, 2)*
08484
08485
08486 pow(e0c, 2)*k*pow(epsc1, 2) -
08487
08488
08489 6*as2*ch*d*e0c*e0cn*k*pow(epsc1, 2) +
08490
08491
08492 b*d*e0c*fc*
08493
08494
08495 pow(h, 2)*((-2 + 3*k)*epsc1 -
08496
08497
08498 2*(-1 + k)*(epsch1 + epschrk1 + 2*epsn)) +
08499
08500
08501 sqrt(e0c*(e0c*
08502
08503
08504 pow(6*d*(as1*d*e0c + as2*ch*e0cn)*k*
08505
08506
08507 pow(epsc1, 2) +
08508
08509
08510 b*fc*pow(h,
08511
08512
08513 2)*(4*h*(-1 + k)*(epsch1 + epschrk1) +
08514
08515
08516 3*d*((-2 + 3*k)*epsc1 -
08517
08518
08519 2*(-1 + k)*(epsch1 + epschrk1 +
08520
08521
08522 2*epsn))), 2) +
08523
08524
08525 16*b*fc*
08526
08527
08528 pow(h,
08529
08530
08531 3)*(-1 +
08532
08533
08534 k)*(b*e0c*fc*
08535
08536
08537 h*(-(pow(h, 2)*(-1 + k)*
08538
08539
08540 pow(epsch1 + epschrk1, 2)) -
08541
08542
08543 3*pow(d,
08544
08545
08546 2)*(epsch1 + epschrk1 +
08547
08548
08549 2*epsn)*((2 - 3*k)*
08550
08551
08552 epsc1 + (-1 + k)*(epsch1 + epschrk1 +
08553
08554
08555 2*epsn)) + (3*d*
08556
08557
08558 h*(epsch1 +
08559
08560
08561 epschrk1)*((2 - 3*k)*epsc1 +
08562
08563
08564 2*(-1 + k)*(epsch1 + epschrk1 +
08565
08566
08567 2*epsn)))/2.) +
08568
08569
08570 6*d*k*
08571
08572
08573 pow(epsc1,
08574
08575
08576 2)*(d*
08577
08578
08579 e0c*(-n0 +
08580
08581
08582 as1*e0c*
08583
08584
08585 epsn) - (as2*(ch*e0c*
08586
08587
08588 e0cn*(epsch1 + epschrk1) +
08589
08590
08591 d*(-2*e0cn*fy +
08592
08593
08594 e0c*(2*fy - e0cn*(epsch1 + epschrk1 +
08595
08596
08597 2*epsn)))))/2.))))))/(pow(d, 2)*
08598
08599
08600 pow(e0c, 2)*k*pow(epsc1, 2)) + (24*
08601
08602
08603 as2*(2*ch -
08604
08605
08606 h)*(b*d*fc*
08607
08608
08609 pow(h, 2)*(8*e0cn*fy*h*(-1 + k) +
08610
08611
08612 e0c*(-8*fy*h*(-1 + k) +
08613
08614
08615 e0cn*(4*h*(-1 + k)*(epsch1 + epschrk1 + 2*epsn) +
08616
08617
08618 3*ch*((-2 + 3*k)*epsc1 -
08619
08620
08621 2*(-1 + k)*(epsch1 + epschrk1 +
08622
08623
08624 2*epsn))))) +
08625
08626
08627 ch*e0cn*(6*as1*pow(d, 2)*pow(e0c, 2)*k*pow(epsc1, 2) +
08628
08629
08630 6*as2*ch*d*e0c*e0cn*k*pow(epsc1, 2) -
08631
08632
08633 sqrt(e0c*(e0c*
08634
08635
08636 pow(6*d*(as1*d*e0c + as2*ch*e0cn)*k*
08637
08638
08639 pow(epsc1, 2) +
08640
08641
08642 b*fc*pow(h,
08643
08644
08645 2)*(4*
08646
08647
08648 h*(-1 + k)*(epsch1 + epschrk1) +
08649
08650
08651 3*d*((-2 + 3*k)*epsc1 -
08652
08653
08654 2*(-1 + k)*(epsch1 + epschrk1 +
08655
08656
08657 2*epsn))), 2) +
08658
08659
08660 16*b*fc*
08661
08662
08663 pow(h,
08664
08665
08666 3)*(-1 +
08667
08668
08669 k)*(b*e0c*fc*
08670
08671
08672 h*(-(pow(h, 2)*(-1 + k)*
08673
08674
08675 pow(epsch1 + epschrk1, 2)) -
08676
08677
08678 3*pow(d,
08679
08680
08681 2)*(epsch1 + epschrk1 +
08682
08683
08684 2*epsn)*((2 - 3*k)*
08685
08686
08687 epsc1 + (-1 + k)*(epsch1 + epschrk1 +
08688
08689
08690 2*epsn)) + (3*d*
08691
08692
08693 h*(epsch1 + epschrk1)*((2 - 3*k)*
08694
08695
08696 epsc1 + 2*(-1 + k)*(epsch1 +
08697
08698
08699 epschrk1 + 2*epsn)))/2.) +
08700
08701
08702 6*d*k*
08703
08704
08705 pow(epsc1,
08706
08707
08708 2)*(d*
08709
08710
08711 e0c*(-n0 +
08712
08713
08714 as1*e0c*epsn) - (as2*(ch*e0c*
08715
08716
08717 e0cn*(epsch1 + epschrk1) +
08718
08719
08720 d*(-2*e0cn*fy + e0c*(2*fy -
08721
08722
08723 e0cn*(epsch1 + epschrk1 + 2*epsn)))))/
08724
08725
08726 2.)))))))/(d*e0c))/(384.*b*fc*
08727
08728
08729 pow(h, 3)*(-1 + k)) + e0c*(-(as1*(-cd + h/2.)) + as2*(-ch + h/2.))*epsn;
08730
08731
08732
08733
08734
08735 return mh1hrk1;
08736
08737
08738 }
08739
08740
08741
08742
08743
08744
08745
08746
08747
08748
08749
08750
08751
08752
08753
08754
08755
08756
08757
08758
08759 double normmat::compute_epschr5 ()
08760
08761
08762 {
08763
08764
08765 double ac1,ac2,ac3,epschr5;
08766
08767
08768
08769
08770 ac1 =((sqrt(3.)*sqrt(k*pow(epsc1,
08771
08772
08773 2)*(3*k*pow(epsc1, 2)*
08774
08775
08776 pow(-2*as2*ch*pow(e0c, 2)*epsc1 +
08777
08778
08779 d*(-(as1*e0cn*fy) +
08780
08781
08782 e0c*(-n0 + as2*e0c*(epsc1 + epsn) +
08783
08784
08785 as1*(fy + e0cn*(-epsc1 + epsn)))), 2) -
08786
08787
08788 2*e0c*(as2*ch*e0c +
08789
08790
08791 as1*d*e0cn)*(-(b*pow(d, 2)*e0c*fc*
08792
08793
08794 pow(epsc1 + epsn,
08795
08796
08797 2)*((-2 + 5*k)*epsc1 - 4*(-1 + k)*epsn)) +
08798
08799
08800 6*k*pow(epsc1,
08801
08802
08803 3)*(as1*d*(e0cn*fy - e0c*(fy + e0cn*epsn)) +
08804
08805
08806 e0c*(as2*ch*e0c*epsc1 +
08807
08808
08809 d*(n0 -
08810
08811
08812 as2*e0c*(epsc1 + epsn)))))))*((3*
08813
08814
08815 pow(e0c,
08816
08817
08818 2)*(pow(as2*(2*ch - d)*e0c + as1*d*e0cn, 2)*k*
08819
08820
08821 pow(epsc1, 2) -
08822
08823
08824 2*(as2*ch*e0c +
08825
08826
08827 as1*d*e0cn)*(2*as2*(ch - d)*e0c*k*
08828
08829
08830 pow(epsc1, 2) +
08831
08832
08833 b*pow(d, 2)*
08834
08835
08836 fc*((-2 + k)*epsc1 + 4*(-1 + k)*epsn))))/(3*
08837
08838
08839 k*pow(epsc1, 2)*
08840
08841
08842 pow(-2*as2*ch*pow(e0c, 2)*epsc1 +
08843
08844
08845 d*(-(as1*e0cn*fy) +
08846
08847
08848 e0c*(-n0 + as2*e0c*(epsc1 + epsn) +
08849
08850
08851 as1*(fy + e0cn*(-epsc1 + epsn)))),
08852
08853
08854 2) - 2*
08855
08856
08857 e0c*(as2*ch*e0c +
08858
08859
08860 as1*d*e0cn)*(-(b*pow(d, 2)*e0c*fc*
08861
08862
08863 pow(epsc1 + epsn,
08864
08865
08866 2)*((-2 + 5*k)*epsc1 -
08867
08868
08869 4*(-1 + k)*epsn)) +
08870
08871
08872 6*k*pow(epsc1,
08873
08874
08875 3)*(as1*d*(e0cn*fy - e0c*(fy + e0cn*epsn)) +
08876
08877
08878 e0c*(as2*ch*e0c*epsc1 +
08879
08880
08881 d*(n0 - as2*e0c*(epsc1 + epsn)))))) -
08882
08883
08884 pow(6*e0c*(as2*(2*ch - d)*e0c + as1*d*e0cn)*k*
08885
08886
08887 pow(epsc1,
08888
08889
08890 2)*(-2*as2*ch*pow(e0c, 2)*epsc1 +
08891
08892
08893 d*(-(as1*e0cn*fy) +
08894
08895
08896 e0c*(-n0 + as2*e0c*(epsc1 + epsn) +
08897
08898
08899 as1*(fy + e0cn*(-epsc1 + epsn))))) +
08900
08901
08902 2*e0c*(as2*ch*e0c +
08903
08904
08905 as1*d*e0cn)*(-6*b*pow(d, 2)*e0c*
08906
08907
08908 fc*(epsc1 + epsn)*(k*(epsc1 - 2*epsn) +
08909
08910
08911 2*epsn) -
08912
08913
08914 6*k*pow(epsc1,
08915
08916
08917 2)*(as1*
08918
08919
08920 d*(-(e0cn*fy) + e0c*(fy + e0cn*epsn)) +
08921
08922
08923 e0c*(-2*as2*ch*e0c*epsc1 +
08924
08925
08926 d*(-n0 + as2*e0c*(2*epsc1 + epsn))))),
08927
08928
08929 2)/(4.*
08930
08931
08932 pow(3*k*pow(epsc1, 2)*
08933
08934
08935 pow(-2*as2*ch*pow(e0c, 2)*epsc1 +
08936
08937
08938 d*(-(as1*e0cn*fy) +
08939
08940
08941 e0c*(-n0 + as2*e0c*(epsc1 + epsn) +
08942
08943
08944 as1*(fy + e0cn*(-epsc1 + epsn)))),
08945
08946
08947 2) - 2*
08948
08949
08950 e0c*(as2*ch*e0c +
08951
08952
08953 as1*d*
08954
08955
08956 e0cn)*(-(b*pow(d, 2)*e0c*fc*
08957
08958
08959 pow(epsc1 + epsn,
08960
08961
08962 2)*((-2 + 5*k)*epsc1 -
08963
08964
08965 4*(-1 + k)*epsn)) +
08966
08967
08968 6*k*pow(epsc1,
08969
08970
08971 3)*(as1*
08972
08973
08974 d*(e0cn*fy - e0c*(fy + e0cn*epsn)) +
08975
08976
08977 e0c*(as2*ch*e0c*epsc1 +
08978
08979
08980 d*(n0 - as2*e0c*(epsc1 + epsn))))),
08981
08982
08983 2))))/((as2*ch*e0c + as1*d*e0cn)*
08984
08985
08986 k) + (2*(-3*as1*d*k*
08987
08988
08989 pow(epsc1,
08990
08991
08992 2)*(-2*d*e0cn*(fy + e0c*(epsc1 + epsn)) +
08993
08994
08995 ch*(-(e0cn*fy) + e0c*(fy + e0cn*(epsc1 + epsn)))) +
08996
08997
08998 ch*(3*d*e0c*k*n0*pow(epsc1, 2) +
08999
09000
09001 3*as2*d*e0c*k*
09002
09003
09004 pow(epsc1, 2)*(2*fy + e0c*(epsc1 + epsn)) +
09005
09006
09007 sqrt(3.)*
09008
09009
09010 sqrt(k*
09011
09012
09013 pow(epsc1,
09014
09015
09016 2)*(3*k*pow(epsc1, 2)*
09017
09018
09019 pow(-2*as2*ch*pow(e0c, 2)*epsc1 +
09020
09021
09022 d*(-(as1*e0cn*fy) +
09023
09024
09025 e0c*(-n0 + as2*e0c*(epsc1 + epsn) +
09026
09027
09028 as1*(fy + e0cn*(-epsc1 + epsn)))),
09029
09030
09031 2) - 2*
09032
09033
09034 e0c*(as2*ch*e0c +
09035
09036
09037 as1*d*
09038
09039
09040 e0cn)*(-(b*pow(d, 2)*e0c*fc*
09041
09042
09043 pow(epsc1 + epsn,
09044
09045
09046 2)*((-2 + 5*k)*epsc1 -
09047
09048
09049 4*(-1 + k)*epsn)) +
09050
09051
09052 6*k*pow(epsc1,
09053
09054
09055 3)*(as1*
09056
09057
09058 d*(e0cn*fy - e0c*(fy + e0cn*epsn)) +
09059
09060
09061 e0c*(as2*ch*e0c*epsc1 +
09062
09063
09064 d*(n0 - as2*e0c*(epsc1 +
09065
09066
09067 epsn))))))))))/(ch*(as2*ch*e0c +
09068
09069
09070 as1*d*e0cn)*k*pow(epsc1, 2)) -
09071
09072
09073 2*epsc1*((6*(-ch + d)*e0c)/
09074
09075
09076 ch + (3*e0c*(2*as2*ch*e0c - as2*d*e0c +
09077
09078
09079 as1*d*e0cn + (sqrt(3.)*
09080
09081
09082 pow(d,
09083
09084
09085 2)*(pow(as2, 2)*pow(e0c, 3)*k*
09086
09087
09088 pow(epsc1, 2)*(epsc1 + epsn) +
09089
09090
09091 as1*e0cn*(2*b*d*e0c*
09092
09093
09094 fc*(epsc1 +
09095
09096
09097 epsn)*(k*(epsc1 - 2*epsn) + 2*epsn) +
09098
09099
09100 k*pow(epsc1,
09101
09102
09103 2)*(-(e0c*n0) +
09104
09105
09106 as1*(-(e0cn*fy) +
09107
09108
09109 e0c*(fy + e0cn*(epsc1 + epsn))))) +
09110
09111
09112 as2*e0c*(2*b*ch*e0c*
09113
09114
09115 fc*(epsc1 +
09116
09117
09118 epsn)*(k*(epsc1 - 2*epsn) + 2*epsn) +
09119
09120
09121 k*pow(epsc1,
09122
09123
09124 2)*(-(e0c*n0) +
09125
09126
09127 as1*(-(e0cn*fy) +
09128
09129
09130 e0c*(fy + 2*e0cn*(epsc1 + epsn)))))))/
09131
09132
09133 sqrt(k*
09134
09135
09136 pow(epsc1,
09137
09138
09139 2)*(3*k*pow(epsc1, 2)*
09140
09141
09142 pow(-2*as2*ch*pow(e0c, 2)*epsc1 +
09143
09144
09145 d*(-(as1*e0cn*fy) +
09146
09147
09148 e0c*(-n0 + as2*e0c*(epsc1 + epsn) +
09149
09150
09151 as1*(fy + e0cn*(-epsc1 + epsn)))),
09152
09153
09154 2) - 2*
09155
09156
09157 e0c*(as2*ch*e0c +
09158
09159
09160 as1*d*
09161
09162
09163 e0cn)*(-(b*pow(d, 2)*e0c*fc*
09164
09165
09166 pow(epsc1 + epsn,
09167
09168
09169 2)*((-2 + 5*k)*epsc1 -
09170
09171
09172 4*(-1 + k)*epsn)) +
09173
09174
09175 6*k*pow(epsc1,
09176
09177
09178 3)*(as1*
09179
09180
09181 d*(e0cn*fy - e0c*(fy + e0cn*epsn)) +
09182
09183
09184 e0c*(as2*ch*e0c*epsc1 +
09185
09186
09187 d*(n0 - as2*e0c*(epsc1 +
09188
09189
09190 epsn)))))))))/(as2*ch*e0c +
09191
09192
09193 as1*d*e0cn)))/(12.*e0c);
09194
09195 ac2 =((6*(-ch + d)*e0c)/
09196
09197
09198 ch + (3*e0c*(2*as2*ch*e0c - as2*d*e0c +
09199
09200
09201 as1*d*e0cn + (sqrt(3.)*
09202
09203
09204 pow(d,
09205
09206
09207 2)*(pow(as2, 2)*pow(e0c, 3)*k*
09208
09209
09210 pow(epsc1, 2)*(epsc1 + epsn) +
09211
09212
09213 as1*e0cn*(2*b*d*e0c*
09214
09215
09216 fc*(epsc1 + epsn)*(k*(epsc1 - 2*epsn) +
09217
09218
09219 2*epsn) +
09220
09221
09222 k*pow(epsc1,
09223
09224
09225 2)*(-(e0c*n0) +
09226
09227
09228 as1*(-(e0cn*fy) +
09229
09230
09231 e0c*(fy + e0cn*(epsc1 + epsn))))) +
09232
09233
09234 as2*e0c*(2*b*ch*e0c*
09235
09236
09237 fc*(epsc1 + epsn)*(k*(epsc1 - 2*epsn) +
09238
09239
09240 2*epsn) +
09241
09242
09243 k*pow(epsc1,
09244
09245
09246 2)*(-(e0c*n0) +
09247
09248
09249 as1*(-(e0cn*fy) +
09250
09251
09252 e0c*(fy + 2*e0cn*(epsc1 + epsn)))))))/
09253
09254
09255 sqrt(k*pow(epsc1,
09256
09257
09258 2)*(3*k*pow(epsc1, 2)*
09259
09260
09261 pow(-2*as2*ch*pow(e0c, 2)*epsc1 +
09262
09263
09264 d*(-(as1*e0cn*fy) +
09265
09266
09267 e0c*(-n0 + as2*e0c*(epsc1 + epsn) +
09268
09269
09270 as1*(fy + e0cn*(-epsc1 + epsn)))),
09271
09272
09273 2) - 2*
09274
09275
09276 e0c*(as2*ch*e0c +
09277
09278
09279 as1*d*
09280
09281
09282 e0cn)*(-(b*pow(d, 2)*e0c*fc*
09283
09284
09285 pow(epsc1 + epsn,
09286
09287
09288 2)*((-2 + 5*k)*epsc1 -
09289
09290
09291 4*(-1 + k)*epsn)) +
09292
09293
09294 6*k*pow(epsc1,
09295
09296
09297 3)*(as1*
09298
09299
09300 d*(e0cn*fy - e0c*(fy + e0cn*epsn)) +
09301
09302
09303 e0c*(as2*ch*e0c*epsc1 +
09304
09305
09306 d*(n0 - as2*
09307
09308
09309 e0c*(epsc1 + epsn)))))))))/(as2*ch*
09310
09311
09312 e0c + as1*d*e0cn) - (sqrt(3.)*
09313
09314
09315 sqrt(k*pow(epsc1,
09316
09317
09318 2)*(3*k*pow(epsc1, 2)*
09319
09320
09321 pow(-2*as2*ch*pow(e0c, 2)*epsc1 +
09322
09323
09324 d*(-(as1*e0cn*fy) +
09325
09326
09327 e0c*(-n0 + as2*e0c*(epsc1 + epsn) +
09328
09329
09330 as1*(fy + e0cn*(-epsc1 + epsn)))), 2) -
09331
09332
09333 2*e0c*(as2*ch*e0c +
09334
09335
09336 as1*d*e0cn)*(-(b*pow(d, 2)*e0c*fc*
09337
09338
09339 pow(epsc1 + epsn,
09340
09341
09342 2)*((-2 + 5*k)*epsc1 - 4*(-1 + k)*epsn)) +
09343
09344
09345 6*k*pow(epsc1,
09346
09347
09348 3)*(as1*d*(e0cn*fy - e0c*(fy + e0cn*epsn)) +
09349
09350
09351 e0c*(as2*ch*e0c*epsc1 +
09352
09353
09354 d*(n0 -
09355
09356
09357 as2*e0c*(epsc1 + epsn)))))))*((3*
09358
09359
09360 pow(e0c,
09361
09362
09363 2)*(pow(as2*(2*ch - d)*e0c + as1*d*e0cn, 2)*k*
09364
09365
09366 pow(epsc1, 2) -
09367
09368
09369 2*(as2*ch*e0c +
09370
09371
09372 as1*d*e0cn)*(2*as2*(ch - d)*e0c*k*
09373
09374
09375 pow(epsc1, 2) +
09376
09377
09378 b*pow(d, 2)*
09379
09380
09381 fc*((-2 + k)*epsc1 + 4*(-1 + k)*epsn))))/(3*
09382
09383
09384 k*pow(epsc1, 2)*
09385
09386
09387 pow(-2*as2*ch*pow(e0c, 2)*epsc1 +
09388
09389
09390 d*(-(as1*e0cn*fy) +
09391
09392
09393 e0c*(-n0 + as2*e0c*(epsc1 + epsn) +
09394
09395
09396 as1*(fy + e0cn*(-epsc1 + epsn)))),
09397
09398
09399 2) - 2*
09400
09401
09402 e0c*(as2*ch*e0c +
09403
09404
09405 as1*d*e0cn)*(-(b*pow(d, 2)*e0c*fc*
09406
09407
09408 pow(epsc1 + epsn,
09409
09410
09411 2)*((-2 + 5*k)*epsc1 -
09412
09413
09414 4*(-1 + k)*epsn)) +
09415
09416
09417 6*k*pow(epsc1,
09418
09419
09420 3)*(as1*d*(e0cn*fy - e0c*(fy + e0cn*epsn)) +
09421
09422
09423 e0c*(as2*ch*e0c*epsc1 +
09424
09425
09426 d*(n0 - as2*e0c*(epsc1 + epsn)))))) -
09427
09428
09429 pow(6*e0c*(as2*(2*ch - d)*e0c + as1*d*e0cn)*k*
09430
09431
09432 pow(epsc1,
09433
09434
09435 2)*(-2*as2*ch*pow(e0c, 2)*epsc1 +
09436
09437
09438 d*(-(as1*e0cn*fy) +
09439
09440
09441 e0c*(-n0 + as2*e0c*(epsc1 + epsn) +
09442
09443
09444 as1*(fy + e0cn*(-epsc1 + epsn))))) +
09445
09446
09447 2*e0c*(as2*ch*e0c +
09448
09449
09450 as1*d*e0cn)*(-6*b*pow(d, 2)*e0c*
09451
09452
09453 fc*(epsc1 + epsn)*(k*(epsc1 - 2*epsn) +
09454
09455
09456 2*epsn) -
09457
09458
09459 6*k*pow(epsc1,
09460
09461
09462 2)*(as1*
09463
09464
09465 d*(-(e0cn*fy) + e0c*(fy + e0cn*epsn)) +
09466
09467
09468 e0c*(-2*as2*ch*e0c*epsc1 +
09469
09470
09471 d*(-n0 + as2*e0c*(2*epsc1 + epsn))))),
09472
09473
09474 2)/(4.*
09475
09476
09477 pow(3*k*pow(epsc1, 2)*
09478
09479
09480 pow(-2*as2*ch*pow(e0c, 2)*epsc1 +
09481
09482
09483 d*(-(as1*e0cn*fy) +
09484
09485
09486 e0c*(-n0 + as2*e0c*(epsc1 + epsn) +
09487
09488
09489 as1*(fy + e0cn*(-epsc1 + epsn)))),
09490
09491
09492 2) - 2*
09493
09494
09495 e0c*(as2*ch*e0c +
09496
09497
09498 as1*d*
09499
09500
09501 e0cn)*(-(b*pow(d, 2)*e0c*fc*
09502
09503
09504 pow(epsc1 + epsn,
09505
09506
09507 2)*((-2 + 5*k)*epsc1 -
09508
09509
09510 4*(-1 + k)*epsn)) +
09511
09512
09513 6*k*pow(epsc1,
09514
09515
09516 3)*(as1*
09517
09518
09519 d*(e0cn*fy - e0c*(fy + e0cn*epsn)) +
09520
09521
09522 e0c*(as2*ch*e0c*epsc1 +
09523
09524
09525 d*(n0 - as2*e0c*(epsc1 + epsn))))),
09526
09527
09528 2))))/((as2*ch*e0c + as1*d*e0cn)*k*epsc1))/(6.*e0c);
09529
09530 ac3 =(sqrt(k*pow(epsc1,
09531
09532
09533 2)*(3*k*pow(epsc1, 2)*
09534
09535
09536 pow(-2*as2*ch*pow(e0c, 2)*epsc1 +
09537
09538
09539 d*(-(as1*e0cn*fy) +
09540
09541
09542 e0c*(-n0 + as2*e0c*(epsc1 + epsn) +
09543
09544
09545 as1*(fy + e0cn*(-epsc1 + epsn)))), 2) -
09546
09547
09548 2*e0c*(as2*ch*e0c +
09549
09550
09551 as1*d*e0cn)*(-(b*pow(d, 2)*e0c*fc*
09552
09553
09554 pow(epsc1 + epsn,
09555
09556
09557 2)*((-2 + 5*k)*epsc1 - 4*(-1 + k)*epsn)) +
09558
09559
09560 6*k*pow(epsc1,
09561
09562
09563 3)*(as1*d*(e0cn*fy - e0c*(fy + e0cn*epsn)) +
09564
09565
09566 e0c*(as2*ch*e0c*epsc1 +
09567
09568
09569 d*(n0 - as2*e0c*(epsc1 + epsn)))))))*((3*
09570
09571
09572 pow(e0c,
09573
09574
09575 2)*(pow(as2*(2*ch - d)*e0c + as1*d*e0cn, 2)*k*
09576
09577
09578 pow(epsc1, 2) -
09579
09580
09581 2*(as2*ch*e0c +
09582
09583
09584 as1*d*e0cn)*(2*as2*(ch - d)*e0c*k*pow(epsc1, 2) +
09585
09586
09587 b*pow(d, 2)*
09588
09589
09590 fc*((-2 + k)*epsc1 + 4*(-1 + k)*epsn))))/(3*k*
09591
09592
09593 pow(epsc1, 2)*
09594
09595
09596 pow(-2*as2*ch*pow(e0c, 2)*epsc1 +
09597
09598
09599 d*(-(as1*e0cn*fy) +
09600
09601
09602 e0c*(-n0 + as2*e0c*(epsc1 + epsn) +
09603
09604
09605 as1*(fy + e0cn*(-epsc1 + epsn)))), 2) -
09606
09607
09608 2*e0c*(as2*ch*e0c +
09609
09610
09611 as1*d*e0cn)*(-(b*pow(d, 2)*e0c*fc*
09612
09613
09614 pow(epsc1 + epsn,
09615
09616
09617 2)*((-2 + 5*k)*epsc1 - 4*(-1 + k)*epsn)) +
09618
09619
09620 6*k*pow(epsc1,
09621
09622
09623 3)*(as1*d*(e0cn*fy - e0c*(fy + e0cn*epsn)) +
09624
09625
09626 e0c*(as2*ch*e0c*epsc1 +
09627
09628
09629 d*(n0 - as2*e0c*(epsc1 + epsn)))))) -
09630
09631
09632 pow(6*e0c*(as2*(2*ch - d)*e0c + as1*d*e0cn)*k*
09633
09634
09635 pow(epsc1,
09636
09637
09638 2)*(-2*as2*ch*pow(e0c, 2)*epsc1 +
09639
09640
09641 d*(-(as1*e0cn*fy) +
09642
09643
09644 e0c*(-n0 + as2*e0c*(epsc1 + epsn) +
09645
09646
09647 as1*(fy + e0cn*(-epsc1 + epsn))))) +
09648
09649
09650 2*e0c*(as2*ch*e0c +
09651
09652
09653 as1*d*e0cn)*(-6*b*pow(d, 2)*e0c*
09654
09655
09656 fc*(epsc1 + epsn)*(k*(epsc1 - 2*epsn) + 2*epsn) -
09657
09658
09659 6*k*pow(epsc1,
09660
09661
09662 2)*(as1*d*(-(e0cn*fy) + e0c*(fy + e0cn*epsn)) +
09663
09664
09665 e0c*(-2*as2*ch*e0c*epsc1 +
09666
09667
09668 d*(-n0 + as2*e0c*(2*epsc1 + epsn))))),
09669
09670
09671 2)/(4.*pow(3*k*pow(epsc1, 2)*
09672
09673
09674 pow(-2*as2*ch*pow(e0c, 2)*epsc1 +
09675
09676
09677 d*(-(as1*e0cn*fy) +
09678
09679
09680 e0c*(-n0 + as2*e0c*(epsc1 + epsn) +
09681
09682
09683 as1*(fy + e0cn*(-epsc1 + epsn)))),
09684
09685
09686 2) - 2*
09687
09688
09689 e0c*(as2*ch*e0c +
09690
09691
09692 as1*d*e0cn)*(-(b*pow(d, 2)*e0c*fc*
09693
09694
09695 pow(epsc1 + epsn,
09696
09697
09698 2)*((-2 + 5*k)*epsc1 -
09699
09700
09701 4*(-1 + k)*epsn)) +
09702
09703
09704 6*k*pow(epsc1,
09705
09706
09707 3)*(as1*d*(e0cn*fy - e0c*(fy + e0cn*epsn)) +
09708
09709
09710 e0c*(as2*ch*e0c*epsc1 +
09711
09712
09713 d*(n0 - as2*e0c*(epsc1 + epsn))))),
09714
09715
09716 2))))/(4.*sqrt(3.)*e0c*(as2*ch*e0c + as1*d*e0cn)*k*
09717
09718
09719 pow(epsc1, 2));
09720
09721
09722
09723
09724
09725 if (pow(ac2, 2) - 4*ac1*ac3 < 0.){
09726 epschr5 = -1.;}
09727 else {epschr5 =(-ac2 + sqrt(pow(ac2, 2) - 4*ac1*ac3))/(2.*ac3);}
09728
09729
09730
09731
09732
09733 return epschr5;
09734
09735
09736 }
09737
09738
09739
09740
09741
09742
09743
09744
09745 double normmat::compute_epscs11 ()
09746
09747
09748 {
09749
09750
09751 double ac1,ac2,ac3,epscs11;
09752
09753
09754
09755
09756
09757 ac1 =(25*sqrt(3.)*
09758
09759
09760 sqrt(k*pow(epsc1,
09761
09762
09763 2)*(3*k*pow(epsc1, 2)*
09764
09765
09766 pow((-5*as2*ch*pow(e0c, 2)*epsc1)/2. +
09767
09768
09769 d*(-(as1*e0cn*fy) +
09770
09771
09772 e0c*(-n0 + as2*e0c*((5*epsc1)/4. + epsn) +
09773
09774
09775 as1*(fy + e0cn*((-5*epsc1)/4. + epsn)))),
09776
09777
09778 2) - 2*e0c*(as2*ch*e0c +
09779
09780
09781 as1*d*e0cn)*(-(b*pow(d, 2)*e0c*fc*
09782
09783
09784 pow(5*epsc1 + 4*epsn,
09785
09786
09787 2)*((-1 + 4*k)*epsc1 - 4*(-1 + k)*epsn))/
09788
09789
09790 16. + (15*k*
09791
09792
09793 pow(epsc1,
09794
09795
09796 3)*(as1*d*(e0cn*fy - e0c*(fy + e0cn*epsn)) +
09797
09798
09799 e0c*((5*as2*ch*e0c*epsc1)/4. +
09800
09801
09802 d*(n0 - (as2*e0c*(5*epsc1 + 4*epsn))/
09803
09804
09805 4.))))/2.)))*(-pow(2*
09806
09807
09808 e0c*(as2*ch*e0c +
09809
09810
09811 as1*d*e0cn)*((-3*b*pow(d, 2)*e0c*
09812
09813
09814 fc*(5*epsc1 + 4*epsn)*(epsc1 + k*epsc1 +
09815
09816
09817 4*epsn - 4*k*epsn))/4. -
09818
09819
09820 3*k*pow(epsc1,
09821
09822
09823 2)*(e0c*(-2*d*n0 - 5*as2*ch*e0c*epsc1 +
09824
09825
09826 5*as2*d*e0c*epsc1 + 2*as2*d*e0c*epsn) +
09827
09828
09829 2*as1*
09830
09831
09832 d*(e0c*fy - e0cn*fy + e0c*e0cn*epsn))) +
09833
09834
09835 6*e0c*(as2*(2*ch - d)*e0c + as1*d*e0cn)*k*
09836
09837
09838 pow(epsc1,
09839
09840
09841 2)*((-5*as2*ch*pow(e0c, 2)*epsc1)/2. +
09842
09843
09844 d*(-(as1*e0cn*fy) +
09845
09846
09847 e0c*(-n0 + as2*e0c*((5*epsc1)/4. + epsn) +
09848
09849
09850 as1*(fy +
09851
09852
09853 e0cn*((-5*epsc1)/4. + epsn))))),
09854
09855
09856 2)/(4.*pow(3*k*pow(epsc1, 2)*
09857
09858
09859 pow((-5*as2*ch*pow(e0c, 2)*epsc1)/2. +
09860
09861
09862 d*(-(as1*e0cn*fy) +
09863
09864
09865 e0c*(-n0 + as2*e0c*((5*epsc1)/4. + epsn) +
09866
09867
09868 as1*(fy +
09869
09870
09871 e0cn*((-5*epsc1)/4. + epsn)))), 2) -
09872
09873
09874 2*e0c*(as2*ch*e0c +
09875
09876
09877 as1*d*e0cn)*(-(b*pow(d, 2)*e0c*fc*
09878
09879
09880 pow(5*epsc1 + 4*epsn,
09881
09882
09883 2)*((-1 + 4*k)*epsc1 -
09884
09885
09886 4*(-1 + k)*epsn))/
09887
09888
09889 16. + (15*k*
09890
09891
09892 pow(epsc1,
09893
09894
09895 3)*(as1*
09896
09897
09898 d*(e0cn*fy - e0c*(fy + e0cn*epsn)) +
09899
09900
09901 e0c*((5*as2*ch*e0c*epsc1)/4. +
09902
09903
09904 d*(n0 - (as2*e0c*(5*epsc1 + 4*epsn))/
09905
09906
09907 4.))))/2.), 2)) + (3*
09908
09909
09910 pow(e0c,
09911
09912
09913 2)*(pow(as2*(2*ch - d)*e0c + as1*d*e0cn, 2)*k*
09914
09915
09916 pow(epsc1, 2) -
09917
09918
09919 2*(as2*ch*e0c +
09920
09921
09922 as1*d*e0cn)*(2*as2*(ch - d)*e0c*k*pow(epsc1, 2) +
09923
09924
09925 b*pow(d, 2)*
09926
09927
09928 fc*((-3 + 2*k)*epsc1 + 4*(-1 + k)*epsn))))/(3*k*
09929
09930
09931 pow(epsc1, 2)*
09932
09933
09934 pow((-5*as2*ch*pow(e0c, 2)*epsc1)/2. +
09935
09936
09937 d*(-(as1*e0cn*fy) +
09938
09939
09940 e0c*(-n0 + as2*e0c*((5*epsc1)/4. + epsn) +
09941
09942
09943 as1*(fy + e0cn*((-5*epsc1)/4. + epsn)))),
09944
09945
09946 2) - 2*e0c*(as2*ch*e0c +
09947
09948
09949 as1*d*e0cn)*(-(b*pow(d, 2)*e0c*fc*
09950
09951
09952 pow(5*epsc1 + 4*epsn,
09953
09954
09955 2)*((-1 + 4*k)*epsc1 - 4*(-1 + k)*epsn))/
09956
09957
09958 16. + (15*k*
09959
09960
09961 pow(epsc1,
09962
09963
09964 3)*(as1*d*(e0cn*fy - e0c*(fy + e0cn*epsn)) +
09965
09966
09967 e0c*((5*as2*ch*e0c*epsc1)/4. +
09968
09969
09970 d*(n0 - (as2*e0c*(5*epsc1 + 4*epsn))/
09971
09972
09973 4.))))/2.))) -
09974
09975
09976 30*e0c*k*epsc1*(8*as2*ch*e0c - 4*as2*d*e0c +
09977
09978
09979 4*as1*d*e0cn + (sqrt(3.)*
09980
09981
09982 pow(d, 2)*(pow(as2, 2)*pow(e0c, 3)*k*
09983
09984
09985 pow(epsc1, 2)*(5*epsc1 + 4*epsn) +
09986
09987
09988 as1*e0cn*(b*d*e0c*
09989
09990
09991 fc*(5*epsc1 + 4*epsn)*(epsc1 + k*epsc1 +
09992
09993
09994 4*epsn - 4*k*epsn) +
09995
09996
09997 k*pow(epsc1,
09998
09999
10000 2)*(-4*e0c*n0 +
10001
10002
10003 as1*(4*e0c*fy - 4*e0cn*fy +
10004
10005
10006 5*e0c*e0cn*epsc1 +
10007
10008
10009 4*e0c*e0cn*epsn))) +
10010
10011
10012 as2*e0c*(b*ch*e0c*
10013
10014
10015 fc*(5*epsc1 + 4*epsn)*(epsc1 + k*epsc1 +
10016
10017
10018 4*epsn - 4*k*epsn) +
10019
10020
10021 2*k*pow(epsc1,
10022
10023
10024 2)*(-2*e0c*n0 +
10025
10026
10027 as1*(2*e0c*fy - 2*e0cn*fy +
10028
10029
10030 5*e0c*e0cn*epsc1 +
10031
10032
10033 4*e0c*e0cn*epsn)))))/
10034
10035
10036 sqrt(k*pow(epsc1,
10037
10038
10039 2)*(3*k*pow(epsc1, 2)*
10040
10041
10042 pow((-5*as2*ch*pow(e0c, 2)*epsc1)/2. +
10043
10044
10045 d*(-(as1*e0cn*fy) +
10046
10047
10048 e0c*(-n0 + as2*e0c*((5*epsc1)/4. + epsn) +
10049
10050
10051 as1*(fy +
10052
10053
10054 e0cn*((-5*epsc1)/4. + epsn)))), 2) -
10055
10056
10057 2*e0c*(as2*ch*e0c +
10058
10059
10060 as1*d*e0cn)*(-(b*pow(d, 2)*e0c*fc*
10061
10062
10063 pow(5*epsc1 + 4*epsn,
10064
10065
10066 2)*((-1 + 4*k)*epsc1 -
10067
10068
10069 4*(-1 + k)*epsn))/
10070
10071
10072 16. + (15*k*
10073
10074
10075 pow(epsc1,
10076
10077
10078 3)*(as1*
10079
10080
10081 d*(e0cn*fy - e0c*(fy + e0cn*epsn)) +
10082
10083
10084 e0c*((5*as2*ch*e0c*epsc1)/4. +
10085
10086
10087 d*(n0 - (as2*e0c*(5*epsc1 + 4*epsn))/
10088
10089
10090 4.))))/2.)))) + (32*((15*as2*ch*
10091
10092
10093 pow(e0c, 2)*k*pow(epsc1, 3))/2. -
10094
10095
10096 3*d*k*pow(epsc1,
10097
10098
10099 2)*(-(as1*e0cn*fy) +
10100
10101
10102 e0c*(-n0 + as2*e0c*((5*epsc1)/4. + epsn) +
10103
10104
10105 as1*(fy + e0cn*((-5*epsc1)/4. + epsn)))) +
10106
10107
10108 sqrt(3.)*
10109
10110
10111 sqrt(k*pow(epsc1,
10112
10113
10114 2)*(3*k*pow(epsc1, 2)*
10115
10116
10117 pow((-5*as2*ch*pow(e0c, 2)*epsc1)/2. +
10118
10119
10120 d*(-(as1*e0cn*fy) +
10121
10122
10123 e0c*(-n0 +
10124
10125
10126 as2*e0c*((5*epsc1)/4. + epsn) +
10127
10128
10129 as1*(fy + e0cn*((-5*epsc1)/4. +
10130
10131
10132 epsn)))), 2) -
10133
10134
10135 2*e0c*(as2*ch*e0c +
10136
10137
10138 as1*d*
10139
10140
10141 e0cn)*(-(b*pow(d, 2)*e0c*fc*
10142
10143
10144 pow(5*epsc1 + 4*epsn,
10145
10146
10147 2)*((-1 + 4*k)*epsc1 -
10148
10149
10150 4*(-1 + k)*epsn))/
10151
10152
10153 16. + (15*k*
10154
10155
10156 pow(epsc1,
10157
10158
10159 3)*(as1*
10160
10161
10162 d*(e0cn*fy - e0c*(fy + e0cn*epsn)) +
10163
10164
10165 e0c*((5*as2*ch*e0c*epsc1)/4. +
10166
10167
10168 d*(n0 - (as2*e0c*(5*epsc1 + 4*epsn))/
10169
10170
10171 4.))))/2.)))))/pow(epsc1, 2))/(192.*
10172
10173
10174 e0c*(as2*ch*e0c + as1*d*e0cn)*k);
10175
10176
10177
10178
10179
10180 ac2 =(-5*sqrt(3.)*
10181
10182
10183 sqrt(k*pow(epsc1,
10184
10185
10186 2)*(3*k*pow(epsc1, 2)*
10187
10188
10189 pow((-5*as2*ch*pow(e0c, 2)*epsc1)/2. +
10190
10191
10192 d*(-(as1*e0cn*fy) +
10193
10194
10195 e0c*(-n0 + as2*e0c*((5*epsc1)/4. + epsn) +
10196
10197
10198 as1*(fy + e0cn*((-5*epsc1)/4. + epsn)))),
10199
10200
10201 2) - 2*e0c*(as2*ch*e0c +
10202
10203
10204 as1*d*e0cn)*(-(b*pow(d, 2)*e0c*fc*
10205
10206
10207 pow(5*epsc1 + 4*epsn,
10208
10209
10210 2)*((-1 + 4*k)*epsc1 - 4*(-1 + k)*epsn))/
10211
10212
10213 16. + (15*k*
10214
10215
10216 pow(epsc1,
10217
10218
10219 3)*(as1*d*(e0cn*fy - e0c*(fy + e0cn*epsn)) +
10220
10221
10222 e0c*((5*as2*ch*e0c*epsc1)/4. +
10223
10224
10225 d*(n0 - (as2*e0c*(5*epsc1 + 4*epsn))/
10226
10227
10228 4.))))/2.)))*(-pow(2*
10229
10230
10231 e0c*(as2*ch*e0c +
10232
10233
10234 as1*d*e0cn)*((-3*b*pow(d, 2)*e0c*
10235
10236
10237 fc*(5*epsc1 + 4*epsn)*(epsc1 + k*epsc1 +
10238
10239
10240 4*epsn - 4*k*epsn))/4. -
10241
10242
10243 3*k*pow(epsc1,
10244
10245
10246 2)*(e0c*(-2*d*n0 - 5*as2*ch*e0c*epsc1 +
10247
10248
10249 5*as2*d*e0c*epsc1 + 2*as2*d*e0c*epsn) +
10250
10251
10252 2*as1*
10253
10254
10255 d*(e0c*fy - e0cn*fy + e0c*e0cn*epsn))) +
10256
10257
10258 6*e0c*(as2*(2*ch - d)*e0c + as1*d*e0cn)*k*
10259
10260
10261 pow(epsc1,
10262
10263
10264 2)*((-5*as2*ch*pow(e0c, 2)*epsc1)/2. +
10265
10266
10267 d*(-(as1*e0cn*fy) +
10268
10269
10270 e0c*(-n0 + as2*e0c*((5*epsc1)/4. + epsn) +
10271
10272
10273 as1*(fy +
10274
10275
10276 e0cn*((-5*epsc1)/4. + epsn))))),
10277
10278
10279 2)/(4.*pow(3*k*pow(epsc1, 2)*
10280
10281
10282 pow((-5*as2*ch*pow(e0c, 2)*epsc1)/2. +
10283
10284
10285 d*(-(as1*e0cn*fy) +
10286
10287
10288 e0c*(-n0 + as2*e0c*((5*epsc1)/4. + epsn) +
10289
10290
10291 as1*(fy +
10292
10293
10294 e0cn*((-5*epsc1)/4. + epsn)))), 2) -
10295
10296
10297 2*e0c*(as2*ch*e0c +
10298
10299
10300 as1*d*e0cn)*(-(b*pow(d, 2)*e0c*fc*
10301
10302
10303 pow(5*epsc1 + 4*epsn,
10304
10305
10306 2)*((-1 + 4*k)*epsc1 -
10307
10308
10309 4*(-1 + k)*epsn))/
10310
10311
10312 16. + (15*k*
10313
10314
10315 pow(epsc1,
10316
10317
10318 3)*(as1*
10319
10320
10321 d*(e0cn*fy - e0c*(fy + e0cn*epsn)) +
10322
10323
10324 e0c*((5*as2*ch*e0c*epsc1)/4. +
10325
10326
10327 d*(n0 - (as2*e0c*(5*epsc1 + 4*epsn))/
10328
10329
10330 4.))))/2.), 2)) + (3*
10331
10332
10333 pow(e0c,
10334
10335
10336 2)*(pow(as2*(2*ch - d)*e0c + as1*d*e0cn, 2)*k*
10337
10338
10339 pow(epsc1, 2) -
10340
10341
10342 2*(as2*ch*e0c +
10343
10344
10345 as1*d*e0cn)*(2*as2*(ch - d)*e0c*k*pow(epsc1, 2) +
10346
10347
10348 b*pow(d, 2)*
10349
10350
10351 fc*((-3 + 2*k)*epsc1 + 4*(-1 + k)*epsn))))/(3*k*
10352
10353
10354 pow(epsc1, 2)*
10355
10356
10357 pow((-5*as2*ch*pow(e0c, 2)*epsc1)/2. +
10358
10359
10360 d*(-(as1*e0cn*fy) +
10361
10362
10363 e0c*(-n0 + as2*e0c*((5*epsc1)/4. + epsn) +
10364
10365
10366 as1*(fy + e0cn*((-5*epsc1)/4. + epsn)))),
10367
10368
10369 2) - 2*e0c*(as2*ch*e0c +
10370
10371
10372 as1*d*e0cn)*(-(b*pow(d, 2)*e0c*fc*
10373
10374
10375 pow(5*epsc1 + 4*epsn,
10376
10377
10378 2)*((-1 + 4*k)*epsc1 - 4*(-1 + k)*epsn))/
10379
10380
10381 16. + (15*k*
10382
10383
10384 pow(epsc1,
10385
10386
10387 3)*(as1*d*(e0cn*fy - e0c*(fy + e0cn*epsn)) +
10388
10389
10390 e0c*((5*as2*ch*e0c*epsc1)/4. +
10391
10392
10393 d*(n0 - (as2*e0c*(5*epsc1 + 4*epsn))/
10394
10395
10396 4.))))/2.))) +
10397
10398
10399 3*e0c*k*epsc1*(8*as2*ch*e0c - 4*as2*d*e0c +
10400
10401
10402 4*as1*d*e0cn + (sqrt(3.)*
10403
10404
10405 pow(d, 2)*(pow(as2, 2)*pow(e0c, 3)*k*
10406
10407
10408 pow(epsc1, 2)*(5*epsc1 + 4*epsn) +
10409
10410
10411 as1*e0cn*(b*d*e0c*
10412
10413
10414 fc*(5*epsc1 + 4*epsn)*(epsc1 + k*epsc1 +
10415
10416
10417 4*epsn - 4*k*epsn) +
10418
10419
10420 k*pow(epsc1,
10421
10422
10423 2)*(-4*e0c*n0 +
10424
10425
10426 as1*(4*e0c*fy - 4*e0cn*fy +
10427
10428
10429 5*e0c*e0cn*epsc1 +
10430
10431
10432 4*e0c*e0cn*epsn))) +
10433
10434
10435 as2*e0c*(b*ch*e0c*
10436
10437
10438 fc*(5*epsc1 + 4*epsn)*(epsc1 + k*epsc1 +
10439
10440
10441 4*epsn - 4*k*epsn) +
10442
10443
10444 2*k*pow(epsc1,
10445
10446
10447 2)*(-2*e0c*n0 +
10448
10449
10450 as1*(2*e0c*fy - 2*e0cn*fy +
10451
10452
10453 5*e0c*e0cn*epsc1 +
10454
10455
10456 4*e0c*e0cn*epsn)))))/
10457
10458
10459 sqrt(k*pow(epsc1,
10460
10461
10462 2)*(3*k*pow(epsc1, 2)*
10463
10464
10465 pow((-5*as2*ch*pow(e0c, 2)*epsc1)/2. +
10466
10467
10468 d*(-(as1*e0cn*fy) +
10469
10470
10471 e0c*(-n0 + as2*e0c*((5*epsc1)/4. + epsn) +
10472
10473
10474 as1*(fy +
10475
10476
10477 e0cn*((-5*epsc1)/4. + epsn)))), 2) -
10478
10479
10480 2*e0c*(as2*ch*e0c +
10481
10482
10483 as1*d*e0cn)*(-(b*pow(d, 2)*e0c*fc*
10484
10485
10486 pow(5*epsc1 + 4*epsn,
10487
10488
10489 2)*((-1 + 4*k)*epsc1 -
10490
10491
10492 4*(-1 + k)*epsn))/
10493
10494
10495 16. + (15*k*
10496
10497
10498 pow(epsc1,
10499
10500
10501 3)*(as1*
10502
10503
10504 d*(e0cn*fy - e0c*(fy + e0cn*epsn)) +
10505
10506
10507 e0c*((5*as2*ch*e0c*epsc1)/4. +
10508
10509
10510 d*(n0 - (as2*e0c*(5*epsc1 + 4*epsn))/
10511
10512
10513 4.))))/2.)))))/(24.*
10514
10515
10516 e0c*(as2*ch*e0c + as1*d*e0cn)*k*epsc1);
10517
10518
10519
10520
10521
10522 ac3 =(sqrt(k*pow(epsc1,
10523
10524
10525 2)*(3*k*pow(epsc1, 2)*
10526
10527
10528 pow((-5*as2*ch*pow(e0c, 2)*epsc1)/2. +
10529
10530
10531 d*(-(as1*e0cn*fy) +
10532
10533
10534 e0c*(-n0 + as2*e0c*((5*epsc1)/4. + epsn) +
10535
10536
10537 as1*(fy + e0cn*((-5*epsc1)/4. + epsn)))),
10538
10539
10540 2) - 2*e0c*(as2*ch*e0c +
10541
10542
10543 as1*d*e0cn)*(-(b*pow(d, 2)*e0c*fc*
10544
10545
10546 pow(5*epsc1 + 4*epsn,
10547
10548
10549 2)*((-1 + 4*k)*epsc1 - 4*(-1 + k)*epsn))/
10550
10551
10552 16. + (15*k*
10553
10554
10555 pow(epsc1,
10556
10557
10558 3)*(as1*d*(e0cn*fy - e0c*(fy + e0cn*epsn)) +
10559
10560
10561 e0c*((5*as2*ch*e0c*epsc1)/4. +
10562
10563
10564 d*(n0 - (as2*e0c*(5*epsc1 + 4*epsn))/
10565
10566
10567 4.))))/2.)))*(-pow(2*
10568
10569
10570 e0c*(as2*ch*e0c +
10571
10572
10573 as1*d*e0cn)*((-3*b*pow(d, 2)*e0c*
10574
10575
10576 fc*(5*epsc1 + 4*epsn)*(epsc1 + k*epsc1 +
10577
10578
10579 4*epsn - 4*k*epsn))/4. -
10580
10581
10582 3*k*pow(epsc1,
10583
10584
10585 2)*(e0c*(-2*d*n0 - 5*as2*ch*e0c*epsc1 +
10586
10587
10588 5*as2*d*e0c*epsc1 + 2*as2*d*e0c*epsn) +
10589
10590
10591 2*as1*d*(e0c*fy - e0cn*fy + e0c*e0cn*epsn))) +
10592
10593
10594 6*e0c*(as2*(2*ch - d)*e0c + as1*d*e0cn)*k*
10595
10596
10597 pow(epsc1,
10598
10599
10600 2)*((-5*as2*ch*pow(e0c, 2)*epsc1)/2. +
10601
10602
10603 d*(-(as1*e0cn*fy) +
10604
10605
10606 e0c*(-n0 + as2*e0c*((5*epsc1)/4. + epsn) +
10607
10608
10609 as1*(fy + e0cn*((-5*epsc1)/4. + epsn))))),
10610
10611
10612 2)/(4.*
10613
10614
10615 pow(3*k*pow(epsc1, 2)*
10616
10617
10618 pow((-5*as2*ch*pow(e0c, 2)*epsc1)/2. +
10619
10620
10621 d*(-(as1*e0cn*fy) +
10622
10623
10624 e0c*(-n0 + as2*e0c*((5*epsc1)/4. + epsn) +
10625
10626
10627 as1*(fy +
10628
10629
10630 e0cn*((-5*epsc1)/4. + epsn)))), 2) -
10631
10632
10633 2*e0c*(as2*ch*e0c +
10634
10635
10636 as1*d*e0cn)*(-(b*pow(d, 2)*e0c*fc*
10637
10638
10639 pow(5*epsc1 + 4*epsn,
10640
10641
10642 2)*((-1 + 4*k)*epsc1 -
10643
10644
10645 4*(-1 + k)*epsn))/
10646
10647
10648 16. + (15*k*
10649
10650
10651 pow(epsc1,
10652
10653
10654 3)*(as1*
10655
10656
10657 d*(e0cn*fy - e0c*(fy + e0cn*epsn)) +
10658
10659
10660 e0c*((5*as2*ch*e0c*epsc1)/4. +
10661
10662
10663 d*(n0 - (as2*e0c*(5*epsc1 + 4*epsn))/
10664
10665
10666 4.))))/2.), 2)) + (3*
10667
10668
10669 pow(e0c,
10670
10671
10672 2)*(pow(as2*(2*ch - d)*e0c + as1*d*e0cn, 2)*k*
10673
10674
10675 pow(epsc1, 2) -
10676
10677
10678 2*(as2*ch*e0c +
10679
10680
10681 as1*d*e0cn)*(2*as2*(ch - d)*e0c*k*pow(epsc1, 2) +
10682
10683
10684 b*pow(d, 2)*
10685
10686
10687 fc*((-3 + 2*k)*epsc1 + 4*(-1 + k)*epsn))))/(3*k*
10688
10689
10690 pow(epsc1, 2)*
10691
10692
10693 pow((-5*as2*ch*pow(e0c, 2)*epsc1)/2. +
10694
10695
10696 d*(-(as1*e0cn*fy) +
10697
10698
10699 e0c*(-n0 + as2*e0c*((5*epsc1)/4. + epsn) +
10700
10701
10702 as1*(fy + e0cn*((-5*epsc1)/4. + epsn)))),
10703
10704
10705 2) - 2*e0c*(as2*ch*e0c +
10706
10707
10708 as1*d*e0cn)*(-(b*pow(d, 2)*e0c*fc*
10709
10710
10711 pow(5*epsc1 + 4*epsn,
10712
10713
10714 2)*((-1 + 4*k)*epsc1 - 4*(-1 + k)*epsn))/
10715
10716
10717 16. + (15*k*
10718
10719
10720 pow(epsc1,
10721
10722
10723 3)*(as1*d*(e0cn*fy - e0c*(fy + e0cn*epsn)) +
10724
10725
10726 e0c*((5*as2*ch*e0c*epsc1)/4. +
10727
10728
10729 d*(n0 - (as2*e0c*(5*epsc1 + 4*epsn))/
10730
10731
10732 4.))))/2.))))/(4.*sqrt(3.)*
10733
10734
10735 e0c*(as2*ch*e0c + as1*d*e0cn)*k*pow(epsc1, 2));
10736
10737
10738
10739
10740
10741 if (pow(ac2, 2) - 4*ac1*ac3 + 4*ac3*epss1lim < 0.0){
10742
10743
10744
10745
10746
10747 epscs11=-1.0;
10748
10749
10750 }
10751
10752
10753 else{
10754
10755
10756
10757
10758
10759 epscs11=-((ac2 + sqrt(pow(ac2, 2) - 4*ac1*ac3 + 4*ac3*epss1lim))/(2.*ac3));
10760
10761
10762 }
10763
10764
10765 return epscs11;
10766
10767
10768 }
10769
10770
10771
10772
10773
10774
10775
10776
10777 double normmat::compute_mhr5 ()
10778
10779
10780 {
10781
10782
10783 double mhr5;
10784
10785
10786
10787 if(epschr5 == -1.){mhr5 = 1000000000.;}
10788
10789 else { mhr5 =(-6*as2*e0c*(-2*ch + h)*(epschr5 - (ch*epschr5)/d +
10790
10791
10792 epsn + (ch*(6*as2*ch*pow(e0c, 2)*k*epschr5*pow(epsc1, 2) -
10793
10794
10795 3*d*k*pow(epsc1,
10796
10797
10798 2)*(-(as1*e0cn*fy) +
10799
10800
10801 e0c*(-n0 + as2*e0c*(epschr5 + epsn) +
10802
10803
10804 as1*(fy + e0cn*(-epschr5 + epsn)))) +
10805
10806
10807 sqrt(3.)*
10808
10809
10810 sqrt(k*
10811
10812
10813 pow(epsc1,
10814
10815
10816 2)*(3*k*pow(epsc1, 2)*
10817
10818
10819 pow(-2*as2*ch*pow(e0c, 2)*epschr5 +
10820
10821
10822 d*(-(as1*e0cn*fy) +
10823
10824
10825 e0c*(-n0 + as2*e0c*(epschr5 + epsn) +
10826
10827
10828 as1*(fy + e0cn*(-epschr5 + epsn)))),
10829
10830
10831 2) - 2*
10832
10833
10834 e0c*(as2*ch*e0c +
10835
10836
10837 as1*d*e0cn)*(b*pow(d, 2)*e0c*fc*
10838
10839
10840 pow(epschr5 + epsn,
10841
10842
10843 2)*(4*(-1 + k)*epschr5 + (6 - 9*k)*
10844
10845
10846 epsc1 + 4*(-1 + k)*epsn) +
10847
10848
10849 6*k*epschr5*
10850
10851
10852 pow(epsc1,
10853
10854
10855 2)*(as1*
10856
10857
10858 d*(e0cn*fy - e0c*(fy + e0cn*epsn)) +
10859
10860
10861 e0c*(as2*ch*e0c*epschr5 +
10862
10863
10864 d*(n0 - as2*e0c*(epschr5 +
10865
10866
10867 epsn)))))))))/(6.*d*
10868
10869
10870 e0c*(as2*ch*e0c + as1*d*e0cn)*k*pow(epsc1, 2))) - (b*d*fc*
10871
10872
10873 pow(epschr5 + epsn,
10874
10875
10876 2)*(2*d*(epschr5 +
10877
10878
10879 epsn)*((-1 + k)*epschr5 + (2 - 3*k)*epsc1 + (-1 + k)*
10880
10881
10882 epsn) -
10883
10884
10885 h*(4*(-1 + k)*epschr5 + (6 - 9*k)*epsc1 +
10886
10887
10888 4*(-1 + k)*
10889
10890
10891 epsn)*(epschr5 - (6*as2*ch*pow(e0c, 2)*k*epschr5*
10892
10893
10894 pow(epsc1, 2) -
10895
10896
10897 3*d*k*pow(epsc1,
10898
10899
10900 2)*(-(as1*e0cn*fy) +
10901
10902
10903 e0c*(-n0 + as2*e0c*(epschr5 + epsn) +
10904
10905
10906 as1*(fy + e0cn*(-epschr5 + epsn)))) +
10907
10908
10909 sqrt(3.)*
10910
10911
10912 sqrt(k*
10913
10914
10915 pow(epsc1,
10916
10917
10918 2)*(3*k*pow(epsc1, 2)*
10919
10920
10921 pow(-2*as2*ch*pow(e0c, 2)*epschr5 +
10922
10923
10924 d*(-(as1*e0cn*fy) +
10925
10926
10927 e0c*(-n0 + as2*e0c*(epschr5 + epsn) +
10928
10929
10930 as1*(fy + e0cn*(-epschr5 + epsn)))),
10931
10932
10933 2) -
10934
10935
10936 2*e0c*(as2*ch*e0c +
10937
10938
10939 as1*d*e0cn)*(b*pow(d, 2)*e0c*fc*
10940
10941
10942 pow(epschr5 + epsn,
10943
10944
10945 2)*(4*(-1 + k)*epschr5 + (6 - 9*k)*
10946
10947
10948 epsc1 + 4*(-1 + k)*epsn) +
10949
10950
10951 6*k*epschr5*
10952
10953
10954 pow(epsc1,
10955
10956
10957 2)*(as1*d*(e0cn*fy -
10958
10959
10960 e0c*(fy + e0cn*epsn)) +
10961
10962
10963 e0c*(as2*ch*e0c*epschr5 +
10964
10965
10966 d*(n0 - as2*e0c*(epschr5 +
10967
10968
10969 epsn))))))))/(6.*
10970
10971
10972 e0c*(as2*ch*e0c + as1*d*e0cn)*k*
10973
10974
10975 pow(epsc1, 2)))))/(k*pow(epsc1, 2)*
10976
10977
10978 pow(epschr5 - (6*as2*ch*pow(e0c, 2)*k*epschr5*pow(epsc1, 2) -
10979
10980
10981 3*d*k*pow(epsc1,
10982
10983
10984 2)*(-(as1*e0cn*fy) +
10985
10986
10987 e0c*(-n0 + as2*e0c*(epschr5 + epsn) +
10988
10989
10990 as1*(fy + e0cn*(-epschr5 + epsn)))) +
10991
10992
10993 sqrt(3.)*
10994
10995
10996 sqrt(k*
10997
10998
10999 pow(epsc1,
11000
11001
11002 2)*(3*k*pow(epsc1, 2)*
11003
11004
11005 pow(-2*as2*ch*pow(e0c, 2)*epschr5 +
11006
11007
11008 d*(-(as1*e0cn*fy) +
11009
11010
11011 e0c*(-n0 + as2*e0c*(epschr5 + epsn) +
11012
11013
11014 as1*(fy + e0cn*(-epschr5 + epsn)))),
11015
11016
11017 2) - 2*
11018
11019
11020 e0c*(as2*ch*e0c +
11021
11022
11023 as1*d*e0cn)*(b*pow(d, 2)*e0c*fc*
11024
11025
11026 pow(epschr5 + epsn,
11027
11028
11029 2)*(4*(-1 + k)*epschr5 + (6 - 9*k)*
11030
11031
11032 epsc1 + 4*(-1 + k)*epsn) +
11033
11034
11035 6*k*epschr5*
11036
11037
11038 pow(epsc1,
11039
11040
11041 2)*(as1*
11042
11043
11044 d*(e0cn*fy - e0c*(fy + e0cn*epsn)) +
11045
11046
11047 e0c*(as2*ch*e0c*epschr5 +
11048
11049
11050 d*(n0 - as2*e0c*(epschr5 +
11051
11052
11053 epsn))))))))/(6.*
11054
11055
11056 e0c*(as2*ch*e0c + as1*d*e0cn)*k*pow(epsc1, 2)), 2)) +
11057
11058
11059 6*as1*(-2*cd + h)*(fy +
11060
11061
11062 e0cn*(-(fy/e0c) +
11063
11064
11065 epsn + (6*as2*ch*pow(e0c, 2)*k*epschr5*pow(epsc1, 2) -
11066
11067
11068 3*d*k*pow(epsc1,
11069
11070
11071 2)*(-(as1*e0cn*fy) +
11072
11073
11074 e0c*(-n0 + as2*e0c*(epschr5 + epsn) +
11075
11076
11077 as1*(fy + e0cn*(-epschr5 + epsn)))) +
11078
11079
11080 sqrt(3.)*
11081
11082
11083 sqrt(k*
11084
11085
11086 pow(epsc1,
11087
11088
11089 2)*(3*k*pow(epsc1, 2)*
11090
11091
11092 pow(-2*as2*ch*pow(e0c, 2)*epschr5 +
11093
11094
11095 d*(-(as1*e0cn*fy) +
11096
11097
11098 e0c*(-n0 + as2*e0c*(epschr5 + epsn) +
11099
11100
11101 as1*(fy + e0cn*(-epschr5 + epsn)))),
11102
11103
11104 2) - 2*
11105
11106
11107 e0c*(as2*ch*e0c +
11108
11109
11110 as1*d*e0cn)*(b*pow(d, 2)*e0c*fc*
11111
11112
11113 pow(epschr5 + epsn,
11114
11115
11116 2)*(4*(-1 + k)*epschr5 + (6 - 9*k)*
11117
11118
11119 epsc1 + 4*(-1 + k)*epsn) +
11120
11121
11122 6*k*epschr5*
11123
11124
11125 pow(epsc1,
11126
11127
11128 2)*(as1*
11129
11130
11131 d*(e0cn*fy - e0c*(fy + e0cn*epsn)) +
11132
11133
11134 e0c*(as2*ch*e0c*epschr5 +
11135
11136
11137 d*(n0 - as2*e0c*(epschr5 +
11138
11139
11140 epsn))))))))/(6.*
11141
11142
11143 e0c*(as2*ch*e0c + as1*d*e0cn)*k*pow(epsc1, 2)))))/12. + e0c*(-(as1*(-cd + h/2.)) + as2*(-ch + h/2.))*epsn;}
11144
11145
11146
11147
11148
11149 return mhr5;
11150
11151
11152 }
11153
11154
11155
11156
11157
11158
11159
11160
11161 double normmat::compute_mmax2 ()
11162
11163
11164 {
11165
11166
11167 double mmax2;
11168
11169
11170
11171
11172
11173 mmax2 =((-36*b*d*pow(e0c, 2)*pow(as2*ch*e0c + as1*d*e0cn, 3)*fc*pow(k, 2)*
11174
11175
11176 pow(epsc1, 4)*
11177
11178
11179 pow(epscmax1 + epsn,
11180
11181
11182 2)*(2*d*(epscmax1 +
11183
11184
11185 epsn)*((2 - 3*k)*
11186
11187
11188 epsc1 + (-1 + k)*(epscmax1 +
11189
11190
11191 epsn)) + (h*(3*(-2 + 3*k)*epsc1 -
11192
11193
11194 4*(-1 + k)*(epscmax1 + epsn))*(3*d*e0c*k*
11195
11196
11197 pow(epsc1,
11198
11199
11200 2)*(-n0 + as2*e0c*(epscmax1 + epsn)) +
11201
11202
11203 3*as1*d*k*
11204
11205
11206 pow(epsc1,
11207
11208
11209 2)*(-(e0cn*fy) +
11210
11211
11212 e0c*(fy + e0cn*(epscmax1 + epsn))) -
11213
11214
11215 sqrt(3.)*
11216
11217
11218 sqrt(k*
11219
11220
11221 pow(epsc1,
11222
11223
11224 2)*(3*k*pow(epsc1, 2)*
11225
11226
11227 pow(-2*as2*ch*pow(e0c, 2)*epscmax1 +
11228
11229
11230 d*(-(as1*e0cn*fy) +
11231
11232
11233 e0c*(-n0 + as2*e0c*(epscmax1 + epsn) +
11234
11235
11236 as1*(fy + e0cn*(-epscmax1 + epsn)))),
11237
11238
11239 2) -
11240
11241
11242 2*e0c*(as2*ch*e0c +
11243
11244
11245 as1*d*e0cn)*(b*pow(d, 2)*e0c*fc*
11246
11247
11248 pow(epscmax1 + epsn,
11249
11250
11251 2)*((6 - 9*k)*epsc1 +
11252
11253
11254 4*(-1 + k)*(epscmax1 + epsn)) +
11255
11256
11257 6*k*pow(epsc1, 2)*
11258
11259
11260 epscmax1*(as1*
11261
11262
11263 d*(e0cn*fy - e0c*(fy + e0cn*epsn)) +
11264
11265
11266 e0c*(as2*ch*e0c*epscmax1 +
11267
11268
11269 d*(n0 - as2*e0c*(epscmax1 +
11270
11271
11272 epsn)))))))))/(6.*
11273
11274
11275 e0c*(as2*ch*e0c + as1*d*e0cn)*k*pow(epsc1, 2))))/
11276
11277
11278 pow(3*d*e0c*k*pow(epsc1, 2)*(-n0 + as2*e0c*(epscmax1 + epsn)) +
11279
11280
11281 3*as1*d*k*
11282
11283
11284 pow(epsc1, 2)*(-(e0cn*fy) + e0c*(fy + e0cn*(epscmax1 + epsn))) -
11285
11286
11287 sqrt(3.)*
11288
11289
11290 sqrt(k*pow(epsc1,
11291
11292
11293 2)*(3*k*pow(epsc1, 2)*
11294
11295
11296 pow(-2*as2*ch*pow(e0c, 2)*epscmax1 +
11297
11298
11299 d*(-(as1*e0cn*fy) +
11300
11301
11302 e0c*(-n0 + as2*e0c*(epscmax1 + epsn) +
11303
11304
11305 as1*(fy + e0cn*(-epscmax1 + epsn)))),
11306
11307
11308 2) - 2*
11309
11310
11311 e0c*(as2*ch*e0c +
11312
11313
11314 as1*d*e0cn)*(b*pow(d, 2)*e0c*fc*
11315
11316
11317 pow(epscmax1 + epsn,
11318
11319
11320 2)*((6 - 9*k)*epsc1 +
11321
11322
11323 4*(-1 + k)*(epscmax1 + epsn)) +
11324
11325
11326 6*k*pow(epsc1, 2)*
11327
11328
11329 epscmax1*(as1*
11330
11331
11332 d*(e0cn*fy - e0c*(fy + e0cn*epsn)) +
11333
11334
11335 e0c*(as2*ch*e0c*epscmax1 +
11336
11337
11338 d*(n0 -
11339
11340
11341 as2*e0c*(epscmax1 + epsn))))))),
11342
11343
11344 2) + (as2*(2*ch -
11345
11346
11347 h)*(-3*as1*d*k*
11348
11349
11350 pow(epsc1,
11351
11352
11353 2)*(-2*d*e0c*e0cn*(epscmax1 + epsn) +
11354
11355
11356 ch*(-(e0cn*fy) + e0c*(fy + e0cn*(epscmax1 + epsn)))) +
11357
11358
11359 ch*(3*d*e0c*k*pow(epsc1, 2)*(n0 + as2*e0c*(epscmax1 + epsn)) +
11360
11361
11362 sqrt(3.)*
11363
11364
11365 sqrt(k*
11366
11367
11368 pow(epsc1,
11369
11370
11371 2)*(3*k*pow(epsc1, 2)*
11372
11373
11374 pow(-2*as2*ch*pow(e0c, 2)*epscmax1 +
11375
11376
11377 d*(-(as1*e0cn*fy) +
11378
11379
11380 e0c*(-n0 + as2*e0c*(epscmax1 + epsn) +
11381
11382
11383 as1*(fy + e0cn*(-epscmax1 + epsn)))),
11384
11385
11386 2) -
11387
11388
11389 2*e0c*(as2*ch*e0c +
11390
11391
11392 as1*d*e0cn)*(b*pow(d, 2)*e0c*fc*
11393
11394
11395 pow(epscmax1 + epsn,
11396
11397
11398 2)*((6 - 9*k)*epsc1 +
11399
11400
11401 4*(-1 + k)*(epscmax1 + epsn)) +
11402
11403
11404 6*k*pow(epsc1, 2)*
11405
11406
11407 epscmax1*(as1*
11408
11409
11410 d*(e0cn*fy - e0c*(fy + e0cn*epsn)) +
11411
11412
11413 e0c*(as2*ch*e0c*epscmax1 +
11414
11415
11416 d*(n0 - as2*e0c*(epscmax1 +
11417
11418
11419 epsn))))))))))/
11420
11421
11422 d - (as1*(2*cd -
11423
11424
11425 h)*(3*as2*e0c*k*
11426
11427
11428 pow(epsc1,
11429
11430
11431 2)*(-(d*e0c*e0cn*(epscmax1 + epsn)) +
11432
11433
11434 2*ch*(-(e0cn*fy) + e0c*(fy + e0cn*(epscmax1 + epsn)))) +
11435
11436
11437 e0cn*(3*d*e0c*k*n0*pow(epsc1, 2) +
11438
11439
11440 3*as1*d*k*
11441
11442
11443 pow(epsc1,
11444
11445
11446 2)*(-(e0cn*fy) +
11447
11448
11449 e0c*(fy + e0cn*(epscmax1 + epsn))) +
11450
11451
11452 sqrt(3.)*
11453
11454
11455 sqrt(k*
11456
11457
11458 pow(epsc1,
11459
11460
11461 2)*(3*k*pow(epsc1, 2)*
11462
11463
11464 pow(-2*as2*ch*pow(e0c, 2)*epscmax1 +
11465
11466
11467 d*(-(as1*e0cn*fy) +
11468
11469
11470 e0c*(-n0 + as2*e0c*(epscmax1 + epsn) +
11471
11472
11473 as1*(fy + e0cn*(-epscmax1 + epsn)))),
11474
11475
11476 2) -
11477
11478
11479 2*e0c*(as2*ch*e0c +
11480
11481
11482 as1*d*e0cn)*(b*pow(d, 2)*e0c*fc*
11483
11484
11485 pow(epscmax1 + epsn,
11486
11487
11488 2)*((6 - 9*k)*epsc1 +
11489
11490
11491 4*(-1 + k)*(epscmax1 + epsn)) +
11492
11493
11494 6*k*pow(epsc1, 2)*
11495
11496
11497 epscmax1*(as1*
11498
11499
11500 d*(e0cn*fy - e0c*(fy + e0cn*epsn)) +
11501
11502
11503 e0c*(as2*ch*e0c*epscmax1 +
11504
11505
11506 d*(n0 - as2*e0c*(epscmax1 +
11507
11508
11509 epsn))))))))))/
11510
11511
11512 e0c)/(12.*(as2*ch*e0c + as1*d*e0cn)*k*pow(epsc1, 2)) + e0c*(-(as1*(-cd + h/2.)) + as2*(-ch + h/2.))*epsn;
11513
11514
11515
11516
11517
11518 return mmax2;
11519
11520
11521 }
11522
11523
11524
11525
11526
11527
11528
11529
11530 double normmat::compute_ms11 ()
11531
11532
11533
11534
11535
11536 {
11537
11538
11539 double ms11;
11540
11541
11542
11543
11544
11545 if (epscs11 == -1.0){
11546
11547
11548
11549
11550
11551 ms11=1000000000.0;
11552
11553
11554
11555
11556
11557 }
11558
11559
11560
11561
11562
11563 else{
11564
11565
11566
11567
11568
11569 ms11=0.08333333333333333*(-6*as2*
11570
11571
11572 e0c*(-2*ch + h)*(epscs11 - (ch*epscs11)/d +
11573
11574
11575 epsn + (ch*(6*as2*ch*pow(e0c, 2)*k*pow(epsc1, 2)*epscs11 -
11576
11577
11578 3*d*k*pow(epsc1,
11579
11580
11581 2)*(-as1*e0cn*fy +
11582
11583
11584 e0c*(-n0 + as2*e0c*(epscs11 + epsn) +
11585
11586
11587 as1*(fy + e0cn*(-epscs11 + epsn)))) +
11588
11589
11590 sqrt(3.)*
11591
11592
11593 sqrt(k*
11594
11595
11596 pow(epsc1,
11597
11598
11599 2)*(3*k*pow(epsc1, 2)*
11600
11601
11602 pow(-2*as2*ch*pow(e0c, 2)*epscs11 +
11603
11604
11605 d*(-as1*e0cn*fy +
11606
11607
11608 e0c*(-n0 + as2*e0c*(epscs11 + epsn) +
11609
11610
11611 as1*(fy + e0cn*(-epscs11 + epsn)))),
11612
11613
11614 2) - 2*
11615
11616
11617 e0c*(as2*ch*e0c +
11618
11619
11620 as1*d*e0cn)*(b*pow(d, 2)*e0c*fc*
11621
11622
11623 pow(epscs11 + epsn,
11624
11625
11626 2)*((6 - 9*k)*epsc1 +
11627
11628
11629 4*(-1 + k)*epscs11 +
11630
11631
11632 4*(-1 + k)*epsn) +
11633
11634
11635 6*k*pow(epsc1, 2)*
11636
11637
11638 epscs11*(as1*
11639
11640
11641 d*(e0cn*fy - e0c*(fy + e0cn*epsn)) +
11642
11643
11644 e0c*(as2*ch*e0c*epscs11 +
11645
11646
11647 d*(n0 - as2*e0c*(epscs11 +
11648
11649
11650 epsn)))))))))/(6.*d*
11651
11652
11653 e0c*(as2*ch*e0c + as1*d*e0cn)*k*pow(epsc1, 2))) - (b*d*fc*
11654
11655
11656 pow(epscs11 + epsn,
11657
11658
11659 2)*(2*d*(epscs11 +
11660
11661
11662 epsn)*((2 - 3*k)*epsc1 + (-1 + k)*epscs11 + (-1 + k)*
11663
11664
11665 epsn) -
11666
11667
11668 h*((6 - 9*k)*epsc1 + 4*(-1 + k)*epscs11 +
11669
11670
11671 4*(-1 + k)*
11672
11673
11674 epsn)*(epscs11 - (6*as2*ch*pow(e0c, 2)*k*
11675
11676
11677 pow(epsc1, 2)*epscs11 -
11678
11679
11680 3*d*k*pow(epsc1,
11681
11682
11683 2)*(-as1*e0cn*fy +
11684
11685
11686 e0c*(-n0 + as2*e0c*(epscs11 + epsn) +
11687
11688
11689 as1*(fy + e0cn*(-epscs11 + epsn)))) +
11690
11691
11692 sqrt(3.)*
11693
11694
11695 sqrt(k*
11696
11697
11698 pow(epsc1,
11699
11700
11701 2)*(3*k*pow(epsc1, 2)*
11702
11703
11704 pow(-2*as2*ch*pow(e0c, 2)*epscs11 +
11705
11706
11707 d*(-as1*e0cn*fy +
11708
11709
11710 e0c*(-n0 + as2*e0c*(epscs11 + epsn) +
11711
11712
11713 as1*(fy + e0cn*(-epscs11 + epsn)))),
11714
11715
11716 2) -
11717
11718
11719 2*e0c*(as2*ch*e0c +
11720
11721
11722 as1*d*e0cn)*(b*pow(d, 2)*e0c*fc*
11723
11724
11725 pow(epscs11 + epsn,
11726
11727
11728 2)*((6 - 9*k)*epsc1 +
11729
11730
11731 4*(-1 + k)*epscs11 +
11732
11733
11734 4*(-1 + k)*epsn) +
11735
11736
11737 6*k*pow(epsc1, 2)*
11738
11739
11740 epscs11*(as1*
11741
11742
11743 d*(e0cn*fy - e0c*(fy + e0cn*epsn)) +
11744
11745
11746 e0c*(as2*ch*e0c*epscs11 +
11747
11748
11749 d*(n0 - as2*e0c*(epscs11 +
11750
11751
11752 epsn))))))))/(6.*
11753
11754
11755 e0c*(as2*ch*e0c + as1*d*e0cn)*k*
11756
11757
11758 pow(epsc1, 2)))))/(k*pow(epsc1, 2)*
11759
11760
11761 pow(epscs11 - (6*as2*ch*pow(e0c, 2)*k*pow(epsc1, 2)*epscs11 -
11762
11763
11764 3*d*k*pow(epsc1,
11765
11766
11767 2)*(-as1*e0cn*fy +
11768
11769
11770 e0c*(-n0 + as2*e0c*(epscs11 + epsn) +
11771
11772
11773 as1*(fy + e0cn*(-epscs11 + epsn)))) +
11774
11775
11776 sqrt(3.)*
11777
11778
11779 sqrt(k*
11780
11781
11782 pow(epsc1,
11783
11784
11785 2)*(3*k*pow(epsc1, 2)*
11786
11787
11788 pow(-2*as2*ch*pow(e0c, 2)*epscs11 +
11789
11790
11791 d*(-as1*e0cn*fy +
11792
11793
11794 e0c*(-n0 + as2*e0c*(epscs11 + epsn) +
11795
11796
11797 as1*(fy + e0cn*(-epscs11 + epsn)))),
11798
11799
11800 2) - 2*
11801
11802
11803 e0c*(as2*ch*e0c +
11804
11805
11806 as1*d*e0cn)*(b*pow(d, 2)*e0c*fc*
11807
11808
11809 pow(epscs11 + epsn,
11810
11811
11812 2)*((6 - 9*k)*epsc1 +
11813
11814
11815 4*(-1 + k)*epscs11 +
11816
11817
11818 4*(-1 + k)*epsn) +
11819
11820
11821 6*k*pow(epsc1, 2)*
11822
11823
11824 epscs11*(as1*
11825
11826
11827 d*(e0cn*fy - e0c*(fy + e0cn*epsn)) +
11828
11829
11830 e0c*(as2*ch*e0c*epscs11 +
11831
11832
11833 d*(n0 - as2*e0c*(epscs11 +
11834
11835
11836 epsn))))))))/(6.*
11837
11838
11839 e0c*(as2*ch*e0c + as1*d*e0cn)*k*pow(epsc1, 2)), 2)) +
11840
11841
11842 6*as1*(-2*cd + h)*(fy +
11843
11844
11845 e0cn*(-(fy/e0c) +
11846
11847
11848 epsn + (6*as2*ch*pow(e0c, 2)*k*pow(epsc1, 2)*epscs11 -
11849
11850
11851 3*d*k*pow(epsc1,
11852
11853
11854 2)*(-as1*e0cn*fy +
11855
11856
11857 e0c*(-n0 + as2*e0c*(epscs11 + epsn) +
11858
11859
11860 as1*(fy + e0cn*(-epscs11 + epsn)))) +
11861
11862
11863 sqrt(3.)*
11864
11865
11866 sqrt(k*
11867
11868
11869 pow(epsc1,
11870
11871
11872 2)*(3*k*pow(epsc1, 2)*
11873
11874
11875 pow(-2*as2*ch*pow(e0c, 2)*epscs11 +
11876
11877
11878 d*(-as1*e0cn*fy +
11879
11880
11881 e0c*(-n0 + as2*e0c*(epscs11 + epsn) +
11882
11883
11884 as1*(fy + e0cn*(-epscs11 + epsn)))),
11885
11886
11887 2) - 2*
11888
11889
11890 e0c*(as2*ch*e0c +
11891
11892
11893 as1*d*e0cn)*(b*pow(d, 2)*e0c*fc*
11894
11895
11896 pow(epscs11 + epsn,
11897
11898
11899 2)*((6 - 9*k)*epsc1 +
11900
11901
11902 4*(-1 + k)*epscs11 +
11903
11904
11905 4*(-1 + k)*epsn) +
11906
11907
11908 6*k*pow(epsc1, 2)*
11909
11910
11911 epscs11*(as1*
11912
11913
11914 d*(e0cn*fy - e0c*(fy + e0cn*epsn)) +
11915
11916
11917 e0c*(as2*ch*e0c*epscs11 +
11918
11919
11920 d*(n0 - as2*e0c*(epscs11 +
11921
11922
11923 epsn))))))))/(6.*
11924
11925
11926 e0c*(as2*ch*e0c + as1*d*e0cn)*k*pow(epsc1, 2))))) + e0c*(-(as1*(-cd + h/2.)) + as2*(-ch + h/2.))*epsn;
11927
11928
11929
11930
11931
11932 }
11933
11934
11935 return ms11;
11936
11937
11938 }
11939
11940
11941
11942
11943
11944
11945
11946
11947 double normmat::compute_mh5a ()
11948
11949
11950 {
11951
11952
11953 double mh5a;
11954
11955
11956
11957
11958
11959 if (mhr5-mmax2 > 0.0){
11960
11961
11962
11963
11964
11965 mh5a=mmax2;
11966
11967
11968 }
11969
11970
11971 else{
11972
11973
11974 mh5a=mhr5;
11975
11976
11977 }
11978
11979
11980 return mh5a;
11981
11982
11983 }
11984
11985
11986
11987
11988
11989
11990
11991
11992 double normmat::compute_epsch5a ()
11993
11994
11995 {
11996
11997
11998 double epsch5a;
11999
12000
12001
12002
12003
12004 if (mhr5-mmax2 > 0.0){
12005
12006
12007
12008
12009
12010 epsch5a=epscmax1;
12011
12012
12013 }
12014
12015
12016 else{
12017
12018
12019 epsch5a=epschr5;
12020
12021
12022 }
12023
12024
12025 return epsch5a;
12026
12027
12028 }
12029
12030
12031
12032
12033
12034
12035
12036
12037 double normmat::compute_mh5p ()
12038
12039
12040 {
12041
12042
12043 double mh5p;
12044
12045
12046
12047
12048
12049 if (mh5a-fabs(ms11) > 0.0){
12050
12051
12052
12053
12054
12055 mh5p=ms11;
12056
12057
12058 }
12059
12060
12061 else{
12062
12063
12064 mh5p=mh5a;
12065
12066
12067 }
12068
12069
12070 return mh5p;
12071
12072
12073 }
12074
12075
12076
12077
12078
12079
12080
12081
12082 double normmat::compute_epsch5p ()
12083
12084
12085 {
12086
12087
12088 double epsch5p;
12089
12090
12091
12092
12093
12094 if (mh5a-fabs(ms11) > 0.0){
12095
12096
12097
12098
12099
12100 epsch5p=epscs11;
12101
12102
12103 }
12104
12105
12106 else{
12107
12108
12109 epsch5p=epsch5a;
12110
12111
12112 }
12113
12114
12115 return epsch5p;
12116
12117
12118 }
12119
12120
12121
12122
12123
12124
12125
12126
12127 double normmat::compute_mh25a ()
12128
12129
12130 {
12131
12132
12133 double mh25a;
12134
12135
12136 mh25a =((-6*b*d*pow(e0c, 2)*pow(as2*ch*e0c + as1*d*e0cn, 3)*fc*pow(k, 2)*
12137
12138
12139 pow(epsc1, 4)*
12140
12141
12142 pow(epsch2 + epsch5p + 2*epsn,
12143
12144
12145 2)*(6*d*(epsch2 + epsch5p +
12146
12147
12148 2*epsn)*((4 - 6*k)*
12149
12150
12151 epsc1 + (-1 + k)*(epsch2 + epsch5p +
12152
12153
12154 2*epsn)) + (h*(3*(-2 + 3*k)*epsc1 -
12155
12156
12157 2*(-1 + k)*(epsch2 + epsch5p + 2*epsn))*(3*d*e0c*
12158
12159
12160 k*pow(epsc1,
12161
12162
12163 2)*(-2*n0 +
12164
12165
12166 as2*e0c*(epsch2 + epsch5p + 2*epsn)) +
12167
12168
12169 3*as1*d*k*
12170
12171
12172 pow(epsc1,
12173
12174
12175 2)*(-2*e0cn*fy +
12176
12177
12178 e0c*(2*fy +
12179
12180
12181 e0cn*(epsch2 + epsch5p + 2*epsn))) -
12182
12183
12184 2*sqrt(3.)*
12185
12186
12187 sqrt(k*
12188
12189
12190 pow(epsc1,
12191
12192
12193 2)*(3*k*pow(epsc1, 2)*
12194
12195
12196 pow(as2*ch*
12197
12198
12199 pow(e0c, 2)*(epsch2 + epsch5p) -
12200
12201
12202 d*(-(as1*e0cn*fy) + (e0c*(-2*n0 +
12203
12204
12205 as1*(2*fy - e0cn*(epsch2 + epsch5p -
12206
12207
12208 2*epsn)) + as2*e0c*(epsch2 +
12209
12210
12211 epsch5p + 2*epsn)))/2.), 2) -
12212
12213
12214 2*e0c*(as2*ch*e0c +
12215
12216
12217 as1*d*
12218
12219
12220 e0cn)*((b*pow(d, 2)*e0c*fc*
12221
12222
12223 pow(epsch2 + epsch5p + 2*epsn,
12224
12225
12226 2)*((6 - 9*k)*epsc1 +
12227
12228
12229 2*(-1 + k)*(epsch2 + epsch5p +
12230
12231
12232 2*epsn)))/4. +
12233
12234
12235 3*k*pow(epsc1,
12236
12237
12238 2)*(epsch2 +
12239
12240
12241 epsch5p)*(as1*
12242
12243
12244 d*(e0cn*fy - e0c*(fy +
12245
12246
12247 e0cn*epsn)) + (e0c*(as2*ch*
12248
12249
12250 e0c*(epsch2 + epsch5p) +
12251
12252
12253 d*(2*n0 - as2*e0c*(epsch2 + epsch5p +
12254
12255
12256 2*epsn))))/2.))))))/(e0c*(as2*ch*e0c +
12257
12258
12259 as1*d*e0cn)*k*pow(epsc1, 2))))/
12260
12261
12262 pow(3*d*e0c*k*
12263
12264
12265 pow(epsc1, 2)*(-2*n0 + as2*e0c*(epsch2 + epsch5p + 2*epsn)) +
12266
12267
12268 3*as1*d*k*
12269
12270
12271 pow(epsc1,
12272
12273
12274 2)*(-2*e0cn*fy +
12275
12276
12277 e0c*(2*fy + e0cn*(epsch2 + epsch5p + 2*epsn))) -
12278
12279
12280 2*sqrt(3.)*
12281
12282
12283 sqrt(k*pow(epsc1,
12284
12285
12286 2)*(3*k*pow(epsc1, 2)*
12287
12288
12289 pow(as2*ch*pow(e0c, 2)*(epsch2 + epsch5p) -
12290
12291
12292 d*(-(as1*e0cn*
12293
12294
12295 fy) + (e0c*(-2*n0 +
12296
12297
12298 as1*(2*fy -
12299
12300
12301 e0cn*(epsch2 + epsch5p - 2*epsn)) +
12302
12303
12304 as2*e0c*(epsch2 + epsch5p + 2*epsn)))/
12305
12306
12307 2.), 2) -
12308
12309
12310 2*e0c*(as2*ch*e0c +
12311
12312
12313 as1*d*e0cn)*((b*pow(d, 2)*e0c*fc*
12314
12315
12316 pow(epsch2 + epsch5p + 2*epsn,
12317
12318
12319 2)*((6 - 9*k)*epsc1 +
12320
12321
12322 2*(-1 + k)*(epsch2 + epsch5p +
12323
12324
12325 2*epsn)))/4. +
12326
12327
12328 3*k*pow(epsc1,
12329
12330
12331 2)*(epsch2 +
12332
12333
12334 epsch5p)*(as1*
12335
12336
12337 d*(e0cn*fy -
12338
12339
12340 e0c*(fy + e0cn*epsn)) + (e0c*(as2*ch*
12341
12342
12343 e0c*(epsch2 + epsch5p) +
12344
12345
12346 d*(2*n0 -
12347
12348
12349 as2*e0c*(epsch2 + epsch5p +
12350
12351
12352 2*epsn))))/2.)))),
12353
12354
12355 2) + (as2*(2*ch -
12356
12357
12358 h)*(-3*as1*d*k*
12359
12360
12361 pow(epsc1,
12362
12363
12364 2)*(-2*d*e0c*e0cn*(epsch2 + epsch5p + 2*epsn) +
12365
12366
12367 ch*(-2*e0cn*fy +
12368
12369
12370 e0c*(2*fy + e0cn*(epsch2 + epsch5p + 2*epsn)))) +
12371
12372
12373 ch*(3*d*e0c*k*
12374
12375
12376 pow(epsc1,
12377
12378
12379 2)*(2*n0 + as2*e0c*(epsch2 + epsch5p + 2*epsn)) +
12380
12381
12382 2*sqrt(3.)*
12383
12384
12385 sqrt(k*
12386
12387
12388 pow(epsc1,
12389
12390
12391 2)*(3*k*pow(epsc1, 2)*
12392
12393
12394 pow(as2*ch*pow(e0c, 2)*(epsch2 + epsch5p) -
12395
12396
12397 d*(-(as1*e0cn*
12398
12399
12400 fy) + (e0c*(-2*n0 +
12401
12402
12403 as1*(2*fy - e0cn*(epsch2 + epsch5p -
12404
12405
12406 2*epsn)) + as2*e0c*(epsch2 +
12407
12408
12409 epsch5p + 2*epsn)))/2.), 2)
12410
12411
12412 -2*e0c*(as2*ch*e0c +
12413
12414
12415 as1*d*
12416
12417
12418 e0cn)*((b*pow(d, 2)*e0c*fc*
12419
12420
12421 pow(epsch2 + epsch5p + 2*epsn,
12422
12423
12424 2)*((6 - 9*k)*epsc1 +
12425
12426
12427 2*(-1 + k)*(epsch2 + epsch5p +
12428
12429
12430 2*epsn)))/4. +
12431
12432
12433 3*k*pow(epsc1,
12434
12435
12436 2)*(epsch2 +
12437
12438
12439 epsch5p)*(as1*
12440
12441
12442 d*(e0cn*fy -
12443
12444
12445 e0c*(fy + e0cn*epsn)) + (e0c*(as2*ch*
12446
12447
12448 e0c*(epsch2 + epsch5p) +
12449
12450
12451 d*(2*n0 - as2*e0c*(epsch2 + epsch5p +
12452
12453
12454 2*epsn))))/2.)))))))/
12455
12456
12457 d - (as1*(2*cd -
12458
12459
12460 h)*(3*as2*e0c*k*
12461
12462
12463 pow(epsc1,
12464
12465
12466 2)*(-(d*e0c*e0cn*(epsch2 + epsch5p + 2*epsn)) +
12467
12468
12469 2*ch*(-2*e0cn*fy +
12470
12471
12472 e0c*(2*fy + e0cn*(epsch2 + epsch5p + 2*epsn)))) +
12473
12474
12475 e0cn*(6*d*e0c*k*n0*pow(epsc1, 2) +
12476
12477
12478 3*as1*d*k*
12479
12480
12481 pow(epsc1,
12482
12483
12484 2)*(-2*e0cn*fy +
12485
12486
12487 e0c*(2*fy + e0cn*(epsch2 + epsch5p + 2*epsn))) +
12488
12489
12490 2*sqrt(3.)*
12491
12492
12493 sqrt(k*
12494
12495
12496 pow(epsc1,
12497
12498
12499 2)*(3*k*pow(epsc1, 2)*
12500
12501
12502 pow(as2*ch*pow(e0c, 2)*(epsch2 + epsch5p) -
12503
12504
12505 d*(-(as1*e0cn*
12506
12507
12508 fy) + (e0c*(-2*n0 +
12509
12510
12511 as1*(2*fy - e0cn*(epsch2 + epsch5p -
12512
12513
12514 2*epsn)) + as2*e0c*(epsch2 +
12515
12516
12517 epsch5p + 2*epsn)))/2.), 2)
12518
12519
12520 -2*e0c*(as2*ch*e0c +
12521
12522
12523 as1*d*
12524
12525
12526 e0cn)*((b*pow(d, 2)*e0c*fc*
12527
12528
12529 pow(epsch2 + epsch5p + 2*epsn,
12530
12531
12532 2)*((6 - 9*k)*epsc1 +
12533
12534
12535 2*(-1 + k)*(epsch2 + epsch5p +
12536
12537
12538 2*epsn)))/4. +
12539
12540
12541 3*k*pow(epsc1,
12542
12543
12544 2)*(epsch2 +
12545
12546
12547 epsch5p)*(as1*
12548
12549
12550 d*(e0cn*fy -
12551
12552
12553 e0c*(fy + e0cn*epsn)) + (e0c*(as2*ch*
12554
12555
12556 e0c*(epsch2 + epsch5p) +
12557
12558
12559 d*(2*n0 - as2*e0c*(epsch2 + epsch5p +
12560
12561
12562 2*epsn))))/2.)))))))/
12563
12564
12565 e0c)/(24.*(as2*ch*e0c + as1*d*e0cn)*k*pow(epsc1, 2)) + e0c*(-(as1*(-cd + h/2.)) + as2*(-ch + h/2.))*epsn;
12566
12567
12568
12569
12570
12571 return mh25a;
12572
12573
12574 }
12575
12576
12577
12578
12579
12580
12581
12582
12583 double normmat::compute_epscder4 ()
12584
12585
12586 {
12587
12588
12589 double epscder4;
12590
12591
12592
12593
12594
12595 epscder4 =-(-(mh2*epsch2) + 4*mh25a*epsch2 - 3*mh5p*epsch2 - 3*mh2*epsch5p +
12596
12597
12598 4*mh25a*epsch5p - mh5p*epsch5p)/(4.*(mh2 - 2*mh25a + mh5p));
12599
12600
12601
12602
12603
12604 return epscder4;
12605
12606
12607 }
12608
12609
12610
12611
12612
12613
12614
12615
12616
12617
12618
12619
12620 double normmat::compute_mmax5 ()
12621
12622
12623 {
12624
12625
12626 double mmax5;
12627
12628
12629
12630
12631
12632 mmax5 =(-6*as2*e0c*(-2*ch + h)*(epscder4 - (ch*epscder4)/d +
12633
12634
12635 epsn + (ch*(6*as2*ch*pow(e0c, 2)*k*pow(epsc1, 2)*epscder4 -
12636
12637
12638 3*d*k*pow(epsc1,
12639
12640
12641 2)*(-(as1*e0cn*fy) +
12642
12643
12644 e0c*(-n0 + as2*e0c*(epscder4 + epsn) +
12645
12646
12647 as1*(fy + e0cn*(-epscder4 + epsn)))) +
12648
12649
12650 sqrt(3.)*
12651
12652
12653 sqrt(k*
12654
12655
12656 pow(epsc1,
12657
12658
12659 2)*(3*k*pow(epsc1, 2)*
12660
12661
12662 pow(-2*as2*ch*pow(e0c, 2)*epscder4 +
12663
12664
12665 d*(-(as1*e0cn*fy) +
12666
12667
12668 e0c*(-n0 + as2*e0c*(epscder4 + epsn) +
12669
12670
12671 as1*(fy + e0cn*(-epscder4 + epsn)))),
12672
12673
12674 2) -
12675
12676
12677 2*e0c*(as2*ch*e0c +
12678
12679
12680 as1*d*e0cn)*(b*pow(d, 2)*e0c*fc*
12681
12682
12683 pow(epscder4 + epsn,
12684
12685
12686 2)*((6 - 9*k)*epsc1 +
12687
12688
12689 4*(-1 + k)*epscder4 +
12690
12691
12692 4*(-1 + k)*epsn) +
12693
12694
12695 6*k*pow(epsc1, 2)*
12696
12697
12698 epscder4*(as1*
12699
12700
12701 d*(e0cn*fy - e0c*(fy + e0cn*epsn)) +
12702
12703
12704 e0c*(as2*ch*e0c*epscder4 +
12705
12706
12707 d*(n0 - as2*e0c*(epscder4 +
12708
12709
12710 epsn)))))))))/(6.*d*
12711
12712
12713 e0c*(as2*ch*e0c + as1*d*e0cn)*k*pow(epsc1, 2))) - (b*d*fc*
12714
12715
12716 pow(epscder4 + epsn,
12717
12718
12719 2)*(2*d*(epscder4 +
12720
12721
12722 epsn)*((2 - 3*k)*epsc1 + (-1 + k)*epscder4 + (-1 + k)*
12723
12724
12725 epsn) -
12726
12727
12728 h*((6 - 9*k)*epsc1 + 4*(-1 + k)*epscder4 +
12729
12730
12731 4*(-1 + k)*
12732
12733
12734 epsn)*(epscder4 - (6*as2*ch*pow(e0c, 2)*k*
12735
12736
12737 pow(epsc1, 2)*epscder4 -
12738
12739
12740 3*d*k*pow(epsc1,
12741
12742
12743 2)*(-(as1*e0cn*fy) +
12744
12745
12746 e0c*(-n0 + as2*e0c*(epscder4 + epsn) +
12747
12748
12749 as1*(fy + e0cn*(-epscder4 + epsn)))) +
12750
12751
12752 sqrt(3.)*
12753
12754
12755 sqrt(k*
12756
12757
12758 pow(epsc1,
12759
12760
12761 2)*(3*k*pow(epsc1, 2)*
12762
12763
12764 pow(-2*as2*ch*pow(e0c, 2)*epscder4 +
12765
12766
12767 d*(-(as1*e0cn*fy) +
12768
12769
12770 e0c*(-n0 + as2*e0c*(epscder4 + epsn) +
12771
12772
12773 as1*(fy + e0cn*(-epscder4 + epsn)))),
12774
12775
12776 2) -
12777
12778
12779 2*e0c*(as2*ch*e0c +
12780
12781
12782 as1*d*e0cn)*(b*pow(d, 2)*e0c*fc*
12783
12784
12785 pow(epscder4 + epsn,
12786
12787
12788 2)*((6 - 9*k)*epsc1 +
12789
12790
12791 4*(-1 + k)*epscder4 +
12792
12793
12794 4*(-1 + k)*epsn) +
12795
12796
12797 6*k*pow(epsc1, 2)*
12798
12799
12800 epscder4*(as1*
12801
12802
12803 d*(e0cn*fy - e0c*(fy + e0cn*epsn)) +
12804
12805
12806 e0c*(as2*ch*e0c*epscder4 +
12807
12808
12809 d*(n0 - as2*e0c*(epscder4 +
12810
12811
12812 epsn))))))))/(6.*
12813
12814
12815 e0c*(as2*ch*e0c + as1*d*e0cn)*k*
12816
12817
12818 pow(epsc1, 2)))))/(k*pow(epsc1, 2)*
12819
12820
12821 pow(epscder4 - (6*as2*ch*pow(e0c, 2)*k*pow(epsc1, 2)*epscder4 -
12822
12823
12824 3*d*k*pow(epsc1,
12825
12826
12827 2)*(-(as1*e0cn*fy) +
12828
12829
12830 e0c*(-n0 + as2*e0c*(epscder4 + epsn) +
12831
12832
12833 as1*(fy + e0cn*(-epscder4 + epsn)))) +
12834
12835
12836 sqrt(3.)*
12837
12838
12839 sqrt(k*
12840
12841
12842 pow(epsc1,
12843
12844
12845 2)*(3*k*pow(epsc1, 2)*
12846
12847
12848 pow(-2*as2*ch*pow(e0c, 2)*epscder4 +
12849
12850
12851 d*(-(as1*e0cn*fy) +
12852
12853
12854 e0c*(-n0 + as2*e0c*(epscder4 + epsn) +
12855
12856
12857 as1*(fy + e0cn*(-epscder4 + epsn)))),
12858
12859
12860 2) -
12861
12862
12863 2*e0c*(as2*ch*e0c +
12864
12865
12866 as1*d*e0cn)*(b*pow(d, 2)*e0c*fc*
12867
12868
12869 pow(epscder4 + epsn,
12870
12871
12872 2)*((6 - 9*k)*epsc1 +
12873
12874
12875 4*(-1 + k)*epscder4 +
12876
12877
12878 4*(-1 + k)*epsn) +
12879
12880
12881 6*k*pow(epsc1, 2)*
12882
12883
12884 epscder4*(as1*
12885
12886
12887 d*(e0cn*fy - e0c*(fy + e0cn*epsn)) +
12888
12889
12890 e0c*(as2*ch*e0c*epscder4 +
12891
12892
12893 d*(n0 - as2*e0c*(epscder4 +
12894
12895
12896 epsn))))))))/(6.*
12897
12898
12899 e0c*(as2*ch*e0c + as1*d*e0cn)*k*pow(epsc1, 2)), 2)) +
12900
12901
12902 6*as1*(-2*cd + h)*(fy +
12903
12904
12905 e0cn*(-(fy/e0c) +
12906
12907
12908 epsn + (6*as2*ch*pow(e0c, 2)*k*pow(epsc1, 2)*epscder4 -
12909
12910
12911 3*d*k*pow(epsc1,
12912
12913
12914 2)*(-(as1*e0cn*fy) +
12915
12916
12917 e0c*(-n0 + as2*e0c*(epscder4 + epsn) +
12918
12919
12920 as1*(fy + e0cn*(-epscder4 + epsn)))) +
12921
12922
12923 sqrt(3.)*
12924
12925
12926 sqrt(k*
12927
12928
12929 pow(epsc1,
12930
12931
12932 2)*(3*k*pow(epsc1, 2)*
12933
12934
12935 pow(-2*as2*ch*pow(e0c, 2)*epscder4 +
12936
12937
12938 d*(-(as1*e0cn*fy) +
12939
12940
12941 e0c*(-n0 + as2*e0c*(epscder4 + epsn) +
12942
12943
12944 as1*(fy + e0cn*(-epscder4 + epsn)))),
12945
12946
12947 2) -
12948
12949
12950 2*e0c*(as2*ch*e0c +
12951
12952
12953 as1*d*e0cn)*(b*pow(d, 2)*e0c*fc*
12954
12955
12956 pow(epscder4 + epsn,
12957
12958
12959 2)*((6 - 9*k)*epsc1 +
12960
12961
12962 4*(-1 + k)*epscder4 +
12963
12964
12965 4*(-1 + k)*epsn) +
12966
12967
12968 6*k*pow(epsc1, 2)*
12969
12970
12971 epscder4*(as1*
12972
12973
12974 d*(e0cn*fy - e0c*(fy + e0cn*epsn)) +
12975
12976
12977 e0c*(as2*ch*e0c*epscder4 +
12978
12979
12980 d*(n0 - as2*e0c*(epscder4 +
12981
12982
12983 epsn))))))))/(6.*
12984
12985
12986 e0c*(as2*ch*e0c + as1*d*e0cn)*k*pow(epsc1, 2)))))/12. + e0c*(-(as1*(-cd + h/2.)) + as2*(-ch + h/2.))*epsn;
12987
12988
12989
12990
12991
12992 return mmax5;
12993
12994
12995 }
12996
12997
12998
12999
13000
13001
13002
13003
13004 double normmat::compute_mh5 ()
13005
13006
13007 {
13008
13009
13010 double mh5;
13011
13012
13013
13014
13015
13016 if ((epscder4-epsch2) < 0.0 && (epscder4-epsch5p) > 0.0){
13017
13018
13019
13020
13021
13022 mh5=mmax5;
13023
13024
13025 }
13026
13027
13028 else{
13029
13030
13031 mh5=mh5p;
13032
13033
13034 }
13035
13036
13037 return mh5;
13038
13039
13040 }
13041
13042
13043
13044
13045
13046
13047
13048
13049 double normmat::compute_epsch5 ()
13050
13051
13052 {
13053
13054
13055 double epsch5;
13056
13057
13058
13059
13060
13061 if ((epscder4-epsch2) < 0.0 && (epscder4-epsch5p) > 0.0){
13062
13063
13064
13065
13066
13067 epsch5=epscder4;
13068
13069
13070 }
13071
13072
13073 else{
13074
13075
13076 epsch5=epsch5p;
13077
13078
13079 }
13080
13081
13082 return epsch5;
13083
13084
13085 }
13086
13087
13088
13089
13090
13091
13092
13093
13094
13095
13096
13097
13098
13099
13100 double normmat::compute_epscp ()
13101
13102
13103 {
13104
13105
13106 double ac1,ac2,ac3,epscp;
13107
13108
13109
13110
13111
13112 ac1 =-(fy/e0c) + epsn + (sqrt(k*
13113
13114
13115 pow(epsc1,
13116
13117
13118 2)*(3*k*pow(epsc1, 2)*
13119
13120
13121 pow(d*e0c*(n0 + as1*e0c*(epsc1 - epsn)) +
13122
13123
13124 as2*(2*ch*e0c*e0cn*epsc1 -
13125
13126
13127 d*(e0cn*fy + e0c*(-fy + e0cn*(epsc1 + epsn)))),
13128
13129
13130 2) + 2*e0c*(as1*d*e0c +
13131
13132
13133 as2*ch*e0cn)*(b*pow(d, 2)*e0c*fc*
13134
13135
13136 pow(epsc1 + epsn,
13137
13138
13139 2)*((-2 + 5*k)*epsc1 - 4*(-1 + k)*epsn) +
13140
13141
13142 6*k*pow(epsc1,
13143
13144
13145 3)*(-(as2*ch*e0c*e0cn*epsc1) +
13146
13147
13148 d*(as2*e0cn*fy + as1*pow(e0c, 2)*epsn +
13149
13150
13151 e0c*(-(as2*fy) - n0 +
13152
13153
13154 as2*e0cn*(epsc1 + epsn)))))))*(-pow(2*
13155
13156
13157 e0c*(as1*d*e0c +
13158
13159
13160 as2*ch*e0cn)*(6*b*pow(d, 2)*e0c*
13161
13162
13163 fc*(epsc1 + epsn)*(k*(epsc1 - 2*epsn) + 2*epsn) +
13164
13165
13166 6*k*pow(epsc1,
13167
13168
13169 2)*(d*e0c*(-n0 + as1*e0c*epsn) +
13170
13171
13172 as2*(-2*ch*e0c*e0cn*epsc1 +
13173
13174
13175 d*(-(e0c*fy) + e0cn*fy +
13176
13177
13178 2*e0c*e0cn*epsc1 +
13179
13180
13181 e0c*e0cn*epsn)))) +
13182
13183
13184 6*e0c*(as1*d*e0c + as2*(2*ch - d)*e0cn)*k*
13185
13186
13187 pow(epsc1,
13188
13189
13190 2)*(d*e0c*(n0 + as1*e0c*(epsc1 - epsn)) +
13191
13192
13193 as2*(2*ch*e0c*e0cn*epsc1 -
13194
13195
13196 d*(e0cn*fy +
13197
13198
13199 e0c*(-fy + e0cn*(epsc1 + epsn))))),
13200
13201
13202 2)/(4.*pow(3*k*pow(epsc1, 2)*
13203
13204
13205 pow(d*e0c*(n0 + as1*e0c*(epsc1 - epsn)) +
13206
13207
13208 as2*(2*ch*e0c*e0cn*epsc1 -
13209
13210
13211 d*(e0cn*fy +
13212
13213
13214 e0c*(-fy + e0cn*(epsc1 + epsn)))),
13215
13216
13217 2) + 2*
13218
13219
13220 e0c*(as1*d*e0c +
13221
13222
13223 as2*ch*e0cn)*(b*pow(d, 2)*e0c*fc*
13224
13225
13226 pow(epsc1 + epsn,
13227
13228
13229 2)*((-2 + 5*k)*epsc1 - 4*(-1 + k)*epsn) +
13230
13231
13232 6*k*pow(epsc1,
13233
13234
13235 3)*(-(as2*ch*e0c*e0cn*epsc1) +
13236
13237
13238 d*(as2*e0cn*fy + as1*pow(e0c, 2)*epsn +
13239
13240
13241 e0c*(-(as2*fy) - n0 +
13242
13243
13244 as2*e0cn*(epsc1 + epsn))))), 2)) + (3*
13245
13246
13247 pow(e0c,
13248
13249
13250 2)*(pow(as1*d*e0c + as2*(2*ch - d)*e0cn, 2)*k*
13251
13252
13253 pow(epsc1, 2) -
13254
13255
13256 2*(as1*d*e0c +
13257
13258
13259 as2*ch*e0cn)*(2*as2*(ch - d)*e0cn*k*
13260
13261
13262 pow(epsc1, 2) +
13263
13264
13265 b*pow(d, 2)*
13266
13267
13268 fc*((-2 + k)*epsc1 + 4*(-1 + k)*epsn))))/(3*k*
13269
13270
13271 pow(epsc1, 2)*
13272
13273
13274 pow(d*e0c*(n0 + as1*e0c*(epsc1 - epsn)) +
13275
13276
13277 as2*(2*ch*e0c*e0cn*epsc1 -
13278
13279
13280 d*(e0cn*fy + e0c*(-fy + e0cn*(epsc1 + epsn)))),
13281
13282
13283 2) + 2*e0c*(as1*d*e0c +
13284
13285
13286 as2*ch*e0cn)*(b*pow(d, 2)*e0c*fc*
13287
13288
13289 pow(epsc1 + epsn,
13290
13291
13292 2)*((-2 + 5*k)*epsc1 - 4*(-1 + k)*epsn) +
13293
13294
13295 6*k*pow(epsc1,
13296
13297
13298 3)*(-(as2*ch*e0c*e0cn*epsc1) +
13299
13300
13301 d*(as2*e0cn*fy + as1*pow(e0c, 2)*epsn +
13302
13303
13304 e0c*(-(as2*fy) - n0 +
13305
13306
13307 as2*e0cn*(epsc1 + epsn))))))))/(4.*
13308
13309
13310 sqrt(3.)*e0c*(as1*d*e0c + as2*ch*e0cn)*
13311
13312
13313 k) + (3*d*e0c*k*pow(epsc1, 2)*(n0 + as1*e0c*(epsc1 - epsn)) -
13314
13315
13316 3*as2*k*pow(epsc1,
13317
13318
13319 2)*(-2*ch*e0c*e0cn*epsc1 +
13320
13321
13322 d*(e0cn*fy + e0c*(-fy + e0cn*(epsc1 + epsn)))) +
13323
13324
13325 sqrt(3.)*sqrt(k*
13326
13327
13328 pow(epsc1,
13329
13330
13331 2)*(3*k*pow(epsc1, 2)*
13332
13333
13334 pow(d*e0c*(n0 + as1*e0c*(epsc1 - epsn)) +
13335
13336
13337 as2*(2*ch*e0c*e0cn*epsc1 -
13338
13339
13340 d*(e0cn*fy + e0c*(-fy + e0cn*(epsc1 + epsn)))),
13341
13342
13343 2) + 2*e0c*(as1*d*e0c +
13344
13345
13346 as2*ch*e0cn)*(b*pow(d, 2)*e0c*fc*
13347
13348
13349 pow(epsc1 + epsn,
13350
13351
13352 2)*((-2 + 5*k)*epsc1 - 4*(-1 + k)*epsn) +
13353
13354
13355 6*k*pow(epsc1,
13356
13357
13358 3)*(-(as2*ch*e0c*e0cn*epsc1) +
13359
13360
13361 d*(as2*e0cn*fy + as1*pow(e0c, 2)*epsn +
13362
13363
13364 e0c*(-(as2*fy) - n0 +
13365
13366
13367 as2*e0cn*(epsc1 + epsn))))))))/(6.*
13368
13369
13370 e0c*(as1*d*e0c + as2*ch*e0cn)*k*
13371
13372
13373 pow(epsc1, 2)) - (as1*d*e0c*k*pow(epsc1, 2) +
13374
13375
13376 as2*(2*ch - d)*e0cn*k*
13377
13378
13379 pow(epsc1,
13380
13381
13382 2) + (sqrt(3.)*(pow(as1, 2)*pow(e0c, 3)*k*
13383
13384
13385 pow(epsc1, 2)*(epsc1 + epsn) +
13386
13387
13388 as2*e0cn*(2*b*ch*e0c*
13389
13390
13391 fc*(epsc1 + epsn)*(k*(epsc1 - 2*epsn) + 2*epsn) +
13392
13393
13394 k*pow(epsc1,
13395
13396
13397 2)*(-(e0c*n0) +
13398
13399
13400 as2*(e0cn*fy +
13401
13402
13403 e0c*(-fy + e0cn*(epsc1 + epsn))))) +
13404
13405
13406 as1*e0c*(2*b*d*e0c*
13407
13408
13409 fc*(epsc1 + epsn)*(k*(epsc1 - 2*epsn) + 2*epsn) +
13410
13411
13412 k*pow(epsc1,
13413
13414
13415 2)*(-(e0c*n0) +
13416
13417
13418 as2*(e0cn*fy +
13419
13420
13421 e0c*(-fy + 2*e0cn*(epsc1 + epsn))))))*
13422
13423
13424 sqrt(k*pow(epsc1,
13425
13426
13427 2)*(3*k*pow(epsc1, 2)*
13428
13429
13430 pow(d*e0c*(n0 + as1*e0c*(epsc1 - epsn)) +
13431
13432
13433 as2*(2*ch*e0c*e0cn*epsc1 -
13434
13435
13436 d*(e0cn*fy +
13437
13438
13439 e0c*(-fy + e0cn*(epsc1 + epsn)))),
13440
13441
13442 2) + 2*
13443
13444
13445 e0c*(as1*d*e0c +
13446
13447
13448 as2*ch*e0cn)*(b*pow(d, 2)*e0c*fc*
13449
13450
13451 pow(epsc1 + epsn,
13452
13453
13454 2)*((-2 + 5*k)*epsc1 - 4*(-1 + k)*epsn) +
13455
13456
13457 6*k*pow(epsc1,
13458
13459
13460 3)*(-(as2*ch*e0c*e0cn*epsc1) +
13461
13462
13463 d*(as2*e0cn*fy + as1*pow(e0c, 2)*epsn +
13464
13465
13466 e0c*(-(as2*fy) - n0 +
13467
13468
13469 as2*e0cn*(epsc1 + epsn))))))))/(3*
13470
13471
13472 pow(as2, 2)*k*pow(epsc1, 2)*
13473
13474
13475 pow(e0cn*fy + e0c*(-fy + e0cn*(epsc1 + epsn)), 2) +
13476
13477
13478 pow(e0c,
13479
13480
13481 2)*(-4*as1*b*d*e0c*fc*(epsc1 - 2*epsn)*
13482
13483
13484 pow(epsc1 + epsn, 2) +
13485
13486
13487 k*(3*pow(n0, 2)*pow(epsc1, 2) -
13488
13489
13490 6*as1*e0c*n0*pow(epsc1, 2)*(epsc1 + epsn) +
13491
13492
13493 as1*e0c*(3*as1*e0c*pow(epsc1, 2) +
13494
13495
13496 2*b*d*fc*(5*epsc1 - 4*epsn))*
13497
13498
13499 pow(epsc1 + epsn, 2))) -
13500
13501
13502 2*as2*e0c*(3*e0cn*fy*k*n0*pow(epsc1, 2) -
13503
13504
13505 3*as1*pow(e0c, 2)*k*
13506
13507
13508 pow(epsc1,
13509
13510
13511 2)*(epsc1 + epsn)*(-fy + e0cn*(epsc1 + epsn)) -
13512
13513
13514 e0c*(3*fy*k*pow(epsc1, 2)*(n0 + as1*e0cn*(epsc1 + epsn)) +
13515
13516
13517 e0cn*(epsc1 + epsn)*(-3*k*n0*pow(epsc1, 2) +
13518
13519
13520 b*ch*fc*(epsc1 + epsn)*((-2 + 5*k)*epsc1 -
13521
13522
13523 4*(-1 + k)*epsn))))))/(2.*(as1*d*e0c +
13524
13525
13526 as2*ch*e0cn)*k*epsc1);
13527
13528
13529
13530
13531
13532 ac2 =(3*as1*d*pow(e0c, 2)*k*pow(epsc1, 2) +
13533
13534
13535 3*as2*(2*ch - d)*e0c*e0cn*k*
13536
13537
13538 pow(epsc1,
13539
13540
13541 2) + (3*sqrt(3.)*
13542
13543
13544 e0c*(pow(as1, 2)*pow(e0c, 3)*k*pow(epsc1, 2)*(epsc1 + epsn) +
13545
13546
13547 as2*e0cn*(2*b*ch*e0c*
13548
13549
13550 fc*(epsc1 + epsn)*(k*(epsc1 - 2*epsn) + 2*epsn) +
13551
13552
13553 k*pow(epsc1,
13554
13555
13556 2)*(-(e0c*n0) +
13557
13558
13559 as2*(e0cn*fy +
13560
13561
13562 e0c*(-fy + e0cn*(epsc1 + epsn))))) +
13563
13564
13565 as1*e0c*(2*b*d*e0c*
13566
13567
13568 fc*(epsc1 + epsn)*(k*(epsc1 - 2*epsn) + 2*epsn) +
13569
13570
13571 k*pow(epsc1,
13572
13573
13574 2)*(-(e0c*n0) +
13575
13576
13577 as2*(e0cn*fy +
13578
13579
13580 e0c*(-fy + 2*e0cn*(epsc1 + epsn))))))*
13581
13582
13583 sqrt(k*pow(epsc1,
13584
13585
13586 2)*(3*k*pow(epsc1, 2)*
13587
13588
13589 pow(d*e0c*(n0 + as1*e0c*(epsc1 - epsn)) +
13590
13591
13592 as2*(2*ch*e0c*e0cn*epsc1 -
13593
13594
13595 d*(e0cn*fy +
13596
13597
13598 e0c*(-fy + e0cn*(epsc1 + epsn)))), 2) +
13599
13600
13601 2*e0c*(as1*d*e0c +
13602
13603
13604 as2*ch*e0cn)*(b*pow(d, 2)*e0c*fc*
13605
13606
13607 pow(epsc1 + epsn,
13608
13609
13610 2)*((-2 + 5*k)*epsc1 - 4*(-1 + k)*epsn) +
13611
13612
13613 6*k*pow(epsc1,
13614
13615
13616 3)*(-(as2*ch*e0c*e0cn*epsc1) +
13617
13618
13619 d*(as2*e0cn*fy + as1*pow(e0c, 2)*epsn +
13620
13621
13622 e0c*(-(as2*fy) - n0 +
13623
13624
13625 as2*e0cn*(epsc1 + epsn))))))))/(3*
13626
13627
13628 pow(as2, 2)*k*pow(epsc1, 2)*
13629
13630
13631 pow(e0cn*fy + e0c*(-fy + e0cn*(epsc1 + epsn)), 2) +
13632
13633
13634 pow(e0c,
13635
13636
13637 2)*(-4*as1*b*d*e0c*fc*(epsc1 - 2*epsn)*pow(epsc1 + epsn, 2) +
13638
13639
13640 k*(3*pow(n0, 2)*pow(epsc1, 2) -
13641
13642
13643 6*as1*e0c*n0*pow(epsc1, 2)*(epsc1 + epsn) +
13644
13645
13646 as1*e0c*(3*as1*e0c*pow(epsc1, 2) +
13647
13648
13649 2*b*d*fc*(5*epsc1 - 4*epsn))*
13650
13651
13652 pow(epsc1 + epsn, 2))) -
13653
13654
13655 2*as2*e0c*(3*e0cn*fy*k*n0*pow(epsc1, 2) -
13656
13657
13658 3*as1*pow(e0c, 2)*k*
13659
13660
13661 pow(epsc1, 2)*(epsc1 + epsn)*(-fy + e0cn*(epsc1 + epsn)) -
13662
13663
13664 e0c*(3*fy*k*pow(epsc1, 2)*(n0 + as1*e0cn*(epsc1 + epsn)) +
13665
13666
13667 e0cn*(epsc1 + epsn)*(-3*k*n0*pow(epsc1, 2) +
13668
13669
13670 b*ch*fc*(epsc1 + epsn)*((-2 + 5*k)*epsc1 -
13671
13672
13673 4*(-1 + k)*epsn))))) -
13674
13675
13676 sqrt(3.)*epsc1*
13677
13678
13679 sqrt(k*pow(epsc1,
13680
13681
13682 2)*(3*k*pow(epsc1, 2)*
13683
13684
13685 pow(d*e0c*(n0 + as1*e0c*(epsc1 - epsn)) +
13686
13687
13688 as2*(2*ch*e0c*e0cn*epsc1 -
13689
13690
13691 d*(e0cn*fy + e0c*(-fy + e0cn*(epsc1 + epsn)))),
13692
13693
13694 2) + 2*e0c*(as1*d*e0c +
13695
13696
13697 as2*ch*e0cn)*(b*pow(d, 2)*e0c*fc*
13698
13699
13700 pow(epsc1 + epsn,
13701
13702
13703 2)*((-2 + 5*k)*epsc1 - 4*(-1 + k)*epsn) +
13704
13705
13706 6*k*pow(epsc1,
13707
13708
13709 3)*(-(as2*ch*e0c*e0cn*epsc1) +
13710
13711
13712 d*(as2*e0cn*fy + as1*pow(e0c, 2)*epsn +
13713
13714
13715 e0c*(-(as2*fy) - n0 +
13716
13717
13718 as2*e0cn*(epsc1 + epsn)))))))*(-pow(2*
13719
13720
13721
13722
13723
13724 e0c*(as1*d*e0c +
13725
13726
13727 as2*ch*e0cn)*(6*b*pow(d, 2)*e0c*
13728
13729
13730 fc*(epsc1 + epsn)*(k*(epsc1 - 2*epsn) + 2*epsn) +
13731
13732
13733 6*k*pow(epsc1,
13734
13735
13736 2)*(d*e0c*(-n0 + as1*e0c*epsn) +
13737
13738
13739 as2*(-2*ch*e0c*e0cn*epsc1 +
13740
13741
13742 d*(-(e0c*fy) + e0cn*fy +
13743
13744
13745 2*e0c*e0cn*epsc1 +
13746
13747
13748 e0c*e0cn*epsn)))) +
13749
13750
13751 6*e0c*(as1*d*e0c + as2*(2*ch - d)*e0cn)*k*
13752
13753
13754 pow(epsc1,
13755
13756
13757 2)*(d*e0c*(n0 + as1*e0c*(epsc1 - epsn)) +
13758
13759
13760 as2*(2*ch*e0c*e0cn*epsc1 -
13761
13762
13763 d*(e0cn*fy +
13764
13765
13766 e0c*(-fy + e0cn*(epsc1 + epsn))))),
13767
13768
13769 2)/(4.*pow(3*k*pow(epsc1, 2)*
13770
13771
13772 pow(d*e0c*(n0 + as1*e0c*(epsc1 - epsn)) +
13773
13774
13775 as2*(2*ch*e0c*e0cn*epsc1 -
13776
13777
13778 d*(e0cn*fy +
13779
13780
13781 e0c*(-fy + e0cn*(epsc1 + epsn)))),
13782
13783
13784 2) + 2*
13785
13786
13787 e0c*(as1*d*e0c +
13788
13789
13790 as2*ch*e0cn)*(b*pow(d, 2)*e0c*fc*
13791
13792
13793 pow(epsc1 + epsn,
13794
13795
13796 2)*((-2 + 5*k)*epsc1 - 4*(-1 + k)*epsn) +
13797
13798
13799 6*k*pow(epsc1,
13800
13801
13802 3)*(-(as2*ch*e0c*e0cn*epsc1) +
13803
13804
13805 d*(as2*e0cn*fy + as1*pow(e0c, 2)*epsn +
13806
13807
13808 e0c*(-(as2*fy) - n0 +
13809
13810
13811 as2*e0cn*(epsc1 + epsn))))), 2)) + (3*
13812
13813
13814 pow(e0c,
13815
13816
13817 2)*(pow(as1*d*e0c + as2*(2*ch - d)*e0cn, 2)*k*
13818
13819
13820 pow(epsc1, 2) -
13821
13822
13823 2*(as1*d*e0c +
13824
13825
13826 as2*ch*e0cn)*(2*as2*(ch - d)*e0cn*k*
13827
13828
13829 pow(epsc1, 2) +
13830
13831
13832 b*pow(d, 2)*
13833
13834
13835 fc*((-2 + k)*epsc1 + 4*(-1 + k)*epsn))))/(3*k*
13836
13837
13838 pow(epsc1, 2)*
13839
13840
13841 pow(d*e0c*(n0 + as1*e0c*(epsc1 - epsn)) +
13842
13843
13844 as2*(2*ch*e0c*e0cn*epsc1 -
13845
13846
13847 d*(e0cn*fy + e0c*(-fy + e0cn*(epsc1 + epsn)))),
13848
13849
13850 2) + 2*e0c*(as1*d*e0c +
13851
13852
13853 as2*ch*e0cn)*(b*pow(d, 2)*e0c*fc*
13854
13855
13856 pow(epsc1 + epsn,
13857
13858
13859 2)*((-2 + 5*k)*epsc1 - 4*(-1 + k)*epsn) +
13860
13861
13862 6*k*pow(epsc1,
13863
13864
13865 3)*(-(as2*ch*e0c*e0cn*epsc1) +
13866
13867
13868 d*(as2*e0cn*fy + as1*pow(e0c, 2)*epsn +
13869
13870
13871 e0c*(-(as2*fy) - n0 +
13872
13873
13874 as2*e0cn*(epsc1 + epsn))))))))/(6.*
13875
13876
13877 e0c*(as1*d*e0c + as2*ch*e0cn)*k*pow(epsc1, 2));
13878
13879
13880 ac3 =(sqrt(k*pow(epsc1,
13881
13882
13883 2)*(3*k*pow(epsc1, 2)*
13884
13885
13886 pow(d*e0c*(n0 + as1*e0c*(epsc1 - epsn)) +
13887
13888
13889 as2*(2*ch*e0c*e0cn*epsc1 -
13890
13891
13892 d*(e0cn*fy + e0c*(-fy + e0cn*(epsc1 + epsn)))),
13893
13894
13895 2) + 2*e0c*(as1*d*e0c +
13896
13897
13898 as2*ch*e0cn)*(b*pow(d, 2)*e0c*fc*
13899
13900
13901 pow(epsc1 + epsn,
13902
13903
13904 2)*((-2 + 5*k)*epsc1 - 4*(-1 + k)*epsn) +
13905
13906
13907 6*k*pow(epsc1,
13908
13909
13910 3)*(-(as2*ch*e0c*e0cn*epsc1) +
13911
13912
13913 d*(as2*e0cn*fy + as1*pow(e0c, 2)*epsn +
13914
13915
13916 e0c*(-(as2*fy) - n0 +
13917
13918
13919 as2*e0cn*(epsc1 + epsn)))))))*(-pow(2*
13920
13921
13922 e0c*(as1*d*e0c +
13923
13924
13925 as2*ch*e0cn)*(6*b*pow(d, 2)*e0c*
13926
13927
13928 fc*(epsc1 + epsn)*(k*(epsc1 - 2*epsn) + 2*epsn) +
13929
13930
13931 6*k*pow(epsc1,
13932
13933
13934 2)*(d*e0c*(-n0 + as1*e0c*epsn) +
13935
13936
13937 as2*(-2*ch*e0c*e0cn*epsc1 +
13938
13939
13940 d*(-(e0c*fy) + e0cn*fy +
13941
13942
13943 2*e0c*e0cn*epsc1 +
13944
13945
13946 e0c*e0cn*epsn)))) +
13947
13948
13949 6*e0c*(as1*d*e0c + as2*(2*ch - d)*e0cn)*k*
13950
13951
13952 pow(epsc1,
13953
13954
13955 2)*(d*e0c*(n0 + as1*e0c*(epsc1 - epsn)) +
13956
13957
13958 as2*(2*ch*e0c*e0cn*epsc1 -
13959
13960
13961 d*(e0cn*fy + e0c*(-fy + e0cn*(epsc1 + epsn))))),
13962
13963
13964 2)/(4.*
13965
13966
13967 pow(3*k*pow(epsc1, 2)*
13968
13969
13970 pow(d*e0c*(n0 + as1*e0c*(epsc1 - epsn)) +
13971
13972
13973 as2*(2*ch*e0c*e0cn*epsc1 -
13974
13975
13976 d*(e0cn*fy +
13977
13978
13979 e0c*(-fy + e0cn*(epsc1 + epsn)))),
13980
13981
13982 2) + 2*
13983
13984
13985 e0c*(as1*d*e0c +
13986
13987
13988 as2*ch*e0cn)*(b*pow(d, 2)*e0c*fc*
13989
13990
13991 pow(epsc1 + epsn,
13992
13993
13994 2)*((-2 + 5*k)*epsc1 - 4*(-1 + k)*epsn) +
13995
13996
13997 6*k*pow(epsc1,
13998
13999
14000 3)*(-(as2*ch*e0c*e0cn*epsc1) +
14001
14002
14003 d*(as2*e0cn*fy + as1*pow(e0c, 2)*epsn +
14004
14005
14006 e0c*(-(as2*fy) - n0 +
14007
14008
14009 as2*e0cn*(epsc1 + epsn))))), 2)) + (3*
14010
14011
14012 pow(e0c,
14013
14014
14015 2)*(pow(as1*d*e0c + as2*(2*ch - d)*e0cn, 2)*k*
14016
14017
14018 pow(epsc1, 2) -
14019
14020
14021 2*(as1*d*e0c +
14022
14023
14024 as2*ch*e0cn)*(2*as2*(ch - d)*e0cn*k*pow(epsc1, 2) +
14025
14026
14027 b*pow(d, 2)*
14028
14029
14030 fc*((-2 + k)*epsc1 + 4*(-1 + k)*epsn))))/(3*k*
14031
14032
14033 pow(epsc1, 2)*
14034
14035
14036 pow(d*e0c*(n0 + as1*e0c*(epsc1 - epsn)) +
14037
14038
14039 as2*(2*ch*e0c*e0cn*epsc1 -
14040
14041
14042 d*(e0cn*fy + e0c*(-fy + e0cn*(epsc1 + epsn)))),
14043
14044
14045 2) + 2*e0c*(as1*d*e0c +
14046
14047
14048 as2*ch*e0cn)*(b*pow(d, 2)*e0c*fc*
14049
14050
14051 pow(epsc1 + epsn,
14052
14053
14054 2)*((-2 + 5*k)*epsc1 - 4*(-1 + k)*epsn) +
14055
14056
14057 6*k*pow(epsc1,
14058
14059
14060 3)*(-(as2*ch*e0c*e0cn*epsc1) +
14061
14062
14063 d*(as2*e0cn*fy + as1*pow(e0c, 2)*epsn +
14064
14065
14066 e0c*(-(as2*fy) - n0 +
14067
14068
14069 as2*e0cn*(epsc1 + epsn))))))))/(4.*
14070
14071
14072 sqrt(3.)*e0c*(as1*d*e0c + as2*ch*e0cn)*k*pow(epsc1, 2));
14073
14074
14075
14076
14077
14078
14079
14080
14081 if (pow(ac2, 2) - 4*ac1*ac3 < 0.0){
14082
14083
14084
14085
14086
14087 epscp=-1.0;
14088
14089
14090
14091
14092
14093 }
14094
14095
14096
14097
14098
14099 else{
14100
14101
14102
14103
14104
14105 epscp=(-ac2 - sqrt(pow(ac2, 2) - 4*ac1*ac3))/(2.*ac3);
14106
14107
14108
14109
14110
14111 }
14112
14113
14114 return epscp;
14115
14116
14117 }
14118
14119
14120
14121
14122
14123
14124
14125
14126 double normmat::compute_epschr6 ()
14127
14128
14129 {
14130
14131
14132 double ac1,ac2,ac3,epschr6;
14133
14134
14135
14136
14137
14138 ac1 =-(fy/e0c) + epsn + (3*d*e0c*k*pow(epsc1, 2)*(n0 + as1*e0c*(epscp - epsn)) +
14139
14140
14141 3*as2*k*pow(epsc1,
14142
14143
14144 2)*(2*ch*e0c*e0cn*epscp +
14145
14146
14147 d*(-(e0cn*fy) + e0c*(fy - e0cn*(epscp + epsn)))) +
14148
14149
14150 sqrt(3.)*sqrt(k*
14151
14152
14153 pow(epsc1,
14154
14155
14156 2)*(3*k*pow(epsc1, 2)*
14157
14158
14159 pow(d*e0c*(n0 + as1*e0c*(epscp - epsn)) +
14160
14161
14162 as2*(2*ch*e0c*e0cn*epscp -
14163
14164
14165 d*(e0cn*fy + e0c*(-fy + e0cn*(epscp + epsn)))),
14166
14167
14168 2) + 2*e0c*(as1*d*e0c +
14169
14170
14171 as2*ch*
14172
14173
14174 e0cn)*(-(b*pow(d, 2)*e0c*fc*
14175
14176
14177 pow(epscp + epsn,
14178
14179
14180 2)*((6 - 9*k)*epsc1 +
14181
14182
14183 4*(-1 + k)*(epscp + epsn))) +
14184
14185
14186 6*k*pow(epsc1, 2)*
14187
14188
14189 epscp*(-(as2*ch*e0c*e0cn*epscp) +
14190
14191
14192 d*(as2*e0cn*fy + as1*pow(e0c, 2)*epsn +
14193
14194
14195 e0c*(-(as2*fy) - n0 +
14196
14197
14198 as2*e0cn*(epscp + epsn))))))))/(6.*
14199
14200
14201 e0c*(as1*d*e0c + as2*ch*e0cn)*k*
14202
14203
14204 pow(epsc1,
14205
14206
14207 2)) - (epscp*(6*as1*d*pow(e0c, 2) +
14208
14209
14210 6*as2*(2*ch - d)*e0c*
14211
14212
14213 e0cn + (sqrt(3.)*(6*e0c*(as1*d*e0c + as2*(2*ch - d)*e0cn)*k*
14214
14215
14216 pow(epsc1,
14217
14218
14219 2)*(d*e0c*(n0 + as1*e0c*(epscp - epsn)) +
14220
14221
14222 as2*(2*ch*e0c*e0cn*epscp -
14223
14224
14225 d*(e0cn*fy +
14226
14227
14228 e0c*(-fy + e0cn*(epscp + epsn))))) +
14229
14230
14231 2*e0c*(as1*d*e0c +
14232
14233
14234 as2*ch*e0cn)*(-6*b*pow(d, 2)*e0c*
14235
14236
14237 fc*(epscp + epsn)*((2 - 3*k)*epsc1 +
14238
14239
14240 2*(-1 + k)*(epscp + epsn)) -
14241
14242
14243 6*k*pow(epsc1,
14244
14245
14246 2)*(d*e0c*(n0 - as1*e0c*epsn) +
14247
14248
14249 as2*(2*ch*e0c*e0cn*epscp +
14250
14251
14252 d*(-(e0cn*fy) +
14253
14254
14255 e0c*(fy - e0cn*(2*epscp +
14256
14257
14258 epsn))))))))/
14259
14260
14261 sqrt(k*pow(epsc1,
14262
14263
14264 2)*(3*k*pow(epsc1, 2)*
14265
14266
14267 pow(d*e0c*(n0 + as1*e0c*(epscp - epsn)) +
14268
14269
14270 as2*(2*ch*e0c*e0cn*epscp -
14271
14272
14273 d*(e0cn*fy +
14274
14275
14276 e0c*(-fy + e0cn*(epscp + epsn)))),
14277
14278
14279 2) + 2*
14280
14281
14282 e0c*(as1*d*e0c +
14283
14284
14285 as2*ch*
14286
14287
14288 e0cn)*(-(b*pow(d, 2)*e0c*fc*
14289
14290
14291 pow(epscp + epsn,
14292
14293
14294 2)*((6 - 9*k)*epsc1 +
14295
14296
14297 4*(-1 + k)*(epscp + epsn))) +
14298
14299
14300 6*k*pow(epsc1, 2)*
14301
14302
14303 epscp*(-(as2*ch*e0c*e0cn*epscp) +
14304
14305
14306 d*(as2*e0cn*fy + as1*pow(e0c, 2)*epsn +
14307
14308
14309 e0c*(-(as2*fy) - n0 +
14310
14311
14312 as2*e0cn*(epscp + epsn)))))))))/(12.*
14313
14314
14315 e0c*(as1*d*e0c + as2*ch*e0cn)) + (pow(epscp, 2)*
14316
14317
14318 sqrt(k*pow(epsc1,
14319
14320
14321 2)*(3*k*pow(epsc1, 2)*
14322
14323
14324 pow(d*e0c*(n0 + as1*e0c*(epscp - epsn)) +
14325
14326
14327 as2*(2*ch*e0c*e0cn*epscp -
14328
14329
14330 d*(e0cn*fy + e0c*(-fy + e0cn*(epscp + epsn)))),
14331
14332
14333 2) + 2*e0c*(as1*d*e0c +
14334
14335
14336 as2*ch*e0cn)*(-(b*pow(d, 2)*e0c*fc*
14337
14338
14339 pow(epscp + epsn,
14340
14341
14342 2)*((6 - 9*k)*epsc1 +
14343
14344
14345 4*(-1 + k)*(epscp + epsn))) +
14346
14347
14348 6*k*pow(epsc1, 2)*
14349
14350
14351 epscp*(-(as2*ch*e0c*e0cn*epscp) +
14352
14353
14354 d*(as2*e0cn*fy + as1*pow(e0c, 2)*epsn +
14355
14356
14357 e0c*(-(as2*fy) - n0 +
14358
14359
14360 as2*e0cn*(epscp +
14361
14362
14363 epsn)))))))*((e0c*(3*e0c*
14364
14365
14366 pow(as1*d*e0c + as2*(2*ch - d)*e0cn, 2)*k*
14367
14368
14369 pow(epsc1, 2) +
14370
14371
14372 2*(as1*d*e0c +
14373
14374
14375 as2*ch*e0cn)*(6*as2*(-ch + d)*e0c*e0cn*k*
14376
14377
14378 pow(epsc1, 2) +
14379
14380
14381 3*b*pow(d, 2)*e0c*
14382
14383
14384 fc*((-2 + 3*k)*epsc1 -
14385
14386
14387 4*(-1 + k)*(epscp + epsn)))))/(3*k*
14388
14389
14390 pow(epsc1, 2)*
14391
14392
14393 pow(d*e0c*(n0 + as1*e0c*(epscp - epsn)) +
14394
14395
14396 as2*(2*ch*e0c*e0cn*epscp -
14397
14398
14399 d*(e0cn*fy + e0c*(-fy + e0cn*(epscp + epsn)))),
14400
14401
14402 2) + 2*e0c*(as1*d*e0c +
14403
14404
14405 as2*ch*
14406
14407
14408 e0cn)*(-(b*pow(d, 2)*e0c*fc*
14409
14410
14411 pow(epscp + epsn,
14412
14413
14414 2)*((6 - 9*k)*epsc1 +
14415
14416
14417 4*(-1 + k)*(epscp + epsn))) +
14418
14419
14420 6*k*pow(epsc1, 2)*
14421
14422
14423 epscp*(-(as2*ch*e0c*e0cn*epscp) +
14424
14425
14426 d*(as2*e0cn*fy + as1*pow(e0c, 2)*epsn +
14427
14428
14429 e0c*(-(as2*fy) - n0 +
14430
14431
14432 as2*e0cn*(epscp + epsn)))))) -
14433
14434
14435 pow(6*e0c*(as1*d*e0c + as2*(2*ch - d)*e0cn)*k*
14436
14437
14438 pow(epsc1,
14439
14440
14441 2)*(d*e0c*(n0 + as1*e0c*(epscp - epsn)) +
14442
14443
14444 as2*(2*ch*e0c*e0cn*epscp -
14445
14446
14447 d*(e0cn*fy +
14448
14449
14450 e0c*(-fy + e0cn*(epscp + epsn))))) +
14451
14452
14453 2*e0c*(as1*d*e0c +
14454
14455
14456 as2*ch*e0cn)*(-6*b*pow(d, 2)*e0c*
14457
14458
14459 fc*(epscp + epsn)*((2 - 3*k)*epsc1 +
14460
14461
14462 2*(-1 + k)*(epscp + epsn)) -
14463
14464
14465 6*k*pow(epsc1,
14466
14467
14468 2)*(d*e0c*(n0 - as1*e0c*epsn) +
14469
14470
14471 as2*(2*ch*e0c*e0cn*epscp +
14472
14473
14474 d*(-(e0cn*fy) +
14475
14476
14477 e0c*(fy - e0cn*(2*epscp + epsn)))))),
14478
14479
14480 2)/(4.*pow(3*k*pow(epsc1, 2)*
14481
14482
14483 pow(d*e0c*(n0 + as1*e0c*(epscp - epsn)) +
14484
14485
14486 as2*(2*ch*e0c*e0cn*epscp -
14487
14488
14489 d*(e0cn*fy +
14490
14491
14492 e0c*(-fy + e0cn*(epscp + epsn)))),
14493
14494
14495 2) + 2*
14496
14497
14498 e0c*(as1*d*e0c +
14499
14500
14501 as2*ch*
14502
14503
14504 e0cn)*(-(b*pow(d, 2)*e0c*fc*
14505
14506
14507 pow(epscp + epsn,
14508
14509
14510 2)*((6 - 9*k)*epsc1 +
14511
14512
14513 4*(-1 + k)*(epscp + epsn))) +
14514
14515
14516 6*k*pow(epsc1, 2)*
14517
14518
14519 epscp*(-(as2*ch*e0c*e0cn*epscp) +
14520
14521
14522 d*(as2*e0cn*fy + as1*pow(e0c, 2)*epsn +
14523
14524
14525 e0c*(-(as2*fy) - n0 +
14526
14527
14528 as2*e0cn*(epscp + epsn))))),
14529
14530
14531 2))))/(4.*sqrt(3.)*e0c*(as1*d*e0c + as2*ch*e0cn)*k*
14532
14533
14534 pow(epsc1, 2));
14535
14536
14537
14538
14539
14540 ac2 =(3*as1*d*pow(e0c, 2)*k*pow(epsc1, 2) +
14541
14542
14543 3*as2*(2*ch - d)*e0c*e0cn*k*
14544
14545
14546 pow(epsc1,
14547
14548
14549 2) + (sqrt(3.)*k*
14550
14551
14552 pow(epsc1,
14553
14554
14555 2)*(6*e0c*(as1*d*e0c + as2*(2*ch - d)*e0cn)*k*
14556
14557
14558 pow(epsc1,
14559
14560
14561 2)*(d*e0c*(n0 + as1*e0c*(epscp - epsn)) +
14562
14563
14564 as2*(2*ch*e0c*e0cn*epscp -
14565
14566
14567 d*(e0cn*fy + e0c*(-fy + e0cn*(epscp + epsn))))) +
14568
14569
14570 2*e0c*(as1*d*e0c +
14571
14572
14573 as2*ch*e0cn)*(-6*b*pow(d, 2)*e0c*
14574
14575
14576 fc*(epscp + epsn)*((2 - 3*k)*epsc1 +
14577
14578
14579 2*(-1 + k)*(epscp + epsn)) -
14580
14581
14582 6*k*pow(epsc1,
14583
14584
14585 2)*(d*e0c*(n0 - as1*e0c*epsn) +
14586
14587
14588 as2*(2*ch*e0c*e0cn*epscp +
14589
14590
14591 d*(-(e0cn*fy) +
14592
14593
14594 e0c*(fy -
14595
14596
14597 e0cn*(2*epscp + epsn))))))))/(2.*
14598
14599
14600 sqrt(k*pow(epsc1,
14601
14602
14603 2)*(3*k*pow(epsc1, 2)*
14604
14605
14606 pow(d*e0c*(n0 + as1*e0c*(epscp - epsn)) +
14607
14608
14609 as2*(2*ch*e0c*e0cn*epscp -
14610
14611
14612 d*(e0cn*fy +
14613
14614
14615 e0c*(-fy + e0cn*(epscp + epsn)))), 2) +
14616
14617
14618 2*e0c*(as1*d*e0c +
14619
14620
14621 as2*ch*
14622
14623
14624 e0cn)*(-(b*pow(d, 2)*e0c*fc*
14625
14626
14627 pow(epscp + epsn,
14628
14629
14630 2)*((6 - 9*k)*epsc1 +
14631
14632
14633 4*(-1 + k)*(epscp + epsn))) +
14634
14635
14636 6*k*pow(epsc1, 2)*
14637
14638
14639 epscp*(-(as2*ch*e0c*e0cn*epscp) +
14640
14641
14642 d*(as2*e0cn*fy + as1*pow(e0c, 2)*epsn +
14643
14644
14645 e0c*(-(as2*fy) - n0 +
14646
14647
14648 as2*e0cn*(epscp + epsn)))))))) -
14649
14650
14651 sqrt(3.)*epscp*
14652
14653
14654 sqrt(k*pow(epsc1,
14655
14656
14657 2)*(3*k*pow(epsc1, 2)*
14658
14659
14660 pow(d*e0c*(n0 + as1*e0c*(epscp - epsn)) +
14661
14662
14663 as2*(2*ch*e0c*e0cn*epscp -
14664
14665
14666 d*(e0cn*fy + e0c*(-fy + e0cn*(epscp + epsn)))),
14667
14668
14669 2) + 2*e0c*(as1*d*e0c +
14670
14671
14672 as2*ch*e0cn)*(-(b*pow(d, 2)*e0c*fc*
14673
14674
14675 pow(epscp + epsn,
14676
14677
14678 2)*((6 - 9*k)*epsc1 +
14679
14680
14681 4*(-1 + k)*(epscp + epsn))) +
14682
14683
14684 6*k*pow(epsc1, 2)*
14685
14686
14687 epscp*(-(as2*ch*e0c*e0cn*epscp) +
14688
14689
14690 d*(as2*e0cn*fy + as1*pow(e0c, 2)*epsn +
14691
14692
14693 e0c*(-(as2*fy) - n0 +
14694
14695
14696 as2*e0cn*(epscp +
14697
14698
14699 epsn)))))))*((e0c*(3*e0c*
14700
14701
14702 pow(as1*d*e0c + as2*(2*ch - d)*e0cn, 2)*k*
14703
14704
14705 pow(epsc1, 2) +
14706
14707
14708 2*(as1*d*e0c +
14709
14710
14711 as2*ch*e0cn)*(6*as2*(-ch + d)*e0c*e0cn*k*
14712
14713
14714 pow(epsc1, 2) +
14715
14716
14717 3*b*pow(d, 2)*e0c*
14718
14719
14720 fc*((-2 + 3*k)*epsc1 -
14721
14722
14723 4*(-1 + k)*(epscp + epsn)))))/(3*k*
14724
14725
14726 pow(epsc1, 2)*
14727
14728
14729 pow(d*e0c*(n0 + as1*e0c*(epscp - epsn)) +
14730
14731
14732 as2*(2*ch*e0c*e0cn*epscp -
14733
14734
14735 d*(e0cn*fy + e0c*(-fy + e0cn*(epscp + epsn)))),
14736
14737
14738 2) + 2*e0c*(as1*d*e0c +
14739
14740
14741 as2*ch*
14742
14743
14744 e0cn)*(-(b*pow(d, 2)*e0c*fc*
14745
14746
14747 pow(epscp + epsn,
14748
14749
14750 2)*((6 - 9*k)*epsc1 +
14751
14752
14753 4*(-1 + k)*(epscp + epsn))) +
14754
14755
14756 6*k*pow(epsc1, 2)*
14757
14758
14759 epscp*(-(as2*ch*e0c*e0cn*epscp) +
14760
14761
14762 d*(as2*e0cn*fy + as1*pow(e0c, 2)*epsn +
14763
14764
14765 e0c*(-(as2*fy) - n0 +
14766
14767
14768 as2*e0cn*(epscp + epsn)))))) -
14769
14770
14771 pow(6*e0c*(as1*d*e0c + as2*(2*ch - d)*e0cn)*k*
14772
14773
14774 pow(epsc1,
14775
14776
14777 2)*(d*e0c*(n0 + as1*e0c*(epscp - epsn)) +
14778
14779
14780 as2*(2*ch*e0c*e0cn*epscp -
14781
14782
14783 d*(e0cn*fy +
14784
14785
14786 e0c*(-fy + e0cn*(epscp + epsn))))) +
14787
14788
14789 2*e0c*(as1*d*e0c +
14790
14791
14792 as2*ch*e0cn)*(-6*b*pow(d, 2)*e0c*
14793
14794
14795 fc*(epscp + epsn)*((2 - 3*k)*epsc1 +
14796
14797
14798 2*(-1 + k)*(epscp + epsn)) -
14799
14800
14801 6*k*pow(epsc1,
14802
14803
14804 2)*(d*e0c*(n0 - as1*e0c*epsn) +
14805
14806
14807 as2*(2*ch*e0c*e0cn*epscp +
14808
14809
14810 d*(-(e0cn*fy) +
14811
14812
14813 e0c*(fy - e0cn*(2*epscp + epsn)))))),
14814
14815
14816 2)/(4.*pow(3*k*pow(epsc1, 2)*
14817
14818
14819 pow(d*e0c*(n0 + as1*e0c*(epscp - epsn)) +
14820
14821
14822 as2*(2*ch*e0c*e0cn*epscp -
14823
14824
14825 d*(e0cn*fy +
14826
14827
14828 e0c*(-fy + e0cn*(epscp + epsn)))),
14829
14830
14831 2) + 2*
14832
14833
14834 e0c*(as1*d*e0c +
14835
14836
14837 as2*ch*
14838
14839
14840 e0cn)*(-(b*pow(d, 2)*e0c*fc*
14841
14842
14843 pow(epscp + epsn,
14844
14845
14846 2)*((6 - 9*k)*epsc1 +
14847
14848
14849 4*(-1 + k)*(epscp + epsn))) +
14850
14851
14852 6*k*pow(epsc1, 2)*
14853
14854
14855 epscp*(-(as2*ch*e0c*e0cn*epscp) +
14856
14857
14858 d*(as2*e0cn*fy + as1*pow(e0c, 2)*epsn +
14859
14860
14861 e0c*(-(as2*fy) - n0 +
14862
14863
14864 as2*e0cn*(epscp + epsn))))),
14865
14866
14867 2))))/(6.*e0c*(as1*d*e0c + as2*ch*e0cn)*k*pow(epsc1, 2));
14868
14869
14870
14871
14872
14873 ac3 =(sqrt(k*pow(epsc1,
14874
14875
14876 2)*(3*k*pow(epsc1, 2)*
14877
14878
14879 pow(d*e0c*(n0 + as1*e0c*(epscp - epsn)) +
14880
14881
14882 as2*(2*ch*e0c*e0cn*epscp -
14883
14884
14885 d*(e0cn*fy + e0c*(-fy + e0cn*(epscp + epsn)))),
14886
14887
14888 2) + 2*e0c*(as1*d*e0c +
14889
14890
14891 as2*ch*e0cn)*(-(b*pow(d, 2)*e0c*fc*
14892
14893
14894 pow(epscp + epsn,
14895
14896
14897 2)*((6 - 9*k)*epsc1 +
14898
14899
14900 4*(-1 + k)*(epscp + epsn))) +
14901
14902
14903 6*k*pow(epsc1, 2)*
14904
14905
14906 epscp*(-(as2*ch*e0c*e0cn*epscp) +
14907
14908
14909 d*(as2*e0cn*fy + as1*pow(e0c, 2)*epsn +
14910
14911
14912 e0c*(-(as2*fy) - n0 +
14913
14914
14915 as2*e0cn*(epscp + epsn)))))))*((e0c*(3*
14916
14917
14918 e0c*pow(as1*d*e0c + as2*(2*ch - d)*e0cn, 2)*k*
14919
14920
14921 pow(epsc1, 2) +
14922
14923
14924 2*(as1*d*e0c +
14925
14926
14927 as2*ch*e0cn)*(6*as2*(-ch + d)*e0c*e0cn*k*
14928
14929
14930 pow(epsc1, 2) +
14931
14932
14933 3*b*pow(d, 2)*e0c*
14934
14935
14936 fc*((-2 + 3*k)*epsc1 -
14937
14938
14939 4*(-1 + k)*(epscp + epsn)))))/(3*k*
14940
14941
14942 pow(epsc1, 2)*
14943
14944
14945 pow(d*e0c*(n0 + as1*e0c*(epscp - epsn)) +
14946
14947
14948 as2*(2*ch*e0c*e0cn*epscp -
14949
14950
14951 d*(e0cn*fy + e0c*(-fy + e0cn*(epscp + epsn)))),
14952
14953
14954 2) + 2*e0c*(as1*d*e0c +
14955
14956
14957 as2*ch*e0cn)*(-(b*pow(d, 2)*e0c*fc*
14958
14959
14960 pow(epscp + epsn,
14961
14962
14963 2)*((6 - 9*k)*epsc1 +
14964
14965
14966 4*(-1 + k)*(epscp + epsn))) +
14967
14968
14969 6*k*pow(epsc1, 2)*
14970
14971
14972 epscp*(-(as2*ch*e0c*e0cn*epscp) +
14973
14974
14975 d*(as2*e0cn*fy + as1*pow(e0c, 2)*epsn +
14976
14977
14978 e0c*(-(as2*fy) - n0 +
14979
14980
14981 as2*e0cn*(epscp + epsn)))))) -
14982
14983
14984 pow(6*e0c*(as1*d*e0c + as2*(2*ch - d)*e0cn)*k*
14985
14986
14987 pow(epsc1,
14988
14989
14990 2)*(d*e0c*(n0 + as1*e0c*(epscp - epsn)) +
14991
14992
14993 as2*(2*ch*e0c*e0cn*epscp -
14994
14995
14996 d*(e0cn*fy +
14997
14998
14999 e0c*(-fy + e0cn*(epscp + epsn))))) +
15000
15001
15002 2*e0c*(as1*d*e0c +
15003
15004
15005 as2*ch*e0cn)*(-6*b*pow(d, 2)*e0c*
15006
15007
15008 fc*(epscp + epsn)*((2 - 3*k)*epsc1 +
15009
15010
15011 2*(-1 + k)*(epscp + epsn)) -
15012
15013
15014 6*k*pow(epsc1,
15015
15016
15017 2)*(d*e0c*(n0 - as1*e0c*epsn) +
15018
15019
15020 as2*(2*ch*e0c*e0cn*epscp +
15021
15022
15023 d*(-(e0cn*fy) +
15024
15025
15026 e0c*(fy - e0cn*(2*epscp + epsn)))))),
15027
15028
15029 2)/(4.*pow(3*k*pow(epsc1, 2)*
15030
15031
15032 pow(d*e0c*(n0 + as1*e0c*(epscp - epsn)) +
15033
15034
15035 as2*(2*ch*e0c*e0cn*epscp -
15036
15037
15038 d*(e0cn*fy +
15039
15040
15041 e0c*(-fy + e0cn*(epscp + epsn)))),
15042
15043
15044 2) + 2*
15045
15046
15047 e0c*(as1*d*e0c +
15048
15049
15050 as2*ch*
15051
15052
15053 e0cn)*(-(b*pow(d, 2)*e0c*fc*
15054
15055
15056 pow(epscp + epsn,
15057
15058
15059 2)*((6 - 9*k)*epsc1 +
15060
15061
15062 4*(-1 + k)*(epscp + epsn))) +
15063
15064
15065 6*k*pow(epsc1, 2)*
15066
15067
15068 epscp*(-(as2*ch*e0c*e0cn*epscp) +
15069
15070
15071 d*(as2*e0cn*fy + as1*pow(e0c, 2)*epsn +
15072
15073
15074 e0c*(-(as2*fy) - n0 +
15075
15076
15077 as2*e0cn*(epscp + epsn))))),
15078
15079
15080 2))))/(4.*sqrt(3.)*e0c*(as1*d*e0c + as2*ch*e0cn)*k*
15081
15082
15083 pow(epsc1, 2));
15084
15085
15086
15087
15088
15089
15090
15091
15092 if ((sqrt(k*pow(epsc1,
15093
15094
15095 2)*(3*k*pow(epsc1, 2)*
15096
15097
15098 pow(d*e0c*(n0 + as1*e0c*(epscp - epsn)) +
15099
15100
15101 as2*(2*ch*e0c*e0cn*epscp -
15102
15103
15104 d*(e0cn*fy + e0c*(-fy + e0cn*(epscp + epsn)))), 2) +
15105
15106
15107 2*e0c*(as1*d*e0c +
15108
15109
15110 as2*ch*e0cn)*(-(b*pow(d, 2)*e0c*fc*
15111
15112
15113 pow(epscp + epsn,
15114
15115
15116 2)*((6 - 9*k)*epsc1 + 4*(-1 + k)*(epscp + epsn))) +
15117
15118
15119 6*k*pow(epsc1, 2)*
15120
15121
15122 epscp*(-(as2*ch*e0c*e0cn*epscp) +
15123
15124
15125 d*(as2*e0cn*fy + as1*pow(e0c, 2)*epsn +
15126
15127
15128 e0c*(-(as2*fy) - n0 +
15129
15130
15131 as2*e0cn*(epscp + epsn)))))))) < 0.0 || epscp == -1.0 || (pow(ac2, 2) - 4*ac1*ac3) < 0.0){
15132
15133
15134
15135
15136
15137 epschr6=-1.0;
15138
15139
15140
15141
15142
15143 }
15144
15145
15146 else{
15147
15148
15149 epschr6=(-ac2 - sqrt(pow(ac2, 2) - 4*ac1*ac3))/(2.*ac3);
15150
15151
15152 }
15153
15154
15155 return epschr6;
15156
15157
15158 }
15159
15160
15161
15162
15163
15164
15165
15166
15167 double normmat::compute_mhr6 ()
15168
15169
15170 {
15171
15172
15173 double mhr6;
15174
15175
15176
15177
15178
15179 if (epschr6 < 0 && epschr6 != -1){
15180
15181
15182
15183
15184
15185 mhr6=0.08333333333333333*(6*as1*
15186
15187
15188 e0c*(-2*cd +
15189
15190
15191 h)*(epsn + (3*d*e0c*k*
15192
15193
15194 pow(epsc1, 2)*(n0 + as1*e0c*(epschr6 - epsn)) +
15195
15196
15197 3*as2*k*
15198
15199
15200 pow(epsc1,
15201
15202
15203 2)*(2*ch*e0c*e0cn*epschr6 +
15204
15205
15206 d*(-e0cn*fy + e0c*(fy - e0cn*(epschr6 + epsn)))) +
15207
15208
15209 sqrt(3.)*
15210
15211
15212 sqrt(k*pow(epsc1,
15213
15214
15215 2)*(3*k*pow(epsc1, 2)*
15216
15217
15218 pow(d*e0c*(n0 + as1*e0c*(epschr6 - epsn)) +
15219
15220
15221 as2*(2*ch*e0c*e0cn*epschr6 +
15222
15223
15224 d*(-e0cn*fy +
15225
15226
15227 e0c*(fy - e0cn*(epschr6 + epsn)))),
15228
15229
15230 2) + 2*
15231
15232
15233 e0c*(as1*d*e0c +
15234
15235
15236 as2*ch*e0cn)*(-b*pow(d, 2)*e0c*fc*
15237
15238
15239 pow(epschr6 + epsn,
15240
15241
15242 2)*(4*(-1 + k)*epschr6 + (6 - 9*k)*
15243
15244
15245 epsc1 + 4*(-1 + k)*epsn) +
15246
15247
15248 6*k*epschr6*
15249
15250
15251 pow(epsc1,
15252
15253
15254 2)*(-as2*ch*e0c*e0cn*epschr6 +
15255
15256
15257 d*(as2*e0cn*fy +
15258
15259
15260 as1*pow(e0c, 2)*epsn +
15261
15262
15263 e0c*(-as2*fy - n0 +
15264
15265
15266 as2*e0cn*(epschr6 + epsn))))))))/(6.*
15267
15268
15269 e0c*(as1*d*e0c + as2*ch*e0cn)*k*pow(epsc1, 2))) - (b*d*fc*
15270
15271
15272 pow(epschr6 + epsn,
15273
15274
15275 2)*(2*d*(epschr6 +
15276
15277
15278 epsn)*((-1 + k)*epschr6 + (2 - 3*k)*epsc1 + (-1 + k)*
15279
15280
15281 epsn) -
15282
15283
15284 h*(4*(-1 + k)*epschr6 + (6 - 9*k)*epsc1 +
15285
15286
15287 4*(-1 + k)*
15288
15289
15290 epsn)*(epschr6 - (3*d*e0c*k*
15291
15292
15293 pow(epsc1, 2)*(n0 + as1*e0c*(epschr6 - epsn)) +
15294
15295
15296 3*as2*k*
15297
15298
15299 pow(epsc1,
15300
15301
15302 2)*(2*ch*e0c*e0cn*epschr6 +
15303
15304
15305 d*(-e0cn*fy +
15306
15307
15308 e0c*(fy - e0cn*(epschr6 + epsn)))) +
15309
15310
15311 sqrt(3.)*
15312
15313
15314 sqrt(k*
15315
15316
15317 pow(epsc1,
15318
15319
15320 2)*(3*k*pow(epsc1, 2)*
15321
15322
15323 pow(d*
15324
15325
15326 e0c*(n0 + as1*e0c*(epschr6 - epsn)) +
15327
15328
15329 as2*(2*ch*e0c*e0cn*epschr6 +
15330
15331
15332 d*(-e0cn*fy + e0c*(fy -
15333
15334
15335 e0cn*(epschr6 + epsn)))), 2) +
15336
15337
15338 2*e0c*(as1*d*e0c +
15339
15340
15341 as2*ch*e0cn)*(-b*pow(d, 2)*e0c*fc*
15342
15343
15344 pow(epschr6 + epsn,
15345
15346
15347 2)*(4*(-1 + k)*epschr6 + (6 - 9*k)*
15348
15349
15350 epsc1 + 4*(-1 + k)*epsn) +
15351
15352
15353 6*k*epschr6*
15354
15355
15356 pow(epsc1,
15357
15358
15359 2)*(-as2*ch*e0c*e0cn*epschr6 +
15360
15361
15362 d*(as2*e0cn*fy +
15363
15364
15365 as1*pow(e0c, 2)*epsn +
15366
15367
15368 e0c*(-as2*fy - n0 + as2*
15369
15370
15371 e0cn*(epschr6 + epsn))))))))/(6.*
15372
15373
15374 e0c*(as1*d*e0c + as2*ch*e0cn)*k*
15375
15376
15377 pow(epsc1, 2)))))/(k*pow(epsc1, 2)*
15378
15379
15380 pow(epschr6 - (3*d*e0c*k*
15381
15382
15383 pow(epsc1, 2)*(n0 + as1*e0c*(epschr6 - epsn)) +
15384
15385
15386 3*as2*k*
15387
15388
15389 pow(epsc1,
15390
15391
15392 2)*(2*ch*e0c*e0cn*epschr6 +
15393
15394
15395 d*(-e0cn*fy + e0c*(fy - e0cn*(epschr6 + epsn)))) +
15396
15397
15398 sqrt(3.)*
15399
15400
15401 sqrt(k*
15402
15403
15404 pow(epsc1,
15405
15406
15407 2)*(3*k*pow(epsc1, 2)*
15408
15409
15410 pow(d*e0c*(n0 + as1*e0c*(epschr6 - epsn)) +
15411
15412
15413 as2*(2*ch*e0c*e0cn*epschr6 +
15414
15415
15416 d*(-e0cn*fy +
15417
15418
15419 e0c*(fy - e0cn*(epschr6 + epsn)))),
15420
15421
15422 2) + 2*
15423
15424
15425 e0c*(as1*d*e0c +
15426
15427
15428 as2*ch*e0cn)*(-b*pow(d, 2)*e0c*fc*
15429
15430
15431 pow(epschr6 + epsn,
15432
15433
15434 2)*(4*(-1 + k)*epschr6 + (6 - 9*k)*
15435
15436
15437 epsc1 + 4*(-1 + k)*epsn) +
15438
15439
15440 6*k*epschr6*
15441
15442
15443 pow(epsc1,
15444
15445
15446 2)*(-as2*ch*e0c*e0cn*epschr6 +
15447
15448
15449 d*(as2*e0cn*fy +
15450
15451
15452 as1*pow(e0c, 2)*epsn +
15453
15454
15455 e0c*(-as2*fy - n0 +
15456
15457
15458 as2*e0cn*(epschr6 + epsn))))))))/(6.*
15459
15460
15461 e0c*(as1*d*e0c + as2*ch*e0cn)*k*pow(epsc1, 2)), 2)) +
15462
15463
15464 6*as2*(-2*ch + h)*(fy -
15465
15466
15467 e0cn*(fy/e0c + epschr6 - (ch*epschr6)/d +
15468
15469
15470 epsn + (ch*(3*d*e0c*k*
15471
15472
15473 pow(epsc1, 2)*(n0 + as1*e0c*(epschr6 - epsn)) +
15474
15475
15476 3*as2*k*
15477
15478
15479 pow(epsc1,
15480
15481
15482 2)*(2*ch*e0c*e0cn*epschr6 +
15483
15484
15485 d*(-e0cn*fy +
15486
15487
15488 e0c*(fy - e0cn*(epschr6 + epsn)))) +
15489
15490
15491 sqrt(3.)*
15492
15493
15494 sqrt(k*
15495
15496
15497 pow(epsc1,
15498
15499
15500 2)*(3*k*pow(epsc1, 2)*
15501
15502
15503 pow(d*
15504
15505
15506 e0c*(n0 + as1*e0c*(epschr6 - epsn)) +
15507
15508
15509 as2*(2*ch*e0c*e0cn*epschr6 +
15510
15511
15512 d*(-e0cn*fy + e0c*(fy -
15513
15514
15515 e0cn*(epschr6 + epsn)))), 2) +
15516
15517
15518 2*e0c*(as1*d*e0c +
15519
15520
15521 as2*ch*e0cn)*(-b*pow(d, 2)*e0c*fc*
15522
15523
15524 pow(epschr6 + epsn,
15525
15526
15527 2)*(4*(-1 + k)*epschr6 + (6 - 9*k)*
15528
15529
15530 epsc1 + 4*(-1 + k)*epsn) +
15531
15532
15533 6*k*epschr6*
15534
15535
15536 pow(epsc1,
15537
15538
15539 2)*(-as2*ch*e0c*e0cn*epschr6 +
15540
15541
15542 d*(as2*e0cn*fy +
15543
15544
15545 as1*pow(e0c, 2)*epsn +
15546
15547
15548 e0c*(-as2*fy - n0 + as2*
15549
15550
15551 e0cn*(epschr6 + epsn)))))))))/(6.*d*
15552
15553
15554 e0c*(as1*d*e0c + as2*ch*e0cn)*k*pow(epsc1, 2))))) + e0c*(-(as1*(-cd + h/2.)) + as2*(-ch + h/2.))*epsn;
15555
15556
15557
15558
15559
15560 }
15561
15562
15563 else{
15564
15565
15566 mhr6=1000000000.0;
15567
15568
15569 }
15570
15571
15572 return mhr6;
15573
15574
15575 }
15576
15577
15578
15579
15580
15581
15582
15583
15584 double normmat::compute_mmax3 ()
15585
15586
15587 {
15588
15589
15590 double mmax3;
15591
15592
15593
15594
15595
15596 mmax3 =(6*as1*e0c*(-2*cd +
15597
15598
15599 h)*(epsn + (3*d*e0c*k*
15600
15601
15602 pow(epsc1, 2)*(n0 + as1*e0c*(epscmax1 - epsn)) +
15603
15604
15605 3*as2*k*
15606
15607
15608 pow(epsc1,
15609
15610
15611 2)*(2*ch*e0c*e0cn*epscmax1 +
15612
15613
15614 d*(-(e0cn*fy) + e0c*(fy - e0cn*(epscmax1 + epsn)))) +
15615
15616
15617 sqrt(3.)*
15618
15619
15620 sqrt(k*pow(epsc1,
15621
15622
15623 2)*(3*k*pow(epsc1, 2)*
15624
15625
15626 pow(d*e0c*(n0 + as1*e0c*(epscmax1 - epsn)) +
15627
15628
15629 as2*(2*ch*e0c*e0cn*epscmax1 +
15630
15631
15632 d*(-(e0cn*fy) +
15633
15634
15635 e0c*(fy - e0cn*(epscmax1 + epsn)))),
15636
15637
15638 2) + 2*
15639
15640
15641 e0c*(as1*d*e0c +
15642
15643
15644 as2*ch*
15645
15646
15647 e0cn)*(-(b*pow(d, 2)*e0c*fc*
15648
15649
15650 pow(epscmax1 + epsn,
15651
15652
15653 2)*((6 - 9*k)*epsc1 +
15654
15655
15656 4*(-1 + k)*epscmax1 +
15657
15658
15659 4*(-1 + k)*epsn)) +
15660
15661
15662 6*k*pow(epsc1, 2)*
15663
15664
15665 epscmax1*(-(as2*ch*e0c*e0cn*epscmax1) +
15666
15667
15668 d*(as2*e0cn*fy +
15669
15670
15671 as1*pow(e0c, 2)*epsn +
15672
15673
15674 e0c*(-(as2*fy) - n0 +
15675
15676
15677 as2*e0cn*(epscmax1 + epsn))))))))/(6.*
15678
15679
15680 e0c*(as1*d*e0c + as2*ch*e0cn)*k*pow(epsc1, 2))) - (b*d*fc*
15681
15682
15683 pow(epscmax1 + epsn,
15684
15685
15686 2)*(2*d*(epscmax1 +
15687
15688
15689 epsn)*((2 - 3*k)*epsc1 + (-1 + k)*epscmax1 + (-1 + k)*
15690
15691
15692 epsn) -
15693
15694
15695 h*((6 - 9*k)*epsc1 + 4*(-1 + k)*epscmax1 +
15696
15697
15698 4*(-1 + k)*
15699
15700
15701 epsn)*(epscmax1 - (3*d*e0c*k*
15702
15703
15704 pow(epsc1,
15705
15706
15707 2)*(n0 + as1*e0c*(epscmax1 - epsn)) +
15708
15709
15710 3*as2*k*
15711
15712
15713 pow(epsc1,
15714
15715
15716 2)*(2*ch*e0c*e0cn*epscmax1 +
15717
15718
15719 d*(-(e0cn*fy) +
15720
15721
15722 e0c*(fy - e0cn*(epscmax1 + epsn)))) +
15723
15724
15725 sqrt(3.)*
15726
15727
15728 sqrt(k*
15729
15730
15731 pow(epsc1,
15732
15733
15734 2)*(3*k*pow(epsc1, 2)*
15735
15736
15737 pow(d*
15738
15739
15740 e0c*(n0 + as1*e0c*(epscmax1 - epsn)) +
15741
15742
15743 as2*(2*ch*e0c*e0cn*epscmax1 +
15744
15745
15746 d*(-(e0cn*fy) +
15747
15748
15749 e0c*(fy - e0cn*(epscmax1 + epsn)))),
15750
15751
15752 2) +
15753
15754
15755 2*e0c*(as1*d*e0c +
15756
15757
15758 as2*ch*
15759
15760
15761 e0cn)*(-(b*pow(d, 2)*e0c*fc*
15762
15763
15764 pow(epscmax1 + epsn,
15765
15766
15767 2)*((6 - 9*k)*epsc1 +
15768
15769
15770 4*(-1 + k)*epscmax1 +
15771
15772
15773 4*(-1 + k)*epsn)) +
15774
15775
15776 6*k*pow(epsc1, 2)*
15777
15778
15779 epscmax1*(-(as2*ch*e0c*e0cn*
15780
15781
15782 epscmax1) +
15783
15784
15785 d*(as2*e0cn*fy +
15786
15787
15788 as1*pow(e0c, 2)*epsn +
15789
15790
15791 e0c*(-(as2*fy) - n0 +
15792
15793
15794 as2*e0cn*(epscmax1 + epsn))))))))/(6.*
15795
15796
15797 e0c*(as1*d*e0c + as2*ch*e0cn)*k*
15798
15799
15800 pow(epsc1, 2)))))/(k*pow(epsc1, 2)*
15801
15802
15803 pow(epscmax1 - (3*d*e0c*k*
15804
15805
15806 pow(epsc1, 2)*(n0 + as1*e0c*(epscmax1 - epsn)) +
15807
15808
15809 3*as2*k*
15810
15811
15812 pow(epsc1,
15813
15814
15815 2)*(2*ch*e0c*e0cn*epscmax1 +
15816
15817
15818 d*(-(e0cn*fy) +
15819
15820
15821 e0c*(fy - e0cn*(epscmax1 + epsn)))) +
15822
15823
15824 sqrt(3.)*
15825
15826
15827 sqrt(k*
15828
15829
15830 pow(epsc1,
15831
15832
15833 2)*(3*k*pow(epsc1, 2)*
15834
15835
15836 pow(d*e0c*(n0 + as1*e0c*(epscmax1 - epsn)) +
15837
15838
15839 as2*(2*ch*e0c*e0cn*epscmax1 +
15840
15841
15842 d*(-(e0cn*fy) +
15843
15844
15845 e0c*(fy - e0cn*(epscmax1 + epsn)))),
15846
15847
15848 2) + 2*
15849
15850
15851 e0c*(as1*d*e0c +
15852
15853
15854 as2*ch*
15855
15856
15857 e0cn)*(-(b*pow(d, 2)*e0c*fc*
15858
15859
15860 pow(epscmax1 + epsn,
15861
15862
15863 2)*((6 - 9*k)*epsc1 +
15864
15865
15866 4*(-1 + k)*epscmax1 +
15867
15868
15869 4*(-1 + k)*epsn)) +
15870
15871
15872 6*k*pow(epsc1, 2)*
15873
15874
15875 epscmax1*(-(as2*ch*e0c*e0cn*
15876
15877
15878 epscmax1) +
15879
15880
15881 d*(as2*e0cn*fy +
15882
15883
15884 as1*pow(e0c, 2)*epsn +
15885
15886
15887 e0c*(-(as2*fy) - n0 +
15888
15889
15890 as2*e0cn*(epscmax1 + epsn))))))))/(6.*
15891
15892
15893 e0c*(as1*d*e0c + as2*ch*e0cn)*k*pow(epsc1, 2)), 2)) +
15894
15895
15896 6*as2*(-2*ch + h)*(fy -
15897
15898
15899 e0cn*(fy/e0c + epscmax1 - (ch*epscmax1)/d +
15900
15901
15902 epsn + (ch*(3*d*e0c*k*
15903
15904
15905 pow(epsc1,
15906
15907
15908 2)*(n0 + as1*e0c*(epscmax1 - epsn)) +
15909
15910
15911 3*as2*k*
15912
15913
15914 pow(epsc1,
15915
15916
15917 2)*(2*ch*e0c*e0cn*epscmax1 +
15918
15919
15920 d*(-(e0cn*fy) +
15921
15922
15923 e0c*(fy - e0cn*(epscmax1 + epsn)))) +
15924
15925
15926 sqrt(3.)*
15927
15928
15929 sqrt(k*
15930
15931
15932 pow(epsc1,
15933
15934
15935 2)*(3*k*pow(epsc1, 2)*
15936
15937
15938 pow(d*
15939
15940
15941 e0c*(n0 + as1*e0c*(epscmax1 - epsn)) +
15942
15943
15944 as2*(2*ch*e0c*e0cn*epscmax1 +
15945
15946
15947 d*(-(e0cn*fy) +
15948
15949
15950 e0c*(fy - e0cn*(epscmax1 + epsn)))),
15951
15952
15953 2) +
15954
15955
15956 2*e0c*(as1*d*e0c +
15957
15958
15959 as2*ch*
15960
15961
15962 e0cn)*(-(b*pow(d, 2)*e0c*fc*
15963
15964
15965 pow(epscmax1 + epsn,
15966
15967
15968 2)*((6 - 9*k)*epsc1 +
15969
15970
15971 4*(-1 + k)*epscmax1 +
15972
15973
15974 4*(-1 + k)*epsn)) +
15975
15976
15977 6*k*pow(epsc1, 2)*
15978
15979
15980 epscmax1*(-(as2*ch*e0c*e0cn*
15981
15982
15983 epscmax1) +
15984
15985
15986 d*(as2*e0cn*fy +
15987
15988
15989 as1*pow(e0c, 2)*epsn +
15990
15991
15992 e0c*(-(as2*fy) - n0 +
15993
15994
15995 as2*e0cn*(epscmax1 +
15996
15997
15998 epsn)))))))))/(6.*d*
15999
16000
16001 e0c*(as1*d*e0c + as2*ch*e0cn)*k*pow(epsc1, 2)))))/12. + e0c*(-(as1*(-cd + h/2.)) + as2*(-ch + h/2.))*epsn;
16002
16003
16004
16005
16006
16007 return mmax3;
16008
16009
16010 }
16011
16012
16013
16014
16015
16016
16017
16018
16019 double normmat::compute_mh6a ()
16020
16021
16022 {
16023
16024
16025 double mh6a;
16026
16027
16028
16029
16030
16031 if ((mmax3-mhr6) > 0.0 && (mhr6-mh3) > 0.0){
16032
16033
16034
16035
16036
16037 mh6a=mhr6;
16038
16039
16040 }
16041
16042
16043 else{
16044
16045
16046 mh6a=mmax3;
16047
16048
16049 }
16050
16051
16052 return mh6a;
16053
16054
16055 }
16056
16057
16058
16059
16060
16061
16062
16063
16064 double normmat::compute_epsch6a ()
16065
16066
16067 {
16068
16069
16070 double epsch6a;
16071
16072
16073
16074
16075
16076 if ((mmax3-mhr6) > 0.0 && (mhr6-mh3) > 0.0){
16077
16078
16079
16080
16081
16082 epsch6a=epschr6;
16083
16084
16085 }
16086
16087
16088 else{
16089
16090
16091 epsch6a=epscmax1;
16092
16093
16094 }
16095
16096
16097 return epsch6a;
16098
16099
16100 }
16101
16102
16103
16104
16105
16106
16107
16108
16109 double normmat::compute_mh7 ()
16110
16111
16112 {
16113
16114
16115 double mh7;
16116
16117
16118
16119
16120
16121 if (mh2-mhr2 == 0.0){
16122
16123
16124
16125
16126
16127 mh7=mh5;
16128
16129
16130 }
16131
16132
16133 else{
16134
16135
16136 mh7=mh6;
16137
16138
16139 }
16140
16141
16142 return mh7;
16143
16144
16145 }
16146
16147
16148
16149
16150
16151
16152
16153
16154 double normmat::compute_epsch7 ()
16155
16156
16157 {
16158
16159
16160 double epsch7;
16161
16162
16163
16164
16165
16166 if (mh2-mhr2 == 0.0){
16167
16168
16169
16170
16171
16172 epsch7=epsch5;
16173
16174
16175 }
16176
16177
16178 else{
16179
16180
16181 epsch7=epsch6;
16182
16183
16184 }
16185
16186
16187 return epsch7;
16188
16189
16190 }
16191
16192
16193
16194
16195
16196
16197
16198
16199 double normmat::compute_epsch12 ()
16200
16201
16202 {
16203
16204
16205 double epsch12;
16206
16207
16208
16209
16210
16211 epsch12 =epsch1 + (-epsch1 + epsch2)/2.;
16212
16213
16214
16215
16216
16217 return epsch12;
16218
16219
16220 }
16221
16222
16223
16224
16225
16226
16227
16228
16229 double normmat::compute_epss1h1 ()
16230
16231
16232 {
16233
16234
16235 double epss1h1;
16236
16237
16238
16239
16240
16241 epss1h1 =(6*as2*ch*e0c*k*pow(epsc1, 2)*epsch1 +
16242
16243
16244 3*d*k*pow(epsc1,
16245
16246
16247 2)*(n0 + as1*e0c*(epsch1 - epsn) - as2*e0c*(epsch1 + epsn)) +
16248
16249
16250 sqrt(3.)*sqrt(k*
16251
16252
16253 pow(epsc1,
16254
16255
16256 2)*(3*k*pow(epsc1, 2)*
16257
16258
16259 pow(-2*as2*ch*e0c*epsch1 +
16260
16261
16262 d*(-n0 - as1*e0c*epsch1 +
16263
16264
16265 as2*e0c*epsch1 + (as1 + as2)*e0c*epsn), 2) -
16266
16267
16268 2*(as2*ch + as1*d)*
16269
16270
16271 e0c*(b*pow(d, 2)*fc*
16272
16273
16274 pow(epsch1 + epsn,
16275
16276
16277 2)*((6 - 9*k)*epsc1 + 4*(-1 + k)*epsch1 +
16278
16279
16280 4*(-1 + k)*epsn) +
16281
16282
16283 6*k*pow(epsc1, 2)*
16284
16285
16286 epsch1*(as2*ch*e0c*epsch1 +
16287
16288
16289 d*(n0 -
16290
16291
16292 e0c*(as2*epsch1 + (as1 + as2)*
16293
16294
16295 epsn)))))))/(6.*(as2*ch + as1*d)*e0c*
16296
16297
16298 k*pow(epsc1, 2));
16299
16300
16301
16302
16303
16304 return epss1h1;
16305
16306
16307 }
16308
16309
16310
16311
16312
16313
16314
16315
16316 double normmat::compute_epss1h2 ()
16317
16318
16319 {
16320
16321
16322 double epss1h2;
16323
16324
16325
16326
16327
16328 epss1h2 =(6*as2*ch*e0c*k*pow(epsc1, 2)*epsch2 +
16329
16330
16331 3*d*k*pow(epsc1,
16332
16333
16334 2)*(n0 + as1*e0c*(epsch2 - epsn) - as2*e0c*(epsch2 + epsn)) +
16335
16336
16337 sqrt(3.)*sqrt(k*
16338
16339
16340 pow(epsc1,
16341
16342
16343 2)*(3*k*pow(epsc1, 2)*
16344
16345
16346 pow(-2*as2*ch*e0c*epsch2 +
16347
16348
16349 d*(-n0 - as1*e0c*epsch2 +
16350
16351
16352 as2*e0c*epsch2 + (as1 + as2)*e0c*epsn), 2) -
16353
16354
16355 2*(as2*ch + as1*d)*
16356
16357
16358 e0c*(b*pow(d, 2)*fc*
16359
16360
16361 pow(epsch2 + epsn,
16362
16363
16364 2)*((6 - 9*k)*epsc1 + 4*(-1 + k)*epsch2 +
16365
16366
16367 4*(-1 + k)*epsn) +
16368
16369
16370 6*k*pow(epsc1, 2)*
16371
16372
16373 epsch2*(as2*ch*e0c*epsch2 +
16374
16375
16376 d*(n0 -
16377
16378
16379 e0c*(as2*epsch2 + (as1 + as2)*
16380
16381
16382 epsn)))))))/(6.*(as2*ch + as1*d)*e0c*
16383
16384
16385 k*pow(epsc1, 2));
16386
16387
16388
16389
16390
16391 return epss1h2;
16392
16393
16394 }
16395
16396
16397
16398
16399
16400
16401
16402
16403 double normmat::compute_mh01 ()
16404
16405
16406 {
16407
16408
16409 double mh01;
16410
16411
16412
16413
16414
16415 if ((pow(d, 2)*(12*pow(as2*ch + as1*d, 2)*pow(e0c, 2)*pow(k, 2)*pow(epsc1, 4) -
16416
16417
16418 pow(b, 2)*pow(fc, 2)*
16419
16420
16421 pow(h, 4)*((6 - 9*k)*epsc1 + 2*(-1 + k)*epsch1 +
16422
16423
16424 4*(-1 + k)*epsn)*((-2 + 3*k)*epsc1 + 2*(-1 + k)*epsch1 +
16425
16426
16427 4*(-1 + k)*epsn) +
16428
16429
16430 4*b*fc*pow(h, 2)*k*
16431
16432
16433 pow(epsc1,
16434
16435
16436 2)*(3*(as2*ch + as1*d)*
16437
16438
16439 e0c*((-2 + 3*k)*epsc1 - 2*(-1 + k)*epsch1 - 4*(-1 + k)*epsn) +
16440
16441
16442 8*h*(-1 + k)*(-n0 + (as1 + as2)*e0c*(epsch1/2. + epsn))))) >= 0.0){
16443
16444
16445
16446
16447
16448 mh01=1/(384.*b*pow(d, 2)*fc*pow(h, 2)*(-1 + k)*k*
16449
16450
16451 pow(epsc1, 2))*((-6*b*d*fc*pow(h, 2)*epsc1 +
16452
16453
16454 9*b*d*fc*pow(h, 2)*k*epsc1 + 6*as2*ch*d*e0c*k*pow(epsc1, 2) +
16455
16456
16457 6*as1*pow(d, 2)*e0c*k*pow(epsc1, 2) + 6*b*d*fc*pow(h, 2)*epsch1 -
16458
16459
16460 6*b*d*fc*pow(h, 2)*k*epsch1 + 12*b*d*fc*pow(h, 2)*epsn -
16461
16462
16463 12*b*d*fc*pow(h, 2)*k*epsn -
16464
16465
16466 sqrt(3.)*sqrt(pow(d,
16467
16468
16469 2)*(12*pow(as2*ch + as1*d, 2)*pow(e0c, 2)*pow(k, 2)*
16470
16471
16472 pow(epsc1, 4) -
16473
16474
16475 pow(b, 2)*pow(fc, 2)*
16476
16477
16478 pow(h,
16479
16480
16481 4)*((6 - 9*k)*epsc1 + 2*(-1 + k)*epsch1 +
16482
16483
16484 4*(-1 + k)*epsn)*((-2 + 3*k)*epsc1 +
16485
16486
16487 2*(-1 + k)*epsch1 + 4*(-1 + k)*epsn) +
16488
16489
16490 4*b*fc*pow(h, 2)*k*
16491
16492
16493 pow(epsc1,
16494
16495
16496 2)*(3*(as2*ch + as1*d)*
16497
16498
16499 e0c*((-2 + 3*k)*epsc1 - 2*(-1 + k)*epsch1 -
16500
16501
16502 4*(-1 + k)*epsn) +
16503
16504
16505 8*h*(-1 +
16506
16507
16508 k)*(-n0 + (as1 + as2)*
16509
16510
16511 e0c*(epsch1/2. + epsn))))))*(-2*b*d*fc*
16512
16513
16514 pow(h, 2)*epsc1 + 3*b*d*fc*pow(h, 2)*k*epsc1 -
16515
16516
16517 6*as2*ch*d*e0c*k*pow(epsc1, 2) -
16518
16519
16520 6*as1*pow(d, 2)*e0c*k*pow(epsc1, 2) + 2*b*d*fc*pow(h, 2)*epsch1 -
16521
16522
16523 2*b*d*fc*pow(h, 2)*k*epsch1 + 4*b*d*fc*pow(h, 2)*epsn -
16524
16525
16526 4*b*d*fc*pow(h, 2)*k*epsn +
16527
16528
16529 sqrt(3.)*sqrt(pow(d,
16530
16531
16532 2)*(12*pow(as2*ch + as1*d, 2)*pow(e0c, 2)*pow(k, 2)*
16533
16534
16535 pow(epsc1, 4) -
16536
16537
16538 pow(b, 2)*pow(fc, 2)*
16539
16540
16541 pow(h,
16542
16543
16544 4)*((6 - 9*k)*epsc1 + 2*(-1 + k)*epsch1 +
16545
16546
16547 4*(-1 + k)*epsn)*((-2 + 3*k)*epsc1 +
16548
16549
16550 2*(-1 + k)*epsch1 + 4*(-1 + k)*epsn) +
16551
16552
16553 4*b*fc*pow(h, 2)*k*
16554
16555
16556 pow(epsc1,
16557
16558
16559 2)*(3*(as2*ch + as1*d)*
16560
16561
16562 e0c*((-2 + 3*k)*epsc1 - 2*(-1 + k)*epsch1 -
16563
16564
16565 4*(-1 + k)*epsn) +
16566
16567
16568 8*h*(-1 +
16569
16570
16571 k)*(-n0 + (as1 + as2)*
16572
16573
16574 e0c*(epsch1/2. + epsn))))))) +
16575
16576
16577 0.5*as1*e0c*(-2*cd + h)*(epsn +
16578
16579
16580 1/(8.*b*fc*pow(h, 3)*(-1 + k))*(6*d*(as2*ch + as1*d)*e0c*k*
16581
16582
16583 pow(epsc1, 2) +
16584
16585
16586 b*fc*pow(h,
16587
16588
16589 2)*(4*h*(-1 + k)*epsch1 -
16590
16591
16592 3*d*((2 - 3*k)*epsc1 + 2*(-1 + k)*epsch1 +
16593
16594
16595 4*(-1 + k)*epsn)) -
16596
16597
16598 sqrt(3.)*sqrt(pow(d,
16599
16600
16601 2)*(12*pow(as2*ch + as1*d, 2)*pow(e0c, 2)*pow(k, 2)*
16602
16603
16604 pow(epsc1, 4) -
16605
16606
16607 pow(b, 2)*pow(fc, 2)*
16608
16609
16610 pow(h,
16611
16612
16613 4)*((6 - 9*k)*epsc1 + 2*(-1 + k)*epsch1 +
16614
16615
16616 4*(-1 + k)*epsn)*((-2 + 3*k)*epsc1 +
16617
16618
16619 2*(-1 + k)*epsch1 + 4*(-1 + k)*epsn) +
16620
16621
16622 4*b*fc*pow(h, 2)*k*
16623
16624
16625 pow(epsc1,
16626
16627
16628 2)*(3*(as2*ch + as1*d)*
16629
16630
16631 e0c*((-2 + 3*k)*epsc1 - 2*(-1 + k)*epsch1 -
16632
16633
16634 4*(-1 + k)*epsn) +
16635
16636
16637 8*h*(-1 +
16638
16639
16640 k)*(-n0 + (as1 + as2)*
16641
16642
16643 e0c*(epsch1/2. + epsn))))))) -
16644
16645
16646 0.5*as2*e0c*(-2*ch + h)*(epsch1/2. - (ch*epsch1)/(2.*d) + epsn +
16647
16648
16649 1/(8.*b*d*fc*
16650
16651
16652 pow(h, 3)*(-1 + k))*(ch*(6*d*(as2*ch + as1*d)*e0c*k*
16653
16654
16655 pow(epsc1, 2) +
16656
16657
16658 b*fc*pow(h,
16659
16660
16661 2)*(4*h*(-1 + k)*epsch1 -
16662
16663
16664 3*d*((2 - 3*k)*epsc1 + 2*(-1 + k)*epsch1 +
16665
16666
16667 4*(-1 + k)*epsn)) -
16668
16669
16670 sqrt(3.)*
16671
16672
16673 sqrt(pow(d,
16674
16675
16676 2)*(12*pow(as2*ch + as1*d, 2)*pow(e0c, 2)*pow(k, 2)*
16677
16678
16679 pow(epsc1, 4) -
16680
16681
16682 pow(b, 2)*pow(fc, 2)*
16683
16684
16685 pow(h,
16686
16687
16688 4)*((6 - 9*k)*epsc1 + 2*(-1 + k)*epsch1 +
16689
16690
16691 4*(-1 + k)*epsn)*((-2 + 3*k)*epsc1 +
16692
16693
16694 2*(-1 + k)*epsch1 + 4*(-1 + k)*epsn) +
16695
16696
16697 4*b*fc*pow(h, 2)*k*
16698
16699
16700 pow(epsc1,
16701
16702
16703 2)*(3*(as2*ch + as1*d)*
16704
16705
16706 e0c*((-2 + 3*k)*epsc1 -
16707
16708
16709 2*(-1 + k)*epsch1 -
16710
16711
16712 4*(-1 + k)*epsn) +
16713
16714
16715 8*h*(-1 +
16716
16717
16718 k)*(-n0 + (as1 + as2)*
16719
16720
16721 e0c*(epsch1/2. + epsn)))))))) + e0c*(-(as1*(-cd + h/2.)) + as2*(-ch + h/2.))*epsn;
16722
16723
16724
16725
16726
16727 }
16728
16729
16730 else{
16731
16732
16733 mh01=1000000000.0;
16734
16735
16736 }
16737
16738
16739 return mh01;
16740
16741
16742 }
16743
16744
16745
16746
16747
16748
16749
16750
16751 double normmat::compute_mh12 ()
16752
16753
16754 {
16755
16756
16757 double mh12;
16758
16759
16760
16761
16762
16763 if ((k*pow(epsc1,
16764
16765
16766 2)*((3*k*pow(epsc1, 2)*
16767
16768
16769 pow(2*as2*ch*e0c*(epsch2 + epschr1) +
16770
16771
16772 d*(2*n0 +
16773
16774
16775 e0c*(as1*(epsch2 + epschr1 - 2*epsn) -
16776
16777
16778 as2*(epsch2 + epschr1 + 2*epsn))), 2))/
16779
16780
16781 4. - ((as2*ch + as1*d)*
16782
16783
16784 e0c*(b*pow(d, 2)*fc*
16785
16786
16787 pow(epsch2 + epschr1 + 2*epsn,
16788
16789
16790 2)*((6 - 9*k)*epsc1 +
16791
16792
16793 2*(-1 + k)*(epsch2 + epschr1 + 2*epsn)) -
16794
16795
16796 6*k*pow(epsc1,
16797
16798
16799 2)*(epsch2 +
16800
16801
16802 epschr1)*(-(as2*ch*e0c*(epsch2 + epschr1)) +
16803
16804
16805 d*(-2*n0 +
16806
16807
16808 e0c*(2*as1*epsn +
16809
16810
16811 as2*(epsch2 + epschr1 + 2*epsn))))))/2.)) >= 0.0){
16812
16813
16814
16815
16816
16817 mh12=1.0/(24.0*(as2*ch + as1*d)*k*pow(epsc1,2))*(0.0-(6*b*d*pow(as2*ch + as1*d,3)*pow(e0c, 2)*fc*pow(k, 2)*
16818
16819
16820 pow(epsc1, 4)*pow(epschr1 + epsch2 + 2*epsn,2)*(6*d*(epschr1 + epsch2 +
16821
16822
16823 2*epsn)*((4 - 6*k)*
16824
16825
16826 epsc1 + (-1 + k)*(epschr1 + epsch2 + 2*epsn)) +
16827
16828
16829 1/((as2*ch + as1*d)*e0c*k*
16830
16831
16832 pow(epsc1, 2))*(h*(3*(-2 + 3*k)*epsc1 -
16833
16834
16835 2*(-1 + k)*(epschr1 + epsch2 + 2*epsn))*(3*d*k*
16836
16837
16838 pow(epsc1,
16839
16840
16841 2)*(-2*n0 + (as1 + as2)*
16842
16843
16844 e0c*(epschr1 + epsch2 + 2*epsn)) -
16845
16846
16847 2*sqrt(3.)*
16848
16849
16850 sqrt(k*
16851
16852
16853 pow(epsc1,
16854
16855
16856 2)*(0.75*k*pow(epsc1, 2)*
16857
16858
16859 pow(2*as2*ch*e0c*(epschr1 + epsch2) +
16860
16861
16862 d*(2*n0 + e0c*(as1*(epschr1 +
16863
16864
16865 epsch2 - 2*epsn) -
16866
16867
16868 as2*(epschr1 + epsch2 + 2*epsn))),
16869
16870
16871 2)
16872
16873
16874 -0.5*(as2*ch + as1*d)*
16875
16876
16877 e0c*(b*pow(d, 2)*fc*
16878
16879
16880 pow(epschr1 + epsch2 + 2*epsn,
16881
16882
16883 2)*((6 - 9*k)*epsc1 +
16884
16885
16886 2*(-1 + k)*(epschr1 + epsch2 +
16887
16888
16889 2*epsn)) -
16890
16891
16892 6*k*pow(epsc1,
16893
16894
16895 2)*(epschr1 +
16896
16897
16898 epsch2)*(-as2*ch*
16899
16900
16901 e0c*(epschr1 + epsch2) +
16902
16903
16904 d*(-2*n0 + e0c*(2*as1*epsn +
16905
16906
16907 as2*(epschr1 + epsch2 +
16908
16909
16910 2*epsn)))))))))))/
16911
16912
16913 pow(3*d*k*
16914
16915
16916 pow(epsc1,
16917
16918
16919 2)*(-2*n0 + (as1 + as2)*e0c*(epschr1 + epsch2 + 2*epsn)) -
16920
16921
16922 2*sqrt(3.)*
16923
16924
16925 sqrt(k*pow(epsc1,
16926
16927
16928 2)*(0.75*k*pow(epsc1, 2)*
16929
16930
16931 pow(2*as2*ch*e0c*(epschr1 + epsch2) +
16932
16933
16934 d*(2*n0 +
16935
16936
16937 e0c*(as1*(epschr1 + epsch2 - 2*epsn) -
16938
16939
16940 as2*(epschr1 + epsch2 + 2*epsn))),
16941
16942
16943 2) - 0.5*(as2*ch + as1*d)*
16944
16945
16946 e0c*(b*pow(d, 2)*fc*
16947
16948
16949 pow(epschr1 + epsch2 + 2*epsn,
16950
16951
16952 2)*((6 - 9*k)*epsc1 +
16953
16954
16955 2*(-1 + k)*(epschr1 + epsch2 + 2*epsn)) -
16956
16957
16958 6*k*pow(epsc1,
16959
16960
16961 2)*(epschr1 +
16962
16963
16964 epsch2)*(-as2*ch*e0c*(epschr1 + epsch2) +
16965
16966
16967 d*(-2*n0 +
16968
16969
16970 e0c*(2*as1*epsn +
16971
16972
16973 as2*(epschr1 + epsch2 + 2*epsn))))))),
16974
16975
16976 2) - as1*(2*cd -
16977
16978
16979 h)*(3*d*k*
16980
16981
16982 pow(epsc1,
16983
16984
16985 2)*(2*n0 + (as1 - as2)*e0c*(epschr1 + epsch2 + 2*epsn)) +
16986
16987
16988 2*(3*as2*ch*e0c*k*pow(epsc1, 2)*(epschr1 + epsch2 + 2*epsn) +
16989
16990
16991 sqrt(3.)*
16992
16993
16994 sqrt(k*pow(epsc1,
16995
16996
16997 2)*(0.75*k*pow(epsc1, 2)*
16998
16999
17000 pow(2*as2*ch*e0c*(epschr1 + epsch2) +
17001
17002
17003 d*(2*n0 +
17004
17005
17006 e0c*(as1*(epschr1 + epsch2 - 2*epsn) -
17007
17008
17009 as2*(epschr1 + epsch2 + 2*epsn))),
17010
17011
17012 2) - 0.5*(as2*ch + as1*d)*
17013
17014
17015 e0c*(b*pow(d, 2)*fc*
17016
17017
17018 pow(epschr1 + epsch2 + 2*epsn,
17019
17020
17021 2)*((6 - 9*k)*epsc1 +
17022
17023
17024 2*(-1 + k)*(epschr1 + epsch2 +
17025
17026
17027 2*epsn)) -
17028
17029
17030 6*k*
17031
17032
17033 pow(epsc1,
17034
17035
17036 2)*(epschr1 +
17037
17038
17039 epsch2)*(-as2*ch*
17040
17041
17042 e0c*(epschr1 + epsch2) +
17043
17044
17045 d*(-2*n0 +
17046
17047
17048 e0c*(2*as1*epsn +
17049
17050
17051 as2*(epschr1 + epsch2 +
17052
17053
17054 2*epsn))))))))) +
17055
17056
17057 1/d*(as2*(2*ch -
17058
17059
17060 h)*(6*as1*pow(d, 2)*e0c*k*
17061
17062
17063 pow(epsc1, 2)*(epschr1 + epsch2 + 2*epsn) +
17064
17065
17066 ch*(3*d*k*
17067
17068
17069 pow(epsc1,
17070
17071
17072 2)*(2*n0 - (as1 - as2)*
17073
17074
17075 e0c*(epschr1 + epsch2 + 2*epsn)) +
17076
17077
17078 2*sqrt(3.)*
17079
17080
17081 sqrt(k*
17082
17083
17084 pow(epsc1,
17085
17086
17087 2)*(0.75*k*pow(epsc1, 2)*
17088
17089
17090 pow(2*as2*ch*e0c*(epschr1 + epsch2) +
17091
17092
17093 d*(2*n0 +
17094
17095
17096 e0c*(as1*(epschr1 + epsch2 - 2*epsn) -
17097
17098
17099 as2*(epschr1 + epsch2 + 2*epsn))),
17100
17101
17102 2) - 0.5*(as2*ch + as1*d)*
17103
17104
17105 e0c*(b*pow(d, 2)*fc*
17106
17107
17108 pow(epschr1 + epsch2 + 2*epsn,
17109
17110
17111 2)*((6 - 9*k)*epsc1 +
17112
17113
17114 2*(-1 + k)*(epschr1 + epsch2 +
17115
17116
17117 2*epsn)) -
17118
17119
17120 6*k*pow(epsc1,
17121
17122
17123 2)*(epschr1 +
17124
17125
17126 epsch2)*(-as2*ch*
17127
17128
17129 e0c*(epschr1 + epsch2) +
17130
17131
17132 d*(-2*n0 +
17133
17134
17135 e0c*(2*as1*epsn +
17136
17137
17138 as2*(epschr1 + epsch2 +
17139
17140
17141 2*epsn))))))))))) + e0c*(-(as1*(-cd + h/2.)) + as2*(-ch + h/2.))*epsn;
17142
17143
17144
17145
17146
17147 }
17148
17149
17150 else{
17151
17152
17153 mh12=1000000000.0;
17154
17155
17156 }
17157
17158
17159
17160
17161
17162 return mh12;
17163
17164
17165 }
17166
17167
17168
17169
17170
17171
17172
17173
17174 double normmat::compute_mh25 ()
17175
17176
17177 {
17178
17179
17180 double mh25;
17181
17182
17183
17184
17185
17186 if ((k*pow(epsc1,
17187
17188
17189 2)*(3*k*pow(epsc1, 2)*
17190
17191
17192 pow(as2*ch*pow(e0c, 2)*(epsch2 + epsch5) -
17193
17194
17195 d*(-(as1*e0cn*
17196
17197
17198 fy) + (e0c*(-2*n0 +
17199
17200
17201 as1*(2*fy - e0cn*(epsch2 + epsch5 - 2*epsn)) +
17202
17203
17204 as2*e0c*(epsch2 + epsch5 + 2*epsn)))/2.), 2) -
17205
17206
17207 2*e0c*(as2*ch*e0c +
17208
17209
17210 as1*d*e0cn)*((b*pow(d, 2)*e0c*fc*
17211
17212
17213 pow(epsch2 + epsch5 + 2*epsn,
17214
17215
17216 2)*((6 - 9*k)*epsc1 +
17217
17218
17219 2*(-1 + k)*(epsch2 + epsch5 + 2*epsn)))/4. +
17220
17221
17222 3*k*pow(epsc1,
17223
17224
17225 2)*(epsch2 +
17226
17227
17228 epsch5)*(as1*
17229
17230
17231 d*(e0cn*fy -
17232
17233
17234 e0c*(fy + e0cn*epsn)) + (e0c*(as2*ch*
17235
17236
17237 e0c*(epsch2 + epsch5) +
17238
17239
17240 d*(2*n0 - as2*e0c*(epsch2 + epsch5 + 2*epsn))))/
17241
17242
17243 2.)))) >= 0.0){
17244
17245
17246
17247
17248
17249 mh25=(-((6*b*d*pow(e0c, 2)*pow(as2*ch*e0c + as1*d*e0cn, 3)*fc*pow(k, 2)*
17250
17251
17252 pow(epsc1, 4)*
17253
17254
17255 pow(epsch2 + epsch5 + 2*epsn,
17256
17257
17258 2)*(6*d*(epsch2 + epsch5 +
17259
17260
17261 2*epsn)*((4 - 6*k)*
17262
17263
17264 epsc1 + (-1 + k)*(epsch2 + epsch5 +
17265
17266
17267 2*epsn)) + (h*(3*(-2 + 3*k)*epsc1 -
17268
17269
17270 2*(-1 + k)*(epsch2 + epsch5 + 2*epsn))*(3*d*
17271
17272
17273 e0c*k*
17274
17275
17276 pow(epsc1,
17277
17278
17279 2)*(-2*n0 +
17280
17281
17282 as2*e0c*(epsch2 + epsch5 + 2*epsn)) +
17283
17284
17285 3*as1*d*k*
17286
17287
17288 pow(epsc1,
17289
17290
17291 2)*(-2*e0cn*fy +
17292
17293
17294 e0c*(2*fy +
17295
17296
17297 e0cn*(epsch2 + epsch5 + 2*epsn))) -
17298
17299
17300 2*sqrt(3.)*
17301
17302
17303 sqrt(k*
17304
17305
17306 pow(epsc1,
17307
17308
17309 2)*(3*k*pow(epsc1, 2)*
17310
17311
17312 pow(as2*ch*
17313
17314
17315 pow(e0c, 2)*(epsch2 + epsch5) -
17316
17317
17318 d*(-as1*e0cn*fy +
17319
17320
17321 0.5*e0c*(-2*n0 + as1*(2*fy -
17322
17323
17324 e0cn*(epsch2 + epsch5 - 2*epsn)) +
17325
17326
17327 as2*e0c*(epsch2 + epsch5 + 2*epsn))),
17328
17329
17330 2) -
17331
17332
17333 2*e0c*(as2*ch*e0c +
17334
17335
17336 as1*d*e0cn)*(0.25*b*pow(d, 2)*e0c*fc*
17337
17338
17339 pow(epsch2 + epsch5 + 2*epsn,
17340
17341
17342 2)*((6 - 9*k)*epsc1 +
17343
17344
17345 2*(-1 + k)*(epsch2 + epsch5 +
17346
17347
17348 2*epsn)) +
17349
17350
17351 3*k*pow(epsc1,
17352
17353
17354 2)*(epsch2 + epsch5)*(as1*
17355
17356
17357 d*(e0cn*fy - e0c*(fy + e0cn*epsn)) +
17358
17359
17360 0.5*e0c*(as2*ch*e0c*(epsch2 +
17361
17362
17363 epsch5) + d*(2*n0 - as2*e0c*(epsch2 +
17364
17365
17366 epsch5 + 2*epsn)))))))))/(e0c*(as2*ch*
17367
17368
17369 e0c + as1*d*e0cn)*k*pow(epsc1, 2))))/
17370
17371
17372 pow(3*d*e0c*k*
17373
17374
17375 pow(epsc1,
17376
17377
17378 2)*(-2*n0 + as2*e0c*(epsch2 + epsch5 + 2*epsn)) +
17379
17380
17381 3*as1*d*k*
17382
17383
17384 pow(epsc1,
17385
17386
17387 2)*(-2*e0cn*fy +
17388
17389
17390 e0c*(2*fy + e0cn*(epsch2 + epsch5 + 2*epsn))) -
17391
17392
17393 2*sqrt(3.)*
17394
17395
17396 sqrt(k*pow(epsc1,
17397
17398
17399 2)*(3*k*pow(epsc1, 2)*
17400
17401
17402 pow(as2*ch*pow(e0c, 2)*(epsch2 + epsch5) -
17403
17404
17405 d*(-as1*e0cn*fy +
17406
17407
17408 0.5*e0c*(-2*n0 +
17409
17410
17411 as1*(2*fy -
17412
17413
17414 e0cn*(epsch2 + epsch5 - 2*epsn)) +
17415
17416
17417 as2*e0c*(epsch2 + epsch5 + 2*epsn))),
17418
17419
17420 2) - 2*
17421
17422
17423 e0c*(as2*ch*e0c +
17424
17425
17426 as1*d*e0cn)*(0.25*b*pow(d, 2)*e0c*fc*
17427
17428
17429 pow(epsch2 + epsch5 + 2*epsn,
17430
17431
17432 2)*((6 - 9*k)*epsc1 +
17433
17434
17435 2*(-1 + k)*(epsch2 + epsch5 +
17436
17437
17438 2*epsn)) +
17439
17440
17441 3*k*pow(epsc1,
17442
17443
17444 2)*(epsch2 +
17445
17446
17447 epsch5)*(as1*
17448
17449
17450 d*(e0cn*fy - e0c*(fy + e0cn*epsn)) +
17451
17452
17453 0.5*e0c*(as2*ch*e0c*(epsch2 + epsch5) +
17454
17455
17456 d*(2*n0 -
17457
17458
17459 as2*e0c*(epsch2 + epsch5 +
17460
17461
17462 2*epsn))))))), 2)) +
17463
17464
17465 1/d*(as2*(2*ch -
17466
17467
17468 h)*(-3*as1*d*k*
17469
17470
17471 pow(epsc1,
17472
17473
17474 2)*(-2*d*e0c*e0cn*(epsch2 + epsch5 + 2*epsn) +
17475
17476
17477 ch*(-2*e0cn*fy +
17478
17479
17480 e0c*(2*fy + e0cn*(epsch2 + epsch5 + 2*epsn)))) +
17481
17482
17483 ch*(3*d*e0c*k*
17484
17485
17486 pow(epsc1,
17487
17488
17489 2)*(2*n0 + as2*e0c*(epsch2 + epsch5 + 2*epsn)) +
17490
17491
17492 2*sqrt(3.)*
17493
17494
17495 sqrt(k*
17496
17497
17498 pow(epsc1,
17499
17500
17501 2)*(3*k*pow(epsc1, 2)*
17502
17503
17504 pow(as2*ch*pow(e0c, 2)*(epsch2 + epsch5) -
17505
17506
17507 d*(-as1*e0cn*fy +
17508
17509
17510 0.5*e0c*(-2*n0 +
17511
17512
17513 as1*(2*fy - e0cn*(epsch2 + epsch5 -
17514
17515
17516 2*epsn)) +
17517
17518
17519 as2*e0c*(epsch2 + epsch5 + 2*epsn))),
17520
17521
17522 2)
17523
17524
17525 -2*e0c*(as2*ch*e0c +
17526
17527
17528 as1*d*e0cn)*(0.25*b*pow(d, 2)*e0c*fc*
17529
17530
17531 pow(epsch2 + epsch5 + 2*epsn,
17532
17533
17534 2)*((6 - 9*k)*epsc1 +
17535
17536
17537 2*(-1 + k)*(epsch2 + epsch5 +
17538
17539
17540 2*epsn)) +
17541
17542
17543 3*k*pow(epsc1,
17544
17545
17546 2)*(epsch2 +
17547
17548
17549 epsch5)*(as1*
17550
17551
17552 d*(e0cn*fy - e0c*(fy + e0cn*epsn)) +
17553
17554
17555 0.5*e0c*(as2*ch*
17556
17557
17558 e0c*(epsch2 + epsch5) +
17559
17560
17561 d*(2*n0 - as2*e0c*(epsch2 + epsch5 +
17562
17563
17564 2*epsn)))))))))) -
17565
17566
17567 1/e0c*(as1*(2*cd -
17568
17569
17570 h)*(3*as2*e0c*k*
17571
17572
17573 pow(epsc1,
17574
17575
17576 2)*(-d*e0c*e0cn*(epsch2 + epsch5 + 2*epsn) +
17577
17578
17579 2*ch*(-2*e0cn*fy +
17580
17581
17582 e0c*(2*fy + e0cn*(epsch2 + epsch5 + 2*epsn)))) +
17583
17584
17585 e0cn*(6*d*e0c*k*n0*pow(epsc1, 2) +
17586
17587
17588 3*as1*d*k*
17589
17590
17591 pow(epsc1,
17592
17593
17594 2)*(-2*e0cn*fy +
17595
17596
17597 e0c*(2*fy + e0cn*(epsch2 + epsch5 + 2*epsn))) +
17598
17599
17600 2*sqrt(3.)*
17601
17602
17603 sqrt(k*
17604
17605
17606 pow(epsc1,
17607
17608
17609 2)*(3*k*pow(epsc1, 2)*
17610
17611
17612 pow(as2*ch*pow(e0c, 2)*(epsch2 + epsch5) -
17613
17614
17615 d*(-as1*e0cn*fy +
17616
17617
17618 0.5*e0c*(-2*n0 +
17619
17620
17621 as1*(2*fy - e0cn*(epsch2 + epsch5 -
17622
17623
17624 2*epsn)) +
17625
17626
17627 as2*e0c*(epsch2 + epsch5 + 2*epsn))),
17628
17629
17630 2)
17631
17632
17633 -2*e0c*(as2*ch*e0c +
17634
17635
17636 as1*d*e0cn)*(0.25*b*pow(d, 2)*e0c*fc*
17637
17638
17639 pow(epsch2 + epsch5 + 2*epsn,
17640
17641
17642 2)*((6 - 9*k)*epsc1 +
17643
17644
17645 2*(-1 + k)*(epsch2 + epsch5 +
17646
17647
17648 2*epsn)) +
17649
17650
17651 3*k*pow(epsc1,
17652
17653
17654 2)*(epsch2 +
17655
17656
17657 epsch5)*(as1*
17658
17659
17660 d*(e0cn*fy - e0c*(fy + e0cn*epsn)) +
17661
17662
17663 0.5*e0c*(as2*ch*
17664
17665
17666 e0c*(epsch2 + epsch5) +
17667
17668
17669 d*(2*n0 - as2*e0c*(epsch2 + epsch5 +
17670
17671
17672 2*epsn)))))))))))/(24.*(as2*ch*e0c +
17673
17674
17675 as1*d*e0cn)*k*pow(epsc1, 2)) + e0c*(-(as1*(-cd + h/2.)) + as2*(-ch + h/2.))*epsn;
17676
17677
17678
17679
17680
17681 }
17682
17683
17684 else{
17685
17686
17687 mh25=1000000000.0;
17688
17689
17690 }
17691
17692
17693 return mh25;
17694
17695
17696 }
17697
17698
17699
17700
17701
17702
17703
17704
17705 double normmat::compute_mh36a ()
17706
17707
17708 {
17709
17710
17711 double mh36a;
17712
17713
17714
17715
17716
17717 if (((k*pow(epsc1,
17718
17719
17720 2)*(3*k*pow(epsc1, 2)*
17721
17722
17723 pow((d*e0c*(2*n0 + as1*e0c*(epsch3 + epsch6a - 2*epsn)))/2. +
17724
17725
17726 as2*(ch*e0c*
17727
17728
17729 e0cn*(epsch3 +
17730
17731
17732 epsch6a) + (d*(-2*e0cn*fy +
17733
17734
17735 e0c*(2*fy - e0cn*(epsch3 + epsch6a + 2*epsn))))/
17736
17737
17738 2.), 2) +
17739
17740
17741 2*e0c*(as1*d*e0c +
17742
17743
17744 as2*ch*e0cn)*(-(b*pow(d, 2)*e0c*fc*
17745
17746
17747 pow(epsch3 + epsch6a + 2*epsn,
17748
17749
17750 2)*((6 - 9*k)*epsc1 +
17751
17752
17753 2*(-1 + k)*(epsch3 + epsch6a + 2*epsn)))/
17754
17755
17756 4. + (3*k*
17757
17758
17759 pow(epsc1,
17760
17761
17762 2)*(epsch3 + epsch6a)*(2*d*e0c*(-n0 + as1*e0c*epsn) +
17763
17764
17765 as2*(-(ch*e0c*e0cn*(epsch3 + epsch6a)) +
17766
17767
17768 d*(2*e0cn*fy +
17769
17770
17771 e0c*(-2*fy +
17772
17773
17774 e0cn*(epsch3 + epsch6a + 2*epsn))))))/
17775
17776
17777 2.))) >= 0.0)){
17778
17779
17780
17781
17782
17783 mh36a=(-as1*(2*cd -
17784
17785
17786 h)*(3*d*e0c*k*
17787
17788
17789 pow(epsc1, 2)*(2*n0 + as1*e0c*(epsch3 + epsch6a + 2*epsn)) +
17790
17791
17792 3*as2*k*pow(epsc1,
17793
17794
17795 2)*(2*ch*e0c*e0cn*(epsch3 + epsch6a + 2*epsn) +
17796
17797
17798 d*(-2*e0cn*fy +
17799
17800
17801 e0c*(2*fy - e0cn*(epsch3 + epsch6a + 2*epsn)))) +
17802
17803
17804 2*sqrt(3.)*
17805
17806
17807 sqrt(k*pow(epsc1,
17808
17809
17810 2)*(3*k*pow(epsc1, 2)*
17811
17812
17813 pow(0.5*d*
17814
17815
17816 e0c*(2*n0 +
17817
17818
17819 as1*e0c*(epsch3 + epsch6a - 2*epsn)) +
17820
17821
17822 as2*(ch*e0c*e0cn*(epsch3 + epsch6a) +
17823
17824
17825 0.5*d*(-2*e0cn*fy +
17826
17827
17828 e0c*(2*fy -
17829
17830
17831 e0cn*(epsch3 + epsch6a + 2*epsn)))),
17832
17833
17834 2) + 2*
17835
17836
17837 e0c*(as1*d*e0c +
17838
17839
17840 as2*ch*e0cn)*(-0.25*b*pow(d, 2)*e0c*fc*
17841
17842
17843 pow(epsch3 + epsch6a + 2*epsn,
17844
17845
17846 2)*((6 - 9*k)*epsc1 +
17847
17848
17849 2*(-1 + k)*(epsch3 + epsch6a + 2*epsn)) +
17850
17851
17852 1.5*k*pow(epsc1,
17853
17854
17855 2)*(epsch3 +
17856
17857
17858 epsch6a)*(2*d*e0c*(-n0 + as1*e0c*epsn) +
17859
17860
17861 as2*(-ch*e0c*e0cn*(epsch3 + epsch6a) +
17862
17863
17864 d*(2*e0cn*fy +
17865
17866
17867 e0c*(-2*fy +
17868
17869
17870 e0cn*(epsch3 + epsch6a +
17871
17872
17873 2*epsn))))))))) - (6*b*d*pow(e0c, 2)*
17874
17875
17876 pow(as1*d*e0c + as2*ch*e0cn, 3)*fc*pow(k, 2)*pow(epsc1, 4)*
17877
17878
17879 pow(epsch3 + epsch6a + 2*epsn,
17880
17881
17882 2)*(6*d*(epsch3 + epsch6a +
17883
17884
17885 2*epsn)*((4 - 6*k)*
17886
17887
17888 epsc1 + (-1 + k)*(epsch3 + epsch6a +
17889
17890
17891 2*epsn)) + (h*(3*(-2 + 3*k)*epsc1 -
17892
17893
17894 2*(-1 + k)*(epsch3 + epsch6a + 2*epsn))*(3*d*e0c*
17895
17896
17897 k*pow(epsc1,
17898
17899
17900 2)*(-2*n0 +
17901
17902
17903 as1*e0c*(epsch3 + epsch6a + 2*epsn)) +
17904
17905
17906 3*as2*d*k*
17907
17908
17909 pow(epsc1,
17910
17911
17912 2)*(2*e0cn*fy +
17913
17914
17915 e0c*(-2*fy +
17916
17917
17918 e0cn*(epsch3 + epsch6a + 2*epsn))) -
17919
17920
17921 2*sqrt(3.)*
17922
17923
17924 sqrt(k*
17925
17926
17927 pow(epsc1,
17928
17929
17930 2)*(3*k*pow(epsc1, 2)*
17931
17932
17933 pow(0.5*d*
17934
17935
17936 e0c*(2*n0 +
17937
17938
17939 as1*e0c*(epsch3 + epsch6a - 2*epsn)) +
17940
17941
17942 as2*(ch*e0c*
17943
17944
17945 e0cn*(epsch3 + epsch6a) +
17946
17947
17948 0.5*d*(-2*e0cn*fy +
17949
17950
17951 e0c*(2*fy - e0cn*(epsch3 + epsch6a +
17952
17953
17954 2*epsn)))), 2) +
17955
17956
17957 2*e0c*(as1*d*e0c +
17958
17959
17960 as2*ch*e0cn)*(-0.25*b*pow(d, 2)*e0c*
17961
17962
17963 fc*pow(epsch3 + epsch6a + 2*epsn,
17964
17965
17966 2)*((6 - 9*k)*epsc1 +
17967
17968
17969 2*(-1 + k)*(epsch3 + epsch6a +
17970
17971
17972 2*epsn)) +
17973
17974
17975 1.5*k*
17976
17977
17978 pow(epsc1,
17979
17980
17981 2)*(epsch3 +
17982
17983
17984 epsch6a)*(2*d*
17985
17986
17987 e0c*(-n0 + as1*e0c*epsn) +
17988
17989
17990 as2*(-ch*e0c*e0cn*(epsch3 + epsch6a) +
17991
17992
17993 d*(2*e0cn*fy + e0c*(-2*fy +
17994
17995
17996 e0cn*(epsch3 + epsch6a +
17997
17998
17999 2*epsn))))))))))/(e0c*(as1*d*e0c +
18000
18001
18002 as2*ch*e0cn)*k*pow(epsc1, 2))))/
18003
18004
18005 pow(3*d*e0c*k*
18006
18007
18008 pow(epsc1, 2)*(-2*n0 + as1*e0c*(epsch3 + epsch6a + 2*epsn)) +
18009
18010
18011 3*as2*d*k*
18012
18013
18014 pow(epsc1,
18015
18016
18017 2)*(2*e0cn*fy +
18018
18019
18020 e0c*(-2*fy + e0cn*(epsch3 + epsch6a + 2*epsn))) -
18021
18022
18023 2*sqrt(3.)*
18024
18025
18026 sqrt(k*pow(epsc1,
18027
18028
18029 2)*(3*k*pow(epsc1, 2)*
18030
18031
18032 pow(0.5*d*
18033
18034
18035 e0c*(2*n0 +
18036
18037
18038 as1*e0c*(epsch3 + epsch6a - 2*epsn)) +
18039
18040
18041 as2*(ch*e0c*e0cn*(epsch3 + epsch6a) +
18042
18043
18044 0.5*d*(-2*e0cn*fy +
18045
18046
18047 e0c*(2*fy -
18048
18049
18050 e0cn*(epsch3 + epsch6a + 2*epsn)))),
18051
18052
18053 2) + 2*
18054
18055
18056 e0c*(as1*d*e0c +
18057
18058
18059 as2*ch*e0cn)*(-0.25*b*pow(d, 2)*e0c*fc*
18060
18061
18062 pow(epsch3 + epsch6a + 2*epsn,
18063
18064
18065 2)*((6 - 9*k)*epsc1 +
18066
18067
18068 2*(-1 + k)*(epsch3 + epsch6a + 2*epsn)) +
18069
18070
18071 1.5*k*pow(epsc1,
18072
18073
18074 2)*(epsch3 +
18075
18076
18077 epsch6a)*(2*d*e0c*(-n0 + as1*e0c*epsn) +
18078
18079
18080 as2*(-ch*e0c*e0cn*(epsch3 + epsch6a) +
18081
18082
18083 d*(2*e0cn*fy +
18084
18085
18086 e0c*(-2*fy +
18087
18088
18089 e0cn*(epsch3 + epsch6a +
18090
18091
18092 2*epsn)))))))), 2) +
18093
18094
18095 1/(d*e0c)*(as2*(2*ch -
18096
18097
18098 h)*(-3*as1*d*e0c*k*
18099
18100
18101 pow(epsc1,
18102
18103
18104 2)*(ch*e0c*e0cn*(epsch3 + epsch6a + 2*epsn) -
18105
18106
18107 2*d*(2*e0cn*fy +
18108
18109
18110 e0c*(-2*fy + e0cn*(epsch3 + epsch6a + 2*epsn)))) +
18111
18112
18113 ch*e0cn*(6*d*e0c*k*n0*pow(epsc1, 2) +
18114
18115
18116 3*as2*d*k*
18117
18118
18119 pow(epsc1,
18120
18121
18122 2)*(2*e0cn*fy +
18123
18124
18125 e0c*(-2*fy + e0cn*(epsch3 + epsch6a + 2*epsn))) +
18126
18127
18128 2*sqrt(3.)*
18129
18130
18131 sqrt(k*
18132
18133
18134 pow(epsc1,
18135
18136
18137 2)*(3*k*pow(epsc1, 2)*
18138
18139
18140 pow(0.5*d*
18141
18142
18143 e0c*(2*n0 +
18144
18145
18146 as1*e0c*(epsch3 + epsch6a - 2*epsn)) +
18147
18148
18149 as2*(ch*e0c*e0cn*(epsch3 + epsch6a) +
18150
18151
18152 0.5*d*(-2*e0cn*fy +
18153
18154
18155 e0c*(2*fy - e0cn*(epsch3 + epsch6a +
18156
18157
18158 2*epsn)))), 2) +
18159
18160
18161 2*e0c*(as1*d*e0c +
18162
18163
18164 as2*ch*e0cn)*(-0.25*b*pow(d, 2)*e0c*fc*
18165
18166
18167 pow(epsch3 + epsch6a + 2*epsn,
18168
18169
18170 2)*((6 - 9*k)*epsc1 +
18171
18172
18173 2*(-1 + k)*(epsch3 + epsch6a +
18174
18175
18176 2*epsn)) +
18177
18178
18179 1.5*k*
18180
18181
18182 pow(epsc1,
18183
18184
18185 2)*(epsch3 +
18186
18187
18188 epsch6a)*(2*d*
18189
18190
18191 e0c*(-n0 + as1*e0c*epsn) +
18192
18193
18194 as2*(-ch*e0c*e0cn*(epsch3 + epsch6a) +
18195
18196
18197 d*(2*e0cn*fy +
18198
18199
18200 e0c*(-2*fy + e0cn*(epsch3 + epsch6a +
18201
18202
18203 2*epsn))))))))))))/(24.*(as1*d*e0c +
18204
18205
18206 as2*ch*e0cn)*k*pow(epsc1, 2)) + e0c*(-(as1*(-cd + h/2.)) + as2*(-ch + h/2.))*epsn;
18207
18208
18209
18210
18211
18212 }
18213
18214
18215 else{
18216
18217
18218 mh36a=1000000000.0;
18219
18220
18221 }
18222
18223
18224 return mh36a;
18225
18226
18227 }
18228
18229
18230
18231
18232
18233
18234
18235
18236 double normmat::compute_epscder1 ()
18237
18238
18239 {
18240
18241
18242 double epscder1;
18243
18244
18245
18246
18247
18248 epscder1 =(mh3*epsch3 - 4*mh36a*epsch3 + 3*mh6a*epsch3 + 3*mh3*epsch6a -
18249
18250
18251 4*mh36a*epsch6a + mh6a*epsch6a)/(4.*(mh3 - 2*mh36a + mh6a));
18252
18253
18254
18255
18256
18257 return epscder1;
18258
18259
18260 }
18261
18262
18263
18264
18265
18266
18267
18268
18269 double normmat::compute_mmax4 ()
18270
18271
18272 {
18273
18274
18275 double mmax4;
18276
18277
18278
18279
18280
18281 mmax4 =(6*as1*e0c*(-2*cd +
18282
18283
18284 h)*(epsn + (3*d*e0c*k*
18285
18286
18287 pow(epsc1, 2)*(n0 + as1*e0c*(epscder1 - epsn)) +
18288
18289
18290 3*as2*k*
18291
18292
18293 pow(epsc1,
18294
18295
18296 2)*(2*ch*e0c*e0cn*epscder1 +
18297
18298
18299 d*(-(e0cn*fy) + e0c*(fy - e0cn*(epscder1 + epsn)))) +
18300
18301
18302 sqrt(3.)*
18303
18304
18305 sqrt(k*pow(epsc1,
18306
18307
18308 2)*(3*k*pow(epsc1, 2)*
18309
18310
18311 pow(d*e0c*(n0 + as1*e0c*(epscder1 - epsn)) +
18312
18313
18314 as2*(2*ch*e0c*e0cn*epscder1 +
18315
18316
18317 d*(-(e0cn*fy) +
18318
18319
18320 e0c*(fy - e0cn*(epscder1 + epsn)))),
18321
18322
18323 2) + 2*
18324
18325
18326 e0c*(as1*d*e0c +
18327
18328
18329 as2*ch*
18330
18331
18332 e0cn)*(-(b*pow(d, 2)*e0c*fc*
18333
18334
18335 pow(epscder1 + epsn,
18336
18337
18338 2)*((6 - 9*k)*epsc1 +
18339
18340
18341 4*(-1 + k)*epscder1 +
18342
18343
18344 4*(-1 + k)*epsn)) +
18345
18346
18347 6*k*pow(epsc1, 2)*
18348
18349
18350 epscder1*(-(as2*ch*e0c*e0cn*epscder1) +
18351
18352
18353 d*(as2*e0cn*fy +
18354
18355
18356 as1*pow(e0c, 2)*epsn +
18357
18358
18359 e0c*(-(as2*fy) - n0 +
18360
18361
18362 as2*e0cn*(epscder1 + epsn))))))))/(6.*
18363
18364
18365 e0c*(as1*d*e0c + as2*ch*e0cn)*k*pow(epsc1, 2))) - (b*d*fc*
18366
18367
18368 pow(epscder1 + epsn,
18369
18370
18371 2)*(2*d*(epscder1 +
18372
18373
18374 epsn)*((2 - 3*k)*epsc1 + (-1 + k)*epscder1 + (-1 + k)*
18375
18376
18377 epsn) -
18378
18379
18380 h*((6 - 9*k)*epsc1 + 4*(-1 + k)*epscder1 +
18381
18382
18383 4*(-1 + k)*
18384
18385
18386 epsn)*(epscder1 - (3*d*e0c*k*
18387
18388
18389 pow(epsc1,
18390
18391
18392 2)*(n0 + as1*e0c*(epscder1 - epsn)) +
18393
18394
18395 3*as2*k*
18396
18397
18398 pow(epsc1,
18399
18400
18401 2)*(2*ch*e0c*e0cn*epscder1 +
18402
18403
18404 d*(-(e0cn*fy) +
18405
18406
18407 e0c*(fy - e0cn*(epscder1 + epsn)))) +
18408
18409
18410 sqrt(3.)*
18411
18412
18413 sqrt(k*
18414
18415
18416 pow(epsc1,
18417
18418
18419 2)*(3*k*pow(epsc1, 2)*
18420
18421
18422 pow(d*
18423
18424
18425 e0c*(n0 + as1*e0c*(epscder1 - epsn)) +
18426
18427
18428 as2*(2*ch*e0c*e0cn*epscder1 +
18429
18430
18431 d*(-(e0cn*fy) +
18432
18433
18434 e0c*(fy - e0cn*(epscder1 + epsn)))),
18435
18436
18437 2) +
18438
18439
18440 2*e0c*(as1*d*e0c +
18441
18442
18443 as2*ch*
18444
18445
18446 e0cn)*(-(b*pow(d, 2)*e0c*fc*
18447
18448
18449 pow(epscder1 + epsn,
18450
18451
18452 2)*((6 - 9*k)*epsc1 +
18453
18454
18455 4*(-1 + k)*epscder1 +
18456
18457
18458 4*(-1 + k)*epsn)) +
18459
18460
18461 6*k*pow(epsc1, 2)*
18462
18463
18464 epscder1*(-(as2*ch*e0c*e0cn*
18465
18466
18467 epscder1) +
18468
18469
18470 d*(as2*e0cn*fy +
18471
18472
18473 as1*pow(e0c, 2)*epsn +
18474
18475
18476 e0c*(-(as2*fy) - n0 +
18477
18478
18479 as2*e0cn*(epscder1 + epsn))))))))/(6.*
18480
18481
18482 e0c*(as1*d*e0c + as2*ch*e0cn)*k*
18483
18484
18485 pow(epsc1, 2)))))/(k*pow(epsc1, 2)*
18486
18487
18488 pow(epscder1 - (3*d*e0c*k*
18489
18490
18491 pow(epsc1, 2)*(n0 + as1*e0c*(epscder1 - epsn)) +
18492
18493
18494 3*as2*k*
18495
18496
18497 pow(epsc1,
18498
18499
18500 2)*(2*ch*e0c*e0cn*epscder1 +
18501
18502
18503 d*(-(e0cn*fy) +
18504
18505
18506 e0c*(fy - e0cn*(epscder1 + epsn)))) +
18507
18508
18509 sqrt(3.)*
18510
18511
18512 sqrt(k*
18513
18514
18515 pow(epsc1,
18516
18517
18518 2)*(3*k*pow(epsc1, 2)*
18519
18520
18521 pow(d*e0c*(n0 + as1*e0c*(epscder1 - epsn)) +
18522
18523
18524 as2*(2*ch*e0c*e0cn*epscder1 +
18525
18526
18527 d*(-(e0cn*fy) +
18528
18529
18530 e0c*(fy - e0cn*(epscder1 + epsn)))),
18531
18532
18533 2) + 2*
18534
18535
18536 e0c*(as1*d*e0c +
18537
18538
18539 as2*ch*
18540
18541
18542 e0cn)*(-(b*pow(d, 2)*e0c*fc*
18543
18544
18545 pow(epscder1 + epsn,
18546
18547
18548 2)*((6 - 9*k)*epsc1 +
18549
18550
18551 4*(-1 + k)*epscder1 +
18552
18553
18554 4*(-1 + k)*epsn)) +
18555
18556
18557 6*k*pow(epsc1, 2)*
18558
18559
18560 epscder1*(-(as2*ch*e0c*e0cn*
18561
18562
18563 epscder1) +
18564
18565
18566 d*(as2*e0cn*fy +
18567
18568
18569 as1*pow(e0c, 2)*epsn +
18570
18571
18572 e0c*(-(as2*fy) - n0 +
18573
18574
18575 as2*e0cn*(epscder1 + epsn))))))))/(6.*
18576
18577
18578 e0c*(as1*d*e0c + as2*ch*e0cn)*k*pow(epsc1, 2)), 2)) +
18579
18580
18581 6*as2*(-2*ch + h)*(fy -
18582
18583
18584 e0cn*(fy/e0c + epscder1 - (ch*epscder1)/d +
18585
18586
18587 epsn + (ch*(3*d*e0c*k*
18588
18589
18590 pow(epsc1,
18591
18592
18593 2)*(n0 + as1*e0c*(epscder1 - epsn)) +
18594
18595
18596 3*as2*k*
18597
18598
18599 pow(epsc1,
18600
18601
18602 2)*(2*ch*e0c*e0cn*epscder1 +
18603
18604
18605 d*(-(e0cn*fy) +
18606
18607
18608 e0c*(fy - e0cn*(epscder1 + epsn)))) +
18609
18610
18611 sqrt(3.)*
18612
18613
18614 sqrt(k*
18615
18616
18617 pow(epsc1,
18618
18619
18620 2)*(3*k*pow(epsc1, 2)*
18621
18622
18623 pow(d*
18624
18625
18626 e0c*(n0 + as1*e0c*(epscder1 - epsn)) +
18627
18628
18629 as2*(2*ch*e0c*e0cn*epscder1 +
18630
18631
18632 d*(-(e0cn*fy) +
18633
18634
18635 e0c*(fy - e0cn*(epscder1 + epsn)))),
18636
18637
18638 2) +
18639
18640
18641 2*e0c*(as1*d*e0c +
18642
18643
18644 as2*ch*
18645
18646
18647 e0cn)*(-(b*pow(d, 2)*e0c*fc*
18648
18649
18650 pow(epscder1 + epsn,
18651
18652
18653 2)*((6 - 9*k)*epsc1 +
18654
18655
18656 4*(-1 + k)*epscder1 +
18657
18658
18659 4*(-1 + k)*epsn)) +
18660
18661
18662 6*k*pow(epsc1, 2)*
18663
18664
18665 epscder1*(-(as2*ch*e0c*e0cn*
18666
18667
18668 epscder1) +
18669
18670
18671 d*(as2*e0cn*fy +
18672
18673
18674 as1*pow(e0c, 2)*epsn +
18675
18676
18677 e0c*(-(as2*fy) - n0 +
18678
18679
18680 as2*e0cn*(epscder1 +
18681
18682
18683 epsn)))))))))/(6.*d*
18684
18685
18686 e0c*(as1*d*e0c + as2*ch*e0cn)*k*pow(epsc1, 2)))))/12. + e0c*(-(as1*(-cd + h/2.)) + as2*(-ch + h/2.))*epsn;
18687
18688
18689
18690
18691
18692 return mmax4;
18693
18694
18695 }
18696
18697
18698
18699
18700
18701
18702 double normmat::compute_mh6 ()
18703
18704
18705 {
18706
18707
18708 double mh6;
18709
18710
18711
18712
18713
18714 if ((epscder1-epsch3) < 0.0 && (epscder1-epsch6a) > 0.0){
18715
18716
18717
18718
18719
18720 mh6 = mmax4;
18721
18722
18723 }
18724
18725
18726 else{
18727
18728
18729 mh6=mh6a;
18730
18731
18732 }
18733
18734
18735 return mh6;
18736
18737
18738 }
18739
18740
18741
18742
18743
18744 double normmat::compute_epsch6 ()
18745
18746
18747 {
18748
18749
18750 double epsch6;
18751
18752
18753
18754
18755
18756 if ((epscder1-epsch3) < 0.0 && (epscder1-epsch6a) > 0.0){
18757
18758
18759
18760
18761
18762 epsch6=epscder1;
18763
18764
18765 }
18766
18767
18768 else{
18769
18770
18771 epsch6=epsch6a;
18772
18773
18774 }
18775
18776
18777 return epsch6;
18778
18779
18780 }
18781
18782
18783
18784
18785
18786
18787
18788
18789 double normmat::compute_mh36 ()
18790
18791
18792 {
18793
18794
18795 double mh36;
18796
18797
18798
18799
18800
18801 mh36 =(-(as1*(2*cd - h)*(3*d*e0c*k*
18802
18803
18804 pow(epsc1, 2)*(2*n0 + as1*e0c*(epsch3 + epsch6 + 2*epsn)) +
18805
18806
18807 3*as2*k*
18808
18809
18810 pow(epsc1,
18811
18812
18813 2)*(2*ch*e0c*e0cn*(epsch3 + epsch6 + 2*epsn) +
18814
18815
18816 d*(-2*e0cn*fy +
18817
18818
18819 e0c*(2*fy - e0cn*(epsch3 + epsch6 + 2*epsn)))) +
18820
18821
18822 2*sqrt(3.)*
18823
18824
18825 sqrt(k*pow(epsc1,
18826
18827
18828 2)*(3*k*pow(epsc1, 2)*
18829
18830
18831 pow((d*e0c*(2*n0 +
18832
18833
18834 as1*e0c*(epsch3 + epsch6 - 2*epsn)))/
18835
18836
18837 2. + as2*(ch*e0c*
18838
18839
18840 e0cn*(epsch3 +
18841
18842
18843 epsch6) + (d*(-2*e0cn*fy +
18844
18845
18846 e0c*(2*fy - e0cn*(epsch3 + epsch6 +
18847
18848
18849 2*epsn))))/2.), 2) +
18850
18851
18852 2*e0c*(as1*d*e0c +
18853
18854
18855 as2*ch*
18856
18857
18858 e0cn)*(-(b*pow(d, 2)*e0c*fc*
18859
18860
18861 pow(epsch3 + epsch6 + 2*epsn,
18862
18863
18864 2)*((6 - 9*k)*epsc1 +
18865
18866
18867 2*(-1 + k)*(epsch3 + epsch6 +
18868
18869
18870 2*epsn)))/
18871
18872
18873 4. + (3*k*
18874
18875
18876 pow(epsc1,
18877
18878
18879 2)*(epsch3 +
18880
18881
18882 epsch6)*(2*d*
18883
18884
18885 e0c*(-n0 + as1*e0c*epsn) +
18886
18887
18888 as2*(-(ch*e0c*
18889
18890
18891 e0cn*(epsch3 + epsch6)) +
18892
18893
18894 d*(2*e0cn*fy +
18895
18896
18897 e0c*(-2*fy + e0cn*(epsch3 + epsch6 +
18898
18899
18900 2*epsn))))))/2.))))) - (6*b*d*
18901
18902
18903 pow(e0c, 2)*pow(as1*d*e0c + as2*ch*e0cn, 3)*fc*pow(k, 2)*
18904
18905
18906 pow(epsc1, 4)*
18907
18908
18909 pow(epsch3 + epsch6 + 2*epsn,
18910
18911
18912 2)*(6*d*(epsch3 + epsch6 +
18913
18914
18915 2*epsn)*((4 - 6*k)*
18916
18917
18918 epsc1 + (-1 + k)*(epsch3 + epsch6 +
18919
18920
18921 2*epsn)) + (h*(3*(-2 + 3*k)*epsc1 -
18922
18923
18924 2*(-1 + k)*(epsch3 + epsch6 + 2*epsn))*(3*d*e0c*k*
18925
18926
18927 pow(epsc1,
18928
18929
18930 2)*(-2*n0 +
18931
18932
18933 as1*e0c*(epsch3 + epsch6 + 2*epsn)) +
18934
18935
18936 3*as2*d*k*
18937
18938
18939 pow(epsc1,
18940
18941
18942 2)*(2*e0cn*fy +
18943
18944
18945 e0c*(-2*fy +
18946
18947
18948 e0cn*(epsch3 + epsch6 + 2*epsn))) -
18949
18950
18951 2*sqrt(3.)*
18952
18953
18954 sqrt(k*
18955
18956
18957 pow(epsc1,
18958
18959
18960 2)*(3*k*pow(epsc1, 2)*
18961
18962
18963 pow((d*e0c*(2*n0 +
18964
18965
18966 as1*e0c*(epsch3 + epsch6 - 2*epsn)))/
18967
18968
18969 2. +
18970
18971
18972 as2*(ch*e0c*
18973
18974
18975 e0cn*(epsch3 + epsch6) + (d*(-2*e0cn*
18976
18977
18978 fy + e0c*(2*fy - e0cn*(epsch3 +
18979
18980
18981 epsch6 + 2*epsn))))/2.), 2) +
18982
18983
18984 2*e0c*(as1*d*e0c +
18985
18986
18987 as2*ch*
18988
18989
18990 e0cn)*(-(b*pow(d, 2)*e0c*fc*
18991
18992
18993 pow(epsch3 + epsch6 + 2*epsn,
18994
18995
18996 2)*((6 - 9*k)*epsc1 +
18997
18998
18999 2*(-1 + k)*(epsch3 + epsch6 +
19000
19001
19002 2*epsn)))/
19003
19004
19005 4. + (3*k*
19006
19007
19008 pow(epsc1, 2)*(epsch3 +
19009
19010
19011 epsch6)*(2*d*e0c*(-n0 +
19012
19013
19014 as1*e0c*epsn) +
19015
19016
19017 as2*(-(ch*e0c*e0cn*(epsch3 +
19018
19019
19020 epsch6)) + d*(2*e0cn*fy +
19021
19022
19023 e0c*(-2*fy + e0cn*(epsch3 + epsch6 +
19024
19025
19026 2*epsn))))))/2.)))))/(e0c*(as1*d*e0c +
19027
19028
19029 as2*ch*e0cn)*k*pow(epsc1, 2))))/
19030
19031
19032 pow(3*d*e0c*k*
19033
19034
19035 pow(epsc1, 2)*(-2*n0 + as1*e0c*(epsch3 + epsch6 + 2*epsn)) +
19036
19037
19038 3*as2*d*k*
19039
19040
19041 pow(epsc1,
19042
19043
19044 2)*(2*e0cn*fy +
19045
19046
19047 e0c*(-2*fy + e0cn*(epsch3 + epsch6 + 2*epsn))) -
19048
19049
19050 2*sqrt(3.)*
19051
19052
19053 sqrt(k*pow(epsc1,
19054
19055
19056 2)*(3*k*pow(epsc1, 2)*
19057
19058
19059 pow((d*e0c*(2*n0 +
19060
19061
19062 as1*e0c*(epsch3 + epsch6 - 2*epsn)))/
19063
19064
19065 2. + as2*(ch*e0c*
19066
19067
19068 e0cn*(epsch3 +
19069
19070
19071 epsch6) + (d*(-2*e0cn*fy +
19072
19073
19074 e0c*(2*fy -
19075
19076
19077 e0cn*(epsch3 + epsch6 + 2*epsn))))/
19078
19079
19080 2.), 2) +
19081
19082
19083 2*e0c*(as1*d*e0c +
19084
19085
19086 as2*ch*
19087
19088
19089 e0cn)*(-(b*pow(d, 2)*e0c*fc*
19090
19091
19092 pow(epsch3 + epsch6 + 2*epsn,
19093
19094
19095 2)*((6 - 9*k)*epsc1 +
19096
19097
19098 2*(-1 + k)*(epsch3 + epsch6 +
19099
19100
19101 2*epsn)))/
19102
19103
19104 4. + (3*k*
19105
19106
19107 pow(epsc1,
19108
19109
19110 2)*(epsch3 +
19111
19112
19113 epsch6)*(2*d*e0c*(-n0 + as1*e0c*epsn) +
19114
19115
19116 as2*(-(ch*e0c*e0cn*(epsch3 + epsch6)) +
19117
19118
19119 d*(2*e0cn*fy +
19120
19121
19122 e0c*(-2*fy + e0cn*(epsch3 + epsch6 +
19123
19124
19125 2*epsn))))))/2.))),
19126
19127
19128 2) + (as2*(2*ch -
19129
19130
19131 h)*(-3*as1*d*e0c*k*
19132
19133
19134 pow(epsc1,
19135
19136
19137 2)*(ch*e0c*e0cn*(epsch3 + epsch6 + 2*epsn) -
19138
19139
19140 2*d*(2*e0cn*fy +
19141
19142
19143 e0c*(-2*fy + e0cn*(epsch3 + epsch6 + 2*epsn)))) +
19144
19145
19146 ch*e0cn*(6*d*e0c*k*n0*pow(epsc1, 2) +
19147
19148
19149 3*as2*d*k*
19150
19151
19152 pow(epsc1,
19153
19154
19155 2)*(2*e0cn*fy +
19156
19157
19158 e0c*(-2*fy + e0cn*(epsch3 + epsch6 + 2*epsn))) +
19159
19160
19161 2*sqrt(3.)*
19162
19163
19164 sqrt(k*
19165
19166
19167 pow(epsc1,
19168
19169
19170 2)*(3*k*pow(epsc1, 2)*
19171
19172
19173 pow((d*e0c*(2*n0 +
19174
19175
19176 as1*e0c*(epsch3 + epsch6 - 2*epsn)))/
19177
19178
19179 2. +
19180
19181
19182 as2*(ch*e0c*
19183
19184
19185 e0cn*(epsch3 +
19186
19187
19188 epsch6) + (d*(-2*e0cn*fy +
19189
19190
19191 e0c*(2*fy - e0cn*(epsch3 + epsch6 +
19192
19193
19194 2*epsn))))/2.), 2) +
19195
19196
19197 2*e0c*(as1*d*e0c +
19198
19199
19200 as2*ch*
19201
19202
19203 e0cn)*(-(b*pow(d, 2)*e0c*fc*
19204
19205
19206 pow(epsch3 + epsch6 + 2*epsn,
19207
19208
19209 2)*((6 - 9*k)*epsc1 +
19210
19211
19212 2*(-1 + k)*(epsch3 + epsch6 +
19213
19214
19215 2*epsn)))/
19216
19217
19218 4. + (3*k*
19219
19220
19221 pow(epsc1,
19222
19223
19224 2)*(epsch3 +
19225
19226
19227 epsch6)*(2*d*
19228
19229
19230 e0c*(-n0 + as1*e0c*epsn) +
19231
19232
19233 as2*(-(ch*e0c*e0cn*(epsch3 +
19234
19235
19236 epsch6)) + d*(2*e0cn*fy +
19237
19238
19239 e0c*(-2*fy + e0cn*(epsch3 + epsch6 +
19240
19241
19242 2*epsn))))))/2.))))))/(d*
19243
19244
19245 e0c))/(24.*(as1*d*e0c + as2*ch*e0cn)*k*pow(epsc1, 2)) + e0c*(-(as1*(-cd + h/2.)) + as2*(-ch + h/2.))*epsn;
19246
19247
19248
19249
19250
19251 return mh36;
19252
19253
19254 }
19255
19256
19257
19258
19259
19260
19261
19262
19263 double normmat::compute_mh7maxa ()
19264
19265
19266 {
19267
19268
19269 double mh7maxa;
19270
19271
19272
19273
19274
19275 mh7maxa =-(as1*(2*cd - h)*(3*d*e0c*k*n0*pow(epsc1, 2) +
19276
19277
19278 3*as1*d*k*
19279
19280
19281 pow(epsc1,
19282
19283
19284 2)*(-(e0cn*
19285
19286
19287 fy) + (e0c*(2*fy +
19288
19289
19290 e0cn*(epsch7 + epscmax1 + 2*epsn)))/2.) +
19291
19292
19293 3*as2*k*pow(epsc1,
19294
19295
19296 2)*(-(d*(2*e0cn*fy +
19297
19298
19299 e0c*(-2*fy +
19300
19301
19302 e0cn*(epsch7 + epscmax1 + 2*epsn))))/
19303
19304
19305 2. + ch*(-2*e0cn*fy +
19306
19307
19308 e0c*(2*fy + e0cn*(epsch7 + epscmax1 + 2*epsn)))) +
19309
19310
19311 sqrt(3.)*sqrt(k*
19312
19313
19314 pow(epsc1,
19315
19316
19317 2)*((3*k*pow(epsc1, 2)*
19318
19319
19320 pow(-2*d*e0c*n0 +
19321
19322
19323 as1*d*(-2*e0cn*fy +
19324
19325
19326 e0c*(2*fy -
19327
19328
19329 e0cn*(epsch7 + epscmax1 - 2*epsn))) +
19330
19331
19332 as2*(-2*ch*e0c*e0cn*(epsch7 + epscmax1) +
19333
19334
19335 d*(2*e0cn*fy +
19336
19337
19338 e0c*(-2*fy +
19339
19340
19341 e0cn*(epsch7 + epscmax1 + 2*epsn)))),
19342
19343
19344 2))/4. - ((as2*ch + as1*d)*e0c*
19345
19346
19347 e0cn*(b*pow(d, 2)*e0c*fc*
19348
19349
19350 pow(epsch7 + epscmax1 + 2*epsn,
19351
19352
19353 2)*((6 - 9*k)*epsc1 +
19354
19355
19356 2*(-1 + k)*(epsch7 + epscmax1 +
19357
19358
19359 2*epsn)) -
19360
19361
19362 6*k*pow(epsc1,
19363
19364
19365 2)*(epsch7 + epscmax1)*(-2*d*e0c*n0 +
19366
19367
19368 2*as1*
19369
19370
19371 d*(-(e0cn*fy) +
19372
19373
19374 e0c*(fy + e0cn*epsn)) +
19375
19376
19377 as2*(-(ch*e0c*
19378
19379
19380 e0cn*(epsch7 + epscmax1)) +
19381
19382
19383 d*(2*e0cn*fy +
19384
19385
19386 e0c*(-2*fy + e0cn*(epsch7 +
19387
19388
19389 epscmax1 + 2*epsn)))))))/
19390
19391
19392 2.))) - (as2*(2*ch -
19393
19394
19395 h)*(-3*as1*d*k*
19396
19397
19398 pow(epsc1,
19399
19400
19401 2)*(-2*d*(2*e0cn*fy +
19402
19403
19404 e0c*(-2*fy +
19405
19406
19407 e0cn*(epsch7 + epscmax1 + 2*epsn))) +
19408
19409
19410 ch*(-2*e0cn*fy +
19411
19412
19413 e0c*(2*fy +
19414
19415
19416 e0cn*(epsch7 + epscmax1 + 2*epsn)))) +
19417
19418
19419 ch*(6*d*e0c*k*n0*pow(epsc1, 2) +
19420
19421
19422 3*as2*d*k*
19423
19424
19425 pow(epsc1,
19426
19427
19428 2)*(2*e0cn*fy +
19429
19430
19431 e0c*(-2*fy +
19432
19433
19434 e0cn*(epsch7 + epscmax1 + 2*epsn))) +
19435
19436
19437 2*sqrt(3.)*
19438
19439
19440 sqrt(k*
19441
19442
19443 pow(epsc1,
19444
19445
19446 2)*((3*k*pow(epsc1, 2)*
19447
19448
19449 pow(-2*d*e0c*n0 +
19450
19451
19452 as1*d*(-2*e0cn*fy +
19453
19454
19455 e0c*(2*fy - e0cn*(epsch7 + epscmax1 -
19456
19457
19458 2*epsn))) +
19459
19460
19461 as2*(-2*ch*e0c*
19462
19463
19464 e0cn*(epsch7 + epscmax1) +
19465
19466
19467 d*(2*e0cn*fy + e0c*(-2*fy +
19468
19469
19470 e0cn*(epsch7 + epscmax1 + 2*epsn)))),
19471
19472
19473 2))/4. - ((as2*ch + as1*d)*e0c*
19474
19475
19476 e0cn*(b*pow(d, 2)*e0c*fc*
19477
19478
19479 pow(epsch7 + epscmax1 + 2*epsn,
19480
19481
19482 2)*((6 - 9*k)*epsc1 +
19483
19484
19485 2*(-1 + k)*(epsch7 + epscmax1 +
19486
19487
19488 2*epsn)) -
19489
19490
19491 6*k*pow(epsc1,
19492
19493
19494 2)*(epsch7 + epscmax1)*(-2*d*e0c*n0 +
19495
19496
19497 2*as1*d*(-(e0cn*fy) +
19498
19499
19500 e0c*(fy + e0cn*epsn)) +
19501
19502
19503 as2*(-(ch*e0c*e0cn*(epsch7 +
19504
19505
19506 epscmax1)) + d*(2*e0cn*fy +
19507
19508
19509 e0c*(-2*fy + e0cn*(epsch7 +
19510
19511
19512 epscmax1 + 2*epsn)))))))/2.)))))/(2.*
19513
19514
19515 d) + (3*b*d*pow(as2*ch + as1*d, 3)*pow(e0c, 3)*pow(e0cn, 2)*fc*
19516
19517
19518 pow(k, 2)*pow(epsc1, 4)*
19519
19520
19521 pow(epsch7 + epscmax1 + 2*epsn,
19522
19523
19524 2)*(6*d*(epsch7 + epscmax1 +
19525
19526
19527 2*epsn)*((4 - 6*k)*
19528
19529
19530 epsc1 + (-1 + k)*(epsch7 + epscmax1 +
19531
19532
19533 2*epsn)) + (h*(3*(-2 + 3*k)*epsc1 -
19534
19535
19536 2*(-1 + k)*(epsch7 + epscmax1 + 2*epsn))*(3*as2*
19537
19538
19539 d*k*pow(epsc1,
19540
19541
19542 2)*(2*e0cn*fy +
19543
19544
19545 e0c*(-2*fy +
19546
19547
19548 e0cn*(epsch7 + epscmax1 + 2*epsn))) +
19549
19550
19551 3*as1*d*k*
19552
19553
19554 pow(epsc1,
19555
19556
19557 2)*(-2*e0cn*fy +
19558
19559
19560 e0c*(2*fy +
19561
19562
19563 e0cn*(epsch7 + epscmax1 + 2*epsn))) -
19564
19565
19566 2*(3*d*e0c*k*n0*pow(epsc1, 2) +
19567
19568
19569 sqrt(3.)*
19570
19571
19572 sqrt(k*
19573
19574
19575 pow(epsc1,
19576
19577
19578 2)*((3*k*pow(epsc1, 2)*
19579
19580
19581 pow(-2*d*e0c*n0 +
19582
19583
19584 as1*d*(-2*e0cn*fy + e0c*(2*fy -
19585
19586
19587 e0cn*(epsch7 + epscmax1 - 2*epsn))) +
19588
19589
19590 as2*(-2*ch*e0c*e0cn*(epsch7 +
19591
19592
19593 epscmax1) + d*(2*e0cn*fy +
19594
19595
19596 e0c*(-2*fy + e0cn*(epsch7 +
19597
19598
19599 epscmax1 + 2*epsn)))), 2))/4.
19600
19601
19602 -((as2*ch + as1*d)*e0c*
19603
19604
19605 e0cn*(b*pow(d, 2)*e0c*fc*
19606
19607
19608 pow(epsch7 + epscmax1 + 2*epsn,
19609
19610
19611 2)*((6 - 9*k)*epsc1 + 2*(-1 +
19612
19613
19614 k)*(epsch7 + epscmax1 + 2*epsn)) -
19615
19616
19617 6*k*pow(epsc1, 2)*(epsch7 +
19618
19619
19620 epscmax1)*(-2*d*e0c*n0 + 2*as1*
19621
19622
19623 d*(e0c*fy - e0cn*fy + e0c*e0cn*epsn) +
19624
19625
19626 as2*(-(ch*e0c*e0cn*(epsch7 +
19627
19628
19629 epscmax1)) + d*(2*e0cn*fy +
19630
19631
19632 e0c*(-2*fy + e0cn*(epsch7 +
19633
19634
19635 epscmax1 + 2*epsn)))))))/
19636
19637
19638 2.)))))/((as2*ch + as1*d)*e0c*e0cn*k*
19639
19640
19641 pow(epsc1, 2))))/
19642
19643
19644 pow(6*d*e0c*k*n0*pow(epsc1, 2) -
19645
19646
19647 3*as2*d*k*
19648
19649
19650 pow(epsc1,
19651
19652
19653 2)*(2*e0cn*fy +
19654
19655
19656 e0c*(-2*fy + e0cn*(epsch7 + epscmax1 + 2*epsn))) -
19657
19658
19659 3*as1*d*k*
19660
19661
19662 pow(epsc1,
19663
19664
19665 2)*(-2*e0cn*fy +
19666
19667
19668 e0c*(2*fy + e0cn*(epsch7 + epscmax1 + 2*epsn))) +
19669
19670
19671 2*sqrt(3.)*
19672
19673
19674 sqrt(k*pow(epsc1,
19675
19676
19677 2)*((3*k*pow(epsc1, 2)*
19678
19679
19680 pow(-2*d*e0c*n0 +
19681
19682
19683 as1*d*(-2*e0cn*fy +
19684
19685
19686 e0c*(2*fy -
19687
19688
19689 e0cn*(epsch7 + epscmax1 - 2*epsn))) +
19690
19691
19692 as2*(-2*ch*e0c*e0cn*(epsch7 + epscmax1) +
19693
19694
19695 d*(2*e0cn*fy +
19696
19697
19698 e0c*(-2*fy +
19699
19700
19701 e0cn*(epsch7 + epscmax1 + 2*epsn)))),
19702
19703
19704 2))/4. - ((as2*ch + as1*d)*e0c*
19705
19706
19707 e0cn*(b*pow(d, 2)*e0c*fc*
19708
19709
19710 pow(epsch7 + epscmax1 + 2*epsn,
19711
19712
19713 2)*((6 - 9*k)*epsc1 +
19714
19715
19716 2*(-1 + k)*(epsch7 + epscmax1 +
19717
19718
19719 2*epsn)) -
19720
19721
19722 6*k*pow(epsc1,
19723
19724
19725 2)*(epsch7 + epscmax1)*(-2*d*e0c*n0 +
19726
19727
19728 2*as1*
19729
19730
19731 d*(-(e0cn*fy) +
19732
19733
19734 e0c*(fy + e0cn*epsn)) +
19735
19736
19737 as2*(-(ch*e0c*
19738
19739
19740 e0cn*(epsch7 + epscmax1)) +
19741
19742
19743 d*(2*e0cn*fy +
19744
19745
19746 e0c*(-2*fy + e0cn*(epsch7 +
19747
19748
19749 epscmax1 + 2*epsn)))))))/2.)),
19750
19751
19752 2))/(12.*(as2*ch + as1*d)*e0c*k*pow(epsc1, 2)) + e0c*(-(as1*(-cd + h/2.)) + as2*(-ch + h/2.))*epsn;
19753
19754
19755
19756
19757
19758 return mh7maxa;
19759
19760
19761 }
19762
19763
19764
19765
19766
19767
19768
19769
19770 double normmat::compute_mhmaxa ()
19771
19772
19773 {
19774
19775
19776 double mhmaxa;
19777
19778
19779
19780
19781
19782 mhmaxa =(-(as1*(2*cd - h)*(3*d*e0c*k*n0*pow(epsc1, 2) +
19783
19784
19785 3*as1*d*k*
19786
19787
19788 pow(epsc1,
19789
19790
19791 2)*(-(e0cn*fy) + e0c*(fy + e0cn*(epscmax1 + epsn))) +
19792
19793
19794 3*as2*k*
19795
19796
19797 pow(epsc1,
19798
19799
19800 2)*(d*(-(e0cn*fy) + e0c*(fy - e0cn*(epscmax1 + epsn))) +
19801
19802
19803 2*ch*(-(e0cn*fy) + e0c*(fy + e0cn*(epscmax1 + epsn)))) +
19804
19805
19806 sqrt(3.)*
19807
19808
19809 sqrt(k*pow(epsc1,
19810
19811
19812 2)*(3*k*pow(epsc1, 2)*
19813
19814
19815 pow(-(d*e0c*n0) +
19816
19817
19818 as1*d*(-(e0cn*fy) +
19819
19820
19821 e0c*(fy + e0cn*(-epscmax1 + epsn))) +
19822
19823
19824 as2*(-2*ch*e0c*e0cn*epscmax1 +
19825
19826
19827 d*(e0cn*fy +
19828
19829
19830 e0c*(-fy + e0cn*(epscmax1 + epsn)))),
19831
19832
19833 2) - 2*(as2*ch + as1*d)*e0c*
19834
19835
19836 e0cn*(b*pow(d, 2)*e0c*fc*
19837
19838
19839 pow(epscmax1 + epsn,
19840
19841
19842 2)*((6 - 9*k)*epsc1 +
19843
19844
19845 4*(-1 + k)*epscmax1 +
19846
19847
19848 4*(-1 + k)*epsn) +
19849
19850
19851 6*k*pow(epsc1, 2)*
19852
19853
19854 epscmax1*(d*e0c*n0 +
19855
19856
19857 as1*d*(e0cn*fy - e0c*(fy + e0cn*epsn)) +
19858
19859
19860 as2*(ch*e0c*e0cn*epscmax1 +
19861
19862
19863 d*(-(e0cn*fy) +
19864
19865
19866 e0c*(fy - e0cn*(epscmax1 +
19867
19868
19869 epsn)))))))))) - (36*b*d*
19870
19871
19872 pow(as2*ch + as1*d, 3)*pow(e0c, 3)*pow(e0cn, 2)*fc*pow(k, 2)*
19873
19874
19875 pow(epsc1, 4)*
19876
19877
19878 pow(epscmax1 + epsn,
19879
19880
19881 2)*(2*d*(epscmax1 +
19882
19883
19884 epsn)*((2 - 3*k)*epsc1 + (-1 + k)*epscmax1 + (-1 + k)*
19885
19886
19887 epsn) - (h*((6 - 9*k)*epsc1 + 4*(-1 + k)*epscmax1 +
19888
19889
19890 4*(-1 + k)*epsn)*(-3*d*e0c*k*n0*pow(epsc1, 2) +
19891
19892
19893 3*as2*d*k*
19894
19895
19896 pow(epsc1,
19897
19898
19899 2)*(e0cn*fy +
19900
19901
19902 e0c*(-fy + e0cn*(epscmax1 + epsn))) +
19903
19904
19905 3*as1*d*k*
19906
19907
19908 pow(epsc1,
19909
19910
19911 2)*(-(e0cn*fy) +
19912
19913
19914 e0c*(fy + e0cn*(epscmax1 + epsn))) -
19915
19916
19917 sqrt(3.)*
19918
19919
19920 sqrt(k*
19921
19922
19923 pow(epsc1,
19924
19925
19926 2)*(3*k*pow(epsc1, 2)*
19927
19928
19929 pow(-(d*e0c*n0) +
19930
19931
19932 as1*d*(-(e0cn*fy) +
19933
19934
19935 e0c*(fy + e0cn*(-epscmax1 + epsn))) +
19936
19937
19938 as2*(-2*ch*e0c*e0cn*epscmax1 +
19939
19940
19941 d*(e0cn*fy + e0c*(-fy +
19942
19943
19944 e0cn*(epscmax1 + epsn)))), 2) -
19945
19946
19947 2*(as2*ch + as1*d)*e0c*
19948
19949
19950 e0cn*(b*pow(d, 2)*e0c*fc*
19951
19952
19953 pow(epscmax1 + epsn,2)*((6 - 9*k)*epsc1 +
19954
19955
19956 4*(-1 + k)*epscmax1 +
19957
19958
19959 4*(-1 + k)*epsn) +
19960
19961
19962 6*k*pow(epsc1, 2)*
19963
19964
19965 epscmax1*(d*e0c*n0 +
19966
19967
19968 as1*d*(e0cn*fy -
19969
19970
19971 e0c*(fy + e0cn*epsn)) +
19972
19973
19974 as2*(ch*e0c*e0cn*epscmax1 +
19975
19976
19977 d*(-(e0cn*fy) + e0c*(fy -
19978
19979
19980 e0cn*(epscmax1 +
19981
19982
19983 epsn))))))))))/(6.*(as2*ch + as1*d)*
19984
19985
19986 e0c*e0cn*k*pow(epsc1, 2))))/
19987
19988
19989 pow(3*d*e0c*k*n0*pow(epsc1, 2) +
19990
19991
19992 3*as2*d*k*
19993
19994
19995 pow(epsc1,
19996
19997
19998 2)*(-(e0cn*fy) + e0c*(fy - e0cn*(epscmax1 + epsn))) -
19999
20000
20001 3*as1*d*k*
20002
20003
20004 pow(epsc1, 2)*(-(e0cn*fy) + e0c*(fy + e0cn*(epscmax1 + epsn))) +
20005
20006
20007 sqrt(3.)*
20008
20009
20010 sqrt(k*pow(epsc1,
20011
20012
20013 2)*(3*k*pow(epsc1, 2)*
20014
20015
20016 pow(-(d*e0c*n0) +
20017
20018
20019 as1*d*(-(e0cn*fy) +
20020
20021
20022 e0c*(fy + e0cn*(-epscmax1 + epsn))) +
20023
20024
20025 as2*(-2*ch*e0c*e0cn*epscmax1 +
20026
20027
20028 d*(e0cn*fy +
20029
20030
20031 e0c*(-fy + e0cn*(epscmax1 + epsn)))),
20032
20033
20034 2) - 2*(as2*ch + as1*d)*e0c*
20035
20036
20037 e0cn*(b*pow(d, 2)*e0c*fc*
20038
20039
20040 pow(epscmax1 + epsn,
20041
20042
20043 2)*((6 - 9*k)*epsc1 + 4*(-1 + k)*epscmax1 +
20044
20045
20046 4*(-1 + k)*epsn) +
20047
20048
20049 6*k*pow(epsc1, 2)*
20050
20051
20052 epscmax1*(d*e0c*n0 +
20053
20054
20055 as1*d*(e0cn*fy - e0c*(fy + e0cn*epsn)) +
20056
20057
20058 as2*(ch*e0c*e0cn*epscmax1 +
20059
20060
20061 d*(-(e0cn*fy) +
20062
20063
20064 e0c*(fy - e0cn*(epscmax1 +
20065
20066
20067 epsn)))))))),
20068
20069
20070 2) + (as2*(2*ch -
20071
20072
20073 h)*(-3*as1*d*k*
20074
20075
20076 pow(epsc1,
20077
20078
20079 2)*(-2*d*(e0cn*fy + e0c*(-fy + e0cn*(epscmax1 + epsn))) +
20080
20081
20082 ch*(-(e0cn*fy) + e0c*(fy + e0cn*(epscmax1 + epsn)))) +
20083
20084
20085 ch*(3*d*e0c*k*n0*pow(epsc1, 2) +
20086
20087
20088 3*as2*d*k*
20089
20090
20091 pow(epsc1,
20092
20093
20094 2)*(e0cn*fy + e0c*(-fy + e0cn*(epscmax1 + epsn))) +
20095
20096
20097 sqrt(3.)*
20098
20099
20100 sqrt(k*
20101
20102
20103 pow(epsc1,
20104
20105
20106 2)*(3*k*pow(epsc1, 2)*
20107
20108
20109 pow(-(d*e0c*n0) +
20110
20111
20112 as1*d*(-(e0cn*fy) +
20113
20114
20115 e0c*(fy + e0cn*(-epscmax1 + epsn))) +
20116
20117
20118 as2*(-2*ch*e0c*e0cn*epscmax1 +
20119
20120
20121 d*(e0cn*fy +
20122
20123
20124 e0c*(-fy + e0cn*(epscmax1 + epsn)))),
20125
20126
20127 2) - 2*(as2*ch + as1*d)*e0c*
20128
20129
20130 e0cn*(b*pow(d, 2)*e0c*fc*
20131
20132
20133 pow(epscmax1 + epsn,
20134
20135
20136 2)*((6 - 9*k)*epsc1 +
20137
20138
20139 4*(-1 + k)*epscmax1 +
20140
20141
20142 4*(-1 + k)*epsn) +
20143
20144
20145 6*k*pow(epsc1, 2)*
20146
20147
20148 epscmax1*(d*e0c*n0 +
20149
20150
20151 as1*d*(e0cn*fy -
20152
20153
20154 e0c*(fy + e0cn*epsn)) +
20155
20156
20157 as2*(ch*e0c*e0cn*epscmax1 +
20158
20159
20160 d*(-(e0cn*fy) +
20161
20162
20163 e0c*(fy - e0cn*(epscmax1 +
20164
20165
20166 epsn)))))))))))/
20167
20168
20169 d)/(12.*(as2*ch + as1*d)*e0c*k*pow(epsc1, 2)) + e0c*(-(as1*(-cd + h/2.)) + as2*(-ch + h/2.))*epsn;
20170
20171
20172
20173
20174
20175 return mhmaxa;
20176
20177
20178 }
20179
20180
20181
20182
20183
20184
20185
20186
20187 double normmat::compute_epscder3 ()
20188
20189
20190 {
20191
20192
20193 double epscder3;
20194
20195
20196
20197
20198
20199 epscder3 =-(-(mh7*epsch7) + 4*mh7maxa*epsch7 - 3*mhmaxa*epsch7 - 3*mh7*epscmax1 +
20200
20201
20202 4*mh7maxa*epscmax1 - mhmaxa*epscmax1)/(4.*(mh7 - 2*mh7maxa + mhmaxa));
20203
20204
20205
20206
20207
20208 return epscder3;
20209
20210
20211 }
20212
20213
20214
20215
20216
20217
20218
20219
20220 double normmat::compute_mhmax ()
20221
20222
20223 {
20224
20225
20226 double mhmax;
20227
20228
20229
20230
20231
20232 mhmax =(-(as1*(2*cd - h)*(3*d*e0c*k*n0*pow(epsc1, 2) +
20233
20234
20235 3*as1*d*k*
20236
20237
20238 pow(epsc1,
20239
20240
20241 2)*(-(e0cn*fy) + e0c*(fy + e0cn*(epscder3 + epsn))) +
20242
20243
20244 3*as2*k*
20245
20246
20247 pow(epsc1,
20248
20249
20250 2)*(d*(-(e0cn*fy) + e0c*(fy - e0cn*(epscder3 + epsn))) +
20251
20252
20253 2*ch*(-(e0cn*fy) + e0c*(fy + e0cn*(epscder3 + epsn)))) +
20254
20255
20256 sqrt(3.)*
20257
20258
20259 sqrt(k*pow(epsc1,
20260
20261
20262 2)*(3*k*pow(epsc1, 2)*
20263
20264
20265 pow(-(d*e0c*n0) +
20266
20267
20268 as1*d*(-(e0cn*fy) +
20269
20270
20271 e0c*(fy + e0cn*(-epscder3 + epsn))) +
20272
20273
20274 as2*(-2*ch*e0c*e0cn*epscder3 +
20275
20276
20277 d*(e0cn*fy +
20278
20279
20280 e0c*(-fy + e0cn*(epscder3 + epsn)))),
20281
20282
20283 2) - 2*(as2*ch + as1*d)*e0c*
20284
20285
20286 e0cn*(b*pow(d, 2)*e0c*fc*
20287
20288
20289 pow(epscder3 + epsn,
20290
20291
20292 2)*((6 - 9*k)*epsc1 +
20293
20294
20295 4*(-1 + k)*epscder3 +
20296
20297
20298 4*(-1 + k)*epsn) +
20299
20300
20301 6*k*pow(epsc1, 2)*
20302
20303
20304 epscder3*(d*e0c*n0 +
20305
20306
20307 as1*d*(e0cn*fy - e0c*(fy + e0cn*epsn)) +
20308
20309
20310 as2*(ch*e0c*e0cn*epscder3 +
20311
20312
20313 d*(-(e0cn*fy) +
20314
20315
20316 e0c*(fy - e0cn*(epscder3 +
20317
20318
20319 epsn)))))))))) - (36*b*d*
20320
20321
20322 pow(as2*ch + as1*d, 3)*pow(e0c, 3)*pow(e0cn, 2)*fc*pow(k, 2)*
20323
20324
20325 pow(epsc1, 4)*
20326
20327
20328 pow(epscder3 + epsn,
20329
20330
20331 2)*(2*d*(epscder3 +
20332
20333
20334 epsn)*((2 - 3*k)*epsc1 + (-1 + k)*epscder3 + (-1 + k)*
20335
20336
20337 epsn) - (h*((6 - 9*k)*epsc1 + 4*(-1 + k)*epscder3 +
20338
20339
20340 4*(-1 + k)*epsn)*(-3*d*e0c*k*n0*pow(epsc1, 2) +
20341
20342
20343 3*as2*d*k*
20344
20345
20346 pow(epsc1,
20347
20348
20349 2)*(e0cn*fy +
20350
20351
20352 e0c*(-fy + e0cn*(epscder3 + epsn))) +
20353
20354
20355 3*as1*d*k*
20356
20357
20358 pow(epsc1,
20359
20360
20361 2)*(-(e0cn*fy) +
20362
20363
20364 e0c*(fy + e0cn*(epscder3 + epsn))) -
20365
20366
20367 sqrt(3.)*
20368
20369
20370 sqrt(k*
20371
20372
20373 pow(epsc1,
20374
20375
20376 2)*(3*k*pow(epsc1, 2)*
20377
20378
20379 pow(-(d*e0c*n0) +
20380
20381
20382 as1*d*(-(e0cn*fy) +
20383
20384
20385 e0c*(fy + e0cn*(-epscder3 + epsn))) +
20386
20387
20388 as2*(-2*ch*e0c*e0cn*epscder3 +
20389
20390
20391 d*(e0cn*fy + e0c*(-fy +
20392
20393
20394 e0cn*(epscder3 + epsn)))), 2) -
20395
20396
20397 2*(as2*ch + as1*d)*e0c*
20398
20399
20400 e0cn*(b*pow(d, 2)*e0c*fc*
20401
20402
20403 pow(epscder3 + epsn,
20404
20405
20406 2)*((6 - 9*k)*epsc1 +
20407
20408
20409 4*(-1 + k)*epscder3 +
20410
20411
20412 4*(-1 + k)*epsn) +
20413
20414
20415 6*k*pow(epsc1, 2)*
20416
20417
20418 epscder3*(d*e0c*n0 +
20419
20420
20421 as1*d*(e0cn*fy -
20422
20423
20424 e0c*(fy + e0cn*epsn)) +
20425
20426
20427 as2*(ch*e0c*e0cn*epscder3 +
20428
20429
20430 d*(-(e0cn*fy) + e0c*(fy -
20431
20432
20433 e0cn*(epscder3 +
20434
20435
20436 epsn))))))))))/(6.*(as2*ch + as1*d)*
20437
20438
20439 e0c*e0cn*k*pow(epsc1, 2))))/
20440
20441
20442 pow(3*d*e0c*k*n0*pow(epsc1, 2) +
20443
20444
20445 3*as2*d*k*
20446
20447
20448 pow(epsc1,
20449
20450
20451 2)*(-(e0cn*fy) + e0c*(fy - e0cn*(epscder3 + epsn))) -
20452
20453
20454 3*as1*d*k*
20455
20456
20457 pow(epsc1, 2)*(-(e0cn*fy) + e0c*(fy + e0cn*(epscder3 + epsn))) +
20458
20459
20460 sqrt(3.)*
20461
20462
20463 sqrt(k*pow(epsc1,
20464
20465
20466 2)*(3*k*pow(epsc1, 2)*
20467
20468
20469 pow(-(d*e0c*n0) +
20470
20471
20472 as1*d*(-(e0cn*fy) +
20473
20474
20475 e0c*(fy + e0cn*(-epscder3 + epsn))) +
20476
20477
20478 as2*(-2*ch*e0c*e0cn*epscder3 +
20479
20480
20481 d*(e0cn*fy +
20482
20483
20484 e0c*(-fy + e0cn*(epscder3 + epsn)))),
20485
20486
20487 2) - 2*(as2*ch + as1*d)*e0c*
20488
20489
20490 e0cn*(b*pow(d, 2)*e0c*fc*
20491
20492
20493 pow(epscder3 + epsn,
20494
20495
20496 2)*((6 - 9*k)*epsc1 + 4*(-1 + k)*epscder3 +
20497
20498
20499 4*(-1 + k)*epsn) +
20500
20501
20502 6*k*pow(epsc1, 2)*
20503
20504
20505 epscder3*(d*e0c*n0 +
20506
20507
20508 as1*d*(e0cn*fy - e0c*(fy + e0cn*epsn)) +
20509
20510
20511 as2*(ch*e0c*e0cn*epscder3 +
20512
20513
20514 d*(-(e0cn*fy) +
20515
20516
20517 e0c*(fy - e0cn*(epscder3 +
20518
20519
20520 epsn)))))))),
20521
20522
20523 2) + (as2*(2*ch -
20524
20525
20526 h)*(-3*as1*d*k*
20527
20528
20529 pow(epsc1,
20530
20531
20532 2)*(-2*d*(e0cn*fy + e0c*(-fy + e0cn*(epscder3 + epsn))) +
20533
20534
20535 ch*(-(e0cn*fy) + e0c*(fy + e0cn*(epscder3 + epsn)))) +
20536
20537
20538 ch*(3*d*e0c*k*n0*pow(epsc1, 2) +
20539
20540
20541 3*as2*d*k*
20542
20543
20544 pow(epsc1,
20545
20546
20547 2)*(e0cn*fy + e0c*(-fy + e0cn*(epscder3 + epsn))) +
20548
20549
20550 sqrt(3.)*
20551
20552
20553 sqrt(k*
20554
20555
20556 pow(epsc1,
20557
20558
20559 2)*(3*k*pow(epsc1, 2)*
20560
20561
20562 pow(-(d*e0c*n0) +
20563
20564
20565 as1*d*(-(e0cn*fy) +
20566
20567
20568 e0c*(fy + e0cn*(-epscder3 + epsn))) +
20569
20570
20571 as2*(-2*ch*e0c*e0cn*epscder3 +
20572
20573
20574 d*(e0cn*fy +
20575
20576
20577 e0c*(-fy + e0cn*(epscder3 + epsn)))),
20578
20579
20580 2) - 2*(as2*ch + as1*d)*e0c*
20581
20582
20583 e0cn*(b*pow(d, 2)*e0c*fc*
20584
20585
20586 pow(epscder3 + epsn,
20587
20588
20589 2)*((6 - 9*k)*epsc1 +
20590
20591
20592 4*(-1 + k)*epscder3 +
20593
20594
20595 4*(-1 + k)*epsn) +
20596
20597
20598 6*k*pow(epsc1, 2)*
20599
20600
20601 epscder3*(d*e0c*n0 +
20602
20603
20604 as1*d*(e0cn*fy -
20605
20606
20607 e0c*(fy + e0cn*epsn)) +
20608
20609
20610 as2*(ch*e0c*e0cn*epscder3 +
20611
20612
20613 d*(-(e0cn*fy) +
20614
20615
20616 e0c*(fy - e0cn*(epscder3 +
20617
20618
20619 epsn)))))))))))/
20620
20621
20622 d)/(12.*(as2*ch + as1*d)*e0c*k*pow(epsc1, 2)) + e0c*(-(as1*(-cd + h/2.)) + as2*(-ch + h/2.))*epsn;
20623
20624
20625
20626
20627
20628 return mhmax;
20629
20630
20631 }
20632
20633
20634
20635
20636
20637
20638
20639
20640 double normmat::compute_mh8p ()
20641
20642
20643 {
20644
20645
20646 double mh8p;
20647
20648
20649
20650
20651
20652 if ((epscder3-epsch7) < 0.0 && (epscder3-epscmax1) > 0.0){
20653
20654
20655
20656
20657
20658 mh8p=mhmax;
20659
20660
20661 }
20662
20663
20664 else{
20665
20666
20667 mh8p=mhmaxa;
20668
20669
20670 }
20671
20672
20673 return mh8p;
20674
20675
20676 }
20677
20678
20679
20680
20681
20682
20683
20684
20685 double normmat::compute_epsch8p ()
20686
20687
20688 {
20689
20690
20691 double epsch8p;
20692
20693
20694
20695
20696
20697 if ((epscder3-epsch7) < 0.0 && (epscder3-epscmax1) > 0.0){
20698
20699
20700
20701
20702
20703 epsch8p=epscder3;
20704
20705
20706 }
20707
20708
20709 else{
20710
20711
20712 epsch8p=epscmax1;
20713
20714
20715 }
20716
20717
20718 return epsch8p;
20719
20720
20721 }
20722
20723
20724
20725
20726
20727
20728
20729
20730 double normmat::compute_mh8 ()
20731
20732
20733 {
20734
20735
20736 double mh8;
20737
20738
20739
20740
20741
20742 if (((epscder3-epsch7) > 0.0) || (((epscder3-epscmax1) < 0.0) && ((mh8p-mh7) < 0.0))){
20743
20744
20745
20746
20747
20748 mh8=mh7;
20749
20750
20751 }
20752
20753
20754 else{
20755
20756
20757 mh8=mh8p;
20758
20759
20760 }
20761
20762
20763 return mh8;
20764
20765
20766 }
20767
20768
20769
20770
20771
20772
20773
20774
20775 double normmat::compute_epsch8 ()
20776
20777
20778 {
20779
20780
20781 double epsch8;
20782
20783
20784
20785
20786
20787 if (((epscder3-epsch7) > 0.0) || (((epscder3-epscmax1) < 0.0) && ((mh8p-mh7) < 0.0))){
20788
20789
20790
20791
20792
20793 epsch8=epsch7;
20794
20795
20796 }
20797
20798
20799 else{
20800
20801
20802 epsch8=epsch8p;
20803
20804
20805 }
20806
20807
20808 return epsch8;
20809
20810
20811 }
20812
20813
20814
20815
20816
20817
20818
20819
20820 double normmat::compute_mh78 ()
20821
20822
20823 {
20824
20825
20826 double mh78;
20827
20828
20829
20830
20831
20832 mh78 =-(as1*(2*cd - h)*(3*d*e0c*k*n0*pow(epsc1, 2) +
20833
20834
20835 3*as1*d*k*
20836
20837
20838 pow(epsc1,
20839
20840
20841 2)*(-(e0cn*
20842
20843
20844 fy) + (e0c*(2*fy +
20845
20846
20847 e0cn*(epsch7 + epsch8 + 2*epsn)))/2.) +
20848
20849
20850 3*as2*k*pow(epsc1,
20851
20852
20853 2)*(-(d*(2*e0cn*fy +
20854
20855
20856 e0c*(-2*fy +
20857
20858
20859 e0cn*(epsch7 + epsch8 + 2*epsn))))/2. +
20860
20861
20862 ch*(-2*e0cn*fy +
20863
20864
20865 e0c*(2*fy + e0cn*(epsch7 + epsch8 + 2*epsn)))) +
20866
20867
20868 sqrt(3.)*sqrt(k*
20869
20870
20871 pow(epsc1,
20872
20873
20874 2)*((3*k*pow(epsc1, 2)*
20875
20876
20877 pow(-2*d*e0c*n0 +
20878
20879
20880 as1*d*(-2*e0cn*fy +
20881
20882
20883 e0c*(2*fy -
20884
20885
20886 e0cn*(epsch7 + epsch8 - 2*epsn))) +
20887
20888
20889 as2*(-2*ch*e0c*e0cn*(epsch7 + epsch8) +
20890
20891
20892 d*(2*e0cn*fy +
20893
20894
20895 e0c*(-2*fy +
20896
20897
20898 e0cn*(epsch7 + epsch8 + 2*epsn)))),
20899
20900
20901 2))/4. - ((as2*ch + as1*d)*e0c*
20902
20903
20904 e0cn*(b*pow(d, 2)*e0c*fc*
20905
20906
20907 pow(epsch7 + epsch8 + 2*epsn,
20908
20909
20910 2)*((6 - 9*k)*epsc1 +
20911
20912
20913 2*(-1 + k)*(epsch7 + epsch8 +
20914
20915
20916 2*epsn)) -
20917
20918
20919 6*k*pow(epsc1,
20920
20921
20922 2)*(epsch7 + epsch8)*(-2*d*e0c*n0 +
20923
20924
20925 2*as1*
20926
20927
20928 d*(-(e0cn*fy) +
20929
20930
20931 e0c*(fy + e0cn*epsn)) +
20932
20933
20934 as2*(-(ch*e0c*
20935
20936
20937 e0cn*(epsch7 + epsch8)) +
20938
20939
20940 d*(2*e0cn*fy +
20941
20942
20943 e0c*(-2*fy + e0cn*(epsch7 + epsch8 +
20944
20945
20946 2*epsn)))))))/2.))) - (as2*(2*ch -
20947
20948
20949 h)*(-3*as1*d*k*
20950
20951
20952 pow(epsc1,
20953
20954
20955 2)*(-2*d*(2*e0cn*fy +
20956
20957
20958 e0c*(-2*fy + e0cn*(epsch7 + epsch8 + 2*epsn))) +
20959
20960
20961 ch*(-2*e0cn*fy +
20962
20963
20964 e0c*(2*fy + e0cn*(epsch7 + epsch8 + 2*epsn)))) +
20965
20966
20967 ch*(6*d*e0c*k*n0*pow(epsc1, 2) +
20968
20969
20970 3*as2*d*k*
20971
20972
20973 pow(epsc1,
20974
20975
20976 2)*(2*e0cn*fy +
20977
20978
20979 e0c*(-2*fy +
20980
20981
20982 e0cn*(epsch7 + epsch8 + 2*epsn))) +
20983
20984
20985 2*sqrt(3.)*
20986
20987
20988 sqrt(k*
20989
20990
20991 pow(epsc1,
20992
20993
20994 2)*((3*k*pow(epsc1, 2)*
20995
20996
20997 pow(-2*d*e0c*n0 +
20998
20999
21000 as1*d*(-2*e0cn*fy +
21001
21002
21003 e0c*(2*fy - e0cn*(epsch7 + epsch8 -
21004
21005
21006 2*epsn))) +
21007
21008
21009 as2*(-2*ch*e0c*
21010
21011
21012 e0cn*(epsch7 + epsch8) +
21013
21014
21015 d*(2*e0cn*fy + e0c*(-2*fy +
21016
21017
21018 e0cn*(epsch7 + epsch8 + 2*epsn)))),
21019
21020
21021 2))/4. - ((as2*ch + as1*d)*e0c*
21022
21023
21024 e0cn*(b*pow(d, 2)*e0c*fc*
21025
21026
21027 pow(epsch7 + epsch8 + 2*epsn,
21028
21029
21030 2)*((6 - 9*k)*epsc1 +
21031
21032
21033 2*(-1 + k)*(epsch7 + epsch8 +
21034
21035
21036 2*epsn)) -
21037
21038
21039 6*k*pow(epsc1,
21040
21041
21042 2)*(epsch7 + epsch8)*(-2*d*e0c*n0 +
21043
21044
21045 2*as1*d*(-(e0cn*fy) +
21046
21047
21048 e0c*(fy + e0cn*epsn)) +
21049
21050
21051 as2*(-(ch*e0c*e0cn*(epsch7 +
21052
21053
21054 epsch8)) + d*(2*e0cn*fy +
21055
21056
21057 e0c*(-2*fy + e0cn*(epsch7 + epsch8 +
21058
21059
21060 2*epsn)))))))/2.)))))/(2.*
21061
21062
21063 d) + (3*b*d*pow(as2*ch + as1*d, 3)*pow(e0c, 3)*pow(e0cn, 2)*fc*
21064
21065
21066 pow(k, 2)*pow(epsc1, 4)*
21067
21068
21069 pow(epsch7 + epsch8 + 2*epsn,
21070
21071
21072 2)*(6*d*(epsch7 + epsch8 +
21073
21074
21075 2*epsn)*((4 - 6*k)*
21076
21077
21078 epsc1 + (-1 + k)*(epsch7 + epsch8 +
21079
21080
21081 2*epsn)) + (h*(3*(-2 + 3*k)*epsc1 -
21082
21083
21084 2*(-1 + k)*(epsch7 + epsch8 + 2*epsn))*(3*as2*d*
21085
21086
21087 k*pow(epsc1,
21088
21089
21090 2)*(2*e0cn*fy +
21091
21092
21093 e0c*(-2*fy +
21094
21095
21096 e0cn*(epsch7 + epsch8 + 2*epsn))) +
21097
21098
21099 3*as1*d*k*
21100
21101
21102 pow(epsc1,
21103
21104
21105 2)*(-2*e0cn*fy +
21106
21107
21108 e0c*(2*fy +
21109
21110
21111 e0cn*(epsch7 + epsch8 + 2*epsn))) -
21112
21113
21114 2*(3*d*e0c*k*n0*pow(epsc1, 2) +
21115
21116
21117 sqrt(3.)*
21118
21119
21120 sqrt(k*
21121
21122
21123 pow(epsc1,
21124
21125
21126 2)*((3*k*pow(epsc1, 2)*
21127
21128
21129 pow(-2*d*e0c*n0 +
21130
21131
21132 as1*d*(-2*e0cn*fy + e0c*(2*fy -
21133
21134
21135 e0cn*(epsch7 + epsch8 - 2*epsn))) +
21136
21137
21138 as2*(-2*ch*e0c*e0cn*(epsch7 +
21139
21140
21141 epsch8) + d*(2*e0cn*fy + e0c*(-2*fy +
21142
21143
21144 e0cn*(epsch7 + epsch8 + 2*epsn)))),
21145
21146
21147 2))/4. - ((as2*ch + as1*d)*e0c*
21148
21149
21150 e0cn*(b*pow(d, 2)*e0c*fc*
21151
21152
21153 pow(epsch7 + epsch8 + 2*epsn,
21154
21155
21156 2)*((6 - 9*k)*epsc1 +
21157
21158
21159 2*(-1 + k)*(epsch7 + epsch8 +
21160
21161
21162 2*epsn)) - 6*k*pow(epsc1,
21163
21164
21165 2)*(epsch7 + epsch8)*(-2*d*e0c*n0 +
21166
21167
21168 2*as1*d*(e0c*fy - e0cn*fy +
21169
21170
21171 e0c*e0cn*epsn) +
21172
21173
21174 as2*(-(ch*e0c*e0cn*(epsch7 +
21175
21176
21177 epsch8)) + d*(2*e0cn*fy +
21178
21179
21180 e0c*(-2*fy + e0cn*(epsch7 + epsch8 +
21181
21182
21183 2*epsn)))))))/2.)))))/((as2*ch +
21184
21185
21186 as1*d)*e0c*e0cn*k*pow(epsc1, 2))))/
21187
21188
21189 pow(6*d*e0c*k*n0*pow(epsc1, 2) -
21190
21191
21192 3*as2*d*k*
21193
21194
21195 pow(epsc1,
21196
21197
21198 2)*(2*e0cn*fy +
21199
21200
21201 e0c*(-2*fy + e0cn*(epsch7 + epsch8 + 2*epsn))) -
21202
21203
21204 3*as1*d*k*
21205
21206
21207 pow(epsc1,
21208
21209
21210 2)*(-2*e0cn*fy +
21211
21212
21213 e0c*(2*fy + e0cn*(epsch7 + epsch8 + 2*epsn))) +
21214
21215
21216 2*sqrt(3.)*
21217
21218
21219 sqrt(k*pow(epsc1,
21220
21221
21222 2)*((3*k*pow(epsc1, 2)*
21223
21224
21225 pow(-2*d*e0c*n0 +
21226
21227
21228 as1*d*(-2*e0cn*fy +
21229
21230
21231 e0c*(2*fy -
21232
21233
21234 e0cn*(epsch7 + epsch8 - 2*epsn))) +
21235
21236
21237 as2*(-2*ch*e0c*e0cn*(epsch7 + epsch8) +
21238
21239
21240 d*(2*e0cn*fy +
21241
21242
21243 e0c*(-2*fy +
21244
21245
21246 e0cn*(epsch7 + epsch8 + 2*epsn)))),
21247
21248
21249 2))/4. - ((as2*ch + as1*d)*e0c*
21250
21251
21252 e0cn*(b*pow(d, 2)*e0c*fc*
21253
21254
21255 pow(epsch7 + epsch8 + 2*epsn,
21256
21257
21258 2)*((6 - 9*k)*epsc1 +
21259
21260
21261 2*(-1 + k)*(epsch7 + epsch8 +
21262
21263
21264 2*epsn)) -
21265
21266
21267 6*k*pow(epsc1,
21268
21269
21270 2)*(epsch7 + epsch8)*(-2*d*e0c*n0 +
21271
21272
21273 2*as1*
21274
21275
21276 d*(-(e0cn*fy) +
21277
21278
21279 e0c*(fy + e0cn*epsn)) +
21280
21281
21282 as2*(-(ch*e0c*
21283
21284
21285 e0cn*(epsch7 + epsch8)) +
21286
21287
21288 d*(2*e0cn*fy +
21289
21290
21291 e0c*(-2*fy + e0cn*(epsch7 + epsch8 +
21292
21293
21294 2*epsn)))))))/2.)), 2))/(12.*(as2*ch +
21295
21296
21297 as1*d)*e0c*k*pow(epsc1, 2)) + e0c*(-(as1*(-cd + h/2.)) + as2*(-ch + h/2.))*epsn;
21298
21299
21300
21301
21302
21303 return mh78;
21304
21305
21306 }
21307
21308
21309
21310
21311
21312
21313
21314
21315 double normmat::compute_mhoc1 ()
21316
21317
21318 {
21319
21320
21321 double mhoc1;
21322
21323
21324
21325
21326
21327 mhoc1 = -(as2*(ch - d)*(fy + e0c*epsn));
21328
21329
21330
21331
21332
21333 return mhoc1;
21334
21335
21336 }
21337
21338
21339
21340
21341
21342
21343
21344
21345 double normmat::compute_mmaxoc1 ()
21346
21347
21348 {
21349
21350
21351 double mmaxoc1;
21352
21353
21354
21355
21356
21357 mmaxoc1 = -((as2*(ch - d)*(-(e0cn*fy) + pow(e0c, 2)*epsn +
21358
21359
21360 e0c*(fy + e0cn*epss1lim)))/e0c);
21361
21362
21363
21364
21365
21366 return mmaxoc1;
21367
21368
21369 }
21370
21371
21372
21373
21374
21375
21376
21377
21378 double normmat::compute_epss1oc1 ()
21379
21380
21381 {
21382
21383
21384 double epss1oc1;
21385
21386
21387
21388
21389
21390 epss1oc1 = mhoc1/(-(as1*ch*e0c) + as1*d*e0c);
21391
21392
21393
21394
21395
21396 return epss1oc1;
21397
21398
21399 }
21400
21401
21402
21403
21404
21405
21406
21407
21408 double normmat::compute_mhoc2 ()
21409
21410
21411 {
21412
21413
21414 double mhoc2;
21415
21416
21417
21418
21419
21420 mhoc2 = as1*(ch - d)*(-fy + e0c*epsn);
21421
21422
21423
21424
21425
21426 return mhoc2;
21427
21428
21429 }
21430
21431
21432
21433
21434
21435
21436
21437
21438 double normmat::compute_epss1oc2 ()
21439
21440
21441 {
21442
21443
21444 double epss1oc2;
21445
21446
21447
21448
21449
21450 epss1oc2 = -((mhoc2 - (as1*(ch - d)*(-(e0c*fy) + e0cn*fy +
21451
21452
21453 pow(e0c, 2)*epsn))/e0c)/(as1*(ch - d)*e0cn));
21454
21455
21456
21457
21458
21459 return epss1oc2;
21460
21461
21462 }
21463
21464
21465
21466
21467
21468
21469
21470
21471 double normmat::compute_mmaxoc2 ()
21472
21473
21474 {
21475
21476
21477 double mmaxoc2;
21478
21479
21480
21481
21482
21483 mmaxoc2 = (as1*(ch - d)*(e0cn*fy + pow(e0c, 2)*epsn -
21484
21485
21486 e0c*(fy + e0cn*epss1lim)))/e0c;
21487
21488
21489
21490
21491
21492 return mmaxoc2;
21493
21494
21495 }
21496
21497
21498
21499
21500
21501
21502
21503
21504 double normmat::compute_mht1 ()
21505
21506
21507 {
21508
21509
21510 double mht1;
21511
21512
21513
21514
21515
21516 if (mh1 == mhr4){
21517
21518
21519
21520
21521
21522 mht1 = mhr4;
21523
21524
21525 }
21526
21527
21528 else{
21529
21530
21531 mht1 = mhr1;
21532
21533
21534 }
21535
21536
21537 return mht1;
21538
21539
21540 }
21541
21542
21543
21544
21545
21546
21547
21548
21549 double normmat::compute_mht2 ()
21550
21551
21552 {
21553
21554
21555 double mht2;
21556
21557
21558
21559
21560
21561 if ((mh1 == mhr4) && (mhrk1 == mmax1)){
21562
21563
21564
21565
21566
21567 mht2 = mmax1;
21568
21569
21570 }
21571
21572
21573 else if ((mh1 == mhr4) && (mhrk1 == mhr4b)){
21574
21575
21576
21577
21578
21579 mht2 = mhr4b;
21580
21581
21582 }
21583
21584
21585 else if ((mh1 == mhr1) && (mh2 == mhr2)){
21586
21587
21588
21589
21590
21591 mht2 = mhr2;
21592
21593
21594 }
21595
21596
21597 else if ((mh1 == mhr1) && (mh2 == mhr3)){
21598
21599
21600
21601
21602
21603 mht2 = mhr3;
21604
21605
21606 }
21607
21608
21609 return mht2;
21610
21611
21612 }
21613
21614
21615
21616
21617
21618
21619
21620
21621 double normmat::compute_mht3 ()
21622
21623
21624 {
21625
21626
21627 double mht3;
21628
21629
21630
21631
21632
21633 if ((mh1 == mhr4) && (mhrk1 == mmax1)){
21634
21635
21636
21637
21638
21639 mht3 = mmax1;
21640
21641
21642 }
21643
21644
21645 else if ((mht2 == mhr4b) && (mh6 == mmax4)){
21646
21647
21648
21649
21650
21651 mht3 = mmax4;
21652
21653
21654 }
21655
21656
21657 else if ((mht2 == mhr4b) && (mh6 == mmax3)){
21658
21659
21660
21661
21662
21663 mht3 = mmax3;
21664
21665
21666 }
21667
21668
21669 else if ((mht2 == mhr4b) && (mh6 == mhr6)){
21670
21671
21672
21673
21674
21675 mht3 = mhr6;
21676
21677
21678 }
21679
21680
21681 else if ((mht2 == mhr2) && (mh5 == mhr5)){
21682
21683
21684
21685
21686
21687 mht3 = mhr5;
21688
21689
21690 }
21691
21692
21693 else if ((mht2 == mhr2) && (mh5 == mmax2)){
21694
21695
21696
21697
21698
21699 mht3 = mmax2;
21700
21701
21702 }
21703
21704
21705 else if ((mht2 == mhr2) && (mh5 == ms11)){
21706
21707
21708
21709
21710
21711 mht3 = ms11;
21712
21713
21714 }
21715
21716
21717 else if ((mht2 == mhr2) && (mh5 == mmax5)){
21718
21719
21720
21721
21722
21723 mht3 = mmax5;
21724
21725
21726 }
21727
21728
21729 else if ((mht2 == mhr3) && (mh6 == mhr6)){
21730
21731
21732
21733
21734
21735 mht3 = mhr6;
21736
21737
21738 }
21739
21740
21741 else if ((mht2 == mhr3) && (mh6 == mmax3)){
21742
21743
21744
21745
21746
21747 mht3 = mmax3;
21748
21749
21750 }
21751
21752
21753 else if ((mht2 == mhr3) && (mh6 == mmax4)){
21754
21755
21756
21757
21758
21759 mht3 = mmax4;
21760
21761
21762 }
21763
21764
21765 return mht3;
21766
21767
21768 }
21769
21770
21771
21772
21773
21774
21775
21776
21777 double normmat::compute_mht4 ()
21778
21779
21780 {
21781
21782
21783 double mht4;
21784
21785
21786
21787
21788
21789 if ((mht3 == mhr5) || (mht3 == mhr6)){
21790
21791
21792
21793
21794
21795 mht4 = mh8;
21796
21797
21798 }
21799
21800
21801 else if (mht2 == mmax1){
21802
21803
21804
21805
21806
21807 mht4 = mh2;
21808
21809
21810 }
21811
21812
21813 else{
21814
21815
21816 mht4 = mht3;
21817
21818
21819 }
21820
21821
21822 return mht4;
21823
21824
21825 }
21826
21827
21828
21829
21830
21831
21832
21833
21834 double normmat::compute_mmax ()
21835
21836
21837 {
21838
21839
21840 double mmax;
21841
21842
21843
21844
21845
21846 if ((mht3 == mhr5) || (mht3 == mhr6)){
21847
21848
21849
21850
21851
21852 mmax = mht4;
21853
21854
21855 }
21856
21857
21858 else if (mht2 == mmax1){
21859
21860
21861
21862
21863
21864 mmax = mht2;
21865
21866
21867 }
21868
21869
21870 else{
21871
21872
21873 mmax = mht3;
21874
21875
21876 }
21877
21878
21879 return mmax;
21880
21881
21882 }
21883
21884
21885
21886
21887
21888
21889
21890
21891 double normmat::compute_epscht1 ()
21892
21893
21894 {
21895
21896
21897 double epscht1;
21898
21899
21900
21901
21902
21903 if (mh1 == mhr4){
21904
21905
21906
21907
21908
21909 epscht1 = epschr4;
21910
21911
21912 }
21913
21914
21915 else{
21916
21917
21918 epscht1 = epschr1;
21919
21920
21921 }
21922
21923
21924 return epscht1;
21925
21926
21927 }
21928
21929
21930
21931
21932
21933
21934
21935
21936 double normmat::compute_epscht2 ()
21937
21938
21939 {
21940
21941
21942 double epscht2;
21943
21944
21945
21946
21947
21948 if ((mh1 == mhr4) && (mhrk1 == mmax1)){
21949
21950
21951
21952
21953
21954 epscht2 = epscder2;
21955
21956
21957 }
21958
21959
21960 else if ((mh1 == mhr4) && (mhrk1 == mhr4b)){
21961
21962
21963
21964
21965
21966 epscht2 = epschr4b;
21967
21968
21969 }
21970
21971
21972 else if ((mh1 == mhr1) && (mh2 == mhr2)){
21973
21974
21975
21976
21977
21978 epscht2 = epschr2;
21979
21980
21981 }
21982
21983
21984 else if ((mh1 == mhr1) && (mh2 == mhr3)){
21985
21986
21987
21988
21989
21990 epscht2 = epschr3;
21991
21992
21993 }
21994
21995
21996 return epscht2;
21997
21998
21999 }
22000
22001
22002
22003
22004
22005
22006
22007
22008 double normmat::compute_epscht3 ()
22009
22010
22011 {
22012
22013
22014 double epscht3;
22015
22016
22017
22018
22019
22020 if ((mh1 == mhr4) && (mhrk1 == mmax1)){
22021
22022
22023
22024
22025
22026 epscht3 = epscder2;
22027
22028
22029 }
22030
22031
22032 else if ((mht2 == mhr4b) && (mh6 == mmax4)){
22033
22034
22035
22036
22037
22038 epscht3 = epscder1;
22039
22040
22041 }
22042
22043
22044 else if ((mht2 == mhr4b) && (mh6 == mmax3)){
22045
22046
22047
22048
22049
22050 epscht3 = epscmax1;
22051
22052
22053 }
22054
22055
22056 else if ((mht2 == mhr4b) && (mh6 == mhr6)){
22057
22058
22059
22060
22061
22062 epscht3 = epschr6;
22063
22064
22065 }
22066
22067
22068 else if ((mht2 == mhr2) && (mh5 == mhr5)){
22069
22070
22071
22072
22073
22074 epscht3 = epschr5;
22075
22076
22077 }
22078
22079
22080 else if ((mht2 == mhr2) && (mh5 == mmax2)){
22081
22082
22083
22084
22085
22086 epscht3 = epscmax1;
22087
22088
22089 }
22090
22091
22092 else if ((mht2 == mhr2) && (mh5 == ms11)){
22093
22094
22095
22096
22097
22098 epscht3 = epscs11;
22099
22100
22101 }
22102
22103
22104 else if ((mht2 == mhr2) && (mh5 == mmax5)){
22105
22106
22107
22108
22109
22110 epscht3 = epscder4;
22111
22112
22113 }
22114
22115
22116 else if ((mht2 == mhr3) && (mh6 == mhr6)){
22117
22118
22119
22120
22121
22122 epscht3 = epschr6;
22123
22124
22125 }
22126
22127
22128 else if ((mht2 == mhr3) && (mh6 == mmax3)){
22129
22130
22131
22132
22133
22134 epscht3 = epscmax1;
22135
22136
22137 }
22138
22139
22140 else if ((mht2 == mhr3) && (mh6 == mmax4)){
22141
22142
22143
22144
22145
22146 epscht3 = epscder1;
22147
22148
22149 }
22150
22151
22152 return epscht3;
22153
22154
22155 }
22156
22157
22158
22159
22160
22161
22162
22163
22164 double normmat::compute_epscht4 ()
22165
22166
22167 {
22168
22169
22170 double epscht4;
22171
22172
22173
22174
22175
22176 if ((mht3 == mhr5) || (mht3 == mhr6)){
22177
22178
22179
22180
22181
22182 epscht4 = epsch8;
22183
22184
22185 }
22186
22187
22188 else if (epscht2 == epscmax1){
22189
22190
22191
22192
22193
22194 epscht4 = epsch2;
22195
22196
22197 }
22198
22199
22200 else{
22201
22202
22203 epscht4 = epscht3;
22204
22205
22206 }
22207
22208
22209 return epscht4;
22210
22211
22212 }
22213
22214
22215
22216
22217
22218
22219
22220
22221 double normmat::compute_epscmax ()
22222
22223
22224 {
22225
22226
22227 double epscmax;
22228
22229
22230
22231
22232
22233 if ((mht3 == mhr5) || (mht3 == mhr6)){
22234
22235
22236
22237
22238
22239 epscmax = epscht4;
22240
22241
22242 }
22243
22244
22245 else if (epscht2 == epscmax1){
22246
22247
22248
22249
22250
22251 epscmax = epscht2;
22252
22253
22254 }
22255
22256
22257 else{
22258
22259
22260 epscmax = epscht3;
22261
22262
22263 }
22264
22265
22266 return epscmax;
22267
22268
22269 }
22270
22271
22272
22273
22274
22275
22276
22277
22278 void normmat::compute_mp ()
22279 {
22280
22281 long i;
22282
22283 for (i=0;i<4;i++){
22284
22285
22286 if ((mpp[i] > mmax) && (iter <= 2)){
22287
22288
22289
22290
22291
22292 mp[i] = mmax;
22293
22294
22295 }
22296
22297
22298 else {
22299
22300
22301
22302
22303
22304 mp[i] = mpp[i];
22305
22306
22307 }
22308
22309
22310 }
22311
22312
22313 }
22314
22315
22316
22317
22318
22319
22320
22321
22322
22323 void normmat::compute_tcn ()
22324
22325
22326 {
22327
22328
22329 long i;
22330
22331
22332 for (i=0;i<4;i++){
22333
22334
22335
22336
22337
22338 if ((mp[i] > mmax) || (tcv[i] == 1.)){
22339
22340
22341
22342
22343
22344 tcn[i] = 1.;
22345
22346
22347 }
22348
22349
22350 else {
22351
22352
22353
22354
22355
22356 tcn[i] = 0.;
22357
22358
22359 }
22360
22361
22362 }
22363
22364
22365 }
22366
22367
22368
22369
22370
22371
22372
22373
22374 void normmat::compute_epscsp ()
22375
22376
22377 {
22378
22379
22380 long i;
22381
22382
22383
22384
22385
22386
22387
22388 for (i=0;i<4;i++){
22389
22390
22391 if ((mp[i] <= mht1) && (tcn[i] == 0)){
22392
22393
22394
22395
22396
22397 epscsp[i] = (4*mh01*epsch1 - mh1*epsch1 -
22398
22399
22400 epsch1*sqrt(16*pow(mh01, 2) - 8*mh01*mh1 + pow(mh1, 2) -
22401
22402
22403 16*mh01*mp[i] + 8*mh1*mp[i]))/(2.*(4*mh01 - 2*mh1));
22404
22405
22406 }
22407
22408
22409 else if ((mp[i] > mht1) && (mht1 == mhr4) && (mp[i] <= mht2) && (tcn[i] == 0)){
22410
22411
22412
22413
22414
22415 epscsp[i] = (3*mhrk1*epsch1 + mhrk1*epschrk1 - 4*mh1hrk1*(epsch1 + epschrk1) +
22416
22417
22418 mh1*(epsch1 + 3*epschrk1) + (-epsch1 + epschrk1)*
22419
22420
22421 sqrt(pow(mh1, 2) + pow(-4*mh1hrk1 + mhrk1, 2) -
22422
22423
22424 2*mh1*(4*mh1hrk1 + mhrk1 - 4*mp[i]) +
22425
22426
22427 8*(-2*mh1hrk1 + mhrk1)*mp[i]))/(4.*(mh1 - 2*mh1hrk1 + mhrk1));
22428
22429
22430 }
22431
22432
22433 else if ((mp[i] > mht2) && (mht2 == mhr4b) && (mp[i] <= mht3) && (tcn[i] == 0)){
22434
22435
22436
22437
22438
22439 epscsp[i] = (3*mh6*epsch3 + mh6*epsch6 - 4*mh36*(epsch3 + epsch6) +
22440
22441
22442 mh3*(epsch3 + 3*epsch6) + (-epsch3 + epsch6)*
22443
22444
22445 sqrt(pow(mh3, 2) + pow(-4*mh36 + mh6, 2) -
22446
22447
22448 2*mh3*(4*mh36 + mh6 - 4*mp[i]) +
22449
22450
22451 8*(-2*mh36 + mh6)*mp[i]))/(4.*(mh3 - 2*mh36 + mh6));
22452
22453
22454 }
22455
22456
22457 else if ((mp[i] > mht1) && (mht1 == mhr1) && (mp[i] <= mht2) && (tcn[i] == 0)){
22458
22459
22460
22461
22462
22463 epscsp[i] = ((-mh2 - 3*mhr1)*epsch2 - (3*mh2 + mhr1)*epschr1 +
22464
22465
22466 4*mh12*(epsch2 + epschr1) + (-epsch2 + epschr1)*
22467
22468
22469 sqrt(16*pow(mh12, 2) + pow(mh2 - mhr1, 2) + 8*(mh2 + mhr1)*mp[i] -
22470
22471
22472 8*mh12*(mh2 + mhr1 + 2*mp[i])))/(8*mh12 - 4*(mh2 + mhr1));
22473
22474
22475 }
22476
22477
22478 else if ((mp[i] > mht2) && (mht2 == mhr2) && (mp[i] <= mht3) && (tcn[i] == 0)){
22479
22480
22481
22482
22483
22484 epscsp[i] = (3*mh5*epsch2 + mh5*epsch5 - 4*mh25*(epsch2 + epsch5) +
22485
22486
22487 mh2*(epsch2 + 3*epsch5) + (-epsch2 + epsch5)*
22488
22489
22490 sqrt(pow(mh2, 2) + pow(-4*mh25 + mh5, 2) -
22491
22492
22493 2*mh2*(4*mh25 + mh5 - 4*mp[i]) +
22494
22495
22496 8*(-2*mh25 + mh5)*mp[i]))/(4.*(mh2 - 2*mh25 + mh5));
22497
22498
22499 }
22500
22501
22502 else if ((mp[i] > mht2) && (mht2 == mhr3) && (mp[i] <= mht3) && (tcn[i] == 0)){
22503
22504
22505
22506
22507
22508 epscsp[i] = (3*mh6*epsch3 + mh6*epsch6 - 4*mh36*(epsch3 + epsch6) +
22509
22510
22511 mh3*(epsch3 + 3*epsch6) + (-epsch3 + epsch6)*
22512
22513
22514 sqrt(pow(mh3, 2) + pow(-4*mh36 + mh6, 2) -
22515
22516
22517 2*mh3*(4*mh36 + mh6 - 4*mp[i]) +
22518
22519
22520 8*(-2*mh36 + mh6)*mp[i]))/(4.*(mh3 - 2*mh36 + mh6));
22521
22522
22523 }
22524
22525
22526 else if ((mp[i] > mht3) && ((mht3 == mhr6) || (mht3 == mhr5)) && (mp[i] <= mht4) && (tcn[i] == 0)){
22527
22528
22529
22530
22531
22532 epscsp[i] = (3*mh8*epsch7 + mh8*epsch8 - 4*mh78*(epsch7 + epsch8) +
22533
22534
22535 mh7*(epsch7 + 3*epsch8) + (-epsch7 + epsch8)*
22536
22537
22538 sqrt(pow(mh7, 2) + pow(-4*mh78 + mh8, 2) -
22539
22540
22541 2*mh7*(4*mh78 + mh8 - 4*mp[i]) +
22542
22543
22544 8*(-2*mh78 + mh8)*mp[i]))/(4.*(mh7 - 2*mh78 + mh8));
22545
22546
22547 }
22548
22549
22550 else {
22551
22552
22553
22554
22555
22556 epscsp[i] = 1;
22557
22558
22559 }
22560
22561
22562 }
22563
22564
22565
22566
22567
22568 }
22569
22570
22571
22572
22573
22574
22575
22576
22577
22578
22579 void normmat::compute_epss1sp ()
22580
22581
22582 {
22583
22584
22585 long i;
22586
22587
22588
22589
22590
22591
22592
22593
22594
22595
22596
22597 for (i=0;i<4;i++){
22598
22599
22600 if ((mp[i] <= mht1) && (tcn[i] == 0.)){
22601
22602
22603
22604
22605
22606 epss1sp[i] = (6*d*(as2*ch + as1*d)*e0c*k*pow(epsc1, 2) +
22607
22608
22609 b*fc*pow(h,
22610
22611
22612 2)*(8*h*(-1 + k)*epscsp[i] -
22613
22614
22615 3*d*((2 - 3*k)*epsc1 + 4*(-1 + k)*epscsp[i] + 4*(-1 + k)*epsn)) -
22616
22617
22618 sqrt(3.)*sqrt(pow(d,
22619
22620
22621 2)*(12*pow(as2*ch + as1*d, 2)*pow(e0c, 2)*pow(k, 2)*
22622
22623
22624 pow(epsc1, 4) -
22625
22626
22627 pow(b, 2)*pow(fc, 2)*
22628
22629
22630 pow(h, 4)*((6 - 9*k)*epsc1 + 4*(-1 + k)*epscsp[i] +
22631
22632
22633 4*(-1 + k)*epsn)*((-2 + 3*k)*epsc1 +
22634
22635
22636 4*(-1 + k)*epscsp[i] + 4*(-1 + k)*epsn) +
22637
22638
22639 4*b*fc*pow(h, 2)*k*
22640
22641
22642 pow(epsc1,
22643
22644
22645 2)*(3*(as2*ch + as1*d)*
22646
22647
22648 e0c*(-2*epsc1 + 3*k*epsc1 - 4*(-1 + k)*epscsp[i] +
22649
22650
22651 4*epsn - 4*k*epsn) +
22652
22653
22654 8*h*(-1 +
22655
22656
22657 k)*(-n0 + (as1 + as2)*
22658
22659
22660 e0c*(epscsp[i] + epsn))))))/(8.*b*fc*
22661
22662
22663 pow(h, 3)*(-1 + k));
22664
22665
22666 }
22667
22668 else if ((mp[i] > mht1) && (mht1 == mhr4) && (mp[i] <= mht2) && (tcn[i] == 0.)){
22669
22670
22671
22672
22673
22674 epss1sp[i] = (6*d*e0c*(as1*d*e0c + as2*ch*e0cn)*k*pow(epsc1, 2) +
22675
22676
22677 b*e0c*fc*pow(h,
22678
22679
22680 2)*(8*h*(-1 + k)*epscsp[i] -
22681
22682
22683 3*d*((2 - 3*k)*epsc1 + 4*(-1 + k)*epscsp[i] + 4*(-1 + k)*epsn)) -
22684
22685
22686 sqrt(e0c*(e0c*
22687
22688
22689 pow(6*d*(as1*d*e0c + as2*ch*e0cn)*k*pow(epsc1, 2) +
22690
22691
22692 b*fc*pow(h,
22693
22694
22695 2)*(8*h*(-1 + k)*epscsp[i] -
22696
22697
22698 3*d*((2 - 3*k)*epsc1 + 4*(-1 + k)*epscsp[i] +
22699
22700
22701 4*(-1 + k)*epsn)), 2) +
22702
22703
22704 16*b*fc*
22705
22706
22707 pow(h, 3)*(-1 +
22708
22709
22710 k)*(b*e0c*fc*
22711
22712
22713 h*(-4*pow(h, 2)*(-1 + k)*pow(epscsp[i], 2) -
22714
22715
22716 6*pow(d,
22717
22718
22719 2)*(epscsp[i] + epsn)*((2 - 3*k)*epsc1 +
22720
22721
22722 2*(-1 + k)*epscsp[i] + 2*(-1 + k)*epsn) +
22723
22724
22725 3*d*h*epscsp[i]*((2 - 3*k)*epsc1 +
22726
22727
22728 4*(-1 + k)*epscsp[i] + 4*(-1 + k)*epsn)) +
22729
22730
22731 6*d*k*pow(epsc1,
22732
22733
22734 2)*(d*e0c*(-n0 + as1*e0c*epsn) +
22735
22736
22737 as2*(-(ch*e0c*e0cn*epscsp[i]) +
22738
22739
22740 d*(e0cn*fy +
22741
22742
22743 e0c*(-fy +
22744
22745
22746 e0cn*(epscsp[i] + epsn)))))))))/(8.*b*
22747
22748
22749 e0c*fc*pow(h, 3)*(-1 + k));
22750
22751
22752 }
22753
22754 else if ((mp[i] > mht2) && (mht2 == mhr4b) && (mp[i] <= mht3) && (tcn[i] == 0.)){
22755
22756
22757
22758
22759
22760 epss1sp[i] = (3*d*e0c*k*pow(epsc1, 2)*(n0 + as1*e0c*(epscsp[i] - epsn)) +
22761
22762
22763 3*as2*k*pow(epsc1,
22764
22765
22766 2)*(2*ch*e0c*e0cn*epscsp[i] +
22767
22768
22769 d*(-(e0cn*fy) + e0c*(fy - e0cn*(epscsp[i] + epsn)))) +
22770
22771
22772 sqrt(3.)*sqrt(k*
22773
22774
22775 pow(epsc1,
22776
22777
22778 2)*(3*k*pow(epsc1, 2)*
22779
22780
22781 pow(d*e0c*(n0 + as1*e0c*(epscsp[i] - epsn)) +
22782
22783
22784 as2*(2*ch*e0c*e0cn*epscsp[i] +
22785
22786
22787 d*(-(e0cn*fy) +
22788
22789
22790 e0c*(fy - e0cn*(epscsp[i] + epsn)))), 2) +
22791
22792
22793 2*e0c*(as1*d*e0c +
22794
22795
22796 as2*ch*e0cn)*(-(b*pow(d, 2)*e0c*fc*
22797
22798
22799 pow(epscsp[i] + epsn,
22800
22801
22802 2)*((6 - 9*k)*epsc1 + 4*(-1 + k)*epscsp[i] +
22803
22804
22805 4*(-1 + k)*epsn)) +
22806
22807
22808 6*k*pow(epsc1, 2)*
22809
22810
22811 epscsp[i]*(-(as2*ch*e0c*e0cn*epscsp[i]) +
22812
22813
22814 d*(as2*e0cn*fy + as1*pow(e0c, 2)*epsn +
22815
22816
22817 e0c*(-(as2*fy) - n0 +
22818
22819
22820 as2*e0cn*(epscsp[i] + epsn))))))))/(6.*
22821
22822
22823 e0c*(as1*d*e0c + as2*ch*e0cn)*k*pow(epsc1, 2));
22824
22825
22826 }
22827
22828 else if ((mp[i] > mht1) && (mht1 == mhr1) && (mp[i] <= mht2) && (tcn[i] == 0.)){
22829
22830
22831
22832
22833
22834 epss1sp[i] = (6*as2*ch*e0c*k*pow(epsc1, 2)*epscsp[i] +
22835
22836
22837 3*d*k*pow(epsc1,
22838
22839
22840 2)*(n0 + as1*e0c*(epscsp[i] - epsn) - as2*e0c*(epscsp[i] + epsn)) +
22841
22842
22843 sqrt(3.)*sqrt(k*
22844
22845
22846 pow(epsc1,
22847
22848
22849 2)*(3*k*pow(epsc1, 2)*
22850
22851
22852 pow(-2*as2*ch*e0c*epscsp[i] +
22853
22854
22855 d*(-n0 - as1*e0c*epscsp[i] +
22856
22857
22858 as2*e0c*epscsp[i] + (as1 + as2)*e0c*epsn), 2) -
22859
22860
22861 2*(as2*ch + as1*d)*
22862
22863
22864 e0c*(b*pow(d, 2)*fc*
22865
22866
22867 pow(epscsp[i] + epsn,
22868
22869
22870 2)*((6 - 9*k)*epsc1 + 4*(-1 + k)*epscsp[i] +
22871
22872
22873 4*(-1 + k)*epsn) +
22874
22875
22876 6*k*pow(epsc1, 2)*
22877
22878
22879 epscsp[i]*(as2*ch*e0c*epscsp[i] +
22880
22881
22882 d*(n0 -
22883
22884
22885 e0c*(as2*epscsp[i] + (as1 + as2)*
22886
22887
22888 epsn)))))))/(6.*(as2*ch + as1*d)*e0c*
22889
22890
22891 k*pow(epsc1, 2));
22892
22893
22894 }
22895
22896 else if ((mp[i] > mht2) && (mht2 == mhr2) && (mp[i] <= mht3) && (tcn[i] == 0.)){
22897
22898
22899
22900
22901
22902 epss1sp[i] = (6*as2*ch*pow(e0c, 2)*k*pow(epsc1, 2)*epscsp[i] -
22903
22904
22905 3*d*k*pow(epsc1,
22906
22907
22908 2)*(-(as1*e0cn*fy) +
22909
22910
22911 e0c*(-n0 + as2*e0c*(epscsp[i] + epsn) +
22912
22913
22914 as1*(fy + e0cn*(-epscsp[i] + epsn)))) +
22915
22916
22917 sqrt(3.)*sqrt(k*
22918
22919
22920 pow(epsc1,
22921
22922
22923 2)*(3*k*pow(epsc1, 2)*
22924
22925
22926 pow(-2*as2*ch*pow(e0c, 2)*epscsp[i] +
22927
22928
22929 d*(-(as1*e0cn*fy) +
22930
22931
22932 e0c*(-n0 + as2*e0c*(epscsp[i] + epsn) +
22933
22934
22935 as1*(fy + e0cn*(-epscsp[i] + epsn)))), 2) -
22936
22937
22938 2*e0c*(as2*ch*e0c +
22939
22940
22941 as1*d*e0cn)*(b*pow(d, 2)*e0c*fc*
22942
22943
22944 pow(epscsp[i] + epsn,
22945
22946
22947 2)*((6 - 9*k)*epsc1 + 4*(-1 + k)*epscsp[i] +
22948
22949
22950 4*(-1 + k)*epsn) +
22951
22952
22953 6*k*pow(epsc1, 2)*
22954
22955
22956 epscsp[i]*(as1*d*(e0cn*fy - e0c*(fy + e0cn*epsn)) +
22957
22958
22959 e0c*(as2*ch*e0c*epscsp[i] +
22960
22961
22962 d*(n0 -
22963
22964
22965 as2*e0c*(epscsp[i] + epsn))))))))/(6.*
22966
22967
22968 e0c*(as2*ch*e0c + as1*d*e0cn)*k*pow(epsc1, 2));
22969
22970
22971 }
22972
22973 else if ((mp[i] > mht2) && (mht2 == mhr3) && (mp[i] <= mht3) && (tcn[i] == 0.)){
22974
22975
22976
22977
22978
22979 epss1sp[i] = (3*d*e0c*k*pow(epsc1, 2)*(n0 + as1*e0c*(epscsp[i] - epsn)) +
22980
22981
22982 3*as2*k*pow(epsc1,
22983
22984
22985 2)*(2*ch*e0c*e0cn*epscsp[i] +
22986
22987
22988 d*(-(e0cn*fy) + e0c*(fy - e0cn*(epscsp[i] + epsn)))) +
22989
22990
22991 sqrt(3.)*sqrt(k*
22992
22993
22994 pow(epsc1,
22995
22996
22997 2)*(3*k*pow(epsc1, 2)*
22998
22999
23000 pow(d*e0c*(n0 + as1*e0c*(epscsp[i] - epsn)) +
23001
23002
23003 as2*(2*ch*e0c*e0cn*epscsp[i] +
23004
23005
23006 d*(-(e0cn*fy) +
23007
23008
23009 e0c*(fy - e0cn*(epscsp[i] + epsn)))), 2) +
23010
23011
23012 2*e0c*(as1*d*e0c +
23013
23014
23015 as2*ch*e0cn)*(-(b*pow(d, 2)*e0c*fc*
23016
23017
23018 pow(epscsp[i] + epsn,
23019
23020
23021 2)*((6 - 9*k)*epsc1 + 4*(-1 + k)*epscsp[i] +
23022
23023
23024 4*(-1 + k)*epsn)) +
23025
23026
23027 6*k*pow(epsc1, 2)*
23028
23029
23030 epscsp[i]*(-(as2*ch*e0c*e0cn*epscsp[i]) +
23031
23032
23033 d*(as2*e0cn*fy + as1*pow(e0c, 2)*epsn +
23034
23035
23036 e0c*(-(as2*fy) - n0 +
23037
23038
23039 as2*e0cn*(epscsp[i] + epsn))))))))/(6.*
23040
23041
23042 e0c*(as1*d*e0c + as2*ch*e0cn)*k*pow(epsc1, 2));
23043
23044
23045 }
23046
23047 else if ((mp[i] > mht3) && ((mht3 == mhr6) || (mht3 == mhr5)) && (mp[i] <= mht4) && (tcn[i] == 0.)){
23048
23049
23050
23051
23052
23053 epss1sp[i] = (3*as1*d*k*pow(epsc1, 2)*(e0cn*fy - e0c*(fy + e0cn*(-epscsp[i] + epsn))) +
23054
23055
23056 3*k*pow(epsc1,
23057
23058
23059 2)*(d*e0c*n0 +
23060
23061
23062 as2*(2*ch*e0c*e0cn*epscsp[i] +
23063
23064
23065 d*(-(e0cn*fy) + e0c*(fy - e0cn*(epscsp[i] + epsn))))) +
23066
23067
23068 sqrt(3.)*sqrt(k*
23069
23070
23071 pow(epsc1,
23072
23073
23074 2)*(3*k*pow(epsc1, 2)*
23075
23076
23077 pow(-(d*e0c*n0) +
23078
23079
23080 as1*d*(-(e0cn*fy) +
23081
23082
23083 e0c*(fy - e0cn*epscsp[i] + e0cn*epsn)) +
23084
23085
23086 as2*(-2*ch*e0c*e0cn*epscsp[i] +
23087
23088
23089 d*(e0cn*fy + e0c*(-fy + e0cn*(epscsp[i] + epsn)))),
23090
23091
23092 2) - 2*(as2*ch + as1*d)*e0c*
23093
23094
23095 e0cn*(b*pow(d, 2)*e0c*fc*
23096
23097
23098 pow(epscsp[i] + epsn,
23099
23100
23101 2)*((6 - 9*k)*epsc1 + 4*(-1 + k)*epscsp[i] +
23102
23103
23104 4*(-1 + k)*epsn) +
23105
23106
23107 6*k*pow(epsc1, 2)*
23108
23109
23110 epscsp[i]*(d*e0c*n0 +
23111
23112
23113 as1*d*(e0cn*fy - e0c*(fy + e0cn*epsn)) +
23114
23115
23116 as2*(ch*e0c*e0cn*epscsp[i] +
23117
23118
23119 d*(-(e0cn*fy) +
23120
23121
23122 e0c*(fy -
23123
23124
23125 e0cn*(epscsp[i] +
23126
23127
23128 epsn)))))))))/(6.*(as2*ch + as1*d)*
23129
23130
23131 e0c*e0cn*k*pow(epsc1, 2));
23132
23133
23134 }
23135
23136 else if ((tcn[i] != 0.) && (mp[i] <= mhoc1)){
23137
23138
23139
23140
23141
23142 epss1sp[i] = mp[i]/(-(as1*ch*e0c) + as1*d*e0c);
23143
23144
23145 }
23146
23147
23148
23149
23150 else if ((tcn[i] != 0.) && (mp[i] > mhoc1) && (mp[i] <= mhoc2)){
23151
23152
23153
23154
23155
23156 epss1sp[i] = mp[i]/(-(as1*ch*e0c) + as1*d*e0c);
23157
23158
23159 }
23160
23161 else {
23162
23163
23164
23165
23166
23167 epss1sp[i] = -((-((as1*(ch - d)*(-(e0c*fy) + e0cn*fy + pow(e0c, 2)*epsn))/e0c) +
23168
23169
23170 mp[i])/(as1*(ch - d)*e0cn));
23171
23172
23173 } }
23174
23175
23176
23177
23178
23179 }
23180
23181
23182
23183
23184
23185
23186
23187
23188 void normmat::compute_a1sp ()
23189
23190
23191 {
23192
23193
23194 long i;
23195
23196
23197
23198
23199
23200
23201
23202
23203 for (i=0;i<4;i++){
23204
23205
23206 if ((mp[i] <= mht1) && (tcn[i] == 0)){
23207
23208
23209
23210
23211
23212 a1sp[i] = (4*mh01*(epsch1 - 2*epscsp[i]) + mh1*(-epsch1 + 4*epscsp[i]))/pow(epsch1, 2);
23213
23214
23215 }
23216
23217 else if ((mp[i] > mht1) && (mht1 == mhr4) && (mp[i] <= mht2) && (tcn[i] == 0)){
23218
23219
23220
23221
23222
23223 a1sp[i] = (4*mh1hrk1*(epsch1 + epschrk1 - 2*epscsp[i]) +
23224
23225
23226 mh1*(-epsch1 - 3*epschrk1 + 4*epscsp[i]) +
23227
23228
23229 mhrk1*(-3*epsch1 - epschrk1 + 4*epscsp[i]))/pow(epsch1 - epschrk1, 2);
23230
23231
23232 }
23233
23234 else if ((mp[i] > mht2) && (mht2 == mhr4b) && (mp[i] <= mht3) && (tcn[i] == 0)){
23235
23236
23237
23238
23239
23240 a1sp[i] = (4*mh36*(epsch3 + epsch6 - 2*epscsp[i]) +
23241
23242
23243 mh3*(-epsch3 - 3*epsch6 + 4*epscsp[i]) +
23244
23245
23246 mh6*(-3*epsch3 - epsch6 + 4*epscsp[i]))/pow(epsch3 - epsch6, 2);
23247
23248
23249 }
23250
23251 else if ((mp[i] > mht1) && (mht1 == mhr1) && (mp[i] <= mht2) && (tcn[i] == 0)){
23252
23253
23254
23255
23256
23257 a1sp[i] = (-(mh2*epsch2) - 3*mhr1*epsch2 - (3*mh2 + mhr1)*epschr1 +
23258
23259
23260 4*mh12*(epsch2 + epschr1 - 2*epscsp[i]) + 4*mh2*epscsp[i] +
23261
23262
23263 4*mhr1*epscsp[i])/pow(epsch2 - epschr1, 2);
23264
23265
23266 }
23267
23268 else if ((mp[i] > mht2) && (mht2 == mhr2) && (mp[i] <= mht3) && (tcn[i] == 0)){
23269
23270
23271
23272
23273
23274 a1sp[i] = (4*mh25*(epsch2 + epsch5 - 2*epscsp[i]) +
23275
23276
23277 mh2*(-epsch2 - 3*epsch5 + 4*epscsp[i]) +
23278
23279
23280 mh5*(-3*epsch2 - epsch5 + 4*epscsp[i]))/pow(epsch2 - epsch5, 2);
23281
23282
23283 }
23284
23285 else if ((mp[i] > mht2) && (mht2 == mhr3) && (mp[i] <= mht3) && (tcn[i] == 0)){
23286
23287
23288
23289
23290
23291 a1sp[i] = (4*mh36*(epsch3 + epsch6 - 2*epscsp[i]) +
23292
23293
23294 mh3*(-epsch3 - 3*epsch6 + 4*epscsp[i]) +
23295
23296
23297 mh6*(-3*epsch3 - epsch6 + 4*epscsp[i]))/pow(epsch3 - epsch6, 2);
23298
23299
23300 }
23301
23302 else if ((mp[i] > mht3) && ((mht3 == mhr6) || (mht3 == mhr5)) && (mp[i] <= mht4) && (tcn[i] == 0)){
23303
23304
23305
23306
23307
23308 a1sp[i] = (4*mh78*(epsch7 + epsch8 - 2*epscsp[i]) +
23309
23310
23311 mh7*(-epsch7 - 3*epsch8 + 4*epscsp[i]) +
23312
23313
23314 mh8*(-3*epsch7 - epsch8 + 4*epscsp[i]))/pow(epsch7 - epsch8, 2);
23315
23316
23317 }
23318
23319 else if ((tcn[i] != 0) && (mp[i] <= mhoc1)){
23320
23321
23322
23323
23324
23325 a1sp[i] = 1;
23326
23327
23328 }
23329
23330
23331 else if ((tcn[i] != 0) && (mp[i] > mhoc1) && (mp[i] <= mhoc2)){
23332
23333
23334
23335
23336
23337 a1sp[i] = 1;
23338
23339
23340 }
23341
23342 else {
23343
23344
23345
23346
23347
23348 a1sp[i] = 1;
23349
23350
23351 } }
23352
23353
23354
23355
23356
23357 }
23358
23359
23360
23361
23362
23363
23364
23365
23366 void normmat::compute_a2spp ()
23367
23368
23369 {
23370
23371
23372 long i;
23373
23374
23375
23376
23377
23378
23379 for (i=0;i<4;i++){
23380
23381
23382 if ((mp[i] <= mmax) && (tcn[i] == 0)){
23383
23384
23385
23386
23387
23388 a2spp[i] = -(a1sp[i]*epscsp[i]) + mp[i];
23389
23390
23391 }
23392
23393 else if ((tcn[i] != 0) && (mp[i] <= mhoc1)){
23394
23395
23396
23397
23398
23399 a2spp[i] = 0;
23400
23401
23402 }
23403
23404
23405 else if ((tcn[i] != 0) && (mp[i] > mhoc1) && (mp[i] <= mhoc2)){
23406
23407
23408
23409
23410
23411 a2spp[i] = 0;
23412
23413
23414 }
23415
23416 else {
23417
23418
23419
23420
23421
23422 a2spp[i] = 0;
23423
23424
23425 } }
23426
23427
23428
23429
23430
23431 }
23432
23433
23434
23435
23436
23437
23438
23439
23440 void normmat::compute_a2sp ()
23441
23442
23443 {
23444
23445
23446 long i;
23447
23448
23449
23450
23451
23452 for (i=0;i<4;i++){
23453
23454
23455 if (m[i] > 0){
23456
23457
23458
23459
23460
23461 a2sp[i] = -a2spp[i];
23462
23463
23464 }
23465
23466
23467 else {
23468
23469
23470
23471
23472
23473 a2sp[i] = a2spp[i];
23474
23475
23476 }
23477
23478
23479 }
23480
23481
23482
23483
23484
23485 }
23486
23487
23488
23489
23490
23491
23492
23493
23494
23495 void normmat::compute_b1sp ()
23496
23497
23498 {
23499
23500
23501 long i;
23502
23503
23504
23505
23506
23507
23508
23509 for (i=0;i<4;i++){
23510
23511
23512 if ((mp[i] <= mht1) && (tcn[i] == 0.)){
23513
23514
23515
23516
23517
23518 b1sp[i] = (b*fc*pow(h,
23519
23520
23521 2)*(-12*d*(-1 + k) + 8*h*(-1 + k)) - (sqrt(3.)*
23522
23523
23524 pow(d, 2)*(4*b*fc*
23525
23526
23527 pow(h, 2)*(-12*(as2*ch + as1*d)*e0c*(-1 + k) +
23528
23529
23530 8*(as1 + as2)*e0c*h*(-1 + k))*k*pow(epsc1, 2) -
23531
23532
23533 4*pow(b, 2)*pow(fc, 2)*
23534
23535
23536 pow(h, 4)*(-1 + k)*((6 - 9*k)*epsc1 + 4*(-1 + k)*epscsp[i] +
23537
23538
23539 4*(-1 + k)*epsn) -
23540
23541
23542 4*pow(b, 2)*pow(fc, 2)*
23543
23544
23545 pow(h, 4)*(-1 + k)*((-2 + 3*k)*epsc1 +
23546
23547
23548 4*(-1 + k)*epscsp[i] + 4*(-1 + k)*epsn)))/(2.*
23549
23550
23551 sqrt(pow(d,
23552
23553
23554 2)*(12*pow(as2*ch + as1*d, 2)*pow(e0c, 2)*pow(k, 2)*
23555
23556
23557 pow(epsc1, 4) -
23558
23559
23560 pow(b, 2)*pow(fc, 2)*
23561
23562
23563 pow(h, 4)*((6 - 9*k)*epsc1 + 4*(-1 + k)*epscsp[i] +
23564
23565
23566 4*(-1 + k)*epsn)*((-2 + 3*k)*epsc1 +
23567
23568
23569 4*(-1 + k)*epscsp[i] + 4*(-1 + k)*epsn) +
23570
23571
23572 4*b*fc*pow(h, 2)*k*
23573
23574
23575 pow(epsc1,
23576
23577
23578 2)*(3*(as2*ch + as1*d)*
23579
23580
23581 e0c*(-2*epsc1 + 3*k*epsc1 - 4*(-1 + k)*epscsp[i] +
23582
23583
23584 4*epsn - 4*k*epsn) +
23585
23586
23587 8*h*(-1 +
23588
23589
23590 k)*(-n0 + (as1 + as2)*
23591
23592
23593 e0c*(epscsp[i] + epsn)))))))/(8.*b*fc*
23594
23595
23596 pow(h, 3)*(-1 + k));
23597
23598
23599 }
23600
23601 else if ((mp[i] > mht1) && (mht1 == mhr4) && (mp[i] <= mht2) && (tcn[i] == 0)){
23602
23603
23604
23605
23606
23607 b1sp[i] = (b*e0c*fc*
23608
23609
23610 pow(h, 2)*(-12*d*(-1 + k) +
23611
23612
23613 8*h*(-1 + k)) - (e0c*(2*b*e0c*fc*
23614
23615
23616 pow(h, 2)*(-12*d*(-1 + k) +
23617
23618
23619 8*h*(-1 + k))*(6*d*(as1*d*e0c + as2*ch*e0cn)*k*
23620
23621
23622 pow(epsc1, 2) +
23623
23624
23625 b*fc*pow(h,
23626
23627
23628 2)*(8*h*(-1 + k)*epscsp[i] -
23629
23630
23631 3*d*((2 - 3*k)*epsc1 + 4*(-1 + k)*epscsp[i] +
23632
23633
23634 4*(-1 + k)*epsn))) +
23635
23636
23637 16*b*fc*
23638
23639
23640 pow(h, 3)*(-1 +
23641
23642
23643 k)*(6*as2*d*(-(ch*e0c*e0cn) + d*e0c*e0cn)*k*
23644
23645
23646 pow(epsc1, 2) +
23647
23648
23649 b*e0c*fc*
23650
23651
23652 h*(12*d*h*(-1 + k)*epscsp[i] -
23653
23654
23655 8*pow(h, 2)*(-1 + k)*epscsp[i] -
23656
23657
23658 12*pow(d, 2)*(-1 + k)*(epscsp[i] + epsn) -
23659
23660
23661 6*pow(d,
23662
23663
23664 2)*((2 - 3*k)*epsc1 + 2*(-1 + k)*epscsp[i] +
23665
23666
23667 2*(-1 + k)*epsn) +
23668
23669
23670 3*d*h*((2 - 3*k)*epsc1 + 4*(-1 + k)*epscsp[i] +
23671
23672
23673 4*(-1 + k)*epsn)))))/(2.*
23674
23675
23676 sqrt(e0c*(e0c*
23677
23678
23679 pow(6*d*(as1*d*e0c + as2*ch*e0cn)*k*pow(epsc1, 2) +
23680
23681
23682 b*fc*pow(h,
23683
23684
23685 2)*(8*h*(-1 + k)*epscsp[i] -
23686
23687
23688 3*d*((2 - 3*k)*epsc1 + 4*(-1 + k)*epscsp[i] +
23689
23690
23691 4*(-1 + k)*epsn)), 2) +
23692
23693
23694 16*b*fc*
23695
23696
23697 pow(h, 3)*(-1 +
23698
23699
23700 k)*(b*e0c*fc*
23701
23702
23703 h*(-4*pow(h, 2)*(-1 + k)*pow(epscsp[i], 2) -
23704
23705
23706 6*pow(d,
23707
23708
23709 2)*(epscsp[i] + epsn)*((2 - 3*k)*epsc1 +
23710
23711
23712 2*(-1 + k)*epscsp[i] +
23713
23714
23715 2*(-1 + k)*epsn) +
23716
23717
23718 3*d*h*
23719
23720
23721 epscsp[i]*((2 - 3*k)*epsc1 +
23722
23723
23724 4*(-1 + k)*epscsp[i] +
23725
23726
23727 4*(-1 + k)*epsn)) +
23728
23729
23730 6*d*k*pow(epsc1,
23731
23732
23733 2)*(d*e0c*(-n0 + as1*e0c*epsn) +
23734
23735
23736 as2*(-(ch*e0c*e0cn*epscsp[i]) +
23737
23738
23739 d*(e0cn*fy +
23740
23741
23742 e0c*(-fy +
23743
23744
23745 e0cn*(epscsp[i] + epsn))))))))))/(8.*b*
23746
23747
23748 e0c*fc*pow(h, 3)*(-1 + k));
23749
23750
23751 }
23752
23753 else if ((mp[i] > mht2) && (mht2 == mhr4b) && (mp[i] <= mht3) && (tcn[i] == 0)){
23754
23755
23756
23757
23758
23759 b1sp[i] = (3*as1*d*pow(e0c, 2)*k*pow(epsc1, 2) +
23760
23761
23762 3*as2*(2*ch*e0c*e0cn - d*e0c*e0cn)*k*
23763
23764
23765 pow(epsc1,
23766
23767
23768 2) + (sqrt(3.)*k*
23769
23770
23771 pow(epsc1,
23772
23773
23774 2)*(6*(as1*d*pow(e0c, 2) + as2*(2*ch*e0c*e0cn - d*e0c*e0cn))*k*
23775
23776
23777 pow(epsc1,
23778
23779
23780 2)*(d*e0c*(n0 + as1*e0c*(epscsp[i] - epsn)) +
23781
23782
23783 as2*(2*ch*e0c*e0cn*epscsp[i] +
23784
23785
23786 d*(-(e0cn*fy) +
23787
23788
23789 e0c*(fy - e0cn*(epscsp[i] + epsn))))) +
23790
23791
23792 2*e0c*(as1*d*e0c +
23793
23794
23795 as2*ch*e0cn)*(6*(-(as2*ch*e0c*e0cn) + as2*d*e0c*e0cn)*k*
23796
23797
23798 pow(epsc1, 2)*epscsp[i] -
23799
23800
23801 4*b*pow(d, 2)*e0c*fc*(-1 + k)*pow(epscsp[i] + epsn, 2) -
23802
23803
23804 2*b*pow(d, 2)*e0c*
23805
23806
23807 fc*(epscsp[i] + epsn)*((6 - 9*k)*epsc1 +
23808
23809
23810 4*(-1 + k)*epscsp[i] + 4*(-1 + k)*epsn) +
23811
23812
23813 6*k*pow(epsc1,
23814
23815
23816 2)*(-(as2*ch*e0c*e0cn*epscsp[i]) +
23817
23818
23819 d*(as2*e0cn*fy + as1*pow(e0c, 2)*epsn +
23820
23821
23822 e0c*(-(as2*fy) - n0 +
23823
23824
23825 as2*e0cn*(epscsp[i] + epsn)))))))/(2.*
23826
23827
23828 sqrt(k*pow(epsc1,
23829
23830
23831 2)*(3*k*pow(epsc1, 2)*
23832
23833
23834 pow(d*e0c*(n0 + as1*e0c*(epscsp[i] - epsn)) +
23835
23836
23837 as2*(2*ch*e0c*e0cn*epscsp[i] +
23838
23839
23840 d*(-(e0cn*fy) +
23841
23842
23843 e0c*(fy - e0cn*(epscsp[i] + epsn)))),
23844
23845
23846 2) + 2*
23847
23848
23849 e0c*(as1*d*e0c +
23850
23851
23852 as2*ch*
23853
23854
23855 e0cn)*(-(b*pow(d, 2)*e0c*fc*
23856
23857
23858 pow(epscsp[i] + epsn,
23859
23860
23861 2)*((6 - 9*k)*epsc1 + 4*(-1 + k)*epscsp[i] +
23862
23863
23864 4*(-1 + k)*epsn)) +
23865
23866
23867 6*k*pow(epsc1, 2)*
23868
23869
23870 epscsp[i]*(-(as2*ch*e0c*e0cn*epscsp[i]) +
23871
23872
23873 d*(as2*e0cn*fy + as1*pow(e0c, 2)*epsn +
23874
23875
23876 e0c*(-(as2*fy) - n0 +
23877
23878
23879 as2*e0cn*(epscsp[i] +
23880
23881
23882 epsn)))))))))/(6.*
23883
23884
23885 e0c*(as1*d*e0c + as2*ch*e0cn)*k*pow(epsc1, 2));
23886
23887
23888 }
23889
23890 else if ((mp[i] > mht1) && (mht1 == mhr1) && (mp[i] <= mht2) && (tcn[i] == 0)){
23891
23892
23893
23894
23895
23896 b1sp[i] = (2*as2*ch + (as1 - as2)*
23897
23898
23899 d + (sqrt(3.)*
23900
23901
23902 pow(d, 2)*(pow(as2, 2)*e0c*k*pow(epsc1, 2)*(epscsp[i] + epsn) +
23903
23904
23905 as1*(-2*b*d*
23906
23907
23908 fc*(epscsp[i] + epsn)*((2 - 3*k)*epsc1 +
23909
23910
23911 2*(-1 + k)*epscsp[i] + 2*(-1 + k)*epsn) +
23912
23913
23914 k*pow(epsc1, 2)*(-n0 + as1*e0c*(epscsp[i] + epsn))) +
23915
23916
23917 as2*(-2*b*ch*
23918
23919
23920 fc*(epscsp[i] + epsn)*((2 - 3*k)*epsc1 +
23921
23922
23923 2*(-1 + k)*epscsp[i] + 2*(-1 + k)*epsn) +
23924
23925
23926 k*pow(epsc1,
23927
23928
23929 2)*(-n0 + 2*as1*e0c*(epscsp[i] + epsn)))))/
23930
23931
23932 sqrt(k*pow(epsc1,
23933
23934
23935 2)*(3*k*pow(epsc1, 2)*
23936
23937
23938 pow(-2*as2*ch*e0c*epscsp[i] +
23939
23940
23941 d*(-n0 - as1*e0c*epscsp[i] +
23942
23943
23944 as2*e0c*epscsp[i] + (as1 + as2)*e0c*epsn), 2) -
23945
23946
23947 2*(as2*ch + as1*d)*
23948
23949
23950 e0c*(b*pow(d, 2)*fc*
23951
23952
23953 pow(epscsp[i] + epsn,
23954
23955
23956 2)*((6 - 9*k)*epsc1 + 4*(-1 + k)*epscsp[i] +
23957
23958
23959 4*(-1 + k)*epsn) +
23960
23961
23962 6*k*pow(epsc1, 2)*
23963
23964
23965 epscsp[i]*(as2*ch*e0c*epscsp[i] +
23966
23967
23968 d*(n0 -
23969
23970
23971 e0c*(as2*epscsp[i] + (as1 + as2)*
23972
23973
23974 epsn)))))))/(2.*(as2*ch + as1*d));
23975
23976
23977 }
23978
23979 else if ((mp[i] > mht2) && (mht2 == mhr2) && (mp[i] <= mht3) && (tcn[i] == 0)){
23980
23981
23982
23983
23984
23985 b1sp[i] = (6*as2*ch*pow(e0c, 2)*k*pow(epsc1, 2) -
23986
23987
23988 3*d*e0c*(as2*e0c - as1*e0cn)*k*
23989
23990
23991 pow(epsc1,
23992
23993
23994 2) + (sqrt(3.)*k*
23995
23996
23997 pow(epsc1,
23998
23999
24000 2)*(6*(-2*as2*ch*pow(e0c, 2) + d*e0c*(as2*e0c - as1*e0cn))*k*
24001
24002
24003 pow(epsc1,
24004
24005
24006 2)*(-2*as2*ch*pow(e0c, 2)*epscsp[i] +
24007
24008
24009 d*(-(as1*e0cn*fy) +
24010
24011
24012 e0c*(-n0 + as2*e0c*(epscsp[i] + epsn) +
24013
24014
24015 as1*(fy + e0cn*(-epscsp[i] + epsn)))))
24016
24017
24018 -2*e0c*(as2*ch*e0c +
24019
24020
24021 as1*d*e0cn)*(6*e0c*(as2*ch*e0c - as2*d*e0c)*k*
24022
24023
24024 pow(epsc1, 2)*epscsp[i] +
24025
24026
24027 4*b*pow(d, 2)*e0c*fc*(-1 + k)*pow(epscsp[i] + epsn, 2) +
24028
24029
24030 2*b*pow(d, 2)*e0c*
24031
24032
24033 fc*(epscsp[i] + epsn)*((6 - 9*k)*epsc1 +
24034
24035
24036 4*(-1 + k)*epscsp[i] + 4*(-1 + k)*epsn) +
24037
24038
24039 6*k*pow(epsc1,
24040
24041
24042 2)*(as1*d*(e0cn*fy - e0c*(fy + e0cn*epsn)) +
24043
24044
24045 e0c*(as2*ch*e0c*epscsp[i] +
24046
24047
24048 d*(n0 - as2*e0c*(epscsp[i] + epsn)))))))/(2.*
24049
24050
24051 sqrt(k*pow(epsc1,
24052
24053
24054 2)*(3*k*pow(epsc1, 2)*
24055
24056
24057 pow(-2*as2*ch*pow(e0c, 2)*epscsp[i] +
24058
24059
24060 d*(-(as1*e0cn*fy) +
24061
24062
24063 e0c*(-n0 + as2*e0c*(epscsp[i] + epsn) +
24064
24065
24066 as1*(fy + e0cn*(-epscsp[i] + epsn)))),
24067
24068
24069 2) - 2*
24070
24071
24072 e0c*(as2*ch*e0c +
24073
24074
24075 as1*d*e0cn)*(b*pow(d, 2)*e0c*fc*
24076
24077
24078 pow(epscsp[i] + epsn,
24079
24080
24081 2)*((6 - 9*k)*epsc1 + 4*(-1 + k)*epscsp[i] +
24082
24083
24084 4*(-1 + k)*epsn) +
24085
24086
24087 6*k*pow(epsc1, 2)*
24088
24089
24090 epscsp[i]*(as1*d*(e0cn*fy - e0c*(fy + e0cn*epsn)) +
24091
24092
24093 e0c*(as2*ch*e0c*epscsp[i] +
24094
24095
24096 d*(n0 -
24097
24098
24099 as2*e0c*(epscsp[i] + epsn)))))))))/(6.*
24100
24101
24102 e0c*(as2*ch*e0c + as1*d*e0cn)*k*pow(epsc1, 2));
24103
24104
24105 }
24106
24107 else if ((mp[i] > mht2) && (mht2 == mhr3) && (mp[i] <= mht3) && (tcn[i] == 0)){
24108
24109
24110
24111
24112
24113 b1sp[i] = (3*as1*d*pow(e0c, 2)*k*pow(epsc1, 2) +
24114
24115
24116 3*as2*(2*ch*e0c*e0cn - d*e0c*e0cn)*k*
24117
24118
24119 pow(epsc1,
24120
24121
24122 2) + (sqrt(3.)*k*
24123
24124
24125 pow(epsc1,
24126
24127
24128 2)*(6*(as1*d*pow(e0c, 2) + as2*(2*ch*e0c*e0cn - d*e0c*e0cn))*k*
24129
24130
24131 pow(epsc1,
24132
24133
24134 2)*(d*e0c*(n0 + as1*e0c*(epscsp[i] - epsn)) +
24135
24136
24137 as2*(2*ch*e0c*e0cn*epscsp[i] +
24138
24139
24140 d*(-(e0cn*fy) +
24141
24142
24143 e0c*(fy - e0cn*(epscsp[i] + epsn))))) +
24144
24145
24146 2*e0c*(as1*d*e0c +
24147
24148
24149 as2*ch*e0cn)*(6*(-(as2*ch*e0c*e0cn) + as2*d*e0c*e0cn)*k*
24150
24151
24152 pow(epsc1, 2)*epscsp[i] -
24153
24154
24155 4*b*pow(d, 2)*e0c*fc*(-1 + k)*pow(epscsp[i] + epsn, 2) -
24156
24157
24158 2*b*pow(d, 2)*e0c*
24159
24160
24161 fc*(epscsp[i] + epsn)*((6 - 9*k)*epsc1 +
24162
24163
24164 4*(-1 + k)*epscsp[i] + 4*(-1 + k)*epsn) +
24165
24166
24167 6*k*pow(epsc1,
24168
24169
24170 2)*(-(as2*ch*e0c*e0cn*epscsp[i]) +
24171
24172
24173 d*(as2*e0cn*fy + as1*pow(e0c, 2)*epsn +
24174
24175
24176 e0c*(-(as2*fy) - n0 +
24177
24178
24179 as2*e0cn*(epscsp[i] + epsn)))))))/(2.*
24180
24181
24182 sqrt(k*pow(epsc1,
24183
24184
24185 2)*(3*k*pow(epsc1, 2)*
24186
24187
24188 pow(d*e0c*(n0 + as1*e0c*(epscsp[i] - epsn)) +
24189
24190
24191 as2*(2*ch*e0c*e0cn*epscsp[i] +
24192
24193
24194 d*(-(e0cn*fy) +
24195
24196
24197 e0c*(fy - e0cn*(epscsp[i] + epsn)))),
24198
24199
24200 2) + 2*
24201
24202
24203 e0c*(as1*d*e0c +
24204
24205
24206 as2*ch*
24207
24208
24209 e0cn)*(-(b*pow(d, 2)*e0c*fc*
24210
24211
24212 pow(epscsp[i] + epsn,
24213
24214
24215 2)*((6 - 9*k)*epsc1 + 4*(-1 + k)*epscsp[i] +
24216
24217
24218 4*(-1 + k)*epsn)) +
24219
24220
24221 6*k*pow(epsc1, 2)*
24222
24223
24224 epscsp[i]*(-(as2*ch*e0c*e0cn*epscsp[i]) +
24225
24226
24227 d*(as2*e0cn*fy + as1*pow(e0c, 2)*epsn +
24228
24229
24230 e0c*(-(as2*fy) - n0 +
24231
24232
24233 as2*e0cn*(epscsp[i] +
24234
24235
24236 epsn)))))))))/(6.*
24237
24238
24239 e0c*(as1*d*e0c + as2*ch*e0cn)*k*pow(epsc1, 2));
24240
24241
24242 }
24243
24244 else if ((mp[i] > mht3) && ((mht3 == mhr6) || (mht3 == mhr5)) && (mp[i] <= mht4) && (tcn[i] == 0)){
24245
24246
24247
24248
24249
24250 b1sp[i] = (3*as1*d*e0c*e0cn*k*pow(epsc1, 2) +
24251
24252
24253 3*as2*(2*ch*e0c*e0cn - d*e0c*e0cn)*k*
24254
24255
24256 pow(epsc1,
24257
24258
24259 2) + (sqrt(3.)*k*
24260
24261
24262 pow(epsc1,
24263
24264
24265 2)*(6*(-(as1*d*e0c*e0cn) + as2*(-2*ch*e0c*e0cn + d*e0c*e0cn))*k*
24266
24267
24268 pow(epsc1,
24269
24270
24271 2)*(-(d*e0c*n0) +
24272
24273
24274 as1*d*(-(e0cn*fy) +
24275
24276
24277 e0c*(fy - e0cn*epscsp[i] + e0cn*epsn)) +
24278
24279
24280 as2*(-2*ch*e0c*e0cn*epscsp[i] +
24281
24282
24283 d*(e0cn*fy +
24284
24285
24286 e0c*(-fy + e0cn*(epscsp[i] + epsn))))) -
24287
24288
24289 2*(as2*ch + as1*d)*e0c*
24290
24291
24292 e0cn*(6*as2*(ch*e0c*e0cn - d*e0c*e0cn)*k*pow(epsc1, 2)*
24293
24294
24295 epscsp[i] +
24296
24297
24298 4*b*pow(d, 2)*e0c*fc*(-1 + k)*pow(epscsp[i] + epsn, 2) +
24299
24300
24301 2*b*pow(d, 2)*e0c*
24302
24303
24304 fc*(epscsp[i] + epsn)*((6 - 9*k)*epsc1 +
24305
24306
24307 4*(-1 + k)*epscsp[i] + 4*(-1 + k)*epsn) +
24308
24309
24310 6*k*pow(epsc1,
24311
24312
24313 2)*(d*e0c*n0 +
24314
24315
24316 as1*d*(e0cn*fy - e0c*(fy + e0cn*epsn)) +
24317
24318
24319 as2*(ch*e0c*e0cn*epscsp[i] +
24320
24321
24322 d*(-(e0cn*fy) +
24323
24324
24325 e0c*(fy -
24326
24327
24328 e0cn*(epscsp[i] + epsn))))))))/(2.*
24329
24330
24331 sqrt(k*pow(epsc1,
24332
24333
24334 2)*(3*k*pow(epsc1, 2)*
24335
24336
24337 pow(-(d*e0c*n0) +
24338
24339
24340 as1*d*(-(e0cn*fy) +
24341
24342
24343 e0c*(fy - e0cn*epscsp[i] + e0cn*epsn)) +
24344
24345
24346 as2*(-2*ch*e0c*e0cn*epscsp[i] +
24347
24348
24349 d*(e0cn*fy +
24350
24351
24352 e0c*(-fy + e0cn*(epscsp[i] + epsn)))),
24353
24354
24355 2) - 2*(as2*ch + as1*d)*e0c*
24356
24357
24358 e0cn*(b*pow(d, 2)*e0c*fc*
24359
24360
24361 pow(epscsp[i] + epsn,
24362
24363
24364 2)*((6 - 9*k)*epsc1 + 4*(-1 + k)*epscsp[i] +
24365
24366
24367 4*(-1 + k)*epsn) +
24368
24369
24370 6*k*pow(epsc1, 2)*
24371
24372
24373 epscsp[i]*(d*e0c*n0 +
24374
24375
24376 as1*d*(e0cn*fy - e0c*(fy + e0cn*epsn)) +
24377
24378
24379 as2*(ch*e0c*e0cn*epscsp[i] +
24380
24381
24382 d*(-(e0cn*fy) +
24383
24384
24385 e0c*(fy -
24386
24387
24388 e0cn*(epscsp[i] +
24389
24390
24391 epsn))))))))))/(6.*(as2*ch + as1*d)*
24392
24393
24394 e0c*e0cn*k*pow(epsc1, 2));
24395
24396
24397 }
24398
24399 else if ((tcn[i] != 0) && (mp[i] <= mhoc1)){
24400
24401
24402
24403
24404
24405 b1sp[i] = 1/(-(as1*ch*e0c) + as1*d*e0c);
24406
24407
24408 }
24409
24410
24411 else if ((tcn[i] != 0) && (mp[i] > mhoc1) && (mp[i] <= mhoc2)){
24412
24413
24414
24415
24416
24417 b1sp[i] = 1/(-(as1*ch*e0c) + as1*d*e0c);
24418
24419
24420 }
24421
24422 else {
24423
24424
24425
24426
24427
24428 b1sp[i] = 1/(-(as1*ch*e0c) + as1*d*e0c);
24429
24430
24431 } }
24432
24433
24434 }
24435
24436
24437
24438
24439
24440
24441
24442
24443 void normmat::compute_b2spp ()
24444
24445
24446 {
24447
24448
24449 long i;
24450
24451
24452
24453
24454
24455
24456
24457
24458
24459
24460
24461 for (i=0;i<4;i++){
24462
24463
24464 if ((mp[i] <= mht1) && (tcn[i] == 0.)){
24465
24466
24467
24468
24469
24470 b2spp[i] = -(b1sp[i]*epscsp[i]) + (6*d*(as2*ch + as1*d)*e0c*k*pow(epsc1, 2) +
24471
24472
24473 b*fc*pow(h,
24474
24475
24476 2)*(8*h*(-1 + k)*epscsp[i] -
24477
24478
24479 3*d*((2 - 3*k)*epsc1 + 4*(-1 + k)*epscsp[i] + 4*(-1 + k)*epsn)) -
24480
24481
24482 sqrt(3.)*
24483
24484
24485 sqrt(pow(d,
24486
24487
24488 2)*(12*pow(as2*ch + as1*d, 2)*pow(e0c, 2)*pow(k, 2)*
24489
24490
24491 pow(epsc1, 4) -
24492
24493
24494 pow(b, 2)*pow(fc, 2)*
24495
24496
24497 pow(h, 4)*((6 - 9*k)*epsc1 + 4*(-1 + k)*epscsp[i] +
24498
24499
24500 4*(-1 + k)*epsn)*((-2 + 3*k)*epsc1 +
24501
24502
24503 4*(-1 + k)*epscsp[i] + 4*(-1 + k)*epsn) +
24504
24505
24506 4*b*fc*pow(h, 2)*k*
24507
24508
24509 pow(epsc1,
24510
24511
24512 2)*(3*(as2*ch + as1*d)*
24513
24514
24515 e0c*(-2*epsc1 + 3*k*epsc1 - 4*(-1 + k)*epscsp[i] +
24516
24517
24518 4*epsn - 4*k*epsn) +
24519
24520
24521 8*h*(-1 +
24522
24523
24524 k)*(-n0 + (as1 + as2)*
24525
24526
24527 e0c*(epscsp[i] + epsn))))))/(8.*b*fc*
24528
24529
24530 pow(h, 3)*(-1 + k));
24531
24532
24533 }
24534
24535 else if ((mp[i] > mht1) && (mht1 == mhr4) && (mp[i] <= mht2) && (tcn[i] == 0.)){
24536
24537
24538
24539
24540
24541 b2spp[i] = -(b1sp[i]*epscsp[i]) + (6*d*e0c*(as1*d*e0c + as2*ch*e0cn)*k*pow(epsc1, 2) +
24542
24543
24544 b*e0c*fc*
24545
24546
24547 pow(h, 2)*(8*h*(-1 + k)*epscsp[i] -
24548
24549
24550 3*d*((2 - 3*k)*epsc1 + 4*(-1 + k)*epscsp[i] + 4*(-1 + k)*epsn)) -
24551
24552
24553 sqrt(e0c*(e0c*
24554
24555
24556 pow(6*d*(as1*d*e0c + as2*ch*e0cn)*k*pow(epsc1, 2) +
24557
24558
24559 b*fc*pow(h,
24560
24561
24562 2)*(8*h*(-1 + k)*epscsp[i] -
24563
24564
24565 3*d*((2 - 3*k)*epsc1 + 4*(-1 + k)*epscsp[i] +
24566
24567
24568 4*(-1 + k)*epsn)), 2) +
24569
24570
24571 16*b*fc*
24572
24573
24574 pow(h, 3)*(-1 +
24575
24576
24577 k)*(b*e0c*fc*
24578
24579
24580 h*(-4*pow(h, 2)*(-1 + k)*pow(epscsp[i], 2) -
24581
24582
24583 6*pow(d,
24584
24585
24586 2)*(epscsp[i] + epsn)*((2 - 3*k)*epsc1 +
24587
24588
24589 2*(-1 + k)*epscsp[i] + 2*(-1 + k)*epsn) +
24590
24591
24592 3*d*h*epscsp[i]*((2 - 3*k)*epsc1 +
24593
24594
24595 4*(-1 + k)*epscsp[i] + 4*(-1 + k)*epsn)) +
24596
24597
24598 6*d*k*pow(epsc1,
24599
24600
24601 2)*(d*e0c*(-n0 + as1*e0c*epsn) +
24602
24603
24604 as2*(-(ch*e0c*e0cn*epscsp[i]) +
24605
24606
24607 d*(e0cn*fy +
24608
24609
24610 e0c*(-fy +
24611
24612
24613 e0cn*(epscsp[i] + epsn)))))))))/(8.*b*
24614
24615
24616 e0c*fc*pow(h, 3)*(-1 + k));
24617
24618
24619 }
24620
24621 else if ((mp[i] > mht2) && (mht2 == mhr4b) && (mp[i] <= mht3) && (tcn[i] == 0.)){
24622
24623
24624
24625
24626
24627 b2spp[i] = -(b1sp[i]*epscsp[i]) + (3*d*e0c*k*pow(epsc1, 2)*(n0 + as1*e0c*(epscsp[i] - epsn)) +
24628
24629
24630 3*as2*k*pow(epsc1,
24631
24632
24633 2)*(2*ch*e0c*e0cn*epscsp[i] +
24634
24635
24636 d*(-(e0cn*fy) + e0c*(fy - e0cn*(epscsp[i] + epsn)))) +
24637
24638
24639 sqrt(3.)*sqrt(k*
24640
24641
24642 pow(epsc1,
24643
24644
24645 2)*(3*k*pow(epsc1, 2)*
24646
24647
24648 pow(d*e0c*(n0 + as1*e0c*(epscsp[i] - epsn)) +
24649
24650
24651 as2*(2*ch*e0c*e0cn*epscsp[i] +
24652
24653
24654 d*(-(e0cn*fy) +
24655
24656
24657 e0c*(fy - e0cn*(epscsp[i] + epsn)))), 2) +
24658
24659
24660 2*e0c*(as1*d*e0c +
24661
24662
24663 as2*ch*
24664
24665
24666 e0cn)*(-(b*pow(d, 2)*e0c*fc*
24667
24668
24669 pow(epscsp[i] + epsn,
24670
24671
24672 2)*((6 - 9*k)*epsc1 + 4*(-1 + k)*epscsp[i] +
24673
24674
24675 4*(-1 + k)*epsn)) +
24676
24677
24678 6*k*pow(epsc1, 2)*
24679
24680
24681 epscsp[i]*(-(as2*ch*e0c*e0cn*epscsp[i]) +
24682
24683
24684 d*(as2*e0cn*fy + as1*pow(e0c, 2)*epsn +
24685
24686
24687 e0c*(-(as2*fy) - n0 +
24688
24689
24690 as2*e0cn*(epscsp[i] + epsn))))))))/(6.*
24691
24692
24693 e0c*(as1*d*e0c + as2*ch*e0cn)*k*pow(epsc1, 2));
24694
24695
24696 }
24697
24698 else if ((mp[i] > mht1) && (mht1 == mhr1) && (mp[i] <= mht2) && (tcn[i] == 0.)){
24699
24700
24701
24702
24703
24704 b2spp[i] = -(b1sp[i]*epscsp[i]) + (6*as2*ch*e0c*k*pow(epsc1, 2)*epscsp[i] +
24705
24706
24707 3*d*k*pow(epsc1,
24708
24709
24710 2)*(n0 + as1*e0c*(epscsp[i] - epsn) - as2*e0c*(epscsp[i] + epsn)) +
24711
24712
24713 sqrt(3.)*sqrt(k*
24714
24715
24716 pow(epsc1,
24717
24718
24719 2)*(3*k*pow(epsc1, 2)*
24720
24721
24722 pow(-2*as2*ch*e0c*epscsp[i] +
24723
24724
24725 d*(-n0 - as1*e0c*epscsp[i] +
24726
24727
24728 as2*e0c*epscsp[i] + (as1 + as2)*e0c*epsn), 2) -
24729
24730
24731 2*(as2*ch + as1*d)*
24732
24733
24734 e0c*(b*pow(d, 2)*fc*
24735
24736
24737 pow(epscsp[i] + epsn,
24738
24739
24740 2)*((6 - 9*k)*epsc1 + 4*(-1 + k)*epscsp[i] +
24741
24742
24743 4*(-1 + k)*epsn) +
24744
24745
24746 6*k*pow(epsc1, 2)*
24747
24748
24749 epscsp[i]*(as2*ch*e0c*epscsp[i] +
24750
24751
24752 d*(n0 -
24753
24754
24755 e0c*(as2*epscsp[i] + (as1 + as2)*
24756
24757
24758 epsn)))))))/(6.*(as2*ch + as1*d)*e0c*
24759
24760
24761 k*pow(epsc1, 2));
24762
24763
24764 }
24765
24766 else if ((mp[i] > mht2) && (mht2 == mhr2) && (mp[i] <= mht3) && (tcn[i] == 0.)){
24767
24768
24769
24770
24771
24772 b2spp[i] = -(b1sp[i]*epscsp[i]) + (6*as2*ch*pow(e0c, 2)*k*pow(epsc1, 2)*epscsp[i] -
24773
24774
24775 3*d*k*pow(epsc1,
24776
24777
24778 2)*(-(as1*e0cn*fy) +
24779
24780
24781 e0c*(-n0 + as2*e0c*(epscsp[i] + epsn) +
24782
24783
24784 as1*(fy + e0cn*(-epscsp[i] + epsn)))) +
24785
24786
24787 sqrt(3.)*sqrt(k*
24788
24789
24790 pow(epsc1,
24791
24792
24793 2)*(3*k*pow(epsc1, 2)*
24794
24795
24796 pow(-2*as2*ch*pow(e0c, 2)*epscsp[i] +
24797
24798
24799 d*(-(as1*e0cn*fy) +
24800
24801
24802 e0c*(-n0 + as2*e0c*(epscsp[i] + epsn) +
24803
24804
24805 as1*(fy + e0cn*(-epscsp[i] + epsn)))),
24806
24807
24808 2) - 2*e0c*(as2*ch*e0c +
24809
24810
24811 as1*d*e0cn)*(b*pow(d, 2)*e0c*fc*
24812
24813
24814 pow(epscsp[i] + epsn,
24815
24816
24817 2)*((6 - 9*k)*epsc1 + 4*(-1 + k)*epscsp[i] +
24818
24819
24820 4*(-1 + k)*epsn) +
24821
24822
24823 6*k*pow(epsc1, 2)*
24824
24825
24826 epscsp[i]*(as1*d*(e0cn*fy - e0c*(fy + e0cn*epsn)) +
24827
24828
24829 e0c*(as2*ch*e0c*epscsp[i] +
24830
24831
24832 d*(n0 -
24833
24834
24835 as2*e0c*(epscsp[i] + epsn))))))))/(6.*
24836
24837
24838 e0c*(as2*ch*e0c + as1*d*e0cn)*k*pow(epsc1, 2));
24839
24840
24841 }
24842
24843 else if ((mp[i] > mht2) && (mht2 == mhr3) && (mp[i] <= mht3) && (tcn[i] == 0.)){
24844
24845
24846
24847
24848
24849 b2spp[i] = -(b1sp[i]*epscsp[i]) + (3*d*e0c*k*pow(epsc1, 2)*(n0 + as1*e0c*(epscsp[i] - epsn)) +
24850
24851
24852 3*as2*k*pow(epsc1,
24853
24854
24855 2)*(2*ch*e0c*e0cn*epscsp[i] +
24856
24857
24858 d*(-(e0cn*fy) + e0c*(fy - e0cn*(epscsp[i] + epsn)))) +
24859
24860
24861 sqrt(3.)*sqrt(k*
24862
24863
24864 pow(epsc1,
24865
24866
24867 2)*(3*k*pow(epsc1, 2)*
24868
24869
24870 pow(d*e0c*(n0 + as1*e0c*(epscsp[i] - epsn)) +
24871
24872
24873 as2*(2*ch*e0c*e0cn*epscsp[i] +
24874
24875
24876 d*(-(e0cn*fy) +
24877
24878
24879 e0c*(fy - e0cn*(epscsp[i] + epsn)))), 2) +
24880
24881
24882 2*e0c*(as1*d*e0c +
24883
24884
24885 as2*ch*
24886
24887
24888 e0cn)*(-(b*pow(d, 2)*e0c*fc*
24889
24890
24891 pow(epscsp[i] + epsn,
24892
24893
24894 2)*((6 - 9*k)*epsc1 + 4*(-1 + k)*epscsp[i] +
24895
24896
24897 4*(-1 + k)*epsn)) +
24898
24899
24900 6*k*pow(epsc1, 2)*
24901
24902
24903 epscsp[i]*(-(as2*ch*e0c*e0cn*epscsp[i]) +
24904
24905
24906 d*(as2*e0cn*fy + as1*pow(e0c, 2)*epsn +
24907
24908
24909 e0c*(-(as2*fy) - n0 +
24910
24911
24912 as2*e0cn*(epscsp[i] + epsn))))))))/(6.*
24913
24914
24915 e0c*(as1*d*e0c + as2*ch*e0cn)*k*pow(epsc1, 2));
24916
24917
24918 }
24919
24920 else if ((mp[i] > mht3) && ((mht3 == mhr6) || (mht3 == mhr5)) && (mp[i] <= mht4) && (tcn[i] == 0.)){
24921
24922
24923
24924
24925
24926 b2spp[i] = -(b1sp[i]*epscsp[i]) + (3*as1*d*k*
24927
24928
24929 pow(epsc1, 2)*(e0cn*fy - e0c*(fy + e0cn*(-epscsp[i] + epsn))) +
24930
24931
24932 3*k*pow(epsc1,
24933
24934
24935 2)*(d*e0c*n0 +
24936
24937
24938 as2*(2*ch*e0c*e0cn*epscsp[i] +
24939
24940
24941 d*(-(e0cn*fy) + e0c*(fy - e0cn*(epscsp[i] + epsn))))) +
24942
24943
24944 sqrt(3.)*sqrt(k*
24945
24946
24947 pow(epsc1,
24948
24949
24950 2)*(3*k*pow(epsc1, 2)*
24951
24952
24953 pow(-(d*e0c*n0) +
24954
24955
24956 as1*d*(-(e0cn*fy) +
24957
24958
24959 e0c*(fy - e0cn*epscsp[i] + e0cn*epsn)) +
24960
24961
24962 as2*(-2*ch*e0c*e0cn*epscsp[i] +
24963
24964
24965 d*(e0cn*fy +
24966
24967
24968 e0c*(-fy + e0cn*(epscsp[i] + epsn)))),
24969
24970
24971 2) - 2*(as2*ch + as1*d)*e0c*
24972
24973
24974 e0cn*(b*pow(d, 2)*e0c*fc*
24975
24976
24977 pow(epscsp[i] + epsn,
24978
24979
24980 2)*((6 - 9*k)*epsc1 + 4*(-1 + k)*epscsp[i] +
24981
24982
24983 4*(-1 + k)*epsn) +
24984
24985
24986 6*k*pow(epsc1, 2)*
24987
24988
24989 epscsp[i]*(d*e0c*n0 +
24990
24991
24992 as1*d*(e0cn*fy - e0c*(fy + e0cn*epsn)) +
24993
24994
24995 as2*(ch*e0c*e0cn*epscsp[i] +
24996
24997
24998 d*(-(e0cn*fy) +
24999
25000
25001 e0c*(fy -
25002
25003
25004 e0cn*(epscsp[i] +
25005
25006
25007 epsn)))))))))/(6.*(as2*ch + as1*d)*
25008
25009
25010 e0c*e0cn*k*pow(epsc1, 2));
25011
25012
25013 }
25014
25015 else if ((tcn[i] != 0.) && (mp[i] <= mhoc1)){
25016
25017
25018
25019
25020
25021 b2spp[i] = 0;
25022
25023
25024 }
25025
25026
25027
25028 else if ((tcn[i] != 0.) && (mp[i] > mhoc1) && (mp[i] <= mhoc2)){
25029
25030
25031
25032
25033
25034 b2spp[i] = 0;
25035
25036
25037 }
25038
25039 else {
25040
25041
25042
25043
25044
25045 b2spp[i] = fy/e0c - fy/e0cn + (e0c*epsn)/e0cn;
25046
25047
25048 } }
25049
25050
25051
25052
25053
25054 }
25055
25056
25057
25058
25059
25060
25061
25062
25063 void normmat::compute_b2sp ()
25064
25065
25066 {
25067
25068
25069 long i;
25070
25071
25072
25073
25074 for (i=0;i<4;i++){
25075
25076
25077 if (m[i] > 0.){
25078
25079
25080
25081
25082
25083 b2sp[i] = -b2spp[i];
25084
25085
25086 }
25087
25088
25089 else {
25090
25091
25092
25093
25094
25095 b2sp[i] = b2spp[i];
25096
25097
25098 }
25099
25100
25101 }
25102
25103
25104
25105
25106
25107 }
25108
25109
25110
25111
25112
25113
25114
25115
25116
25117 void normmat::compute_mr ()
25118
25119
25120 {
25121
25122
25123 long i;
25124
25125
25126
25127
25128
25129
25130 for (i=0;i<4;i++){
25131
25132
25133 if ((mp[i] <= mht1) && (tcn[i] == 0.)){
25134
25135
25136
25137
25138
25139 mr[i] = 0.0;
25140
25141
25142 }
25143
25144 else if ((mp[i] > mht1) && (mht1 == mhr4) && (mp[i] <= mht2) && (tcn[i] == 0.)){
25145
25146
25147
25148
25149
25150 mr[i] = mh1;
25151
25152
25153 }
25154
25155 else if ((mp[i] > mht2) && (mht2 == mhr4b) && (mp[i] <= mht3) && (tcn[i] == 0.)){
25156
25157
25158
25159
25160
25161 mr[i] = mh3;
25162
25163
25164 }
25165
25166 else if ((mp[i] > mht1) && (mht1 == mhr1) && (mp[i] <= mht2) && (tcn[i] == 0.)){
25167
25168
25169
25170
25171
25172 mr[i] = mhr1;
25173
25174
25175 }
25176
25177 else if ((mp[i] > mht2) && (mht2 == mhr2) && (mp[i] <= mht3) && (tcn[i] == 0.)){
25178
25179
25180
25181
25182
25183 mr[i] = mh2;
25184
25185
25186 }
25187
25188 else if ((mp[i] > mht2) && (mht2 == mhr3) && (mp[i] <= mht3) && (tcn[i] == 0.)){
25189
25190
25191
25192
25193
25194 mr[i] = mh3;
25195
25196
25197 }
25198
25199 else if ((mp[i] > mht3) && ((mht3 == mhr6) || (mht3 == mhr5)) && (mp[i] <= mht4) && (tcn[i] == 0.)){
25200
25201
25202
25203
25204
25205 mr[i] = mh7;
25206
25207
25208 }
25209
25210 else if ((tcn[i] != 0.) && (mp[i] <= mhoc1)){
25211
25212
25213
25214
25215
25216 mr[i] = 0.;
25217
25218
25219 }
25220
25221
25222 else if ((tcn[i] != 0.) && (mp[i] > mhoc1) && (mp[i] <= mhoc2)){
25223
25224
25225
25226
25227
25228 mr[i] = mhoc1;
25229
25230
25231 }
25232
25233 else {
25234
25235
25236
25237
25238
25239 mr[i] = mhoc2;
25240
25241
25242 } }
25243
25244
25245
25246
25247
25248
25249
25250
25251 }
25252
25253
25254
25255
25256
25257
25258
25259
25260
25261
25262
25263 void normmat::compute_epscr ()
25264
25265
25266 {
25267
25268
25269 long i;
25270
25271
25272
25273
25274
25275
25276
25277
25278
25279
25280 for (i=0;i<4;i++){
25281
25282
25283 if ((mp[i] <= mht1) && (tcn[i] == 0.)){
25284
25285
25286
25287
25288
25289 epscr[i] = 0.0;
25290
25291
25292 }
25293
25294 else if ((mp[i] > mht1) && (mht1 == mhr4) && (mp[i] <= mht2) && (tcn[i] == 0.)){
25295
25296
25297
25298
25299
25300 epscr[i] = epsch1;
25301
25302
25303 }
25304
25305 else if ((mp[i] > mht2) && (mht2 == mhr4b) && (mp[i] <= mht3) && (tcn[i] == 0.)){
25306
25307
25308
25309
25310
25311 epscr[i] = epsch3;
25312
25313
25314 }
25315
25316 else if ((mp[i] > mht1) && (mht1 == mhr1) && (mp[i] <= mht2) && (tcn[i] == 0.)){
25317
25318
25319
25320
25321
25322 epscr[i] = epschr1;
25323
25324
25325 }
25326
25327 else if ((mp[i] > mht2) && (mht2 == mhr2) && (mp[i] <= mht3) && (tcn[i] == 0.)){
25328
25329
25330
25331
25332
25333 epscr[i] = epsch2;
25334
25335
25336 }
25337
25338 else if ((mp[i] > mht2) && (mht2 == mhr3) && (mp[i] <= mht3) && (tcn[i] == 0.)){
25339
25340
25341
25342
25343
25344 epscr[i] = epsch3;
25345
25346
25347 }
25348
25349 else if ((mp[i] > mht3) && ((mht3 == mhr6) || (mht3 == mhr5)) && (mp[i] <= mht4) && (tcn[i] == 0.)){
25350
25351
25352
25353
25354
25355 epscr[i] = epsch7;
25356
25357
25358 }
25359
25360 else if ((tcn[i] != 0.) && (mp[i] <= mhoc1)){
25361
25362
25363
25364
25365
25366 epscr[i] = 0;
25367
25368
25369 }
25370
25371
25372 else if ((tcn[i] != 0.) && (mp[i] > mhoc1) && (mp[i] <= mhoc2)){
25373
25374
25375
25376
25377
25378 epscr[i] = 0;
25379
25380
25381 }
25382
25383 else {
25384
25385
25386
25387
25388
25389 epscr[i] = 0;
25390
25391
25392 } }
25393
25394
25395
25396
25397
25398 }
25399
25400
25401
25402
25403
25404
25405
25406
25407 void normmat::compute_epss1r ()
25408
25409
25410 {
25411
25412
25413 long i;
25414
25415
25416
25417
25418
25419
25420 for (i=0;i<4;i++){
25421
25422
25423 if ((mp[i] <= mht1) && (tcn[i] == 0.)){
25424
25425
25426
25427
25428
25429 epss1r[i] = (6*d*(as2*ch + as1*d)*e0c*k*pow(epsc1, 2) +
25430
25431
25432 b*fc*pow(h,
25433
25434
25435 2)*(8*h*(-1 + k)*epscr[i] -
25436
25437
25438 3*d*(4*(-1 + k)*epscr[i] + (2 - 3*k)*epsc1 + 4*(-1 + k)*epsn)) -
25439
25440
25441 sqrt(3.)*sqrt(pow(d,
25442
25443
25444 2)*(12*pow(as2*ch + as1*d, 2)*pow(e0c, 2)*pow(k, 2)*
25445
25446
25447 pow(epsc1, 4) -
25448
25449
25450 pow(b, 2)*pow(fc, 2)*
25451
25452
25453 pow(h, 4)*(4*(-1 + k)*epscr[i] + (6 - 9*k)*epsc1 +
25454
25455
25456 4*(-1 + k)*epsn)*(4*(-1 + k)*epscr[i] + (-2 + 3*k)*
25457
25458
25459 epsc1 + 4*(-1 + k)*epsn) +
25460
25461
25462 4*b*fc*pow(h, 2)*k*
25463
25464
25465 pow(epsc1,
25466
25467
25468 2)*(3*(as2*ch + as1*d)*
25469
25470
25471 e0c*(-4*(-1 + k)*epscr[i] - 2*epsc1 + 3*k*epsc1 +
25472
25473
25474 4*epsn - 4*k*epsn) +
25475
25476
25477 8*h*(-1 +
25478
25479
25480 k)*(-n0 + (as1 + as2)*
25481
25482
25483 e0c*(epscr[i] + epsn))))))/(8.*b*fc*
25484
25485
25486 pow(h, 3)*(-1 + k));
25487
25488
25489 }
25490
25491 else if ((mp[i] > mht1) && (mht1 == mhr4) && (mp[i] <= mht2) && (tcn[i] == 0.)){
25492
25493
25494
25495
25496
25497 epss1r[i] = (6*d*e0c*(as1*d*e0c + as2*ch*e0cn)*k*pow(epsc1, 2) +
25498
25499
25500 b*e0c*fc*pow(h,
25501
25502
25503 2)*(8*h*(-1 + k)*epscr[i] -
25504
25505
25506 3*d*(4*(-1 + k)*epscr[i] + (2 - 3*k)*epsc1 + 4*(-1 + k)*epsn)) -
25507
25508
25509 sqrt(e0c*(e0c*
25510
25511
25512 pow(6*d*(as1*d*e0c + as2*ch*e0cn)*k*pow(epsc1, 2) +
25513
25514
25515 b*fc*pow(h,
25516
25517
25518 2)*(8*h*(-1 + k)*epscr[i] -
25519
25520
25521 3*d*(4*(-1 + k)*epscr[i] + (2 - 3*k)*epsc1 +
25522
25523
25524 4*(-1 + k)*epsn)), 2) +
25525
25526
25527 16*b*fc*
25528
25529
25530 pow(h, 3)*(-1 +
25531
25532
25533 k)*(b*e0c*fc*
25534
25535
25536 h*(-4*pow(h, 2)*(-1 + k)*pow(epscr[i], 2) -
25537
25538
25539 6*pow(d,
25540
25541
25542 2)*(epscr[i] +
25543
25544
25545 epsn)*(2*(-1 + k)*epscr[i] + (2 - 3*k)*epsc1 +
25546
25547
25548 2*(-1 + k)*epsn) +
25549
25550
25551 3*d*h*epscr[i]*(4*(-1 + k)*epscr[i] + (2 - 3*k)*epsc1 +
25552
25553
25554 4*(-1 + k)*epsn)) +
25555
25556
25557 6*d*k*pow(epsc1,
25558
25559
25560 2)*(d*e0c*(-n0 + as1*e0c*epsn) +
25561
25562
25563 as2*(-(ch*e0c*e0cn*epscr[i]) +
25564
25565
25566 d*(e0cn*fy +
25567
25568
25569 e0c*(-fy +
25570
25571
25572 e0cn*(epscr[i] + epsn)))))))))/(8.*b*e0c*
25573
25574
25575 fc*pow(h, 3)*(-1 + k));
25576
25577
25578 }
25579
25580 else if ((mp[i] > mht2) && (mht2 == mhr4b) && (mp[i] <= mht3) && (tcn[i] == 0.)){
25581
25582
25583
25584
25585
25586 epss1r[i] = (3*d*e0c*k*pow(epsc1, 2)*(n0 + as1*e0c*(epscr[i] - epsn)) +
25587
25588
25589 3*as2*k*pow(epsc1,
25590
25591
25592 2)*(2*ch*e0c*e0cn*epscr[i] +
25593
25594
25595 d*(-(e0cn*fy) + e0c*(fy - e0cn*(epscr[i] + epsn)))) +
25596
25597
25598 sqrt(3.)*sqrt(k*
25599
25600
25601 pow(epsc1,
25602
25603
25604 2)*(3*k*pow(epsc1, 2)*
25605
25606
25607 pow(d*e0c*(n0 + as1*e0c*(epscr[i] - epsn)) +
25608
25609
25610 as2*(2*ch*e0c*e0cn*epscr[i] +
25611
25612
25613 d*(-(e0cn*fy) + e0c*(fy - e0cn*(epscr[i] + epsn)))),
25614
25615
25616 2) + 2*e0c*(as1*d*e0c +
25617
25618
25619 as2*ch*e0cn)*(-(b*pow(d, 2)*e0c*fc*
25620
25621
25622 pow(epscr[i] + epsn,
25623
25624
25625 2)*(4*(-1 + k)*epscr[i] + (6 - 9*k)*epsc1 +
25626
25627
25628 4*(-1 + k)*epsn)) +
25629
25630
25631 6*k*epscr[i]*
25632
25633
25634 pow(epsc1,
25635
25636
25637 2)*(-(as2*ch*e0c*e0cn*epscr[i]) +
25638
25639
25640 d*(as2*e0cn*fy + as1*pow(e0c, 2)*epsn +
25641
25642
25643 e0c*(-(as2*fy) - n0 +
25644
25645
25646 as2*e0cn*(epscr[i] + epsn))))))))/(6.*
25647
25648
25649 e0c*(as1*d*e0c + as2*ch*e0cn)*k*pow(epsc1, 2));
25650
25651
25652 }
25653
25654 else if ((mp[i] > mht1) && (mht1 == mhr1) && (mp[i] <= mht2) && (tcn[i] == 0.)){
25655
25656
25657
25658
25659
25660 epss1r[i] = (6*as2*ch*e0c*k*epscr[i]*pow(epsc1, 2) +
25661
25662
25663 3*d*k*pow(epsc1,
25664
25665
25666 2)*(n0 + as1*e0c*(epscr[i] - epsn) - as2*e0c*(epscr[i] + epsn)) +
25667
25668
25669 sqrt(3.)*sqrt(k*
25670
25671
25672 pow(epsc1,
25673
25674
25675 2)*(3*k*pow(epsc1, 2)*
25676
25677
25678 pow(-2*as2*ch*e0c*epscr[i] +
25679
25680
25681 d*(-n0 - as1*e0c*epscr[i] +
25682
25683
25684 as2*e0c*epscr[i] + (as1 + as2)*e0c*epsn), 2) -
25685
25686
25687 2*(as2*ch + as1*d)*
25688
25689
25690 e0c*(b*pow(d, 2)*fc*
25691
25692
25693 pow(epscr[i] + epsn,
25694
25695
25696 2)*(4*(-1 + k)*epscr[i] + (6 - 9*k)*epsc1 +
25697
25698
25699 4*(-1 + k)*epsn) +
25700
25701
25702 6*k*epscr[i]*
25703
25704
25705 pow(epsc1,
25706
25707
25708 2)*(as2*ch*e0c*epscr[i] +
25709
25710
25711 d*(n0 -
25712
25713
25714 e0c*(as2*epscr[i] + (as1 + as2)*
25715
25716
25717 epsn)))))))/(6.*(as2*ch + as1*d)*e0c*
25718
25719
25720 k*pow(epsc1, 2));
25721
25722
25723 }
25724
25725 else if ((mp[i] > mht2) && (mht2 == mhr2) && (mp[i] <= mht3) && (tcn[i] == 0.)){
25726
25727
25728
25729
25730
25731 epss1r[i] = (6*as2*ch*pow(e0c, 2)*k*epscr[i]*pow(epsc1, 2) -
25732
25733
25734 3*d*k*pow(epsc1,
25735
25736
25737 2)*(-(as1*e0cn*fy) +
25738
25739
25740 e0c*(-n0 + as2*e0c*(epscr[i] + epsn) +
25741
25742
25743 as1*(fy + e0cn*(-epscr[i] + epsn)))) +
25744
25745
25746 sqrt(3.)*sqrt(k*
25747
25748
25749 pow(epsc1,
25750
25751
25752 2)*(3*k*pow(epsc1, 2)*
25753
25754
25755 pow(-2*as2*ch*pow(e0c, 2)*epscr[i] +
25756
25757
25758 d*(-(as1*e0cn*fy) +
25759
25760
25761 e0c*(-n0 + as2*e0c*(epscr[i] + epsn) +
25762
25763
25764 as1*(fy + e0cn*(-epscr[i] + epsn)))), 2) -
25765
25766
25767 2*e0c*(as2*ch*e0c +
25768
25769
25770 as1*d*e0cn)*(b*pow(d, 2)*e0c*fc*
25771
25772
25773 pow(epscr[i] + epsn,
25774
25775
25776 2)*(4*(-1 + k)*epscr[i] + (6 - 9*k)*epsc1 +
25777
25778
25779 4*(-1 + k)*epsn) +
25780
25781
25782 6*k*epscr[i]*
25783
25784
25785 pow(epsc1,
25786
25787
25788 2)*(as1*d*(e0cn*fy - e0c*(fy + e0cn*epsn)) +
25789
25790
25791 e0c*(as2*ch*e0c*epscr[i] +
25792
25793
25794 d*(n0 - as2*e0c*(epscr[i] + epsn))))))))/(6.*
25795
25796
25797 e0c*(as2*ch*e0c + as1*d*e0cn)*k*pow(epsc1, 2));
25798
25799
25800 }
25801
25802 else if ((mp[i] > mht2) && (mht2 == mhr3) && (mp[i] <= mht3) && (tcn[i] == 0.)){
25803
25804
25805
25806
25807
25808 epss1r[i] = (3*d*e0c*k*pow(epsc1, 2)*(n0 + as1*e0c*(epscr[i] - epsn)) +
25809
25810
25811 3*as2*k*pow(epsc1,
25812
25813
25814 2)*(2*ch*e0c*e0cn*epscr[i] +
25815
25816
25817 d*(-(e0cn*fy) + e0c*(fy - e0cn*(epscr[i] + epsn)))) +
25818
25819
25820 sqrt(3.)*sqrt(k*
25821
25822
25823 pow(epsc1,
25824
25825
25826 2)*(3*k*pow(epsc1, 2)*
25827
25828
25829 pow(d*e0c*(n0 + as1*e0c*(epscr[i] - epsn)) +
25830
25831
25832 as2*(2*ch*e0c*e0cn*epscr[i] +
25833
25834
25835 d*(-(e0cn*fy) + e0c*(fy - e0cn*(epscr[i] + epsn)))),
25836
25837
25838 2) + 2*e0c*(as1*d*e0c +
25839
25840
25841 as2*ch*e0cn)*(-(b*pow(d, 2)*e0c*fc*
25842
25843
25844 pow(epscr[i] + epsn,
25845
25846
25847 2)*(4*(-1 + k)*epscr[i] + (6 - 9*k)*epsc1 +
25848
25849
25850 4*(-1 + k)*epsn)) +
25851
25852
25853 6*k*epscr[i]*
25854
25855
25856 pow(epsc1,
25857
25858
25859 2)*(-(as2*ch*e0c*e0cn*epscr[i]) +
25860
25861
25862 d*(as2*e0cn*fy + as1*pow(e0c, 2)*epsn +
25863
25864
25865 e0c*(-(as2*fy) - n0 +
25866
25867
25868 as2*e0cn*(epscr[i] + epsn))))))))/(6.*
25869
25870
25871 e0c*(as1*d*e0c + as2*ch*e0cn)*k*pow(epsc1, 2));
25872
25873
25874 }
25875
25876 else if ((mp[i] > mht3) && ((mht3 == mhr6) || (mht3 == mhr5)) && (mp[i] <= mht4) && (tcn[i] == 0.)){
25877
25878
25879
25880
25881
25882 epss1r[i] = (3*as1*d*k*pow(epsc1, 2)*(e0cn*fy - e0c*(fy + e0cn*(-epscr[i] + epsn))) +
25883
25884
25885 3*k*pow(epsc1,
25886
25887
25888 2)*(d*e0c*n0 +
25889
25890
25891 as2*(2*ch*e0c*e0cn*epscr[i] +
25892
25893
25894 d*(-(e0cn*fy) + e0c*(fy - e0cn*(epscr[i] + epsn))))) +
25895
25896
25897 sqrt(3.)*sqrt(k*
25898
25899
25900 pow(epsc1,
25901
25902
25903 2)*(3*k*pow(epsc1, 2)*
25904
25905
25906 pow(-(d*e0c*n0) +
25907
25908
25909 as1*d*(-(e0cn*fy) + e0c*(fy - e0cn*epscr[i] + e0cn*epsn)) +
25910
25911
25912 as2*(-2*ch*e0c*e0cn*epscr[i] +
25913
25914
25915 d*(e0cn*fy + e0c*(-fy + e0cn*(epscr[i] + epsn)))),
25916
25917
25918 2) - 2*(as2*ch + as1*d)*e0c*
25919
25920
25921 e0cn*(b*pow(d, 2)*e0c*fc*
25922
25923
25924 pow(epscr[i] + epsn,
25925
25926
25927 2)*(4*(-1 + k)*epscr[i] + (6 - 9*k)*epsc1 +
25928
25929
25930 4*(-1 + k)*epsn) +
25931
25932
25933 6*k*epscr[i]*
25934
25935
25936 pow(epsc1,
25937
25938
25939 2)*(d*e0c*n0 +
25940
25941
25942 as1*d*(e0cn*fy - e0c*(fy + e0cn*epsn)) +
25943
25944
25945 as2*(ch*e0c*e0cn*epscr[i] +
25946
25947
25948 d*(-(e0cn*fy) +
25949
25950
25951 e0c*(fy -
25952
25953
25954 e0cn*(epscr[i] + epsn)))))))))/(6.*(as2*
25955
25956
25957 ch + as1*d)*e0c*e0cn*k*pow(epsc1, 2));
25958
25959
25960 }
25961
25962 else if ((tcn[i] != 0.) && (mp[i] <= mhoc1)){
25963
25964
25965
25966
25967
25968 epss1r[i] = 0;
25969
25970
25971 }
25972
25973
25974
25975 else if ((tcn[i] != 0.) && (mp[i] > mhoc1) && (mp[i] <= mhoc2)){
25976
25977
25978
25979
25980
25981 epss1r[i] = mhoc1/(-(as1*ch*e0c) + as1*d*e0c);
25982
25983
25984 }
25985
25986 else {
25987
25988
25989
25990
25991
25992 epss1r[i] = -((mhoc2 - (as1*(ch - d)*(-(e0c*fy) + e0cn*fy + pow(e0c,2)*epsn))/e0c)/(as1*(ch - d)*e0cn));
25993
25994
25995 }
25996
25997
25998 }
25999
26000
26001
26002
26003
26004 }
26005
26006
26007
26008
26009
26010
26011
26012
26013
26014 void normmat::compute_epss1spp ()
26015
26016
26017 {
26018
26019
26020 long i;
26021
26022
26023
26024
26025
26026
26027
26028
26029
26030
26031 for (i=0;i<4;i++){
26032
26033
26034 epss1spp[i]=(a2spp[i]*b1sp[i])/a1sp[i] - b2spp[i] + epss1sp[i];
26035
26036
26037 }
26038
26039
26040 }
26041
26042
26043
26044
26045
26046
26047
26048
26049
26050 void normmat::compute_xr ()
26051
26052
26053 {
26054
26055
26056 long i;
26057
26058
26059
26060
26061
26062
26063
26064
26065
26066 for (i=0;i<4;i++){
26067
26068
26069 if ((epscr[i] < 0.) && (d*(-epsn - epscr[i]))/(-epscr[i] + epss1r[i]) <= h){
26070
26071
26072 xr[i] = -(epscr[i] + epsn)*d/(-epscr[i] + epss1r[i]);
26073
26074
26075 }
26076
26077
26078 else {
26079
26080
26081 xr[i] = h;
26082
26083
26084 }
26085
26086
26087 }
26088
26089
26090 }
26091
26092
26093
26094
26095
26096
26097
26098
26099
26100 void normmat::compute_xsp ()
26101
26102
26103 {
26104
26105
26106 long i;
26107
26108
26109
26110
26111
26112
26113
26114 for (i=0;i<4;i++){
26115
26116
26117 if ((epscsp[i] < 0.) && (d*(-epsn - epscsp[i]))/(-epscsp[i] + epss1sp[i]) <= h){
26118
26119
26120
26121
26122
26123 xsp[i] = -(epscsp[i] + epsn)*d/(-epscsp[i] + epss1sp[i]);
26124
26125
26126 } else {
26127
26128
26129
26130
26131
26132 xsp[i] = h;
26133
26134
26135 }
26136
26137
26138 }
26139
26140
26141 }
26142
26143
26144
26145
26146
26147
26148
26149
26150
26151
26152
26153
26154 void normmat::compute_ir1 ()
26155
26156
26157 {
26158
26159
26160 long i;
26161
26162
26163
26164
26165
26166
26167 for (i=0;i<4;i++){
26168
26169
26170 if ((epscr[i] < 0.) && (tcn[i] == 0.) && (xr[i] != h)){
26171
26172
26173
26174
26175
26176 ir1[i] = (b*d*fc*(-3.*(-1. + k)*pow(epscr[i], 4) +
26177
26178
26179 pow(epsn, 3)*((-4. + 6.*k)*epsc1 - 5.*(-1. + k)*epsn) +
26180
26181
26182 2*pow(epscr[i], 3)*((-2. + 3.*k)*epsc1 - 4.*(-1. + k)*epsn)))/(6.*k*
26183
26184
26185 pow(epsc1, 2)*(epscr[i] - epss1r[i]));
26186
26187
26188 }
26189
26190 else if ((epscr[i] < 0.) && (tcn[i] == 0.) && (xr[i] == h)){
26191
26192
26193
26194
26195
26196 ir1[i] = 1./(4.*pow(d, 3)*k*pow(epsc1, 2))*(b*
26197
26198
26199 fc*(4*pow(d, 3)*h*
26200
26201
26202 pow(epscr[i],
26203
26204
26205 2)*(-2.*(-1. + k)*epscr[i] + (-2. + 3.*k)*epsc1 - 4.*(-1. + k)*epsn) +
26206
26207
26208 4.*pow(d, 2)*pow(h, 2)*
26209
26210
26211 epscr[i]*(3.*(-1. + k)*epscr[i] + (2. - 3.*k)*epsc1 + 4.*(-1. + k)*epsn)*(epscr[i] -
26212
26213
26214 epss1r[i]) -
26215
26216
26217 4./3.*d*
26218
26219
26220 pow(h, 3)*(6.*(-1. + k)*epscr[i] + (2. - 3.*k)*epsc1 + 4.*(-1. + k)*epsn)*
26221
26222
26223 pow(epscr[i] - epss1r[i], 2) +
26224
26225
26226 2.*pow(h, 4)*(-1. + k)*pow(epscr[i] - epss1r[i], 3)));
26227
26228
26229 }
26230
26231 else {
26232
26233
26234
26235
26236
26237 ir1[i] = 0.0;
26238
26239
26240 } }
26241
26242
26243
26244
26245
26246 }
26247
26248
26249
26250
26251
26252
26253
26254
26255 void normmat::compute_ims1 ()
26256
26257
26258 {
26259
26260
26261 long i;
26262
26263
26264
26265
26266
26267
26268
26269 for (i=0;i<4;i++){
26270
26271
26272 if ((epscsp[i] < 0.) && (tcn[i] == 0.) && (xsp[i] != h)){
26273
26274
26275
26276
26277
26278 ims1[i] = (b*d*fc*(-3.*(-1. + k)*pow(epscsp[i], 4) +
26279
26280
26281 pow(epsn, 3)*((-4. + 6.*k)*epsc1 - 5.*(-1. + k)*epsn) +
26282
26283
26284 2.*pow(epscsp[i], 3)*((-2. + 3.*k)*epsc1 - 4.*(-1. + k)*epsn)))/(6.*k*
26285
26286
26287 pow(epsc1, 2)*(epscsp[i] - epss1sp[i]));
26288
26289
26290 }
26291
26292 else if ((epscsp[i] < 0.) && (tcn[i] == 0.) && (xsp[i] == h)){
26293
26294
26295
26296 ims1[i] = 1./(4.*pow(d, 3)*k*pow(epsc1, 2))*(b*
26297
26298
26299 fc*(4.*pow(d, 3)*h*
26300
26301
26302 pow(epscsp[i],
26303
26304
26305 2)*(-2.*(-1. + k)*epscsp[i] + (-2. + 3.*k)*epsc1 - 4.*(-1. + k)*epsn) +
26306
26307
26308 4.*pow(d, 2)*pow(h, 2)*
26309
26310
26311 epscsp[i]*(3.*(-1. + k)*epscsp[i] + (2. - 3.*k)*epsc1 + 4.*(-1. + k)*epsn)*(epscsp[i] -
26312
26313
26314 epss1sp[i]) -
26315
26316
26317 4./3.*d*
26318
26319
26320 pow(h, 3)*(6.*(-1. + k)*epscsp[i] + (2. - 3.*k)*epsc1 + 4.*(-1. + k)*epsn)*
26321
26322
26323 pow(epscsp[i] - epss1sp[i], 2) +
26324
26325
26326 2.*pow(h, 4)*(-1. + k)*pow(epscsp[i] - epss1sp[i], 3)));
26327
26328
26329 }
26330
26331 else {
26332
26333
26334
26335
26336
26337 ims1[i] = 0.0;
26338
26339
26340 }
26341
26342
26343
26344 }
26345
26346
26347
26348
26349
26350 }
26351
26352
26353
26354
26355
26356
26357
26358
26359
26360 void normmat::compute_ims2 ()
26361
26362
26363 {
26364
26365
26366 long i;
26367
26368
26369
26370
26371
26372
26373
26374
26375 for (i=0;i<4;i++){
26376
26377
26378 if ((epss1sp[i]+epsn) <= fy/e0c){
26379
26380
26381
26382
26383
26384 ims2[i] = as1*e0c*epss1sp[i]*epss1sp[i];
26385
26386
26387 }
26388
26389 else {
26390
26391
26392
26393
26394
26395 ims2[i] = (e0cn*(epss1sp[i] - fy/e0c + epsn) + e0c*(fy/e0c - epsn))*epss1sp[i]*as1;
26396
26397
26398 } }
26399
26400
26401
26402
26403
26404 }
26405
26406
26407
26408
26409
26410
26411
26412
26413
26414
26415
26416
26417
26418
26419 void normmat::compute_ir2 ()
26420
26421
26422 {
26423
26424
26425 long i;
26426
26427
26428
26429
26430
26431
26432 for (i=0;i<4;i++){
26433
26434
26435 if ((epss1r[i]+epsn) <= fy/e0c){
26436
26437
26438
26439
26440
26441 ir2[i] = as1*e0c*epss1r[i]*epss1r[i];
26442
26443
26444 } else {
26445
26446
26447
26448
26449
26450 ir2[i] = (e0cn*(epss1r[i] - fy/e0c + epsn) + e0c*(fy/e0c - epsn))*epss1r[i]*as1;
26451
26452
26453 }
26454
26455
26456 }
26457
26458
26459 }
26460
26461
26462
26463
26464
26465
26466
26467
26468
26469
26470
26471
26472
26473
26474
26475
26476
26477
26478
26479
26480
26481 void normmat::compute_ir3 ()
26482
26483
26484 {
26485
26486
26487 long i;
26488
26489
26490
26491
26492
26493
26494
26495 for (i=0;i<4;i++){
26496
26497
26498 if ((epsn + (-(ch*epscr[i]) + d*epscr[i] + ch*epss1r[i])/d) >= -(fy/e0c) &&
26499
26500
26501 (tcn[i] == 0)){
26502
26503
26504
26505
26506
26507 ir3[i] = (as2*e0c*(d*epscr[i] + ch*(-epscr[i] + epss1r[i]))*(d*epscr[i] + ch*(-epscr[i] + epss1r[i])))/pow(d,
26508
26509
26510 2);
26511
26512
26513 }
26514
26515 else if (((ch*epss1r[i] + ch*-epscr[i] - d*-epscr[i])/d + epsn) < -fy/e0c && (tcn[i] == 0)){
26516
26517
26518
26519
26520
26521 ir3[i] = (e0c*(-fy/e0c - epsn) +
26522
26523
26524 e0cn*((ch*epss1r[i] + ch*-epscr[i] - d*-epscr[i])/d + epsn + fy/e0c))*(ch*epss1r[i] +
26525
26526
26527 ch*-epscr[i] - d*-epscr[i])/d*as2;
26528
26529
26530 }
26531
26532 else if ((-((as1*epss1r[i])/as2) + epsn) >= -fy/e0c && (tcn[i] == 1.) && (mhoc1 >= mp[i])){
26533
26534
26535
26536
26537
26538 ir3[i] = -((as1*epss1r[i])/as2)*e0c*-((as1*epss1r[i])/as2)*as2;
26539
26540
26541 }
26542
26543 else if (((as2*(e0c - e0cn)*(fy + e0c*epsn) - as1*pow(e0c, 2)*epss1r[i])/(as2*e0c*
26544
26545
26546 e0cn) + epsn) < -fy/e0c && (tcn[i] == 1.) && (mhoc2 >= mp[i]) &&
26547
26548
26549 (mhoc1 < mp[i])){
26550
26551
26552
26553
26554
26555 ir3[i] = -((as2*e0cn*epsn + as1*e0c*epss1r[i])/as2)*(as2*(e0c - e0cn)*(fy + e0c*epsn) -
26556
26557
26558 as1*pow(e0c, 2)*epss1r[i])/(as2*e0c*e0cn)*as2;
26559
26560
26561 }
26562
26563 else {
26564
26565
26566
26567
26568
26569 ir3[i] = (-as2*e0c*e0cn*epsn +
26570
26571
26572 as1*(e0cn*fy + pow(e0c, 2)*epsn -
26573
26574
26575 e0c*(fy + e0cn*(epsn + epss1r[i]))))/(as2*
26576
26577
26578 e0c)*((e0c - e0cn)*(-as1*fy + as2*fy + as1*e0c*epsn + as2*e0c*epsn) -
26579
26580
26581 as1*e0c*e0cn*epss1r[i])/(as2*e0c*e0cn)*as2;
26582
26583
26584 } }
26585
26586
26587
26588
26589
26590 }
26591
26592
26593
26594
26595
26596
26597
26598
26599 void normmat::compute_ims3 ()
26600
26601
26602 {
26603
26604
26605 long i;
26606
26607
26608
26609
26610
26611
26612
26613 for (i=0;i<4;i++){
26614
26615
26616 if ((epsn + (-(ch*epscsp[i]) + d*epscsp[i] + ch*epss1sp[i])/d) >= -(fy/e0c) &&
26617
26618
26619 (tcn[i] == 0.)){
26620
26621
26622
26623
26624
26625 ims3[i] = (as2*e0c*(d*epscsp[i] + ch*(-epscsp[i] + epss1sp[i]))*(d*epscsp[i] + ch*(-epscsp[i] + epss1sp[i])))/pow(d,
26626
26627
26628 2);
26629
26630
26631 }
26632
26633 else if (((ch*epss1sp[i] + ch*-epscsp[i] - d*-epscsp[i])/d + epsn) < -fy/e0c && (tcn[i] == 0.)){
26634
26635
26636
26637
26638
26639 ims3[i] = (e0c*(-fy/e0c - epsn) +
26640
26641
26642 e0cn*((ch*epss1sp[i] + ch*-epscsp[i] - d*-epscsp[i])/d + epsn + fy/e0c))*(ch*epss1sp[i] + ch*-epscsp[i] - d*-epscsp[i])/d*as2;
26643
26644
26645 }
26646
26647 else if ((-((as1*epss1sp[i])/as2) + epsn) >= -fy/e0c && (tcn[i] == 1.) && (mhoc1 >= mp[i])){
26648
26649
26650
26651
26652
26653 ims3[i] = -((as1*epss1sp[i])/as2)*e0c*-((as1*epss1sp[i])/as2)*as2;
26654
26655
26656 }
26657
26658 else if (((as2*(e0c - e0cn)*(fy + e0c*epsn) - as1*pow(e0c, 2)*epss1sp[i])/(as2*e0c*
26659
26660
26661 e0cn) + epsn) < -fy/e0c && (tcn[i] == 1.) && (mhoc2 >= mp[i]) &&
26662
26663
26664 (mhoc1 < mp[i])){
26665
26666
26667
26668
26669
26670 ims3[i] = -((as2*e0cn*epsn + as1*e0c*epss1sp[i])/as2)*(as2*(e0c - e0cn)*(fy + e0c*epsn) -
26671
26672
26673 as1*pow(e0c, 2)*epss1sp[i])/(as2*e0c*e0cn)*as2;
26674
26675
26676 }
26677
26678 else {
26679
26680
26681
26682
26683
26684 ims3[i] = (-as2*e0c*e0cn*epsn +
26685
26686
26687 as1*(e0cn*fy + pow(e0c, 2)*epsn -
26688
26689
26690 e0c*(fy + e0cn*(epsn + epss1sp[i]))))/(as2*
26691
26692
26693 e0c)*((e0c - e0cn)*(-as1*fy + as2*fy + as1*e0c*epsn + as2*e0c*epsn) -
26694
26695
26696 as1*e0c*e0cn*epss1sp[i])/(as2*e0c*e0cn)*as2;
26697
26698
26699 } }
26700
26701
26702
26703
26704
26705 }
26706
26707
26708
26709
26710
26711
26712
26713
26714 void normmat::compute_ic1 ()
26715
26716
26717 {
26718
26719
26720 long i;
26721
26722
26723
26724
26725
26726
26727
26728
26729 for (i=0;i<4;i++){
26730
26731
26732 ic1[i] = ir1[i]+ir2[i]+ir3[i];
26733
26734
26735 }
26736
26737
26738
26739
26740
26741 }
26742
26743
26744
26745
26746
26747
26748
26749
26750
26751
26752 void normmat::compute_ic2 ()
26753
26754
26755 {
26756
26757
26758 long i;
26759
26760
26761
26762
26763
26764
26765
26766 for (i=0;i<4;i++){
26767
26768
26769 ic2[i] = ims1[i]+ims2[i]+ims3[i];
26770
26771
26772 }
26773
26774
26775 }
26776
26777
26778
26779
26780
26781
26782
26783
26784 void normmat::compute_icp ()
26785
26786
26787 {
26788
26789
26790 long i;
26791
26792
26793
26794
26795
26796
26797
26798
26799
26800 for (i=0;i<4;i++){
26801
26802
26803 icp[i] = as1*e0c*epss1sp[i]*epss1spp[i];
26804
26805
26806 }
26807
26808
26809 }
26810
26811
26812
26813
26814
26815
26816
26817
26818
26819 void normmat::compute_c1 ()
26820
26821
26822 {
26823
26824
26825 long i;
26826
26827
26828
26829
26830
26831 for (i=0;i<4;i++){
26832
26833
26834 c1[i] = -((-ic1[i] + ic2[i])/(-pow(mp[i], 2) + pow(mr[i], 2)));
26835
26836
26837 }
26838
26839
26840 }
26841
26842
26843
26844
26845
26846
26847
26848
26849
26850 void normmat::compute_c2 ()
26851
26852
26853 {
26854
26855
26856 long i;
26857
26858
26859
26860
26861
26862
26863
26864
26865 for (i=0;i<4;i++){
26866
26867
26868 c2[i] = -((ic1[i]*pow(mp[i], 2) - ic2[i]*pow(mr[i], 2))/(-pow(mp[i], 2) + pow(mr[i], 2)));
26869
26870
26871 }
26872
26873
26874
26875
26876
26877 }
26878
26879
26880
26881
26882
26883
26884
26885
26886
26887 void normmat::compute_c1p ()
26888
26889
26890 {
26891
26892
26893 long i;
26894
26895
26896
26897
26898
26899
26900
26901
26902 for (i=0;i<4;i++){
26903
26904
26905 c1p[i] = -((-ic1[i] + icp[i])/(-pow(mp[i], 2) + pow(mr[i], 2)));
26906
26907
26908 }
26909
26910
26911
26912
26913
26914 }
26915
26916
26917
26918
26919
26920
26921
26922
26923
26924 void normmat::compute_c2p ()
26925
26926
26927 {
26928
26929
26930 long i;
26931
26932
26933
26934
26935
26936
26937 for (i=0;i<4;i++){
26938
26939
26940 c2p[i] = -((ic1[i]*pow(mp[i], 2) - icp[i]*pow(mr[i], 2))/(-pow(mp[i], 2) + pow(mr[i], 2)));
26941
26942
26943 }
26944
26945
26946 }
26947
26948
26949
26950
26951
26952
26953
26954
26955
26956 void normmat::compute_kih (double lp)
26957
26958
26959 {
26960
26961
26962
26963
26964
26965
26966
26967
26968 kih[0]=(lp*((3*pow(fp, 2)*pow(lp, 4) + 20.*fp*pow(lp, 2)*(3.*lp*z1 + 16.*z2) +
26969
26970
26971 320.*(pow(lp, 2)*pow(z1, 2) + 12.*lp*z1*z2 + 48.*pow(z2, 2)))*
26972
26973
26974 c1[0] + 15360.*c2[0]))/61440.;
26975
26976
26977 kih[1]=(lp*(93.*pow(fp, 2)*pow(lp, 4) + 20.*fp*pow(lp, 2)*(45.*lp*z1 + 112.*z2) +
26978
26979
26980 320.*(7.*pow(lp, 2)*pow(z1, 2) + 36.*lp*z1*z2 + 48.*pow(z2, 2)))*
26981
26982
26983 c1[1])/61440. + (lp*c2[1])/4.;
26984
26985
26986 kih[2]=(lp*(633.*pow(fp, 2)*pow(lp, 4) + 20.*fp*pow(lp, 2)*(195.*lp*z1 + 304.*z2) +
26987
26988
26989 320.*(19.*pow(lp, 2)*pow(z1, 2) + 60.*lp*z1*z2 + 48.*pow(z2, 2)))*
26990
26991
26992 c1[2])/61440. + (lp*c2[2])/4.;
26993
26994
26995 kih[3]=(lp*(2343.*pow(fp, 2)*pow(lp, 4) + 20.*fp*pow(lp, 2)*(525.*lp*z1 + 592.*z2) +
26996
26997
26998 320.*(37.*pow(lp, 2)*pow(z1, 2) + 84.*lp*z1*z2 + 48.*pow(z2, 2)))*
26999
27000
27001 c1[3])/61440. + (lp*c2[3])/4.;
27002
27003
27004
27005
27006
27007 }
27008
27009
27010
27011
27012
27013
27014
27015
27016
27017 void normmat::compute_kid (double lp)
27018
27019
27020 {
27021
27022
27023
27024
27025
27026
27027
27028
27029 kid[0]=(lp*((3.*pow(fp, 2)*pow(lp, 4) + 20.*fp*pow(lp, 2)*(3.*lp*z1 + 16.*z2) +
27030
27031
27032 320.*(pow(lp, 2)*pow(z1, 2) + 12.*lp*z1*z2 + 48.*pow(z2, 2)))*
27033
27034
27035 c1p[0] + 15360.*c2p[0]))/61440.;
27036
27037
27038 kid[1]=(lp*(93.*pow(fp, 2)*pow(lp, 4) + 20.*fp*pow(lp, 2)*(45.*lp*z1 + 112.*z2) +
27039
27040
27041 320.*(7.*pow(lp, 2)*pow(z1, 2) + 36.*lp*z1*z2 + 48.*pow(z2, 2)))*
27042
27043
27044 c1p[1])/61440. + (lp*c2p[1])/4.;
27045
27046
27047 kid[2]=(lp*(633.*pow(fp, 2)*pow(lp, 4) + 20.*fp*pow(lp, 2)*(195.*lp*z1 + 304.*z2) +
27048
27049
27050 320.*(19.*pow(lp, 2)*pow(z1, 2) + 60.*lp*z1*z2 + 48.*pow(z2, 2)))*
27051
27052
27053 c1p[2])/61440. + (lp*c2p[2])/4.;
27054
27055
27056 kid[3]=(lp*(2343.*pow(fp, 2)*pow(lp, 4) + 20.*fp*pow(lp, 2)*(525.*lp*z1 + 592.*z2) +
27057
27058
27059 320.*(37.*pow(lp, 2)*pow(z1, 2) + 84.*lp*z1*z2 + 48.*pow(z2, 2)))*
27060
27061
27062 c1p[3])/61440. + (lp*c2p[3])/4.;
27063
27064
27065
27066
27067
27068 }
27069
27070
27071
27072
27073
27074
27075
27076
27077 void normmat::compute_ki ()
27078
27079
27080 {
27081
27082
27083 long i;
27084
27085
27086
27087
27088
27089
27090
27091 for (i=0;i<4;i++){
27092
27093
27094 ki[i] = kih[i]/kid[i];
27095
27096
27097 }
27098
27099
27100
27101
27102
27103 }
27104
27105
27106
27107
27108
27109
27110
27111
27112
27113 double normmat::compute_k11 (double lp)
27114
27115
27116 {
27117
27118
27119 double k11;
27120
27121
27122
27123
27124
27125 k11 = (768*(pow(a1sp[0], 2)*pow(a1sp[1], 4)*pow(a1sp[2], 4)*pow(a1sp[3], 4)*
27126
27127
27128 pow(b1sp[0], 2)*ki[0] +
27129
27130
27131 pow(a1sp[0],
27132
27133
27134 4)*(pow(a1sp[1], 2)*pow(a1sp[2], 4)*pow(a1sp[3], 4)*
27135
27136
27137 pow(b1sp[1], 2)*ki[1] +
27138
27139
27140 pow(a1sp[1],
27141
27142
27143 4)*(pow(a1sp[2], 2)*pow(a1sp[3], 4)*pow(b1sp[2], 2)*
27144
27145
27146 ki[2] +
27147
27148
27149 pow(a1sp[2], 4)*pow(a1sp[3], 2)*pow(b1sp[3], 2)*
27150
27151
27152 ki[3]))))/(as1*e0c*
27153
27154
27155 pow(lp, 3)*(pow(a1sp[0], 4)*pow(a1sp[2], 4)*pow(a1sp[3], 4)*
27156
27157
27158 pow(b1sp[1], 4)*pow(ki[1], 2) +
27159
27160
27161 2*pow(a1sp[0], 2)*pow(a1sp[1], 2)*pow(a1sp[2], 2)*pow(a1sp[3], 2)*
27162
27163
27164 pow(b1sp[1], 2)*
27165
27166
27167 ki[1]*(7*pow(a1sp[0], 2)*pow(a1sp[3], 2)*pow(b1sp[2], 2)*ki[2] +
27168
27169
27170 pow(a1sp[2],
27171
27172
27173 2)*(7*pow(a1sp[3], 2)*pow(b1sp[0], 2)*ki[0] +
27174
27175
27176 25*pow(a1sp[0], 2)*pow(b1sp[3], 2)*ki[3])) +
27177
27178
27179 pow(a1sp[1],
27180
27181
27182 4)*(pow(a1sp[0], 4)*pow(a1sp[3], 4)*pow(b1sp[2], 4)*
27183
27184
27185 pow(ki[2], 2) +
27186
27187
27188 2*pow(a1sp[0], 2)*pow(a1sp[2], 2)*pow(a1sp[3], 2)*
27189
27190
27191 pow(b1sp[2], 2)*
27192
27193
27194 ki[2]*(25*pow(a1sp[3], 2)*pow(b1sp[0], 2)*ki[0] +
27195
27196
27197 7*pow(a1sp[0], 2)*pow(b1sp[3], 2)*ki[3]) +
27198
27199
27200 pow(a1sp[2],
27201
27202
27203 4)*(pow(a1sp[3], 4)*pow(b1sp[0], 4)*pow(ki[0], 2) +
27204
27205
27206 110*pow(a1sp[0], 2)*pow(a1sp[3], 2)*pow(b1sp[0], 2)*
27207
27208
27209 pow(b1sp[3], 2)*ki[0]*ki[3] +
27210
27211
27212 pow(a1sp[0], 4)*pow(b1sp[3], 4)*pow(ki[3], 2)))));
27213
27214
27215 return k11; }
27216
27217
27218
27219
27220
27221
27222
27223
27224 double normmat::compute_k12 (double lp)
27225
27226
27227 {
27228
27229
27230 double k12;
27231
27232
27233
27234
27235
27236
27237
27238
27239 k12 = (-96*(pow(a1sp[0], 2)*pow(a1sp[1], 4)*pow(a1sp[2], 4)*pow(a1sp[3], 4)*
27240
27241
27242 pow(b1sp[0], 2)*ki[0] +
27243
27244
27245 pow(a1sp[0],
27246
27247
27248 4)*(3*pow(a1sp[1], 2)*pow(a1sp[2], 4)*pow(a1sp[3], 4)*
27249
27250
27251 pow(b1sp[1], 2)*ki[1] +
27252
27253
27254 pow(a1sp[1],
27255
27256
27257 4)*(5*pow(a1sp[2], 2)*pow(a1sp[3], 4)*pow(b1sp[2], 2)*
27258
27259
27260 ki[2] +
27261
27262
27263 7*pow(a1sp[2], 4)*pow(a1sp[3], 2)*pow(b1sp[3], 2)*
27264
27265
27266 ki[3]))))/(as1*e0c*
27267
27268
27269 pow(lp, 2)*(pow(a1sp[0], 4)*pow(a1sp[2], 4)*pow(a1sp[3], 4)*
27270
27271
27272 pow(b1sp[1], 4)*pow(ki[1], 2) +
27273
27274
27275 2*pow(a1sp[0], 2)*pow(a1sp[1], 2)*pow(a1sp[2], 2)*pow(a1sp[3], 2)*
27276
27277
27278 pow(b1sp[1], 2)*
27279
27280
27281 ki[1]*(7*pow(a1sp[0], 2)*pow(a1sp[3], 2)*pow(b1sp[2], 2)*ki[2] +
27282
27283
27284 pow(a1sp[2],
27285
27286
27287 2)*(7*pow(a1sp[3], 2)*pow(b1sp[0], 2)*ki[0] +
27288
27289
27290 25*pow(a1sp[0], 2)*pow(b1sp[3], 2)*ki[3])) +
27291
27292
27293 pow(a1sp[1],
27294
27295
27296 4)*(pow(a1sp[0], 4)*pow(a1sp[3], 4)*pow(b1sp[2], 4)*
27297
27298
27299 pow(ki[2], 2) +
27300
27301
27302 2*pow(a1sp[0], 2)*pow(a1sp[2], 2)*pow(a1sp[3], 2)*
27303
27304
27305 pow(b1sp[2], 2)*
27306
27307
27308 ki[2]*(25*pow(a1sp[3], 2)*pow(b1sp[0], 2)*ki[0] +
27309
27310
27311 7*pow(a1sp[0], 2)*pow(b1sp[3], 2)*ki[3]) +
27312
27313
27314 pow(a1sp[2],
27315
27316
27317 4)*(pow(a1sp[3], 4)*pow(b1sp[0], 4)*pow(ki[0], 2) +
27318
27319
27320 110*pow(a1sp[0], 2)*pow(a1sp[3], 2)*pow(b1sp[0], 2)*
27321
27322
27323 pow(b1sp[3], 2)*ki[0]*ki[3] +
27324
27325
27326 pow(a1sp[0], 4)*pow(b1sp[3], 4)*pow(ki[3], 2)))));
27327
27328
27329 return k12; }
27330
27331
27332
27333
27334
27335
27336 double normmat::compute_k13 (double lp)
27337
27338
27339 {
27340
27341
27342 double k13;
27343
27344
27345
27346
27347
27348 k13 = (-768*(pow(a1sp[0], 2)*pow(a1sp[1], 4)*pow(a1sp[2], 4)*pow(a1sp[3], 4)*
27349
27350
27351 pow(b1sp[0], 2)*ki[0] +
27352
27353
27354 pow(a1sp[0],
27355
27356
27357 4)*(pow(a1sp[1], 2)*pow(a1sp[2], 4)*pow(a1sp[3], 4)*
27358
27359
27360 pow(b1sp[1], 2)*ki[1] +
27361
27362
27363 pow(a1sp[1],
27364
27365
27366 4)*(pow(a1sp[2], 2)*pow(a1sp[3], 4)*pow(b1sp[2], 2)*
27367
27368
27369 ki[2] +
27370
27371
27372 pow(a1sp[2], 4)*pow(a1sp[3], 2)*pow(b1sp[3], 2)*
27373
27374
27375 ki[3]))))/(as1*e0c*
27376
27377
27378 pow(lp, 3)*(pow(a1sp[0], 4)*pow(a1sp[2], 4)*pow(a1sp[3], 4)*
27379
27380
27381 pow(b1sp[1], 4)*pow(ki[1], 2) +
27382
27383
27384 2*pow(a1sp[0], 2)*pow(a1sp[1], 2)*pow(a1sp[2], 2)*pow(a1sp[3], 2)*
27385
27386
27387 pow(b1sp[1], 2)*
27388
27389
27390 ki[1]*(7*pow(a1sp[0], 2)*pow(a1sp[3], 2)*pow(b1sp[2], 2)*ki[2] +
27391
27392
27393 pow(a1sp[2],
27394
27395
27396 2)*(7*pow(a1sp[3], 2)*pow(b1sp[0], 2)*ki[0] +
27397
27398
27399 25*pow(a1sp[0], 2)*pow(b1sp[3], 2)*ki[3])) +
27400
27401
27402 pow(a1sp[1],
27403
27404
27405 4)*(pow(a1sp[0], 4)*pow(a1sp[3], 4)*pow(b1sp[2], 4)*
27406
27407
27408 pow(ki[2], 2) +
27409
27410
27411 2*pow(a1sp[0], 2)*pow(a1sp[2], 2)*pow(a1sp[3], 2)*
27412
27413
27414 pow(b1sp[2], 2)*
27415
27416
27417 ki[2]*(25*pow(a1sp[3], 2)*pow(b1sp[0], 2)*ki[0] +
27418
27419
27420 7*pow(a1sp[0], 2)*pow(b1sp[3], 2)*ki[3]) +
27421
27422
27423 pow(a1sp[2],
27424
27425
27426 4)*(pow(a1sp[3], 4)*pow(b1sp[0], 4)*pow(ki[0], 2) +
27427
27428
27429 110*pow(a1sp[0], 2)*pow(a1sp[3], 2)*pow(b1sp[0], 2)*
27430
27431
27432 pow(b1sp[3], 2)*ki[0]*ki[3] +
27433
27434
27435 pow(a1sp[0], 4)*pow(b1sp[3], 4)*pow(ki[3], 2)))));
27436
27437
27438 return k13; }
27439
27440
27441
27442
27443
27444
27445
27446
27447 double normmat::compute_k14 (double lp)
27448
27449
27450 {
27451
27452
27453 double k14;
27454
27455
27456
27457
27458
27459 k14 = (-96*(7*pow(a1sp[0], 2)*pow(a1sp[1], 4)*pow(a1sp[2], 4)*pow(a1sp[3], 4)*
27460
27461
27462 pow(b1sp[0], 2)*ki[0] +
27463
27464
27465 pow(a1sp[0],
27466
27467
27468 4)*(5*pow(a1sp[1], 2)*pow(a1sp[2], 4)*pow(a1sp[3], 4)*
27469
27470
27471 pow(b1sp[1], 2)*ki[1] +
27472
27473
27474 pow(a1sp[1],
27475
27476
27477 4)*(3*pow(a1sp[2], 2)*pow(a1sp[3], 4)*pow(b1sp[2], 2)*
27478
27479
27480 ki[2] +
27481
27482
27483 pow(a1sp[2], 4)*pow(a1sp[3], 2)*pow(b1sp[3], 2)*
27484
27485
27486 ki[3]))))/(as1*e0c*
27487
27488
27489 pow(lp, 2)*(pow(a1sp[0], 4)*pow(a1sp[2], 4)*pow(a1sp[3], 4)*
27490
27491
27492 pow(b1sp[1], 4)*pow(ki[1], 2) +
27493
27494
27495 2*pow(a1sp[0], 2)*pow(a1sp[1], 2)*pow(a1sp[2], 2)*pow(a1sp[3], 2)*
27496
27497
27498 pow(b1sp[1], 2)*
27499
27500
27501 ki[1]*(7*pow(a1sp[0], 2)*pow(a1sp[3], 2)*pow(b1sp[2], 2)*ki[2] +
27502
27503
27504 pow(a1sp[2],
27505
27506
27507 2)*(7*pow(a1sp[3], 2)*pow(b1sp[0], 2)*ki[0] +
27508
27509
27510 25*pow(a1sp[0], 2)*pow(b1sp[3], 2)*ki[3])) +
27511
27512
27513 pow(a1sp[1],
27514
27515
27516 4)*(pow(a1sp[0], 4)*pow(a1sp[3], 4)*pow(b1sp[2], 4)*
27517
27518
27519 pow(ki[2], 2) +
27520
27521
27522 2*pow(a1sp[0], 2)*pow(a1sp[2], 2)*pow(a1sp[3], 2)*
27523
27524
27525 pow(b1sp[2], 2)*
27526
27527
27528 ki[2]*(25*pow(a1sp[3], 2)*pow(b1sp[0], 2)*ki[0] +
27529
27530
27531 7*pow(a1sp[0], 2)*pow(b1sp[3], 2)*ki[3]) +
27532
27533
27534 pow(a1sp[2],
27535
27536
27537 4)*(pow(a1sp[3], 4)*pow(b1sp[0], 4)*pow(ki[0], 2) +
27538
27539
27540 110*pow(a1sp[0], 2)*pow(a1sp[3], 2)*pow(b1sp[0], 2)*
27541
27542
27543 pow(b1sp[3], 2)*ki[0]*ki[3] +
27544
27545
27546 pow(a1sp[0], 4)*pow(b1sp[3], 4)*pow(ki[3], 2)))));
27547
27548
27549 return k14; }
27550
27551
27552
27553
27554
27555
27556
27557
27558 double normmat::compute_f1 (double lp)
27559
27560
27561 {
27562
27563
27564 double f1;
27565
27566
27567
27568
27569
27570 f1 = (-3*fp*pow(lp, 2)*pow(a1sp[0], 4)*pow(a1sp[2], 4)*pow(a1sp[3], 4)*
27571
27572
27573 pow(b1sp[1], 4)*pow(ki[1], 2) +
27574
27575
27576 384*pow(a1sp[0], 2)*pow(a1sp[1], 3)*pow(a1sp[2], 2)*pow(a1sp[3], 2)*
27577
27578
27579 b1sp[1]*b2sp[1]*
27580
27581
27582 ki[1]*(pow(a1sp[0], 2)*pow(a1sp[3], 2)*pow(b1sp[2], 2)*ki[2] +
27583
27584
27585 pow(a1sp[2],
27586
27587
27588 2)*(-(pow(a1sp[3], 2)*pow(b1sp[0], 2)*ki[0]) +
27589
27590
27591 2*pow(a1sp[0], 2)*pow(b1sp[3], 2)*ki[3])) -
27592
27593
27594 2*pow(a1sp[0], 2)*pow(a1sp[1], 2)*pow(a1sp[2], 2)*pow(a1sp[3], 2)*
27595
27596
27597 pow(b1sp[1], 2)*
27598
27599
27600 ki[1]*(4*pow(a1sp[0], 2)*
27601
27602
27603 pow(a1sp[3], 2)*(7*fp*pow(lp, 2) + 48*a2sp[1] - 48*a2sp[2])*
27604
27605
27606 pow(b1sp[2], 2)*ki[2] +
27607
27608
27609 192*pow(a1sp[0], 2)*a1sp[2]*pow(a1sp[3], 2)*b1sp[2]*b2sp[2]*
27610
27611
27612 ki[2] + pow(a1sp[2],
27613
27614
27615 2)*(2*pow(a1sp[3], 2)*
27616
27617
27618 b1sp[0]*((7*fp*pow(lp, 2) + 96*a2sp[0] - 96*a2sp[1])*
27619
27620
27621 b1sp[0] - 96*a1sp[0]*b2sp[0])*ki[0] +
27622
27623
27624 pow(a1sp[0],
27625
27626
27627 2)*(125*fp*pow(lp, 2) + 384*a2sp[1] - 384*a2sp[3])*
27628
27629
27630 pow(b1sp[3], 2)*ki[3] +
27631
27632
27633 384*pow(a1sp[0], 2)*a1sp[3]*b1sp[3]*b2sp[3]*ki[3])) -
27634
27635
27636 pow(a1sp[1],
27637
27638
27639 4)*(5*fp*pow(lp, 2)*pow(a1sp[0], 4)*pow(a1sp[3], 4)*pow(b1sp[2], 4)*
27640
27641
27642 pow(ki[2], 2) -
27643
27644
27645 384*pow(a1sp[0], 2)*pow(a1sp[2], 3)*pow(a1sp[3], 2)*b1sp[2]*
27646
27647
27648 b2sp[2]*ki[
27649
27650
27651 3]*(-2*pow(a1sp[3], 2)*pow(b1sp[0], 2)*ki[0] +
27652
27653
27654 pow(a1sp[0], 2)*pow(b1sp[3], 2)*ki[3]) +
27655
27656
27657 6*pow(a1sp[0], 2)*pow(a1sp[2], 2)*pow(a1sp[3], 2)*pow(b1sp[2], 2)*
27658
27659
27660 ki[2]*(pow(a1sp[3], 2)*
27661
27662
27663 b1sp[0]*((25*fp*pow(lp, 2) + 128*a2sp[0] - 128*a2sp[2])*
27664
27665
27666 b1sp[0] - 128*a1sp[0]*b2sp[0])*ki[0] +
27667
27668
27669 2*pow(a1sp[0],
27670
27671
27672 2)*(7*fp*pow(lp, 2) + 32*a2sp[2] - 32*a2sp[3])*
27673
27674
27675 pow(b1sp[3], 2)*ki[3] +
27676
27677
27678 64*pow(a1sp[0], 2)*a1sp[3]*b1sp[3]*b2sp[3]*ki[3]) +
27679
27680
27681 pow(a1sp[2],
27682
27683
27684 4)*(fp*pow(lp, 2)*pow(a1sp[3], 4)*pow(b1sp[0], 4)*
27685
27686
27687 pow(ki[0], 2) +
27688
27689
27690 8*pow(a1sp[0], 2)*pow(a1sp[3], 2)*b1sp[0]*
27691
27692
27693 pow(b1sp[3],
27694
27695
27696 2)*((55*fp*pow(lp, 2) + 144*a2sp[0] - 144*a2sp[3])*
27697
27698
27699 b1sp[0] - 144*a1sp[0]*b2sp[0])*ki[0]*ki[3] +
27700
27701
27702 1152*pow(a1sp[0], 2)*pow(a1sp[3], 3)*pow(b1sp[0], 2)*
27703
27704
27705 b1sp[3]*b2sp[3]*ki[0]*ki[3] +
27706
27707
27708 7*fp*pow(lp, 2)*pow(a1sp[0], 4)*pow(b1sp[3], 4)*
27709
27710
27711 pow(ki[3], 2))))/(8.*
27712
27713
27714 lp*(pow(a1sp[0], 4)*pow(a1sp[2], 4)*pow(a1sp[3], 4)*pow(b1sp[1], 4)*
27715
27716
27717 pow(ki[1], 2) +
27718
27719
27720 2*pow(a1sp[0], 2)*pow(a1sp[1], 2)*pow(a1sp[2], 2)*pow(a1sp[3], 2)*
27721
27722
27723 pow(b1sp[1], 2)*
27724
27725
27726 ki[1]*(7*pow(a1sp[0], 2)*pow(a1sp[3], 2)*pow(b1sp[2], 2)*ki[2] +
27727
27728
27729 pow(a1sp[2],
27730
27731
27732 2)*(7*pow(a1sp[3], 2)*pow(b1sp[0], 2)*ki[0] +
27733
27734
27735 25*pow(a1sp[0], 2)*pow(b1sp[3], 2)*ki[3])) +
27736
27737
27738 pow(a1sp[1],
27739
27740
27741 4)*(pow(a1sp[0], 4)*pow(a1sp[3], 4)*pow(b1sp[2], 4)*
27742
27743
27744 pow(ki[2], 2) +
27745
27746
27747 2*pow(a1sp[0], 2)*pow(a1sp[2], 2)*pow(a1sp[3], 2)*
27748
27749
27750 pow(b1sp[2], 2)*
27751
27752
27753 ki[2]*(25*pow(a1sp[3], 2)*pow(b1sp[0], 2)*ki[0] +
27754
27755
27756 7*pow(a1sp[0], 2)*pow(b1sp[3], 2)*ki[3]) +
27757
27758
27759 pow(a1sp[2],
27760
27761
27762 4)*(pow(a1sp[3], 4)*pow(b1sp[0], 4)*pow(ki[0], 2) +
27763
27764
27765 110*pow(a1sp[0], 2)*pow(a1sp[3], 2)*pow(b1sp[0], 2)*
27766
27767
27768 pow(b1sp[3], 2)*ki[0]*ki[3] +
27769
27770
27771 pow(a1sp[0], 4)*pow(b1sp[3], 4)*pow(ki[3], 2)))));
27772
27773
27774 return f1; }
27775
27776
27777
27778
27779
27780
27781
27782
27783 double normmat::compute_k21 (double lp)
27784
27785
27786 {
27787
27788
27789 double k21;
27790
27791
27792
27793
27794
27795 k21 = (-96*(pow(a1sp[0], 2)*pow(a1sp[1], 4)*pow(a1sp[2], 4)*pow(a1sp[3], 4)*
27796
27797
27798 pow(b1sp[0], 2)*ki[0] +
27799
27800
27801 pow(a1sp[0],
27802
27803
27804 4)*(3*pow(a1sp[1], 2)*pow(a1sp[2], 4)*pow(a1sp[3], 4)*
27805
27806
27807 pow(b1sp[1], 2)*ki[1] +
27808
27809
27810 pow(a1sp[1],
27811
27812
27813 4)*(5*pow(a1sp[2], 2)*pow(a1sp[3], 4)*pow(b1sp[2], 2)*
27814
27815
27816 ki[2] +
27817
27818
27819 7*pow(a1sp[2], 4)*pow(a1sp[3], 2)*pow(b1sp[3], 2)*
27820
27821
27822 ki[3]))))/(as1*e0c*
27823
27824
27825 pow(lp, 2)*(pow(a1sp[0], 4)*pow(a1sp[2], 4)*pow(a1sp[3], 4)*
27826
27827
27828 pow(b1sp[1], 4)*pow(ki[1], 2) +
27829
27830
27831 2*pow(a1sp[0], 2)*pow(a1sp[1], 2)*pow(a1sp[2], 2)*pow(a1sp[3], 2)*
27832
27833
27834 pow(b1sp[1], 2)*
27835
27836
27837 ki[1]*(7*pow(a1sp[0], 2)*pow(a1sp[3], 2)*pow(b1sp[2], 2)*ki[2] +
27838
27839
27840 pow(a1sp[2],
27841
27842
27843 2)*(7*pow(a1sp[3], 2)*pow(b1sp[0], 2)*ki[0] +
27844
27845
27846 25*pow(a1sp[0], 2)*pow(b1sp[3], 2)*ki[3])) +
27847
27848
27849 pow(a1sp[1],
27850
27851
27852 4)*(pow(a1sp[0], 4)*pow(a1sp[3], 4)*pow(b1sp[2], 4)*
27853
27854
27855 pow(ki[2], 2) +
27856
27857
27858 2*pow(a1sp[0], 2)*pow(a1sp[2], 2)*pow(a1sp[3], 2)*
27859
27860
27861 pow(b1sp[2], 2)*
27862
27863
27864 ki[2]*(25*pow(a1sp[3], 2)*pow(b1sp[0], 2)*ki[0] +
27865
27866
27867 7*pow(a1sp[0], 2)*pow(b1sp[3], 2)*ki[3]) +
27868
27869
27870 pow(a1sp[2],
27871
27872
27873 4)*(pow(a1sp[3], 4)*pow(b1sp[0], 4)*pow(ki[0], 2) +
27874
27875
27876 110*pow(a1sp[0], 2)*pow(a1sp[3], 2)*pow(b1sp[0], 2)*
27877
27878
27879 pow(b1sp[3], 2)*ki[0]*ki[3] +
27880
27881
27882 pow(a1sp[0], 4)*pow(b1sp[3], 4)*pow(ki[3], 2)))));
27883
27884
27885 return k21; }
27886
27887
27888
27889
27890
27891
27892
27893
27894 double normmat::compute_k22 (double lp)
27895
27896
27897 {
27898
27899
27900 double k22;
27901
27902
27903
27904
27905
27906 k22 = (16*(pow(a1sp[0], 2)*pow(a1sp[1], 4)*pow(a1sp[2], 4)*pow(a1sp[3], 4)*
27907
27908
27909 pow(b1sp[0], 2)*ki[0] +
27910
27911
27912 pow(a1sp[0],
27913
27914
27915 4)*(7*pow(a1sp[1], 2)*pow(a1sp[2], 4)*pow(a1sp[3], 4)*
27916
27917
27918 pow(b1sp[1], 2)*ki[1] +
27919
27920
27921 pow(a1sp[1],
27922
27923
27924 4)*(19*pow(a1sp[2], 2)*pow(a1sp[3], 4)*pow(b1sp[2], 2)*
27925
27926
27927 ki[2] +
27928
27929
27930 37*pow(a1sp[2], 4)*pow(a1sp[3], 2)*pow(b1sp[3], 2)*
27931
27932
27933 ki[3]))))/(as1*e0c*
27934
27935
27936 lp*(pow(a1sp[0], 4)*pow(a1sp[2], 4)*pow(a1sp[3], 4)*pow(b1sp[1], 4)*
27937
27938
27939 pow(ki[1], 2) +
27940
27941
27942 2*pow(a1sp[0], 2)*pow(a1sp[1], 2)*pow(a1sp[2], 2)*pow(a1sp[3], 2)*
27943
27944
27945 pow(b1sp[1], 2)*
27946
27947
27948 ki[1]*(7*pow(a1sp[0], 2)*pow(a1sp[3], 2)*pow(b1sp[2], 2)*ki[2] +
27949
27950
27951 pow(a1sp[2],
27952
27953
27954 2)*(7*pow(a1sp[3], 2)*pow(b1sp[0], 2)*ki[0] +
27955
27956
27957 25*pow(a1sp[0], 2)*pow(b1sp[3], 2)*ki[3])) +
27958
27959
27960 pow(a1sp[1],
27961
27962
27963 4)*(pow(a1sp[0], 4)*pow(a1sp[3], 4)*pow(b1sp[2], 4)*
27964
27965
27966 pow(ki[2], 2) +
27967
27968
27969 2*pow(a1sp[0], 2)*pow(a1sp[2], 2)*pow(a1sp[3], 2)*
27970
27971
27972 pow(b1sp[2], 2)*
27973
27974
27975 ki[2]*(25*pow(a1sp[3], 2)*pow(b1sp[0], 2)*ki[0] +
27976
27977
27978 7*pow(a1sp[0], 2)*pow(b1sp[3], 2)*ki[3]) +
27979
27980
27981 pow(a1sp[2],
27982
27983
27984 4)*(pow(a1sp[3], 4)*pow(b1sp[0], 4)*pow(ki[0], 2) +
27985
27986
27987 110*pow(a1sp[0], 2)*pow(a1sp[3], 2)*pow(b1sp[0], 2)*
27988
27989
27990 pow(b1sp[3], 2)*ki[0]*ki[3] +
27991
27992
27993 pow(a1sp[0], 4)*pow(b1sp[3], 4)*pow(ki[3], 2)))));
27994
27995
27996 return k22; }
27997
27998
27999
28000
28001
28002
28003 double normmat::compute_k23 (double lp)
28004
28005
28006 {
28007
28008
28009 double k23;
28010
28011
28012
28013
28014
28015 k23 = (96*(pow(a1sp[0], 2)*pow(a1sp[1], 4)*pow(a1sp[2], 4)*pow(a1sp[3], 4)*
28016
28017
28018 pow(b1sp[0], 2)*ki[0] +
28019
28020
28021 pow(a1sp[0],
28022
28023
28024 4)*(3*pow(a1sp[1], 2)*pow(a1sp[2], 4)*pow(a1sp[3], 4)*
28025
28026
28027 pow(b1sp[1], 2)*ki[1] +
28028
28029
28030 pow(a1sp[1],
28031
28032
28033 4)*(5*pow(a1sp[2], 2)*pow(a1sp[3], 4)*pow(b1sp[2], 2)*
28034
28035
28036 ki[2] +
28037
28038
28039 7*pow(a1sp[2], 4)*pow(a1sp[3], 2)*pow(b1sp[3], 2)*
28040
28041
28042 ki[3]))))/(as1*e0c*
28043
28044
28045 pow(lp, 2)*(pow(a1sp[0], 4)*pow(a1sp[2], 4)*pow(a1sp[3], 4)*
28046
28047
28048 pow(b1sp[1], 4)*pow(ki[1], 2) +
28049
28050
28051 2*pow(a1sp[0], 2)*pow(a1sp[1], 2)*pow(a1sp[2], 2)*pow(a1sp[3], 2)*
28052
28053
28054 pow(b1sp[1], 2)*
28055
28056
28057 ki[1]*(7*pow(a1sp[0], 2)*pow(a1sp[3], 2)*pow(b1sp[2], 2)*ki[2] +
28058
28059
28060 pow(a1sp[2],
28061
28062
28063 2)*(7*pow(a1sp[3], 2)*pow(b1sp[0], 2)*ki[0] +
28064
28065
28066 25*pow(a1sp[0], 2)*pow(b1sp[3], 2)*ki[3])) +
28067
28068
28069 pow(a1sp[1],
28070
28071
28072 4)*(pow(a1sp[0], 4)*pow(a1sp[3], 4)*pow(b1sp[2], 4)*
28073
28074
28075 pow(ki[2], 2) +
28076
28077
28078 2*pow(a1sp[0], 2)*pow(a1sp[2], 2)*pow(a1sp[3], 2)*
28079
28080
28081 pow(b1sp[2], 2)*
28082
28083
28084 ki[2]*(25*pow(a1sp[3], 2)*pow(b1sp[0], 2)*ki[0] +
28085
28086
28087 7*pow(a1sp[0], 2)*pow(b1sp[3], 2)*ki[3]) +
28088
28089
28090 pow(a1sp[2],
28091
28092
28093 4)*(pow(a1sp[3], 4)*pow(b1sp[0], 4)*pow(ki[0], 2) +
28094
28095
28096 110*pow(a1sp[0], 2)*pow(a1sp[3], 2)*pow(b1sp[0], 2)*
28097
28098
28099 pow(b1sp[3], 2)*ki[0]*ki[3] +
28100
28101
28102 pow(a1sp[0], 4)*pow(b1sp[3], 4)*pow(ki[3], 2)))));
28103
28104
28105 return k23; }
28106
28107
28108
28109
28110
28111
28112
28113
28114 double normmat::compute_k24 (double lp)
28115
28116
28117 {
28118
28119
28120 double k24;
28121
28122
28123
28124
28125
28126 k24 = (16*(5*pow(a1sp[0], 2)*pow(a1sp[1], 4)*pow(a1sp[2], 4)*pow(a1sp[3], 4)*
28127
28128
28129 pow(b1sp[0], 2)*ki[0] +
28130
28131
28132 pow(a1sp[0],
28133
28134
28135 4)*(11*pow(a1sp[1], 2)*pow(a1sp[2], 4)*pow(a1sp[3], 4)*
28136
28137
28138 pow(b1sp[1], 2)*ki[1] +
28139
28140
28141 pow(a1sp[1],
28142
28143
28144 4)*(11*pow(a1sp[2], 2)*pow(a1sp[3], 4)*pow(b1sp[2], 2)*
28145
28146
28147 ki[2] +
28148
28149
28150 5*pow(a1sp[2], 4)*pow(a1sp[3], 2)*pow(b1sp[3], 2)*
28151
28152
28153 ki[3]))))/(as1*e0c*
28154
28155
28156 lp*(pow(a1sp[0], 4)*pow(a1sp[2], 4)*pow(a1sp[3], 4)*pow(b1sp[1], 4)*
28157
28158
28159 pow(ki[1], 2) +
28160
28161
28162 2*pow(a1sp[0], 2)*pow(a1sp[1], 2)*pow(a1sp[2], 2)*pow(a1sp[3], 2)*
28163
28164
28165 pow(b1sp[1], 2)*
28166
28167
28168 ki[1]*(7*pow(a1sp[0], 2)*pow(a1sp[3], 2)*pow(b1sp[2], 2)*ki[2] +
28169
28170
28171 pow(a1sp[2],
28172
28173
28174 2)*(7*pow(a1sp[3], 2)*pow(b1sp[0], 2)*ki[0] +
28175
28176
28177 25*pow(a1sp[0], 2)*pow(b1sp[3], 2)*ki[3])) +
28178
28179
28180 pow(a1sp[1],
28181
28182
28183 4)*(pow(a1sp[0], 4)*pow(a1sp[3], 4)*pow(b1sp[2], 4)*
28184
28185
28186 pow(ki[2], 2) +
28187
28188
28189 2*pow(a1sp[0], 2)*pow(a1sp[2], 2)*pow(a1sp[3], 2)*
28190
28191
28192 pow(b1sp[2], 2)*
28193
28194
28195 ki[2]*(25*pow(a1sp[3], 2)*pow(b1sp[0], 2)*ki[0] +
28196
28197
28198 7*pow(a1sp[0], 2)*pow(b1sp[3], 2)*ki[3]) +
28199
28200
28201 pow(a1sp[2],
28202
28203
28204 4)*(pow(a1sp[3], 4)*pow(b1sp[0], 4)*pow(ki[0], 2) +
28205
28206
28207 110*pow(a1sp[0], 2)*pow(a1sp[3], 2)*pow(b1sp[0], 2)*
28208
28209
28210 pow(b1sp[3], 2)*ki[0]*ki[3] +
28211
28212
28213 pow(a1sp[0], 4)*pow(b1sp[3], 4)*pow(ki[3], 2)))));
28214
28215
28216 return k24; }
28217
28218
28219
28220
28221
28222
28223
28224
28225 double normmat::compute_f2 (double lp)
28226
28227
28228
28229
28230
28231 {
28232
28233
28234 double f2;
28235
28236
28237
28238
28239
28240 f2 = (pow(a1sp[0], 4)*pow(a1sp[2], 4)*
28241
28242
28243 pow(a1sp[3], 4)*(13*fp*pow(lp, 2) + 192*a2sp[1])*pow(b1sp[1], 4)*
28244
28245
28246 pow(ki[1], 2) -
28247
28248
28249 192*pow(a1sp[0], 4)*a1sp[1]*pow(a1sp[2], 4)*pow(a1sp[3], 4)*
28250
28251
28252 pow(b1sp[1], 3)*b2sp[1]*pow(ki[1], 2) -
28253
28254
28255 192*pow(a1sp[0], 2)*pow(a1sp[1], 3)*pow(a1sp[2], 2)*pow(a1sp[3], 2)*
28256
28257
28258 b1sp[1]*b2sp[1]*
28259
28260
28261 ki[1]*(31*pow(a1sp[0], 2)*pow(a1sp[3], 2)*pow(b1sp[2], 2)*ki[2] -
28262
28263
28264 5*pow(a1sp[2],
28265
28266
28267 2)*(pow(a1sp[3], 2)*pow(b1sp[0], 2)*ki[0] -
28268
28269
28270 17*pow(a1sp[0], 2)*pow(b1sp[3], 2)*ki[3])) +
28271
28272
28273 2*pow(a1sp[0], 2)*pow(a1sp[1], 2)*pow(a1sp[2], 2)*pow(a1sp[3], 2)*
28274
28275
28276 pow(b1sp[1], 2)*
28277
28278
28279 ki[1]*(pow(a1sp[0], 2)*
28280
28281
28282 pow(a1sp[3],
28283
28284
28285 2)*(151*fp*pow(lp, 2) + 2976*a2sp[1] - 1632*a2sp[2])*
28286
28287
28288 pow(b1sp[2], 2)*ki[2] +
28289
28290
28291 1632*pow(a1sp[0], 2)*a1sp[2]*pow(a1sp[3], 2)*b1sp[2]*b2sp[2]*
28292
28293
28294 ki[2] + pow(a1sp[2],
28295
28296
28297 2)*(pow(a1sp[3], 2)*
28298
28299
28300 b1sp[0]*((25*fp*pow(lp, 2) + 1824*a2sp[0] - 480*a2sp[1])*
28301
28302
28303 b1sp[0] - 1824*a1sp[0]*b2sp[0])*ki[0] +
28304
28305
28306 pow(a1sp[0],
28307
28308
28309 2)*(763*fp*pow(lp, 2) + 8160*a2sp[1] - 3360*a2sp[3])*
28310
28311
28312 pow(b1sp[3], 2)*ki[3] +
28313
28314
28315 3360*pow(a1sp[0], 2)*a1sp[3]*b1sp[3]*b2sp[3]*ki[3])) +
28316
28317
28318 pow(a1sp[1],
28319
28320
28321 4)*(pow(a1sp[0], 4)*
28322
28323
28324 pow(a1sp[3], 4)*(37*fp*pow(lp, 2) + 192*a2sp[2])*
28325
28326
28327 pow(b1sp[2], 4)*pow(ki[2], 2) -
28328
28329
28330 192*pow(a1sp[0], 4)*a1sp[2]*pow(a1sp[3], 4)*pow(b1sp[2], 3)*
28331
28332
28333 b2sp[2]*pow(ki[2], 2) -
28334
28335
28336 192*pow(a1sp[0], 2)*pow(a1sp[2], 3)*pow(a1sp[3], 2)*b1sp[2]*
28337
28338
28339 b2sp[2]*ki[
28340
28341
28342 3]*(-11*pow(a1sp[3], 2)*pow(b1sp[0], 2)*ki[0] +
28343
28344
28345 43*pow(a1sp[0], 2)*pow(b1sp[3], 2)*ki[3]) +
28346
28347
28348 2*pow(a1sp[0], 2)*pow(a1sp[2], 2)*pow(a1sp[3], 2)*pow(b1sp[2], 2)*
28349
28350
28351 ki[2]*(pow(a1sp[3], 2)*
28352
28353
28354 b1sp[0]*((163*fp*pow(lp, 2) + 5856*a2sp[0] -
28355
28356
28357 1056*a2sp[2])*b1sp[0] - 5856*a1sp[0]*b2sp[0])*
28358
28359
28360 ki[0] +
28361
28362
28363 pow(a1sp[0],
28364
28365
28366 2)*(361*fp*pow(lp, 2) + 4128*a2sp[2] - 2784*a2sp[3])*
28367
28368
28369 pow(b1sp[3], 2)*ki[3] +
28370
28371
28372 2784*pow(a1sp[0], 2)*a1sp[3]*b1sp[3]*b2sp[3]*ki[3]) +
28373
28374
28375 pow(a1sp[2],
28376
28377
28378 4)*(pow(a1sp[3], 4)*
28379
28380
28381 pow(b1sp[0],
28382
28383
28384 3)*((fp*pow(lp, 2) + 192*a2sp[0])*b1sp[0] -
28385
28386
28387 192*a1sp[0]*b2sp[0])*pow(ki[0], 2) +
28388
28389
28390 2*pow(a1sp[0], 2)*pow(a1sp[3], 2)*b1sp[0]*
28391
28392
28393 pow(b1sp[3],
28394
28395
28396 2)*((523*fp*pow(lp, 2) + 12192*a2sp[0] - 1632*a2sp[3])*
28397
28398
28399 b1sp[0] - 12192*a1sp[0]*b2sp[0])*ki[0]*ki[3] +
28400
28401
28402 3264*pow(a1sp[0], 2)*pow(a1sp[3], 3)*pow(b1sp[0], 2)*
28403
28404
28405 b1sp[3]*b2sp[3]*ki[0]*ki[3] +
28406
28407
28408 pow(a1sp[0], 4)*(73*fp*pow(lp, 2) + 192*a2sp[3])*
28409
28410
28411 pow(b1sp[3], 4)*pow(ki[3], 2) -
28412
28413
28414 192*pow(a1sp[0], 4)*a1sp[3]*pow(b1sp[3], 3)*b2sp[3]*
28415
28416
28417 pow(ki[3], 2))))/(192.*(pow(a1sp[0], 4)*pow(a1sp[2], 4)*
28418
28419
28420 pow(a1sp[3], 4)*pow(b1sp[1], 4)*pow(ki[1], 2) +
28421
28422
28423 2*pow(a1sp[0], 2)*pow(a1sp[1], 2)*pow(a1sp[2], 2)*pow(a1sp[3], 2)*
28424
28425
28426 pow(b1sp[1], 2)*
28427
28428
28429 ki[1]*(7*pow(a1sp[0], 2)*pow(a1sp[3], 2)*pow(b1sp[2], 2)*ki[2] +
28430
28431
28432 pow(a1sp[2],
28433
28434
28435 2)*(7*pow(a1sp[3], 2)*pow(b1sp[0], 2)*ki[0] +
28436
28437
28438 25*pow(a1sp[0], 2)*pow(b1sp[3], 2)*ki[3])) +
28439
28440
28441 pow(a1sp[1],
28442
28443
28444 4)*(pow(a1sp[0], 4)*pow(a1sp[3], 4)*pow(b1sp[2], 4)*
28445
28446
28447 pow(ki[2], 2) +
28448
28449
28450 2*pow(a1sp[0], 2)*pow(a1sp[2], 2)*pow(a1sp[3], 2)*
28451
28452
28453 pow(b1sp[2], 2)*
28454
28455
28456 ki[2]*(25*pow(a1sp[3], 2)*pow(b1sp[0], 2)*ki[0] +
28457
28458
28459 7*pow(a1sp[0], 2)*pow(b1sp[3], 2)*ki[3]) +
28460
28461
28462 pow(a1sp[2],
28463
28464
28465 4)*(pow(a1sp[3], 4)*pow(b1sp[0], 4)*pow(ki[0], 2) +
28466
28467
28468 110*pow(a1sp[0], 2)*pow(a1sp[3], 2)*pow(b1sp[0], 2)*
28469
28470
28471 pow(b1sp[3], 2)*ki[0]*ki[3] +
28472
28473
28474 pow(a1sp[0], 4)*pow(b1sp[3], 4)*pow(ki[3], 2)))));
28475
28476
28477 return f2; }
28478
28479
28480
28481
28482
28483
28484
28485
28486 double normmat::compute_k31 (double lp)
28487
28488
28489 {
28490
28491
28492 double k31;
28493
28494
28495
28496
28497
28498 k31 = (-768*(pow(a1sp[0], 2)*pow(a1sp[1], 4)*pow(a1sp[2], 4)*pow(a1sp[3], 4)*
28499
28500
28501 pow(b1sp[0], 2)*ki[0] +
28502
28503
28504 pow(a1sp[0],
28505
28506
28507 4)*(pow(a1sp[1], 2)*pow(a1sp[2], 4)*pow(a1sp[3], 4)*
28508
28509
28510 pow(b1sp[1], 2)*ki[1] +
28511
28512
28513 pow(a1sp[1],
28514
28515
28516 4)*(pow(a1sp[2], 2)*pow(a1sp[3], 4)*pow(b1sp[2], 2)*
28517
28518
28519 ki[2] +
28520
28521
28522 pow(a1sp[2], 4)*pow(a1sp[3], 2)*pow(b1sp[3], 2)*
28523
28524
28525 ki[3]))))/(as1*e0c*
28526
28527
28528 pow(lp, 3)*(pow(a1sp[0], 4)*pow(a1sp[2], 4)*pow(a1sp[3], 4)*
28529
28530
28531 pow(b1sp[1], 4)*pow(ki[1], 2) +
28532
28533
28534 2*pow(a1sp[0], 2)*pow(a1sp[1], 2)*pow(a1sp[2], 2)*pow(a1sp[3], 2)*
28535
28536
28537 pow(b1sp[1], 2)*
28538
28539
28540 ki[1]*(7*pow(a1sp[0], 2)*pow(a1sp[3], 2)*pow(b1sp[2], 2)*ki[2] +
28541
28542
28543 pow(a1sp[2],
28544
28545
28546 2)*(7*pow(a1sp[3], 2)*pow(b1sp[0], 2)*ki[0] +
28547
28548
28549 25*pow(a1sp[0], 2)*pow(b1sp[3], 2)*ki[3])) +
28550
28551
28552 pow(a1sp[1],
28553
28554
28555 4)*(pow(a1sp[0], 4)*pow(a1sp[3], 4)*pow(b1sp[2], 4)*
28556
28557
28558 pow(ki[2], 2) +
28559
28560
28561 2*pow(a1sp[0], 2)*pow(a1sp[2], 2)*pow(a1sp[3], 2)*
28562
28563
28564 pow(b1sp[2], 2)*
28565
28566
28567 ki[2]*(25*pow(a1sp[3], 2)*pow(b1sp[0], 2)*ki[0] +
28568
28569
28570 7*pow(a1sp[0], 2)*pow(b1sp[3], 2)*ki[3]) +
28571
28572
28573 pow(a1sp[2],
28574
28575
28576 4)*(pow(a1sp[3], 4)*pow(b1sp[0], 4)*pow(ki[0], 2) +
28577
28578
28579 110*pow(a1sp[0], 2)*pow(a1sp[3], 2)*pow(b1sp[0], 2)*
28580
28581
28582 pow(b1sp[3], 2)*ki[0]*ki[3] +
28583
28584
28585 pow(a1sp[0], 4)*pow(b1sp[3], 4)*pow(ki[3], 2)))));
28586
28587
28588 return k31; }
28589
28590
28591
28592
28593
28594
28595
28596
28597 double normmat::compute_k32 (double lp)
28598
28599
28600 {
28601
28602
28603 double k32;
28604
28605
28606
28607
28608
28609 k32 = (96*(pow(a1sp[0], 2)*pow(a1sp[1], 4)*pow(a1sp[2], 4)*pow(a1sp[3], 4)*
28610
28611
28612 pow(b1sp[0], 2)*ki[0] +
28613
28614
28615 pow(a1sp[0],
28616
28617
28618 4)*(3*pow(a1sp[1], 2)*pow(a1sp[2], 4)*pow(a1sp[3], 4)*
28619
28620
28621 pow(b1sp[1], 2)*ki[1] +
28622
28623
28624 pow(a1sp[1],
28625
28626
28627 4)*(5*pow(a1sp[2], 2)*pow(a1sp[3], 4)*pow(b1sp[2], 2)*
28628
28629
28630 ki[2] +
28631
28632
28633 7*pow(a1sp[2], 4)*pow(a1sp[3], 2)*pow(b1sp[3], 2)*
28634
28635
28636 ki[3]))))/(as1*e0c*
28637
28638
28639 pow(lp, 2)*(pow(a1sp[0], 4)*pow(a1sp[2], 4)*pow(a1sp[3], 4)*
28640
28641
28642 pow(b1sp[1], 4)*pow(ki[1], 2) +
28643
28644
28645 2*pow(a1sp[0], 2)*pow(a1sp[1], 2)*pow(a1sp[2], 2)*pow(a1sp[3], 2)*
28646
28647
28648 pow(b1sp[1], 2)*
28649
28650
28651 ki[1]*(7*pow(a1sp[0], 2)*pow(a1sp[3], 2)*pow(b1sp[2], 2)*ki[2] +
28652
28653
28654 pow(a1sp[2],
28655
28656
28657 2)*(7*pow(a1sp[3], 2)*pow(b1sp[0], 2)*ki[0] +
28658
28659
28660 25*pow(a1sp[0], 2)*pow(b1sp[3], 2)*ki[3])) +
28661
28662
28663 pow(a1sp[1],
28664
28665
28666 4)*(pow(a1sp[0], 4)*pow(a1sp[3], 4)*pow(b1sp[2], 4)*
28667
28668
28669 pow(ki[2], 2) +
28670
28671
28672 2*pow(a1sp[0], 2)*pow(a1sp[2], 2)*pow(a1sp[3], 2)*
28673
28674
28675 pow(b1sp[2], 2)*
28676
28677
28678 ki[2]*(25*pow(a1sp[3], 2)*pow(b1sp[0], 2)*ki[0] +
28679
28680
28681 7*pow(a1sp[0], 2)*pow(b1sp[3], 2)*ki[3]) +
28682
28683
28684 pow(a1sp[2],
28685
28686
28687 4)*(pow(a1sp[3], 4)*pow(b1sp[0], 4)*pow(ki[0], 2) +
28688
28689
28690 110*pow(a1sp[0], 2)*pow(a1sp[3], 2)*pow(b1sp[0], 2)*
28691
28692
28693 pow(b1sp[3], 2)*ki[0]*ki[3] +
28694
28695
28696 pow(a1sp[0], 4)*pow(b1sp[3], 4)*pow(ki[3], 2)))));
28697
28698
28699 return k32; }
28700
28701
28702
28703
28704
28705
28706 double normmat::compute_k33 (double lp)
28707
28708
28709 {
28710
28711
28712 double k33;
28713
28714
28715
28716
28717
28718 k33 = (768*(pow(a1sp[0], 2)*pow(a1sp[1], 4)*pow(a1sp[2], 4)*pow(a1sp[3], 4)*
28719
28720
28721 pow(b1sp[0], 2)*ki[0] +
28722
28723
28724 pow(a1sp[0],
28725
28726
28727 4)*(pow(a1sp[1], 2)*pow(a1sp[2], 4)*pow(a1sp[3], 4)*
28728
28729
28730 pow(b1sp[1], 2)*ki[1] +
28731
28732
28733 pow(a1sp[1],
28734
28735
28736 4)*(pow(a1sp[2], 2)*pow(a1sp[3], 4)*pow(b1sp[2], 2)*
28737
28738
28739 ki[2] +
28740
28741
28742 pow(a1sp[2], 4)*pow(a1sp[3], 2)*pow(b1sp[3], 2)*
28743
28744
28745 ki[3]))))/(as1*e0c*
28746
28747
28748 pow(lp, 3)*(pow(a1sp[0], 4)*pow(a1sp[2], 4)*pow(a1sp[3], 4)*
28749
28750
28751 pow(b1sp[1], 4)*pow(ki[1], 2) +
28752
28753
28754 2*pow(a1sp[0], 2)*pow(a1sp[1], 2)*pow(a1sp[2], 2)*pow(a1sp[3], 2)*
28755
28756
28757 pow(b1sp[1], 2)*
28758
28759
28760 ki[1]*(7*pow(a1sp[0], 2)*pow(a1sp[3], 2)*pow(b1sp[2], 2)*ki[2] +
28761
28762
28763 pow(a1sp[2],
28764
28765
28766 2)*(7*pow(a1sp[3], 2)*pow(b1sp[0], 2)*ki[0] +
28767
28768
28769 25*pow(a1sp[0], 2)*pow(b1sp[3], 2)*ki[3])) +
28770
28771
28772 pow(a1sp[1],
28773
28774
28775 4)*(pow(a1sp[0], 4)*pow(a1sp[3], 4)*pow(b1sp[2], 4)*
28776
28777
28778 pow(ki[2], 2) +
28779
28780
28781 2*pow(a1sp[0], 2)*pow(a1sp[2], 2)*pow(a1sp[3], 2)*
28782
28783
28784 pow(b1sp[2], 2)*
28785
28786
28787 ki[2]*(25*pow(a1sp[3], 2)*pow(b1sp[0], 2)*ki[0] +
28788
28789
28790 7*pow(a1sp[0], 2)*pow(b1sp[3], 2)*ki[3]) +
28791
28792
28793 pow(a1sp[2],
28794
28795
28796 4)*(pow(a1sp[3], 4)*pow(b1sp[0], 4)*pow(ki[0], 2) +
28797
28798
28799 110*pow(a1sp[0], 2)*pow(a1sp[3], 2)*pow(b1sp[0], 2)*
28800
28801
28802 pow(b1sp[3], 2)*ki[0]*ki[3] +
28803
28804
28805 pow(a1sp[0], 4)*pow(b1sp[3], 4)*pow(ki[3], 2)))));
28806
28807
28808 return k33; }
28809
28810
28811
28812
28813
28814
28815
28816
28817 double normmat::compute_k34 (double lp)
28818
28819
28820 {
28821
28822
28823 double k34;
28824
28825
28826
28827
28828
28829 k34 = (96*(7*pow(a1sp[0], 2)*pow(a1sp[1], 4)*pow(a1sp[2], 4)*pow(a1sp[3], 4)*
28830
28831
28832 pow(b1sp[0], 2)*ki[0] +
28833
28834
28835 pow(a1sp[0],
28836
28837
28838 4)*(5*pow(a1sp[1], 2)*pow(a1sp[2], 4)*pow(a1sp[3], 4)*
28839
28840
28841 pow(b1sp[1], 2)*ki[1] +
28842
28843
28844 pow(a1sp[1],
28845
28846
28847 4)*(3*pow(a1sp[2], 2)*pow(a1sp[3], 4)*pow(b1sp[2], 2)*
28848
28849
28850 ki[2] +
28851
28852
28853 pow(a1sp[2], 4)*pow(a1sp[3], 2)*pow(b1sp[3], 2)*
28854
28855
28856 ki[3]))))/(as1*e0c*
28857
28858
28859 pow(lp, 2)*(pow(a1sp[0], 4)*pow(a1sp[2], 4)*pow(a1sp[3], 4)*
28860
28861
28862 pow(b1sp[1], 4)*pow(ki[1], 2) +
28863
28864
28865 2*pow(a1sp[0], 2)*pow(a1sp[1], 2)*pow(a1sp[2], 2)*pow(a1sp[3], 2)*
28866
28867
28868 pow(b1sp[1], 2)*
28869
28870
28871 ki[1]*(7*pow(a1sp[0], 2)*pow(a1sp[3], 2)*pow(b1sp[2], 2)*ki[2] +
28872
28873
28874 pow(a1sp[2],
28875
28876
28877 2)*(7*pow(a1sp[3], 2)*pow(b1sp[0], 2)*ki[0] +
28878
28879
28880 25*pow(a1sp[0], 2)*pow(b1sp[3], 2)*ki[3])) +
28881
28882
28883 pow(a1sp[1],
28884
28885
28886 4)*(pow(a1sp[0], 4)*pow(a1sp[3], 4)*pow(b1sp[2], 4)*
28887
28888
28889 pow(ki[2], 2) +
28890
28891
28892 2*pow(a1sp[0], 2)*pow(a1sp[2], 2)*pow(a1sp[3], 2)*
28893
28894
28895 pow(b1sp[2], 2)*
28896
28897
28898 ki[2]*(25*pow(a1sp[3], 2)*pow(b1sp[0], 2)*ki[0] +
28899
28900
28901 7*pow(a1sp[0], 2)*pow(b1sp[3], 2)*ki[3]) +
28902
28903
28904 pow(a1sp[2],
28905
28906
28907 4)*(pow(a1sp[3], 4)*pow(b1sp[0], 4)*pow(ki[0], 2) +
28908
28909
28910 110*pow(a1sp[0], 2)*pow(a1sp[3], 2)*pow(b1sp[0], 2)*
28911
28912
28913 pow(b1sp[3], 2)*ki[0]*ki[3] +
28914
28915
28916 pow(a1sp[0], 4)*pow(b1sp[3], 4)*pow(ki[3], 2)))));
28917
28918
28919 return k34; }
28920
28921
28922
28923
28924
28925
28926
28927
28928 double normmat::compute_f3 (double lp)
28929
28930
28931
28932
28933
28934 {
28935
28936
28937 double f3;
28938
28939
28940
28941
28942
28943 f3 = (-5*fp*pow(lp, 2)*pow(a1sp[0], 4)*pow(a1sp[2], 4)*pow(a1sp[3], 4)*
28944
28945
28946 pow(b1sp[1], 4)*pow(ki[1], 2) -
28947
28948
28949 384*pow(a1sp[0], 2)*pow(a1sp[1], 3)*pow(a1sp[2], 2)*pow(a1sp[3], 2)*
28950
28951
28952 b1sp[1]*b2sp[1]*
28953
28954
28955 ki[1]*(pow(a1sp[0], 2)*pow(a1sp[3], 2)*pow(b1sp[2], 2)*ki[2] +
28956
28957
28958 pow(a1sp[2],
28959
28960
28961 2)*(-(pow(a1sp[3], 2)*pow(b1sp[0], 2)*ki[0]) +
28962
28963
28964 2*pow(a1sp[0], 2)*pow(b1sp[3], 2)*ki[3])) -
28965
28966
28967 2*pow(a1sp[0], 2)*pow(a1sp[1], 2)*pow(a1sp[2], 2)*pow(a1sp[3], 2)*
28968
28969
28970 pow(b1sp[1], 2)*
28971
28972
28973 ki[1]*(4*pow(a1sp[0], 2)*
28974
28975
28976 pow(a1sp[3], 2)*(7*fp*pow(lp, 2) - 48*a2sp[1] + 48*a2sp[2])*
28977
28978
28979 pow(b1sp[2], 2)*ki[2] -
28980
28981
28982 192*pow(a1sp[0], 2)*a1sp[2]*pow(a1sp[3], 2)*b1sp[2]*b2sp[2]*
28983
28984
28985 ki[2] + 3*
28986
28987
28988 pow(a1sp[2],
28989
28990
28991 2)*(2*pow(a1sp[3], 2)*
28992
28993
28994 b1sp[0]*((7*fp*pow(lp, 2) - 32*a2sp[0] + 32*a2sp[1])*
28995
28996
28997 b1sp[0] + 32*a1sp[0]*b2sp[0])*ki[0] +
28998
28999
29000 pow(a1sp[0],
29001
29002
29003 2)*(25*fp*pow(lp, 2) - 128*a2sp[1] + 128*a2sp[3])*
29004
29005
29006 pow(b1sp[3], 2)*ki[3] -
29007
29008
29009 128*pow(a1sp[0], 2)*a1sp[3]*b1sp[3]*b2sp[3]*ki[3])) -
29010
29011
29012 pow(a1sp[1],
29013
29014
29015 4)*(3*fp*pow(lp, 2)*pow(a1sp[0], 4)*pow(a1sp[3], 4)*pow(b1sp[2], 4)*
29016
29017
29018 pow(ki[2], 2) +
29019
29020
29021 384*pow(a1sp[0], 2)*pow(a1sp[2], 3)*pow(a1sp[3], 2)*b1sp[2]*
29022
29023
29024 b2sp[2]*ki[
29025
29026
29027 3]*(-2*pow(a1sp[3], 2)*pow(b1sp[0], 2)*ki[0] +
29028
29029
29030 pow(a1sp[0], 2)*pow(b1sp[3], 2)*ki[3]) +
29031
29032
29033 2*pow(a1sp[0], 2)*pow(a1sp[2], 2)*pow(a1sp[3], 2)*pow(b1sp[2], 2)*
29034
29035
29036 ki[2]*(pow(a1sp[3], 2)*
29037
29038
29039 b1sp[0]*((125*fp*pow(lp, 2) - 384*a2sp[0] + 384*a2sp[2])*
29040
29041
29042 b1sp[0] + 384*a1sp[0]*b2sp[0])*ki[0] +
29043
29044
29045 2*pow(a1sp[0],
29046
29047
29048 2)*(7*fp*pow(lp, 2) - 96*a2sp[2] + 96*a2sp[3])*
29049
29050
29051 pow(b1sp[3], 2)*ki[3] -
29052
29053
29054 192*pow(a1sp[0], 2)*a1sp[3]*b1sp[3]*b2sp[3]*ki[3]) +
29055
29056
29057 pow(a1sp[2],
29058
29059
29060 4)*(7*fp*pow(lp, 2)*pow(a1sp[3], 4)*pow(b1sp[0], 4)*
29061
29062
29063 pow(ki[0], 2) +
29064
29065
29066 8*pow(a1sp[0], 2)*pow(a1sp[3], 2)*b1sp[0]*
29067
29068
29069 pow(b1sp[3],
29070
29071
29072 2)*((55*fp*pow(lp, 2) - 144*a2sp[0] + 144*a2sp[3])*
29073
29074
29075 b1sp[0] + 144*a1sp[0]*b2sp[0])*ki[0]*ki[3] -
29076
29077
29078 1152*pow(a1sp[0], 2)*pow(a1sp[3], 3)*pow(b1sp[0], 2)*
29079
29080
29081 b1sp[3]*b2sp[3]*ki[0]*ki[3] +
29082
29083
29084 fp*pow(lp, 2)*pow(a1sp[0], 4)*pow(b1sp[3], 4)*
29085
29086
29087 pow(ki[3], 2))))/(8.*
29088
29089
29090 lp*(pow(a1sp[0], 4)*pow(a1sp[2], 4)*pow(a1sp[3], 4)*pow(b1sp[1], 4)*
29091
29092
29093 pow(ki[1], 2) +
29094
29095
29096 2*pow(a1sp[0], 2)*pow(a1sp[1], 2)*pow(a1sp[2], 2)*pow(a1sp[3], 2)*
29097
29098
29099 pow(b1sp[1], 2)*
29100
29101
29102 ki[1]*(7*pow(a1sp[0], 2)*pow(a1sp[3], 2)*pow(b1sp[2], 2)*ki[2] +
29103
29104
29105 pow(a1sp[2],
29106
29107
29108 2)*(7*pow(a1sp[3], 2)*pow(b1sp[0], 2)*ki[0] +
29109
29110
29111 25*pow(a1sp[0], 2)*pow(b1sp[3], 2)*ki[3])) +
29112
29113
29114 pow(a1sp[1],
29115
29116
29117 4)*(pow(a1sp[0], 4)*pow(a1sp[3], 4)*pow(b1sp[2], 4)*
29118
29119
29120 pow(ki[2], 2) +
29121
29122
29123 2*pow(a1sp[0], 2)*pow(a1sp[2], 2)*pow(a1sp[3], 2)*
29124
29125
29126 pow(b1sp[2], 2)*
29127
29128
29129 ki[2]*(25*pow(a1sp[3], 2)*pow(b1sp[0], 2)*ki[0] +
29130
29131
29132 7*pow(a1sp[0], 2)*pow(b1sp[3], 2)*ki[3]) +
29133
29134
29135 pow(a1sp[2],
29136
29137
29138 4)*(pow(a1sp[3], 4)*pow(b1sp[0], 4)*pow(ki[0], 2) +
29139
29140
29141 110*pow(a1sp[0], 2)*pow(a1sp[3], 2)*pow(b1sp[0], 2)*
29142
29143
29144 pow(b1sp[3], 2)*ki[0]*ki[3] +
29145
29146
29147 pow(a1sp[0], 4)*pow(b1sp[3], 4)*pow(ki[3], 2)))));
29148
29149
29150 return f3; }
29151
29152
29153
29154
29155
29156
29157
29158
29159 double normmat::compute_k41 (double lp)
29160
29161
29162 {
29163
29164
29165 double k41;
29166
29167
29168
29169
29170
29171 k41 = (-96*(7*pow(a1sp[0], 2)*pow(a1sp[1], 4)*pow(a1sp[2], 4)*pow(a1sp[3], 4)*
29172
29173
29174 pow(b1sp[0], 2)*ki[0] +
29175
29176
29177 pow(a1sp[0],
29178
29179
29180 4)*(5*pow(a1sp[1], 2)*pow(a1sp[2], 4)*pow(a1sp[3], 4)*
29181
29182
29183 pow(b1sp[1], 2)*ki[1] +
29184
29185
29186 pow(a1sp[1],
29187
29188
29189 4)*(3*pow(a1sp[2], 2)*pow(a1sp[3], 4)*pow(b1sp[2], 2)*
29190
29191
29192 ki[2] +
29193
29194
29195 pow(a1sp[2], 4)*pow(a1sp[3], 2)*pow(b1sp[3], 2)*
29196
29197
29198 ki[3]))))/(as1*e0c*
29199
29200
29201 pow(lp, 2)*(pow(a1sp[0], 4)*pow(a1sp[2], 4)*pow(a1sp[3], 4)*
29202
29203
29204 pow(b1sp[1], 4)*pow(ki[1], 2) +
29205
29206
29207 2*pow(a1sp[0], 2)*pow(a1sp[1], 2)*pow(a1sp[2], 2)*pow(a1sp[3], 2)*
29208
29209
29210 pow(b1sp[1], 2)*
29211
29212
29213 ki[1]*(7*pow(a1sp[0], 2)*pow(a1sp[3], 2)*pow(b1sp[2], 2)*ki[2] +
29214
29215
29216 pow(a1sp[2],
29217
29218
29219 2)*(7*pow(a1sp[3], 2)*pow(b1sp[0], 2)*ki[0] +
29220
29221
29222 25*pow(a1sp[0], 2)*pow(b1sp[3], 2)*ki[3])) +
29223
29224
29225 pow(a1sp[1],
29226
29227
29228 4)*(pow(a1sp[0], 4)*pow(a1sp[3], 4)*pow(b1sp[2], 4)*
29229
29230
29231 pow(ki[2], 2) +
29232
29233
29234 2*pow(a1sp[0], 2)*pow(a1sp[2], 2)*pow(a1sp[3], 2)*
29235
29236
29237 pow(b1sp[2], 2)*
29238
29239
29240 ki[2]*(25*pow(a1sp[3], 2)*pow(b1sp[0], 2)*ki[0] +
29241
29242
29243 7*pow(a1sp[0], 2)*pow(b1sp[3], 2)*ki[3]) +
29244
29245
29246 pow(a1sp[2],
29247
29248
29249 4)*(pow(a1sp[3], 4)*pow(b1sp[0], 4)*pow(ki[0], 2) +
29250
29251
29252 110*pow(a1sp[0], 2)*pow(a1sp[3], 2)*pow(b1sp[0], 2)*
29253
29254
29255 pow(b1sp[3], 2)*ki[0]*ki[3] +
29256
29257
29258 pow(a1sp[0], 4)*pow(b1sp[3], 4)*pow(ki[3], 2)))));
29259
29260
29261 return k41; }
29262
29263
29264
29265
29266
29267
29268
29269
29270 double normmat::compute_k42 (double lp)
29271
29272
29273 {
29274
29275
29276 double k42;
29277
29278
29279
29280
29281
29282 k42 = (16*(5*pow(a1sp[0], 2)*pow(a1sp[1], 4)*pow(a1sp[2], 4)*pow(a1sp[3], 4)*
29283
29284
29285 pow(b1sp[0], 2)*ki[0] +
29286
29287
29288 pow(a1sp[0],
29289
29290
29291 4)*(11*pow(a1sp[1], 2)*pow(a1sp[2], 4)*pow(a1sp[3], 4)*
29292
29293
29294 pow(b1sp[1], 2)*ki[1] +
29295
29296
29297 pow(a1sp[1],
29298
29299
29300 4)*(11*pow(a1sp[2], 2)*pow(a1sp[3], 4)*pow(b1sp[2], 2)*
29301
29302
29303 ki[2] +
29304
29305
29306 5*pow(a1sp[2], 4)*pow(a1sp[3], 2)*pow(b1sp[3], 2)*
29307
29308
29309 ki[3]))))/(as1*e0c*
29310
29311
29312 lp*(pow(a1sp[0], 4)*pow(a1sp[2], 4)*pow(a1sp[3], 4)*pow(b1sp[1], 4)*
29313
29314
29315 pow(ki[1], 2) +
29316
29317
29318 2*pow(a1sp[0], 2)*pow(a1sp[1], 2)*pow(a1sp[2], 2)*pow(a1sp[3], 2)*
29319
29320
29321 pow(b1sp[1], 2)*
29322
29323
29324 ki[1]*(7*pow(a1sp[0], 2)*pow(a1sp[3], 2)*pow(b1sp[2], 2)*ki[2] +
29325
29326
29327 pow(a1sp[2],
29328
29329
29330 2)*(7*pow(a1sp[3], 2)*pow(b1sp[0], 2)*ki[0] +
29331
29332
29333 25*pow(a1sp[0], 2)*pow(b1sp[3], 2)*ki[3])) +
29334
29335
29336 pow(a1sp[1],
29337
29338
29339 4)*(pow(a1sp[0], 4)*pow(a1sp[3], 4)*pow(b1sp[2], 4)*
29340
29341
29342 pow(ki[2], 2) +
29343
29344
29345 2*pow(a1sp[0], 2)*pow(a1sp[2], 2)*pow(a1sp[3], 2)*
29346
29347
29348 pow(b1sp[2], 2)*
29349
29350
29351 ki[2]*(25*pow(a1sp[3], 2)*pow(b1sp[0], 2)*ki[0] +
29352
29353
29354 7*pow(a1sp[0], 2)*pow(b1sp[3], 2)*ki[3]) +
29355
29356
29357 pow(a1sp[2],
29358
29359
29360 4)*(pow(a1sp[3], 4)*pow(b1sp[0], 4)*pow(ki[0], 2) +
29361
29362
29363 110*pow(a1sp[0], 2)*pow(a1sp[3], 2)*pow(b1sp[0], 2)*
29364
29365
29366 pow(b1sp[3], 2)*ki[0]*ki[3] +
29367
29368
29369 pow(a1sp[0], 4)*pow(b1sp[3], 4)*pow(ki[3], 2)))));
29370
29371
29372 return k42; }
29373
29374
29375
29376
29377
29378
29379 double normmat::compute_k43 (double lp)
29380
29381
29382 {
29383
29384
29385 double k43;
29386
29387
29388
29389
29390
29391 k43 = (96*(7*pow(a1sp[0], 2)*pow(a1sp[1], 4)*pow(a1sp[2], 4)*pow(a1sp[3], 4)*
29392
29393
29394 pow(b1sp[0], 2)*ki[0] +
29395
29396
29397 pow(a1sp[0],
29398
29399
29400 4)*(5*pow(a1sp[1], 2)*pow(a1sp[2], 4)*pow(a1sp[3], 4)*
29401
29402
29403 pow(b1sp[1], 2)*ki[1] +
29404
29405
29406 pow(a1sp[1],
29407
29408
29409 4)*(3*pow(a1sp[2], 2)*pow(a1sp[3], 4)*pow(b1sp[2], 2)*
29410
29411
29412 ki[2] +
29413
29414
29415 pow(a1sp[2], 4)*pow(a1sp[3], 2)*pow(b1sp[3], 2)*
29416
29417
29418 ki[3]))))/(as1*e0c*
29419
29420
29421 pow(lp, 2)*(pow(a1sp[0], 4)*pow(a1sp[2], 4)*pow(a1sp[3], 4)*
29422
29423
29424 pow(b1sp[1], 4)*pow(ki[1], 2) +
29425
29426
29427 2*pow(a1sp[0], 2)*pow(a1sp[1], 2)*pow(a1sp[2], 2)*pow(a1sp[3], 2)*
29428
29429
29430 pow(b1sp[1], 2)*
29431
29432
29433 ki[1]*(7*pow(a1sp[0], 2)*pow(a1sp[3], 2)*pow(b1sp[2], 2)*ki[2] +
29434
29435
29436 pow(a1sp[2],
29437
29438
29439 2)*(7*pow(a1sp[3], 2)*pow(b1sp[0], 2)*ki[0] +
29440
29441
29442 25*pow(a1sp[0], 2)*pow(b1sp[3], 2)*ki[3])) +
29443
29444
29445 pow(a1sp[1],
29446
29447
29448 4)*(pow(a1sp[0], 4)*pow(a1sp[3], 4)*pow(b1sp[2], 4)*
29449
29450
29451 pow(ki[2], 2) +
29452
29453
29454 2*pow(a1sp[0], 2)*pow(a1sp[2], 2)*pow(a1sp[3], 2)*
29455
29456
29457 pow(b1sp[2], 2)*
29458
29459
29460 ki[2]*(25*pow(a1sp[3], 2)*pow(b1sp[0], 2)*ki[0] +
29461
29462
29463 7*pow(a1sp[0], 2)*pow(b1sp[3], 2)*ki[3]) +
29464
29465
29466 pow(a1sp[2],
29467
29468
29469 4)*(pow(a1sp[3], 4)*pow(b1sp[0], 4)*pow(ki[0], 2) +
29470
29471
29472 110*pow(a1sp[0], 2)*pow(a1sp[3], 2)*pow(b1sp[0], 2)*
29473
29474
29475 pow(b1sp[3], 2)*ki[0]*ki[3] +
29476
29477
29478 pow(a1sp[0], 4)*pow(b1sp[3], 4)*pow(ki[3], 2)))));
29479
29480
29481 return k43; }
29482
29483
29484
29485
29486
29487
29488
29489
29490 double normmat::compute_k44 (double lp)
29491
29492
29493 {
29494
29495
29496 double k44;
29497
29498
29499
29500
29501
29502 k44 = (16*(37*pow(a1sp[0], 2)*pow(a1sp[1], 4)*pow(a1sp[2], 4)*pow(a1sp[3], 4)*
29503
29504
29505 pow(b1sp[0], 2)*ki[0] +
29506
29507
29508 pow(a1sp[0],
29509
29510
29511 4)*(19*pow(a1sp[1], 2)*pow(a1sp[2], 4)*pow(a1sp[3], 4)*
29512
29513
29514 pow(b1sp[1], 2)*ki[1] +
29515
29516
29517 pow(a1sp[1],
29518
29519
29520 4)*(7*pow(a1sp[2], 2)*pow(a1sp[3], 4)*pow(b1sp[2], 2)*
29521
29522
29523 ki[2] +
29524
29525
29526 pow(a1sp[2], 4)*pow(a1sp[3], 2)*pow(b1sp[3], 2)*
29527
29528
29529 ki[3]))))/(as1*e0c*
29530
29531
29532 lp*(pow(a1sp[0], 4)*pow(a1sp[2], 4)*pow(a1sp[3], 4)*pow(b1sp[1], 4)*
29533
29534
29535 pow(ki[1], 2) +
29536
29537
29538 2*pow(a1sp[0], 2)*pow(a1sp[1], 2)*pow(a1sp[2], 2)*pow(a1sp[3], 2)*
29539
29540
29541 pow(b1sp[1], 2)*
29542
29543
29544 ki[1]*(7*pow(a1sp[0], 2)*pow(a1sp[3], 2)*pow(b1sp[2], 2)*ki[2] +
29545
29546
29547 pow(a1sp[2],
29548
29549
29550 2)*(7*pow(a1sp[3], 2)*pow(b1sp[0], 2)*ki[0] +
29551
29552
29553 25*pow(a1sp[0], 2)*pow(b1sp[3], 2)*ki[3])) +
29554
29555
29556 pow(a1sp[1],
29557
29558
29559 4)*(pow(a1sp[0], 4)*pow(a1sp[3], 4)*pow(b1sp[2], 4)*
29560
29561
29562 pow(ki[2], 2) +
29563
29564
29565 2*pow(a1sp[0], 2)*pow(a1sp[2], 2)*pow(a1sp[3], 2)*
29566
29567
29568 pow(b1sp[2], 2)*
29569
29570
29571 ki[2]*(25*pow(a1sp[3], 2)*pow(b1sp[0], 2)*ki[0] +
29572
29573
29574 7*pow(a1sp[0], 2)*pow(b1sp[3], 2)*ki[3]) +
29575
29576
29577 pow(a1sp[2],
29578
29579
29580 4)*(pow(a1sp[3], 4)*pow(b1sp[0], 4)*pow(ki[0], 2) +
29581
29582
29583 110*pow(a1sp[0], 2)*pow(a1sp[3], 2)*pow(b1sp[0], 2)*
29584
29585
29586 pow(b1sp[3], 2)*ki[0]*ki[3] +
29587
29588
29589 pow(a1sp[0], 4)*pow(b1sp[3], 4)*pow(ki[3], 2)))));
29590
29591
29592 return k44; }
29593
29594
29595
29596
29597
29598
29599
29600
29601 double normmat::compute_f4 (double lp)
29602
29603
29604
29605
29606
29607 {
29608
29609
29610 double f4;
29611
29612
29613
29614
29615
29616 f4 = (-(pow(a1sp[0], 4)*pow(a1sp[2], 4)*
29617
29618
29619 pow(a1sp[3], 4)*(37*fp*pow(lp, 2) + 192*a2sp[1])*pow(b1sp[1], 4)*
29620
29621
29622 pow(ki[1], 2)) +
29623
29624
29625 192*pow(a1sp[0], 4)*a1sp[1]*pow(a1sp[2], 4)*pow(a1sp[3], 4)*
29626
29627
29628 pow(b1sp[1], 3)*b2sp[1]*pow(ki[1], 2) -
29629
29630
29631 192*pow(a1sp[0], 2)*pow(a1sp[1], 3)*pow(a1sp[2], 2)*pow(a1sp[3], 2)*
29632
29633
29634 b1sp[1]*b2sp[1]*
29635
29636
29637 ki[1]*(17*pow(a1sp[0], 2)*pow(a1sp[3], 2)*pow(b1sp[2], 2)*ki[2] +
29638
29639
29640 pow(a1sp[2],
29641
29642
29643 2)*(-43*pow(a1sp[3], 2)*pow(b1sp[0], 2)*ki[0] +
29644
29645
29646 11*pow(a1sp[0], 2)*pow(b1sp[3], 2)*ki[3])) -
29647
29648
29649 2*pow(a1sp[0], 2)*pow(a1sp[1], 2)*pow(a1sp[2], 2)*pow(a1sp[3], 2)*
29650
29651
29652 pow(b1sp[1], 2)*
29653
29654
29655 ki[1]*(pow(a1sp[0], 2)*
29656
29657
29658 pow(a1sp[3],
29659
29660
29661 2)*(151*fp*pow(lp, 2) - 1632*a2sp[1] + 2976*a2sp[2])*
29662
29663
29664 pow(b1sp[2], 2)*ki[2] -
29665
29666
29667 2976*pow(a1sp[0], 2)*a1sp[2]*pow(a1sp[3], 2)*b1sp[2]*b2sp[2]*
29668
29669
29670 ki[2] + pow(a1sp[2],
29671
29672
29673 2)*(pow(a1sp[3], 2)*
29674
29675
29676 b1sp[0]*((361*fp*pow(lp, 2) - 2784*a2sp[0] +
29677
29678
29679 4128*a2sp[1])*b1sp[0] + 2784*a1sp[0]*b2sp[0])*
29680
29681
29682 ki[0] +
29683
29684
29685 pow(a1sp[0],
29686
29687
29688 2)*(163*fp*pow(lp, 2) - 1056*a2sp[1] + 5856*a2sp[3])*
29689
29690
29691 pow(b1sp[3], 2)*ki[3] -
29692
29693
29694 5856*pow(a1sp[0], 2)*a1sp[3]*b1sp[3]*b2sp[3]*ki[3])) -
29695
29696
29697 pow(a1sp[1],
29698
29699
29700 4)*(pow(a1sp[0], 4)*
29701
29702
29703 pow(a1sp[3], 4)*(13*fp*pow(lp, 2) + 192*a2sp[2])*
29704
29705
29706 pow(b1sp[2], 4)*pow(ki[2], 2) -
29707
29708
29709 192*pow(a1sp[0], 4)*a1sp[2]*pow(a1sp[3], 4)*pow(b1sp[2], 3)*
29710
29711
29712 b2sp[2]*pow(ki[2], 2) +
29713
29714
29715 960*pow(a1sp[0], 2)*pow(a1sp[2], 3)*pow(a1sp[3], 2)*b1sp[2]*
29716
29717
29718 b2sp[2]*ki[
29719
29720
29721 3]*(-17*pow(a1sp[3], 2)*pow(b1sp[0], 2)*ki[0] +
29722
29723
29724 pow(a1sp[0], 2)*pow(b1sp[3], 2)*ki[3]) +
29725
29726
29727 2*pow(a1sp[0], 2)*pow(a1sp[2], 2)*pow(a1sp[3], 2)*pow(b1sp[2], 2)*
29728
29729
29730 ki[2]*(pow(a1sp[3], 2)*
29731
29732
29733 b1sp[0]*((763*fp*pow(lp, 2) - 3360*a2sp[0] +
29734
29735
29736 8160*a2sp[2])*b1sp[0] + 3360*a1sp[0]*b2sp[0])*
29737
29738
29739 ki[0] +
29740
29741
29742 pow(a1sp[0],
29743
29744
29745 2)*(25*fp*pow(lp, 2) - 480*a2sp[2] + 1824*a2sp[3])*
29746
29747
29748 pow(b1sp[3], 2)*ki[3] -
29749
29750
29751 1824*pow(a1sp[0], 2)*a1sp[3]*b1sp[3]*b2sp[3]*ki[3]) +
29752
29753
29754 pow(a1sp[2],
29755
29756
29757 4)*(pow(a1sp[3], 4)*
29758
29759
29760 pow(b1sp[0],
29761
29762
29763 3)*((73*fp*pow(lp, 2) + 192*a2sp[0])*b1sp[0] -
29764
29765
29766 192*a1sp[0]*b2sp[0])*pow(ki[0], 2) +
29767
29768
29769 2*pow(a1sp[0], 2)*pow(a1sp[3], 2)*b1sp[0]*
29770
29771
29772 pow(b1sp[3],
29773
29774
29775 2)*((523*fp*pow(lp, 2) - 1632*a2sp[0] + 12192*a2sp[3])*
29776
29777
29778 b1sp[0] + 1632*a1sp[0]*b2sp[0])*ki[0]*ki[3] -
29779
29780
29781 24384*pow(a1sp[0], 2)*pow(a1sp[3], 3)*pow(b1sp[0], 2)*
29782
29783
29784 b1sp[3]*b2sp[3]*ki[0]*ki[3] +
29785
29786
29787 pow(a1sp[0], 4)*(fp*pow(lp, 2) + 192*a2sp[3])*
29788
29789
29790 pow(b1sp[3], 4)*pow(ki[3], 2) -
29791
29792
29793 192*pow(a1sp[0], 4)*a1sp[3]*pow(b1sp[3], 3)*b2sp[3]*
29794
29795
29796 pow(ki[3], 2))))/(192.*(pow(a1sp[0], 4)*pow(a1sp[2], 4)*
29797
29798
29799 pow(a1sp[3], 4)*pow(b1sp[1], 4)*pow(ki[1], 2) +
29800
29801
29802 2*pow(a1sp[0], 2)*pow(a1sp[1], 2)*pow(a1sp[2], 2)*pow(a1sp[3], 2)*
29803
29804
29805 pow(b1sp[1], 2)*
29806
29807
29808 ki[1]*(7*pow(a1sp[0], 2)*pow(a1sp[3], 2)*pow(b1sp[2], 2)*ki[2] +
29809
29810
29811 pow(a1sp[2],
29812
29813
29814 2)*(7*pow(a1sp[3], 2)*pow(b1sp[0], 2)*ki[0] +
29815
29816
29817 25*pow(a1sp[0], 2)*pow(b1sp[3], 2)*ki[3])) +
29818
29819
29820 pow(a1sp[1],
29821
29822
29823 4)*(pow(a1sp[0], 4)*pow(a1sp[3], 4)*pow(b1sp[2], 4)*
29824
29825
29826 pow(ki[2], 2) +
29827
29828
29829 2*pow(a1sp[0], 2)*pow(a1sp[2], 2)*pow(a1sp[3], 2)*
29830
29831
29832 pow(b1sp[2], 2)*
29833
29834
29835 ki[2]*(25*pow(a1sp[3], 2)*pow(b1sp[0], 2)*ki[0] +
29836
29837
29838 7*pow(a1sp[0], 2)*pow(b1sp[3], 2)*ki[3]) +
29839
29840
29841 pow(a1sp[2],
29842
29843
29844 4)*(pow(a1sp[3], 4)*pow(b1sp[0], 4)*pow(ki[0], 2) +
29845
29846
29847 110*pow(a1sp[0], 2)*pow(a1sp[3], 2)*pow(b1sp[0], 2)*
29848
29849
29850 pow(b1sp[3], 2)*ki[0]*ki[3] +
29851
29852
29853 pow(a1sp[0], 4)*pow(b1sp[3], 4)*pow(ki[3], 2)))));
29854
29855
29856 return f4;
29857
29858
29859 }
29860
29861
29862
29863
29864
29865
29866
29867
29868 void normmat::compute_kp (double lp)
29869
29870
29871 {
29872
29873 if (fabs(z1)<zero && fabs(z2)<zero){
29874
29875
29876
29877 kp[0][0]=ecnom*b*(h*h*h)/12.*((12.)/pow(lp,3));
29878
29879
29880 kp[0][1]=ecnom*b*(h*h*h)/12.*((-6.)/pow(lp,2));
29881
29882
29883 kp[0][2]=ecnom*b*(h*h*h)/12.*((-12.)/pow(lp,3));
29884
29885
29886 kp[0][3]=ecnom*b*(h*h*h)/12.*((-6.)/pow(lp,2));
29887
29888
29889 kp[1][0]=ecnom*b*(h*h*h)/12.*((-6.)/pow(lp,2));
29890
29891
29892 kp[1][1]=ecnom*b*(h*h*h)/12.*((4.)/lp);
29893
29894
29895 kp[1][2]=ecnom*b*(h*h*h)/12.*((6.)/pow(lp,2));
29896
29897
29898 kp[1][3]=ecnom*b*(h*h*h)/12.*((2.)/lp);
29899
29900
29901 kp[2][0]=ecnom*b*(h*h*h)/12.*((-12.)/pow(lp,3));
29902
29903
29904 kp[2][1]=ecnom*b*(h*h*h)/12.*((6.)/pow(lp,2));
29905
29906
29907 kp[2][2]=ecnom*b*(h*h*h)/12.*((12.)/pow(lp,3));
29908
29909
29910 kp[2][3]=ecnom*b*(h*h*h)/12.*((6.)/pow(lp,2));
29911
29912
29913 kp[3][0]=ecnom*b*(h*h*h)/12.*((-6.)/pow(lp,2));
29914
29915
29916 kp[3][1]=ecnom*b*(h*h*h)/12.*((2.)/lp);
29917
29918
29919 kp[3][2]=ecnom*b*(h*h*h)/12.*((6.)/pow(lp,2));
29920
29921
29922 kp[3][3]=ecnom*b*(h*h*h)/12.*((4.)/lp);
29923
29924 }
29925 else{
29926
29927
29928 kp[0][0]=k11;
29929
29930
29931 kp[0][1]=k12;
29932
29933
29934 kp[0][2]=k13;
29935
29936
29937 kp[0][3]=k14;
29938
29939
29940 kp[1][0]=k21;
29941
29942
29943 kp[1][1]=k22;
29944
29945
29946 kp[1][2]=k23;
29947
29948
29949 kp[1][3]=k24;
29950
29951
29952 kp[2][0]=k31;
29953
29954
29955 kp[2][1]=k32;
29956
29957
29958 kp[2][2]=k33;
29959
29960
29961 kp[2][3]=k34;
29962
29963
29964 kp[3][0]=k41;
29965
29966
29967 kp[3][1]=k42;
29968
29969
29970 kp[3][2]=k43;
29971
29972
29973 kp[3][3]=k44;
29974
29975 }
29976
29977
29978
29979
29980
29981 }
29982
29983
29984
29985
29986
29987
29988
29989
29990 void normmat::compute_fkp (double lp)
29991
29992
29993 {
29994
29995 if (fabs(z1)<zero && fabs(z2)<zero){
29996
29997
29998 fkp[0]=(fp*lp)/2.;
29999
30000
30001 fkp[1]=-(fp*pow(lp,2))/12.;
30002
30003
30004 fkp[2]=(fp*lp)/2.;
30005
30006
30007 fkp[3]=(fp*pow(lp,2))/12.;
30008
30009 }
30010
30011 else {
30012
30013 fkp[0]=-f1;
30014
30015
30016 fkp[1]=-f2;
30017
30018
30019 fkp[2]=-f3;
30020
30021
30022 fkp[3]=-f4;
30023
30024 }
30025
30026
30027 }
30028
30029
30030
30031
30032
30033
30034
30035
30036
30037
30038
30039 void normmat::compute_kn (double lp)
30040
30041
30042 {
30043 if (fabs(z3p)<zero){
30044
30045
30046 kn[0][0] = ecnom*a/lp;
30047
30048
30049 kn[0][1] = -ecnom*a/lp;
30050
30051
30052 kn[1][0] = -ecnom*a/lp;
30053
30054
30055 kn[1][1] = ecnom*a/lp;
30056
30057 }
30058
30059 else {
30060
30061 kn[0][0] = pow(an1, 2)/(as1*e0c*kin*lp);
30062
30063
30064 kn[0][1] = -(pow(an1, 2)/(as1*e0c*kin*lp));
30065
30066
30067 kn[1][0] = -(pow(an1, 2)/(as1*e0c*kin*lp));
30068
30069
30070 kn[1][1] = (pow(an1, 2)/(as1*e0c*kin*lp));
30071
30072 }
30073
30074
30075
30076
30077
30078
30079
30080
30081 }
30082
30083
30084
30085
30086
30087
30088
30089
30090
30091 void normmat::compute_fkn (double lp)
30092
30093
30094 {
30095 if (fabs(z3p)<zero)
30096
30097 {
30098
30099 fkn[0]= - (fn*lp)/2.;
30100
30101
30102 fkn[1]= - (fn*lp)/2.;
30103
30104 }
30105
30106
30107 else {
30108
30109 fkn[0]=(an2 - (fn*lp)/2.);
30110
30111
30112 fkn[1]=(-an2 - (fn*lp)/2.);
30113
30114 }
30115
30116
30117 }
30118
30119
30120
30121
30122
30123
30124 void normmat::compute_all (long ipp,double lp)
30125 {
30126
30127 compute_z1 (ipp,lp);
30128 compute_z2 (ipp,lp);
30129 compute_z3p (ipp,lp);
30130 compute_z3 ();
30131 as1 = compute_as1 (lp);
30132 as2 = compute_as2 (lp);
30133 compute_m (lp);
30134
30135 compute_mpp (lp);
30136
30137 n0 = compute_n0 (lp);
30138
30139 iter = compute_iter ();
30140
30141 compute_tcv ();
30142
30143 epsn = compute_epsn ();
30144
30145 nmax = compute_nmax ();
30146
30147 an1 = compute_an1 ();
30148
30149 an2 = compute_an2 ();
30150
30151 in1 = compute_in1 (lp);
30152
30153 in2 = compute_in2 (lp);
30154
30155 kinh = compute_kinh ();
30156
30157 kind = compute_kind (lp);
30158
30159 kin = compute_kin ();
30160
30161 epschr1 = compute_epschr1 ();
30162
30163 mhr1 = compute_mhr1 ();
30164
30165 epschr2 = compute_epschr2 ();
30166
30167 mhr2 = compute_mhr2 ();
30168
30169 epschr3 = compute_epschr3 ();
30170
30171 mhr3 = compute_mhr3 ();
30172
30173 epschr4 = compute_epschr4 ();
30174
30175 epscmax1 = compute_epscmax1 ();
30176
30177 epschr4b = compute_epschr4b ();
30178
30179 epschrk1a = compute_epschrk1a ();
30180
30181 mhr4 = compute_mhr4 ();
30182
30183 mhr4b = compute_mhr4b ();
30184
30185 epscmax1p = compute_epscmax1p ();
30186
30187 mmax1a = compute_mmax1a ();
30188
30189 mh1 = compute_mh1 ();
30190
30191 epsch1 = compute_epsch1 ();
30192
30193 mh1hrk1a = compute_mh1hrk1a ();
30194
30195 mhrk1a = compute_mhrk1a ();
30196
30197 mh3 = compute_mh3 ();
30198
30199 epsch3 = compute_epsch3 ();
30200
30201 mh2 = compute_mh2 ();
30202
30203 epsch2 = compute_epsch2 ();
30204
30205 epscder2 = compute_epscder2 ();
30206
30207 mmax1 = compute_mmax1 ();
30208
30209 mhrk1 = compute_mhrk1 ();
30210
30211 epschrk1 = compute_epschrk1 ();
30212
30213 mh1hrk1 = compute_mh1hrk1 ();
30214
30215 epschr5 = compute_epschr5 ();
30216
30217 epscs11 = compute_epscs11 ();
30218
30219 mhr5 = compute_mhr5 ();
30220
30221 mmax2 = compute_mmax2 ();
30222
30223 ms11 = compute_ms11 ();
30224
30225 mh5a = compute_mh5a ();
30226
30227 epsch5a = compute_epsch5a ();
30228
30229 mh5p = compute_mh5p ();
30230
30231 epsch5p = compute_epsch5p ();
30232
30233 mh25a = compute_mh25a ();
30234
30235 epscder4 = compute_epscder4 ();
30236
30237 mmax5 = compute_mmax5 ();
30238
30239 mh5 = compute_mh5 ();
30240
30241 epsch5 = compute_epsch5 ();
30242
30243 epscp = compute_epscp ();
30244
30245 epschr6 = compute_epschr6 ();
30246
30247 mhr6 = compute_mhr6 ();
30248
30249 mmax3 = compute_mmax3 ();
30250
30251 mh6a = compute_mh6a ();
30252
30253 epsch6a = compute_epsch6a ();
30254
30255 mh7 = compute_mh7 ();
30256
30257 epsch7 = compute_epsch7 ();
30258
30259 epsch12 = compute_epsch12 ();
30260
30261 epss1h1 = compute_epss1h1 ();
30262
30263 epss1h2 = compute_epss1h2 ();
30264
30265 mh01 = compute_mh01 ();
30266
30267 mh12 = compute_mh12 ();
30268
30269 mh25 = compute_mh25 ();
30270
30271 mh36a = compute_mh36a ();
30272
30273 epscder1 = compute_epscder1 ();
30274
30275 mmax4 = compute_mmax4 ();
30276
30277 mh6 = compute_mh6 ();
30278
30279 epsch6 = compute_epsch6 ();
30280
30281 mh36 = compute_mh36 ();
30282
30283 mh7maxa = compute_mh7maxa ();
30284
30285 mhmaxa = compute_mhmaxa ();
30286
30287 epscder3 = compute_epscder3 ();
30288
30289 mhmax = compute_mhmax ();
30290
30291 mh8p = compute_mh8p ();
30292
30293 epsch8p = compute_epsch8p ();
30294
30295 mh8 = compute_mh8 ();
30296
30297 epsch8 = compute_epsch8 ();
30298
30299 mh78 = compute_mh78 ();
30300
30301 mhoc1 = compute_mhoc1 ();
30302
30303 mmaxoc1 = compute_mmaxoc1 ();
30304
30305 epss1oc1 = compute_epss1oc1 ();
30306
30307 mhoc2 = compute_mhoc2 ();
30308
30309 epss1oc2 = compute_epss1oc2 ();
30310
30311 mmaxoc2 = compute_mmaxoc2 ();
30312
30313 mht1 = compute_mht1 ();
30314
30315 mht2 = compute_mht2 ();
30316
30317 mht3 = compute_mht3 ();
30318
30319 mht4 = compute_mht4 ();
30320
30321 mmax = compute_mmax ();
30322
30323 epscht1 = compute_epscht1 ();
30324
30325 epscht2 = compute_epscht2 ();
30326
30327 epscht3 = compute_epscht3 ();
30328
30329 epscht4 = compute_epscht4 ();
30330
30331 epscmax = compute_epscmax ();
30332
30333 compute_mp ();
30334
30335 compute_tcn ();
30336
30337 compute_epscsp ();
30338
30339 compute_epss1sp ();
30340
30341 compute_a1sp ();
30342
30343 compute_a2spp ();
30344
30345 compute_a2sp ();
30346
30347 compute_b1sp ();
30348
30349 compute_b2spp ();
30350
30351 compute_b2sp ();
30352
30353 compute_mr ();
30354
30355 compute_epscr ();
30356
30357 compute_epss1r ();
30358
30359 compute_epss1spp ();
30360
30361 compute_xr ();
30362
30363 compute_xsp ();
30364
30365 compute_ir1 ();
30366
30367 compute_ims1 ();
30368
30369 compute_ir2 ();
30370
30371 compute_ims2 ();
30372
30373 compute_ir3 ();
30374
30375 compute_ims3 ();
30376
30377 compute_ic1 ();
30378
30379 compute_ic2 ();
30380
30381 compute_icp ();
30382
30383 compute_c1 ();
30384
30385 compute_c2 ();
30386
30387 compute_c1p ();
30388
30389 compute_c2p ();
30390
30391 compute_kih (lp);
30392
30393 compute_kid (lp);
30394
30395 compute_ki ();
30396
30397
30398 k11 = compute_k11 (lp);
30399
30400 k12 = compute_k12 (lp);
30401
30402 k13 = compute_k13 (lp);
30403
30404 k14 = compute_k14 (lp);
30405
30406 f1 = compute_f1 (lp);
30407
30408 k21 = compute_k21 (lp);
30409
30410 k22 = compute_k22 (lp);
30411
30412 k23 = compute_k23 (lp);
30413
30414 k24 = compute_k24 (lp);
30415
30416 f2 = compute_f2 (lp);
30417
30418 k31 = compute_k31 (lp);
30419
30420 k32 = compute_k32 (lp);
30421
30422 k33 = compute_k33 (lp);
30423
30424 k34 = compute_k34 (lp);
30425
30426 f3 = compute_f3 (lp);
30427
30428 k41 = compute_k41 (lp);
30429
30430 k42 = compute_k42 (lp);
30431
30432 k43 = compute_k43 (lp);
30433
30434 k44 = compute_k44 (lp);
30435
30436 f4 = compute_f4 ( lp);
30437
30438 compute_kp (lp);
30439
30440 compute_fkp (lp);
30441
30442 compute_kn (lp);
30443
30444 compute_fkn (lp);
30445
30446
30447
30448
30449
30450 }
30451
30452
30453
30454
30455
30456
30457
30458
30459
30460
30461
30462
30463
30464
30465
30466
30467
30468 void normmat::stiffness_matrix (matrix &sm,long ipp,double lp)
30469 {
30470
30471 compute_all (ipp,lp);
30472
30473
30474 sm[0][0]=kn[0][0];
30475
30476
30477 sm[0][1]=0.0;
30478
30479
30480 sm[0][2]=0.0;
30481
30482
30483 sm[0][3]=kn[0][1];
30484
30485
30486 sm[0][4]=0.0;
30487
30488
30489 sm[0][5]=0.0;
30490
30491
30492
30493
30494
30495 sm[1][0]=0.0;
30496
30497
30498 sm[1][1]=kp[0][0];
30499
30500
30501 sm[1][2]=kp[0][1];
30502
30503
30504 sm[1][3]=0.0;
30505
30506
30507 sm[1][4]=kp[0][2];
30508
30509
30510 sm[1][5]=kp[0][3];
30511
30512
30513
30514
30515
30516 sm[2][0]=0.0;
30517
30518
30519 sm[2][1]=kp[1][0];
30520
30521
30522 sm[2][2]=kp[1][1];
30523
30524
30525 sm[2][3]=0.0;
30526
30527
30528 sm[2][4]=kp[1][2];
30529
30530
30531 sm[2][5]=kp[1][3];
30532
30533
30534
30535
30536
30537 sm[3][0]=kn[1][0];
30538
30539
30540 sm[3][1]=0.0;
30541
30542
30543 sm[3][2]=0.0;
30544
30545
30546 sm[3][3]=kn[1][1];
30547
30548
30549 sm[3][4]=0.0;
30550
30551
30552 sm[3][5]=0.0;
30553
30554
30555
30556
30557
30558 sm[4][0]=0.0;
30559
30560
30561 sm[4][1]=kp[2][0];
30562
30563
30564 sm[4][2]=kp[2][1];
30565
30566
30567 sm[4][3]=0.0;
30568
30569
30570 sm[4][4]=kp[2][2];
30571
30572
30573 sm[4][5]=kp[2][3];
30574
30575
30576
30577
30578
30579 sm[5][0]=0.0;
30580
30581
30582 sm[5][1]=kp[3][0];
30583
30584
30585 sm[5][2]=kp[3][1];
30586
30587
30588 sm[5][3]=0.0;
30589
30590
30591 sm[5][4]=kp[3][2];
30592
30593
30594 sm[5][5]=kp[3][3];
30595
30596
30597
30598
30599
30600 }
30601
30602
30603
30604
30605
30606 void normmat::internal_forces (vector &ifor,long ipp,double lp)
30607
30608
30609 {
30610 vector kp(6);
30611 matrix sm(6,6);
30612
30613 compute_all (ipp,lp);
30614
30615
30616
30617 kp[0] = Mm->ip[ipp].strain[0];
30618 kp[1] = Mm->ip[ipp].strain[1];
30619 kp[2] = Mm->ip[ipp].strain[2];
30620
30621 kp[3] = Mm->ip[ipp].strain[3];
30622 kp[4] = Mm->ip[ipp].strain[4];
30623 kp[5] = Mm->ip[ipp].strain[5];
30624
30625
30626 stiffness_matrix (sm,ipp,lp);
30627
30628 mxv (sm,kp,ifor);
30629
30630 ifor[0]+=fkn[0];
30631 ifor[1]+=fkp[0];
30632 ifor[2]+=fkp[1];
30633 ifor[3]+=fkn[1];
30634 ifor[4]+=fkp[2];
30635 ifor[5]+=fkp[3];
30636
30637
30638
30639
30640
30641
30642
30643
30644
30645
30646
30647
30648
30649
30650
30651
30652
30653
30654
30655
30656
30657
30658
30659
30660
30661 Mm->ip[ipp].stress[0]=ifor[0];
30662 Mm->ip[ipp].stress[1]=ifor[1];
30663 Mm->ip[ipp].stress[2]=ifor[2];
30664
30665
30666 compute_all (ipp,lp);
30667
30668 stiffness_matrix (sm,ipp,lp);
30669
30670 mxv (sm,kp,ifor);
30671
30672 ifor[0]+=fkn[0];
30673 ifor[1]+=fkp[0];
30674 ifor[2]+=fkp[1];
30675 ifor[3]+=fkn[1];
30676 ifor[4]+=fkp[2];
30677 ifor[5]+=fkp[3];
30678
30679 Mm->ip[ipp].stress[0]=ifor[0];
30680 Mm->ip[ipp].stress[1]=ifor[1];
30681 Mm->ip[ipp].stress[2]=ifor[2];
30682
30683 }
30684
30685
30686
30687
30688
30689
30690