OpenRadioss 2025.1.11
OpenRadioss project
Loading...
Searching...
No Matches
nlsqf.F File Reference
#include "implicit_f.inc"
#include "units_c.inc"

Go to the source code of this file.

Macros

#define IDEBUG   0
#define IOCSV   0

Functions/Subroutines

subroutine mrqmin (x, y, sig, ndata, a, ia, ma, covar, alpha, nca, errnow, ifuncs, gamma, iret, icomp, mmax, atry)
subroutine mrqcof (x, y, sig, ndata, a, ia, ma, alpha, beta, nalp, errnow, ifuncs, icomp)
subroutine inversion (a, n, np, b, m, mp, iret)
subroutine covsrt (covar, sizcovar, ma, ia, mfit)
subroutine ogden0 (x, a, y, na)
 @purpose calculate stress from stretch for OGDEN (uniaxial tension)
subroutine ogden1 (x, a, dyda, ia, na)
 @purpose calculate d(stress)/d(A) OGDEN (uniaxial tension)
subroutine law69_nlsqf (lawid, stretch, y, ma, nmual, npt, mual, icheck, nstart, errtol, id, titr, is_encrypted)
subroutine zero2small (value, small)
subroutine law69_guess1 (lawid, nmual, icheck, mu_incr, irnd1, a0, ia, mcof_min, mcof_max, nguess)
 @purpose get one guess for starting Levenberg-Marquardt method
subroutine law69_check (lawid, a, nmual, icheck, mu_incr, ivalid)
 @purpose check if the guess of material properties is valid for LM optimization
subroutine law69_guess_bounds (lawid, icheck, x, y, npt, nmual, mcof_min, mcof_max, icomp)
 @purpose Esstimate lwer/upper bounds of mu_i and alpha_i which will be used to generate initial guess
real function rand1 (ival)
 @purpose return a random value within [0.0, 1.0) with uniform distribution

Macro Definition Documentation

◆ IDEBUG

#define IDEBUG   0

◆ IOCSV

#define IOCSV   0

Function/Subroutine Documentation

◆ covsrt()

subroutine covsrt ( covar,
integer sizcovar,
integer ma,
integer, dimension(ma) ia,
integer mfit )

Definition at line 419 of file nlsqf.F.

420C-----------------------------------------------
421C I M P L I C I T T Y P E S
422C-----------------------------------------------
423#include "implicit_f.inc"
424C----------------------------------------------------------------
425C D u m m y A r g u m e n t s
426C----------------------------------------------------------------
427 INTEGER MA,MFIT,SIZCOVAR,IA(MA)
428 my_real covar(sizcovar,sizcovar),swap
429C----------------------------------------------------------------
430C L O C A L V A R I B L E S
431C----------------------------------------------------------------
432 INTEGER I,J,K
433C=======================================================================
434 DO 12 i=mfit+1,ma
435 DO 11 j=1,i
436 covar(i,j)=0.
437 covar(j,i)=0.
43811 CONTINUE
43912 CONTINUE
440 k=mfit
441 DO 15 j=ma,1,-1
442 IF(ia(j)/=0)THEN
443 DO 13 i=1,ma
444 swap=covar(i,k)
445 covar(i,k)=covar(i,j)
446 covar(i,j)=swap
44713 CONTINUE
448 DO 14 i=1,ma
449 swap=covar(k,i)
450 covar(k,i)=covar(j,i)
451 covar(j,i)=swap
45214 CONTINUE
453 k=k-1
454 ENDIF
45515 CONTINUE
456C-----------
457 RETURN
my_real
#define my_real
Definition cppsort.cpp:32
swap
#define swap(a, b, tmp)
Definition macros.h:40

◆ inversion()

subroutine inversion ( a,
integer n,
integer np,
b,
integer m,
integer mp,
integer iret )

Definition at line 303 of file nlsqf.F.

304C-----------------------------------------------
305C I M P L I C I T T Y P E S
306C-----------------------------------------------
307#include "implicit_f.inc"
308C-----------------------------------------------
309C D u m m y A r g u m e n t s
310C-----------------------------------------------
311 INTEGER M,MP,N,NP
312 my_real a(np,np),b(np,mp)
313C----------------------------------------------------------------
314C L O C A L V A R I B L E S
315C----------------------------------------------------------------
316 INTEGER I,NMAX,ICOL,IROW,J,K,L,LL
317 parameter(nmax=50)
318 INTEGER INDXC(NMAX),INDXR(NMAX),IPIV(NMAX)
319 my_real
320 . big,dum,pivinv
321
322 INTEGER IRET
323
324 iret = 0
325
326 icol = -1
327 irow = -1
328
329C=======================================================================
330 DO 11 j=1,n
331 ipiv(j)=0
33211 CONTINUE
333 DO 22 i=1,n
334 big=zero
335 DO 13 j=1,n
336 IF(ipiv(j)/=1)THEN
337 DO 12 k=1,n
338 IF (ipiv(k)==0) THEN
339 IF (abs(a(j,k))>=big)THEN
340 big=abs(a(j,k))
341 irow=j
342 icol=k
343 ENDIF
344 ELSE IF (ipiv(k)>1) THEN
345 iret = __line__
346 WRITE(*,*) 'SINGULAR MATRIX IN INVERSION'
347 RETURN
348 ENDIF
34912 CONTINUE
350 ENDIF
35113 CONTINUE
352
353 IF (icol == -1) THEN
354 iret = __line__
355 WRITE(*,*) 'FATAL ERROR IN INVERSION'
356 RETURN
357 ENDIF
358
359 ipiv(icol)=ipiv(icol)+1
360 IF (irow/=icol) THEN
361 DO 14 l=1,n
362 dum=a(irow,l)
363 a(irow,l)=a(icol,l)
364 a(icol,l)=dum
36514 CONTINUE
366 DO 15 l=1,m
367 dum=b(irow,l)
368 b(irow,l)=b(icol,l)
369 b(icol,l)=dum
37015 CONTINUE
371 ENDIF
372 indxr(i)=irow
373 indxc(i)=icol
374 IF (a(icol,icol)==0.) THEN
375 iret = __line__
376 WRITE(*,*) 'SINGULAR MATRIX IN INVERSION'
377 RETURN
378 ENDIF
379 pivinv=1./a(icol,icol)
380 a(icol,icol)=1.
381 DO 16 l=1,n
382 a(icol,l)=a(icol,l)*pivinv
38316 CONTINUE
384 DO 17 l=1,m
385 b(icol,l)=b(icol,l)*pivinv
38617 CONTINUE
387 DO 21 ll=1,n
388 IF(ll/=icol)THEN
389 dum=a(ll,icol)
390 a(ll,icol)=0.
391 DO 18 l=1,n
392 a(ll,l)=a(ll,l)-a(icol,l)*dum
39318 CONTINUE
394 DO 19 l=1,m
395 b(ll,l)=b(ll,l)-b(icol,l)*dum
39619 CONTINUE
397 ENDIF
39821 CONTINUE
39922 CONTINUE
400 DO 24 l=n,1,-1
401 IF(indxr(l)/=indxc(l))THEN
402 DO 23 k=1,n
403 dum=a(k,indxr(l))
404 a(k,indxr(l))=a(k,indxc(l))
405 a(k,indxc(l))=dum
40623 CONTINUE
407 ENDIF
40824 CONTINUE
409C-----------
410 RETURN

◆ law69_check()

subroutine law69_check ( integer lawid,
a,
integer nmual,
integer icheck,
integer mu_incr,
integer ivalid )

@purpose check if the guess of material properties is valid for LM optimization

Parameters
[in]ICHECKchecking level <=0 no constraint (IVALID always return as 1) 1 SUM( mu(i) * alpha(i) ) > 0.0 2 mu(i) * alpha(i) > 0.0
[in]MU_INCRif condition mu(i) <= mu(i+1) is checked
0=no, 1=yes
[out]IVALID0=not valid, 1=valid

Definition at line 1178 of file nlsqf.F.

1180#include "implicit_f.inc"
1181#include "units_c.inc"
1182 INTEGER LAWID, NMUAL, ICHECK, MU_INCR, IVALID
1183 my_real a(nmual)
1184
1185c local vars
1186 INTEGER J
1187 my_real sum_mu_x_af
1188
1189 IF (idebug > 0) THEN
1190 WRITE(iout,*) 'LAW69_CHECK ...'
1191 DO j = 1, nmual
1192 WRITE(iout,*) 'J, A(J) = ', j, a(j)
1193 ENDDO
1194 ENDIF
1195
1196 ivalid = 1
1197 IF (icheck == 0) GOTO 49
1198
1199 IF (mu_incr > 0) THEN
1200 IF (lawid == 1) THEN
1201 IF (nmual >= 4) THEN
1202 DO j = 1, nmual/2-1
1203 IF ( a(2*j-1) > a(2*(j+1)-1) ) THEN
1204 IF (idebug > 0) THEN
1205 WRITE(iout,*) 'J,2*J-1,2*(J+1)-1 = ',
1206 $ j,2*j-1,2*(j+1)-1
1207 WRITE(iout,*) ' A(2*J-1), A(2*(J+1)-1) = ',
1208 $ a(2*j-1), a(2*(j+1)-1)
1209 WRITE(iout,*) ' MU(i) > MU(i+1) '
1210 ENDIF
1211 ivalid = 0
1212 goto 49
1213 ENDIF
1214 ENDDO
1215 ENDIF
1216 ENDIF
1217 ENDIF
1218
1219 IF (icheck == 1) THEN
1220C CHECK IF SUM(MU_I * ALPHA_I) > 0.0
1221 sum_mu_x_af = 0.0
1222 DO j = 1, nmual/2
1223 sum_mu_x_af = sum_mu_x_af + a(2*j-1) * a(2*j)
1224 ENDDO
1225 IF ( sum_mu_x_af <= 0.0) THEN
1226 IF (idebug > 0) THEN
1227 WRITE(iout,*) ' SUM_MU_X_AF = ', sum_mu_x_af
1228 ENDIF
1229 ivalid = 0
1230 GOTO 49
1231 ENDIF
1232 ELSEIF (icheck == 2) THEN
1233 DO j = 1, nmual/2
1234 IF ( ( a(2*j-1) * a(2*j) ) <= 0.0 ) THEN
1235 IF (idebug > 0) THEN
1236 WRITE(iout,*) ' A(2*J-1) * A(2*J) <= 0 '
1237 WRITE(iout,*) ' J, A(2*J-1), A(2*J) = ',
1238 $ j, a(2*j-1), a(2*j)
1239 ENDIF
1240 ivalid = 0
1241 GOTO 49
1242 ENDIF
1243 ENDDO
1244 ENDIF
1245
124649 CONTINUE
1247
1248 IF (idebug > 0) THEN
1249 WRITE(iout,*) 'IVALID = ', ivalid
1250 ENDIF
1251
1252 RETURN
1253

◆ law69_guess1()

subroutine law69_guess1 ( integer lawid,
integer nmual,
integer icheck,
integer mu_incr,
integer irnd1,
a0,
integer, dimension(nmual) ia,
mcof_min,
mcof_max,
integer nguess )

@purpose get one guess for starting Levenberg-Marquardt method

Parameters
[in]LAWIDmaterial type(1=Ogden, 2=Mooney-Rivlin)
[out]NGUESSNumber of returned guess 0 = no return,already go through all combinations, 1 = return one guess point successfully
[out]A0(NMUAL)returned guess

Definition at line 1108 of file nlsqf.F.

1111#include "implicit_f.inc"
1112C-----------------------------------------------
1113C A n a l y s e M o d u l e
1114C-----------------------------------------------
1115
1116 REAL RAND1
1117 EXTERNAL rand1
1118
1119 INTEGER LAWID, NMUAL, ICHECK, MU_INCR, IRND1, NGUESS
1120 my_real a0(nmual)
1121 INTEGER IA(NMUAL)
1122
1123 my_real small
1124 data small /1e-15/
1125 save small
1126
1127 my_real mcof_min(nmual) ! lower bounds of material parameters
1128 my_real mcof_max(nmual) ! upper bounds of material parameters
1129
1130 real*4 randnum
1131
1132 INTEGER I, IVALID
1133
1134 nguess = 0
1135
1136 IF (lawid == 2) THEN
1137 a0(2) = 2.0
1138 a0(4) = -2.0
1139 ENDIF
1140
1141 DO WHILE (.true.)
1142 DO i = 1, nmual
1143 IF (ia(i) > 0) THEN
1144 randnum = rand1(irnd1)
1145 a0(i) = (1.0-randnum)*mcof_min(i) + randnum*mcof_max(i)
1146 CALL zero2small(a0(i), small)
1147 ENDIF
1148 ENDDO
1149
1150 CALL law69_check( lawid, a0, nmual,
1151 $ icheck, mu_incr, ivalid)
1152 IF (ivalid == 1) THEN
1153 nguess = 1
1154 GOTO 299
1155 ENDIF
1156 ENDDO
1157
1158299 CONTINUE
1159
zero2small
subroutine zero2small(value, small)
Definition nlsqf.F:1079
rand1
real function rand1(ival)
@purpose return a random value within [0.0, 1.0) with uniform distribution
Definition nlsqf.F:1364
law69_check
subroutine law69_check(lawid, a, nmual, icheck, mu_incr, ivalid)
@purpose check if the guess of material properties is valid for LM optimization
Definition nlsqf.F:1180

◆ law69_guess_bounds()

subroutine law69_guess_bounds ( integer lawid,
integer icheck,
x,
y,
integer npt,
integer nmual,
mcof_min,
mcof_max,
integer icomp )

@purpose Esstimate lwer/upper bounds of mu_i and alpha_i which will be used to generate initial guess

Parameters
[in]LAWID1=Ogden, 2=Mooney-Rivlin
[in]ICHECKChecking level
[in]X(NPT)stretch values of given stress/strain(stretch) curve
[in]Y(NPT)engineering stress values of given stress/strain curve
[in]NPTnumber of points on the given stress/strain curve
[out]MCOF_MIN(NMUAL)estimated lower bounds of A(1:NMUAL)
[out]MCOF_MAX(NMUAL)estimated upper bounds of A(1:NMUAL)

Definition at line 1273 of file nlsqf.F.

1275#include "implicit_f.inc"
1276#include "units_c.inc"
1277
1278 INTEGER LAWID, ICHECK, NPT,ICOMP
1279 my_real x(npt), y(npt)
1280 INTEGER NMUAL
1281 my_real mcof_min(nmual), mcof_max(nmual)
1282
1283 INTEGER I
1284
1285 my_real ave_slope, mu_max, dx,dy
1286
1287 ave_slope = zero
1288 DO i = 1, npt
1289 dx = x(i) - one
1290c avolid dx to be too small
1291 IF (dx >= zero) THEN
1292 dx = max(dx, em6)
1293 ELSE
1294 dx = min(dx, -em6)
1295 ENDIF
1296 ave_slope = ave_slope + (y(i) - zero) / dx
1297!ok AVE_SLOPE = MAX(AVE_SLOPE , (Y(I) - ZERO) / dx )
1298 ENDDO
1299 ave_slope = ave_slope / (one * npt)
1300 IF (idebug > 0) THEN
1301 WRITE(iout, *) 'AVE_SLOPE = ', ave_slope
1302 ENDIF
1303 mu_max = ave_slope
1304 IF(icomp == 0 ) mu_max = max(ave_slope, twenty)
1305 IF (lawid == 1) THEN
1306 DO i = 1, nmual/2
1307 ! mu_i
1308 mcof_min(2*i-1) = -mu_max
1309 mcof_max(2*i-1) = mu_max
1310
1311 ! alpha_i
1312 mcof_min(2*i) = -10.0
1313 mcof_max(2*i) = +10.0
1314 ENDDO
1315 ELSEIF (lawid == 2) THEN
1316
1317 IF (icheck == 2) THEN
1318 mcof_min(1) = 0.0
1319 mcof_max(1) = mu_max
1320 ELSE
1321 mcof_min(1) = -mu_max
1322 mcof_max(1) = mu_max
1323 ENDIF
1324
1325 mcof_min(2) = +2.0
1326 mcof_max(2) = +2.0
1327
1328 IF (icheck == 2) THEN
1329 mcof_min(3) = -mu_max
1330 mcof_max(3) = 0.0
1331 ELSE
1332 mcof_min(3) = -mu_max
1333 mcof_max(3) = mu_max
1334 ENDIF
1335
1336 mcof_min(4) = -2.0
1337 mcof_max(4) = -2.0
1338
1339 ENDIF
1340
1341 IF (idebug > 0) THEN
1342 DO i = 1, nmual
1343 WRITE(iout,*) 'I, MCOF_MIN(I), MCOF_MAX(I) = ',
1344 $ i, mcof_min(i), mcof_max(i)
1345 ENDDO
1346 ENDIF
1347
min
#define min(a, b)
Definition macros.h:20
max
#define max(a, b)
Definition macros.h:21

◆ law69_nlsqf()

subroutine law69_nlsqf ( integer lawid,
stretch,
y,
integer ma,
integer nmual,
integer npt,
mual,
integer icheck,
integer nstart,
errtol,
integer id,
character(len=nchartitle) titr,
integer, intent(in) is_encrypted )
Parameters
[in]LAWIDlaw_ID on /MAT/LAW69 (1=Ogden, 2=Mooney-Rivlin)
[in]ICHECKchecking level <=0 no constraint (IVALID always return as 1) 1 SUM( mu(i) * alpha(i) ) > 0.0 2 mu(i) * alpha(i) > 0.0 3 Try ICHECK=2 at first, if it fails in fitting, switch to ICHECK=1, and try again
[in]ERRTOLIf ERRAVE < ERRTOL, data fitting converges. ERRAVE = ( SUM [ ABS ( ( Y_inp-Y_fit) / Y_inp ) ) / NPT
[out]MUAL(1:NMUAL)optimized material properties

Definition at line 563 of file nlsqf.F.

565 USE message_mod
566 USE names_and_titles_mod , ONLY : nchartitle
567C-----------------------------------------------
568C I m p l i c i t T y p e s
569C-----------------------------------------------
570#include "implicit_f.inc"
571C-----------------------------------------------
572C C o m m o n B l o c k s
573C-----------------------------------------------
574#include "units_c.inc"
575C-----------------------------------------------
576 INTEGER MAXA
577 parameter(maxa=20)
578
579 INTEGER LAWID, NPT, MA, ICHECK, NSTART
580 INTEGER , INTENT(IN) :: IS_ENCRYPTED
581 my_real errtol
582 INTEGER I,NONZERO(MAXA),IDUM,ITER,ICOUNT,J,K,NMUAL
583 my_real gamma,errnow,gasdev,errpre,
584 . stretch(npt),mual(10)
585 my_real a(maxa),covar(maxa,maxa),alpha(maxa,maxa),y(npt)
586 my_real mcof_min(maxa), mcof_max(maxa)
587 my_real yogd,xogd
588
589 INTEGER ID
590 CHARACTER(LEN=NCHARTITLE) :: TITR
591 INTEGER MINITER_LM, MAXITER_LM
592 DATA miniter_lm /5/
593 SAVE miniter_lm
594
595 DATA maxiter_lm /100/
596 SAVE maxiter_lm
597
598 ! if ( (ERRNOW-ERRPRE) / ERRPRE ) < EPS_LM, CNT_HIT_EPS_LM = CNT_HIT_EPS_LM + 1,
599 ! if CNT_HIT_EPS_LM == LMT_HIT_EPS_LM, it converges
600 my_real eps_lm
601 DATA eps_lm /1e-3/
602 SAVE eps_lm
603
604 INTEGER CNT_HIT_EPS_LM
605 INTEGER LMT_HIT_EPS_LM
606 DATA lmt_hit_eps_lm /2/
607 SAVE lmt_hit_eps_lm
608
609 INTEGER LMSTOP
610
611 INTEGER IFUNCS
612
613 INTEGER NGUESS
614 my_real a0(maxa)
615 my_real errmin, errmax, errave, errave_min, err
616
617 INTEGER ISTART, NPSAVED, IVALID,ICOMP, MMAX
618 parameter(mmax =20)
619 my_real atry(mmax)
620
621 INTEGER ICURV
622 LOGICAL lopened
623
624c during LM optimization, if the objective is not improved,
625c GAMMA will be increased. We should terminate the iteration once
626c GAMMA becomes very huge.
627 my_real gamma_stop
628 data gamma_stop /1e15/
629 save gamma_stop
630
631c if check the validity of initial guess (0=no, 1=yes)
632c we don't want to check, because invalid initial point could converge to valid point.
633 INTEGER ICHECK_GUESS
634 data icheck_guess /0/
635 save icheck_guess
636
637 INTEGER JCHECK, IFIT_SUCCESS
638
639c if enforce mu(i) < mu(i+1) in generating initial guess
640c we don't need this anymore since we are using random numbers instead of loop through all
641c the combinations
642 INTEGER MU_INCR_GUESS
643 data mu_incr_guess /0/
644 save mu_incr_guess
645
646 my_real max_abs_yi
647 my_real small_fac_abs_yi, small_abs_yi
648
649 my_real, DIMENSION(:), ALLOCATABLE :: sig
650 my_real spready
651 INTEGER IRET
652 INTEGER IRND1
653! ------------------------------------------------------------------------------
654 ALLOCATE (sig(1:npt))
655!
656 !
657 IF ( maxa < ma ) THEN
658 WRITE(*,*) 'ERROR, MAXA < MA'
659 WRITE(*,*) __file__,__line__
660 CALL my_exit(2)
661 ENDIF
662 icomp=0
663 IF(icheck < 0) icomp= 1
664 icheck = abs(icheck)
665 ! IF ABS(Y(I)) < SMALL_ABS_YI, use SMALL_ABS_YI to avoid
666 ! unnecessary numerical issues when avoid divided by small value
667
668 max_abs_yi = zero
669 DO i = 1, npt
670 max_abs_yi = max( max_abs_yi, abs(y(i)) )
671 ENDDO
672
673 small_fac_abs_yi = em3
674
675 small_abs_yi = max_abs_yi * small_fac_abs_yi
676
677 IF (idebug > 0) THEN
678 WRITE(iout, *) ' MAX_ABS_YI, SMALL_FAC_ABS_YI, SMALL_ABS_YI = ',
679 $ max_abs_yi, small_fac_abs_yi, small_abs_yi
680 ENDIF
681
682 spready=0.01
683 IF(icomp == 0) THEN
684 DO j=1,npt
685 sig(j)=spready*max(small_abs_yi, abs(y(j)) )
686 IF (idebug > 0) THEN
687 WRITE(iout, *) 'J, SIG(J) = ', j, sig(j)
688 ENDIF
689 ENDDO
690 ELSE
691 DO j=1,npt
692 sig(j) = y(j)
693 IF(sig(j) == zero) sig(j) = em15
694 IF (idebug > 0) THEN
695 WRITE(iout, *) 'j, sig(j) = ', J, SIG(J)
696 ENDIF
697 ENDDO
698 ENDIF
699
700 IF (MAXA < MA) THEN
701! TBD_KANG
702 WRITE(*,*) 'error: maxa < ma'
703 WRITE(*,*) ' maxa = ', MAXA
704 WRITE(*,*) ' ma = ', MAXA
705 WRITE(*,*) ' file = ', __FILE__
706 WRITE(*,*) ' line = ', __LINE__
707 CALL MY_EXIT(2)
708 ENDIF
709
710C=======================================================================
711 DO I=1,NMUAL
712 NONZERO(I)=1
713 ENDDO
714
715 IF (LAWID == 1) then ! OGDEN
716 DO I=NMUAL+1,10
717 NONZERO(I)=0
718 A(I)=ZERO
719 ENDDO
720
721 IFUNCS = 1 ! SUBROUTINE OGDEN0/OGDEN1
722
723 ELSEIF (LAWID == 2) then ! Mooney-Rivlin
724 DO I=NMUAL+1,MA
725 NONZERO(I)=0
726 ENDDO
727 NONZERO(2)=0
728 NONZERO(4)=0
729
730 DO I=NMUAL+1,MA
731 A(I)=ZERO
732 ENDDO
733
734 IFUNCS = 1 ! SUBROUTINE OGDEN0/OGDEN1
735
736 ENDIF
737
738 JCHECK =ICHECK
739 IF (JCHECK == 3) THEN
740 JCHECK = 2
741 ENDIF
742
74399 CONTINUE ! location to start optimization with different JCHECK
744
745 IFIT_SUCCESS = 0
746
747 ISTART = 0
748 NPSAVED = 0
749
750c calculate MCOF_MIN, MCOF_MAX
751 CALL LAW69_GUESS_BOUNDS(LAWID, JCHECK, STRETCH, Y, NPT,
752 $ NMUAL, MCOF_MIN, MCOF_MAX,ICOMP)
753
754c initialize random number generator in LAW69_GUESS1
755 IRND1 = 205
756 ATRY(1:MMAX) = ZERO ! Initialization of ATRY
757 DO 111 WHILE ( ISTART < NSTART )
758c get one guess point A0(1:NMUAL)
759 CALL LAW69_GUESS1(
760 $ LAWID, NMUAL, ICHECK_GUESS, MU_INCR_GUESS,IRND1,
761 $ A0, NONZERO, MCOF_MIN, MCOF_MAX, NGUESS)
762
763 IF (NGUESS == 0) THEN
764 GOTO 112
765 ENDIF
766
767C calculate averaged ERROR before LM
768 ERRAVE = 0.0
769 IF(ICOMP == 0) THEN
770 DO I=1,NPT
771 CALL OGDEN0(STRETCH(I), A0, YOGD, NMUAL)
772 ERR = ABS(Y(I) - YOGD) / max(SMALL_ABS_YI, ABS(Y(I)))
773 ERRAVE = ERRAVE + ERR
774 ENDDO
775 ELSE
776 DO I=1,NPT
777 CALL OGDEN0(STRETCH(I), A0, YOGD, NMUAL)
778 ERR = ABS(Y(I) - YOGD) / MAX(EM15,ABS(Y(I)))
779 ERRAVE = ERRAVE + ERR
780 ENDDO
781 ENDIF
782C
783 ERRAVE = ERRAVE / (1.0 * NPT)
784
785 ISTART = ISTART + 1
786
787 IF (IDEBUG > 0) THEN
788 WRITE(IOUT,*) ' istart = ', ISTART
789 WRITE(IOUT,*) ' before lm optimization ...'
790 DO I = 1, NMUAL
791 WRITE(IOUT, *) ' i, a0(i) = ', I, A0(I)
792 ENDDO
793 WRITE(IOUT,*) ' lm0, errave = ', ERRAVE
794 ENDIF
795
796! start loop of LM optimization
797 ITER = 0
798 CNT_HIT_EPS_LM = 0
799
800 ITER = ITER + 1
801 GAMMA=-1
802 CALL MRQMIN(STRETCH,Y,SIG,NPT,A0,NONZERO,
803 $ NMUAL,COVAR,ALPHA,MA,ERRNOW,
804 $ IFUNCS,GAMMA,IRET,ICOMP,MMAX,ATRY)
805 IF (IRET /= 0) GOTO 111
806
807 IF (IDEBUG > 0) THEN
808 ERRAVE = 0.0
809 IF(ICOMP == 0) THEN
810 DO I=1,NPT
811 CALL OGDEN0(STRETCH(I), A0, YOGD, NMUAL)
812 ERR = ABS(Y(I) - YOGD) / max(SMALL_ABS_YI, ABS(Y(I)))
813 ERRAVE = ERRAVE + ERR
814 ENDDO
815 ELSE
816 DO I=1,NPT
817 CALL OGDEN0(STRETCH(I), A0, YOGD, NMUAL)
818 ERR = ABS(Y(I) - YOGD) / MAX(EM15,ABS(Y(I)))
819 ERRAVE = ERRAVE + ERR
820 ENDDO
821 ENDIF
822 ERRAVE = ERRAVE / (1.0 * NPT)
823
824 WRITE(IOUT, '(a,i4, 3e16.8)')
825 $ 'iter, errnow, gamma, errave = ',
826 $ ITER, ERRNOW, GAMMA, ERRAVE
827 DO I = 1, NMUAL
828 WRITE(IOUT, *) ' - i, a0(i) = ', I, A0(I)
829 ENDDO
830 ENDIF
831
83221 CONTINUE
833 ERRPRE=ERRNOW
834
835 ITER = ITER + 1
836 CALL MRQMIN(STRETCH,Y,SIG,NPT,A0,NONZERO,
837 $ MA,COVAR,ALPHA, MA, ERRNOW,
838 $ IFUNCS,GAMMA,IRET,ICOMP,MMAX,ATRY)
839 IF (IRET /= 0) GOTO 111
840
841 IF (IDEBUG == 1) THEN
842 ERRAVE = ZERO
843 IF(ICOMP == 0) THEN
844 DO I=1,NPT
845 CALL OGDEN0(STRETCH(I), A0, YOGD, NMUAL)
846 ERR = ABS(Y(I) - YOGD) / max(SMALL_ABS_YI, ABS(Y(I)))
847 ERRAVE = ERRAVE + ERR
848 ENDDO
849 ELSE
850 DO I=1,NPT
851 CALL OGDEN0(STRETCH(I), A0, YOGD, NMUAL)
852 ERR = ABS(Y(I) - YOGD) / MAX(EM15,ABS(Y(I)))
853 ERRAVE = ERRAVE + ERR
854 ENDDO
855 ENDIF
856 ERRAVE = ERRAVE / (1.0 * NPT)
857
858 WRITE(IOUT, '(a,i4, 5e16.8)')
859 $ 'iter, errnow, gamma, errave, errnow-errpre,'//
860 $ '(errnow-errpre)/errpre = ',
861 $ ITER, ERRNOW, GAMMA, ERRAVE, ERRNOW-ERRPRE,
862 $ (ERRNOW-ERRPRE)/ERRPRE
863 DO I = 1, NMUAL
864 WRITE(IOUT, *) ' - i, a0(i) = ', I, A0(I)
865 ENDDO
866 ENDIF
867
868c IF A0(J) is too small, restart from next initial guess
869 DO J = 1, NMUAL
870 IF ( ABS( A0(J) ) < 1E-20 ) THEN
871 goto 111 ! restart from next initial guess
872c WRITE(IOUT, *) ' A is too small, and could result in error'
873c WRITE(IOUT,*) 'J, A0(J) = ', J, A0(J)
874c STOP
875 ENDIF
876 ENDDO
877
878c check convergence of LM optimization
879 LMSTOP = 0
880 IF (IDEBUG > 0) THEN
881 WRITE(IOUT, *) ' errnow/(1.0*npt) = ', ERRNOW/(1.0*NPT)
882 WRITE(IOUT, *) ' errnow < errpre = ', (ERRNOW < ERRPRE)
883 ENDIF
884
885 IF ( ITER > MINITER_LM ) THEN
886 IF (ERRNOW < ERRPRE) THEN
887 IF ( ABS(ERRPRE) > ZERO) THEN
888 IF ( ABS( (ERRNOW-ERRPRE)/ ERRPRE ) < EPS_LM) THEN
889 CNT_HIT_EPS_LM = CNT_HIT_EPS_LM + 1
890
891 IF (IDEBUG > 0) THEN
892 WRITE(IOUT,*)
893 $ ' cnt_hit_eps_lm, abs((errnow-errpre)/errpre) = ',
894 $ CNT_HIT_EPS_LM, ABS( (ERRNOW-ERRPRE)/ ERRPRE )
895 ENDIF
896
897 IF ( CNT_HIT_EPS_LM >= LMT_HIT_EPS_LM ) THEN
898 IF (IDEBUG > 0) THEN
899 WRITE(IOUT,*) 'stop at ', __LINE__
900 ENDIF
901 LMSTOP = 1
902 ENDIF
903 ENDIF
904 ENDIF
905.OR. ELSEIF (ITER >= MAXITER_LM GAMMA >= GAMMA_STOP) THEN
906 IF (IDEBUG > 0) THEN
907 WRITE(IOUT,*) 'stop at ', __LINE__
908 ENDIF
909 LMSTOP = 1
910 ENDIF
911 ENDIF
912
913 IF (LMSTOP== 0) THEN
914 GOTO 21
915 ENDIF
916! end loop of LM optimization
917
918 ERRAVE = 0.0
919 IF(ICOMP == 0) THEN
920 DO I=1,NPT
921 CALL OGDEN0(STRETCH(I), A0, YOGD, NMUAL)
922 ERR = ABS(Y(I) - YOGD) / max(SMALL_ABS_YI, ABS(Y(I)))
923 ERRAVE = ERRAVE + ERR
924 ENDDO
925 ELSE
926 DO I=1,NPT
927 CALL OGDEN0(STRETCH(I), A0, YOGD, NMUAL)
928 ERR = ABS(Y(I) - YOGD) / MAX(EM15,ABS(Y(I)))
929 ERRAVE = ERRAVE + ERR
930 ENDDO
931 ENDIF
932 ERRAVE = ERRAVE / (1.0 * NPT)
933
934 IF (IDEBUG > 0) THEN
935 WRITE(IOUT,*) ' after lm optimization ...'
936 DO I = 1, MA
937 WRITE(IOUT, *) ' i, a0(i) = ', I, A0(I)
938 ENDDO
939 WRITE(IOUT,*) ' lm1, errave = ', ERRAVE
940 ENDIF
941
942 CALL LAW69_CHECK(LAWID, A0, NMUAL, JCHECK, 0, IVALID)
943 IF (IVALID > 0) THEN
944.OR. IF ( NPSAVED==0
945.AND. $ ( NPSAVED>0 ERRAVE<ERRAVE_MIN) ) THEN
946 NPSAVED = NPSAVED + 1
947 ERRAVE_MIN = ERRAVE
948 DO I = 1, NMUAL
949 A(I) = A0(I)
950 ENDDO
951 ENDIF
952 ELSE
953 IF (IDEBUG > 0) THEN
954 WRITE(IOUT,*) __FILE__,__LINE__
955 WRITE(IOUT,*) ' lm converges to invalid point'
956 ENDIF
957 ENDIF
958
959 IF (NPSAVED > 0) THEN
960 IF (IDEBUG > 0) THEN
961 WRITE(*, *) ' istart, npsaved, errave_min = ',
962 $ ISTART, NPSAVED, ERRAVE_MIN
963 WRITE(IOUT, *) ' istart, npsaved, errave_min = ',
964 $ ISTART, NPSAVED, ERRAVE_MIN
965 ENDIF
966
967 IF ( ERRAVE_MIN < ERRTOL ) THEN
968 IFIT_SUCCESS = 1
969 GOTO 112
970 ENDIF
971 ELSE
972 IF (IDEBUG > 0) THEN
973 WRITE(*, *) ' istart, npsaved ',
974 $ ISTART, NPSAVED
975 WRITE(IOUT, *) ' istart, npsaved ',
976 $ ISTART, NPSAVED
977 ENDIF
978 ENDIF
979
980111 CONTINUE ! WHILE ( ISTART < NSTART )
981
982112 CONTINUE
983
984.AND. IF (IFIT_SUCCESS == 0 ICHECK == 3) THEN
985 IF (JCHECK == 2) THEN
986 JCHECK = 1
987 IF (IDEBUG > 0) THEN
988 IF (NPSAVED > 0) THEN
989 WRITE(*,'(a)')
990 $ '*** curve fitting result of /mat/law69 with'
991 $ //' icheck=2 is not satisfactory.'
992 WRITE(*,'(a,f10.2,a)') 'errave = ', ERRAVE_MIN*100.0,'%'
993 WRITE(*,'(a)') ' switching to icheck=1 and trying again.'
994
995 ELSE
996 WRITE(*,'(a)')
997 $ '*** failed to fit /mat/law69 with icheck=2.'
998 WRITE(*,'(a)') ' switching to icheck=1 and trying again.'
999 ENDIF
1000 ENDIF
1001 GOTO 99
1002 ENDIF
1003 ENDIF
1004
1005 DEALLOCATE (SIG)
1006
1007 IF (IFIT_SUCCESS == 0) THEN
1008 IF (NPSAVED == 0) THEN
1009 CALL ANCMSG(MSGID=901,
1010 . MSGTYPE=MSGERROR,
1011 . ANMODE=ANINFO,
1012 . I1=ID,
1013 . C1=TITR)
1014 ENDIF
1015 ENDIF
1016C
1017 DO I=1,10
1018 MUAL(I)=A(I)
1019 ENDDO
1020
1021 IF (LAWID == 2) THEN
1022 DO I=5,10
1023 MUAL(I) = ZERO
1024 ENDDO
1025 ENDIF
1026 IF(IS_ENCRYPTED == 0)THEN
1027 WRITE(IOUT,'(//6x,a,/)')'fitting result comparison:'
1028 WRITE(IOUT,'(6x,a,/)')'uniaxial test data'
1029 WRITE(IOUT,'(a20,5x,a20,a30)') 'nominal strain',
1030 * 'nominal stress(test)', 'nominal stress(radioss)'
1031 ENDIF
1032
1033c output curcves to .csv format to simplify visualization
1034 ICURV = 0
1035 IF (IOCSV> 0) THEN
1036 DO ICURV = 25, 99
1037 inquire (unit=ICURV, opened=lopened)
1038.not. if ( lopened) goto 77
1039 ENDDO
104077 CONTINUE
1041 OPEN(UNIT=ICURV, FILE='curv.csv')
1042 WRITE(ICURV,'(a)') 'nominal strain, nominal stress(test), '//
1043 $ 'nominal stress(radioss)'
1044 ENDIF
1045 IF(IS_ENCRYPTED == 0)THEN
1046 DO I=1,NPT
1047 CALL OGDEN0(STRETCH(I), A, YOGD, NMUAL)
1048!! WRITE(IOUT,'(f18.4,f20.4,f28.4)')
1049 WRITE(IOUT, '(1f18.6, 3x,1f20.13, 6x, 1f20.13)')
1050 * STRETCH(I)-ONE,Y(I),YOGD
1051 IF (ICURV > 0) THEN
1052 WRITE(ICURV, '(f18.4, a, f18.4, a, f18.4)')
1053 $ STRETCH(I)-ONE,',',Y(I),',',YOGD
1054 ENDIF
1055 ENDDO
1056 ENDIF
1057
1058 WRITE(IOUT, *) ''
1059 WRITE(IOUT, '(a)') '-------------------------------------------'
1060 WRITE(IOUT, '(a,f10.2,a)') 'averaged error of fitting : ',
1061 $ ERRAVE_MIN*100.0, '%'
1062
1063c output curcves to .csv format to simplify visualization
1064 IF ( ICURV > 0) THEN
1065 CLOSE(ICURV)
1066 ENDIF
1067C-----------
1068 RETURN
my_exit
void my_exit(int *i)
Definition analyse.c:1038
alpha
#define alpha
Definition eval.h:35
message_mod
Definition message_mod.F:1249
names_and_titles_mod
Definition names_and_titles_mod.F:997
names_and_titles_mod::nchartitle
integer, parameter nchartitle
Definition names_and_titles_mod.F:1003
radioss
program radioss
Definition radioss.F:34

◆ mrqcof()

subroutine mrqcof ( x,
y,
sig,
integer ndata,
a,
integer, dimension(ma) ia,
integer ma,
alpha,
beta,
integer nalp,
errnow,
integer ifuncs,
integer icomp )

Definition at line 185 of file nlsqf.F.

188C-----------------------------------------------
189C I m p l i c i t T y p e s
190C-----------------------------------------------
191#include "implicit_f.inc"
192C-----------------------------------------------
193C D u m m y A r g u m e n t s
194C-----------------------------------------------
195 INTEGER MA,NALP,NDATA,IA(MA),ICOMP
196 my_real
197 . errnow,a(ma),alpha(nalp,nalp),beta(ma),
198 . x(ndata),y(ndata),sig(ndata)
199 INTEGER IFUNCS
200C----------------------------------------------------------------
201C L O C A L V A R I B L E S
202C----------------------------------------------------------------
203 INTEGER MFIT,I,J,K,L,M,MMAX
204 parameter(mmax=20)
205 my_real
206 . dy,wt,ymod,dyda(mmax)
207
208 my_real y_min
209
210 y_min = em3
211
212C=======================================================================
213 mfit=0
214 DO 11 j=1,ma
215 IF (ia(j)/=0) mfit=mfit+1
21611 CONTINUE
217 DO 13 j=1,mfit
218 DO 12 k=1,j
219 alpha(j,k)=0.
22012 CONTINUE
221 beta(j)=0.
22213 CONTINUE
223 errnow=zero
224 IF(icomp == 0) THEN
225 DO 16 i=1,ndata
226 IF (ifuncs == 1) THEN
227 CALL ogden0(x(i),a,ymod, ma)
228 CALL ogden1(x(i),a,dyda, ia, ma)
229 ELSE
230! TBD, UNKOWN IFUNCS, ERROR OUT!!!
231 WRITE(*,*) 'ERROR: UNKOWN IFUNCS = ', ifuncs
232 CALL my_exit(2)
233 ENDIF
234
235 dy=y(i)-ymod
236 errnow=errnow+dy*dy/(sig(i)*sig(i))
237c IF (Y(I)>EM5) DY=Y(I)-YMOD
238c IF (Y(I)<EM5) DY=EM5
239
240 j=0
241 DO 15 l=1,ma
242 IF(ia(l)/=0) THEN
243 j=j+1
244 wt=dyda(l)
245 wt=dyda(l)/(sig(i)*sig(i))
246 k=0
247 DO 14 m=1,l
248 IF(ia(m)/=0) THEN
249 k=k+1
250 alpha(j,k)=alpha(j,k)+wt*dyda(m)
251 ENDIF
25214 CONTINUE
253 beta(j)=beta(j)+dy*wt
254 ENDIF
25515 CONTINUE
25616 CONTINUE
257 ELSE
258 DO i=1,ndata
259 IF (ifuncs == 1) THEN
260 CALL ogden0(x(i),a,ymod, ma)
261 CALL ogden1(x(i),a,dyda, ia, ma)
262 ELSE
263! TBD, UNKOWN IFUNCS, ERROR OUT!!!
264 WRITE(*,*) 'ERROR: UNKOWN IFUNCS = ', ifuncs
265 CALL my_exit(2)
266 ENDIF
267
268 dy=y(i)-ymod
269 errnow = errnow + dy*dy
270 j=0
271 DO l=1,ma
272 IF(ia(l)/=0) THEN
273 j=j+1
274 wt=dyda(l)
275 k=0
276 DO m=1,l
277 IF(ia(m)/=0) THEN
278 k=k+1
279 alpha(j,k)=alpha(j,k)+wt*dyda(m)
280 ENDIF
281 ENDDO ! M
282 beta(j)=beta(j)+dy*wt
283 ENDIF
284 ENDDO ! L
285 ENDDO ! I
286 ENDIF
287 DO 18 j=2,mfit
288 DO 17 k=1,j-1
289 alpha(k,j)=alpha(j,k)
29017 CONTINUE
291
29218 CONTINUE
293 RETURN
ogden1
subroutine ogden1(x, a, dyda, ia, na)
@purpose calculate d(stress)/d(A) OGDEN (uniaxial tension)
Definition nlsqf.F:508
ogden0
subroutine ogden0(x, a, y, na)
@purpose calculate stress from stretch for OGDEN (uniaxial tension)
Definition nlsqf.F:473

◆ mrqmin()

subroutine mrqmin ( x,
y,
sig,
integer ndata,
a,
integer, dimension(ma) ia,
integer ma,
covar,
alpha,
integer nca,
errnow,
integer ifuncs,
gamma,
integer iret,
integer icomp,
integer, intent(in) mmax,
dimension(mmax), intent(inout) atry )
Parameters
[in]IFUNCSSUBROUTINE handle/ID for evaluation : 1=OGDEN0/OGDEN1
[out]Aupdated coeeficients
[out]IRETreturn code 0 : optimization succeeded; 1 : optimization failed;

Definition at line 42 of file nlsqf.F.

45C-----------------------------------------------
46C I m p l i c i t T y p e s
47C-----------------------------------------------
48#include "implicit_f.inc"
49C-----------------------------------------------
50C C o m m o n B l o c k s
51C-----------------------------------------------
52#include "units_c.inc"
53C-----------------------------------------------
54C D u m m y A r g u m e n t s
55C-----------------------------------------------
56 INTEGER , INTENT(IN) :: MMAX
57 my_real , INTENT(INOUT) :: atry(mmax)
58C----------------------------------------------------------------
59C L O C A L V A R I B L E S
60C----------------------------------------------------------------
61 INTEGER MA,NCA,NDATA,IA(MA) ,ICOMP
62 my_real
63 . gamma,errnow,a(ma),alpha(nca,nca),
64 . covar(nca,nca),x(ndata),y(ndata),sig(ndata)
65 INTEGER J,K,L,MFIT ,NMAX
66 parameter(nmax = 20) ! NMAX = MMAX
67 my_real errpre,beta(nmax),da(nmax)
68 SAVE errpre,beta,da,mfit
69 INTEGER IFUNCS, IRET
70C=======================================================================
71
72 iret = 0
73
74 IF (gamma < zero) THEN
75 mfit=0
76 DO j=1,ma
77 IF (ia(j)/=0) mfit=mfit+1
78 ENDDO
79! in Numerical Recript, 0.001 is used, however from my tests, the
80! difference is small (0.01 vs 0.001)
81 gamma=0.01
82 CALL mrqcof(x,y,sig,ndata,
83 . a,ia,ma,alpha,beta,nca,errnow,
84 . ifuncs,icomp)
85
86 errpre=errnow
87 DO j=1,ma
88 atry(j)=a(j)
89 ENDDO
90 ENDIF
91C
92 DO j=1,mfit
93 DO k=1,mfit
94 covar(j,k)=alpha(j,k)
95 ENDDO
96 covar(j,j)=alpha(j,j)*(1.+gamma)
97 da(j)=beta(j)
98 ENDDO
99C
100 CALL inversion(covar,mfit,nca,da,1,1,iret)
101 IF (iret /= 0) THEN
102 IF (idebug > 0) THEN
103 WRITE(*,*) ' IRET = ', iret
104 DO j=1,ma
105 WRITE(iout, *) 'J, A(J) = ', j, a(j)
106 ENDDO
107 ENDIF
108 RETURN
109 ENDIF
110
111 IF (gamma == zero) THEN
112 CALL covsrt(covar,nca,ma,ia,mfit)
113 RETURN
114 ENDIF
115C
116 j=0
117 DO l=1,ma
118 IF(ia(l)/=0) THEN
119 j=j+1
120 atry(l)=a(l)+da(j)
121 ENDIF
122 ENDDO
123
124 IF (idebug > 0) THEN
125 WRITE(iout,*) __file__,__line__
126 DO j=1, ma
127 write(iout,*) 'J,ATRY(J) = ', j, atry(j)
128 ENDDO
129 ENDIF
130
131c limit ATRY (ALPHA) to avoid too big power (overflow)
132c |ALPHA_i| <= 20.0
133 DO j=1, ma-1, 2
134 if (atry(j+1) > twenty) then
135 IF (idebug > 0) THEN
136 write(iout,*) 'Setting Big ALPHA to ',twenty
137 write(iout,*) ' J, ATRY(J) = ',j+1,atry(j+1)
138 ENDIF
139 atry(j+1) = twenty
140 ELSEIF (atry(j+1) < -twenty) THEN
141 IF (idebug > 0) THEN
142 write(iout,*) 'Setting Big ALPHA to -',twenty
143 write(iout,*) ' J, ATRY(J) = ',j+1,atry(j+1)
144 ENDIF
145 atry(j+1) = -twenty
146 ENDIF
147 ENDDO
148
149C
150 CALL mrqcof(x,y,sig,ndata,
151 . atry,ia,ma,covar,da,nca,errnow,
152 . ifuncs,icomp)
153C
154 IF (errnow < errpre) THEN
155 gamma=0.1*gamma
156 errpre=errnow
157 DO j=1,mfit
158 DO k=1,mfit
159 alpha(j,k)=covar(j,k)
160 ENDDO
161 beta(j)=da(j)
162 ENDDO
163 DO l=1,ma
164 a(l)=atry(l)
165 ENDDO
166 ELSE
167 gamma=10.*gamma
168 errnow=errpre
169 ENDIF
170C-----------
171 RETURN
inversion
subroutine inversion(a, n, np, b, m, mp, iret)
Definition nlsqf.F:304
mrqcof
subroutine mrqcof(x, y, sig, ndata, a, ia, ma, alpha, beta, nalp, errnow, ifuncs, icomp)
Definition nlsqf.F:188
covsrt
subroutine covsrt(covar, sizcovar, ma, ia, mfit)
Definition nlsqf.F:420

◆ ogden0()

subroutine ogden0 ( x,
a,
y,
integer na )

@purpose calculate stress from stretch for OGDEN (uniaxial tension)

Parameters
[in]Xstretch
[in]A(NA)material parameters [mu_1, alpha_1,mu_2, alpha_2,...]
[out]Ystress

Definition at line 472 of file nlsqf.F.

473C-----------------------------------------------
474C I m p l i c i t T y p e s
475C-----------------------------------------------
476#include "implicit_f.inc"
477C-----------------------------------------------
478C D u m m y A r g u m e n t s
479C-----------------------------------------------
480 INTEGER NA
481 my_real x, a(na), y
482C----------------------------------------------------------------
483C L O C A L V A R I B L E S
484C----------------------------------------------------------------
485 INTEGER I
486C=======================================================================
487 y=zero
488 DO i=1,na-1,2
489 y = y + a(i)*(x**(-1.+a(i+1))-x**(-0.5*a(i+1)-1.))
490 ENDDO
491C-----------
492 RETURN

◆ ogden1()

subroutine ogden1 ( x,
a,
dyda,
integer, dimension(na) ia,
integer na )

@purpose calculate d(stress)/d(A) OGDEN (uniaxial tension)

Parameters
[in]Xstretch
[in]A(NA)material parameters [mu_1, alpha_1,mu_2, alpha_2,...]
[in]IA(NA)flags if derivative needs to be calculated 1=yes, 0=no
[out]DYDA(NA)derivatives d(stress)/d(A)

Definition at line 507 of file nlsqf.F.

508C-----------------------------------------------
509C I m p l i c i t T y p e s
510C-----------------------------------------------
511#include "implicit_f.inc"
512C-----------------------------------------------
513C D u m m y A r g u m e n t s
514C-----------------------------------------------
515 INTEGER NA
516 INTEGER IA(NA)
517 my_real x, a(na),dyda(na)
518 my_real tmp1, tmp2
519C----------------------------------------------------------------
520C L O C A L V A R I B L E S
521C----------------------------------------------------------------
522 INTEGER I
523C=======================================================================
524 DO i=1,na-1,2
525 tmp1 = x**(-1.+a(i+1))
526 tmp2 = x**(-0.5*a(i+1)-1.)
527 IF (ia(i) /= 0) THEN
528 dyda(i) = tmp1 - tmp2
529 ENDIF
530
531 IF (ia(i+1) /= 0) THEN
532 dyda(i+1) = a(i)*log(x)*(tmp1 + 0.5*tmp2)
533 ENDIF
534 ENDDO
535
536 RETURN

◆ rand1()

real function rand1 ( integer ival)

@purpose return a random value within [0.0, 1.0) with uniform distribution

Parameters
[in]IVALinteger for calculating next random number
Note
  • random number generator of Park and Miller.
  • Schrage's modification is used to avoid 'a*(m-1)' overflows for 32-bit.

Definition at line 1363 of file nlsqf.F.

1364#include "implicit_f.inc"
1365 INTEGER IVAL
1366 INTEGER IA, IM, IQ, IR
1367 REAL RIM
1368 parameter(ia=69621, im=2147483647,rim=1./im,iq=30845,ir=23902)
1369
1370 INTEGER IDQ
1371
1372 IF (ival <= 0) THEN
1373 WRITE(*,*) 'ERROR, IVAL <= 0'
1374 WRITE(*,*) __file__,__line__
1375 CALL my_exit(2)
1376 ELSEIF (ival > im) THEN
1377 WRITE(*,*) 'ERROR, IVAL > IM'
1378 WRITE(*,*) __file__,__line__
1379 CALL my_exit(2)
1380 ENDIF
1381
1382 idq = ival / iq
1383 ival = ia * (ival - idq * iq) - ir * idq
1384 if (ival < 0) ival = ival + im
1385
1386 rand1 = real(ival) * rim
1387
1388 RETURN

◆ zero2small()

subroutine zero2small ( value,
small )

Definition at line 1078 of file nlsqf.F.

1079#include "implicit_f.inc"
1080 my_real value, small
1081
1082 if ( abs(value) < small ) then
1083 if (value >= 0.0) then
1084 value = small
1085 else
1086 value = -small
1087 endif
1088 endif